@ccpocket/bridge 1.68.1 → 1.69.0

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";
@@ -90,8 +90,12 @@ const CODEX_USER_TURN_UUID_RE = /^codex:user-turn:(\d+)$/;
 const OPT_IN_SERVER_MESSAGES = new Set([
     "conversation_queue",
     "goal_state",
+    "guardian_approval",
     "prompt_history_status",
 ]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function parseCodexUserTurnOrdinal(uuid) {
     if (!uuid)
         return null;
@@ -979,89 +983,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 +1100,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 +1222,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 +1276,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";
     }
@@ -5147,14 +5220,18 @@ export class BridgeWebSocketServer {
         }
     }
     broadcastSessionMessageNow(sessionId, msg, exclude) {
-        const data = JSON.stringify({ ...msg, sessionId });
         for (const client of this.wss.clients) {
             if (client === exclude)
                 continue;
             if (client.readyState === WebSocket.OPEN) {
-                if (!this.shouldSendToClient(client, msg))
+                const outboundMsg = {
+                    ...msg,
+                    sessionId,
+                };
+                const compatibleMsg = this.prepareServerMessageForClient(client, outboundMsg);
+                if (!compatibleMsg)
                     continue;
-                client.send(data);
+                client.send(JSON.stringify(compatibleMsg));
             }
         }
     }
@@ -5657,15 +5734,39 @@ export class BridgeWebSocketServer {
         }
     }
     broadcast(msg) {
-        const data = JSON.stringify(msg);
         for (const client of this.wss.clients) {
             if (client.readyState === WebSocket.OPEN) {
-                if (!this.shouldSendToClient(client, msg))
+                const compatibleMsg = this.prepareServerMessageForClient(client, msg);
+                if (!compatibleMsg)
                     continue;
-                client.send(data);
+                client.send(JSON.stringify(compatibleMsg));
             }
         }
     }
+    prepareServerMessageForClient(ws, msg) {
+        if (!this.shouldSendToClient(ws, msg))
+            return null;
+        if (!("messages" in msg) || !Array.isArray(msg.messages))
+            return msg;
+        const messages = msg.messages;
+        if (msg.type === "history") {
+            return {
+                ...msg,
+                messages: messages.filter((message) => isRecord(message) && this.shouldSendToClient(ws, message)),
+            };
+        }
+        if (msg.type === "history_delta" || msg.type === "history_snapshot") {
+            return {
+                ...msg,
+                messages: messages.filter((entry) => {
+                    if (!isRecord(entry) || !isRecord(entry.message))
+                        return true;
+                    return this.shouldSendToClient(ws, entry.message);
+                }),
+            };
+        }
+        return msg;
+    }
     shouldSendToClient(ws, msg) {
         const type = typeof msg.type === "string" ? msg.type : "";
         if (!OPT_IN_SERVER_MESSAGES.has(type))
@@ -5673,9 +5774,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);
@@ -5757,19 +5860,20 @@ export class BridgeWebSocketServer {
         this.send(ws, msg);
     }
     send(ws, msg) {
-        if (!this.shouldSendToClient(ws, msg))
+        const compatibleMsg = this.prepareServerMessageForClient(ws, msg);
+        if (!compatibleMsg)
             return;
-        const sessionId = this.extractSessionIdFromServerMessage(msg);
+        const sessionId = this.extractSessionIdFromServerMessage(compatibleMsg);
         if (sessionId) {
             this.recordDebugEvent(sessionId, {
                 direction: "outgoing",
                 channel: "ws",
-                type: String(msg.type ?? "unknown"),
-                detail: this.summarizeOutboundMessage(msg),
+                type: String(compatibleMsg.type ?? "unknown"),
+                detail: this.summarizeOutboundMessage(compatibleMsg),
             });
         }
         if (ws.readyState === WebSocket.OPEN) {
-            ws.send(JSON.stringify(msg));
+            ws.send(JSON.stringify(compatibleMsg));
         }
     }
     /** Broadcast a gallery_new_image message to all connected clients. */