@mooncompany/uplink-chat 0.5.0

package/public/js/gateway-chat.js

@@ -0,0 +1,538 @@
+// ============================================
+// GATEWAY CHAT MODULE
+// Handles Gateway WebSocket events with streaming fix
+// Subscribes to agent events for deltas, chat events for final state
+// ============================================
+
+import { UplinkCore } from './core.js';
+
+// WebSocket reference (from connection.js)
+let ws = null;
+
+// Message listeners for external consumers
+let messageListeners = [];
+
+// Track streaming message state
+let currentStreamingMessage = null;
+let currentMessageId = null;
+
+// History state
+let historyLoaded = false;
+
+// Gateway API endpoint
+const GATEWAY_API_BASE = '/api/gateway';
+
+// Module init retry state
+let initRetryCount = 0;
+const MAX_INIT_RETRIES = 10;
+
+/**
+ * Initialize the gateway chat module
+ * Sets up WebSocket listeners using the shared connection
+ */
+function init() {
+  // Wait for connection module to be ready
+  if (!window.UplinkConnection) {
+    if (initRetryCount >= MAX_INIT_RETRIES) {
+      logger.error('GatewayChat: UplinkConnection not found after max retries, giving up');
+      return;
+    }
+    initRetryCount++;
+    const delay = Math.min(100 * Math.pow(2, initRetryCount), 5000);
+    logger.debug(`GatewayChat: Waiting for UplinkConnection (${initRetryCount}/${MAX_INIT_RETRIES})...`);
+    setTimeout(init, delay);
+    return;
+  }
+
+  // Subscribe to connection events
+  window.UplinkConnection.onConnection((event, data) => {
+    if (event === 'connected') {
+      onConnected();
+    } else if (event === 'disconnected') {
+      onDisconnected();
+    } else if (event === 'message') {
+      handleWebSocketMessage(data);
+    }
+  });
+
+  // Get initial WebSocket if already connected
+  ws = window.UplinkConnection.getWebSocket();
+  if (ws && window.UplinkConnection.isConnected()) {
+    onConnected();
+  }
+
+  logger.debug('GatewayChat: Initialized');
+}
+
+/**
+ * Called when WebSocket connects
+ */
+function onConnected() {
+  ws = window.UplinkConnection.getWebSocket();
+  logger.debug('GatewayChat: Connected to Gateway');
+  
+  // Load history on connect if not already loaded
+  if (!historyLoaded) {
+    loadHistory();
+  }
+}
+
+/**
+ * Called when WebSocket disconnects
+ */
+function onDisconnected() {
+  ws = null;
+  logger.debug('GatewayChat: Disconnected from Gateway');
+  
+  // Finalize any streaming message
+  if (currentStreamingMessage) {
+    finalizeStreamingMessage();
+  }
+}
+
+// Track malformed message count for rate limiting error display
+let malformedMessageCount = 0;
+let lastMalformedErrorShown = 0;
+const MALFORMED_ERROR_COOLDOWN_MS = 10000; // Only show error every 10 seconds
+
+/**
+ * Handle incoming WebSocket messages
+ * @param {string} data - Raw message data
+ */
+function handleWebSocketMessage(data) {
+  try {
+    const message = JSON.parse(data);
+    
+    // Reset malformed count on successful parse
+    malformedMessageCount = 0;
+    
+    // Handle agent events - streaming deltas
+    // Gateway sends streaming deltas on agent events at payload.data.delta
+    if (message.type === 'agent' || message.event === 'agent') {
+      handleAgentEvent(message);
+      return;
+    }
+    
+    // Handle chat events - final message state
+    if (message.type === 'chat' || message.event === 'chat') {
+      handleChatEvent(message);
+      return;
+    }
+    
+    // Handle pong/heartbeat
+    if (message.type === 'pong') {
+      return;
+    }
+    
+    // Notify listeners of other message types
+    notifyListeners('message', message);
+    
+  } catch (e) {
+    // Log malformed message with details for debugging
+    malformedMessageCount++;
+    const truncatedData = data && data.length > 200 ? data.substring(0, 200) + '...' : data;
+    logger.warn('GatewayChat: Malformed message received', {
+      error: e.message,
+      dataPreview: truncatedData,
+      dataLength: data ? data.length : 0,
+      count: malformedMessageCount
+    });
+    
+    // Notify listeners about the malformed message
+    notifyListeners('malformed-message', {
+      error: e.message,
+      dataPreview: truncatedData,
+      count: malformedMessageCount
+    });
+    
+    // Show user-friendly error if we're getting repeated malformed messages
+    // This suggests a critical protocol issue
+    const now = Date.now();
+    if (malformedMessageCount >= 5 && (now - lastMalformedErrorShown) > MALFORMED_ERROR_COOLDOWN_MS) {
+      lastMalformedErrorShown = now;
+      showMalformedMessageError();
+    }
+  }
+}
+
+/**
+ * Show user-friendly error for repeated malformed messages
+ */
+function showMalformedMessageError() {
+  const errorMsg = 'Communication issue detected. Some messages may not display correctly.';
+  
+  // Try to use UplinkChat to show the error
+  if (window.UplinkChat?.addMessage) {
+    window.UplinkChat.addMessage(errorMsg, 'system', null, false);
+  } else if (window.addMessage) {
+    window.addMessage(errorMsg, 'system', null, false);
+  }
+  
+  // Also notify listeners
+  notifyListeners('critical-error', {
+    type: 'malformed-messages',
+    message: errorMsg,
+    count: malformedMessageCount
+  });
+  
+  logger.error('GatewayChat: Critical - repeated malformed messages detected', {
+    count: malformedMessageCount
+  });
+}
+
+/**
+ * Handle agent events - streaming deltas from Gateway
+ * @param {object} message - The agent event message
+ */
+function handleAgentEvent(message) {
+  // Extract delta from payload.data.delta (per Gateway spec)
+  const delta = message.payload?.data?.delta || 
+                message.data?.delta || 
+                message.delta;
+  
+  if (!delta) {
+    // No delta in this agent event, might be status update
+    if (message.payload?.status || message.status) {
+      const status = message.payload?.status || message.status;
+      notifyListeners('status', { status, type: 'agent' });
+    }
+    return;
+  }
+
+  // Check if this is tool output that should be filtered
+  if (isToolOutput(delta)) {
+    // Route to activity panel instead of chat
+    routeToActivityPanel(delta, 'tool');
+    return;
+  }
+
+  // Start or continue streaming message
+  if (!currentStreamingMessage) {
+    currentStreamingMessage = delta;
+    currentMessageId = message.messageId || message.id || generateId();
+    
+    notifyListeners('stream-start', {
+      messageId: currentMessageId,
+      content: delta
+    });
+  } else {
+    currentStreamingMessage += delta;
+    
+    notifyListeners('stream-delta', {
+      messageId: currentMessageId,
+      delta: delta,
+      content: currentStreamingMessage
+    });
+  }
+}
+
+/**
+ * Handle chat events - final message state from Gateway
+ * @param {object} message - The chat event message
+ */
+function handleChatEvent(message) {
+  const content = message.payload?.content || 
+                  message.payload?.text || 
+                  message.content || 
+                  message.text;
+  
+  const messageId = message.messageId || message.id || generateId();
+  
+  // Finalize any ongoing streaming
+  if (currentStreamingMessage) {
+    finalizeStreamingMessage();
+  }
+  
+  // Handle tool output filtering for final messages too
+  if (content && isToolOutput(content)) {
+    routeToActivityPanel(content, 'tool');
+    return;
+  }
+  
+  // Notify listeners of final message
+  notifyListeners('message-final', {
+    messageId: messageId,
+    content: content,
+    role: message.payload?.role || message.role || 'assistant',
+    timestamp: message.timestamp || Date.now()
+  });
+}
+
+/**
+ * Finalize the current streaming message
+ */
+function finalizeStreamingMessage() {
+  if (!currentStreamingMessage) return;
+  
+  notifyListeners('stream-end', {
+    messageId: currentMessageId,
+    content: currentStreamingMessage
+  });
+  
+  currentStreamingMessage = null;
+  currentMessageId = null;
+}
+
+/**
+ * Send a message to the Gateway
+ * @param {string} text - The message text to send
+ * @returns {Promise<boolean>} - Success status
+ */
+function sendMessage(text) {
+  if (!text || !text.trim()) {
+    logger.warn('GatewayChat: Cannot send empty message');
+    return Promise.resolve(false);
+  }
+
+  // Check connection
+  if (!ws || ws.readyState !== WebSocket.OPEN) {
+    logger.error('GatewayChat: Cannot send message - not connected');
+    return Promise.resolve(false);
+  }
+
+  const message = {
+    type: 'chat',
+    content: text.trim(),
+    timestamp: Date.now(),
+    messageId: generateId()
+  };
+
+  try {
+    ws.send(JSON.stringify(message));
+    
+    notifyListeners('message-sent', {
+      messageId: message.messageId,
+      content: message.content
+    });
+    
+    logger.debug('GatewayChat: Message sent', message.messageId);
+    return Promise.resolve(true);
+  } catch (e) {
+    logger.error('GatewayChat: Failed to send message', e);
+    return Promise.resolve(false);
+  }
+}
+
+/**
+ * Load chat history from Gateway
+ * @returns {Promise<Array>} - Array of history messages
+ */
+async function loadHistory() {
+  try {
+    const response = await fetch(`${GATEWAY_API_BASE}/history`);
+    
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    
+    const data = await response.json();
+    const messages = data.messages || data.history || data || [];
+    
+    historyLoaded = true;
+    
+    notifyListeners('history-loaded', { messages });
+    
+    logger.debug('GatewayChat: History loaded', messages.length, 'messages');
+    return messages;
+  } catch (e) {
+    logger.error('GatewayChat: Failed to load history', e);
+    notifyListeners('history-error', { error: e.message });
+    return [];
+  }
+}
+
+/**
+ * Register a callback for message events
+ * @param {Function} callback - Function to call with (eventType, data)
+ * @returns {Function} - Unsubscribe function
+ */
+function onMessage(callback) {
+  if (typeof callback !== 'function') {
+    logger.warn('GatewayChat: onMessage requires a function');
+    return () => {};
+  }
+  
+  messageListeners.push(callback);
+  
+  // Return unsubscribe function
+  return () => {
+    messageListeners = messageListeners.filter(cb => cb !== callback);
+  };
+}
+
+/**
+ * Notify all registered listeners
+ * @param {string} eventType - Type of event
+ * @param {object} data - Event data
+ */
+function notifyListeners(eventType, data) {
+  messageListeners.forEach(callback => {
+    try {
+      callback(eventType, data);
+    } catch (e) {
+      logger.error('GatewayChat: Listener error', e);
+    }
+  });
+}
+
+/**
+ * Check if text is tool output that should be filtered from chat
+ * @param {string} text - Text to check
+ * @returns {boolean} - True if this is tool output
+ */
+function isToolOutput(text) {
+  if (!text || typeof text !== 'string') return false;
+  
+  const lines = text.split('\n');
+  
+  // Check each line for tool output patterns
+  for (const line of lines) {
+    const trimmed = line.trim();
+    
+    // Lines starting with "SUCCESS:"
+    if (trimmed.startsWith('SUCCESS:')) {
+      return true;
+    }
+    
+    // Lines starting with "FAILED:" or "ERROR:"
+    if (trimmed.startsWith('FAILED:') || trimmed.startsWith('ERROR:')) {
+      return true;
+    }
+    
+    // File paths with line numbers (e.g., path/file.js:123)
+    if (/^[\w\/\\.-]+\.[\w]+:\d+/.test(trimmed)) {
+      return true;
+    }
+    
+    // TCP connection output patterns
+    if (/TCP\s+(connection|socket|listen|accept)/i.test(trimmed)) {
+      return true;
+    }
+    if (/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+/.test(trimmed)) {
+      return true; // IP:port pattern
+    }
+    
+    // Command output indicators
+    if (trimmed.startsWith('$ ') || trimmed.startsWith('> ')) {
+      return true;
+    }
+    
+    // Process output patterns
+    if (/^\[.*\]\s*(stdout|stderr|exit|pid)/i.test(trimmed)) {
+      return true;
+    }
+  }
+  
+  // Check for command output blocks (multiple lines that look like terminal output)
+  const codeBlockPatterns = [
+    /```(?:bash|sh|shell|powershell|cmd)/i,
+    /```\n\$/,
+    /```\n>/
+  ];
+  
+  for (const pattern of codeBlockPatterns) {
+    if (pattern.test(text)) {
+      return true;
+    }
+  }
+  
+  return false;
+}
+
+/**
+ * Route tool output to the activity panel instead of chat
+ * @param {string} content - The content to route
+ * @param {string} type - Type of content (tool, command, etc.)
+ */
+function routeToActivityPanel(content, type) {
+  logger.debug('GatewayChat: Routing to activity panel', type);
+  
+  // Try to use the developer/activity panel
+  if (window.UplinkDeveloper) {
+    // Log as a tool call
+    if (type === 'tool') {
+      window.UplinkDeveloper.logTool('Gateway Tool Output');
+      window.UplinkDeveloper.logToolCall('output', { content: truncate(content, 500) }, null);
+    }
+  }
+  
+  // Also notify listeners so they can handle it
+  notifyListeners('tool-output', {
+    content: content,
+    type: type,
+    timestamp: Date.now()
+  });
+}
+
+/**
+ * Generate a unique message ID
+ * @returns {string} - Unique ID
+ */
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+
+/**
+ * Truncate string to max length
+ * @param {string} str - String to truncate
+ * @param {number} maxLen - Maximum length
+ * @returns {string} - Truncated string
+ */
+function truncate(str, maxLen) {
+  if (!str || str.length <= maxLen) return str;
+  return str.slice(0, maxLen) + '... [truncated]';
+}
+
+/**
+ * Get current connection state
+ * @returns {object} - Connection state
+ */
+function getState() {
+  return {
+    connected: ws !== null && ws.readyState === WebSocket.OPEN,
+    streaming: currentStreamingMessage !== null,
+    historyLoaded: historyLoaded,
+    messageId: currentMessageId
+  };
+}
+
+/**
+ * Clear/reset the module state
+ */
+function clear() {
+  currentStreamingMessage = null;
+  currentMessageId = null;
+  historyLoaded = false;
+  messageListeners = [];
+}
+
+// Export API
+export const gatewayChat = {
+  init,
+  sendMessage,
+  loadHistory,
+  onMessage,
+  isToolOutput,
+  getState,
+  clear
+};
+
+// Backward compat: assign to window
+window.gatewayChat = gatewayChat;
+window.gatewayChat.send = sendMessage;
+
+// Helper for init retry with exponential backoff
+function scheduleInitRetry() {
+  if (initRetryCount >= MAX_INIT_RETRIES) {
+    logger.warn('GatewayChat: Max init retries reached, giving up');
+    return;
+  }
+  initRetryCount++;
+  const delay = Math.min(50 * Math.pow(2, initRetryCount), 5000);
+  setTimeout(init, delay);
+}
+
+// Register with core for coordinated initialization
+UplinkCore.registerModule('gateway-chat', init);
+
+logger.debug('GatewayChat: Module loaded');

package/public/js/logger.js

@@ -0,0 +1,112 @@
+// ============================================
+// LOGGER MODULE
+// Centralized logging with level control
+// ============================================
+
+// Log levels
+const LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  none: 4
+};
+
+// Default level (production = warn, can be overridden)
+let currentLevel = LEVELS.warn;
+
+// Load level from settings if available
+function loadLevel() {
+  try {
+    const settings = JSON.parse(localStorage.getItem('uplink-settings') || '{}');
+    if (settings.logLevel && LEVELS[settings.logLevel] !== undefined) {
+      currentLevel = LEVELS[settings.logLevel];
+    }
+  } catch (e) {
+    // Ignore
+  }
+}
+
+// Set log level
+function setLevel(level) {
+  if (LEVELS[level] !== undefined) {
+    currentLevel = LEVELS[level];
+    try {
+      const settings = JSON.parse(localStorage.getItem('uplink-settings') || '{}');
+      settings.logLevel = level;
+      localStorage.setItem('uplink-settings', JSON.stringify(settings));
+    } catch (e) {
+      // Ignore
+    }
+  }
+}
+
+// Get current level name
+function getLevel() {
+  return Object.keys(LEVELS).find(k => LEVELS[k] === currentLevel) || 'warn';
+}
+
+// Logging functions
+function debug(...args) {
+  if (currentLevel <= LEVELS.debug) {
+    console.log('[DEBUG]', ...args);
+  }
+}
+
+function info(...args) {
+  if (currentLevel <= LEVELS.info) {
+    console.log('[INFO]', ...args);
+  }
+}
+
+function warn(...args) {
+  if (currentLevel <= LEVELS.warn) {
+    console.warn('[WARN]', ...args);
+  }
+}
+
+function error(...args) {
+  if (currentLevel <= LEVELS.error) {
+    console.error('[ERROR]', ...args);
+  }
+}
+
+// Group logging (for structured output)
+function group(label, fn) {
+  if (currentLevel <= LEVELS.debug) {
+    console.group(label);
+    try {
+      fn();
+    } finally {
+      console.groupEnd();
+    }
+  } else {
+    fn();
+  }
+}
+
+// Initialize
+loadLevel();
+
+// Export API
+export const UplinkLogger = {
+  debug,
+  info,
+  warn,
+  error,
+  group,
+  setLevel,
+  getLevel,
+  LEVELS
+};
+
+export { debug, info, warn, error, group, setLevel, getLevel, LEVELS };
+
+// Backward compat: assign to window
+if (typeof window !== 'undefined') {
+  window.UplinkLogger = UplinkLogger;
+  window.logger = UplinkLogger;
+}
+
+// Logger initialized - use debug for init message (only shown if level is debug)
+debug('Logger: Initialized (level=' + getLevel() + ')');