function getMockCallObject(mock: ReturnType<typeof vi.fn>, callIndex = 0, argIndex = 0) {

const value = mock.mock.calls[callIndex]?.[argIndex];

expect(typeof value).toBe("object");

expect(value).not.toBeNull();

if (!value || typeof value !== "object") {

throw new Error(`expected mock call ${callIndex} arg ${argIndex} object`);

}

return value as Record<string, unknown>;

}

}

function asRecord(value: unknown): Record<string, unknown> {

expect(value).not.toBeNull();

expect(typeof value).toBe("object");

if (!value || typeof value !== "object") {

throw new Error("expected record");

}

expect(Array.isArray(value)).toBe(false);

return value as Record<string, unknown>;

}

import { runTrustedToolPolicies } from "../trusted-tool-policy.js";

function requireRecord(value: unknown, label: string): Record<string, unknown> {

expect(value, label).toBeTypeOf("object");

expect(value, label).not.toBeNull();

if (!value || typeof value !== "object") {

throw new Error(`expected ${label}`);

}

return value as Record<string, unknown>;

}

function expectParsedGitSpec(spec: string) {

const parsed = parseGitPluginSpec(spec);

expect(parsed).not.toBeNull();

if (!parsed) {

throw new Error(`Expected ${spec} to parse as a git plugin spec`);

}

}

function requirePersisted(index: InstalledPluginIndex | null): InstalledPluginIndex {

expect(index).not.toBeNull();

if (!index) {

throw new Error("Expected persisted installed plugin index");

}

function installPluginInput(callIndex = 0): Record<string, unknown> {

const input = installPluginFromPathMock.mock.calls[callIndex]?.[0];

expect(typeof input).toBe("object");

expect(input).not.toBeNull();

if (!input || typeof input !== "object") {

throw new Error(`expected install plugin input ${callIndex}`);

}

return input as Record<string, unknown>;

}

function fetchGuardInput(callIndex = 0): Record<string, unknown> {

const input = fetchWithSsrFGuardMock.mock.calls[callIndex]?.[0];

expect(typeof input).toBe("object");

expect(input).not.toBeNull();

if (!input || typeof input !== "object") {

throw new Error(`expected fetch guard input ${callIndex}`);

}

return input as Record<string, unknown>;

}

marketplaceSource?: string;

},

) {

expect(typeof result).toBe("object");

expect(result).not.toBeNull();

if (!result || typeof result !== "object") {

throw new Error("expected marketplace install result");

}

const record = result as Record<string, unknown>;

expect(record.ok).toBe(true);

expect(record.pluginId).toBe(params.pluginId ?? "frontend-design");

}

function requireRecord(value: unknown, label: string): Record<string, unknown> {

expect(value, label).toBeTypeOf("object");

expect(value, label).not.toBeNull();

if (!value || typeof value !== "object") {

throw new Error(`expected ${label}`);

}

return value as Record<string, unknown>;

}

}

function requireRecord(value: unknown, label: string): Record<string, unknown> {

expect(typeof value, label).toBe("object");

expect(value, label).not.toBeNull();

if (!value || typeof value !== "object") {

throw new Error(`expected ${label}`);

}

return value as Record<string, unknown>;

}

});

const persisted = await readPersistedInstalledPluginIndex({ stateDir });

expect(persisted).not.toBeNull();

if (!persisted) {

throw new Error("Expected persisted plugin index");

}

}

function expectFields(value: unknown, expected: Record<string, unknown>): void {

expect(value).toBeTypeOf("object");

expect(value).not.toBeNull();

if (!value || typeof value !== "object") {

throw new Error("expected fields object");

}

const record = value as Record<string, unknown>;

for (const [key, expectedValue] of Object.entries(expected)) {

expect(record[key], key).toEqual(expectedValue);

};

function requireRecord(value: unknown, label: string): Record<string, unknown> {

expect(typeof value, label).toBe("object");

expect(value, label).not.toBeNull();

if (!value || typeof value !== "object") {

throw new Error(`expected ${label}`);

}

return value as Record<string, unknown>;

}