@ccpocket/bridge 1.51.0 → 1.53.0

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, codexThreadToSessionHistory, 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,139 @@ 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);
+}
+function normalizeHistoryContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return [];
+    const normalized = [];
+    for (const item of content) {
+        if (!item || typeof item !== "object")
+            continue;
+        const value = item;
+        if (typeof value.type !== "string")
+            continue;
+        if (value.type === "text") {
+            normalized.push({
+                type: "text",
+                text: typeof value.text === "string" ? value.text : "",
+            });
+        }
+        else if (value.type === "tool_use") {
+            normalized.push({
+                type: "tool_use",
+                id: typeof value.id === "string" ? value.id : undefined,
+                name: typeof value.name === "string" ? value.name : undefined,
+                input: value.input && typeof value.input === "object" && !Array.isArray(value.input)
+                    ? value.input
+                    : undefined,
+            });
+        }
+    }
+    return normalized;
+}
+function buildCodexHistoryPrefix(session, targetOrdinal) {
+    const messages = [];
+    let userOrdinal = 0;
+    let reachedEnd = false;
+    const appendPastMessage = (message) => {
+        if (reachedEnd || !message || typeof message !== "object")
+            return;
+        const item = message;
+        if (item.role === "user" && item.isMeta !== true) {
+            userOrdinal += 1;
+            if (userOrdinal > targetOrdinal) {
+                reachedEnd = true;
+                return;
+            }
+            messages.push({ ...item });
+            return;
+        }
+        if (item.role === "assistant" && userOrdinal > 0 && userOrdinal <= targetOrdinal) {
+            messages.push({ ...item });
+        }
+    };
+    for (const message of session.pastMessages ?? []) {
+        appendPastMessage(message);
+        if (reachedEnd)
+            return messages;
+    }
+    for (const message of session.history) {
+        if (message.type === "user_input") {
+            if (message.isMeta === true)
+                continue;
+            const userInput = message;
+            userOrdinal += 1;
+            if (userOrdinal > targetOrdinal)
+                break;
+            messages.push({
+                role: "user",
+                uuid: userInput.userMessageUuid,
+                timestamp: userInput.timestamp,
+                imageCount: userInput.imageCount,
+                content: [{ type: "text", text: userInput.text }],
+            });
+        }
+        else if (message.type === "assistant" &&
+            userOrdinal > 0 &&
+            userOrdinal <= targetOrdinal) {
+            messages.push({
+                role: "assistant",
+                uuid: message.messageUuid,
+                content: normalizeHistoryContent(message.message.content),
+            });
+        }
+    }
+    return messages;
+}
+function countCodexHistoryUserTurns(messages) {
+    return messages.filter((message) => message.role === "user" && !message.isMeta)
+        .length;
+}
 // ---- Codex mode mapping helpers ----
 /** Map unified PermissionMode to Codex approval_policy.
  *  Only "bypassPermissions" maps to "never"; all others use "on-request". */
@@ -394,6 +523,204 @@ 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 + 1;
+        if (numTurns <= 0) {
+            this.send(ws, {
+                type: "rewind_result",
+                success: false,
+                mode,
+                error: "Invalid Codex rewind target",
+            });
+            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;
+        const rolledBackThread = await codexProcess.rollbackThread(numTurns);
+        const pastMessages = this.codexHistoryFromThreadOrFallback({
+            thread: rolledBackThread,
+            expectedUserTurns: targetOrdinal - 1,
+            fallback: buildCodexHistoryPrefix(session, targetOrdinal - 1),
+        });
+        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);
+    }
+    async forkCodexSession(ws, sessionId, targetUuid) {
+        const session = this.sessionManager.get(sessionId);
+        if (!session) {
+            this.send(ws, {
+                type: "error",
+                message: `Session ${sessionId} not found`,
+                errorCode: "fork_failed",
+            });
+            return;
+        }
+        const codexProcess = session.process;
+        if (session.provider !== "codex" ||
+            typeof codexProcess.forkThread !== "function") {
+            this.send(ws, {
+                type: "error",
+                message: "Fork is only supported for Codex sessions",
+                errorCode: "fork_failed",
+            });
+            return;
+        }
+        if (session.status !== "idle" || (codexProcess.status ?? session.status) !== "idle") {
+            this.send(ws, {
+                type: "error",
+                message: "Cannot fork while Codex is running",
+                errorCode: "fork_failed",
+            });
+            return;
+        }
+        if (session.codexQueuedInput) {
+            this.send(ws, {
+                type: "error",
+                message: "Cannot fork while Codex has queued input",
+                errorCode: "fork_failed",
+            });
+            return;
+        }
+        const targetOrdinal = parseCodexUserTurnOrdinal(targetUuid);
+        const totalUserTurns = countCodexUserTurnsInSession(session);
+        if (targetOrdinal === null || targetOrdinal > totalUserTurns) {
+            this.send(ws, {
+                type: "error",
+                message: "Invalid Codex fork target",
+                errorCode: "fork_failed",
+            });
+            return;
+        }
+        const projectPath = session.projectPath;
+        const codexSettings = session.codexSettings;
+        const worktreeOpts = session.worktreePath
+            ? {
+                existingWorktreePath: session.worktreePath,
+                worktreeBranch: session.worktreeBranch,
+            }
+            : undefined;
+        const forked = await codexProcess.forkThread();
+        const forkedThreadId = forked.threadId;
+        const turnsToDrop = totalUserTurns - targetOrdinal;
+        let forkedThread = forked.thread;
+        if (turnsToDrop > 0) {
+            forkedThread = await codexProcess.rollbackThreadById(forkedThreadId, turnsToDrop);
+        }
+        const pastMessages = this.codexHistoryFromThreadOrFallback({
+            thread: forkedThread,
+            expectedUserTurns: targetOrdinal,
+            fallback: buildCodexHistoryPrefix(session, targetOrdinal),
+        });
+        const newSessionId = this.sessionManager.create(projectPath, undefined, pastMessages, worktreeOpts, "codex", {
+            ...(codexSettings ?? {}),
+            threadId: forkedThreadId,
+        });
+        const newSession = this.sessionManager.get(newSessionId);
+        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",
@@ -461,6 +788,39 @@ export class BridgeWebSocketServer {
         }
         return { pastMessages, historyMessages };
     }
+    async getCodexThreadHistoryFromRpc(threadId, projectPath) {
+        const activeProcess = this.getActiveCodexProcess();
+        const process = activeProcess ?? (await this.createStandaloneCodexProcess(projectPath));
+        const isStandalone = process !== activeProcess;
+        try {
+            const thread = await process.readThread(threadId, true);
+            return codexThreadToSessionHistory(thread);
+        }
+        finally {
+            if (isStandalone) {
+                process.stop();
+            }
+        }
+    }
+    async getCodexThreadHistory(threadId, projectPath) {
+        if (!this.getActiveCodexProcess() && process.env.NODE_ENV === "test") {
+            return getCodexSessionHistory(threadId);
+        }
+        try {
+            return await this.getCodexThreadHistoryFromRpc(threadId, projectPath);
+        }
+        catch (err) {
+            console.warn(`[ws] thread/read failed for ${threadId}; falling back to JSONL: ${err instanceof Error ? err.message : String(err)}`);
+            return getCodexSessionHistory(threadId);
+        }
+    }
+    codexHistoryFromThreadOrFallback(params) {
+        const messages = codexThreadToSessionHistory(params.thread);
+        if (countCodexHistoryUserTurns(messages) >= params.expectedUserTurns) {
+            return messages;
+        }
+        return params.fallback;
+    }
     createClaudeSessionWithFallback(params) {
         const initialMode = params.options?.permissionMode ?? "default";
         try {
@@ -769,7 +1129,9 @@ export class BridgeWebSocketServer {
                 // The SDK stream does NOT emit user messages, so session.history would
                 // otherwise lack them.  This ensures get_history responses include user
                 // messages and replaceEntries on the client side preserves them.
-                // We do NOT broadcast this back — Flutter already shows it via sendMessage().
+                // Flutter already shows the user bubble optimistically. For Codex we
+                // echo the accepted user_input back with its synthetic UUID so the live
+                // bubble becomes rewindable/forkable without requiring a stop+resume.
                 //
                 // Register images in the image store so they can be served via HTTP
                 // when the client re-enters the session and loads history.
@@ -810,6 +1172,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,12 +1209,22 @@ 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 } : {}),
                     ...(imageRefs ? { images: imageRefs } : {}),
                 });
                 const acceptedSeq = userEntry?.seq ?? session.historyRevision;
+                if (session.provider === "codex" && userEntry) {
+                    this.send(ws, {
+                        ...userEntry.message,
+                        sessionId: session.id,
+                        historySeq: acceptedSeq,
+                    });
+                }
                 // Persist images to Gallery Store asynchronously (fire-and-forget)
                 if (images.length > 0 && this.galleryStore && session.projectPath) {
                     for (const img of images) {
@@ -1266,7 +1639,7 @@ export class BridgeWebSocketServer {
                             worktreeBranch,
                         };
                     }
-                    getCodexSessionHistory(threadId)
+                    this.getCodexThreadHistory(threadId, effectiveProjectPath)
                         .then((pastMessages) => {
                         const newId = this.sessionManager.create(effectiveProjectPath, undefined, pastMessages, worktreeOpts, "codex", {
                             threadId,
@@ -1491,7 +1864,7 @@ export class BridgeWebSocketServer {
                 else if (worktreePath) {
                     worktreeOpts = { existingWorktreePath: worktreePath, worktreeBranch };
                 }
-                getCodexSessionHistory(threadId)
+                this.getCodexThreadHistory(threadId, effectiveProjectPath)
                     .then((pastMessages) => {
                     const newId = this.sessionManager.create(effectiveProjectPath, undefined, pastMessages, worktreeOpts, "codex", {
                         threadId,
@@ -2028,8 +2401,8 @@ export class BridgeWebSocketServer {
                             };
                         }
                     }
-                    getCodexSessionHistory(sessionRefId)
-                        .then((pastMessages) => {
+                    try {
+                        const pastMessages = await this.getCodexThreadHistory(sessionRefId, effectiveProjectPath);
                         const sessionId = this.sessionManager.create(effectiveProjectPath, undefined, pastMessages, worktreeOpts, "codex", {
                             threadId: sessionRefId,
                             profile: effectiveProfile,
@@ -2048,22 +2421,21 @@ export class BridgeWebSocketServer {
                                 : "default",
                         });
                         const createdSession = this.sessionManager.get(sessionId);
-                        void this.loadAndSetSessionName(createdSession, "codex", effectiveProjectPath, sessionRefId).then(() => {
-                            this.send(ws, this.buildSessionCreatedMessage({
-                                sessionId,
-                                provider: "codex",
-                                projectPath: effectiveProjectPath,
-                                session: createdSession,
-                                sandboxMode: createdSession?.codexSettings?.sandboxMode
-                                    ? sandboxModeToExternal(createdSession.codexSettings.sandboxMode)
-                                    : undefined,
-                                approvalsReviewer: createdSession?.codexSettings?.approvalsReviewer,
-                                permissionMode: legacyPermissionMode,
-                                executionMode,
-                                planMode,
-                            }));
-                            this.broadcastSessionList();
-                        });
+                        await this.loadAndSetSessionName(createdSession, "codex", effectiveProjectPath, sessionRefId);
+                        this.send(ws, this.buildSessionCreatedMessage({
+                            sessionId,
+                            provider: "codex",
+                            projectPath: effectiveProjectPath,
+                            session: createdSession,
+                            sandboxMode: createdSession?.codexSettings?.sandboxMode
+                                ? sandboxModeToExternal(createdSession.codexSettings.sandboxMode)
+                                : undefined,
+                            approvalsReviewer: createdSession?.codexSettings?.approvalsReviewer,
+                            permissionMode: legacyPermissionMode,
+                            executionMode,
+                            planMode,
+                        }));
+                        this.broadcastSessionList();
                         this.debugEvents.set(sessionId, []);
                         this.recordDebugEvent(sessionId, {
                             direction: "internal",
@@ -2072,13 +2444,13 @@ export class BridgeWebSocketServer {
                             detail: `provider=codex thread=${sessionRefId}`,
                         });
                         this.projectHistory?.addProject(effectiveProjectPath);
-                    })
-                        .catch((err) => {
+                    }
+                    catch (err) {
                         this.send(ws, {
                             type: "error",
                             message: `Failed to load Codex session history: ${err}`,
                         });
-                    });
+                    }
                     break;
                 }
                 const claudeSessionId = sessionRefId;
@@ -2304,11 +2676,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 +2745,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 +2754,7 @@ export class BridgeWebSocketServer {
                         this.send(ws, {
                             type: "file_content",
                             filePath: msg.filePath,
+                            kind: "text",
                             content,
                             language,
                             totalLines: lines.length,
@@ -2972,6 +3375,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 +3424,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
@@ -3109,6 +3525,17 @@ export class BridgeWebSocketServer {
                 }
                 break;
             }
+            case "fork": {
+                this.forkCodexSession(ws, msg.sessionId, msg.targetUuid).catch((err) => {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    this.send(ws, {
+                        type: "error",
+                        message: errMsg,
+                        errorCode: "fork_failed",
+                    });
+                });
+                break;
+            }
             case "list_windows": {
                 listWindows()
                     .then((windows) => {
@@ -4072,6 +4499,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