@ai-sdk/harness-claude-code 1.0.80 → 1.0.82

package/dist/index.js

@@ -8,12 +8,15 @@ import {
 } from "@ai-sdk/harness";
 import {
   classifyDiskLog,
+  experimental_createBridgeUserMessageSubmitter,
   createBridgeErrorHandler,
   createBridgeStartupError,
   drainBridgeProcessStream,
   forwardBridgeProcessStream,
+  getRestrictedSandboxSession,
   markBridgeStarting,
   maskSandboxCredentials,
+  resolveSandboxDefaultWorkingDirectory,
   resolveSandboxHomeDir,
   SandboxChannel,
   shellQuote,
@@ -263,7 +266,7 @@ var inboundMessageSchema = z.discriminatedUnion("type", [
 ]);
 
 // src/version.ts
-var VERSION = true ? "1.0.80" : "0.0.0-test";
+var VERSION = true ? "1.0.82" : "0.0.0-test";
 
 // src/claude-code-harness.ts
 var CLAUDE_CODE_CLIENT_APP = `ai-sdk/harness-claude-code/${VERSION}`;
@@ -889,13 +892,30 @@ function createClaudeCode(settings = {}) {
     getBootstrap: getClaudeCodeBootstrap,
     doStart: async (startOpts) => {
       const sandboxSession = startOpts.sandboxSession;
+      const toolSafeSandboxSession = getRestrictedSandboxSession(sandboxSession);
+      const sandboxId = "id" in sandboxSession ? sandboxSession.id : void 0;
+      validateBasicSandboxSettings({
+        sandboxSession,
+        port: settings.port,
+        portEndpoint: settings.portEndpoint
+      });
+      if (settings.mintBridgeToken != null && sandboxId == null) {
+        throw new HarnessCapabilityUnsupportedError({
+          harnessId: "claude-code",
+          message: "The Claude Code harness cannot use `mintBridgeToken` with a sandbox session that does not expose an id."
+        });
+      }
+      const defaultWorkingDirectory = await resolveSandboxDefaultWorkingDirectory({
+        sandboxSession,
+        abortSignal: startOpts.abortSignal
+      });
       const authenticationMode = resolveClaudeCodeAuthenticationMode(
         settings.auth
       );
       const resolvedAuthEnvironment = resolveClaudeCodeEnv(settings.auth);
       let authEnv = resolvedAuthEnvironment;
       let sandboxTurnEnvironment = settings.env;
-      if (sandboxSession.addRequestTransformations != null) {
+      if ("addRequestTransformations" in sandboxSession && sandboxSession.addRequestTransformations != null) {
         const requestTransformations = createClaudeCodeRequestTransformations(
           {
             ...resolvedAuthEnvironment,
@@ -919,10 +939,8 @@ function createClaudeCode(settings = {}) {
       } else {
         warnCredentialBrokeringUnavailable();
       }
-      const session = sandboxSession.restricted();
-      const sandboxId = sandboxSession.id;
       const bootstrapDir = posix.resolve(
-        sandboxSession.defaultWorkingDirectory,
+        defaultWorkingDirectory,
         CLAUDE_CODE_BOOTSTRAP_DIR
       );
       const lifecycleState = startOpts.continueFrom ?? startOpts.resumeFrom;
@@ -930,7 +948,7 @@ function createClaudeCode(settings = {}) {
       const isContinue = startOpts.continueFrom != null;
       const coords = isResume ? lifecycleState?.data?.bridge : void 0;
       const workDir = startOpts.sessionWorkDir;
-      const sessionDataDir = `${sandboxSession.defaultWorkingDirectory}/.agent-runs/${startOpts.sessionId}`;
+      const sessionDataDir = `${defaultWorkingDirectory}/.agent-runs/${startOpts.sessionId}`;
       const bridgeStateDir = `${sessionDataDir}/bridge`;
       const timeoutMs = settings.startupTimeoutMs ?? 12e4;
       const report = startOpts.observability?.report;
@@ -944,14 +962,22 @@ function createClaudeCode(settings = {}) {
         harnessId: "claude-code",
         sessionId: startOpts.sessionId
       });
+      let supportsUserMessageResponses = false;
       const buildConnect = (endpoint2) => async () => {
-        return openBridgeWebSocket({ endpoint: endpoint2, timeoutMs });
+        return openBridgeWebSocket({
+          endpoint: endpoint2,
+          timeoutMs,
+          onHello: (supportsResponses) => {
+            supportsUserMessageResponses = supportsResponses;
+          }
+        });
       };
       if (coords) {
         try {
-          const endpoint2 = await sandboxSession.getPortEndpoint({
-            port: coords.port,
-            protocol: "ws"
+          const endpoint2 = await resolveBridgeEndpoint({
+            sandboxSession,
+            override: settings.portEndpoint,
+            port: coords.port
           });
           const attachEndpoint = withBridgeToken({
             endpoint: endpoint2,
@@ -987,7 +1013,8 @@ function createClaudeCode(settings = {}) {
             permissionMode: startOpts.permissionMode,
             builtinToolFiltering: startOpts.builtinToolFiltering,
             skills: startOpts.skills ?? [],
-            mcpServers: settings.mcpServers
+            mcpServers: settings.mcpServers,
+            supportsUserMessageResponses: () => supportsUserMessageResponses
           });
         } catch {
         }
@@ -995,7 +1022,7 @@ function createClaudeCode(settings = {}) {
       let respawnStrategy = isResume ? "rerun" : void 0;
       if (coords && isContinue) {
         const logRaw = await Promise.resolve(
-          session.readTextFile({
+          toolSafeSandboxSession.readTextFile({
             path: `${bridgeStateDir}/event-log.ndjson`,
             abortSignal: startOpts.abortSignal
           })
@@ -1005,10 +1032,13 @@ function createClaudeCode(settings = {}) {
         }
       }
       const sandboxHomeDir = startOpts.skills && startOpts.skills.length > 0 ? await resolveSandboxHomeDir({
-        sandbox: session,
+        sandbox: toolSafeSandboxSession,
         abortSignal: startOpts.abortSignal
       }) : void 0;
-      const port = resolveBridgePort(sandboxSession, settings.port);
+      const port = resolveBridgePort({
+        sandboxSession,
+        override: settings.port
+      });
       const token = settings.mintBridgeToken == null ? randomBytes(32).toString("hex") : settings.mintBridgeToken(sandboxId);
       const env = {
         ...authEnv,
@@ -1025,7 +1055,7 @@ function createClaudeCode(settings = {}) {
         ...respawnStrategy === "replay" ? { BRIDGE_REPLAY_FROM_DISK: "1" } : {}
       };
       if (respawnStrategy === void 0) {
-        await session.run({
+        await toolSafeSandboxSession.run({
           command: `mkdir -p ${shellQuote(workDir)} ${shellQuote(bridgeStateDir)}`,
           abortSignal: startOpts.abortSignal
         });
@@ -1034,7 +1064,7 @@ function createClaudeCode(settings = {}) {
             throw new Error("Unable to resolve sandbox HOME directory.");
           }
           await writeClaudeCodeSkills({
-            sandbox: session,
+            sandbox: toolSafeSandboxSession,
             homeDir: sandboxHomeDir,
             skills: startOpts.skills,
             abortSignal: startOpts.abortSignal
@@ -1042,12 +1072,12 @@ function createClaudeCode(settings = {}) {
         }
       }
       await markBridgeStarting({
-        sandbox: session,
+        sandbox: toolSafeSandboxSession,
         bridgeStateDir,
         bridgeType: "claude-code",
         abortSignal: startOpts.abortSignal
       });
-      const proc = await session.spawn({
+      const proc = await toolSafeSandboxSession.spawn({
         command: `node ${shellQuote(`${bootstrapDir}/bridge.mjs`)} --workdir ${shellQuote(workDir)} --bridge-state-dir ${shellQuote(bridgeStateDir)}`,
         env,
         abortSignal: startOpts.abortSignal
@@ -1062,7 +1092,7 @@ function createClaudeCode(settings = {}) {
       void bridgeStartupStderrDone;
       const { port: boundPort } = await waitForBridgeReady({
         proc,
-        sandbox: session,
+        sandbox: toolSafeSandboxSession,
         bridgeStateDir,
         bridgeType: "claude-code",
         timeoutMs,
@@ -1083,9 +1113,10 @@ function createClaudeCode(settings = {}) {
         })
       });
       void drainBridgeProcessStream(proc.stdout);
-      const endpoint = await sandboxSession.getPortEndpoint({
-        port: boundPort,
-        protocol: "ws"
+      const endpoint = await resolveBridgeEndpoint({
+        sandboxSession,
+        override: settings.portEndpoint,
+        port: boundPort
       });
       const bridgeEndpoint = withBridgeToken({ endpoint, token });
       const channel = new SandboxChannel({
@@ -1120,19 +1151,58 @@ function createClaudeCode(settings = {}) {
         permissionMode: startOpts.permissionMode,
         builtinToolFiltering: startOpts.builtinToolFiltering,
         skills: startOpts.skills ?? [],
-        mcpServers: settings.mcpServers
+        mcpServers: settings.mcpServers,
+        supportsUserMessageResponses: () => supportsUserMessageResponses
       });
     }
   };
 }
-function resolveBridgePort(sandboxSession, override) {
+function resolveBridgePort({
+  sandboxSession,
+  override
+}) {
   if (override !== void 0) return override;
-  if (sandboxSession.ports.length > 0) return sandboxSession.ports[0];
+  if ("ports" in sandboxSession && sandboxSession.ports.length > 0) {
+    return sandboxSession.ports[0];
+  }
   throw new HarnessCapabilityUnsupportedError({
     harnessId: "claude-code",
     message: "The claude-code harness needs a TCP port exposed by the sandbox. Create the sandbox with `ports: [<port>]` or pass `createClaudeCode({ port })`."
   });
 }
+function validateBasicSandboxSettings({
+  sandboxSession,
+  port,
+  portEndpoint
+}) {
+  if ("getPortEndpoint" in sandboxSession) return;
+  if (port == null) {
+    throw new HarnessCapabilityUnsupportedError({
+      harnessId: "claude-code",
+      message: "The Claude Code harness requires an explicit `port` when using a basic sandbox session."
+    });
+  }
+  if (portEndpoint == null) {
+    throw new HarnessCapabilityUnsupportedError({
+      harnessId: "claude-code",
+      message: "The Claude Code harness requires an explicit `portEndpoint` when using a basic sandbox session."
+    });
+  }
+}
+async function resolveBridgeEndpoint({
+  sandboxSession,
+  override,
+  port
+}) {
+  if (override != null) return override;
+  if ("getPortEndpoint" in sandboxSession) {
+    return sandboxSession.getPortEndpoint({ port, protocol: "ws" });
+  }
+  throw new HarnessCapabilityUnsupportedError({
+    harnessId: "claude-code",
+    message: "The Claude Code harness requires an explicit `portEndpoint` when using a basic sandbox session."
+  });
+}
 async function writeClaudeCodeSkills({
   sandbox,
   homeDir,
@@ -1152,7 +1222,8 @@ async function writeClaudeCodeSkills({
 function openWebSocketAndWaitForBridgeHello({
   endpoint,
   openTimeoutMs,
-  getHelloTimeoutMs
+  getHelloTimeoutMs,
+  onHello
 }) {
   return new Promise((resolve, reject) => {
     const ws = new WebSocket(endpoint.url, {
@@ -1218,6 +1289,8 @@ function openWebSocketAndWaitForBridgeHello({
         if (!parsed.success || settled) return;
         const value = parsed.value;
         if (typeof value === "object" && value !== null && !Array.isArray(value) && value.type === "bridge-hello") {
+          const capabilities = value.capabilities;
+          onHello(capabilities?.experimental_userMessageResponses === true);
           sawBridgeHello = true;
           tryResolve();
         }
@@ -1242,7 +1315,8 @@ function openWebSocketAndWaitForBridgeHello({
 }
 async function openBridgeWebSocket({
   endpoint,
-  timeoutMs
+  timeoutMs,
+  onHello
 }) {
   const deadline = Date.now() + timeoutMs;
   let attempt = 0;
@@ -1254,7 +1328,8 @@ async function openBridgeWebSocket({
       return await openWebSocketAndWaitForBridgeHello({
         endpoint,
         openTimeoutMs: Math.min(1e4, remaining),
-        getHelloTimeoutMs: () => Math.min(5e3, Math.max(1, deadline - Date.now()))
+        getHelloTimeoutMs: () => Math.min(5e3, Math.max(1, deadline - Date.now())),
+        onHello
       });
     } catch (err) {
       lastError = err;
@@ -1316,7 +1391,8 @@ function createSession({
   permissionMode,
   builtinToolFiltering,
   skills,
-  mcpServers
+  mcpServers,
+  supportsUserMessageResponses
 }) {
   let stopped = false;
   let stopPromise;
@@ -1328,6 +1404,11 @@ function createSession({
       pendingResolve = resolve;
       pendingReject = reject;
     });
+    const userMessageSubmitter = supportsUserMessageResponses() ? experimental_createBridgeUserMessageSubmitter({
+      send: (message) => channel.send(message),
+      onResponse: (listener) => channel.on("user-message-response", listener),
+      onReconnect: (listener) => channel.onReconnect(listener)
+    }) : void 0;
     const unsubs = [];
     const forward = (event) => {
       try {
@@ -1339,12 +1420,14 @@ function createSession({
     const settleSuccess = () => {
       if (isSettled) return;
       isSettled = true;
+      userMessageSubmitter?.close();
       for (const u of unsubs) u();
       pendingResolve();
     };
     const settleError = (err) => {
       if (isSettled) return;
       isSettled = true;
+      userMessageSubmitter?.close(err);
       for (const u of unsubs) u();
       pendingReject(err);
     };
@@ -1428,8 +1511,10 @@ function createSession({
           reason: input.reason
         });
       },
-      submitUserMessage: async (text) => {
-        channel.send({ type: "user-message", text });
+      ...userMessageSubmitter == null ? {} : {
+        submitUserMessage: async (text) => {
+          await userMessageSubmitter.submit(text);
+        }
       },
       done
     };
@@ -1541,7 +1626,7 @@ function createSession({
             port: bridgePort,
             token: bridgeToken,
             lastSeenEventId,
-            sandboxId
+            ...sandboxId == null ? {} : { sandboxId }
           }
         }
       };
@@ -1655,7 +1740,7 @@ function createSession({
             port: bridgePort,
             token: bridgeToken,
             lastSeenEventId,
-            sandboxId
+            ...sandboxId == null ? {} : { sandboxId }
           }
         }
       };