@mooncompany/uplink-chat 0.5.0

package/server/routes/webhooks.js

@@ -0,0 +1,203 @@
+/**
+ * Webhook Routes - External integrations and OpenClaw push
+ */
+
+import crypto from 'crypto';
+import { badRequest, unauthorized, internalError, ErrorCodes } from '../../utils/errors.js';
+
+/**
+ * Setup webhook routes
+ * @param {Express} app - Express app instance
+ * @param {Object} context - Request context
+ */
+export function setupWebhookRoutes(app, context) {
+  const {
+    verifyWebhookToken,
+    fetch: fetchWithTimeout,
+    broadcastOpenClawPush,
+    broadcastToAll,
+    wsClients,
+    log,
+    config,
+  } = context;
+
+  const { GATEWAY_URL, GATEWAY_TOKEN, OPENCLAW_CALLBACK_SECRET, REQUEST_TIMEOUT } = config;
+
+  // ===========================================
+  // OpenClaw Channel Push
+  // ===========================================
+
+  app.post('/api/openclaw/push', async (req, res) => {
+    const headerSecret = req.get('X-Uplink-Secret') || '';
+    
+    // Validate callback secret using timing-safe comparison
+    let isValid = false;
+    if (OPENCLAW_CALLBACK_SECRET && headerSecret) {
+      const providedBuf = Buffer.from(headerSecret);
+      const expectedBuf = Buffer.from(OPENCLAW_CALLBACK_SECRET);
+      if (providedBuf.length === expectedBuf.length) {
+        isValid = crypto.timingSafeEqual(providedBuf, expectedBuf);
+      }
+    }
+    
+    if (!isValid) {
+      log('warn', '[OpenClaw Push] Unauthorized request - invalid or missing secret');
+      return unauthorized(res, 'Invalid or missing secret');
+    }
+    
+    const payload = req.body || {};
+    const allowedTypes = new Set(['message', 'chunk', 'tool', 'complete', 'error']);
+    const hasValidType = allowedTypes.has(payload.type);
+    const hasSatelliteId = typeof payload.satelliteId === 'string' && payload.satelliteId.length > 0;
+    const hasTimestamp = typeof payload.timestamp === 'number';
+    
+    if (!hasValidType || !hasSatelliteId || !hasTimestamp) {
+      log('warn', `[OpenClaw Push] Invalid payload: type=${payload.type}, satelliteId=${payload.satelliteId}`);
+      return badRequest(res, 'Invalid payload: type, satelliteId, and timestamp required', ErrorCodes.VALIDATION_ERROR);
+    }
+    
+    // Broadcast to WebSocket clients
+    broadcastOpenClawPush(payload);
+    
+    // Check if any WebSocket clients received the message
+    const wsDelivered = wsClients.size > 0;
+    
+    if (!wsDelivered && payload.type === 'message' && payload.message) {
+      // No WebSocket clients connected
+      
+      // 1. Queue message for when they open Uplink
+      const { addMissedMessage } = await import('./missed-messages.js');
+      await addMissedMessage({
+        type: payload.type,
+        message: payload.message,
+        satelliteId: payload.satelliteId,
+        author: 'Assistant'
+      });
+      log('debug', `[OpenClaw Push] Queued missed message for satellite ${payload.satelliteId}`);
+      
+      // 2. Send push notification to wake them up
+      try {
+        const { sendPushNotification } = await import('./push.js');
+        const pushResult = await sendPushNotification('default', {
+          title: 'Uplink',
+          body: payload.message.length > 100 ? payload.message.substring(0, 100) + '...' : payload.message,
+          url: '/',
+          satelliteId: payload.satelliteId,
+          tag: 'uplink-message'
+        });
+        if (pushResult.ok) {
+          log('debug', `[OpenClaw Push] Sent push notification for satellite ${payload.satelliteId}`);
+        }
+      } catch (pushErr) {
+        log('debug', `[OpenClaw Push] Push notification failed: ${pushErr.message}`);
+      }
+    }
+    
+    log('debug', `[OpenClaw Push] Broadcasted ${payload.type} for satellite ${payload.satelliteId} (WS: ${wsDelivered})`);
+    
+    return res.json({ ok: true });
+  });
+
+  // ===========================================
+  // Webhooks
+  // ===========================================
+
+  app.post('/api/webhook/message', verifyWebhookToken, async (req, res) => {
+    try {
+      const { message, source = 'webhook', metadata = {} } = req.body;
+      
+      if (!message) {
+        return badRequest(res, 'message required', ErrorCodes.MISSING_FIELD);
+      }
+      
+      // Validate message length (security)
+      if (message.length > config.MAX_INPUT_LENGTHS.MESSAGE) {
+        return badRequest(res, `message exceeds maximum length of ${config.MAX_INPUT_LENGTHS.MESSAGE} characters`, ErrorCodes.VALIDATION_ERROR);
+      }
+      
+      log('info', `[Webhook] Message from ${source}: "${message.substring(0, 50)}..."`);
+      
+      const formattedMessage = `[External: ${source}] ${message}`;
+      
+      const chatResponse = await fetchWithTimeout(`${GATEWAY_URL}/v1/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${GATEWAY_TOKEN}`
+        },
+        body: JSON.stringify({
+          model: 'openclaw',
+          user: 'webhook',
+          messages: [{ role: 'user', content: formattedMessage }]
+        })
+      }, REQUEST_TIMEOUT);
+      
+      if (!chatResponse.ok) {
+        throw new Error(`Gateway error: ${chatResponse.status}`);
+      }
+      
+      const data = await chatResponse.json();
+      const response = data.choices?.[0]?.message?.content || 'No response';
+      
+      broadcastToAll(JSON.stringify({
+        type: 'webhook_message',
+        source,
+        message,
+        response,
+        metadata,
+        timestamp: Date.now()
+      }));
+      
+      res.json({ ok: true, response });
+    } catch (e) {
+      log('error', '[Webhook] Message error:', e.message);
+      internalError(res, e.message, ErrorCodes.GATEWAY_ERROR);
+    }
+  });
+
+  app.post('/api/webhook/notify', verifyWebhookToken, async (req, res) => {
+    try {
+      const { title, body, type = 'info', data = {} } = req.body;
+      
+      if (!title && !body) {
+        return badRequest(res, 'title or body required', ErrorCodes.MISSING_FIELD);
+      }
+      
+      log('info', `[Webhook] Notification: ${title || body}`);
+      
+      broadcastToAll(JSON.stringify({
+        type: 'notification',
+        notification: { title, body, type, data, timestamp: Date.now() }
+      }));
+      
+      res.json({ ok: true, delivered: wsClients.size });
+    } catch (e) {
+      log('error', '[Webhook] Notify error:', e.message);
+      internalError(res, e.message, ErrorCodes.INTERNAL_ERROR);
+    }
+  });
+
+  app.post('/api/webhook/trigger', verifyWebhookToken, async (req, res) => {
+    try {
+      const { action, params = {} } = req.body;
+      
+      if (!action) {
+        return badRequest(res, 'action required', ErrorCodes.MISSING_FIELD);
+      }
+      
+      log('info', `[Webhook] Trigger: ${action}`);
+      
+      broadcastToAll(JSON.stringify({
+        type: 'trigger',
+        action,
+        params,
+        timestamp: Date.now()
+      }));
+      
+      res.json({ ok: true, action, delivered: wsClients.size });
+    } catch (e) {
+      log('error', '[Webhook] Trigger error:', e.message);
+      internalError(res, e.message, ErrorCodes.INTERNAL_ERROR);
+    }
+  });
+}

package/server/routes.js

@@ -0,0 +1,206 @@
+/**
+ * Routes Module - API endpoints orchestrator
+ * 
+ * This module coordinates all route handlers by importing modular route files
+ * and passing shared dependencies to each.
+ */
+
+import multer from 'multer';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+import { log, fetchWithTimeout } from './utils.js';
+import { transcribe, chat, chatWithParallelTTS, generateTTS } from './chat.js';
+import { isPrivateIP, verifyWebhookToken, strictLimiter } from './middleware.js';
+import { broadcastOpenClawPush, broadcastToAll, wsClients } from './websocket/index.js';
+import { sendMessage } from './channel.js';
+import { getClientConfig, saveConfig, needsOnboarding, loadConfig } from './runtime-config.js';
+import { createRequestContext } from './context.js';
+import {
+  GATEWAY_URL, GATEWAY_TOKEN,
+  ALLOWED_IMAGE_TYPES, ALLOWED_AUDIO_TYPES,
+  ROOT_DIR, ACTIVITY_FILE, MESSAGES_FILE,
+  MAX_ACTIVITY_ITEMS, MAX_SYNC_MESSAGES,
+  WAKE_WORD, TTS_VOICE_NAME, SESSION_USER,
+  OPENCLAW_CALLBACK_SECRET, REQUEST_TIMEOUT
+} from './config.js';
+
+// Route modules
+import {
+  setupVoiceRoutes,
+  setupChatRoutes,
+  setupMediaRoutes,
+  setupWebhookRoutes,
+  setupConfigRoutes,
+  setupStatusRoutes,
+  setupSatelliteRoutes,
+  setupMissedMessagesRoutes,
+  addMissedMessage,
+  setupPushRoutes,
+  sendPushNotification,
+  setupSTTRoutes,
+  setupFileRoutes,
+  setupAgentRoutes,
+  setupPremiumRoutes,
+  setupArtifactsRoutes,
+} from './routes/index.js';
+import { initPremium } from './premium/index.js';
+
+// ===========================================
+// Directory Setup
+// ===========================================
+
+const TEMP_DIR = path.join(os.tmpdir(), 'voice-chat');
+const UPLOADS_DIR = path.join(ROOT_DIR, 'uploads');
+
+// ===========================================
+// Multer configurations
+// ===========================================
+
+const audioUpload = multer({
+  dest: TEMP_DIR,
+  limits: { fileSize: 25 * 1024 * 1024 }
+}).single('audio');
+
+const imageUpload = multer({
+  dest: path.join(TEMP_DIR, 'images'),
+  limits: { fileSize: 10 * 1024 * 1024 }
+}).single('image');
+
+const videoUpload = multer({
+  dest: path.join(TEMP_DIR, 'videos'),
+  limits: { fileSize: 50 * 1024 * 1024 }
+}).single('video');
+
+const fileUpload = multer({
+  dest: path.join(TEMP_DIR, 'files'),
+  limits: { fileSize: 10 * 1024 * 1024 }
+}).single('file');
+
+// ===========================================
+// Message Sync Helper (sequential write queue to prevent race conditions)
+// ===========================================
+
+let syncWriteQueue = Promise.resolve();
+
+export async function saveMessageToSync(role, content, timestamp = new Date().toISOString()) {
+  syncWriteQueue = syncWriteQueue.then(async () => {
+    try {
+      let messages = [];
+      try {
+        const fileContent = await fs.readFile(MESSAGES_FILE, 'utf8');
+        messages = JSON.parse(fileContent);
+      } catch (readError) { /* File may not exist yet */ }
+
+      messages.push({
+        id: Date.now(),
+        role,
+        content,
+        timestamp
+      });
+
+      if (messages.length > MAX_SYNC_MESSAGES) {
+        messages = messages.slice(-MAX_SYNC_MESSAGES);
+      }
+
+      await fs.writeFile(MESSAGES_FILE, JSON.stringify(messages, null, 2));
+    } catch (err) {
+      log('error', 'Failed to save message to sync:', err.message);
+    }
+  }).catch(err => {
+    log('error', 'Sync write queue error:', err.message);
+  });
+  return syncWriteQueue;
+}
+
+// ===========================================
+// Setup Routes - Main Orchestrator
+// ===========================================
+
+export function setupRoutes(app, requestHelpers) {
+  // Shared configuration object
+  const config = {
+    GATEWAY_URL,
+    GATEWAY_TOKEN,
+    ALLOWED_IMAGE_TYPES,
+    ALLOWED_AUDIO_TYPES,
+    ACTIVITY_FILE,
+    MESSAGES_FILE,
+    MAX_ACTIVITY_ITEMS,
+    MAX_SYNC_MESSAGES,
+    WAKE_WORD,
+    TTS_VOICE_NAME,
+    SESSION_USER,
+    OPENCLAW_CALLBACK_SECRET,
+    REQUEST_TIMEOUT,
+  };
+
+  // Create standardized request context for all route modules
+  const context = createRequestContext({
+    // Configuration
+    config,
+    
+    // Core utilities
+    log,
+    fetchWithTimeout,
+    
+    // Chat functions
+    transcribe,
+    chat,
+    chatWithParallelTTS,
+    generateTTS,
+    sendMessage,
+    saveMessageToSync,
+    
+    // WebSocket broadcasting
+    broadcastOpenClawPush,
+    broadcastToAll,
+    wsClients,
+    
+    // Middleware
+    verifyWebhookToken,
+    strictLimiter,
+    isPrivateIP,
+    
+    // Config management
+    loadConfig,
+    getClientConfig,
+    saveConfig,
+    needsOnboarding,
+    
+    // File uploads
+    audioUpload,
+    imageUpload,
+    videoUpload,
+    fileUpload,
+    
+    // Directories
+    uploadsDir: UPLOADS_DIR,
+    tempDir: TEMP_DIR,
+    
+    // Request tracking
+    requestHelpers,
+  });
+
+  // Initialize premium from stored license key
+  initPremium();
+
+  // Initialize all route modules with standardized context
+  setupPremiumRoutes(app, context);
+  setupStatusRoutes(app, context);
+  setupSatelliteRoutes(app, context);
+  setupVoiceRoutes(app, context);
+  setupChatRoutes(app, context);
+  setupMediaRoutes(app, context);
+  setupWebhookRoutes(app, context);
+  setupConfigRoutes(app, context);
+  setupMissedMessagesRoutes(app, context);
+  setupPushRoutes(app, context);
+  setupSTTRoutes(app, context);
+  setupFileRoutes(app, context);
+  setupAgentRoutes(app, context);
+  setupArtifactsRoutes(app, context);
+
+  log('info', 'Routes initialized: premium, status, satellite, voice, chat, media, webhooks, config, missed-messages, push, stt, files, agents, artifacts');
+}