claude-phone-local 2.0.0

package/cli/lib/prerequisites.js

@@ -0,0 +1,115 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+/**
+ * Check if Docker is installed and accessible
+ * @returns {Promise<object>} Prerequisite check result
+ * @property {boolean} installed - True if Docker is available
+ * @property {string} [version] - Docker version if installed
+ * @property {string} [error] - Error message if check failed
+ * @property {string} [installUrl] - Installation URL if not installed
+ */
+export async function checkDocker() {
+  try {
+    // Check if docker command exists
+    const { stdout: whichOutput } = await execAsync('which docker');
+
+    if (!whichOutput.trim()) {
+      return {
+        installed: false,
+        installUrl: 'https://docs.docker.com/engine/install/'
+      };
+    }
+
+    // Get Docker version
+    const { stdout: versionOutput } = await execAsync('docker --version');
+    const version = versionOutput.trim();
+
+    return {
+      installed: true,
+      version: version
+    };
+  } catch (error) {
+    // Docker not found or not executable
+    return {
+      installed: false,
+      error: error.message,
+      installUrl: 'https://docs.docker.com/engine/install/'
+    };
+  }
+}
+
+/**
+ * Check if docker-compose or docker compose is available
+ * @returns {Promise<object>} Prerequisite check result
+ * @property {boolean} installed - True if compose is available
+ * @property {string} [version] - Compose version if installed
+ * @property {string} [method] - 'plugin' or 'standalone'
+ * @property {string} [error] - Error message if check failed
+ * @property {string} [installUrl] - Installation URL if not installed
+ */
+export async function checkDockerCompose() {
+  // Try docker compose (plugin) first
+  try {
+    const { stdout } = await execAsync('docker compose version');
+    const version = stdout.trim();
+
+    return {
+      installed: true,
+      version: version,
+      method: 'plugin'
+    };
+  } catch (pluginError) {
+    // Plugin not found, try standalone docker-compose
+    try {
+      const { stdout } = await execAsync('docker-compose --version');
+      const version = stdout.trim();
+
+      return {
+        installed: true,
+        version: version,
+        method: 'standalone'
+      };
+    } catch (standaloneError) {
+      // Neither available
+      return {
+        installed: false,
+        error: 'Neither docker compose nor docker-compose found',
+        installUrl: 'https://docs.docker.com/compose/install/'
+      };
+    }
+  }
+}
+
+/**
+ * Check all prerequisites for Raspberry Pi deployment
+ * @returns {Promise<Array>} Array of prerequisite check results
+ */
+export async function checkPiPrerequisites() {
+  const checks = [];
+
+  // Check Docker
+  const dockerResult = await checkDocker();
+  checks.push({
+    name: 'Docker',
+    installed: dockerResult.installed,
+    version: dockerResult.version,
+    error: dockerResult.error,
+    installUrl: dockerResult.installUrl
+  });
+
+  // Check Docker Compose
+  const composeResult = await checkDockerCompose();
+  checks.push({
+    name: 'Docker Compose',
+    installed: composeResult.installed,
+    version: composeResult.version,
+    method: composeResult.method,
+    error: composeResult.error,
+    installUrl: composeResult.installUrl
+  });
+
+  return checks;
+}

package/cli/lib/process-manager.js

@@ -0,0 +1,176 @@
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { getPidPath, getConfigDir } from './config.js';
+
+/**
+ * Get the server PID from the PID file
+ * @param {string} [pidPath] - Optional PID file path (for testing)
+ * @returns {number|null} PID or null if not found
+ */
+export function getServerPid(pidPath = null) {
+  pidPath = pidPath || getPidPath();
+
+  if (!fs.existsSync(pidPath)) {
+    return null;
+  }
+
+  try {
+    const pidStr = fs.readFileSync(pidPath, 'utf8').trim();
+    return parseInt(pidStr, 10);
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Check if a process is running
+ * @param {number} pid - Process ID
+ * @returns {boolean} True if running
+ */
+function isProcessRunning(pid) {
+  try {
+    // Sending signal 0 checks if process exists without killing it
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Check if the server is running
+ * @param {string} [pidPath] - Optional PID file path (for testing)
+ * @returns {Promise<boolean>} True if running
+ */
+export async function isServerRunning(pidPath = null) {
+  const pid = getServerPid(pidPath);
+
+  if (!pid) {
+    return false;
+  }
+
+  return isProcessRunning(pid);
+}
+
+/**
+ * Start the claude-api-server
+ * @param {string} serverPath - Path to claude-api-server directory
+ * @param {number} port - Port to listen on
+ * @param {string} [pidPath] - Optional PID file path (for testing)
+ * @returns {Promise<number>} Process PID
+ */
+export async function startServer(serverPath, port, pidPath = null) {
+  pidPath = pidPath || getPidPath();
+
+  // Check if already running
+  if (await isServerRunning(pidPath)) {
+    const pid = getServerPid(pidPath);
+    throw new Error(`Server already running (PID: ${pid})`);
+  }
+
+  return new Promise((resolve, reject) => {
+    // Spawn detached process
+    const child = spawn('node', ['server.js'], {
+      cwd: serverPath,
+      detached: true,
+      stdio: 'ignore',
+      env: {
+        ...process.env,
+        PORT: port
+      }
+    });
+
+    // Don't wait for child process
+    child.unref();
+
+    // Write PID file
+    try {
+      fs.writeFileSync(pidPath, child.pid.toString(), { mode: 0o600 });
+      resolve(child.pid);
+    } catch (error) {
+      // Kill the child if we can't write PID file
+      try {
+        process.kill(child.pid, 'SIGTERM');
+      } catch (killError) {
+        // Ignore kill errors
+      }
+      reject(new Error(`Failed to write PID file: ${error.message}`));
+    }
+  });
+}
+
+/**
+ * Stop the claude-api-server
+ * @param {string} [pidPath] - Optional PID file path (for testing)
+ * @returns {Promise<void>}
+ */
+export async function stopServer(pidPath = null) {
+  pidPath = pidPath || getPidPath();
+  const pid = getServerPid(pidPath);
+
+  if (!pid) {
+    // Remove stale PID file if it exists
+    if (fs.existsSync(pidPath)) {
+      fs.unlinkSync(pidPath);
+    }
+    return;
+  }
+
+  if (!isProcessRunning(pid)) {
+    // Process not running, remove PID file
+    fs.unlinkSync(pidPath);
+    return;
+  }
+
+  // Try graceful shutdown first
+  try {
+    process.kill(pid, 'SIGTERM');
+
+    // Wait up to 5 seconds for graceful shutdown
+    const startTime = Date.now();
+    while (isProcessRunning(pid) && (Date.now() - startTime) < 5000) {
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+
+    // Force kill if still running
+    if (isProcessRunning(pid)) {
+      process.kill(pid, 'SIGKILL');
+      // Wait a bit more
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+  } catch (error) {
+    // Process might already be dead
+  }
+
+  // Remove PID file
+  if (fs.existsSync(pidPath)) {
+    fs.unlinkSync(pidPath);
+  }
+}
+
+/**
+ * Save a PID file for a named service
+ * @param {string} name - Service name (e.g., 'claude-api-server')
+ * @param {number} pid - Process ID
+ */
+export function savePid(name, pid) {
+  const configDir = getConfigDir();
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
+  }
+  const pidFile = path.join(configDir, `${name}.pid`);
+  fs.writeFileSync(pidFile, pid.toString(), { mode: 0o600 });
+}
+
+/**
+ * Remove a PID file for a named service
+ * @param {string} name - Service name (e.g., 'claude-api-server')
+ */
+export function removePid(name) {
+  const configDir = getConfigDir();
+  const pidFile = path.join(configDir, `${name}.pid`);
+  if (fs.existsSync(pidFile)) {
+    fs.unlinkSync(pidFile);
+  }
+}

package/cli/lib/utils.js

@@ -0,0 +1,78 @@
+import os from 'os';
+import path from 'path';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Get the project root directory (where voice-app and claude-api-server live)
+ * This resolves from the CLI package location, not process.cwd()
+ *
+ * Directory structure:
+ *   claude-phone/           <- project root (returned)
+ *   ├── cli/
+ *   │   └── lib/
+ *   │       └── utils.js    <- this file
+ *   ├── voice-app/
+ *   └── claude-api-server/
+ *
+ * @returns {string} Absolute path to project root
+ */
+export function getProjectRoot() {
+  // utils.js is at cli/lib/utils.js
+  // Project root is two levels up: cli/lib -> cli -> project root
+  return path.resolve(__dirname, '..', '..');
+}
+
+/**
+ * Get local IP address (best guess)
+ * @returns {string} Local IP address or 'auto'
+ */
+export function getLocalIP() {
+  const interfaces = os.networkInterfaces();
+
+  // Look for non-internal IPv4 addresses
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name]) {
+      // Skip internal (loopback) and IPv6
+      if (iface.family === 'IPv4' && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+
+  return 'auto';
+}
+
+/**
+ * Check if Claude CLI is installed
+ * @returns {Promise<boolean>}
+ */
+export async function isClaudeInstalled() {
+  return new Promise((resolve) => {
+    const check = spawn('which', ['claude']);
+    check.on('close', (code) => {
+      resolve(code === 0);
+    });
+  });
+}
+
+/**
+ * Sleep for specified milliseconds
+ * @param {number} ms - Milliseconds to sleep
+ * @returns {Promise<void>}
+ */
+export function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Format device config for display
+ * @param {object} device - Device configuration
+ * @returns {string} Formatted device info
+ */
+export function formatDevice(device) {
+  return `${device.name} (ext ${device.extension})`;
+}

package/cli/lib/validators.js

@@ -0,0 +1,219 @@
+import axios from 'axios';
+
+/**
+ * Validate ElevenLabs API key by making a test request
+ * @param {string} apiKey - ElevenLabs API key
+ * @returns {Promise<{valid: boolean, error?: string}>} Validation result
+ */
+export async function validateElevenLabsKey(apiKey) {
+  if (!apiKey || apiKey.trim() === '') {
+    return {
+      valid: false,
+      error: 'API key cannot be empty'
+    };
+  }
+
+  try {
+    const response = await axios.get('https://api.elevenlabs.io/v1/voices', {
+      headers: {
+        'xi-api-key': apiKey
+      },
+      timeout: 10000
+    });
+
+    if (response.status === 200) {
+      return { valid: true };
+    }
+
+    return {
+      valid: false,
+      error: `Unexpected status: ${response.status}`
+    };
+  } catch (error) {
+    if (error.response) {
+      if (error.response.status === 401) {
+        return {
+          valid: false,
+          error: 'Invalid API key (401 Unauthorized)'
+        };
+      }
+      return {
+        valid: false,
+        error: `API error: ${error.response.status} ${error.response.statusText}`
+      };
+    }
+
+    if (error.code === 'ECONNABORTED') {
+      return {
+        valid: false,
+        error: 'Request timeout - check your internet connection'
+      };
+    }
+
+    return {
+      valid: false,
+      error: `Network error: ${error.message}`
+    };
+  }
+}
+
+/**
+ * Validate OpenAI API key by making a test request
+ * @param {string} apiKey - OpenAI API key
+ * @returns {Promise<{valid: boolean, error?: string}>} Validation result
+ */
+export async function validateOpenAIKey(apiKey) {
+  if (!apiKey || apiKey.trim() === '') {
+    return {
+      valid: false,
+      error: 'API key cannot be empty'
+    };
+  }
+
+  try {
+    const response = await axios.get('https://api.openai.com/v1/models', {
+      headers: {
+        'Authorization': `Bearer ${apiKey}`
+      },
+      timeout: 10000
+    });
+
+    if (response.status === 200) {
+      return { valid: true };
+    }
+
+    return {
+      valid: false,
+      error: `Unexpected status: ${response.status}`
+    };
+  } catch (error) {
+    if (error.response) {
+      if (error.response.status === 401) {
+        return {
+          valid: false,
+          error: 'Invalid API key (401 Unauthorized)'
+        };
+      }
+      return {
+        valid: false,
+        error: `API error: ${error.response.status} ${error.response.statusText}`
+      };
+    }
+
+    if (error.code === 'ECONNABORTED') {
+      return {
+        valid: false,
+        error: 'Request timeout - check your internet connection'
+      };
+    }
+
+    return {
+      valid: false,
+      error: `Network error: ${error.message}`
+    };
+  }
+}
+
+/**
+ * Validate SIP extension format
+ * @param {string} extension - SIP extension number
+ * @returns {boolean} True if valid
+ */
+export function validateExtension(extension) {
+  return /^\d{4,5}$/.test(extension);
+}
+
+/**
+ * Validate IP address format
+ * @param {string} ip - IP address
+ * @returns {boolean} True if valid
+ */
+export function validateIP(ip) {
+  const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
+  if (!ipv4Regex.test(ip)) {
+    return false;
+  }
+
+  const parts = ip.split('.');
+  return parts.every(part => {
+    const num = parseInt(part, 10);
+    return num >= 0 && num <= 255;
+  });
+}
+
+/**
+ * Validate hostname format
+ * @param {string} hostname - Hostname or FQDN
+ * @returns {boolean} True if valid
+ */
+export function validateHostname(hostname) {
+  const hostnameRegex = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
+  return hostnameRegex.test(hostname);
+}
+
+/**
+ * Validate ElevenLabs voice ID
+ * @param {string} apiKey - ElevenLabs API key
+ * @param {string} voiceId - Voice ID to validate
+ * @returns {Promise<{valid: boolean, name?: string, error?: string}>} Validation result
+ */
+export async function validateVoiceId(apiKey, voiceId) {
+  if (!voiceId || voiceId.trim() === '') {
+    return {
+      valid: false,
+      error: 'Voice ID cannot be empty'
+    };
+  }
+
+  try {
+    const response = await axios.get(`https://api.elevenlabs.io/v1/voices/${voiceId}`, {
+      headers: {
+        'xi-api-key': apiKey
+      },
+      timeout: 10000
+    });
+
+    if (response.status === 200 && response.data.name) {
+      return {
+        valid: true,
+        name: response.data.name
+      };
+    }
+
+    return {
+      valid: false,
+      error: `Unexpected response: ${response.status}`
+    };
+  } catch (error) {
+    if (error.response) {
+      if (error.response.status === 404) {
+        return {
+          valid: false,
+          error: 'Voice ID not found'
+        };
+      }
+      if (error.response.status === 401) {
+        return {
+          valid: false,
+          error: 'Invalid API key (cannot validate voice ID)'
+        };
+      }
+      return {
+        valid: false,
+        error: `API error: ${error.response.status} ${error.response.statusText}`
+      };
+    }
+
+    if (error.code === 'ECONNABORTED') {
+      return {
+        valid: false,
+        error: 'Request timeout - check your internet connection'
+      };
+    }
+
+    return {
+      valid: false,
+      error: `Network error: ${error.message}`
+    };
+  }
+}

package/cli/lib/voice-downloader.js

@@ -0,0 +1,79 @@
+import fs from 'fs';
+import path from 'path';
+import https from 'https';
+
+// Curated list of common Piper voices with their known-good download URLs.
+// If a user picks one of these during setup, we fetch it automatically.
+// Anyone who wants a different voice from the full catalog at
+// huggingface.co/rhasspy/piper-voices can still drop files into
+// <ttsLocal>/voices/ manually — that path stays supported.
+const KNOWN_VOICES = {
+  'en_US-lessac-medium': 'en/en_US/lessac/medium',
+  'en_US-amy-medium': 'en/en_US/amy/medium',
+  'en_US-ryan-high': 'en/en_US/ryan/high',
+  'en_GB-alan-medium': 'en/en_GB/alan/medium'
+};
+
+const BASE_URL = 'https://huggingface.co/rhasspy/piper-voices/resolve/main';
+
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(destPath);
+    https.get(url, (response) => {
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        // follow redirect
+        https.get(response.headers.location, (redirected) => {
+          redirected.pipe(file);
+          file.on('finish', () => file.close(resolve));
+        }).on('error', reject);
+        return;
+      }
+      if (response.statusCode !== 200) {
+        reject(new Error(`HTTP ${response.statusCode} for ${url}`));
+        return;
+      }
+      response.pipe(file);
+      file.on('finish', () => file.close(resolve));
+    }).on('error', (err) => {
+      fs.unlink(destPath, () => {});
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Ensure a Piper voice model is present locally, downloading it if it's a
+ * known voice and not already there. Silently does nothing for unknown
+ * voice names (those are assumed to be manually placed by the user).
+ * @param {string} voiceName - e.g. "en_US-lessac-medium"
+ * @param {string} voicesDir - path to tts-local/voices
+ * @returns {Promise<{downloaded: boolean, skipped: boolean, error?: string}>}
+ */
+export async function ensureVoiceModel(voiceName, voicesDir) {
+  const modelPath = path.join(voicesDir, `${voiceName}.onnx`);
+  const configPath = path.join(voicesDir, `${voiceName}.onnx.json`);
+
+  if (fs.existsSync(modelPath) && fs.existsSync(configPath)) {
+    return { downloaded: false, skipped: true };
+  }
+
+  const subPath = KNOWN_VOICES[voiceName];
+  if (!subPath) {
+    return {
+      downloaded: false,
+      skipped: false,
+      error: `Unknown voice "${voiceName}" — not in the auto-download list. ` +
+             `Download it manually from huggingface.co/rhasspy/piper-voices ` +
+             `into ${voicesDir}/`
+    };
+  }
+
+  fs.mkdirSync(voicesDir, { recursive: true });
+
+  await downloadFile(`${BASE_URL}/${subPath}/${voiceName}.onnx`, modelPath);
+  await downloadFile(`${BASE_URL}/${subPath}/${voiceName}.onnx.json`, configPath);
+
+  return { downloaded: true, skipped: false };
+}
+
+export { KNOWN_VOICES };