@ccpocket/bridge 1.68.0 → 1.68.2

package/dist/websocket.js

@@ -5,7 +5,7 @@ import { lstat, readFile, readlink, stat, unlink } from "node:fs/promises";
 import { resolve, extname } from "node:path";
 import { promisify } from "node:util";
 import { WebSocketServer, WebSocket } from "ws";
-import { SessionManager, } from "./session.js";
+import { SessionManager, MAX_HISTORY_PER_SESSION, } from "./session.js";
 import { SdkProcess, listAvailableClaudeModels, } from "./sdk-process.js";
 import { CodexProcess, } from "./codex-process.js";
 import { stopManagedCodexAppServers } from "./codex-transport.js";
@@ -979,89 +979,110 @@ export class BridgeWebSocketServer {
             message,
         }));
         this.applyCodexCanonicalHistoryBaseline(session, history, entries);
-        return [...entries, ...session.historyEntries];
+        return entries;
     }
     applyCodexCanonicalHistoryBaseline(session, history, canonicalEntries) {
-        const liveEntries = session.historyEntries.map((entry) => ({
+        const orderedRevision = session.codexOrderedHistoryRevision ?? 0;
+        const liveEntries = [
+            ...(session.codexOrderedHistoryEntries ?? []),
+            ...session.historyEntries.filter((entry) => entry.seq > orderedRevision),
+        ].map((entry) => ({
             seq: entry.seq,
             message: entry.message,
         }));
-        const canonicalKeys = new Set();
+        const latestUserInput = session.codexLatestUserInput;
+        const latestUserKeys = latestUserInput
+            ? this.codexHistoryMessageIdentityKeys(latestUserInput)
+            : [];
+        if (latestUserInput &&
+            !liveEntries.some((entry) => entry.message === latestUserInput ||
+                (entry.message.type === "user_input" &&
+                    this.codexHistoryMessageIdentityKeys(entry.message).some((key) => latestUserKeys.includes(key))))) {
+            const historySeq = latestUserInput
+                .historySeq;
+            liveEntries.unshift({
+                seq: typeof historySeq === "number" ? historySeq : 0,
+                message: latestUserInput,
+            });
+        }
         const canonicalUserUuids = new Set();
         for (const entry of canonicalEntries) {
-            for (const key of this.codexHistoryMessageIdentityKeys(entry.message)) {
-                canonicalKeys.add(key);
-            }
             const message = entry.message;
             if (message.type === "user_input" && message.userMessageUuid) {
                 canonicalUserUuids.add(message.userMessageUuid);
             }
         }
         this.seedCodexCanonicalUserTurnUuidMap(session, history);
-        let nextSeq = canonicalEntries.at(-1)?.seq ?? 0;
-        const canonicalAssistantContentsByUser = new Map();
-        let canonicalUserKey = null;
-        for (const entry of canonicalEntries) {
-            if (entry.message.type === "user_input") {
-                canonicalUserKey = entry.message.userMessageUuid
-                    ? `user:${entry.message.userMessageUuid}`
-                    : null;
-                continue;
+        const merged = [];
+        let canonicalCursor = 0;
+        let hasCanonicalAnchor = false;
+        let canMatchAssistantContent = false;
+        const appendCanonicalUntil = (endExclusive) => {
+            while (canonicalCursor < endExclusive) {
+                const message = canonicalEntries[canonicalCursor].message;
+                merged.push({ message, retained: false });
+                canonicalCursor += 1;
+                hasCanonicalAnchor = true;
+                if (message.type === "user_input") {
+                    canMatchAssistantContent = true;
+                }
             }
-            if (entry.message.type !== "assistant" || !canonicalUserKey)
-                continue;
-            const contents = canonicalAssistantContentsByUser.get(canonicalUserKey);
-            const contentKey = this.historyValueKey(entry.message.message.content);
-            if (contents)
-                contents.push(contentKey);
-            else
-                canonicalAssistantContentsByUser.set(canonicalUserKey, [contentKey]);
-        }
-        let pendingCanonicalAssistantContents = [];
-        const retainedMessages = [];
-        const retainedEntries = [];
-        for (const entry of liveEntries) {
-            if (!this.shouldRetainCodexLiveHistoryMessage(entry.message))
-                continue;
-            const keys = this.codexHistoryMessageIdentityKeys(entry.message);
-            const matchesCanonical = keys.some((key) => canonicalKeys.has(key));
-            if (entry.message.type === "user_input") {
-                const userKey = entry.message.userMessageUuid
-                    ? `user:${entry.message.userMessageUuid}`
-                    : null;
-                pendingCanonicalAssistantContents =
-                    matchesCanonical && userKey
-                        ? [...(canonicalAssistantContentsByUser.get(userKey) ?? [])]
-                        : [];
-            }
-            if (entry.message.type === "assistant") {
-                const contentKey = this.historyValueKey(entry.message.message.content);
-                const contentIndex = pendingCanonicalAssistantContents.indexOf(contentKey);
-                if (matchesCanonical) {
-                    if (contentIndex !== -1) {
-                        pendingCanonicalAssistantContents.splice(contentIndex, 1);
-                    }
-                    continue;
+        };
+        for (let liveIndex = 0; liveIndex < liveEntries.length; liveIndex++) {
+            const liveEntry = liveEntries[liveIndex];
+            const matchIndex = this.findCodexCanonicalMatchIndex(canonicalEntries, liveEntry.message, canonicalCursor, canMatchAssistantContent);
+            if (matchIndex === -1) {
+                let nextMatchIndex = -1;
+                for (let nextLiveIndex = liveIndex + 1; nextLiveIndex < liveEntries.length; nextLiveIndex++) {
+                    nextMatchIndex = this.findCodexCanonicalMatchIndex(canonicalEntries, liveEntries[nextLiveIndex].message, canonicalCursor, canMatchAssistantContent);
+                    if (nextMatchIndex !== -1)
+                        break;
                 }
-                const matchesCanonicalTurnAssistant = contentIndex !== -1;
-                if (matchesCanonicalTurnAssistant) {
-                    pendingCanonicalAssistantContents.splice(contentIndex, 1);
+                if (nextMatchIndex !== -1) {
+                    appendCanonicalUntil(nextMatchIndex);
+                }
+                else if (!hasCanonicalAnchor) {
+                    appendCanonicalUntil(canonicalEntries.length);
+                }
+                if (this.shouldRetainCodexLiveHistoryMessage(liveEntry.message)) {
+                    merged.push({ message: liveEntry.message, retained: true });
                 }
-                if (matchesCanonicalTurnAssistant)
-                    continue;
-            }
-            if (matchesCanonical)
                 continue;
-            const seq = ++nextSeq;
-            entry.message.historySeq = seq;
-            retainedMessages.push(entry.message);
-            retainedEntries.push({ seq, message: entry.message });
+            }
+            appendCanonicalUntil(matchIndex + 1);
         }
+        appendCanonicalUntil(canonicalEntries.length);
+        const retainedMessages = [];
+        const retainedEntries = [];
+        let canonicalRevision = 0;
+        const previousRevision = session.historyRevision;
+        const requiresNewBaselineRevision = previousRevision > 0;
+        const targetRevision = requiresNewBaselineRevision
+            ? Math.max(merged.length, previousRevision + 1)
+            : merged.length;
+        const sequenceOffset = targetRevision - merged.length;
+        const mergedEntries = merged.map(({ message, retained }, index) => {
+            const seq = sequenceOffset + index + 1;
+            if (retained) {
+                message.historySeq = seq;
+                retainedMessages.push(message);
+                retainedEntries.push({ seq, message });
+            }
+            else {
+                canonicalRevision = seq;
+            }
+            return { seq, message };
+        });
+        canonicalEntries.splice(0, canonicalEntries.length, ...mergedEntries);
+        session.codexOrderedHistoryEntries =
+            this.buildCodexOrderedHistoryWindow(mergedEntries);
+        session.codexOrderedHistoryRevision = targetRevision;
         session.pastMessages = history;
         session.history = retainedMessages;
         session.historyEntries = retainedEntries;
-        session.historyRevision = nextSeq;
-        session.codexCanonicalHistoryRevision = canonicalEntries.at(-1)?.seq ?? 0;
+        session.historyRevision = targetRevision;
+        session.codexCanonicalHistoryRevision = canonicalRevision;
+        session.codexHistoryResetRevision = targetRevision;
         session.historyLowWatermark =
             retainedEntries[0]?.seq ?? session.historyRevision + 1;
         if (session.pendingCodexUserEchoUuids) {
@@ -1075,6 +1096,52 @@ export class BridgeWebSocketServer {
             }
         }
     }
+    buildCodexOrderedHistoryWindow(entries) {
+        if (entries.length <= MAX_HISTORY_PER_SESSION) {
+            return entries.map((entry) => ({
+                seq: entry.seq,
+                message: entry.message,
+            }));
+        }
+        const tail = entries.slice(-MAX_HISTORY_PER_SESSION);
+        if (tail.some((entry) => entry.message.type === "user_input")) {
+            return tail;
+        }
+        let latestUser;
+        for (let index = entries.length - 1; index >= 0; index--) {
+            if (entries[index].message.type === "user_input") {
+                latestUser = entries[index];
+                break;
+            }
+        }
+        return latestUser
+            ? [latestUser, ...entries.slice(-(MAX_HISTORY_PER_SESSION - 1))]
+            : tail;
+    }
+    findCodexCanonicalMatchIndex(canonicalEntries, liveMessage, start, allowAssistantContentMatch) {
+        const liveKeys = this.codexHistoryMessageIdentityKeys(liveMessage);
+        if (liveKeys.length > 0) {
+            for (let index = start; index < canonicalEntries.length; index++) {
+                const canonicalKeys = this.codexHistoryMessageIdentityKeys(canonicalEntries[index].message);
+                if (liveKeys.some((key) => canonicalKeys.includes(key)))
+                    return index;
+            }
+        }
+        if (!allowAssistantContentMatch || liveMessage.type !== "assistant") {
+            return -1;
+        }
+        const liveContent = this.historyValueKey(liveMessage.message.content);
+        for (let index = start; index < canonicalEntries.length; index++) {
+            const canonicalMessage = canonicalEntries[index].message;
+            if (canonicalMessage.type === "user_input")
+                break;
+            if (canonicalMessage.type === "assistant" &&
+                this.historyValueKey(canonicalMessage.message.content) === liveContent) {
+                return index;
+            }
+        }
+        return -1;
+    }
     seedCodexCanonicalUserTurnUuidMap(session, history) {
         if (session.provider !== "codex")
             return;
@@ -1151,8 +1218,8 @@ export class BridgeWebSocketServer {
             this.send(ws, {
                 type: "history_snapshot",
                 sessionId,
-                fromSeq: entries[0]?.seq ?? 1,
-                toSeq: entries.at(-1)?.seq ?? 0,
+                fromSeq: entries[0]?.seq ?? session.historyRevision + 1,
+                toSeq: session.historyRevision,
                 messages: entries,
                 status: session.status,
                 reason: "reset",
@@ -1205,9 +1272,11 @@ export class BridgeWebSocketServer {
     shouldResetCodexHistoryDelta(session, sinceSeq, resultKind) {
         if (!this.codexThreadIdForSession(session))
             return false;
-        if (typeof session.codexCanonicalHistoryRevision !== "number")
+        const resetRevision = session.codexHistoryResetRevision ??
+            session.codexCanonicalHistoryRevision;
+        if (typeof resetRevision !== "number")
             return true;
-        if (sinceSeq < session.codexCanonicalHistoryRevision)
+        if (sinceSeq < resetRevision)
             return true;
         return resultKind === "snapshot";
     }
@@ -1620,9 +1689,6 @@ export class BridgeWebSocketServer {
                         this.send(ws, this.buildPathNotAllowedError(additionalWritableRoots.deniedRoot));
                         break;
                     }
-                    const cached = provider === "claude"
-                        ? this.sessionManager.getCachedCommands(projectPath)
-                        : undefined;
                     const { sessionId, permissionMode: effectivePermissionMode, executionMode: effectiveExecutionMode, planMode: effectivePlanMode, usedFallback: autoFallbackUsed, } = provider === "claude"
                         ? this.createClaudeSessionWithFallback({
                             projectPath,
@@ -1687,6 +1753,7 @@ export class BridgeWebSocketServer {
                             usedFallback: false,
                         };
                     const createdSession = this.sessionManager.get(sessionId);
+                    const cached = this.sessionManager.getCachedCommands(provider, createdSession?.worktreePath ?? projectPath);
                     // Load saved session name from CLI storage (for resumed sessions)
                     void this.loadAndSetSessionName(createdSession, provider, projectPath, msg.sessionId).then(() => {
                         this.send(ws, this.buildSessionCreatedMessage({
@@ -3380,6 +3447,7 @@ export class BridgeWebSocketServer {
                                 : "default",
                         });
                         const createdSession = this.sessionManager.get(sessionId);
+                        const cached = this.sessionManager.getCachedCommands("codex", createdSession?.worktreePath ?? effectiveProjectPath);
                         await this.loadAndSetSessionName(createdSession, "codex", effectiveProjectPath, sessionRefId);
                         this.send(ws, this.buildSessionCreatedMessage({
                             sessionId,
@@ -3394,6 +3462,23 @@ export class BridgeWebSocketServer {
                             permissionMode: legacyPermissionMode,
                             executionMode,
                             planMode,
+                            ...(cached
+                                ? {
+                                    slashCommands: cached.slashCommands,
+                                    skills: cached.skills,
+                                    ...(cached.skillMetadata
+                                        ? { skillMetadata: cached.skillMetadata }
+                                        : {}),
+                                    apps: cached.apps,
+                                    ...(cached.appMetadata
+                                        ? { appMetadata: cached.appMetadata }
+                                        : {}),
+                                    plugins: cached.plugins,
+                                    ...(cached.pluginMetadata
+                                        ? { pluginMetadata: cached.pluginMetadata }
+                                        : {}),
+                                }
+                                : {}),
                         }));
                         this.broadcastSessionList();
                         this.debugEvents.set(sessionId, []);
@@ -3414,7 +3499,6 @@ export class BridgeWebSocketServer {
                     break;
                 }
                 const claudeSessionId = sessionRefId;
-                const cached = this.sessionManager.getCachedCommands(resumeProjectPath);
                 let pendingResumes = this.pendingClaudeResumeInputs.get(ws);
                 if (!pendingResumes) {
                     pendingResumes = new Map();
@@ -3469,6 +3553,7 @@ export class BridgeWebSocketServer {
                         worktreeOptions: worktreeOpts,
                     });
                     const createdSession = this.sessionManager.get(sessionId);
+                    const cached = this.sessionManager.getCachedCommands("claude", createdSession?.worktreePath ?? resumeProjectPath);
                     const finishResume = () => {
                         this.send(ws, {
                             ...this.buildSessionCreatedMessage({
@@ -5657,9 +5742,11 @@ export class BridgeWebSocketServer {
         return (this.clientSupportedServerMessages.get(ws)?.has(type) ?? false);
     }
     hasInputConflictSince(session, baseSeq) {
+        const codexResetRevision = session.codexHistoryResetRevision ??
+            session.codexCanonicalHistoryRevision;
         if (session.provider === "codex" &&
-            typeof session.codexCanonicalHistoryRevision === "number" &&
-            baseSeq < session.codexCanonicalHistoryRevision) {
+            typeof codexResetRevision === "number" &&
+            baseSeq < codexResetRevision) {
             return true;
         }
         const delta = this.sessionManager.getHistorySince(session.id, baseSeq);
@@ -5714,7 +5801,7 @@ export class BridgeWebSocketServer {
     sendCachedCommands(ws, sessionId, session) {
         // Restore command metadata when the original init/supported_commands event
         // has fallen out of the bounded in-memory history.
-        const cached = this.sessionManager.getCachedCommands(session.projectPath);
+        const cached = this.sessionManager.getCachedCommands(session.provider, session.worktreePath ?? session.projectPath);
         if (!cached ||
             (cached.slashCommands.length === 0 &&
                 cached.skills.length === 0 &&