From 586c6aa091bd0e1e175650ab5d196a4134dfe5e7 Mon Sep 17 00:00:00 2001 From: Devin Foley Date: Tue, 17 Nov 2026 15:00:10 -0800 Subject: [PATCH] Fix in-place SSH execution across supported Cloud harnesses Use the shared remote execution capability registry for durable SSH task admission. Keep controller workspace checks and transfers off authoritative remote paths across all eight SSH-capable adapters. Preserve connection identity in their session codecs, stabilize managed ACP skill-home identity, and stage Grok project assets through the SSH target. Expand the real SSH heartbeat matrix to every direct harness, including compatible managed accounts, task-file persistence, and follow-up turns. Verify previous-release conversation handling, runtime cleanup, local and copied workspaces, and native Runner contracts. Co-Authored-By: Paperclip --- doc/tailscale-environments.md | 26 ++++-- .../src/acpx-engine/execute.test.ts | 29 +++++- .../adapter-utils/src/acpx-engine/execute.ts | 25 ++++- .../src/execution-target.test.ts | 23 ++++- .../adapter-utils/src/execution-target.ts | 11 ++- .../claude-local/src/server/execute.ts | 6 +- .../cursor-local/src/server/execute.ts | 4 +- .../adapters/cursor-local/src/server/index.ts | 5 + .../gemini-local/src/server/acp.test.ts | 4 +- .../adapters/gemini-local/src/server/acp.ts | 8 +- .../src/server/engine-availability.test.ts | 27 ++++++ .../gemini-local/src/server/execute.ts | 4 +- .../adapters/gemini-local/src/server/index.ts | 5 + .../grok-local/src/server/execute.test.ts | 3 +- .../adapters/grok-local/src/server/execute.ts | 35 +++++-- .../adapters/grok-local/src/server/index.ts | 5 + .../src/server/remote-project-assets.test.ts | 44 +++++++++ .../src/server/remote-project-assets.ts | 61 +++++++++++++ .../adapters/kimi-local/src/server/acp.ts | 8 +- .../src/server/engine-availability.test.ts | 27 ++++++ .../kimi-local/src/server/execute.test.ts | 3 +- .../adapters/kimi-local/src/server/execute.ts | 4 +- .../adapters/kimi-local/src/server/index.ts | 5 + .../opencode-local/src/server/execute.ts | 4 +- .../opencode-local/src/server/index.ts | 5 + .../adapters/pi-local/src/server/execute.ts | 4 +- .../adapters/pi-local/src/server/index.ts | 5 + .../ephemeral-server-contract.test.ts | 2 +- .../ssh-adapter-session-codecs.test.ts | 22 +++++ .../heartbeat/runtime-selection.test.ts | 2 +- .../heartbeat/workspace-preparation.test.ts | 2 +- server/src/services/remote-workspaces.ts | 4 +- .../ssh-remote-workspace.integration.test.ts | 91 +++++++++++++++---- 33 files changed, 437 insertions(+), 76 deletions(-) create mode 100644 packages/adapters/grok-local/src/server/remote-project-assets.test.ts create mode 100644 packages/adapters/grok-local/src/server/remote-project-assets.ts create mode 100644 server/src/__tests__/ssh-adapter-session-codecs.test.ts diff --git a/doc/tailscale-environments.md b/doc/tailscale-environments.md index ebd55e1d4d2..a642cf379b1 100644 --- a/doc/tailscale-environments.md +++ b/doc/tailscale-environments.md @@ -64,12 +64,17 @@ and Tailscale connections. ## SSH on a volume-free Cloud stack Cloud SSH execution uses the same durable task workspace storage as Cloud -sandboxes. Claude Code and Codex use their existing SSH adapters. With an -agent-selected Paperclip AI account, the default ACP engine runs directly in the -remote task directory and stages only private runtime assets. The CLI engine -also supports this directory. ACP requires its server command, such as -`claude-agent-acp`, on the SSH login PATH. Selecting SSH does not change the -agent's engine or permission settings. +sandboxes. All built-in SSH-capable harnesses use their existing adapters: +Claude Code, Codex, Cursor, Gemini, Grok, Kimi, OpenCode, and Pi. The native +Paperclip Runner also retains its SSH execution path. Cloud API and gateway +adapters keep their provider-managed execution rather than selecting an SSH host. + +With a compatible agent-selected Paperclip AI account, ACP can run directly in +the remote task directory and stage only private runtime assets. Claude Code, +Codex, Gemini, and Kimi expose this ACP path. The CLI engines support the same +remote directory. ACP requires its server command, such as `claude-agent-acp`, +on the SSH login PATH. Selecting SSH does not change the agent's engine, +account compatibility, or permission settings. An in-place SSH workspace exists on the SSH computer. Neither engine creates that workspace path on the controller. ACP keeps its local relay and state files @@ -82,6 +87,15 @@ The SSH account supplies the installed harness; the agent's Paperclip AI account supplies authentication unless the remote authentication option is enabled. Host authentication remains supported by the CLI engine. +Saved CLI sessions retain the SSH connection identity through persistence, so a +follow-up cannot attach to a different host. Disposable managed account-home +paths do not reset new ACP conversations. A configuration identity change is +reported as `acpx_session_identity_changed`; older Codex or Gemini ACP sessions +that used the former home identity can reset once at upgrade. Task files remain +in their durable SSH workspace. Older CLI sessions without a saved SSH identity +remain unresumable; Core does not guess their source host. + + Each task receives a private directory below the configured SSH workspace path, inside `.paperclip-workspaces`. The task runs in that remote directory. Core keeps the workspace binding and saved file versions in its database and object diff --git a/packages/adapter-utils/src/acpx-engine/execute.test.ts b/packages/adapter-utils/src/acpx-engine/execute.test.ts index e7e8b0ef583..74f3d01a97b 100644 --- a/packages/adapter-utils/src/acpx-engine/execute.test.ts +++ b/packages/adapter-utils/src/acpx-engine/execute.test.ts @@ -2181,11 +2181,11 @@ describe("shared ACPX engine runtime behavior", () => { ); const changedEnv = await runExecutor( { ...baseConfig, env: { OPENROUTER_API_KEY: "value-2" } }, - { context: { taskId: "issue-1", wakeReason: "issue_assigned" } }, + { context: { taskId: "issue-1", wakeReason: "issue_assigned" }, runtime: { sessionParams: first.result.sessionParams } }, ); const sameEnvNewWake = await runExecutor( { ...baseConfig, env: { OPENROUTER_API_KEY: "value-1" } }, - { context: { taskId: "issue-1", wakeReason: "comment", wakeCommentId: "c-9" } }, + { context: { taskId: "issue-1", wakeReason: "comment", wakeCommentId: "c-9" }, runtime: { sessionParams: first.result.sessionParams } }, ); const fp = (r: { result: { sessionParams?: unknown } }) => @@ -2195,9 +2195,11 @@ describe("shared ACPX engine runtime behavior", () => { // the next launch sources the latest env. expect(fp(first)).toBeDefined(); expect(fp(changedEnv)).not.toBe(fp(first)); + expect(changedEnv.result.resultJson?.sessionReset).toMatchObject({ code: "acpx_session_identity_changed" }); // A new heartbeat with the same config env keeps the fingerprint stable, so // per-wake PAPERCLIP_* churn does not needlessly reset the session. expect(fp(sameEnvNewWake)).toBe(fp(first)); + expect(sameEnvNewWake.result.resultJson?.sessionReset).toBeUndefined(); }); it("keeps rotated run scratch paths out of session identity while retaining user temp overrides", async () => { @@ -4563,7 +4565,7 @@ describe("ACPX engine remote managed-home seam (PR 2: per-adapter home seed)", ( return { root, stateDir, localCwd, remoteCwd, executionTarget }; } - it.each(["custom", "claude"].flatMap(agent => ["turn", "bridge"].flatMap(failure => [ + it.each(["custom", "claude", "codex", "gemini"].flatMap(agent => ["turn", "bridge"].flatMap(failure => [ { inPlace: false, legacySettings: false }, { inPlace: true, legacySettings: false }, ...(agent === "claude" ? [{ inPlace: true, legacySettings: true }] : []), ].map(workspace => ({ agent, failure, ...workspace })))))( @@ -4723,6 +4725,27 @@ describe("ACPX engine remote managed-home seam (PR 2: per-adapter home seed)", ( expect(restore).toHaveBeenCalledTimes(4); expect(dispose).toHaveBeenCalledTimes(2); expect(stagedRuntimes.size).toBe(0); + if (inPlace && failure === "turn" && ["codex", "gemini"].includes(agent)) { + const canonical = (value: unknown): unknown => Array.isArray(value) ? value.map(canonical) + : value && typeof value === "object" ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => [key, canonical(entry)])) : value; + const legacyHash = (value: unknown) => createHash("sha256").update(JSON.stringify(canonical(value))).digest("hex").slice(0, 16); + const { commandNotes: _notes, ...legacySkills } = result.result.sessionParams!.skills as Record; + const legacyFingerprint = buildSessionFingerprint({ acpxAgent: agent, agentCommand: "fixture-acp-client", cwd: remoteCwd, + mode: "persistent", permissionMode: "approve-all", nonInteractivePermissions: "deny", requestedModel: "", requestedThinkingEffort: "", fastMode: false, + remoteExecutionIdentity: result.result.sessionParams!.remoteExecution as Record, + additionalSourcesIdentity: [] as unknown as Record, skillsIdentity: legacySkills, skillPromptInstructions: "", + paperclipClaudeSettings: null, mcpServers: [], secretManifestHash: legacyHash([]), + adapterEnvHash: legacyHash(managedAiSessionFingerprintConfig({ env: config.env, managedAiConnection: config.managedAiConnection }, config.env.HOME)) }); + expect(legacyFingerprint).not.toBe(result.result.sessionParams!.configFingerprint); + const stored = sessionCodec.serialize({ ...result.result.sessionParams, configFingerprint: legacyFingerprint, + sessionKey: buildSessionKey({ companyId: "company-1", agentId: "agent-1", taskKey: "default" }, legacyFingerprint) }); + failTurn = false; + const upgraded = await runExecutor(configForTurn(1), { ...options, runId: "run-upgrade", + runtime: { sessionParams: sessionCodec.deserialize(JSON.parse(JSON.stringify(stored))) } }); + expect(upgraded.sessionInputs[0]?.resumeSessionId).toBeUndefined(); + expect(upgraded.result.resultJson?.sessionReset).toMatchObject({ code: "acpx_session_identity_changed" }); + await expect(fs.readFile(remoteMount, "utf8")).resolves.toBe("This path is not a directory on the controller."); + } } finally { vi.mocked(prepareAdapterExecutionTargetRuntime).mockReset().mockImplementation(actual.prepareAdapterExecutionTargetRuntime); vi.mocked(startAdapterExecutionTargetPaperclipBridge).mockReset().mockImplementation(actual.startAdapterExecutionTargetPaperclipBridge); diff --git a/packages/adapter-utils/src/acpx-engine/execute.ts b/packages/adapter-utils/src/acpx-engine/execute.ts index a88f1c172d5..6f0dc54eb4c 100644 --- a/packages/adapter-utils/src/acpx-engine/execute.ts +++ b/packages/adapter-utils/src/acpx-engine/execute.ts @@ -30,6 +30,7 @@ import { adapterExecutionTargetEnablesSandboxDuplexBridge, formatAdapterExecutionTimeoutErrorMessage, formatAdapterExecutionTimeoutStartLogLine, + ensureAdapterExecutionTargetLocalWorkspace, prepareAdapterExecutionTargetRuntime, readAdapterExecutionTarget, resolveAdapterExecutionTargetTimeout, @@ -75,7 +76,6 @@ import { asString, buildInvocationEnvForLogs, buildPaperclipEnv, - ensureAbsoluteDirectory, ensurePathInEnv, ensurePaperclipSkillSymlink, isForbiddenConfigEnvKey, @@ -2001,9 +2001,8 @@ async function buildRuntime(input: { }); // Step 1 — workspace.resolve: the workspace resolution/fallback chain closes // here on the awaited directory materialization. - await measureStartupStep(input.ctx, nowMs, "workspace.resolve", async () => { - if (!sshWorkspaceInPlace) await ensureAbsoluteDirectory(cwd, { createIfMissing: true }); - }, + await measureStartupStep(input.ctx, nowMs, "workspace.resolve", () => + ensureAdapterExecutionTargetLocalWorkspace(executionTarget, cwd), stepMetrics, ); @@ -2354,6 +2353,14 @@ async function buildRuntime(input: { : resolvedAdapterEnv, ), }; + if (useRemoteProcessSession && executionTarget?.kind === "remote" && executionTarget.transport === "ssh" && config.managedAiConnection && env.HOME) { + const managedHome = path.resolve(env.HOME); + const skills = Object.fromEntries(Object.entries(skillsIdentity).map(([key, value]) => [key, + typeof value === "string" && path.isAbsolute(value) && (value === managedHome || value.startsWith(managedHome + path.sep)) + ? path.join("", path.relative(managedHome, value)) : value, + ])); + fingerprintIdentity = { ...fingerprintIdentity, skillsIdentity: skills }; + } const taskKey = asString(input.ctx.runtime.taskKey, "") || wakeTaskId || workspaceId || "default"; const sshWorkspaceRunId = useRemoteProcessSession && executionTarget?.kind === "remote" && executionTarget.transport === "ssh" ? shortHash({ companyId: agent.companyId, agentId: agent.id, taskKey, fingerprintIdentity }) @@ -6007,7 +6014,15 @@ export function createAcpxEngineExecutor(deps: AcpxEngineExecutorOptions = {}) { }; }, }; - return await runAttempt(plan); + const result = await runAttempt(plan); + const previousSession = parseObject(ctx.runtime.sessionParams); + if (asString(previousSession.acpSessionId, "") && result.sessionParams?.configFingerprint + && previousSession.configFingerprint !== result.sessionParams.configFingerprint) { + return { ...result, resultJson: { ...result.resultJson, + sessionReset: { code: "acpx_session_identity_changed", reason: "The agent configuration or execution identity changed." }, + } }; + } + return result; } finally { // Record the in-memory evidence synchronously, but never let diagnostic // persistence hold the staging lease or delay the completed run's return. diff --git a/packages/adapter-utils/src/execution-target.test.ts b/packages/adapter-utils/src/execution-target.test.ts index 28f239e0f9d..d4da107bd46 100644 --- a/packages/adapter-utils/src/execution-target.test.ts +++ b/packages/adapter-utils/src/execution-target.test.ts @@ -1,5 +1,7 @@ +import os from "node:os"; +import path from "node:path"; import { randomUUID } from "node:crypto"; -import { access, readFile } from "node:fs/promises"; +import { access, mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; import { afterEach, describe, expect, it, vi } from "vitest"; import * as ssh from "./ssh.js"; import * as serverUtils from "./server-utils.js"; @@ -11,6 +13,7 @@ import { normalizeAdapterExecutionTargetSessionIdentity, ensureAdapterExecutionTargetRuntimeCommandInstalled, ensureAdapterExecutionTargetDirectory, + ensureAdapterExecutionTargetLocalWorkspace, ensureAdapterExecutionTargetCommandResolvable, isAdapterExecutionTargetUnavailableError, resolveAdapterExecutionTargetCwd, @@ -471,3 +474,21 @@ describe("GitHub launcher lifecycle", () => { expect(runner.execute).toHaveBeenCalledTimes(1); }); }); + + +describe("controller workspace preparation", () => { + it.each(["local", "copy", "in_place"] as const)("keeps %s workspace access on its owning filesystem", async mode => { + const root = await mkdtemp(path.join(os.tmpdir(), "paperclip-remote-path-")); + try { + const mount = path.join(root, "remote-filesystem"); + await writeFile(mount, "Not a controller directory"); + const cwd = path.join(mount, "workspace"); + const target = mode === "local" ? null : { ...sshExecutionTarget(), remoteCwd: cwd, + workspaceRealization: { mode, authoritativeRoot: cwd, pathAliases: [], outboundRestorePaths: [] } }; + const prepare = ensureAdapterExecutionTargetLocalWorkspace(target, cwd); + if (mode === "in_place") await expect(prepare).resolves.toBeUndefined(); + else await expect(prepare).rejects.toMatchObject({ code: "ENOTDIR" }); + expect(await readFile(mount, "utf8")).toBe("Not a controller directory"); + } finally { await rm(root, { recursive: true, force: true }); } + }); +}); diff --git a/packages/adapter-utils/src/execution-target.ts b/packages/adapter-utils/src/execution-target.ts index 077cb38b63d..bea4c856ed8 100644 --- a/packages/adapter-utils/src/execution-target.ts +++ b/packages/adapter-utils/src/execution-target.ts @@ -77,6 +77,7 @@ import { } from "./duplex-observability.js"; import { createSshCommandManagedRuntimeRunner, parseSshRemoteExecutionSpec, runSshCommand, shellQuote } from "./ssh.js"; import { + ensureAbsoluteDirectory, ensureCommandResolvable, resolveCommandForLogs, runChildProcess, @@ -1313,6 +1314,11 @@ export async function ensureAdapterExecutionTargetFile( ); } +export async function ensureAdapterExecutionTargetLocalWorkspace(target: AdapterExecutionTarget | null | undefined, cwd: string): Promise { + if (target?.kind === "remote" && target.workspaceRealization?.mode === "in_place") return; + await ensureAbsoluteDirectory(cwd, { createIfMissing: true }); +} + /** * Ensure a working directory exists (and is a directory) on the execution target. * @@ -1566,6 +1572,7 @@ export async function prepareAdapterExecutionTargetRuntime(input: { }; } + const syncWorkspace = input.syncWorkspace ?? target.workspaceRealization?.mode !== "in_place"; if (target.transport === "ssh") { const prepared = await prepareRemoteManagedRuntime({ spec: target.spec, @@ -1573,7 +1580,7 @@ export async function prepareAdapterExecutionTargetRuntime(input: { adapterKey: input.adapterKey, workspaceLocalDir: input.workspaceLocalDir, workspaceRemoteDir: input.workspaceRemoteDir, - syncWorkspace: input.syncWorkspace, + syncWorkspace, privateRuntime: input.privateRuntime, retainRuntime: input.retainRuntime, workspaceFileMode: input.workspaceFileMode, @@ -1613,7 +1620,7 @@ export async function prepareAdapterExecutionTargetRuntime(input: { workspaceLocalDir: input.workspaceLocalDir, workspaceRemoteDir: input.workspaceRemoteDir, runtimeRootDir: input.runtimeRootDir, - syncWorkspace: input.syncWorkspace, + syncWorkspace, workspaceInboundMode: input.workspaceInboundMode, workspaceSnapshotIsolation: input.workspaceSnapshotIsolation, workspaceGitIndexRefresh: input.workspaceGitIndexRefresh, diff --git a/packages/adapters/claude-local/src/server/execute.ts b/packages/adapters/claude-local/src/server/execute.ts index 278f61a04d0..67c1194edda 100644 --- a/packages/adapters/claude-local/src/server/execute.ts +++ b/packages/adapters/claude-local/src/server/execute.ts @@ -19,6 +19,7 @@ import { adapterExecutionTargetUsesPaperclipBridge, describeAdapterExecutionTarget, ensureAdapterExecutionTargetCommandResolvable, + ensureAdapterExecutionTargetLocalWorkspace, ensureAdapterExecutionTargetRuntimeCommandInstalled, prepareAdapterExecutionTargetRuntime, adapterExecutionTargetDuplexObservabilityRecorder, @@ -44,7 +45,6 @@ import { readPaperclipIssueWorkModeFromContext, joinPromptSections, buildInvocationEnvForLogs, - ensureAbsoluteDirectory, ensurePathInEnv, isForbiddenConfigEnvKey, isPaperclipRuntimeEnvKey, @@ -222,9 +222,7 @@ async function buildClaudeRuntimeConfig(input: ClaudeExecutionInput): Promise = { ...buildPaperclipEnv(agent, input.agentIdentity) }; diff --git a/packages/adapters/cursor-local/src/server/execute.ts b/packages/adapters/cursor-local/src/server/execute.ts index ad3430bf723..07736f782bf 100644 --- a/packages/adapters/cursor-local/src/server/execute.ts +++ b/packages/adapters/cursor-local/src/server/execute.ts @@ -16,6 +16,7 @@ import { adapterExecutionTargetUsesPaperclipBridge, describeAdapterExecutionTarget, ensureAdapterExecutionTargetCommandResolvable, + ensureAdapterExecutionTargetLocalWorkspace, ensureAdapterExecutionTargetRuntimeCommandInstalled, prepareAdapterExecutionTargetRuntime, adapterExecutionTargetDuplexObservabilityRecorder, @@ -36,7 +37,6 @@ import { buildPaperclipEnv, buildRuntimeToolsEnv, buildInvocationEnvForLogs, - ensureAbsoluteDirectory, ensurePaperclipSkillSymlink, ensurePathInEnv, refreshPaperclipWorkspaceEnvForExecution, @@ -228,7 +228,7 @@ export async function execute(ctx: AdapterExecutionContext): Promise { ).resolves.toMatchObject({ engine: "acp", explicit: true, unavailableReason: expect.stringContaining("Node") }); }); - it("reports unavailable ACP for non-sandbox remote auto runs", async () => { + it("reports unavailable ACP for SSH runs without a managed account", async () => { setNodeVersion("v24.11.0"); await expect( resolveGeminiExecutionEngineForRun({ @@ -335,7 +335,7 @@ describe("gemini_local ACP lane", () => { ).resolves.toMatchObject({ engine: "acp", explicit: false, - unavailableReason: expect.stringContaining("sandbox remote targets only"), + unavailableReason: expect.stringContaining("agent-managed SSH account"), }); }); diff --git a/packages/adapters/gemini-local/src/server/acp.ts b/packages/adapters/gemini-local/src/server/acp.ts index d5a06a1bef2..7712c0088cd 100644 --- a/packages/adapters/gemini-local/src/server/acp.ts +++ b/packages/adapters/gemini-local/src/server/acp.ts @@ -329,7 +329,7 @@ async function commandIsResolvable( token, target, resolveAdapterExecutionTargetCwd(target, asString(input?.config.cwd, ""), process.cwd()), - process.env, + target.transport === "ssh" ? { PATH: process.env.PATH } : {}, ); return true; } catch { @@ -360,11 +360,13 @@ async function geminiAcpUnavailableReason( executionTarget: input.executionTarget, legacyRemoteExecution: input.executionTransport?.remoteExecution, }); - if (target?.kind === "remote" && !sandboxTargetHasProcessSessionBridge(target)) { + const managedSsh = target?.kind === "remote" && target.transport === "ssh" + && target.spec.useHostAuth === false && Boolean(input.config.managedAiConnection); + if (target?.kind === "remote" && !sandboxTargetHasProcessSessionBridge(target) && !managedSsh) { if (target.transport === "sandbox") { return "Gemini ACP requires a bidirectional remote process target; this sandbox exposes only one-shot command execution."; } - return "Gemini ACP supports sandbox remote targets only; this run targets a non-sandbox remote environment."; + return "Gemini ACP requires an agent-managed SSH account; host authentication is supported by the CLI engine."; } if (!nodeVersionMeetsGeminiAcpMinimum()) { return `Node ${process.version} (${process.execPath}) does not satisfy Gemini ACP's Node >=${MIN_ACP_NODE_VERSION} prerequisite.`; diff --git a/packages/adapters/gemini-local/src/server/engine-availability.test.ts b/packages/adapters/gemini-local/src/server/engine-availability.test.ts index 3440f874f44..bc9f89ab1c9 100644 --- a/packages/adapters/gemini-local/src/server/engine-availability.test.ts +++ b/packages/adapters/gemini-local/src/server/engine-availability.test.ts @@ -3,6 +3,12 @@ import { resolveGeminiExecutionEngineForRun } from "./acp.js"; import { execute } from "./execute.js"; import { testEnvironment } from "./test.js"; +const remoteCommandProbe = vi.hoisted(() => vi.fn(async (..._args: unknown[]) => undefined)); +vi.mock("@paperclipai/adapter-utils/execution-target", async importOriginal => ({ + ...await importOriginal(), + ensureAdapterExecutionTargetCommandResolvable: remoteCommandProbe, +})); + const originalVersion = process.version; afterEach(() => Object.defineProperty(process, "version", { value: originalVersion })); @@ -42,3 +48,24 @@ describe("gemini engine availability", () => { expect(result.unavailableReason).toContain("not available"); }); }); + + +describe("managed SSH ACP selection", () => { + afterEach(() => remoteCommandProbe.mockReset().mockResolvedValue(undefined)); + it.each(["account", "host auth", "missing account", "missing command"])("checks the selected %s setup", async reason => { + Object.defineProperty(process, "version", { value: "v24.11.0" }); + const config = { managedAiConnection: reason === "missing account" ? undefined : { identity: "fixture-account" } }; + const target = { kind: "remote" as const, transport: "ssh" as const, remoteCwd: "/remote/workspace", + workspaceRealization: { mode: "in_place" as const, authoritativeRoot: "/remote/workspace", pathAliases: [], outboundRestorePaths: [] }, + spec: { useHostAuth: reason === "host auth", host: "ssh.example.test", port: 22, username: "fixture", + remoteCwd: "/remote/workspace", remoteWorkspacePath: "/remote/workspace", privateKey: null, knownHosts: null, strictHostKeyChecking: true } }; + if (reason === "missing command") remoteCommandProbe.mockRejectedValueOnce(new Error("missing command")); + const result = await resolveGeminiExecutionEngineForRun({ config, executionTarget: target }); + expect(result.engine).toBe("acp"); + if (reason === "account") { + expect(result.unavailableReason).toBeUndefined(); + expect(remoteCommandProbe).toHaveBeenCalledOnce(); + expect(remoteCommandProbe.mock.calls[0]![3]).toEqual({ PATH: process.env.PATH }); + } else expect(result.unavailableReason).toBeTruthy(); + }); +}); diff --git a/packages/adapters/gemini-local/src/server/execute.ts b/packages/adapters/gemini-local/src/server/execute.ts index 3a72696aec5..0200585f185 100644 --- a/packages/adapters/gemini-local/src/server/execute.ts +++ b/packages/adapters/gemini-local/src/server/execute.ts @@ -17,6 +17,7 @@ import { adapterExecutionTargetUsesPaperclipBridge, describeAdapterExecutionTarget, ensureAdapterExecutionTargetCommandResolvable, + ensureAdapterExecutionTargetLocalWorkspace, ensureAdapterExecutionTargetRuntimeCommandInstalled, prepareAdapterExecutionTargetRuntime, adapterExecutionTargetDuplexObservabilityRecorder, @@ -37,7 +38,6 @@ import { buildPaperclipEnv, buildRuntimeToolsEnv, buildInvocationEnvForLogs, - ensureAbsoluteDirectory, ensurePaperclipSkillSymlink, joinPromptSections, ensurePathInEnv, @@ -261,7 +261,7 @@ export async function execute(ctx: AdapterExecutionContext): Promise ({ +vi.mock("@paperclipai/adapter-utils/execution-target", async (importOriginal) => ({ + ...await importOriginal(), adapterExecutionTargetIsRemote: () => mocks.state.isRemote, adapterExecutionTargetRemoteCwd: (_target: unknown, cwd: string) => mocks.state.isRemote ? "/remote/workspace" : cwd, diff --git a/packages/adapters/grok-local/src/server/execute.ts b/packages/adapters/grok-local/src/server/execute.ts index fe750052de9..f6bab16ff10 100644 --- a/packages/adapters/grok-local/src/server/execute.ts +++ b/packages/adapters/grok-local/src/server/execute.ts @@ -3,9 +3,12 @@ import { withWorkspaceRestore } from "@paperclipai/adapter-utils/workspace-resto import { cancellableSandboxStartup } from "@paperclipai/adapter-utils/acpx-engine/startup-cancellation"; import fs from "node:fs/promises"; import path from "node:path"; +import os from "node:os"; +import { prepareGrokRemoteProjectAssets } from "./remote-project-assets.js"; import { fileURLToPath } from "node:url"; import type { AdapterExecutionContext, AdapterExecutionResult } from "@paperclipai/adapter-utils"; import { + type AdapterManagedRuntimeAsset, managedRemoteHomeEnvironment, adapterExecutionTargetIsRemote, adapterExecutionTargetRemoteCwd, @@ -13,6 +16,7 @@ import { adapterExecutionTargetSessionMatches, describeAdapterExecutionTarget, ensureAdapterExecutionTargetCommandResolvable, + ensureAdapterExecutionTargetLocalWorkspace, ensureAdapterExecutionTargetRuntimeCommandInstalled, overrideAdapterExecutionTargetRemoteCwd, prepareAdapterExecutionTargetRuntime, @@ -29,7 +33,6 @@ import { buildInvocationEnvForLogs, buildPaperclipEnv, buildRuntimeToolsEnv, - ensureAbsoluteDirectory, ensurePathInEnv, joinPromptSections, materializePaperclipSkillCopy, @@ -292,18 +295,21 @@ async function executeTurn(ctx: AdapterExecutionContext): Promise { if (projectAssetsDir) await fs.rm(projectAssetsDir, { recursive: true, force: true }); throw error; }); + let remoteProjectAssets: Awaited> | null = null; let restoreRemoteWorkspace: (() => Promise) | null = null; // Declared here (not inside the try) so the outer `finally` can remove it on // every exit path (teardown and setup failure alike), mirroring the Codex @@ -429,7 +435,9 @@ async function executeTurn(ctx: AdapterExecutionContext): Promise onLog("stdout", line), onRuntimeProgress: ctx.onRuntimeProgress, - assets: stagedGrokHomeDir + assets: projectAssetsDir || stagedGrokHomeDir ? [ + ...(projectAssetsDir ? [{ key: "project", localDir: projectAssetsDir, followSymlinks: false }] : []), + ...(stagedGrokHomeDir ? [ { key: "home", @@ -444,7 +452,7 @@ async function executeTurn(ctx: AdapterExecutionContext): Promise + restore: async ({ assetDir, readFile }: Parameters>[0]) => void (await copyBackGrokAuth({ readSandboxAuth: () => readFile(path.posix.join(assetDir, "auth.json")), hostHomeDir: hostGrokHome, @@ -453,10 +461,15 @@ async function executeTurn(ctx: AdapterExecutionContext): Promise undefined)), }, ] - : undefined, + : []), + ] : undefined, }); - restoreRemoteWorkspace = () => - preparedExecutionTargetRuntime.restoreWorkspace((line) => onLog("stdout", line)); + restoreRemoteWorkspace = async () => { + try { await remoteProjectAssets?.cleanup(); } + finally { await preparedExecutionTargetRuntime.restoreWorkspace((line) => onLog("stdout", line)); } + }; + if (projectAssetsDir) remoteProjectAssets = await prepareGrokRemoteProjectAssets({ runId, target: executionTarget!, + cwd: preparedExecutionTargetRuntime.workspaceRemoteDir ?? effectiveExecutionCwd, assets: preparedExecutionTargetRuntime.assetDirs.project! }); effectiveExecutionCwd = preparedExecutionTargetRuntime.workspaceRemoteDir ?? effectiveExecutionCwd; refreshPaperclipWorkspaceEnvForExecution({ env, @@ -564,7 +577,8 @@ async function executeTurn(ctx: AdapterExecutionContext): Promise { const fromExtraArgs = asStringArray(config.extraArgs); if (fromExtraArgs.length > 0) return fromExtraArgs; @@ -775,5 +789,6 @@ async function executeTurn(ctx: AdapterExecutionContext): Promise { + const root = await fs.mkdtemp(path.join(os.tmpdir(), "grok-project-assets-")); + try { + const cwd = path.join(root, "workspace"), assets = path.join(root, "assets"), outside = path.join(root, "outside"); + await fs.mkdir(cwd); await fs.mkdir(outside); + await fs.writeFile(path.join(outside, "keep.txt"), "outside"); + const stagedSkill = path.join(assets, ".claude/skills/selected"); + await fs.mkdir(stagedSkill, { recursive: true }); + await fs.writeFile(path.join(stagedSkill, "SKILL.md"), "selected skill"); + await fs.writeFile(path.join(assets, "Agents.md"), "agent instructions"); + if (scenario === "existing") { + await fs.mkdir(path.join(cwd, ".claude/skills/own"), { recursive: true }); + await fs.writeFile(path.join(cwd, ".claude/skills/own/keep.txt"), "user skill"); + } + if (scenario === "unsafe") await fs.symlink(outside, path.join(cwd, ".claude")); + const input = { runId: "fixture", target: { kind: "local" as const }, cwd, assets }; + if (scenario === "unsafe") { + await expect(prepareGrokRemoteProjectAssets(input)).rejects.toThrow("Could not prepare Grok SSH runtime assets"); + expect(await fs.readdir(outside)).toEqual(["keep.txt"]); + return; + } + const prepared = await prepareGrokRemoteProjectAssets(input); + expect(prepared.rulesFilePath).toBe(path.join(assets, "Agents.md")); + expect(await fs.readFile(path.join(cwd, ".claude/skills/selected/SKILL.md"), "utf8")).toBe("selected skill"); + if (scenario === "changed") { + await fs.rename(path.join(cwd, ".claude"), path.join(cwd, ".claude-original")); + await fs.symlink(outside, path.join(cwd, ".claude")); + await expect(prepared.cleanup()).rejects.toThrow("Could not prepare Grok SSH runtime assets"); + expect(await fs.readdir(outside)).toEqual(["keep.txt"]); + } else { + await fs.writeFile(path.join(cwd, ".claude/user.txt"), "user work"); + await prepared.cleanup(); + expect(await fs.readFile(path.join(cwd, ".claude/user.txt"), "utf8")).toBe("user work"); + await expect(fs.stat(path.join(cwd, ".claude/skills/selected"))).rejects.toMatchObject({ code: "ENOENT" }); + if (scenario === "existing") expect(await fs.readFile(path.join(cwd, ".claude/skills/own/keep.txt"), "utf8")).toBe("user skill"); + } + } finally { await fs.rm(root, { recursive: true, force: true }); } +}); diff --git a/packages/adapters/grok-local/src/server/remote-project-assets.ts b/packages/adapters/grok-local/src/server/remote-project-assets.ts new file mode 100644 index 00000000000..8e20f17c280 --- /dev/null +++ b/packages/adapters/grok-local/src/server/remote-project-assets.ts @@ -0,0 +1,61 @@ +import type { AdapterExecutionTarget } from "@paperclipai/adapter-utils/execution-target"; +import { runAdapterExecutionTargetShellCommand } from "@paperclipai/adapter-utils/execution-target"; +import { shellQuote } from "@paperclipai/adapter-utils/ssh"; + +const program = ` +const fs = require('fs'), path = require('path'); +const [operation, assets, cwd, encoded] = process.argv.slice(1); +const created = []; +const cleanup = entries => { for (const entry of [...entries].reverse()) { + const file = path.resolve(cwd, entry.path); + if (!file.startsWith(path.resolve(cwd) + path.sep) || !entry.path.startsWith('.claude')) throw Error('Invalid runtime asset path'); + try { + for (const relative of ['.claude', '.claude/skills']) { + const parent = path.join(cwd, relative); + if (file.startsWith(parent + path.sep) && fs.lstatSync(parent).isSymbolicLink()) throw Error('Unsafe runtime asset parent'); + } + if (entry.kind === 'skill') fs.rmSync(file, {recursive:true, force:true}); else fs.rmdirSync(file); + } + catch (error) { if (!['ENOENT', 'ENOTEMPTY'].includes(error.code)) throw error; } +} }; +if (operation === 'cleanup') { cleanup(JSON.parse(encoded)); process.exit(0); } +try { + const source = path.join(assets, '.claude', 'skills'); + if (fs.existsSync(source)) { + for (const relative of ['.claude', '.claude/skills']) { + const target = path.join(cwd, relative); + if (fs.existsSync(target)) { const st = fs.lstatSync(target); if (st.isSymbolicLink() || !st.isDirectory()) throw Error('Unsafe Grok skills directory'); } + else { fs.mkdirSync(target); created.push({path:relative,kind:'directory'}); } + } + for (const name of fs.readdirSync(source)) { + if (path.basename(name) !== name) throw Error('Invalid skill name'); + const relative = path.join('.claude', 'skills', name), target = path.join(cwd, relative); + if (fs.existsSync(target)) continue; + fs.mkdirSync(target); + created.push({path:relative,kind:'skill'}); + fs.cpSync(path.join(source,name),target,{recursive:true,force:false,errorOnExist:true}); + } + } + const rules = fs.existsSync(path.join(assets,'Agents.md')) ? path.join(assets,'Agents.md') + : !fs.existsSync(path.join(cwd,'Agents.md')) && fs.existsSync(path.join(cwd,'AGENTS.md')) ? path.join(cwd,'AGENTS.md') : null; + console.log(JSON.stringify({created,rules})); +} catch (error) { cleanup(created); throw error; } +`; + +export async function prepareGrokRemoteProjectAssets(input: { + runId: string; target: AdapterExecutionTarget; cwd: string; assets: string; +}): Promise<{ rulesFilePath: string | null; cleanup: () => Promise }> { + const execute = async (operation: string, entries: unknown[]) => { + const result = await runAdapterExecutionTargetShellCommand(input.runId, input.target, + ["node", "-e", program, operation, input.assets, input.cwd, JSON.stringify(entries)].map(shellQuote).join(" "), + { cwd: input.cwd, env: {}, timeoutSec: 15 }); + if (result.exitCode !== 0 || result.timedOut || result.signal) throw new Error("Could not prepare Grok SSH runtime assets"); + return result.stdout; + }; + const result = JSON.parse(await execute("stage", [])) as { created: Array<{ path: string; kind: string }>; rules: string | null }; + if (!Array.isArray(result.created) || result.created.some(entry => !entry || typeof entry !== "object" || typeof entry.path !== "string" || (entry.kind === "directory" ? ![".claude", ".claude/skills"].includes(entry.path) + : entry.kind !== "skill" || !/^\.claude\/skills\/[A-Za-z0-9][A-Za-z0-9._-]*$/.test(entry.path)))) throw new Error("Invalid Grok SSH runtime asset receipt"); + const allowedRules = [input.assets + "/Agents.md", input.cwd + "/AGENTS.md"]; + if (result.rules !== null && !allowedRules.includes(result.rules)) throw new Error("Invalid Grok SSH instructions path"); + return { rulesFilePath: result.rules, cleanup: async () => { await execute("cleanup", result.created); } }; +} diff --git a/packages/adapters/kimi-local/src/server/acp.ts b/packages/adapters/kimi-local/src/server/acp.ts index d1bbaa41d41..52c8ba4b30d 100644 --- a/packages/adapters/kimi-local/src/server/acp.ts +++ b/packages/adapters/kimi-local/src/server/acp.ts @@ -219,7 +219,7 @@ async function commandIsResolvable( token, target, resolveAdapterExecutionTargetCwd(target, asString(input?.config.cwd, ""), process.cwd()), - process.env, + target.transport === "ssh" ? { PATH: process.env.PATH } : {}, ); return true; } catch { @@ -250,11 +250,13 @@ async function kimiAcpUnavailableReason( executionTarget: input.executionTarget, legacyRemoteExecution: input.executionTransport?.remoteExecution, }); - if (target?.kind === "remote" && !sandboxTargetHasProcessSessionBridge(target)) { + const managedSsh = target?.kind === "remote" && target.transport === "ssh" + && target.spec.useHostAuth === false && Boolean(input.config.managedAiConnection); + if (target?.kind === "remote" && !sandboxTargetHasProcessSessionBridge(target) && !managedSsh) { if (target.transport === "sandbox") { return "Kimi ACP requires a bidirectional remote process target; this sandbox exposes only one-shot command execution."; } - return "Kimi ACP supports sandbox remote targets only; this run targets a non-sandbox remote environment."; + return "Kimi ACP requires an agent-managed SSH account; host authentication is supported by the CLI engine."; } if (!nodeVersionMeetsKimiAcpMinimum()) { return `Node ${process.version} (${process.execPath}) does not satisfy Kimi ACP's Node >=${MIN_ACP_NODE_VERSION} prerequisite.`; diff --git a/packages/adapters/kimi-local/src/server/engine-availability.test.ts b/packages/adapters/kimi-local/src/server/engine-availability.test.ts index 24685ed5c7d..e9fbbe645d8 100644 --- a/packages/adapters/kimi-local/src/server/engine-availability.test.ts +++ b/packages/adapters/kimi-local/src/server/engine-availability.test.ts @@ -3,6 +3,12 @@ import { resolveKimiExecutionEngineForRun } from "./acp.js"; import { execute } from "./execute.js"; import { testEnvironment } from "./test.js"; +const remoteCommandProbe = vi.hoisted(() => vi.fn(async (..._args: unknown[]) => undefined)); +vi.mock("@paperclipai/adapter-utils/execution-target", async importOriginal => ({ + ...await importOriginal(), + ensureAdapterExecutionTargetCommandResolvable: remoteCommandProbe, +})); + const originalVersion = process.version; afterEach(() => Object.defineProperty(process, "version", { value: originalVersion })); @@ -42,3 +48,24 @@ describe("kimi engine availability", () => { expect(result.unavailableReason).toContain("not available"); }); }); + + +describe("managed SSH ACP selection", () => { + afterEach(() => remoteCommandProbe.mockReset().mockResolvedValue(undefined)); + it.each(["account", "host auth", "missing account", "missing command"])("checks the selected %s setup", async reason => { + Object.defineProperty(process, "version", { value: "v24.11.0" }); + const config = { managedAiConnection: reason === "missing account" ? undefined : { identity: "fixture-account" } }; + const target = { kind: "remote" as const, transport: "ssh" as const, remoteCwd: "/remote/workspace", + workspaceRealization: { mode: "in_place" as const, authoritativeRoot: "/remote/workspace", pathAliases: [], outboundRestorePaths: [] }, + spec: { useHostAuth: reason === "host auth", host: "ssh.example.test", port: 22, username: "fixture", + remoteCwd: "/remote/workspace", remoteWorkspacePath: "/remote/workspace", privateKey: null, knownHosts: null, strictHostKeyChecking: true } }; + if (reason === "missing command") remoteCommandProbe.mockRejectedValueOnce(new Error("missing command")); + const result = await resolveKimiExecutionEngineForRun({ config, executionTarget: target }); + expect(result.engine).toBe("acp"); + if (reason === "account") { + expect(result.unavailableReason).toBeUndefined(); + expect(remoteCommandProbe).toHaveBeenCalledOnce(); + expect(remoteCommandProbe.mock.calls[0]![3]).toEqual({ PATH: process.env.PATH }); + } else expect(result.unavailableReason).toBeTruthy(); + }); +}); diff --git a/packages/adapters/kimi-local/src/server/execute.test.ts b/packages/adapters/kimi-local/src/server/execute.test.ts index 93ea4dc2b15..ec96fb00e49 100644 --- a/packages/adapters/kimi-local/src/server/execute.test.ts +++ b/packages/adapters/kimi-local/src/server/execute.test.ts @@ -14,7 +14,8 @@ const prepareRuntimeMock = vi.hoisted(() => vi.fn(async () => ({ const resolveCommandForLogsMock = vi.hoisted(() => vi.fn(async () => "kimi")); const runProcessMock = vi.hoisted(() => vi.fn()); -vi.mock("@paperclipai/adapter-utils/execution-target", () => ({ +vi.mock("@paperclipai/adapter-utils/execution-target", async (importOriginal) => ({ + ...await importOriginal(), adapterExecutionTargetIsRemote: () => false, adapterExecutionTargetRemoteCwd: (_target: unknown, cwd: string) => cwd, overrideAdapterExecutionTargetRemoteCwd: (target: unknown, _cwd: string) => target, diff --git a/packages/adapters/kimi-local/src/server/execute.ts b/packages/adapters/kimi-local/src/server/execute.ts index 207a2f05ef1..3cee96c084f 100644 --- a/packages/adapters/kimi-local/src/server/execute.ts +++ b/packages/adapters/kimi-local/src/server/execute.ts @@ -15,6 +15,7 @@ import { adapterExecutionTargetUsesPaperclipBridge, describeAdapterExecutionTarget, ensureAdapterExecutionTargetCommandResolvable, + ensureAdapterExecutionTargetLocalWorkspace, ensureAdapterExecutionTargetRuntimeCommandInstalled, prepareAdapterExecutionTargetRuntime, readAdapterExecutionTarget, @@ -30,7 +31,6 @@ import { buildPaperclipEnv, buildRuntimeToolsEnv, buildInvocationEnvForLogs, - ensureAbsoluteDirectory, joinPromptSections, ensurePathInEnv, refreshPaperclipWorkspaceEnvForExecution, @@ -239,7 +239,7 @@ export async function execute(ctx: AdapterExecutionContext): Promise assertEphemeralNativeRuntime(false)).not.toThrow(); }); -it.each(["claude_local", "codex_local"])("admits %s over SSH only with durable remote workspace authority", adapterType => { +it.each(["claude_local", "codex_local", "cursor", "gemini_local", "grok_local", "kimi_local", "opencode_local", "pi_local"])("admits %s over SSH only with durable remote workspace authority", adapterType => { vi.stubEnv("PAPERCLIP_EPHEMERAL_SERVER", "true"); vi.stubEnv("DATABASE_URL", config.databaseUrl); vi.stubEnv("PAPERCLIP_STORAGE_PROVIDER", "s3"); diff --git a/server/src/__tests__/ssh-adapter-session-codecs.test.ts b/server/src/__tests__/ssh-adapter-session-codecs.test.ts new file mode 100644 index 00000000000..11d2a4d9968 --- /dev/null +++ b/server/src/__tests__/ssh-adapter-session-codecs.test.ts @@ -0,0 +1,22 @@ +import { describe, expect, it } from "vitest"; +import { adapterExecutionTargetSessionIdentity, adapterExecutionTargetSessionMatches, type AdapterSshExecutionTarget } from "@paperclipai/adapter-utils/execution-target"; +import { getServerAdapter } from "../adapters/index.js"; + +describe("SSH adapter saved session identity", () => { + it.each(["claude_local", "codex_local", "cursor", "gemini_local", "grok_local", "kimi_local", "opencode_local", "pi_local"])("keeps %s connection guards through persistence", adapterType => { + const target: AdapterSshExecutionTarget = { kind: "remote", transport: "ssh", remoteCwd: "/remote/task", + spec: { host: "ssh.example.test", port: 22, username: "fixture", remoteCwd: "/remote/task", remoteWorkspacePath: "/remote", + useHostAuth: false, privateKey: null, knownHosts: null, strictHostKeyChecking: true } }; + const identity = adapterExecutionTargetSessionIdentity(target)!; + const codec = getServerAdapter(adapterType).sessionCodec!; + const stored = codec.serialize({ sessionId: "session-fixture", cwd: target.remoteCwd, + remoteExecution: { ...identity, privateKey: "credential-canary", tailscaleSocket: "/private/socket" } }); + const restored = codec.deserialize(JSON.parse(JSON.stringify(stored)))!; + expect(restored.remoteExecution).toEqual(identity); + expect(adapterExecutionTargetSessionMatches(restored.remoteExecution, target)).toBe(true); + expect(adapterExecutionTargetSessionMatches(restored.remoteExecution, { ...target, spec: { ...target.spec, host: "other.example.test" } })).toBe(false); + const legacy = codec.deserialize({ sessionId: "session-fixture", cwd: target.remoteCwd })!; + expect(legacy.remoteExecution).toBeUndefined(); + expect(adapterExecutionTargetSessionMatches(legacy.remoteExecution, target)).toBe(false); + }); +}); diff --git a/server/src/services/heartbeat/runtime-selection.test.ts b/server/src/services/heartbeat/runtime-selection.test.ts index e5a7e4ad989..dcb96533ada 100644 --- a/server/src/services/heartbeat/runtime-selection.test.ts +++ b/server/src/services/heartbeat/runtime-selection.test.ts @@ -942,7 +942,7 @@ describe.skipIf(!support.supported)("heartbeat runtime selection boundary", () = expect(prepareNativeWorkspaceSync).not.toHaveBeenCalled(); }); - it.each(["claude_local", "codex_local"])("keeps %s SSH runtime and its durable workspace receipt on a volume-free server", async adapterType => { + it.each(["claude_local", "codex_local", "cursor", "gemini_local", "grok_local", "kimi_local", "opencode_local", "pi_local"])("keeps %s SSH runtime and its durable workspace receipt on a volume-free server", async adapterType => { const { input, run, agent, issue } = await fixture(adapterType); vi.stubEnv("PAPERCLIP_EPHEMERAL_SERVER", "true"); const environmentId = randomUUID(), leaseId = randomUUID(), workspaceId = randomUUID(); diff --git a/server/src/services/heartbeat/workspace-preparation.test.ts b/server/src/services/heartbeat/workspace-preparation.test.ts index 220a8d06c89..f3966a264a6 100644 --- a/server/src/services/heartbeat/workspace-preparation.test.ts +++ b/server/src/services/heartbeat/workspace-preparation.test.ts @@ -590,7 +590,7 @@ describe.skipIf(!support.supported && !externalDatabaseUrl)("heartbeat workspace expect(await db.select().from(executionWorkspaces)).toHaveLength(0); }); - it.each(["claude_local", "codex_local"])("reserves remote storage for volume-free %s SSH tasks before acquiring the machine", async adapterType => { + it.each(["claude_local", "codex_local", "cursor", "gemini_local", "grok_local", "kimi_local", "opencode_local", "pi_local"])("reserves remote storage for volume-free %s SSH tasks before acquiring the machine", async adapterType => { const { input, issue, envOrchestrator } = await fixture(); configureRemotePersistence(); process.env.PAPERCLIP_EPHEMERAL_SERVER = "true"; diff --git a/server/src/services/remote-workspaces.ts b/server/src/services/remote-workspaces.ts index 23e9f3c6bbc..0c39bcc599f 100644 --- a/server/src/services/remote-workspaces.ts +++ b/server/src/services/remote-workspaces.ts @@ -14,7 +14,7 @@ import { companies, environmentLeases, executionWorkspaces, executionWorkspaceSnapshots, heartbeatRuns, issues, workspaceOperations, type Db, } from "@paperclipai/db"; import { - readRemoteWorkspaceAuthority, remoteWorkspaceSourceSchema, + adapterSupportsRemoteManagedEnvironments, readRemoteWorkspaceAuthority, remoteWorkspaceSourceSchema, type RemoteWorkspaceAuthority, type RemoteWorkspaceRunReference, type RemoteWorkspaceSource, type EnvironmentLease, } from "@paperclipai/shared"; @@ -95,7 +95,7 @@ function sameExportLocation(value: unknown, location: NonNullable { + const harnesses = [ + { adapterType: "claude_local", provider: "anthropic", authEnv: "ANTHROPIC_API_KEY", model: "claude-sonnet-4-6", engines: ["cli", "acp"] }, + { adapterType: "codex_local", provider: "openai", authEnv: "OPENAI_API_KEY", model: "gpt-5.4-mini", engines: ["cli", "acp"] }, + { adapterType: "gemini_local", provider: "google", authEnv: "GEMINI_API_KEY", model: "gemini-2.5-pro", engines: ["cli", "acp"] }, + { adapterType: "grok_local", provider: "xai", authEnv: "XAI_API_KEY", model: "grok-4", engines: ["cli"] }, + { adapterType: "opencode_local", provider: "openrouter", authEnv: "OPENROUTER_API_KEY", model: "openrouter/openai/gpt-4.1", engines: ["cli"] }, + { adapterType: "pi_local", provider: "openai", authEnv: "OPENAI_API_KEY", model: "openai/gpt-5.4-mini", engines: ["cli"] }, + { adapterType: "cursor", provider: null, authEnv: "PAPERCLIP_SSH_FIXTURE_AUTH", model: "auto", engines: ["cli"] }, + { adapterType: "kimi_local", provider: null, authEnv: "PAPERCLIP_SSH_FIXTURE_AUTH", model: "kimi-k2.5", engines: ["cli"] }, + ]; + const runs = harnesses.flatMap(harness => harness.engines.map(engine => ({ ...harness, engine, key: `${harness.adapterType}-${engine}` }))); + it.each(runs)("runs an assigned $key task through heartbeat over SSH", async ({ adapterType, provider, authEnv, model, engine, key }) => { vi.stubEnv("PAPERCLIP_EPHEMERAL_SERVER", "true"); vi.stubEnv("PAPERCLIP_STORAGE_PROVIDER", "s3"); vi.stubEnv("PAPERCLIP_AGENT_JWT_SECRET", "synthetic-cloud-ssh-jwt-secret"); vi.stubEnv("AWS_EC2_METADATA_DISABLED", "true"); - const storage = { ...createStorageService(createLocalDiskStorageProvider(path.join(root, `heartbeat-${engine}-objects`))), provider: "s3" as const }; + const storage = { ...createStorageService(createLocalDiskStorageProvider(path.join(root, `heartbeat-${key}-objects`))), provider: "s3" as const }; vi.spyOn(storageModule, "getStorageService").mockReturnValue(storage); vi.spyOn(runLogModule, "getRunLogStore").mockReturnValue(objectLogFixture()); const companyId = randomUUID(), agentId = randomUUID(), issueId = randomUUID(), userId = `ssh-user-${randomUUID()}`; await db.insert(authUsers).values({ id: userId, name: "SSH test user", email: `${userId}@example.test`, createdAt: new Date(), updatedAt: new Date() }); - await db.insert(companies).values({ id: companyId, name: "Cloud SSH task", issuePrefix: engine === "cli" ? "HCLI" : "HACP", defaultResponsibleUserId: userId }); + await db.insert(companies).values({ id: companyId, name: "Cloud SSH task", issuePrefix: `SSH${runs.findIndex(run => run.key === key)}`, defaultResponsibleUserId: userId }); await db.insert(companyMemberships).values({ companyId, principalId: userId, principalType: "user", status: "active", membershipRole: "member" }); - const account = await aiConnectionService(db).save(companyId, userId, { provider: "anthropic", method: "api_key", - ownership: "personal", name: "Selected test account", apiKey: "synthetic-selected-ssh-key", agentIds: [], allAgents: true }, "synthetic-selected-ssh-key"); + const account = provider ? await aiConnectionService(db).save(companyId, userId, { provider: provider as AiProvider, method: "api_key", + ownership: "personal", name: "Selected test account", apiKey: "synthetic-selected-ssh-key", agentIds: [], allAgents: true }, "synthetic-selected-ssh-key") : null; const config = await buildSshEnvLabFixtureConfig(sshd!); - const command = path.join(root, `fake-claude-${engine}`); + const command = path.join(root, `fake-${key}`); await writeFile(command, `#!${process.execPath} if (process.argv.includes('--version')) { console.log('2.1.0'); process.exit(0); } -if (process.env.ANTHROPIC_API_KEY !== 'synthetic-selected-ssh-key') process.exit(91); +if (process.argv.includes('models')) { console.log(${JSON.stringify(model)}); process.exit(0); } +if (process.env[${JSON.stringify(authEnv)}] !== 'synthetic-selected-ssh-key') process.exit(91); const fs = require('fs'), path = require('path'); -const history = path.join(process.env.CLAUDE_CONFIG_DIR, 'projects', 'fixture-history'); +const harness = ${JSON.stringify(adapterType)}; +const history = harness === 'claude_local' ? path.join(process.env.CLAUDE_CONFIG_DIR, 'projects', 'fixture-history') : path.join(process.cwd(), '.fixture-provider-history'); const runTask = (resumed) => { if (resumed && !fs.existsSync(history)) throw Error('Missing provider conversation history'); fs.mkdirSync(path.dirname(history), {recursive:true}); fs.writeFileSync(history, 'provider conversation state'); @@ -246,26 +260,63 @@ if (process.argv.includes('--acp-fixture')) { } catch (error) { send({jsonrpc:'2.0',id:request.id,error:{code:-32603,message:error.message}}); } }); } else { - runTask(process.argv.includes('--resume')); - console.log(JSON.stringify({type:'result',subtype:'success',is_error:false,result:'Created hello_world.txt',session_id:'12345678-1234-4abc-9def-123456789012',total_cost_usd:0,usage:{input_tokens:1,output_tokens:1}})); + const id = '12345678-1234-4abc-9def-123456789012'; + const resumed = ['--resume', 'resume', '-r'].some(arg => process.argv.includes(arg)) + || (harness === 'opencode_local' && process.argv.includes('--session')) + || (harness === 'pi_local' && fs.existsSync('hello_world.txt')); + runTask(resumed); + const emit = value => console.log(JSON.stringify(value)); + if (harness === 'codex_local') { + emit({type:'thread.started',thread_id:id}); emit({type:'item.completed',item:{type:'agent_message',text:'Created hello_world.txt'}}); + emit({type:'turn.completed',usage:{input_tokens:1,output_tokens:1}}); + } else if (harness === 'gemini_local') { + emit({type:'system',subtype:'init',session_id:id}); emit({type:'message',role:'assistant',content:'Created hello_world.txt'}); + emit({type:'result',status:'success',session_id:id,stats:{input_tokens:1,output_tokens:1}}); + } else if (harness === 'kimi_local') { + emit({role:'assistant',content:'Created hello_world.txt'}); emit({role:'meta',type:'session.resume_hint',session_id:id}); + } else if (harness === 'opencode_local') { + emit({type:'text',sessionID:id,part:{text:'Created hello_world.txt'}}); + emit({type:'step_finish',sessionID:id,part:{cost:0,tokens:{input:1,output:1,cache:{read:0,write:0}}}}); + } else if (harness === 'pi_local') { + emit({type:'turn_end',message:{role:'assistant',content:'Created hello_world.txt',usage:{input:1,output:1}},toolResults:[]}); + } else if (harness === 'grok_local') { + emit({type:'message',data:'Created hello_world.txt'}); emit({type:'end',sessionId:id,stopReason:'EndTurn',usage:{input_tokens:1,output_tokens:1}}); + } else emit({type:'result',subtype:'success',is_error:false,result:'Created hello_world.txt',session_id:id,total_cost_usd:0,usage:{input_tokens:1,output_tokens:1}}); } `, { mode: 0o700 }); - const storedConfig = await normalizeEnvironmentConfigForPersistence({ db, companyId, environmentName: `Heartbeat SSH ${engine}`, - driver: "ssh", secretProvider: "local_encrypted", config: { ...config, useHostAuth: false } }); - const [environment] = await db.insert(environments).values({ driver: "ssh", name: `Heartbeat SSH ${engine}`, config: storedConfig }).returning(); + const storedConfig = await normalizeEnvironmentConfigForPersistence({ db, companyId, environmentName: `Heartbeat SSH ${key}`, + driver: "ssh", secretProvider: "local_encrypted", config: { ...config, useHostAuth: !provider } }); + const [environment] = await db.insert(environments).values({ driver: "ssh", name: `Heartbeat SSH ${key}`, config: storedConfig }).returning(); await secretService(db).replaceSecretRefsForInstanceTarget({ targetType: "environment", targetId: environment.id }, await collectEnvironmentSecretRefs({ db, environment: { id: environment.id, driver: "ssh", config: storedConfig } })); const adapterConfig = { command, ...(engine === "cli" ? { engine: "cli" } : { agentCommand: `${shellQuote(command)} --acp-fixture`, acpWarmHandleIdleMs: 60_000 }), - model: "claude-sonnet-4-6", timeoutSec: 20 }; - await db.insert(agents).values({ id: agentId, companyId, name: "Claude SSH task", adapterType: "claude_local", status: "idle", + model, timeoutSec: 20, ...(!provider ? { env: { [authEnv]: "synthetic-selected-ssh-key" } } : {}) }; + await db.insert(agents).values({ id: agentId, companyId, name: `${adapterType} SSH task`, adapterType, status: "idle", defaultEnvironmentId: environment.id, adapterConfig, - runtimeConfig: { aiConnection: { provider: "anthropic", method: "api_key", mode: "delegated", connectionId: account.connectionId, grantId: account.grantId } } }); + runtimeConfig: account ? { aiConnection: { provider, method: "api_key", mode: "delegated", connectionId: account.connectionId, grantId: account.grantId } } : {} }); await db.insert(issues).values({ id: issueId, companyId, title: "Create hello_world.txt", status: "todo", assigneeAgentId: agentId, responsibleUserId: userId, issueNumber: 1 }); - const adapter = getServerAdapter("claude_local"), execute = adapter.execute; - expect(adapter.type).toBe("claude_local"); + const adapter = getServerAdapter(adapterType), execute = adapter.execute; + expect(adapter.type).toBe(adapterType); const executing = vi.spyOn(adapter, "execute").mockImplementation(async input => { - const result = await execute(input); + const target = input.executionTarget; + expect(target).toMatchObject({ kind: "remote", transport: "ssh", workspaceRealization: { mode: "in_place" } }); + const remoteCwd = target!.kind === "remote" ? target!.remoteCwd : ""; + const localAccesses: string[] = []; + const guards = (["stat", "mkdir"] as const).map(method => { + const original = fs[method].bind(fs); + return vi.spyOn(fs, method).mockImplementation(((candidate: unknown, ...args: unknown[]) => { + if (typeof candidate === "string" && (candidate === remoteCwd || candidate.startsWith(remoteCwd + path.sep))) { + localAccesses.push(method); + return Promise.reject(Object.assign(new Error("SSH workspace is unavailable on the controller"), { code: "EACCES" })); + } + return (original as (...args: unknown[]) => unknown)(candidate, ...args); + }) as never); + }); + let result; + try { result = await execute(input); } + finally { for (const guard of guards) guard.mockRestore(); } + expect(localAccesses).toEqual([]); // The synthetic provider stands in for the final task update too. if (result.exitCode === 0) await db.update(issues).set({ status: "in_review" }).where(eq(issues.id, issueId)); return result;