@ccpocket/bridge 1.51.0 → 1.52.2

package/dist/websocket.d.ts

@@ -61,6 +61,7 @@ export declare class BridgeWebSocketServer {
     private buildPathNotAllowedError;
     private normalizeAdditionalWritableRoots;
     private buildSessionCreatedMessage;
+    private rewindCodexConversation;
     private sendTip;
     private splitPastHistoryMessages;
     private createClaudeSessionWithFallback;
@@ -117,6 +118,7 @@ export declare class BridgeWebSocketServer {
     broadcastGalleryNewImage(image: import("./gallery-store.js").GalleryImageInfo): void;
     private collectGitDiff;
     private static readonly IMAGE_EXTENSIONS;
+    private static readonly FILE_PEEK_IMAGE_EXTENSIONS;
     private static readonly AUTO_DISPLAY_THRESHOLD;
     private static readonly MAX_IMAGE_SIZE;
     private static mimeTypeForExt;

package/dist/websocket.js

@@ -7,9 +7,9 @@ import { promisify } from "node:util";
 import { WebSocketServer, WebSocket } from "ws";
 import { SessionManager, } from "./session.js";
 import { SdkProcess } from "./sdk-process.js";
-import { CodexProcess } from "./codex-process.js";
+import { CodexProcess, } from "./codex-process.js";
 import { parseClientMessage, } from "./parser.js";
-import { getAllRecentSessions, getCodexSessionHistory, getSessionHistory, findSessionsByClaudeIds, extractMessageImages, getClaudeSessionName, loadCodexSessionNames, renameClaudeSession, renameCodexSession, saveCodexSessionProfile, } from "./sessions-index.js";
+import { getAllRecentSessions, getCodexSessionHistory, getSessionHistory, codexUserTurnUuid, findSessionsByClaudeIds, extractMessageImages, getClaudeSessionName, loadCodexSessionNames, renameClaudeSession, renameCodexSession, saveCodexSessionProfile, } from "./sessions-index.js";
 import { ArchiveStore } from "./archive-store.js";
 import { WorktreeStore } from "./worktree-store.js";
 import { listWorktrees, removeWorktree, worktreeExists, getMainBranch, } from "./worktree.js";
@@ -38,10 +38,50 @@ const CODEX_MODELS = [
     "gpt-5.3-codex",
     "gpt-5.3-codex-spark",
 ];
+const CODEX_USER_TURN_UUID_RE = /^codex:user-turn:(\d+)$/;
 const OPT_IN_SERVER_MESSAGES = new Set([
     "conversation_queue",
     "prompt_history_status",
 ]);
+function parseCodexUserTurnOrdinal(uuid) {
+    if (!uuid)
+        return null;
+    const match = uuid.match(CODEX_USER_TURN_UUID_RE);
+    if (!match)
+        return null;
+    const ordinal = Number(match[1]);
+    return Number.isInteger(ordinal) && ordinal > 0 ? ordinal : null;
+}
+function countCodexUserTurnsInSession(session) {
+    let count = 0;
+    let maxOrdinal = 0;
+    const observe = (uuid) => {
+        count += 1;
+        const ordinal = parseCodexUserTurnOrdinal(uuid);
+        if (ordinal !== null) {
+            maxOrdinal = Math.max(maxOrdinal, ordinal);
+        }
+    };
+    if (Array.isArray(session.pastMessages)) {
+        for (const message of session.pastMessages) {
+            if (!message || typeof message !== "object")
+                continue;
+            const item = message;
+            if (item.role === "user" && item.isMeta !== true) {
+                observe(typeof item.uuid === "string" ? item.uuid : undefined);
+            }
+        }
+    }
+    for (const message of session.history) {
+        if (message.type === "user_input") {
+            observe(message.userMessageUuid);
+        }
+    }
+    return Math.max(count, maxOrdinal);
+}
+function nextCodexUserTurnUuid(session) {
+    return codexUserTurnUuid(countCodexUserTurnsInSession(session) + 1);
+}
 // ---- Codex mode mapping helpers ----
 /** Map unified PermissionMode to Codex approval_policy.
  *  Only "bypassPermissions" maps to "never"; all others use "on-request". */
@@ -394,6 +434,118 @@ export class BridgeWebSocketServer {
         }
         return msg;
     }
+    async rewindCodexConversation(ws, sessionId, targetUuid, mode) {
+        if (mode !== "conversation") {
+            this.send(ws, {
+                type: "rewind_result",
+                success: false,
+                mode,
+                error: "Codex only supports conversation rewind",
+            });
+            return;
+        }
+        const session = this.sessionManager.get(sessionId);
+        if (!session) {
+            this.send(ws, {
+                type: "rewind_result",
+                success: false,
+                mode,
+                error: `Session ${sessionId} not found`,
+            });
+            return;
+        }
+        const codexProcess = session.process;
+        if (session.provider !== "codex" ||
+            typeof codexProcess.rollbackThread !== "function") {
+            this.send(ws, {
+                type: "rewind_result",
+                success: false,
+                mode,
+                error: "Session is not a Codex session",
+            });
+            return;
+        }
+        if (session.status !== "idle" || (codexProcess.status ?? session.status) !== "idle") {
+            this.send(ws, {
+                type: "rewind_result",
+                success: false,
+                mode,
+                error: "Cannot rewind while Codex is running",
+            });
+            return;
+        }
+        if (session.codexQueuedInput) {
+            this.send(ws, {
+                type: "rewind_result",
+                success: false,
+                mode,
+                error: "Cannot rewind while Codex has queued input",
+            });
+            return;
+        }
+        const targetOrdinal = parseCodexUserTurnOrdinal(targetUuid);
+        const totalUserTurns = countCodexUserTurnsInSession(session);
+        if (targetOrdinal === null || targetOrdinal > totalUserTurns) {
+            this.send(ws, {
+                type: "rewind_result",
+                success: false,
+                mode,
+                error: "Invalid Codex rewind target",
+            });
+            return;
+        }
+        const numTurns = totalUserTurns - targetOrdinal;
+        if (numTurns <= 0) {
+            this.send(ws, {
+                type: "rewind_result",
+                success: false,
+                mode,
+                error: "No newer turns to rewind",
+            });
+            return;
+        }
+        const threadId = codexProcess.sessionId ?? session.claudeSessionId;
+        if (!threadId) {
+            this.send(ws, {
+                type: "rewind_result",
+                success: false,
+                mode,
+                error: "No Codex thread ID available for rewind",
+            });
+            return;
+        }
+        const projectPath = session.projectPath;
+        const codexSettings = session.codexSettings;
+        const worktreeOpts = session.worktreePath
+            ? {
+                existingWorktreePath: session.worktreePath,
+                worktreeBranch: session.worktreeBranch,
+            }
+            : undefined;
+        await codexProcess.rollbackThread(numTurns);
+        const pastMessages = await getCodexSessionHistory(threadId);
+        this.sessionManager.destroy(sessionId);
+        const newSessionId = this.sessionManager.create(projectPath, undefined, pastMessages, worktreeOpts, "codex", {
+            ...(codexSettings ?? {}),
+            threadId,
+        });
+        const newSession = this.sessionManager.get(newSessionId);
+        this.send(ws, {
+            type: "rewind_result",
+            success: true,
+            mode,
+        });
+        this.send(ws, this.buildSessionCreatedMessage({
+            sessionId: newSessionId,
+            provider: "codex",
+            projectPath,
+            session: newSession,
+            approvalsReviewer: codexSettings?.approvalsReviewer,
+            sandboxMode: codexSettings?.sandboxMode,
+            sourceSessionId: sessionId,
+        }));
+        this.sendSessionList(ws);
+    }
     sendTip(ws, sessionId, tipCode, session) {
         const tipMsg = {
             type: "system",
@@ -810,6 +962,7 @@ export class BridgeWebSocketServer {
                         itemId: randomUUID(),
                         text,
                         createdAt: new Date().toISOString(),
+                        userMessageUuid: nextCodexUserTurnUuid(session),
                         ...(images.length > 0 ? { imageCount: images.length, images } : {}),
                         ...(imageRefs ? { imageRefs } : {}),
                         ...(codexSkills.length > 0 ? { skills: codexSkills } : {}),
@@ -846,6 +999,9 @@ export class BridgeWebSocketServer {
                 const userEntry = this.sessionManager.appendHistory(session.id, {
                     type: "user_input",
                     text,
+                    ...(session.provider === "codex"
+                        ? { userMessageUuid: nextCodexUserTurnUuid(session) }
+                        : {}),
                     ...(clientMessageId ? { clientMessageId } : {}),
                     timestamp: new Date().toISOString(),
                     ...(images.length > 0 ? { imageCount: images.length } : {}),
@@ -2304,11 +2460,41 @@ export class BridgeWebSocketServer {
                             });
                             return;
                         }
+                        const resolvedFileStat = fileStat.isSymbolicLink()
+                            ? await stat(absPath)
+                            : fileStat;
+                        const ext = extname(absPath).toLowerCase();
+                        if (BridgeWebSocketServer.FILE_PEEK_IMAGE_EXTENSIONS.has(ext)) {
+                            const mimeType = BridgeWebSocketServer.mimeTypeForExt(ext);
+                            if (resolvedFileStat.size > BridgeWebSocketServer.MAX_IMAGE_SIZE) {
+                                this.send(ws, {
+                                    type: "file_content",
+                                    filePath: msg.filePath,
+                                    kind: "image",
+                                    content: "",
+                                    mimeType,
+                                    sizeBytes: resolvedFileStat.size,
+                                    error: "Image too large to preview. Maximum size is 5 MB.",
+                                });
+                                return;
+                            }
+                            const buf = await readFile(absPath);
+                            this.send(ws, {
+                                type: "file_content",
+                                filePath: msg.filePath,
+                                kind: "image",
+                                content: "",
+                                base64: buf.toString("base64"),
+                                mimeType,
+                                sizeBytes: buf.length,
+                            });
+                            return;
+                        }
                         const maxLines = typeof msg.maxLines === "number" && msg.maxLines > 0
                             ? msg.maxLines
                             : 5000;
                         const raw = await readFile(absPath, "utf-8");
-                        const ext = extname(absPath).replace(/^\./, "").toLowerCase();
+                        const textExt = ext.replace(/^\./, "").toLowerCase();
                         const languageMap = {
                             ts: "typescript",
                             tsx: "typescript",
@@ -2343,7 +2529,7 @@ export class BridgeWebSocketServer {
                             makefile: "makefile",
                             gradle: "groovy",
                         };
-                        const language = languageMap[ext] ?? (ext || undefined);
+                        const language = languageMap[textExt] ?? (textExt || undefined);
                         const lines = raw.split("\n");
                         const truncated = lines.length > maxLines;
                         const content = truncated
@@ -2352,6 +2538,7 @@ export class BridgeWebSocketServer {
                         this.send(ws, {
                             type: "file_content",
                             filePath: msg.filePath,
+                            kind: "text",
                             content,
                             language,
                             totalLines: lines.length,
@@ -2972,6 +3159,14 @@ export class BridgeWebSocketServer {
                     });
                     return;
                 }
+                if (session.provider === "codex") {
+                    this.send(ws, {
+                        type: "rewind_preview",
+                        canRewind: false,
+                        error: "Codex rewind does not restore files",
+                    });
+                    return;
+                }
                 this.sessionManager
                     .rewindFiles(msg.sessionId, msg.targetUuid, true)
                     .then((result) => {
@@ -3013,6 +3208,11 @@ export class BridgeWebSocketServer {
                         error: errMsg,
                     });
                 };
+                if (session.provider === "codex") {
+                    this.rewindCodexConversation(ws, msg.sessionId, msg.targetUuid, msg.mode)
+                        .catch(handleError);
+                    break;
+                }
                 if (msg.mode === "code") {
                     // Code-only rewind: rewind files without restarting the conversation
                     this.sessionManager
@@ -4072,6 +4272,14 @@ export class BridgeWebSocketServer {
         ".bmp",
         ".svg",
     ]);
+    static FILE_PEEK_IMAGE_EXTENSIONS = new Set([
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".gif",
+        ".webp",
+        ".svg",
+    ]);
     // Image diff thresholds (configurable via environment variables)
     // - Auto-display: images ≤ threshold are sent inline as base64
     // - Max size: images ≤ max are available for on-demand loading