Files
PaperClipAI/server/src/__tests__/agent-test-environment-routes.test.ts
T
Devin FoleyandPaperclip 12aa08721c feat(ssh): use the agent AI account in new environments (#21248)
Use the agent-selected AI account for new SSH environments. Preserve
remote-machine authentication for existing environments and expose it as
an advanced option. Keep managed credentials private while preserving
supported conversation state and credential refreshes across turns.

Validated with focused route, adapter, lifecycle, and real-process tests;
final CI passed on d634944df1.
Greptile Apex reviewed that revision at 5/5 with no unresolved threads.
External neutral security reports remain documented in the pull request.

Co-Authored-By: Paperclip <noreply@paperclip.ing>
2026-11-13 13:20:13 -08:00

1556 lines
80 KiB
TypeScript

import express from "express";
import request from "supertest";
import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
import type { AdapterEnvironmentTestContext } from "@paperclipai/adapter-utils";
import type { ServerAdapterModule } from "../adapters/index.js";
const mockAgentService = vi.hoisted(() => ({
getById: vi.fn(),
getChainOfCommand: vi.fn(async () => []),
}));
const mockAccessService = vi.hoisted(() => ({
canUser: vi.fn(),
decide: vi.fn(),
hasPermission: vi.fn(),
getMembership: vi.fn(async () => null),
listPrincipalGrants: vi.fn(async () => []),
}));
const mockSecretService = vi.hoisted(() => ({
normalizeAdapterConfigForPersistence: vi.fn(async (_companyId: string, config: Record<string, unknown>) => config),
resolveAdapterConfigForRuntime: vi.fn(async (_companyId: string, config: Record<string, unknown>) => ({ config })),
collectMissingRuntimeBindings: vi.fn(async () => [] as Array<Record<string, unknown>>),
resolveEnvBindings: vi.fn(async () => ({
env: {} as Record<string, string>,
secretKeys: new Set<string>(),
manifest: [],
})),
}));
const mockEnvironmentService = vi.hoisted(() => ({
getById: vi.fn(),
releaseLease: vi.fn(),
listBoundCompanyIds: vi.fn(async () => [] as string[]),
findManagedSandboxEnvironment: vi.fn(async () => null as Record<string, unknown> | null),
findKubernetesEnvironment: vi.fn(async () => null as Record<string, unknown> | null),
}));
const mockReleaseRunLease = vi.hoisted(() => vi.fn(async () => undefined));
const mockEnvironmentRuntime = vi.hoisted(() => ({
acquireRunLease: vi.fn(),
realizeWorkspace: vi.fn(),
supportsTasks: vi.fn(async () => false),
getDriver: vi.fn(() => ({
releaseRunLease: mockReleaseRunLease,
})),
}));
const mockResolveEnvironmentExecutionTarget = vi.hoisted(() => vi.fn());
const mockPluginEnvironmentRequiresAgent = vi.hoisted(() => vi.fn(async () => false));
const mockPluginRunnerTaskDriver = vi.hoisted(() => vi.fn(async (): Promise<{ driverKey: string } | undefined> => undefined));
vi.mock("../services/plugin-runner-ai-connection.js", async importOriginal => ({
...await importOriginal<typeof import("../services/plugin-runner-ai-connection.js")>(),
pluginEnvironmentRunnerTaskDriver: mockPluginRunnerTaskDriver,
}));
vi.mock("../services/plugin-environment-driver.js", async importOriginal => ({
...(await importOriginal<typeof import("../services/plugin-environment-driver.js")>()),
pluginEnvironmentRequiresAgent: mockPluginEnvironmentRequiresAgent,
}));
const mockInstanceSettingsService = vi.hoisted(() => ({
get: vi.fn(async () => ({ defaultEnvironmentId: null as string | null })),
getGeneral: vi.fn(async () => ({ censorUsernameInLogs: false, executionMode: "local" })),
getExperimental: vi.fn(async (): Promise<{
enableManagedSandboxOnly: boolean;
enableOpenAiDot?: boolean;
}> => ({ enableManagedSandboxOnly: false })),
}));
vi.mock("../services/index.js", () => ({
agentService: () => mockAgentService,
agentInstructionsService: () => ({}),
accessService: () => mockAccessService,
approvalService: () => ({}),
builtInAgentService: () => ({ ensureCompanyDefaultAgentGrants: vi.fn() }),
companySkillService: () => ({
listRuntimeSkillEntries: vi.fn(async () => []),
resolveRequestedSkillKeys: vi.fn(async () => []),
}),
budgetService: () => ({}),
heartbeatService: () => ({
wakeup: vi.fn(),
cancelActiveForAgent: vi.fn(),
}),
ISSUE_LIST_DEFAULT_LIMIT: 50,
issueApprovalService: () => ({}),
issueService: () => ({}),
logActivity: vi.fn(),
syncInstructionsBundleConfigFromFilePath: vi.fn((_agent, config) => config),
workspaceOperationService: () => ({}),
}));
vi.mock("../services/environments.js", () => ({
environmentService: () => mockEnvironmentService,
}));
vi.mock("../services/secrets.js", () => ({
secretService: () => mockSecretService,
}));
vi.mock("../services/environment-runtime.js", () => ({
environmentRuntimeService: () => mockEnvironmentRuntime,
}));
vi.mock("../services/environment-execution-target.js", () => ({
resolveEnvironmentExecutionTarget: mockResolveEnvironmentExecutionTarget,
}));
vi.mock("../services/instance-settings.js", () => ({
instanceSettingsService: () => mockInstanceSettingsService,
}));
vi.mock("../services/adapter-settings.js", async (importOriginal) => ({
...(await importOriginal<typeof import("../services/adapter-settings.js")>()),
adapterSettingsService: () => ({ getDisabledTypes: async () => [] }),
}));
vi.mock("../services/dot-runner-broker.js", () => ({
dotRunnerBroker: () => ({ enabled: async () => true, bindingForAgent: async () => null }),
}));
const testEnvironmentSpy = vi.fn();
const externalAdapter: ServerAdapterModule = {
type: "external_test",
execute: async () => ({ exitCode: 0, signal: null, timedOut: false }),
testEnvironment: testEnvironmentSpy,
};
// Only the runtime preparation is replaced: it needs a database and a stored
// grant, and these tests exercise the route's verdict, not credential
// resolution. Everything else in the module stays real. The same goes for
// validateAiApiKey — it calls the provider's real endpoint, and these tests
// direct its verdict instead of the network.
const mockPrepareManagedAiRuntime = vi.hoisted(() => vi.fn());
vi.mock("../services/ai-connection-runtime.js", async (importOriginal) => ({
...(await importOriginal<typeof import("../services/ai-connection-runtime.js")>()),
prepareManagedAiRuntime: mockPrepareManagedAiRuntime,
withManagedAiProbe: async (_db: unknown, input: unknown, probe: (runtime: unknown) => Promise<unknown>) => {
const runtime = await mockPrepareManagedAiRuntime(_db, input);
try { return await probe(runtime); } finally { await runtime.cleanup(); }
},
}));
// Runner selection stays real unless a test overrides the resolved adapter.
const mockResolveNewAgentRunnerForCompany = vi.hoisted(() => vi.fn());
vi.mock("../services/agent-runner-selection.js", async (importOriginal) => {
const actual = await importOriginal<typeof import("../services/agent-runner-selection.js")>();
mockResolveNewAgentRunnerForCompany.mockImplementation(actual.resolveNewAgentRunnerForCompany);
return { ...actual, resolveNewAgentRunnerForCompany: mockResolveNewAgentRunnerForCompany };
});
const mockValidateAiApiKey = vi.hoisted(() => vi.fn(async () => undefined));
vi.mock("../services/ai-api-key-test.js", () => ({ validateAiApiKey: mockValidateAiApiKey }));
const mockMarkAuthenticationFailed = vi.hoisted(() => vi.fn(async () => undefined));
const mockSelectAiConnection = vi.hoisted(() => vi.fn(async (_input: unknown) => ({ connectionId: "copilot-connection", grantId: "copilot-grant" })));
const mockAiCredential = vi.hoisted(() => vi.fn(async (_selection: unknown) => "synthetic-copilot-token"));
const mockCopilotModels = vi.hoisted(() => vi.fn(async () => ({ models: [{ id: "gpt-5.6-luna", label: "GPT-5.6 Luna" }], promptSent: false })));
const mockCopilotProbe = vi.hoisted(() => vi.fn(async () => ({ status: "verified", promptSent: false })));
vi.mock("../services/copilot-connection-probe.js", async importOriginal => ({
...(await importOriginal<object>()), probeCopilotExecutionTarget: mockCopilotProbe, probeCopilotConnection: mockCopilotModels,
}));
vi.mock("../services/ai-connections.js", async (importOriginal) => ({
...(await importOriginal<typeof import("../services/ai-connections.js")>()),
aiConnectionService: () => ({ markAuthenticationFailed: mockMarkAuthenticationFailed, select: mockSelectAiConnection, credential: mockAiCredential }),
}));
function mockManagedRuntime(method: "api_key" | "subscription") {
mockPrepareManagedAiRuntime.mockImplementation(
async (_db: unknown, input: { config: Record<string, unknown> }) => ({
config: {
...input.config,
// The real preparation injects the credential under the provider's
// env key; the adoption re-verification reads it from there.
env: { ...(method === "api_key" ? { ANTHROPIC_API_KEY: "sk-ant-test-key" } : {}) },
managedAiConnection: {
connectionId: "conn-1",
grantId: "grant-1",
provider: "anthropic",
method,
mode: "responsible_user",
responsibleUserId: "local-board",
identity: "grant-1:local-board:0000000000000000",
},
},
attribution: {
connectionId: "conn-1",
grantId: "grant-1",
provider: "anthropic",
method,
mode: "responsible_user",
responsibleUserId: "local-board",
},
accountName: "My Claude Account",
accountOwnerUserId: "local-board",
identity: "grant-1:local-board:0000000000000000",
cleanup: vi.fn(async () => {}),
}),
);
}
function loadAppModules() {
return Promise.all([
vi.importActual<typeof import("../routes/agents.js")>("../routes/agents.js"),
vi.importActual<typeof import("../middleware/index.js")>("../middleware/index.js"),
]);
}
async function createApp(actor: Record<string, unknown> = {}) {
const [{ agentRoutes }, { errorHandler }] = await loadAppModules();
const app = express();
app.use(express.json());
app.use((req, _res, next) => {
(req as any).actor = {
type: "board",
userId: "local-board",
companyIds: ["company-1"],
source: "local_implicit",
isInstanceAdmin: false,
...actor,
};
next();
});
app.use("/api", agentRoutes({} as any));
app.use(errorHandler);
return app;
}
async function unregisterTestAdapter(type: string) {
const { unregisterServerAdapter } = await import("../adapters/index.js");
unregisterServerAdapter(type);
}
describe("agent test-environment route", () => {
beforeAll(async () => {
vi.resetModules();
await loadAppModules();
});
beforeEach(async () => {
vi.clearAllMocks();
mockInstanceSettingsService.get.mockResolvedValue({ defaultEnvironmentId: null });
mockInstanceSettingsService.getGeneral.mockResolvedValue({ censorUsernameInLogs: false, executionMode: "local" });
mockEnvironmentService.findKubernetesEnvironment.mockResolvedValue(null);
mockInstanceSettingsService.getExperimental.mockResolvedValue({ enableManagedSandboxOnly: false });
mockEnvironmentService.findManagedSandboxEnvironment.mockResolvedValue(null);
mockAccessService.decide.mockResolvedValue({
allowed: true,
reason: "allow_explicit_grant",
explanation: "Allowed by test grant",
});
mockEnvironmentService.getById.mockResolvedValue({
id: "11111111-1111-4111-8111-111111111111",
companyId: "company-1",
name: "Sandbox QA",
driver: "sandbox",
config: { provider: "fake-plugin" },
});
// Default to an instance-global environment with no company binding, so the
// tenant-binding guard passes unless a test overrides it.
mockEnvironmentService.listBoundCompanyIds.mockResolvedValue([]);
mockEnvironmentRuntime.acquireRunLease.mockResolvedValue({
lease: {
id: "lease-1",
provider: "daytona",
providerLeaseId: "provider-lease-1",
metadata: {
remoteCwd: "/home/user/paperclip-workspace",
sandboxId: "sandbox-1",
sandboxName: "paperclip-probe",
templateKind: "snapshot",
templateRef: "snapshot-1",
},
},
leaseContext: {
executionWorkspaceId: null,
executionWorkspaceMode: null,
},
});
mockEnvironmentRuntime.realizeWorkspace.mockResolvedValue({
cwd: "/home/user/paperclip-workspace",
});
mockResolveEnvironmentExecutionTarget.mockResolvedValue(null);
testEnvironmentSpy.mockResolvedValue({
adapterType: "external_test",
status: "pass",
checks: [
{
code: "host_probe_ran",
level: "info",
message: "host probe should not run",
},
],
testedAt: new Date(0).toISOString(),
});
await unregisterTestAdapter("external_test");
const { registerServerAdapter } = await import("../adapters/index.js");
registerServerAdapter(externalAdapter);
});
afterEach(async () => {
await unregisterTestAdapter("external_test");
});
it("tests the saved Cursor API controller without allocating a Computer under managed-only policy", async () => {
const { registerServerAdapter, unregisterServerAdapter, getServerAdapter } = await import("../adapters/index.js");
const previous = getServerAdapter("paperclip_runner");
const probe = vi.fn(async () => ({ adapterType: "paperclip_runner", status: "warn" as const, testedAt: new Date().toISOString(),
checks: [{ code: "cursor_cloud_account_ready", level: "info" as const, message: "Synthetic account probe; no prompt." }] }));
registerServerAdapter({ ...externalAdapter, type: "paperclip_runner", testEnvironment: probe });
try {
const id = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
const adapterConfig = { provider: "cursor_cloud", model: "caller-model", repoUrl: "https://github.com/example/qualification", env: { CURSOR_API_KEY: "synthetic" } };
mockAgentService.getById.mockResolvedValue({ id, companyId: "company-1", adapterType: "paperclip_runner", adapterConfig, defaultEnvironmentId: "11111111-1111-4111-8111-111111111111" });
mockInstanceSettingsService.getExperimental.mockResolvedValue({ enableManagedSandboxOnly: true });
mockInstanceSettingsService.get.mockResolvedValue({ defaultEnvironmentId: "11111111-1111-4111-8111-111111111111" });
const app = await createApp();
const response = await request(app).post("/api/companies/company-1/adapters/paperclip_runner/test-environment").send({ agentId: id, adapterConfig });
expect(response.status, JSON.stringify(response.body)).toBe(200);
expect(response.body).toMatchObject({ status: "warn", checks: [{ code: "cursor_cloud_account_ready" }] });
expect(probe).toHaveBeenCalledWith(expect.objectContaining({ executionTarget: null, environmentName: null, config: adapterConfig }));
expect(mockEnvironmentRuntime.acquireRunLease).not.toHaveBeenCalled();
expect(mockEnvironmentRuntime.realizeWorkspace).not.toHaveBeenCalled();
expect(mockEnvironmentService.findManagedSandboxEnvironment).not.toHaveBeenCalled();
mockInstanceSettingsService.getGeneral.mockResolvedValue({ censorUsernameInLogs: false, executionMode: "kubernetes" });
const denied = await request(app).post("/api/companies/company-1/adapters/paperclip_runner/test-environment").send({ agentId: id, adapterConfig });
expect(denied.status).toBe(422);
expect(denied.body.details?.code ?? denied.body.code).toBe("provider_api_kubernetes_execution_unsupported");
expect(probe).toHaveBeenCalledOnce();
} finally { unregisterServerAdapter("paperclip_runner"); if (previous) registerServerAdapter(previous); }
});
async function mockCursorSwitchProbes() {
const { getServerAdapter } = await import("../adapters/index.js");
const legacy = vi.spyOn(getServerAdapter("cursor_cloud"), "testEnvironment").mockImplementation(async () => ({
adapterType: "cursor_cloud", status: "pass", checks: [], testedAt: new Date().toISOString(),
}));
const native = vi.spyOn(getServerAdapter("paperclip_runner"), "testEnvironment").mockImplementation(async () => ({
adapterType: "paperclip_runner", status: "warn", testedAt: new Date().toISOString(),
checks: [{ code: "cursor_cloud_account_ready", level: "info", message: "Synthetic no-prompt probe" }],
}));
return { legacy, native, restore: () => { legacy.mockRestore(); native.mockRestore(); } };
}
function savedCursorSwitchFixture() {
const id = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
const environmentId = "22222222-2222-4222-8222-222222222222";
const adapterConfig = { provider: "cursor_cloud", model: "caller-model", repoUrl: "https://github.com/example/qualification", env: {} };
mockAgentService.getById.mockResolvedValue({ id, companyId: "company-1", adapterType: "paperclip_runner",
adapterConfig, runtimeConfig: {}, defaultEnvironmentId: "11111111-1111-4111-8111-111111111111" });
const envVars = { CURSOR_API_KEY: { type: "secret_ref", secretId: "computer-key" } };
mockEnvironmentService.getById.mockResolvedValue({ id: environmentId, name: "Chosen Computer",
driver: "local", config: {}, envVars });
mockSecretService.resolveEnvBindings.mockResolvedValue({ env: { CURSOR_API_KEY: "chosen-computer-key" },
secretKeys: new Set(["CURSOR_API_KEY"]), manifest: [] });
return { id, environmentId, adapterConfig, envVars };
}
it.each([false, true])("tests a saved native Cursor's explicit Legacy switch on the selected Computer (legacyPrompt=%s)", async legacyPrompt => {
const probes = await mockCursorSwitchProbes();
const probe = probes.legacy;
try {
const f = savedCursorSwitchFixture();
const config = { ...f.adapterConfig, ...(legacyPrompt ? { promptTemplate: "Legacy prompt" } : {}) };
const response = await request(await createApp()).post("/api/companies/company-1/adapters/paperclip_runner/test-environment")
.send({ agentId: f.id, runner: "legacy", environmentId: f.environmentId, adapterConfig: config });
expect(response.status, JSON.stringify(response.body)).toBe(200);
expect(probe).toHaveBeenCalledWith(expect.objectContaining({ environmentName: "Chosen Computer", executionTarget: null,
config: expect.objectContaining({ model: "caller-model", env: { CURSOR_API_KEY: "chosen-computer-key" },
...(legacyPrompt ? { promptTemplate: "Legacy prompt" } : {}) }) }));
expect(probe.mock.calls[0][0].config).not.toHaveProperty("provider");
expect(mockSecretService.resolveEnvBindings).toHaveBeenCalledWith("company-1", f.envVars,
expect.objectContaining({ consumerType: "environment", consumerId: f.environmentId }));
expect(mockEnvironmentRuntime.acquireRunLease).not.toHaveBeenCalled();
expect(probes.native).not.toHaveBeenCalled();
} finally { probes.restore(); }
});
it("fails closed on a foreign Computer before credentials for an explicit Legacy switch", async () => {
const probes = await mockCursorSwitchProbes();
try {
const f = savedCursorSwitchFixture();
mockEnvironmentService.listBoundCompanyIds.mockResolvedValue(["company-2"]);
const response = await request(await createApp()).post("/api/companies/company-1/adapters/paperclip_runner/test-environment")
.send({ agentId: f.id, runner: "legacy", environmentId: f.environmentId,
adapterConfig: { ...f.adapterConfig, promptTemplate: "Legacy prompt" } });
expect(response.status).toBe(403);
expect(mockSecretService.resolveAdapterConfigForRuntime).not.toHaveBeenCalled();
expect(mockSecretService.resolveEnvBindings).not.toHaveBeenCalled();
expect(mockEnvironmentRuntime.acquireRunLease).not.toHaveBeenCalled();
expect(probes.legacy).not.toHaveBeenCalled();
expect(probes.native).not.toHaveBeenCalled();
} finally { probes.restore(); }
});
it("keeps managed-only policy for a Legacy switch rather than testing its API controller", async () => {
const probes = await mockCursorSwitchProbes();
const probe = probes.legacy;
try {
const f = savedCursorSwitchFixture();
mockInstanceSettingsService.getExperimental.mockResolvedValue({ enableManagedSandboxOnly: true });
const response = await request(await createApp()).post("/api/companies/company-1/adapters/paperclip_runner/test-environment")
.send({ agentId: f.id, runner: "legacy", environmentId: f.environmentId, adapterConfig: f.adapterConfig });
expect(response.status, JSON.stringify(response.body)).toBe(200);
expect(response.body).toMatchObject({ status: "fail", checks: expect.arrayContaining([
expect.objectContaining({ code: "managed_sandbox_unavailable", level: "error" }),
]) });
expect(probe).not.toHaveBeenCalled();
expect(mockEnvironmentRuntime.acquireRunLease).not.toHaveBeenCalled();
expect(probes.native).not.toHaveBeenCalled();
} finally { probes.restore(); }
});
it("keeps an explicit Paperclip Cursor test API-only despite a selected Computer", async () => {
const probes = await mockCursorSwitchProbes();
const probe = probes.native;
try {
const f = savedCursorSwitchFixture();
const settings = { defaultEnvironmentId: null, experimental: { enableManagedSandboxOnly: true, enableNativeRunner: true } };
mockInstanceSettingsService.get.mockResolvedValue(settings);
mockInstanceSettingsService.getExperimental.mockResolvedValue(settings.experimental);
const response = await request(await createApp()).post("/api/companies/company-1/adapters/paperclip_runner/test-environment")
.send({ agentId: f.id, runner: "paperclip", environmentId: f.environmentId, adapterConfig: f.adapterConfig });
expect(response.status, JSON.stringify(response.body)).toBe(200);
expect(probe).toHaveBeenCalledWith(expect.objectContaining({ executionTarget: null, environmentName: null,
config: expect.objectContaining({ provider: "cursor_cloud" }) }));
expect(mockEnvironmentService.getById).not.toHaveBeenCalled();
expect(mockSecretService.resolveEnvBindings).not.toHaveBeenCalled();
expect(mockEnvironmentRuntime.acquireRunLease).not.toHaveBeenCalled();
expect(probes.legacy).not.toHaveBeenCalled();
} finally { probes.restore(); }
});
it.each([
{ patch: { model: "" }, code: "paperclip_runner_cursor_cloud_model_required" },
{ patch: { command: "untrusted" }, code: "paperclip_runner_cursor_cloud_config_invalid" },
])("returns a useful validation error before Computer or credential work for invalid native Cursor input ($code)", async ({ patch, code }) => {
const app = await createApp();
const response = await request(app).post("/api/companies/company-1/adapters/paperclip_runner/test-environment").send({
adapterConfig: { provider: "cursor_cloud", model: "caller-model", repoUrl: "https://github.com/example/qualification", ...patch },
});
expect(response.status, JSON.stringify(response.body)).toBe(422);
expect(response.body.details?.code).toBe(code);
expect(mockEnvironmentRuntime.acquireRunLease).not.toHaveBeenCalled();
expect(mockEnvironmentRuntime.realizeWorkspace).not.toHaveBeenCalled();
expect(mockEnvironmentService.findManagedSandboxEnvironment).not.toHaveBeenCalled();
});
it.each([undefined, "auto"] as const)("tests the prospective managed Cursor API default without converting saved Legacy agents (%s)", async runner => {
const { getServerAdapter } = await import("../adapters/index.js");
const native = getServerAdapter("paperclip_runner");
const probe = vi.spyOn(native, "testEnvironment").mockImplementation(async () => ({ adapterType: "paperclip_runner", status: "warn" as const, testedAt: new Date().toISOString(),
checks: [{ code: "cursor_cloud_account_ready", level: "info" as const, message: "Synthetic account probe; no prompt." }] }));
try {
const settings = { defaultEnvironmentId: null, experimental: { enableManagedSandboxOnly: true, enableNativeRunner: true } };
mockInstanceSettingsService.get.mockResolvedValue(settings);
mockInstanceSettingsService.getExperimental.mockResolvedValue(settings.experimental);
const adapterConfig = { model: "caller-model", repoUrl: "https://github.com/example/qualification", env: { CURSOR_API_KEY: "synthetic" } };
const app = await createApp();
const response = await request(app).post("/api/companies/company-1/adapters/cursor_cloud/test-environment").send({ runner, adapterConfig });
expect(response.status, JSON.stringify(response.body)).toBe(200);
expect(response.body).toMatchObject({ adapterType: "paperclip_runner", checks: [{ code: "cursor_cloud_account_ready" }] });
expect(probe).toHaveBeenCalledWith(expect.objectContaining({ executionTarget: null, environmentName: null,
config: expect.objectContaining({ provider: "cursor_cloud", model: "caller-model" }) }));
expect(mockEnvironmentService.findManagedSandboxEnvironment).not.toHaveBeenCalled();
expect(mockEnvironmentRuntime.acquireRunLease).not.toHaveBeenCalled();
const id = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
mockAgentService.getById.mockResolvedValue({ id, companyId: "company-1", adapterType: "cursor_cloud", adapterConfig, defaultEnvironmentId: null });
const legacy = await request(app).post("/api/companies/company-1/adapters/cursor_cloud/test-environment").send({ agentId: id, adapterConfig });
expect(legacy.status).toBe(422);
expect(legacy.body.details?.code).toBe("managed_sandbox_unavailable");
expect(probe).toHaveBeenCalledOnce();
} finally { probe.mockRestore(); }
});
it("accepts a managed Dot environment without allocating an idle sandbox", async () => {
vi.stubEnv("PAPERCLIP_PUBLIC_URL", "https://paperclip.example");
mockInstanceSettingsService.getExperimental.mockResolvedValue({
enableManagedSandboxOnly: false,
enableOpenAiDot: true,
});
mockInstanceSettingsService.get.mockResolvedValue({ defaultEnvironmentId: "11111111-1111-4111-8111-111111111111" });
const app = await createApp();
try {
const res = await request(app).post("/api/companies/company-1/adapters/paperclip_runner/test-environment")
.send({ adapterConfig: { provider: "openai_dot", allowUnmeteredProvider: true } });
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(res.body.checks).toContainEqual(expect.objectContaining({ code: "dot_controller", level: "info" }));
expect(mockEnvironmentRuntime.acquireRunLease).not.toHaveBeenCalled();
expect(testEnvironmentSpy).not.toHaveBeenCalled();
} finally { vi.unstubAllEnvs(); }
});
it("fails the Cloud Dot check without a managed sandbox instead of probing the host", async () => {
vi.stubEnv("PAPERCLIP_PUBLIC_URL", "https://paperclip.example");
vi.stubEnv("PAPERCLIP_CLOUD_TENANT_SERVER_TOKEN", "test-cloud");
mockInstanceSettingsService.getExperimental.mockResolvedValue({
enableManagedSandboxOnly: false,
enableOpenAiDot: true,
});
const app = await createApp();
try {
const res = await request(app).post("/api/companies/company-1/adapters/paperclip_runner/test-environment")
.send({ adapterConfig: { provider: "openai_dot", allowUnmeteredProvider: true } });
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(res.body.status).toBe("fail");
expect(res.body.checks).toContainEqual(expect.objectContaining({ code: "dot_controller", level: "error" }));
expect(mockEnvironmentRuntime.acquireRunLease).not.toHaveBeenCalled();
expect(testEnvironmentSpy).not.toHaveBeenCalled();
} finally { vi.unstubAllEnvs(); }
});
it("lets an authorized agent editor discover Copilot models", async () => {
mockAgentService.getById.mockResolvedValue({ id: "agent-1", companyId: "company-1" });
const response = await request(await createApp()).get("/api/companies/company-1/adapters/paperclip_runner/models")
.query({ provider: "acpx", acpxAgent: "copilot", agentId: "agent-1" });
expect(response.status).toBe(200);
expect(response.body).toEqual([{ id: "gpt-5.6-luna", label: "GPT-5.6 Luna" }]);
expect(response.headers["cache-control"]).toBe("no-store");
expect(mockAccessService.decide).toHaveBeenCalledWith(expect.objectContaining({ action: "agent_config:update" }));
expect(mockSelectAiConnection).toHaveBeenCalledExactlyOnceWith(expect.objectContaining({
companyId: "company-1", userId: "local-board", agentId: "agent-1", runnerProvider: "acpx", acpxAgent: "copilot",
binding: { provider: "github", method: "api_key", mode: "responsible_user" }, allowUninstalledShared: false,
}));
expect(mockCopilotModels).toHaveBeenCalledExactlyOnceWith(expect.anything(), "company-1", "synthetic-copilot-token", null, undefined, expect.anything());
});
it.each([
["board viewer", { type: "board" }],
["agent reader", { type: "agent", agentId: "reader-agent", companyId: "company-1", onBehalfOfUserId: "reader-user",
onBehalfOfMemberships: [{ companyId: "company-1", status: "active", membershipRole: "member" }] }],
])("refuses a %s discovery probe before resolving a shared token", async (_label, actor) => {
mockAccessService.decide.mockImplementation(async ({ action }) => ({
allowed: action === "agent_config:read", explanation: "No configuration update grant",
}));
mockAccessService.canUser.mockResolvedValue(false);
mockAgentService.getById.mockResolvedValue({ id: "agent-1", companyId: "company-1" });
const binding = { provider: "github", method: "api_key", mode: "shared",
connectionId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", grantId: "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb" };
const response = await request(await createApp(actor)).get("/api/companies/company-1/adapters/paperclip_runner/models")
.query({ provider: "acpx", acpxAgent: "copilot", agentId: "agent-1",
environmentId: "33333333-3333-4333-8333-333333333333", aiConnection: JSON.stringify(binding) });
expect(response.status).toBe(403);
expect(mockAccessService.decide).toHaveBeenCalledWith(expect.objectContaining({ action: "agent_config:update" }));
expect(mockSelectAiConnection).not.toHaveBeenCalled();
expect(mockAiCredential).not.toHaveBeenCalled();
expect(mockCopilotModels).not.toHaveBeenCalled();
});
it.each([undefined, "33333333-3333-4333-8333-333333333333"])("uses the saved or editor-selected Copilot environment (%s)", async environmentId => {
const savedEnvironmentId = "22222222-2222-4222-8222-222222222222";
mockAgentService.getById.mockResolvedValue({ id: "agent-1", companyId: "company-1", defaultEnvironmentId: savedEnvironmentId });
const response = await request(await createApp()).get("/api/companies/company-1/adapters/paperclip_runner/models")
.query({ provider: "acpx", acpxAgent: "copilot", agentId: "agent-1", ...(environmentId ? { environmentId } : {}) });
expect(response.status).toBe(200);
expect(mockCopilotModels).toHaveBeenCalledExactlyOnceWith(expect.anything(), "company-1", "synthetic-copilot-token",
environmentId ?? savedEnvironmentId, undefined, expect.objectContaining({ targetAgentId: "agent-1" }));
});
it("refuses model discovery for a foreign agent before selecting credentials", async () => {
mockAgentService.getById.mockResolvedValue({ id: "agent-foreign", companyId: "company-2" });
const response = await request(await createApp()).get("/api/companies/company-1/adapters/paperclip_runner/models")
.query({ provider: "acpx", acpxAgent: "copilot", agentId: "agent-foreign" });
expect(response.status).toBe(404);
expect(mockSelectAiConnection).not.toHaveBeenCalled();
expect(mockAiCredential).not.toHaveBeenCalled();
expect(mockCopilotModels).not.toHaveBeenCalled();
});
it("keeps saved connection access enforced before Copilot model probing", async () => {
const { forbidden } = await import("../errors.js");
mockAgentService.getById.mockResolvedValue({ id: "agent-1", companyId: "company-1" });
mockSelectAiConnection.mockRejectedValueOnce(forbidden("Saved connection access denied"));
const response = await request(await createApp()).get("/api/companies/company-1/adapters/paperclip_runner/models")
.query({ provider: "acpx", acpxAgent: "copilot", agentId: "agent-1" });
expect(response.status).toBe(403);
expect(mockAiCredential).not.toHaveBeenCalled();
expect(mockCopilotModels).not.toHaveBeenCalled();
});
it.each([undefined, true, false])("uses the selected SSH authentication source for probes (%s)", async useHostAuth => {
const environmentId = "11111111-1111-4111-8111-111111111111";
mockEnvironmentService.getById.mockResolvedValue({ id: environmentId, name: "SSH", driver: "ssh",
config: { ...(useHostAuth !== undefined ? { useHostAuth } : {}), host: "fixture.invalid", username: "fixture", remoteWorkspacePath: "/workspace" } });
const target = { kind: "remote", transport: "ssh", remoteCwd: "/workspace", spec: { host: "fixture.invalid", port: 22, username: "fixture", remoteCwd: "/workspace", remoteWorkspacePath: "/workspace", useHostAuth } };
mockResolveEnvironmentExecutionTarget.mockResolvedValue(target);
const response = await request(await createApp()).post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ adapterConfig: {}, environmentId });
if (useHostAuth === false) {
expect(response.status, JSON.stringify(response.body)).toBe(422);
expect(response.body.code).toBe("ssh_ai_connection_required");
expect(testEnvironmentSpy).not.toHaveBeenCalled();
} else {
expect(response.status, JSON.stringify(response.body)).toBe(200);
expect(testEnvironmentSpy).toHaveBeenCalledWith(expect.objectContaining({ executionTarget: target }));
}
});
it("tests the instance default sandbox when the agent inherits its environment", async () => {
const environmentId = "11111111-1111-4111-8111-111111111111";
mockInstanceSettingsService.get.mockResolvedValue({ defaultEnvironmentId: environmentId });
const target = {
kind: "remote", transport: "sandbox", remoteCwd: "/workspace",
providerKey: "daytona", runner: { execute: vi.fn() },
};
mockResolveEnvironmentExecutionTarget.mockResolvedValue(target);
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ adapterConfig: {}, environmentId: null });
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(mockEnvironmentRuntime.acquireRunLease).toHaveBeenCalled();
expect(testEnvironmentSpy).toHaveBeenCalledWith(expect.objectContaining({ executionTarget: target }));
expect(mockReleaseRunLease).toHaveBeenCalled();
});
it.each([
{ selection: "omitted", environmentId: undefined, expectedId: "22222222-2222-4222-8222-222222222222" },
{ selection: "cleared", environmentId: null, expectedId: "11111111-1111-4111-8111-111111111111" },
{ selection: "replaced", environmentId: "33333333-3333-4333-8333-333333333333", expectedId: "33333333-3333-4333-8333-333333333333" },
])("resolves the saved agent environment when the request selection is $selection", async ({ environmentId, expectedId }) => {
const agentId = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
mockAgentService.getById.mockResolvedValue({
id: agentId, companyId: "company-1", adapterType: "external_test",
adapterConfig: {}, runtimeConfig: {}, defaultEnvironmentId: "22222222-2222-4222-8222-222222222222",
});
mockInstanceSettingsService.get.mockResolvedValue({ defaultEnvironmentId: "11111111-1111-4111-8111-111111111111" });
mockEnvironmentService.getById.mockImplementation(async (id) => ({
id, name: "Selected sandbox", driver: "sandbox", status: "active", config: { provider: "fake-plugin" },
}));
const target = { kind: "remote", transport: "sandbox", remoteCwd: "/workspace", providerKey: "daytona", runner: { execute: vi.fn() } };
mockResolveEnvironmentExecutionTarget.mockResolvedValue(target);
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ agentId, adapterConfig: {}, ...(environmentId === undefined ? {} : { environmentId }) });
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(mockEnvironmentRuntime.acquireRunLease).toHaveBeenCalledWith(expect.objectContaining({
agentId, environment: expect.objectContaining({ id: expectedId }),
}));
expect(mockSecretService.resolveAdapterConfigForRuntime).toHaveBeenCalledWith(
"company-1", {}, expect.objectContaining({ consumerType: "environment", consumerId: expectedId }),
expect.any(Object),
);
expect(testEnvironmentSpy).toHaveBeenCalledWith(expect.objectContaining({ executionTarget: target }));
});
it("keeps an explicit local override ahead of the instance sandbox default", async () => {
mockInstanceSettingsService.get.mockResolvedValue({ defaultEnvironmentId: "11111111-1111-4111-8111-111111111111" });
mockEnvironmentService.getById.mockResolvedValue({ id: "33333333-3333-4333-8333-333333333333", name: "Local", driver: "local", status: "active", config: {} });
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ environmentId: "33333333-3333-4333-8333-333333333333" });
expect(res.status).toBe(200);
expect(mockInstanceSettingsService.get).not.toHaveBeenCalled();
expect(mockEnvironmentRuntime.acquireRunLease).not.toHaveBeenCalled();
expect(testEnvironmentSpy).toHaveBeenCalledWith(expect.objectContaining({ executionTarget: null }));
});
it("uses the managed sandbox when managed-only execution has no configured default", async () => {
mockInstanceSettingsService.getExperimental.mockResolvedValue({ enableManagedSandboxOnly: true });
mockEnvironmentService.findManagedSandboxEnvironment.mockResolvedValue({ id: "11111111-1111-4111-8111-111111111111" });
const target = { kind: "remote", transport: "sandbox", remoteCwd: "/workspace", providerKey: "daytona", runner: { execute: vi.fn() } };
mockResolveEnvironmentExecutionTarget.mockResolvedValue(target);
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ environmentId: null });
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(testEnvironmentSpy).toHaveBeenCalledWith(expect.objectContaining({ executionTarget: target }));
});
it.each([null, "33333333-3333-4333-8333-333333333333"])("verifies Copilot on forced Kubernetes before the host selection (%s)", async environmentId => {
const kubernetesId = "11111111-1111-4111-8111-111111111111";
mockInstanceSettingsService.getGeneral.mockResolvedValue({ censorUsernameInLogs: false, executionMode: "kubernetes" });
mockEnvironmentService.findKubernetesEnvironment.mockResolvedValue({ id: kubernetesId });
const target = { kind: "remote", transport: "sandbox", remoteCwd: "/workspace", providerKey: "kubernetes", runner: { execute: vi.fn() } };
mockResolveEnvironmentExecutionTarget.mockResolvedValue(target);
mockPrepareManagedAiRuntime.mockImplementation(async (_db, input) => ({
config: { ...input.config, env: { COPILOT_GITHUB_TOKEN: "private-fixture" } },
attribution: { provider: "github", method: "api_key" }, cleanup: vi.fn(),
}));
const app = await createApp();
const response = await request(app).post("/api/companies/company-1/adapters/paperclip_runner/test-environment").send({
environmentId, adapterConfig: { provider: "acpx", acpxAgent: "copilot", model: "gpt-5.6-luna" },
aiConnection: { provider: "github", method: "api_key", mode: "responsible_user" },
});
expect(response.status, JSON.stringify(response.body)).toBe(200);
expect(response.body.status).toBe("pass");
expect(mockEnvironmentRuntime.acquireRunLease).toHaveBeenCalledWith(expect.objectContaining({ environment: expect.objectContaining({ id: kubernetesId }) }));
expect(mockCopilotProbe).toHaveBeenCalledExactlyOnceWith("private-fixture", target, "gpt-5.6-luna");
expect(mockReleaseRunLease).toHaveBeenCalledOnce();
});
it("refuses a Copilot test before credentials when forced Kubernetes is unavailable", async () => {
mockInstanceSettingsService.getGeneral.mockResolvedValue({ censorUsernameInLogs: false, executionMode: "kubernetes" });
const app = await createApp();
const response = await request(app).post("/api/companies/company-1/adapters/paperclip_runner/test-environment").send({
adapterConfig: { provider: "acpx", acpxAgent: "copilot", model: "gpt-5.6-luna" },
aiConnection: { provider: "github", method: "api_key", mode: "responsible_user" },
});
expect(response.status).toBe(422);
expect(response.body.details.code).toBe("copilot_environment_unavailable");
expect(mockPrepareManagedAiRuntime).not.toHaveBeenCalled();
expect(mockCopilotProbe).not.toHaveBeenCalled();
});
it("checks the inherited environment's company before resolving credentials", async () => {
mockInstanceSettingsService.get.mockResolvedValue({ defaultEnvironmentId: "11111111-1111-4111-8111-111111111111" });
mockEnvironmentService.listBoundCompanyIds.mockResolvedValue(["company-2"]);
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ adapterConfig: {} });
expect(res.status).toBe(403);
expect(mockSecretService.normalizeAdapterConfigForPersistence).not.toHaveBeenCalled();
expect(testEnvironmentSpy).not.toHaveBeenCalled();
});
it("never probes the host when an inherited environment is missing", async () => {
mockInstanceSettingsService.get.mockResolvedValue({ defaultEnvironmentId: "11111111-1111-4111-8111-111111111111" });
mockEnvironmentService.getById.mockResolvedValue(null);
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ adapterConfig: {} });
expect(res.body.checks).toEqual([expect.objectContaining({ code: "environment_not_found" })]);
expect(testEnvironmentSpy).not.toHaveBeenCalled();
});
it("does not probe locally when managed-only execution has no default or sandbox", async () => {
mockInstanceSettingsService.getExperimental.mockResolvedValue({ enableManagedSandboxOnly: true });
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ adapterConfig: {} });
expect(res.status).toBe(422);
expect(res.body.details.code).toBe("managed_sandbox_unavailable");
expect(testEnvironmentSpy).not.toHaveBeenCalled();
});
it("tests a prospective adapter switch before saving the agent", async () => {
mockAgentService.getById.mockResolvedValue({
id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", companyId: "company-1",
adapterType: "codex_local", adapterConfig: {}, runtimeConfig: {},
});
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ agentId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", adapterConfig: { model: "prospective-model" } });
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(testEnvironmentSpy).toHaveBeenCalledWith(expect.objectContaining({ config: { model: "prospective-model" } }));
});
it("requires agent update permission to test a prospective adapter switch", async () => {
mockAgentService.getById.mockResolvedValue({ id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", companyId: "company-1", adapterType: "codex_local", adapterConfig: {} });
mockAccessService.decide.mockImplementation(async ({ action }) => ({ allowed: action !== "agent_config:update", reason: "test", explanation: "Update denied" }));
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ agentId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", adapterConfig: {} });
expect(res.status).toBe(403);
expect(testEnvironmentSpy).not.toHaveBeenCalled();
});
it.each(["CURSOR_API_KEY", "KIMI_MODEL_API_KEY", "ZAI_API_KEY", "KIMI_API_KEY", "MINIMAX_API_KEY"])("accepts %s as a probe-only credential", async (key) => {
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ testCredentials: { [key]: "probe-only-key" } });
expect(res.status).toBe(200);
expect(mockSecretService.normalizeAdapterConfigForPersistence.mock.calls[0]?.[1]).toEqual({});
expect(testEnvironmentSpy.mock.calls[0]?.[0].config.env).toEqual({ [key]: "probe-only-key" });
});
it("maps the Hermes gateway probe key without passing it to persistence", async () => {
const { registerServerAdapter, getServerAdapter, unregisterServerAdapter } = await import("../adapters/index.js");
const previous = getServerAdapter("hermes_gateway");
unregisterServerAdapter("hermes_gateway");
registerServerAdapter({ ...externalAdapter, type: "hermes_gateway" });
try {
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/hermes_gateway/test-environment")
.send({ adapterConfig: { apiBaseUrl: "https://hermes.example.com" }, testCredentials: { API_SERVER_KEY: "gateway-probe-key" } });
expect(res.status).toBe(200);
expect(mockSecretService.normalizeAdapterConfigForPersistence.mock.calls[0]?.[1]).toEqual({ apiBaseUrl: "https://hermes.example.com" });
expect(testEnvironmentSpy.mock.calls[0]?.[0].config.apiKey).toBe("gateway-probe-key");
expect(JSON.stringify(res.body)).not.toContain("gateway-probe-key");
} finally {
unregisterServerAdapter("hermes_gateway");
if (previous) registerServerAdapter(previous);
}
});
// The managed-adoption verdict, all three ways. An api_key account is
// re-verified against the provider's endpoint at adoption — the same check
// its save performed, catching a key revoked since — but never through the
// CLI-lane hello probe, which a clean machine without a provider CLI can
// never pass (the regression that walled off onboarding's API-key path in
// the nightly release smoke). A stored subscription login still needs the
// hello probe: only a real turn proves the runtime lane can consume it.
it("adopts an api_key connection on the engine's verdict plus a live key check, without a CLI hello probe", async () => {
mockManagedRuntime("api_key");
// A sentinel in claude_local's slot: the forced CLI-lane fallback would
// land here, so the fix is proven by this never being consulted — not by
// whatever verdict the host machine's real adapter would return.
const { registerServerAdapter, getServerAdapter, unregisterServerAdapter } = await import("../adapters/index.js");
const previous = getServerAdapter("claude_local");
unregisterServerAdapter("claude_local");
const cliProbeSpy = vi.fn(async () => ({
adapterType: "claude_local",
status: "fail" as const,
checks: [{ code: "adapter_command_missing", level: "error" as const, message: 'Command not found in PATH: "claude"' }],
testedAt: new Date(0).toISOString(),
}));
registerServerAdapter({ ...externalAdapter, type: "claude_local", testEnvironment: cliProbeSpy });
try {
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({
adapterConfig: { cwd: "/" },
aiConnection: { provider: "anthropic", method: "api_key", mode: "responsible_user" },
});
expect(res.status).toBe(200);
expect(res.body.status).toBe("pass");
expect(JSON.stringify(res.body)).not.toContain("ai_connection_validation_incomplete");
expect(res.body.checks.map((check: { code: string }) => check.code)).toContain("ai_connection_api_key_reverified");
expect(mockValidateAiApiKey).toHaveBeenCalledWith("anthropic", "sk-ant-test-key");
expect(testEnvironmentSpy).toHaveBeenCalledTimes(1);
expect(cliProbeSpy).not.toHaveBeenCalled();
} finally {
unregisterServerAdapter("claude_local");
if (previous) registerServerAdapter(previous);
}
});
it("fails adoption of an api_key connection the provider no longer accepts", async () => {
mockManagedRuntime("api_key");
const { unprocessable } = await import("../errors.js");
mockValidateAiApiKey.mockRejectedValueOnce(unprocessable("The provider rejected this API key.", {
code: "ai_connection_api_key_rejected",
}));
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({
adapterConfig: { cwd: "/" },
aiConnection: { provider: "anthropic", method: "api_key", mode: "responsible_user" },
});
expect(res.status).toBe(200);
expect(res.body.status).toBe("fail");
expect(res.body.checks.map((check: { code: string }) => check.code)).toContain("ai_connection_api_key_rejected");
expect(mockMarkAuthenticationFailed).toHaveBeenCalledWith(expect.objectContaining({
companyId: "company-1",
attribution: expect.objectContaining({ connectionId: "conn-1", grantId: "grant-1" }),
}));
});
it("still fails subscription adoption when no hello probe can run", async () => {
mockManagedRuntime("subscription");
const { registerServerAdapter, getServerAdapter, unregisterServerAdapter } = await import("../adapters/index.js");
const previous = getServerAdapter("claude_local");
unregisterServerAdapter("claude_local");
const cliProbeSpy = vi.fn(async (_context: AdapterEnvironmentTestContext) => ({
adapterType: "claude_local",
status: "fail" as const,
checks: [{ code: "adapter_command_missing", level: "error" as const, message: 'Command not found in PATH: "claude"' }],
testedAt: new Date(0).toISOString(),
}));
registerServerAdapter({ ...externalAdapter, type: "claude_local", testEnvironment: cliProbeSpy });
try {
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({
adapterConfig: { cwd: "/" },
aiConnection: { provider: "anthropic", method: "subscription", mode: "responsible_user" },
});
expect(res.status).toBe(200);
expect(res.body.status).toBe("fail");
expect(res.body.checks.map((check: { code: string }) => check.code)).toContain("ai_connection_validation_incomplete");
expect(cliProbeSpy).toHaveBeenCalledTimes(1);
expect(cliProbeSpy.mock.calls[0]?.[0]?.config.engine).toBe("cli");
} finally {
unregisterServerAdapter("claude_local");
if (previous) registerServerAdapter(previous);
}
});
it("passes the selected Antigravity managed home through ordinary Test and accepts its native admission receipt", async () => {
const { registerServerAdapter, getServerAdapter, unregisterServerAdapter } = await import("../adapters/index.js");
const previous = getServerAdapter("paperclip_runner");
const adapterConfig = { provider: "acpx", acpxAgent: "antigravity", model: "exact-google-model" };
const binding = { provider: "google", method: "subscription", mode: "responsible_user" };
const agentId = "11111111-1111-4111-8111-111111111111";
mockAgentService.getById.mockResolvedValue({ id: agentId, companyId: "company-1", adapterType: "paperclip_runner",
adapterConfig, runtimeConfig: { aiConnection: binding }, createdByUserId: "local-board", pauseReason: "setup" });
mockPrepareManagedAiRuntime.mockImplementation(async (_db: unknown, input: { config: Record<string, unknown> }) => ({
config: { ...input.config, env: { GEMINI_HOME: "/selected-private-home/provider" }, managedAiConnection: { method: "subscription" } },
home: "/selected-private-home", cleanup: vi.fn(), accountName: "My Google subscription", attribution: { provider: "google" },
}));
const nativeProbe = vi.fn(async () => ({ adapterType: "paperclip_runner", status: "pass" as const, testedAt: new Date(0).toISOString(),
checks: [{ code: "antigravity_metadata_verified", level: "info" as const, message: "Native account and model accepted without a prompt." }] }));
unregisterServerAdapter("paperclip_runner");
registerServerAdapter({ ...externalAdapter, type: "paperclip_runner", testEnvironment: nativeProbe });
try {
const app = await createApp();
const response = await request(app).post("/api/companies/company-1/adapters/paperclip_runner/test-environment")
.send({ adapterConfig, aiConnection: binding, agentId });
expect(response.status, JSON.stringify(response.body)).toBe(200);
expect(response.body.status).toBe("pass");
expect(nativeProbe).toHaveBeenCalledExactlyOnceWith(expect.objectContaining({ companyId: "company-1", managedAiCredentialHome: "/selected-private-home/provider" }));
expect(response.body.checks).toContainEqual(expect.objectContaining({ code: "antigravity_metadata_verified" }));
expect(response.body.checks.some((check: { code: string }) => check.code.includes("hello_probe"))).toBe(false);
} finally {
unregisterServerAdapter("paperclip_runner");
if (previous) registerServerAdapter(previous);
}
});
it("passes one-shot provider credentials only to the probe, never persistence normalization", async () => {
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ adapterConfig: { env: { KEEP: "value" } }, testCredentials: { OPENROUTER_API_KEY: "probe-only-key" } });
expect(res.status).toBe(200);
expect(mockSecretService.normalizeAdapterConfigForPersistence.mock.calls[0]?.[1]).toEqual({ env: { KEEP: "value" } });
expect(testEnvironmentSpy.mock.calls[0]?.[0].config.env).toEqual({ KEEP: "value", OPENROUTER_API_KEY: "probe-only-key" });
expect(JSON.stringify(res.body)).not.toContain("probe-only-key");
});
it("rejects non-provider variables in one-shot credentials", async () => {
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ testCredentials: { NODE_OPTIONS: "--require unsafe" } });
expect(res.status).toBe(400);
expect(testEnvironmentSpy).not.toHaveBeenCalled();
});
it("does not fall back to a host probe when a requested environment cannot produce an execution target", async () => {
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({
adapterConfig: {},
environmentId: "11111111-1111-4111-8111-111111111111",
});
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(testEnvironmentSpy).not.toHaveBeenCalled();
expect(res.body).toMatchObject({
adapterType: "external_test",
status: "warn",
checks: [
{
code: "environment_target_unsupported",
level: "warn",
message: 'Adapter "external_test" is not allowed in "Sandbox QA" environments.',
},
],
});
expect(mockReleaseRunLease).toHaveBeenCalledWith({
environment: expect.objectContaining({
id: "11111111-1111-4111-8111-111111111111",
name: "Sandbox QA",
driver: "sandbox",
}),
lease: expect.objectContaining({
id: "lease-1",
}),
status: "failed",
});
});
it("returns a diagnostic result instead of probing the host when the requested environment is missing", async () => {
// The route reads the environment more than once: the tenant-binding guard
// loads it, then the execution-context resolver loads it. Return null for
// every read so the missing-environment path is stable.
mockEnvironmentService.getById.mockResolvedValue(null);
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({
adapterConfig: {},
environmentId: "22222222-2222-4222-8222-222222222222",
});
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(testEnvironmentSpy).not.toHaveBeenCalled();
expect(mockEnvironmentRuntime.acquireRunLease).not.toHaveBeenCalled();
expect(res.body).toMatchObject({
adapterType: "external_test",
status: "warn",
checks: [
{
code: "environment_not_found",
level: "warn",
message: "Selected environment was not found. The test did not run.",
},
],
});
});
it("runs the adapter probe against the resolved sandbox target on the happy path and releases the lease on success", async () => {
mockResolveEnvironmentExecutionTarget.mockResolvedValueOnce({
kind: "remote",
transport: "sandbox",
remoteCwd: "/home/user/paperclip-workspace",
providerKey: "fake-plugin",
runner: { execute: vi.fn() },
});
testEnvironmentSpy.mockResolvedValueOnce({
adapterType: "external_test",
status: "pass",
checks: [
{
code: "external_test_hello_probe_passed",
level: "info",
message: "OK",
},
],
testedAt: new Date(0).toISOString(),
});
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({
adapterConfig: {},
environmentId: "11111111-1111-4111-8111-111111111111",
});
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(testEnvironmentSpy).toHaveBeenCalledTimes(1);
// Test leases boot fresh and stay debuggable: never resume a retained
// agent lease, archive (not delete) the sandbox on release.
expect(mockEnvironmentRuntime.acquireRunLease).toHaveBeenCalledWith(
expect.objectContaining({
applyCustomImageTemplate: true,
configuredEnvironment: expect.objectContaining({
id: "11111111-1111-4111-8111-111111111111",
config: { provider: "fake-plugin" },
}),
// The Test lease re-checks the company binding, so a binding change
// between the route guard and the lease cannot open a foreign sandbox.
assertCompanyBinding: true,
environment: expect.objectContaining({
config: expect.objectContaining({
reuseLease: false,
archiveOnRelease: true,
}),
}),
}),
);
expect(testEnvironmentSpy.mock.calls[0]?.[0]).toMatchObject({
executionTarget: expect.objectContaining({
kind: "remote",
transport: "sandbox",
}),
environmentName: "Sandbox QA",
});
expect(res.body).toMatchObject({ adapterType: "external_test", status: "pass" });
expect(res.body.checks).toEqual([
expect.objectContaining({
code: "sandbox_test_identity",
level: "info",
message: 'Environment test identity for "Sandbox QA".',
detail: expect.stringContaining("paperclipLeaseId=lease-1"),
}),
expect.objectContaining({
code: "external_test_hello_probe_passed",
level: "info",
message: "OK",
}),
]);
expect(res.body.checks[0].detail).toContain("providerLeaseId=provider-lease-1");
expect(res.body.checks[0].detail).toContain("provider=daytona");
expect(res.body.checks[0].detail).toContain("sandboxId=sandbox-1");
expect(res.body.checks[0].detail).toContain("sandboxName=paperclip-probe");
expect(res.body.checks[0].detail).toContain("snapshotRef=snapshot-1");
expect(mockReleaseRunLease).toHaveBeenCalledWith({
environment: expect.objectContaining({ id: "11111111-1111-4111-8111-111111111111" }),
lease: expect.objectContaining({ id: "lease-1" }),
status: "released",
});
});
it("releases the lease as failed and returns a diagnostic when realizeWorkspace throws", async () => {
mockEnvironmentRuntime.realizeWorkspace.mockRejectedValueOnce(
new Error("workspace realization failed"),
);
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({
adapterConfig: {},
environmentId: "11111111-1111-4111-8111-111111111111",
});
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(testEnvironmentSpy).not.toHaveBeenCalled();
expect(res.body).toMatchObject({
adapterType: "external_test",
status: "fail",
checks: [
expect.objectContaining({
code: "environment_workspace_realize_failed",
level: "error",
}),
],
});
expect(mockReleaseRunLease).toHaveBeenCalledWith({
environment: expect.objectContaining({ id: "11111111-1111-4111-8111-111111111111" }),
lease: expect.objectContaining({ id: "lease-1" }),
status: "failed",
});
});
describe("environment envVars merge", () => {
const environmentId = "11111111-1111-4111-8111-111111111111";
const sandboxExecutionTarget = {
kind: "remote",
transport: "sandbox",
remoteCwd: "/home/user/paperclip-workspace",
providerKey: "fake-plugin",
runner: { execute: vi.fn() },
};
it("merges resolved environment envVars under the agent adapterConfig env", async () => {
mockEnvironmentService.getById.mockResolvedValue({
id: environmentId,
companyId: "company-1",
name: "Sandbox QA",
driver: "sandbox",
config: { provider: "fake-plugin" },
envVars: {
CLAUDE_CODE_OAUTH_TOKEN: { type: "secret_ref", secretId: "secret-1" },
FOO: { type: "plain", value: "env-foo" },
PAPERCLIP_API_KEY: { type: "plain", value: "must-not-flow" },
},
});
mockResolveEnvironmentExecutionTarget.mockResolvedValueOnce(sandboxExecutionTarget);
mockSecretService.resolveEnvBindings.mockResolvedValueOnce({
env: { CLAUDE_CODE_OAUTH_TOKEN: "resolved-token", FOO: "env-foo" },
secretKeys: new Set(["CLAUDE_CODE_OAUTH_TOKEN"]),
manifest: [],
});
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({
adapterConfig: { env: { FOO: "agent-foo" } },
environmentId,
});
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(mockSecretService.resolveEnvBindings).toHaveBeenCalledWith(
"company-1",
{
CLAUDE_CODE_OAUTH_TOKEN: { type: "secret_ref", secretId: "secret-1" },
FOO: { type: "plain", value: "env-foo" },
},
expect.objectContaining({
consumerType: "environment",
consumerId: environmentId,
}),
);
expect(testEnvironmentSpy).toHaveBeenCalledTimes(1);
// Environment env is the base layer; the agent's own env wins on conflicts.
expect(testEnvironmentSpy.mock.calls[0]?.[0]?.config?.env).toEqual({
CLAUDE_CODE_OAUTH_TOKEN: "resolved-token",
FOO: "agent-foo",
});
expect(res.body.status).toBe("pass");
});
it("skips env vars with missing secret bindings and fails the test", async () => {
mockEnvironmentService.getById.mockResolvedValue({
id: environmentId,
companyId: "company-1",
name: "Sandbox QA",
driver: "sandbox",
config: { provider: "fake-plugin" },
envVars: {
MISSING_TOKEN: { type: "secret_ref", secretId: "secret-gone" },
GOOD: { type: "plain", value: "ok" },
},
});
mockResolveEnvironmentExecutionTarget.mockResolvedValueOnce(sandboxExecutionTarget);
mockSecretService.collectMissingRuntimeBindings.mockResolvedValueOnce([
{
consumerType: "environment",
consumerId: environmentId,
configPath: "env.MISSING_TOKEN",
envKey: "MISSING_TOKEN",
secretId: "secret-gone",
secretName: "Gone",
},
]);
mockSecretService.resolveEnvBindings.mockResolvedValueOnce({
env: { GOOD: "ok" },
secretKeys: new Set<string>(),
manifest: [],
});
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ adapterConfig: {}, environmentId });
expect(res.status, JSON.stringify(res.body)).toBe(200);
// The unresolved key is excluded from resolution; the rest still flows.
expect(mockSecretService.resolveEnvBindings).toHaveBeenCalledWith(
"company-1",
{ GOOD: { type: "plain", value: "ok" } },
expect.objectContaining({ consumerType: "environment" }),
);
expect(testEnvironmentSpy).toHaveBeenCalledTimes(1);
expect(testEnvironmentSpy.mock.calls[0]?.[0]?.config?.env).toEqual({ GOOD: "ok" });
// A missing binding blocks real dispatch, so the test reports fail even
// though the adapter probe itself passed.
expect(res.body.status).toBe("fail");
expect(res.body.checks).toEqual(
expect.arrayContaining([
expect.objectContaining({
code: "environment_env_binding_missing",
level: "error",
message: expect.stringContaining("MISSING_TOKEN"),
}),
]),
);
});
it("includes environment env checks when the environment cannot produce an execution target", async () => {
mockEnvironmentService.getById.mockResolvedValue({
id: environmentId,
companyId: "company-1",
name: "Sandbox QA",
driver: "sandbox",
config: { provider: "fake-plugin" },
envVars: {
MISSING_TOKEN: { type: "secret_ref", secretId: "secret-gone" },
},
});
mockSecretService.collectMissingRuntimeBindings.mockResolvedValueOnce([
{
consumerType: "environment",
consumerId: environmentId,
configPath: "env.MISSING_TOKEN",
envKey: "MISSING_TOKEN",
secretId: "secret-gone",
secretName: "Gone",
},
]);
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ adapterConfig: {}, environmentId });
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(testEnvironmentSpy).not.toHaveBeenCalled();
expect(res.body.status).toBe("fail");
expect(res.body.checks).toEqual([
expect.objectContaining({ code: "environment_target_unsupported", level: "warn" }),
expect.objectContaining({ code: "environment_env_binding_missing", level: "error" }),
]);
});
});
describe("driver guard after runner selection", () => {
const pluginEnvironment = {
id: "33333333-3333-4333-8333-333333333333",
companyId: "company-1",
name: "Agent computer",
driver: "plugin",
status: "active",
config: { pluginKey: "acme.computers", driverKey: "tasks", driverConfig: {} },
};
const savedAgentId = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
beforeEach(() => {
mockEnvironmentService.getById.mockResolvedValue(pluginEnvironment);
mockResolveNewAgentRunnerForCompany.mockClear();
});
it("reports the missing agent prerequisite without acquiring a lease or probing the host", async () => {
mockPluginEnvironmentRequiresAgent.mockResolvedValueOnce(true);
mockResolveNewAgentRunnerForCompany.mockResolvedValueOnce({ adapterType: "paperclip_runner", adapterConfig: { provider: "codex" } });
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/codex_local/test-environment")
.send({ adapterConfig: {}, environmentId: pluginEnvironment.id });
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(res.body).toMatchObject({ status: "warn", checks: [{ code: "environment_agent_required", level: "warn" }] });
expect(mockEnvironmentRuntime.acquireRunLease).not.toHaveBeenCalled();
expect(testEnvironmentSpy).not.toHaveBeenCalled();
});
it("checks the plugin driver against the resolved Runner adapter, not the requested harness", async () => {
mockResolveNewAgentRunnerForCompany.mockResolvedValueOnce({ adapterType: "paperclip_runner", adapterConfig: { provider: "acpx", acpxAgent: "claude" } });
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/claude_local/test-environment")
.send({ adapterConfig: {}, environmentId: pluginEnvironment.id });
expect(mockResolveNewAgentRunnerForCompany).toHaveBeenCalledWith(expect.anything(), "company-1",
expect.objectContaining({ adapterType: "claude_local", defaultEnvironmentId: pluginEnvironment.id }));
// The driver check passes, and the resolved Runner leases the plugin
// environment. The probe stops at the controlled task-capability check.
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(mockEnvironmentRuntime.acquireRunLease).toHaveBeenCalledWith(expect.objectContaining({
adapterType: "paperclip_runner",
environment: expect.objectContaining({ id: pluginEnvironment.id, driver: "plugin" }),
}));
expect(mockEnvironmentRuntime.supportsTasks).toHaveBeenCalledWith({ lease: expect.objectContaining({ id: "lease-1" }) });
expect(res.body).toMatchObject({
adapterType: "paperclip_runner",
status: "fail",
checks: [expect.objectContaining({ detail: "Plugin environment does not provide native Runner task execution" })],
});
expect(testEnvironmentSpy).not.toHaveBeenCalled();
});
it.each([
{ name: "without a managed AI connection", adapterConfig: { provider: "codex" }, message: "Choose an AI connection" },
{ name: "with a preconfigured Runner home", adapterConfig: { provider: "codex", homeMode: "preconfigured" }, message: "isolated Runner home" },
])("refuses a Runner-task environment $name before secrets or a lease", async ({ adapterConfig, message }) => {
mockPluginRunnerTaskDriver.mockResolvedValueOnce({ driverKey: "tasks" });
mockResolveNewAgentRunnerForCompany.mockResolvedValueOnce({ adapterType: "paperclip_runner", adapterConfig });
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/codex_local/test-environment")
.send({ adapterConfig: {}, environmentId: pluginEnvironment.id });
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(res.body).toMatchObject({ adapterType: "paperclip_runner", status: "fail",
checks: [{ code: "ai_connection_required", level: "error", message: expect.stringContaining(message) }] });
expect(mockPluginRunnerTaskDriver).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ id: pluginEnvironment.id }));
expect(mockSecretService.resolveAdapterConfigForRuntime).not.toHaveBeenCalled();
expect(mockEnvironmentRuntime.acquireRunLease).not.toHaveBeenCalled();
expect(testEnvironmentSpy).not.toHaveBeenCalled();
});
it("still rejects a plugin environment when selection keeps a legacy adapter, before resolving secrets", async () => {
mockResolveNewAgentRunnerForCompany.mockResolvedValueOnce({ adapterType: "external_test", adapterConfig: {} });
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ adapterConfig: { env: { FOO: "bar" } }, environmentId: pluginEnvironment.id });
expect(res.status, JSON.stringify(res.body)).toBe(422);
expect(res.body.error).toContain('Environment driver "plugin" is not allowed here');
expect(mockSecretService.normalizeAdapterConfigForPersistence).not.toHaveBeenCalled();
expect(mockSecretService.resolveAdapterConfigForRuntime).not.toHaveBeenCalled();
expect(testEnvironmentSpy).not.toHaveBeenCalled();
});
it("re-resolves a saved adapter that cannot run on the requested environment", async () => {
mockAgentService.getById.mockResolvedValue({ id: savedAgentId, companyId: "company-1", adapterType: "external_test", adapterConfig: {}, runtimeConfig: {} });
mockResolveNewAgentRunnerForCompany.mockResolvedValueOnce({ adapterType: "external_test", adapterConfig: {} });
const app = await createApp();
await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ agentId: savedAgentId, adapterConfig: {}, environmentId: pluginEnvironment.id });
expect(mockResolveNewAgentRunnerForCompany).toHaveBeenCalledTimes(1);
});
it("keeps a saved adapter's execution when it can run on the requested environment", async () => {
mockEnvironmentService.getById.mockResolvedValue({ ...pluginEnvironment, driver: "local", config: {} });
mockAgentService.getById.mockResolvedValue({ id: savedAgentId, companyId: "company-1", adapterType: "external_test", adapterConfig: {}, runtimeConfig: {} });
const app = await createApp();
await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ agentId: savedAgentId, adapterConfig: {}, environmentId: pluginEnvironment.id });
expect(mockResolveNewAgentRunnerForCompany).not.toHaveBeenCalled();
});
});
describe("tenant-binding guard", () => {
async function postForeignEnvironmentTest() {
const app = await createApp();
return request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({
adapterConfig: { env: { FOO: "bar" } },
environmentId: "11111111-1111-4111-8111-111111111111",
});
}
function expectCompanyMismatch(res: request.Response) {
expect(res.status, JSON.stringify(res.body)).toBe(403);
expect(JSON.stringify(res.body)).toContain("environment_company_mismatch");
// The guard rejects before any secret resolution, target resolution,
// sandbox lease, or adapter test runs.
expect(mockSecretService.normalizeAdapterConfigForPersistence).not.toHaveBeenCalled();
expect(mockSecretService.resolveAdapterConfigForRuntime).not.toHaveBeenCalled();
expect(mockEnvironmentRuntime.acquireRunLease).not.toHaveBeenCalled();
expect(testEnvironmentSpy).not.toHaveBeenCalled();
}
it("rejects an active environment bound to another company", async () => {
mockEnvironmentService.listBoundCompanyIds.mockResolvedValue(["company-2"]);
expectCompanyMismatch(await postForeignEnvironmentTest());
});
it("rejects an archived environment bound to another company without revealing its status", async () => {
mockEnvironmentService.getById.mockResolvedValue({
id: "11111111-1111-4111-8111-111111111111",
companyId: "company-2",
name: "Sandbox QA",
driver: "sandbox",
status: "archived",
config: { provider: "fake-plugin" },
});
mockEnvironmentService.listBoundCompanyIds.mockResolvedValue(["company-2"]);
expectCompanyMismatch(await postForeignEnvironmentTest());
});
it("rejects a disallowed-driver environment bound to another company without revealing its driver", async () => {
mockEnvironmentService.getById.mockResolvedValue({
id: "11111111-1111-4111-8111-111111111111",
companyId: "company-2",
name: "Plugin Env",
driver: "plugin",
status: "active",
config: {},
});
mockEnvironmentService.listBoundCompanyIds.mockResolvedValue(["company-2"]);
expectCompanyMismatch(await postForeignEnvironmentTest());
});
it("allows an instance-global environment with no company binding", async () => {
mockEnvironmentService.listBoundCompanyIds.mockResolvedValue([]);
const res = await postForeignEnvironmentTest();
// The guard passes and the route proceeds to secret resolution.
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(mockSecretService.normalizeAdapterConfigForPersistence).toHaveBeenCalled();
});
it("allows an environment bound to the caller company", async () => {
mockEnvironmentService.listBoundCompanyIds.mockResolvedValue(["company-1"]);
const res = await postForeignEnvironmentTest();
// The guard passes and the route proceeds to secret resolution.
expect(res.status, JSON.stringify(res.body)).toBe(200);
expect(mockSecretService.normalizeAdapterConfigForPersistence).toHaveBeenCalled();
});
});
describe("managed-sandbox-only redirect", () => {
const localEnvironmentId = "33333333-3333-4333-8333-333333333333";
const managedSandboxEnvironment = {
id: "44444444-4444-4444-8444-444444444444",
companyId: null,
name: "Managed sandbox",
driver: "sandbox",
status: "active",
config: { provider: "fake-plugin" },
};
const localEnvironment = {
id: localEnvironmentId,
companyId: null,
name: "Local host",
driver: "local",
status: "active",
config: {},
};
it("redirects a local-environment Test onto the managed sandbox and never probes the host", async () => {
mockEnvironmentService.getById.mockResolvedValue(localEnvironment);
mockInstanceSettingsService.getExperimental.mockResolvedValue({
enableManagedSandboxOnly: true,
});
mockEnvironmentService.findManagedSandboxEnvironment.mockResolvedValue(
managedSandboxEnvironment,
);
mockResolveEnvironmentExecutionTarget.mockResolvedValueOnce({
kind: "remote",
transport: "sandbox",
remoteCwd: "/home/user/paperclip-workspace",
providerKey: "fake-plugin",
runner: { execute: vi.fn() },
});
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ adapterConfig: {}, environmentId: localEnvironmentId });
expect(res.status, JSON.stringify(res.body)).toBe(200);
// The Test leases and probes the managed sandbox the real run uses, not
// the local host that the agent default still names.
expect(mockEnvironmentRuntime.acquireRunLease).toHaveBeenCalledWith(
expect.objectContaining({
environment: expect.objectContaining({ id: managedSandboxEnvironment.id }),
}),
);
expect(testEnvironmentSpy).toHaveBeenCalledTimes(1);
expect(testEnvironmentSpy.mock.calls[0]?.[0]).toMatchObject({
executionTarget: expect.objectContaining({ kind: "remote", transport: "sandbox" }),
environmentName: "Managed sandbox",
});
});
it("fails closed when the policy is on and no managed sandbox environment exists", async () => {
mockEnvironmentService.getById.mockResolvedValue(localEnvironment);
mockInstanceSettingsService.getExperimental.mockResolvedValue({
enableManagedSandboxOnly: true,
});
mockEnvironmentService.findManagedSandboxEnvironment.mockResolvedValue(null);
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ adapterConfig: {}, environmentId: localEnvironmentId });
expect(res.status, JSON.stringify(res.body)).toBe(200);
// No fall back to a host probe: the Test reports fail-closed.
expect(testEnvironmentSpy).not.toHaveBeenCalled();
expect(mockEnvironmentRuntime.acquireRunLease).not.toHaveBeenCalled();
expect(res.body.status).toBe("fail");
expect(res.body.checks).toEqual([
expect.objectContaining({ code: "managed_sandbox_unavailable", level: "error" }),
]);
});
it("probes the local host when the managed-sandbox-only policy is off", async () => {
mockEnvironmentService.getById.mockResolvedValue(localEnvironment);
mockInstanceSettingsService.getExperimental.mockResolvedValue({
enableManagedSandboxOnly: false,
});
const app = await createApp();
const res = await request(app)
.post("/api/companies/company-1/adapters/external_test/test-environment")
.send({ adapterConfig: {}, environmentId: localEnvironmentId });
expect(res.status, JSON.stringify(res.body)).toBe(200);
// Legacy behavior: a local environment probes the host with no redirect
// and no sandbox lease.
expect(mockEnvironmentService.findManagedSandboxEnvironment).not.toHaveBeenCalled();
expect(mockEnvironmentRuntime.acquireRunLease).not.toHaveBeenCalled();
expect(testEnvironmentSpy).toHaveBeenCalledTimes(1);
expect(testEnvironmentSpy.mock.calls[0]?.[0]?.executionTarget ?? null).toBeNull();
});
});
});
vi.mock("../services/agent-lifecycle.js", async (importOriginal) => {
const actual = await importOriginal<typeof import("../services/agent-lifecycle.js")>();
return { ...actual, createAgentLifecycle: () => ({
}) };
});