The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
import { describe, expect, it, vi } from "vitest";
import { execFile } from "node:child_process";
import { promisify } from "node:util";
import { prepareVerifiedRemoteProviderPack, useVerifiedPreinstalledRemoteProviderPack, runRemoteProviderVerification, shouldUseBundledAcpxImageAssets } from "./remote-provider-pack.js";
describe("remote provider verification", () => {
const ok = { exitCode: 0, timedOut: false, stdout: "verified", stderr: "", signal: null };
it.each([
{ ...ok, exitCode: null, timedOut: true },
{ ...ok, exitCode: null },
{ ...ok, exitCode: 137, signal: "SIGKILL" },
])("retries an interrupted read without calling it incompatible: %j", async result => {
const execute = vi.fn().mockResolvedValueOnce(result).mockResolvedValueOnce(ok);
await expect(runRemoteProviderVerification(execute, "pack")).resolves.toEqual(ok);
expect(execute).toHaveBeenCalledTimes(2);
});
it("exhausts its own read budget after two inconclusive reads, including empty stderr", async () => {
const execute = vi.fn().mockResolvedValue({ ...ok, exitCode: null, timedOut: true });
await expect(runRemoteProviderVerification(execute, "pack"))
.rejects.toThrow("runner_remote_provider_verification_unavailable: pack unavailable after 2 verification attempts (exitCode=null; timedOut=true");
expect(execute).toHaveBeenCalledTimes(2);
});
it.each(["", "manifest mismatch", "dist tree digest mismatch"])("fails closed without retrying a completed rejection: %s", async stderr => {
const execute = vi.fn().mockResolvedValue({ ...ok, exitCode: 1, stderr });
await expect(runRemoteProviderVerification(execute, "pack")).rejects.toThrow("runner_remote_provider_artifact_incompatible: pack failed (exitCode=1");
expect(execute).toHaveBeenCalledOnce();
});
it("retains a bounded redacted rejection from a combined-output transport", async () => {
const execute = vi.fn().mockResolvedValue({ ...ok, exitCode: 1,
stdout: "Error: manifest mismatch\nANTHROPIC_API_KEY=secret-fixture-value", stderr: "" });
const failure = await runRemoteProviderVerification(execute, "pack").catch(error => error);
expect(failure.message).toContain("manifest mismatch");
expect(failure.message).not.toContain("secret-fixture-value");
expect(execute).toHaveBeenCalledOnce();
});
it("recovers a transport exception and propagates cancellation", async () => {
const execute = vi.fn().mockRejectedValueOnce(new Error("connection unavailable")).mockResolvedValueOnce(ok);
await expect(runRemoteProviderVerification(execute, "pack")).resolves.toEqual(ok);
const abort = new DOMException("cancelled", "AbortError");
execute.mockReset().mockRejectedValue(abort);
await expect(runRemoteProviderVerification(execute, "pack")).rejects.toBe(abort);
expect(execute).toHaveBeenCalledOnce();
});
it("retries after a real timed-out subprocess exits while unrelated work remains responsive", async () => {
let attempts = 0;
let responsive = false;
const unrelated = new Promise<void>(resolve => setTimeout(() => { responsive = true; resolve(); }, 5));
const result = await runRemoteProviderVerification(async () => {
attempts += 1;
try {
const result = await promisify(execFile)(process.execPath, ["-e", attempts === 1 ? "setInterval(()=>{},1000)" : "process.stdout.write('verified')"], { timeout: attempts === 1 ? 100 : 2_000 });
return { ...ok, ...result };
} catch (error) {
const failure = error as Error & { killed: boolean; signal: string; stdout: string; stderr: string };
if (!failure.killed) throw error;
return { ...ok, exitCode: null, timedOut: true, signal: failure.signal, stderr: failure.stderr };
}
}, "pack");
await unrelated;
expect({ attempts, responsive, stdout: result.stdout }).toEqual({ attempts: 2, responsive: true, stdout: "verified" });
});
});
describe("remote provider pack reuse", () => {
it("keeps a verified staged pack without consulting the image or uploading again", async () => {
const usePreinstalled = vi.fn();
const stageAndVerify = vi.fn();
expect(await prepareVerifiedRemoteProviderPack({
verifyStaged: async () => {}, usePreinstalled, stageAndVerify,
})).toBe("staged");
expect(usePreinstalled).not.toHaveBeenCalled();
expect(stageAndVerify).not.toHaveBeenCalled();
});
it.each(["missing pack", "manifest mismatch", "artifact hash mismatch"])(
"replaces a %s with a verified image pack",
async (reason) => {
const stageAndVerify = vi.fn();
expect(await prepareVerifiedRemoteProviderPack({
verifyStaged: async () => { throw new Error(reason); },
usePreinstalled: async () => true,
stageAndVerify,
})).toBe("preinstalled");
expect(stageAndVerify).not.toHaveBeenCalled();
},
);
it("uploads when neither existing pack is valid and fails closed if upload verification fails", async () => {
const stageAndVerify = vi.fn().mockRejectedValue(new Error("artifact hash mismatch"));
const input = {
verifyStaged: async () => { throw new Error("stale staged pack"); },
usePreinstalled: async () => false,
stageAndVerify,
};
await expect(prepareVerifiedRemoteProviderPack(input)).rejects.toThrow("artifact hash mismatch");
stageAndVerify.mockResolvedValue(undefined);
await expect(prepareVerifiedRemoteProviderPack(input)).resolves.toBe("uploaded");
});
});
describe("ordinary ACPX image artifacts", () => {
const provider = (agent: string) => ({ kind: "acpx", agent, model: "selected-model" } as Parameters<typeof shouldUseBundledAcpxImageAssets>[0]["provider"]);
it.each(["cursor", "copilot"])("selects bundled artifacts for remote %s without an operator override", agent => {
expect(shouldUseBundledAcpxImageAssets({ requiresRemoteProviderPack: true, configuredProviderPackRoot: null, provider: provider(agent) })).toBe(true);
expect(shouldUseBundledAcpxImageAssets({ requiresRemoteProviderPack: false, configuredProviderPackRoot: null, provider: provider(agent) })).toBe(false);
expect(shouldUseBundledAcpxImageAssets({ requiresRemoteProviderPack: true, configuredProviderPackRoot: "/explicit/pack", provider: provider(agent) })).toBe(false);
});
it.each(["pi", "claude", "codex", "grok"])("does not change the artifact authority for %s", agent => {
expect(shouldUseBundledAcpxImageAssets({ requiresRemoteProviderPack: true, configuredProviderPackRoot: null, provider: provider(agent) })).toBe(false);
});
it("does not admit a non-ACPX provider through bundled image selection", () => {
expect(shouldUseBundledAcpxImageAssets({ requiresRemoteProviderPack: true, configuredProviderPackRoot: null, provider: { kind: "codex", model: null } })).toBe(false);
});
});
describe("standard remote provider pack discovery", () => {
const roots = ["/opt/paperclip-runner/provider-pack", "/home/operator/.local/share/paperclip-runner/provider-pack"];
it.each(["old manifest", "modified artifact", "failed link"])("tries the matching home pack after %s rejects /opt", async reason => {
const verifyAndLink = vi.fn(async (root: string) => {
if (root === roots[0]) throw new Error(reason);
});
await expect(useVerifiedPreinstalledRemoteProviderPack({ candidates: roots, verifyAndLink })).resolves.toBe(true);
expect(verifyAndLink.mock.calls.map(([root]) => root)).toEqual(roots);
});
it("keeps the first matching pack without consulting another installation", async () => {
const verifyAndLink = vi.fn(async () => {});
await expect(useVerifiedPreinstalledRemoteProviderPack({ candidates: roots, verifyAndLink })).resolves.toBe(true);
expect(verifyAndLink).toHaveBeenCalledExactlyOnceWith(roots[0]);
});
it("fails closed when every standard installation is incompatible", async () => {
const verifyAndLink = vi.fn().mockRejectedValue(new Error("manifest mismatch"));
await expect(useVerifiedPreinstalledRemoteProviderPack({ candidates: roots, verifyAndLink })).resolves.toBe(false);
expect(verifyAndLink).toHaveBeenCalledTimes(2);
});
});