bloby-bot 0.48.3 → 0.49.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.48.3",
+  "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

@@ -1660,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();
 
@@ -1675,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;
@@ -1738,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');
     });
   });