@mooncompany/uplink-chat 0.5.0

package/server/routes/status.js

@@ -0,0 +1,251 @@
+/**
+ * Status Routes - Health checks, activity feed, and session status
+ */
+
+import fs from 'fs/promises';
+import { badRequest, internalError, ErrorCodes } from '../../utils/errors.js';
+import { getOpenClawStateDir } from '../openclaw-discover.js';
+import { sanitizeSatelliteId } from '../../utils/id-sanitize.js';
+
+/**
+ * Setup status routes
+ * @param {Express} app - Express app instance
+ * @param {Object} context - Request context
+ */
+// Validation constants
+const MAX_TYPE_LENGTH = 32;
+const MAX_SUMMARY_LENGTH = 500;
+const MAX_DETAILS_LENGTH = 5000;
+
+export function setupStatusRoutes(app, context) {
+  const {
+    fetch: fetchWithTimeout,
+    log,
+    config,
+    requestHelpers,
+  } = context;
+
+  const { isProcessing, activeRequests, MAX_CONCURRENT_REQUESTS } = requestHelpers;
+  const { 
+    TTS_VOICE_NAME, 
+    ACTIVITY_FILE, 
+    MESSAGES_FILE, 
+    MAX_ACTIVITY_ITEMS,
+    GATEWAY_URL,
+    GATEWAY_TOKEN,
+    SESSION_USER,
+  } = config;
+
+  // ===========================================
+  // Status
+  // ===========================================
+  
+  app.get('/api/status', (req, res) => {
+    res.json({
+      processing: isProcessing(),
+      activeRequests: activeRequests.size,
+      maxConcurrent: MAX_CONCURRENT_REQUESTS
+    });
+  });
+
+  app.get('/api/health', (req, res) => {
+    res.json({
+      status: 'ok',
+      processing: isProcessing(),
+      activeRequests: activeRequests.size,
+      timestamp: new Date().toISOString(),
+      tts: `ElevenLabs (${TTS_VOICE_NAME})`,
+      whisper: 'whisper-small',
+      websocket: true
+    });
+  });
+
+  // ===========================================
+  // Activity Feed
+  // ===========================================
+
+  app.get('/api/activity', async (req, res) => {
+    try {
+      const data = await fs.readFile(ACTIVITY_FILE, 'utf8').catch(() => '[]');
+      res.json(JSON.parse(data));
+    } catch (e) {
+      res.json([]);
+    }
+  });
+
+  app.post('/api/activity', async (req, res) => {
+    try {
+      const { type, summary, details, timestamp } = req.body;
+      
+      // Validate required fields
+      if (!type || !summary) {
+        return badRequest(res, 'type and summary required', ErrorCodes.MISSING_FIELD);
+      }
+      
+      // Validate type
+      if (typeof type !== 'string' || type.length > MAX_TYPE_LENGTH) {
+        return badRequest(res, `type must be a string with max ${MAX_TYPE_LENGTH} chars`, ErrorCodes.VALIDATION_ERROR);
+      }
+      
+      // Validate summary
+      if (typeof summary !== 'string' || summary.length > MAX_SUMMARY_LENGTH) {
+        return badRequest(res, `summary must be a string with max ${MAX_SUMMARY_LENGTH} chars`, ErrorCodes.VALIDATION_ERROR);
+      }
+      
+      // Validate details if provided
+      if (details !== undefined && details !== null) {
+        if (typeof details !== 'string' || details.length > MAX_DETAILS_LENGTH) {
+          return badRequest(res, `details must be a string with max ${MAX_DETAILS_LENGTH} chars`, ErrorCodes.VALIDATION_ERROR);
+        }
+      }
+
+      let activities = [];
+      try {
+        const data = await fs.readFile(ACTIVITY_FILE, 'utf8');
+        activities = JSON.parse(data);
+      } catch (e) {}
+
+      activities.unshift({
+        id: Date.now(),
+        type: type.slice(0, MAX_TYPE_LENGTH),
+        summary: summary.slice(0, MAX_SUMMARY_LENGTH),
+        details: details ? details.slice(0, MAX_DETAILS_LENGTH) : null,
+        timestamp: timestamp || new Date().toISOString()
+      });
+
+      if (activities.length > MAX_ACTIVITY_ITEMS) {
+        activities = activities.slice(0, MAX_ACTIVITY_ITEMS);
+      }
+
+      await fs.writeFile(ACTIVITY_FILE, JSON.stringify(activities, null, 2));
+      res.json({ ok: true });
+    } catch (e) {
+      internalError(res, e.message, ErrorCodes.INTERNAL_ERROR);
+    }
+  });
+
+  // ===========================================
+  // Message Sync
+  // ===========================================
+
+  app.get('/api/messages/sync', async (req, res) => {
+    try {
+      // Validate since param before parseInt
+      let since = 0;
+      if (req.query.since !== undefined) {
+        const sinceStr = String(req.query.since).trim();
+        if (!/^\d+$/.test(sinceStr)) {
+          return badRequest(res, 'since must be a numeric timestamp', ErrorCodes.INVALID_FORMAT);
+        }
+        since = parseInt(sinceStr, 10);
+        if (isNaN(since) || since < 0) {
+          return badRequest(res, 'since must be a valid positive number', ErrorCodes.VALIDATION_ERROR);
+        }
+      }
+      
+      const data = await fs.readFile(MESSAGES_FILE, 'utf8').catch(() => '[]');
+      const messages = JSON.parse(data);
+      const filtered = since ? messages.filter(m => m.id > since) : messages;
+      res.json({ ok: true, messages: filtered });
+    } catch (e) {
+      res.json({ ok: false, messages: [], error: e.message });
+    }
+  });
+
+  // ===========================================
+  // Session Status
+  // ===========================================
+
+  /**
+   * Get session status for a satellite
+   * Returns derived session key and connection status
+   */
+  // ===========================================
+  // Context Tracking
+  // ===========================================
+
+  /**
+   * Get context window usage for a satellite session
+   * Reads the gateway session store file directly for accurate token counts
+   */
+  app.get('/api/session/context', async (req, res) => {
+    const satelliteId = sanitizeSatelliteId(req.query.satelliteId);
+    const agentId = req.query.agentId ? String(req.query.agentId).replace(/[^a-z0-9-]/g, '').substring(0, 64) || 'main' : 'main';
+    
+    // Derive session key - must match channel.js logic
+    const sessionKey = satelliteId === 'main' 
+      ? `agent:${agentId}:main`
+      : `agent:${agentId}:uplink:satellite:${satelliteId}`;
+    
+    try {
+      // Read the gateway session store (supports WSL paths on Windows)
+      const path = await import('path');
+      const stateDir = await getOpenClawStateDir();
+      const sessionsFile = path.join(stateDir, 'agents', agentId, 'sessions', 'sessions.json');
+      
+      const data = await fs.readFile(sessionsFile, 'utf8');
+      const sessions = JSON.parse(data);
+      const session = sessions[sessionKey];
+      
+      if (session) {
+        res.json({
+          ok: true,
+          sessionKey,
+          totalTokens: session.totalTokens || 0,
+          contextTokens: session.contextTokens || 200000,
+          inputTokens: session.inputTokens || 0,
+          outputTokens: session.outputTokens || 0,
+        });
+      } else {
+        res.json({
+          ok: true,
+          sessionKey,
+          totalTokens: 0,
+          contextTokens: 200000,
+          inputTokens: 0,
+          outputTokens: 0,
+        });
+      }
+    } catch (e) {
+      log('warn', `[Context] Failed to read session store: ${e.message}`);
+      res.json({
+        ok: false,
+        error: e.message,
+        totalTokens: 0,
+        contextTokens: 200000,
+      });
+    }
+  });
+
+  app.get('/api/session/status', async (req, res) => {
+    const satelliteId = sanitizeSatelliteId(req.query.satelliteId);
+    const agentId = req.query.agentId ? String(req.query.agentId).replace(/[^a-z0-9-]/g, '').substring(0, 64) || 'main' : 'main';
+    
+    // Derive session key - must match channel.js logic
+    // Main satellite shares session with Dashboard: agent:{agentId}:main
+    // Other satellites get isolated: agent:{agentId}:uplink:satellite:<satelliteId>
+    const fullSessionKey = satelliteId === 'main' 
+      ? `agent:${agentId}:main`
+      : `agent:${agentId}:uplink:satellite:${satelliteId}`;
+    
+    // Check gateway health
+    let gatewayConnected = false;
+    try {
+      const healthCheck = await fetchWithTimeout(`${GATEWAY_URL}/health`, {
+        method: 'GET',
+        headers: { 'Authorization': `Bearer ${GATEWAY_TOKEN}` }
+      }, 3000);
+      gatewayConnected = healthCheck.ok;
+    } catch {
+      gatewayConnected = false;
+    }
+    
+    res.json({
+      satelliteId,
+      sessionKey: fullSessionKey,
+      gatewayConnected,
+      gatewayUrl: GATEWAY_URL,
+      timestamp: Date.now()
+    });
+  });
+}

package/server/routes/stt.js

@@ -0,0 +1,35 @@
+/**
+ * STT Routes - Speech-to-Text testing endpoint
+ */
+
+import { testSTT } from '../stt/index.js';
+import { internalError, ErrorCodes } from '../../utils/errors.js';
+import { requirePremium } from '../premium/index.js';
+
+/**
+ * Setup STT routes
+ * @param {Express} app - Express app instance
+ * @param {Object} context - Request context
+ */
+export function setupSTTRoutes(app, context) {
+  const { strictLimiter, log } = context;
+
+  /**
+   * Test current STT provider configuration
+   * POST /api/stt/test
+   * 
+   * Optionally accepts multipart audio file for a real transcription test.
+   * Without a file, just validates the config (API key present, server reachable).
+   * 
+   * Returns: { success: boolean, provider: string, transcription?: string, error?: string }
+   */
+  app.post('/api/stt/test', requirePremium('Speech-to-text'), strictLimiter, async (req, res) => {
+    try {
+      const result = await testSTT();
+      res.json(result);
+    } catch (error) {
+      log('error', '[STT] Test endpoint error:', error.message);
+      internalError(res, 'Failed to test STT configuration', ErrorCodes.CONFIG_ERROR);
+    }
+  });
+}

package/server/routes/voice.js

@@ -0,0 +1,260 @@
+/**
+ * Voice Routes - Audio transcription and voice chat
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileTypeFromBuffer } from 'file-type';
+import { sanitizeFilename } from '../utils/filename.js';
+import { badRequest, internalError, ErrorCodes } from '../../utils/errors.js';
+import { requirePremium } from '../premium/index.js';
+
+// ===========================================
+// Temp File Cleanup Utilities
+// ===========================================
+
+/**
+ * Creates a cleanup tracker for temp files
+ * @returns {Object} Cleanup tracker with add/cleanup methods
+ */
+function createTempFileTracker() {
+  const files = new Set();
+  return {
+    add(filePath) {
+      if (filePath) files.add(filePath);
+    },
+    async cleanup() {
+      const promises = [...files].map(f => 
+        fs.unlink(f).catch(() => {}) // Ignore errors if file doesn't exist
+      );
+      await Promise.all(promises);
+      files.clear();
+    }
+  };
+}
+
+/**
+ * Clean up orphaned temp files from previous sessions
+ * Removes files matching voice upload patterns older than maxAge
+ * @param {string} uploadDir - Directory to clean
+ * @param {number} maxAgeMs - Max age in milliseconds (default: 1 hour)
+ * @param {Function} log - Logger function
+ */
+export async function cleanupOrphanedTempFiles(uploadDir, maxAgeMs = 60 * 60 * 1000, log = console.log) {
+  try {
+    const files = await fs.readdir(uploadDir);
+    const now = Date.now();
+    let cleaned = 0;
+    
+    for (const file of files) {
+      // Match multer-style temp files (random hex names, with or without extensions)
+      if (/^[a-f0-9]{32}(\.(webm|mp4|m4a|wav|ogg))?$/i.test(file)) {
+        const filePath = path.join(uploadDir, file);
+        try {
+          const stat = await fs.stat(filePath);
+          if (now - stat.mtimeMs > maxAgeMs) {
+            await fs.unlink(filePath);
+            cleaned++;
+          }
+        } catch {
+          // File may have been removed already
+        }
+      }
+    }
+    
+    if (cleaned > 0) {
+      log('info', `[Voice] Cleaned up ${cleaned} orphaned temp file(s)`);
+    }
+  } catch (error) {
+    // Upload directory may not exist yet
+    if (error.code !== 'ENOENT') {
+      log('warn', `[Voice] Temp cleanup error: ${error.message}`);
+    }
+  }
+}
+
+// ===========================================
+// Wake Word Handling
+// ===========================================
+
+function buildWakePatterns(word) {
+  const escaped = word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return [
+    new RegExp(`^hey[\\s,\\.]*${escaped}`, 'i'),
+    new RegExp(`^hi[\\s,\\.]*${escaped}`, 'i'),
+    new RegExp(`^yo[\\s,\\.]*${escaped}`, 'i'),
+    new RegExp(`^${escaped}[\\s,\\.]`, 'i'),
+    new RegExp(`^okay[\\s,\\.]*${escaped}`, 'i'),
+    new RegExp(`^ok[\\s,\\.]*${escaped}`, 'i'),
+    new RegExp(`${escaped}[\\s,\\.]+`, 'i'),
+  ];
+}
+
+function hasWakeWord(text, patterns) {
+  return patterns.some(pattern => pattern.test(text.trim()));
+}
+
+function stripWakeWord(text, patterns) {
+  let cleaned = text.trim();
+  for (const pattern of patterns) {
+    cleaned = cleaned.replace(pattern, '').trim();
+  }
+  return cleaned.replace(/^[,.\s]+/, '').trim();
+}
+
+/**
+ * Setup voice routes
+ * @param {Express} app - Express app instance
+ * @param {Object} context - Request context
+ */
+export function setupVoiceRoutes(app, context) {
+  const {
+    audioUpload,
+    transcribe,
+    chat,
+    chatWithParallelTTS,
+    generateTTS,
+    log,
+    config,
+    requestHelpers,
+    broadcastToAll,
+  } = context;
+
+  const { canAcceptRequest, startRequest, endRequest, activeRequests, MAX_CONCURRENT_REQUESTS } = requestHelpers;
+  const { ALLOWED_AUDIO_TYPES, WAKE_WORD, SESSION_USER, UPLOAD_DIR } = config;
+
+  const WAKE_PATTERNS = buildWakePatterns(WAKE_WORD);
+
+  // Clean up orphaned temp files on startup
+  if (UPLOAD_DIR) {
+    cleanupOrphanedTempFiles(UPLOAD_DIR, 60 * 60 * 1000, log);
+  }
+
+  // ===========================================
+  // Voice Chat
+  // ===========================================
+
+  app.post('/api/voice', requirePremium('Voice chat'), (req, res) => {
+    audioUpload(req, res, async (err) => {
+      if (err) {
+        return badRequest(res, 'Upload failed: ' + err.message, ErrorCodes.UPLOAD_FAILED);
+      }
+
+      if (!canAcceptRequest()) {
+        log('warn', `Rejecting request - at capacity (${activeRequests.size}/${MAX_CONCURRENT_REQUESTS})`);
+        return res.status(429).json({ error: true, message: 'Server busy. Please wait a moment.', code: 'RATE_LIMITED' });
+      }
+
+      const requestId = startRequest('voice');
+      const startTime = Date.now();
+      const handsFree = req.body?.handsFree === 'true';
+      
+      // Track temp files for cleanup
+      const tempFiles = createTempFileTracker();
+
+      try {
+        if (!req.file) {
+          return badRequest(res, 'No audio file provided', ErrorCodes.MISSING_FIELD);
+        }
+
+        // Track the original uploaded file
+        tempFiles.add(req.file.path);
+        
+        log('debug', `[Voice] Received audio: ${req.file.size} bytes (handsFree: ${handsFree})`);
+
+        // Validate audio type
+        const audioBuffer = await fs.readFile(req.file.path);
+        const detectedAudioType = await fileTypeFromBuffer(audioBuffer);
+
+        if (!detectedAudioType || !ALLOWED_AUDIO_TYPES.includes(detectedAudioType.mime)) {
+          log('warn', `[Voice] Rejected invalid audio type: ${detectedAudioType?.mime || 'unknown'}`);
+          return badRequest(res, 'Invalid audio type', ErrorCodes.INVALID_FILE_TYPE);
+        }
+
+        // Rename with proper extension (sanitize originalname to prevent path traversal)
+        const safeOriginalname = sanitizeFilename(req.file.originalname || '');
+        const ext = safeOriginalname?.endsWith('.mp4') ? '.mp4' :
+                    safeOriginalname?.endsWith('.m4a') ? '.m4a' :
+                    req.file.mimetype?.includes('mp4') ? '.mp4' :
+                    req.file.mimetype?.includes('webm') ? '.webm' : '.webm';
+        const inputPath = `${req.file.path}${ext}`;
+        await fs.rename(req.file.path, inputPath);
+        
+        // Update tracker: add renamed path (original path no longer exists after rename)
+        tempFiles.add(inputPath);
+
+        // Transcribe
+        log('debug', 'Transcribing with OpenAI Whisper...');
+        if (broadcastToAll) broadcastToAll({ type: 'voiceStatus', stage: 'transcribing', label: 'Transcribing speech...' });
+        const transcription = await transcribe(inputPath);
+        log('debug', `Transcription: "${transcription}"`);
+
+        if (!transcription || transcription.length < 2) {
+          return res.json({
+            transcription: '',
+            response: '',
+            audioUrl: null,
+            message: 'No speech detected'
+          });
+        }
+
+        // Check wake word in hands-free mode
+        if (handsFree && !hasWakeWord(transcription, WAKE_PATTERNS)) {
+          log('debug', 'No wake word detected, ignoring');
+          return res.json({ ignored: true });
+        }
+
+        const message = handsFree ? (stripWakeWord(transcription, WAKE_PATTERNS) || "Hey, what's up?") : transcription;
+
+        // Get response with parallel TTS
+        if (broadcastToAll) broadcastToAll({ type: 'voiceStatus', stage: 'thinking', label: 'Thinking...' });
+        let response = '';
+        let audioUrl = null;
+        let audioUrls = [];
+        
+        try {
+          const result = await chatWithParallelTTS(message, SESSION_USER);
+          response = result.response;
+          audioUrl = result.audioUrl;
+          audioUrls = result.audioUrls || [];
+        } catch (chatError) {
+          log('error', 'Chat with parallel TTS failed, falling back:', chatError.message);
+          try {
+            response = await chat(message, SESSION_USER, 'voice');
+            try {
+              audioUrl = await generateTTS(response);
+              audioUrls = audioUrl ? [audioUrl] : [];
+            } catch (ttsError) {
+              log('error', 'TTS fallback error:', ttsError.message);
+            }
+          } catch (fallbackError) {
+            throw fallbackError;
+          }
+        }
+
+        if (broadcastToAll) broadcastToAll({ type: 'voiceStatus', stage: 'complete', label: 'Done' });
+        const elapsed = Date.now() - startTime;
+        log('info', `[Voice] Complete in ${elapsed}ms (${audioUrls.length} audio chunks)`);
+
+        res.json({
+          transcription: handsFree ? message : transcription,
+          response,
+          audioUrl,
+          audioUrls,
+          elapsed
+        });
+
+      } catch (error) {
+        log('error', 'Voice chat error:', error);
+        const errorMessage = process.env.NODE_ENV === 'production' 
+          ? 'Voice processing failed'
+          : error.message;
+        internalError(res, errorMessage, ErrorCodes.INTERNAL_ERROR);
+      } finally {
+        // Always cleanup temp files, regardless of success or error
+        await tempFiles.cleanup();
+        endRequest(requestId);
+      }
+    });
+  });
+}