neoagent 2.3.1-beta.99 → 2.4.1-beta.10

package/server/services/websocket.js

@@ -35,6 +35,8 @@ const EVENT_RATE_LIMITS = Object.freeze({
   'integrations:status': { windowMs: 10 * 1000, max: 20 },
   'memory:read': { windowMs: 10 * 1000, max: 20 },
   'memory:search': { windowMs: 10 * 1000, max: 20 },
+  'stream:subscribe': { windowMs: 10 * 1000, max: 40 },
+  'stream:unsubscribe': { windowMs: 10 * 1000, max: 40 },
 });
 
 function asObject(value) {
@@ -54,6 +56,19 @@ function toBoundedInt(value, fallback, min, max) {
   return Math.min(max, Math.max(min, Math.floor(parsed)));
 }
 
+function normalizeStreamPayload(raw) {
+  const data = asObject(raw);
+  const platform = toOptionalString(data?.platform, 32).toLowerCase() || 'desktop';
+  if (!['desktop', 'android', 'browser'].includes(platform)) {
+    throw new Error('platform must be desktop, android, or browser.');
+  }
+  const deviceId = toOptionalString(data?.deviceId || data?.device_id, 256);
+  return {
+    platform,
+    deviceId: deviceId || (platform === 'browser' ? 'browser' : ''),
+  };
+}
+
 function resolveAgentFromPayload(userId, value) {
   const data = asObject(value);
   return resolveAgentId(userId, data?.agentId || data?.agent_id || null);
@@ -831,9 +846,67 @@ function setupWebSocket(io, services) {
       }
     });
 
+    // ── Remote Control Streams ──
+
+    socket.on('stream:subscribe', (raw) => {
+      const limit = allowEvent('stream:subscribe');
+      if (!limit.allowed) {
+        recordRateLimitHit(rateLimitObserver, userId, socket.id, 'stream:subscribe', limit.retryAfterMs);
+        return socket.emit('stream:error', {
+          error: `Rate limit exceeded for stream:subscribe. Retry in ${Math.ceil(limit.retryAfterMs / 1000)}s.`,
+        });
+      }
+      try {
+        const streamHub = services.streamHub || services.app?.locals?.streamHub;
+        if (!streamHub) throw new Error('Stream hub is unavailable.');
+        const data = normalizeStreamPayload(raw);
+        if (!data.deviceId) throw new Error('deviceId is required.');
+        const subscriberCount = streamHub.subscribe(userId, data.deviceId, data.platform, socket.id);
+        socket.emit('stream:subscribed', {
+          platform: data.platform,
+          deviceId: data.deviceId,
+          subscriberCount,
+        });
+      } catch (err) {
+        console.error(`[WS] stream:subscribe failed for user ${userId}:`, err);
+        socket.emit('stream:error', { error: sanitizeError(err) });
+      }
+    });
+
+    socket.on('stream:unsubscribe', async (raw) => {
+      const limit = allowEvent('stream:unsubscribe');
+      if (!limit.allowed) {
+        recordRateLimitHit(rateLimitObserver, userId, socket.id, 'stream:unsubscribe', limit.retryAfterMs);
+        return socket.emit('stream:error', {
+          error: `Rate limit exceeded for stream:unsubscribe. Retry in ${Math.ceil(limit.retryAfterMs / 1000)}s.`,
+        });
+      }
+      try {
+        const streamHub = services.streamHub || services.app?.locals?.streamHub;
+        if (!streamHub) throw new Error('Stream hub is unavailable.');
+        const data = normalizeStreamPayload(raw);
+        if (!data.deviceId) throw new Error('deviceId is required.');
+        const subscriberCount = await streamHub.unsubscribe(userId, data.platform, data.deviceId, socket.id);
+        socket.emit('stream:unsubscribed', {
+          platform: data.platform,
+          deviceId: data.deviceId,
+          subscriberCount,
+        });
+      } catch (err) {
+        console.error(`[WS] stream:unsubscribe failed for user ${userId}:`, err);
+        socket.emit('stream:error', { error: sanitizeError(err) });
+      }
+    });
+
     // ── Disconnect ──
 
     socket.on('disconnect', () => {
+      const streamHub = services.streamHub || services.app?.locals?.streamHub;
+      if (streamHub && typeof streamHub.unsubscribeAll === 'function') {
+        void streamHub.unsubscribeAll(socket.id).catch((err) => {
+          console.error(`[WS] Failed to unsubscribe streams for socket ${socket.id}:`, err);
+        });
+      }
       if (!voiceRuntimeManager || typeof voiceRuntimeManager.closeSession !== 'function') {
         socket.data.voiceSessionIds?.clear?.();
         console.log(`[WS] User ${userId} disconnected (${socket.id})`);

package/server/services/widgets/focus_widget.js

@@ -52,6 +52,18 @@ function buildAssistantFocusSnapshot(memoryManager, userId, agentId) {
   ).all(userId, scopedAgentId);
   const conversations = memoryManager?.getRecentConversations?.(userId, 4, { agentId: scopedAgentId }) || [];
   const memories = memoryManager?.listMemories?.(userId, { limit: 6, agentId: scopedAgentId }) || [];
+  const recentKnowledgeChanges = memoryManager?.listRecentKnowledgeChanges?.(userId, {
+    agentId: scopedAgentId,
+    limit: 5,
+  }) || [];
+  const knowledgeViews = memoryManager?.listKnowledgeViews?.(userId, {
+    agentId: scopedAgentId,
+    limit: 4,
+  }) || [];
+  const ingestionOverview = memoryManager?.getIngestionOverview?.(userId, {
+    agentId: scopedAgentId,
+    limit: 8,
+  }) || [];
 
   const activeThreads = conversations.slice(0, 3).map((conversation) => ({
     title: safeTrim(conversation.title, 80),
@@ -75,6 +87,24 @@ function buildAssistantFocusSnapshot(memoryManager, userId, agentId) {
     value: safeTrim(run.status || 'unknown', 32),
   }));
   const rememberedContext = memories.slice(0, 2).map((memory) => safeTrim(memory.content, 140));
+  const backgroundAwareness = {
+    summary: safeTrim(
+      recentKnowledgeChanges[0]?.summary
+      || recentKnowledgeChanges[0]?.title
+      || knowledgeViews[0]?.summary
+      || '',
+      180,
+    ),
+    changedCount: recentKnowledgeChanges.length,
+    lastChangedAt: recentKnowledgeChanges[0]?.updatedAt || null,
+  };
+  const syncHealth = ingestionOverview.slice(0, 3).map((source) => ({
+    label: safeTrim(source.providerKey || source.sourceTypes?.[0] || 'Background context', 80),
+    value: safeTrim(source.status || 'ready', 32),
+    lastRefreshAt: source.lastRefreshAt || null,
+    nextRefreshAt: source.nextRefreshAt || null,
+    documentCount: Number(source.documentCount || 0),
+  }));
 
   const currentFocus = safeTrim(
     selfState.focus?.currentFocus
@@ -90,6 +120,10 @@ function buildAssistantFocusSnapshot(memoryManager, userId, agentId) {
     nearTermPriorities,
     recentSignals,
     rememberedContext,
+    recentKnowledgeChanges,
+    knowledgeViews,
+    backgroundAwareness,
+    syncHealth,
     assistantIdentity: {
       name: safeTrim(selfState.identity?.displayName, 80),
       style: safeTrim(selfState.identity?.style, 120),
@@ -99,11 +133,15 @@ function buildAssistantFocusSnapshot(memoryManager, userId, agentId) {
 }
 
 function buildAssistantFocusWidgetPayload(snapshot) {
+  const knowledgeChangeCount = Number(snapshot.backgroundAwareness?.changedCount || 0);
+  const primaryMetric = knowledgeChangeCount > 0 ? knowledgeChangeCount : snapshot.activeThreads.length;
   const rows = [
     ...snapshot.nearTermPriorities,
     ...snapshot.recentSignals,
+    ...snapshot.syncHealth,
   ].slice(0, 3);
   const chips = [
+    ...snapshot.recentKnowledgeChanges.map((item) => item.title),
     ...snapshot.activeThreads.map((item) => item.title),
     ...snapshot.rememberedContext,
   ].filter(Boolean).slice(0, 3);
@@ -113,14 +151,17 @@ function buildAssistantFocusWidgetPayload(snapshot) {
     kicker: 'Assistant state',
     subtitle: snapshot.currentFocus,
     body: snapshot.activeThreads[0]?.preview
+      || snapshot.backgroundAwareness?.summary
       || snapshot.rememberedContext[0]
       || 'Watching recent conversations, tasks, and runs.',
-    metric: String(snapshot.activeThreads.length),
-    metricLabel: snapshot.activeThreads.length === 1 ? 'active thread' : 'active threads',
+    metric: String(primaryMetric),
+    metricLabel: knowledgeChangeCount > 0
+      ? (knowledgeChangeCount === 1 ? 'knowledge change' : 'knowledge changes')
+      : (snapshot.activeThreads.length === 1 ? 'active thread' : 'active threads'),
     secondaryMetric: String(snapshot.nearTermPriorities.length),
     secondaryLabel: 'priorities',
-    tertiaryMetric: formatRelativeTimestamp(snapshot.generatedAt),
-    tertiaryLabel: 'updated',
+    tertiaryMetric: formatRelativeTimestamp(snapshot.backgroundAwareness?.lastChangedAt || snapshot.generatedAt),
+    tertiaryLabel: snapshot.backgroundAwareness?.lastChangedAt ? 'last change' : 'updated',
     rows,
     chips,
     iconToken: 'focus',