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 type { AdapterInfo } from "../api/adapters";
import { qualifyClaudeSetup } from "./qualify-claude-setup";
const image = `registry.example.test/runtime@sha256:${"a".repeat(64)}`;
const discovery = (runner: "paperclip" | "legacy", overrides = {}) => [
{ type: "claude_local", defaultRunner: runner, supportedRunners: [runner], ...overrides },
{ type: "paperclip_runner" },
] as AdapterInfo[];
function setup() {
return {
adapterType: "claude_local", runner: "auto" as const,
environment: { driver: "sandbox" as const, config: { provider: "daytona", image } },
readAdapters: vi.fn().mockResolvedValueOnce(discovery("legacy")).mockResolvedValue(discovery("paperclip")),
probeEnvironment: vi.fn().mockResolvedValue({ ok: true, driver: "sandbox", summary: "Measured image",
details: { platformQualificationRecorded: true, leaseId: "owned-probe-lease" } }),
isCurrent: vi.fn(() => true),
};
}
describe("Claude explicit setup qualification", () => {
it("qualifies a named Daytona snapshot through the normal Connect action", async () => {
const s = setup();
const input: Parameters<typeof qualifyClaudeSetup>[0] = { ...s, environment: { driver: "sandbox", config: { provider: "daytona", snapshot: "managed-snapshot" } } };
expect((await qualifyClaudeSetup(input))?.runner).toBe("paperclip");
expect(s.probeEnvironment).toHaveBeenCalledTimes(1);
});
it.each(["paperclip", "legacy"] as const)("uses fresh discovery and honors measured %s selection", async runner => {
const s = setup();
s.readAdapters.mockResolvedValueOnce(discovery(runner));
const result = await qualifyClaudeSetup(s);
expect(result?.runner).toBe(runner);
expect(s.readAdapters).toHaveBeenCalledTimes(2);
expect(s.probeEnvironment).toHaveBeenCalledTimes(1);
expect(s.readAdapters.mock.invocationCallOrder[0]).toBeLessThan(s.probeEnvironment.mock.invocationCallOrder[0]);
expect(s.probeEnvironment.mock.invocationCallOrder[0]).toBeLessThan(s.readAdapters.mock.invocationCallOrder[1]);
});
it.each(["permission", "cleanup", "missing-lease", "connection", "discovery"])("stops before adapter setup after %s failure", async failure => {
const s = setup();
if (failure === "permission") s.probeEnvironment.mockRejectedValue(new Error("Instance admin access required"));
else if (failure === "discovery") s.readAdapters.mockRejectedValue(new Error("Discovery unavailable"));
else s.probeEnvironment.mockResolvedValue({ ok: failure !== "connection", summary: "Qualification rejected",
details: { platformQualificationRecorded: failure !== "cleanup", ...(failure === "missing-lease" ? {} : { leaseId: "lease" }) } });
await expect(qualifyClaudeSetup(s)).rejects.toThrow(failure === "permission" ? "Instance admin" : failure === "discovery" ? "Discovery" : "Qualification rejected");
});
it.each(["legacy", "native", "local", "snapshot", "tag", "saved", "codex", "qualified", "disabled", "override", "missing-native"])("does not allocate an extra probe for %s", async mode => {
const s = setup();
const input: Parameters<typeof qualifyClaudeSetup>[0] = s;
if (mode === "legacy" || mode === "native") input.runner = mode === "native" ? "paperclip" : "legacy";
if (mode === "local") input.environment = { driver: "local", config: {} };
if (mode === "snapshot") input.environment = { driver: "sandbox", config: { image, snapshot: "named-snapshot" } };
if (mode === "tag") input.environment = { driver: "sandbox", config: { image: "registry.example.test/runtime:latest" } };
if (mode === "saved") input.savedAgentId = "saved-agent";
if (mode === "codex") input.adapterType = "codex_local";
if (mode === "qualified") s.readAdapters.mockReset().mockResolvedValue(discovery("paperclip"));
if (mode === "disabled" || mode === "override") s.readAdapters.mockReset().mockResolvedValue(discovery("legacy", mode === "disabled" ? { disabled: true } : { overriddenBuiltin: true }));
if (mode === "missing-native") s.readAdapters.mockReset().mockResolvedValue(discovery("legacy").slice(0, 1));
await qualifyClaudeSetup(input);
expect(s.probeEnvironment).not.toHaveBeenCalled();
});
it("abandons a stale selection before probing and after probing", async () => {
const before = setup(); before.isCurrent.mockReturnValue(false);
expect(await qualifyClaudeSetup(before)).toBeUndefined();
expect(before.probeEnvironment).not.toHaveBeenCalled();
const after = setup(); after.isCurrent.mockReturnValueOnce(true).mockReturnValue(false);
expect(await qualifyClaudeSetup(after)).toBeUndefined();
expect(after.probeEnvironment).toHaveBeenCalledTimes(1);
expect(after.readAdapters).toHaveBeenCalledTimes(1);
});
});