nothumanallowed 10.4.0 → 10.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "10.4.0",
+  "version": "10.6.0",
   "description": "NotHumanAllowed — 38 AI agents, 53 tools. Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, GitHub, Notion, Slack, voice chat, 28 languages. Zero-dependency CLI.",
   "type": "module",
   "bin": {

package/src/commands/ui.mjs

@@ -395,7 +395,20 @@ export async function cmdUI(args) {
             method: 'POST', headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({ senderFingerprint: identity.fingerprint, nonce: nonce.toString('base64'), ciphertext, type: 'text' }),
           });
-          sendJSON(res, 200, await r.json());
+          const result = await r.json();
+          // Broadcast own message via WS immediately (so other tabs/views see it)
+          wsBroadcast({
+            type: 'collab_message',
+            channelId: body.channelId,
+            message: {
+              senderName: identity.displayName || 'You',
+              senderFingerprint: identity.fingerprint,
+              content: body.message,
+              timestamp: result.timestamp || new Date().toISOString(),
+              type: 'text',
+            },
+          });
+          sendJSON(res, 200, result);
           logRequest(method, pathname, 200, Date.now() - start);
           return;
         }
@@ -2050,16 +2063,26 @@ export async function cmdUI(args) {
 
   const server = http.createServer(handleRequest);
 
-  // ── WebSocket server (ws package) — relay daemon events to browser ──
+  // ── WebSocket server — daemon relay + Alexandria real-time ──────────
+  let wsBroadcast = (msg) => {}; // no-op until WS is ready
   try {
-    const { WebSocketServer } = await import('ws');
+    const { WebSocketServer, WebSocket: WsClient } = await import('ws');
     const wss = new WebSocketServer({ server });
+    const wsClients = new Set();
+
+    wsBroadcast = (msg) => {
+      const data = JSON.stringify(msg);
+      for (const ws of wsClients) {
+        if (ws.readyState === 1) try { ws.send(data); } catch {}
+      }
+    };
 
     wss.on('connection', (browserWs) => {
+      wsClients.add(browserWs);
+
       // Connect to daemon WS on port 3848 and relay messages
       let daemonWs = null;
       try {
-        const { WebSocket: WsClient } = require('ws');
         daemonWs = new WsClient('ws://127.0.0.1:3848');
         daemonWs.on('message', (data) => {
           if (browserWs.readyState === 1) browserWs.send(data.toString());
@@ -2068,11 +2091,85 @@ export async function cmdUI(args) {
         daemonWs.on('close', () => { daemonWs = null; });
       } catch {}
 
-      browserWs.on('close', () => { if (daemonWs) try { daemonWs.close(); } catch {} });
-      browserWs.on('error', () => { if (daemonWs) try { daemonWs.close(); } catch {} });
+      browserWs.on('close', () => { wsClients.delete(browserWs); if (daemonWs) try { daemonWs.close(); } catch {} });
+      browserWs.on('error', () => { wsClients.delete(browserWs); if (daemonWs) try { daemonWs.close(); } catch {} });
     });
+
+    // ── Alexandria real-time — connect to server WS for each channel ──────
+    const collabDir = path.join(NHA_DIR, 'collab');
+    const alexWsConnections = new Map(); // channelId → ws
+
+    function connectAlexandriaWs(channelId, channelName) {
+      if (alexWsConnections.has(channelId)) return;
+      try {
+        const { WebSocket: WsClient } = require('ws');
+        const wsUrl = 'wss://nothumanallowed.com/ws/alexandria/' + channelId;
+        const alexWs = new WsClient(wsUrl);
+
+        alexWs.on('open', () => {
+          alexWsConnections.set(channelId, alexWs);
+        });
+
+        alexWs.on('message', (data) => {
+          try {
+            const msg = JSON.parse(data.toString());
+            if (msg.type === 'new_message' && msg.message) {
+              // Decrypt the message
+              const channelKey = crypto.createHash('sha256').update('alexandria-channel-key-v1').update(channelId).digest();
+              let content = '[encrypted]';
+              try {
+                const nonce = Buffer.from(msg.message.nonce, 'base64');
+                const raw = Buffer.from(msg.message.ciphertext, 'base64');
+                const tag = raw.subarray(raw.length - 16);
+                const encrypted = raw.subarray(0, raw.length - 16);
+                const decipher = crypto.createDecipheriv('aes-256-gcm', channelKey, nonce);
+                decipher.setAuthTag(tag);
+                content = decipher.update(encrypted) + decipher.final('utf-8');
+              } catch {}
+
+              // Push to browser via local WS
+              wsBroadcast({
+                type: 'collab_message',
+                channelId,
+                channelName,
+                message: {
+                  senderName: msg.message.senderName || msg.message.senderFingerprint?.slice(0, 8) || 'Unknown',
+                  senderFingerprint: msg.message.senderFingerprint,
+                  content,
+                  timestamp: msg.message.timestamp,
+                  type: msg.message.type,
+                },
+              });
+            }
+          } catch {}
+        });
+
+        alexWs.on('close', () => {
+          alexWsConnections.delete(channelId);
+          // Reconnect after 5s
+          setTimeout(() => connectAlexandriaWs(channelId, channelName), 5000);
+        });
+        alexWs.on('error', () => {
+          alexWsConnections.delete(channelId);
+        });
+      } catch {}
+    }
+
+    // Connect to all channels on startup
+    setTimeout(() => {
+      try {
+        const chFile = path.join(collabDir, 'channels.json');
+        if (fs.existsSync(chFile)) {
+          const channels = JSON.parse(fs.readFileSync(chFile, 'utf-8'));
+          for (const ch of channels) {
+            connectAlexandriaWs(ch.id, ch.name);
+          }
+        }
+      } catch {}
+    }, 2000);
+
   } catch {
-    // ws package not available — live updates disabled, everything else works
+    // ws package not available — live updates disabled
   }
 
   server.on('error', (err) => {

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '10.4.0';
+export const VERSION = '10.6.0';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/services/web-ui.mjs

@@ -1600,42 +1600,12 @@ var collabLastMessageCount=0;
 var collabUnreadCount=0;
 var collabGlobalPolling=null;
 
-// Global polling — check for new messages across ALL channels every 3s (even when not on Collab tab)
+// No client-side polling needed — server pushes via WebSocket
 function startCollabGlobalPolling(){
-  if(collabGlobalPolling)return;
-  // Load channels first
+  // Just load channels list once
   apiGet('/api/collab/channels').then(function(r){
     if(r&&r.channels)collabChannels=r.channels;
   }).catch(function(){});
-  collabGlobalPolling=setInterval(function(){
-    if(collabChannels.length===0)return;
-    // Check each channel for new messages
-    for(var i=0;i<collabChannels.length;i++){
-      (function(ch){
-        apiGet('/api/collab/messages?channelId='+ch.id).then(function(r){
-          if(!r||!r.messages)return;
-          var prevCount=ch._lastCount||0;
-          var newCount=r.messages.length;
-          if(newCount>prevCount&&prevCount>0){
-            var diff=newCount-prevCount;
-            collabUnreadCount+=diff;
-            updateCollabBadge();
-            // Show toast notification
-            var lastMsg=r.messages[r.messages.length-1];
-            if(lastMsg&&currentView!=='collab'){
-              showToast('collab','AgentMessenger','New message in '+ch.name+': '+(lastMsg.content||'[encrypted]').slice(0,80),5000);
-            }
-            // Update messages if viewing this channel
-            if(collabActiveChannel===ch.id&&currentView==='collab'){
-              collabMessages=r.messages;
-              renderCollabMessages();
-            }
-          }
-          ch._lastCount=newCount;
-        }).catch(function(){});
-      })(collabChannels[i]);
-    }
-  },3000);
 }
 
 function updateCollabBadge(){
@@ -2209,6 +2179,27 @@ function handleDaemonEvent(msg) {
       showToast('plan', 'Daily Plan Ready', 'Your plan for ' + msg.data.date + ' has been generated.', 10000);
       if (currentView === 'plan') renderPlan(document.getElementById('content'));
       break;
+
+    case 'collab_message':
+      // Real-time Alexandria message via WebSocket
+      var cm = msg.message;
+      if (cm) {
+        // Add to messages if viewing this channel
+        if (currentView === 'collab' && collabActiveChannel === msg.channelId) {
+          // Avoid duplicates
+          var isDup = collabMessages.some(function(m) { return m.timestamp === cm.timestamp && m.content === cm.content; });
+          if (!isDup) {
+            collabMessages.push({senderName: cm.senderName, timestamp: cm.timestamp, content: cm.content, type: cm.type});
+            renderCollabMessages();
+          }
+        } else {
+          // Not viewing this channel — show badge + toast
+          collabUnreadCount++;
+          updateCollabBadge();
+          showToast('collab', 'AgentMessenger', cm.senderName + ': ' + (cm.content || '').slice(0, 100), 5000);
+        }
+      }
+      break;
   }
 }