@mooncompany/uplink-chat 0.5.0

package/server/tts.js

@@ -0,0 +1,646 @@
+/**
+ * TTS Module - ElevenLabs, Edge TTS, and Local XTTS voice synthesis
+ */
+
+import { randomUUID } from 'crypto';
+import fs from 'fs/promises';
+import path from 'path';
+import { spawn } from 'child_process';
+import { createLogger } from './logger.js';
+
+const log = createLogger('TTS');
+
+// Edge TTS - optional, user must install: npm install node-edge-tts
+let EdgeTTS = null;
+try {
+  EdgeTTS = (await import('node-edge-tts')).EdgeTTS;
+} catch {
+  // Not installed - that's fine, it's optional
+}
+
+// TTS config from environment (fallbacks — runtime config takes priority)
+const ELEVENLABS_API_KEY = process.env.ELEVENLABS_API_KEY;
+const ELEVENLABS_VOICE_ID = process.env.ELEVENLABS_VOICE_ID;
+
+// Local TTS config - user must configure these in .env
+const LOCAL_TTS_SCRIPT = process.env.LOCAL_TTS_SCRIPT;
+const LOCAL_TTS_PYTHON = process.env.LOCAL_TTS_PYTHON;
+const LOCAL_TTS_URL = process.env.LOCAL_TTS_URL;
+
+// Edge TTS config (optional - user installs node-edge-tts themselves)
+const EDGE_TTS_VOICE = process.env.EDGE_TTS_VOICE || 'en-US-AriaNeural';
+
+// OpenAI TTS config
+const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+const OPENAI_TTS_VOICE = process.env.OPENAI_TTS_VOICE || 'nova'; // alloy, echo, fable, onyx, nova, shimmer
+const OPENAI_TTS_MODEL = process.env.OPENAI_TTS_MODEL || 'tts-1'; // tts-1, tts-1-hd
+
+// Piper TTS config (local, requires piper executable)
+const PIPER_EXECUTABLE = process.env.PIPER_EXECUTABLE || 'piper';
+const PIPER_MODEL = process.env.PIPER_MODEL; // Path to .onnx model file
+const PIPER_CONFIG = process.env.PIPER_CONFIG; // Optional: path to .json config
+
+// Lazy import runtime config to avoid circular deps
+let _loadConfig = null;
+async function getRuntimeConfig() {
+  if (!_loadConfig) {
+    const mod = await import('./runtime-config.js');
+    _loadConfig = mod.loadConfig;
+  }
+  return _loadConfig();
+}
+
+/**
+ * List available Edge TTS voices
+ * @returns {Promise<Array>} List of voice objects with Name, ShortName, Gender, Locale
+ */
+export async function listEdgeTTSVoices() {
+  if (!EdgeTTS) return [];
+  try {
+    const tts = new EdgeTTS();
+    const voices = await tts.getVoices();
+    return voices.map(v => ({
+      shortName: v.ShortName,
+      name: v.FriendlyName || v.ShortName,
+      gender: v.Gender,
+      locale: v.Locale,
+    }));
+  } catch (e) {
+    log.error('Failed to list Edge TTS voices:', e);
+    return [];
+  }
+}
+
+/**
+ * Clean text for speech synthesis
+ */
+export function cleanTextForTTS(text) {
+  return text
+    .replace(/\*\*/g, '')
+    .replace(/\*/g, '')
+    .replace(/`/g, '')
+    .replace(/\[.*?\]/g, '')
+    .replace(/#{1,6}\s/g, '')
+    .replace(/[\u{1F600}-\u{1F64F}]/gu, '') // Remove emojis
+    .replace(/[\u{1F300}-\u{1F5FF}]/gu, '')
+    .replace(/[\u{1F680}-\u{1F6FF}]/gu, '')
+    .replace(/[\u{2600}-\u{26FF}]/gu, '')
+    .trim()
+    .substring(0, 500); // Keep it short for faster TTS
+}
+
+/**
+ * Extract first sentence for parallel TTS
+ */
+export function extractFirstSentence(text) {
+  // Match sentence ending with . ! ? (optionally followed by closing quote/paren)
+  // Then followed by whitespace, newline, or end of string
+  const match = text.match(/^(.+?[.!?]["'»)…]?)(?:\s|$)/s);
+  if (match) {
+    return {
+      sentence: match[1].trim(),
+      remaining: text.slice(match[0].length).trim()
+    };
+  }
+  return null;
+}
+
+/**
+ * Generate TTS audio using ElevenLabs
+ * @param {string} text - Text to convert to speech
+ * @param {string} outputDir - Directory to save audio file
+ * @param {Object} options - Options
+ * @param {number} options.timeoutMs - Request timeout in milliseconds (default: 30000)
+ * @returns {Promise<string>} - URL path to the generated audio file
+ */
+export async function textToSpeech(text, outputDir, options = {}) {
+  const audioId = randomUUID();
+  const outputPath = path.join(outputDir, `${audioId}.mp3`);
+  const timeoutMs = options.timeoutMs || 30000;
+
+  await fs.mkdir(outputDir, { recursive: true });
+
+  const cleanText = cleanTextForTTS(text);
+
+  if (!cleanText) {
+    throw new Error('No text to speak');
+  }
+
+  // Check if TTS is configured
+  if (!isTTSConfigured()) {
+    throw new Error('TTS is not configured. Please set ELEVENLABS_API_KEY environment variable.');
+  }
+
+  // Create abort controller for timeout
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${ELEVENLABS_VOICE_ID}`, {
+      method: 'POST',
+      headers: {
+        'xi-api-key': ELEVENLABS_API_KEY,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        text: cleanText,
+        model_id: 'eleven_multilingual_v2',
+        voice_settings: {
+          stability: 0.48,
+          similarity_boost: 0.92,
+          style: 0.07,
+          use_speaker_boost: true
+        }
+      }),
+      signal: controller.signal
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      let errorMessage;
+      try {
+        const errorData = await response.json();
+        errorMessage = errorData.detail?.message || errorData.detail || JSON.stringify(errorData);
+      } catch {
+        errorMessage = await response.text();
+      }
+
+      // Log server-side for debugging
+      log.error(`ElevenLabs API error: ${response.status} - ${errorMessage}`);
+
+      // Return user-friendly error based on status code
+      if (response.status === 401) {
+        throw new Error('Text-to-speech service authentication failed. Please check your API key configuration.');
+      } else if (response.status === 429) {
+        throw new Error('Text-to-speech service is temporarily busy. Please try again in a moment.');
+      } else if (response.status >= 500) {
+        throw new Error('Text-to-speech service is experiencing issues. Please try again later.');
+      } else {
+        throw new Error('Failed to generate speech audio. Please try again.');
+      }
+    }
+
+    const audioBuffer = await response.arrayBuffer();
+    await fs.writeFile(outputPath, Buffer.from(audioBuffer));
+
+    return `/audio/${audioId}.mp3`;
+  } catch (error) {
+    clearTimeout(timeoutId);
+
+    // Handle timeout specifically
+    if (error.name === 'AbortError') {
+      log.error(`Request timed out after ${timeoutMs}ms`);
+      throw new Error('Text-to-speech generation timed out. Please try again with shorter text.');
+    }
+
+    // Handle network errors
+    if (error.code === 'ENOTFOUND' || error.code === 'ECONNREFUSED' || error.type === 'system') {
+      log.error('Network error:', error.message);
+      throw new Error('Unable to connect to text-to-speech service. Please check your network connection.');
+    }
+
+    // Re-throw user-friendly errors we've already created
+    if (error.message.includes('Text-to-speech') || error.message.includes('TTS')) {
+      throw error;
+    }
+
+    // Log unexpected errors and return generic message
+    log.error('Unexpected error:', error);
+    throw new Error('An unexpected error occurred while generating speech. Please try again.');
+  }
+}
+
+/**
+ * Check if Edge TTS is available (user installed node-edge-tts)
+ */
+export function isEdgeTTSAvailable() {
+  return EdgeTTS !== null;
+}
+
+/**
+ * Generate TTS audio using Microsoft Edge TTS
+ * Requires user to install: npm install node-edge-tts
+ * @param {string} text - Text to convert to speech
+ * @param {string} outputDir - Directory to save audio file
+ * @param {Object} options - Options
+ * @param {string} options.voice - Voice to use (default: EDGE_TTS_VOICE env var)
+ * @param {number} options.timeoutMs - Request timeout in milliseconds (default: 30000)
+ * @returns {Promise<string>} - URL path to the generated audio file
+ */
+export async function textToSpeechEdge(text, outputDir, options = {}) {
+  if (!EdgeTTS) {
+    throw new Error('Edge TTS not installed. Run: npm install node-edge-tts');
+  }
+
+  const audioId = randomUUID();
+  const outputPath = path.join(outputDir, `${audioId}.mp3`);
+  const timeoutMs = options.timeoutMs || 30000;
+
+  // Read voice from runtime config (falls back to env var)
+  const config = await getRuntimeConfig();
+  const voice = options.voice || config.edgeTtsVoice || EDGE_TTS_VOICE;
+
+  await fs.mkdir(outputDir, { recursive: true });
+
+  const cleanText = cleanTextForTTS(text);
+  if (!cleanText) {
+    throw new Error('No text to speak');
+  }
+
+  try {
+    const tts = new EdgeTTS({
+      voice: voice,
+      timeout: timeoutMs,
+    });
+
+    await tts.ttsPromise(cleanText, outputPath);
+
+    return `/audio/${audioId}.mp3`;
+  } catch (error) {
+    log.error('Edge TTS error:', error);
+    
+    if (error.message?.includes('timeout')) {
+      throw new Error('Edge TTS generation timed out. Please try again with shorter text.');
+    }
+    
+    throw new Error('Edge TTS failed: ' + (error.message || 'Unknown error'));
+  }
+}
+
+/**
+ * Generate TTS audio using OpenAI TTS API
+ * @param {string} text - Text to convert to speech
+ * @param {string} outputDir - Directory to save audio file
+ * @param {Object} options - Options
+ * @param {string} options.voice - Voice to use (alloy, echo, fable, onyx, nova, shimmer)
+ * @param {string} options.model - Model to use (tts-1, tts-1-hd)
+ * @param {number} options.timeoutMs - Request timeout in milliseconds (default: 30000)
+ * @returns {Promise<string>} - URL path to the generated audio file
+ */
+export async function textToSpeechOpenAI(text, outputDir, options = {}) {
+  const audioId = randomUUID();
+  const outputPath = path.join(outputDir, `${audioId}.mp3`);
+  const timeoutMs = options.timeoutMs || 30000;
+
+  // Read voice/model from runtime config (falls back to env vars)
+  const config = await getRuntimeConfig();
+  const voice = options.voice || config.openaiTtsVoice || OPENAI_TTS_VOICE;
+  const model = options.model || config.openaiTtsModel || OPENAI_TTS_MODEL;
+
+  await fs.mkdir(outputDir, { recursive: true });
+
+  const cleanText = cleanTextForTTS(text);
+  if (!cleanText) {
+    throw new Error('No text to speak');
+  }
+
+  const openaiKey = config.openaiApiKey || OPENAI_API_KEY;
+  if (!openaiKey) {
+    throw new Error('OpenAI API key not configured. Add it in Settings → Voice & TTS.');
+  }
+
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch('https://api.openai.com/v1/audio/speech', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${openaiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: model,
+        input: cleanText,
+        voice: voice,
+        response_format: 'mp3',
+      }),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      log.error(`OpenAI API error: ${response.status} - ${errorText}`);
+      
+      if (response.status === 401) {
+        throw new Error('OpenAI authentication failed. Please check your API key.');
+      } else if (response.status === 429) {
+        throw new Error('OpenAI rate limit reached. Please try again in a moment.');
+      }
+      throw new Error('OpenAI TTS failed. Please try again.');
+    }
+
+    const audioBuffer = await response.arrayBuffer();
+    await fs.writeFile(outputPath, Buffer.from(audioBuffer));
+
+    return `/audio/${audioId}.mp3`;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    
+    if (error.name === 'AbortError') {
+      throw new Error('OpenAI TTS timed out. Please try again with shorter text.');
+    }
+    
+    if (error.message.includes('OpenAI')) {
+      throw error;
+    }
+    
+    log.error('OpenAI TTS error:', error);
+    throw new Error('OpenAI TTS failed: ' + error.message);
+  }
+}
+
+/**
+ * Generate TTS audio using Piper (local, fast, many voices)
+ * Requires piper executable installed: https://github.com/rhasspy/piper
+ * @param {string} text - Text to convert to speech
+ * @param {string} outputDir - Directory to save audio file
+ * @param {Object} options - Options
+ * @param {number} options.timeoutMs - Request timeout in milliseconds (default: 30000)
+ * @returns {Promise<string>} - URL path to the generated audio file
+ */
+export async function textToSpeechPiper(text, outputDir, options = {}) {
+  const audioId = randomUUID();
+  const outputPath = path.join(outputDir, `${audioId}.wav`);
+  const timeoutMs = options.timeoutMs || 30000;
+
+  await fs.mkdir(outputDir, { recursive: true });
+
+  const cleanText = cleanTextForTTS(text);
+  if (!cleanText) {
+    throw new Error('No text to speak');
+  }
+
+  if (!PIPER_MODEL) {
+    throw new Error('Piper TTS requires PIPER_MODEL environment variable (path to .onnx model)');
+  }
+
+  return new Promise((resolve, reject) => {
+    const args = ['--model', PIPER_MODEL, '--output_file', outputPath];
+    if (PIPER_CONFIG) {
+      args.push('--config', PIPER_CONFIG);
+    }
+
+    const piperProcess = spawn(PIPER_EXECUTABLE, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let stderr = '';
+
+    const timeout = setTimeout(() => {
+      piperProcess.kill();
+      reject(new Error('Piper TTS timed out. Please try again with shorter text.'));
+    }, timeoutMs);
+
+    piperProcess.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    piperProcess.on('close', async (code) => {
+      clearTimeout(timeout);
+
+      if (code !== 0) {
+        log.error(`Piper exited with code ${code}: ${stderr}`);
+        reject(new Error('Piper TTS failed. Check that piper is installed and model path is correct.'));
+        return;
+      }
+
+      // Verify output file exists
+      try {
+        await fs.stat(outputPath);
+        resolve(`/audio/${audioId}.wav`);
+      } catch {
+        reject(new Error('Piper TTS did not produce output file.'));
+      }
+    });
+
+    piperProcess.on('error', (error) => {
+      clearTimeout(timeout);
+      log.error('Piper spawn error:', error);
+      if (error.code === 'ENOENT') {
+        reject(new Error('Piper executable not found. Install from: https://github.com/rhasspy/piper'));
+      } else {
+        reject(new Error('Failed to start Piper: ' + error.message));
+      }
+    });
+
+    // Send text to stdin
+    piperProcess.stdin.write(cleanText);
+    piperProcess.stdin.end();
+  });
+}
+
+/**
+ * Generate TTS audio using local XTTS script (process-based)
+ * @param {string} text - Text to convert to speech
+ * @param {string} outputDir - Directory to save audio file
+ * @param {Object} options - Options
+ * @param {number} options.timeoutMs - Request timeout in milliseconds (default: 60000)
+ * @returns {Promise<string>} - URL path to the generated audio file
+ */
+export async function localTextToSpeech(text, outputDir, options = {}) {
+  const audioId = randomUUID();
+  const timeoutMs = options.timeoutMs || 60000;
+
+  await fs.mkdir(outputDir, { recursive: true });
+
+  const cleanText = cleanTextForTTS(text);
+
+  if (!cleanText) {
+    throw new Error('No text to speak');
+  }
+
+  // Check if local TTS is configured
+  if (!isLocalTTSConfigured()) {
+    throw new Error('Local TTS is not configured. Please check LOCAL_TTS_SCRIPT and LOCAL_TTS_PYTHON environment variables.');
+  }
+
+  return new Promise((resolve, reject) => {
+    const pythonProcess = spawn(LOCAL_TTS_PYTHON, [LOCAL_TTS_SCRIPT], {
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    const timeout = setTimeout(() => {
+      pythonProcess.kill();
+      reject(new Error('Local TTS generation timed out. Please try again with shorter text.'));
+    }, timeoutMs);
+
+    pythonProcess.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    pythonProcess.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    pythonProcess.on('close', async (code) => {
+      clearTimeout(timeout);
+
+      if (code !== 0) {
+        log.error(`Local TTS process exited with code ${code}: ${stderr}`);
+        reject(new Error('Local TTS generation failed. Please check the TTS script configuration.'));
+        return;
+      }
+
+      // The script outputs the WAV file path
+      const wavPath = stdout.trim();
+      
+      if (!wavPath || !(await fs.stat(wavPath).catch(() => null))) {
+        log.error('Local TTS did not produce a valid output file:', wavPath);
+        reject(new Error('Local TTS did not produce audio output.'));
+        return;
+      }
+
+      try {
+        // Copy the WAV file to our output directory
+        const outputPath = path.join(outputDir, `${audioId}.wav`);
+        await fs.copyFile(wavPath, outputPath);
+        
+        // Optionally clean up the original file
+        await fs.unlink(wavPath).catch(() => {});
+        
+        resolve(`/audio/${audioId}.wav`);
+      } catch (error) {
+        log.error('Failed to process local TTS output:', error);
+        reject(new Error('Failed to process local TTS audio output.'));
+      }
+    });
+
+    pythonProcess.on('error', (error) => {
+      clearTimeout(timeout);
+      log.error('Failed to spawn local TTS process:', error);
+      reject(new Error('Failed to start local TTS process. Please check Python path.'));
+    });
+
+    // Send text to stdin and close it
+    pythonProcess.stdin.write(cleanText);
+    pythonProcess.stdin.end();
+  });
+}
+
+/**
+ * Check if local TTS is configured (server or process-based)
+ */
+export function isLocalTTSConfigured() {
+  // Note: This is a sync check using env vars only.
+  // For runtime config check, use isLocalTTSConfiguredAsync()
+  return !!(LOCAL_TTS_URL || (LOCAL_TTS_SCRIPT && LOCAL_TTS_PYTHON));
+}
+
+export async function isLocalTTSConfiguredAsync() {
+  const config = await getRuntimeConfig();
+  return !!(config.localTtsUrl || LOCAL_TTS_URL || (LOCAL_TTS_SCRIPT && LOCAL_TTS_PYTHON));
+}
+
+/**
+ * Check if Piper TTS is configured
+ */
+export function isPiperConfigured() {
+  return !!PIPER_MODEL;
+}
+
+/**
+ * Check if TTS is configured (any provider)
+ */
+export function isTTSConfigured(provider = 'elevenlabs') {
+  switch (provider) {
+    case 'local':
+      return isLocalTTSConfigured();
+    case 'edge':
+      return isEdgeTTSAvailable();
+    case 'openai':
+      // Note: sync check only uses env var. Async callers should check runtime config.
+      return !!OPENAI_API_KEY;
+    case 'piper':
+      return isPiperConfigured();
+    case 'elevenlabs':
+    default:
+      return !!(ELEVENLABS_API_KEY && ELEVENLABS_VOICE_ID);
+  }
+}
+
+/**
+ * Generate TTS using local XTTS server
+ */
+export async function textToSpeechLocal(text, outputDir, options = {}) {
+  const audioId = randomUUID();
+  const outputPath = path.join(outputDir, `${audioId}.wav`);
+  const timeoutMs = options.timeoutMs || 60000; // Local TTS can be slower
+
+  await fs.mkdir(outputDir, { recursive: true });
+
+  const cleanText = cleanTextForTTS(text);
+  if (!cleanText) throw new Error('No text to speak');
+
+  // Read URL from runtime config (falls back to env var)
+  const config = await getRuntimeConfig();
+  const ttsUrl = config.localTtsUrl || LOCAL_TTS_URL;
+  
+  if (!ttsUrl) {
+    throw new Error('XTTS server URL not configured. Set it in Settings → Voice & TTS.');
+  }
+
+  // Try calling local TTS server
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch(`${ttsUrl}/synthesize`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text: cleanText, use_short_ref: true }),
+      signal: controller.signal
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      log.error('Local TTS error:', response.status, errorText);
+      throw new Error(`Local TTS error: ${response.status}`);
+    }
+
+    // Save the audio data
+    const audioBuffer = await response.arrayBuffer();
+    await fs.writeFile(outputPath, Buffer.from(audioBuffer));
+
+    return `/audio/${audioId}.wav`;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    
+    if (error.name === 'AbortError') {
+      throw new Error('Local TTS request timed out. The GPU might be warming up - try again.');
+    }
+    
+    // If server not running, provide helpful message
+    if (error.code === 'ECONNREFUSED') {
+      throw new Error('Local TTS server not running. Start it with: python uplink_tts_adapter.py');
+    }
+
+    log.error('Local TTS error:', error);
+    throw new Error('Local TTS failed: ' + error.message);
+  }
+}
+
+export default {
+  cleanTextForTTS,
+  extractFirstSentence,
+  textToSpeech,
+  textToSpeechEdge,
+  textToSpeechOpenAI,
+  textToSpeechPiper,
+  localTextToSpeech,
+  textToSpeechLocal,
+  isTTSConfigured,
+  isLocalTTSConfigured,
+  isLocalTTSConfiguredAsync,
+  isEdgeTTSAvailable,
+  isPiperConfigured,
+  listEdgeTTSVoices,
+};