diff --git a/doc/connections/AI-CONNECTIONS.md b/doc/connections/AI-CONNECTIONS.md index eee20ba3f81..8ba64f3f933 100644 --- a/doc/connections/AI-CONNECTIONS.md +++ b/doc/connections/AI-CONNECTIONS.md @@ -456,7 +456,9 @@ Credential-bearing launch commands travel through SSH stdin instead of SSH process arguments. The existing account-specific refresh merge runs before per-turn directories are removed, including after provider or setup failure. Environment tests use the selected account and remove their temporary homes -after probing. A disconnected target can prevent remote cleanup; the run reports +after probing. Managed Codex probes copy refreshed credentials to that account's +local home before cleanup, even when the provider request fails. The merge rejects +credentials from another account. A copyback failure fails the probe. A disconnected target can prevent remote cleanup; the run reports the resulting failure rather than silently selecting another account. Codex CLI runs in an in-place SSH workspace keep conversation files and native @@ -477,7 +479,11 @@ ACP SSH sessions use the existing remote process bridge and session reuse lifecycle. A compatible session can retain its private remote home; workspace sync and credential refresh run at turn teardown, and the session disposal hook removes the home on retirement. Workspace identity includes the company, agent, -task and execution fingerprint. Older managed SSH ACP sessions used a different +task and execution fingerprint. The fingerprint normalizes temporary managed-home +paths and credential refreshes against the stable account session identity. +Switching accounts or changing other adapter environment values starts a fresh +conversation. The launch still receives the current credentials. +Older managed SSH ACP sessions used a different working-directory identity and start fresh after this change. Native runner session identities and sandbox staging are unchanged. diff --git a/packages/adapter-utils/src/acpx-engine/execute.test.ts b/packages/adapter-utils/src/acpx-engine/execute.test.ts index 1502b016a0d..8ac015aa8c0 100644 --- a/packages/adapter-utils/src/acpx-engine/execute.test.ts +++ b/packages/adapter-utils/src/acpx-engine/execute.test.ts @@ -4561,7 +4561,12 @@ describe("ACPX engine remote managed-home seam (PR 2: per-adapter home seed)", ( it.each(["turn", "bridge"])("stages the configured agent account for SSH, resumes it, and copies back before disposal after a %s failure", async failure => { const { root, stateDir, localCwd, remoteCwd } = await setupRemoteSandbox(); - const home = path.join(root, "selected-account");await fs.mkdir(home); + const homes = await Promise.all(["first", "second", "third"].map(async name => { + const home = path.join(root, `selected-account-${name}`); + await fs.mkdir(path.join(home, "provider"), { recursive: true }); + return home; + })); + const home = path.join(homes[0]!, "provider"); const workspace = path.posix.join(remoteCwd, ".paperclip-runtime/runs/run-1/workspace"); const runtimeRootDir = path.posix.join(workspace, ".paperclip-runtime/custom"); const executionTarget = { kind: "remote", transport: "ssh", remoteCwd, spec: { useHostAuth: false, host: "ssh.example.test", port: 22, username: "agent", remoteCwd, remoteWorkspacePath: remoteCwd, privateKey: null, knownHosts: null, strictHostKeyChecking: true } }; @@ -4569,18 +4574,21 @@ describe("ACPX engine remote managed-home seam (PR 2: per-adapter home seed)", ( const stopControl = vi.fn(async () => {}), stopProcess = vi.fn(async () => {}); const stagedRuntimes: NonNullable = new Map(); const seam = vi.fn(async (input: Parameters>[0]) => { - const stagedRuntime = await input.stage([{ key: "home", localDir: home }]); + const stagedRuntime = await input.stage([{ key: "home", localDir: input.env.CODEX_HOME! }]); input.env.CODEX_HOME = stagedRuntime.assetDirs.home!; return { stagedRuntime }; }); const actual = await vi.importActual("@paperclipai/adapter-utils/execution-target"); - vi.mocked(prepareAdapterExecutionTargetRuntime).mockResolvedValueOnce({ target: executionTarget as never, workspaceRemoteDir: workspace, runtimeRootDir, + vi.mocked(prepareAdapterExecutionTargetRuntime).mockResolvedValue({ target: executionTarget as never, workspaceRemoteDir: workspace, runtimeRootDir, assetDirs: { home: path.posix.join(runtimeRootDir, "home") }, additionalSourceDirs: {}, additionalSourceFailures: [], workspaceSyncSnapshot: null, restoreWorkspace: restore, disposeRuntime: dispose }); vi.mocked(startAdapterExecutionTargetPaperclipBridge).mockResolvedValue({ env: { PAPERCLIP_API_URL: "http://127.0.0.1:3210", PAPERCLIP_API_KEY: "bridge-fixture" }, stop: stopControl }); vi.mocked(startAdapterExecutionTargetProcessSessionBridge).mockResolvedValue({ agentCommand: "/fixture/agent-proxy.cjs", stop: stopProcess }); try { - const config = { agent: "custom", agentCommand: "node ./fake-acp.js", stateDir, cwd: localCwd, - managedAiConnection: { identity: "selected-agent-account" }, env: { CODEX_HOME: home, HOME: home }, mode: "persistent" }; + const configForTurn = (turn: number) => ({ agent: "custom", agentCommand: "node ./fake-acp.js", stateDir, cwd: localCwd, + managedAiConnection: { identity: `credential-revision-${turn}`, sessionIdentity: "selected-agent-account" }, + env: { CODEX_HOME: path.join(homes[turn]!, "provider"), HOME: homes[turn]!, XDG_CONFIG_HOME: path.join(homes[turn]!, "config"), + XDG_DATA_HOME: path.join(homes[turn]!, "data"), OPENAI_API_KEY: `fixture-token-${turn}`, USER_OPTION: "kept" }, mode: "persistent" }); + const config = configForTurn(0); let failTurn = false; const options = { authToken: "run-fixture", executionTarget, prepareRemoteManagedHome: seam, stagedRuntimes, onStartTurn: () => { if (failTurn) throw new Error("fixture SSH turn failed"); } }; @@ -4597,16 +4605,20 @@ describe("ACPX engine remote managed-home seam (PR 2: per-adapter home seed)", ( expect(stopControl).toHaveBeenCalledOnce(); expect(stopProcess).toHaveBeenCalledOnce(); expect(dispose).not.toHaveBeenCalled(); - const resumed = await runExecutor(config, { ...options, runId: "run-2", runtime: { sessionParams: result.result.sessionParams } }); + const resumed = await runExecutor(configForTurn(1), { ...options, runId: "run-2", runtime: { sessionParams: result.result.sessionParams } }); expect(resumed.sessionInputs[0]?.cwd).toBe(result.sessionInputs[0]?.cwd); + expect(resumed.sessionInputs[0]?.resumeSessionId).toBe(result.result.sessionId); + const resumeBridge = vi.mocked(startAdapterExecutionTargetProcessSessionBridge).mock.calls.at(-1)![0]; + const resumedEnv = typeof resumeBridge.env === "function" ? await resumeBridge.env() : resumeBridge.env; + expect(resumedEnv.OPENAI_API_KEY).toBe("fixture-token-1"); expect(seam).toHaveBeenCalledOnce(); expect(restore).toHaveBeenCalledTimes(2); if (failure === "bridge") { vi.mocked(startAdapterExecutionTargetProcessSessionBridge).mockRejectedValueOnce(new Error("fixture SSH bridge unavailable")); - await expect(runExecutor(config, { ...options, runId: "run-3", runtime: { sessionParams: resumed.result.sessionParams } })).rejects.toThrow("fixture SSH bridge unavailable"); + await expect(runExecutor(configForTurn(2), { ...options, runId: "run-3", runtime: { sessionParams: resumed.result.sessionParams } })).rejects.toThrow("fixture SSH bridge unavailable"); } else { failTurn = true; - await runExecutor(config, { ...options, runId: "run-3", expectedExitCode: 1, runtime: { sessionParams: resumed.result.sessionParams } }); + await runExecutor(configForTurn(2), { ...options, runId: "run-3", expectedExitCode: 1, runtime: { sessionParams: resumed.result.sessionParams } }); } expect(restore).toHaveBeenCalledTimes(3); expect(stopControl.mock.invocationCallOrder[2]).toBeLessThan(restore.mock.invocationCallOrder[2]!); @@ -4615,6 +4627,18 @@ describe("ACPX engine remote managed-home seam (PR 2: per-adapter home seed)", ( expect(stopControl).toHaveBeenCalledTimes(3); expect(stopProcess).toHaveBeenCalledTimes(failure === "bridge" ? 2 : 3); expect(stagedRuntimes.size).toBe(0); + failTurn = true; + const changed = configForTurn(0); + if (failure === "turn") changed.managedAiConnection.sessionIdentity = "different-agent-account"; + else changed.env.USER_OPTION = "changed"; + const reset = await runExecutor(changed, { ...options, runId: "run-4", expectedExitCode: 1, + runtime: { sessionParams: resumed.result.sessionParams } }); + expect(reset.sessionInputs[0]?.cwd).not.toBe(result.sessionInputs[0]?.cwd); + expect(reset.sessionInputs[0]?.resumeSessionId).not.toBe(result.result.sessionId); + expect(seam).toHaveBeenCalledTimes(2); + expect(restore).toHaveBeenCalledTimes(4); + expect(dispose).toHaveBeenCalledTimes(2); + expect(stagedRuntimes.size).toBe(0); } 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 259777d5a0f..77b316a84cb 100644 --- a/packages/adapter-utils/src/acpx-engine/execute.ts +++ b/packages/adapter-utils/src/acpx-engine/execute.ts @@ -1,3 +1,4 @@ +import { managedAiSessionFingerprintConfig } from "../managed-ai-runtime-env.js"; import { createWorkspaceRestoreTeardown } from "../workspace-restore-teardown.js"; import { isOpenRouterUrl, openRouterClaudeHeaders } from "@paperclipai/shared/openrouter-attribution"; import { prepareAcpxCodexObservabilityHome } from "../codex-observability-home.js"; @@ -2331,7 +2332,16 @@ async function buildRuntime(input: { // that sources the latest env. secretManifestHash alone misses plain-value // edits and same-version secret rotations. Per-wake runtime vars never enter // resolvedAdapterEnv, so they don't churn the fingerprint every heartbeat. - adapterEnvHash: shortHash(resolvedAdapterEnv), + // Managed SSH identity uses the selected account's stable session identity; + // temporary credential homes and token refreshes affect only the launch env. + adapterEnvHash: shortHash( + useRemoteProcessSession && executionTarget?.kind === "remote" && executionTarget.transport === "ssh" + ? managedAiSessionFingerprintConfig( + { env: resolvedAdapterEnv, managedAiConnection: config.managedAiConnection }, + asString(resolvedAdapterEnv.HOME, "") || undefined, + ) + : resolvedAdapterEnv, + ), }; const taskKey = asString(input.ctx.runtime.taskKey, "") || wakeTaskId || workspaceId || "default"; const sshWorkspaceRunId = useRemoteProcessSession && executionTarget?.kind === "remote" && executionTarget.transport === "ssh" diff --git a/packages/adapter-utils/src/managed-ai-runtime-env.ts b/packages/adapter-utils/src/managed-ai-runtime-env.ts new file mode 100644 index 00000000000..e994ea9aca4 --- /dev/null +++ b/packages/adapter-utils/src/managed-ai-runtime-env.ts @@ -0,0 +1,48 @@ +import path from "node:path"; + +export function managedAiHomeEnvironment(home: string): Record { + const providerHome = path.join(home, "provider"); + return { + HOME: home, + XDG_CONFIG_HOME: path.join(home, "config"), + XDG_DATA_HOME: path.join(home, "data"), + CODEX_HOME: providerHome, + GROK_HOME: providerHome, + CLAUDE_CONFIG_DIR: providerHome, + HERMES_HOME: providerHome, + }; +} + +/** Only the server-created credential home is volatile; retain all other config. */ +export function managedAiSessionFingerprintConfig( + config: Record, + managedHome: string | undefined, +): Record { + if (!managedHome) return config; + const env = { ...(config.env as Record | undefined) }; + const stable = managedAiHomeEnvironment(""); + for (const [key, value] of Object.entries(managedAiHomeEnvironment(managedHome))) { + if (env[key] === value) env[key] = stable[key]; + } + if (env.GEMINI_HOME === path.join(managedHome, "provider")) { + env.GEMINI_HOME = path.join("", "provider"); + } + const managed = config.managedAiConnection as Record | undefined; + if (managed?.sessionIdentity) { + for (const key of [ + "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "CLAUDE_CODE_OAUTH_TOKEN", + "OPENAI_API_KEY", "CODEX_API_KEY", "OPENROUTER_API_KEY", "XAI_API_KEY", + "GROK_API_KEY", "GEMINI_API_KEY", "GOOGLE_API_KEY", + "OPENCODE_AUTH_JSON", "OPENCODE_CONFIG_CONTENT", + ]) { + if (env[key]) env[key] = ""; + } + } + return { + ...config, + env, + ...(managed?.sessionIdentity + ? { managedAiConnection: { ...managed, identity: managed.sessionIdentity } } + : {}), + }; +} diff --git a/packages/adapters/codex-local/src/server/test.remote.test.ts b/packages/adapters/codex-local/src/server/test.remote.test.ts index 4cab7a6d0cb..048701c9291 100644 --- a/packages/adapters/codex-local/src/server/test.remote.test.ts +++ b/packages/adapters/codex-local/src/server/test.remote.test.ts @@ -2,7 +2,7 @@ import fs from "node:fs/promises"; import os from "node:os"; import path from "node:path"; import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; -import type { AdapterExecutionTarget } from "@paperclipai/adapter-utils/execution-target"; +import type { AdapterManagedRuntimeAsset, AdapterExecutionTarget } from "@paperclipai/adapter-utils/execution-target"; const { ensureAdapterExecutionTargetDirectory, @@ -52,7 +52,7 @@ const { } return fallbackCwd; }), - prepareAdapterExecutionTargetRuntime: vi.fn(async (input: { assets?: Array<{ key: string; localDir: string }> }) => { + prepareAdapterExecutionTargetRuntime: vi.fn(async (input: { assets?: AdapterManagedRuntimeAsset[] }) => { const homeAsset = input?.assets?.find((asset) => asset.key === "home"); if (homeAsset) { capturedHomeAssetFiles.value = (await fs.readdir(homeAsset.localDir)).sort(); @@ -176,7 +176,7 @@ describe("codex remote environment diagnostics", () => { workspaceLocalDir: string; target?: { remoteCwd?: string }; workspaceRemoteDir?: string; - assets?: Array<{ key: string; localDir: string }>; + assets?: AdapterManagedRuntimeAsset[]; }, ]>; const runtimeInput = runtimeCalls[0]?.[0]; @@ -512,6 +512,65 @@ describe("codex remote environment diagnostics", () => { last_refresh: lastRefresh, }); + it.each(["success", "provider failure", "foreign account", "copyback failure"])( + "preserves managed SSH probe credentials through %s before cleanup", + async outcome => { + const selectedHome = await makeScratchDir("paperclip-test-selected-codex-"); + const original = subscriptionAuth("acct-selected", "original", "2020-01-01T00:00:00Z"); + const refreshed = subscriptionAuth(outcome === "foreign account" ? "acct-other" : "acct-selected", "refreshed", "2020-01-02T00:00:00Z"); + const shared = subscriptionAuth("acct-shared", "untouched", "2020-01-01T00:00:00Z"); + const authPath = path.join(selectedHome, "auth.json"); + await fs.writeFile(authPath, original); + await fs.writeFile(path.join(process.env.CODEX_HOME!, "auth.json"), shared); + const basePrepare = prepareAdapterExecutionTargetRuntime.getMockImplementation()!; + let stagingDir = ""; + let assetRestoreCalls = 0; + prepareAdapterExecutionTargetRuntime.mockImplementationOnce(async input => { + const prepared = await basePrepare(input); + const home = input.assets!.find(asset => asset.key === "home")!; + stagingDir = home.localDir; + return { ...prepared, restoreWorkspace: vi.fn(async () => { + try { + expect(home.restore).toBeTypeOf("function"); + await home.restore!({ assetDir: prepared.assetDirs.home, + readFile: async remotePath => { + expect(remotePath).toBe(path.posix.join(prepared.assetDirs.home, "auth.json")); + assetRestoreCalls += 1; + await expect(fs.stat(stagingDir)).resolves.toBeDefined(); + if (outcome === "copyback failure") throw new Error("fixture credential read failed"); + return Buffer.from(refreshed); + }, + } as Parameters>[0]); + expect(await fs.readFile(authPath, "utf8")).toBe(outcome === "foreign account" ? original : refreshed); + } finally { + await restoreWorkspace(); + } + }) }; + }); + if (outcome === "provider failure") { + const success = await runAdapterExecutionTargetProcess.getMockImplementation()!(); + runAdapterExecutionTargetProcess.mockResolvedValueOnce({ ...success, exitCode: 1, stdout: "", stderr: "fixture provider unavailable" }); + } + const probe = testEnvironment({ companyId: "company-1", adapterType: "codex_local", + config: { engine: "cli", command: "codex", managedAiConnection: { identity: "selected-account" }, env: { CODEX_HOME: selectedHome } }, + executionTarget: { kind: "remote", transport: "ssh", remoteCwd: "/remote/workspace", + spec: { host: "ssh.example.test", port: 22, username: "agent", privateKey: null, knownHosts: null, + strictHostKeyChecking: true, remoteCwd: "/remote/workspace", remoteWorkspacePath: "/remote/workspace", useHostAuth: false } }, + }); + if (outcome === "copyback failure") await expect(probe).rejects.toThrow("fixture credential read failed"); + else { + const result = await probe; + expect(result.status).toBe(outcome === "provider failure" ? "fail" : "pass"); + expect(JSON.stringify(result)).not.toContain("synthetic-"); + } + expect(assetRestoreCalls).toBe(1); + expect(restoreWorkspace).toHaveBeenCalledOnce(); + await expect(fs.stat(stagingDir)).rejects.toMatchObject({ code: "ENOENT" }); + expect(await fs.readFile(path.join(process.env.CODEX_HOME!, "auth.json"), "utf8")).toBe(shared); + expect(await fs.readFile(authPath, "utf8")).toBe(["foreign account", "copyback failure"].includes(outcome) ? original : refreshed); + }, + ); + function sandboxTarget(): AdapterExecutionTarget { return { kind: "remote", diff --git a/packages/adapters/codex-local/src/server/test.ts b/packages/adapters/codex-local/src/server/test.ts index 6fdea1e2122..f8936c41b16 100644 --- a/packages/adapters/codex-local/src/server/test.ts +++ b/packages/adapters/codex-local/src/server/test.ts @@ -22,6 +22,7 @@ import { import fs from "node:fs/promises"; import path from "node:path"; import os from "node:os"; +import { copyBackCodexAuth } from "./codex-auth-copyback.js"; import { parseCodexJsonl } from "./parse.js"; import { SANDBOX_INSTALL_COMMAND } from "../index.js"; import { codexHomeDir, readCodexAuthInfo } from "./quota.js"; @@ -103,12 +104,17 @@ async function prepareCodexHelloProbe(input: { let probeHomeLocalDir: string | null = null; const cleanup = async () => { - await preparedRuntime?.restoreWorkspace().catch(() => {}); - if (preparedRuntimeWorkspaceLocalDir) { - await fs.rm(preparedRuntimeWorkspaceLocalDir, { recursive: true, force: true }).catch(() => {}); - } - if (probeHomeLocalDir) { - await fs.rm(probeHomeLocalDir, { recursive: true, force: true }).catch(() => {}); + try { + await preparedRuntime?.restoreWorkspace(); + } catch (error) { + if (input.managedAiConnection) throw error; + } finally { + if (preparedRuntimeWorkspaceLocalDir) { + await fs.rm(preparedRuntimeWorkspaceLocalDir, { recursive: true, force: true }).catch(() => {}); + } + if (probeHomeLocalDir) { + await fs.rm(probeHomeLocalDir, { recursive: true, force: true }).catch(() => {}); + } } }; @@ -207,6 +213,15 @@ async function prepareCodexHelloProbe(input: { key: "home", localDir: probeHomeLocalDir, followSymlinks: true, + restore: input.managedAiConnection + ? async ({ assetDir, readFile }) => { + await copyBackCodexAuth({ + readSandboxAuth: () => readFile(path.posix.join(assetDir, "auth.json")), + hostAuthPath: path.join(effectiveHome, "auth.json"), + log: async () => {}, + }); + } + : undefined, }, ], }); diff --git a/server/src/services/ai-connection-runtime.ts b/server/src/services/ai-connection-runtime.ts index ade2d0e0f53..03ccb040d50 100644 --- a/server/src/services/ai-connection-runtime.ts +++ b/server/src/services/ai-connection-runtime.ts @@ -1,3 +1,5 @@ +import { managedAiHomeEnvironment } from "@paperclipai/adapter-utils/managed-ai-runtime-env"; +export { managedAiSessionFingerprintConfig } from "@paperclipai/adapter-utils/managed-ai-runtime-env"; import { environmentTaskResultSchema } from "@paperclipai/plugin-sdk"; import type { ManagedAiCredentialWritebackBinding } from "./managed-ai-credential-writeback.js"; import { OPENROUTER_ATTRIBUTION_HEADERS, openRouterClaudeHeaders } from "@paperclipai/shared/openrouter-attribution"; @@ -208,40 +210,6 @@ done`, } } -function managedAiHomeEnvironment(home: string): Record { - const providerHome = path.join(home, "provider"); - return { - HOME: home, - XDG_CONFIG_HOME: path.join(home, "config"), - XDG_DATA_HOME: path.join(home, "data"), - CODEX_HOME: providerHome, - GROK_HOME: providerHome, - CLAUDE_CONFIG_DIR: providerHome, - HERMES_HOME: providerHome, - }; -} - -/** Only the server-created credential home is volatile; retain all other config. */ -export function managedAiSessionFingerprintConfig( - config: Record, - managedHome: string | undefined, -): Record { - if (!managedHome) return config; - const env = { ...(config.env as Record | undefined) }; - const stable = managedAiHomeEnvironment(""); - for (const [key, value] of Object.entries(managedAiHomeEnvironment(managedHome))) { - if (env[key] === value) env[key] = stable[key]; - } - if (env.GEMINI_HOME === path.join(managedHome, "provider")) env.GEMINI_HOME = path.join("", "provider"); - const managed = config.managedAiConnection as Record | undefined; - if (managed?.sessionIdentity) { - for (const key of ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "CLAUDE_CODE_OAUTH_TOKEN", "OPENAI_API_KEY", "CODEX_API_KEY", "OPENROUTER_API_KEY", "XAI_API_KEY", "GROK_API_KEY", "GEMINI_API_KEY", "GOOGLE_API_KEY", "OPENCODE_AUTH_JSON", "OPENCODE_CONFIG_CONTENT"]) { - if (env[key]) env[key] = ""; - } - } - return { ...config, env, ...(managed?.sessionIdentity ? { managedAiConnection: { ...managed, identity: managed.sessionIdentity } } : {}) }; -} - export async function prepareManagedAiRuntime( db: Db, input: {