@mclawnet/agent 0.6.33 → 0.6.34

package/dist/dist-VLBO5CT3.js

@@ -0,0 +1,775 @@
+// ../codex-adapter/dist/codex-adapter.js
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// ../codex-adapter/dist/codex-spawn-args.js
+import { writeFileSync, unlinkSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { randomUUID } from "crypto";
+import { DEFAULT_SANDBOX } from "@mclawnet/shared";
+function escapeToml(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function buildCodexSpawnArgs(options) {
+  const args = ["app-server"];
+  let briefingFile;
+  void options.resumeId;
+  args.push("-c", 'approval_policy="never"');
+  const sandboxLevel = options.sandbox ?? DEFAULT_SANDBOX;
+  const codexSandboxMode = sandboxLevel === "read-only" ? "read-only" : sandboxLevel === "full-access" ? "danger-full-access" : "workspace-write";
+  args.push("-c", `sandbox_mode="${codexSandboxMode}"`);
+  if (options.mcpServer) {
+    const { command, args: serverArgs, env } = options.mcpServer;
+    args.push("-c", `mcp_servers.clawnet-mcp.command="${escapeToml(command)}"`);
+    if (serverArgs && serverArgs.length > 0) {
+      const argsToml = "[" + serverArgs.map((a) => `"${escapeToml(a)}"`).join(", ") + "]";
+      args.push("-c", `mcp_servers.clawnet-mcp.args=${argsToml}`);
+    }
+    if (env) {
+      for (const [key, value] of Object.entries(env)) {
+        args.push("-c", `mcp_servers.clawnet-mcp.env.${key}="${escapeToml(value)}"`);
+      }
+    }
+    args.push("-c", 'mcp_servers.clawnet-mcp.default_tools_approval_mode="approve"');
+  }
+  if (options.systemPrompt) {
+    briefingFile = join(tmpdir(), `clawnet-briefing-${options.sessionId}-${randomUUID().slice(0, 8)}.md`);
+    writeFileSync(briefingFile, options.systemPrompt, { encoding: "utf-8", mode: 384 });
+    args.push("-c", `model_instructions_file="${escapeToml(briefingFile)}"`);
+  }
+  return { args, briefingFile };
+}
+function cleanupBriefingFile(filePath) {
+  try {
+    unlinkSync(filePath);
+  } catch {
+  }
+}
+
+// ../codex-adapter/dist/codex-adapter.js
+import { createLogger, preview } from "@mclawnet/logger";
+
+// ../codex-adapter/dist/json-rpc-client.js
+var JsonRpcClient = class {
+  stdin;
+  buffer = "";
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  onRequest;
+  onNotification;
+  onMalformedLine;
+  constructor(opts) {
+    this.stdin = opts.stdin;
+    this.onRequest = opts.onRequest;
+    this.onNotification = opts.onNotification;
+    this.onMalformedLine = opts.onMalformedLine;
+    opts.stdout.on("data", (chunk) => this.feed(chunk.toString("utf-8")));
+  }
+  request(method, params) {
+    const id = this.nextId++;
+    const frame = { jsonrpc: "2.0", id, method, params };
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.stdin.write(JSON.stringify(frame) + "\n");
+    });
+  }
+  notify(method, params) {
+    this.stdin.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n");
+  }
+  feed(s) {
+    this.buffer += s;
+    let nl;
+    while ((nl = this.buffer.indexOf("\n")) >= 0) {
+      const line = this.buffer.slice(0, nl).trim();
+      this.buffer = this.buffer.slice(nl + 1);
+      if (!line)
+        continue;
+      this.dispatch(line);
+    }
+  }
+  dispatch(line) {
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch (err) {
+      this.onMalformedLine?.(line, err);
+      return;
+    }
+    if (typeof msg.id === "number" && (msg.result !== void 0 || msg.error !== void 0)) {
+      const pending = this.pending.get(msg.id);
+      if (!pending)
+        return;
+      this.pending.delete(msg.id);
+      if (msg.error)
+        pending.reject(new Error(msg.error.message));
+      else
+        pending.resolve(msg.result);
+      return;
+    }
+    if (msg.method && typeof msg.id === "number") {
+      const id = msg.id;
+      const method = msg.method;
+      const params = msg.params;
+      void Promise.resolve(this.onRequest?.(method, params)).then((result) => {
+        this.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n");
+      }).catch((err) => {
+        this.stdin.write(JSON.stringify({
+          jsonrpc: "2.0",
+          id,
+          error: { code: -32e3, message: err.message }
+        }) + "\n");
+      });
+      return;
+    }
+    if (msg.method) {
+      this.onNotification?.(msg.method, msg.params);
+    }
+  }
+};
+
+// ../codex-adapter/dist/permission-mapper.js
+function decisionToWire(d) {
+  switch (d) {
+    case "allow":
+      return "approved";
+    case "allow_session":
+      return "approved_for_session";
+    case "deny":
+      return "denied";
+    case "abort":
+      return "abort";
+    default: {
+      const _exhaustive = d;
+      return _exhaustive;
+    }
+  }
+}
+function decisionToV2Wire(d) {
+  switch (d) {
+    case "allow":
+      return "accept";
+    case "allow_session":
+      return "acceptForSession";
+    case "deny":
+      return "decline";
+    case "abort":
+      return "cancel";
+    default: {
+      const _exhaustive = d;
+      return _exhaustive;
+    }
+  }
+}
+function decisionToMcpAction(d) {
+  switch (d) {
+    case "allow":
+    case "allow_session":
+      return "accept";
+    case "deny":
+      return "decline";
+    case "abort":
+      return "cancel";
+    default: {
+      const _exhaustive = d;
+      return _exhaustive;
+    }
+  }
+}
+function buildApprovalReply(family, decision) {
+  switch (family) {
+    case "legacy":
+      return { decision: decisionToWire(decision) };
+    case "v2":
+      return { decision: decisionToV2Wire(decision) };
+    case "mcp":
+      return { action: decisionToMcpAction(decision) };
+    default: {
+      const _exhaustive = family;
+      return _exhaustive;
+    }
+  }
+}
+function parseApprovalRequest(method, params) {
+  const p = params ?? {};
+  const callId = p.callId ?? p.itemId;
+  if (!callId)
+    return null;
+  const reason = p.reason;
+  const cwd = p.cwd;
+  if (method === "execCommandApproval") {
+    return {
+      req: {
+        callId,
+        toolName: "shell",
+        input: { command: p.command, cwd },
+        meta: { backend: "codex", reason, cwd }
+      },
+      wireFamily: "legacy"
+    };
+  }
+  if (method === "item/commandExecution/requestApproval") {
+    return {
+      req: {
+        callId,
+        toolName: "shell",
+        input: { command: p.command, cwd },
+        meta: { backend: "codex", reason, cwd }
+      },
+      wireFamily: "v2"
+    };
+  }
+  if (method === "applyPatchApproval") {
+    return {
+      req: {
+        callId,
+        toolName: "apply_patch",
+        input: { fileChanges: p.fileChanges },
+        meta: { backend: "codex", reason, cwd }
+      },
+      wireFamily: "legacy"
+    };
+  }
+  if (method === "item/fileChange/requestApproval") {
+    return {
+      req: {
+        callId,
+        toolName: "apply_patch",
+        input: { fileChanges: p.fileChanges },
+        meta: { backend: "codex", reason, cwd }
+      },
+      wireFamily: "v2"
+    };
+  }
+  if (method === "mcpServer/elicitation/request") {
+    return {
+      req: {
+        callId,
+        toolName: p.serverName ?? "mcp",
+        input: { message: p.message, meta: p._meta },
+        meta: { backend: "codex", reason }
+      },
+      wireFamily: "mcp"
+    };
+  }
+  return null;
+}
+
+// ../codex-adapter/dist/output-mapper.js
+function mapCodexFrame(frame) {
+  const params = frame.params ?? {};
+  switch (frame.method) {
+    // ── v2 frames (real codex app-server v2 protocol) ─────────────────
+    case "item/agentMessage/delta": {
+      const delta = params.delta;
+      if (typeof delta === "string") {
+        return { kind: "assistant_text", text: delta };
+      }
+      break;
+    }
+    case "item/completed": {
+      const item = params.item;
+      if (item?.type === "agentMessage" && typeof item.text === "string") {
+        return { kind: "assistant_text", text: item.text };
+      }
+      if (item?.type === "commandExecution") {
+        const failed = item.status === "failed" || item.status === "declined";
+        const badExit = typeof item.exitCode === "number" && item.exitCode !== 0;
+        return {
+          kind: "tool_result",
+          callId: String(item.id ?? ""),
+          output: item.aggregatedOutput ?? null,
+          isError: failed || badExit
+        };
+      }
+      if (item?.type === "fileChange") {
+        const failed = item.status === "failed" || item.status === "declined";
+        return {
+          kind: "tool_result",
+          callId: String(item.id ?? ""),
+          output: { changes: item.changes },
+          isError: failed
+        };
+      }
+      if (item?.type === "mcpToolCall") {
+        const failed = item.status === "failed" || item.error != null;
+        return {
+          kind: "tool_result",
+          callId: String(item.id ?? ""),
+          output: failed ? item.error : item.result,
+          isError: failed
+        };
+      }
+      break;
+    }
+    case "item/started": {
+      const item = params.item;
+      if (item?.type === "commandExecution") {
+        return {
+          kind: "tool_use",
+          callId: String(item.id ?? ""),
+          toolName: "shell",
+          input: { command: item.command }
+        };
+      }
+      if (item?.type === "mcpToolCall") {
+        return {
+          kind: "tool_use",
+          callId: String(item.id ?? ""),
+          toolName: String(item.name ?? "mcp"),
+          input: item.input
+        };
+      }
+      break;
+    }
+    // ── legacy frame names (kept for back-compat with older codex / tests) ──
+    case "thread/message": {
+      const role = params.role;
+      const content = params.content;
+      if (role === "assistant" && content) {
+        const text = content.filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text).join("");
+        return { kind: "assistant_text", text };
+      }
+      break;
+    }
+    case "thread/toolUse":
+      return {
+        kind: "tool_use",
+        callId: String(params.callId ?? ""),
+        toolName: String(params.name ?? ""),
+        input: params.input
+      };
+    case "thread/toolResult":
+      return {
+        kind: "tool_result",
+        callId: String(params.callId ?? ""),
+        output: params.output,
+        isError: Boolean(params.isError)
+      };
+  }
+  return { kind: "raw", backend: "codex", payload: frame };
+}
+
+// ../codex-adapter/dist/codex-adapter.js
+var log = createLogger({ module: "codex-adapter" });
+var CLAWNET_CLIENT_INFO = {
+  name: "clawnet",
+  version: "0.1.0",
+  title: "ClawNet Agent"
+};
+var CodexProcess = class extends EventEmitter {
+  id;
+  workDir;
+  pid;
+  proc;
+  killed = false;
+  /** callId → JSON-RPC server-request id we still owe a result to. */
+  pendingApprovals = /* @__PURE__ */ new Map();
+  /** callId → originating wire family (drives v2/legacy/mcp reply shape). */
+  approvalMethods = /* @__PURE__ */ new Map();
+  /** Monotonic counter for approval resolver keys. */
+  nextResolverKey = 1;
+  /** Resolver registered by the rpc client for each pending approval. */
+  approvalResolvers = /* @__PURE__ */ new Map();
+  rpc;
+  backendSessionId;
+  /**
+   * Thread id to resume on agent restart. When set, handshake() sends
+   * `thread/resume { threadId }` instead of `thread/start { cwd }`.
+   * Set from SpawnOptions.resumeId in CodexAdapter.spawn(). Must NOT be
+   * passed as `--resume` CLI flag — app-server rejects it.
+   */
+  resumeId;
+  /** True once `initialize` round-trip + `thread/start` (or `thread/resume`) have completed. */
+  handshakeComplete = false;
+  /** Inputs queued by send() while the handshake is still in flight. */
+  pendingInputs = [];
+  /** Temp file for briefing injection; cleaned up on kill(). */
+  briefingFile;
+  /**
+   * Set by CodexAdapter.spawn() so handshake() can surface real process-exit
+   * info if the codex CLI died (e.g. arg parse error). Without this, a dead
+   * process leads to a generic "handshake timeout" instead of the actual
+   * "error: unexpected argument …" stderr message.
+   *
+   * Default returns (null, "") for tests that construct CodexProcess
+   * directly without going through spawn() (e.g. attachRpc mock pipes).
+   * spawn() overrides these with real getters wired to the child process.
+   */
+  getExitInfo = () => null;
+  getStderr = () => "";
+  /** Allocate a resolver key. Monotonic; never reused. */
+  allocResolverKey() {
+    return this.nextResolverKey++;
+  }
+  constructor(sessionId, workDir, proc) {
+    super();
+    this.id = sessionId;
+    this.workDir = workDir;
+    this.proc = proc;
+    this.pid = proc?.pid;
+  }
+  async kill() {
+    this.killed = true;
+    for (const [, resolver] of this.approvalResolvers) {
+      try {
+        resolver({ decision: "abort" });
+      } catch {
+      }
+    }
+    this.pendingApprovals.clear();
+    this.approvalMethods.clear();
+    this.approvalResolvers.clear();
+    this.pendingInputs.length = 0;
+    if (this.briefingFile) {
+      cleanupBriefingFile(this.briefingFile);
+      this.briefingFile = void 0;
+    }
+    if (this.proc && !this.proc.killed) {
+      try {
+        this.proc.kill("SIGTERM");
+      } catch {
+      }
+    }
+  }
+  isAlive() {
+    if (this.killed)
+      return false;
+    if (!this.proc)
+      return true;
+    return !this.proc.killed && this.proc.exitCode === null;
+  }
+};
+var CodexAdapter = class {
+  type = "codex";
+  codexBin;
+  handshakeTimeoutMs;
+  constructor(options) {
+    this.codexBin = options?.codexBin ?? "codex";
+    const envTimeout = Number(process.env.CLAWNET_CODEX_HANDSHAKE_TIMEOUT_MS);
+    this.handshakeTimeoutMs = options?.handshakeTimeoutMs ?? (Number.isFinite(envTimeout) && envTimeout > 0 ? envTimeout : 15e3);
+  }
+  async spawn(options) {
+    let cwd = options.workDir || process.cwd();
+    if (!existsSync(cwd))
+      cwd = homedir();
+    const mcpServer = this.buildMcpServerConfig(options);
+    const { args, briefingFile } = buildCodexSpawnArgs({
+      sessionId: options.sessionId,
+      resumeId: options.resumeId,
+      systemPrompt: options.systemPrompt,
+      mcpServer,
+      sandbox: options.sandbox
+    });
+    log.info({ sessionId: options.sessionId, bin: this.codexBin, args, cwd, resumeId: options.resumeId }, "codex spawn: forking app-server");
+    const proc = spawn(this.codexBin, args, {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: process.env,
+      windowsHide: true
+    });
+    const stderrChunks = [];
+    proc.stderr?.on("data", (chunk) => {
+      const text = chunk.toString("utf8").trim();
+      if (text) {
+        stderrChunks.push(text);
+        log.warn({ sessionId: options.sessionId, stderr: text }, "codex stderr");
+      }
+    });
+    let exitInfo = null;
+    proc.on("exit", (code, signal) => {
+      const isClean = code === 0 || signal === "SIGTERM";
+      const level = isClean ? "debug" : "warn";
+      log[level]({ sessionId: options.sessionId, code, signal }, "codex process exited");
+      if (!exitInfo)
+        exitInfo = { code, signal };
+    });
+    await new Promise((resolve, reject) => {
+      const t = setTimeout(() => resolve(), 2e3);
+      proc.on("error", (err) => {
+        clearTimeout(t);
+        reject(new Error(`Failed to spawn codex CLI: ${err.message}`));
+      });
+      proc.on("spawn", () => {
+        clearTimeout(t);
+        log.debug({ sessionId: options.sessionId, pid: proc.pid }, "codex spawn: process started");
+        resolve();
+      });
+    });
+    const cp = new CodexProcess(options.sessionId, cwd, proc);
+    cp.briefingFile = briefingFile;
+    cp.resumeId = options.resumeId;
+    cp.getExitInfo = () => exitInfo;
+    cp.getStderr = () => stderrChunks.join("\n").slice(0, 800);
+    this.wireRpc(cp);
+    return cp;
+  }
+  buildMcpServerConfig(options) {
+    let serverPath;
+    try {
+      const require2 = createRequire(import.meta.url);
+      serverPath = require2.resolve("@mclawnet/mcp-server/dist/server.js");
+    } catch {
+      const devPath = join2(import.meta.dirname ?? __dirname, "../../mcp-server/dist/server.js");
+      if (existsSync(devPath))
+        serverPath = devPath;
+    }
+    if (!serverPath) {
+      log.warn({ pkg: "@mclawnet/mcp-server" }, "codex: clawnet-mcp-server not resolvable, codex role will lack MCP tools");
+      return void 0;
+    }
+    const env = {};
+    if (options.workDir)
+      env.CLAWNET_WORK_DIR = options.workDir;
+    const home = process.env.CLAWNET_HOME ?? homedir();
+    env.CLAWNET_HOME = home;
+    return { command: "node", args: [serverPath], env };
+  }
+  /**
+   * Bind a CodexProcess to a JSON-RPC duplex. Public so tests can inject a
+   * mocked stdin/stdout pair without spawning a real subprocess.
+   *
+   * Drives the v2 handshake automatically: `initialize` → `thread/start`.
+   * Once `thread/start` resolves, `cp.backendSessionId` is set and a
+   * `session_started` event fires so the agent's hub bridge can persist it.
+   */
+  attachRpc(cp, stdin, stdout) {
+    const rpc = new JsonRpcClient({
+      stdin,
+      stdout,
+      onRequest: (method, params) => this.handleServerRequest(cp, method, params),
+      onNotification: (method, params) => this.handleNotification(cp, method, params),
+      onMalformedLine: (line, err) => log.warn({ sessionId: cp.id, err: err.message, linePreview: line.slice(0, 200) }, "codex stdout: non-JSON line ignored")
+    });
+    cp.rpc = rpc;
+    void this.handshake(cp);
+  }
+  async handshake(cp) {
+    if (!cp.rpc)
+      return;
+    const rpc = cp.rpc;
+    const resumeId = cp.resumeId;
+    log.info({ sessionId: cp.id, workDir: cp.workDir, resumeId }, "codex handshake: start");
+    let raceSettled = false;
+    const handshakeAttempt = (async () => {
+      await rpc.request("initialize", { clientInfo: CLAWNET_CLIENT_INFO });
+      log.info({ sessionId: cp.id }, "codex handshake: initialize ok");
+      let threadId;
+      if (resumeId) {
+        const resumed = await rpc.request("thread/resume", { threadId: resumeId });
+        threadId = resumed?.thread?.id ?? resumed?.threadId;
+      } else {
+        const started = await rpc.request("thread/start", { cwd: cp.workDir });
+        threadId = started?.thread?.id ?? started?.threadId;
+      }
+      if (!threadId) {
+        throw new Error(`codex handshake: ${resumeId ? "thread/resume" : "thread/start"} returned no threadId`);
+      }
+      if (raceSettled) {
+        log.warn({ sessionId: cp.id, threadId }, "codex handshake resolved AFTER race already lost \u2014 discarding result");
+        return;
+      }
+      cp.backendSessionId = threadId;
+      cp.handshakeComplete = true;
+      log.info({ sessionId: cp.id, threadId, queuedInputs: cp.pendingInputs.length }, "codex handshake: complete, flushing queued inputs");
+      cp.emit("session_started", { backendSessionId: threadId });
+      const queued = cp.pendingInputs.splice(0);
+      for (const input of queued) {
+        this.dispatchTurn(cp, input);
+      }
+    })();
+    handshakeAttempt.catch(() => {
+    });
+    let timeoutHandle;
+    let exitPollHandle;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutHandle = setTimeout(() => {
+        reject(new Error(`codex handshake timeout after ${this.handshakeTimeoutMs}ms (process may have died)`));
+      }, this.handshakeTimeoutMs);
+    });
+    const deathPromise = new Promise((_, reject) => {
+      const poll = () => {
+        if (raceSettled)
+          return;
+        const exit = cp.getExitInfo();
+        if (exit) {
+          const stderr = cp.getStderr();
+          reject(new Error(`codex process died during handshake (code=${exit.code}, signal=${exit.signal}). stderr: ${stderr || "(empty)"}`));
+          return;
+        }
+        exitPollHandle = setTimeout(poll, 100);
+      };
+      poll();
+    });
+    try {
+      await Promise.race([handshakeAttempt, timeoutPromise, deathPromise]);
+    } catch (err) {
+      log.error({ err, sessionId: cp.id }, "codex v2 handshake failed");
+      cp.emit("error", err);
+    } finally {
+      raceSettled = true;
+      if (timeoutHandle)
+        clearTimeout(timeoutHandle);
+      if (exitPollHandle)
+        clearTimeout(exitPollHandle);
+    }
+  }
+  wireRpc(cp) {
+    const proc = cp.proc;
+    if (proc?.stdin && proc?.stdout) {
+      this.attachRpc(cp, proc.stdin, proc.stdout);
+    }
+  }
+  handleServerRequest(cp, method, params) {
+    const parsed = parseApprovalRequest(method, params);
+    if (!parsed) {
+      log.warn({ method }, "codex server-request: unrecognized method");
+      return Promise.resolve({ decision: "denied" });
+    }
+    const { req, wireFamily } = parsed;
+    return new Promise((resolve) => {
+      const resolverKey = cp.allocResolverKey();
+      cp.pendingApprovals.set(req.callId, resolverKey);
+      cp.approvalMethods.set(req.callId, wireFamily);
+      cp.approvalResolvers.set(resolverKey, (reply) => {
+        resolve(reply);
+      });
+      cp.emit("permission_request", req);
+    });
+  }
+  handleNotification(cp, method, params) {
+    if (method === "thread/started") {
+      return;
+    }
+    if (method === "error") {
+      log.warn({ sessionId: cp.id, params }, "codex error notification");
+    }
+    if (method === "turn/completed" || method === "thread/turnComplete" || method === "turn/complete") {
+      log.info({ sessionId: cp.id, method }, "codex turn complete");
+      cp.emit("turn_complete", {
+        backendSessionId: cp.backendSessionId
+      });
+      return;
+    }
+    if (method === "turn/started") {
+      log.info({ sessionId: cp.id }, "codex turn started");
+      return;
+    }
+    const out = mapCodexFrame({ method, params });
+    this.logBackendOutput(cp.id, method, out);
+    cp.emit("output", out);
+  }
+  /**
+   * Selective notification logging. The previous catch-all `log.debug("codex
+   * notification")` fired for every streaming `item/agentMessage/delta` chunk
+   * (many per turn), drowning the actually useful events. Instead, log only
+   * structural events at INFO and surface unrecognised methods as WARN so the
+   * `{kind:"raw"}` degradation isn't silent.
+   */
+  logBackendOutput(sessionId, method, out) {
+    if (method === "item/agentMessage/delta")
+      return;
+    if (method === "thread/tokenUsageUpdated")
+      return;
+    switch (out.kind) {
+      case "tool_use":
+        log.info({ sessionId, callId: out.callId, tool: out.toolName, input: preview(out.input, 120) }, "codex tool_use");
+        return;
+      case "tool_result":
+        log.info({ sessionId, callId: out.callId, isError: out.isError, output: preview(out.output, 120) }, "codex tool_result");
+        return;
+      case "assistant_text":
+        log.debug({ sessionId, len: out.text.length, text: preview(out.text, 120) }, "codex assistant_text");
+        return;
+      case "raw":
+        log.warn({ sessionId, method, payload: preview(out.payload, 200) }, "codex unhandled frame");
+        return;
+    }
+  }
+  async stop(process2) {
+    await process2.kill();
+  }
+  send(process2, input) {
+    if (!(process2 instanceof CodexProcess)) {
+      log.warn({ sessionId: process2?.id, len: input.length }, "codex send: not a CodexProcess \u2014 input dropped");
+      return;
+    }
+    if (!process2.rpc) {
+      log.warn({ sessionId: process2.id, len: input.length }, "codex send: no rpc \u2014 input dropped");
+      return;
+    }
+    if (!process2.backendSessionId) {
+      process2.pendingInputs.push(input);
+      log.info({ sessionId: process2.id, queueDepth: process2.pendingInputs.length, len: input.length }, "codex send: handshake pending, queued");
+      return;
+    }
+    log.info({ sessionId: process2.id, threadId: process2.backendSessionId, len: input.length }, "codex send: dispatching turn/start");
+    this.dispatchTurn(process2, input);
+  }
+  dispatchTurn(process2, input) {
+    if (!process2.rpc || !process2.backendSessionId)
+      return;
+    void process2.rpc.request("turn/start", {
+      threadId: process2.backendSessionId,
+      input: [{ type: "text", text: input }]
+    }).then(() => {
+      log.info({ sessionId: process2.id, threadId: process2.backendSessionId }, "codex turn/start: accepted by server");
+    }).catch((err) => {
+      log.warn({ err, sessionId: process2.id }, "turn/start failed");
+      process2.emit("error", err);
+    });
+  }
+  onOutput(process2, handler) {
+    if (process2 instanceof CodexProcess)
+      process2.on("output", handler);
+  }
+  onPermissionRequest(process2, handler) {
+    if (process2 instanceof CodexProcess)
+      process2.on("permission_request", handler);
+  }
+  async respondToPermission(process2, decision) {
+    if (!(process2 instanceof CodexProcess))
+      return;
+    const key = process2.pendingApprovals.get(decision.callId);
+    if (key === void 0) {
+      log.warn({ callId: decision.callId }, "respondToPermission: no pending approval");
+      return;
+    }
+    const family = process2.approvalMethods.get(decision.callId) ?? "legacy";
+    const resolver = process2.approvalResolvers.get(key);
+    process2.pendingApprovals.delete(decision.callId);
+    process2.approvalMethods.delete(decision.callId);
+    process2.approvalResolvers.delete(key);
+    const reply = buildApprovalReply(family, decision.decision);
+    resolver?.(reply);
+  }
+  onTurnComplete(process2, handler) {
+    if (process2 instanceof CodexProcess)
+      process2.on("turn_complete", handler);
+  }
+  onSessionStarted(process2, handler) {
+    if (process2 instanceof CodexProcess)
+      process2.on("session_started", handler);
+  }
+  onError(process2, handler) {
+    if (process2 instanceof CodexProcess)
+      process2.on("error", handler);
+  }
+  onExit(process2, handler) {
+    if (process2 instanceof CodexProcess)
+      process2.on("exit", handler);
+  }
+};
+export {
+  CodexAdapter,
+  CodexProcess,
+  JsonRpcClient,
+  decisionToWire,
+  mapCodexFrame,
+  parseApprovalRequest
+};
+//# sourceMappingURL=dist-VLBO5CT3.js.map