bloby-bot 0.48.2 → 0.49.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.48.2",
+  "version": "0.49.0",
   "releaseNotes": [
     "1. Something great..",
     "2. ",

package/supervisor/app-ws.js

@@ -16,6 +16,25 @@
   var intentionalClose = false;
   var originalFetch = window.fetch;
 
+  // Chat pub/sub state — bot:* / chat:* events forwarded from the supervisor's chat
+  // broadcaster. Listeners are independent of WS lifecycle: when the WS reconnects we
+  // re-send the subscribe message automatically.
+  var chatListeners = [];
+  var chatSubscribed = false;
+  var chatClientId = null;
+
+  function emitChatEvent(eventType, data) {
+    for (var i = 0; i < chatListeners.length; i++) {
+      try { chatListeners[i](eventType, data); } catch (err) { console.error('[app-ws] chat listener error', err); }
+    }
+  }
+
+  function sendChatSubscribe() {
+    if (!ws || ws.readyState !== WebSocket.OPEN) return;
+    ws.send(JSON.stringify({ type: 'chat:subscribe', data: { clientId: chatClientId } }));
+    console.log('[app-ws] chat:subscribe sent clientId=' + chatClientId);
+  }
+
   function buildWsUrl() {
     var proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
     return proto + '//' + location.host + '/app/ws';
@@ -56,6 +75,7 @@
       reconnectDelay = RECONNECT_BASE;
       startHeartbeat();
       console.log('[app-ws] Connected to /app/ws');
+      if (chatSubscribed) sendChatSubscribe();
     };
 
     ws.onmessage = function (e) {
@@ -68,6 +88,16 @@
         return;
       }
 
+      if (msg.type === 'chat:event' && msg.data) {
+        emitChatEvent(msg.data.eventType, msg.data.eventData);
+        return;
+      }
+
+      if (msg.type === 'chat:subscribed') {
+        console.log('[app-ws] chat:subscribed ack clientId=' + (msg.data && msg.data.clientId));
+        return;
+      }
+
       if (msg.type === 'app:api:response' && msg.data && msg.data.id) {
         var pending = pendingRequests[msg.data.id];
         if (pending) {
@@ -194,6 +224,29 @@
     connected: function () {
       return connected;
     },
+    // Subscribe to chat events (bot:typing, bot:token, bot:response, chat:sync, …).
+    // Returns an unsubscribe function. Multiple listeners are supported. The underlying
+    // subscribe message is sent on first listener registration and re-sent on reconnect.
+    onChatEvent: function (handler) {
+      chatListeners.push(handler);
+      if (!chatSubscribed) {
+        chatSubscribed = true;
+        chatClientId =
+          (typeof crypto !== 'undefined' && crypto.randomUUID)
+            ? crypto.randomUUID()
+            : 'ws-' + Math.random().toString(36).slice(2);
+        if (ws && ws.readyState === WebSocket.OPEN) sendChatSubscribe();
+      }
+      return function unsubscribe() {
+        var i = chatListeners.indexOf(handler);
+        if (i >= 0) chatListeners.splice(i, 1);
+      };
+    },
+    // Stable per-tab clientId used to identify this subscriber to the server. Useful
+    // when calling /api/agent/chat/message so the server can skip echoing chat:sync back.
+    clientId: function () {
+      return chatClientId;
+    },
   };
 
   connect();

package/supervisor/index.ts

@@ -441,7 +441,21 @@ export async function startSupervisor() {
       const proxy = http.request(
         { host: '127.0.0.1', port: backendPort, path: backendPath, method: req.method, headers: req.headers },
         (proxyRes) => {
+          const ct = String(proxyRes.headers['content-type'] || '');
+          const isSse = ct.includes('text/event-stream');
+          if (isSse) {
+            console.log(`[app-proxy] SSE upstream status=${proxyRes.statusCode} ct="${ct}" url=${backendPath}`);
+          }
           res.writeHead(proxyRes.statusCode!, proxyRes.headers);
+          if (isSse) {
+            try { res.socket?.setNoDelay(true); } catch {}
+            proxyRes.on('data', (chunk: Buffer) => {
+              console.log(`[app-proxy] SSE chunk bytes=${chunk.length} preview=${JSON.stringify(chunk.toString('utf-8').slice(0, 80))}`);
+            });
+            proxyRes.on('end', () => console.log(`[app-proxy] SSE upstream END`));
+            proxyRes.on('error', (e: any) => console.log(`[app-proxy] SSE upstream ERROR ${e.message}`));
+            res.on('close', () => console.log(`[app-proxy] SSE res CLOSE`));
+          }
           proxyRes.pipe(res);
         },
       );
@@ -1243,25 +1257,33 @@ mint();
       // GET /api/agent/chat/stream — Server-Sent Events, every chat event (bot:*, chat:*)
       if (req.method === 'GET' && agentPath === '/api/agent/chat/stream') {
         const clientId = urlObj.searchParams.get('clientId') || undefined;
+        const subId = crypto.randomBytes(8).toString('hex');
+        console.log(`[sse-handler] OPEN sub=${subId} clientId=${clientId} remote=${req.socket.remoteAddress}`);
+
         res.setHeader('Content-Type', 'text/event-stream');
         res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate');
         res.setHeader('Connection', 'keep-alive');
         res.setHeader('X-Accel-Buffering', 'no');
         res.writeHead(200);
-        res.write(': connected\n\n');
+        try { res.socket?.setNoDelay(true); } catch {}
+        const wrote = res.write(': connected\n\n');
+        console.log(`[sse-handler] wrote initial comment sub=${subId} writeOk=${wrote}`);
 
         const sub: ChatSubscriber = {
-          id: crypto.randomBytes(8).toString('hex'),
+          id: subId,
           clientId,
           send: (type, data) => {
-            if (res.writableEnded) return;
-            res.write(`event: ${type}\ndata: ${JSON.stringify(data)}\n\n`);
+            if (res.writableEnded) {
+              console.log(`[sse-handler] skip write (ended) sub=${subId} type=${type}`);
+              return;
+            }
+            const ok = res.write(`event: ${type}\ndata: ${JSON.stringify(data)}\n\n`);
+            console.log(`[sse-handler] write sub=${subId} type=${type} ok=${ok} bytes=${(type.length + JSON.stringify(data).length + 10)}`);
           },
           close: () => { try { res.end(); } catch {} },
         };
         chatSubscribers.add(sub);
 
-        // Replay current streaming state so a late-joining workspace catches up mid-turn
         if (agentQueryActive && currentStreamConvId) {
           sub.send('chat:state', {
             streaming: true,
@@ -1273,12 +1295,20 @@ mint();
         const keepAlive = setInterval(() => {
           if (res.writableEnded) return;
           res.write(': ping\n\n');
+          console.log(`[sse-handler] ping sub=${subId}`);
         }, 25_000);
 
         req.on('close', () => {
+          console.log(`[sse-handler] CLOSE sub=${subId} reason=req-close`);
           clearInterval(keepAlive);
           chatSubscribers.delete(sub);
         });
+        res.on('close', () => {
+          console.log(`[sse-handler] CLOSE sub=${subId} reason=res-close`);
+        });
+        res.on('error', (err: any) => {
+          console.log(`[sse-handler] ERROR sub=${subId} ${err?.message}`);
+        });
         return;
       }
 
@@ -1630,6 +1660,12 @@ mint();
   appWss.on('connection', (ws) => {
     console.log('[supervisor] App API WS client connected');
 
+    // Per-WS chat subscription: when the client opts in, this WS joins chatSubscribers
+    // and receives every bot:* / chat:* event the dashboard widget does. SSE through the
+    // Cloudflare tunnel buffers chunks; WebSocket frames flow through reliably (same
+    // reason /app/api fetch is routed through this WS to begin with).
+    let chatSub: ChatSubscriber | null = null;
+
     ws.on('message', (raw) => {
       const rawStr = raw.toString();
 
@@ -1645,6 +1681,44 @@ mint();
         return;
       }
 
+      if (msg.type === 'chat:subscribe') {
+        if (chatSub) chatSubscribers.delete(chatSub);
+        const clientId = msg.data?.clientId;
+        const subId = crypto.randomBytes(8).toString('hex');
+        chatSub = {
+          id: subId,
+          clientId,
+          send: (type, data) => {
+            if (ws.readyState !== WebSocket.OPEN) return;
+            ws.send(JSON.stringify({ type: 'chat:event', data: { eventType: type, eventData: data } }));
+          },
+          close: () => {},
+        };
+        chatSubscribers.add(chatSub);
+        console.log(`[app-ws-chat] subscribe sub=${subId} clientId=${clientId} total=${chatSubscribers.size}`);
+
+        if (agentQueryActive && currentStreamConvId) {
+          chatSub.send('chat:state', {
+            streaming: true,
+            conversationId: currentStreamConvId,
+            buffer: currentStreamBuffer,
+          });
+        }
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: 'chat:subscribed', data: { clientId, subId } }));
+        }
+        return;
+      }
+
+      if (msg.type === 'chat:unsubscribe') {
+        if (chatSub) {
+          chatSubscribers.delete(chatSub);
+          console.log(`[app-ws-chat] unsubscribe sub=${chatSub.id} total=${chatSubscribers.size}`);
+          chatSub = null;
+        }
+        return;
+      }
+
       if (msg.type !== 'app:api' || !msg.data) return;
 
       const { id, method, path: reqPath, headers: reqHeaders, body } = msg.data;
@@ -1708,6 +1782,11 @@ mint();
     });
 
     ws.on('close', () => {
+      if (chatSub) {
+        chatSubscribers.delete(chatSub);
+        console.log(`[app-ws-chat] auto-unsubscribe on close sub=${chatSub.id} total=${chatSubscribers.size}`);
+        chatSub = null;
+      }
       console.log('[supervisor] App API WS client disconnected');
     });
   });
@@ -1716,11 +1795,18 @@ mint();
    *  subscribers. The workspace mirror sees the exact same event stream the widget does. */
   function broadcastBloby(type: string, data: any = {}) {
     const msg = JSON.stringify({ type, data });
+    let wsCount = 0;
     for (const client of blobyWss.clients) {
-      if (client.readyState === WebSocket.OPEN) client.send(msg);
+      if (client.readyState === WebSocket.OPEN) { client.send(msg); wsCount++; }
     }
+    let sseCount = 0;
     for (const sub of chatSubscribers) {
-      try { sub.send(type, data); } catch {}
+      try { sub.send(type, data); sseCount++; } catch (e: any) {
+        console.log(`[sse-broadcast] send failed sub=${sub.id}: ${e.message}`);
+      }
+    }
+    if (type.startsWith('bot:') || type.startsWith('chat:')) {
+      console.log(`[sse-broadcast] type=${type} ws=${wsCount} sse=${sseCount} subs=${chatSubscribers.size}`);
     }
   }