@ccpocket/bridge 1.85.0 → 1.85.2

package/dist/codex-history.d.ts

@@ -0,0 +1,5 @@
+/** Bound unusually large tool payloads before retaining all history pages. */
+export declare function compactCodexHistoryItem(item: Record<string, unknown>): {
+    item: Record<string, unknown>;
+    chars: number;
+};

package/dist/codex-history.js

@@ -0,0 +1,53 @@
+// These limits apply only to the Bridge's display copy, never to Codex's
+// persisted history or the model's context.
+const MAX_TOOL_ITEM_CHARS = 256 * 1024;
+const MAX_TOOL_STRING_CHARS = 16 * 1024;
+const OMITTED = "[Large tool detail omitted from Bridge history]";
+const TRUNCATED = "\n[Truncated in Bridge history]";
+const TOOL_TYPES = new Set([
+    "commandExecution", "fileChange", "mcpToolCall", "dynamicToolCall",
+    "functionCallOutput", "imageGeneration",
+]);
+/** Bound unusually large tool payloads before retaining all history pages. */
+export function compactCodexHistoryItem(item) {
+    const chars = JSON.stringify(item).length;
+    if (!TOOL_TYPES.has(String(item.type)) || chars <= MAX_TOOL_ITEM_CHARS) {
+        return { item, chars };
+    }
+    const compacted = compactValue(item, 0);
+    // Generated images use a bare base64 string. Never pass truncated base64 to
+    // the image decoder; show an explicit text result instead.
+    if (item.type === "imageGeneration") {
+        delete compacted.result;
+        compacted.revisedPrompt = `${compacted.revisedPrompt ?? ""}\n${OMITTED}`;
+    }
+    return { item: compacted, chars: JSON.stringify(compacted).length };
+}
+function compactValue(value, depth) {
+    if (typeof value === "string") {
+        if (value.length <= MAX_TOOL_STRING_CHARS)
+            return value;
+        if (value.startsWith("data:image/"))
+            return OMITTED;
+        return value.slice(0, MAX_TOOL_STRING_CHARS) + TRUNCATED;
+    }
+    if (value == null || typeof value !== "object")
+        return value;
+    if (depth >= 20)
+        return OMITTED;
+    if (Array.isArray(value)) {
+        return value.map((entry) => compactValue(entry, depth + 1));
+    }
+    const record = value;
+    if (record.type === "image" && typeof record.data === "string"
+        && record.data.length > MAX_TOOL_STRING_CHARS) {
+        return { type: "text", text: OMITTED };
+    }
+    if (record.type === "inputImage" && typeof record.imageUrl === "string"
+        && record.imageUrl.length > MAX_TOOL_STRING_CHARS) {
+        return { type: "inputText", text: OMITTED };
+    }
+    return Object.fromEntries(Object.entries(record)
+        .map(([key, entry]) => [key, compactValue(entry, depth + 1)]));
+}
+//# sourceMappingURL=codex-history.js.map

package/dist/codex-history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-history.js","sourceRoot":"","sources":["../src/codex-history.ts"],"names":[],"mappings":"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"}

package/dist/codex-process.d.ts

@@ -146,6 +146,7 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
      * copied at most once instead of repeatedly rebuilding one growing string.
      */
     private stdoutLineChunks;
+    private stdoutLineChars;
     private _approvalPolicy;
     private _approvalsReviewer;
     private _codexPermissionsMode;
@@ -226,6 +227,9 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
      */
     archiveThread(threadId: string): Promise<void>;
     readThread(threadId: string, includeTurns?: boolean): Promise<Record<string, unknown>>;
+    private checkHistorySize;
+    private readTurnPages;
+    private readHistoryPages;
     /** Fork at a complete turn boundary without mutating the source history. */
     forkThreadAtUserTurn(userTurnOrdinal: number): Promise<{
         threadId: string;
@@ -341,7 +345,7 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
     private emitCompletionEntitiesSnapshot;
     private runInputLoop;
     private handleStdoutChunk;
-    private completeStdoutLine;
+    private failStdout;
     private handleRpcEnvelope;
     private handleRpcResponse;
     private handleServerRequest;

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 { compactCodexHistoryItem } from "./codex-history.js";
 import { codexThreadToSessionHistory } from "./sessions-index.js";
 import { codexCliJoinTarget } from "./codex-app-server-config.js";
 import { normalizeCodexServiceTierForClient, normalizeCodexServiceTierForRpc, } from "./codex-service-tier.js";
@@ -13,6 +14,8 @@ export { buildCodexSpawnSpec };
 const DEFAULT_CODEX_MODEL = "gpt-5.5";
 const COMPLETION_FETCH_COOLDOWN_MS = 1000;
 const ARCHIVE_RPC_TIMEOUT_MS = 15_000;
+const MAX_STDOUT_LINE_CHARS = 64 * 1024 * 1024;
+const MAX_RETAINED_HISTORY_CHARS = 64 * 1024 * 1024;
 const UNKNOWN_AGENT_ITEM_ID = "__unknown_agent_message__";
 const CODEX_CLI_NOT_FOUND_MESSAGE = "Codex CLI is not installed or not available on PATH on the Bridge machine. Install it with `curl -fsSL https://chatgpt.com/codex/install.sh | sh`, then restart Bridge.";
 export class CodexRpcError extends Error {
@@ -102,6 +105,7 @@ export class CodexProcess extends EventEmitter {
      * copied at most once instead of repeatedly rebuilding one growing string.
      */
     stdoutLineChunks = [];
+    stdoutLineChars = 0;
     // Collaboration mode & plan completion state
     _approvalPolicy = undefined;
     _approvalsReviewer = undefined;
@@ -292,55 +296,133 @@ export class CodexProcess extends EventEmitter {
         }
         if (!includeTurns)
             return thread;
+        try {
+            // A single autonomous turn can contain thousands of screenshots/tool
+            // results. Page turn metadata separately, then hydrate by item count.
+            const turns = await this.readTurnPages(threadId, "notLoaded");
+            const byId = new Map();
+            for (const turn of turns) {
+                if (typeof turn.id !== "string")
+                    throw new Error("Codex turn has no id");
+                turn.items = [];
+                byId.set(turn.id, turn);
+            }
+            let retainedChars = JSON.stringify(turns).length;
+            await this.readHistoryPages("thread/items/list", {
+                threadId, limit: 10, sortDirection: "asc",
+            }, (entries) => {
+                for (const rawEntry of entries) {
+                    const entry = asRecord(rawEntry);
+                    const item = asRecord(entry?.item);
+                    const turn = typeof entry?.turnId === "string"
+                        ? byId.get(entry.turnId) : undefined;
+                    if (!item || !turn) {
+                        throw new Error("Codex history changed while reading; retry opening the session");
+                    }
+                    const compacted = compactCodexHistoryItem(item);
+                    retainedChars += compacted.chars;
+                    this.checkHistorySize(retainedChars);
+                    turn.items.push(compacted.item);
+                }
+            });
+            for (const turn of turns)
+                turn.itemsView = "full";
+            return { ...thread, turns };
+        }
+        catch (err) {
+            if (err instanceof CodexRpcError && err.code === -32600 &&
+                err.message.includes("is not materialized yet")) {
+                return { ...thread, turns: [] };
+            }
+            // Unsupported methods/views permit the compatibility path. Never retry
+            // a size/transport failure with a larger full-history response.
+            const unsupportedMetadataView = err instanceof CodexRpcError &&
+                err.code === -32602 && /unknown variant.*notLoaded/i.test(err.message);
+            if (!unsupportedMetadataView &&
+                (!(err instanceof CodexRpcError) || err.code !== -32601))
+                throw err;
+        }
+        try {
+            return { ...thread, turns: await this.readTurnPages(threadId, "full") };
+        }
+        catch (err) {
+            if (!(err instanceof CodexRpcError) || err.code !== -32601)
+                throw err;
+        }
+        const legacy = (await this.request("thread/read", {
+            threadId, includeTurns: true,
+        }));
+        const legacyThread = asRecord(legacy.thread);
+        if (!legacyThread)
+            throw new Error("thread/read returned no thread");
+        if (Array.isArray(legacyThread.turns)) {
+            let chars = 0;
+            for (const rawTurn of legacyThread.turns) {
+                const turn = asRecord(rawTurn);
+                if (!turn || !Array.isArray(turn.items))
+                    continue;
+                turn.items = turn.items.map((rawItem) => {
+                    const item = asRecord(rawItem);
+                    if (!item)
+                        return rawItem;
+                    const compacted = compactCodexHistoryItem(item);
+                    chars += compacted.chars;
+                    this.checkHistorySize(chars);
+                    return compacted.item;
+                });
+            }
+        }
+        return legacyThread;
+    }
+    checkHistorySize(chars) {
+        if (chars > MAX_RETAINED_HISTORY_CHARS) {
+            throw new Error("Codex display history exceeds the Bridge 64 Mi-character limit");
+        }
+    }
+    async readTurnPages(threadId, itemsView) {
         const turns = [];
+        let retainedChars = 0;
+        await this.readHistoryPages("thread/turns/list", {
+            threadId, limit: itemsView === "full" ? 1 : 50,
+            sortDirection: "asc", itemsView,
+        }, (data) => {
+            for (const rawTurn of data) {
+                const turn = asRecord(rawTurn);
+                if (!turn)
+                    throw new Error("thread/turns/list returned an invalid turn");
+                if (itemsView === "full" && Array.isArray(turn.items)) {
+                    turn.items = turn.items.map((rawItem) => {
+                        const item = asRecord(rawItem);
+                        return item ? compactCodexHistoryItem(item).item : rawItem;
+                    });
+                }
+                retainedChars += JSON.stringify(turn).length;
+                this.checkHistorySize(retainedChars);
+                turns.push(turn);
+            }
+        });
+        return turns;
+    }
+    async readHistoryPages(method, params, consume) {
         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);
+            const page = (await this.request(method, {
+                ...params, ...(cursor !== undefined ? { cursor } : {}),
+            }));
+            if (!Array.isArray(page.data))
+                throw new Error(`${method} returned invalid data`);
+            consume(page.data);
             if (page.nextCursor != null && typeof page.nextCursor !== "string") {
-                throw new Error("thread/turns/list returned an invalid cursor");
+                throw new Error(`${method} 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");
-                }
+                if (seenCursors.has(cursor))
+                    throw new Error(`${method} returned a repeated cursor`);
                 seenCursors.add(cursor);
             }
         } while (cursor !== undefined);
-        return { ...thread, turns };
     }
     /** Fork at a complete turn boundary without mutating the source history. */
     async forkThreadAtUserTurn(userTurnOrdinal) {
@@ -520,6 +602,8 @@ export class CodexProcess extends EventEmitter {
         }
         this.pendingApprovals.clear();
         this.pendingUserInputs.clear();
+        this.stdoutLineChunks = [];
+        this.stdoutLineChars = 0;
         this.cleanupSteerTempPaths();
         this.rejectAllPending(new Error("stopped"));
         if (this.transport) {
@@ -570,6 +654,7 @@ export class CodexProcess extends EventEmitter {
         this._pendingPlanInput = null;
         this._projectPath = projectPath;
         this.stdoutLineChunks = [];
+        this.stdoutLineChars = 0;
     }
     launchAppServer(projectPath, options) {
         const sandboxLog = options?.sandboxMode ?? "config";
@@ -1566,17 +1651,37 @@ export class CodexProcess extends EventEmitter {
         }
     }
     handleStdoutChunk(chunk) {
+        if (this.stopped)
+            return;
         let lineStart = 0;
         while (lineStart < chunk.length) {
             const newlineIndex = chunk.indexOf("\n", lineStart);
+            const end = newlineIndex < 0 ? chunk.length : newlineIndex;
+            const fragment = chunk.slice(lineStart, end);
+            this.stdoutLineChars += fragment.length;
+            if (this.stdoutLineChars > MAX_STDOUT_LINE_CHARS) {
+                this.failStdout(new Error("Codex app-server response exceeds the Bridge 64 Mi-character limit " +
+                    `(pending: ${[...this.pendingRpc.values()].map((rpc) => rpc.method).join(", ") || "notification"}). ` +
+                    "Only this Codex connection was closed; Bridge is still running."));
+                return;
+            }
             if (newlineIndex < 0) {
-                this.stdoutLineChunks.push(chunk.slice(lineStart));
+                this.stdoutLineChunks.push(fragment);
+                return;
+            }
+            let line;
+            try {
+                // Guard both fragmented and single-chunk records before joining, and
+                // keep allocation errors inside the connection's failure boundary.
+                this.stdoutLineChunks.push(fragment);
+                line = this.stdoutLineChunks.join("").trim();
+            }
+            catch (err) {
+                this.failStdout(err instanceof Error ? err : new Error(String(err)));
                 return;
             }
-            const lineFragment = chunk.slice(lineStart, newlineIndex);
-            const line = this.stdoutLineChunks.length === 0
-                ? lineFragment.trim()
-                : this.completeStdoutLine(lineFragment);
+            this.stdoutLineChunks = [];
+            this.stdoutLineChars = 0;
             lineStart = newlineIndex + 1;
             if (!line)
                 continue;
@@ -1585,7 +1690,7 @@ export class CodexProcess extends EventEmitter {
                 this.handleRpcEnvelope(envelope);
             }
             catch (err) {
-                console.warn(`[codex-process] failed to parse app-server JSON line: ${line.slice(0, 200)}`);
+                console.warn("[codex-process] failed to parse app-server JSON line");
                 if (!this.stopped) {
                     this.emitMessage({
                         type: "error",
@@ -1595,11 +1700,12 @@ export class CodexProcess extends EventEmitter {
             }
         }
     }
-    completeStdoutLine(finalChunk) {
-        this.stdoutLineChunks.push(finalChunk);
-        const line = this.stdoutLineChunks.join("").trim();
-        this.stdoutLineChunks = [];
-        return line;
+    failStdout(error) {
+        console.error(`[codex-process] ${error.message}`);
+        this.rejectReadiness(error);
+        this.rejectAllPending(error);
+        this.emitMessage({ type: "error", message: error.message });
+        this.stop();
     }
     handleRpcEnvelope(envelope) {
         if (envelope.id != null &&