@ccpocket/bridge 1.81.4 → 1.81.5

package/dist/codex-process.d.ts

@@ -226,9 +226,8 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
      */
     archiveThread(threadId: string): Promise<void>;
     readThread(threadId: string, includeTurns?: boolean): Promise<Record<string, unknown>>;
-    rollbackThread(numTurns: number): Promise<Record<string, unknown>>;
-    rollbackThreadById(threadId: string, numTurns: number): Promise<Record<string, unknown>>;
-    forkThread(): Promise<{
+    /** Fork at a complete turn boundary without mutating the source history. */
+    forkThreadAtUserTurn(userTurnOrdinal: number): Promise<{
         threadId: string;
         thread: Record<string, unknown>;
     }>;
@@ -364,6 +363,7 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
     private resetReadiness;
     private resolveReadiness;
     private rejectReadiness;
+    private hasBlockingUserInput;
     private setStatus;
     private emitMessage;
     private extractToolUseId;

package/dist/codex-process.js

@@ -5,6 +5,7 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { rm, writeFile } from "node:fs/promises";
 import { createCodexTransport, buildCodexSpawnSpec, } from "./codex-transport.js";
+import { codexThreadToSessionHistory } from "./sessions-index.js";
 import { codexCliJoinTarget } from "./codex-app-server-config.js";
 import { normalizeCodexServiceTierForClient, normalizeCodexServiceTierForRpc, } from "./codex-service-tier.js";
 import { resolvePlatformPath } from "./path-utils.js";
@@ -283,43 +284,108 @@ export class CodexProcess extends EventEmitter {
     async readThread(threadId, includeTurns = true) {
         const response = (await this.request("thread/read", {
             threadId,
-            includeTurns,
+            includeTurns: false,
         }));
         const thread = response.thread;
         if (!thread) {
             throw new Error("thread/read returned no thread");
         }
-        return thread;
-    }
-    async rollbackThread(numTurns) {
-        if (!this._threadId) {
-            throw new Error("No thread ID available for rollback");
-        }
-        return this.rollbackThreadById(this._threadId, numTurns);
-    }
-    async rollbackThreadById(threadId, numTurns) {
-        const response = (await this.request("thread/rollback", {
-            threadId,
-            numTurns,
-        }));
-        const thread = response.thread;
-        if (!thread) {
-            throw new Error("thread/rollback returned no thread");
-        }
-        return thread;
+        if (!includeTurns)
+            return thread;
+        const turns = [];
+        const seenCursors = new Set();
+        let cursor;
+        do {
+            let page;
+            try {
+                page = (await this.request("thread/turns/list", {
+                    threadId,
+                    ...(cursor !== undefined ? { cursor } : {}),
+                    limit: 50,
+                    sortDirection: "asc",
+                    itemsView: "full",
+                }));
+            }
+            catch (err) {
+                // New threads have metadata but no persisted turn history yet.
+                if (cursor === undefined &&
+                    err instanceof CodexRpcError &&
+                    err.code === -32600 &&
+                    err.message.includes("is not materialized yet; thread/turns/list is unavailable before first user message")) {
+                    return { ...thread, turns: [] };
+                }
+                // Older app-servers do not expose turn pagination.
+                if (!(err instanceof CodexRpcError) || err.code !== -32601)
+                    throw err;
+                const legacy = (await this.request("thread/read", {
+                    threadId,
+                    includeTurns: true,
+                }));
+                if (!legacy.thread)
+                    throw new Error("thread/read returned no thread");
+                return legacy.thread;
+            }
+            if (!Array.isArray(page.data)) {
+                throw new Error("thread/turns/list returned invalid data");
+            }
+            turns.push(...page.data);
+            if (page.nextCursor != null && typeof page.nextCursor !== "string") {
+                throw new Error("thread/turns/list returned an invalid cursor");
+            }
+            cursor = page.nextCursor ?? undefined;
+            if (cursor !== undefined) {
+                if (seenCursors.has(cursor)) {
+                    throw new Error("thread/turns/list returned a repeated cursor");
+                }
+                seenCursors.add(cursor);
+            }
+        } while (cursor !== undefined);
+        return { ...thread, turns };
     }
-    async forkThread() {
-        if (!this._threadId) {
+    /** Fork at a complete turn boundary without mutating the source history. */
+    async forkThreadAtUserTurn(userTurnOrdinal) {
+        if (!this._threadId)
             throw new Error("No thread ID available for fork");
+        if (!Number.isInteger(userTurnOrdinal) || userTurnOrdinal < 1) {
+            throw new Error("Invalid Codex fork target");
+        }
+        const source = await this.readThread(this._threadId);
+        let userCount = 0;
+        let lastTurnId;
+        for (const raw of Array.isArray(source.turns) ? source.turns : []) {
+            const turn = asRecord(raw);
+            if (!turn)
+                continue;
+            userCount += codexThreadToSessionHistory({ turns: [turn] }).filter((message) => message.role === "user").length;
+            if (userCount > userTurnOrdinal) {
+                throw new Error("Cannot fork within a Codex turn containing multiple user messages");
+            }
+            if (userCount === userTurnOrdinal) {
+                if (turn.status === "inProgress") {
+                    throw new Error("Cannot fork an in-progress Codex turn");
+                }
+                lastTurnId = typeof turn.id === "string" ? turn.id : undefined;
+                break;
+            }
+        }
+        if (!lastTurnId) {
+            throw new Error("Codex fork target was not found in stored history");
         }
         const response = (await this.request("thread/fork", {
             threadId: this._threadId,
-            persistExtendedHistory: true,
+            lastTurnId,
+            excludeTurns: true,
         }));
-        const thread = response.thread;
-        const threadId = typeof thread?.id === "string" ? thread.id : undefined;
-        if (!thread || !threadId) {
+        const metadata = asRecord(response.thread);
+        const threadId = typeof metadata?.id === "string" ? metadata.id : undefined;
+        if (!threadId)
             throw new Error("thread/fork returned no thread id");
+        const thread = await this.readThread(threadId);
+        // Older servers may silently ignore lastTurnId. Never resume excess history.
+        const turns = Array.isArray(thread.turns) ? thread.turns : [];
+        const forkedUserCount = codexThreadToSessionHistory(thread).filter((message) => message.role === "user").length;
+        if (asRecord(turns.at(-1))?.id !== lastTurnId || forkedUserCount !== userTurnOrdinal) {
+            throw new Error("Codex did not fork at the requested turn; update Codex CLI");
         }
         return { threadId, thread };
     }
@@ -637,7 +703,9 @@ export class CodexProcess extends EventEmitter {
         this.pendingApprovals.delete(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, "accept"));
         this.emitToolResult(pending.toolUseId, "Approved", "approved");
-        if (this.pendingApprovals.size === 0) {
+        if (this.pendingApprovals.size === 0 &&
+            !this.hasBlockingUserInput() &&
+            !this.pendingPlanCompletion) {
             this.setStatus("running");
         }
         return true;
@@ -655,7 +723,9 @@ export class CodexProcess extends EventEmitter {
         this.pendingApprovals.delete(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, "acceptForSession"));
         this.emitToolResult(pending.toolUseId, "Approved (always)", "approved_for_session");
-        if (this.pendingApprovals.size === 0) {
+        if (this.pendingApprovals.size === 0 &&
+            !this.hasBlockingUserInput() &&
+            !this.pendingPlanCompletion) {
             this.setStatus("running");
         }
         return true;
@@ -678,7 +748,9 @@ export class CodexProcess extends EventEmitter {
         this.pendingApprovals.delete(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, resolveApprovalRejectDecision(pending)));
         this.emitToolResult(pending.toolUseId, "Rejected", "rejected");
-        if (this.pendingApprovals.size === 0) {
+        if (this.pendingApprovals.size === 0 &&
+            !this.hasBlockingUserInput() &&
+            !this.pendingPlanCompletion) {
             this.setStatus("running");
         }
         return true;
@@ -692,8 +764,12 @@ export class CodexProcess extends EventEmitter {
         this.pendingUserInputs.delete(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildUserInputResponse(pending, result));
         this.emitToolResult(pending.toolUseId, "Answered", "answered");
-        if (this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
-            this.setStatus("running");
+        if (this.pendingApprovals.size === 0 &&
+            !this.hasBlockingUserInput() &&
+            !this.pendingPlanCompletion) {
+            if (pending.isBlocking !== false || this.pendingTurnId) {
+                this.setStatus("running");
+            }
         }
         return true;
     }
@@ -831,8 +907,8 @@ export class CodexProcess extends EventEmitter {
     resolvePendingUserInput(toolUseId) {
         if (toolUseId)
             return this.pendingUserInputs.get(toolUseId);
-        const first = this.pendingUserInputs.values().next();
-        return first.done ? undefined : first.value;
+        const requests = [...this.pendingUserInputs.values()];
+        return requests.find((request) => request.isBlocking !== false) ?? requests[0];
     }
     /**
      * Approve a pending user-input request (McpElicitation fallback).
@@ -858,7 +934,9 @@ export class CodexProcess extends EventEmitter {
         this.emitToolResult(pending.toolUseId, "Approved", result === "Allow for this session"
             ? "approved_for_session"
             : "approved");
-        if (this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
+        if (this.pendingApprovals.size === 0 &&
+            !this.hasBlockingUserInput() &&
+            !this.pendingPlanCompletion) {
             this.setStatus("running");
         }
         return true;
@@ -884,7 +962,9 @@ export class CodexProcess extends EventEmitter {
             toolUseId: pending.toolUseId,
         });
         this.emitToolResult(pending.toolUseId, toolResult);
-        if (this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
+        if (this.pendingApprovals.size === 0 &&
+            !this.hasBlockingUserInput() &&
+            !this.pendingPlanCompletion) {
             this.setStatus("running");
         }
     }
@@ -898,7 +978,9 @@ export class CodexProcess extends EventEmitter {
         this.pendingUserInputs.delete(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildUserInputResponse(pending, resolveUserInputRejectResult(pending, result)));
         this.emitToolResult(pending.toolUseId, "Rejected", "rejected");
-        if (this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
+        if (this.pendingApprovals.size === 0 &&
+            !this.hasBlockingUserInput() &&
+            !this.pendingPlanCompletion) {
             this.setStatus("running");
         }
         return true;
@@ -1040,6 +1122,7 @@ export class CodexProcess extends EventEmitter {
             const method = options?.threadId ? "thread/resume" : "thread/start";
             if (options?.threadId) {
                 threadParams.threadId = options.threadId;
+                threadParams.excludeTurns = true;
             }
             else {
                 threadParams.experimentalRawEvents = false;
@@ -1634,6 +1717,7 @@ export class CodexProcess extends EventEmitter {
                 const toolUseId = this.extractToolUseId(params, id);
                 const questions = normalizeUserInputQuestions(params.questions);
                 const input = {
+                    isBlocking: params.isBlocking !== false,
                     questions: questions.map((q) => ({
                         id: q.id,
                         question: q.question,
@@ -1654,6 +1738,7 @@ export class CodexProcess extends EventEmitter {
                     })),
                     input,
                     kind: "questions",
+                    isBlocking: params.isBlocking !== false,
                 });
                 this.emitMessage({
                     type: "permission_request",
@@ -1661,7 +1746,8 @@ export class CodexProcess extends EventEmitter {
                     toolName: "AskUserQuestion",
                     input,
                 });
-                this.setStatus("waiting_approval");
+                if (params.isBlocking !== false)
+                    this.setStatus("waiting_approval");
                 break;
             }
             case "item/permissions/requestApproval": {
@@ -2010,7 +2096,7 @@ export class CodexProcess extends EventEmitter {
         else {
             this.lastPlanItemText = null;
             if (this.pendingApprovals.size === 0 &&
-                this.pendingUserInputs.size === 0) {
+                !this.hasBlockingUserInput()) {
                 this.setStatus("idle");
             }
         }
@@ -2588,6 +2674,9 @@ export class CodexProcess extends EventEmitter {
             waiter.reject(error);
         this.readinessWaiters.clear();
     }
+    hasBlockingUserInput() {
+        return [...this.pendingUserInputs.values()].some((request) => request.isBlocking !== false);
+    }
     setStatus(status) {
         if (this._status !== status) {
             this._status = status;
@@ -2631,7 +2720,7 @@ export class CodexProcess extends EventEmitter {
         }
         if (!this.pendingPlanCompletion &&
             this.pendingApprovals.size === 0 &&
-            this.pendingUserInputs.size === 0) {
+            !this.hasBlockingUserInput()) {
             this.setStatus(this.pendingTurnId ? "running" : "idle");
         }
     }
@@ -2910,16 +2999,16 @@ function extractReasoningEfforts(raw) {
     return efforts;
 }
 function extractServiceTiers(raw) {
-    // Recent app-server versions expose the user-facing Fast option as
+    // Older app-server versions expose the user-facing Fast option as
     // `additionalSpeedTiers: ["fast"]`, while the lower-level service tier is
-    // advertised as `{ id: "priority", name: "Fast" }`. Merge both shapes and
-    // normalize them to the value accepted by `service_tier` in config/RPCs.
-    const values = [
-        ...(Array.isArray(raw.additionalSpeedTiers)
+    // advertised as `{ id: "priority", name: "Fast" }`. Prefer the current
+    // catalog and normalize its values for the client.
+    // The current catalog is authoritative, including an explicitly empty list.
+    const values = Array.isArray(raw.serviceTiers)
+        ? raw.serviceTiers
+        : Array.isArray(raw.additionalSpeedTiers)
             ? raw.additionalSpeedTiers
-            : []),
-        ...(Array.isArray(raw.serviceTiers) ? raw.serviceTiers : []),
-    ];
+            : [];
     const seen = new Set();
     const tiers = [];
     for (const value of values) {