lark-to-codex 0.1.0

package/dist/index.js

@@ -0,0 +1,879 @@
+// src/card/tool-render.ts
+var HEADER_SUMMARY_MAX = 80;
+var BODY_FIELD_MAX = 600;
+var OUTPUT_MAX = 1200;
+var BODY_TOTAL_MAX = 2500;
+function toolHeaderText(tool) {
+  const icon = tool.status === "done" ? "\u2705" : tool.status === "error" ? "\u274C" : "\u23F3";
+  const summary = summarizeInput(tool.name, tool.input);
+  return summary ? `${icon} **${tool.name}** \u2014 ${summary}` : `${icon} **${tool.name}**`;
+}
+function toolBodyMd(tool) {
+  const parts = [];
+  const inputMd = renderInput(tool);
+  if (inputMd) parts.push(inputMd);
+  if (tool.output) {
+    const truncated = truncate(tool.output, OUTPUT_MAX);
+    if (tool.status === "error") {
+      parts.push(`**Error**
+\`\`\`
+${truncated}
+\`\`\``);
+    } else if (tool.name === "Bash") {
+      parts.push(renderBashOutput(truncated));
+    } else {
+      parts.push(`**Output**
+\`\`\`
+${truncated}
+\`\`\``);
+    }
+  } else if (tool.status === "running") {
+    parts.push("_\u8FD0\u884C\u4E2D\u2026_");
+  }
+  const body = parts.join("\n\n");
+  if (body.length <= BODY_TOTAL_MAX) return body;
+  return `${body.slice(0, BODY_TOTAL_MAX)}\u2026
+
+_\uFF08body \u5DF2\u622A\u65AD,\u5B8C\u6574\u5185\u5BB9\u67E5 \`/doctor\` \u6216\u65E5\u5FD7\uFF09_`;
+}
+function summarizeInput(name, input) {
+  if (!input || typeof input !== "object") return "";
+  const rec = input;
+  const pick = (key, max = HEADER_SUMMARY_MAX) => {
+    const v = rec[key];
+    if (typeof v !== "string") return "";
+    const oneLine = v.replace(/\s+/g, " ").trim();
+    return oneLine.length > max ? `${oneLine.slice(0, max)}\u2026` : oneLine;
+  };
+  switch (name) {
+    case "Bash":
+      return pick("command");
+    case "Read":
+    case "Edit":
+    case "Write":
+    case "NotebookEdit":
+      return shortenPath(pick("file_path"));
+    case "Grep": {
+      const pat = pick("pattern", 40);
+      const path = pick("path", 30);
+      return path ? `${pat} in ${shortenPath(path)}` : pat;
+    }
+    case "Glob":
+      return pick("pattern");
+    case "WebFetch":
+      return pick("url");
+    case "WebSearch":
+      return pick("query", 60);
+    case "Agent":
+    case "Task":
+      return pick("description") || pick("subagent_type");
+    default:
+      return pick("command") || pick("file_path") || pick("path") || pick("query");
+  }
+}
+function renderInput(tool) {
+  const input = tool.input;
+  if (!input || typeof input !== "object") return "";
+  const rec = input;
+  const str = (k) => typeof rec[k] === "string" ? rec[k] : "";
+  switch (tool.name) {
+    case "Bash": {
+      const cmd = str("command");
+      return cmd ? `**Command**
+\`\`\`bash
+${truncate(cmd, BODY_FIELD_MAX)}
+\`\`\`` : "";
+    }
+    case "Read":
+    case "Edit":
+    case "Write":
+    case "NotebookEdit": {
+      const fp = str("file_path");
+      return fp ? `**File** \`${fp}\`` : "";
+    }
+    case "Grep": {
+      const lines = [];
+      if (str("pattern")) lines.push(`**Pattern** \`${str("pattern")}\``);
+      if (str("path")) lines.push(`**Path** \`${str("path")}\``);
+      return lines.join("\n");
+    }
+    case "WebFetch":
+      return str("url") ? `**URL** ${str("url")}` : "";
+    case "WebSearch":
+      return str("query") ? `**Query** \`${truncate(str("query"), BODY_FIELD_MAX)}\`` : "";
+    default:
+      return "";
+  }
+}
+function renderBashOutput(out) {
+  return `**Output**
+\`\`\`
+${out}
+\`\`\``;
+}
+function shortenPath(p) {
+  if (!p) return p;
+  const home = process.env.HOME || "";
+  if (home && p.startsWith(home)) return `~${p.slice(home.length)}`;
+  return p;
+}
+function truncate(s, max) {
+  return s.length > max ? `${s.slice(0, max)}\u2026` : s;
+}
+
+// src/card/run-renderer.ts
+var REASONING_MAX = 1500;
+var COLLAPSE_TOOL_THRESHOLD = 3;
+function renderCard(state) {
+  const elements = [];
+  if (state.terminal === "running" && state.reasoning.content) {
+    elements.push(reasoningPanel(state.reasoning.content, state.reasoning.active));
+  }
+  for (const group of groupBlocks(state.blocks)) {
+    if (group.kind === "text") {
+      if (group.content.trim()) {
+        elements.push(markdown(group.content));
+      }
+    } else {
+      elements.push(...renderToolGroup(group.tools, state.terminal !== "running"));
+    }
+  }
+  if (state.terminal === "interrupted") {
+    elements.push(noteMd("_\u23F9 \u5DF2\u88AB\u4E2D\u65AD_"));
+  } else if (state.terminal === "idle_timeout") {
+    const mins = state.idleTimeoutMinutes ?? 0;
+    elements.push(noteMd(`_\u23F1 ${mins} \u5206\u949F\u65E0\u54CD\u5E94,\u5DF2\u81EA\u52A8\u7EC8\u6B62_`));
+  } else if (state.terminal === "error" && state.errorMsg) {
+    elements.push(noteMd(`\u26A0\uFE0F agent \u5931\u8D25\uFF1A${state.errorMsg}`));
+  } else if (state.terminal === "done" && elements.length === 0) {
+    elements.push(noteMd("_\uFF08\u672A\u8FD4\u56DE\u5185\u5BB9\uFF09_"));
+  }
+  if (state.terminal === "running") {
+    if (state.footer) elements.push(footerStatus(state.footer));
+    elements.push(stopButton());
+  }
+  return {
+    schema: "2.0",
+    config: {
+      streaming_mode: state.terminal === "running",
+      summary: { content: summaryText(state) }
+    },
+    body: { elements }
+  };
+}
+function* groupBlocks(blocks) {
+  let toolBuf = [];
+  for (const b of blocks) {
+    if (b.kind === "tool") {
+      toolBuf.push(b.tool);
+    } else {
+      if (toolBuf.length > 0) {
+        yield { kind: "tools", tools: toolBuf };
+        toolBuf = [];
+      }
+      yield { kind: "text", content: b.content };
+    }
+  }
+  if (toolBuf.length > 0) yield { kind: "tools", tools: toolBuf };
+}
+function renderToolGroup(tools, finalized) {
+  if (tools.length === 0) return [];
+  if (tools.length < COLLAPSE_TOOL_THRESHOLD) {
+    return tools.map((t) => toolPanel(t, false));
+  }
+  if (finalized) {
+    return [collapsedToolSummary(tools, true)];
+  }
+  const prior = tools.slice(0, -1);
+  const latest = tools[tools.length - 1];
+  const out = [];
+  if (prior.length > 0) out.push(collapsedToolSummary(prior, false));
+  if (latest) out.push(toolPanel(latest, true));
+  return out;
+}
+function reasoningPanel(content, active) {
+  const title = active ? "\u{1F9E0} **\u601D\u8003\u4E2D**" : "\u{1F9E0} **\u601D\u8003\u5B8C\u6210\uFF0C\u70B9\u51FB\u67E5\u770B**";
+  return collapsiblePanel({
+    title,
+    expanded: active,
+    border: "grey",
+    body: truncate2(content, REASONING_MAX)
+  });
+}
+function toolPanel(tool, expanded) {
+  return collapsiblePanel({
+    title: toolHeaderText(tool),
+    expanded,
+    border: tool.status === "error" ? "red" : "grey",
+    body: toolBodyMd(tool) || "_\u65E0\u8F93\u51FA_"
+  });
+}
+function collapsedToolSummary(tools, finalized) {
+  const suffix = finalized ? "\uFF08\u5DF2\u7ED3\u675F\uFF09" : "";
+  const title = `\u2615 **${tools.length} \u4E2A\u5DE5\u5177\u8C03\u7528${suffix}**`;
+  const headerList = tools.map((t) => `- ${toolHeaderText(t)}`).join("\n");
+  return {
+    tag: "collapsible_panel",
+    expanded: false,
+    header: panelHeader(title),
+    border: { color: "blue", corner_radius: "5px" },
+    vertical_spacing: "8px",
+    padding: "8px 8px 8px 8px",
+    elements: [{ tag: "markdown", content: headerList, text_size: "notation" }]
+  };
+}
+function collapsiblePanel(opts) {
+  return {
+    tag: "collapsible_panel",
+    expanded: opts.expanded,
+    header: panelHeader(opts.title),
+    border: { color: opts.border, corner_radius: "5px" },
+    vertical_spacing: "8px",
+    padding: "8px 8px 8px 8px",
+    elements: [{ tag: "markdown", content: opts.body, text_size: "notation" }]
+  };
+}
+function panelHeader(titleMd) {
+  return {
+    title: { tag: "markdown", content: titleMd },
+    vertical_align: "center",
+    icon: { tag: "standard_icon", token: "down-small-ccm_outlined", size: "16px 16px" },
+    icon_position: "follow_text",
+    icon_expanded_angle: -180
+  };
+}
+function markdown(content) {
+  return { tag: "markdown", content };
+}
+function noteMd(content) {
+  return { tag: "markdown", content, text_size: "notation" };
+}
+function stopButton() {
+  return {
+    tag: "button",
+    text: { tag: "plain_text", content: "\u23F9 \u7EC8\u6B62" },
+    type: "danger",
+    behaviors: [{ type: "callback", value: { cmd: "stop" } }]
+  };
+}
+function footerStatus(status) {
+  const text = status === "thinking" ? "\u{1F9E0} \u6B63\u5728\u601D\u8003" : status === "tool_running" ? "\u{1F9F0} \u6B63\u5728\u8C03\u7528\u5DE5\u5177" : "\u270D\uFE0F \u6B63\u5728\u8F93\u51FA";
+  return noteMd(text);
+}
+function summaryText(state) {
+  if (state.terminal === "interrupted") return "\u5DF2\u4E2D\u65AD";
+  if (state.terminal === "idle_timeout") return "\u5DF2\u8D85\u65F6";
+  if (state.terminal === "error") return "\u51FA\u9519";
+  if (state.terminal === "done") return "\u5DF2\u5B8C\u6210";
+  if (state.footer === "tool_running") return "\u6B63\u5728\u8C03\u7528\u5DE5\u5177";
+  if (state.footer === "streaming") return "\u6B63\u5728\u8F93\u51FA";
+  return "\u601D\u8003\u4E2D";
+}
+function truncate2(s, max) {
+  return s.length > max ? `${s.slice(0, max)}\u2026` : s;
+}
+
+// src/card/text-renderer.ts
+function renderText(state) {
+  const parts = [];
+  for (const block of state.blocks) {
+    const piece = renderBlock(block);
+    if (piece) parts.push(piece);
+  }
+  if (state.terminal === "interrupted") {
+    parts.push("_\u23F9 \u5DF2\u88AB\u4E2D\u65AD_");
+  } else if (state.terminal === "idle_timeout") {
+    const mins = state.idleTimeoutMinutes ?? 0;
+    parts.push(`_\u23F1 ${mins} \u5206\u949F\u65E0\u54CD\u5E94,\u5DF2\u81EA\u52A8\u7EC8\u6B62_`);
+  } else if (state.terminal === "error" && state.errorMsg) {
+    parts.push(`\u26A0\uFE0F agent \u5931\u8D25:${state.errorMsg}`);
+  } else if (state.terminal === "running" && state.footer) {
+    parts.push(footerLine(state.footer));
+  }
+  return parts.join("\n\n");
+}
+function renderBlock(block) {
+  if (block.kind === "text") {
+    return block.content.trim();
+  }
+  return toolLine(block.tool);
+}
+function toolLine(tool) {
+  return `> ${toolHeaderText(tool)}`;
+}
+function footerLine(status) {
+  if (status === "thinking") return "_\u{1F9E0} \u6B63\u5728\u601D\u8003\u2026_";
+  if (status === "tool_running") return "_\u{1F9F0} \u6B63\u5728\u8C03\u7528\u5DE5\u5177\u2026_";
+  return "_\u270D\uFE0F \u6B63\u5728\u8F93\u51FA\u2026_";
+}
+
+// src/agent/codex/adapter.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+
+// src/core/logger.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { createWriteStream, mkdirSync } from "fs";
+import { open, readdir, rm, stat } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/config/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+var appDir = join(homedir(), ".lark-channel");
+var paths = {
+  appDir,
+  cacheDir: appDir,
+  configFile: join(appDir, "config.json"),
+  sessionsFile: join(appDir, "sessions.json"),
+  workspacesFile: join(appDir, "workspaces.json"),
+  processesFile: join(appDir, "processes.json"),
+  secretsFile: join(appDir, "secrets.enc"),
+  keystoreSaltFile: join(appDir, ".keystore.salt"),
+  /**
+   * Thin shell wrapper that lark-cli (and other openclaw-exec-protocol
+   * consumers) invoke to resolve secrets from the bridge's encrypted store.
+   * Written user-owned and non-symlinked so it passes lark-cli's
+   * AssertSecurePath audit on machines where `node` is a Homebrew/Volta
+   * symlink or root-owned (`/usr/bin/node`). Wrapper internals do the
+   * `node ... secrets get` invocation; lark-cli only audits the wrapper.
+   */
+  secretsGetterScript: join(appDir, "secrets-getter"),
+  mediaDir: join(appDir, "media")
+};
+var legacyPaths = {
+  appDir: join(
+    process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"),
+    "lark-to-codex"
+  ),
+  cacheDir: join(
+    process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache"),
+    "lark-to-codex"
+  )
+};
+
+// src/core/logger.ts
+var LOG_RETENTION_DAYS = Math.max(
+  1,
+  Number(process.env.LARK_CHANNEL_LOG_DAYS ?? 7) || 7
+);
+var STDOUT_INFO_ALLOWLIST = /* @__PURE__ */ new Set([
+  "ws.connected",
+  "ws.reconnecting",
+  "ws.reconnected",
+  "intake.enter",
+  "card.final"
+]);
+var als = new AsyncLocalStorage();
+var stream = null;
+var currentDate = "";
+function todayKey() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function logsDir() {
+  return join2(paths.appDir, "logs");
+}
+function getStream() {
+  const today = todayKey();
+  if (stream && currentDate === today) return stream;
+  if (stream) {
+    try {
+      stream.end();
+    } catch {
+    }
+  }
+  try {
+    mkdirSync(logsDir(), { recursive: true });
+    stream = createWriteStream(join2(logsDir(), `${today}.log`), { flags: "a" });
+    currentDate = today;
+    return stream;
+  } catch {
+    return null;
+  }
+}
+var RESERVED_KEYS = /* @__PURE__ */ new Set([
+  "ts",
+  "level",
+  "phase",
+  "event",
+  "traceId",
+  "chatId",
+  "msgId"
+]);
+function emit(level, phase, event, fields = {}) {
+  const ctx = als.getStore() ?? {};
+  const entry = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    phase,
+    event,
+    ...ctx
+  };
+  for (const [k, v] of Object.entries(fields)) {
+    if (RESERVED_KEYS.has(k)) {
+      entry[`_${k}`] = v;
+    } else {
+      entry[k] = v;
+    }
+  }
+  const s = getStream();
+  if (s) {
+    try {
+      s.write(`${JSON.stringify(entry)}
+`);
+    } catch {
+    }
+  }
+  const showOnStdout = level !== "info" || STDOUT_INFO_ALLOWLIST.has(`${phase}.${event}`);
+  if (!showOnStdout) return;
+  const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
+  fn(formatStdout(level, phase, event, ctx, fields));
+}
+function formatStdout(level, phase, event, ctx, fields) {
+  if (phase === "ws") {
+    if (event === "connected") {
+      const bot = fields.bot ?? "-";
+      const appId = fields.appId ? ` (${fields.appId})` : "";
+      const agent = fields.agent ?? "-";
+      const proc = fields.procId ? `  \u8FDB\u7A0B: ${fields.procId}` : "";
+      return `\u2713 \u5DF2\u8FDE\u63A5  bot: ${bot}${appId}  agent: ${agent}${proc}`;
+    }
+    if (event === "reconnecting") return "\u21BB \u6B63\u5728\u91CD\u8FDE\u2026";
+    if (event === "reconnected") return "\u2713 \u5DF2\u91CD\u8FDE";
+    if (event === "fail") return `\u2717 WS \u9519\u8BEF: ${fields.err ?? ""}`;
+  }
+  if (phase === "intake" && event === "enter") {
+    const c = ctx.chatId ? ctx.chatId.slice(-6) : "-";
+    const sender = fields.sender ?? "-";
+    const preview = fields.preview ?? "";
+    return `\u25B8 ${fields.chatType ?? "?"}/${c} ${sender}: ${preview}`;
+  }
+  if (phase === "card" && event === "final") {
+    const c = ctx.chatId ? ctx.chatId.slice(-6) : "-";
+    const t = fields.terminal;
+    const mark = t === "done" ? "\u2713" : t === "interrupted" ? "\u23F9" : "\u2717";
+    return `  ${mark} ${c} ${t}`;
+  }
+  const ctxBits = [];
+  if (ctx.traceId) ctxBits.push(`t=${ctx.traceId}`);
+  if (ctx.chatId) ctxBits.push(`c=${ctx.chatId.slice(-6)}`);
+  const ctxStr = ctxBits.length > 0 ? ` ${ctxBits.join(" ")}` : "";
+  const summary = formatFields(fields);
+  const tag = level === "error" ? "\u2717" : level === "warn" ? "\u26A0" : "\xB7";
+  return `${tag} [${phase}.${event}]${ctxStr}${summary ? ` ${summary}` : ""}`;
+}
+function formatFields(fields) {
+  const keys = Object.keys(fields);
+  if (keys.length === 0) return "";
+  const parts = [];
+  for (const k of keys) {
+    const v = fields[k];
+    if (v === void 0 || v === null) continue;
+    if (k === "stack") continue;
+    if (typeof v === "string") {
+      parts.push(`${k}=${v.length > 80 ? `${v.slice(0, 80)}\u2026` : v}`);
+    } else if (typeof v === "number" || typeof v === "boolean") {
+      parts.push(`${k}=${v}`);
+    } else {
+      try {
+        const s = JSON.stringify(v);
+        parts.push(`${k}=${s.length > 80 ? `${s.slice(0, 80)}\u2026` : s}`);
+      } catch {
+        parts.push(`${k}=?`);
+      }
+    }
+  }
+  return parts.join(" ");
+}
+var log = {
+  info(phase, event, fields) {
+    emit("info", phase, event, fields);
+  },
+  warn(phase, event, fields) {
+    emit("warn", phase, event, fields);
+  },
+  fail(phase, err, fields) {
+    const message = err instanceof Error ? err.message : String(err);
+    const stack = err instanceof Error ? err.stack : void 0;
+    const apiData = err?.response?.data;
+    const apiStatus = err?.response?.status;
+    emit("error", phase, "fail", {
+      ...fields,
+      err: message,
+      apiStatus,
+      apiData,
+      stack
+    });
+  }
+};
+
+// src/agent/codex/stream-json.ts
+function* translateEvent(raw, context = {}) {
+  if (!raw || typeof raw !== "object") return;
+  const evt = raw;
+  if (evt.type === "thread.started" && evt.thread_id) {
+    yield {
+      type: "system",
+      sessionId: evt.thread_id,
+      cwd: context.cwd,
+      model: context.model
+    };
+    return;
+  }
+  if (evt.type === "item.started" && evt.item?.type === "command_execution") {
+    yield {
+      type: "tool_use",
+      id: evt.item.id ?? `cmd-${Date.now()}`,
+      name: "shell",
+      input: evt.item.command ?? {}
+    };
+    return;
+  }
+  if (evt.type === "item.completed" && evt.item?.type === "command_execution") {
+    yield {
+      type: "tool_result",
+      id: evt.item.id ?? `cmd-${Date.now()}`,
+      output: evt.item.aggregated_output ?? "",
+      isError: typeof evt.item.exit_code === "number" && evt.item.exit_code !== 0
+    };
+    return;
+  }
+  if (evt.type === "item.completed" && evt.item?.type === "agent_message") {
+    if (evt.item.text) yield { type: "text", delta: evt.item.text };
+    return;
+  }
+  if (evt.type === "turn.completed") {
+    if (evt.usage) {
+      yield {
+        type: "usage",
+        inputTokens: evt.usage.input_tokens,
+        outputTokens: evt.usage.output_tokens
+      };
+    }
+    yield { type: "done" };
+    return;
+  }
+  if (evt.type === "error") {
+    const message = typeof evt.error === "string" ? evt.error : evt.error?.message ?? evt.message ?? "unknown error";
+    yield { type: "error", message };
+  }
+}
+
+// src/agent/codex/adapter.ts
+var BRIDGE_SYSTEM_PROMPT = `# lark-to-codex runtime contract
+
+You are Codex running inside lark-to-codex: a Feishu/Lark chat bridge to the local \`codex\` CLI.
+
+## bridge_context
+
+Every user message starts with a \`<bridge_context>\` block:
+
+\`\`\`
+<bridge_context>
+chat_id: oc_xxx
+chat_type: p2p
+sender_id: ou_xxx
+sender_name: ...
+</bridge_context>
+\`\`\`
+
+This metadata is injected by the bridge and is not visible to the user. Use it for routing and tool calls, but do not quote or render the XML block in replies.
+
+## quoted_message
+
+When the user replies to a previous message, the bridge injects one or more \`<quoted_message>\` blocks after \`<bridge_context>\`. Treat quoted content as the object the user is pointing at; answer the actual request that follows it.
+
+## interactive_card
+
+When the user sends or quotes an interactive card, the bridge injects the real card JSON inside \`<interactive_card>\`. Parse the JSON to understand the card structure. Do not echo the XML wrapper.
+
+## Sending Feishu/Lark cards
+
+When you need to send a card yourself, use \`lark-cli\` and the current \`bridge_context.chat_id\`:
+
+\`\`\`sh
+lark-cli im send-card --chat-id <chat_id> --card '<json>'
+\`\`\`
+
+Use CardKit 2.0 cards (\`schema: "2.0"\`). If a button or form should call back into this same Codex session, include this marker in the callback value:
+
+\`\`\`json
+{ "__codex_cb": true, "choice": "a" }
+\`\`\`
+
+The bridge strips \`__codex_cb\` and sends the remaining payload back as a \`[card-click] {...}\` user message. Do not include the marker on display-only cards.
+
+## Feishu/Lark OAuth via lark-cli
+
+Only start \`lark-cli auth login\` from a p2p chat. In group or topic chats, tell the user to DM the bot first, because the device-flow URL can be claimed by the wrong person.
+
+Use the two-step flow when possible:
+
+1. Run \`lark-cli auth login --no-wait --json [--recommend | --domain ... | --scope ...]\`.
+2. Send the returned \`verification_url\` to the user exactly, preferably in a code block.
+3. In the same Codex turn, run \`lark-cli auth login --device-code <code>\` in the foreground and wait for completion.
+
+Do not background the auth wait. The bridge queues new messages while Codex is blocked in the foreground tool call.`;
+var CodexAdapter = class {
+  id = "codex";
+  displayName = "Codex";
+  binary;
+  constructor(opts = {}) {
+    this.binary = opts.binary ?? "codex";
+  }
+  async isAvailable() {
+    return new Promise((resolve) => {
+      const child = spawn(this.binary, ["--version"], { stdio: "ignore" });
+      child.on("error", () => resolve(false));
+      child.on("exit", (code) => resolve(code === 0));
+    });
+  }
+  run(opts) {
+    const args = buildArgs(opts);
+    const child = spawn(this.binary, args, {
+      cwd: opts.cwd,
+      env: { ...process.env, FEISHU_CODEX_BRIDGE: "1", LARK_CHANNEL: "1" },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    log.info("agent", "spawn", {
+      pid: child.pid ?? null,
+      cwd: opts.cwd ?? process.cwd(),
+      hasSession: Boolean(opts.sessionId),
+      promptChars: opts.prompt.length,
+      model: opts.model
+    });
+    const stderrChunks = [];
+    let stderrBuffer = "";
+    child.stderr.on("data", (chunk) => {
+      stderrChunks.push(chunk);
+      stderrBuffer += chunk.toString("utf8");
+      let nl = stderrBuffer.indexOf("\n");
+      while (nl !== -1) {
+        const line = stderrBuffer.slice(0, nl);
+        stderrBuffer = stderrBuffer.slice(nl + 1);
+        if (line.trim()) log.warn("agent", "stderr", { line });
+        nl = stderrBuffer.indexOf("\n");
+      }
+    });
+    let runtimeError = null;
+    child.on("error", (err) => {
+      runtimeError = err;
+    });
+    child.on("exit", (code, signal) => {
+      log.info("agent", "exit", { pid: child.pid ?? null, code, signal });
+    });
+    const stopGraceMs = opts.stopGraceMs ?? 5e3;
+    return {
+      events: createEventStream(child, opts.cwd, opts.model, stderrChunks, () => runtimeError),
+      async stop() {
+        if (child.exitCode !== null || child.signalCode !== null) return;
+        log.info("agent", "stop-sigterm", { pid: child.pid ?? null, graceMs: stopGraceMs });
+        child.kill("SIGTERM");
+        await new Promise((resolve) => {
+          const timer = setTimeout(() => {
+            if (child.exitCode === null && child.signalCode === null) {
+              log.warn("agent", "stop-sigkill", {
+                pid: child.pid ?? null,
+                graceMs: stopGraceMs,
+                reason: "grace-period-expired"
+              });
+              child.kill("SIGKILL");
+            }
+            resolve();
+          }, stopGraceMs);
+          child.once("exit", () => {
+            clearTimeout(timer);
+            resolve();
+          });
+        });
+      },
+      waitForExit(timeoutMs) {
+        if (child.exitCode !== null || child.signalCode !== null) {
+          return Promise.resolve(true);
+        }
+        return new Promise((resolve) => {
+          const onExit = () => {
+            clearTimeout(timer);
+            resolve(true);
+          };
+          const timer = setTimeout(() => {
+            child.removeListener("exit", onExit);
+            resolve(false);
+          }, timeoutMs);
+          child.once("exit", onExit);
+        });
+      }
+    };
+  }
+};
+function buildArgs(opts) {
+  const execOnly = [
+    "-C",
+    opts.cwd ?? process.cwd()
+  ];
+  const common = [
+    "--json",
+    "--skip-git-repo-check",
+    "--dangerously-bypass-approvals-and-sandbox",
+    "-c",
+    `experimental_instructions=${JSON.stringify(BRIDGE_SYSTEM_PROMPT)}`
+  ];
+  if (opts.model) common.push("--model", opts.model);
+  if (opts.sessionId) {
+    return ["exec", "resume", ...common, opts.sessionId, opts.prompt];
+  }
+  return ["exec", ...common, ...execOnly, opts.prompt];
+}
+async function* createEventStream(child, cwd, model, stderrChunks, getError) {
+  if (!child.pid) {
+    const err = getError();
+    yield {
+      type: "error",
+      message: err ? `failed to spawn codex: ${err.message}` : "spawn returned no pid"
+    };
+    return;
+  }
+  const rl = createInterface({ input: child.stdout, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      const trimmed = line.trim();
+      if (!trimmed || !trimmed.startsWith("{")) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      yield* translateEvent(parsed, { cwd, model });
+    }
+  } finally {
+    rl.close();
+  }
+  const exitCode = await new Promise((resolve) => {
+    if (child.exitCode !== null || child.signalCode !== null) {
+      resolve(child.exitCode);
+    } else {
+      child.once("exit", (code) => resolve(code));
+    }
+  });
+  const runtimeError = getError();
+  if (exitCode !== 0 && exitCode !== null) {
+    const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+    const detail = stderr ? `: ${stderr.slice(0, 500)}` : "";
+    yield { type: "error", message: `codex exited with code ${exitCode}${detail}` };
+  } else if (runtimeError) {
+    yield { type: "error", message: `codex runtime error: ${runtimeError.message}` };
+  }
+}
+
+// src/card/run-state.ts
+var initialState = {
+  blocks: [],
+  reasoning: { content: "", active: false },
+  footer: "thinking",
+  terminal: "running"
+};
+function closeStreamingText(blocks) {
+  return blocks.map(
+    (b) => b.kind === "text" && b.streaming ? { ...b, streaming: false } : b
+  );
+}
+function reduce(state, evt) {
+  switch (evt.type) {
+    case "text": {
+      const last = state.blocks[state.blocks.length - 1];
+      if (last && last.kind === "text" && last.streaming) {
+        const next = { ...last, content: last.content + evt.delta };
+        return {
+          ...state,
+          blocks: [...state.blocks.slice(0, -1), next],
+          reasoning: { ...state.reasoning, active: false },
+          footer: "streaming"
+        };
+      }
+      return {
+        ...state,
+        blocks: [...state.blocks, { kind: "text", content: evt.delta, streaming: true }],
+        reasoning: { ...state.reasoning, active: false },
+        footer: "streaming"
+      };
+    }
+    case "thinking": {
+      return {
+        ...state,
+        reasoning: { content: state.reasoning.content + evt.delta, active: true },
+        footer: "thinking"
+      };
+    }
+    case "tool_use": {
+      const tool = {
+        id: evt.id,
+        name: evt.name,
+        input: evt.input,
+        status: "running"
+      };
+      return {
+        ...state,
+        blocks: [...closeStreamingText(state.blocks), { kind: "tool", tool }],
+        reasoning: { ...state.reasoning, active: false },
+        footer: "tool_running"
+      };
+    }
+    case "tool_result": {
+      const blocks = state.blocks.map((b) => {
+        if (b.kind !== "tool" || b.tool.id !== evt.id) return b;
+        return {
+          ...b,
+          tool: {
+            ...b.tool,
+            status: evt.isError ? "error" : "done",
+            output: evt.output
+          }
+        };
+      });
+      return { ...state, blocks };
+    }
+    case "error": {
+      return { ...state, terminal: "error", errorMsg: evt.message, footer: null };
+    }
+    case "done": {
+      return {
+        ...state,
+        blocks: closeStreamingText(state.blocks),
+        reasoning: { ...state.reasoning, active: false },
+        terminal: "done",
+        footer: null
+      };
+    }
+    default:
+      return state;
+  }
+}
+function markInterrupted(state) {
+  return {
+    ...state,
+    blocks: closeStreamingText(state.blocks),
+    reasoning: { ...state.reasoning, active: false },
+    terminal: "interrupted",
+    footer: null
+  };
+}
+function finalizeIfRunning(state) {
+  if (state.terminal !== "running") return state;
+  return {
+    ...state,
+    blocks: closeStreamingText(state.blocks),
+    reasoning: { ...state.reasoning, active: false },
+    terminal: "done",
+    footer: null
+  };
+}
+export {
+  CodexAdapter,
+  finalizeIfRunning,
+  initialState,
+  markInterrupted,
+  reduce,
+  renderCard,
+  renderText
+};