diff --git a/packages/paperclip-runner/src/drivers/acpx/claude-scheduling-tools.claude-acp.test.ts b/packages/paperclip-runner/src/drivers/acpx/claude-scheduling-tools.claude-acp.test.ts new file mode 100644 index 00000000000..11ae233b846 --- /dev/null +++ b/packages/paperclip-runner/src/drivers/acpx/claude-scheduling-tools.claude-acp.test.ts @@ -0,0 +1,146 @@ +import { spawn } from "node:child_process"; +import { createServer } from "node:http"; +import { mkdir, mkdtemp, rm } from "node:fs/promises"; +import { createRequire } from "node:module"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { createInterface } from "node:readline"; +import { afterEach, expect, it } from "vitest"; +import { resolveQualifiedAcpxProfile } from "./qualified-profiles.js"; +import { createAcpxRecoveryBinding } from "./recovery-identity.js"; +import { prepareAcpxRuntimeSandbox } from "./runtime-sandbox.js"; + +const SELF_SCHEDULING = ["CronCreate", "CronDelete", "CronList", "ScheduleWakeup"]; +const RETAINED = ["Agent", "Bash", "ListAgents", "SendMessage", "TaskStop", "Workflow"]; +const agentEntry = createRequire(import.meta.url).resolve("@agentclientprotocol/claude-agent-acp/dist/index.js"); +const cleanup: Array<() => Promise> = []; +afterEach(async () => { for (const step of cleanup.splice(0).reverse()) await step(); }); + +async function fakeAnthropicApi(): Promise<{ url: string; offered: string[][] }> { + const offered: string[][] = []; + const api = createServer(async (request, response) => { + let raw = ""; + for await (const chunk of request) raw += chunk; + if (request.method !== "POST" || request.url?.includes("count_tokens")) { + response.writeHead(200, { "content-type": "application/json" }); + response.end(request.url?.includes("count_tokens") ? JSON.stringify({ input_tokens: 1 }) : JSON.stringify({ data: [], has_more: false })); + return; + } + const body = JSON.parse(raw || "{}"); + if (Array.isArray(body.tools)) offered.push(body.tools.map((tool: { name: string }) => tool.name)); + response.writeHead(200, { "content-type": "text/event-stream" }); + for (const frame of [ + { type: "message_start", message: { id: "msg_fixture", type: "message", role: "assistant", model: body.model ?? "claude-sonnet-5", content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: 1, output_tokens: 0 } } }, + { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } }, + { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "Local fixture complete." } }, + { type: "content_block_stop", index: 0 }, + { type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { output_tokens: 1 } }, + { type: "message_stop" }, + ]) response.write(`event: ${frame.type}\ndata: ${JSON.stringify(frame)}\n\n`); + response.end(); + }); + await new Promise(resolve => api.listen(0, "127.0.0.1", resolve)); + cleanup.push(async () => { api.closeAllConnections(); await new Promise(resolve => api.close(() => resolve())); }); + return { url: `http://127.0.0.1:${(api.address() as { port: number }).port}`, offered }; +} + +async function promptOnce(env: NodeJS.ProcessEnv, cwd: string): Promise { + const agent = spawn(process.execPath, [agentEntry], { cwd, env, detached: true, stdio: ["pipe", "pipe", "ignore"] }); + const closed = new Promise(resolve => agent.once("close", () => resolve())); + let stopping: Promise | undefined; + const stop = () => stopping ??= stopProcessGroup(agent.pid!, closed); + cleanup.push(stop); + let nextId = 1; + const pending = new Map) => void; reject: (error: unknown) => void }>(); + const send = (message: Record) => agent.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", ...message })}\n`); + const request = (method: string, params: Record) => new Promise>((resolve, reject) => { + const id = nextId++; + pending.set(id, { resolve, reject }); + send({ id, method, params }); + }); + createInterface({ input: agent.stdout }).on("line", line => { + let message: { id?: number; method?: string; result?: Record; error?: unknown }; + try { message = JSON.parse(line); } catch { return; } + if (message.id !== undefined && message.method === undefined) { + const waiter = pending.get(message.id); + pending.delete(message.id); + if (message.error) waiter?.reject(message.error); else waiter?.resolve(message.result ?? {}); + } else if (message.id !== undefined) { + send({ id: message.id, error: { code: -32601, message: "Not supported by this fixture" } }); + } + }); + agent.once("exit", code => { for (const waiter of pending.values()) waiter.reject(new Error(`claude-agent-acp exited with ${code}`)); }); + await request("initialize", { protocolVersion: 1, clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false } }); + const session = await request("session/new", { cwd, mcpServers: [] }); + await request("session/prompt", { sessionId: session.sessionId, prompt: [{ type: "text", text: "Report this local fixture's result. Do not call tools." }] }); + await stop(); +} + +function signalGroup(pid: number, signal: NodeJS.Signals | 0): boolean { + try { process.kill(-pid, signal); return true; } catch (error) { + if ((error as NodeJS.ErrnoException).code === "ESRCH") return false; + throw error; + } +} + +async function stopProcessGroup(pid: number, closed: Promise): Promise { + signalGroup(pid, "SIGTERM"); + const deadline = (ms: number) => new Promise<"timeout">(resolve => setTimeout(() => resolve("timeout"), ms).unref()); + if (await Promise.race([closed, deadline(5_000)]) === "timeout") signalGroup(pid, "SIGKILL"); + await closed; + for (let attempt = 0; signalGroup(pid, 0); attempt += 1) { + if (attempt === 50) signalGroup(pid, "SIGKILL"); + if (attempt > 100) throw new Error(`claude-agent-acp process group ${pid} did not exit`); + await deadline(50); + } +} + +function fixtureEnvironment(apiUrl: string): NodeJS.ProcessEnv { + return { + PATH: process.env.PATH, ANTHROPIC_API_KEY: "local-fixture-only", ANTHROPIC_BASE_URL: apiUrl, + CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1", + }; +} + +const launchOnlyEnvironment = { DISABLE_TELEMETRY: "1", DISABLE_ERROR_REPORTING: "1", DISABLE_AUTOUPDATER: "1", ENABLE_TOOL_SEARCH: "false" }; + +it("withholds Claude's self-scheduling tools from a Paperclip-launched ACPX session", async () => { + const root = await mkdtemp(join(tmpdir(), "claude-scheduling-tools-")); + cleanup.push(() => rm(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 })); + const workspace = join(root, "workspace"), runtimeDirectory = join(root, "runtime"); + await Promise.all([mkdir(workspace), mkdir(runtimeDirectory)]); + const binding = await createAcpxRecoveryBinding({ + runtimeDirectory, normalizedSessionId: "claude-scheduling-tools", workingDirectory: workspace, + profile: resolveQualifiedAcpxProfile("claude", "claude-sonnet-5"), requestedModel: "claude-sonnet-5", + permissionMode: "approve-reads", + }); + const api = await fakeAnthropicApi(); + const sandbox = await prepareAcpxRuntimeSandbox({ binding, agent: "claude", environment: fixtureEnvironment(api.url) }); + await sandbox.initializeOwnedConfiguration?.(); + await promptOnce({ ...sandbox.launchEnvironment, ...launchOnlyEnvironment, TMPDIR: root }, workspace); + expect(api.offered.length).toBeGreaterThan(0); + const offered = api.offered.reduce((longest, tools) => tools.length > longest.length ? tools : longest); + for (const tool of SELF_SCHEDULING) expect(offered).not.toContain(tool); + for (const tool of RETAINED) expect(offered).toContain(tool); +}, 60_000); + +it("withholds Claude's cron tools when the run uses a preconfigured home", async () => { + const root = await mkdtemp(join(tmpdir(), "claude-scheduling-tools-home-")); + cleanup.push(() => rm(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 })); + const workspace = join(root, "workspace"), runtimeDirectory = join(root, "runtime"), home = join(root, "home"); + await Promise.all([mkdir(workspace), mkdir(runtimeDirectory), mkdir(home)]); + const binding = await createAcpxRecoveryBinding({ + runtimeDirectory, normalizedSessionId: "claude-scheduling-tools-home", workingDirectory: workspace, + profile: resolveQualifiedAcpxProfile("claude", "claude-sonnet-5"), requestedModel: "claude-sonnet-5", + permissionMode: "approve-reads", + }); + const api = await fakeAnthropicApi(); + const sandbox = await prepareAcpxRuntimeSandbox({ binding, agent: "claude", environment: { + ...fixtureEnvironment(api.url), HOME: home, PAPERCLIP_RUNNER_HOME_MODE: "preconfigured", + } }); + await promptOnce({ ...sandbox.launchEnvironment, ...launchOnlyEnvironment, TMPDIR: root }, workspace); + expect(api.offered.length).toBeGreaterThan(0); + const offered = api.offered.reduce((longest, tools) => tools.length > longest.length ? tools : longest); + for (const tool of ["CronCreate", "CronDelete", "CronList"]) expect(offered).not.toContain(tool); + for (const tool of RETAINED) expect(offered).toContain(tool); +}, 60_000); diff --git a/packages/paperclip-runner/src/drivers/acpx/environment.test.ts b/packages/paperclip-runner/src/drivers/acpx/environment.test.ts index 7b0d756b4c1..8561406c85f 100644 --- a/packages/paperclip-runner/src/drivers/acpx/environment.test.ts +++ b/packages/paperclip-runner/src/drivers/acpx/environment.test.ts @@ -3,9 +3,9 @@ import { afterEach, describe, expect, it, vi } from "vitest"; afterEach(() => vi.unstubAllEnvs()); -import { ACPX_CREDENTIAL_BINDING_ENV, CLAUDE_TODO_TOOLS_ENV, createAcpxCredentialBinding, createAcpxSidecarHostEnvironment, createSanitizedAcpxSpawnInput } from "./environment.js"; +import { ACPX_CREDENTIAL_BINDING_ENV, CLAUDE_CRON_DISABLE_ENV, CLAUDE_TODO_TOOLS_ENV, createAcpxCredentialBinding, createAcpxSidecarHostEnvironment, createSanitizedAcpxSpawnInput } from "./environment.js"; -const claudeLauncherEnv = { [CLAUDE_TODO_TOOLS_ENV]: "1" }; +const claudeLauncherEnv = { [CLAUDE_TODO_TOOLS_ENV]: "1", [CLAUDE_CRON_DISABLE_ENV]: "1" }; describe("ACPX launch environment", () => { it("enables Claude's task-list tools for the native plan and only for Claude", () => { @@ -15,6 +15,13 @@ describe("ACPX launch environment", () => { expect(createSanitizedAcpxSpawnInput(host, "codex").env[CLAUDE_TODO_TOOLS_ENV]).toBeUndefined(); }); + it("disables Claude's own cron scheduler for every Claude launch and only for Claude", () => { + const host = { PATH: "/bin", [CLAUDE_CRON_DISABLE_ENV]: "0" }; + expect(createSanitizedAcpxSpawnInput(host, "claude").env[CLAUDE_CRON_DISABLE_ENV]).toBe("1"); + expect(createSanitizedAcpxSpawnInput({ PATH: "/bin", PAPERCLIP_RUNNER_HOME_MODE: "preconfigured" }, "claude").env[CLAUDE_CRON_DISABLE_ENV]).toBe("1"); + expect(createSanitizedAcpxSpawnInput(host, "codex").env[CLAUDE_CRON_DISABLE_ENV]).toBeUndefined(); + }); + it("rejects task shell selectors without a controller-owned helper projection", () => { const selectors = { BASH_ENV: "/workspace/hook.sh", ZDOTDIR: "/workspace", GH_CONFIG_DIR: "/workspace/gh" }; expect(createSanitizedAcpxSpawnInput(selectors, "claude").env).toEqual(claudeLauncherEnv); diff --git a/packages/paperclip-runner/src/drivers/acpx/environment.ts b/packages/paperclip-runner/src/drivers/acpx/environment.ts index e0489522c4e..c3e0ad5ca89 100644 --- a/packages/paperclip-runner/src/drivers/acpx/environment.ts +++ b/packages/paperclip-runner/src/drivers/acpx/environment.ts @@ -19,6 +19,7 @@ export const ACPX_CREDENTIAL_NAMES: Readonly `plan.updated`), // so the launcher owns this value; a host setting cannot switch it off. if (agent === "claude") result[CLAUDE_TODO_TOOLS_ENV] = "1"; + if (agent === "claude") result[CLAUDE_CRON_DISABLE_ENV] = "1"; if (agent === "claude" && isOpenRouterUrl(result.ANTHROPIC_BASE_URL)) { result.ANTHROPIC_CUSTOM_HEADERS = openRouterClaudeHeaders(result.ANTHROPIC_CUSTOM_HEADERS); } diff --git a/packages/paperclip-runner/src/drivers/acpx/permission-policy.ts b/packages/paperclip-runner/src/drivers/acpx/permission-policy.ts index 576ff3ce1db..a934bc81481 100644 --- a/packages/paperclip-runner/src/drivers/acpx/permission-policy.ts +++ b/packages/paperclip-runner/src/drivers/acpx/permission-policy.ts @@ -26,6 +26,8 @@ const AUTOMATIC_PAPERCLIP_WORKFLOW_ACTIONS = new Set([ "create_project", "select_workspace", "request_approval", ]); +export const CLAUDE_SELF_SCHEDULING_TOOLS: readonly string[] = Object.freeze(["CronCreate", "CronDelete", "CronList", "ScheduleWakeup"]); + /** Exact SDK rules for the run's runner-owned Paperclip MCP connection. */ export function claudePaperclipPermissionRules( tools: readonly Readonly>[], diff --git a/packages/paperclip-runner/src/drivers/acpx/runtime-host.test.ts b/packages/paperclip-runner/src/drivers/acpx/runtime-host.test.ts index 7a6b650da9f..6b020d14f8a 100644 --- a/packages/paperclip-runner/src/drivers/acpx/runtime-host.test.ts +++ b/packages/paperclip-runner/src/drivers/acpx/runtime-host.test.ts @@ -28,6 +28,8 @@ import type { VerifiedAcpxInstallation, } from "./installation-integrity.js"; import { resolveQualifiedAcpxProfile } from "./qualified-profiles.js"; +import type { AcpxExpectedSessionIdentity } from "./sidecar-protocol.js"; +import { acpxProviderSessionIdentity } from "./recovery-identity.js"; import { prepareAcpxRuntimeSandbox, type AcpxRuntimeSandbox, @@ -543,7 +545,7 @@ describe("ACPX runtime host", () => { join(options.launchEnvironment.CLAUDE_CONFIG_DIR!, "settings.json"), "utf8", )); - expect(settings.permissions).toEqual(allow ? { allow } : undefined); + expect(settings.permissions).toEqual({ ...(allow ? { allow } : {}), deny: ["CronCreate", "CronDelete", "CronList", "ScheduleWakeup"] }); expect(options.mcpServers).toMatchObject([ { name: "paperclip", runnerOwned: true }, ]); @@ -570,6 +572,57 @@ describe("ACPX runtime host", () => { await host.close({ reason: "read permission verified" }); }); + it("resumes a Claude session saved by the previous release and withholds self-scheduling tools on relaunch", async () => { + const fixture = await hostFixture(); + const tools = { + tools: [{ name: "get_task_context", inputSchema: { type: "object" } }], + handler: async () => ({}), + }; + const launches: Array<{ env: Readonly; settings: Record; restoring: boolean }> = []; + const dependencies = fixture.dependencies({ + openRuntime: async (options) => { + launches.push({ + env: options.launchEnvironment, + settings: JSON.parse(await readFile(join(options.launchEnvironment.CLAUDE_CONFIG_DIR!, "settings.json"), "utf8")), + restoring: options.restoringSession === true, + }); + return runtimePort({ getStatus: async () => ({ models: { currentModelId: "claude-sonnet-5" } }) }); + }, + }); + const open = (expectedIdentity?: AcpxExpectedSessionIdentity) => AcpxRuntimeHost.open({ + ...fixture.options, agent: "claude", model: "claude-sonnet-5", permissionMode: "approve-reads", + semanticTools: tools, ...(expectedIdentity ? { expectedIdentity } : {}), + }, dependencies); + + const first = await open(); + const savedIdentity = acpxProviderSessionIdentity(first.identity(), first.binding()); + await first.close({ reason: "previous release parked the session" }); + const claudeHome = launches[0]!.env.CLAUDE_CONFIG_DIR!; + const previousReleaseSettings = { + model: "claude-sonnet-5", availableModels: ["claude-sonnet-5"], + permissions: { allow: ["mcp__paperclip__get_task_context"] }, + }; + await writeFile(join(claudeHome, "settings.json"), `${JSON.stringify(previousReleaseSettings)}\n`, { mode: 0o600 }); + const transcript = join(claudeHome, "projects", "workspace", "agent-1.jsonl"); + await mkdir(join(claudeHome, "projects", "workspace"), { recursive: true }); + await writeFile(transcript, "{\"type\":\"user\",\"message\":\"saved by the previous release\"}\n"); + + const resumed = await open(savedIdentity); + try { + expect(resumed.identity()).toEqual(first.identity()); + expect(launches[1]!.restoring).toBe(true); + expect(launches[1]!.env.CLAUDE_CONFIG_DIR).toBe(claudeHome); + expect(launches[1]!.env.CLAUDE_CODE_DISABLE_CRON).toBe("1"); + expect(launches[1]!.settings).toEqual({ + ...previousReleaseSettings, + permissions: { ...previousReleaseSettings.permissions, deny: ["CronCreate", "CronDelete", "CronList", "ScheduleWakeup"] }, + }); + expect(await readFile(transcript, "utf8")).toContain("saved by the previous release"); + } finally { + await resumed.close({ reason: "previous-release session resumed" }); + } + }); + it("loads assigned Claude skills before launch and refreshes them when reopening", async () => { const fixture = await hostFixture(); const skillRoot = join(fixture.root, "assigned-source"); diff --git a/packages/paperclip-runner/src/drivers/acpx/runtime-sandbox.test.ts b/packages/paperclip-runner/src/drivers/acpx/runtime-sandbox.test.ts index a508285096d..70b8230aeb3 100644 --- a/packages/paperclip-runner/src/drivers/acpx/runtime-sandbox.test.ts +++ b/packages/paperclip-runner/src/drivers/acpx/runtime-sandbox.test.ts @@ -212,6 +212,17 @@ describe("ACPX runtime sandbox", () => { } }); + it.each(["approve-reads", "approve-paperclip", "deny-all", "approve-all"] as const)( + "denies Claude's self-scheduling tools in isolated settings under %s", + async (permissionMode) => { + const fixture = await sandboxFixture("claude"); + const sandbox = await prepareAcpxRuntimeSandbox({ binding: { ...fixture.binding, permissionMode }, agent: "claude" }); + await sandbox.initializeOwnedConfiguration?.(); + const settings = JSON.parse(await readFile(join(sandbox.agentHomeDirectory, "settings.json"), "utf8")); + expect(settings.permissions.deny).toEqual(["CronCreate", "CronDelete", "CronList", "ScheduleWakeup"]); + }, + ); + it("restores bound Claude effort in private settings across cold connections", async () => { const fixture = await sandboxFixture("claude"); for (const claudeEffort of ["high", "xhigh", "max"] as const) { diff --git a/packages/paperclip-runner/src/drivers/acpx/runtime-sandbox.ts b/packages/paperclip-runner/src/drivers/acpx/runtime-sandbox.ts index fe12d82c715..d34a93fa197 100644 --- a/packages/paperclip-runner/src/drivers/acpx/runtime-sandbox.ts +++ b/packages/paperclip-runner/src/drivers/acpx/runtime-sandbox.ts @@ -36,7 +36,7 @@ import { import { createSanitizedAcpxSpawnInput } from "./environment.js"; import { cursorInstructionBinding } from "./cursor-instructions.js"; -import { claudePaperclipPermissionRules } from "./permission-policy.js"; +import { CLAUDE_SELF_SCHEDULING_TOOLS, claudePaperclipPermissionRules } from "./permission-policy.js"; import type { QualifiedAcpxAgent } from "./qualified-profiles.js"; import { resolveAcpxRuntimeRoot, @@ -440,9 +440,12 @@ export async function prepareAcpxRuntimeSandbox(input: { model: input.binding.requestedModel, availableModels: [input.binding.requestedModel], ...(input.binding.claudeEffort ? { effortLevel: input.binding.claudeEffort } : {}), - ...((input.binding.permissionMode === "approve-reads" || input.binding.permissionMode === "approve-paperclip") - ? { permissions: { allow: claudePaperclipPermissionRules(input.tools ?? [], input.binding.permissionMode) } } - : {}), + permissions: { + ...((input.binding.permissionMode === "approve-reads" || input.binding.permissionMode === "approve-paperclip") + ? { allow: claudePaperclipPermissionRules(input.tools ?? [], input.binding.permissionMode) } + : {}), + deny: [...CLAUDE_SELF_SCHEDULING_TOOLS], + }, })}\n`, ); } : input.agent === "antigravity" ? async () => {