@ai-sdk/harness-claude-code 1.0.0-canary.2 → 1.0.0-canary.4

package/dist/index.js

@@ -1,15 +1,20 @@
 // src/claude-code-harness.ts
 import { randomBytes } from "crypto";
 import { readFile } from "fs/promises";
+import path from "path";
 import { fileURLToPath } from "url";
 import {
   commonTool,
   harnessV1DiagnosticFromBridgeFrame,
   HarnessCapabilityUnsupportedError
 } from "@ai-sdk/harness";
-import { classifyDiskLog, SandboxChannel } from "@ai-sdk/harness/utils";
 import {
-  safeParseJSON,
+  classifyDiskLog,
+  markBridgeStarting,
+  SandboxChannel,
+  waitForBridgeReady
+} from "@ai-sdk/harness/utils";
+import {
   tool
 } from "@ai-sdk/provider-utils";
 import { WebSocket } from "ws";
@@ -101,6 +106,7 @@ var outboundMessageSchema = harnessV1BridgeOutboundMessageSchema;
 var startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
   thinking: z.enum(["off", "on", "adaptive"]).optional(),
   maxTurns: z.number().optional(),
+  skills: z.array(z.string()).optional(),
   // Resume signal. When true, the bridge passes `{ continue: true }` to the
   // Claude SDK so the in-workdir thread state is rehydrated. The host sets this
   // on the first prompt after a cross-process resume.
@@ -110,7 +116,6 @@ var inboundMessageSchema = z.discriminatedUnion("type", [
   startMessageSchema,
   ...harnessV1BridgeInboundCommandSchemas
 ]);
-var bridgeReadySchema = harnessV1BridgeReadySchema;
 
 // src/claude-code-harness.ts
 var CLAUDE_CODE_BUILTIN_TOOLS = {
@@ -460,7 +465,8 @@ function createClaudeCode(settings = {}) {
             bridgeToken: coords.token,
             sandboxId,
             debug: startOpts.observability?.debug,
-            permissionMode: startOpts.permissionMode
+            permissionMode: startOpts.permissionMode,
+            skills: startOpts.skills ?? []
           });
         } catch {
         }
@@ -477,12 +483,17 @@ function createClaudeCode(settings = {}) {
           respawnStrategy = "replay";
         }
       }
+      const sandboxHomeDir = startOpts.skills && startOpts.skills.length > 0 ? await resolveSandboxHomeDir({
+        sandbox: session,
+        abortSignal: startOpts.abortSignal
+      }) : void 0;
       const port = resolveBridgePort(sandboxSession, settings.port);
       const token = randomBytes(32).toString("hex");
       const env = {
         ...resolveClaudeCodeEnv(settings.auth),
         BRIDGE_CHANNEL_TOKEN: token,
         BRIDGE_WS_PORT: String(port),
+        ...sandboxHomeDir ? { HOME: sandboxHomeDir } : {},
         ...respawnStrategy === "replay" ? { BRIDGE_REPLAY_FROM_DISK: "1" } : {}
       };
       if (respawnStrategy === void 0) {
@@ -491,14 +502,23 @@ function createClaudeCode(settings = {}) {
           abortSignal: startOpts.abortSignal
         });
         if (startOpts.skills && startOpts.skills.length > 0) {
+          if (!sandboxHomeDir) {
+            throw new Error("Unable to resolve sandbox HOME directory.");
+          }
           await writeSkills({
             sandbox: session,
-            workdir: workDir,
+            homeDir: sandboxHomeDir,
             skills: startOpts.skills,
             abortSignal: startOpts.abortSignal
           });
         }
       }
+      await markBridgeStarting({
+        sandbox: session,
+        bridgeStateDir,
+        bridgeType: "claude-code",
+        abortSignal: startOpts.abortSignal
+      });
       const proc = await session.spawn({
         command: `node ${BOOTSTRAP_DIR}/bridge.mjs --workdir ${workDir} --bridge-state-dir ${bridgeStateDir}`,
         env,
@@ -512,10 +532,25 @@ function createClaudeCode(settings = {}) {
       void bridgeStartupStderrDone;
       const { port: boundPort } = await waitForBridgeReady({
         proc,
+        sandbox: session,
+        bridgeStateDir,
+        bridgeType: "claude-code",
         timeoutMs,
         abortSignal: startOpts.abortSignal,
-        stderrTail: bridgeStartupStderr,
-        stderrDone: bridgeStartupStderrDone
+        createTimeoutError: ({ proc: proc2, stdoutTail }) => createBridgeStartupError({
+          message: "claude-code bridge did not become ready in time.",
+          proc: proc2,
+          stdoutTail,
+          stderrTail: bridgeStartupStderr,
+          stderrDone: bridgeStartupStderrDone
+        }),
+        createExitError: ({ proc: proc2, stdoutTail }) => createBridgeStartupError({
+          message: "claude-code bridge exited before becoming ready.",
+          proc: proc2,
+          stdoutTail,
+          stderrTail: bridgeStartupStderr,
+          stderrDone: bridgeStartupStderrDone
+        })
       });
       void drainRest(proc.stdout);
       const wsUrl = await sandboxSession.getPortUrl({
@@ -548,7 +583,8 @@ function createClaudeCode(settings = {}) {
         bridgeToken: token,
         sandboxId,
         debug: startOpts.observability?.debug,
-        permissionMode: startOpts.permissionMode
+        permissionMode: startOpts.permissionMode,
+        skills: startOpts.skills ?? []
       });
     }
   };
@@ -563,16 +599,27 @@ function resolveBridgePort(sandboxSession, override) {
 }
 async function writeSkills({
   sandbox,
-  workdir,
+  homeDir,
   skills,
   abortSignal
 }) {
+  for (const skill of skills) {
+    safeClaudeSkillName(skill.name);
+    for (const file of skill.files ?? []) {
+      safeClaudeSkillFilePath({
+        skillName: skill.name,
+        filePath: file.path
+      });
+    }
+  }
   await sandbox.run({
-    command: `mkdir -p ${workdir}/.claude/skills`,
+    command: `mkdir -p ${shellQuote(homeDir)}/.claude/skills`,
     abortSignal
   });
   for (const skill of skills) {
-    const path = `${workdir}/.claude/skills/${skill.name}.md`;
+    const name = safeClaudeSkillName(skill.name);
+    const skillDir = `${homeDir}/.claude/skills/${name}`;
+    const path2 = `${skillDir}/SKILL.md`;
     const content = `---
 name: ${skill.name}
 description: ${skill.description}
@@ -580,9 +627,57 @@ description: ${skill.description}
 
 ${skill.content}
 `;
-    await sandbox.writeTextFile({ path, content, abortSignal });
+    await sandbox.writeTextFile({ path: path2, content, abortSignal });
+    for (const file of skill.files ?? []) {
+      const filePath = safeClaudeSkillFilePath({
+        skillName: skill.name,
+        filePath: file.path
+      });
+      await sandbox.writeTextFile({
+        path: `${skillDir}/${filePath}`,
+        content: file.content,
+        abortSignal
+      });
+    }
   }
 }
+async function resolveSandboxHomeDir({
+  sandbox,
+  abortSignal
+}) {
+  const result = await sandbox.run({
+    command: 'printf "%s" "$HOME"',
+    abortSignal
+  });
+  const homeDir = result.stdout.trim();
+  if (result.exitCode !== 0 || !homeDir || !path.posix.isAbsolute(homeDir)) {
+    throw new Error(
+      `Unable to resolve sandbox HOME directory: ${result.stderr || result.stdout}`
+    );
+  }
+  return homeDir;
+}
+function safeClaudeSkillName(name) {
+  if (!/^[A-Za-z0-9._-]+$/.test(name) || name === "." || name === "..") {
+    throw new Error(`Invalid Claude Code skill name: ${name}`);
+  }
+  return name;
+}
+function safeClaudeSkillFilePath({
+  skillName,
+  filePath
+}) {
+  const normalized = path.posix.normalize(filePath);
+  if (normalized === "." || normalized.startsWith("../") || path.posix.isAbsolute(normalized)) {
+    throw new Error(
+      `Invalid Claude Code skill file path for ${skillName}: ${filePath}`
+    );
+  }
+  return normalized;
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
 async function readBridgeAsset(name) {
   const candidates = [
     new URL(`./bridge/${name}`, import.meta.url),
@@ -600,71 +695,6 @@ async function readBridgeAsset(name) {
   }
   throw lastErr ?? new Error(`bridge asset not found: ${name}`);
 }
-async function waitForBridgeReady({
-  proc,
-  timeoutMs,
-  abortSignal,
-  stderrTail,
-  stderrDone
-}) {
-  const reader = proc.stdout.pipeThrough(new TextDecoderStream()).getReader();
-  const decoder = lineDecoder();
-  const stdoutTail = [];
-  const deadline = Date.now() + timeoutMs;
-  try {
-    while (true) {
-      if (abortSignal?.aborted) {
-        await proc.kill();
-        throw abortSignal.reason ?? new DOMException("Aborted", "AbortError");
-      }
-      const remaining = deadline - Date.now();
-      if (remaining <= 0) {
-        await proc.kill();
-        throw await createBridgeStartupError({
-          message: "claude-code bridge did not become ready in time.",
-          proc,
-          stdoutTail,
-          stderrTail,
-          stderrDone
-        });
-      }
-      const { value, done } = await Promise.race([
-        reader.read(),
-        new Promise(
-          (resolve) => setTimeout(
-            () => resolve({ value: void 0, done: false }),
-            remaining
-          )
-        )
-      ]);
-      if (done) {
-        for (const line of decoder.flush()) {
-          stdoutTail.push(line);
-          if (stdoutTail.length > 20) stdoutTail.shift();
-        }
-        throw await createBridgeStartupError({
-          message: "claude-code bridge exited before becoming ready.",
-          proc,
-          stdoutTail,
-          stderrTail,
-          stderrDone
-        });
-      }
-      if (value === void 0) continue;
-      for (const line of decoder.push(value)) {
-        stdoutTail.push(line);
-        if (stdoutTail.length > 20) stdoutTail.shift();
-        const parsed = await safeParseJSON({
-          text: line,
-          schema: bridgeReadySchema
-        });
-        if (parsed.success) return { port: parsed.value.port };
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
 async function createBridgeStartupError({
   message,
   proc,
@@ -910,7 +940,8 @@ function createSession({
   bridgeToken,
   sandboxId,
   debug,
-  permissionMode
+  permissionMode,
+  skills
 }) {
   let stopped = false;
   let stopPromise;
@@ -1054,6 +1085,7 @@ function createSession({
         model,
         maxTurns,
         thinking,
+        ...skills.length > 0 ? { skills: skills.map((skill) => skill.name) } : {},
         ...permissionMode ? { permissionMode } : {},
         ...debug ? { debug } : {},
         ...pendingResumeFlag ? { continue: true } : {}
@@ -1087,6 +1119,7 @@ function createSession({
           model,
           maxTurns,
           thinking,
+          ...skills.length > 0 ? { skills: skills.map((skill) => skill.name) } : {},
           ...permissionMode ? { permissionMode } : {},
           ...debug ? { debug } : {},
           continue: true