@ccpocket/bridge 1.52.2 → 1.53.1

package/dist/websocket.js

@@ -9,7 +9,7 @@ import { SessionManager, } from "./session.js";
 import { SdkProcess } from "./sdk-process.js";
 import { CodexProcess, } from "./codex-process.js";
 import { parseClientMessage, } from "./parser.js";
-import { getAllRecentSessions, getCodexSessionHistory, getSessionHistory, codexUserTurnUuid, 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";
@@ -82,6 +82,95 @@ function countCodexUserTurnsInSession(session) {
 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". */
@@ -494,13 +583,13 @@ export class BridgeWebSocketServer {
             });
             return;
         }
-        const numTurns = totalUserTurns - targetOrdinal;
+        const numTurns = totalUserTurns - targetOrdinal + 1;
         if (numTurns <= 0) {
             this.send(ws, {
                 type: "rewind_result",
                 success: false,
                 mode,
-                error: "No newer turns to rewind",
+                error: "Invalid Codex rewind target",
             });
             return;
         }
@@ -522,8 +611,12 @@ export class BridgeWebSocketServer {
                 worktreeBranch: session.worktreeBranch,
             }
             : undefined;
-        await codexProcess.rollbackThread(numTurns);
-        const pastMessages = await getCodexSessionHistory(threadId);
+        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 ?? {}),
@@ -546,6 +639,88 @@ export class BridgeWebSocketServer {
         }));
         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",
@@ -613,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 {
@@ -921,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.
@@ -1008,6 +1218,13 @@ export class BridgeWebSocketServer {
                     ...(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) {
@@ -1422,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,
@@ -1647,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,
@@ -2184,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,
@@ -2204,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",
@@ -2228,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;
@@ -3309,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) => {