claude-phone-local 2.0.0

package/cli/lib/commands/device/add.js

@@ -0,0 +1,143 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig, saveConfig, configExists } from '../../config.js';
+import { validateExtension, validateVoiceId } from '../../validators.js';
+import { writeDockerConfig } from '../../docker.js';
+
+/**
+ * Device add command - Add a new SIP device
+ * @returns {Promise<void>}
+ */
+export async function deviceAddCommand() {
+  console.log(chalk.bold.cyan('\n➕ Add New Device\n'));
+
+  if (!configExists()) {
+    console.log(chalk.red('✗ Not configured'));
+    console.log(chalk.gray('  Run "claude-phone setup" first\n'));
+    process.exit(1);
+  }
+
+  const config = await loadConfig();
+
+  // Gather device information
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Device name:',
+      validate: (input) => {
+        if (!input || input.trim() === '') {
+          return 'Device name cannot be empty';
+        }
+        // Check for duplicate names
+        const duplicate = config.devices.find(d => d.name.toLowerCase() === input.trim().toLowerCase());
+        if (duplicate) {
+          return `Device name "${input}" already exists`;
+        }
+        return true;
+      }
+    },
+    {
+      type: 'input',
+      name: 'extension',
+      message: 'SIP extension (4-5 digits):',
+      validate: (input) => {
+        if (!validateExtension(input)) {
+          return 'Extension must be 4-5 digits';
+        }
+        // Check for duplicate extensions
+        const duplicate = config.devices.find(d => d.extension === input);
+        if (duplicate) {
+          return `Extension ${input} is already used by device "${duplicate.name}"`;
+        }
+        return true;
+      }
+    },
+    {
+      type: 'input',
+      name: 'authId',
+      message: 'SIP auth ID (press Enter to use extension):',
+      default: (answers) => answers.extension
+    },
+    {
+      type: 'password',
+      name: 'password',
+      message: 'SIP password:',
+      validate: (input) => {
+        if (!input || input.trim() === '') {
+          return 'Password cannot be empty';
+        }
+        return true;
+      }
+    },
+    {
+      type: 'input',
+      name: 'voiceId',
+      message: config.api.mode === 'local'
+        ? 'Piper voice for this device (e.g. en_US-lessac-medium):'
+        : 'ElevenLabs voice ID:',
+      default: config.api.mode === 'local'
+        ? (config.api.local?.voice || 'en_US-lessac-medium')
+        : (config.api.elevenlabs.defaultVoiceId || ''),
+      validate: (input) => {
+        if (!input || input.trim() === '') {
+          return 'Voice cannot be empty';
+        }
+        return true;
+      }
+    },
+    {
+      type: 'input',
+      name: 'prompt',
+      message: 'System prompt:',
+      default: (answers) => `You are ${answers.name}, a helpful AI assistant accessible via phone.`
+    }
+  ]);
+
+  // Validate voice ID with ElevenLabs API — only relevant in cloud mode.
+  // In local mode, the "voice" is just a Piper model name, nothing to validate remotely.
+  let voiceResult = { valid: true, name: answers.voiceId };
+  if (config.api.mode !== 'local') {
+    const spinner = ora('Validating voice ID with ElevenLabs...').start();
+    voiceResult = await validateVoiceId(config.api.elevenlabs.apiKey, answers.voiceId);
+
+    if (!voiceResult.valid) {
+      spinner.fail(chalk.red(`Voice ID validation failed: ${voiceResult.error}`));
+      console.log(chalk.gray('\nPlease check your voice ID and try again.\n'));
+      process.exit(1);
+    }
+
+    spinner.succeed(chalk.green(`Voice validated: ${voiceResult.name}`));
+  }
+
+  // Add device to config
+  const newDevice = {
+    name: answers.name.trim(),
+    extension: answers.extension,
+    authId: answers.authId || answers.extension,
+    password: answers.password,
+    voiceId: answers.voiceId,
+    prompt: answers.prompt || `You are ${answers.name}, a helpful AI assistant accessible via phone.`
+  };
+
+  config.devices.push(newDevice);
+
+  // Save config
+  const saveSpinner = ora('Saving configuration...').start();
+  await saveConfig(config);
+
+  // Regenerate Docker config with new device
+  await writeDockerConfig(config);
+
+  saveSpinner.succeed(chalk.green('Configuration saved'));
+
+  console.log(chalk.bold.green('\n✓ Device added successfully!'));
+  console.log(chalk.gray('\nDevice details:'));
+  console.log(chalk.gray(`  Name: ${newDevice.name}`));
+  console.log(chalk.gray(`  Extension: ${newDevice.extension}`));
+  console.log(chalk.gray(`  Voice: ${voiceResult.name} (${newDevice.voiceId})`));
+  console.log(chalk.yellow('\n⚠ Restart services to apply changes:'));
+  console.log(chalk.gray('  claude-phone stop'));
+  console.log(chalk.gray('  claude-phone start\n'));
+}

package/cli/lib/commands/device/list.js

@@ -0,0 +1,55 @@
+import chalk from 'chalk';
+import { loadConfig, configExists } from '../../config.js';
+
+/**
+ * Device list command - List all configured devices
+ * @returns {Promise<void>}
+ */
+export async function deviceListCommand() {
+  console.log(chalk.bold.cyan('\n📱 Configured Devices\n'));
+
+  if (!configExists()) {
+    console.log(chalk.red('✗ Not configured'));
+    console.log(chalk.gray('  Run "claude-phone setup" first\n'));
+    process.exit(1);
+  }
+
+  const config = await loadConfig();
+
+  if (config.devices.length === 0) {
+    console.log(chalk.yellow('No devices configured.'));
+    console.log(chalk.gray('  Run "claude-phone device add" to add a device\n'));
+    return;
+  }
+
+  // Calculate column widths
+  const nameWidth = Math.max(10, ...config.devices.map(d => d.name.length));
+  const extWidth = 9; // "Extension"
+  const voiceWidth = 30;
+
+  // Print header
+  const horizontalLine = '─'.repeat(nameWidth + extWidth + voiceWidth + 8);
+  console.log('┌' + horizontalLine + '┐');
+
+  const namePad = 'Name'.padEnd(nameWidth);
+  const extPad = 'Extension'.padEnd(extWidth);
+  const voicePad = 'Voice ID'.padEnd(voiceWidth);
+  console.log(`│ ${chalk.bold(namePad)} │ ${chalk.bold(extPad)} │ ${chalk.bold(voicePad)} │`);
+
+  console.log('├' + horizontalLine + '┤');
+
+  // Print devices
+  for (const device of config.devices) {
+    const namePad = device.name.padEnd(nameWidth);
+    const extPad = device.extension.padEnd(extWidth);
+    const voiceDisplay = device.voiceId.length > voiceWidth
+      ? device.voiceId.substring(0, voiceWidth - 3) + '...'
+      : device.voiceId.padEnd(voiceWidth);
+
+    console.log(`│ ${namePad} │ ${extPad} │ ${voiceDisplay} │`);
+  }
+
+  console.log('└' + horizontalLine + '┘');
+
+  console.log(chalk.gray(`\nTotal: ${config.devices.length} device(s)\n`));
+}

package/cli/lib/commands/device/remove.js

@@ -0,0 +1,83 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig, saveConfig, configExists } from '../../config.js';
+import { writeDockerConfig } from '../../docker.js';
+
+/**
+ * Device remove command - Remove a device
+ * @param {string} deviceName - Name of device to remove
+ * @returns {Promise<void>}
+ */
+export async function deviceRemoveCommand(deviceName) {
+  console.log(chalk.bold.cyan('\n🗑️  Remove Device\n'));
+
+  if (!configExists()) {
+    console.log(chalk.red('✗ Not configured'));
+    console.log(chalk.gray('  Run "claude-phone setup" first\n'));
+    process.exit(1);
+  }
+
+  const config = await loadConfig();
+
+  // Find device
+  const deviceIndex = config.devices.findIndex(
+    d => d.name.toLowerCase() === deviceName.toLowerCase()
+  );
+
+  if (deviceIndex === -1) {
+    console.log(chalk.red(`✗ Device "${deviceName}" not found\n`));
+    console.log(chalk.gray('Available devices:'));
+    for (const device of config.devices) {
+      console.log(chalk.gray(`  • ${device.name}`));
+    }
+    console.log();
+    process.exit(1);
+  }
+
+  const device = config.devices[deviceIndex];
+
+  // Prevent removing last device
+  if (config.devices.length === 1) {
+    console.log(chalk.red('✗ Cannot remove the last device'));
+    console.log(chalk.gray('  At least one device must be configured\n'));
+    process.exit(1);
+  }
+
+  // Confirm removal
+  console.log(chalk.yellow('Device details:'));
+  console.log(chalk.gray(`  Name: ${device.name}`));
+  console.log(chalk.gray(`  Extension: ${device.extension}`));
+  console.log(chalk.gray(`  Voice ID: ${device.voiceId}\n`));
+
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message: `Are you sure you want to remove device "${device.name}"?`,
+      default: false
+    }
+  ]);
+
+  if (!confirmed) {
+    console.log(chalk.gray('\nCancelled. No changes made.\n'));
+    return;
+  }
+
+  // Remove device
+  const spinner = ora('Removing device...').start();
+  config.devices.splice(deviceIndex, 1);
+
+  // Save config
+  await saveConfig(config);
+
+  // Regenerate Docker config without this device
+  await writeDockerConfig(config);
+
+  spinner.succeed(chalk.green('Device removed'));
+
+  console.log(chalk.bold.green('\n✓ Device removed successfully!'));
+  console.log(chalk.yellow('\n⚠ Restart services to apply changes:'));
+  console.log(chalk.gray('  claude-phone stop'));
+  console.log(chalk.gray('  claude-phone start\n'));
+}

package/cli/lib/commands/doctor.js

@@ -0,0 +1,422 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { spawn } from 'child_process';
+import axios from 'axios';
+import { loadConfig, configExists, getInstallationType } from '../config.js';
+import { checkDocker, getContainerStatus } from '../docker.js';
+import { isServerRunning, getServerPid } from '../process-manager.js';
+import { validateElevenLabsKey, validateOpenAIKey } from '../validators.js';
+import { isReachable, checkClaudeApiServer as checkClaudeApiHealth } from '../network.js';
+import { checkPort } from '../port-check.js';
+
+/**
+ * Check if Claude CLI is installed
+ * @returns {Promise<{installed: boolean, version?: string, error?: string}>}
+ */
+async function checkClaudeCLI() {
+  return new Promise((resolve) => {
+    const child = spawn('claude', ['--version'], {
+      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) {
+        // Extract version from output
+        const versionMatch = output.match(/(\d+\.\d+\.\d+)/);
+        resolve({
+          installed: true,
+          version: versionMatch ? versionMatch[1] : 'unknown'
+        });
+      } else {
+        resolve({
+          installed: false,
+          error: 'Claude CLI not found in PATH'
+        });
+      }
+    });
+
+    child.on('error', () => {
+      resolve({
+        installed: false,
+        error: 'Claude CLI not found'
+      });
+    });
+  });
+}
+
+/**
+ * Check ElevenLabs API connectivity
+ * @param {string} apiKey - ElevenLabs API key
+ * @returns {Promise<{connected: boolean, error?: string}>}
+ */
+async function checkElevenLabsAPI(apiKey) {
+  try {
+    const result = await validateElevenLabsKey(apiKey);
+    if (result.valid) {
+      return { connected: true };
+    } else {
+      return { connected: false, error: result.error };
+    }
+  } catch (error) {
+    return { connected: false, error: error.message };
+  }
+}
+
+/**
+ * Check OpenAI API connectivity
+ * @param {string} apiKey - OpenAI API key
+ * @returns {Promise<{connected: boolean, error?: string}>}
+ */
+async function checkOpenAIAPI(apiKey) {
+  try {
+    const result = await validateOpenAIKey(apiKey);
+    if (result.valid) {
+      return { connected: true };
+    } else {
+      return { connected: false, error: result.error };
+    }
+  } catch (error) {
+    return { connected: false, error: error.message };
+  }
+}
+
+/**
+ * Check if voice-app container is running
+ * @returns {Promise<{running: boolean, error?: string}>}
+ */
+async function checkVoiceApp() {
+  const containers = await getContainerStatus();
+  const voiceApp = containers.find(c => c.name.includes('voice-app'));
+
+  if (!voiceApp) {
+    return {
+      running: false,
+      error: 'Container not found'
+    };
+  }
+
+  const isRunning = voiceApp.status.toLowerCase().includes('up') ||
+                    voiceApp.status.toLowerCase().includes('running');
+
+  if (!isRunning) {
+    return {
+      running: false,
+      error: `Container status: ${voiceApp.status}`
+    };
+  }
+
+  return { running: true };
+}
+
+/**
+ * Check if claude-api-server is running
+ * @param {number} port - Port to check
+ * @returns {Promise<{running: boolean, pid?: number, healthy?: boolean, error?: string}>}
+ */
+async function checkClaudeAPIServer(port) {
+  const running = await isServerRunning();
+
+  if (!running) {
+    return {
+      running: false,
+      error: 'Process not running'
+    };
+  }
+
+  const pid = getServerPid();
+
+  // Try HTTP health check
+  try {
+    const response = await axios.get(`http://localhost:${port}/health`, {
+      timeout: 5000
+    });
+
+    if (response.status === 200) {
+      return {
+        running: true,
+        pid,
+        healthy: true
+      };
+    } else {
+      return {
+        running: true,
+        pid,
+        healthy: false,
+        error: `Health check returned status ${response.status}`
+      };
+    }
+  } catch (error) {
+    return {
+      running: true,
+      pid,
+      healthy: false,
+      error: 'Health endpoint not responding'
+    };
+  }
+}
+
+/**
+ * Doctor command - Run health checks
+ * @returns {Promise<void>}
+ */
+export async function doctorCommand() {
+  console.log(chalk.bold.cyan('\n🔍 Claude Phone Health Check\n'));
+
+  if (!configExists()) {
+    console.log(chalk.red('✗ Not configured'));
+    console.log(chalk.gray('  → Run "claude-phone setup" first\n'));
+    process.exit(1);
+  }
+
+  const config = await loadConfig();
+  const installationType = getInstallationType(config);
+  const isPiSplit = config.deployment && config.deployment.mode === 'pi-split';
+
+  console.log(chalk.bold(`Installation Type: ${installationType === 'api-server' ? 'API Server' : installationType === 'voice-server' ? 'Voice Server' : 'Both (all-in-one)'}\n`));
+
+  const checks = [];
+  let passedCount = 0;
+
+  // Run type-appropriate checks
+  if (installationType === 'api-server') {
+    const result = await runApiServerChecks(config);
+    checks.push(...result.checks);
+    passedCount += result.passedCount;
+  } else if (installationType === 'voice-server') {
+    const result = await runVoiceServerChecks(config, isPiSplit);
+    checks.push(...result.checks);
+    passedCount += result.passedCount;
+  } else {
+    // Both - run all checks
+    const apiResult = await runApiServerChecks(config);
+    checks.push(...apiResult.checks);
+    passedCount += apiResult.passedCount;
+
+    const voiceResult = await runVoiceServerChecks(config, isPiSplit);
+    checks.push(...voiceResult.checks);
+    passedCount += voiceResult.passedCount;
+  }
+
+  // Summary
+  console.log(chalk.bold(`\n${passedCount}/${checks.length} checks passed\n`));
+
+  if (passedCount === checks.length) {
+    console.log(chalk.green('✓ All systems operational!\n'));
+    process.exit(0);
+  } else if (passedCount > checks.length / 2) {
+    console.log(chalk.yellow('⚠ Some issues detected. Review the failures above.\n'));
+    process.exit(1);
+  } else {
+    console.log(chalk.red('✗ Multiple failures detected. Fix the issues above before using Claude Phone.\n'));
+    process.exit(1);
+  }
+}
+
+/**
+ * Run API server health checks
+ * @param {object} config - Configuration
+ * @returns {Promise<{checks: Array, passedCount: number}>}
+ */
+async function runApiServerChecks(config) {
+  const checks = [];
+  let passedCount = 0;
+
+  // Check Claude CLI
+  const claudeSpinner = ora('Checking Claude CLI...').start();
+  const claudeResult = await checkClaudeCLI();
+  if (claudeResult.installed) {
+    claudeSpinner.succeed(chalk.green(`Claude CLI installed (v${claudeResult.version})`));
+    passedCount++;
+  } else {
+    claudeSpinner.fail(chalk.red(`Claude CLI not found: ${claudeResult.error}`));
+    console.log(chalk.gray('  → Install Claude CLI: npm install -g @anthropic-ai/claude\n'));
+  }
+  checks.push({ name: 'Claude CLI', passed: claudeResult.installed });
+
+  // Check local Claude API server
+  const apiServerSpinner = ora('Checking Claude API server...').start();
+  const apiServerResult = await checkClaudeAPIServer(config.server.claudeApiPort);
+  if (apiServerResult.running && apiServerResult.healthy) {
+    apiServerSpinner.succeed(chalk.green(`Claude API server running (PID: ${apiServerResult.pid})`));
+    passedCount++;
+  } else if (apiServerResult.running && !apiServerResult.healthy) {
+    apiServerSpinner.warn(chalk.yellow(`Claude API server running but unhealthy (PID: ${apiServerResult.pid})`));
+    console.log(chalk.gray(`  → ${apiServerResult.error}\n`));
+    passedCount++; // Count as partial pass
+  } else {
+    apiServerSpinner.fail(chalk.red(`Claude API server not running: ${apiServerResult.error}`));
+    console.log(chalk.gray('  → Run "claude-phone start" to launch services\n'));
+  }
+  checks.push({ name: 'Claude API server', passed: apiServerResult.running });
+
+  return { checks, passedCount };
+}
+
+/**
+ * Run voice server health checks
+ * @param {object} config - Configuration
+ * @param {boolean} isPiSplit - Is Pi split mode
+ * @returns {Promise<{checks: Array, passedCount: number}>}
+ */
+async function runVoiceServerChecks(config, isPiSplit) {
+  const checks = [];
+  let passedCount = 0;
+
+  // Check Docker
+  const dockerSpinner = ora('Checking Docker...').start();
+  const dockerResult = await checkDocker();
+  if (dockerResult.installed && dockerResult.running) {
+    dockerSpinner.succeed(chalk.green('Docker is running'));
+    passedCount++;
+  } else {
+    dockerSpinner.fail(chalk.red(`Docker check failed: ${dockerResult.error}`));
+    console.log(chalk.gray('  → Install Docker Desktop from https://www.docker.com/products/docker-desktop\n'));
+  }
+  checks.push({ name: 'Docker', passed: dockerResult.installed && dockerResult.running });
+
+  if (config.api && config.api.mode === 'local') {
+    // Local mode: check the faster-whisper and Piper sidecar containers instead of cloud APIs
+    const sttSpinner = ora('Checking local STT (faster-whisper)...').start();
+    try {
+      // Doctor runs on the host, not inside the Docker network, so it must
+      // use the localhost-published port (see docker-compose.yml), not the
+      // internal service-name URL that voice-app uses.
+      await axios.get('http://127.0.0.1:9001/health', { timeout: 3000 });
+      sttSpinner.succeed(chalk.green('Local STT (stt-local) is reachable'));
+      passedCount++;
+      checks.push({ name: 'Local STT', passed: true });
+    } catch (error) {
+      sttSpinner.fail(chalk.red(`Local STT unreachable: ${error.message}`));
+      console.log(chalk.gray('  → Check "docker compose logs stt-local"\n'));
+      checks.push({ name: 'Local STT', passed: false });
+    }
+
+    const ttsSpinner = ora('Checking local TTS (Piper)...').start();
+    try {
+      await axios.get('http://127.0.0.1:9002/health', { timeout: 3000 });
+      ttsSpinner.succeed(chalk.green('Local TTS (tts-local) is reachable'));
+      passedCount++;
+      checks.push({ name: 'Local TTS', passed: true });
+    } catch (error) {
+      ttsSpinner.fail(chalk.red(`Local TTS unreachable: ${error.message}`));
+      console.log(chalk.gray('  → Check "docker compose logs tts-local"\n'));
+      checks.push({ name: 'Local TTS', passed: false });
+    }
+  } else {
+    // Check ElevenLabs API (only if configured)
+    if (config.api && config.api.elevenlabs && config.api.elevenlabs.apiKey) {
+      const elevenLabsSpinner = ora('Checking ElevenLabs API...').start();
+      const elevenLabsResult = await checkElevenLabsAPI(config.api.elevenlabs.apiKey);
+      if (elevenLabsResult.connected) {
+        elevenLabsSpinner.succeed(chalk.green('ElevenLabs API connected'));
+        passedCount++;
+      } else {
+        elevenLabsSpinner.fail(chalk.red(`ElevenLabs API failed: ${elevenLabsResult.error}`));
+        console.log(chalk.gray('  → Check your API key in ~/.claude-phone/config.json\n'));
+      }
+      checks.push({ name: 'ElevenLabs API', passed: elevenLabsResult.connected });
+    }
+
+    // Check OpenAI API (only if configured)
+    if (config.api && config.api.openai && config.api.openai.apiKey) {
+      const openAISpinner = ora('Checking OpenAI API...').start();
+      const openAIResult = await checkOpenAIAPI(config.api.openai.apiKey);
+      if (openAIResult.connected) {
+        openAISpinner.succeed(chalk.green('OpenAI API connected'));
+        passedCount++;
+      } else {
+        openAISpinner.fail(chalk.red(`OpenAI API failed: ${openAIResult.error}`));
+        console.log(chalk.gray('  → Check your API key in ~/.claude-phone/config.json\n'));
+      }
+      checks.push({ name: 'OpenAI API', passed: openAIResult.connected });
+    }
+  }
+
+  // Check Voice-app container
+  const voiceAppSpinner = ora('Checking voice-app container...').start();
+  const voiceAppResult = await checkVoiceApp();
+  if (voiceAppResult.running) {
+    voiceAppSpinner.succeed(chalk.green('Voice-app container running'));
+    passedCount++;
+  } else {
+    voiceAppSpinner.fail(chalk.red(`Voice-app container not running: ${voiceAppResult.error}`));
+    console.log(chalk.gray('  → Run "claude-phone start" to launch services\n'));
+  }
+  checks.push({ name: 'Voice-app container', passed: voiceAppResult.running });
+
+  // Check API server reachability (voice-server mode)
+  if (isPiSplit) {
+    // Pi-split mode: Check API server IP reachability
+    const apiIpSpinner = ora('Checking API server IP reachability...').start();
+    const apiServerIp = config.deployment.pi.macIp;
+    const apiServerReachable = await isReachable(apiServerIp);
+
+    if (apiServerReachable) {
+      apiIpSpinner.succeed(chalk.green(`API server IP reachable (${apiServerIp})`));
+      passedCount++;
+    } else {
+      apiIpSpinner.fail(chalk.red(`API server IP not reachable: ${apiServerIp}`));
+      console.log(chalk.gray('  → Check network connection between Pi and API server\n'));
+    }
+    checks.push({ name: 'API server IP reachability', passed: apiServerReachable });
+
+    // Check Claude API server on remote server
+    const apiServerSpinner = ora('Checking Claude API server...').start();
+    const apiUrl = `http://${apiServerIp}:${config.server.claudeApiPort}`;
+    const apiHealth = await checkClaudeApiHealth(apiUrl);
+
+    if (apiHealth.healthy) {
+      apiServerSpinner.succeed(chalk.green(`Claude API server healthy at ${apiUrl}`));
+      passedCount++;
+    } else {
+      apiServerSpinner.fail(chalk.red(`Claude API server not responding`));
+      console.log(chalk.gray(`  → Run "claude-phone api-server" on your API server\n`));
+    }
+    checks.push({ name: 'Claude API server (remote)', passed: apiHealth.healthy });
+
+    // Check drachtio port availability
+    const drachtioPort = config.deployment.pi.drachtioPort || 5060;
+    const drachtioSpinner = ora(`Checking drachtio port ${drachtioPort}...`).start();
+    const drachtioPortCheck = await checkPort(drachtioPort);
+
+    if (drachtioPortCheck.inUse) {
+      if (drachtioPort === 5070) {
+        drachtioSpinner.succeed(chalk.green(`Port ${drachtioPort} in use (expected - drachtio running)`));
+        passedCount++;
+      } else {
+        drachtioSpinner.warn(chalk.yellow(`Port ${drachtioPort} in use (may conflict)`));
+        passedCount++; // Partial pass
+      }
+    } else {
+      drachtioSpinner.succeed(chalk.green(`Port ${drachtioPort} available`));
+      passedCount++;
+    }
+    checks.push({ name: `Drachtio port ${drachtioPort}`, passed: true });
+  } else if (config.deployment && config.deployment.apiServerIp) {
+    // Voice server mode (non-Pi): Check remote API server
+    const apiServerIp = config.deployment.apiServerIp;
+    const apiServerSpinner = ora('Checking remote API server...').start();
+    const apiUrl = `http://${apiServerIp}:${config.server.claudeApiPort}`;
+    const apiHealth = await checkClaudeApiHealth(apiUrl);
+
+    if (apiHealth.healthy) {
+      apiServerSpinner.succeed(chalk.green(`API server healthy at ${apiUrl}`));
+      passedCount++;
+    } else {
+      apiServerSpinner.fail(chalk.red(`API server not responding`));
+      console.log(chalk.gray(`  → Run "claude-phone api-server" on your API server\n`));
+    }
+    checks.push({ name: 'API server (remote)', passed: apiHealth.healthy });
+  }
+
+  return { checks, passedCount };
+}