@mooncompany/uplink-chat 0.5.0

package/server/chat.js

@@ -0,0 +1,270 @@
+/**
+ * Chat Module - AI chat functions, transcription, parallel TTS
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { log, fetchWithTimeout, withRetry } from './utils.js';
+import { textToSpeech, textToSpeechLocal, textToSpeechEdge, textToSpeechOpenAI, textToSpeechPiper, extractFirstSentence } from './tts.js';
+import { GATEWAY_URL as STATIC_GATEWAY_URL, GATEWAY_TOKEN as STATIC_GATEWAY_TOKEN, ROOT_DIR, SESSION_USER, REQUEST_TIMEOUT } from './config.js';
+import { loadConfig } from './runtime-config.js';
+
+/**
+ * Get gateway URL and token dynamically (includes auto-discovered values)
+ */
+async function getGatewayConfig() {
+  try {
+    const config = await loadConfig();
+    return {
+      GATEWAY_URL: config.gatewayUrl || STATIC_GATEWAY_URL,
+      GATEWAY_TOKEN: config.gatewayToken || STATIC_GATEWAY_TOKEN,
+    };
+  } catch {
+    return { GATEWAY_URL: STATIC_GATEWAY_URL, GATEWAY_TOKEN: STATIC_GATEWAY_TOKEN };
+  }
+}
+import { transcribe } from './stt/index.js';
+import { broadcastToAll } from './websocket/index.js';
+
+const AUDIO_OUTPUT_DIR = path.join(ROOT_DIR, 'public', 'audio');
+
+// Helper to pick the right TTS function based on config
+async function getTTSFunction() {
+  const config = await loadConfig();
+  switch (config.ttsProvider) {
+    case 'local':
+      return textToSpeechLocal;
+    case 'edge':
+      return textToSpeechEdge;
+    case 'openai':
+      return textToSpeechOpenAI;
+    case 'piper':
+      return textToSpeechPiper;
+    case 'elevenlabs':
+    default:
+      return textToSpeech;
+  }
+}
+
+// Re-export transcribe from STT module (used by routes.js deps)
+export { transcribe };
+
+// ===========================================
+// Basic Chat (Non-streaming)
+// ===========================================
+
+export async function chat(message, sessionUser = SESSION_USER, mode = 'voice') {
+  return withRetry(async () => {
+    const gw = await getGatewayConfig();
+    const prefix = mode === 'voice'
+      ? '[Voice chat - keep response brief and conversational, 1-2 sentences max] '
+      : '[Text chat via Uplink] ';
+
+    // Use canonical session key format matching channel.js
+    const sessionKey = 'agent:main:main';
+
+    const response = await fetchWithTimeout(`${gw.GATEWAY_URL}/v1/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${gw.GATEWAY_TOKEN}`,
+        'x-openclaw-session-key': sessionKey
+      },
+      body: JSON.stringify({
+        model: 'openclaw',
+        user: sessionUser,
+        messages: [{
+          role: 'user',
+          content: `${prefix}${message}`
+        }]
+      })
+    }, REQUEST_TIMEOUT);
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Chat API error: ${response.status} - ${text}`);
+    }
+
+    const data = await response.json();
+    return data.choices?.[0]?.message?.content || 'No response';
+  }, { maxRetries: 3 });
+}
+
+// ===========================================
+// Parallel TTS Chat (Streaming with early TTS)
+// ===========================================
+
+export async function chatWithParallelTTS(message, sessionUser = SESSION_USER) {
+  const gw = await getGatewayConfig();
+  const prefix = '[Voice chat - respond naturally and conversationally] ';
+  
+  // Use canonical session key format matching channel.js
+  const sessionKey = 'agent:main:main';
+
+  const response = await fetchWithTimeout(`${gw.GATEWAY_URL}/v1/chat/completions`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${gw.GATEWAY_TOKEN}`,
+      'x-openclaw-session-key': sessionKey
+    },
+    body: JSON.stringify({
+      model: 'openclaw',
+      user: sessionUser,
+      stream: true,
+      messages: [{
+        role: 'user',
+        content: `${prefix}${message}`
+      }]
+    })
+  }, REQUEST_TIMEOUT);
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Chat API error: ${response.status} - ${text}`);
+  }
+
+  let fullResponse = '';
+  let processedUpTo = 0; // Track how much text we've already sent to TTS
+  const ttsPromises = []; // All TTS generation promises
+  let sentenceBatch = []; // Accumulate sentences before firing TTS
+  let batchCharCount = 0;
+  let isFirstChunk = true;
+  
+  // Batching config:
+  // First chunk: send after 1 sentence (fast first audio)
+  // Subsequent chunks: batch 2-3 sentences (~200 chars) for efficiency
+  const BATCH_TARGET_CHARS = 200;
+  const MAX_BATCH_SENTENCES = 3;
+
+  function flushBatch() {
+    if (sentenceBatch.length === 0) return;
+    const text = sentenceBatch.join(' ');
+    const chunkIndex = ttsPromises.length;
+    log('debug', `[Chunked TTS] Chunk ${chunkIndex + 1} (${sentenceBatch.length} sentences, ${text.length} chars): "${text.substring(0, 80)}..."`);
+    
+    // Broadcast "speaking" status on first TTS chunk
+    if (chunkIndex === 0) {
+      try { broadcastToAll({ type: 'voiceStatus', stage: 'speaking', label: 'Generating speech...' }); } catch (e) {}
+    }
+    
+    const promise = (async () => {
+      const tts = await getTTSFunction();
+      return tts(text, AUDIO_OUTPUT_DIR);
+    })().catch(ttsError => {
+      log('error', `[Chunked TTS] Chunk ${chunkIndex + 1} failed:`, ttsError.message);
+      return null;
+    });
+    ttsPromises.push(promise);
+    sentenceBatch = [];
+    batchCharCount = 0;
+    isFirstChunk = false;
+  }
+  
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const data = line.slice(6);
+          if (data === '[DONE]') continue;
+          try {
+            const parsed = JSON.parse(data);
+            const content = parsed.choices?.[0]?.delta?.content || '';
+            if (content) {
+              fullResponse += content;
+              
+              // Extract ALL complete sentences from unprocessed text
+              let keepExtracting = true;
+              while (keepExtracting) {
+                const unprocessed = fullResponse.slice(processedUpTo);
+                const extracted = extractFirstSentence(unprocessed);
+                if (extracted) {
+                  const sentence = extracted.sentence;
+                  // Move processedUpTo past this sentence
+                  const sentenceEnd = unprocessed.indexOf(sentence) + sentence.length;
+                  processedUpTo += sentenceEnd;
+                  // Skip whitespace
+                  while (processedUpTo < fullResponse.length && /\s/.test(fullResponse[processedUpTo])) processedUpTo++;
+                  
+                  sentenceBatch.push(sentence);
+                  batchCharCount += sentence.length;
+                  
+                  // Flush batch: immediately for first chunk, or when batch is full
+                  if (isFirstChunk || batchCharCount >= BATCH_TARGET_CHARS || sentenceBatch.length >= MAX_BATCH_SENTENCES) {
+                    flushBatch();
+                  }
+                } else {
+                  keepExtracting = false;
+                }
+              }
+            }
+          } catch (parseError) {
+            // Skip unparseable chunks
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  // Flush any remaining batched sentences
+  flushBatch();
+
+  // Handle any remaining text that didn't end with punctuation
+  const remaining = fullResponse.slice(processedUpTo).trim();
+  if (remaining) {
+    const chunkIndex = ttsPromises.length;
+    log('debug', `[Chunked TTS] Final chunk ${chunkIndex + 1}: "${remaining}"`);
+    const promise = (async () => {
+      const tts = await getTTSFunction();
+      return tts(remaining, AUDIO_OUTPUT_DIR);
+    })().catch(ttsError => {
+      log('error', `[Chunked TTS] Final chunk failed:`, ttsError.message);
+      return null;
+    });
+    ttsPromises.push(promise);
+  }
+
+  // If no sentences were extracted at all, TTS the whole thing
+  if (ttsPromises.length === 0 && fullResponse) {
+    try {
+      const tts = await getTTSFunction();
+      const url = await tts(fullResponse, AUDIO_OUTPUT_DIR);
+      ttsPromises.push(Promise.resolve(url));
+    } catch (ttsError) {
+      log('error', '[Chunked TTS] Full response TTS failed:', ttsError.message);
+    }
+  }
+
+  // Wait for all TTS chunks and collect URLs (in order)
+  const audioUrls = (await Promise.all(ttsPromises)).filter(Boolean);
+  
+  log('info', `[Chunked TTS] Generated ${audioUrls.length} audio chunks for response`);
+
+  return {
+    response: fullResponse || 'No response',
+    audioUrl: audioUrls[0] || null,  // Backward compat: first chunk
+    audioUrls                         // New: all chunks for queue
+  };
+}
+
+// ===========================================
+// TTS Wrapper (for routes)
+// ===========================================
+
+export async function generateTTS(text) {
+  const tts = await getTTSFunction();
+  return tts(text, AUDIO_OUTPUT_DIR);
+}

package/server/config-store.js

@@ -0,0 +1,362 @@
+/**
+ * Config Store Module
+ * ===================
+ * Encrypted configuration storage for Uplink.
+ * Replaces .env file editing with a secure, file-based config system.
+ * 
+ * Storage layout:
+ *   config/config.json  — Non-sensitive preferences + encrypted secrets blob
+ *   config/config.backup.json — Auto-backup before migrations
+ * 
+ * Uses AES-256-GCM with scrypt key derivation for encryption.
+ */
+
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { ROOT_DIR } from './config.js';
+import { createLogger } from './logger.js';
+
+const log = createLogger('config-store');
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const CONFIG_DIR = path.join(ROOT_DIR, 'config');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const BACKUP_FILE = path.join(CONFIG_DIR, 'config.backup.json');
+
+const ALGORITHM = 'aes-256-gcm';
+const SCRYPT_N = 16384;
+const SCRYPT_R = 8;
+const SCRYPT_P = 1;
+const KEY_LEN = 32;
+const SALT_LEN = 32;
+const IV_LEN = 16;
+
+// ---------------------------------------------------------------------------
+// Default config structure
+// ---------------------------------------------------------------------------
+const DEFAULT_CONFIG = {
+  version: 1,
+  onboarding: {
+    completed: false,
+    currentStep: 0,
+    steps: {},
+  },
+  preferences: {
+    theme: 'dark',
+    fontSize: 14,
+    language: 'en',
+    notifications: true,
+  },
+  connections: {
+    gatewayUrl: '',
+    gatewayToken: '',
+    autoReconnect: true,
+    reconnectIntervalMs: 5000,
+  },
+  voice: {
+    enabled: false,
+    ttsProvider: 'elevenlabs',
+    ttsVoice: '',
+    volume: 0.8,
+    speed: 1.0,
+  },
+  security: {
+    passwordHash: '',
+    lockTimeoutMin: 15,
+    requirePasswordOnStart: true,
+  },
+};
+
+// In-memory config state
+let _config = structuredClone(DEFAULT_CONFIG);
+let _initialized = false;
+
+// ---------------------------------------------------------------------------
+// Crypto helpers
+// ---------------------------------------------------------------------------
+
+function deriveKey(password, salt) {
+  return crypto.scryptSync(password, salt, KEY_LEN, {
+    N: SCRYPT_N,
+    r: SCRYPT_R,
+    p: SCRYPT_P,
+  });
+}
+
+function encrypt(plaintext, password) {
+  const salt = crypto.randomBytes(SALT_LEN);
+  const iv = crypto.randomBytes(IV_LEN);
+  const key = deriveKey(password, salt);
+
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+  const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+  const tag = cipher.getAuthTag();
+
+  return {
+    salt: salt.toString('base64'),
+    iv: iv.toString('base64'),
+    tag: tag.toString('base64'),
+    ciphertext: encrypted.toString('base64'),
+  };
+}
+
+function decrypt(envelope, password) {
+  const salt = Buffer.from(envelope.salt, 'base64');
+  const iv = Buffer.from(envelope.iv, 'base64');
+  const tag = Buffer.from(envelope.tag, 'base64');
+  const data = Buffer.from(envelope.ciphertext, 'base64');
+  const key = deriveKey(password, salt);
+
+  const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+  decipher.setAuthTag(tag);
+
+  const decrypted = Buffer.concat([decipher.update(data), decipher.final()]);
+  return decrypted.toString('utf8');
+}
+
+// ---------------------------------------------------------------------------
+// File I/O
+// ---------------------------------------------------------------------------
+
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+function readConfigFile() {
+  if (!fs.existsSync(CONFIG_FILE)) return null;
+  try {
+    const raw = fs.readFileSync(CONFIG_FILE, 'utf8');
+    return JSON.parse(raw);
+  } catch (err) {
+    log.error('Failed to read config file:', err.message);
+    return null;
+  }
+}
+
+function writeConfigFile(data) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function backupConfigFile() {
+  if (fs.existsSync(CONFIG_FILE)) {
+    ensureConfigDir();
+    fs.copyFileSync(CONFIG_FILE, BACKUP_FILE);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/** Initialize the config store. Loads from disk or creates defaults. */
+export function init() {
+  if (_initialized) return;
+
+  const stored = readConfigFile();
+  if (stored) {
+    // Merge stored config over defaults (handles new fields added in updates)
+    _config = mergeDeep(structuredClone(DEFAULT_CONFIG), stored);
+    log.info('Loaded configuration from disk');
+  } else {
+    _config = structuredClone(DEFAULT_CONFIG);
+    log.info('No config file found, using defaults');
+  }
+  _initialized = true;
+}
+
+/** Check if config store has been initialized */
+export function isInitialized() {
+  return _initialized;
+}
+
+/** Check if onboarding has been completed */
+export function isOnboarded() {
+  return _config.onboarding.completed;
+}
+
+/** Return the full internal config (use with care — contains secrets). */
+export function getRaw() {
+  return structuredClone(_config);
+}
+
+/** Return a client-safe copy with sensitive fields stripped. */
+export function getSafe() {
+  const safe = structuredClone(_config);
+  if (safe.connections) delete safe.connections.gatewayToken;
+  if (safe.security) delete safe.security.passwordHash;
+  return safe;
+}
+
+/** Get a single config value by dot-path (e.g. 'connections.gatewayUrl') */
+export function get(keyPath) {
+  const parts = keyPath.split('.');
+  let current = _config;
+  for (const part of parts) {
+    if (current === null || current === undefined) return undefined;
+    current = current[part];
+  }
+  return current;
+}
+
+/** Set a single config value by dot-path */
+export function set(keyPath, value) {
+  const parts = keyPath.split('.');
+  let current = _config;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (current[parts[i]] === undefined) current[parts[i]] = {};
+    current = current[parts[i]];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+
+/** Merge a partial object into a config section. Returns updated safe config. */
+export function updateSection(section, partial) {
+  if (!_config[section] || typeof _config[section] !== 'object') {
+    throw new Error(`Unknown config section: ${section}`);
+  }
+  Object.assign(_config[section], partial);
+  return getSafe();
+}
+
+/** Save onboarding step data */
+export function saveOnboardingStep(stepNumber, data) {
+  _config.onboarding.steps[stepNumber] = data;
+  _config.onboarding.currentStep = Math.max(
+    _config.onboarding.currentStep,
+    Number(stepNumber),
+  );
+}
+
+/** Mark onboarding complete */
+export function completeOnboarding() {
+  _config.onboarding.completed = true;
+}
+
+/** Persist config to disk */
+export async function save() {
+  backupConfigFile();
+  writeConfigFile(_config);
+}
+
+/** Hash and store a new master password */
+export function setPassword(password) {
+  const salt = crypto.randomBytes(SALT_LEN);
+  const hash = deriveKey(password, salt).toString('hex');
+  _config.security.passwordHash = salt.toString('hex') + ':' + hash;
+}
+
+/** Verify a password against stored hash */
+export function verifyPassword(password) {
+  if (!_config.security.passwordHash) return true; // no password set
+  const [saltHex, hashHex] = _config.security.passwordHash.split(':');
+  const salt = Buffer.from(saltHex, 'hex');
+  const derived = deriveKey(password, salt).toString('hex');
+  return derived === hashHex;
+}
+
+/** Export encrypted config for backup/transfer */
+export function exportEncrypted(password) {
+  const plaintext = JSON.stringify(_config);
+  return {
+    version: 1,
+    exportedAt: new Date().toISOString(),
+    ...encrypt(plaintext, password),
+  };
+}
+
+/** Import and restore config from encrypted backup */
+export function importEncrypted(envelope, password) {
+  const plaintext = decrypt(envelope, password);
+  const parsed = JSON.parse(plaintext);
+  _config = mergeDeep(structuredClone(DEFAULT_CONFIG), parsed);
+  return getSafe();
+}
+
+/** Migrate settings from existing .env file */
+export function migrateFromEnv() {
+  const envPath = path.join(ROOT_DIR, '.env');
+  if (!fs.existsSync(envPath)) return false;
+
+  log.info('Found .env file, migrating...');
+
+  // Read current env vars (already loaded by dotenv in config.js)
+  const updates = {};
+
+  if (process.env.GATEWAY_URL) {
+    set('connections.gatewayUrl', process.env.GATEWAY_URL);
+  }
+  if (process.env.GATEWAY_TOKEN) {
+    set('connections.gatewayToken', process.env.GATEWAY_TOKEN);
+  }
+  if (process.env.ELEVENLABS_API_KEY) {
+    set('voice.enabled', true);
+    set('voice.ttsProvider', 'elevenlabs');
+  }
+  if (process.env.ELEVENLABS_VOICE_ID) {
+    set('voice.ttsVoice', process.env.ELEVENLABS_VOICE_ID);
+  }
+  if (process.env.SESSION_USER) {
+    set('preferences.sessionUser', process.env.SESSION_USER);
+  }
+  if (process.env.ASSISTANT_NAME) {
+    set('preferences.assistantName', process.env.ASSISTANT_NAME);
+  }
+
+  // Rename .env to .env.backup
+  const backupPath = path.join(ROOT_DIR, '.env.backup');
+  try {
+    fs.renameSync(envPath, backupPath);
+    log.info('.env renamed to .env.backup');
+  } catch (err) {
+    log.warn('Could not rename .env:', err.message);
+  }
+
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// Utility
+// ---------------------------------------------------------------------------
+
+/** Deep merge source into target (target values are overwritten) */
+function mergeDeep(target, source) {
+  for (const key of Object.keys(source)) {
+    if (
+      source[key] &&
+      typeof source[key] === 'object' &&
+      !Array.isArray(source[key]) &&
+      target[key] &&
+      typeof target[key] === 'object'
+    ) {
+      mergeDeep(target[key], source[key]);
+    } else {
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+
+export default {
+  init,
+  isInitialized,
+  isOnboarded,
+  getRaw,
+  getSafe,
+  get,
+  set,
+  updateSection,
+  saveOnboardingStep,
+  completeOnboarding,
+  save,
+  setPassword,
+  verifyPassword,
+  exportEncrypted,
+  importEncrypted,
+  migrateFromEnv,
+};