tide-commander 0.52.0

package/dist/src/packages/server/routes/tts.js

@@ -0,0 +1,166 @@
+/**
+ * TTS (Text-to-Speech) Route
+ * Uses Piper for high-quality speech synthesis, returns audio to browser
+ * Auto-detects language (Spanish/English) based on text content
+ */
+import { Router } from 'express';
+import { spawn } from 'child_process';
+import os from 'os';
+import path from 'path';
+import { logger } from '../utils/logger.js';
+const router = Router();
+// Piper voice model paths
+const PIPER_VOICES_DIR = path.join(os.homedir(), '.local/share/piper-voices');
+// Voice models by language
+const VOICES = {
+    es: 'es_MX-claude-high', // Latin American Spanish (Mexican female - Claude voice)
+    en: 'en_US-amy-medium', // American English (female)
+};
+// Common Spanish words for language detection
+const SPANISH_INDICATORS = [
+    // Common words
+    'el', 'la', 'los', 'las', 'un', 'una', 'unos', 'unas',
+    'de', 'del', 'en', 'con', 'por', 'para', 'sin', 'sobre',
+    'que', 'qué', 'como', 'cómo', 'cuando', 'cuándo', 'donde', 'dónde',
+    'es', 'está', 'son', 'están', 'ser', 'estar', 'hay',
+    'yo', 'tú', 'él', 'ella', 'nosotros', 'ellos', 'ellas',
+    'mi', 'tu', 'su', 'nuestro', 'vuestro',
+    'este', 'esta', 'estos', 'estas', 'ese', 'esa', 'esos', 'esas',
+    'pero', 'porque', 'aunque', 'también', 'además', 'entonces',
+    'puede', 'pueden', 'puedo', 'podemos', 'hacer', 'hecho',
+    'muy', 'más', 'menos', 'bien', 'mal', 'sí', 'no',
+    'ahora', 'aquí', 'allí', 'hoy', 'ayer', 'mañana',
+    // Verbs
+    'tiene', 'tienen', 'tengo', 'tenemos', 'quiero', 'quiere',
+    'necesito', 'necesita', 'busco', 'busca', 'encuentro', 'encuentra',
+    // Tech terms often used in Spanish
+    'archivo', 'archivos', 'código', 'función', 'método', 'clase',
+    'ejecutar', 'compilar', 'instalar', 'configurar',
+];
+// Common English words for language detection
+const ENGLISH_INDICATORS = [
+    // Common words
+    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been',
+    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should',
+    'this', 'that', 'these', 'those', 'it', 'its',
+    'i', 'you', 'he', 'she', 'we', 'they', 'my', 'your', 'his', 'her', 'our', 'their',
+    'and', 'or', 'but', 'if', 'then', 'else', 'when', 'where', 'how', 'what', 'which',
+    'to', 'of', 'in', 'on', 'at', 'by', 'for', 'with', 'about', 'from',
+    'not', 'no', 'yes', 'can', 'cannot', "can't", "don't", "doesn't", "won't",
+    'here', 'there', 'now', 'today', 'tomorrow', 'yesterday',
+    // Tech terms
+    'file', 'files', 'code', 'function', 'method', 'class',
+    'run', 'execute', 'compile', 'install', 'configure', 'build',
+    'error', 'warning', 'success', 'failed', 'complete',
+];
+/**
+ * Detect language based on word frequency
+ * Returns 'es' for Spanish, 'en' for English
+ */
+function detectLanguage(text) {
+    const words = text.toLowerCase().split(/\s+/);
+    let spanishScore = 0;
+    let englishScore = 0;
+    for (const word of words) {
+        // Clean punctuation from word
+        const cleanWord = word.replace(/[.,!?;:'"()[\]{}]/g, '');
+        if (SPANISH_INDICATORS.includes(cleanWord)) {
+            spanishScore++;
+        }
+        if (ENGLISH_INDICATORS.includes(cleanWord)) {
+            englishScore++;
+        }
+    }
+    // Check for Spanish-specific characters (accents, ñ, ¿, ¡)
+    if (/[áéíóúüñ¿¡]/.test(text)) {
+        spanishScore += 3;
+    }
+    const detected = spanishScore > englishScore ? 'es' : 'en';
+    logger.server.log(`[TTS] Language detection: Spanish=${spanishScore}, English=${englishScore} -> ${detected}`);
+    return detected;
+}
+/**
+ * POST /api/tts/speak
+ * Generates audio using Piper TTS and returns WAV audio data
+ * Auto-detects language if not specified
+ */
+router.post('/speak', async (req, res) => {
+    const { text, voice, lang } = req.body;
+    if (!text || typeof text !== 'string') {
+        return res.status(400).json({ error: 'Text is required' });
+    }
+    // Clean text for speech (remove markdown, etc.)
+    const cleanedText = text
+        .replace(/```[\s\S]*?```/g, ' code block ')
+        .replace(/`[^`]+`/g, ' code ')
+        .replace(/^#{1,6}\s+/gm, '')
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/\*([^*]+)\*/g, '$1')
+        .replace(/__([^_]+)__/g, '$1')
+        .replace(/_([^_]+)_/g, '$1')
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+        .replace(/!\[([^\]]*)\]\([^)]+\)/g, '$1')
+        .replace(/^[-*_]{3,}$/gm, '')
+        .replace(/<[^>]+>/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!cleanedText) {
+        return res.status(400).json({ error: 'No text to speak after cleaning' });
+    }
+    // Determine voice: explicit voice > explicit lang > auto-detect
+    let selectedVoice;
+    if (voice) {
+        selectedVoice = voice;
+    }
+    else {
+        const detectedLang = lang || detectLanguage(cleanedText);
+        selectedVoice = VOICES[detectedLang] || VOICES.en;
+    }
+    logger.server.log(`[TTS] Generating audio with voice ${selectedVoice}: ${cleanedText.substring(0, 50)}...`);
+    const modelPath = path.join(PIPER_VOICES_DIR, `${selectedVoice}.onnx`);
+    try {
+        // Generate WAV audio using piper
+        const audioData = await new Promise((resolve, reject) => {
+            const chunks = [];
+            const piper = spawn('piper', [
+                '--model', modelPath,
+                '--output_file', '-' // Output to stdout as WAV
+            ]);
+            piper.stdout.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            piper.stderr.on('data', (data) => {
+                // Piper outputs progress to stderr, ignore it
+                const msg = data.toString();
+                if (msg.includes('Error') || msg.includes('error')) {
+                    logger.server.error(`[TTS] Piper stderr: ${msg}`);
+                }
+            });
+            piper.on('error', (err) => {
+                reject(new Error(`Piper spawn error: ${err.message}`));
+            });
+            piper.on('close', (code) => {
+                if (code === 0) {
+                    resolve(Buffer.concat(chunks));
+                }
+                else {
+                    reject(new Error(`Piper exited with code ${code}`));
+                }
+            });
+            // Send text to piper
+            if (piper.stdin) {
+                piper.stdin.write(cleanedText);
+                piper.stdin.end();
+            }
+        });
+        // Send WAV audio back to browser
+        res.setHeader('Content-Type', 'audio/wav');
+        res.setHeader('Content-Length', audioData.length);
+        res.send(audioData);
+    }
+    catch (err) {
+        logger.server.error(`[TTS] Error generating audio: ${err}`);
+        res.status(500).json({ error: 'Failed to generate audio' });
+    }
+});
+export default router;

package/dist/src/packages/server/routes/voice-assistant.js

@@ -0,0 +1,310 @@
+/**
+ * Voice Assistant Route
+ * Processes voice commands using Claude Code (haiku) with persistent session
+ */
+import { Router } from 'express';
+import { spawn } from 'child_process';
+import { StringDecoder } from 'string_decoder';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { agentService } from '../services/index.js';
+import { loadAreas } from '../data/index.js';
+import { ClaudeBackend } from '../claude/index.js';
+import { logger, sanitizeUnicode } from '../utils/index.js';
+const router = Router();
+const claudeBackend = new ClaudeBackend();
+// Voice assistant state file
+const VOICE_STATE_FILE = path.join(os.homedir(), '.local/share/tide-commander/voice-assistant.json');
+// Persistent session ID for voice assistant
+let voiceSessionId = null;
+/**
+ * Load voice assistant state from disk
+ */
+function loadVoiceState() {
+    try {
+        if (fs.existsSync(VOICE_STATE_FILE)) {
+            const data = JSON.parse(fs.readFileSync(VOICE_STATE_FILE, 'utf-8'));
+            voiceSessionId = data.sessionId || null;
+            logger.server.log(`[VoiceAssistant] Loaded session: ${voiceSessionId}`);
+        }
+    }
+    catch (err) {
+        logger.server.error(`[VoiceAssistant] Failed to load state:`, err);
+    }
+}
+/**
+ * Save voice assistant state to disk
+ */
+function saveVoiceState() {
+    try {
+        const dir = path.dirname(VOICE_STATE_FILE);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(VOICE_STATE_FILE, JSON.stringify({
+            sessionId: voiceSessionId,
+            updatedAt: Date.now(),
+        }, null, 2));
+    }
+    catch (err) {
+        logger.server.error(`[VoiceAssistant] Failed to save state:`, err);
+    }
+}
+// Load state on module init
+loadVoiceState();
+/**
+ * Build the system prompt with current agent list and their areas
+ */
+function buildSystemPrompt() {
+    const agents = agentService.getAllAgents();
+    const areas = loadAreas();
+    // Build agent list with their assigned areas and boss status
+    const agentList = agents.map(a => {
+        const agentAreas = areas.filter(area => area.assignedAgentIds.includes(a.id));
+        const areaNames = agentAreas.map(area => area.name).join(', ');
+        const parts = [`${a.name} (id: ${a.id}, ${a.status})`];
+        if (a.isBoss)
+            parts.push('[BOSS]');
+        if (areaNames)
+            parts.push(`[areas: ${areaNames}]`);
+        return `- ${parts.join(' ')}`;
+    }).join('\n');
+    return `YOU ARE A JSON API. YOU MUST ONLY OUTPUT VALID JSON. NEVER OUTPUT TEXT OR EXPLANATIONS.
+
+You route voice commands to AI agents. You do NOT write code. You do NOT help directly. You ONLY parse and route.
+
+Agents:
+${agentList}
+
+REQUIRED OUTPUT FORMAT (nothing else):
+{"targetAgentId":"id|null","targetAgentName":"name|null","messageToAgent":"the user's request to forward","responseToUser":"brief confirmation under 15 words","action":"send_to_agent|list_agents|general_response"}
+
+ACTIONS:
+- send_to_agent: User wants an agent to do something. Put their request in messageToAgent.
+- list_agents: User asks about agents
+- general_response: Greetings only
+
+IMPORTANT: responseToUser MUST be in the SAME LANGUAGE as the user's message. If user speaks Spanish, respond in Spanish. If English, respond in English.
+
+CRITICAL: Your response must be ONLY the JSON object. No markdown. No explanations. No code.`;
+}
+/**
+ * Call Claude Code with haiku model, maintaining session
+ */
+async function callClaudeHaiku(userMessage, isFirstMessage) {
+    return new Promise((resolve, reject) => {
+        const executable = claudeBackend.getExecutablePath();
+        const args = [
+            '--print',
+            '--verbose',
+            '--model', 'haiku',
+            '--output-format', 'stream-json',
+            '--input-format', 'stream-json',
+        ];
+        // Always write system prompt to temp file - Claude Code needs it on every call
+        const systemPromptFile = path.join(os.tmpdir(), `voice-assistant-prompt-${Date.now()}.txt`);
+        fs.writeFileSync(systemPromptFile, buildSystemPrompt());
+        args.push('--system-prompt-file', systemPromptFile);
+        // Resume existing session if available
+        if (voiceSessionId && !isFirstMessage) {
+            args.push('--resume', voiceSessionId);
+        }
+        const childProcess = spawn(executable, args, {
+            env: { ...process.env, LANG: 'en_US.UTF-8', LC_ALL: 'en_US.UTF-8' },
+            shell: false, // Don't use shell to avoid escaping issues
+        });
+        // Clean up temp file when done
+        const cleanup = () => {
+            if (fs.existsSync(systemPromptFile)) {
+                try {
+                    fs.unlinkSync(systemPromptFile);
+                }
+                catch { /* ignore */ }
+            }
+        };
+        const decoder = new StringDecoder('utf8');
+        let buffer = '';
+        let textOutput = '';
+        let newSessionId = null;
+        childProcess.stdout?.on('data', (data) => {
+            buffer += decoder.write(data);
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const event = JSON.parse(line);
+                    // Capture session ID from init event
+                    if (event.type === 'system' && event.session_id) {
+                        newSessionId = event.session_id;
+                    }
+                    if (event.type === 'assistant' && event.message?.content) {
+                        for (const block of event.message.content) {
+                            if (block.type === 'text' && block.text)
+                                textOutput += block.text;
+                        }
+                    }
+                    if (event.type === 'stream_event' && event.event?.type === 'content_block_delta') {
+                        if (event.event.delta?.type === 'text_delta' && event.event.delta.text) {
+                            textOutput += event.event.delta.text;
+                        }
+                    }
+                }
+                catch { /* ignore non-JSON */ }
+            }
+        });
+        childProcess.stderr?.on('data', (data) => {
+            const msg = decoder.write(data);
+            // Only log actual errors, not verbose output
+            if (msg.includes('Error') || msg.includes('error')) {
+                logger.server.error(`[VoiceAssistant] Claude stderr: ${msg}`);
+            }
+        });
+        childProcess.on('close', (code) => {
+            cleanup();
+            const remaining = buffer + decoder.end();
+            if (remaining.trim()) {
+                try {
+                    const event = JSON.parse(remaining);
+                    if (event.type === 'system' && event.session_id) {
+                        newSessionId = event.session_id;
+                    }
+                    if (event.type === 'assistant' && event.message?.content) {
+                        for (const block of event.message.content) {
+                            if (block.type === 'text' && block.text)
+                                textOutput += block.text;
+                        }
+                    }
+                }
+                catch { /* ignore */ }
+            }
+            if (code !== 0 && !textOutput)
+                reject(new Error(`Claude exited with code ${code}`));
+            else if (!textOutput)
+                reject(new Error('No response from Claude'));
+            else
+                resolve({ text: textOutput, sessionId: newSessionId });
+        });
+        childProcess.on('error', (err) => {
+            cleanup();
+            reject(err);
+        });
+        childProcess.on('spawn', () => {
+            // Include routing instruction with every message to ensure compliance
+            const routingInstruction = isFirstMessage ? '' : '\n\n[REMINDER: Output ONLY JSON. No explanations.]';
+            const stdinMessage = JSON.stringify({
+                type: 'user',
+                message: { role: 'user', content: sanitizeUnicode(userMessage) + routingInstruction },
+            });
+            childProcess.stdin?.write(stdinMessage + '\n');
+            childProcess.stdin?.end();
+        });
+        setTimeout(() => {
+            if (!childProcess.killed) {
+                childProcess.kill('SIGTERM');
+                cleanup();
+                reject(new Error('Claude timed out'));
+            }
+        }, 30000);
+    });
+}
+function stripCodeFences(s) {
+    s = s.trim();
+    if (s.startsWith('```json'))
+        s = s.slice(7);
+    else if (s.startsWith('```'))
+        s = s.slice(3);
+    if (s.endsWith('```'))
+        s = s.slice(0, -3);
+    return s.trim();
+}
+/**
+ * POST /api/voice-assistant/process
+ */
+router.post('/process', async (req, res) => {
+    const { text } = req.body;
+    if (!text || typeof text !== 'string') {
+        return res.status(400).json({ error: 'Text is required' });
+    }
+    logger.server.log(`[VoiceAssistant] Processing: "${text}" (session: ${voiceSessionId || 'new'})`);
+    try {
+        const isFirstMessage = !voiceSessionId;
+        const { text: response, sessionId } = await callClaudeHaiku(text, isFirstMessage);
+        // Save session ID for future messages
+        if (sessionId && sessionId !== voiceSessionId) {
+            voiceSessionId = sessionId;
+            saveVoiceState();
+            logger.server.log(`[VoiceAssistant] Session saved: ${voiceSessionId}`);
+        }
+        const jsonStr = stripCodeFences(response);
+        let parsed;
+        try {
+            parsed = JSON.parse(jsonStr);
+        }
+        catch {
+            logger.server.error(`[VoiceAssistant] Failed to parse: ${jsonStr}`);
+            throw new Error('Failed to parse response');
+        }
+        logger.server.log(`[VoiceAssistant] Parsed:`, parsed);
+        if (parsed.action === 'send_to_agent' && parsed.targetAgentId) {
+            const targetAgent = agentService.getAgent(parsed.targetAgentId);
+            if (!targetAgent) {
+                return res.json({
+                    success: true,
+                    response: `No encuentro al agente ${parsed.targetAgentName}`,
+                });
+            }
+            const { runtimeService, bossMessageService } = await import('../services/index.js');
+            const { buildCustomAgentConfig } = await import('../websocket/handlers/command-handler.js');
+            if (targetAgent.isBoss || targetAgent.class === 'boss') {
+                const { message: bossMessage, systemPrompt } = await bossMessageService.buildBossMessage(parsed.targetAgentId, parsed.messageToAgent);
+                await runtimeService.sendCommand(parsed.targetAgentId, bossMessage, systemPrompt);
+            }
+            else {
+                const customAgentConfig = buildCustomAgentConfig(parsed.targetAgentId, targetAgent.class);
+                await runtimeService.sendCommand(parsed.targetAgentId, parsed.messageToAgent, undefined, undefined, customAgentConfig);
+            }
+            logger.server.log(`[VoiceAssistant] Sent to ${targetAgent.name}: "${parsed.messageToAgent}"`);
+            return res.json({
+                success: true,
+                response: parsed.responseToUser,
+                targetAgent: { id: targetAgent.id, name: targetAgent.name },
+                messageSent: parsed.messageToAgent,
+            });
+        }
+        return res.json({
+            success: true,
+            response: parsed.responseToUser,
+        });
+    }
+    catch (err) {
+        const msg = err?.message || 'Unknown error';
+        logger.server.error(`[VoiceAssistant] Error: ${msg}`);
+        // Reset session on error so next message starts fresh
+        if (msg.includes('exited with code') || msg.includes('timed out')) {
+            voiceSessionId = null;
+        }
+        return res.status(500).json({ error: 'Failed to process', details: msg });
+    }
+});
+/**
+ * POST /api/voice-assistant/reset
+ * Reset the voice assistant session
+ */
+router.post('/reset', (_req, res) => {
+    voiceSessionId = null;
+    saveVoiceState();
+    logger.server.log('[VoiceAssistant] Session reset');
+    res.json({ success: true, message: 'Session reset' });
+});
+router.get('/status', (_req, res) => {
+    res.json({
+        available: true,
+        hasSession: !!voiceSessionId,
+        sessionId: voiceSessionId,
+        agentCount: agentService.getAllAgents().length,
+    });
+});
+export default router;

package/dist/src/packages/server/runtime/claude-runtime-provider.js

@@ -0,0 +1,10 @@
+import { ClaudeRunner } from '../claude/runner.js';
+class ClaudeRuntimeProvider {
+    name = 'claude';
+    createRunner(callbacks) {
+        return new ClaudeRunner(callbacks);
+    }
+}
+export function createClaudeRuntimeProvider() {
+    return new ClaudeRuntimeProvider();
+}

package/dist/src/packages/server/runtime/codex-runtime-provider.js

@@ -0,0 +1,11 @@
+import { ClaudeRunner } from '../claude/runner.js';
+import { CodexBackend } from '../codex/backend.js';
+class CodexRuntimeProvider {
+    name = 'codex';
+    createRunner(callbacks) {
+        return new ClaudeRunner(callbacks, new CodexBackend());
+    }
+}
+export function createCodexRuntimeProvider() {
+    return new CodexRuntimeProvider();
+}

package/dist/src/packages/server/runtime/index.js

@@ -0,0 +1,2 @@
+export { createClaudeRuntimeProvider } from './claude-runtime-provider.js';
+export { createCodexRuntimeProvider } from './codex-runtime-provider.js';

package/dist/src/packages/server/runtime/types.js

@@ -0,0 +1,6 @@
+/**
+ * Runtime abstraction types for agent CLI providers.
+ * Phase 1 keeps Claude as the only implementation but routes through these
+ * contracts so additional providers can be introduced safely.
+ */
+export {};

package/dist/src/packages/server/services/agent-lifecycle-service.js

@@ -0,0 +1,82 @@
+/**
+ * Agent Lifecycle Service
+ * Handles agent restart operations when skills or class instructions change
+ */
+import * as agentService from './agent-service.js';
+import * as runtimeService from './runtime-service.js';
+import * as customClassService from './custom-class-service.js';
+import { createLogger } from '../utils/index.js';
+const log = createLogger('AgentLifecycle');
+/**
+ * Restart all agents using a given skill when the skill is updated.
+ * An agent uses a skill if:
+ * 1. The skill is directly assigned to the agent
+ * 2. The skill is assigned to the agent's class
+ * 3. The agent's custom class has the skill as a default
+ */
+export async function restartAgentsWithSkill(skill, sendActivity) {
+    const allAgents = agentService.getAllAgents();
+    const affectedAgents = allAgents.filter(agent => {
+        // Check direct assignment
+        if (skill.assignedAgentIds.includes(agent.id))
+            return true;
+        // Check class assignment (skill assigned to agent's class)
+        if (skill.assignedAgentClasses.includes(agent.class))
+            return true;
+        // Check custom class default skills
+        const customClass = customClassService.getCustomClass(agent.class);
+        if (customClass?.defaultSkillIds?.includes(skill.id))
+            return true;
+        return false;
+    });
+    if (affectedAgents.length === 0) {
+        log.log(`🔄 No agents using skill "${skill.name}" to restart`);
+        return;
+    }
+    log.log(`🔄 Restarting ${affectedAgents.length} agent(s) using skill "${skill.name}" due to skill update`);
+    for (const agent of affectedAgents) {
+        await restartAgent(agent, `skill "${skill.name}" updated`, sendActivity);
+    }
+}
+/**
+ * Restart all agents with a given class when the class instructions are updated.
+ * This stops the agent's current session and clears the sessionId so the next
+ * command will start a fresh session with the new instructions.
+ */
+export async function restartAgentsWithClass(classId, sendActivity) {
+    const allAgents = agentService.getAllAgents();
+    const affectedAgents = allAgents.filter(agent => agent.class === classId);
+    if (affectedAgents.length === 0) {
+        log.log(`🔄 No agents with class "${classId}" to restart`);
+        return;
+    }
+    log.log(`🔄 Restarting ${affectedAgents.length} agent(s) with class "${classId}" due to instructions update`);
+    for (const agent of affectedAgents) {
+        await restartAgent(agent, 'class instructions updated', sendActivity);
+    }
+}
+/**
+ * Internal helper to restart a single agent
+ */
+async function restartAgent(agent, reason, sendActivity) {
+    try {
+        log.log(`🔄 Restarting agent ${agent.name} (${agent.id}) due to ${reason}`);
+        // Stop the current process if running
+        await runtimeService.stopAgent(agent.id);
+        // Reset status but preserve sessionId - the session will resume with new instructions
+        agentService.updateAgent(agent.id, {
+            status: 'idle',
+            currentTask: undefined,
+            currentTool: undefined,
+            // Note: sessionId is preserved - Claude will resume the existing session
+            // with the new instructions/skills on the next command
+        });
+        // Notify the user
+        sendActivity?.(agent.id, `Agent restarted - ${reason}`);
+        log.log(`🔄 Agent ${agent.name} restarted successfully`);
+    }
+    catch (err) {
+        log.error(`🔄 Failed to restart agent ${agent.name}:`, err);
+        sendActivity?.(agent.id, `Failed to restart after ${reason}`);
+    }
+}