claude-phone-local 2.0.0

package/cli/lib/prereqs/installers/node.js

@@ -0,0 +1,254 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import path from 'path';
+import os from 'os';
+import { downloadFile, showPreview, runWithLogging } from '../utils/execute.js';
+import { withSudo } from '../utils/sudo.js';
+import { checkNode } from '../checks/node.js';
+
+/**
+ * Install Node.js based on platform
+ * @param {object} platform - Platform info from detectPlatform()
+ * @returns {Promise<{success: boolean, cancelled?: boolean}>}
+ */
+export async function installNode(platform) {
+  console.log(chalk.bold.cyan('\n📦 Node.js Installation\n'));
+
+  // Confirm installation
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message: 'Install Node.js 20 LTS automatically?',
+      default: false
+    }
+  ]);
+
+  if (!confirmed) {
+    showNodeManualInstructions(platform);
+    return { success: false, cancelled: true };
+  }
+
+  // Route to platform-specific installer
+  let result;
+
+  switch (platform.packageManager) {
+    case 'apt':
+      result = await installNodeApt();
+      break;
+    case 'dnf':
+    case 'yum':
+      result = await installNodeDnf(platform.packageManager);
+      break;
+    case 'pacman':
+      result = await installNodePacman();
+      break;
+    case 'brew':
+      result = await installNodeBrew();
+      break;
+    default:
+      console.error(chalk.red(`\n❌ Unsupported package manager: ${platform.packageManager}`));
+      showNodeManualInstructions(platform);
+      return { success: false };
+  }
+
+  if (!result.success) {
+    return result;
+  }
+
+  // Verify installation
+  console.log(chalk.cyan('\n✓ Verifying Node.js installation...'));
+  const check = await checkNode(platform);
+
+  if (check.passed) {
+    console.log(chalk.green(`✓ Node.js v${check.version} installed successfully\n`));
+    return { success: true };
+  } else {
+    console.error(chalk.red('\n❌ Node.js installation verification failed'));
+    console.log(chalk.yellow('Node.js was installed but version check failed.'));
+    return { success: false };
+  }
+}
+
+/**
+ * Install Node.js on Ubuntu/Debian using NodeSource repository
+ * @returns {Promise<{success: boolean}>}
+ */
+async function installNodeApt() {
+  const scriptUrl = 'https://deb.nodesource.com/setup_20.x';
+  const tempFile = path.join(os.tmpdir(), `nodesource_setup_${Date.now()}.sh`);
+
+  try {
+    // Download script
+    console.log(chalk.cyan('\nDownloading NodeSource setup script...'));
+    await downloadFile(scriptUrl, tempFile);
+
+    // Show preview
+    await showPreview(tempFile);
+
+    // Confirm execution
+    const { executeConfirmed } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'executeConfirmed',
+        message: 'Run NodeSource setup script as root?',
+        default: false
+      }
+    ]);
+
+    if (!executeConfirmed) {
+      return { success: false, cancelled: true };
+    }
+
+    // Run with sudo
+    const commands = [
+      `bash ${tempFile}`,
+      'apt-get update',
+      'apt-get install -y nodejs'
+    ];
+
+    const result = await withSudo(commands);
+
+    // Clean up temp file
+    try {
+      const fs = await import('fs');
+      fs.unlinkSync(tempFile);
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+
+    return result;
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Installation failed: ${error.message}`));
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Install Node.js on RHEL/Fedora using NodeSource repository
+ * @param {string} packageManager - 'dnf' or 'yum'
+ * @returns {Promise<{success: boolean}>}
+ */
+async function installNodeDnf(packageManager) {
+  const scriptUrl = 'https://rpm.nodesource.com/setup_20.x';
+  const tempFile = path.join(os.tmpdir(), `nodesource_setup_${Date.now()}.sh`);
+
+  try {
+    // Download script
+    console.log(chalk.cyan('\nDownloading NodeSource setup script...'));
+    await downloadFile(scriptUrl, tempFile);
+
+    // Show preview
+    await showPreview(tempFile);
+
+    // Confirm execution
+    const { executeConfirmed } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'executeConfirmed',
+        message: 'Run NodeSource setup script as root?',
+        default: false
+      }
+    ]);
+
+    if (!executeConfirmed) {
+      return { success: false, cancelled: true };
+    }
+
+    // Run with sudo
+    const commands = [
+      `bash ${tempFile}`,
+      `${packageManager} install -y nodejs`
+    ];
+
+    const result = await withSudo(commands);
+
+    // Clean up temp file
+    try {
+      const fs = await import('fs');
+      fs.unlinkSync(tempFile);
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+
+    return result;
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Installation failed: ${error.message}`));
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Install Node.js on Arch Linux using pacman
+ * @returns {Promise<{success: boolean}>}
+ */
+async function installNodePacman() {
+  const commands = ['pacman -Sy --noconfirm nodejs npm'];
+
+  console.log(chalk.cyan('\nInstalling Node.js via pacman...'));
+
+  return await withSudo(commands);
+}
+
+/**
+ * Install Node.js on macOS using Homebrew
+ * @returns {Promise<{success: boolean}>}
+ */
+async function installNodeBrew() {
+  try {
+    console.log(chalk.cyan('\nInstalling Node.js 20 via Homebrew...'));
+    console.log(chalk.gray('This may take several minutes...\n'));
+
+    const result = await runWithLogging('brew install node@20');
+
+    if (result.success) {
+      // Link node@20
+      console.log(chalk.cyan('\nLinking Node.js 20...'));
+      await runWithLogging('brew link node@20');
+    }
+
+    return result;
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Installation failed: ${error.message}`));
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Show manual installation instructions for Node.js
+ * @param {object} platform - Platform info
+ * @returns {void}
+ */
+function showNodeManualInstructions(platform) {
+  console.log(chalk.yellow('\n📋 Manual Node.js Installation\n'));
+
+  switch (platform.packageManager) {
+    case 'apt':
+      console.log(chalk.gray('For Ubuntu/Debian:\n'));
+      console.log(chalk.cyan('  curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -'));
+      console.log(chalk.cyan('  sudo apt-get install -y nodejs\n'));
+      break;
+
+    case 'dnf':
+    case 'yum':
+      console.log(chalk.gray('For RHEL/Fedora:\n'));
+      console.log(chalk.cyan('  curl -fsSL https://rpm.nodesource.com/setup_20.x | sudo bash -'));
+      console.log(chalk.cyan(`  sudo ${platform.packageManager} install -y nodejs\n`));
+      break;
+
+    case 'pacman':
+      console.log(chalk.gray('For Arch Linux:\n'));
+      console.log(chalk.cyan('  sudo pacman -Sy nodejs npm\n'));
+      break;
+
+    case 'brew':
+      console.log(chalk.gray('For macOS:\n'));
+      console.log(chalk.cyan('  brew install node@20\n'));
+      break;
+
+    default:
+      console.log(chalk.gray('Download from: https://nodejs.org/\n'));
+  }
+
+  console.log(chalk.gray('After installation, run "claude-phone setup" again.\n'));
+}

package/cli/lib/prereqs/platform.js

@@ -0,0 +1,175 @@
+import os from 'os';
+import fs from 'fs';
+import { execSync } from 'child_process';
+
+/**
+ * Detect platform information (OS, distro, arch, package manager)
+ * @returns {Promise<object>} Platform information object
+ */
+export async function detectPlatform() {
+  const platform = os.platform(); // 'darwin', 'linux', 'win32'
+  const arch = os.arch(); // 'x64', 'arm64', 'arm'
+
+  // Normalize architecture names
+  const normalizedArch = normalizeArch(arch);
+  const isArm = ['arm64', 'armv7l'].includes(normalizedArch);
+
+  let distro = null;
+  let distroVersion = null;
+  let packageManager = null;
+  let isPi = false;
+
+  if (platform === 'darwin') {
+    // macOS
+    distro = 'macos';
+    packageManager = 'brew';
+    distroVersion = await getMacOSVersion();
+  } else if (platform === 'linux') {
+    // Linux - detect distro from /etc/os-release
+    const osRelease = parseOsRelease();
+    distro = osRelease.id || 'unknown';
+    distroVersion = osRelease.version_id || 'unknown';
+    packageManager = detectPackageManager(distro);
+    isPi = await isRaspberryPi();
+  }
+
+  return {
+    os: platform,
+    distro,
+    distroVersion,
+    arch: normalizedArch,
+    packageManager,
+    isArm,
+    isPi
+  };
+}
+
+/**
+ * Normalize architecture names to consistent format
+ * @param {string} arch - Raw arch from os.arch()
+ * @returns {string} Normalized arch name
+ */
+function normalizeArch(arch) {
+  const mapping = {
+    'x64': 'x86_64',
+    'x86_64': 'x86_64',
+    'arm64': 'arm64',
+    'aarch64': 'arm64',
+    'arm': 'armv7l',
+    'armv7l': 'armv7l'
+  };
+
+  return mapping[arch] || arch;
+}
+
+/**
+ * Parse /etc/os-release file on Linux
+ * @returns {object} Parsed key-value pairs from os-release
+ */
+function parseOsRelease() {
+  try {
+    const content = fs.readFileSync('/etc/os-release', 'utf-8');
+    const lines = content.split('\n');
+    const result = {};
+
+    for (const line of lines) {
+      const match = line.match(/^([A-Z_]+)=(.*)$/);
+      if (match) {
+        const key = match[1].toLowerCase();
+        let value = match[2];
+
+        // Remove quotes
+        value = value.replace(/^"(.*)"$/, '$1');
+        value = value.replace(/^'(.*)'$/, '$1');
+
+        result[key] = value;
+      }
+    }
+
+    return result;
+  } catch (error) {
+    return {};
+  }
+}
+
+/**
+ * Detect package manager based on distro
+ * @param {string} distro - Distro ID from os-release
+ * @returns {string} Package manager command (apt, dnf, yum, pacman, brew)
+ */
+function detectPackageManager(distro) {
+  // Debian/Ubuntu family
+  if (['ubuntu', 'debian', 'raspbian'].includes(distro)) {
+    return 'apt';
+  }
+
+  // RHEL/Fedora family
+  if (['fedora', 'rhel', 'centos', 'rocky', 'almalinux'].includes(distro)) {
+    // Newer versions use dnf
+    try {
+      execSync('which dnf', { stdio: 'pipe' });
+      return 'dnf';
+    } catch (e) {
+      return 'yum';
+    }
+  }
+
+  // Arch family
+  if (['arch', 'manjaro'].includes(distro)) {
+    return 'pacman';
+  }
+
+  // Fallback - try to detect by checking which command exists
+  const packageManagers = ['apt', 'dnf', 'yum', 'pacman'];
+  for (const pm of packageManagers) {
+    try {
+      execSync(`which ${pm}`, { stdio: 'pipe' });
+      return pm;
+    } catch (e) {
+      // Continue to next
+    }
+  }
+
+  return 'unknown';
+}
+
+/**
+ * Check if running on Raspberry Pi
+ * @returns {Promise<boolean>} True if Raspberry Pi
+ */
+async function isRaspberryPi() {
+  try {
+    // Check device tree model file
+    const modelPath = '/sys/firmware/devicetree/base/model';
+    if (fs.existsSync(modelPath)) {
+      const model = fs.readFileSync(modelPath, 'utf-8').toLowerCase();
+      return model.includes('raspberry pi');
+    }
+
+    // Fallback: Check /proc/cpuinfo
+    if (fs.existsSync('/proc/cpuinfo')) {
+      const cpuinfo = fs.readFileSync('/proc/cpuinfo', 'utf-8').toLowerCase();
+      return cpuinfo.includes('raspberry pi');
+    }
+
+    return false;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Get macOS version
+ * @returns {Promise<string>} macOS version string
+ */
+async function getMacOSVersion() {
+  try {
+    const output = execSync('sw_vers -productVersion', {
+      encoding: 'utf-8',
+      stdio: 'pipe'
+    });
+    return output.trim();
+  } catch (error) {
+    return 'unknown';
+  }
+}

package/cli/lib/prereqs/utils/execute.js

@@ -0,0 +1,208 @@
+import axios from 'axios';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync, spawn } from 'child_process';
+import chalk from 'chalk';
+
+/**
+ * Download a file from URL to local path
+ * @param {string} url - URL to download from
+ * @param {string} destPath - Destination file path
+ * @returns {Promise<void>}
+ */
+export async function downloadFile(url, destPath) {
+  const response = await axios.get(url, {
+    responseType: 'stream',
+    timeout: 30000 // 30 second timeout
+  });
+
+  const writer = fs.createWriteStream(destPath);
+
+  response.data.pipe(writer);
+
+  return new Promise((resolve, reject) => {
+    writer.on('finish', resolve);
+    writer.on('error', reject);
+  });
+}
+
+/**
+ * Read first N lines from a file
+ * @param {string} filePath - Path to file
+ * @param {number} count - Number of lines to read
+ * @returns {Promise<string>} File content (first N lines)
+ */
+export async function readLines(filePath, count) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.split('\n');
+  const preview = lines.slice(0, count);
+
+  return preview.join('\n');
+}
+
+/**
+ * Show preview of a script file before execution
+ * @param {string} filePath - Path to script file
+ * @param {number} lineCount - Number of lines to preview (default: 50)
+ * @returns {Promise<void>}
+ */
+export async function showPreview(filePath, lineCount = 50) {
+  console.log(chalk.yellow('\n📄 Script preview (first 50 lines):'));
+  console.log(chalk.gray('─'.repeat(60)));
+
+  const preview = await readLines(filePath, lineCount);
+  const lines = preview.split('\n');
+
+  for (let i = 0; i < lines.length; i++) {
+    console.log(chalk.gray(`${(i + 1).toString().padStart(4)} │ ${lines[i]}`));
+  }
+
+  if (lines.length === lineCount) {
+    console.log(chalk.gray('     │ ... (truncated)'));
+  }
+
+  console.log(chalk.gray('─'.repeat(60)));
+}
+
+/**
+ * Run a command with logging to file
+ * @param {string} command - Command to run
+ * @param {object} options - Execution options
+ * @returns {Promise<{success: boolean, output?: string, error?: string}>}
+ */
+export async function runWithLogging(command, options = {}) {
+  const logFile = getLogFile();
+
+  // Log command
+  const timestamp = new Date().toISOString();
+  fs.appendFileSync(logFile, `\n[${timestamp}] Running: ${command}\n`);
+
+  try {
+    const output = execSync(command, {
+      encoding: 'utf-8',
+      stdio: options.silent ? 'pipe' : 'inherit',
+      ...options
+    });
+
+    // Log success
+    fs.appendFileSync(logFile, `[${timestamp}] Success\n`);
+
+    return {
+      success: true,
+      output
+    };
+  } catch (error) {
+    // Log error
+    fs.appendFileSync(logFile, `[${timestamp}] Error: ${error.message}\n`);
+
+    if (error.stderr) {
+      fs.appendFileSync(logFile, `[${timestamp}] stderr: ${error.stderr}\n`);
+    }
+
+    return {
+      success: false,
+      error: error.message,
+      stderr: error.stderr
+    };
+  }
+}
+
+/**
+ * Run a command and stream output in real-time
+ * @param {string} command - Command to run
+ * @param {Array<string>} args - Command arguments
+ * @param {object} options - Spawn options
+ * @returns {Promise<{success: boolean, code: number}>}
+ */
+export async function runWithStreaming(command, args = [], options = {}) {
+  const logFile = getLogFile();
+  const timestamp = new Date().toISOString();
+  const fullCommand = `${command} ${args.join(' ')}`;
+
+  fs.appendFileSync(logFile, `\n[${timestamp}] Running: ${fullCommand}\n`);
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: 'inherit',
+      ...options
+    });
+
+    child.on('close', (code) => {
+      fs.appendFileSync(
+        logFile,
+        `[${timestamp}] Exited with code ${code}\n`
+      );
+
+      resolve({
+        success: code === 0,
+        code
+      });
+    });
+
+    child.on('error', (error) => {
+      fs.appendFileSync(logFile, `[${timestamp}] Error: ${error.message}\n`);
+      reject(error);
+    });
+  });
+}
+
+/**
+ * Download script to temp file, preview, confirm, and execute
+ * @param {string} url - Script URL
+ * @param {object} options - Execution options
+ * @returns {Promise<{success: boolean, cancelled?: boolean}>}
+ */
+export async function executeScript(url, options = {}) {
+  // 1. Download to temp file
+  const tempFile = path.join(os.tmpdir(), `prereq_${Date.now()}.sh`);
+
+  try {
+    console.log(chalk.cyan(`\nDownloading script from ${url}...`));
+    await downloadFile(url, tempFile);
+
+    // 2. Show preview
+    await showPreview(tempFile);
+
+    // 3. Get confirmation (handled by caller)
+    // The caller should confirm before calling executeScript
+
+    // 4. Execute with logging
+    const result = await runWithLogging(`bash ${tempFile}`, options);
+
+    // 5. Clean up temp file
+    try {
+      fs.unlinkSync(tempFile);
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+
+    return result;
+  } catch (error) {
+    // Clean up on error
+    try {
+      if (fs.existsSync(tempFile)) {
+        fs.unlinkSync(tempFile);
+      }
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+
+    throw error;
+  }
+}
+
+/**
+ * Get log file path
+ * @returns {string} Path to log file
+ */
+function getLogFile() {
+  const configDir = path.join(os.homedir(), '.claude-phone');
+
+  // Ensure config directory exists
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
+  }
+
+  return path.join(configDir, 'prereq-install.log');
+}