claude-phone-local 2.1.0 → 2.1.2

package/cli/lib/commands/logs.js

@@ -1,8 +1,8 @@
 import chalk from 'chalk';
 import { spawn } from 'child_process';
-import axios from 'axios';
-import { loadConfig, configExists, getDockerComposePath, getPidPath } from '../config.js';
+import { loadConfig, configExists, getDockerComposePath, getPidPath, getConfigDir } from '../config.js';
 import fs from 'fs';
+import path from 'path';
 
 /**
  * Logs command - Tail service logs
@@ -104,49 +104,53 @@ function tailDockerLogs(dockerComposePath) {
 
 /**
  * Tail API server logs
- * @param {object} config - Configuration object
+ * @param {object} _config - Configuration object (unused; log path is fixed)
  */
-function tailAPIServerLogs(config) {
-  console.log(chalk.gray('Watching Claude API server output...\n'));
+function tailAPIServerLogs(_config) {
+  const logPath = path.join(getConfigDir(), 'claude-api-server.log');
 
-  // Since the server runs detached, we can't easily tail its logs
-  // Instead, we'll monitor its health endpoint
-  console.log(chalk.yellow('Note: API server logs are not available (runs detached)'));
-  console.log(chalk.gray('Monitoring health endpoint instead...\n'));
+  if (!fs.existsSync(logPath)) {
+    console.log(chalk.yellow('⚠ No log file yet - the API server has not written any output'));
+    console.log(chalk.gray(`  Expected at: ${logPath}\n`));
+    process.exit(1);
+  }
+
+  console.log(chalk.gray(`Watching ${logPath}\n`));
+
+  // Print the last ~50 lines, then follow new writes. No native `tail -f` on
+  // Windows, so poll the file size and read only the appended bytes.
+  const fullContent = fs.readFileSync(logPath, 'utf8');
+  const lines = fullContent.split('\n');
+  const tailLines = lines.slice(Math.max(0, lines.length - 50));
+  process.stdout.write(tailLines.join('\n'));
 
-  let consecutiveFailures = 0;
+  let position = fs.statSync(logPath).size;
 
-  const checkHealth = async () => {
+  const poll = setInterval(() => {
     try {
-      const response = await axios.get(`http://localhost:${config.server.claudeApiPort}/health`, {
-        timeout: 3000
-      });
-
-      if (response.status === 200) {
-        console.log(chalk.green(`[${new Date().toISOString()}] ✓ API server healthy`));
-        consecutiveFailures = 0;
-      } else {
-        console.log(chalk.yellow(`[${new Date().toISOString()}] ⚠ Unexpected status: ${response.status}`));
+      const { size } = fs.statSync(logPath);
+      if (size < position) {
+        // Log file was rotated/truncated (e.g. by a restart) - start over.
+        position = 0;
       }
-    } catch (error) {
-      consecutiveFailures++;
-      console.log(chalk.red(`[${new Date().toISOString()}] ✗ Health check failed: ${error.message}`));
-
-      if (consecutiveFailures >= 3) {
-        console.log(chalk.red('\n✗ API server appears to be down. Stopping health checks.\n'));
-        process.exit(1);
+      if (size > position) {
+        const fd = fs.openSync(logPath, 'r');
+        const buffer = Buffer.alloc(size - position);
+        fs.readSync(fd, buffer, 0, buffer.length, position);
+        fs.closeSync(fd);
+        process.stdout.write(buffer.toString('utf8'));
+        position = size;
       }
+    } catch (err) {
+      console.log(chalk.red(`\n✗ Lost access to log file: ${err.message}\n`));
+      clearInterval(poll);
+      process.exit(1);
     }
-  };
+  }, 1000);
 
-  // Check immediately, then every 5 seconds
-  checkHealth();
-  const interval = setInterval(checkHealth, 5000);
-
-  // Handle Ctrl+C
   process.on('SIGINT', () => {
-    clearInterval(interval);
-    console.log(chalk.gray('\n\nStopped monitoring API server.\n'));
+    clearInterval(poll);
+    console.log(chalk.gray('\n\nStopped tailing logs.\n'));
     process.exit(0);
   });
 }
@@ -157,7 +161,7 @@ function tailAPIServerLogs(config) {
  * @param {object} _config - Configuration object (unused)
  */
 function tailBothServices(dockerComposePath, _config) {
-  console.log(chalk.gray('Showing Docker container logs (API server logs not available)\n'));
+  console.log(chalk.gray('Showing Docker container logs. Run "claude-phone logs api-server" separately for the host-side API server log.\n'));
 
   const child = spawn('docker', [
     'compose',

package/cli/lib/commands/start.js

@@ -6,7 +6,7 @@ import { loadConfig, configExists, getInstallationType } from '../config.js';
 import { checkDocker, writeDockerConfig, startContainers } from '../docker.js';
 import { startServer, isServerRunning } from '../process-manager.js';
 import { isClaudeInstalled } from '../utils.js';
-import { checkClaudeApiServer, waitForVoiceAppReady } from '../network.js';
+import { checkClaudeApiServer, waitForVoiceAppReady, waitForClaudeApiServerReady } from '../network.js';
 import { runPrereqChecks } from '../prereqs.js';
 
 /**
@@ -91,7 +91,17 @@ async function startApiServer(config) {
       spinner.warn('Claude API server already running');
     } else {
       await startServer(config.paths.claudeApiServer, config.server.claudeApiPort);
-      spinner.succeed(`Claude API server started on port ${config.server.claudeApiPort}`);
+      // startServer only confirms the process was spawned, not that it
+      // actually bound its port and stayed up (e.g. a stale process already
+      // on that port crashes it with EADDRINUSE within milliseconds).
+      const readiness = await waitForClaudeApiServerReady(`http://localhost:${config.server.claudeApiPort}`);
+      if (readiness.healthy) {
+        spinner.succeed(`Claude API server started on port ${config.server.claudeApiPort}`);
+      } else {
+        spinner.fail(`Claude API server did not become healthy: ${readiness.error || 'timed out'}`);
+        console.log(chalk.yellow(`\n  Check the log: claude-phone logs api-server\n`));
+        process.exit(1);
+      }
     }
   } catch (error) {
     spinner.fail(`Failed to start server: ${error.message}`);
@@ -332,7 +342,17 @@ async function startBoth(config, isPiMode) {
         spinner.warn('Claude API server already running');
       } else {
         await startServer(config.paths.claudeApiServer, config.server.claudeApiPort);
-        spinner.succeed(`Claude API server started on port ${config.server.claudeApiPort}`);
+        // startServer only confirms the process was spawned, not that it
+        // actually bound its port and stayed up (e.g. a stale process
+        // already on that port crashes it with EADDRINUSE within ms).
+        const apiReadiness = await waitForClaudeApiServerReady(`http://localhost:${config.server.claudeApiPort}`);
+        if (apiReadiness.healthy) {
+          spinner.succeed(`Claude API server started on port ${config.server.claudeApiPort}`);
+        } else {
+          spinner.fail(`Claude API server did not become healthy: ${apiReadiness.error || 'timed out'}`);
+          console.log(chalk.yellow(`\n  Check the log: claude-phone logs api-server\n`));
+          process.exit(1);
+        }
       }
     } catch (error) {
       spinner.fail(`Failed to start server: ${error.message}`);

package/cli/lib/network.js

@@ -108,6 +108,33 @@ export async function checkClaudeApiServer(url) {
   });
 }
 
+/**
+ * Poll claude-api-server's /health until it responds, or the timeout
+ * elapses. startServer() only confirms the process was spawned (got a PID) -
+ * not that it actually bound its port and stayed up. A crash right after
+ * spawn (e.g. EADDRINUSE from a stale process already on that port) was
+ * previously reported as "✔ Claude API server started" and "✓ All services
+ * running!" with no indication anything was wrong.
+ * @param {string} url - claude-api-server base URL (e.g. http://localhost:3333)
+ * @param {object} [opts]
+ * @param {number} [opts.timeoutMs=10000] - Give up after this long
+ * @param {number} [opts.intervalMs=500] - Poll interval
+ * @returns {Promise<{healthy: boolean, timedOut: boolean, error?: string}>}
+ */
+export async function waitForClaudeApiServerReady(url, { timeoutMs = 10000, intervalMs = 500 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+
+  while (Date.now() < deadline) {
+    const result = await checkClaudeApiServer(url);
+    if (result.reachable && result.healthy) return { healthy: true, timedOut: false };
+    lastError = result.error;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+
+  return { healthy: false, timedOut: true, error: lastError };
+}
+
 /**
  * Poll voice-app's /health until it reports drachtio + FreeSWITCH both
  * connected, or the timeout elapses. Fixes `claude-phone start` reporting

package/cli/lib/process-manager.js

@@ -70,17 +70,26 @@ export async function startServer(serverPath, port, pidPath = null) {
   }
 
   return new Promise((resolve, reject) => {
+    // Redirect stdout/stderr to a log file instead of discarding them - this
+    // process's own console.log is the only place query timing, session
+    // tracking, and CLI/SDK errors are visible; with stdio: 'ignore' there
+    // was no way to diagnose a slow or failed call after the fact.
+    const logPath = path.join(getConfigDir(), 'claude-api-server.log');
+    const logFd = fs.openSync(logPath, 'a');
+
     // Spawn detached process
     const child = spawn('node', ['server.js'], {
       cwd: serverPath,
       detached: true,
-      stdio: 'ignore',
+      stdio: ['ignore', logFd, logFd],
       env: {
         ...process.env,
         PORT: port
       }
     });
 
+    fs.closeSync(logFd); // child holds its own reference to the fd via dup()
+
     // Don't wait for child process
     child.unref();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-phone-local",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "Local/offline fork of NetworkChuck's claude-phone: talk to Claude Code over 3CX/SIP with faster-whisper STT + Piper TTS in one Docker container.",
   "type": "module",
   "bin": {