very-happy-cli 0.2.175 → 0.2.176

package/dist/{codexAppServerClient-CppPl_R6.mjs → codexAppServerClient-C70pJ-BB.mjs}

@@ -1,12 +1,100 @@
-import { execSync } from 'node:child_process';
-import { spawn } from 'cross-spawn';
+import { spawn, execSync } from 'node:child_process';
+import { spawn as spawn$1 } from 'cross-spawn';
 import { createInterface } from 'node:readline';
-import { l as logger } from './logger-D5EzMy30.mjs';
+import { l as logger } from './logger-CihCDWDw.mjs';
 import { e as errorLogMetadata, c as contentLogMetadata } from './contentLogMetadata-BlWI0egu.mjs';
-import { i as initializeSandbox, w as wrapForMcpTransport } from './manager-BEsI4qt3.mjs';
-import { p as packageJson } from './package-D0dxZ-W8.mjs';
-import { s as shouldReadCodexRateLimits, i as isUnsupportedCodexMethodError } from './rateLimitWindows-Bo6XVnie.mjs';
+import { i as initializeSandbox, a as wrapForMcpTransport } from './manager-2Il8XJVq.mjs';
+import { p as packageJson } from './package-ayqGDKSp.mjs';
+import { s as shouldReadCodexRateLimits, i as isUnsupportedCodexMethodError } from './rateLimitWindows-E5DRjfE6.mjs';
 
+const CODEX_HELPER_LABEL_MAX_CHARS = 80;
+function codexHelperLabel(prompt) {
+  if (typeof prompt !== "string") return null;
+  const collapsed = prompt.replace(/\s+/g, " ").trim();
+  if (collapsed.length === 0) return null;
+  if (collapsed.length <= CODEX_HELPER_LABEL_MAX_CHARS) return collapsed;
+  const keep = CODEX_HELPER_LABEL_MAX_CHARS - 1;
+  const last = collapsed.charCodeAt(keep - 1);
+  const end = last >= 55296 && last <= 56319 ? keep - 1 : keep;
+  return `${collapsed.slice(0, end)}\u2026`;
+}
+function codexAgentPathSegments(agentPath) {
+  if (typeof agentPath !== "string") return [];
+  return agentPath.split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+}
+function isRootAgentPath(segments) {
+  return segments.length === 1 && segments[0] === "root";
+}
+function codexChildAnnouncements(item) {
+  if (item.type === "subAgentActivity") {
+    const threadId = item.agentThreadId;
+    if (typeof threadId !== "string" || threadId.length === 0) return [];
+    const segments = codexAgentPathSegments(item.agentPath);
+    if (isRootAgentPath(segments)) return [];
+    const leaf = segments.at(-1);
+    return [{ threadId, label: leaf && leaf.length > 0 ? leaf : null }];
+  }
+  if (item.type === "collabAgentToolCall") {
+    const receivers = Array.isArray(item.receiverThreadIds) ? item.receiverThreadIds.filter((id) => typeof id === "string" && id.length > 0) : [];
+    const label = item.tool === "spawnAgent" ? codexHelperLabel(item.prompt) : null;
+    return [...new Set(receivers)].map((threadId) => ({ threadId, label }));
+  }
+  return [];
+}
+
+function stopCodexProcess(proc, deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  try {
+    proc.stdin?.end();
+  } catch {
+  }
+  if (platform === "win32") return;
+  try {
+    proc.kill("SIGTERM");
+  } catch {
+  }
+}
+function killCodexProcessTree(proc, deps = {}) {
+  if (proc.exitCode != null || proc.signalCode != null) return;
+  const killRoot = () => {
+    try {
+      proc.kill("SIGKILL");
+    } catch {
+    }
+  };
+  const pid = proc.pid;
+  if (!pid || !("exitCode" in proc)) {
+    killRoot();
+    return;
+  }
+  const platform = deps.platform ?? process.platform;
+  const spawn$1 = deps.spawn ?? ((command, args, options) => spawn(command, args, options));
+  if (platform === "win32") {
+    try {
+      const killer = spawn$1("taskkill", ["/pid", String(pid), "/t", "/f"], { stdio: "ignore", windowsHide: true });
+      killer.on("error", killRoot);
+      killer.on("exit", (code) => {
+        if (code !== 0) killRoot();
+      });
+      killer.unref();
+    } catch {
+      killRoot();
+    }
+    return;
+  }
+  try {
+    const reaper = spawn$1("pkill", ["-KILL", "-P", String(pid)], { stdio: "ignore", windowsHide: true });
+    reaper.on("error", () => void 0);
+    reaper.unref();
+  } catch {
+  }
+  killRoot();
+}
+
+function jsonRpcErrorCodeOf(error) {
+  const code = error?.jsonRpcCode;
+  return typeof code === "number" ? code : null;
+}
 function isAppServerAvailable() {
   try {
     const version = execSync("codex --version", { encoding: "utf8", windowsHide: true }).trim();
@@ -121,6 +209,18 @@ class CodexAppServerClient {
   // Approval / elicitation requests we are still answering: a human may take
   // longer than the watchdog to decide, and that is not Codex going silent.
   inflightServerRequests = 0;
+  // B-628: `turn/steer` — a message sent into the running turn (approach from Orca,
+  // src/main/codex/codex-structured-turn-start.ts). This app-server has no such
+  // method (-32601) until it is respawned; a refusal is per call (the turn it named
+  // ended or changed meanwhile, a review/compact turn).
+  steerUnsupported = false;
+  /** Steered inputs Codex has not echoed back as a `userMessage` item yet: clientId → turnId. */
+  steeredAwaitingEcho = /* @__PURE__ */ new Map();
+  /** Waiters for the pending turn to open (steerTurn); released when it opens or ends. */
+  turnOpenWaiters = [];
+  /** B-628: the names Codex gave the child threads it spawned (see codexChildThreads.ts). */
+  childThreadLabels = /* @__PURE__ */ new Map();
+  static MAX_CHILD_LABELS = 128;
   // Handlers set by the consumer (runCodex.ts)
   eventHandler = null;
   approvalHandler = null;
@@ -191,6 +291,58 @@ class CodexAppServerClient {
     const threadId = this.extractThreadId(params);
     return threadId === null || this._threadId === null || threadId === this._threadId;
   }
+  /** B-628: the child thread a frame belongs to, or null for the session's own. */
+  childThreadIdOf(params) {
+    return this.isOwnThreadFrame(params) ? null : this.extractThreadId(params);
+  }
+  /**
+   * B-628: what a child thread's item carries so the mapper files it under the child's
+   * card (`subagent` → the session protocol's sub-agent envelope, as a Claude Task's
+   * children are) instead of in the main conversation as the session's own work.
+   */
+  childItemFields(params) {
+    const child = this.childThreadIdOf(params);
+    if (!child) return {};
+    const label = this.childThreadLabels.get(child);
+    return { subagent: child, ...label ? { subagent_label: label } : {} };
+  }
+  rememberChildLabels(item) {
+    for (const { threadId, label } of codexChildAnnouncements(item)) {
+      if (!label || this.childThreadLabels.has(threadId)) continue;
+      if (this.childThreadLabels.size >= CodexAppServerClient.MAX_CHILD_LABELS) {
+        const oldest = this.childThreadLabels.keys().next().value;
+        if (oldest !== void 0) this.childThreadLabels.delete(oldest);
+      }
+      this.childThreadLabels.set(threadId, label);
+    }
+  }
+  /**
+   * B-628: steered inputs the ended turn never echoed. `report` = the turn did not complete
+   * (interrupted, failed, app-server gone, given up): Codex never read them, tell the runner.
+   * A turn that *completed* drains its pending input before it ends (core/src/session/turn.rs),
+   * so an unechoed input there is a codex that accepted the steer but echoes no `clientId` —
+   * forgotten silently, because a false「not delivered」on a message the model did read would
+   * be worse than today's silence.
+   */
+  dropUnechoedSteers(turnId, report) {
+    const dropped = [];
+    for (const [clientId, steeredTurn] of this.steeredAwaitingEcho) {
+      if (turnId === null || steeredTurn === turnId) {
+        dropped.push(clientId);
+        this.steeredAwaitingEcho.delete(clientId);
+      }
+    }
+    if (dropped.length === 0) return;
+    if (!report) {
+      logger.debug(`[CodexAppServer] ${dropped.length} steered message(s) completed without an echo; not reported`);
+      return;
+    }
+    this.eventHandler?.({
+      type: "steer_dropped",
+      client_ids: dropped,
+      ...turnId ? { turn_id: turnId } : {}
+    });
+  }
   /** Codex's last stderr lines, one line, for a message a person reads. */
   stderrTail() {
     return this.stderrRing.replace(/\x1b\[[0-9;]*m/g, "").replace(/\s+/g, " ").trim();
@@ -225,6 +377,7 @@ class CodexAppServerClient {
       this.completedTurnIds.add(turnId);
       if (failed) this.failedTurnIds.add(turnId);
     }
+    this.dropUnechoedSteers(turnId, aborted || failed);
     if (aborted) {
       this.eventHandler?.({
         type: "turn_aborted",
@@ -264,6 +417,11 @@ class CodexAppServerClient {
     if (method === "turn/completed") {
       if (!this.isOwnThreadFrame(params)) {
         logger.debug(`[CodexAppServer] Child thread ${this.extractThreadId(params)} ended a turn`);
+        this.eventHandler?.({
+          type: "subagent_turn_end",
+          ...this.childItemFields(params),
+          status: this.extractTurnStatus(params)
+        });
         return true;
       }
       this.emitRawTurnCompletion(
@@ -296,6 +454,7 @@ class CodexAppServerClient {
       return true;
     }
     if (method === "thread/tokenUsage/updated") {
+      if (!this.isOwnThreadFrame(params)) return true;
       const tokenUsage = params?.tokenUsage;
       if (tokenUsage && typeof tokenUsage === "object") {
         this.eventHandler?.({
@@ -309,8 +468,15 @@ class CodexAppServerClient {
     if (!item || typeof item !== "object") {
       return method.startsWith("item/");
     }
+    const child = this.childItemFields(params);
     if ((method === "item/started" || method === "item/completed") && (item.type === "collabAgentToolCall" || item.type === "subAgentActivity")) {
-      this.eventHandler?.({ type: "collab_agent_item", item });
+      this.rememberChildLabels(item);
+      this.eventHandler?.({ type: "collab_agent_item", item, ...child });
+      return true;
+    }
+    if (method === "item/completed" && item.type === "userMessage") {
+      const clientId = typeof item.clientId === "string" ? item.clientId : null;
+      if (clientId && !child.subagent) this.steeredAwaitingEcho.delete(clientId);
       return true;
     }
     if (method === "item/started" && item.type === "commandExecution") {
@@ -321,7 +487,8 @@ class CodexAppServerClient {
         callId,
         command: item.command,
         cwd: item.cwd,
-        description: item.command
+        description: item.command,
+        ...child
       });
       return true;
     }
@@ -336,7 +503,8 @@ class CodexAppServerClient {
         duration_ms: item.durationMs ?? null,
         status: item.status,
         cwd: item.cwd,
-        command: item.command
+        command: item.command,
+        ...child
       });
       return true;
     }
@@ -351,7 +519,8 @@ class CodexAppServerClient {
           type: "patch_apply_begin",
           call_id: callId,
           callId,
-          changes: changes ?? {}
+          changes: changes ?? {},
+          ...child
         });
         return true;
       }
@@ -360,7 +529,8 @@ class CodexAppServerClient {
           type: "patch_apply_end",
           call_id: callId,
           callId,
-          status: item.status
+          status: item.status,
+          ...child
         });
         if (callId && (item.status === "completed" || item.status === "failed" || item.status === "declined")) {
           this.rawFileChangesByItemId.delete(callId);
@@ -375,7 +545,8 @@ class CodexAppServerClient {
           type: "agent_message",
           message: text,
           item_id: item.id,
-          phase: item.phase
+          phase: item.phase,
+          ...child
         });
       }
       return true;
@@ -421,7 +592,7 @@ class CodexAppServerClient {
     }
     logger.debug(`[CodexAppServer] Spawning: ${command} ${args.join(" ")}`);
     const epoch = ++this.processEpoch;
-    const proc = spawn(command, args, {
+    const proc = spawn$1(command, args, {
       stdio: ["pipe", "pipe", "pipe"],
       env,
       windowsHide: true
@@ -448,6 +619,7 @@ class CodexAppServerClient {
       }
       if (this.pendingTurnCompletion) {
         const turnId = this.pendingTurnCompletion.turnId ?? this._turnId;
+        this.dropUnechoedSteers(null, true);
         this.eventHandler?.({
           type: "turn_aborted",
           reason: "process-exit",
@@ -458,6 +630,9 @@ class CodexAppServerClient {
       this.resolvePendingTurn(true);
     });
     this.stderrRing = "";
+    this.steerUnsupported = false;
+    this.steeredAwaitingEcho.clear();
+    this.childThreadLabels.clear();
     proc.stderr?.on("data", (chunk) => {
       if (this.process !== proc || this.processEpoch !== epoch) return;
       const text = chunk.toString().trim();
@@ -496,20 +671,12 @@ ${text}`.slice(-400);
     logger.debug(`[CodexAppServer] Disconnecting; pid=${pid ?? "none"}`);
     this.readline?.close();
     this.readline = null;
-    try {
-      proc?.stdin?.end();
-      proc?.kill("SIGTERM");
-    } catch {
-    }
-    if (pid) {
-      const killTimer = setTimeout(() => {
-        try {
-          process.kill(pid, 0);
-          process.kill(pid, "SIGKILL");
-        } catch {
-        }
-      }, 2e3);
-      killTimer.unref();
+    if (proc) {
+      stopCodexProcess(proc);
+      if (pid) {
+        const killTimer = setTimeout(() => killCodexProcessTree(proc), CodexAppServerClient.FORCE_KILL_AFTER_MS);
+        killTimer.unref();
+      }
     }
     this.process = null;
     this.connected = false;
@@ -528,6 +695,7 @@ ${text}`.slice(-400);
       req.reject(new Error(`Codex process disconnected while waiting for ${req.method}`));
       this.pending.delete(id);
     }
+    this.dropUnechoedSteers(null, true);
     this.resolvePendingTurn(true);
     if (this.sandboxCleanup) {
       try {
@@ -731,6 +899,8 @@ ${text}`.slice(-400);
   // ─── Turn management ────────────────────────────────────────
   /** Default grace period after interrupt before forcing a restart (ms). */
   static ABORT_GRACE_MS = 3e3;
+  /** How long the graceful stop gets before the process tree is killed (disconnectInternal). */
+  static FORCE_KILL_AFTER_MS = 2e3;
   hasPendingTurnCompletion() {
     return this.pendingTurnCompletion !== null;
   }
@@ -740,6 +910,7 @@ ${text}`.slice(-400);
     this.clearThreadStopGrace();
     this.pendingTurnCompletion.resolve(aborted);
     this.pendingTurnCompletion = null;
+    this.releaseTurnOpenWaiters();
   }
   markPendingTurnStarted(turnId) {
     if (!this.pendingTurnCompletion) return;
@@ -747,6 +918,86 @@ ${text}`.slice(-400);
     if (turnId) {
       this.pendingTurnCompletion.turnId = turnId;
     }
+    this.releaseTurnOpenWaiters();
+  }
+  // ─── B-628: steering the running turn ───────────────────────
+  /** How long a steer waits for the pending turn to open before the message is queued instead. */
+  static STEER_OPEN_WAIT_MS = 5e3;
+  /** A turn Codex has reported running, under an id `turn/steer` can name. */
+  turnIsOpen() {
+    return this.pendingTurnCompletion?.opened === true && this._turnId !== null;
+  }
+  releaseTurnOpenWaiters() {
+    const waiters = this.turnOpenWaiters;
+    this.turnOpenWaiters = [];
+    for (const release of waiters) release();
+  }
+  /**
+   * Waits for the pending turn to open — `turn/start` is in flight, or the runner is still
+   * bringing a released app-server back before sending it (B-461) — as Orca's send does
+   * (codex-structured-turn-open-wait.ts, 5 s). Resolves early when the turn ends instead.
+   */
+  async waitForTurnOpen(timeoutMs) {
+    if (this.turnIsOpen()) return true;
+    if (timeoutMs <= 0) return false;
+    await new Promise((resolve) => {
+      const release = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      const timer = setTimeout(release, timeoutMs);
+      timer.unref();
+      this.turnOpenWaiters.push(release);
+    });
+    return this.turnIsOpen();
+  }
+  /**
+   * B-628: send a message into the turn running right now (`turn/steer`, codex ≥ 0.148 /
+   * app-server-protocol v2 `TurnSteerParams`). Codex appends it to that turn's pending input
+   * and the model reads it before its next call; the turn keeps its own model, approval
+   * policy and sandbox — the runner applies any change on the next `turn/start`. Codex
+   * refuses before taking any input (expectedTurnId is a precondition), so a non-`steered`
+   * outcome always means "queue it for the next turn as before": `no-turn` (nothing running,
+   * or it ended while we waited), `unsupported` (this app-server has no `turn/steer`,
+   * remembered until it is respawned), `refused` (Codex declined this one), `failed`
+   * (transport — the turn itself is reported through its own events).
+   */
+  async steerTurn(input, opts) {
+    if (this.steerUnsupported) return "unsupported";
+    if (this.pendingInterrupt) return "no-turn";
+    const opened = await this.waitForTurnOpen(opts?.waitForTurnMs ?? CodexAppServerClient.STEER_OPEN_WAIT_MS);
+    const threadId = this._threadId;
+    const turnId = this._turnId;
+    if (!opened || !threadId || !turnId || !this.connected || this.pendingInterrupt) return "no-turn";
+    const params = {
+      threadId,
+      expectedTurnId: turnId,
+      ...input.clientId ? { clientUserMessageId: input.clientId } : {},
+      input: [
+        { type: "text", text: input.text },
+        ...(input.images ?? []).map((path) => ({ type: "localImage", path }))
+      ]
+    };
+    try {
+      const result = await this.request("turn/steer", params);
+      const steeredTurnId = typeof result?.turnId === "string" && result.turnId.length > 0 ? result.turnId : turnId;
+      if (input.clientId) this.steeredAwaitingEcho.set(input.clientId, steeredTurnId);
+      logger.debug(`[CodexAppServer] Steered a message into turn ${steeredTurnId}`);
+      return "steered";
+    } catch (error) {
+      const code = jsonRpcErrorCodeOf(error);
+      if (code === -32601) {
+        this.steerUnsupported = true;
+        logger.debug("[CodexAppServer] turn/steer is not supported by this codex; queuing instead");
+        return "unsupported";
+      }
+      if (code !== null) {
+        logger.debug("[CodexAppServer] turn/steer refused:", errorLogMetadata(error));
+        return "refused";
+      }
+      logger.debug("[CodexAppServer] turn/steer failed:", errorLogMetadata(error));
+      return "failed";
+    }
   }
   /** Default wait for Codex's `turn/completed` after its thread reported idle/systemError. */
   static THREAD_STOP_GRACE_MS = 1500;
@@ -909,6 +1160,7 @@ ${text}`.slice(-400);
     } catch (err) {
       this.clearTurnWatchdog();
       this.pendingTurnCompletion = null;
+      this.releaseTurnOpenWaiters();
       throw err;
     }
     const aborted = await completion;
@@ -926,6 +1178,7 @@ ${text}`.slice(-400);
       }
       logger.warn(`[CodexAppServer] No notification from Codex for ${timeoutMs}ms \u2014 giving the turn up as aborted`);
       const turnId = this.pendingTurnCompletion.turnId ?? this._turnId;
+      this.dropUnechoedSteers(turnId, true);
       this.eventHandler?.({
         type: "turn_aborted",
         reason: "timeout",
@@ -976,6 +1229,7 @@ ${text}`.slice(-400);
     logger.debug(
       `[CodexAppServer] Clearing thread state: thread=${this._threadId ?? "none"} turn=${this._turnId ?? "none"}`
     );
+    this.dropUnechoedSteers(null, true);
     this.resolvePendingTurn(true);
     this._threadId = null;
     this._turnId = null;
@@ -984,6 +1238,7 @@ ${text}`.slice(-400);
     this.failedTurnIds.clear();
     this.lastTurnError = null;
     this.rawFileChangesByItemId.clear();
+    this.childThreadLabels.clear();
   }
   // ─── JSON-RPC transport ─────────────────────────────────────
   /** Default timeout for RPC requests (ms). */
@@ -1064,7 +1319,9 @@ ${text}`.slice(-400);
         }
         this.pending.delete(msg.id);
         if (msg.error) {
-          pending.reject(new Error(`${pending.method}: ${msg.error.message} (code=${msg.error.code})`));
+          const error = new Error(`${pending.method}: ${msg.error.message} (code=${msg.error.code})`);
+          if (typeof msg.error.code === "number") error.jsonRpcCode = msg.error.code;
+          pending.reject(error);
         } else {
           pending.resolve(msg.result);
         }