@ccpocket/bridge 1.43.1 → 1.44.1

package/dist/websocket.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { execFile, execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { lstat, readFile, readlink, stat, unlink } from "node:fs/promises";
@@ -178,6 +179,7 @@ export class BridgeWebSocketServer {
     failSetPermissionMode = envFlagEnabled("BRIDGE_FAIL_SET_PERMISSION_MODE");
     failSetSandboxMode = envFlagEnabled("BRIDGE_FAIL_SET_SANDBOX_MODE");
     platform;
+    clientSupportedServerMessages = new WeakMap();
     constructor(options) {
         const { server, apiKey, allowedDirs, imageStore, galleryStore, projectHistory, debugTraceStore, recordingStore, firebaseAuth, promptHistoryBackup, platform, } = options;
         this.apiKey = apiKey ?? null;
@@ -477,6 +479,10 @@ export class BridgeWebSocketServer {
         });
     }
     async handleClientMessage(msg, ws) {
+        if (msg.type === "client_capabilities") {
+            this.clientSupportedServerMessages.set(ws, new Set(msg.supportedServerMessages ?? []));
+            return;
+        }
         const incomingSessionId = this.extractSessionIdFromClientMessage(msg);
         const isActiveRuntimeSession = incomingSessionId != null &&
             this.sessionManager.get(incomingSessionId) != null;
@@ -667,16 +673,8 @@ export class BridgeWebSocketServer {
                     return;
                 }
                 const text = msg.text;
-                // Codex: reject if the process is not waiting for input (turn-based, no internal queue)
-                if (session.provider === "codex" &&
-                    !session.process.isWaitingForInput) {
-                    this.send(ws, {
-                        type: "input_rejected",
-                        sessionId: session.id,
-                        reason: "Process is busy",
-                    });
-                    break;
-                }
+                const codexSkills = msg.skills ?? (msg.skill ? [msg.skill] : []);
+                const codexMentions = msg.mentions ?? [];
                 // Snapshot busy state before dispatch. We prefer the actual enqueue
                 // result returned by SdkProcess sendInput* below, but keep this as a
                 // fallback for test doubles and async paths.
@@ -709,6 +707,50 @@ export class BridgeWebSocketServer {
                     if (imageRefs.length === 0)
                         imageRefs = undefined;
                 }
+                if (session.provider === "codex" &&
+                    !session.process.isWaitingForInput) {
+                    if (session.codexQueuedInput) {
+                        this.send(ws, {
+                            type: "input_rejected",
+                            sessionId: session.id,
+                            reason: "Queue is full",
+                        });
+                        break;
+                    }
+                    const queued = this.sessionManager.queueCodexInput(session.id, {
+                        itemId: randomUUID(),
+                        text,
+                        createdAt: new Date().toISOString(),
+                        ...(images.length > 0 ? { imageCount: images.length, images } : {}),
+                        ...(imageRefs ? { imageRefs } : {}),
+                        ...(codexSkills.length > 0 ? { skills: codexSkills } : {}),
+                        ...(codexMentions.length > 0 ? { mentions: codexMentions } : {}),
+                    });
+                    if (!queued) {
+                        this.send(ws, {
+                            type: "input_rejected",
+                            sessionId: session.id,
+                            reason: "Queue is full",
+                        });
+                        break;
+                    }
+                    if (images.length > 0 && this.galleryStore && session.projectPath) {
+                        for (const img of images) {
+                            this.galleryStore
+                                .addImageFromBase64(img.base64, img.mimeType, session.projectPath, msg.sessionId)
+                                .catch((err) => {
+                                console.warn(`[ws] Failed to persist queued image to gallery: ${err}`);
+                            });
+                        }
+                    }
+                    this.send(ws, {
+                        type: "input_ack",
+                        sessionId: session.id,
+                        queued: true,
+                    });
+                    this.broadcastSessionList();
+                    break;
+                }
                 session.history.push({
                     type: "user_input",
                     text,
@@ -734,13 +776,11 @@ export class BridgeWebSocketServer {
                         queued: false,
                     });
                     const codexProc = session.process;
-                    const skills = msg.skills ?? (msg.skill ? [msg.skill] : []);
-                    const mentions = msg.mentions ?? [];
                     if (images.length > 0) {
                         codexProc.sendInputStructured(text, {
                             images,
-                            skills,
-                            mentions,
+                            skills: codexSkills,
+                            mentions: codexMentions,
                         });
                     }
                     else if (msg.imageId && this.galleryStore) {
@@ -750,22 +790,31 @@ export class BridgeWebSocketServer {
                             if (imageData) {
                                 codexProc.sendInputStructured(text, {
                                     images: [imageData],
-                                    skills,
-                                    mentions,
+                                    skills: codexSkills,
+                                    mentions: codexMentions,
                                 });
                             }
                             else {
                                 console.warn(`[ws] Image not found: ${msg.imageId}`);
-                                codexProc.sendInputStructured(text, { skills, mentions });
+                                codexProc.sendInputStructured(text, {
+                                    skills: codexSkills,
+                                    mentions: codexMentions,
+                                });
                             }
                         })
                             .catch((err) => {
                             console.error(`[ws] Failed to load image: ${err}`);
-                            codexProc.sendInputStructured(text, { skills, mentions });
+                            codexProc.sendInputStructured(text, {
+                                skills: codexSkills,
+                                mentions: codexMentions,
+                            });
                         });
                     }
-                    else if (skills.length > 0 || mentions.length > 0) {
-                        codexProc.sendInputStructured(text, { skills, mentions });
+                    else if (codexSkills.length > 0 || codexMentions.length > 0) {
+                        codexProc.sendInputStructured(text, {
+                            skills: codexSkills,
+                            mentions: codexMentions,
+                        });
                     }
                     else {
                         codexProc.sendInput(text);
@@ -841,6 +890,69 @@ export class BridgeWebSocketServer {
                 }
                 break;
             }
+            case "update_queued_input": {
+                const session = this.resolveSession(msg.sessionId);
+                if (!session || session.provider !== "codex") {
+                    this.send(ws, { type: "error", message: "No active Codex session." });
+                    return;
+                }
+                if (!msg.text.trim()) {
+                    this.send(ws, {
+                        type: "error",
+                        message: "Queued message cannot be empty.",
+                    });
+                    return;
+                }
+                const success = this.sessionManager.updateCodexQueuedInput(session.id, msg.itemId, msg.text, { skills: msg.skills ?? [], mentions: msg.mentions ?? [] });
+                if (!success) {
+                    this.send(ws, {
+                        type: "error",
+                        message: "Queued message not found.",
+                        errorCode: "queued_input_not_found",
+                    });
+                    return;
+                }
+                this.broadcastSessionList();
+                break;
+            }
+            case "cancel_queued_input": {
+                const session = this.resolveSession(msg.sessionId);
+                if (!session || session.provider !== "codex") {
+                    this.send(ws, { type: "error", message: "No active Codex session." });
+                    return;
+                }
+                const success = this.sessionManager.cancelCodexQueuedInput(session.id, msg.itemId);
+                if (!success) {
+                    this.send(ws, {
+                        type: "error",
+                        message: "Queued message not found.",
+                        errorCode: "queued_input_not_found",
+                    });
+                    return;
+                }
+                this.broadcastSessionList();
+                break;
+            }
+            case "steer_queued_input": {
+                const session = this.resolveSession(msg.sessionId);
+                if (!session || session.provider !== "codex") {
+                    this.send(ws, { type: "error", message: "No active Codex session." });
+                    return;
+                }
+                const result = await this.sessionManager.steerCodexQueuedInput(session.id, msg.itemId);
+                if (!result.ok) {
+                    this.send(ws, {
+                        type: "error",
+                        message: result.error,
+                        errorCode: result.error === "Queued message not found."
+                            ? "queued_input_not_found"
+                            : "queued_input_steer_failed",
+                    });
+                    return;
+                }
+                this.broadcastSessionList();
+                break;
+            }
             case "push_register": {
                 const locale = normalizePushLocale(msg.locale);
                 const privacyMode = msg.privacyMode === true;
@@ -1478,6 +1590,31 @@ export class BridgeWebSocketServer {
                         status: session.status,
                         sessionId: msg.sessionId,
                     });
+                    if (session.provider === "codex") {
+                        const item = session.codexQueuedInput;
+                        this.sendConversationQueue(ws, {
+                            type: "conversation_queue",
+                            sessionId: msg.sessionId,
+                            limit: 1,
+                            items: item
+                                ? [
+                                    {
+                                        itemId: item.itemId,
+                                        text: item.text,
+                                        createdAt: item.createdAt,
+                                        ...(item.updatedAt ? { updatedAt: item.updatedAt } : {}),
+                                        ...(item.imageCount
+                                            ? { imageCount: item.imageCount }
+                                            : {}),
+                                        ...(item.skills?.length ? { skills: item.skills } : {}),
+                                        ...(item.mentions?.length
+                                            ? { mentions: item.mentions }
+                                            : {}),
+                                    },
+                                ]
+                                : [],
+                        });
+                    }
                     // Send cached slash commands so the client can restore them even when
                     // the original init/supported_commands message was evicted from the
                     // in-memory history (MAX_HISTORY_PER_SESSION overflow).
@@ -3049,6 +3186,8 @@ export class BridgeWebSocketServer {
         const data = JSON.stringify({ ...msg, sessionId });
         for (const client of this.wss.clients) {
             if (client.readyState === WebSocket.OPEN) {
+                if (!this.shouldSendToClient(client, msg))
+                    continue;
                 client.send(data);
             }
         }
@@ -3371,11 +3510,27 @@ export class BridgeWebSocketServer {
         const data = JSON.stringify(msg);
         for (const client of this.wss.clients) {
             if (client.readyState === WebSocket.OPEN) {
+                if (!this.shouldSendToClient(client, msg))
+                    continue;
                 client.send(data);
             }
         }
     }
+    shouldSendToClient(ws, msg) {
+        if (msg.type !== "conversation_queue")
+            return true;
+        return (this.clientSupportedServerMessages
+            .get(ws)
+            ?.has("conversation_queue") ?? false);
+    }
+    sendConversationQueue(ws, msg) {
+        if (!this.shouldSendToClient(ws, msg))
+            return;
+        this.send(ws, msg);
+    }
     send(ws, msg) {
+        if (!this.shouldSendToClient(ws, msg))
+            return;
         const sessionId = this.extractSessionIdFromServerMessage(msg);
         if (sessionId) {
             this.recordDebugEvent(sessionId, {