@mooncompany/uplink-chat 0.5.0

package/server/websocket/routing.js

@@ -0,0 +1,277 @@
+/**
+ * WebSocket Routing Module
+ * Message type dispatch, chat handler, abort handling
+ */
+
+import { log } from '../utils.js';
+import { sendMessage } from '../channel.js';
+import { SESSION_USER, WEBSOCKET } from '../config.js';
+import { validateSetUser, isAuthEnabled } from '../middleware/auth.js';
+import {
+  wsClients,
+  activeStreamingRequests,
+  safeSend,
+  trimStreamingRequests,
+  WS_CONNECTION_LIMITS,
+} from './connections.js';
+import {
+  generateMessageId,
+  broadcastSyncMessage,
+  broadcastSyncThinking,
+  broadcastSyncTool,
+  sendToClient,
+} from './broadcast.js';
+import {
+  broadcastSyncDelta,
+  cleanupSyncDeltaThrottle,
+} from './sync.js';
+
+// ============================================
+// Chat Handler
+// ============================================
+
+async function handleWebSocketChat(clientId, payload, requestHelpers, saveMessageToSync) {
+  const client = wsClients.get(clientId);
+  if (!client) return;
+
+  const { message, mode = 'text', requestId } = payload;
+  const { canAcceptRequest, startRequest, endRequest, textToSpeech } = requestHelpers;
+
+  if (!message) {
+    safeSend(client.ws, {
+      type: 'error',
+      requestId,
+      error: 'No message provided'
+    });
+    return;
+  }
+
+  if (!canAcceptRequest()) {
+    safeSend(client.ws, {
+      type: 'error',
+      requestId,
+      error: 'Server busy. Please wait a moment.'
+    });
+    return;
+  }
+
+  const trackingId = startRequest('ws-chat');
+  const startTime = Date.now();
+
+  const abortController = new AbortController();
+
+  // Ensure streaming requests map doesn't grow unbounded
+  trimStreamingRequests();
+
+  activeStreamingRequests.set(requestId, { abortController, clientId, startedAt: Date.now() });
+
+  log('debug', `[WS Chat] "${message.substring(0, 50)}..." from ${clientId}`);
+
+  // Extract satellite ID from session user (format: SESSION_USER or SESSION_USER:satelliteId)
+  // Must be declared before any usage to avoid TDZ error in strict mode
+  const sessionParts = (client.sessionUser || SESSION_USER).split(':');
+  const satelliteId = sessionParts[1] || 'main';
+
+  await saveMessageToSync('user', message);
+
+  // Generate message ID for sync
+  const userMessageId = generateMessageId();
+
+  // Broadcast user message to other clients for sync
+  broadcastSyncMessage('user', message, satelliteId, userMessageId, clientId);
+
+  safeSend(client.ws, {
+    type: 'chat_start',
+    requestId,
+    timestamp: new Date().toISOString()
+  });
+
+  // Generate a request ID for correlating sync stream deltas with final message
+  const syncRequestId = generateMessageId();
+
+  try {
+    let fullResponse = '';
+    let detectedTools = [];
+
+    // Use unified sendMessage (routes through channel if enabled)
+    const result = await sendMessage({
+      message,
+      satelliteId,
+      mode,
+      requestId,
+      signal: abortController.signal,
+      onThinking: () => {
+        sendToClient(clientId, {
+          type: 'chat_thinking',
+          requestId,
+          timestamp: Date.now()
+        });
+        broadcastSyncThinking(syncRequestId, satelliteId, clientId);
+      },
+      onChunk: (content) => {
+        fullResponse += content;
+        sendToClient(clientId, {
+          type: 'chat_chunk',
+          requestId,
+          content,
+          timestamp: Date.now()
+        });
+        broadcastSyncDelta(syncRequestId, content, satelliteId, clientId);
+      },
+      onTool: (tool) => {
+        if (!detectedTools.includes(tool)) {
+          detectedTools.push(tool);
+          sendToClient(clientId, {
+            type: 'tool_used',
+            requestId,
+            tool,
+            timestamp: Date.now()
+          });
+        }
+        broadcastSyncTool(syncRequestId, tool, satelliteId, clientId);
+      },
+    });
+
+    const elapsed = Date.now() - startTime;
+
+    if (result.response) {
+      await saveMessageToSync('assistant', result.response);
+
+      // Flush remaining deltas before sending final sync message
+      cleanupSyncDeltaThrottle(syncRequestId);
+
+      // Broadcast assistant response to other clients for sync (with requestId for stream finalization)
+      const assistantMessageId = generateMessageId();
+      broadcastSyncMessage('assistant', result.response, satelliteId, assistantMessageId, clientId, syncRequestId);
+    }
+
+    let audioUrl = null;
+    if (mode === 'voice' && result.response && textToSpeech) {
+      try {
+        audioUrl = await textToSpeech(result.response);
+      } catch (e) {
+        log('error', '[WS Chat] TTS failed:', e.message);
+      }
+    }
+
+    sendToClient(clientId, {
+      type: 'chat_complete',
+      requestId,
+      response: result.response,
+      audioUrl,
+      elapsed,
+      usage: result.usage,
+      tools: result.tools,
+      timestamp: Date.now()
+    });
+
+    log('debug', `[WS Chat] Complete in ${elapsed}ms, tokens: ${result.usage?.total_tokens || '?'}${result.usage?.estimated ? ' (est)' : ''}`);
+
+  } catch (err) {
+    cleanupSyncDeltaThrottle(syncRequestId);
+    if (err.name === 'AbortError') {
+      sendToClient(clientId, {
+        type: 'chat_aborted',
+        requestId,
+        response: '',
+        timestamp: Date.now()
+      });
+      log('info', `[WS Chat] Aborted by user`);
+    } else {
+      log('error', `[WS Chat] Error:`, err.message);
+      sendToClient(clientId, {
+        type: 'chat_error',
+        requestId,
+        error: err.message,
+        timestamp: Date.now()
+      });
+    }
+  } finally {
+    cleanupSyncDeltaThrottle(syncRequestId);
+    activeStreamingRequests.delete(requestId);
+    endRequest(trackingId);
+  }
+}
+
+// ============================================
+// Message Dispatcher
+// ============================================
+
+/**
+ * Handle an incoming WebSocket message, dispatching by type
+ */
+export async function handleWebSocketMessage(clientId, message, requestHelpers, saveMessageToSync) {
+  const client = wsClients.get(clientId);
+  if (!client) return;
+
+  const { type, ...payload } = message;
+  const { isProcessing, activeRequests, MAX_CONCURRENT_REQUESTS } = requestHelpers;
+
+  switch (type) {
+    case 'ping':
+      client.lastPing = Date.now();
+      safeSend(client.ws, { type: 'pong', timestamp: Date.now() });
+      break;
+
+    case 'status':
+      safeSend(client.ws, {
+        type: 'status',
+        data: {
+          processing: isProcessing(),
+          activeRequests: activeRequests.size,
+          maxConcurrent: MAX_CONCURRENT_REQUESTS,
+          connectedClients: wsClients.size,
+          maxConnections: WS_CONNECTION_LIMITS.maxTotal,
+          maxPerIp: WS_CONNECTION_LIMITS.maxPerIp,
+          timestamp: new Date().toISOString()
+        }
+      });
+      break;
+
+    case 'chat':
+      await handleWebSocketChat(clientId, payload, requestHelpers, saveMessageToSync);
+      break;
+
+    case 'abort':
+      if (payload.requestId) {
+        const activeReq = activeStreamingRequests.get(payload.requestId);
+        if (activeReq && activeReq.clientId === clientId) {
+          log('info', `[WS] Aborting request ${payload.requestId}`);
+          activeReq.abortController.abort();
+          activeStreamingRequests.delete(payload.requestId);
+          safeSend(client.ws, {
+            type: 'chat_aborted',
+            requestId: payload.requestId,
+            timestamp: Date.now()
+          });
+        }
+      }
+      break;
+
+    case 'set_user':
+      if (payload.user) {
+        // M-39 (H-02): Validate set_user when auth is enabled to prevent impersonation
+        if (!validateSetUser(payload.user, client.sessionUser)) {
+          log('warn', `[WS] set_user rejected for ${clientId}: cannot impersonate ${payload.user}`);
+          safeSend(client.ws, {
+            type: 'error',
+            message: 'Authentication required to change user identity'
+          });
+          break;
+        }
+
+        client.sessionUser = payload.user;
+        safeSend(client.ws, {
+          type: 'user_set',
+          user: payload.user
+        });
+      }
+      break;
+
+    default:
+      safeSend(client.ws, {
+        type: 'error',
+        error: `Unknown message type: ${type}`
+      });
+  }
+}

package/server/websocket/sync.js

@@ -0,0 +1,102 @@
+/**
+ * WebSocket Sync Module
+ * Sync delta throttling, cross-device streaming state
+ */
+
+import { log } from '../utils.js';
+import { WEBSOCKET } from '../config.js';
+import { broadcastToProxyClients } from '../gateway-proxy.js';
+import { broadcast } from './broadcast.js';
+
+// ============================================
+// Sync Delta Throttling
+// ============================================
+
+/** Sync delta throttles: requestId -> { lastSent, pendingContent, timer, satelliteId, excludeClientId } */
+const syncDeltaThrottles = new Map();
+const SYNC_DELTA_THROTTLE_MS = WEBSOCKET.syncDeltaThrottleMs;
+
+/**
+ * Flush accumulated sync delta content to all clients
+ */
+function flushSyncDelta(requestId) {
+  const state = syncDeltaThrottles.get(requestId);
+  if (!state || !state.pendingContent) return;
+
+  const message = {
+    type: 'event',
+    event: 'sync.delta',
+    payload: {
+      requestId,
+      content: state.pendingContent,
+      satelliteId: state.satelliteId || 'main',
+    },
+  };
+  broadcast(message, state.excludeClientId);
+  broadcastToProxyClients(message);
+
+  state.pendingContent = '';
+  state.lastSent = Date.now();
+  if (state.timer) {
+    clearTimeout(state.timer);
+    state.timer = null;
+  }
+}
+
+/**
+ * Broadcast sync.delta event with throttling
+ * Accumulates content and flushes at most every SYNC_DELTA_THROTTLE_MS
+ */
+export function broadcastSyncDelta(requestId, content, satelliteId, excludeClientId = null) {
+  let state = syncDeltaThrottles.get(requestId);
+  if (!state) {
+    state = { lastSent: 0, pendingContent: '', timer: null, satelliteId, excludeClientId };
+    syncDeltaThrottles.set(requestId, state);
+  }
+
+  state.pendingContent += content;
+
+  const elapsed = Date.now() - state.lastSent;
+  if (elapsed >= SYNC_DELTA_THROTTLE_MS) {
+    // Enough time has passed, flush immediately
+    flushSyncDelta(requestId);
+  } else if (!state.timer) {
+    // Schedule a flush for the remaining time
+    const remaining = SYNC_DELTA_THROTTLE_MS - elapsed;
+    state.timer = setTimeout(() => {
+      state.timer = null;
+      flushSyncDelta(requestId);
+    }, remaining);
+  }
+}
+
+/**
+ * Cleanup sync delta throttle state for a completed request
+ * Flushes any remaining content and removes the entry
+ */
+export function cleanupSyncDeltaThrottle(requestId) {
+  const state = syncDeltaThrottles.get(requestId);
+  if (!state) return;
+
+  // Flush remaining content
+  if (state.pendingContent) {
+    flushSyncDelta(requestId);
+  }
+  if (state.timer) {
+    clearTimeout(state.timer);
+  }
+  syncDeltaThrottles.delete(requestId);
+}
+
+/**
+ * Clean up sync delta throttles for a specific client (called on disconnect)
+ * @param {string} clientId - The client ID to clean up throttles for
+ */
+export function cleanupSyncForClient(clientId) {
+  for (const [reqId, state] of syncDeltaThrottles) {
+    if (state.excludeClientId === clientId) {
+      if (state.timer) clearTimeout(state.timer);
+      syncDeltaThrottles.delete(reqId);
+    }
+  }
+}