claude-phone-local 2.0.0

package/cli/lib/commands/logs.js

@@ -0,0 +1,186 @@
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+import axios from 'axios';
+import { loadConfig, configExists, getDockerComposePath, getPidPath } from '../config.js';
+import fs from 'fs';
+
+/**
+ * Logs command - Tail service logs
+ * @param {string} [service] - Optional service name (voice-app or api-server)
+ * @returns {Promise<void>}
+ */
+export async function logsCommand(service = null) {
+  if (!configExists()) {
+    console.log(chalk.red('\n✗ Not configured'));
+    console.log(chalk.gray('  Run "claude-phone setup" first\n'));
+    process.exit(1);
+  }
+
+  const config = await loadConfig();
+  const dockerComposePath = getDockerComposePath();
+
+  // Validate service argument
+  const validServices = ['voice-app', 'api-server'];
+  if (service && !validServices.includes(service)) {
+    console.log(chalk.red(`\n✗ Invalid service: ${service}`));
+    console.log(chalk.gray('  Valid services: voice-app, api-server'));
+    console.log(chalk.gray('  Or omit service to tail all logs\n'));
+    process.exit(1);
+  }
+
+  // Header
+  if (service) {
+    console.log(chalk.bold.cyan(`\n📋 Tailing logs for ${service}...\n`));
+  } else {
+    console.log(chalk.bold.cyan('\n📋 Tailing all service logs...\n'));
+  }
+
+  // Handle different service options
+  if (!service || service === 'voice-app') {
+    // Docker container logs
+    if (!fs.existsSync(dockerComposePath)) {
+      console.log(chalk.yellow('⚠ Docker containers not configured'));
+      console.log(chalk.gray('  Run "claude-phone start" first\n'));
+      if (service === 'voice-app') {
+        process.exit(1);
+      }
+    } else if (!service) {
+      // Both services - interleave logs
+      tailBothServices(dockerComposePath, config);
+      return;
+    } else {
+      // Just voice-app
+      tailDockerLogs(dockerComposePath);
+      return;
+    }
+  }
+
+  if (!service || service === 'api-server') {
+    // API server logs
+    const pidPath = getPidPath();
+    if (!fs.existsSync(pidPath)) {
+      console.log(chalk.yellow('⚠ Claude API server not running'));
+      console.log(chalk.gray('  Run "claude-phone start" first\n'));
+      if (service === 'api-server') {
+        process.exit(1);
+      }
+    } else if (service === 'api-server') {
+      tailAPIServerLogs(config);
+      return;
+    }
+  }
+}
+
+/**
+ * Tail Docker container logs
+ * @param {string} dockerComposePath - Path to docker-compose.yml
+ */
+function tailDockerLogs(dockerComposePath) {
+  const child = spawn('docker', [
+    'compose',
+    '-f',
+    dockerComposePath,
+    'logs',
+    '-f',
+    '--tail=50'
+  ], {
+    stdio: 'inherit'
+  });
+
+  // Handle Ctrl+C gracefully
+  process.on('SIGINT', () => {
+    child.kill('SIGTERM');
+    console.log(chalk.gray('\n\nStopped tailing logs.\n'));
+    process.exit(0);
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0 && code !== null) {
+      console.log(chalk.red(`\n✗ Docker logs failed with exit code ${code}\n`));
+      process.exit(code);
+    }
+  });
+}
+
+/**
+ * Tail API server logs
+ * @param {object} config - Configuration object
+ */
+function tailAPIServerLogs(config) {
+  console.log(chalk.gray('Watching Claude API server output...\n'));
+
+  // 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'));
+
+  let consecutiveFailures = 0;
+
+  const checkHealth = async () => {
+    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}`));
+      }
+    } 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);
+      }
+    }
+  };
+
+  // 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'));
+    process.exit(0);
+  });
+}
+
+/**
+ * Tail both services with interleaved output
+ * @param {string} dockerComposePath - Path to docker-compose.yml
+ * @param {object} _config - Configuration object (unused)
+ */
+function tailBothServices(dockerComposePath, _config) {
+  console.log(chalk.gray('Showing Docker container logs (API server logs not available)\n'));
+
+  const child = spawn('docker', [
+    'compose',
+    '-f',
+    dockerComposePath,
+    'logs',
+    '-f',
+    '--tail=50'
+  ], {
+    stdio: 'inherit'
+  });
+
+  // Handle Ctrl+C gracefully
+  process.on('SIGINT', () => {
+    child.kill('SIGTERM');
+    console.log(chalk.gray('\n\nStopped tailing logs.\n'));
+    process.exit(0);
+  });
+
+  child.on('close', (code) => {
+    if (code !== 0 && code !== null) {
+      console.log(chalk.red(`\n✗ Docker logs failed with exit code ${code}\n`));
+      process.exit(code);
+    }
+  });
+}

package/cli/lib/commands/restore.js

@@ -0,0 +1,172 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { getConfigPath, getConfigDir } from '../config.js';
+
+/**
+ * Get the backups directory path
+ * @returns {string} Path to ~/.claude-phone/backups
+ */
+function getBackupsDir() {
+  return path.join(getConfigDir(), 'backups');
+}
+
+/**
+ * Format file size in human-readable format
+ * @param {number} bytes - File size in bytes
+ * @returns {string} Formatted size string
+ */
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const kb = bytes / 1024;
+  if (kb < 1024) return `${kb.toFixed(2)} KB`;
+  const mb = kb / 1024;
+  return `${mb.toFixed(2)} MB`;
+}
+
+/**
+ * Parse timestamp from backup filename
+ * @param {string} filename - Backup filename
+ * @returns {Date|null} Parsed date or null
+ */
+function parseBackupTimestamp(filename) {
+  // Extract timestamp from format: config.YYYY-MM-DD.HHmmss.json
+  const match = filename.match(/config\.(\d{4}-\d{2}-\d{2})\.(\d{6})\.json/);
+  if (!match) return null;
+
+  const datePart = match[1];
+  const timePart = match[2];
+
+  // Parse: YYYY-MM-DD and HHmmss
+  const year = datePart.substring(0, 4);
+  const month = datePart.substring(5, 7);
+  const day = datePart.substring(8, 10);
+  const hour = timePart.substring(0, 2);
+  const minute = timePart.substring(2, 4);
+  const second = timePart.substring(4, 6);
+
+  return new Date(`${year}-${month}-${day}T${hour}:${minute}:${second}`);
+}
+
+/**
+ * Format date in readable format
+ * @param {Date} date - Date object
+ * @returns {string} Formatted date string
+ */
+function formatDate(date) {
+  return date.toLocaleString('en-US', {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit'
+  });
+}
+
+/**
+ * Restore command - Restore configuration from backup
+ * @returns {Promise<void>}
+ */
+export async function restoreCommand() {
+  console.log(chalk.bold.cyan('\n🔄 Restore Configuration\n'));
+
+  const backupsDir = getBackupsDir();
+
+  // Check if backups directory exists
+  if (!fs.existsSync(backupsDir)) {
+    console.log(chalk.yellow('⚠️  No backups directory found.'));
+    console.log(chalk.gray('Create a backup first with: claude-phone backup\n'));
+    return;
+  }
+
+  // List available backups
+  const files = await fs.promises.readdir(backupsDir);
+  const backups = files.filter(f => f.startsWith('config.') && f.endsWith('.json'));
+
+  if (backups.length === 0) {
+    console.log(chalk.yellow('⚠️  No backups found.'));
+    console.log(chalk.gray('Create a backup first with: claude-phone backup\n'));
+    return;
+  }
+
+  // Sort backups by timestamp (newest first)
+  backups.sort().reverse();
+
+  // Get backup details
+  const backupChoices = await Promise.all(
+    backups.map(async (filename) => {
+      const filepath = path.join(backupsDir, filename);
+      const stats = await fs.promises.stat(filepath);
+      const date = parseBackupTimestamp(filename);
+      const dateStr = date ? formatDate(date) : 'Unknown date';
+      const size = formatSize(stats.size);
+
+      return {
+        name: `${dateStr} (${size})`,
+        value: filename,
+        short: filename
+      };
+    })
+  );
+
+  // Let user select backup
+  const { selectedBackup } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selectedBackup',
+      message: 'Select backup to restore:',
+      choices: backupChoices,
+      pageSize: 10
+    }
+  ]);
+
+  const backupPath = path.join(backupsDir, selectedBackup);
+
+  // Show what will be restored
+  console.log(chalk.bold('\n📋 Restore details:'));
+  const stats = await fs.promises.stat(backupPath);
+  console.log(chalk.gray(`  Source: ${selectedBackup}`));
+  console.log(chalk.gray(`  Size: ${formatSize(stats.size)}`));
+
+  // Confirm restoration
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message: 'This will replace your current configuration. Continue?',
+      default: false
+    }
+  ]);
+
+  if (!confirmed) {
+    console.log(chalk.gray('\nRestore cancelled.\n'));
+    return;
+  }
+
+  const spinner = ora('Restoring configuration...').start();
+
+  try {
+    const configPath = getConfigPath();
+
+    // Backup current config before overwriting (safety)
+    if (fs.existsSync(configPath)) {
+      const safetyBackup = configPath + '.pre-restore';
+      await fs.promises.copyFile(configPath, safetyBackup);
+      spinner.text = 'Current config backed up, restoring...';
+    }
+
+    // Restore selected backup
+    await fs.promises.copyFile(backupPath, configPath);
+
+    spinner.succeed('Configuration restored');
+
+    console.log(chalk.bold.green('\n✓ Configuration restored successfully!\n'));
+    console.log(chalk.gray('Run "claude-phone start" to apply changes.\n'));
+  } catch (error) {
+    spinner.fail(`Restore failed: ${error.message}`);
+    throw error;
+  }
+}