claude-phone-local 2.0.0

package/cli/lib/commands/uninstall.js

@@ -0,0 +1,183 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { getConfigDir, configExists } from '../config.js';
+import { stopContainers } from '../docker.js';
+import { stopServer, isServerRunning } from '../process-manager.js';
+
+/**
+ * Get the CLI install directory path
+ * @returns {string} Path to ~/.claude-phone-cli
+ */
+function getCliInstallDir() {
+  return path.join(os.homedir(), '.claude-phone-cli');
+}
+
+/**
+ * Find symlink location
+ * @returns {Promise<string|null>} Symlink path or null if not found
+ */
+async function findSymlink() {
+  const possiblePaths = [
+    '/usr/local/bin/claude-phone',
+    path.join(os.homedir(), '.local/bin/claude-phone')
+  ];
+
+  for (const symlinkPath of possiblePaths) {
+    try {
+      const stats = await fs.promises.lstat(symlinkPath);
+      if (stats.isSymbolicLink()) {
+        return symlinkPath;
+      }
+    } catch (error) {
+      // Path doesn't exist, continue
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Remove directory recursively
+ * @param {string} dirPath - Directory path to remove
+ * @returns {Promise<void>}
+ */
+async function removeDirectory(dirPath) {
+  if (fs.existsSync(dirPath)) {
+    await fs.promises.rm(dirPath, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Uninstall command - Complete removal of Claude Phone
+ * @returns {Promise<void>}
+ */
+export async function uninstallCommand() {
+  console.log(chalk.bold.red('\n🗑️  Uninstall Claude Phone\n'));
+
+  const configDir = getConfigDir();
+  const cliDir = getCliInstallDir();
+  const hasConfig = configExists();
+  const symlinkPath = await findSymlink();
+
+  // Show what will be removed
+  console.log(chalk.bold('The following will be removed:\n'));
+
+  if (hasConfig || fs.existsSync(configDir)) {
+    console.log(chalk.yellow('  • Configuration directory:'));
+    console.log(chalk.gray(`    ${configDir}`));
+    console.log(chalk.gray('    (includes config.json, backups, generated files)'));
+  }
+
+  if (fs.existsSync(cliDir)) {
+    console.log(chalk.yellow('\n  • CLI installation:'));
+    console.log(chalk.gray(`    ${cliDir}`));
+  }
+
+  if (symlinkPath) {
+    console.log(chalk.yellow('\n  • Symlink:'));
+    console.log(chalk.gray(`    ${symlinkPath}`));
+  }
+
+  console.log(chalk.yellow('\n  • Docker containers:'));
+  console.log(chalk.gray('    voice-app, drachtio, freeswitch'));
+
+  // First confirmation: Remove Claude Phone?
+  console.log(chalk.bold.red('\n⚠️  WARNING: This action cannot be undone!\n'));
+
+  const { confirmUninstall } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmUninstall',
+      message: 'Remove Claude Phone?',
+      default: false
+    }
+  ]);
+
+  if (!confirmUninstall) {
+    console.log(chalk.gray('\nUninstall cancelled.\n'));
+    return;
+  }
+
+  // Second confirmation: Delete configuration and backups?
+  if (hasConfig || fs.existsSync(configDir)) {
+    const { confirmConfig } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmConfig',
+        message: 'Delete configuration and backups? (This will remove API keys and all backups)',
+        default: false
+      }
+    ]);
+
+    if (!confirmConfig) {
+      console.log(chalk.gray('\nUninstall cancelled. Configuration preserved.\n'));
+      return;
+    }
+  }
+
+  console.log(chalk.bold.cyan('\n🧹 Removing Claude Phone...\n'));
+
+  // Step 1: Stop services
+  let spinner = ora('Stopping Claude API server...').start();
+  try {
+    if (await isServerRunning()) {
+      await stopServer();
+      spinner.succeed('Claude API server stopped');
+    } else {
+      spinner.info('Claude API server not running');
+    }
+  } catch (error) {
+    spinner.warn(`Could not stop server: ${error.message}`);
+  }
+
+  spinner = ora('Stopping Docker containers...').start();
+  try {
+    await stopContainers();
+    spinner.succeed('Docker containers stopped');
+  } catch (error) {
+    spinner.warn(`Could not stop containers: ${error.message}`);
+  }
+
+  // Step 2: Remove configuration directory
+  if (fs.existsSync(configDir)) {
+    spinner = ora('Removing configuration directory...').start();
+    try {
+      await removeDirectory(configDir);
+      spinner.succeed('Configuration directory removed');
+    } catch (error) {
+      spinner.fail(`Failed to remove config directory: ${error.message}`);
+    }
+  }
+
+  // Step 3: Remove CLI installation
+  if (fs.existsSync(cliDir)) {
+    spinner = ora('Removing CLI installation...').start();
+    try {
+      await removeDirectory(cliDir);
+      spinner.succeed('CLI installation removed');
+    } catch (error) {
+      spinner.fail(`Failed to remove CLI directory: ${error.message}`);
+    }
+  }
+
+  // Step 4: Remove symlink
+  if (symlinkPath) {
+    spinner = ora('Removing symlink...').start();
+    try {
+      await fs.promises.unlink(symlinkPath);
+      spinner.succeed('Symlink removed');
+    } catch (error) {
+      spinner.warn(`Could not remove symlink: ${error.message}`);
+    }
+  }
+
+  console.log(chalk.bold.green('\n✓ Claude Phone uninstalled\n'));
+  console.log(chalk.gray('Thank you for using Claude Phone! 👋\n'));
+  console.log(chalk.gray('Note: Docker images were not removed. To clean them up, run:'));
+  console.log(chalk.gray('  docker image rm drachtio/drachtio-server:latest'));
+  console.log(chalk.gray('  docker image rm drachtio/drachtio-freeswitch-mrf:latest\n'));
+}

package/cli/lib/commands/update.js

@@ -0,0 +1,205 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { execSync } from 'child_process';
+import { loadConfig, saveConfig, configExists } from '../config.js';
+
+/**
+ * Check for git repository
+ * @param {string} projectRoot - Root directory of claude-phone
+ * @returns {boolean} True if git repo
+ */
+function isGitRepo(projectRoot) {
+  try {
+    execSync('git rev-parse --is-inside-work-tree', {
+      cwd: projectRoot,
+      stdio: 'ignore'
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get current git branch
+ * @param {string} projectRoot - Root directory of claude-phone
+ * @returns {string} Branch name
+ */
+function getCurrentBranch(projectRoot) {
+  try {
+    return execSync('git rev-parse --abbrev-ref HEAD', {
+      cwd: projectRoot,
+      encoding: 'utf8'
+    }).trim();
+  } catch {
+    return 'unknown';
+  }
+}
+
+/**
+ * Get project root directory (where package.json is)
+ * @returns {string} Project root path
+ */
+function getProjectRoot() {
+  // CLI is in cli/lib/commands/, project root is three levels up
+  const currentFile = fileURLToPath(import.meta.url);
+  const commandsDir = path.dirname(currentFile);
+  const libDir = path.dirname(commandsDir);
+  const cliDir = path.dirname(libDir);
+  const projectRoot = path.dirname(cliDir);
+  return fs.realpathSync(projectRoot);
+}
+
+/**
+ * Fetch latest release info from GitHub
+ * @returns {Promise<object>} Release info
+ */
+async function fetchLatestRelease() {
+  try {
+    const response = await fetch(
+      'https://api.github.com/repos/masterdeepak15/claude-phone-local/releases/latest',
+      {
+        headers: {
+          'User-Agent': 'claude-phone-cli',
+          'Accept': 'application/vnd.github.v3+json'
+        }
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.statusText}`);
+    }
+
+    return await response.json();
+  } catch (error) {
+    throw new Error(`Failed to fetch latest release: ${error.message}`);
+  }
+}
+
+/**
+ * Update via git pull
+ * @param {string} projectRoot - Root directory
+ * @returns {Promise<void>}
+ */
+async function updateViaGit(projectRoot) {
+  console.log(chalk.bold('\nUpdating from git...\n'));
+
+  try {
+    // Check current branch
+    const branch = getCurrentBranch(projectRoot);
+    console.log(chalk.gray(`Current branch: ${branch}`));
+
+    // Fetch latest
+    console.log(chalk.gray('Fetching latest changes...'));
+    execSync('git fetch origin', {
+      cwd: projectRoot,
+      stdio: 'inherit'
+    });
+
+    // Check for uncommitted changes
+    const status = execSync('git status --porcelain', {
+      cwd: projectRoot,
+      encoding: 'utf8'
+    });
+
+    if (status.trim()) {
+      console.log(chalk.yellow('\n⚠️  You have uncommitted changes:'));
+      console.log(chalk.gray(status));
+      const { proceed } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'proceed',
+          message: 'Continue with update? (changes will be stashed)',
+          default: false
+        }
+      ]);
+
+      if (!proceed) {
+        console.log(chalk.gray('\n✗ Update cancelled\n'));
+        return;
+      }
+
+      // Stash changes
+      execSync('git stash', { cwd: projectRoot, stdio: 'inherit' });
+      console.log(chalk.green('✓ Changes stashed'));
+    }
+
+    // Pull latest
+    console.log(chalk.gray('\nPulling latest changes...'));
+    execSync('git pull origin main', {
+      cwd: projectRoot,
+      stdio: 'inherit'
+    });
+
+    console.log(chalk.green('\n✓ Update complete\n'));
+    console.log(chalk.gray('Run "claude-phone status" to verify services\n'));
+  } catch (error) {
+    throw new Error(`Git update failed: ${error.message}`);
+  }
+}
+
+/**
+ * Show manual update instructions
+ * @param {object} release - Latest release info
+ * @returns {void}
+ */
+function showManualInstructions(release) {
+  console.log(chalk.bold('\n📥 Manual Update Instructions\n'));
+  console.log(chalk.gray('Latest version:'), chalk.bold(release.tag_name));
+  console.log(chalk.gray('Released:'), release.published_at.split('T')[0]);
+  console.log();
+
+  console.log(chalk.bold('To update manually:\n'));
+  console.log(chalk.gray('1. Stop all services:'));
+  console.log(chalk.bold('   claude-phone stop\n'));
+
+  console.log(chalk.gray('2. Backup your configuration:'));
+  console.log(chalk.bold('   cp ~/.claude-phone/config.json ~/config.json.backup\n'));
+
+  console.log(chalk.gray('3. Run the installer:'));
+  console.log(chalk.bold('   npm install -g claude-phone-local\n'));
+
+  console.log(chalk.gray('4. Start services:'));
+  console.log(chalk.bold('   claude-phone start\n'));
+
+  console.log(chalk.yellow('⚠️  Your configuration will be preserved automatically\n'));
+}
+
+/**
+ * Update command - Update Claude Phone to latest version
+ * @returns {Promise<void>}
+ */
+export async function updateCommand() {
+  console.log(chalk.bold.cyan('\n🔄 Update Claude Phone\n'));
+
+  const projectRoot = getProjectRoot();
+
+  // Backup config before update
+  if (configExists()) {
+    console.log(chalk.gray('Backing up configuration...'));
+    const config = await loadConfig();
+    const backupPath = `${process.env.HOME}/.claude-phone/config.json.pre-update`;
+    await saveConfig(config); // This creates a backup automatically
+    console.log(chalk.green(`✓ Config backed up to: ${backupPath}`));
+  }
+
+  // Check if git repo
+  if (isGitRepo(projectRoot)) {
+    console.log(chalk.gray('Detected git installation\n'));
+    await updateViaGit(projectRoot);
+  } else {
+    // Non-git installation - show manual instructions
+    console.log(chalk.gray('Checking for latest release...\n'));
+
+    try {
+      const release = await fetchLatestRelease();
+      showManualInstructions(release);
+    } catch (error) {
+      console.log(chalk.red(`\n✗ ${error.message}\n`));
+      console.log(chalk.gray('Visit https://github.com/masterdeepak15/claude-phone-local for manual update\n'));
+    }
+  }
+}

package/cli/lib/config.js

@@ -0,0 +1,113 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+/**
+ * Get the config directory path
+ * @returns {string} Path to ~/.claude-phone
+ */
+export function getConfigDir() {
+  return path.join(os.homedir(), '.claude-phone');
+}
+
+/**
+ * Get the config file path
+ * @returns {string} Path to ~/.claude-phone/config.json
+ */
+export function getConfigPath() {
+  return path.join(getConfigDir(), 'config.json');
+}
+
+/**
+ * Check if config file exists
+ * @returns {boolean} True if config exists
+ */
+export function configExists() {
+  return fs.existsSync(getConfigPath());
+}
+
+/**
+ * Load configuration from disk
+ * @returns {Promise<object>} Configuration object
+ */
+export async function loadConfig() {
+  const configPath = getConfigPath();
+
+  if (!fs.existsSync(configPath)) {
+    throw new Error('Configuration not found. Run "claude-phone setup" first.');
+  }
+
+  const data = await fs.promises.readFile(configPath, 'utf8');
+  const config = JSON.parse(data);
+
+  // Ensure installationType exists for backward compatibility
+  if (!config.installationType) {
+    config.installationType = 'both';
+  }
+
+  return config;
+}
+
+/**
+ * Get the installation type from config
+ * @param {object} config - Configuration object
+ * @returns {string} Installation type ('voice-server' | 'api-server' | 'both')
+ */
+export function getInstallationType(config) {
+  return config.installationType || 'both';
+}
+
+/**
+ * Save configuration to disk
+ * @param {object} config - Configuration object
+ * @returns {Promise<void>}
+ */
+export async function saveConfig(config) {
+  const configDir = getConfigDir();
+  const configPath = getConfigPath();
+
+  // Create directory if it doesn't exist
+  if (!fs.existsSync(configDir)) {
+    await fs.promises.mkdir(configDir, { recursive: true, mode: 0o700 });
+  }
+
+  // Backup existing config if it exists
+  if (fs.existsSync(configPath)) {
+    const backupPath = configPath + '.backup';
+    await fs.promises.copyFile(configPath, backupPath);
+  }
+
+  // Add security warning to config
+  const configWithWarning = {
+    _WARNING: 'DO NOT SHARE THIS FILE - Contains API keys and passwords',
+    ...config
+  };
+
+  // Write config file
+  const data = JSON.stringify(configWithWarning, null, 2);
+  await fs.promises.writeFile(configPath, data, { mode: 0o600 });
+}
+
+/**
+ * Get the PID file path
+ * @returns {string} Path to server.pid
+ */
+export function getPidPath() {
+  return path.join(getConfigDir(), 'server.pid');
+}
+
+/**
+ * Get the docker-compose.yml path
+ * @returns {string} Path to generated docker-compose.yml
+ */
+export function getDockerComposePath() {
+  return path.join(getConfigDir(), 'docker-compose.yml');
+}
+
+/**
+ * Get the .env file path
+ * @returns {string} Path to generated .env
+ */
+export function getEnvPath() {
+  return path.join(getConfigDir(), '.env');
+}