@mmmbuto/nexuscrew 0.2.1 → 0.2.2

package/bin/nexuscrew.js

@@ -2,556 +2,280 @@
 'use strict';
 
 const { Command } = require('commander');
-const readline = require('readline/promises');
-const { stdin, stdout } = require('process');
-const { spawn, execSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
-const http = require('http');
-
-const {
-  getConfig,
-  initializeConfig,
-  getConfigValue,
-  setConfigValue,
-  isInitialized,
-  saveConfig
-} = require('../lib/config/manager');
-const { readHosts, writeHosts, ensureHostsFile } = require('../lib/config/hosts');
-const { PATHS, ensureDirectories } = require('../lib/utils/paths');
-const {
-  isTermux,
-  installPackage,
-  isPackageInstalled,
-  isTermuxBootAvailable,
-  isTermuxServicesAvailable,
-  getServiceDir,
-  getStartServicesScript,
-  openUrl
-} = require('../lib/utils/termux');
-const TmuxManager = require('../lib/services/tmux-manager');
-const SpeechManager = require('../lib/server/services/speech-manager');
-const EngineDiscovery = require('../lib/services/engine-discovery');
-
-const program = new Command();
-
-function ensureBaseState() {
-  ensureDirectories();
-  ensureHostsFile();
-  if (!isInitialized()) {
-    initializeConfig({ workspaces: [path.join(process.env.HOME || '', 'Dev')] });
-  }
-}
-
-function commandExists(command) {
-  try {
-    execSync(`which ${command}`, { stdio: 'ignore' });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function prompt(question, fallback = '') {
-  const rl = readline.createInterface({ input: stdin, output: stdout });
-  try {
-    const answer = await rl.question(`${question}${fallback ? ` [${fallback}]` : ''}: `);
-    return answer.trim() || fallback;
-  } finally {
-    rl.close();
-  }
-}
-
-async function promptBoolean(question, defaultValue = false) {
-  const answer = await prompt(question, defaultValue ? 'Y' : 'N');
-  return answer.toLowerCase() === 'y';
-}
-
-function getProjectRoot() {
-  return path.join(__dirname, '..');
-}
-
-function getServerEntry() {
-  return path.join(getProjectRoot(), 'lib', 'server', 'server.js');
-}
-
-function getServerUrl(port) {
-  return `http://localhost:${port}`;
-}
-
-function ensureParentDir(filePath) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-}
-
-function readPidFile() {
-  if (!fs.existsSync(PATHS.PID_FILE)) {
-    return null;
-  }
-
-  const pid = Number(fs.readFileSync(PATHS.PID_FILE, 'utf8').trim());
-  return Number.isInteger(pid) && pid > 0 ? pid : null;
-}
-
-function isPidRunning(pid) {
-  if (!pid) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function writePidFile(pid) {
-  ensureParentDir(PATHS.PID_FILE);
-  fs.writeFileSync(PATHS.PID_FILE, `${pid}\n`, 'utf8');
-}
-
-function removePidFile() {
-  if (fs.existsSync(PATHS.PID_FILE)) {
-    fs.unlinkSync(PATHS.PID_FILE);
-  }
-}
-
-function getListeningPid(port) {
-  try {
-    const pid = execSync(`lsof -ti :${port} 2>/dev/null`, { encoding: 'utf8' }).trim();
-    return pid ? Number(pid) : null;
-  } catch {
-    return null;
-  }
-}
-
-function getExistingServerPid(port) {
-  const pidFromFile = readPidFile();
-  if (isPidRunning(pidFromFile)) {
-    return pidFromFile;
-  }
-
-  if (pidFromFile) {
-    removePidFile();
-  }
-
-  const pidFromPort = getListeningPid(port);
-  if (isPidRunning(pidFromPort)) {
-    writePidFile(pidFromPort);
-    return pidFromPort;
-  }
+const os = require('os');
+const { execSync, spawn } = require('child_process');
 
-  return null;
-}
-
-function isTermuxServiceConfigured(config) {
-  const serviceName = config.termux?.service_name || 'nexuscrew';
-  return fs.existsSync(getServiceDir(serviceName));
-}
-
-function getTermuxServiceStatus(config) {
-  const serviceName = config.termux?.service_name || 'nexuscrew';
-  if (!isTermux() || !isPackageInstalled('sv') || !fs.existsSync(getServiceDir(serviceName))) {
-    return null;
-  }
-
-  try {
-    return execSync(`sv status ${serviceName}`, { encoding: 'utf8' }).trim();
-  } catch (error) {
-    return error.stdout?.toString?.().trim() || 'unknown';
-  }
-}
-
-function configureTermuxBoot(config) {
-  ensureParentDir(PATHS.BOOT_SCRIPT);
-  const startServicesScript = getStartServicesScript();
-  const script = [
-    '#!/data/data/com.termux/files/usr/bin/sh',
-    'termux-wake-lock >/dev/null 2>&1 || true',
-    `[ -f "${startServicesScript}" ] && . "${startServicesScript}"`
-  ].join('\n') + '\n';
-
-  fs.writeFileSync(PATHS.BOOT_SCRIPT, script, 'utf8');
-  fs.chmodSync(PATHS.BOOT_SCRIPT, 0o755);
-  config.termux.boot_start = true;
-}
-
-function configureTermuxService(config, port) {
-  const serviceName = config.termux?.service_name || 'nexuscrew';
-  const serviceDir = getServiceDir(serviceName);
-  const runFile = path.join(serviceDir, 'run');
-  const script = [
-    '#!/data/data/com.termux/files/usr/bin/sh',
-    `cd "${getProjectRoot()}" || exit 1`,
-    'mkdir -p "$HOME/.nexuscrew/logs"',
-    `export PORT="${port}"`,
-    'exec node lib/server/server.js >>"$HOME/.nexuscrew/logs/server.log" 2>&1'
-  ].join('\n') + '\n';
-
-  fs.mkdirSync(serviceDir, { recursive: true });
-  fs.writeFileSync(runFile, script, 'utf8');
-  fs.chmodSync(runFile, 0o755);
-  execSync(`sv-enable ${serviceName}`, { stdio: 'ignore' });
-  config.termux.service_enabled = true;
-}
-
-function waitForHealth(port, timeoutMs = 8000) {
-  const deadline = Date.now() + timeoutMs;
-
-  return new Promise((resolve) => {
-    const probe = () => {
-      const req = http.get(`${getServerUrl(port)}/health`, (res) => {
-        res.resume();
-        resolve(res.statusCode === 200);
-      });
-
-      req.on('error', () => {
-        if (Date.now() >= deadline) {
-          resolve(false);
-          return;
-        }
-        setTimeout(probe, 250);
-      });
-
-      req.setTimeout(1000, () => req.destroy());
-    };
-
-    probe();
-  });
-}
+const EngineDiscovery = require('../lib/services/engine-discovery');
+const packageJson = require('../package.json');
 
-function startDetachedServer(port) {
-  ensureParentDir(PATHS.SERVER_LOG);
-  const logFd = fs.openSync(PATHS.SERVER_LOG, 'a');
-  const child = spawn(process.execPath, [getServerEntry()], {
-    cwd: getProjectRoot(),
-    detached: true,
-    env: {
-      ...process.env,
-      PORT: String(port)
-    },
-    stdio: ['ignore', logFd, logFd]
-  });
+const CONFIG_DIR = path.join(os.homedir(), '.nexuscrew');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+const HOSTS_PATH = path.join(CONFIG_DIR, 'hosts.json');
 
-  child.unref();
-  writePidFile(child.pid);
-  return child.pid;
-}
+const DEFAULT_PORT = '41820';
 
+const program = new Command();
 program
   .name('nexuscrew')
   .description('tmux-based AI cockpit')
-  .version('0.2.1');
+  .version(packageJson.version);
 
 program.command('init')
-  .description('Bootstrap config, directories, and host registry')
-  .option('-s, --silent', 'Silent mode')
+  .description('First-time setup')
+  .option('--silent', 'Suppress setup output')
   .action((opts) => {
-    ensureBaseState();
-    if (!opts.silent) {
-      console.log(`Config: ${PATHS.CONFIG_FILE}`);
-      console.log(`Hosts: ${PATHS.HOSTS_FILE}`);
-      console.log(`Logs: ${PATHS.LOGS_DIR}`);
-      console.log(`Attachments: ${PATHS.ATTACHMENTS_DIR}`);
-      console.log(`tmux: ${commandExists('tmux') ? 'OK' : 'missing'}`);
-      console.log(`ssh: ${commandExists('ssh') ? 'OK' : 'missing'}`);
-      console.log(`scp: ${commandExists('scp') ? 'OK' : 'missing'}`);
-    }
-  });
+    const log = (...args) => {
+      if (!opts.silent) console.log(...args);
+    };
+    const error = (...args) => {
+      if (!opts.silent) console.error(...args);
+    };
 
-program.command('setup')
-  .description('Interactive setup wizard')
-  .action(async () => {
-    ensureBaseState();
-
-    const current = getConfig();
-    const defaultWorkspace = current.workspaces?.default || path.join(process.env.HOME || '', 'Dev');
-    const port = Number(await prompt('HTTP port', String(current.server?.port || 41820)));
-    const tmuxSession = await prompt('tmux session name', current.tmuxSession || 'nexuscrew');
-    const workspace = await prompt('Default workspace', defaultWorkspace);
-    const addHost = await promptBoolean('Add SSH host now? (y/N)', false);
-
-    current.server.port = port;
-    current.tmuxSession = tmuxSession;
-    current.workspaces.default = workspace;
-    current.workspaces.paths = Array.from(new Set([workspace, ...(current.workspaces.paths || [])]));
-
-    if (isTermux()) {
-      for (const pkg of ['tmux', 'openssh', 'termux-services']) {
-        if (!isPackageInstalled(pkg)) {
-          installPackage(pkg);
-        }
-      }
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+      log('Created ~/.nexuscrew/');
     }
 
-    if (addHost) {
-      const name = await prompt('Host alias', 'server');
-      const host = await prompt('SSH host');
-      const user = await prompt('SSH user', 'dag');
-      const sshPort = await prompt('SSH port', '22');
-      const key = await prompt('SSH key path (optional)', '');
-      const hosts = readHosts().filter((entry) => entry.name !== name);
-      hosts.push({
-        name,
-        type: 'ssh',
-        host,
-        user,
-        port: sshPort,
-        key: key || null,
-        default: false
-      });
-      writeHosts(hosts);
+    if (!fs.existsSync(CONFIG_PATH)) {
+      fs.writeFileSync(CONFIG_PATH, JSON.stringify({
+        port: Number(DEFAULT_PORT),
+        logDir: path.join(CONFIG_DIR, 'logs'),
+        autoDiscovery: true,
+        preferredShell: '',
+        extraShellSources: []
+      }, null, 2));
+      log('Created config.json');
     }
 
-    if (isTermux()) {
-      const configureBoot = await promptBoolean('Configure Termux boot? (y/N)', false);
-      const configureService = await promptBoolean('Enable native Termux runit service watchdog? (y/N)', false);
-
-      if (configureBoot) {
-        configureTermuxBoot(current);
-      }
-
-      if (configureService) {
-        if (!isTermuxServicesAvailable()) {
-          console.log('termux-services is not ready yet. Restart the shell after installation and rerun setup if needed.');
-        } else {
-          configureTermuxService(current, port);
-        }
-      }
+    if (!fs.existsSync(HOSTS_PATH)) {
+      fs.writeFileSync(HOSTS_PATH, JSON.stringify([
+        { name: 'local', type: 'local', default: true }
+      ], null, 2));
+      log('Created hosts.json');
     }
 
-    saveConfig(current);
-
-    const speech = new SpeechManager();
-    const sttStatus = speech.getStatus();
-    console.log(`STT provider: ${sttStatus.provider}`);
-    console.log(`Whisper configured: ${sttStatus.whisper.configured ? 'yes' : 'no'}`);
-    if (isTermux()) {
-      if (current.termux?.boot_start && !isTermuxBootAvailable()) {
-        console.log('Boot script created. Install/open the Termux:Boot app once to activate it on boot.');
-      }
-      console.log(`Termux boot: ${current.termux?.boot_start ? 'enabled' : 'disabled'}`);
-      console.log(`Termux service: ${current.termux?.service_enabled ? 'enabled' : 'disabled'}`);
-      console.log(`Boot script: ${PATHS.BOOT_SCRIPT}`);
-      console.log(`Service dir: ${getServiceDir(current.termux?.service_name || 'nexuscrew')}`);
+    const logDir = path.join(CONFIG_DIR, 'logs');
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
     }
-    console.log('Run "nexuscrew stt doctor" to finish local speech setup.');
-  });
 
-program.command('start')
-  .description('Start the server in background')
-  .option('-p, --port <port>', 'Port override')
-  .action(async (opts) => {
-    ensureBaseState();
-    const config = getConfig();
-    const tmux = new TmuxManager(config);
-    const port = Number(opts.port || config.server?.port || 41820);
-    const serviceConfigured = isTermux() && isTermuxServicesAvailable() && isTermuxServiceConfigured(config);
-    const existingPid = getExistingServerPid(port);
-
-    if (existingPid) {
-      console.log(`Server already running on ${getServerUrl(port)} (PID ${existingPid})`);
-      const shouldOpen = await promptBoolean('Open browser? (Y/n)', true);
-      if (shouldOpen && !openUrl(getServerUrl(port))) {
-        console.log(`Open this URL manually: ${getServerUrl(port)}`);
-      }
-      return;
-    }
-
-    tmux.ensureSession('local');
-
-    if (serviceConfigured) {
-      execSync(`sv up ${config.termux?.service_name || 'nexuscrew'}`, { stdio: 'ignore' });
-    } else {
-      startDetachedServer(port);
-    }
-
-    const healthy = await waitForHealth(port);
-    if (!healthy) {
-      console.error('Server did not become healthy in time. Check the log file for details.');
-      console.error(`Log: ${PATHS.SERVER_LOG}`);
-      process.exitCode = 1;
-      return;
+    try {
+      execSync('command -v tmux >/dev/null 2>&1', { stdio: 'pipe' });
+      log('tmux: OK');
+    } catch {
+      error('tmux not found! Install: apt install tmux (or pkg install tmux)');
     }
 
-    const pid = getExistingServerPid(port);
-    console.log(`Server started: ${getServerUrl(port)}${pid ? ` (PID ${pid})` : ''}`);
-    console.log(`Log: ${PATHS.SERVER_LOG}`);
+    log('\nDone! Run: nexuscrew start');
+  });
 
-    const shouldOpen = await promptBoolean('Open browser? (Y/n)', true);
-    if (shouldOpen && !openUrl(getServerUrl(port))) {
-      console.log(`Open this URL manually: ${getServerUrl(port)}`);
-    }
+program.command('start')
+  .description('Start the server')
+  .option('-p, --port <port>', 'Port', DEFAULT_PORT)
+  .option('-d, --dev', 'Dev mode (no frontend)')
+  .action((opts) => {
+    const env = { ...process.env, PORT: opts.port };
+    if (opts.dev) env.NEXUSCREW_DEV = '1';
+
+    const args = [path.join(__dirname, '..', 'lib', 'server', 'server.js')];
+    const child = spawn('node', args, {
+      env,
+      stdio: 'inherit',
+      detached: false
+    });
+    child.on('exit', (code) => process.exit(code || 0));
   });
 
 program.command('stop')
   .description('Stop the server')
   .action(() => {
-    const config = getConfig();
-    const port = config.server?.port || 41820;
-    const serviceName = config.termux?.service_name || 'nexuscrew';
-
-    if (isTermux() && isTermuxServicesAvailable() && isTermuxServiceConfigured(config)) {
-      try {
-        execSync(`sv down ${serviceName}`, { stdio: 'ignore' });
-      } catch {}
-    }
-
-    const pid = getExistingServerPid(port);
-    if (pid) {
-      try {
-        process.kill(pid, 'SIGTERM');
-      } catch {}
-      removePidFile();
-      console.log('Server stopped');
-      return;
+    try {
+      const pid = execSync(`lsof -ti :${DEFAULT_PORT} 2>/dev/null`).toString().trim();
+      if (pid) {
+        execSync(`kill ${pid}`);
+        console.log('Server stopped');
+      } else {
+        console.log('Server not running');
+      }
+    } catch {
+      console.log('Server not running');
     }
-
-    console.log('Server not running');
   });
 
 program.command('status')
-  .description('Show server, tmux, host, and speech status')
-  .action(async () => {
-    ensureBaseState();
-    const config = getConfig();
-    const tmux = new TmuxManager(config);
-    const speech = new SpeechManager();
-    const port = config.server?.port || 41820;
-    const pid = getExistingServerPid(port);
-    const healthy = pid ? await waitForHealth(port, 1500) : false;
-
-    console.log('=== NexusCrew Status ===');
-    console.log(`Server: ${pid ? `RUNNING (${pid})` : 'STOPPED'}`);
-    console.log(`Health: ${healthy ? 'OK' : 'DOWN'}`);
-    console.log(`HTTP: ${getServerUrl(port)}`);
-    console.log(`PID file: ${fs.existsSync(PATHS.PID_FILE) ? PATHS.PID_FILE : 'missing'}`);
-    console.log(`Log file: ${PATHS.SERVER_LOG}`);
-
-    console.log(`tmux session: ${config.tmuxSession}`);
-    tmux.listWindows('local').forEach((window) => {
-      console.log(`  ${window.index}: ${window.name} ${window.active ? '(active)' : ''}`);
-    });
+  .description('Show server and tmux status')
+  .action(() => {
+    console.log('=== NexusCrew Status ===\n');
 
-    console.log('Hosts:');
-    readHosts().forEach((host) => {
-      const status = host.type === 'local' ? 'local' : (tmux.testHost(host) ? 'OK' : 'UNREACHABLE');
-      console.log(`  ${host.name}: ${status}`);
-    });
+    try {
+      const pid = execSync(`lsof -ti :${DEFAULT_PORT} 2>/dev/null`).toString().trim();
+      console.log(`Server: RUNNING (pid ${pid})`);
+    } catch {
+      console.log('Server: STOPPED');
+    }
 
-    const speechStatus = speech.getStatus();
-    console.log(`STT: ${speechStatus.provider} (${speechStatus.whisper.available ? 'bin OK' : 'bin missing'})`);
-    console.log(`TTS: ${speechStatus.tts.provider}`);
-    if (isTermux()) {
-      console.log(`Termux boot: ${config.termux?.boot_start ? 'enabled' : 'disabled'}`);
-      const serviceStatus = getTermuxServiceStatus(config);
-      if (serviceStatus) {
-        console.log(`Termux service: ${serviceStatus}`);
-      }
+    try {
+      const sessions = execSync("tmux list-sessions -F '#{session_name} #{?session_attached,*, }' 2>/dev/null").toString().trim();
+      console.log('\nActive tmux sessions:');
+      sessions.split('\n').filter(Boolean).forEach((session) => console.log(`  ${session}`));
+    } catch {
+      console.log('\nActive tmux sessions: none');
+    }
+
+    if (fs.existsSync(HOSTS_PATH)) {
+      const hosts = JSON.parse(fs.readFileSync(HOSTS_PATH, 'utf8'));
+      console.log('\nHosts:');
+      hosts.forEach((host) => {
+        if (host.type === 'local') {
+          console.log(`  ${host.name}: local`);
+        } else {
+          const status = testSSH(host) ? 'OK' : 'UNREACHABLE';
+          console.log(`  ${host.name}: ${host.user}@${host.host}${host.port ? ':' + host.port : ''} [${status}]`);
+        }
+      });
     }
   });
 
 program.command('attach')
-  .description('Attach to local tmux session')
-  .option('-w, --window <name>', 'Window name')
+  .description('Attach to a tmux session')
+  .requiredOption('-s, --session <name>', 'Session name')
   .action((opts) => {
-    const tmuxSession = getConfig().tmuxSession || 'nexuscrew';
-    const target = opts.window ? `${tmuxSession}:${opts.window}` : tmuxSession;
-    execSync(`tmux attach -t ${target}`, { stdio: 'inherit' });
+    try {
+      execSync(`tmux attach -t ${shellQuote(opts.session)}`, { stdio: 'inherit' });
+    } catch {
+      console.error(`Session not found: ${opts.session}`);
+    }
   });
 
 program.command('sessions')
-  .description('List local tmux windows')
+  .description('List active tmux sessions')
   .action(() => {
-    const tmux = new TmuxManager(getConfig());
-    const windows = tmux.listWindows('local');
-    if (windows.length === 0) {
-      console.log('No tmux session found');
-      return;
+    try {
+      const out = execSync(
+        "tmux list-sessions -F '#{session_name} [#{session_windows} windows] #{?session_attached,(attached),}' 2>/dev/null"
+      ).toString().trim();
+      console.log(out || 'No tmux sessions found');
+    } catch {
+      console.log('No tmux sessions found');
     }
-    windows.forEach((window) => {
-      console.log(`${window.index}: ${window.name} [${window.size}] ${window.active ? '(active)' : ''}`);
-    });
   });
 
 program.command('config')
-  .description('Read or update configuration')
-  .argument('[action]', 'get | set | list', 'list')
-  .argument('[payload]')
-  .action((action, payload) => {
-    ensureBaseState();
-    if (action === 'get' && payload) {
-      console.log(JSON.stringify(getConfigValue(payload), null, 2));
+  .description('View/edit configuration')
+  .option('-l, --list', 'Show current config')
+  .option('-s, --set <key=value>', 'Set a config value')
+  .action((opts) => {
+    if (!fs.existsSync(CONFIG_PATH)) {
+      console.error('Run nexuscrew init first');
       return;
     }
-    if (action === 'set' && payload) {
-      const [key, ...rest] = payload.split('=');
-      setConfigValue(key, rest.join('='));
-      console.log(`Updated ${key}`);
-      return;
+    const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+
+    if (opts.set) {
+      const [key, ...rest] = opts.set.split('=');
+      const value = rest.join('=');
+      let parsedValue = value;
+      if (value === 'true') parsedValue = true;
+      if (value === 'false') parsedValue = false;
+      if (!Number.isNaN(Number(value)) && value.trim() !== '') parsedValue = Number(value);
+      config[key] = parsedValue;
+      fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+      console.log(`Set ${key} = ${value}`);
+    } else {
+      console.log(JSON.stringify(config, null, 2));
     }
-    console.log(JSON.stringify(getConfig(), null, 2));
   });
 
-const hostsCmd = program.command('hosts').description('Manage SSH hosts');
+const hostsCmd = program.command('hosts').description('Manage remote hosts');
 
 hostsCmd.command('list')
+  .description('List configured hosts')
   .action(() => {
-    readHosts().forEach((host) => {
-      console.log(`${host.name} ${host.type === 'local' ? '(local)' : `${host.user}@${host.host}:${host.port}`}`);
+    if (!fs.existsSync(HOSTS_PATH)) {
+      console.log('No hosts configured. Run nexuscrew init.');
+      return;
+    }
+    const hosts = JSON.parse(fs.readFileSync(HOSTS_PATH, 'utf8'));
+    hosts.forEach((host, i) => {
+      const status = host.type === 'local' ? 'local' : (testSSH(host) ? 'OK' : 'UNREACHABLE');
+      console.log(`[${i}] ${host.name} (${host.type}) ${host.host || ''} [${status}]${host.default ? ' *default*' : ''}`);
     });
   });
 
 hostsCmd.command('add')
-  .requiredOption('-n, --name <name>')
-  .requiredOption('-h, --host <host>')
-  .option('-u, --user <user>', 'SSH user', 'dag')
+  .description('Add a remote host')
+  .requiredOption('-n, --name <name>', 'Host name')
+  .requiredOption('-h, --host <host>', 'Hostname or IP')
+  .option('-u, --user <user>', 'SSH user', os.userInfo().username)
   .option('-p, --port <port>', 'SSH port', '22')
   .option('-k, --key <path>', 'SSH key path')
   .action((opts) => {
-    const hosts = readHosts().filter((host) => host.name !== opts.name);
+    const hosts = fs.existsSync(HOSTS_PATH)
+      ? JSON.parse(fs.readFileSync(HOSTS_PATH, 'utf8'))
+      : [];
     hosts.push({
       name: opts.name,
       type: 'ssh',
       host: opts.host,
       user: opts.user,
       port: opts.port,
-      key: opts.key || null,
-      default: false
+      key: opts.key || undefined
     });
-    writeHosts(hosts);
+    fs.writeFileSync(HOSTS_PATH, JSON.stringify(hosts, null, 2));
     console.log(`Added host: ${opts.name}`);
   });
 
 hostsCmd.command('remove')
-  .requiredOption('-n, --name <name>')
+  .description('Remove a host')
+  .requiredOption('-n, --name <name>', 'Host name')
   .action((opts) => {
-    writeHosts(readHosts().filter((host) => host.name !== opts.name));
+    let hosts = fs.existsSync(HOSTS_PATH)
+      ? JSON.parse(fs.readFileSync(HOSTS_PATH, 'utf8'))
+      : [];
+    hosts = hosts.filter((host) => host.name !== opts.name);
+    fs.writeFileSync(HOSTS_PATH, JSON.stringify(hosts, null, 2));
     console.log(`Removed host: ${opts.name}`);
   });
 
-hostsCmd.command('test')
-  .argument('[name]', 'Host name', 'local')
-  .action((name) => {
-    const tmux = new TmuxManager(getConfig());
-    console.log(tmux.testHost(name) ? 'OK' : 'UNREACHABLE');
+program.command('engines')
+  .description('Discover available launchers')
+  .action(() => {
+    const launchers = new EngineDiscovery(readConfig()).getLaunchers();
+    console.log('\nDiscovered Launchers:\n');
+    for (const launcher of launchers) {
+      console.log(`  ${launcher.label}: ${launcher.kind} [${launcher.family}]${launcher.runnable ? '' : ' (detected only)'}`);
+      console.log(`    command: ${launcher.commandPreview}`);
+      console.log(`    source:  ${launcher.source}`);
+    }
+    console.log('');
   });
 
-const sttCmd = program.command('stt').description('Local speech-to-text tools');
+function readConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return { preferredShell: '', extraShellSources: [] };
+  }
+  const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+  if (config.providersPath && !config.extraShellSources) {
+    config.extraShellSources = [config.providersPath].filter(Boolean);
+  }
+  return config;
+}
 
-sttCmd.command('doctor')
-  .description('Inspect local whisper.cpp setup')
-  .action(() => {
-    const speech = new SpeechManager();
-    const status = speech.getStatus();
-    console.log(JSON.stringify(status, null, 2));
-  });
+function testSSH(host) {
+  try {
+    const keyOpt = host.key ? `-i ${shellQuote(host.key)}` : '';
+    const portOpt = host.port && host.port !== '22' ? `-p ${host.port}` : '';
+    execSync(`ssh -o ConnectTimeout=3 -o BatchMode=yes ${keyOpt} ${portOpt} ${host.user}@${host.host} echo ok`, { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
 
-program.command('engines')
-  .description('List discovered CLI engines')
-  .action(() => {
-    const discovery = new EngineDiscovery(getConfig().providersPath);
-    const engines = discovery.discover();
-    Object.entries(engines).forEach(([name, info]) => {
-      console.log(`${name}: ${info.available ? 'OK' : 'NOT FOUND'}${info.path ? ` -> ${info.path}` : ''}`);
-    });
-  });
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
 
-program.parseAsync();
+program.parse();