very-happy-cli 0.2.173 → 0.2.175

package/dist/{codexAppServerClient-BCAPEmbn.mjs → codexAppServerClient-CppPl_R6.mjs}

@@ -1,11 +1,11 @@
 import { execSync } from 'node:child_process';
 import { spawn } from 'cross-spawn';
 import { createInterface } from 'node:readline';
-import { l as logger } from './logger-CKCRe63e.mjs';
+import { l as logger } from './logger-D5EzMy30.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-JFU2Ry9r.mjs';
-import { s as shouldReadCodexRateLimits, i as isUnsupportedCodexMethodError } from './rateLimitWindows-C36y0Ldw.mjs';
+import { p as packageJson } from './package-D0dxZ-W8.mjs';
+import { s as shouldReadCodexRateLimits, i as isUnsupportedCodexMethodError } from './rateLimitWindows-Bo6XVnie.mjs';
 
 function isAppServerAvailable() {
   try {
@@ -89,7 +89,6 @@ class CodexAppServerClient {
   _turnId = null;
   threadDefaults = null;
   // Turn completion tracking for the currently active sendTurnAndWait call.
-  // A completion event only resolves once we have seen task_started for this turn.
   pendingTurnCompletion = null;
   // Tracks in-flight interruptTurn() RPCs so sendTurnAndWait can wait for them
   // before starting a new turn (prevents stale turn/interrupt from aborting the next turn).
@@ -99,7 +98,29 @@ class CodexAppServerClient {
   idleRelease = null;
   notificationProtocol = "unknown";
   completedTurnIds = /* @__PURE__ */ new Set();
+  /** B-625: turns whose failure has already been forwarded, so a second failed frame is not. */
+  failedTurnIds = /* @__PURE__ */ new Set();
+  // B-625: the app-server speaks for every thread it hosts — the session's own and the
+  // children `spawn_agent` opens — so a lifecycle frame (turn/started, turn/completed,
+  // thread/status/changed, error, thread/closed) is the session's only when its `threadId`
+  // is ours; a frame naming no thread belongs to the thread it was asked on (Orca's rule,
+  // src/main/codex/codex-structured-turn-open-wait.ts). Before this, a child's
+  // `turn/completed` ended the parent's turn in the UI and a child's `turn/started`
+  // retargeted `turn/interrupt` at the child.
+  /** The own thread's last turn-ending `error` (willRetry=false), for a turn end that arrives without a verdict. */
+  lastTurnError = null;
+  /** Own thread reported idle/systemError while a turn was pending: Codex's `turn/completed`
+   *  follows within a millisecond; this ends the turn if it does not (see armThreadStopGrace). */
+  threadStopGrace = null;
+  /** Last few hundred chars of the app-server's stderr: Codex's own last words when it dies. */
+  stderrRing = "";
   rawFileChangesByItemId = /* @__PURE__ */ new Map();
+  // B-622: inactivity watchdog for the pending turn — re-armed by every
+  // notification, never a cap on how long a turn may run (see sendTurnAndWait).
+  turnWatchdog = null;
+  // 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;
   // Handlers set by the consumer (runCodex.ts)
   eventHandler = null;
   approvalHandler = null;
@@ -161,8 +182,21 @@ class CodexAppServerClient {
     const status = params?.turn?.status ?? params?.status ?? null;
     return typeof status === "string" && status.length > 0 ? status : null;
   }
+  extractThreadId(params) {
+    const threadId = params?.threadId ?? params?.thread_id ?? params?.thread?.id ?? null;
+    return typeof threadId === "string" && threadId.length > 0 ? threadId : null;
+  }
+  /** B-625: whether a lifecycle frame is about the session's own thread (see the field comment). */
+  isOwnThreadFrame(params) {
+    const threadId = this.extractThreadId(params);
+    return threadId === null || this._threadId === null || threadId === this._threadId;
+  }
+  /** 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();
+  }
   shouldHandleRawNotification(method) {
-    const isRawNotification = method === "thread/started" || method === "turn/started" || method === "turn/completed" || method === "thread/status/changed" || method === "thread/tokenUsage/updated" || method.startsWith("item/");
+    const isRawNotification = method === "thread/started" || method === "turn/started" || method === "turn/completed" || method === "thread/status/changed" || method === "thread/closed" || method === "thread/tokenUsage/updated" || method.startsWith("item/");
     if (!isRawNotification) {
       return false;
     }
@@ -176,14 +210,20 @@ class CodexAppServerClient {
   }
   emitRawTurnCompletion(turnId, status, error, source) {
     const aborted = status === "cancelled" || status === "canceled" || status === "aborted" || status === "interrupted";
+    const failed = status === "failed" || error !== void 0 && error !== null;
+    this.clearThreadStopGrace();
     this.tryResolvePendingTurn(aborted, turnId, source);
     this._turnId = null;
     this.maybeRefreshRateLimits();
+    if (this.lastTurnError && (!turnId || !this.lastTurnError.turnId || this.lastTurnError.turnId === turnId)) {
+      this.lastTurnError = null;
+    }
     if (turnId && this.completedTurnIds.has(turnId)) {
-      return;
+      if (!failed || this.failedTurnIds.has(turnId)) return;
     }
     if (turnId) {
       this.completedTurnIds.add(turnId);
+      if (failed) this.failedTurnIds.add(turnId);
     }
     if (aborted) {
       this.eventHandler?.({
@@ -206,6 +246,10 @@ class CodexAppServerClient {
       return false;
     }
     if (method === "turn/started") {
+      if (!this.isOwnThreadFrame(params)) {
+        logger.debug(`[CodexAppServer] Child thread ${this.extractThreadId(params)} started a turn`);
+        return true;
+      }
       const turnId = this.extractTurnId(params);
       if (turnId) {
         this._turnId = turnId;
@@ -218,6 +262,10 @@ class CodexAppServerClient {
       return true;
     }
     if (method === "turn/completed") {
+      if (!this.isOwnThreadFrame(params)) {
+        logger.debug(`[CodexAppServer] Child thread ${this.extractThreadId(params)} ended a turn`);
+        return true;
+      }
       this.emitRawTurnCompletion(
         this.extractTurnId(params),
         this.extractTurnStatus(params),
@@ -227,9 +275,23 @@ class CodexAppServerClient {
       return true;
     }
     if (method === "thread/status/changed") {
+      if (!this.isOwnThreadFrame(params)) return true;
       const statusType = params?.status?.type;
-      if (statusType === "idle" && this.pendingTurnCompletion) {
-        this.emitRawTurnCompletion(this._turnId, "completed", null, method);
+      if ((statusType === "idle" || statusType === "systemError") && this.pendingTurnCompletion?.opened) {
+        this.armThreadStopGrace(statusType);
+      } else if (statusType === "active") {
+        this.clearThreadStopGrace();
+      }
+      return true;
+    }
+    if (method === "thread/closed") {
+      if (this.isOwnThreadFrame(params) && this.pendingTurnCompletion) {
+        this.emitRawTurnCompletion(
+          this.pendingTurnCompletion.turnId ?? this._turnId,
+          "aborted",
+          { message: "Codex closed the thread before the turn ended." },
+          method
+        );
       }
       return true;
     }
@@ -316,14 +378,6 @@ class CodexAppServerClient {
           phase: item.phase
         });
       }
-      if (item.phase === "final_answer" && this.pendingTurnCompletion) {
-        this.emitRawTurnCompletion(
-          this.extractTurnId(params),
-          "completed",
-          null,
-          `${method}:final_answer`
-        );
-      }
       return true;
     }
     return method.startsWith("item/");
@@ -383,17 +437,35 @@ class CodexAppServerClient {
         return;
       }
       this.connected = false;
+      const tail = this.stderrTail();
+      const exited = `Codex process exited (code=${code ?? "null"}${signal ? `, signal=${signal}` : ""})`;
       for (const [id, req] of this.pending) {
         if (req.epoch !== epoch) continue;
-        req.reject(new Error(`Codex process exited (code=${code}) while waiting for ${req.method}`));
+        const error = new Error(`${exited} while waiting for ${req.method}`);
+        error.codexStderrTail = tail;
+        req.reject(error);
         this.pending.delete(id);
       }
+      if (this.pendingTurnCompletion) {
+        const turnId = this.pendingTurnCompletion.turnId ?? this._turnId;
+        this.eventHandler?.({
+          type: "turn_aborted",
+          reason: "process-exit",
+          ...turnId ? { turn_id: turnId } : {},
+          error: { message: `${exited}${tail ? `: ${tail}` : ""}` }
+        });
+      }
       this.resolvePendingTurn(true);
     });
+    this.stderrRing = "";
     proc.stderr?.on("data", (chunk) => {
       if (this.process !== proc || this.processEpoch !== epoch) return;
       const text = chunk.toString().trim();
-      if (text) logger.debug("[CodexAppServer:stderr]", contentLogMetadata(text));
+      if (text) {
+        logger.debug("[CodexAppServer:stderr]", contentLogMetadata(text));
+        this.stderrRing = `${this.stderrRing}
+${text}`.slice(-400);
+      }
     });
     this.readline = createInterface({ input: proc.stdout });
     this.readline.on("line", (line) => {
@@ -444,6 +516,9 @@ class CodexAppServerClient {
     this._turnId = null;
     this.notificationProtocol = "unknown";
     this.completedTurnIds.clear();
+    this.failedTurnIds.clear();
+    this.lastTurnError = null;
+    this.clearThreadStopGrace();
     if (!opts?.preserveThreadState) {
       this._threadId = null;
       this.threadDefaults = null;
@@ -661,15 +736,50 @@ class CodexAppServerClient {
   }
   resolvePendingTurn(aborted) {
     if (!this.pendingTurnCompletion) return;
+    this.clearTurnWatchdog();
+    this.clearThreadStopGrace();
     this.pendingTurnCompletion.resolve(aborted);
     this.pendingTurnCompletion = null;
   }
   markPendingTurnStarted(turnId) {
     if (!this.pendingTurnCompletion) return;
+    this.pendingTurnCompletion.opened = true;
     if (turnId) {
       this.pendingTurnCompletion.turnId = turnId;
     }
   }
+  /** Default wait for Codex's `turn/completed` after its thread reported idle/systemError. */
+  static THREAD_STOP_GRACE_MS = 1500;
+  /**
+   * B-625: the own thread stopped (idle / systemError) while a turn was pending and
+   * had opened. Codex's `turn/completed` follows at once in every probed release
+   * (0.154.0: 1 ms); this is the net under a release that does not send it, so the
+   * session never waits on the silence watchdog for a turn Codex has already left.
+   */
+  armThreadStopGrace(statusType) {
+    this.clearThreadStopGrace();
+    const graceMs = this.pendingTurnCompletion?.threadStopGraceMs ?? CodexAppServerClient.THREAD_STOP_GRACE_MS;
+    this.threadStopGrace = setTimeout(() => {
+      this.threadStopGrace = null;
+      const pending = this.pendingTurnCompletion;
+      if (!pending) return;
+      const turnId = pending.turnId ?? this._turnId;
+      const lastError = this.lastTurnError && (!turnId || !this.lastTurnError.turnId || this.lastTurnError.turnId === turnId) ? this.lastTurnError.error : null;
+      logger.warn(`[CodexAppServer] Thread went ${statusType} and no turn/completed followed for turn ${turnId ?? "?"}; ending the turn`);
+      const failed = statusType === "systemError" || lastError !== null;
+      this.emitRawTurnCompletion(
+        turnId,
+        failed ? "failed" : "completed",
+        lastError ?? (failed ? { message: "Codex reported a system error and ended the turn without a verdict." } : null),
+        `thread/status/changed:${statusType}`
+      );
+    }, graceMs);
+  }
+  clearThreadStopGrace() {
+    if (!this.threadStopGrace) return;
+    clearTimeout(this.threadStopGrace);
+    this.threadStopGrace = null;
+  }
   tryResolvePendingTurn(aborted, turnId, source) {
     const pending = this.pendingTurnCompletion;
     if (!pending) return;
@@ -771,6 +881,8 @@ class CodexAppServerClient {
   }
   /** Default timeout for waiting on turn completion (ms). 10 minutes. */
   static TURN_TIMEOUT_MS = 10 * 60 * 1e3;
+  /** How much of the app-server's stderr is kept for its exit message. */
+  static STDERR_TAIL_CHARS = 400;
   /**
    * Send a user turn and wait for it to complete (task_complete or turn_aborted).
    * Returns { aborted: true } if the turn was aborted (user cancel, permission reject, etc.).
@@ -782,30 +894,58 @@ class CodexAppServerClient {
     }
     await this.ensureConnected();
     const timeoutMs = opts?.turnTimeoutMs ?? CodexAppServerClient.TURN_TIMEOUT_MS;
-    let timer = null;
     const completion = new Promise((resolve) => {
       this.pendingTurnCompletion = {
         resolve,
-        turnId: null
+        turnId: null,
+        opened: false,
+        threadStopGraceMs: opts?.threadStopGraceMs ?? CodexAppServerClient.THREAD_STOP_GRACE_MS
       };
-      timer = setTimeout(() => {
-        if (this.pendingTurnCompletion) {
-          logger.warn(`[CodexAppServer] Turn timed out after ${timeoutMs}ms \u2014 treating as abort`);
-          this.resolvePendingTurn(true);
-        }
-      }, timeoutMs);
+      this.lastTurnError = null;
+      this.armTurnWatchdog(timeoutMs);
     });
     try {
       await this.sendTurn(prompt, opts);
     } catch (err) {
-      if (timer) clearTimeout(timer);
+      this.clearTurnWatchdog();
       this.pendingTurnCompletion = null;
       throw err;
     }
     const aborted = await completion;
-    if (timer) clearTimeout(timer);
+    this.clearTurnWatchdog();
     return { aborted };
   }
+  armTurnWatchdog(timeoutMs) {
+    this.clearTurnWatchdog();
+    const timer = setTimeout(() => {
+      this.turnWatchdog = null;
+      if (!this.pendingTurnCompletion) return;
+      if (this.inflightServerRequests > 0) {
+        this.armTurnWatchdog(timeoutMs);
+        return;
+      }
+      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.eventHandler?.({
+        type: "turn_aborted",
+        reason: "timeout",
+        ...turnId ? { turn_id: turnId } : {},
+        error: { message: `Codex sent nothing for ${Math.max(1, Math.round(timeoutMs / 6e4))} minutes; this turn was given up. Send the message again, or restart the session if it keeps happening.` }
+      });
+      this.resolvePendingTurn(true);
+    }, timeoutMs);
+    this.turnWatchdog = { timer, timeoutMs };
+  }
+  /** Any sign of life from the app-server while a turn is pending restarts the clock. */
+  touchTurnWatchdog() {
+    if (!this.turnWatchdog || !this.pendingTurnCompletion) return;
+    this.armTurnWatchdog(this.turnWatchdog.timeoutMs);
+  }
+  clearTurnWatchdog() {
+    if (!this.turnWatchdog) return;
+    clearTimeout(this.turnWatchdog.timer);
+    this.turnWatchdog = null;
+  }
   async interruptTurn() {
     if (!this._threadId) return;
     if (!this._turnId) {
@@ -841,6 +981,8 @@ class CodexAppServerClient {
     this._turnId = null;
     this.threadDefaults = null;
     this.completedTurnIds.clear();
+    this.failedTurnIds.clear();
+    this.lastTurnError = null;
     this.rawFileChangesByItemId.clear();
   }
   // ─── JSON-RPC transport ─────────────────────────────────────
@@ -1013,6 +1155,15 @@ class CodexAppServerClient {
     };
   }
   async handleServerRequest(id, method, params) {
+    this.inflightServerRequests += 1;
+    try {
+      await this.handleServerRequestInner(id, method, params);
+    } finally {
+      this.inflightServerRequests -= 1;
+      this.touchTurnWatchdog();
+    }
+  }
+  async handleServerRequestInner(id, method, params) {
     if (method === "mcpServer/elicitation/request") {
       const toolName = this.parseToolNameFromElicitationMessage(params?.message) ?? params?.serverName ?? "McpTool";
       const decision = await this.handleApproval({
@@ -1066,6 +1217,7 @@ class CodexAppServerClient {
     return "denied";
   }
   handleNotification(method, params) {
+    this.touchTurnWatchdog();
     if (method === "codex/event" || method.startsWith("codex/event/")) {
       this.notificationProtocol = "legacy";
       const msg = params?.msg;
@@ -1099,6 +1251,7 @@ class CodexAppServerClient {
     }
     if (method === "thread/started" || method === "turn/started" || method === "turn/completed" || method === "thread/status/changed") {
       logger.debug(`[CodexAppServer] Lifecycle notification: ${method}`);
+      if (!this.isOwnThreadFrame(params)) return;
       if (method === "turn/started") {
         const turnId = this.extractTurnId(params);
         if (turnId) {
@@ -1125,6 +1278,30 @@ class CodexAppServerClient {
       logger.debug(`[CodexAppServer] mcpServer startup status:`, params);
       return;
     }
+    if (method === "error") {
+      if (!this.isOwnThreadFrame(params)) return;
+      const error = params?.error ?? {};
+      const turnId = typeof params?.turnId === "string" && params.turnId.length > 0 ? params.turnId : null;
+      if (params?.willRetry === true) {
+        const message = typeof error.message === "string" ? error.message : "";
+        const info = error.codexErrorInfo;
+        const httpStatus = info && typeof info === "object" ? info.responseStreamDisconnected?.httpStatusCode ?? info.httpStatusCode ?? null : null;
+        this.eventHandler?.({
+          type: "turn_retry",
+          message,
+          ...typeof httpStatus === "number" ? { http_status: httpStatus } : {},
+          ...turnId ? { turn_id: turnId } : {},
+          ...typeof error.additionalDetails === "string" ? { details: error.additionalDetails } : {}
+        });
+        return;
+      }
+      this.lastTurnError = { turnId, error };
+      const pending = this.pendingTurnCompletion;
+      if (pending && !pending.opened && (turnId === null || pending.turnId === null || pending.turnId === turnId)) {
+        this.emitRawTurnCompletion(turnId ?? pending.turnId, "failed", error, "error:unopened-turn");
+      }
+      return;
+    }
     logger.debug(`[CodexAppServer] Notification: ${method}`);
   }
 }