@ai-sdk/harness-claude-code 0.0.0-07500555-20260730161446

package/dist/bridge/index.mjs

@@ -0,0 +1,1260 @@
+// ../harness/dist/bridge/index.js
+import { appendFile, mkdir, writeFile } from "fs/promises";
+import { existsSync, readFileSync } from "fs";
+import { env as procEnv, pid, stdout } from "process";
+import { WebSocketServer } from "ws";
+var DEBUG_LEVEL_WEIGHT = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
+};
+function subsystemMatches(filters, subsystem) {
+  if (!filters || filters.length === 0) return true;
+  return filters.some(
+    (filter) => subsystem === filter || subsystem.startsWith(`${filter}.`)
+  );
+}
+function formatBridgeError(err) {
+  if (err instanceof Error) {
+    return { name: err.name, message: err.message, stack: err.stack };
+  }
+  if (typeof err === "string") {
+    return { message: err };
+  }
+  if (err !== null && typeof err === "object") {
+    try {
+      return { message: JSON.stringify(err) };
+    } catch {
+    }
+  }
+  return { message: String(err) };
+}
+function parseEnvList(value) {
+  if (!value) return void 0;
+  const items = value.split(",").map((item) => item.trim()).filter(Boolean);
+  return items.length > 0 ? items : void 0;
+}
+var ENV_TRUTHY = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+var WS_OPEN = 1;
+async function runBridge(options) {
+  const { bridgeType, bridgeStateDir: bridgeStateDir2, onStart, onDetach } = options;
+  const expectedToken = options.token ?? procEnv.BRIDGE_CHANNEL_TOKEN ?? "";
+  const bridgeWsPort = options.port ?? parseInt(procEnv.BRIDGE_WS_PORT ?? "0", 10);
+  const bridgeMetaPath = `${bridgeStateDir2}/bridge-meta.json`;
+  const startConfigPath = `${bridgeStateDir2}/start-config.json`;
+  const rerunStartConfigPath = `${bridgeStateDir2}/rerun-start-config.json`;
+  const eventLogPath = `${bridgeStateDir2}/event-log.ndjson`;
+  try {
+    await mkdir(bridgeStateDir2, { recursive: true });
+  } catch {
+  }
+  let currentBoundPort = 0;
+  let currentTurnState = "init";
+  let activeSocket;
+  let activeSocketReadyForLiveEvents = false;
+  let isFirstTurn = true;
+  let turnAbort;
+  let currentUserMessages;
+  let currentInterruptHandler;
+  let debugConfig;
+  let consoleCaptureInstalled = false;
+  const envDebugEnabled = ENV_TRUTHY.has(
+    (procEnv.HARNESS_DEBUG ?? "").toLowerCase()
+  );
+  let seqCounter = 0;
+  let eventLog = [];
+  let diskBuffer = "";
+  let flushPromise = null;
+  const flushEventsToDisk = async () => {
+    while (diskBuffer.length > 0) {
+      const buf = diskBuffer;
+      diskBuffer = "";
+      await appendFile(eventLogPath, buf).catch(() => {
+      });
+    }
+  };
+  const scheduleEventFlush = () => {
+    if (flushPromise) return;
+    flushPromise = new Promise((resolve) => {
+      setImmediate(() => {
+        void flushEventsToDisk().finally(resolve);
+      });
+    }).finally(() => {
+      flushPromise = null;
+      if (diskBuffer.length > 0) {
+        scheduleEventFlush();
+      }
+    });
+  };
+  const flushPendingEventsToDisk = async () => {
+    if (diskBuffer.length > 0 && !flushPromise) {
+      scheduleEventFlush();
+    }
+    let inFlight = flushPromise;
+    while (inFlight) {
+      await inFlight;
+      inFlight = flushPromise;
+    }
+  };
+  const replayFromDisk = procEnv.BRIDGE_REPLAY_FROM_DISK === "1";
+  if (replayFromDisk && existsSync(eventLogPath)) {
+    try {
+      const lines = readFileSync(eventLogPath, "utf8").split("\n").map((line) => line.trim()).filter(Boolean);
+      eventLog = lines.map((line) => ({
+        seq: JSON.parse(line).seq,
+        line
+      }));
+      seqCounter = eventLog.at(-1)?.seq ?? 0;
+    } catch {
+      eventLog = [];
+      seqCounter = 0;
+    }
+  }
+  const pendingToolResults = /* @__PURE__ */ new Map();
+  const pendingToolApprovals = /* @__PURE__ */ new Map();
+  const writeBridgeMeta = async (state) => {
+    try {
+      await writeFile(
+        bridgeMetaPath,
+        JSON.stringify({
+          type: bridgeType,
+          port: currentBoundPort,
+          state,
+          pid
+        })
+      );
+    } catch {
+    }
+  };
+  const writeStartConfig = async (start) => {
+    try {
+      const serialized = JSON.stringify(start);
+      await writeFile(startConfigPath, serialized);
+      if (!existsSync(rerunStartConfigPath)) {
+        await writeFile(rerunStartConfigPath, serialized);
+      }
+    } catch {
+    }
+  };
+  const sendControl = (msg) => {
+    if (activeSocket?.readyState === WS_OPEN) {
+      try {
+        activeSocket.send(JSON.stringify(msg));
+      } catch {
+      }
+    }
+  };
+  const emit = (event) => {
+    const seq = ++seqCounter;
+    const line = JSON.stringify({ ...event, seq });
+    eventLog.push({ seq, line });
+    diskBuffer += `${line}
+`;
+    scheduleEventFlush();
+    if (activeSocketReadyForLiveEvents && activeSocket?.readyState === WS_OPEN) {
+      try {
+        activeSocket.send(line);
+      } catch {
+      }
+    }
+  };
+  const replay = (ws, afterSeq) => {
+    for (const entry of eventLog) {
+      if (entry.seq > afterSeq && ws.readyState === WS_OPEN) {
+        ws.send(entry.line);
+      }
+    }
+  };
+  const shouldEmitDebugEvent = (level, subsystem) => {
+    if (!debugConfig?.enabled) return false;
+    const threshold = debugConfig.level ?? "debug";
+    if (DEBUG_LEVEL_WEIGHT[level] > DEBUG_LEVEL_WEIGHT[threshold]) return false;
+    return subsystemMatches(debugConfig.subsystems, subsystem);
+  };
+  const rawStdoutWrite = process.stdout.write.bind(process.stdout);
+  const rawStderrWrite = process.stderr.write.bind(process.stderr);
+  const writeErrorToStderr = (input) => {
+    try {
+      const formatted = formatBridgeError(input.error);
+      rawStderrWrite(
+        `[harness:${bridgeType}:error] ${input.message}: ${formatted.message}
+`
+      );
+      if (formatted.stack) {
+        rawStderrWrite(`${formatted.stack}
+`);
+      }
+    } catch {
+    }
+  };
+  const emitWarning = (input) => {
+    try {
+      for (const line of input.message.split("\n")) {
+        if (line.trim().length > 0) {
+          rawStderrWrite(`[harness:${bridgeType}:warn] ${line}
+`);
+        }
+      }
+    } catch {
+    }
+  };
+  const emitError = (input) => {
+    writeErrorToStderr({
+      message: input.message ?? "bridge error",
+      error: input.error
+    });
+    emit({ type: "error", error: serialiseError(input.error) });
+  };
+  const installConsoleCapture = () => {
+    if (consoleCaptureInstalled) return;
+    consoleCaptureInstalled = true;
+    const buffers = {
+      stdout: "",
+      stderr: ""
+    };
+    const patch = (stream, raw) => (chunk, encoding, cb) => {
+      if (debugConfig?.enabled) {
+        try {
+          const enc = typeof encoding === "string" ? encoding : "utf8";
+          const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString(
+            enc
+          );
+          const combined = buffers[stream] + text.replace(/\r\n/g, "\n");
+          const parts = combined.split("\n");
+          buffers[stream] = parts.pop() ?? "";
+          for (const line of parts) {
+            const trimmed = line.replace(/\s+$/, "");
+            if (trimmed) {
+              emit({
+                type: "sandbox-log",
+                source: bridgeType,
+                stream,
+                line: trimmed
+              });
+            }
+          }
+        } catch {
+        }
+      }
+      return raw(
+        chunk,
+        encoding,
+        cb
+      );
+    };
+    process.stdout.write = patch(
+      "stdout",
+      rawStdoutWrite
+    );
+    process.stderr.write = patch(
+      "stderr",
+      rawStderrWrite
+    );
+  };
+  const handleInbound = async (msg, ws) => {
+    switch (msg.type) {
+      case "start": {
+        if (activeSocket !== ws) return;
+        activeSocketReadyForLiveEvents = true;
+        const firstTurn = isFirstTurn;
+        isFirstTurn = false;
+        eventLog = [];
+        diskBuffer = "";
+        void writeFile(eventLogPath, "").catch(() => {
+        });
+        turnAbort = new AbortController();
+        currentTurnState = "running";
+        currentInterruptHandler = void 0;
+        void writeStartConfig(msg);
+        void writeBridgeMeta("running");
+        const startDebug = msg.debug;
+        debugConfig = {
+          enabled: startDebug?.enabled ?? envDebugEnabled,
+          level: startDebug?.level ?? procEnv.HARNESS_DEBUG_LEVEL,
+          subsystems: startDebug?.subsystems ?? parseEnvList(procEnv.HARNESS_DEBUG_SUBSYSTEMS)
+        };
+        if (debugConfig.enabled) {
+          installConsoleCapture();
+        }
+        const turn = {
+          emit,
+          requestToolResult: (toolCallId) => new Promise((resolve) => {
+            pendingToolResults.set(toolCallId, resolve);
+          }),
+          requestToolApproval: (approvalId) => new Promise((resolve) => {
+            pendingToolApprovals.set(approvalId, resolve);
+          }),
+          pendingUserMessages: [],
+          abortSignal: turnAbort.signal,
+          onInterrupt: (handler) => {
+            currentInterruptHandler = handler;
+          },
+          firstTurn,
+          bridgeLog: (input) => {
+            const level = input.level ?? "debug";
+            if (!shouldEmitDebugEvent(level, input.subsystem)) return;
+            emit({
+              type: "debug-event",
+              level,
+              subsystem: input.subsystem,
+              message: input.message,
+              ...input.attrs ? { attrs: input.attrs } : {},
+              ...input.error !== void 0 ? { error: formatBridgeError(input.error) } : {}
+            });
+          },
+          emitWarning,
+          emitError
+        };
+        currentUserMessages = turn.pendingUserMessages;
+        try {
+          await onStart(msg, turn);
+        } catch (err) {
+          emitError({ error: err, message: "bridge turn failed" });
+        } finally {
+          currentInterruptHandler = void 0;
+          currentTurnState = "waiting";
+          void writeBridgeMeta("waiting");
+        }
+        return;
+      }
+      case "tool-result": {
+        const resolver = pendingToolResults.get(msg.toolCallId);
+        if (resolver) {
+          pendingToolResults.delete(msg.toolCallId);
+          resolver({ output: msg.output, isError: msg.isError });
+        }
+        return;
+      }
+      case "tool-approval-response": {
+        const resolver = pendingToolApprovals.get(msg.approvalId);
+        if (resolver) {
+          pendingToolApprovals.delete(msg.approvalId);
+          resolver({ approved: msg.approved, reason: msg.reason });
+        }
+        return;
+      }
+      case "user-message":
+        currentUserMessages?.push(msg.text);
+        return;
+      case "abort":
+        turnAbort?.abort();
+        return;
+      case "interrupt":
+        try {
+          if (pendingToolResults.size === 0 && pendingToolApprovals.size === 0) {
+            if (currentInterruptHandler) {
+              await currentInterruptHandler();
+            } else {
+              turnAbort?.abort();
+            }
+          }
+          sendControl({ type: "bridge-interrupted", ok: true });
+        } catch (err) {
+          sendControl({
+            type: "bridge-interrupted",
+            ok: false,
+            error: serialiseError(err)
+          });
+        }
+        return;
+      case "resume":
+        if (activeSocket !== ws) return;
+        replay(ws, msg.lastSeenEventId);
+        activeSocketReadyForLiveEvents = true;
+        return;
+      case "shutdown":
+        currentTurnState = "done";
+        void writeBridgeMeta("done");
+        drainThenExit(ws, 1e3, "shutdown");
+        return;
+      case "detach": {
+        currentTurnState = "done";
+        void writeBridgeMeta("done");
+        const data = await onDetach?.() ?? {};
+        sendControl({ type: "bridge-detach", data });
+        drainThenExit(ws, 1e3, "detach");
+        return;
+      }
+    }
+  };
+  void writeBridgeMeta("init");
+  const wss = new WebSocketServer({ port: bridgeWsPort, host: "0.0.0.0" });
+  const exit = () => {
+    if (options.onExit) {
+      options.onExit();
+      return;
+    }
+    wss.close(() => process.exit(0));
+    setTimeout(() => process.exit(0), 1e3).unref();
+  };
+  const drainThenExit = (ws, code, reason) => {
+    const start = Date.now();
+    const tick = () => {
+      const drained = ws.bufferedAmount === 0 || ws.readyState !== WS_OPEN;
+      if (drained || Date.now() - start >= 5e3) {
+        void flushPendingEventsToDisk().finally(() => {
+          try {
+            ws.close(code, reason);
+          } finally {
+            exit();
+          }
+        });
+        return;
+      }
+      setTimeout(tick, 10).unref();
+    };
+    tick();
+  };
+  wss.on("listening", () => {
+    const addr = wss.address();
+    currentBoundPort = typeof addr === "object" && addr ? addr.port : 0;
+    currentTurnState = "waiting";
+    void writeBridgeMeta("waiting");
+    stdout.write(
+      JSON.stringify({
+        type: "bridge-ready",
+        port: currentBoundPort
+      }) + "\n"
+    );
+    options.onListening?.(currentBoundPort);
+  });
+  wss.on("connection", (ws, req) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    if (url.searchParams.get("agent_bridge_token") !== expectedToken) {
+      ws.close(1008, "unauthorized");
+      return;
+    }
+    activeSocket = ws;
+    activeSocketReadyForLiveEvents = false;
+    sendControl({
+      type: "bridge-hello",
+      state: currentTurnState,
+      lastSeq: seqCounter
+    });
+    ws.on("message", (raw) => {
+      let parsed;
+      try {
+        const text = typeof raw === "string" ? raw : Buffer.from(raw).toString("utf8");
+        parsed = JSON.parse(text);
+      } catch (err) {
+        sendControl({
+          type: "error",
+          error: `protocol parse error: ${err.message}`
+        });
+        return;
+      }
+      void handleInbound(parsed, ws);
+    });
+    ws.on("close", () => {
+      if (activeSocket === ws) {
+        activeSocket = void 0;
+        activeSocketReadyForLiveEvents = false;
+      }
+    });
+    ws.on("error", () => {
+    });
+  });
+  process.on("uncaughtException", (err) => {
+    emitError({ error: err, message: "uncaught exception" });
+  });
+  process.on("unhandledRejection", (err) => {
+    emitError({ error: err, message: "unhandled rejection" });
+  });
+  await new Promise((resolve, reject) => {
+    if (wss.address() != null) {
+      resolve();
+      return;
+    }
+    wss.once("listening", resolve);
+    wss.once("error", reject);
+  });
+  return {
+    port: currentBoundPort,
+    close: () => new Promise((resolve) => {
+      wss.close(() => resolve());
+    })
+  };
+}
+function serialiseError(err) {
+  if (err instanceof Error) {
+    return { name: err.name, message: err.message, stack: err.stack };
+  }
+  return err;
+}
+
+// src/bridge/compaction-latch.ts
+function createCompactionLatch(emit) {
+  let boundary;
+  let summary;
+  const tryEmit = () => {
+    if (!boundary || summary === void 0) return;
+    emit({
+      type: "compaction",
+      trigger: boundary.trigger,
+      summary,
+      ...boundary.tokensBefore !== void 0 ? { tokensBefore: boundary.tokensBefore } : {},
+      ...boundary.tokensAfter !== void 0 ? { tokensAfter: boundary.tokensAfter } : {}
+    });
+    boundary = void 0;
+    summary = void 0;
+  };
+  return {
+    onBoundary(next) {
+      boundary = next;
+      tryEmit();
+    },
+    onSummary(next) {
+      summary = next;
+      tryEmit();
+    }
+  };
+}
+
+// src/bridge/index.ts
+import { randomUUID } from "crypto";
+import { argv, stdout as stdout2 } from "process";
+import * as claudeAgentSdk from "@anthropic-ai/claude-agent-sdk";
+import * as mcpServerModule from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/bridge/claude-skills-option.ts
+function toClaudeSkillsOption(skills) {
+  return skills && skills.length > 0 ? "all" : void 0;
+}
+
+// src/bridge/json-schema-to-zod.ts
+import { z } from "zod/v4";
+function jsonSchemaToZodShape(input) {
+  const schema = isJsonSchemaObject(input) ? input : {};
+  return toZodShape(schema);
+}
+function toZodShape(schema) {
+  if (!schema?.properties) return {};
+  const required = new Set(schema.required ?? []);
+  const shape = {};
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    const propType = toZodType(propSchema);
+    let propertyType = required.has(key) ? propType : propType.optional();
+    if (propSchema.description) {
+      propertyType = propertyType.describe(propSchema.description);
+    }
+    shape[key] = propertyType;
+  }
+  return shape;
+}
+function toZodType(schema) {
+  if (!schema) return z.any();
+  let zType = zodForConst(schema) ?? zodForEnum(schema) ?? zodForNullableUnion(schema) ?? zodForType(schema);
+  if (isNullable(schema)) zType = zType.nullable();
+  if (schema.description) zType = zType.describe(schema.description);
+  return zType;
+}
+function zodForType(schema) {
+  const types = getNonNullTypes(schema);
+  if (types.length > 1) return z.any();
+  if (Array.isArray(schema.type) && types.length === 0) return z.null();
+  const type = types[0] ?? (schema.properties ? "object" : void 0);
+  switch (type) {
+    case "string":
+      return z.string();
+    case "number":
+      return z.number();
+    case "integer":
+      return z.number().int();
+    case "boolean":
+      return z.boolean();
+    case "array":
+      return z.array(
+        Array.isArray(schema.items) ? z.any() : toZodType(schema.items)
+      );
+    case "object":
+      return z.object(toZodShape(schema));
+    case "null":
+      return z.null();
+    default:
+      return z.any();
+  }
+}
+function zodForConst(schema) {
+  if (!("const" in schema)) return void 0;
+  return isJsonLiteral(schema.const) ? z.literal(schema.const) : z.any();
+}
+function zodForEnum(schema) {
+  if (!Array.isArray(schema.enum)) return void 0;
+  if (!schema.enum.every(isJsonLiteral)) return z.any();
+  return zodForLiterals(schema.enum);
+}
+function zodForNullableUnion(schema) {
+  const unionSchemas = schema.anyOf ?? schema.oneOf;
+  if (!unionSchemas || unionSchemas.length < 2) return void 0;
+  const nonNullSchemas = unionSchemas.filter((item) => !isNullOnlySchema(item));
+  if (nonNullSchemas.length !== 1) return void 0;
+  return toZodType(nonNullSchemas[0]).nullable();
+}
+function zodForLiterals(values) {
+  if (values.length === 0) return z.any();
+  if (values.length === 1) return z.literal(values[0]);
+  const literals = values.map((value) => z.literal(value));
+  return z.union(literals);
+}
+function getNonNullTypes(schema) {
+  return Array.isArray(schema.type) ? schema.type.filter((type) => type !== "null") : [schema.type].filter(Boolean);
+}
+function isNullable(schema) {
+  return schema.nullable === true || Array.isArray(schema.type) && schema.type.includes("null");
+}
+function isNullOnlySchema(schema) {
+  return schema.type === "null" || Array.isArray(schema.type) && schema.type.length === 1 && schema.type[0] === "null" || schema.const === null || Array.isArray(schema.enum) && schema.enum.length === 1 && schema.enum[0] === null;
+}
+function isJsonSchemaObject(input) {
+  return input != null && typeof input === "object" && !Array.isArray(input);
+}
+function isJsonLiteral(value) {
+  return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+}
+
+// src/bridge/index.ts
+var NATIVE_TO_COMMON = {
+  Read: "read",
+  Write: "write",
+  Edit: "edit",
+  Bash: "bash",
+  Glob: "glob",
+  Grep: "grep",
+  WebSearch: "webSearch"
+};
+var PUBLIC_TO_NATIVE = {
+  read: "Read",
+  write: "Write",
+  edit: "Edit",
+  bash: "Bash",
+  glob: "Glob",
+  grep: "Grep",
+  webSearch: "WebSearch",
+  WebFetch: "WebFetch",
+  NotebookEdit: "NotebookEdit",
+  TodoWrite: "TodoWrite",
+  Agent: "Agent",
+  TaskCreate: "TaskCreate",
+  TaskGet: "TaskGet",
+  TaskUpdate: "TaskUpdate",
+  TaskList: "TaskList",
+  TaskStop: "TaskStop",
+  TaskOutput: "TaskOutput",
+  Monitor: "Monitor",
+  ListMcpResources: "ListMcpResources",
+  ReadMcpResource: "ReadMcpResource",
+  ExitPlanMode: "ExitPlanMode",
+  EnterWorktree: "EnterWorktree",
+  ExitWorktree: "ExitWorktree",
+  AskUserQuestion: "AskUserQuestion",
+  Skill: "Skill",
+  ToolSearch: "ToolSearch"
+};
+var PUBLIC_TOOL_NAMES = Object.keys(PUBLIC_TO_NATIVE);
+var UNRECOVERABLE_API_RETRY_STATUSES = /* @__PURE__ */ new Set([401, 403, 404]);
+var NATIVE_TOOL_KINDS = {
+  Read: "readonly",
+  Glob: "readonly",
+  Grep: "readonly",
+  WebSearch: "readonly",
+  WebFetch: "readonly",
+  TaskGet: "readonly",
+  TaskList: "readonly",
+  TaskOutput: "readonly",
+  ListMcpResources: "readonly",
+  ReadMcpResource: "readonly",
+  Write: "edit",
+  Edit: "edit",
+  NotebookEdit: "edit",
+  TodoWrite: "edit",
+  TaskCreate: "edit",
+  TaskUpdate: "edit",
+  TaskStop: "edit",
+  EnterWorktree: "edit",
+  ExitWorktree: "edit",
+  ExitPlanMode: "edit",
+  Skill: "readonly",
+  AskUserQuestion: "readonly",
+  ToolSearch: "readonly",
+  Bash: "bash",
+  Monitor: "bash"
+};
+function toCommonName(nativeName) {
+  return NATIVE_TO_COMMON[nativeName] ?? nativeName;
+}
+function toNativeName(toolName) {
+  return PUBLIC_TO_NATIVE[toolName] ?? toolName;
+}
+function resolveNativeTools(start) {
+  const toolFiltering = start.builtinToolFiltering;
+  if (toolFiltering == null) return void 0;
+  const activeToolNames = toolFiltering.mode === "allow" ? toolFiltering.toolNames : PUBLIC_TOOL_NAMES.filter(
+    (name) => !toolFiltering.toolNames.includes(name)
+  );
+  return activeToolNames.map((name) => toNativeName(name));
+}
+function resolveInactiveNativeTools(start) {
+  const toolFiltering = start.builtinToolFiltering;
+  if (toolFiltering == null) return [];
+  const inactiveToolNames = toolFiltering.mode === "allow" ? PUBLIC_TOOL_NAMES.filter(
+    (name) => !toolFiltering.toolNames.includes(name)
+  ) : toolFiltering.toolNames;
+  return inactiveToolNames.map((name) => toNativeName(name));
+}
+var args = parseArgs(argv.slice(2));
+var workdir = args.workdir;
+var bridgeStateDir = args.bridgeStateDir;
+if (!workdir) {
+  emitFatal("Missing --workdir argument.");
+}
+if (!bridgeStateDir) {
+  emitFatal("Missing --bridge-state-dir argument.");
+}
+var claudeSdk = claudeAgentSdk;
+var mcpModule = mcpServerModule;
+await runBridge({
+  bridgeType: "claude-code",
+  bridgeStateDir,
+  onStart: runTurn,
+  // Claude Code's session state lives in the workdir on the sandbox filesystem
+  // (captured by the sandbox snapshot on stop); the resume payload is empty.
+  onDetach: () => ({})
+});
+function createPermissionOptions(input) {
+  const permissionMode = input.start.permissionMode ?? "allow-all";
+  const inactiveNativeTools = new Set(input.inactiveNativeTools);
+  const permissionSettings = createPermissionSettings({
+    permissionMode,
+    inactiveNativeTools
+  });
+  if (permissionMode === "allow-all" && inactiveNativeTools.size === 0) {
+    return {
+      permissionMode: "bypassPermissions",
+      allowDangerouslySkipPermissions: true
+    };
+  }
+  return {
+    permissionMode: permissionMode === "allow-edits" ? "acceptEdits" : "default",
+    allowDangerouslySkipPermissions: false,
+    ...permissionSettings ? { settings: permissionSettings } : {},
+    canUseTool: async (toolName, toolInput, options) => {
+      if (toolName.startsWith("mcp__harness-tools__")) {
+        return { behavior: "allow", updatedInput: toolInput };
+      }
+      if (!inactiveNativeTools.has(toolName) && !nativeToolRequiresApproval({
+        nativeName: toolName,
+        permissionMode
+      })) {
+        return { behavior: "allow", updatedInput: toolInput };
+      }
+      const approvalId = options.toolUseID;
+      input.approvalRequestedToolUseIds.add(approvalId);
+      input.nativeToolCallNames.set(approvalId, toolName);
+      input.emit({
+        type: "tool-call",
+        toolCallId: approvalId,
+        toolName: toCommonName(toolName),
+        nativeName: toolName,
+        input: JSON.stringify(toolInput ?? {}),
+        providerExecuted: true
+      });
+      input.emit({
+        type: "tool-approval-request",
+        approvalId,
+        toolCallId: approvalId
+      });
+      input.finishApprovalStep(approvalId);
+      const decision = await input.turn.requestToolApproval(approvalId);
+      return decision.approved ? { behavior: "allow", updatedInput: toolInput, toolUseID: approvalId } : {
+        behavior: "deny",
+        message: decision.reason ?? "Denied",
+        toolUseID: approvalId
+      };
+    }
+  };
+}
+function createPermissionSettings(input) {
+  const askRules = /* @__PURE__ */ new Set();
+  for (const [nativeName, kind] of Object.entries(NATIVE_TOOL_KINDS)) {
+    if (input.inactiveNativeTools.has(nativeName) || (input.permissionMode === "allow-reads" ? kind === "edit" || kind === "bash" : input.permissionMode === "allow-edits" ? kind === "bash" : false)) {
+      askRules.add(`${nativeName}(*)`);
+    }
+  }
+  if (askRules.size === 0) return void 0;
+  return {
+    permissions: { ask: [...askRules] },
+    sandbox: { autoAllowBashIfSandboxed: false }
+  };
+}
+function nativeToolRequiresApproval(input) {
+  if (input.permissionMode === "allow-all") return false;
+  const kind = NATIVE_TOOL_KINDS[input.nativeName] ?? "edit";
+  if (input.permissionMode === "allow-edits") return kind === "bash";
+  return kind === "edit" || kind === "bash";
+}
+async function runTurn(start, turn) {
+  const emit = (msg) => turn.emit(msg);
+  const abortCtl = new AbortController();
+  if (turn.abortSignal.aborted) {
+    abortCtl.abort();
+  } else {
+    turn.abortSignal.addEventListener("abort", () => abortCtl.abort(), {
+      once: true
+    });
+  }
+  const nativeToolCallNames = /* @__PURE__ */ new Map();
+  const approvalRequestedToolUseIds = /* @__PURE__ */ new Set();
+  const partialBlocks = /* @__PURE__ */ new Map();
+  let stepUsage;
+  let pendingStepToolUseIds = /* @__PURE__ */ new Set();
+  let pendingStepUsage;
+  let stepOpen = false;
+  const emitFinishStep = (usage) => {
+    emit({
+      type: "finish-step",
+      finishReason: { unified: "stop", raw: "stop" },
+      usage: usage ?? defaultUsage()
+    });
+    stepUsage = usage ?? stepUsage;
+    pendingStepUsage = void 0;
+    pendingStepToolUseIds = /* @__PURE__ */ new Set();
+    stepOpen = false;
+  };
+  const closeStepIfReady = () => {
+    if (!stepOpen || pendingStepToolUseIds.size > 0 || partialBlocks.size > 0) {
+      return;
+    }
+    emitFinishStep(pendingStepUsage);
+  };
+  const mcpToolUseIds = /* @__PURE__ */ new Set();
+  const mcpServers = {};
+  if (start.tools && start.tools.length > 0) {
+    const server = new mcpModule.McpServer({
+      name: "harness-tools",
+      version: "1.0.0"
+    });
+    for (const tool of start.tools) {
+      const shape = jsonSchemaToZodShape(tool.inputSchema);
+      server.tool(
+        tool.name,
+        tool.description ?? "",
+        shape,
+        async (input) => {
+          const toolCallId = randomUUID();
+          emit({
+            type: "tool-call",
+            toolCallId,
+            toolName: tool.name,
+            input: JSON.stringify(input),
+            providerExecuted: false
+          });
+          const { output, isError } = await turn.requestToolResult(toolCallId);
+          emit({
+            type: "tool-result",
+            toolCallId,
+            toolName: tool.name,
+            result: output ?? null,
+            isError: !!isError
+          });
+          return {
+            content: [{ type: "text", text: JSON.stringify(output ?? null) }],
+            isError
+          };
+        }
+      );
+    }
+    mcpServers["harness-tools"] = {
+      type: "sdk",
+      name: "harness-tools",
+      instance: server
+    };
+  }
+  const compaction = createCompactionLatch((event) => emit(event));
+  const queryInput = createQueryInput({
+    initialUserMessage: start.prompt,
+    pendingUserMessages: turn.pendingUserMessages,
+    abortSignal: abortCtl.signal
+  });
+  const skillsOption = toClaudeSkillsOption(start.skills);
+  const nativeTools = resolveNativeTools(start);
+  const inactiveNativeTools = resolveInactiveNativeTools(start);
+  const permissionOptions = createPermissionOptions({
+    start,
+    inactiveNativeTools,
+    turn,
+    emit,
+    finishApprovalStep: (approvalId) => {
+      stepOpen = true;
+      pendingStepToolUseIds.delete(approvalId);
+      closeStepIfReady();
+    },
+    nativeToolCallNames,
+    approvalRequestedToolUseIds
+  });
+  const q = claudeSdk.query({
+    prompt: queryInput.input,
+    options: {
+      ...start.model ? { model: start.model } : {},
+      ...start.maxTurns !== void 0 ? { maxTurns: start.maxTurns } : {},
+      ...skillsOption ? { skills: skillsOption } : {},
+      ...nativeTools !== void 0 ? { tools: nativeTools } : {},
+      ...inactiveNativeTools.length > 0 ? { disallowedTools: inactiveNativeTools } : {},
+      thinking: start.thinking,
+      includePartialMessages: true,
+      // The `PostCompact` hook carries the compaction summary, which the
+      // `compact_boundary` system message does not. Latch it for the unified
+      // `compaction` event; return an empty output so compaction proceeds.
+      hooks: {
+        PostCompact: [
+          {
+            hooks: [
+              async (input) => {
+                if (typeof input?.compact_summary === "string") {
+                  compaction.onSummary(input.compact_summary);
+                }
+                return {};
+              }
+            ]
+          }
+        ]
+      },
+      // Continuation rule: the host can force-continue (resume after a
+      // cross-process detach) by setting `start.continue: true`; otherwise
+      // we continue every subsequent turn after the first one in this
+      // bridge process.
+      ...start.continue === true || !turn.firstTurn ? { continue: true } : {},
+      ...permissionOptions,
+      mcpServers,
+      cwd: workdir,
+      abortSignal: abortCtl.signal
+    }
+  });
+  turn.onInterrupt(() => q.interrupt());
+  let turnUsage;
+  let totalCostUsd;
+  let observedTerminalError;
+  let emittedTerminalError = false;
+  let emittedTerminalFinish = false;
+  let streamStarted = false;
+  const emitTerminalError = (message) => {
+    const normalized = message?.trim();
+    if (!normalized || emittedTerminalError || emittedTerminalFinish) return;
+    observedTerminalError = normalized;
+    emittedTerminalError = true;
+    turn.emitError({
+      error: normalized,
+      message: "claude-code terminal error"
+    });
+    queryInput.close();
+    abortCtl.abort();
+  };
+  try {
+    for await (const msg of q) {
+      if (abortCtl.signal.aborted) break;
+      const type = msg.type;
+      if (!streamStarted) {
+        const initModel = type === "system" && msg.subtype === "init" && typeof msg.model === "string" ? msg.model : void 0;
+        emit({
+          type: "stream-start",
+          ...initModel ? { modelId: initModel } : {}
+        });
+        streamStarted = true;
+      }
+      if (type === "system" && msg.subtype === "api_retry") {
+        if (typeof msg.error_status === "number" && UNRECOVERABLE_API_RETRY_STATUSES.has(msg.error_status)) {
+          emitTerminalError(
+            `HTTP ${msg.error_status}: ${msg.error ?? "provider request failed"}`
+          );
+          continue;
+        }
+        turn.emitWarning({ message: formatApiRetryWarning(msg) });
+        continue;
+      }
+      if (typeof msg.error === "string" && msg.error.trim()) {
+        observedTerminalError = msg.error.trim();
+      }
+      if (type === "auth_status" && typeof msg.error === "string" && msg.error.trim()) {
+        emitTerminalError(msg.error);
+        continue;
+      }
+      if (type === "system" && msg.subtype === "task_updated" && msg.patch?.status === "failed" && typeof msg.patch.error === "string") {
+        emitTerminalError(msg.patch.error);
+        continue;
+      }
+      if (type === "system" && msg.subtype === "compact_boundary") {
+        const meta = msg.compact_metadata;
+        if (meta) {
+          compaction.onBoundary({
+            trigger: meta.trigger,
+            ...typeof meta.pre_tokens === "number" ? { tokensBefore: meta.pre_tokens } : {},
+            ...typeof meta.post_tokens === "number" ? { tokensAfter: meta.post_tokens } : {}
+          });
+        }
+        continue;
+      }
+      if (type === "stream_event") {
+        handleStreamEvent(msg.event, partialBlocks, emit);
+        continue;
+      }
+      if (type === "assistant" && msg.message?.content) {
+        const usage = mapUsage(msg.message.usage);
+        const toolUseIds = [];
+        let opensStep = false;
+        for (const block of msg.message.content) {
+          if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
+            toolUseIds.push(block.id);
+            const mcpPrefix = "mcp__harness-tools__";
+            if (block.name.startsWith(mcpPrefix)) {
+              pendingStepToolUseIds.add(block.id);
+              mcpToolUseIds.add(block.id);
+              opensStep = true;
+              continue;
+            }
+            nativeToolCallNames.set(block.id, block.name);
+            if (approvalRequestedToolUseIds.has(block.id)) {
+              continue;
+            }
+            pendingStepToolUseIds.add(block.id);
+            opensStep = true;
+            emit({
+              type: "tool-call",
+              toolCallId: block.id,
+              toolName: toCommonName(block.name),
+              nativeName: block.name,
+              input: JSON.stringify(block.input ?? {}),
+              providerExecuted: true
+            });
+          }
+        }
+        if (opensStep || toolUseIds.length === 0) {
+          stepOpen = true;
+          if (usage) pendingStepUsage = usage;
+        }
+        continue;
+      }
+      if (type === "user" && msg.message?.content) {
+        for (const block of msg.message.content) {
+          if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+            if (mcpToolUseIds.has(block.tool_use_id)) {
+              mcpToolUseIds.delete(block.tool_use_id);
+              pendingStepToolUseIds.delete(block.tool_use_id);
+              continue;
+            }
+            approvalRequestedToolUseIds.delete(block.tool_use_id);
+            const nativeName = nativeToolCallNames.get(block.tool_use_id) ?? "unknown";
+            nativeToolCallNames.delete(block.tool_use_id);
+            const toolName = toCommonName(nativeName);
+            const isError = !!block.is_error;
+            const content = stringifyContent(block.content);
+            const result = toolName === "bash" ? { exitCode: isError ? 1 : 0, stdout: content } : content;
+            emit({
+              type: "tool-result",
+              toolCallId: block.tool_use_id,
+              toolName,
+              result,
+              isError
+            });
+            pendingStepToolUseIds.delete(block.tool_use_id);
+          }
+        }
+        closeStepIfReady();
+        continue;
+      }
+      if (type === "result") {
+        if (msg.subtype === "success") {
+          const emptyResult = !msg.result?.trim?.();
+          if (emptyResult && observedTerminalError) {
+            emitTerminalError(observedTerminalError);
+            continue;
+          }
+          const usage = msg.usage ?? msg.message?.usage;
+          const harnessUsage = mapUsage(usage);
+          if (harnessUsage) turnUsage = harnessUsage;
+          if (typeof msg.total_cost_usd === "number") {
+            totalCostUsd = (totalCostUsd ?? 0) + msg.total_cost_usd;
+          }
+          if (stepOpen) emitFinishStep(harnessUsage ?? pendingStepUsage);
+          queryInput.close();
+          break;
+        } else {
+          emitTerminalError(
+            (Array.isArray(msg.errors) ? msg.errors.join("\n") : void 0) || observedTerminalError || msg.result || "Unknown error"
+          );
+        }
+        continue;
+      }
+    }
+  } catch (err) {
+    if (!(abortCtl.signal.aborted && emittedTerminalError)) {
+      turn.emitError({ error: err, message: "claude-code turn failed" });
+    }
+    return;
+  } finally {
+    queryInput.close();
+  }
+  if (emittedTerminalError) return;
+  emittedTerminalFinish = true;
+  void emittedTerminalFinish;
+  emit({
+    type: "finish",
+    finishReason: { unified: "stop", raw: "stop" },
+    totalUsage: turnUsage ?? stepUsage ?? defaultUsage(),
+    ...totalCostUsd !== void 0 ? { harnessMetadata: { "claude-code": { costUsd: totalCostUsd } } } : {}
+  });
+}
+function formatApiRetryWarning(msg) {
+  const details = [];
+  if (typeof msg.attempt === "number") {
+    const maxRetries = typeof msg.max_retries === "number" ? `/${msg.max_retries}` : "";
+    details.push(`attempt ${msg.attempt}${maxRetries}`);
+  }
+  if (typeof msg.error_status === "number") {
+    details.push(`HTTP ${msg.error_status}`);
+  }
+  if (typeof msg.retry_delay_ms === "number") {
+    details.push(`retrying in ${msg.retry_delay_ms}ms`);
+  }
+  if (msg.error) details.push(msg.error);
+  return details.length > 0 ? `Claude Code API retry: ${details.join("; ")}` : "Claude Code API retry";
+}
+function handleStreamEvent(event, partialBlocks, send) {
+  if (!event || typeof event.index !== "number") return;
+  const index = event.index;
+  if (event.type === "content_block_start") {
+    const blockType = event.content_block?.type;
+    if (blockType === "text") {
+      const id = randomUUID();
+      partialBlocks.set(index, { id, kind: "text" });
+      send({ type: "text-start", id });
+    } else if (blockType === "thinking") {
+      const id = randomUUID();
+      partialBlocks.set(index, { id, kind: "thinking" });
+      send({ type: "reasoning-start", id });
+    }
+    return;
+  }
+  if (event.type === "content_block_delta") {
+    const block = partialBlocks.get(index);
+    if (!block) return;
+    if (block.kind === "text" && event.delta?.type === "text_delta" && typeof event.delta.text === "string") {
+      send({ type: "text-delta", id: block.id, delta: event.delta.text });
+    } else if (block.kind === "thinking" && event.delta?.type === "thinking_delta" && typeof event.delta.thinking === "string") {
+      send({
+        type: "reasoning-delta",
+        id: block.id,
+        delta: event.delta.thinking
+      });
+    }
+    return;
+  }
+  if (event.type === "content_block_stop") {
+    const block = partialBlocks.get(index);
+    if (!block) return;
+    partialBlocks.delete(index);
+    if (block.kind === "text") {
+      send({ type: "text-end", id: block.id });
+    } else {
+      send({ type: "reasoning-end", id: block.id });
+    }
+  }
+}
+function createQueryInput({
+  initialUserMessage,
+  pendingUserMessages,
+  abortSignal
+}) {
+  let closed = false;
+  const close = () => {
+    closed = true;
+  };
+  if (abortSignal.aborted) {
+    close();
+  } else {
+    abortSignal.addEventListener("abort", close, { once: true });
+  }
+  const toUserMessage = (text) => ({
+    type: "user",
+    message: {
+      role: "user",
+      content: [{ type: "text", text }]
+    }
+  });
+  return {
+    close,
+    input: {
+      [Symbol.asyncIterator]() {
+        let sentInitial = false;
+        return {
+          async next() {
+            while (!closed && !abortSignal.aborted) {
+              if (!sentInitial) {
+                sentInitial = true;
+                return {
+                  value: toUserMessage(initialUserMessage),
+                  done: false
+                };
+              }
+              if (pendingUserMessages.length > 0) {
+                return {
+                  value: toUserMessage(pendingUserMessages.shift()),
+                  done: false
+                };
+              }
+              await new Promise((resolve) => setTimeout(resolve, 50));
+            }
+            return { value: void 0, done: true };
+          }
+        };
+      }
+    }
+  };
+}
+function stringifyContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map(
+      (entry) => entry && typeof entry === "object" && "text" in entry ? String(entry.text ?? "") : JSON.stringify(entry)
+    ).join("");
+  }
+  return JSON.stringify(content);
+}
+function mapUsage(usage) {
+  if (!usage || typeof usage !== "object") return void 0;
+  const u = usage;
+  return {
+    inputTokens: {
+      total: (u.input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0),
+      noCache: u.input_tokens ?? 0,
+      cacheRead: u.cache_read_input_tokens ?? 0,
+      cacheWrite: u.cache_creation_input_tokens ?? 0
+    },
+    outputTokens: {
+      total: u.output_tokens ?? 0,
+      text: u.output_tokens ?? 0
+    }
+  };
+}
+function defaultUsage() {
+  return {
+    inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+    outputTokens: { total: 0, text: 0 }
+  };
+}
+function parseArgs(args2) {
+  const out = {};
+  for (let i = 0; i < args2.length; i++) {
+    if (args2[i] === "--workdir" && i + 1 < args2.length) {
+      out.workdir = args2[++i];
+    } else if (args2[i] === "--bridge-state-dir" && i + 1 < args2.length) {
+      out.bridgeStateDir = args2[++i];
+    }
+  }
+  return out;
+}
+function emitFatal(message) {
+  stdout2.write(JSON.stringify({ type: "bridge-fatal", message }) + "\n");
+  process.exit(1);
+}
+//# sourceMappingURL=index.mjs.map