svamp-cli 0.2.342 → 0.2.346

package/dist/codexAppServerBackend-VGsYtbqg.mjs

@@ -0,0 +1,786 @@
+import { randomUUID } from 'node:crypto';
+import { execFile, execSync, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import { createInterface } from 'node:readline';
+import { c as codexSupportsSteer } from './pinnedCodex-XW4qvOAe.mjs';
+import { w as wrapWithIsolation } from './wrapCommand-CdNawSaa.mjs';
+import { resolveCodexProvider, buildCodexProviderArgs } from './codexProvider-BtxYc5Rj.mjs';
+
+function mapCodexEventToText(event) {
+  if (!event || typeof event !== "object") return "";
+  if (typeof event.message === "string") return event.message;
+  if (typeof event.text === "string") return event.text;
+  const content = event.content;
+  if (Array.isArray(content)) {
+    return content.map((b) => b && typeof b === "object" && typeof b.text === "string" ? b.text : "").join("");
+  }
+  const delta = event.delta;
+  if (delta && typeof delta === "object" && typeof delta.text === "string") return delta.text;
+  if (typeof delta === "string") return delta;
+  return "";
+}
+function summarizeCodexChanges(changes) {
+  if (!Array.isArray(changes) || changes.length === 0) return { filePath: null, patch: "", kind: null };
+  const parts = changes.map((c) => {
+    const path = typeof c?.path === "string" ? c.path : "";
+    const kind2 = c?.kind?.type ?? (typeof c?.kind === "string" ? c.kind : null);
+    const diff = typeof c?.diff === "string" ? c.diff : "";
+    return { path, kind: kind2, diff };
+  });
+  const filePath = parts.length === 1 ? parts[0].path || null : `${parts.length} files`;
+  const patch = parts.map((x) => parts.length > 1 && x.path ? `--- ${x.path}
+${x.diff}` : x.diff).join("\n");
+  const kind = parts.length === 1 ? parts[0].kind : null;
+  return { filePath, patch, kind };
+}
+function normalizeNotification(method, params) {
+  if (method === "item/agentMessage/delta") {
+    return typeof params?.delta === "string" ? { type: "agent_message_delta", delta: params.delta } : null;
+  }
+  if (method === "item/reasoning/delta") {
+    return typeof params?.delta === "string" ? { type: "agent_reasoning_delta", delta: params.delta } : null;
+  }
+  if (method === "item/started" || method === "item/completed" || method === "item/updated") {
+    const item = params?.item;
+    if (!item || typeof item !== "object") return null;
+    const done = method === "item/completed";
+    switch (item.type) {
+      case "agentMessage":
+        return done && typeof item.text === "string" && item.text ? { type: "agent_message", message: item.text } : null;
+      case "reasoning": {
+        if (!done) return null;
+        const text = Array.isArray(item.content) ? item.content.join("") : Array.isArray(item.summary) ? item.summary.join("") : typeof item.text === "string" ? item.text : "";
+        return text ? { type: "agent_reasoning", text } : null;
+      }
+      case "commandExecution":
+        return done ? { type: "exec_command_end", call_id: item.id, exit_code: item.exitCode, stdout: item.aggregatedOutput ?? "", stderr: "" } : { type: "exec_command_begin", call_id: item.id, command: item.command, cwd: item.cwd };
+      case "fileChange":
+        return done ? { type: "patch_apply_end", call_id: item.id, applied: item.status === "completed" || item.status === "applied", changes: item.changes } : { type: "patch_apply_begin", call_id: item.id, changes: item.changes };
+      case "mcpToolCall":
+        return done ? { type: "mcp_tool_call_end", call_id: item.id, tool: item.tool, result: item.result, error: item.error } : { type: "mcp_tool_call_begin", call_id: item.id, tool: item.tool, server: item.server, arguments: item.arguments };
+      case "userMessage":
+      default:
+        return null;
+    }
+  }
+  if (method === "thread/tokenUsage/updated") {
+    return { type: "token_usage", usage: params?.usage ?? params };
+  }
+  return null;
+}
+function codexCumulativeTokens(payload) {
+  if (!payload || typeof payload !== "object") return 0;
+  const tu = payload.tokenUsage ?? payload.token_usage ?? payload;
+  const bucket = tu?.total ?? tu?.cumulative ?? tu;
+  if (!bucket || typeof bucket !== "object") return 0;
+  const n = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+  const input = n(bucket.inputTokens ?? bucket.input_tokens);
+  const cached = n(bucket.cachedInputTokens ?? bucket.cached_input_tokens ?? bucket.cacheReadInputTokens);
+  const output = n(bucket.outputTokens ?? bucket.output_tokens) + n(bucket.reasoningOutputTokens ?? bucket.reasoning_output_tokens);
+  const nonCachedInput = Math.max(0, input - cached);
+  return nonCachedInput + output + Math.round(cached * 0.1);
+}
+
+function parseCodexVersion(v) {
+  const m = v.match(/codex-cli\s+(\d+)\.(\d+)\.(\d+)/);
+  if (!m) return null;
+  const [major, minor, patch] = [Number(m[1]), Number(m[2]), Number(m[3])];
+  if (![major, minor, patch].every(Number.isFinite)) return null;
+  return { major, minor, patch };
+}
+function codexAppServerAvailable() {
+  try {
+    const v = parseCodexVersion(execSync("codex --version", { encoding: "utf8" }).trim());
+    if (!v) return false;
+    return v.major > 0 || v.minor >= 100;
+  } catch {
+    return null;
+  }
+}
+const _execFileAsync = promisify(execFile);
+let _steerSupport = null;
+let _steerProbedAt = 0;
+let _steerProbe = null;
+const _STEER_TTL_MS = 3e4;
+const DEFAULT_REQUEST_TIMEOUT_MS = 12e4;
+function _steerFresh() {
+  return _steerSupport !== null && Date.now() - _steerProbedAt < _STEER_TTL_MS;
+}
+async function codexSupportsSteerInstalledAsync() {
+  if (_steerFresh()) return _steerSupport;
+  if (_steerProbe) return _steerProbe;
+  _steerProbe = (async () => {
+    try {
+      const { stdout } = await _execFileAsync("codex", ["--version"], { encoding: "utf8" });
+      _steerSupport = codexSupportsSteer(parseCodexVersion(stdout.trim()));
+    } catch {
+      _steerSupport = false;
+    }
+    _steerProbedAt = Date.now();
+    _steerProbe = null;
+    return _steerSupport;
+  })();
+  return _steerProbe;
+}
+class CodexAppServerClient {
+  constructor(opts) {
+    this.opts = opts;
+    this.log = opts.log ?? (() => {
+    });
+  }
+  process = null;
+  readline = null;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  connected = false;
+  _threadId = null;
+  _turnId = null;
+  // A turn is "in flight" from turn/start until task_complete / turn_aborted (or turn/completed).
+  pendingTurn = null;
+  // #0455: bounded — only the most-recent turns can race the turn/completed fallback
+  // against codex/event. An unbounded Set leaked one string per turn for the life of a
+  // long/loop session. Keep a small ring of recent ids (insertion-ordered) and evict the
+  // oldest past the cap; cleared in dispose().
+  completedTurnIds = /* @__PURE__ */ new Set();
+  static MAX_COMPLETED_TURN_IDS = 64;
+  log;
+  get threadId() {
+    return this._threadId;
+  }
+  get isConnected() {
+    return this.connected;
+  }
+  /** The app-server child process (for the daemon's liveness watchdog). */
+  get childProcess() {
+    return this.process;
+  }
+  // ── lifecycle ────────────────────────────────────────────────────────────
+  async start() {
+    if (this.connected) return;
+    let command = "codex";
+    let args = ["app-server", "--listen", "stdio://", ...this.opts.extraArgs ?? []];
+    let isoEnv;
+    if (this.opts.isolationConfig) {
+      const wrapped = wrapWithIsolation(command, args, this.opts.isolationConfig);
+      command = wrapped.command;
+      args = wrapped.args;
+      if (wrapped.env) isoEnv = wrapped.env;
+    }
+    const child = spawn(command, args, {
+      cwd: this.opts.cwd,
+      // RUST_LOG mutes rollout noise on stderr; keep the rest of env for auth (~/.codex or key).
+      // isoEnv goes LAST, matching acpBackend.ts:290 exactly
+      // (`{ ...process.env, ...this.options.env, ...isoEnv }`): the sandbox's HOME redirect
+      // must win over both the inherited environment and any caller-supplied override, or
+      // the confinement is advisory. Keep the two spreads in the same order — the point of
+      // this fix is that the two backends stop disagreeing about a security boundary.
+      env: { RUST_LOG: "error", ...process.env, ...this.opts.env ?? {}, ...isoEnv ?? {} },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.process = child;
+    child.stderr?.on("data", (d) => this.log("[codex-app-server:stderr]", d.toString().trim()));
+    child.on("exit", (code) => {
+      const wasConnected = this.connected;
+      if (this.process === child) this.process = null;
+      this.connected = false;
+      this.failAllPending(new Error(`codex app-server exited (code ${code})`));
+      this.resolvePendingTurn(true);
+      if (wasConnected) this.opts.onExit?.(code);
+    });
+    child.on("error", (err) => {
+      this.log("[codex-app-server] spawn error", err);
+    });
+    this.readline = createInterface({ input: child.stdout });
+    this.readline.on("line", (line) => this.onLine(line));
+    const initParams = {
+      clientInfo: { name: "svamp-codex", title: "Svamp Codex Client", version: "2.0.0" },
+      capabilities: { experimentalApi: true }
+    };
+    await this.request("initialize", initParams);
+    this.notify("initialized");
+    this.connected = true;
+    this.log("[codex-app-server] connected + initialized");
+  }
+  async startThread(o) {
+    const params = {
+      model: o.model ?? null,
+      modelProvider: null,
+      profile: null,
+      cwd: o.cwd ?? this.opts.cwd,
+      approvalPolicy: o.approvalPolicy ?? null,
+      sandbox: o.sandbox ?? null,
+      config: null,
+      baseInstructions: null,
+      developerInstructions: null,
+      compactPrompt: null,
+      includeApplyPatchTool: null,
+      experimentalRawEvents: false,
+      persistExtendedHistory: true
+    };
+    const r = await this.request("thread/start", params);
+    this._threadId = r.thread.id;
+    this._turnId = null;
+    this.log("[codex-app-server] thread started", this._threadId);
+    return { threadId: r.thread.id, model: r.model };
+  }
+  async resumeThread(o) {
+    const params = {
+      threadId: o.threadId,
+      model: o.model ?? null,
+      modelProvider: null,
+      cwd: o.cwd ?? this.opts.cwd,
+      approvalPolicy: o.approvalPolicy ?? null,
+      sandbox: o.sandbox ?? null,
+      config: null,
+      baseInstructions: null,
+      developerInstructions: null,
+      persistExtendedHistory: true
+    };
+    const r = await this.request("thread/resume", params);
+    this._threadId = r.thread.id;
+    this._turnId = null;
+    this.log("[codex-app-server] thread resumed", this._threadId);
+    return { threadId: r.thread.id, model: r.model };
+  }
+  /** Build the turn/start params (exported shape kept minimal; only set fields are sent). */
+  buildTurnParams(prompt, o) {
+    const params = { threadId: this._threadId, input: [{ type: "text", text: prompt }] };
+    if (o?.approvalPolicy) params.approvalPolicy = o.approvalPolicy;
+    if (o?.model) params.model = o.model;
+    if (o?.effort) params.effort = o.effort;
+    if (o?.sandbox) {
+      params.sandboxPolicy = { type: o.sandbox === "workspace-write" ? "workspaceWrite" : o.sandbox === "danger-full-access" ? "dangerFullAccess" : "readOnly" };
+    }
+    return params;
+  }
+  /** Start a turn; resolves immediately (completion is tracked via events / waitForTurn). */
+  async startTurn(prompt, o) {
+    if (!this._threadId) throw new Error("No active codex thread \u2014 call startThread first");
+    const result = await this.request("turn/start", this.buildTurnParams(prompt, o));
+    const id = result?.turn?.id;
+    if (typeof id === "string" && id) this._turnId = id;
+  }
+  /** Send a turn and await completion (resolves {aborted} on task_complete/turn_aborted/timeout). */
+  async sendTurnAndWait(prompt, o) {
+    const timeoutMs = o?.timeoutMs ?? 14 * 24 * 60 * 60 * 1e3;
+    let timer = null;
+    const completion = new Promise((resolve) => {
+      this.pendingTurn = { resolve };
+      timer = setTimeout(() => {
+        this.log("[codex-app-server] turn timeout");
+        this.resolvePendingTurn(true);
+      }, timeoutMs);
+      timer?.unref?.();
+    });
+    try {
+      await this.startTurn(prompt, o);
+    } catch (e) {
+      if (timer) clearTimeout(timer);
+      this.pendingTurn = null;
+      throw e;
+    }
+    const aborted = await completion;
+    if (timer) clearTimeout(timer);
+    return { aborted };
+  }
+  /**
+   * Inject additional input into the CURRENTLY RUNNING turn (Claude-Code-style mid-turn steering).
+   *
+   * Uses codex app-server's NATIVE `turn/steer` — the correct primitive for "append this message to
+   * the in-flight turn without interrupting it." The steered input is applied at the next model step
+   * (it does NOT abort a running tool call), the assistant finishes the current work and drains the
+   * steered message as user input before its next LLM call, and NO separate `turn/started` /
+   * `turn/completed` fires — the original single in-flight completion still resolves `sendTurnAndWait`.
+   * So we send it WITHOUT arming a new `pendingTurn` slot and WITHOUT overwriting `_turnId`.
+   *
+   * (The earlier #86 implementation fired a second `turn/start` mid-turn; on codex 0.144 that
+   * ABORTS/REPLACES the running turn instead of folding — the "cuts off the previous task" bug.)
+   *
+   * Returns false when there is no active turn to steer, or when the server REJECTS the steer
+   * (no active turn / expectedTurnId mismatch / non-steerable turn kind such as review or manual
+   * compact). The caller then falls back to client-side queueing (post-turn drain via sendPrompt),
+   * so a rejected steer degrades gracefully rather than losing the message.
+   */
+  async injectInput(prompt, _o) {
+    if (!this._threadId || !this.pendingTurn || !this._turnId) return false;
+    if (!await codexSupportsSteerInstalledAsync()) return false;
+    const params = {
+      threadId: this._threadId,
+      expectedTurnId: this._turnId,
+      input: [{ type: "text", text: prompt }]
+    };
+    try {
+      await this.request("turn/steer", params);
+      return true;
+    } catch (e) {
+      this.log("[codex-app-server] turn/steer rejected \u2014 falling back to post-turn queue", e);
+      return false;
+    }
+  }
+  /** Interrupt the in-flight turn (real server-side abort — the old MCP path couldn't do this). */
+  async interrupt() {
+    if (!this._threadId || !this._turnId) return;
+    const params = { threadId: this._threadId, turnId: this._turnId };
+    try {
+      await this.request("turn/interrupt", params, 1e4);
+    } catch (e) {
+      this.log("[codex-app-server] interrupt err (may be benign)", e);
+    }
+  }
+  async dispose() {
+    this.readline?.close();
+    this.readline = null;
+    const proc = this.process;
+    const pid = proc?.pid;
+    try {
+      proc?.stdin?.end();
+      proc?.kill("SIGTERM");
+    } catch {
+    }
+    if (pid) {
+      const t = setTimeout(() => {
+        try {
+          process.kill(pid, 0);
+          process.kill(pid, "SIGKILL");
+        } catch {
+        }
+      }, 2e3);
+      t.unref?.();
+    }
+    this.process = null;
+    this.connected = false;
+    this._threadId = null;
+    this._turnId = null;
+    this.completedTurnIds.clear();
+    this.failAllPending(new Error("codex app-server disposed"));
+    this.resolvePendingTurn(true);
+  }
+  // ── JSON-RPC plumbing ──────────────────────────────────────────────────────
+  request(method, params, timeoutMs) {
+    const id = this.nextId++;
+    const effTimeout = timeoutMs ?? this.opts.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject, method });
+      const t = setTimeout(() => {
+        if (this.pending.has(id)) {
+          this.pending.delete(id);
+          reject(new Error(`codex ${method} timed out after ${effTimeout}ms`));
+        }
+      }, effTimeout);
+      t.unref?.();
+      this.write({ jsonrpc: "2.0", id, method, params });
+    });
+  }
+  notify(method, params) {
+    this.write({ jsonrpc: "2.0", method, params });
+  }
+  respond(id, result) {
+    this.write({ jsonrpc: "2.0", id, result });
+  }
+  write(obj) {
+    try {
+      this.process?.stdin?.write(JSON.stringify(obj) + "\n");
+    } catch (e) {
+      this.log("[codex-app-server] write error", e);
+    }
+  }
+  failAllPending(err) {
+    for (const [id, p] of this.pending) {
+      p.reject(err);
+      this.pending.delete(id);
+    }
+  }
+  onLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let msg;
+    try {
+      msg = JSON.parse(trimmed);
+    } catch {
+      this.log("[codex-app-server] non-JSON line", trimmed.slice(0, 200));
+      return;
+    }
+    if (msg.id !== void 0 && msg.method === void 0) {
+      const p = this.pending.get(msg.id);
+      if (!p) return;
+      this.pending.delete(msg.id);
+      const r = msg;
+      if (r.error) p.reject(new Error(`codex ${p.method}: ${r.error.message}`));
+      else p.resolve(r.result);
+      return;
+    }
+    if (msg.id !== void 0 && typeof msg.method === "string") {
+      void this.handleServerRequest(msg.id, msg.method, msg.params);
+      return;
+    }
+    if (typeof msg.method === "string") {
+      this.handleNotification(msg.method, msg.params);
+      return;
+    }
+  }
+  // ── server→client approval requests ────────────────────────────────────────
+  async handleServerRequest(id, method, params) {
+    const handler = this.opts.onApproval;
+    if (method === "item/commandExecution/requestApproval" || method === "execCommandApproval") {
+      const callId = String(params?.itemId ?? params?.callId ?? id);
+      const decision = handler ? await handler({ type: "exec", callId, command: Array.isArray(params?.command) ? params.command : params?.command != null ? [params.command] : [], cwd: params?.cwd, reason: params?.reason }).catch(() => "denied") : "denied";
+      this.respond(id, { decision: mapDecisionToWire(decision) });
+      return;
+    }
+    if (method === "item/fileChange/requestApproval" || method === "applyPatchApproval") {
+      const callId = String(params?.itemId ?? params?.callId ?? id);
+      const decision = handler ? await handler({ type: "patch", callId, fileChanges: params?.fileChanges, reason: params?.reason }).catch(() => "denied") : "denied";
+      this.respond(id, { decision: mapDecisionToWire(decision) });
+      return;
+    }
+    if (method === "mcpServer/elicitation/request") {
+      const callId = `${params?.serverName ?? "mcp"}:${id}`;
+      const decision = handler ? await handler({ type: "mcp", callId, serverName: params?.serverName, toolName: params?.serverName, message: params?.message, input: params?._meta?.tool_params ?? {} }).catch(() => "denied") : "denied";
+      const wire = mapDecisionToWire(decision);
+      this.respond(id, { action: wire === "acceptForSession" ? "accept" : wire });
+      return;
+    }
+    this.respond(id, {});
+  }
+  // ── notifications (events + lifecycle) ──────────────────────────────────────
+  handleNotification(method, params) {
+    if (method === "codex/event" || method.startsWith("codex/event/")) {
+      const emsg = params?.msg;
+      if (!emsg) return;
+      if (emsg.type === "task_started" && emsg.turn_id) this._turnId = String(emsg.turn_id);
+      this.opts.onEvent?.(emsg);
+      if (emsg.type === "task_complete" || emsg.type === "turn_aborted") {
+        const tid = emsg.turn_id ?? emsg.turnId ?? null;
+        if (tid) this.rememberCompletedTurn(String(tid));
+        this.resolvePendingTurn(emsg.type === "turn_aborted");
+        this._turnId = null;
+      }
+      return;
+    }
+    if (method === "turn/started") {
+      const tid = params?.turn?.id ?? params?.turnId;
+      if (tid) this._turnId = String(tid);
+      return;
+    }
+    if (method === "turn/completed") {
+      const tid = params?.turn?.id ?? params?.turnId ?? null;
+      if (tid && this.completedTurnIds.has(String(tid))) return;
+      const status = params?.turn?.status ?? params?.status;
+      const aborted = typeof status === "string" && /abort|cancel|error/i.test(status);
+      this.resolvePendingTurn(aborted);
+      this._turnId = null;
+      return;
+    }
+    const normalized = normalizeNotification(method, params);
+    if (normalized) this.opts.onEvent?.(normalized);
+  }
+  resolvePendingTurn(aborted) {
+    const p = this.pendingTurn;
+    this.pendingTurn = null;
+    p?.resolve(aborted);
+  }
+  /** #0455: record a completed turn id, evicting the oldest past the bounded cap. */
+  rememberCompletedTurn(tid) {
+    this.completedTurnIds.add(tid);
+    while (this.completedTurnIds.size > CodexAppServerClient.MAX_COMPLETED_TURN_IDS) {
+      const oldest = this.completedTurnIds.values().next().value;
+      if (oldest === void 0) break;
+      this.completedTurnIds.delete(oldest);
+    }
+  }
+}
+function mapDecisionToWire(d) {
+  switch (d) {
+    case "approved":
+      return "accept";
+    case "approved_for_session":
+      return "acceptForSession";
+    case "denied":
+      return "decline";
+    case "abort":
+      return "cancel";
+  }
+}
+
+class CodexAppServerBackend {
+  constructor(opts) {
+    this.opts = opts;
+    this.log = opts.log ?? (() => {
+    });
+    const provider = opts.provider ?? resolveCodexProvider();
+    const { configArgs, env: providerEnv, model: providerModel } = buildCodexProviderArgs(provider);
+    this.model = opts.model ?? providerModel;
+    this.approvalPolicy = opts.approvalPolicy;
+    this.sandbox = opts.sandbox;
+    this.client = new CodexAppServerClient({
+      cwd: opts.cwd,
+      env: { ...opts.env ?? {}, ...providerEnv },
+      extraArgs: configArgs,
+      log: this.log,
+      isolationConfig: opts.isolationConfig,
+      onEvent: (m) => this.handleCodexEvent(m),
+      onApproval: (r) => this.handleApproval(r),
+      onExit: (code) => this.emit({ type: "status", status: "error", detail: `codex app-server exited (code ${code})` })
+    });
+  }
+  listeners = [];
+  client;
+  sessionId = randomUUID();
+  log;
+  model;
+  // #0438: codex's own approval policy + sandbox, derived from the svamp permission mode. Mutable
+  // so a mid-session switchMode takes effect on the next turn. yolo → 'never' + 'danger-full-access'
+  // so codex NEVER prompts for writes (and never times out waiting on a prompt).
+  approvalPolicy;
+  sandbox;
+  started = false;
+  // Approval promises keyed by callId, resolved by respondToPermission().
+  pendingApprovals = /* @__PURE__ */ new Map();
+  // Whether we streamed any delta for the in-flight assistant message (to avoid a duplicate
+  // fullText push on the final agent_message when the model DID stream).
+  streamedThisMessage = false;
+  // #0412 P3: cost-weighted CUMULATIVE token total across this thread (from codex usage events),
+  // read by the daemon's loop ledger to enforce token/rate cost caps on Codex loops. Monotonic.
+  cumulativeTokens = 0;
+  // Tracks the in-flight turn so waitForResponseComplete() can await it.
+  turnDone = null;
+  /** True/false if codex supports app-server; null if codex isn't installed. */
+  static available() {
+    return codexAppServerAvailable();
+  }
+  // ── AgentBackend ───────────────────────────────────────────────────────────
+  async startSession(initialPrompt) {
+    this.emit({ type: "status", status: "starting" });
+    const avail = codexAppServerAvailable();
+    if (avail === null) throw new Error("Codex CLI not found. Install it (`npm i -g @openai/codex`) and authenticate (`svamp daemon codex-auth`).");
+    if (avail === false) throw new Error("Installed Codex is too old for app-server \u2014 upgrade to >= 0.100 (`npm i -g @openai/codex@latest`).");
+    await this.client.start();
+    if (this.opts.resumeThreadId) {
+      try {
+        await this.client.resumeThread({ threadId: this.opts.resumeThreadId, model: this.model, approvalPolicy: this.approvalPolicy, sandbox: this.sandbox });
+      } catch (err) {
+        this.log(`[Codex] resumeThread(${this.opts.resumeThreadId}) failed (${err?.message ?? err}) \u2014 starting a fresh thread instead (context lost, session preserved)`);
+        const r = await this.client.startThread({ model: this.model, approvalPolicy: this.approvalPolicy, sandbox: this.sandbox });
+        this.model = this.model ?? r.model;
+      }
+    } else {
+      const r = await this.client.startThread({ model: this.model, approvalPolicy: this.approvalPolicy, sandbox: this.sandbox });
+      this.model = this.model ?? r.model;
+    }
+    this.started = true;
+    this.emit({ type: "status", status: "idle" });
+    if (initialPrompt) await this.sendPrompt(this.sessionId, initialPrompt);
+    return { sessionId: this.sessionId };
+  }
+  async sendPrompt(_sessionId, prompt) {
+    if (!this.started) throw new Error("Codex session not started");
+    this.emit({ type: "status", status: "running" });
+    this.streamedThisMessage = false;
+    let resolveTurn;
+    this.turnDone = new Promise((res) => {
+      resolveTurn = res;
+    });
+    try {
+      await this.client.sendTurnAndWait(prompt, { model: this.model, approvalPolicy: this.approvalPolicy, sandbox: this.sandbox });
+    } catch (err) {
+      this.emit({ type: "status", status: "error", detail: err instanceof Error ? err.message : String(err) });
+    } finally {
+      this.emit({ type: "status", status: "idle" });
+      resolveTurn();
+      this.turnDone = null;
+    }
+  }
+  async cancel(_sessionId) {
+    await this.client.interrupt();
+    this.emit({ type: "status", status: "cancelled" });
+  }
+  /**
+   * Mid-turn message injection (Claude-Code parity): fold `prompt` into the RUNNING turn instead
+   * of deferring it to a separate post-turn turn. Codex app-server absorbs a mid-turn `turn/start`
+   * into the active turn (see CodexAppServerClient.injectInput). Returns true if it was injected
+   * into an in-flight turn; false when no turn is running (the daemon then falls back to a normal
+   * sendPrompt, which properly tracks completion). Guards on `turnDone` to minimize the race where
+   * the turn ends between the daemon's busy-check and this call.
+   */
+  async injectInput(prompt) {
+    if (!this.started || !this.turnDone) return false;
+    return this.client.injectInput(prompt, { model: this.model, approvalPolicy: this.approvalPolicy, sandbox: this.sandbox });
+  }
+  onMessage(handler) {
+    this.listeners.push(handler);
+  }
+  offMessage(handler) {
+    this.listeners = this.listeners.filter((h) => h !== handler);
+  }
+  async respondToPermission(requestId, approved) {
+    const resolve = this.pendingApprovals.get(requestId);
+    if (resolve) {
+      this.pendingApprovals.delete(requestId);
+      resolve(approved ? "approved" : "denied");
+    }
+    this.emit({ type: "permission-response", id: requestId, approved });
+  }
+  async waitForResponseComplete(timeoutMs = 14 * 24 * 60 * 60 * 1e3) {
+    if (!this.turnDone) return;
+    await Promise.race([this.turnDone, new Promise((res) => {
+      const t = setTimeout(res, timeoutMs);
+      t.unref?.();
+    })]);
+  }
+  async dispose() {
+    for (const [, resolve] of this.pendingApprovals) resolve("denied");
+    this.pendingApprovals.clear();
+    await this.client.dispose();
+  }
+  /** The live Codex thread id (for the daemon to persist and resume after a restart). */
+  getThreadId() {
+    return this.client.threadId;
+  }
+  /** The underlying `codex app-server` child process, for the daemon's liveness watchdog. */
+  getProcess() {
+    return this.client.childProcess ?? void 0;
+  }
+  /** Update the model used for subsequent turns (per-turn override — no restart needed). */
+  setModel(model) {
+    this.model = model;
+  }
+  /** #0438: update codex's approval policy + sandbox (from a svamp permission-mode switch). Takes
+   *  effect on the next turn (and next thread start). yolo → 'never' + 'danger-full-access'. */
+  setPermission(approvalPolicy, sandbox) {
+    this.approvalPolicy = approvalPolicy;
+    this.sandbox = sandbox;
+  }
+  /** The model label for assistant-message parity with Claude (frontend schema requires a non-empty `model`). */
+  getModel() {
+    return this.model || "codex";
+  }
+  /** #0412 P3: cost-weighted cumulative token total across the thread, so the loop ledger can
+   *  enforce token/rate cost caps for Codex loops. 0 until the first usage event arrives. */
+  getCumulativeTokens() {
+    return this.cumulativeTokens;
+  }
+  // ── internal ─────────────────────────────────────────────────────────────
+  emit(msg) {
+    for (const h of this.listeners) {
+      try {
+        h(msg);
+      } catch (e) {
+        this.log("[codex-backend] listener error", e);
+      }
+    }
+  }
+  handleApproval(req) {
+    const id = req.callId || randomUUID();
+    const reason = req.type === "exec" ? `Execute: ${(req.command ?? []).join(" ")}` : req.type === "patch" ? "Apply file changes" : req.toolName ? `Tool: ${req.toolName}` : "Codex requires approval";
+    const payload = req.type === "exec" ? { toolName: "CodexBash", input: { command: req.command, cwd: req.cwd } } : req.type === "patch" ? { toolName: "CodexPatch", input: { fileChanges: req.fileChanges } } : { toolName: req.toolName ?? "CodexTool", input: req.input };
+    this.emit({ type: "permission-request", id, reason, payload });
+    return new Promise((resolve) => {
+      this.pendingApprovals.set(id, resolve);
+      const t = setTimeout(() => {
+        if (this.pendingApprovals.delete(id)) resolve("denied");
+      }, 5 * 60 * 1e3);
+      t.unref?.();
+    });
+  }
+  handleCodexEvent(event) {
+    const t = event.type;
+    switch (t) {
+      case "task_started":
+        this.emit({ type: "status", status: "running" });
+        break;
+      case "task_complete":
+      case "turn_aborted":
+        break;
+      case "agent_message_delta": {
+        const delta = event.delta ?? (typeof event.text === "string" ? event.text : "");
+        if (delta) {
+          this.streamedThisMessage = true;
+          this.emit({ type: "model-output", textDelta: delta });
+        }
+        break;
+      }
+      case "agent_message": {
+        this.streamedThisMessage = false;
+        const text = mapCodexEventToText(event);
+        if (text) this.emit({ type: "model-output", fullText: text });
+        break;
+      }
+      case "agent_reasoning_delta": {
+        const text = event.delta?.text || event.text || (Array.isArray(event.content) ? event.content.map((c) => c?.text).join("") : "");
+        if (text) this.emit({ type: "event", name: "thinking", payload: { text, delta: true } });
+        break;
+      }
+      case "agent_reasoning": {
+        const text = event.delta?.text || event.text || (Array.isArray(event.content) ? event.content.map((c) => c?.text).join("") : "");
+        if (text) this.emit({ type: "event", name: "thinking", payload: { text, delta: false } });
+        break;
+      }
+      case "exec_command_begin": {
+        const callId = String(event.call_id ?? event.callId ?? randomUUID());
+        const command = Array.isArray(event.command) ? event.command.join(" ") : String(event.command ?? "");
+        this.emit({ type: "tool-call", toolName: "CodexBash", callId, args: { command, cwd: event.cwd } });
+        break;
+      }
+      case "exec_command_end": {
+        const callId = String(event.call_id ?? event.callId ?? "");
+        this.emit({ type: "tool-result", toolName: "CodexBash", callId, result: { exitCode: event.exit_code ?? event.exitCode, stdout: event.stdout ?? "", stderr: event.stderr ?? "" } });
+        break;
+      }
+      case "patch_apply_begin": {
+        const callId = String(event.call_id ?? event.callId ?? randomUUID());
+        const { filePath, patch, kind } = summarizeCodexChanges(event.changes);
+        this.emit({ type: "tool-call", toolName: "CodexPatch", callId, args: {
+          filePath: filePath ?? event.file_path ?? event.filePath ?? null,
+          patch: patch || (typeof event.patch === "string" ? event.patch : ""),
+          ...kind ? { kind } : {}
+        } });
+        break;
+      }
+      case "patch_apply_end": {
+        const callId = String(event.call_id ?? event.callId ?? "");
+        const { filePath } = summarizeCodexChanges(event.changes);
+        this.emit({ type: "tool-result", toolName: "CodexPatch", callId, result: {
+          filePath: filePath ?? event.file_path ?? event.filePath ?? null,
+          applied: event.applied,
+          error: event.error
+        } });
+        break;
+      }
+      case "mcp_tool_call_begin": {
+        const callId = String(event.call_id ?? event.callId ?? randomUUID());
+        this.emit({ type: "tool-call", toolName: String(event.tool ?? "CodexMcpTool"), callId, args: { server: event.server, arguments: event.arguments } });
+        break;
+      }
+      case "mcp_tool_call_end": {
+        const callId = String(event.call_id ?? event.callId ?? "");
+        this.emit({ type: "tool-result", toolName: String(event.tool ?? "CodexMcpTool"), callId, result: { result: event.result, error: event.error } });
+        break;
+      }
+      case "token_count":
+      case "token_usage": {
+        const payload = event.usage ?? event.info ?? event;
+        const cum = codexCumulativeTokens(payload);
+        if (cum > this.cumulativeTokens) this.cumulativeTokens = cum;
+        this.emit({ type: "event", name: "usage", payload });
+        break;
+      }
+      case "error": {
+        const msg = event.message ?? event.error ?? "Codex error";
+        this.emit({ type: "status", status: "error", detail: String(msg) });
+        break;
+      }
+      default:
+        if (t === "_rpc/thread/tokenUsage/updated") {
+          this.emit({ type: "event", name: "usage", payload: event.params });
+        }
+        break;
+    }
+  }
+}
+
+var codexAppServerBackend = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    CodexAppServerBackend: CodexAppServerBackend
+});
+
+export { CodexAppServerBackend as C, codexAppServerBackend as a, codexAppServerAvailable as c };