claude-phone-local 2.0.0

package/cli/lib/port-check.js

@@ -0,0 +1,135 @@
+import net from 'net';
+import dgram from 'dgram';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+/**
+ * Check if a TCP port is in use
+ * @param {number} port - Port number to check
+ * @param {number} [timeout=1000] - Timeout in milliseconds
+ * @returns {Promise<object>} Port check result
+ * @property {number} port - Port that was checked
+ * @property {boolean} inUse - True if port is in use
+ */
+export async function checkPort(port, timeout = 1000) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+
+    // Set timeout
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve({
+        port: port,
+        inUse: false
+      });
+    }, timeout);
+
+    socket.on('connect', () => {
+      clearTimeout(timer);
+      socket.destroy();
+      resolve({
+        port: port,
+        inUse: true
+      });
+    });
+
+    socket.on('error', (err) => {
+      clearTimeout(timer);
+      socket.destroy();
+
+      // ECONNREFUSED means nothing is listening on the port
+      // EACCES means permission denied (port is in use but we can't connect)
+      // EADDRINUSE means the port is in use
+      if (err.code === 'ECONNREFUSED') {
+        resolve({
+          port: port,
+          inUse: false
+        });
+      } else if (err.code === 'EACCES' || err.code === 'EADDRINUSE') {
+        resolve({
+          port: port,
+          inUse: true
+        });
+      } else {
+        // Unknown error, assume port is not available
+        resolve({
+          port: port,
+          inUse: false,
+          error: err.message
+        });
+      }
+    });
+
+    // Try to connect to the port
+    socket.connect(port, '127.0.0.1');
+  });
+}
+
+/**
+ * Check if a UDP port is in use by trying to bind to it
+ * @param {number} port - Port number to check
+ * @param {number} [timeout=1000] - Timeout in milliseconds
+ * @returns {Promise<boolean>} True if port is in use
+ */
+export async function checkUdpPort(port, timeout = 1000) {
+  return new Promise((resolve) => {
+    const socket = dgram.createSocket('udp4');
+
+    const timer = setTimeout(() => {
+      socket.close();
+      resolve(false);
+    }, timeout);
+
+    socket.on('error', (err) => {
+      clearTimeout(timer);
+      socket.close();
+      // EADDRINUSE means port is in use
+      resolve(err.code === 'EADDRINUSE' || err.code === 'EACCES');
+    });
+
+    socket.bind(port, '0.0.0.0', () => {
+      // Successfully bound = port was free
+      clearTimeout(timer);
+      socket.close();
+      resolve(false);
+    });
+  });
+}
+
+/**
+ * Check if 3CX SBC process is running
+ * @returns {Promise<boolean>} True if 3cxsbc process is running
+ */
+export async function check3cxSbcProcess() {
+  try {
+    const { stdout } = await execAsync('pgrep -x 3cxsbc || systemctl is-active 3cxsbc 2>/dev/null');
+    return stdout.trim().length > 0 || stdout.includes('active');
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Detect if 3CX SBC is running
+ * Checks: 1) 3cxsbc process, 2) UDP port 5060, 3) TCP port 5060
+ * @returns {Promise<boolean>} True if 3CX SBC detected
+ */
+export async function detect3cxSbc() {
+  // Check for 3cxsbc process first (most reliable)
+  const processRunning = await check3cxSbcProcess();
+  if (processRunning) {
+    return true;
+  }
+
+  // Check UDP port 5060 (SIP typically uses UDP)
+  const udpInUse = await checkUdpPort(5060);
+  if (udpInUse) {
+    return true;
+  }
+
+  // Fall back to TCP check
+  const tcpResult = await checkPort(5060);
+  return tcpResult.inUse;
+}

package/cli/lib/prereqs/checks/compose.js

@@ -0,0 +1,147 @@
+import { execSync } from 'child_process';
+
+/**
+ * Check Docker Compose availability (plugin or standalone)
+ * @param {object} _platform - Platform info from detectPlatform()
+ * @returns {Promise<object>} Check result
+ */
+export async function checkCompose(_platform) {
+  const requiredVersion = '1.29.0'; // Minimum for standalone
+  const requiredPluginVersion = '2.0.0'; // Minimum for plugin
+
+  // Try plugin first (preferred)
+  const pluginResult = checkComposePlugin();
+
+  if (pluginResult.success) {
+    const passed = compareVersions(pluginResult.version, requiredPluginVersion) >= 0;
+
+    return {
+      name: 'Docker Compose',
+      passed,
+      version: pluginResult.version,
+      variant: 'plugin',
+      required: `>=${requiredPluginVersion}`,
+      message: passed
+        ? `Docker Compose v${pluginResult.version} (plugin)`
+        : `Docker Compose v${pluginResult.version} (plugin, requires >=${requiredPluginVersion})`,
+      canAutoFix: false // Usually comes with Docker installation
+    };
+  }
+
+  // Fall back to standalone
+  const standaloneResult = checkComposeStandalone();
+
+  if (standaloneResult.success) {
+    const passed = compareVersions(standaloneResult.version, requiredVersion) >= 0;
+
+    return {
+      name: 'Docker Compose',
+      passed,
+      version: standaloneResult.version,
+      variant: 'standalone',
+      required: `>=${requiredVersion}`,
+      message: passed
+        ? `Docker Compose v${standaloneResult.version} (standalone)`
+        : `Docker Compose v${standaloneResult.version} (standalone, requires >=${requiredVersion})`,
+      canAutoFix: false
+    };
+  }
+
+  // Neither available
+  return {
+    name: 'Docker Compose',
+    passed: false,
+    version: null,
+    variant: null,
+    required: `>=${requiredPluginVersion}`,
+    message: 'Docker Compose not available',
+    canAutoFix: false // Usually installed with Docker
+  };
+}
+
+/**
+ * Check for docker compose plugin
+ * @returns {{success: boolean, version?: string}} Result
+ */
+function checkComposePlugin() {
+  try {
+    const output = execSync('docker compose version', {
+      encoding: 'utf-8',
+      stdio: 'pipe'
+    });
+
+    const version = parseComposeVersion(output.trim());
+
+    return {
+      success: true,
+      version: version || 'unknown'
+    };
+  } catch (error) {
+    return {
+      success: false
+    };
+  }
+}
+
+/**
+ * Check for standalone docker-compose
+ * @returns {{success: boolean, version?: string}} Result
+ */
+function checkComposeStandalone() {
+  try {
+    const output = execSync('docker-compose --version', {
+      encoding: 'utf-8',
+      stdio: 'pipe'
+    });
+
+    const version = parseComposeVersion(output.trim());
+
+    return {
+      success: true,
+      version: version || 'unknown'
+    };
+  } catch (error) {
+    return {
+      success: false
+    };
+  }
+}
+
+/**
+ * Parse Docker Compose version from output
+ * @param {string} output - Version output
+ * @returns {string|null} Parsed version (e.g., "2.21.0")
+ */
+function parseComposeVersion(output) {
+  // Handle multiple formats:
+  // Docker Compose version v2.21.0
+  // docker-compose version 1.29.2, build 5becea4c
+  const match = output.match(/version v?([\d.]+)/);
+
+  if (match) {
+    return match[1];
+  }
+
+  return null;
+}
+
+/**
+ * Compare two semantic versions
+ * @param {string} version1 - First version
+ * @param {string} version2 - Second version
+ * @returns {number} -1 if v1 < v2, 0 if equal, 1 if v1 > v2
+ */
+function compareVersions(version1, version2) {
+  const v1parts = version1.split('.').map(Number);
+  const v2parts = version2.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    const v1 = v1parts[i] || 0;
+    const v2 = v2parts[i] || 0;
+
+    if (v1 > v2) return 1;
+    if (v1 < v2) return -1;
+  }
+
+  return 0;
+}

package/cli/lib/prereqs/checks/disk.js

@@ -0,0 +1,89 @@
+import { execSync } from 'child_process';
+
+/**
+ * Check disk space availability
+ * @param {object} platform - Platform info from detectPlatform()
+ * @returns {Promise<object>} Check result
+ */
+export async function checkDisk(platform) {
+  const requiredGB = 2;
+  const requiredBytes = requiredGB * 1024 * 1024 * 1024;
+
+  try {
+    const availableBytes = getDiskSpace(platform);
+
+    if (availableBytes === null) {
+      return {
+        name: 'Disk Space',
+        passed: false,
+        available: null,
+        required: `${requiredGB}GB`,
+        message: 'Could not determine disk space',
+        canAutoFix: false
+      };
+    }
+
+    const availableGB = (availableBytes / (1024 * 1024 * 1024)).toFixed(1);
+    const passed = availableBytes >= requiredBytes;
+
+    return {
+      name: 'Disk Space',
+      passed,
+      available: `${availableGB}GB`,
+      required: `${requiredGB}GB`,
+      message: passed
+        ? `Disk space ${availableGB}GB free (requires >=${requiredGB}GB)`
+        : `Disk space ${availableGB}GB free (requires >=${requiredGB}GB)`,
+      canAutoFix: false
+    };
+  } catch (error) {
+    return {
+      name: 'Disk Space',
+      passed: false,
+      available: null,
+      required: `${requiredGB}GB`,
+      message: 'Error checking disk space',
+      canAutoFix: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Get available disk space in bytes
+ * @param {object} platform - Platform info
+ * @returns {number|null} Available bytes or null on error
+ */
+function getDiskSpace(platform) {
+  try {
+    if (platform.os === 'darwin' || platform.os === 'linux') {
+      // Use df command to get disk space
+      const output = execSync('df -k /', {
+        encoding: 'utf-8',
+        stdio: 'pipe'
+      });
+
+      // Parse output
+      // Filesystem     1K-blocks    Used Available Use% Mounted on
+      // /dev/disk1s1   245107200 89123456 147294848  38% /
+      const lines = output.trim().split('\n');
+
+      if (lines.length < 2) {
+        return null;
+      }
+
+      const dataLine = lines[1];
+      const parts = dataLine.split(/\s+/);
+
+      // Available is typically the 4th column (index 3)
+      if (parts.length >= 4) {
+        const availableKB = parseInt(parts[3], 10);
+        return availableKB * 1024; // Convert KB to bytes
+      }
+    }
+
+    return null;
+  } catch (error) {
+    return null;
+  }
+}

package/cli/lib/prereqs/checks/docker.js

@@ -0,0 +1,155 @@
+import { execSync } from 'child_process';
+
+/**
+ * Check Docker installation and daemon status
+ * @param {object} platform - Platform info from detectPlatform()
+ * @returns {Promise<object>} Check result
+ */
+export async function checkDocker(platform) {
+  // First check if docker command exists
+  const installed = checkDockerInstalled();
+
+  if (!installed.success) {
+    return {
+      name: 'Docker',
+      passed: false,
+      version: null,
+      required: '>=20.0.0',
+      message: 'Docker not installed',
+      canAutoFix: true,
+      error: 'not_installed'
+    };
+  }
+
+  // Check if daemon is running
+  const running = checkDockerRunning();
+
+  if (!running.success) {
+    // Distinguish between permission denied and daemon not running
+    if (running.error === 'permission_denied') {
+      return {
+        name: 'Docker',
+        passed: false,
+        version: installed.version,
+        required: '>=20.0.0',
+        message: 'Docker installed but permission denied (user not in docker group)',
+        canAutoFix: true,
+        error: 'permission_denied'
+      };
+    }
+
+    // Docker Desktop on macOS might be installed but not running
+    if (platform.os === 'darwin') {
+      return {
+        name: 'Docker',
+        passed: false,
+        version: installed.version,
+        required: '>=20.0.0',
+        message: 'Docker installed but daemon not running',
+        canAutoFix: true,
+        error: 'not_running'
+      };
+    }
+
+    return {
+      name: 'Docker',
+      passed: false,
+      version: installed.version,
+      required: '>=20.0.0',
+      message: 'Docker installed but daemon not running',
+      canAutoFix: true,
+      error: 'not_running'
+    };
+  }
+
+  // Both installed and running - success
+  return {
+    name: 'Docker',
+    passed: true,
+    version: installed.version,
+    required: '>=20.0.0',
+    message: `Docker v${installed.version}`,
+    canAutoFix: false
+  };
+}
+
+/**
+ * Check if docker command is installed
+ * @returns {{success: boolean, version?: string}} Result with version if installed
+ */
+function checkDockerInstalled() {
+  try {
+    const output = execSync('docker --version', {
+      encoding: 'utf-8',
+      stdio: 'pipe'
+    });
+
+    const version = parseDockerVersion(output.trim());
+
+    return {
+      success: true,
+      version: version || 'unknown'
+    };
+  } catch (error) {
+    return {
+      success: false
+    };
+  }
+}
+
+/**
+ * Check if Docker daemon is running
+ * @returns {{success: boolean, error?: string}} Result
+ */
+function checkDockerRunning() {
+  try {
+    execSync('docker ps', {
+      encoding: 'utf-8',
+      stdio: 'pipe'
+    });
+
+    return { success: true };
+  } catch (error) {
+    // Check if it's a permission error
+    if (error.stderr && error.stderr.includes('permission denied')) {
+      return {
+        success: false,
+        error: 'permission_denied'
+      };
+    }
+
+    // Check if it's daemon not running error
+    if (
+      error.stderr &&
+      (error.stderr.includes('Cannot connect to the Docker daemon') ||
+       error.stderr.includes('Is the docker daemon running?'))
+    ) {
+      return {
+        success: false,
+        error: 'not_running'
+      };
+    }
+
+    // Unknown error
+    return {
+      success: false,
+      error: 'unknown'
+    };
+  }
+}
+
+/**
+ * Parse Docker version from output
+ * @param {string} output - Docker version output
+ * @returns {string|null} Parsed version (e.g., "24.0.7")
+ */
+function parseDockerVersion(output) {
+  // Docker version 24.0.7, build afdd53b
+  const match = output.match(/Docker version ([\d.]+)/);
+
+  if (match) {
+    return match[1];
+  }
+
+  return null;
+}

package/cli/lib/prereqs/checks/network.js

@@ -0,0 +1,78 @@
+import axios from 'axios';
+
+/**
+ * Check network connectivity to required hosts
+ * @param {object} _platform - Platform info from detectPlatform()
+ * @returns {Promise<object>} Check result
+ */
+export async function checkNetwork(_platform) {
+  const hosts = [
+    { name: 'npm', url: 'https://registry.npmjs.org' },
+    { name: 'docker', url: 'https://hub.docker.com' },
+    { name: 'nodesource', url: 'https://deb.nodesource.com' }
+  ];
+
+  const timeout = 5000; // 5 seconds per host
+  const results = {};
+
+  // Check each host
+  for (const host of hosts) {
+    results[host.name] = await checkHost(host.url, timeout);
+  }
+
+  // Determine if we have enough connectivity
+  const reachable = Object.values(results).filter(r => r).length;
+  const total = hosts.length;
+
+  // We need at least npm to be reachable for auto-fix
+  const npmReachable = results.npm;
+
+  return {
+    name: 'Network',
+    passed: true, // Network check is informational, not a hard requirement
+    reachable,
+    total,
+    details: results,
+    message: formatNetworkMessage(results),
+    canAutoFix: false,
+    autoFixDisabled: !npmReachable // Disable auto-fix if npm is unreachable
+  };
+}
+
+/**
+ * Check if a specific host is reachable
+ * @param {string} url - URL to check
+ * @param {number} timeout - Timeout in milliseconds
+ * @returns {Promise<boolean>} True if reachable
+ */
+async function checkHost(url, timeout) {
+  try {
+    const response = await axios.head(url, {
+      timeout,
+      validateStatus: (status) => status < 500 // Accept redirects, etc.
+    });
+
+    return response.status < 500;
+  } catch (error) {
+    // Timeout or network error
+    return false;
+  }
+}
+
+/**
+ * Format network check message
+ * @param {object} results - Results object with host statuses
+ * @returns {string} Formatted message
+ */
+function formatNetworkMessage(results) {
+  const parts = [];
+
+  parts.push('Network:');
+
+  for (const [name, reachable] of Object.entries(results)) {
+    const symbol = reachable ? '✓' : '✗';
+    parts.push(`${symbol} ${name}`);
+  }
+
+  return parts.join(' ');
+}

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

@@ -0,0 +1,95 @@
+import { execSync } from 'child_process';
+
+/**
+ * Check Node.js version
+ * @param {object} _platform - Platform info from detectPlatform()
+ * @returns {Promise<object>} Check result
+ */
+export async function checkNode(_platform) {
+  const requiredVersion = '18.0.0';
+
+  try {
+    // Run node --version
+    const output = execSync('node --version', {
+      encoding: 'utf-8',
+      stdio: 'pipe'
+    });
+
+    const version = parseNodeVersion(output.trim());
+
+    if (!version) {
+      return {
+        name: 'Node.js',
+        passed: false,
+        version: null,
+        required: `>=${requiredVersion}`,
+        message: 'Node.js version could not be determined',
+        canAutoFix: true
+      };
+    }
+
+    const passed = compareVersions(version, requiredVersion) >= 0;
+
+    return {
+      name: 'Node.js',
+      passed,
+      version,
+      required: `>=${requiredVersion}`,
+      message: passed
+        ? `Node.js v${version} (requires >=${requiredVersion})`
+        : `Node.js v${version} (requires >=${requiredVersion})`,
+      canAutoFix: !passed
+    };
+  } catch (error) {
+    // Node not found
+    return {
+      name: 'Node.js',
+      passed: false,
+      version: null,
+      required: `>=${requiredVersion}`,
+      message: 'Node.js not installed',
+      canAutoFix: true,
+      error: 'command_not_found'
+    };
+  }
+}
+
+/**
+ * Parse Node.js version string (handles v20.11.0 or 20.11.0 format)
+ * @param {string} versionString - Raw version output
+ * @returns {string|null} Parsed version (e.g., "20.11.0")
+ */
+function parseNodeVersion(versionString) {
+  // Remove leading 'v' if present
+  const cleaned = versionString.replace(/^v/, '');
+
+  // Match semantic version pattern (major.minor.patch)
+  const match = cleaned.match(/^(\d+)\.(\d+)\.(\d+)/);
+
+  if (match) {
+    return `${match[1]}.${match[2]}.${match[3]}`;
+  }
+
+  return null;
+}
+
+/**
+ * Compare two semantic versions
+ * @param {string} version1 - First version (e.g., "20.11.0")
+ * @param {string} version2 - Second version (e.g., "18.0.0")
+ * @returns {number} -1 if v1 < v2, 0 if equal, 1 if v1 > v2
+ */
+function compareVersions(version1, version2) {
+  const v1parts = version1.split('.').map(Number);
+  const v2parts = version2.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    const v1 = v1parts[i] || 0;
+    const v2 = v2parts[i] || 0;
+
+    if (v1 > v2) return 1;
+    if (v1 < v2) return -1;
+  }
+
+  return 0;
+}