mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-04 02:32:07 +01:00
DottaandPaperclip
6e09a5ee82
Show CLI as the visible initial engine for fresh legacy agents on active Boat environments and preserve explicit choices through probe and hire. Permit the runtime engine selector on attached Boat environments while retaining managed host-path restrictions and other environment policy. Co-Authored-By: Paperclip <noreply@paperclip.ing>
890 lines
43 KiB
TypeScript
890 lines
43 KiB
TypeScript
// @vitest-environment jsdom
|
|
import { act } from "react";
|
|
import { createRoot, type Root } from "react-dom/client";
|
|
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
|
import { TooltipProvider } from "@/components/ui/tooltip";
|
|
import { queryKeys } from "@/lib/queryKeys";
|
|
import { NewAgent } from "./NewAgent";
|
|
import { ApiError } from "@/api/client";
|
|
|
|
const api = vi.hoisted(() => ({
|
|
get: vi.fn(),
|
|
adapterModels: vi.fn(),
|
|
list: vi.fn(),
|
|
hire: vi.fn(),
|
|
testEnvironment: vi.fn(),
|
|
getAdapterAuthSignal: vi.fn(),
|
|
getClaudeOAuthTokenStatus: vi.fn(),
|
|
}));
|
|
const envApi = vi.hoisted(() => ({ list: vi.fn(), capabilities: vi.fn() }));
|
|
const settings = vi.hoisted(() => ({
|
|
get: vi.fn(),
|
|
getExperimental: vi.fn(),
|
|
getGeneral: vi.fn(),
|
|
}));
|
|
const secrets = vi.hoisted(() => ({
|
|
create: vi.fn(),
|
|
remove: vi.fn(),
|
|
list: vi.fn(),
|
|
listMyUserSecrets: vi.fn(),
|
|
createUserSecretDefinition: vi.fn(),
|
|
createMyUserSecret: vi.fn(),
|
|
rotateMyUserSecret: vi.fn(),
|
|
removeUserSecretDefinition: vi.fn(),
|
|
}));
|
|
const state = vi.hoisted(() => ({
|
|
params: new URLSearchParams(),
|
|
adapters: [] as object[],
|
|
navigate: vi.fn(),
|
|
openNewIssue: vi.fn(),
|
|
}));
|
|
const managedApi = vi.hoisted(() => ({
|
|
list: vi.fn(async () => ({ currentUserId: "user-1", canManageConnections: true, connections: [] })),
|
|
create: vi.fn(async () => ({ connectionId: "managed-connection", grantId: "managed-grant" })),
|
|
setDefault: vi.fn(async () => ({})),
|
|
}));
|
|
vi.mock("@/api/ai-connections", () => ({ aiConnectionsApi: managedApi }));
|
|
vi.mock("@/api/agents", () => ({ agentsApi: api }));
|
|
vi.mock("@/api/environments", () => ({ environmentsApi: envApi }));
|
|
vi.mock("@/api/instanceSettings", () => ({ instanceSettingsApi: settings }));
|
|
vi.mock("@/api/secrets", () => ({ secretsApi: secrets }));
|
|
vi.mock("@/api/adapters", () => ({
|
|
adaptersApi: { list: async () => state.adapters },
|
|
}));
|
|
vi.mock("@/context/CompanyContext", () => ({
|
|
useCompany: () => ({ selectedCompanyId: "company-1" }),
|
|
}));
|
|
vi.mock("../context/BreadcrumbContext", () => ({
|
|
useBreadcrumbs: () => ({ setBreadcrumbs: vi.fn() }),
|
|
}));
|
|
vi.mock("@/context/DialogContext", () => ({
|
|
useDialogActions: () => ({ openNewIssue: state.openNewIssue }),
|
|
}));
|
|
vi.mock("@/lib/router", () => ({
|
|
useNavigate: () => state.navigate,
|
|
useSearchParams: () => [state.params],
|
|
}));
|
|
// Exercise API/persistence contracts with deterministic presentation primitives.
|
|
// The actual searchable dropdown and login panel are covered by their tests and browser verification.
|
|
vi.mock("@/components/AgentConfigForm", () => ({
|
|
ModelDropdown: ({
|
|
value,
|
|
onChange,
|
|
}: {
|
|
value: string;
|
|
onChange: (value: string) => void;
|
|
}) => (
|
|
<input
|
|
aria-label="Model"
|
|
value={value}
|
|
onChange={(e) => onChange(e.target.value)}
|
|
/>
|
|
),
|
|
AdapterLoginPanel: ({ onConnected }: { onConnected: (id: string) => void }) => (
|
|
<button onClick={() => onConnected("login-session")}>
|
|
Complete subscription login
|
|
</button>
|
|
),
|
|
}));
|
|
vi.mock("@/components/onboarding/PillGuy", () => ({ PillGuy: () => null }));
|
|
vi.mock("motion/react", () => ({
|
|
AnimatePresence: ({ children }: any) => children,
|
|
MotionConfig: ({ children }: any) => children,
|
|
motion: {
|
|
span: ({ children }: any) => <span>{children}</span>,
|
|
div: ({ children, initial, animate, exit, transition, ...rest }: any) => (
|
|
<div {...rest}>{children}</div>
|
|
),
|
|
},
|
|
}));
|
|
(globalThis as any).IS_REACT_ACT_ENVIRONMENT = true;
|
|
let root: Root;
|
|
let container: HTMLDivElement;
|
|
let cache: QueryClient;
|
|
async function settle() {
|
|
await act(async () => {
|
|
await new Promise((resolve) => setTimeout(resolve, 20));
|
|
});
|
|
}
|
|
async function click(text: string) {
|
|
const button = [...container.querySelectorAll("button")].find(
|
|
(b) => b.textContent?.trim() === text,
|
|
);
|
|
expect(button, `Missing button ${text}`).toBeTruthy();
|
|
await act(async () => button!.click());
|
|
await settle();
|
|
}
|
|
async function fill(label: string, value: string) {
|
|
const input = container.querySelector(
|
|
`[aria-label="${label}"]`,
|
|
) as HTMLInputElement;
|
|
expect(input).toBeTruthy();
|
|
await act(async () => {
|
|
Object.getOwnPropertyDescriptor(
|
|
HTMLInputElement.prototype,
|
|
"value",
|
|
)!.set!.call(input, value);
|
|
input.dispatchEvent(new Event("input", { bubbles: true }));
|
|
});
|
|
}
|
|
async function render(adapter = "pi_local", runnerProvider = "codex") {
|
|
state.params = new URLSearchParams({
|
|
name: "Atlas",
|
|
adapterType: adapter,
|
|
runnerProvider,
|
|
});
|
|
await act(async () =>
|
|
root.render(
|
|
<QueryClientProvider client={cache}>
|
|
<TooltipProvider><NewAgent /></TooltipProvider>
|
|
</QueryClientProvider>,
|
|
),
|
|
);
|
|
await settle();
|
|
}
|
|
async function connect(provider: string) {
|
|
await click(provider + "Subscription");
|
|
await click("Connect");
|
|
}
|
|
const pass = {
|
|
adapterType: "pi_local",
|
|
status: "pass",
|
|
checks: [
|
|
{ code: "hello_probe_passed", level: "info", message: "Model replied" },
|
|
],
|
|
testedAt: "2026-09-07T00:00:00Z",
|
|
};
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
managedApi.list.mockResolvedValue({ currentUserId: "user-1", canManageConnections: true, connections: [] });
|
|
container = document.createElement("div");
|
|
document.body.append(container);
|
|
root = createRoot(container);
|
|
cache = new QueryClient({
|
|
defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
|
|
});
|
|
state.adapters = [
|
|
"claude_local",
|
|
"codex_local",
|
|
"opencode_local",
|
|
"pi_local",
|
|
"paperclip_runner", "cursor_cloud", "cursor", "gemini_local", "kimi_local", "grok_local", "hermes_local", "hermes_gateway",
|
|
].map((type) => ({ type, loaded: true, disabled: false }));
|
|
api.adapterModels.mockResolvedValue([]);
|
|
api.list.mockResolvedValue([{ id: "ceo", role: "ceo", status: "idle" }]);
|
|
api.getAdapterAuthSignal.mockResolvedValue({ status: "present" });
|
|
api.getClaudeOAuthTokenStatus.mockRejectedValue(new ApiError("Not found", 404, null));
|
|
api.testEnvironment.mockResolvedValue(pass);
|
|
api.hire.mockImplementation(async (_company, input) => ({
|
|
agent: { ...input, id: "new-agent", status: "idle", urlKey: "atlas" },
|
|
}));
|
|
envApi.list.mockResolvedValue([
|
|
{ id: "local-1", name: "Local", driver: "local", config: {} },
|
|
]);
|
|
envApi.capabilities.mockResolvedValue({ sandboxProviders: {} });
|
|
settings.get.mockResolvedValue({ defaultEnvironmentId: "local-1" });
|
|
settings.getExperimental.mockResolvedValue({ enableNativeRunner: true });
|
|
settings.getGeneral.mockResolvedValue({ executionMode: "any" });
|
|
secrets.list.mockResolvedValue([]);
|
|
secrets.create.mockResolvedValue({ id: "org-secret-1" });
|
|
secrets.remove.mockResolvedValue({ ok: true });
|
|
secrets.listMyUserSecrets.mockResolvedValue([]);
|
|
secrets.createUserSecretDefinition.mockResolvedValue({ id: "definition-1" });
|
|
secrets.createMyUserSecret.mockResolvedValue({ id: "secret-1" });
|
|
secrets.removeUserSecretDefinition.mockResolvedValue({ ok: true });
|
|
});
|
|
afterEach(async () => {
|
|
await act(async () => root.unmount());
|
|
cache.clear();
|
|
container.remove();
|
|
});
|
|
describe("New agent setup", () => {
|
|
it("creates Dot through its independent choice without CLI or model setup, then routes to pairing", async () => {
|
|
settings.getExperimental.mockResolvedValue({ enableNativeRunner: false, enableOpenAiDot: true, enablePublicMcp: true });
|
|
await render("paperclip_runner", "openai_dot");
|
|
expect(container.textContent).toContain("OpenAI Dot");
|
|
expect(container.querySelector('[aria-label="Model"]')).toBeNull();
|
|
expect(container.textContent).not.toContain("Connect a model");
|
|
expect(container.textContent).toContain("Check prerequisites");
|
|
expect(container.textContent).not.toContain("runtime and model can respond");
|
|
await click("Finish setup");
|
|
expect(api.hire).not.toHaveBeenCalled();
|
|
expect(container.textContent).toContain("Acknowledge external provider billing");
|
|
await act(async () => container.querySelector<HTMLButtonElement>('[role="switch"]')!.click());
|
|
await click("Finish setup");
|
|
expect(api.hire).toHaveBeenCalledWith("company-1", expect.objectContaining({ adapterType: "paperclip_runner", adapterConfig: {
|
|
provider: "openai_dot", lifecycleMode: "per_turn", allowUnmeteredProvider: true, dotWorkspaceAccess: false, dotAttachmentAccess: false,
|
|
} }));
|
|
expect(container.textContent).toContain("Your Dot agent has been created");
|
|
await click("Pair Dot");
|
|
expect(state.navigate).toHaveBeenLastCalledWith("/agents/atlas/runtime");
|
|
expect(state.openNewIssue).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it.each(["claude_local", "codex_local"])("can choose a sign-in environment in Configure before connecting %s", async (adapterType) => {
|
|
settings.get.mockResolvedValue({ defaultEnvironmentId: "no-login" });
|
|
envApi.list.mockResolvedValue([
|
|
{ id: "no-login", name: "No browser sign-in", status: "active", driver: "sandbox", config: { provider: "other" } },
|
|
{ id: "login-env", name: "Browser sign-in", status: "active", driver: "sandbox", config: { provider: "daytona" } },
|
|
]);
|
|
envApi.capabilities.mockResolvedValue({ sandboxProviders: { daytona: { supportsLoginPty: true } } });
|
|
api.getAdapterAuthSignal.mockResolvedValue({ status: "missing" });
|
|
await render(adapterType);
|
|
expect(container.textContent).toContain("does not support browser sign-in");
|
|
expect(container.querySelector('select[aria-label="Environment"]')).toBeNull();
|
|
await click("2Configure");
|
|
expect(container.querySelector('button[type="submit"]')).toBeNull();
|
|
expect([...container.querySelectorAll("button")].find(button => button.textContent?.trim() === "Run test")?.disabled).toBe(true);
|
|
await click("Connect model");
|
|
expect(api.testEnvironment).not.toHaveBeenCalled();
|
|
expect(api.hire).not.toHaveBeenCalled();
|
|
await click("2Configure");
|
|
const select = container.querySelector('select[aria-label="Environment"]') as HTMLSelectElement;
|
|
await act(async () => {
|
|
select.value = "login-env";
|
|
select.dispatchEvent(new Event("change", { bubbles: true }));
|
|
});
|
|
await settle();
|
|
expect(container.querySelector('select[aria-label="Environment"]')).toBeNull();
|
|
await click("Complete subscription login");
|
|
await click("Finish setup");
|
|
expect(api.hire.mock.calls[0][1]).toMatchObject({ defaultEnvironmentId: "login-env", runtimeConfig: { aiConnection: { method: "subscription" } } });
|
|
});
|
|
it("waits for the resolved environment before allowing a credential-mode selection", async () => {
|
|
let resolveEnvironments!: (value: object[]) => void;
|
|
envApi.list.mockImplementationOnce(() => new Promise<object[]>(resolve => { resolveEnvironments = resolve; }));
|
|
await render("codex_local");
|
|
expect(container.textContent).toContain("Loading connection settings");
|
|
expect(container.querySelector('[role="radiogroup"][aria-label="Connection type"]')).toBeNull();
|
|
await act(async () => resolveEnvironments([{ id: "local-1", name: "Local", driver: "local", config: {} }]));
|
|
await settle();
|
|
await click("OpenAIAPI key");
|
|
expect(container.querySelector('[aria-label="API key"]')).not.toBeNull();
|
|
await settle();
|
|
expect(container.querySelector('[aria-label="API key"]')).not.toBeNull();
|
|
});
|
|
it.each([false, true])("selects the Grok environment in Configure (managed-only=%s)", async (managedOnly) => {
|
|
settings.getExperimental.mockResolvedValue({ enableNativeRunner: true, enableManagedSandboxOnly: managedOnly });
|
|
envApi.list.mockResolvedValue([
|
|
{ id: "local-1", name: "Local", status: "active", driver: "local", config: {} },
|
|
{ id: "grok-sandbox", name: "Grok sandbox", status: "active", driver: "sandbox", config: { provider: "daytona" } },
|
|
]);
|
|
secrets.listMyUserSecrets.mockResolvedValue([{
|
|
definition: { id: "grok-key", companyId: "company-1", key: "XAI_API_KEY", name: "Grok key", status: "active" },
|
|
secret: { companyId: "company-1", status: "active" },
|
|
}]);
|
|
await render("paperclip_runner", "grok");
|
|
expect(container.querySelector('select[aria-label="Environment"]')).toBeNull();
|
|
await click("GrokAPI key");
|
|
await click("Use saved API key");
|
|
const select = container.querySelector('select[aria-label="Environment"]') as HTMLSelectElement;
|
|
expect(select.disabled).toBe(false);
|
|
expect([...select.options].some((option) => option.value === "local-1")).toBe(!managedOnly);
|
|
await act(async () => {
|
|
select.value = "grok-sandbox";
|
|
select.dispatchEvent(new Event("change", { bubbles: true }));
|
|
});
|
|
await settle();
|
|
if (container.querySelector('[role="radiogroup"][aria-label="Connection type"]')) {
|
|
await click("GrokAPI key");
|
|
await click("Use saved API key");
|
|
}
|
|
expect(api.testEnvironment).toHaveBeenCalledWith("company-1", "paperclip_runner", expect.objectContaining({ environmentId: "grok-sandbox" }));
|
|
await click("Finish setup");
|
|
expect(api.hire.mock.calls[0][1].defaultEnvironmentId).toBe("grok-sandbox");
|
|
});
|
|
it.each([false, true])("blocks direct runner setup links when the experiment is disabled (cloud=%s)", async (cloud) => {
|
|
cache.setQueryData(queryKeys.health, { status: "ok", cloud: { managed: cloud } });
|
|
settings.getExperimental.mockResolvedValue({ enableNativeRunner: false });
|
|
await render("paperclip_runner");
|
|
expect(container.textContent).toContain("This adapter is unavailable");
|
|
expect(api.hire).not.toHaveBeenCalled();
|
|
});
|
|
it("blocks direct setup links for unsupported Cloud adapters", async () => {
|
|
cache.setQueryData(queryKeys.health, {
|
|
status: "ok",
|
|
cloud: { managed: true },
|
|
});
|
|
await render("pi_local");
|
|
expect(container.textContent).toContain("This adapter is unavailable");
|
|
expect(api.hire).not.toHaveBeenCalled();
|
|
});
|
|
it.each([
|
|
["codex_local", "OpenAI", undefined], ["claude_local", "Claude", undefined],
|
|
["codex_local", "OpenAI", "acp"], ["claude_local", "Claude", "acp"],
|
|
])("shows Boat's CLI default before connecting and preserves an explicit engine for %s (%s, %s)", async (adapter, provider, choice) => {
|
|
envApi.list.mockResolvedValue([
|
|
{ id: "boat-1", name: "Boat", driver: "computer", status: "active", config: { provider: "boat" } },
|
|
]);
|
|
settings.get.mockResolvedValue({ defaultEnvironmentId: "boat-1" });
|
|
settings.getExperimental.mockResolvedValue({ enableManagedSandboxOnly: true, enableNativeRunner: true });
|
|
await render(adapter);
|
|
const engine = container.querySelector<HTMLSelectElement>('[aria-label="Execution engine"]')!;
|
|
expect(engine).not.toBeNull();
|
|
expect(engine.value).toBe("cli");
|
|
expect(engine.selectedOptions[0].textContent).toBe(adapter === "codex_local" ? "Codex CLI" : "Claude CLI");
|
|
expect(api.testEnvironment).not.toHaveBeenCalled();
|
|
if (choice) await act(async () => {
|
|
engine.value = choice;
|
|
engine.dispatchEvent(new Event("change", { bubbles: true }));
|
|
});
|
|
await click(provider + "API key");
|
|
await fill("API key", "boat-test-key");
|
|
await click("Connect");
|
|
expect(api.testEnvironment.mock.calls[0][2]).toMatchObject({
|
|
environmentId: "boat-1", adapterConfig: { engine: choice ?? "cli" },
|
|
});
|
|
expect(container.querySelector<HTMLSelectElement>('[aria-label="Execution engine"]')?.value).toBe(choice ?? "cli");
|
|
await click("Finish setup");
|
|
expect(api.hire.mock.calls[0][1]).toMatchObject({
|
|
defaultEnvironmentId: "boat-1", adapterConfig: { engine: choice ?? "cli" },
|
|
runtimeConfig: { heartbeat: { enabled: false } },
|
|
});
|
|
});
|
|
|
|
it.each(["codex_local", "claude_local"])("does not expose or inject a Boat engine on a managed sandbox for %s", async adapter => {
|
|
envApi.list.mockResolvedValue([
|
|
{ id: "managed-1", name: "Managed", driver: "sandbox", status: "active", config: { provider: "daytona" } },
|
|
]);
|
|
settings.get.mockResolvedValue({ defaultEnvironmentId: "managed-1" });
|
|
settings.getExperimental.mockResolvedValue({ enableManagedSandboxOnly: true, enableNativeRunner: true });
|
|
await render(adapter);
|
|
expect(container.querySelector('[aria-label="Execution engine"]')).toBeNull();
|
|
await click((adapter === "codex_local" ? "OpenAI" : "Claude") + "API key");
|
|
await fill("API key", "sandbox-test-key");
|
|
await click("Connect");
|
|
expect(api.testEnvironment.mock.calls[0][2].adapterConfig.engine).toBeUndefined();
|
|
await click("Finish setup");
|
|
expect(api.hire.mock.calls[0][1].adapterConfig.engine).toBeUndefined();
|
|
});
|
|
|
|
it.each([
|
|
["grok_local", "subscription"], ["grok_local", "api_key"],
|
|
["paperclip_runner", "subscription"], ["paperclip_runner", "api_key"],
|
|
])("configures %s Grok on Cloud with an xAI %s connection", async (adapterType, method) => {
|
|
cache.setQueryData(queryKeys.health, {
|
|
status: "ok",
|
|
cloud: { managed: true },
|
|
});
|
|
envApi.list.mockResolvedValue([
|
|
{ id: "sandbox-1", name: "Paperclip Cloud", driver: "sandbox", config: { provider: "daytona" } },
|
|
]);
|
|
envApi.capabilities.mockResolvedValue({
|
|
sandboxProviders: { daytona: { supportsLoginPty: true } },
|
|
});
|
|
settings.get.mockResolvedValue({ defaultEnvironmentId: "sandbox-1" });
|
|
settings.getExperimental.mockResolvedValue({ enableManagedSandboxOnly: true, enableNativeRunner: true });
|
|
api.getAdapterAuthSignal.mockResolvedValue({ status: "missing" });
|
|
api.testEnvironment.mockResolvedValue({ ...pass, adapterType });
|
|
await render(adapterType, "grok");
|
|
expect(container.textContent).toContain("Connect a model");
|
|
expect(container.textContent).not.toContain("Connect Atlas to Grok");
|
|
if (method === "subscription") {
|
|
await click("GrokSubscription");
|
|
await click("Complete subscription login");
|
|
} else {
|
|
await click("GrokAPI key");
|
|
await fill("API key", "example-test-secret");
|
|
await click("Connect");
|
|
expect(managedApi.create).toHaveBeenCalledWith("company-1", expect.objectContaining({
|
|
provider: "xai", method: "api_key", apiKey: "example-test-secret",
|
|
}));
|
|
}
|
|
const model = adapterType === "paperclip_runner" ? "grok-4.7" : "grok-code-fast-1";
|
|
await fill("Model", model);
|
|
await click("Run test");
|
|
const binding = method === "api_key"
|
|
? { provider: "xai", method, mode: "delegated", connectionId: "managed-connection", grantId: "managed-grant" }
|
|
: { provider: "xai", method, mode: "responsible_user" };
|
|
expect(api.testEnvironment).toHaveBeenLastCalledWith("company-1", adapterType, expect.objectContaining({
|
|
environmentId: "sandbox-1",
|
|
adapterConfig: expect.objectContaining({ model, ...(adapterType === "paperclip_runner" ? { provider: "acpx", acpxAgent: "grok", acpxPermissionMode: "approve-all" } : {}) }),
|
|
aiConnection: binding,
|
|
testCredentials: {},
|
|
}));
|
|
await click("Finish setup");
|
|
expect(api.hire).toHaveBeenCalledTimes(1);
|
|
expect(api.hire.mock.calls[0][1]).toMatchObject({
|
|
adapterType,
|
|
defaultEnvironmentId: "sandbox-1",
|
|
adapterConfig: { model, ...(adapterType === "paperclip_runner" ? { provider: "acpx", acpxAgent: "grok", acpxPermissionMode: "approve-all" } : {}) },
|
|
runtimeConfig: { aiConnection: binding, heartbeat: { enabled: false } },
|
|
});
|
|
expect(JSON.stringify(api.testEnvironment.mock.calls)).not.toContain("example-test-secret");
|
|
expect(JSON.stringify(api.hire.mock.calls)).not.toContain("example-test-secret");
|
|
expect(container.textContent).toContain("Your agent is ready");
|
|
});
|
|
it("sends Cursor Cloud repo/ref and transient API key, then saves an organization secret", async () => {
|
|
await render("cursor_cloud");
|
|
expect(container.querySelector('[aria-label="Model"]')).toBeNull();
|
|
expect(container.querySelector('[aria-label="Thinking effort"]')).toBeNull();
|
|
await fill("GitHub repository", "https://github.com/paperclipai/paperclip");
|
|
await fill("Branch", "master");
|
|
await fill("CURSOR_API_KEY", "cursor-test-key");
|
|
await click("Run test");
|
|
expect(api.testEnvironment.mock.calls[0][2]).toMatchObject({
|
|
adapterConfig: { repoUrl: "https://github.com/paperclipai/paperclip", repoStartingRef: "master" },
|
|
testCredentials: { CURSOR_API_KEY: "cursor-test-key" },
|
|
});
|
|
expect(secrets.create).not.toHaveBeenCalled();
|
|
await click("Finish setup");
|
|
const config = api.hire.mock.calls[0][1].adapterConfig;
|
|
expect(config).toMatchObject({ repoUrl: "https://github.com/paperclipai/paperclip", repoStartingRef: "master", env: {
|
|
CURSOR_API_KEY: { type: "secret_ref", secretId: "org-secret-1", version: "latest" },
|
|
} });
|
|
expect(config).not.toHaveProperty("repository");
|
|
expect(config).not.toHaveProperty("branch");
|
|
expect(JSON.stringify(config)).not.toContain("cursor-test-key");
|
|
expect(secrets.create).toHaveBeenCalledWith("company-1", expect.objectContaining({ value: "cursor-test-key" }));
|
|
});
|
|
it("requires a new Cursor Cloud key even when organization and personal keys exist", async () => {
|
|
secrets.list.mockResolvedValue([{ id: "existing", key: "CURSOR_API_KEY", name: "Cursor", status: "active" }]);
|
|
secrets.listMyUserSecrets.mockResolvedValue([{ definition: { key: "CURSOR_API_KEY" }, secret: { id: "personal-key" } }]);
|
|
await render("cursor_cloud");
|
|
expect(container.textContent).not.toContain("Or use an organization secret");
|
|
await fill("GitHub repository", "https://github.com/example/repo");
|
|
await click("Finish setup");
|
|
expect(api.hire).not.toHaveBeenCalled();
|
|
expect(container.textContent).toContain("Enter a Cursor API key");
|
|
await fill("CURSOR_API_KEY", "new-cursor-key");
|
|
await click("Finish setup");
|
|
expect(secrets.create).toHaveBeenCalledWith("company-1", expect.objectContaining({ value: "new-cursor-key" }));
|
|
expect(api.hire.mock.calls[0][1].adapterConfig.env.CURSOR_API_KEY).toMatchObject({ type: "secret_ref", secretId: "org-secret-1" });
|
|
});
|
|
it.each([
|
|
["cursor", "CURSOR_API_KEY"],
|
|
["gemini_local", "GEMINI_API_KEY"],
|
|
["hermes_local", "OPENROUTER_API_KEY"],
|
|
])("provides %s credentials to tests and stores only a secret reference", async (adapter, key) => {
|
|
await render(adapter);
|
|
await fill(key, "adapter-test-key");
|
|
await click("Finish setup");
|
|
expect(api.testEnvironment.mock.calls[0][2].testCredentials).toEqual({ [key]: "adapter-test-key" });
|
|
expect(api.hire.mock.calls[0][1].adapterConfig.env[key]).toMatchObject({ type: "secret_ref", secretId: "org-secret-1" });
|
|
expect(container.querySelector('[aria-label="Thinking effort"]')).toBeNull();
|
|
});
|
|
it("defines a Kimi API model without overriding it with a CLI model alias", async () => {
|
|
await render("kimi_local");
|
|
await fill("KIMI_MODEL_API_KEY", "kimi-test-key");
|
|
await click("Run test");
|
|
expect(api.testEnvironment).not.toHaveBeenCalled();
|
|
expect(container.textContent).toContain("Enter the Kimi API model name");
|
|
await fill("Kimi API model name", "kimi-for-coding");
|
|
await fill("Kimi API base URL", "https://api.kimi.com/coding/v1");
|
|
await click("Finish setup");
|
|
const config = api.hire.mock.calls[0][1].adapterConfig;
|
|
expect(config).not.toHaveProperty("model");
|
|
expect(config.env).toMatchObject({
|
|
KIMI_MODEL_NAME: { type: "plain", value: "kimi-for-coding" },
|
|
KIMI_MODEL_BASE_URL: { type: "plain", value: "https://api.kimi.com/coding/v1" },
|
|
KIMI_MODEL_API_KEY: { type: "secret_ref", secretId: "org-secret-1" },
|
|
});
|
|
});
|
|
it("configures Hermes Gateway URL and its top-level secret reference", async () => {
|
|
await render("hermes_gateway");
|
|
expect(container.querySelector('[aria-label="Model"]')).toBeNull();
|
|
await fill("Hermes API base URL", "https://hermes.example.com");
|
|
await fill("API_SERVER_KEY", "hermes-test-key");
|
|
await click("Finish setup");
|
|
expect(api.testEnvironment.mock.calls[0][2]).toMatchObject({
|
|
adapterConfig: { apiBaseUrl: "https://hermes.example.com" },
|
|
testCredentials: { API_SERVER_KEY: "hermes-test-key" },
|
|
});
|
|
expect(api.hire.mock.calls[0][1].adapterConfig.apiKey).toMatchObject({ type: "secret_ref", secretId: "org-secret-1" });
|
|
expect(JSON.stringify(api.hire.mock.calls)).not.toContain("hermes-test-key");
|
|
});
|
|
it("uses the shared Grok connection flow and hides ignored Kimi and OpenCode effort controls", async () => {
|
|
await render("grok_local");
|
|
expect(container.textContent).toContain("Connect a model");
|
|
expect(container.textContent).not.toContain("Connect Atlas to Grok");
|
|
await render("opencode_local");
|
|
expect(container.querySelector('[aria-label="Thinking effort"]')).toBeNull();
|
|
});
|
|
it("restores confirmation on refresh without hiring again", async () => {
|
|
api.get.mockResolvedValue({
|
|
id: "saved-agent",
|
|
companyId: "company-1",
|
|
name: "Atlas",
|
|
adapterType: "pi_local",
|
|
adapterConfig: { model: "openrouter/anthropic/claude-sonnet-4.6" },
|
|
status: "idle",
|
|
});
|
|
state.params = new URLSearchParams({
|
|
name: "Atlas",
|
|
adapterType: "pi_local",
|
|
createdAgentId: "saved-agent",
|
|
});
|
|
await act(async () =>
|
|
root.render(
|
|
<QueryClientProvider client={cache}>
|
|
<TooltipProvider><NewAgent /></TooltipProvider>
|
|
</QueryClientProvider>,
|
|
),
|
|
);
|
|
await settle();
|
|
expect(container.textContent).toContain("Your agent is ready");
|
|
expect(container.textContent).not.toContain("Finish setup");
|
|
expect(api.hire).not.toHaveBeenCalled();
|
|
await click("Assign Atlas a Task");
|
|
expect(state.openNewIssue).toHaveBeenCalledWith({
|
|
assigneeAgentId: "saved-agent",
|
|
status: "todo",
|
|
});
|
|
});
|
|
it("does not advance connection after a timed-out provider probe", async () => {
|
|
api.testEnvironment.mockResolvedValue({
|
|
...pass,
|
|
status: "warn",
|
|
checks: [
|
|
{
|
|
code: "claude_hello_probe_timed_out",
|
|
level: "warn",
|
|
message: "Claude hello probe timed out.",
|
|
},
|
|
],
|
|
});
|
|
await render("claude_local");
|
|
await connect("Claude");
|
|
expect(container.textContent).toContain("Claude hello probe timed out.");
|
|
expect(container.textContent).not.toContain("Finish setup");
|
|
expect(api.hire).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it.each(["claude_local", "codex_local"])(
|
|
"connects %s, creates once, and assigns a task",
|
|
async (adapter) => {
|
|
await render(adapter);
|
|
await connect(adapter === "claude_local" ? "Claude" : "OpenAI");
|
|
expect(api.testEnvironment).toHaveBeenCalledWith(
|
|
"company-1",
|
|
adapter,
|
|
expect.objectContaining({ environmentId: "local-1" }),
|
|
);
|
|
await click("Finish setup");
|
|
expect(api.hire).toHaveBeenCalledTimes(1);
|
|
expect(api.hire.mock.calls[0][1]).toMatchObject({
|
|
name: "Atlas",
|
|
adapterType: adapter,
|
|
reportsTo: "ceo",
|
|
runtimeConfig: { heartbeat: { enabled: false } },
|
|
});
|
|
expect(container.textContent).toContain("Your agent is ready");
|
|
await click("Assign Atlas a Task");
|
|
expect(state.openNewIssue).toHaveBeenCalledWith({
|
|
assigneeAgentId: "new-agent",
|
|
status: "todo",
|
|
});
|
|
},
|
|
);
|
|
it.each([
|
|
["claude_local", "claude", "Claude", "ANTHROPIC_API_KEY"],
|
|
["codex_local", "codex", "OpenAI", "OPENAI_API_KEY"],
|
|
["paperclip_runner", "claude", "Claude", "ANTHROPIC_API_KEY"],
|
|
["paperclip_runner", "codex", "OpenAI", "OPENAI_API_KEY"],
|
|
])("stores %s %s as a reusable connection before hiring", async (adapter, runner, provider, key) => {
|
|
await render(adapter, runner);
|
|
await click(provider + "API key");
|
|
await fill("API key", "connection-key");
|
|
await click("Connect");
|
|
const binding = { provider: key === "ANTHROPIC_API_KEY" ? "anthropic" : "openai", method: "api_key", mode: "delegated", connectionId: "managed-connection", grantId: "managed-grant" };
|
|
expect(managedApi.create).toHaveBeenCalledWith("company-1", expect.objectContaining({ apiKey: "connection-key", provider: binding.provider }));
|
|
expect(api.testEnvironment.mock.calls[0][2].testCredentials).toEqual({});
|
|
expect(api.testEnvironment.mock.calls[0][2].aiConnection).toEqual(binding);
|
|
expect(container.textContent).toContain("Configure your agent");
|
|
expect(container.querySelector('[role="combobox"][aria-label="Connection"]')).toBeNull();
|
|
expect(secrets.createUserSecretDefinition).not.toHaveBeenCalled();
|
|
await click("Finish setup");
|
|
expect(api.hire.mock.calls[0][1].runtimeConfig.aiConnection).toEqual(binding);
|
|
expect(managedApi.create).toHaveBeenCalledTimes(1);
|
|
expect(JSON.stringify(api.hire.mock.calls)).not.toContain("connection-key");
|
|
});
|
|
it.each([
|
|
["claude_local", "claude", "Claude", "ANTHROPIC_API_KEY"],
|
|
["codex_local", "codex", "OpenAI", "OPENAI_API_KEY"],
|
|
["paperclip_runner", "claude", "Claude", "ANTHROPIC_API_KEY"],
|
|
["paperclip_runner", "codex", "OpenAI", "OPENAI_API_KEY"],
|
|
])("defaults %s %s to a saved key and preserves its reference through hire", async (adapter, runner, provider, key) => {
|
|
secrets.listMyUserSecrets.mockResolvedValue([{
|
|
definition: { id: "existing-key", companyId: "company-1", key, name: "Existing key", status: "active" },
|
|
secret: { companyId: "company-1", status: "active" },
|
|
}]);
|
|
await render(adapter, runner);
|
|
await click(provider + "API key");
|
|
expect((container.querySelector("select[aria-label='Saved API key']") as HTMLSelectElement).value).toBe("user:existing-key");
|
|
await click("Use saved API key");
|
|
const binding = { type: "user_secret_ref", key, version: "latest" };
|
|
expect(api.testEnvironment.mock.calls[0][2].adapterConfig.env[key]).toEqual(binding);
|
|
expect(api.testEnvironment.mock.calls[0][2].testCredentials).toEqual({});
|
|
await click("Finish setup");
|
|
expect(api.hire.mock.calls[0][1].adapterConfig.env[key]).toEqual(binding);
|
|
expect(secrets.createUserSecretDefinition).not.toHaveBeenCalled();
|
|
expect(secrets.createMyUserSecret).not.toHaveBeenCalled();
|
|
expect(secrets.rotateMyUserSecret).not.toHaveBeenCalled();
|
|
});
|
|
it.each(["codex_local", "paperclip_runner"])("keeps a saved connection chosen in Connect when hiring %s", async (adapter) => {
|
|
await render(adapter, "codex");
|
|
managedApi.list.mockResolvedValue({
|
|
currentUserId: "user-1",
|
|
connections: [{
|
|
id: "00000000-0000-4000-8000-000000000021", grantId: "00000000-0000-4000-8000-000000000022", companyId: "company-1",
|
|
provider: "openrouter", method: "api_key", name: "Company OpenRouter",
|
|
ownership: "shared", isDefault: false, status: "connected",
|
|
routing: { kind: "openrouter", protocol: "responses", auth: "bearer", models: [] },
|
|
}],
|
|
} as any);
|
|
await click("AdvancedCustom Gateway");
|
|
const picker = container.querySelector('[role="combobox"][aria-label="Connection"]')!;
|
|
await act(async () => picker.dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowDown", bubbles: true })));
|
|
await settle();
|
|
const option = [...document.querySelectorAll('[role="option"]')].find(node => node.textContent?.includes("Company OpenRouter")) as HTMLElement;
|
|
expect(option).toBeTruthy();
|
|
await act(async () => option.click());
|
|
await settle();
|
|
await click("Use connection");
|
|
expect(container.textContent).toContain("Configure your agent");
|
|
expect(container.querySelector('[role="combobox"][aria-label="Connection"]')).toBeNull();
|
|
await click("Run test");
|
|
const binding = { provider: "openrouter", method: "api_key", mode: "shared", connectionId: "00000000-0000-4000-8000-000000000021", grantId: "00000000-0000-4000-8000-000000000022" };
|
|
expect(api.testEnvironment.mock.calls[0][2].aiConnection).toEqual(binding);
|
|
await click("Finish setup");
|
|
expect(api.hire.mock.calls[0][1].runtimeConfig.aiConnection).toEqual(binding);
|
|
});
|
|
it("requires the current connection choice to connect before Configure can save it", async () => {
|
|
await render("codex_local");
|
|
managedApi.list.mockResolvedValue({ currentUserId: "user-1", connections: [{
|
|
id: "00000000-0000-4000-8000-000000000021", grantId: "00000000-0000-4000-8000-000000000022", companyId: "company-1",
|
|
provider: "openrouter", method: "api_key", name: "Company OpenRouter", ownership: "shared", isDefault: false, status: "connected",
|
|
routing: { kind: "openrouter", protocol: "responses", auth: "bearer", models: [] },
|
|
}] } as any);
|
|
await click("AdvancedCustom Gateway");
|
|
const picker = container.querySelector('[role="combobox"][aria-label="Connection"]')!;
|
|
await act(async () => picker.dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowDown", bubbles: true })));
|
|
await settle();
|
|
const option = [...document.querySelectorAll('[role="option"]')].find(node => node.textContent?.includes("Company OpenRouter")) as HTMLElement;
|
|
await act(async () => option.click());
|
|
await settle();
|
|
await click("2Configure");
|
|
expect(container.textContent).not.toContain("Finish setup");
|
|
expect(api.hire).not.toHaveBeenCalled();
|
|
await click("Connect model");
|
|
await click("OpenAIAPI key");
|
|
await fill("API key", "new-api-credential");
|
|
await click("2Configure");
|
|
expect(container.textContent).not.toContain("Finish setup");
|
|
expect(api.testEnvironment).not.toHaveBeenCalled();
|
|
await click("Connect model");
|
|
await click("OpenAIAPI key");
|
|
await fill("API key", "new-api-credential");
|
|
await click("Connect");
|
|
await click("Connection");
|
|
await click("2Configure");
|
|
expect(container.textContent).not.toContain("Finish setup");
|
|
await click("Connect model");
|
|
await click("OpenAIAPI key");
|
|
await fill("API key", "new-api-credential");
|
|
await click("Connect");
|
|
await click("Finish setup");
|
|
expect(api.hire.mock.calls[0][1].runtimeConfig.aiConnection).toEqual({ provider: "openai", method: "api_key", mode: "delegated", connectionId: "managed-connection", grantId: "managed-grant" });
|
|
});
|
|
it.each(["pi_local"])(
|
|
"persists %s OpenRouter credentials only as a secret reference",
|
|
async (adapter) => {
|
|
await render(adapter);
|
|
await fill("Model", "openrouter/anthropic/claude-sonnet-4.6");
|
|
await fill("OPENROUTER_API_KEY", "example-test-secret");
|
|
await click("Run test");
|
|
expect(secrets.rotateMyUserSecret).not.toHaveBeenCalled();
|
|
expect(secrets.createMyUserSecret).not.toHaveBeenCalled();
|
|
expect(api.testEnvironment.mock.calls[0][2].testCredentials).toEqual({ OPENROUTER_API_KEY: "example-test-secret" });
|
|
await click("Finish setup");
|
|
expect(api.hire.mock.calls[0][1].adapterConfig.env.OPENROUTER_API_KEY).toEqual({
|
|
type: "secret_ref",
|
|
secretId: "org-secret-1",
|
|
version: "latest",
|
|
});
|
|
expect(secrets.create).toHaveBeenCalledWith(
|
|
"company-1", expect.objectContaining({ value: "example-test-secret" }),
|
|
);
|
|
expect(JSON.stringify(api.hire.mock.calls)).not.toContain(
|
|
"example-test-secret",
|
|
);
|
|
expect(secrets.create).toHaveBeenCalledTimes(1);
|
|
},
|
|
);
|
|
it("connects OpenRouter before testing and hiring OpenCode without copying credentials into the agent", async () => {
|
|
await render("opencode_local");
|
|
const model = "openrouter/anthropic/claude-sonnet-4.6";
|
|
await fill("Model", model);
|
|
const connectionSelect = container.querySelector('[role="combobox"][aria-label="Connection"]')!;
|
|
await act(async () => connectionSelect.dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowDown", bubbles: true })));
|
|
await settle();
|
|
const connectOption = [...document.querySelectorAll('[role="option"]')].find(option => option.textContent?.includes("Connect an account"))!;
|
|
expect(connectOption).toBeTruthy();
|
|
await act(async () => (connectOption as HTMLElement).click());
|
|
await settle();
|
|
const dialog = document.querySelector('[role="dialog"]')!;
|
|
expect(dialog).toBeTruthy();
|
|
expect(api.hire).not.toHaveBeenCalled();
|
|
expect(api.testEnvironment).not.toHaveBeenCalled();
|
|
const advanced = [...dialog.querySelectorAll("summary")].find(node => node.textContent?.includes("Advanced providers"))!;
|
|
await act(async () => advanced.click());
|
|
const openrouter = [...dialog.querySelectorAll("button")].find(node => node.textContent?.includes("OpenRouter"))!;
|
|
await act(async () => openrouter.click());
|
|
await settle();
|
|
const input = dialog.querySelector('[aria-label="API key"]') as HTMLInputElement;
|
|
expect(input).toBeTruthy();
|
|
await act(async () => {
|
|
Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value")!.set!.call(input, "example-test-secret");
|
|
input.dispatchEvent(new Event("input", { bubbles: true }));
|
|
});
|
|
const connectButton = [...dialog.querySelectorAll("button")].find((button) => button.textContent?.trim() === "Connect")!;
|
|
expect(connectButton.disabled).toBe(false);
|
|
await act(async () => connectButton.click());
|
|
await settle();
|
|
expect(document.querySelector('[role="dialog"]')).toBeNull();
|
|
expect(managedApi.setDefault).not.toHaveBeenCalled();
|
|
expect(api.hire).not.toHaveBeenCalled();
|
|
expect(api.testEnvironment).not.toHaveBeenCalled();
|
|
expect(managedApi.create).toHaveBeenCalledWith("company-1", expect.objectContaining({
|
|
provider: "openrouter", method: "api_key", apiKey: "example-test-secret",
|
|
}));
|
|
const binding = { provider: "openrouter", method: "api_key", mode: "shared", connectionId: "managed-connection", grantId: "managed-grant" };
|
|
|
|
await click("Run test");
|
|
expect(api.testEnvironment.mock.calls[0][2]).toEqual(expect.objectContaining({
|
|
aiConnection: binding, testCredentials: {},
|
|
adapterConfig: expect.objectContaining({ model }),
|
|
}));
|
|
await click("Finish setup");
|
|
expect(api.hire.mock.calls[0][1]).toEqual(expect.objectContaining({
|
|
adapterType: "opencode_local",
|
|
runtimeConfig: expect.objectContaining({ aiConnection: binding }),
|
|
adapterConfig: expect.objectContaining({ model }),
|
|
}));
|
|
expect(managedApi.create).toHaveBeenCalledTimes(1);
|
|
expect(secrets.create).not.toHaveBeenCalled();
|
|
expect(JSON.stringify(api.testEnvironment.mock.calls)).not.toContain("example-test-secret");
|
|
expect(JSON.stringify(api.hire.mock.calls)).not.toContain("example-test-secret");
|
|
});
|
|
it.each(["codex", "claude", "opencode"])(
|
|
"uses the correct native %s runner",
|
|
async (runner) => {
|
|
await render("paperclip_runner", runner);
|
|
if (runner !== "opencode")
|
|
await connect(runner === "claude" ? "Claude" : "OpenAI");
|
|
else await fill("Model", "openrouter/anthropic/claude-sonnet-4.6");
|
|
await click("Finish setup");
|
|
const config = api.hire.mock.calls[0][1].adapterConfig;
|
|
expect(config.provider).toBe(runner === "claude" ? "acpx" : runner);
|
|
if (runner === "claude") {
|
|
expect(config.acpxAgent).toBe("claude");
|
|
expect(config.model).toMatch(/^claude-/);
|
|
}
|
|
if (runner === "codex") expect(config.acpxAgent).toBeUndefined();
|
|
},
|
|
);
|
|
it("does not create when the test fails and permits retry", async () => {
|
|
await render();
|
|
await fill("Model", "openrouter/unknown/model");
|
|
api.testEnvironment.mockResolvedValueOnce({ ...pass, status: "fail" });
|
|
await click("Run test");
|
|
await click("Finish setup");
|
|
expect(api.hire).not.toHaveBeenCalled();
|
|
expect(container.textContent).toContain("Couldn't connect");
|
|
await click("Retry test");
|
|
await click("Finish setup");
|
|
expect(api.hire).toHaveBeenCalledTimes(1);
|
|
});
|
|
it("does not rotate a working provider credential when a new key fails its test", async () => {
|
|
secrets.listMyUserSecrets.mockResolvedValue([{ definition: { id: "existing-definition", key: "OPENROUTER_API_KEY" }, secret: { id: "working-secret" } }]);
|
|
await render();
|
|
await fill("Model", "openrouter/anthropic/claude-sonnet-4.6");
|
|
await fill("OPENROUTER_API_KEY", "invalid-replacement");
|
|
api.testEnvironment.mockResolvedValueOnce({ ...pass, status: "fail" });
|
|
await click("Run test");
|
|
expect(secrets.rotateMyUserSecret).not.toHaveBeenCalled();
|
|
expect(secrets.createUserSecretDefinition).not.toHaveBeenCalled();
|
|
expect(api.testEnvironment.mock.calls[0][2].testCredentials.OPENROUTER_API_KEY).toBe("invalid-replacement");
|
|
await click("Finish setup");
|
|
expect(api.hire).not.toHaveBeenCalled();
|
|
});
|
|
it("does not store a key when leaving after a successful test", async () => {
|
|
await render();
|
|
await fill("Model", "openrouter/anthropic/claude-sonnet-4.6");
|
|
await fill("OPENROUTER_API_KEY", "abandoned-key");
|
|
await click("Run test");
|
|
await act(async () => root.render(null));
|
|
expect(secrets.createUserSecretDefinition).not.toHaveBeenCalled();
|
|
});
|
|
it("removes the staged credential when hiring fails", async () => {
|
|
await render();
|
|
await fill("Model", "openrouter/anthropic/claude-sonnet-4.6");
|
|
await fill("OPENROUTER_API_KEY", "new-key");
|
|
api.hire.mockRejectedValueOnce(new Error("Creation rejected"));
|
|
await click("Finish setup");
|
|
expect(secrets.remove).toHaveBeenCalledWith("org-secret-1");
|
|
expect(container.textContent).toContain("Creation rejected");
|
|
});
|
|
it("preserves the creation error when credential cleanup also fails", async () => {
|
|
await render();
|
|
await fill("Model", "openrouter/anthropic/claude-sonnet-4.6");
|
|
await fill("OPENROUTER_API_KEY", "new-key");
|
|
api.hire.mockRejectedValueOnce(new Error("Agent quota exceeded"));
|
|
secrets.remove.mockRejectedValueOnce(new Error("Cleanup unavailable"));
|
|
await click("Finish setup");
|
|
expect(container.textContent).toContain("Agent quota exceeded");
|
|
expect(container.textContent).toContain("Could not remove an unused setup credential");
|
|
});
|
|
it("requires an explicit provider/model for Pi", async () => {
|
|
await render();
|
|
await click("Run test");
|
|
expect(api.testEnvironment).not.toHaveBeenCalled();
|
|
expect(container.textContent).toContain("provider/model format");
|
|
});
|
|
it("blocks a disabled runner even when opened through a URL", async () => {
|
|
state.adapters = [
|
|
{ type: "paperclip_runner", loaded: true, disabled: true },
|
|
];
|
|
await render("paperclip_runner");
|
|
expect(container.textContent).toContain("This adapter is unavailable");
|
|
expect(api.testEnvironment).not.toHaveBeenCalled();
|
|
expect(api.hire).not.toHaveBeenCalled();
|
|
});
|
|
it("keeps pending agents behind approval and disables task assignment", async () => {
|
|
api.hire.mockResolvedValue({
|
|
agent: { id: "new-agent", name: "Atlas", status: "pending_approval" },
|
|
});
|
|
await render();
|
|
await fill("Model", "openrouter/anthropic/claude-sonnet-4.6");
|
|
await click("Finish setup");
|
|
expect(container.textContent).toContain("Agent submitted for approval");
|
|
await click("Assign Atlas a Task");
|
|
expect(state.openNewIssue).not.toHaveBeenCalled();
|
|
});
|
|
it("uses the same managed environment for connection testing and creation", async () => {
|
|
envApi.list.mockResolvedValue([
|
|
{ id: "sandbox-1", driver: "sandbox", config: { provider: "daytona" } },
|
|
]);
|
|
envApi.capabilities.mockResolvedValue({
|
|
sandboxProviders: { daytona: { supportsLoginPty: true } },
|
|
});
|
|
settings.get.mockResolvedValue({ defaultEnvironmentId: "sandbox-1" });
|
|
settings.getExperimental.mockResolvedValue({
|
|
enableManagedSandboxOnly: true,
|
|
});
|
|
api.getClaudeOAuthTokenStatus.mockResolvedValue({ secretId: "saved-oauth", latestVersion: 1 });
|
|
await render("claude_local");
|
|
await click("ClaudeSubscription");
|
|
await click("Use saved subscription");
|
|
await click("Finish setup");
|
|
expect(api.testEnvironment.mock.calls[0][2].environmentId).toBe(
|
|
"sandbox-1",
|
|
);
|
|
expect(api.hire.mock.calls[0][1]).toMatchObject({
|
|
defaultEnvironmentId: "sandbox-1",
|
|
applyStoredClaudeLogin: true,
|
|
});
|
|
});
|
|
});
|