@mulmobridge/chat-service 1.0.3 → 1.2.0

package/dist/index.d.ts

@@ -14,6 +14,13 @@ export interface ChatService {
      *  before `attachSocket`: the message is queued and flushes on
      *  the next bridge connection for that transport. */
     pushToBridge: PushFn;
+    /** Subscribe an IN-PROCESS bridge to this transport's pushes (#3080).
+     *  Returns the unsubscribe function. An in-process bridge is always live, so
+     *  its pushes are never queued. */
+    registerInProcessBridge(transportId: string, handler: (event: {
+        chatId: string;
+        message: string;
+    }) => void): () => void;
 }
 export declare function createChatService(deps: ChatServiceDeps): ChatService;
 export type { Attachment, ChatServiceDeps, StartChatFn, StartChatParams, OnSessionEventFn } from "./types.js";

package/dist/index.js

@@ -60,7 +60,42 @@ export function createChatService(deps) {
     // The queue is shared with the socket layer so any pushes
     // enqueued during the pre-attach window flush on first connect.
     let livePush = null;
+    // In-process bridges (#3080). Keyed by transportId, at most one each: two
+    // bridges claiming one transportId is what #3079 exists to stop, and the
+    // registry refuses the second rather than silently fanning a reply out twice.
+    const inProcessBridges = new Map();
+    const registerInProcessBridge = (transportId, handler) => {
+        if (inProcessBridges.has(transportId)) {
+            throw new Error(`an in-process bridge is already registered for transport "${transportId}"`);
+        }
+        inProcessBridges.set(transportId, handler);
+        return () => {
+            if (inProcessBridges.get(transportId) === handler)
+                inProcessBridges.delete(transportId);
+        };
+    };
     const pushToBridge = (transportId, chatId, message) => {
+        // An in-process bridge is in this very process, so it is live by
+        // construction — deliver and return rather than consulting the socket
+        // layer, whose miss path would queue a message that has been delivered.
+        const inProcess = inProcessBridges.get(transportId);
+        if (inProcess) {
+            try {
+                // Runs on WHATEVER stack called `pushToBridge` — a route handler, a
+                // scheduler tick. A socket bridge cannot reach us here because its
+                // handler runs in its own process; an in-process one can, so the
+                // isolation has to be written rather than assumed.
+                inProcess({ chatId, message });
+            }
+            catch (err) {
+                logger.error("chat-service", "in-process bridge push handler threw", {
+                    transportId,
+                    chatId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+            return;
+        }
         if (livePush) {
             livePush(transportId, chatId, message);
             return;
@@ -152,6 +187,7 @@ export function createChatService(deps) {
             livePush = handle.pushToBridge;
         },
         pushToBridge,
+        registerInProcessBridge,
     };
 }
 export { writeFileAtomic } from "./atomic-write.js";

package/dist/socket.js

@@ -45,6 +45,15 @@ export const CHAT_SOCKET_EVENTS = {
     /** server → bridge streaming text chunk (Phase C of #268). */
     textChunk: "textChunk",
 };
+// Hard limits to prevent oversized payloads from bridges (DoS /
+// accidental misconfiguration). Express's JSON body limit (50 MB)
+// is the outer gate; these are tighter, attachment-specific caps.
+const MAX_ATTACHMENT_COUNT = 10;
+const MAX_ATTACHMENT_TOTAL_BYTES = 20 * 1024 * 1024; // 20 MB base64
+/** Transport ceiling for one socket frame. Headroom over the attachment
+ *  budget for the rest of the payload (text, ids, options) so the
+ *  application-level cap is what a bridge actually hits. */
+const MAX_SOCKET_PAYLOAD_BYTES = MAX_ATTACHMENT_TOTAL_BYTES + 4 * 1024 * 1024;
 export function bridgeRoom(transportId) {
     return `bridge:${transportId}`;
 }
@@ -55,6 +64,12 @@ export function attachChatSocket(server, deps) {
         // Loopback-only deployment; skip long-polling negotiation for
         // the same reason `/ws/pubsub` does (#311).
         transports: ["websocket"],
+        // Socket.IO's default is 1 MB — below the attachment budget
+        // `parseAttachments` enforces, so a bridge shipping a 900 KB image
+        // had its connection closed before the ack instead of a reply.
+        // `parseAttachments` stays the real gate; this only has to be
+        // wide enough not to pre-empt it.
+        maxHttpBufferSize: MAX_SOCKET_PAYLOAD_BYTES,
     });
     io.use((socket, next) => {
         const result = validateHandshake(socket.handshake.auth, tokenProvider);
@@ -232,11 +247,6 @@ function parseMessagePayload(payload) {
     const attachments = parseAttachments(payload.attachments);
     return { ok: true, externalChatId, text, attachments };
 }
-// Hard limits to prevent oversized payloads from bridges (DoS /
-// accidental misconfiguration). Express's JSON body limit (50 MB)
-// is the outer gate; these are tighter, attachment-specific caps.
-const MAX_ATTACHMENT_COUNT = 10;
-const MAX_ATTACHMENT_TOTAL_BYTES = 20 * 1024 * 1024; // 20 MB base64
 export function parseAttachments(raw) {
     if (!Array.isArray(raw) || raw.length === 0)
         return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mulmobridge/chat-service",
-  "version": "1.0.3",
+  "version": "1.2.0",
   "description": "Server-side chat service for MulmoBridge — socket.io + REST bridge to Claude Code agents",
   "type": "module",
   "main": "./dist/index.js",