@rallycry/conveyor-agent 7.3.9 → 8.0.0

package/dist/chunk-3X63JL6C.js

@@ -0,0 +1,919 @@
+// src/harness/types.ts
+function defineTool(name, description, schema, handler, options) {
+  return {
+    name,
+    description,
+    schema,
+    handler,
+    annotations: options?.annotations
+  };
+}
+
+// src/harness/claude-code/index.ts
+import { query, tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
+var ClaudeCodeHarness = class {
+  async *executeQuery(opts) {
+    const sdkEvents = query({
+      prompt: opts.prompt,
+      options: {
+        ...opts.options,
+        ...opts.resume ? { resume: opts.resume } : {},
+        ...opts.options.sessionId ? { sessionId: opts.options.sessionId } : {},
+        ...opts.options.abortController ? { abortController: opts.options.abortController } : {}
+      }
+    });
+    for await (const event of sdkEvents) {
+      yield event;
+    }
+  }
+  createMcpServer(config) {
+    const sdkTools = config.tools.map(
+      (t) => tool(
+        t.name,
+        t.description,
+        t.schema,
+        t.handler,
+        t.annotations ? { annotations: t.annotations } : void 0
+      )
+    );
+    return createSdkMcpServer({ name: config.name, tools: sdkTools });
+  }
+};
+
+// src/harness/pty/session.ts
+import { mkdtemp, mkdir as mkdir2, rm, stat } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join3, dirname } from "path";
+
+// src/harness/pty/event-queue.ts
+var AsyncEventQueue = class {
+  items = [];
+  closed = false;
+  wake = null;
+  push(item) {
+    if (this.closed) return;
+    this.items.push(item);
+    this.signal();
+  }
+  close() {
+    this.closed = true;
+    this.signal();
+  }
+  get isClosed() {
+    return this.closed;
+  }
+  signal() {
+    const wake = this.wake;
+    if (wake) {
+      this.wake = null;
+      wake();
+    }
+  }
+  async *drain() {
+    while (!this.closed || this.items.length > 0) {
+      if (this.items.length > 0) {
+        const item = this.items.shift();
+        if (item !== void 0) yield item;
+        continue;
+      }
+      await new Promise((resolve) => {
+        this.wake = resolve;
+      });
+    }
+  }
+};
+
+// src/harness/pty/hook-socket.ts
+import { createServer } from "net";
+import { unlink } from "fs/promises";
+function parseEnvelope(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const record = parsed;
+  const result = {};
+  if (typeof record.tool_name === "string") result.tool_name = record.tool_name;
+  if (typeof record.elapsed_time_seconds === "number") {
+    result.elapsed_time_seconds = record.elapsed_time_seconds;
+  }
+  return result;
+}
+var HookSocketServer = class {
+  constructor(socketPath, onProgress) {
+    this.socketPath = socketPath;
+    this.onProgress = onProgress;
+  }
+  socketPath;
+  onProgress;
+  server = null;
+  buffer = "";
+  _closed = false;
+  async listen() {
+    await unlink(this.socketPath).catch(() => void 0);
+    await new Promise((resolve, reject) => {
+      const server = createServer((socket) => this.handleConnection(socket));
+      server.on("error", reject);
+      server.listen(this.socketPath, () => {
+        resolve();
+      });
+      this.server = server;
+    });
+  }
+  get isClosed() {
+    return this._closed;
+  }
+  async close() {
+    if (this._closed) return;
+    this._closed = true;
+    const server = this.server;
+    this.server = null;
+    if (server) {
+      await new Promise((resolve) => {
+        server.close(() => {
+          resolve();
+        });
+      });
+    }
+    await unlink(this.socketPath).catch(() => void 0);
+  }
+  handleConnection(socket) {
+    socket.on("error", () => void 0);
+    socket.on("data", (chunk) => {
+      this.buffer += chunk.toString("utf8");
+      this.ingest();
+    });
+  }
+  ingest() {
+    let index = this.buffer.indexOf("\n");
+    while (index >= 0) {
+      const line = this.buffer.slice(0, index);
+      this.buffer = this.buffer.slice(index + 1);
+      const progress = parseEnvelope(line);
+      if (progress) this.onProgress(progress);
+      index = this.buffer.indexOf("\n");
+    }
+  }
+};
+
+// src/harness/pty/jsonl-tailer.ts
+import { open } from "fs/promises";
+
+// src/harness/pty/record-mapper.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isUnknownArray(value) {
+  return Array.isArray(value);
+}
+function stringField(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string") return value;
+  }
+  return void 0;
+}
+function numberField(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number") return value;
+  }
+  return void 0;
+}
+function mapSystem(record) {
+  if (record.subtype !== "init") return null;
+  const event = {
+    type: "system",
+    subtype: "init",
+    model: stringField(record, "model") ?? ""
+  };
+  const sessionId = stringField(record, "session_id", "sessionId");
+  if (sessionId !== void 0) event.session_id = sessionId;
+  return event;
+}
+function mapUsage(message) {
+  const usage = message.usage;
+  if (!isRecord(usage)) return void 0;
+  const result = {};
+  const input = numberField(usage, "input_tokens");
+  const cacheRead = numberField(usage, "cache_read_input_tokens");
+  const cacheCreation = numberField(usage, "cache_creation_input_tokens");
+  if (input !== void 0) result.input_tokens = input;
+  if (cacheRead !== void 0) result.cache_read_input_tokens = cacheRead;
+  if (cacheCreation !== void 0) result.cache_creation_input_tokens = cacheCreation;
+  return result;
+}
+function mapContentBlock(raw) {
+  if (!isRecord(raw)) return null;
+  const type = stringField(raw, "type");
+  if (type === void 0) return null;
+  const block = { type };
+  const text = stringField(raw, "text");
+  if (text !== void 0) block.text = text;
+  const name = stringField(raw, "name");
+  if (name !== void 0) block.name = name;
+  const id = stringField(raw, "id");
+  if (id !== void 0) block.id = id;
+  if ("input" in raw) block.input = raw.input;
+  return block;
+}
+function mapAssistant(record) {
+  const message = record.message;
+  if (!isRecord(message)) return null;
+  const rawContent = isUnknownArray(message.content) ? message.content : [];
+  const content = [];
+  for (const item of rawContent) {
+    const block = mapContentBlock(item);
+    if (block) content.push(block);
+  }
+  const result = {
+    type: "assistant",
+    message: { role: "assistant", content }
+  };
+  const usage = mapUsage(message);
+  if (usage !== void 0) result.message.usage = usage;
+  return result;
+}
+function mapResultSuccess(record) {
+  const event = {
+    type: "result",
+    subtype: "success",
+    result: stringField(record, "result") ?? "",
+    total_cost_usd: numberField(record, "total_cost_usd", "totalCostUsd") ?? 0
+  };
+  const modelUsage = record.modelUsage;
+  if (isRecord(modelUsage)) event.modelUsage = modelUsage;
+  const sessionId = stringField(record, "session_id", "sessionId");
+  if (sessionId !== void 0) event.sessionId = sessionId;
+  return event;
+}
+function mapResultError(record) {
+  const rawErrors = isUnknownArray(record.errors) ? record.errors : [];
+  const errors = rawErrors.filter((e) => typeof e === "string");
+  const event = { type: "result", subtype: "error", errors };
+  const sessionId = stringField(record, "session_id", "sessionId");
+  if (sessionId !== void 0) event.sessionId = sessionId;
+  return event;
+}
+function mapResult(record) {
+  if (record.subtype === "success") return mapResultSuccess(record);
+  if (record.subtype === "error") return mapResultError(record);
+  return null;
+}
+function mapTranscriptRecord(raw) {
+  if (!isRecord(raw)) return null;
+  switch (raw.type) {
+    case "system":
+      return mapSystem(raw);
+    case "assistant":
+      return mapAssistant(raw);
+    case "result":
+      return mapResult(raw);
+    default:
+      return null;
+  }
+}
+
+// src/harness/pty/jsonl-tailer.ts
+var POLL_INTERVAL_MS = 25;
+var JsonlTailer = class {
+  constructor(path, onEvent) {
+    this.path = path;
+    this.onEvent = onEvent;
+  }
+  path;
+  onEvent;
+  offset = 0;
+  buffer = "";
+  timer = null;
+  chain = Promise.resolve();
+  _closed = false;
+  /**
+   * Begin tailing. Pass `fromOffset` to skip bytes already present when the
+   * tail starts (used on resume so the prior session's records aren't replayed).
+   */
+  start(fromOffset = 0) {
+    if (this.timer) return;
+    this.offset = fromOffset;
+    this.timer = setInterval(() => {
+      if (this._closed) return;
+      void this.enqueueRead();
+    }, POLL_INTERVAL_MS);
+  }
+  close() {
+    this._closed = true;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  /** Read any remaining bytes and flush a trailing line without a newline. */
+  async flush() {
+    await this.enqueueRead();
+    if (this.buffer.length > 0) {
+      this.emitLine(this.buffer);
+      this.buffer = "";
+    }
+  }
+  enqueueRead() {
+    this.chain = this.chain.then(() => this.readOnce());
+    return this.chain;
+  }
+  async readOnce() {
+    let handle = null;
+    try {
+      handle = await open(this.path, "r");
+      const stats = await handle.stat();
+      if (stats.size <= this.offset) return;
+      const length = stats.size - this.offset;
+      const buf = Buffer.alloc(length);
+      await handle.read(buf, 0, length, this.offset);
+      this.offset = stats.size;
+      this.consume(buf.toString("utf8"));
+    } catch {
+    } finally {
+      if (handle) await handle.close();
+    }
+  }
+  consume(chunk) {
+    this.buffer += chunk;
+    let index = this.buffer.indexOf("\n");
+    while (index >= 0) {
+      const line = this.buffer.slice(0, index);
+      this.buffer = this.buffer.slice(index + 1);
+      this.emitLine(line);
+      index = this.buffer.indexOf("\n");
+    }
+  }
+  emitLine(line) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    const event = mapTranscriptRecord(parsed);
+    if (event) this.onEvent(event);
+  }
+};
+
+// src/harness/pty/spawn-args.ts
+function resolveClaudeBinary() {
+  return process.env.CONVEYOR_CLAUDE_BIN ?? "claude";
+}
+function buildSpawnArgs(input) {
+  const args = [];
+  if (input.resume) {
+    args.push("--resume", input.resume);
+  } else if (input.sessionId) {
+    args.push("--session-id", input.sessionId);
+  }
+  args.push("--model", input.model);
+  if (input.permissionMode === "bypassPermissions") {
+    args.push("--dangerously-skip-permissions");
+  } else {
+    args.push("--permission-mode", "plan");
+  }
+  args.push("--settings", input.settingsPath);
+  if (input.mcpConfigPath) {
+    args.push("--mcp-config", input.mcpConfigPath);
+    if (input.strictMcpConfig) {
+      args.push("--strict-mcp-config");
+    }
+  }
+  return args;
+}
+
+// src/harness/pty/settings.ts
+import { mkdir, writeFile, chmod } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+function claudeConfigHome() {
+  return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
+}
+function projectSlug(cwd) {
+  return cwd.replace(/\//g, "-");
+}
+function sessionTranscriptPath(cwd, sessionId) {
+  return join(claudeConfigHome(), "projects", projectSlug(cwd), `${sessionId}.jsonl`);
+}
+var HOOK_HELPER_SOURCE = `"use strict";
+const net = require("node:net");
+
+let raw = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+  raw += chunk;
+});
+process.stdin.on("end", () => {
+  let toolName = "";
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.tool_name === "string") toolName = parsed.tool_name;
+  } catch {
+    toolName = "";
+  }
+  relay(toolName);
+});
+
+function relay(toolName) {
+  const socketPath = process.env.CONVEYOR_HOOK_SOCKET;
+  let done = false;
+  const finish = () => {
+    if (done) return;
+    done = true;
+    process.stdout.write(JSON.stringify({ continue: true }));
+    process.exit(0);
+  };
+  const fallback = setTimeout(finish, 250);
+  if (!socketPath) {
+    clearTimeout(fallback);
+    finish();
+    return;
+  }
+  const client = net.connect(socketPath, () => {
+    // PostToolUse does not supply tool duration, so elapsed_time_seconds is
+    // omitted rather than reported as a misleading 0 (the field is optional).
+    const line = JSON.stringify({ tool_name: toolName }) + "\\n";
+    client.write(line, () => {
+      client.end();
+    });
+  });
+  client.on("close", () => {
+    clearTimeout(fallback);
+    finish();
+  });
+  client.on("error", () => {
+    clearTimeout(fallback);
+    finish();
+  });
+}
+`;
+async function writeHookSettings(dir) {
+  const helperPath = join(dir, "hook-helper.cjs");
+  const settingsPath = join(dir, "settings.json");
+  await mkdir(dir, { recursive: true });
+  await writeFile(helperPath, HOOK_HELPER_SOURCE, "utf8");
+  await chmod(helperPath, 493);
+  const settings = {
+    // Auto-approve every tool call so the interactive (PTY) agent never stops to
+    // prompt the viewer. This only suppresses the per-tool approval prompt — it
+    // does NOT relax the planning gate: in discovery/plan mode the spawn passes
+    // `--permission-mode plan`, which keeps the agent read-only (no edits/commits
+    // until it exits plan mode) regardless of this allow-list. In build mode the
+    // spawn already bypasses prompts via `--dangerously-skip-permissions`.
+    // `mcp__conveyor` is listed explicitly so the agent's Conveyor tools are
+    // covered even if the `*` wildcard doesn't match MCP tool names.
+    permissions: {
+      allow: ["*", "mcp__conveyor"]
+    },
+    hooks: {
+      PostToolUse: [
+        {
+          matcher: "*",
+          hooks: [{ type: "command", command: `node ${JSON.stringify(helperPath)}` }]
+        }
+      ]
+    }
+  };
+  await writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf8");
+  return { settingsPath, helperPath };
+}
+
+// src/harness/pty/tool-server.ts
+import { createServer as createServer2 } from "http";
+import { writeFile as writeFile2 } from "fs/promises";
+import { join as join2 } from "path";
+import { randomBytes } from "crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+
+// src/harness/pty/mcp-server.ts
+var PtyMcpServer = class {
+  constructor(name, tools) {
+    this.name = name;
+    this.tools = tools;
+  }
+  name;
+  tools;
+  getTool(name) {
+    return this.tools.find((tool2) => tool2.name === name);
+  }
+  invokeTool(name, input) {
+    const tool2 = this.getTool(name);
+    if (!tool2) return Promise.reject(new Error(`Unknown tool: ${name}`));
+    return tool2.handler(input);
+  }
+};
+
+// src/harness/pty/tool-server.ts
+var LOOPBACK = "127.0.0.1";
+var PtyToolServer = class {
+  constructor(name, tools) {
+    this.name = name;
+    this.tools = tools;
+  }
+  name;
+  tools;
+  http = null;
+  transport = null;
+  mcp = null;
+  token = randomBytes(24).toString("base64url");
+  async start() {
+    const mcp = new McpServer({ name: this.name, version: "1.0.0" });
+    const register = mcp.tool.bind(mcp);
+    for (const tool2 of this.tools) {
+      register(tool2.name, tool2.description, tool2.schema, (args) => tool2.handler(args));
+    }
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => randomBytes(16).toString("hex"),
+      enableJsonResponse: true
+    });
+    await mcp.connect(transport);
+    const server = createServer2((req, res) => {
+      void this.handle(req, res, transport);
+    });
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(0, LOOPBACK, () => resolve());
+    });
+    const address = server.address();
+    const port = address && typeof address === "object" ? address.port : 0;
+    this.http = server;
+    this.transport = transport;
+    this.mcp = mcp;
+    return { url: `http://${LOOPBACK}:${port}/mcp`, token: this.token };
+  }
+  async handle(req, res, transport) {
+    if (req.headers.authorization !== `Bearer ${this.token}`) {
+      res.writeHead(401).end();
+      return;
+    }
+    try {
+      await transport.handleRequest(req, res);
+    } catch {
+      if (res.headersSent) res.end();
+      else res.writeHead(500).end();
+    }
+  }
+  async close() {
+    try {
+      await this.transport?.close();
+    } catch {
+    }
+    this.transport = null;
+    try {
+      await this.mcp?.close();
+    } catch {
+    }
+    this.mcp = null;
+    const http = this.http;
+    this.http = null;
+    if (http) {
+      await new Promise((resolve) => {
+        http.close(() => resolve());
+      });
+    }
+  }
+};
+async function startToolServers(mcpServers, tempDir) {
+  const servers = [];
+  const config = {};
+  for (const [name, handle] of Object.entries(mcpServers)) {
+    const tools = handle instanceof PtyMcpServer ? handle.tools : [];
+    if (tools.length === 0) continue;
+    const server = new PtyToolServer(name, tools);
+    const { url, token } = await server.start();
+    servers.push(server);
+    config[name] = { type: "http", url, headers: { Authorization: `Bearer ${token}` } };
+  }
+  if (Object.keys(config).length === 0) return { servers, mcpConfigPath: null };
+  const mcpConfigPath = join2(tempDir, "mcp-config.json");
+  await writeFile2(mcpConfigPath, JSON.stringify({ mcpServers: config }, null, 2), "utf8");
+  return { servers, mcpConfigPath };
+}
+
+// src/harness/pty/session.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function extractSpawn(mod) {
+  if (!isRecord2(mod)) return null;
+  if (typeof mod.spawn === "function") return mod.spawn;
+  const def = mod.default;
+  if (isRecord2(def) && typeof def.spawn === "function") return def.spawn;
+  return null;
+}
+async function loadPtySpawn() {
+  const mod = await import("node-pty");
+  const spawn = extractSpawn(mod);
+  if (!spawn) throw new Error("node-pty: spawn export not found");
+  return spawn;
+}
+function inheritedEnv(socketPath) {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string") env[key] = value;
+  }
+  env.CONVEYOR_HOOK_SOCKET = socketPath;
+  return env;
+}
+async function transcriptSize(path) {
+  try {
+    return (await stat(path)).size;
+  } catch {
+    return 0;
+  }
+}
+var PtySession = class {
+  constructor(prompt, options, resume, bridge) {
+    this.prompt = prompt;
+    this.options = options;
+    this.resume = resume;
+    this.bridge = bridge;
+  }
+  prompt;
+  options;
+  resume;
+  bridge;
+  queue = new AsyncEventQueue();
+  socket = null;
+  tailer = null;
+  pty = null;
+  tempDir = "";
+  sawResult = false;
+  _toreDown = false;
+  exitListeners = [];
+  idleListeners = [];
+  abortHandler = null;
+  cols = 120;
+  rows = 40;
+  unsubInput = null;
+  unsubResize = null;
+  // In-process HTTP MCP servers exposing the harness tools to the spawned CLI,
+  // plus the path to the `--mcp-config` that points at them.
+  toolServers = [];
+  mcpConfigPath = null;
+  onIdle(listener) {
+    this.idleListeners.push(listener);
+  }
+  onExit(listener) {
+    this.exitListeners.push(listener);
+  }
+  get isToreDown() {
+    return this._toreDown;
+  }
+  get hookSocketPath() {
+    return this.socket ? this.socket.socketPath : null;
+  }
+  events() {
+    return this.queue.drain();
+  }
+  async start() {
+    const sessionId = this.resume ?? this.options.sessionId;
+    if (!sessionId) {
+      throw new Error("PtySession requires options.sessionId or a resume target");
+    }
+    const signal = this.options.abortController?.signal;
+    if (signal?.aborted) {
+      await this.teardown();
+      return;
+    }
+    try {
+      this.tempDir = await mkdtemp(join3(tmpdir(), "conveyor-pty-"));
+      const socketPath = join3(this.tempDir, "hook.sock");
+      this.socket = new HookSocketServer(socketPath, (progress) => this.handleProgress(progress));
+      await this.socket.listen();
+      const { settingsPath } = await writeHookSettings(this.tempDir);
+      await this.setupToolServers();
+      const transcriptPath = sessionTranscriptPath(this.options.cwd, sessionId);
+      await mkdir2(dirname(transcriptPath), { recursive: true });
+      const startOffset = this.resume ? await transcriptSize(transcriptPath) : 0;
+      this.tailer = new JsonlTailer(transcriptPath, (event) => this.handleTranscriptEvent(event));
+      this.tailer.start(startOffset);
+      await this.spawn(settingsPath, socketPath);
+      if (signal) {
+        this.abortHandler = () => {
+          void this.teardown();
+        };
+        signal.addEventListener("abort", this.abortHandler, { once: true });
+        if (signal.aborted) {
+          await this.teardown();
+          return;
+        }
+      }
+      if (this.bridge) {
+        this.unsubInput = this.bridge.onInput((data) => this.writeStdin(data));
+        this.unsubResize = this.bridge.onResize((cols, rows) => this.resizePty(cols, rows));
+      }
+      await this.feedPrompt();
+    } catch (err) {
+      await this.teardown();
+      throw err;
+    }
+  }
+  writeStdin(text) {
+    this.pty?.write(text);
+  }
+  /** Apply a relayed resize to the live pty (reconciled dims from the server). */
+  resizePty(cols, rows) {
+    if (cols <= 0 || rows <= 0) return;
+    this.cols = cols;
+    this.rows = rows;
+    try {
+      this.pty?.resize(cols, rows);
+    } catch {
+    }
+  }
+  async teardown() {
+    if (this._toreDown) return;
+    this._toreDown = true;
+    this.unsubInput?.();
+    this.unsubInput = null;
+    this.unsubResize?.();
+    this.unsubResize = null;
+    if (this.abortHandler) {
+      this.options.abortController?.signal.removeEventListener("abort", this.abortHandler);
+      this.abortHandler = null;
+    }
+    try {
+      this.pty?.kill();
+    } catch {
+    }
+    this.pty = null;
+    this.tailer?.close();
+    this.tailer = null;
+    if (this.socket) {
+      await this.socket.close();
+      this.socket = null;
+    }
+    for (const toolServer of this.toolServers) {
+      try {
+        await toolServer.close();
+      } catch {
+      }
+    }
+    this.toolServers = [];
+    this.mcpConfigPath = null;
+    this.queue.close();
+    if (this.tempDir) {
+      await rm(this.tempDir, { recursive: true, force: true });
+      this.tempDir = "";
+    }
+  }
+  /**
+   * Serve the harness's in-process tools to the spawned CLI over loopback HTTP
+   * (handlers run in THIS process against the live task-token connection) and
+   * record the `--mcp-config` path for spawn(). No-op when the harness was
+   * constructed without tools (e.g. SDK-only callers).
+   */
+  async setupToolServers() {
+    const { servers, mcpConfigPath } = await startToolServers(
+      this.options.mcpServers ?? {},
+      this.tempDir
+    );
+    this.toolServers = servers;
+    this.mcpConfigPath = mcpConfigPath;
+  }
+  async spawn(settingsPath, socketPath) {
+    const args = buildSpawnArgs({
+      resume: this.resume,
+      sessionId: this.options.sessionId,
+      model: this.options.model,
+      permissionMode: this.options.permissionMode,
+      settingsPath,
+      // Only this config: ignore the user's ~/.claude.json / project .mcp.json
+      // so the agent's tool set is deterministic (and a stale personal conveyor
+      // server doesn't load).
+      ...this.mcpConfigPath ? { mcpConfigPath: this.mcpConfigPath, strictMcpConfig: true } : {}
+    });
+    const spawn = await loadPtySpawn();
+    const pty = spawn(resolveClaudeBinary(), args, {
+      name: "xterm-color",
+      cols: this.cols,
+      rows: this.rows,
+      cwd: this.options.cwd,
+      env: inheritedEnv(socketPath)
+    });
+    pty.onData((data) => {
+      this.bridge?.sendOutput(data, { cols: this.cols, rows: this.rows });
+    });
+    pty.onExit((event) => {
+      void this.finalizeOnExit(event.exitCode);
+    });
+    this.pty = pty;
+  }
+  async feedPrompt() {
+    if (typeof this.prompt === "string") {
+      this.writeStdin(`${this.prompt}\r`);
+      return;
+    }
+    for await (const message of this.prompt) {
+      const content = message.message.content;
+      const text = typeof content === "string" ? content : JSON.stringify(content);
+      this.writeStdin(`${text}\r`);
+    }
+  }
+  handleProgress(progress) {
+    this.queue.push({
+      type: "tool_progress",
+      ...progress.tool_name === void 0 ? {} : { tool_name: progress.tool_name },
+      ...progress.elapsed_time_seconds === void 0 ? {} : { elapsed_time_seconds: progress.elapsed_time_seconds }
+    });
+  }
+  handleTranscriptEvent(event) {
+    this.queue.push(event);
+    if (event.type === "result") {
+      this.sawResult = true;
+      for (const listener of this.idleListeners) listener();
+      this.queue.close();
+    }
+  }
+  async finalizeOnExit(exitCode) {
+    if (this._toreDown) return;
+    if (this.tailer) {
+      this.tailer.close();
+      await this.tailer.flush();
+    }
+    if (!this.sawResult) {
+      this.queue.push({
+        type: "result",
+        subtype: "error",
+        errors: [`claude exited (code ${exitCode}) without a result`]
+      });
+    }
+    for (const listener of this.exitListeners) listener(exitCode);
+    this.queue.close();
+  }
+};
+
+// src/harness/pty/index.ts
+var PtyHarness = class {
+  /**
+   * `bridge` relays raw terminal I/O to/from the S2 server (and on to the S5
+   * terminal). It is undefined for SDK-only callers and PTY runs that never
+   * attach a relay; the session simply discards stdout in that case.
+   */
+  constructor(bridge) {
+    this.bridge = bridge;
+  }
+  bridge;
+  async *executeQuery(opts) {
+    const session = new PtySession(
+      opts.prompt,
+      opts.options,
+      opts.resume ?? opts.options.resume,
+      this.bridge
+    );
+    await session.start();
+    try {
+      for await (const event of session.events()) {
+        yield event;
+      }
+    } finally {
+      await session.teardown();
+    }
+  }
+  createMcpServer(config) {
+    return new PtyMcpServer(config.name, config.tools);
+  }
+};
+
+// src/harness/index.ts
+function createHarness(kind = "sdk", ptyBridge) {
+  return kind === "pty" ? new PtyHarness(ptyBridge) : new ClaudeCodeHarness();
+}
+
+// src/utils/logger.ts
+function createServiceLogger(service) {
+  const prefix = `[conveyor-agent:${service}]`;
+  return {
+    info(message, data) {
+      const extra = data ? ` ${JSON.stringify(data)}` : "";
+      process.stderr.write(`${prefix} ${message}${extra}
+`);
+    },
+    warn(message, data) {
+      const extra = data ? ` ${JSON.stringify(data)}` : "";
+      process.stderr.write(`${prefix} WARN ${message}${extra}
+`);
+    },
+    error(message, data) {
+      const extra = data ? ` ${JSON.stringify(data)}` : "";
+      process.stderr.write(`${prefix} ERROR ${message}${extra}
+`);
+    }
+  };
+}
+
+export {
+  defineTool,
+  createHarness,
+  createServiceLogger
+};
+//# sourceMappingURL=chunk-3X63JL6C.js.map