claude-phone-local 2.0.0

package/cli/lib/docker.js

@@ -0,0 +1,384 @@
+import { spawn, execSync } from 'child_process';
+import crypto from 'crypto';
+import fs from 'fs';
+import {
+  getDockerComposePath,
+  getEnvPath,
+  getConfigDir
+} from './config.js';
+
+/**
+ * Detect which docker compose command to use
+ * Some systems have 'docker compose' (plugin), others have 'docker-compose' (standalone)
+ * @returns {{cmd: string, args: string[]}} Command and base args for compose
+ */
+function getComposeCommand() {
+  // Try 'docker compose' (plugin) first
+  try {
+    execSync('docker compose version', { stdio: 'pipe' });
+    return { cmd: 'docker', args: ['compose'] };
+  } catch (e) {
+    // Fall back to standalone docker-compose
+    try {
+      execSync('docker-compose --version', { stdio: 'pipe' });
+      return { cmd: 'docker-compose', args: [] };
+    } catch (e2) {
+      // Default to plugin style, let it fail with helpful error
+      return { cmd: 'docker', args: ['compose'] };
+    }
+  }
+}
+
+/**
+ * Generate a random secret for Docker services
+ * @returns {string} Random 32-character hex string
+ */
+function generateSecret() {
+  return crypto.randomBytes(16).toString('hex');
+}
+
+/**
+ * Check if Docker is installed and running
+ * @returns {Promise<{installed: boolean, running: boolean, error?: string}>}
+ */
+export async function checkDocker() {
+  // Check if docker command exists
+  const installed = await new Promise((resolve) => {
+    const check = spawn('docker', ['--version']);
+    check.on('close', (code) => resolve(code === 0));
+    check.on('error', () => resolve(false));
+  });
+
+  if (!installed) {
+    return {
+      installed: false,
+      running: false,
+      error: 'Docker not found. Please install Docker from https://docs.docker.com/engine/install/'
+    };
+  }
+
+  // Check if Docker daemon is running by running a simple command
+  const running = await new Promise((resolve) => {
+    const check = spawn('docker', ['ps', '-q'], {
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    check.on('close', (code) => resolve(code === 0));
+    check.on('error', () => resolve(false));
+  });
+
+  if (!running) {
+    return {
+      installed: true,
+      running: false,
+      error: 'Docker is installed but not running. Please start Docker Desktop.'
+    };
+  }
+
+  return {
+    installed: true,
+    running: true
+  };
+}
+
+/**
+ * Generate docker-compose.yml from config
+ * @param {object} config - Configuration object
+ * @returns {string} Docker compose YAML content
+ */
+export function generateDockerCompose(config) {
+  const externalIp = config.server.externalIp === 'auto' ? '${EXTERNAL_IP}' : config.server.externalIp;
+  const drachtioPort = config.deployment?.pi?.drachtioPort || 5070;
+  const rtpStart = config.server.rtpStart || 30000;
+  const rtpEnd = config.server.rtpEnd || 30100;
+
+  // Single image: drachtio + FreeSWITCH + voice-app + STT + TTS under supervisord.
+  // They talk over 127.0.0.1, so there is no container DNS to misconfigure.
+  // Everything that must outlive a restart is on the ./data bind mount.
+  return `# Generated by \`claude-phone setup\` - edit .env, not this file.
+services:
+  claude-phone:
+    build: .
+    image: claude-phone-local:latest
+    container_name: claude-phone
+    restart: unless-stopped
+    env_file:
+      - .env
+    environment:
+      - DRACHTIO_HOST=127.0.0.1
+      - FREESWITCH_HOST=127.0.0.1
+      - STT_LOCAL_URL=http://127.0.0.1:9001
+      - TTS_LOCAL_URL=http://127.0.0.1:9002
+      - AUDIO_BASE_URL=http://127.0.0.1:3000
+      - EXTERNAL_IP=${externalIp}
+      - RTP_START=${rtpStart}
+      - RTP_END=${rtpEnd}
+    ports:
+      - "3000:3000"
+      - "${drachtioPort}:${drachtioPort}/udp"
+      - "${drachtioPort}:${drachtioPort}/tcp"
+      - "${rtpStart}-${rtpEnd}:${rtpStart}-${rtpEnd}/udp"
+    volumes:
+      - ./data:/data
+`;
+}
+
+/**
+ * Generate .env file from config
+ * @param {object} config - Configuration object
+ * @returns {string} Environment file content
+ */
+export function generateEnvFile(config) {
+  // Ensure secrets exist in config
+  if (!config.secrets) {
+    config.secrets = {
+      drachtio: generateSecret(),
+      freeswitch: generateSecret()
+    };
+  }
+
+  // Determine Claude API URL based on deployment mode
+  let claudeApiUrl;
+  if (config.deployment && config.deployment.mode === 'pi-split' && config.deployment.pi && config.deployment.pi.macIp) {
+    // Pi mode: point to remote API server
+    claudeApiUrl = `http://${config.deployment.pi.macIp}:${config.server.claudeApiPort}`;
+  } else if (config.deployment && config.deployment.mode === 'voice-server' && config.deployment.apiServerIp) {
+    // Voice server mode (non-Pi): point to remote API server
+    claudeApiUrl = `http://${config.deployment.apiServerIp}:${config.server.claudeApiPort}`;
+  } else {
+    // Both or api-server mode: local API server runs on the HOST (it shells
+    // out to the `claude` CLI directly), while voice-app runs in Docker on
+    // a bridge network — so it must reach the host via host.docker.internal,
+    // not localhost (which inside the container means the container itself).
+    claudeApiUrl = `http://host.docker.internal:${config.server.claudeApiPort}`;
+  }
+
+  const lines = [
+    '# ====================================',
+    '# WARNING: DO NOT SHARE THIS FILE',
+    '# Contains API keys and passwords',
+    '# ====================================',
+    '# Claude Phone Configuration',
+    '# Generated by claude-phone CLI',
+    '# ====================================',
+    '',
+    '# Network Configuration',
+    `EXTERNAL_IP=${config.server.externalIp === 'auto' ? 'auto' : config.server.externalIp}`,
+    '',
+    '# Drachtio Configuration',
+    'DRACHTIO_HOST=drachtio',
+    'DRACHTIO_PORT=9022',
+    `DRACHTIO_SECRET=${config.secrets.drachtio}`,
+    // SIP port for Contact header (5070 when 3CX SBC is present, 5060 otherwise)
+    `DRACHTIO_SIP_PORT=${config.deployment?.pi?.drachtioPort || 5060}`,
+    '',
+    '# FreeSWITCH Configuration',
+    'FREESWITCH_HOST=freeswitch',
+    'FREESWITCH_PORT=8021',
+    // Note: This is the default ESL password for drachtio/drachtio-freeswitch-mrf
+    'FREESWITCH_SECRET=JambonzR0ck$',
+    '',
+    '# 3CX / SIP Configuration',
+    `SIP_DOMAIN=${config.sip.domain}`,
+    `SIP_REGISTRAR=${config.sip.registrar}`,
+    '',
+    '# Default extension (primary device)',
+    `SIP_EXTENSION=${config.devices[0].extension}`,
+    `SIP_AUTH_ID=${config.devices[0].authId}`,
+    `SIP_PASSWORD=${config.devices[0].password}`,
+    '',
+    '# Claude API Server',
+    `CLAUDE_API_URL=${claudeApiUrl}`,
+    '',
+    ...(config.api.mode === 'local' ? [
+      '# Local STT/TTS (no API keys — faster-whisper + Piper containers)',
+      'STT_MODE=local',
+      'TTS_MODE=local',
+      `STT_LOCAL_URL=${config.api.local?.sttUrl || 'http://stt-local:9001'}`,
+      `TTS_LOCAL_URL=${config.api.local?.ttsUrl || 'http://tts-local:9002'}`,
+      `AUDIO_BASE_URL=${config.api.local?.audioBaseUrl || 'http://voice-app:3000'}`,
+      `PIPER_VOICE=${config.devices[0].voiceId || config.api.local?.voice || 'en_US-lessac-medium'}`,
+      `WHISPER_MODEL=${config.api.local?.whisperModel || 'small'}`,
+      ''
+    ] : [
+      '# STT/TTS mode',
+      'STT_MODE=cloud',
+      'TTS_MODE=cloud',
+      '',
+      '# ElevenLabs TTS',
+      `ELEVENLABS_API_KEY=${config.api.elevenlabs.apiKey}`,
+      `ELEVENLABS_VOICE_ID=${config.devices[0].voiceId}`,
+      '',
+      '# OpenAI (Whisper STT)',
+      `OPENAI_API_KEY=${config.api.openai.apiKey}`,
+      ''
+    ]),
+    '# Application Settings',
+    `HTTP_PORT=${config.server.httpPort}`,
+    'WS_PORT=3001',
+    'AUDIO_DIR=/app/audio',
+    '',
+    '# Outbound Call Settings',
+    'MAX_CONVERSATION_TURNS=10',
+    'OUTBOUND_RING_TIMEOUT=30',
+    ''
+  ];
+
+  return lines.join('\n');
+}
+
+/**
+ * Write Docker configuration files
+ * @param {object} config - Configuration object
+ * @returns {Promise<void>}
+ */
+export async function writeDockerConfig(config) {
+  const dockerComposePath = getDockerComposePath();
+  const envPath = getEnvPath();
+
+  const dockerComposeContent = generateDockerCompose(config);
+  const envContent = generateEnvFile(config);
+
+  await fs.promises.writeFile(dockerComposePath, dockerComposeContent, { mode: 0o644 });
+  await fs.promises.writeFile(envPath, envContent, { mode: 0o600 });
+}
+
+/**
+ * Start Docker containers
+ * @returns {Promise<void>}
+ */
+export async function startContainers() {
+  const configDir = getConfigDir();
+  const dockerComposePath = getDockerComposePath();
+
+  if (!fs.existsSync(dockerComposePath)) {
+    throw new Error('Docker configuration not found. Run "claude-phone setup" first.');
+  }
+
+  const compose = getComposeCommand();
+  const composeArgs = [...compose.args, '-f', dockerComposePath, 'up', '-d'];
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(compose.cmd, composeArgs, {
+      cwd: configDir,
+      stdio: 'pipe'
+    });
+
+    let output = '';
+    child.stdout.on('data', (data) => {
+      output += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      output += data.toString();
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        // AC22: Detect ARM64 image pull failure
+        if (output.includes('no matching manifest') ||
+            output.includes('image with reference') && output.includes('arm64')) {
+          const error = new Error(
+            'ARM64 Docker image pull failed.\n\n' +
+            'Try manually pulling images:\n' +
+            '  docker pull drachtio/drachtio-server:latest\n' +
+            '  docker pull drachtio/drachtio-freeswitch-mrf:latest\n\n' +
+            'If images are not available for ARM64, you may need to build them locally.'
+          );
+          reject(error);
+        } else {
+          reject(new Error(`Docker compose failed (exit ${code}): ${output}`));
+        }
+      }
+    });
+  });
+}
+
+/**
+ * Stop Docker containers
+ * @returns {Promise<void>}
+ */
+export async function stopContainers() {
+  const configDir = getConfigDir();
+  const dockerComposePath = getDockerComposePath();
+
+  if (!fs.existsSync(dockerComposePath)) {
+    // No containers to stop
+    return;
+  }
+
+  const compose = getComposeCommand();
+  const composeArgs = [...compose.args, '-f', dockerComposePath, 'down'];
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(compose.cmd, composeArgs, {
+      cwd: configDir,
+      stdio: 'pipe'
+    });
+
+    let output = '';
+    child.stdout.on('data', (data) => {
+      output += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      output += data.toString();
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Docker compose down failed (exit ${code}): ${output}`));
+      }
+    });
+  });
+}
+
+/**
+ * Get status of Docker containers
+ * @returns {Promise<Array<{name: string, status: string}>>}
+ */
+export async function getContainerStatus() {
+  const dockerComposePath = getDockerComposePath();
+
+  if (!fs.existsSync(dockerComposePath)) {
+    return [];
+  }
+
+  const compose = getComposeCommand();
+  const composeArgs = [...compose.args, '-f', dockerComposePath, 'ps', '--format', 'json'];
+
+  return new Promise((resolve) => {
+    const child = spawn(compose.cmd, composeArgs, {
+      stdio: 'pipe'
+    });
+
+    let output = '';
+    child.stdout.on('data', (data) => {
+      output += data.toString();
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        try {
+          // Parse JSON lines (one per container)
+          const lines = output.trim().split('\n').filter(l => l);
+          const containers = lines.map(line => {
+            const data = JSON.parse(line);
+            return {
+              name: data.Name || data.Service,
+              status: data.State || data.Status
+            };
+          });
+          resolve(containers);
+        } catch (error) {
+          resolve([]);
+        }
+      } else {
+        resolve([]);
+      }
+    });
+  });
+}

package/cli/lib/mcp-register.js

@@ -0,0 +1,108 @@
+/**
+ * Register the claude-phone MCP server with the Claude Code CLI.
+ *
+ * Done from `claude-phone setup` (and `claude-phone mcp install`) rather than
+ * from npm's postinstall, for two reasons:
+ *   - postinstall runs before setup, so the extension to call is not known yet;
+ *   - silently editing the user's ~/.claude.json during `npm install` is rude.
+ *
+ * Everything here is best-effort: a missing `claude` CLI is reported and
+ * skipped, never fatal.
+ */
+
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import chalk from 'chalk';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/** Absolute path to the MCP server entry point inside the installed package. */
+export function mcpServerPath() {
+  return path.resolve(__dirname, '..', '..', 'mcp-server', 'index.js');
+}
+
+function claudeAvailable() {
+  try {
+    execFileSync('claude', ['--version'], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function alreadyRegistered() {
+  try {
+    const out = execFileSync('claude', ['mcp', 'list'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return /^\s*claude-phone:/m.test(out);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {object} opts
+ * @param {string} [opts.defaultTo]  Extension/number Claude should ring.
+ * @param {number} [opts.httpPort]   voice-app HTTP port.
+ * @param {boolean} [opts.force]     Re-register even if already present.
+ * @returns {{ok: boolean, reason?: string}}
+ */
+export function registerMcpServer({ defaultTo, httpPort = 3000, force = false } = {}) {
+  const serverPath = mcpServerPath();
+
+  if (!existsSync(serverPath)) {
+    return { ok: false, reason: `MCP server not found at ${serverPath}` };
+  }
+  if (!claudeAvailable()) {
+    return { ok: false, reason: 'Claude Code CLI not found on PATH' };
+  }
+
+  if (alreadyRegistered()) {
+    if (!force) return { ok: true, reason: 'already registered' };
+    try {
+      execFileSync('claude', ['mcp', 'remove', 'claude-phone', '--scope', 'user'], { stdio: 'ignore' });
+    } catch {
+      // Not fatal - add may still succeed, or report a clearer error.
+    }
+  }
+
+  const args = [
+    'mcp', 'add', 'claude-phone',
+    '--scope', 'user',
+    '--env', `VOICE_APP_URL=http://127.0.0.1:${httpPort}`,
+  ];
+  if (defaultTo) args.push('--env', `PHONE_DEFAULT_TO=${defaultTo}`);
+  args.push('--', 'node', serverPath);
+
+  try {
+    execFileSync('claude', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    return { ok: true };
+  } catch (err) {
+    const detail = (err.stderr && err.stderr.toString().trim()) || err.message;
+    return { ok: false, reason: detail };
+  }
+}
+
+/** Register and print a short human-readable result. Never throws. */
+export function registerMcpServerWithOutput(opts = {}) {
+  const result = registerMcpServer(opts);
+
+  if (result.ok && result.reason === 'already registered') {
+    console.log(chalk.gray('  MCP server already registered (use --force to update)'));
+  } else if (result.ok) {
+    console.log(chalk.green('  MCP server registered as "claude-phone"'));
+    if (opts.defaultTo) {
+      console.log(chalk.gray(`  Claude will ring ${opts.defaultTo} by default`));
+    }
+    console.log(chalk.yellow('  Restart Claude Code, then try: "call me when the build finishes"'));
+  } else {
+    console.log(chalk.yellow(`  Skipped MCP registration: ${result.reason}`));
+    console.log(chalk.gray('  Register later with: claude-phone mcp install'));
+  }
+
+  return result;
+}

package/cli/lib/network.js

@@ -0,0 +1,109 @@
+import net from 'net';
+import http from 'http';
+
+/**
+ * Check if an IP address is reachable on the network
+ * @param {string} ip - IP address to check
+ * @param {number} [port=3333] - Port to check (defaults to API server port)
+ * @param {number} [timeout=3000] - Timeout in milliseconds
+ * @returns {Promise<boolean>} True if IP is reachable
+ */
+export async function isReachable(ip, port = 3333, timeout = 3000) {
+  return new Promise((resolve) => {
+    // Validate IP format first
+    const ipPattern = /^(\d{1,3}\.){3}\d{1,3}$/;
+    if (!ipPattern.test(ip)) {
+      resolve(false);
+      return;
+    }
+
+    const socket = new net.Socket();
+
+    // Set timeout
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, timeout);
+
+    socket.on('connect', () => {
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(true);
+    });
+
+    socket.on('error', (err) => {
+      clearTimeout(timer);
+      socket.destroy();
+
+      // ECONNREFUSED means the IP is reachable but nothing is listening on that port
+      // This is actually a GOOD sign - the IP responded
+      if (err.code === 'ECONNREFUSED') {
+        resolve(true);
+      } else {
+        // ETIMEDOUT, EHOSTUNREACH, etc. mean IP is not reachable
+        resolve(false);
+      }
+    });
+
+    // Connect to the specified port (default 3333 for API server)
+    socket.connect(port, ip);
+  });
+}
+
+/**
+ * Check if claude-api-server is responding at a given URL
+ * @param {string} url - Full URL to claude-api-server (e.g., http://192.168.1.100:3333)
+ * @returns {Promise<object>} Check result
+ * @property {boolean} reachable - True if server is reachable
+ * @property {boolean} [healthy] - True if server responds with success (only if reachable)
+ * @property {string} [error] - Error message if check failed
+ */
+export async function checkClaudeApiServer(url) {
+  return new Promise((resolve) => {
+    try {
+      // Validate URL format
+      // URL is a global in Node.js (no import needed)
+      // eslint-disable-next-line no-undef, no-new
+      new URL(url);
+
+      // Try to reach /health endpoint (or root if /health doesn't exist)
+      const healthUrl = url + '/health';
+
+      const req = http.get(healthUrl, { timeout: 3000 }, (res) => {
+        // Server is reachable
+        const healthy = res.statusCode >= 200 && res.statusCode < 400;
+
+        resolve({
+          reachable: true,
+          healthy: healthy,
+          statusCode: res.statusCode
+        });
+
+        // Consume response to free up memory
+        res.resume();
+      });
+
+      req.on('error', (err) => {
+        // Connection error - server not reachable
+        resolve({
+          reachable: false,
+          error: err.message
+        });
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        resolve({
+          reachable: false,
+          error: 'Connection timeout'
+        });
+      });
+    } catch (err) {
+      // Invalid URL format
+      resolve({
+        reachable: false,
+        error: err.message
+      });
+    }
+  });
+}

package/cli/lib/platform.js

@@ -0,0 +1,85 @@
+import os from 'os';
+import fs from 'fs';
+
+/**
+ * Get Raspberry Pi model string from /proc/device-tree/model
+ * @returns {Promise<string|null>} Pi model string or null if not Pi
+ */
+export async function getPiModel() {
+  const modelPath = '/proc/device-tree/model';
+
+  try {
+    // Check if file exists
+    if (!fs.existsSync(modelPath)) {
+      return null;
+    }
+
+    // Read model file
+    const data = await fs.promises.readFile(modelPath, 'utf8');
+
+    // File contains null-terminated string, clean it
+    const model = data.replace(/\0/g, '').trim();
+
+    // Only return if it's actually a Raspberry Pi
+    if (model.includes('Raspberry Pi')) {
+      return model;
+    }
+
+    return null;
+  } catch (error) {
+    // If we can't read the file, we're not on a Pi
+    return null;
+  }
+}
+
+/**
+ * Check if running on Raspberry Pi
+ * @returns {Promise<boolean>} True if running on Raspberry Pi
+ */
+export async function isRaspberryPi() {
+  // Pi detection requires:
+  // 1. Linux platform
+  // 2. ARM64 architecture
+  // 3. Raspberry Pi model string in /proc/device-tree/model
+
+  if (os.platform() !== 'linux') {
+    return false;
+  }
+
+  if (os.arch() !== 'arm64') {
+    return false;
+  }
+
+  const model = await getPiModel();
+  return model !== null;
+}
+
+/**
+ * Detect current platform and Raspberry Pi status
+ * @returns {Promise<object>} Platform information
+ * @property {string} os - Operating system (darwin, linux, win32)
+ * @property {string} arch - CPU architecture (x64, arm64, arm)
+ * @property {boolean} isPi - True if Raspberry Pi detected
+ * @property {string} [piModel] - Pi model string if isPi is true
+ */
+export async function detectPlatform() {
+  const platform = os.platform();
+  const arch = os.arch();
+  const isPi = await isRaspberryPi();
+
+  const result = {
+    os: platform,
+    arch: arch,
+    isPi: isPi
+  };
+
+  // Add Pi model if detected
+  if (isPi) {
+    const model = await getPiModel();
+    if (model) {
+      result.piModel = model;
+    }
+  }
+
+  return result;
+}