@tickernelz/paperclip-pro-adapter-utils 2026.1006.0 → 2026.1006.2

package/dist/execution-target.js

@@ -9,7 +9,7 @@ import { githubLauncherSource } from "./github-launcher.js";
 import { prepareCommandManagedRuntime, } from "./command-managed-runtime.js";
 import { buildRemoteExecutionSessionIdentity, prepareRemoteManagedRuntime, remoteExecutionSessionMatches, } from "./remote-managed-runtime.js";
 export { resolveReferencedSourceIgnore } from "./sandbox-managed-runtime.js";
-import { createCommandManagedSandboxCallbackBridgeQueueClient, createSandboxCallbackBridgeAsset, createSandboxCallbackBridgeToken, DEFAULT_SANDBOX_CALLBACK_BRIDGE_MAX_BODY_BYTES, HTTP2_SANDBOX_CALLBACK_BRIDGE_ROUTE_ALLOWLIST, SANDBOX_CALLBACK_BRIDGE_HTTP2_MODE, sandboxCallbackBridgeDirectories, startSandboxCallbackBridgeServer, startSandboxCallbackBridgeWorker, syncRemoteTextFileWithHashSkip, syncSandboxCallbackBridgeEntrypoint, } from "./sandbox-callback-bridge.js";
+import { createCommandManagedSandboxCallbackBridgeQueueClient, createSandboxCallbackBridgeAsset, createSandboxCallbackBridgeToken, DEFAULT_SANDBOX_CALLBACK_BRIDGE_MAX_BODY_BYTES, HTTP2_SANDBOX_CALLBACK_BRIDGE_ROUTE_ALLOWLIST, runSandboxBridgeControlCommand, SANDBOX_CALLBACK_BRIDGE_HTTP2_MODE, sandboxCallbackBridgeDirectories, startSandboxCallbackBridgeServer, startSandboxCallbackBridgeWorker, syncRemoteTextFileWithHashSkip, syncSandboxCallbackBridgeEntrypoint, } from "./sandbox-callback-bridge.js";
 import { createHttp2BridgeServer, BridgeProcessCapacityError, } from "./http2-bridge-server.js";
 import { createSandboxRunLogTailFactory, } from "./sandbox-run-log-stream.js";
 import { DEFAULT_DUPLEX_BROKER_BUDGETS, DUPLEX_CHANNEL_LOST_ERROR_CODE, isSafeBridgeMethod, } from "./bridge-transport-contract.js";
@@ -34,13 +34,9 @@ export function postedIssueCommentLogMarker(method, requestPath, status, body) {
     }
 }
 export { sanitizeRemoteExecutionEnv } from "./remote-execution-env.js";
-// 4-hour wall-clock backstop for sandbox-backed adapter runs. This is a
-// last-resort kill switch, not the primary hang detector: genuinely hung runs
-// are caught much earlier by the adapters' output-inactivity monitors (e.g.
-// codex-local's 7-minute monitor). The value intentionally matches the
-// recovery watchdog's ACTIVE_RUN_OUTPUT_CRITICAL_THRESHOLD_MS (4h) in
-// server/src/services/recovery/service.ts so healthy long runs are never
-// killed by the adapter before the watchdog would even consider them stuck.
+// Four-hour wall-clock backstop for sandbox-backed adapter runs. Keep this
+// execution limit independent of the earlier informational silence warnings
+// and the short deadlines for bridge control operations.
 export const DEFAULT_REMOTE_SANDBOX_ADAPTER_TIMEOUT_SEC = 14_400;
 function parseObject(value) {
     return value && typeof value === "object" && !Array.isArray(value)
@@ -434,6 +430,8 @@ export async function runAdapterExecutionTargetProcess(runId, target, command, a
             // after the clean process completion cannot latch a false mid-run loss. A
             // control channel that died before this clean completion still fails the
             // run closed.
+            if (!result.timedOut && typeof result.exitCode === "number" && Number.isInteger(result.exitCode) && result.exitCode >= 0)
+                options.onProcessStopped?.();
             const settled = applyRunDispositionSeam(result, options.settleRunDisposition);
             if (runLogTail) {
                 await runLogTail.finish({ stdout: result.stdout, stderr: result.stderr });
@@ -450,7 +448,7 @@ export async function runAdapterExecutionTargetProcess(runId, target, command, a
     const env = target?.kind === "remote" && target.transport === "ssh"
         ? sanitizeRemoteExecutionEnv(options.env)
         : options.env;
-    return await runChildProcess(runId, command, args, {
+    const result = await runChildProcess(runId, command, args, {
         cwd: options.cwd,
         env,
         stdin: options.stdin,
@@ -463,6 +461,13 @@ export async function runAdapterExecutionTargetProcess(runId, target, command, a
         localProcessSandbox: target?.kind === "local" || !target ? options.localProcessSandbox : null,
         remoteExecution: adapterExecutionTargetToRemoteSpec(target),
     });
+    // Closing an SSH client on timeout/disconnect does not prove the remote
+    // provider exited. SSH status 255 is transport failure, never a stop receipt.
+    if (!target || target.kind === "local" ||
+        (!result.timedOut && !result.signal && result.exitCode !== null && result.exitCode >= 0 && result.exitCode < 255)) {
+        options.onProcessStopped?.();
+    }
+    return result;
 }
 export async function runAdapterExecutionTargetShellCommand(runId, target, command, options) {
     const onLog = options.onLog ?? (async () => { });
@@ -849,6 +854,8 @@ export async function prepareAdapterExecutionTargetRuntime(input) {
             workspaceLocalDir: input.workspaceLocalDir,
             workspaceRemoteDir: input.workspaceRemoteDir,
             syncWorkspace: input.syncWorkspace,
+            workspaceFileMode: input.workspaceFileMode,
+            workspaceExclude: input.workspaceExclude,
             assets: input.assets,
             additionalSources: input.additionalSources,
             onProgress: input.onProgress,
@@ -886,6 +893,7 @@ export async function prepareAdapterExecutionTargetRuntime(input) {
         workspaceBaseline: input.workspaceBaseline,
         workspaceGitSnapshot: input.workspaceGitSnapshot,
         workspaceExclude: input.workspaceExclude,
+        workspaceFileMode: input.workspaceFileMode,
         preserveAbsentOnRestore: input.preserveAbsentOnRestore,
         assets: input.assets,
         additionalSources: input.additionalSources,
@@ -903,6 +911,7 @@ export async function prepareAdapterExecutionTargetRuntime(input) {
         additionalSourceDirs: prepared.additionalSourceDirs,
         additionalSourceFailures: prepared.additionalSourceFailures,
         workspaceSyncSnapshot: prepared.workspaceSyncSnapshot,
+        cleanupWorkspaceSnapshot: prepared.cleanupWorkspaceSnapshot,
         restoreWorkspace: prepared.restoreWorkspace,
     };
 }
@@ -1283,6 +1292,11 @@ export async function startAdapterExecutionTargetProcessSessionBridge(input) {
     }
     const target = input.target;
     const onLog = input.onLog ?? (async () => { });
+    // Failure diagnostics are best effort: stalled or failed run-log persistence
+    // must not prevent sending shutdown or removing the bridge's session files.
+    const logFailureWithoutWaiting = (message) => {
+        void Promise.resolve().then(() => onLog("stderr", message)).catch(() => undefined);
+    };
     const runner = requireSandboxRunner(target);
     // Run one unit of run-time work under its named wrapper span when a span
     // runner is injected. Without a runner, run the work under the current run
@@ -1347,7 +1361,7 @@ export async function startAdapterExecutionTargetProcessSessionBridge(input) {
     else {
         const payloadPath = path.posix.join(sessionDir, "command.b64");
         const runPayloadSetup = async (script) => {
-            const result = await runner.execute({
+            const result = await runSandboxBridgeControlCommand(runner, {
                 command: shellCommand,
                 args: shellCommandArgs(script),
                 cwd: target.remoteCwd,
@@ -1376,7 +1390,7 @@ export async function startAdapterExecutionTargetProcessSessionBridge(input) {
     // as one foreground session command further down instead, so skip this.
     if (!streamOutput) {
         await onLog("stdout", `[paperclip] Starting ACP process session bridge in sandbox (${target.providerKey ?? "provider"}).\n`);
-        const startResult = await runner.execute({
+        const startResult = await runSandboxBridgeControlCommand(runner, {
             command: shellCommand,
             args: shellCommandArgs([
                 `mkdir -p ${shellQuote(stdinDir)} ${shellQuote(eventsDir)}`,
@@ -1421,6 +1435,28 @@ export async function startAdapterExecutionTargetProcessSessionBridge(input) {
     // a big earlier chunk, so the wrapper reads the stdin bytes out of order and
     // corrupts a large prompt on the stdin path.
     let stdinWriteChain = Promise.resolve();
+    let stdinDeliveryFailed = false;
+    const writeStdinFile = async (filePath, body) => {
+        // Retry the same sequence, never the ACP request or the tool itself. Each
+        // upload uses private temporary paths, and the wrapper drops sequences it
+        // already consumed when a provider loses the final rename's response.
+        for (let attempt = 1;; attempt += 1) {
+            try {
+                await client.writeTextFile(filePath, body);
+                return;
+            }
+            catch (error) {
+                // Plugin RPC preserves provider messages but not HTTP error classes.
+                // Match the Daytona SDK and Cloudflare bridge's gateway diagnostics
+                // exactly; shell failures and auth errors must still fail immediately.
+                const gatewayFailure = error instanceof Error && (/^Request failed with status code (502|503|504)$/.test(error.message) ||
+                    /^Cloudflare sandbox bridge request failed with HTTP (502|503|504)\.$/.test(error.message));
+                if (!gatewayFailure || attempt >= 3)
+                    throw error;
+                await new Promise((resolve) => setTimeout(resolve, attempt * 250));
+            }
+        }
+    };
     let pollTimer = null;
     const pendingRemoteEvents = [];
     const token = createSandboxCallbackBridgeToken(18);
@@ -1547,15 +1583,24 @@ export async function startAdapterExecutionTargetProcessSessionBridge(input) {
                     // Chain this write after the previous one, so the atomic rename for
                     // file N finishes before the write for file N+1 starts. Keep the
                     // per-message `sandbox.agentSession.sendInput` span inside the chain.
-                    const write = stdinWriteChain.then(() => runRuntimeWork(AGENT_SESSION_SEND_INPUT_SPAN, () => client.writeTextFile(filePath, jsonLine(stdinPayload))));
-                    // The next message chains after this write on success or failure, so a
-                    // failed write never blocks the chain. This mirrors the wrapper
-                    // `writeChain` pattern for its event files.
-                    stdinWriteChain = write.then(() => undefined, () => undefined);
-                    // Keep the failure behavior: send one error line, then destroy the socket.
-                    write.catch((error) => {
-                        nextSocket.write(jsonLine({ type: "error", message: error instanceof Error ? error.message : String(error) }));
-                        nextSocket.destroy();
+                    stdinWriteChain = stdinWriteChain.then(async () => {
+                        if (stdinDeliveryFailed)
+                            return;
+                        try {
+                            await runRuntimeWork(AGENT_SESSION_SEND_INPUT_SPAN, () => writeStdinFile(filePath, jsonLine(stdinPayload)));
+                        }
+                        catch {
+                            stdinDeliveryFailed = true;
+                            stopping = true;
+                            const message = "ACP process session input delivery failed.";
+                            // Flush the diagnostic before closing; destroy() can discard it
+                            // and leave only ACP's generic connection_close error. Do not
+                            // expose provider error text, which may contain a command payload.
+                            nextSocket.end(jsonLine({ type: "error", message }));
+                            // stop() awaits this input chain before sending shutdown. Run-log
+                            // persistence must not hold teardown open when it stalls or fails.
+                            logFailureWithoutWaiting(`[paperclip] ${message}\n`);
+                        }
                     });
                 }
             }
@@ -1818,7 +1863,7 @@ export async function startAdapterExecutionTargetProcessSessionBridge(input) {
             ]);
             stopReadingForShutdownAck = true;
             if (!acknowledgedInTime) {
-                await onLog("stderr", `[paperclip] ACP process session wrapper did not acknowledge shutdown within ${DEFAULT_PROCESS_SESSION_SHUTDOWN_WAIT_MS}ms; removing the session directory anyway.\n`).catch(() => undefined);
+                logFailureWithoutWaiting(`[paperclip] ACP process session wrapper did not acknowledge shutdown within ${DEFAULT_PROCESS_SESSION_SHUTDOWN_WAIT_MS}ms; removing the session directory anyway.\n`);
             }
             // Unconditional: this removal runs whether or not the wrapper
             // acknowledged, and whether or not any event (real or forged) arrived
@@ -2246,6 +2291,14 @@ async function pollStdin() {
     for (const name of entries) {
       if (shuttingDown) break;
       const entrySeq = Number.parseInt(name, 10);
+      const file = path.posix.join(stdinDir, name);
+      // A successful publication can be retried after its provider response
+      // was lost, even after we consumed it. Never send those bytes twice or
+      // move the expected sequence backwards. This also handles late uploads.
+      if (Number.isFinite(entrySeq) && entrySeq < stdinExpectedSeq) {
+        await fs.rm(file, { force: true }).catch(() => undefined);
+        continue;
+      }
       // Hold the send order when an earlier file has not appeared. Do not consume
       // this later file: wait for the missing file on a later cycle, bounded by
       // the retry budget. After the budget, fail loud and advance past the gap,
@@ -2264,7 +2317,6 @@ async function pollStdin() {
         stdinGapRetries = 0;
         stdinExpectedSeq = entrySeq;
       }
-      const file = path.posix.join(stdinDir, name);
       let message;
       try {
         // Hardening (I3): open with O_NOFOLLOW where the platform defines it,