@ai-sdk/harness-claude-code 0.0.0-6b196531-20260710185421

package/dist/index.js

@@ -0,0 +1,1208 @@
+// src/claude-code-harness.ts
+import { randomBytes } from "crypto";
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+import {
+  commonTool,
+  harnessV1DiagnosticFromBridgeFrame,
+  HarnessCapabilityUnsupportedError
+} from "@ai-sdk/harness";
+import {
+  classifyDiskLog,
+  createBridgeErrorHandler,
+  createBridgeStartupError,
+  drainBridgeProcessStream,
+  forwardBridgeProcessStream,
+  markBridgeStarting,
+  resolveSandboxHomeDir,
+  SandboxChannel,
+  shellQuote,
+  waitForBridgeReady,
+  writeSkills as writeHarnessSkills
+} from "@ai-sdk/harness/utils";
+import {
+  tool
+} from "@ai-sdk/provider-utils";
+import { WebSocket } from "ws";
+import { z as z2 } from "zod/v4";
+
+// src/claude-code-auth.ts
+import { execFileSync } from "child_process";
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { getAiGatewayAuthFromEnv } from "@ai-sdk/harness/utils";
+function resolveClaudeCodeEnv(auth, processEnv = process.env, options = {}) {
+  const readApiKey = options.readApiKeyHelper ?? readApiKeyHelper;
+  if (auth?.anthropic) {
+    return pickAnthropic({ explicit: auth.anthropic, processEnv, readApiKey });
+  }
+  const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({ env: processEnv });
+  if (auth?.gateway) {
+    return pickGateway({
+      explicit: auth.gateway,
+      gatewayAuthFromEnv
+    });
+  }
+  if (gatewayAuthFromEnv.apiKey) {
+    return pickGateway({
+      explicit: {},
+      gatewayAuthFromEnv
+    });
+  }
+  return pickAnthropic({ processEnv, readApiKey });
+}
+function pickAnthropic({
+  explicit,
+  processEnv,
+  readApiKey
+}) {
+  const env = {};
+  const helperKey = explicit ? void 0 : readApiKey();
+  const apiKey = explicit?.apiKey ?? processEnv.ANTHROPIC_API_KEY ?? helperKey;
+  const authToken = explicit?.authToken ?? processEnv.ANTHROPIC_AUTH_TOKEN ?? helperKey;
+  if (apiKey) env.ANTHROPIC_API_KEY = apiKey;
+  if (authToken) env.ANTHROPIC_AUTH_TOKEN = authToken;
+  const baseUrl = explicit?.baseUrl ?? processEnv.ANTHROPIC_BASE_URL;
+  if (baseUrl) env.ANTHROPIC_BASE_URL = baseUrl;
+  return env;
+}
+function readApiKeyHelper() {
+  const home = homedir();
+  if (!home) return void 0;
+  let raw;
+  try {
+    raw = readFileSync(join(home, ".claude", "settings.json"), "utf8");
+  } catch {
+    return void 0;
+  }
+  let settings;
+  try {
+    settings = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  const command = settings.apiKeyHelper;
+  if (typeof command !== "string" || command.length === 0) return void 0;
+  try {
+    const output = execFileSync("sh", ["-c", command], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const trimmed = output.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function pickGateway({
+  explicit,
+  gatewayAuthFromEnv
+}) {
+  const apiKey = explicit.apiKey ?? gatewayAuthFromEnv.apiKey;
+  const baseUrl = explicit.baseUrl ?? gatewayAuthFromEnv.baseUrl;
+  const env = {};
+  if (apiKey) {
+    env.AI_GATEWAY_API_KEY = apiKey;
+    env.ANTHROPIC_API_KEY = apiKey;
+  }
+  env.AI_GATEWAY_BASE_URL = baseUrl;
+  env.ANTHROPIC_BASE_URL = baseUrl;
+  return env;
+}
+
+// src/claude-code-bridge-protocol.ts
+import {
+  harnessV1BridgeInboundCommandSchemas,
+  harnessV1BridgeOutboundMessageSchema,
+  harnessV1BridgeReadySchema,
+  harnessV1BridgeStartBaseSchema
+} from "@ai-sdk/harness";
+import { z } from "zod/v4";
+var outboundMessageSchema = harnessV1BridgeOutboundMessageSchema;
+var thinkingDisplaySchema = z.enum(["summarized", "omitted"]).optional();
+var thinkingSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("adaptive"),
+    display: thinkingDisplaySchema
+  }),
+  z.object({
+    type: z.literal("enabled"),
+    display: thinkingDisplaySchema
+  }),
+  z.object({ type: z.literal("disabled") })
+]);
+var startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
+  thinking: thinkingSchema,
+  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.
+  continue: z.boolean().optional()
+});
+var inboundMessageSchema = z.discriminatedUnion("type", [
+  startMessageSchema,
+  ...harnessV1BridgeInboundCommandSchemas
+]);
+
+// src/version.ts
+var VERSION = true ? "0.0.0-6b196531-20260710185421" : "0.0.0-test";
+
+// src/claude-code-harness.ts
+var CLAUDE_CODE_CLIENT_APP = `ai-sdk/harness-claude-code/${VERSION}`;
+var CLAUDE_CODE_BUILTIN_TOOLS = {
+  read: commonTool("read", {
+    nativeName: "Read",
+    toolUseKind: "readonly",
+    description: "Read file contents (text, image, PDF, notebook)",
+    inputSchema: z2.object({
+      file_path: z2.string(),
+      offset: z2.number().optional(),
+      limit: z2.number().optional(),
+      pages: z2.string().optional()
+    })
+  }),
+  write: commonTool("write", {
+    nativeName: "Write",
+    toolUseKind: "edit",
+    description: "Overwrite or create a file at an absolute path",
+    inputSchema: z2.object({
+      file_path: z2.string(),
+      content: z2.string()
+    })
+  }),
+  edit: commonTool("edit", {
+    nativeName: "Edit",
+    toolUseKind: "edit",
+    description: "Edit a file by exact string replacement",
+    inputSchema: z2.object({
+      file_path: z2.string(),
+      old_string: z2.string(),
+      new_string: z2.string(),
+      replace_all: z2.boolean().optional()
+    })
+  }),
+  bash: commonTool("bash", {
+    nativeName: "Bash",
+    toolUseKind: "bash",
+    description: "Execute a shell command, optionally in background",
+    inputSchema: z2.object({
+      command: z2.string(),
+      timeout: z2.number().optional(),
+      description: z2.string().optional(),
+      run_in_background: z2.boolean().optional(),
+      dangerouslyDisableSandbox: z2.boolean().optional()
+    })
+  }),
+  glob: commonTool("glob", {
+    nativeName: "Glob",
+    toolUseKind: "readonly",
+    description: "Fast file-pattern search using glob syntax",
+    inputSchema: z2.object({
+      pattern: z2.string(),
+      path: z2.string().optional()
+    })
+  }),
+  grep: commonTool("grep", {
+    nativeName: "Grep",
+    toolUseKind: "readonly",
+    description: "Regex search over file contents via ripgrep",
+    inputSchema: z2.object({
+      pattern: z2.string(),
+      path: z2.string().optional(),
+      glob: z2.string().optional(),
+      output_mode: z2.enum(["content", "files_with_matches", "count"]).optional(),
+      "-B": z2.number().optional(),
+      "-A": z2.number().optional(),
+      "-C": z2.number().optional(),
+      context: z2.number().optional(),
+      "-n": z2.boolean().optional(),
+      "-i": z2.boolean().optional(),
+      "-o": z2.boolean().optional(),
+      type: z2.string().optional(),
+      head_limit: z2.number().optional(),
+      offset: z2.number().optional(),
+      multiline: z2.boolean().optional()
+    })
+  }),
+  webSearch: commonTool("webSearch", {
+    nativeName: "WebSearch",
+    toolUseKind: "readonly",
+    description: "Issue web search queries with optional domain filters",
+    inputSchema: z2.object({
+      query: z2.string(),
+      allowed_domains: z2.array(z2.string()).optional(),
+      blocked_domains: z2.array(z2.string()).optional()
+    })
+  }),
+  WebFetch: tool({
+    description: "Fetch a URL and run a prompt against its content",
+    inputSchema: z2.object({
+      url: z2.string(),
+      prompt: z2.string()
+    })
+  }),
+  NotebookEdit: tool({
+    description: "Edit, insert, or delete a Jupyter notebook cell",
+    inputSchema: z2.object({
+      notebook_path: z2.string(),
+      new_source: z2.string(),
+      cell_id: z2.string().optional(),
+      cell_type: z2.enum(["code", "markdown"]).optional(),
+      edit_mode: z2.enum(["replace", "insert", "delete"]).optional()
+    })
+  }),
+  TodoWrite: tool({
+    description: "Replace the session todo list",
+    inputSchema: z2.object({
+      todos: z2.array(
+        z2.object({
+          content: z2.string(),
+          status: z2.enum(["pending", "in_progress", "completed"]),
+          activeForm: z2.string()
+        })
+      )
+    })
+  }),
+  Agent: tool({
+    description: "Spawn a subagent with a task",
+    inputSchema: z2.object({
+      description: z2.string(),
+      prompt: z2.string(),
+      subagent_type: z2.string().optional(),
+      model: z2.enum(["sonnet", "opus", "haiku"]).optional(),
+      run_in_background: z2.boolean().optional(),
+      name: z2.string().optional(),
+      team_name: z2.string().optional(),
+      mode: z2.enum([
+        "acceptEdits",
+        "auto",
+        "bypassPermissions",
+        "default",
+        "dontAsk",
+        "plan"
+      ]).optional(),
+      isolation: z2.literal("worktree").optional()
+    })
+  }),
+  TaskCreate: tool({
+    description: "Create a task in the session-local task list",
+    inputSchema: z2.object({
+      subject: z2.string(),
+      description: z2.string(),
+      activeForm: z2.string().optional(),
+      metadata: z2.record(z2.string(), z2.unknown()).optional()
+    })
+  }),
+  TaskGet: tool({
+    description: "Retrieve a task by id",
+    inputSchema: z2.object({ taskId: z2.string() })
+  }),
+  TaskUpdate: tool({
+    description: "Update fields of an existing task",
+    inputSchema: z2.object({
+      taskId: z2.string(),
+      subject: z2.string().optional(),
+      description: z2.string().optional(),
+      activeForm: z2.string().optional(),
+      status: z2.union([
+        z2.enum(["pending", "in_progress", "completed"]),
+        z2.literal("deleted")
+      ]).optional(),
+      addBlocks: z2.array(z2.string()).optional(),
+      addBlockedBy: z2.array(z2.string()).optional(),
+      owner: z2.string().optional(),
+      metadata: z2.record(z2.string(), z2.unknown()).optional()
+    })
+  }),
+  TaskList: tool({
+    description: "Return all tasks in the session-local task list",
+    inputSchema: z2.object({})
+  }),
+  TaskStop: tool({
+    description: "Stop a running background task by id",
+    inputSchema: z2.object({
+      task_id: z2.string().optional(),
+      shell_id: z2.string().optional()
+    })
+  }),
+  TaskOutput: tool({
+    description: "Poll for output from a background task",
+    inputSchema: z2.object({
+      task_id: z2.string(),
+      block: z2.boolean(),
+      timeout: z2.number()
+    })
+  }),
+  Monitor: tool({
+    description: "Run and monitor a shell command",
+    inputSchema: z2.object({
+      command: z2.string(),
+      description: z2.string().optional(),
+      timeout_ms: z2.number().optional(),
+      persistent: z2.boolean().optional()
+    })
+  }),
+  ListMcpResources: tool({
+    description: "List resources available from MCP servers",
+    inputSchema: z2.object({ server: z2.string().optional() })
+  }),
+  ReadMcpResource: tool({
+    description: "Read a specific MCP resource by URI",
+    inputSchema: z2.object({ server: z2.string(), uri: z2.string() })
+  }),
+  ExitPlanMode: tool({
+    description: "Exit plan mode with optional permission approvals",
+    inputSchema: z2.looseObject({
+      allowedPrompts: z2.array(
+        z2.object({
+          tool: z2.literal("Bash"),
+          prompt: z2.string()
+        })
+      ).optional()
+    })
+  }),
+  EnterWorktree: tool({
+    description: "Create or enter an isolated git worktree",
+    inputSchema: z2.object({
+      name: z2.string().optional(),
+      path: z2.string().optional()
+    })
+  }),
+  ExitWorktree: tool({
+    description: "Exit the current worktree session",
+    inputSchema: z2.object({
+      action: z2.enum(["keep", "remove"]),
+      discard_changes: z2.boolean().optional()
+    })
+  }),
+  AskUserQuestion: tool({
+    description: "Ask the user multiple-choice questions via a structured UI",
+    inputSchema: z2.object({
+      questions: z2.array(
+        z2.object({
+          question: z2.string(),
+          header: z2.string(),
+          options: z2.array(
+            z2.object({
+              label: z2.string(),
+              description: z2.string(),
+              preview: z2.string().optional()
+            })
+          ),
+          multiSelect: z2.boolean()
+        })
+      ).min(1).max(4),
+      answers: z2.record(z2.string(), z2.string()).optional(),
+      annotations: z2.record(
+        z2.string(),
+        z2.object({
+          preview: z2.string().optional(),
+          notes: z2.string().optional()
+        })
+      ).optional(),
+      metadata: z2.object({ source: z2.string().optional() }).optional()
+    })
+  }),
+  Skill: tool({
+    description: "Activate a skill by name",
+    inputSchema: z2.object({
+      skill: z2.string(),
+      args: z2.string().optional()
+    })
+  })
+};
+var BOOTSTRAP_DIR = "/tmp/harness/claude-code";
+var claudeCodeBridgeCoordsSchema = z2.object({
+  port: z2.number(),
+  token: z2.string(),
+  lastSeenEventId: z2.number(),
+  sandboxId: z2.string().optional()
+});
+var claudeCodeResumeStateSchema = z2.looseObject({
+  bridge: claudeCodeBridgeCoordsSchema.optional()
+});
+function createClaudeCode(settings = {}) {
+  let cachedBootstrap;
+  const thinking = settings.thinking ?? {
+    type: "adaptive",
+    display: "summarized"
+  };
+  return {
+    specificationVersion: "harness-v1",
+    harnessId: "claude-code",
+    builtinTools: CLAUDE_CODE_BUILTIN_TOOLS,
+    supportsBuiltinToolApprovals: true,
+    supportsBuiltinToolFiltering: true,
+    lifecycleStateSchema: claudeCodeResumeStateSchema,
+    getBootstrap: async () => {
+      if (cachedBootstrap != null) return cachedBootstrap;
+      const [pkg, lock, bridge] = await Promise.all([
+        readBridgeAsset("package.json"),
+        readBridgeAsset("pnpm-lock.yaml"),
+        readBridgeAsset("index.mjs")
+      ]);
+      cachedBootstrap = {
+        harnessId: "claude-code",
+        bootstrapDir: BOOTSTRAP_DIR,
+        files: [
+          { path: `${BOOTSTRAP_DIR}/package.json`, content: pkg },
+          { path: `${BOOTSTRAP_DIR}/pnpm-lock.yaml`, content: lock },
+          { path: `${BOOTSTRAP_DIR}/bridge.mjs`, content: bridge }
+        ],
+        commands: [
+          { command: `mkdir -p ${BOOTSTRAP_DIR}` },
+          {
+            command: `pnpm --dir ${BOOTSTRAP_DIR} install --frozen-lockfile --store-dir ${BOOTSTRAP_DIR}/.pnpm-store`
+          },
+          {
+            command: `cd ${BOOTSTRAP_DIR} && if [ -f node_modules/@anthropic-ai/claude-code/install.cjs ]; then node node_modules/@anthropic-ai/claude-code/install.cjs; fi && ./node_modules/.bin/claude --version`
+          }
+        ]
+      };
+      return cachedBootstrap;
+    },
+    doStart: async (startOpts) => {
+      const sandboxSession = startOpts.sandboxSession;
+      const session = sandboxSession.restricted();
+      const sandboxId = sandboxSession.id;
+      const lifecycleState = startOpts.continueFrom ?? startOpts.resumeFrom;
+      const isResume = lifecycleState != null;
+      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 bridgeStateDir = `${sessionDataDir}/bridge`;
+      const timeoutMs = settings.startupTimeoutMs ?? 12e4;
+      const report = startOpts.observability?.report;
+      const onDiagnostic = report ? (frame) => report(
+        harnessV1DiagnosticFromBridgeFrame(frame, {
+          sessionId: startOpts.sessionId,
+          timestamp: Date.now()
+        })
+      ) : void 0;
+      const onBridgeError = createBridgeErrorHandler({
+        harnessId: "claude-code",
+        sessionId: startOpts.sessionId
+      });
+      const buildConnect = (wsUrl2) => async () => {
+        return openBridgeWebSocket({ wsUrl: wsUrl2, timeoutMs });
+      };
+      if (coords) {
+        try {
+          const attachUrl = await sandboxSession.getPortUrl({
+            port: coords.port,
+            protocol: "ws"
+          }) + `?agent_bridge_token=${encodeURIComponent(coords.token)}`;
+          const attachChannel = new SandboxChannel({
+            connect: buildConnect(attachUrl),
+            outboundSchema: outboundMessageSchema,
+            initialLastSeenEventId: coords.lastSeenEventId,
+            onDiagnostic,
+            onBridgeError
+          });
+          await attachChannel.open(isContinue ? { resume: true } : void 0);
+          return createSession({
+            sessionId: startOpts.sessionId,
+            channel: attachChannel,
+            // The live bridge was spawned by another process; this one owns no
+            // process handle. The session lifecycle method decides whether the
+            // sandbox is left running, stopped, or destroyed.
+            proc: void 0,
+            model: settings.model,
+            maxTurns: settings.maxTurns,
+            thinking,
+            isResume: true,
+            continueOnFirstPrompt: false,
+            rerunContinue: false,
+            bridgePort: coords.port,
+            bridgeToken: coords.token,
+            sandboxId,
+            debug: startOpts.observability?.debug,
+            permissionMode: startOpts.permissionMode,
+            builtinToolFiltering: startOpts.builtinToolFiltering,
+            skills: startOpts.skills ?? []
+          });
+        } catch {
+        }
+      }
+      let respawnStrategy = isResume ? "rerun" : void 0;
+      if (coords && isContinue) {
+        const logRaw = await Promise.resolve(
+          session.readTextFile({
+            path: `${bridgeStateDir}/event-log.ndjson`,
+            abortSignal: startOpts.abortSignal
+          })
+        ).catch(() => null);
+        if (await classifyDiskLog(logRaw) === "replay") {
+          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),
+        /*
+         * The Claude Agent SDK does not expose arbitrary model-request
+         * headers. It reads this environment variable and sends the value as
+         * `x-client-app`, while also appending `client-app/<value>` to
+         * `User-Agent`, so this is the attribution path for AI Gateway.
+         */
+        CLAUDE_AGENT_SDK_CLIENT_APP: CLAUDE_CODE_CLIENT_APP,
+        BRIDGE_CHANNEL_TOKEN: token,
+        BRIDGE_WS_PORT: String(port),
+        ...sandboxHomeDir ? { HOME: sandboxHomeDir } : {},
+        ...respawnStrategy === "replay" ? { BRIDGE_REPLAY_FROM_DISK: "1" } : {}
+      };
+      if (respawnStrategy === void 0) {
+        await session.run({
+          command: `mkdir -p ${shellQuote(workDir)} ${shellQuote(bridgeStateDir)}`,
+          abortSignal: startOpts.abortSignal
+        });
+        if (startOpts.skills && startOpts.skills.length > 0) {
+          if (!sandboxHomeDir) {
+            throw new Error("Unable to resolve sandbox HOME directory.");
+          }
+          await writeClaudeCodeSkills({
+            sandbox: session,
+            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 ${shellQuote(workDir)} --bridge-state-dir ${shellQuote(bridgeStateDir)}`,
+        env,
+        abortSignal: startOpts.abortSignal
+      });
+      const bridgeStartupStderr = [];
+      const bridgeStartupStderrDone = forwardBridgeProcessStream({
+        stream: proc.stderr,
+        streamName: "stderr",
+        source: "claude-code",
+        collectTail: bridgeStartupStderr
+      });
+      void bridgeStartupStderrDone;
+      const { port: boundPort } = await waitForBridgeReady({
+        proc,
+        sandbox: session,
+        bridgeStateDir,
+        bridgeType: "claude-code",
+        timeoutMs,
+        abortSignal: startOpts.abortSignal,
+        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 drainBridgeProcessStream(proc.stdout);
+      const wsUrl = await sandboxSession.getPortUrl({
+        port: boundPort,
+        protocol: "ws"
+      }) + `?agent_bridge_token=${encodeURIComponent(token)}`;
+      const channel = new SandboxChannel({
+        connect: buildConnect(wsUrl),
+        outboundSchema: outboundMessageSchema,
+        onDiagnostic,
+        onBridgeError,
+        // In replay mode the respawned bridge reloaded the finished turn from
+        // disk; seed the cursor and resume so it streams the tail (incl.
+        // `finish`) rather than starting empty.
+        ...respawnStrategy === "replay" ? { initialLastSeenEventId: coords?.lastSeenEventId ?? 0 } : {}
+      });
+      await channel.open(
+        respawnStrategy === "replay" ? { resume: true } : void 0
+      );
+      return createSession({
+        sessionId: startOpts.sessionId,
+        channel,
+        proc,
+        model: settings.model,
+        maxTurns: settings.maxTurns,
+        thinking,
+        isResume: respawnStrategy !== void 0,
+        continueOnFirstPrompt: respawnStrategy !== void 0,
+        rerunContinue: respawnStrategy === "rerun",
+        bridgePort: boundPort,
+        bridgeToken: token,
+        sandboxId,
+        debug: startOpts.observability?.debug,
+        permissionMode: startOpts.permissionMode,
+        builtinToolFiltering: startOpts.builtinToolFiltering,
+        skills: startOpts.skills ?? []
+      });
+    }
+  };
+}
+function resolveBridgePort(sandboxSession, override) {
+  if (override !== void 0) return override;
+  if (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 })`."
+  });
+}
+async function writeClaudeCodeSkills({
+  sandbox,
+  homeDir,
+  skills,
+  abortSignal
+}) {
+  await writeHarnessSkills({
+    sandbox,
+    rootDir: `${homeDir}/.claude/skills`,
+    skills,
+    abortSignal,
+    invalidSkillNameMessage: ({ name }) => `Invalid Claude Code skill name: ${name}`,
+    invalidSkillFilePathMessage: ({ skillName, filePath }) => `Invalid Claude Code skill file path for ${skillName}: ${filePath}`,
+    trailingNewline: true
+  });
+}
+async function readBridgeAsset(name) {
+  const candidates = [
+    new URL(`./bridge/${name}`, import.meta.url),
+    new URL(`../bridge/${name}`, import.meta.url)
+  ];
+  let lastErr;
+  for (const url of candidates) {
+    try {
+      return await readFile(fileURLToPath(url), "utf8");
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT") throw err;
+      lastErr = err;
+    }
+  }
+  throw lastErr ?? new Error(`bridge asset not found: ${name}`);
+}
+async function waitForBridgeHello({
+  ws,
+  timeoutMs
+}) {
+  await new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      ws.off("message", onMessage);
+      ws.off("close", onClose);
+      ws.off("error", onError);
+      if (timer) clearTimeout(timer);
+    };
+    const settle = (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (err) reject(err);
+      else resolve();
+    };
+    const onMessage = (raw) => {
+      try {
+        const text = typeof raw === "string" ? raw : raw.toString ? raw.toString("utf8") : String(raw);
+        const parsed = JSON.parse(text);
+        if (parsed?.type === "bridge-hello") settle();
+      } catch {
+      }
+    };
+    const onClose = () => {
+      settle(
+        new Error("claude-code bridge closed before sending bridge-hello")
+      );
+    };
+    const onError = (err) => settle(err);
+    const timer = setTimeout(
+      () => settle(
+        new Error(
+          `claude-code bridge did not send bridge-hello within ${timeoutMs}ms`
+        )
+      ),
+      timeoutMs
+    );
+    timer.unref?.();
+    ws.on("message", onMessage);
+    ws.on("close", onClose);
+    ws.on("error", onError);
+  });
+}
+async function openBridgeWebSocket({
+  wsUrl,
+  timeoutMs
+}) {
+  const deadline = Date.now() + timeoutMs;
+  let attempt = 0;
+  let lastError;
+  while (Date.now() < deadline) {
+    attempt++;
+    let ws;
+    try {
+      const remaining = Math.max(1, deadline - Date.now());
+      ws = await openWebSocket({
+        url: wsUrl,
+        timeoutMs: Math.min(1e4, remaining)
+      });
+      await waitForBridgeHello({
+        ws,
+        timeoutMs: Math.min(5e3, Math.max(1, deadline - Date.now()))
+      });
+      return ws;
+    } catch (err) {
+      lastError = err;
+      try {
+        ws?.close();
+      } catch {
+      }
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) break;
+      await sleep(Math.min(250 * attempt, 1e3, remaining));
+    }
+  }
+  throw new Error(
+    `claude-code bridge did not complete WebSocket handshake within ${timeoutMs}ms after ${attempt} attempt(s). Last error: ${formatUnknownError(lastError)}`
+  );
+}
+function openWebSocket({
+  url,
+  timeoutMs
+}) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url);
+    const timer = setTimeout(() => {
+      cleanup();
+      try {
+        ws.terminate();
+      } catch {
+      }
+      reject(new Error(`WebSocket open timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    timer.unref?.();
+    const cleanup = () => {
+      clearTimeout(timer);
+      ws.off("open", onOpen);
+      ws.off("error", onError);
+    };
+    const onOpen = () => {
+      cleanup();
+      resolve(ws);
+    };
+    const onError = (err) => {
+      cleanup();
+      reject(err);
+    };
+    ws.once("open", onOpen);
+    ws.once("error", onError);
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+function formatUnknownError(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+function createSession({
+  sessionId,
+  channel,
+  proc,
+  model,
+  maxTurns,
+  thinking,
+  isResume,
+  continueOnFirstPrompt,
+  rerunContinue,
+  bridgePort,
+  bridgeToken,
+  sandboxId,
+  debug,
+  permissionMode,
+  builtinToolFiltering,
+  skills
+}) {
+  let stopped = false;
+  let stopPromise;
+  let pendingResumeFlag = continueOnFirstPrompt;
+  let instructionsApplied = isResume;
+  const wireTurn = (turnOpts) => {
+    let pendingResolve;
+    let pendingReject;
+    const done = new Promise((resolve, reject) => {
+      pendingResolve = resolve;
+      pendingReject = reject;
+    });
+    const unsubs = [];
+    const forward = (event) => {
+      try {
+        turnOpts.emit(event);
+      } catch {
+      }
+    };
+    let isSettled = false;
+    const settleSuccess = () => {
+      if (isSettled) return;
+      isSettled = true;
+      for (const u of unsubs) u();
+      pendingResolve();
+    };
+    const settleError = (err) => {
+      if (isSettled) return;
+      isSettled = true;
+      for (const u of unsubs) u();
+      pendingReject(err);
+    };
+    const eventTypes = [
+      "stream-start",
+      "text-start",
+      "text-delta",
+      "text-end",
+      "reasoning-start",
+      "reasoning-delta",
+      "reasoning-end",
+      "tool-call",
+      "tool-approval-request",
+      "tool-result",
+      "finish-step",
+      "raw"
+    ];
+    for (const type of eventTypes) {
+      unsubs.push(
+        channel.on(type, (msg) => {
+          forward(msg);
+        })
+      );
+    }
+    unsubs.push(
+      channel.on("finish", (msg) => {
+        forward(msg);
+        settleSuccess();
+      })
+    );
+    unsubs.push(
+      channel.on("error", (msg) => {
+        forward(msg);
+        settleError(msg.error);
+      })
+    );
+    const onClose = (_code, reason) => {
+      if (isSettled) return;
+      if (reason === "suspended") {
+        settleSuccess();
+        return;
+      }
+      settleError(
+        new Error("claude-code bridge closed before the turn finished.")
+      );
+    };
+    channel.onClose(onClose);
+    const onAbort = () => {
+      if (isSettled) return;
+      try {
+        channel.send({ type: "abort" });
+      } catch {
+      }
+      settleError(
+        turnOpts.abortSignal?.reason ?? new DOMException("Aborted", "AbortError")
+      );
+    };
+    if (turnOpts.abortSignal) {
+      if (turnOpts.abortSignal.aborted) {
+        onAbort();
+      } else {
+        turnOpts.abortSignal.addEventListener("abort", onAbort, {
+          once: true
+        });
+      }
+    }
+    return {
+      submitToolResult: async (input) => {
+        channel.send({
+          type: "tool-result",
+          toolCallId: input.toolCallId,
+          output: input.output,
+          isError: input.isError
+        });
+      },
+      submitToolApproval: async (input) => {
+        channel.send({
+          type: "tool-approval-response",
+          approvalId: input.approvalId,
+          approved: input.approved,
+          reason: input.reason
+        });
+      },
+      submitUserMessage: async (text) => {
+        channel.send({ type: "user-message", text });
+      },
+      done
+    };
+  };
+  return {
+    sessionId,
+    isResume,
+    modelId: model,
+    doPromptTurn: async (promptOpts) => {
+      const control = wireTurn({
+        emit: promptOpts.emit,
+        abortSignal: promptOpts.abortSignal
+      });
+      let promptText = extractUserText(promptOpts.prompt);
+      if (!instructionsApplied && promptOpts.instructions) {
+        promptText = frameInstructions(promptOpts.instructions, promptText);
+      }
+      instructionsApplied = true;
+      const startMessage = {
+        type: "start",
+        prompt: promptText,
+        tools: (promptOpts.tools ?? []).map((t) => ({
+          name: t.name,
+          description: t.description,
+          inputSchema: t.inputSchema
+        })),
+        model,
+        maxTurns,
+        thinking,
+        ...skills.length > 0 ? { skills: skills.map((skill) => skill.name) } : {},
+        ...permissionMode ? { permissionMode } : {},
+        ...builtinToolFiltering ? { builtinToolFiltering } : {},
+        ...debug ? { debug } : {},
+        ...pendingResumeFlag ? { continue: true } : {}
+      };
+      pendingResumeFlag = false;
+      channel.send(startMessage);
+      return control;
+    },
+    doContinueTurn: async (continueOpts) => {
+      const control = wireTurn({
+        emit: continueOpts.emit,
+        abortSignal: continueOpts.abortSignal
+      });
+      if (rerunContinue) {
+        pendingResumeFlag = false;
+        channel.send({
+          type: "start",
+          /*
+           * A continuation nudge rather than an empty prompt: `continue: true`
+           * rehydrates the prior thread, and this is the new user turn that
+           * drives it forward. It must be non-empty — an empty text block is
+           * rejected by the Anthropic API once the SDK stamps it with
+           * `cache_control`.
+           */
+          prompt: "Continue.",
+          tools: (continueOpts.tools ?? []).map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema
+          })),
+          model,
+          maxTurns,
+          thinking,
+          ...skills.length > 0 ? { skills: skills.map((skill) => skill.name) } : {},
+          ...permissionMode ? { permissionMode } : {},
+          ...builtinToolFiltering ? { builtinToolFiltering } : {},
+          ...debug ? { debug } : {},
+          continue: true
+        });
+      }
+      return control;
+    },
+    doCompact: async (customInstructions) => {
+      const text = customInstructions && customInstructions.trim() ? `/compact ${customInstructions.trim()}` : "/compact";
+      channel.send({ type: "user-message", text });
+    },
+    doDetach: async () => {
+      if (stopped) {
+        throw new Error(
+          `claude-code session ${sessionId} is already stopped; cannot detach.`
+        );
+      }
+      stopped = true;
+      const lastSeenEventId = await channel.suspend();
+      const payload = {
+        type: "resume-session",
+        harnessId: "claude-code",
+        specificationVersion: "harness-v1",
+        data: {
+          bridge: {
+            port: bridgePort,
+            token: bridgeToken,
+            lastSeenEventId,
+            sandboxId
+          }
+        }
+      };
+      return payload;
+    },
+    doDestroy: async () => {
+      if (stopped) return stopPromise;
+      stopped = true;
+      stopPromise = (async () => {
+        channel.beginClose();
+        try {
+          if (!channel.isClosed()) {
+            channel.send({ type: "shutdown" });
+          }
+        } catch {
+        }
+        let stopTimer;
+        try {
+          if (proc) {
+            await Promise.race([
+              proc.wait(),
+              new Promise((resolve) => {
+                stopTimer = setTimeout(resolve, 5e3);
+                stopTimer.unref?.();
+              })
+            ]);
+          }
+        } finally {
+          if (stopTimer) clearTimeout(stopTimer);
+          try {
+            await proc?.kill();
+          } catch {
+          }
+          channel.close();
+        }
+      })();
+      return stopPromise;
+    },
+    doStop: async () => {
+      if (stopped) {
+        throw new Error(
+          `claude-code session ${sessionId} is already stopped; cannot stop.`
+        );
+      }
+      stopped = true;
+      channel.beginClose();
+      const data = channel.isClosed() ? {} : await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          unsub();
+          reject(
+            new Error(
+              `claude-code session ${sessionId} did not reply to detach within 5s.`
+            )
+          );
+        }, 5e3);
+        timer.unref?.();
+        const unsub = channel.on("bridge-detach", (msg) => {
+          clearTimeout(timer);
+          unsub();
+          resolve(msg.data);
+        });
+        try {
+          channel.send({ type: "detach" });
+        } catch (err) {
+          clearTimeout(timer);
+          unsub();
+          reject(err);
+        }
+      });
+      let stopTimer;
+      try {
+        if (proc) {
+          await Promise.race([
+            proc.wait(),
+            new Promise((resolve) => {
+              stopTimer = setTimeout(resolve, 5e3);
+              stopTimer.unref?.();
+            })
+          ]);
+        }
+      } finally {
+        if (stopTimer) clearTimeout(stopTimer);
+        try {
+          await proc?.kill();
+        } catch {
+        }
+        channel.close();
+      }
+      const payload = {
+        type: "resume-session",
+        harnessId: "claude-code",
+        specificationVersion: "harness-v1",
+        data: data ?? {}
+      };
+      return payload;
+    },
+    doSuspendTurn: async () => {
+      if (stopped) {
+        throw new Error(
+          `claude-code session ${sessionId} is stopped; cannot suspend.`
+        );
+      }
+      stopped = true;
+      await channel.interrupt();
+      const lastSeenEventId = await channel.suspend();
+      const payload = {
+        type: "continue-turn",
+        harnessId: "claude-code",
+        specificationVersion: "harness-v1",
+        data: {
+          bridge: {
+            port: bridgePort,
+            token: bridgeToken,
+            lastSeenEventId,
+            sandboxId
+          }
+        }
+      };
+      return payload;
+    }
+  };
+}
+function frameInstructions(instructions, userText) {
+  return `<session-instructions>
+The block below is operating guidance from the system, not a message from the user \u2014 follow it, but do not mention it or attribute it to the user.
+
+${instructions}
+</session-instructions>
+
+<user-message>
+${userText}
+</user-message>`;
+}
+function extractUserText(prompt) {
+  if (typeof prompt === "string") return prompt;
+  const { content } = prompt;
+  if (typeof content === "string") return content;
+  const parts = [];
+  for (const part of content) {
+    if (part.type !== "text") {
+      throw new HarnessCapabilityUnsupportedError({
+        harnessId: "claude-code",
+        message: `The claude-code harness does not yet support user message parts of type '${part.type}'. Pass a string or a user message whose content contains only text parts.`
+      });
+    }
+    parts.push(part.text);
+  }
+  return parts.join("\n\n");
+}
+
+// src/index.ts
+var claudeCode = createClaudeCode();
+export {
+  VERSION,
+  claudeCode,
+  createClaudeCode
+};
+//# sourceMappingURL=index.js.map