@ccpocket/bridge 1.86.2 → 1.87.0

package/dist/codex-process.d.ts

@@ -211,6 +211,17 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
      * Sends thread/name/set which persists to ~/.codex/session_index.jsonl.
      */
     renameThread(name: string): Promise<void>;
+    private manualInputVersion;
+    private recoveryFailure;
+    private upstreamWillRetry;
+    private inputTurnStarted;
+    private recoveryNotice;
+    private readonly recovery;
+    getRecoveryState(): import("./codex-recovery.js").CodexRecoveryState;
+    setRecoveryEnabled(enabled: boolean): void;
+    cancelRecovery(): void;
+    noteManualInput(): void;
+    private canDispatchRecovery;
     private goalLookup;
     /** Read the persisted goal attached to this Codex thread. */
     getGoal(timeoutMs?: number): Promise<CodexGoal | null>;

package/dist/codex-process.js

@@ -1,3 +1,4 @@
+import { CodexRecovery } from "./codex-recovery.js";
 import { EventEmitter } from "node:events";
 import { randomUUID } from "node:crypto";
 import { realpathSync, statSync } from "node:fs";
@@ -240,6 +241,57 @@ export class CodexProcess extends EventEmitter {
             name,
         });
     }
+    manualInputVersion = 0;
+    recoveryFailure = null;
+    upstreamWillRetry = false;
+    inputTurnStarted = false;
+    recoveryNotice = "";
+    recovery = new CodexRecovery({
+        changed: (recovery) => {
+            this.emitMessage({ type: "codex_recovery_state", recovery });
+            const notice = `${recovery.phase}:${recovery.reason}`;
+            if (notice !== this.recoveryNotice && ["waiting", "blocked", "exhausted"].includes(recovery.phase)) {
+                this.emitMessage({ type: "error", errorCode: "codex_recovery_notice", message: recovery.phase === "waiting"
+                        ? `Automatic recovery is waiting for the usage limit (${recovery.attempts}/${recovery.maxAttempts} attempts used). You can cancel or send a message. ${recovery.reason ?? ""}`
+                        : `Automatic recovery ${recovery.phase}. ${recovery.reason ?? ""}` });
+            }
+            this.recoveryNotice = notice;
+        },
+        canResume: async () => {
+            if (!this.canDispatchRecovery())
+                return false;
+            const goal = await this.getGoal();
+            return this.canDispatchRecovery() && (goal === null ||
+                ((goal.status === "active" || goal.status === "usageLimited") &&
+                    !(typeof goal.tokenBudget === "number" && goal.tokensUsed >= goal.tokenBudget)));
+        },
+        dispatch: (input) => {
+            if (!this.canDispatchRecovery())
+                return false;
+            const resolve = this.inputResolve;
+            this.inputResolve = null;
+            resolve({ ...input, recoveryGeneration: this.recovery.version });
+            return true;
+        },
+        resetAt: async () => {
+            const response = await this.readRateLimits(3_000);
+            const limits = response.rateLimitsByLimitId?.codex ?? response.rateLimits;
+            const resets = [limits?.primary, limits?.secondary]
+                .filter((window) => window && window.usedPercent >= 100 && typeof window.resetsAt === "number" && Number.isFinite(window.resetsAt))
+                .map((window) => window.resetsAt * 1000);
+            return resets.length ? Math.max(...resets) : undefined;
+        },
+    });
+    getRecoveryState() { return this.recovery.state; }
+    setRecoveryEnabled(enabled) { this.recovery.setEnabled(enabled); }
+    cancelRecovery() { this.manualInputVersion++; this.recovery.cancel(); }
+    noteManualInput() { this.manualInputVersion++; this.recovery.manualInput(); }
+    canDispatchRecovery() {
+        return !this.stopped && this._threadId !== null && this.inputResolve !== null &&
+            this.pendingTurnId === null && this.pendingTurnCompletion === null &&
+            this.pendingApprovals.size === 0 && !this.hasBlockingUserInput() &&
+            this.pendingPlanCompletion === null && this._pendingPlanInput === null;
+    }
     goalLookup;
     /** Read the persisted goal attached to this Codex thread. */
     async getGoal(timeoutMs = 3_000) {
@@ -258,6 +310,7 @@ export class CodexProcess extends EventEmitter {
     }
     /** Create or update the persisted goal attached to this Codex thread. */
     async setGoal(update) {
+        this.cancelRecovery();
         if (!this._threadId) {
             throw new Error("No thread ID available for goal update");
         }
@@ -272,6 +325,7 @@ export class CodexProcess extends EventEmitter {
     }
     /** Remove the persisted goal attached to this Codex thread. */
     async clearGoal() {
+        this.cancelRecovery();
         if (!this._threadId) {
             throw new Error("No thread ID available for goal clear");
         }
@@ -601,6 +655,7 @@ export class CodexProcess extends EventEmitter {
     }
     stop() {
         this.stopped = true;
+        this.recovery.setEnabled(false);
         this.rejectReadiness(new Error("codex app-server stopped"));
         if (this.inputResolve) {
             this.inputResolve({ text: "" });
@@ -621,6 +676,7 @@ export class CodexProcess extends EventEmitter {
     }
     prepareLaunch(projectPath, options) {
         this.stopped = false;
+        this.recovery.setEnabled(false);
         this._threadId = null;
         this._agentNickname = null;
         this._agentRole = null;
@@ -702,6 +758,7 @@ export class CodexProcess extends EventEmitter {
         transport.start(projectPath);
     }
     interrupt() {
+        this.cancelRecovery();
         if (!this._threadId || !this.pendingTurnId)
             return;
         void this.request("turn/interrupt", {
@@ -714,6 +771,7 @@ export class CodexProcess extends EventEmitter {
         });
     }
     sendInput(text) {
+        this.noteManualInput();
         if (!this.inputResolve) {
             console.error("[codex-process] No pending input resolver for sendInput");
             return;
@@ -723,6 +781,7 @@ export class CodexProcess extends EventEmitter {
         resolve({ text });
     }
     sendInputWithImages(text, images) {
+        this.noteManualInput();
         if (!this.inputResolve) {
             console.error("[codex-process] No pending input resolver for sendInputWithImages");
             return;
@@ -735,6 +794,7 @@ export class CodexProcess extends EventEmitter {
         this.sendInputStructured(text, { skills: [skill] });
     }
     sendInputStructured(text, options) {
+        this.noteManualInput();
         if (!this.inputResolve) {
             console.error("[codex-process] No pending input resolver for sendInputStructured");
             return;
@@ -749,6 +809,7 @@ export class CodexProcess extends EventEmitter {
         });
     }
     async steerInputStructured(text, options) {
+        this.noteManualInput();
         if (!this._threadId || !this.pendingTurnId) {
             throw new Error("No active Codex turn to steer");
         }
@@ -1600,10 +1661,21 @@ export class CodexProcess extends EventEmitter {
                 });
                 continue;
             }
+            const manualVersion = this.manualInputVersion;
+            this.recoveryFailure = null;
+            this.upstreamWillRetry = false;
+            this.inputTurnStarted = false;
+            let startFailure = null;
             const { input, tempPaths } = await this.toRpcInput(pendingInput);
-            if (!input) {
+            if (!input || (pendingInput.recoveryGeneration !== undefined &&
+                (pendingInput.recoveryGeneration !== this.recovery.version || !this.recovery.state.enabled))) {
+                await Promise.all(tempPaths.map((path) => rm(path, { force: true }).catch(() => { })));
                 continue;
             }
+            if (pendingInput.recoveryContinuation && !pendingInput.recoveryEchoed) {
+                pendingInput.recoveryEchoed = true;
+                this.emitMessage({ type: "user_input", text: pendingInput.text, timestamp: new Date().toISOString() });
+            }
             this.setStatus("running");
             this.lastTokenUsage = null;
             const completion = await new Promise((resolve, reject) => {
@@ -1657,6 +1729,9 @@ export class CodexProcess extends EventEmitter {
                     reject(err instanceof Error ? err : new Error(String(err)));
                 });
             }).catch((err) => {
+                // Only a confirmed turn/start rejection can replay original attachments.
+                if (err instanceof CodexRpcError && !this.inputTurnStarted && !this.pendingTurnId)
+                    startFailure = err;
                 if (!this.stopped) {
                     const message = err instanceof Error ? err.message : String(err);
                     this.emitMessage({ type: "error", message });
@@ -1671,6 +1746,14 @@ export class CodexProcess extends EventEmitter {
             });
             await Promise.all(tempPaths.map((path) => rm(path, { force: true }).catch(() => { })));
             void completion;
+            if (!this.stopped && manualVersion === this.manualInputVersion && !this.upstreamWillRetry) {
+                const failure = startFailure ?? this.recoveryFailure;
+                if (failure)
+                    this.recovery.schedule(failure, startFailure ? pendingInput : {
+                        text: "Automatic recovery: Continue exactly where you left off. Do not repeat completed work. If the task is already complete, stop.",
+                        recoveryContinuation: true,
+                    });
+            }
         }
     }
     handleStdoutChunk(chunk) {
@@ -1955,6 +2038,8 @@ export class CodexProcess extends EventEmitter {
                 break;
             }
             case "turn/started": {
+                this.inputTurnStarted = true;
+                this.recovery.cancel();
                 const turn = params.turn;
                 if (typeof turn?.id === "string") {
                     this.pendingTurnId = turn.id;
@@ -1976,6 +2061,10 @@ export class CodexProcess extends EventEmitter {
             }
             case "thread/goal/updated": {
                 try {
+                    const goal = parseCodexGoal(params.goal);
+                    if (!["active", "usageLimited"].includes(goal.status) ||
+                        (typeof goal.tokenBudget === "number" && goal.tokensUsed >= goal.tokenBudget))
+                        this.cancelRecovery();
                     this.emitMessage({
                         type: "goal_state",
                         goal: parseCodexGoal(params.goal),
@@ -1987,6 +2076,7 @@ export class CodexProcess extends EventEmitter {
                 break;
             }
             case "thread/goal/cleared": {
+                this.cancelRecovery();
                 this.emitMessage({ type: "goal_state", goal: null });
                 break;
             }
@@ -2135,6 +2225,7 @@ export class CodexProcess extends EventEmitter {
                 const error = asRecord(params.error);
                 const message = stringValue(error?.message) ?? "Codex runtime error";
                 if (params.willRetry === true) {
+                    this.upstreamWillRetry = true;
                     console.warn(`[codex-process] Codex will retry: ${message}`);
                     break;
                 }
@@ -2174,6 +2265,13 @@ export class CodexProcess extends EventEmitter {
         this.lastTokenUsage = null;
         if (status === "failed") {
             const errorObj = turn?.error;
+            // A terminal failure ends upstream retry ownership. Warnings alone never
+            // schedule work, and an explicitly retrying terminal payload is excluded.
+            if (this.pendingTurnCompletion && errorObj?.willRetry !== true &&
+                (!this.pendingTurnId || !turn?.id || turn.id === this.pendingTurnId)) {
+                this.upstreamWillRetry = false;
+                this.recoveryFailure = errorObj;
+            }
             const message = typeof errorObj?.message === "string"
                 ? errorObj.message
                 : "Turn failed";