@mmmbuto/nexuscrew 0.2.0 → 0.2.1

package/bin/nexuscrew.js

@@ -2,353 +2,556 @@
 '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 { execSync } = require('child_process');
-
-const CONFIG_DIR = path.join(process.env.HOME || '', '.nexuscrew');
-const DB_PATH = path.join(CONFIG_DIR, 'nexuscrew.db');
-const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
-const HOSTS_PATH = path.join(CONFIG_DIR, 'hosts.json');
-const TMUX_SESSION = 'nexuscrew';
+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;
+  }
+
+  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();
+  });
+}
+
+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]
+  });
+
+  child.unref();
+  writePidFile(child.pid);
+  return child.pid;
+}
+
 program
   .name('nexuscrew')
   .description('tmux-based AI cockpit')
-  .version('0.2.0');
+  .version('0.2.1');
 
-// --- init ---
 program.command('init')
-  .description('First-time setup')
-  .option('-s, --silent', 'Silent mode (no output)')
+  .description('Bootstrap config, directories, and host registry')
+  .option('-s, --silent', 'Silent mode')
   .action((opts) => {
-    if (!fs.existsSync(CONFIG_DIR)) {
-      fs.mkdirSync(CONFIG_DIR, { recursive: true });
-      if (!opts.silent) console.log('Created ~/.nexuscrew/');
+    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'}`);
     }
+  });
 
-    // Default config
-    if (!fs.existsSync(CONFIG_PATH)) {
-      fs.writeFileSync(CONFIG_PATH, JSON.stringify({
-        port: 41820,
-        tmuxSession: TMUX_SESSION,
-        logDir: path.join(CONFIG_DIR, 'logs'),
-        autoDiscovery: true,
-        providersPath: ''
-      }, null, 2));
-      if (!opts.silent) console.log('Created config.json');
+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);
+        }
+      }
     }
 
-    // Default hosts
-    if (!fs.existsSync(HOSTS_PATH)) {
-      fs.writeFileSync(HOSTS_PATH, JSON.stringify([
-        { name: 'local', type: 'local', default: true }
-      ], null, 2));
-      if (!opts.silent) console.log('Created hosts.json');
+    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);
     }
 
-    // Log dir
-    const logDir = path.join(CONFIG_DIR, 'logs');
-    if (!fs.existsSync(logDir)) {
-      fs.mkdirSync(logDir, { recursive: true });
-    }
+    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);
+      }
 
-    // Check tmux
-    try {
-      execSync('which tmux', { stdio: 'pipe' });
-      if (!opts.silent) console.log('tmux: OK');
-    } catch {
-      if (!opts.silent) console.error('tmux not found! Install: apt install tmux (or pkg install tmux)');
+      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 (!opts.silent) console.log('\nDone! Run: nexuscrew start');
+    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')}`);
+    }
+    console.log('Run "nexuscrew stt doctor" to finish local speech setup.');
   });
 
-// --- start ---
 program.command('start')
-  .description('Start the server')
-  .option('-p, --port <port>', 'Port', '41820')
-  .option('-d, --dev', 'Dev mode (no frontend)')
-  .action((opts) => {
-    // Ensure tmux master session exists
-    try {
-      execSync(`tmux has-session -t ${TMUX_SESSION} 2>/dev/null`);
-    } catch {
-      execSync(`tmux new-session -d -s ${TMUX_SESSION} -x 200 -y 50`);
-      console.log(`Created tmux session: ${TMUX_SESSION}`);
+  .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;
     }
 
-    const env = { ...process.env, PORT: opts.port };
-    if (opts.dev) env.NEXUSCREW_DEV = '1';
+    tmux.ensureSession('local');
 
-    const args = [path.join(__dirname, '..', 'lib', 'server', 'server.js')];
-    const child = require('child_process').spawn('node', args, {
-      env,
-      stdio: 'inherit',
-      detached: false
-    });
-    child.on('exit', (code) => process.exit(code || 0));
+    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;
+    }
+
+    const pid = getExistingServerPid(port);
+    console.log(`Server started: ${getServerUrl(port)}${pid ? ` (PID ${pid})` : ''}`);
+    console.log(`Log: ${PATHS.SERVER_LOG}`);
+
+    const shouldOpen = await promptBoolean('Open browser? (Y/n)', true);
+    if (shouldOpen && !openUrl(getServerUrl(port))) {
+      console.log(`Open this URL manually: ${getServerUrl(port)}`);
+    }
   });
 
-// --- stop ---
 program.command('stop')
   .description('Stop the server')
   .action(() => {
-    try {
-      const pid = execSync(`lsof -ti :41820 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');
+    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;
     }
+
+    console.log('Server not running');
   });
 
-// --- status ---
 program.command('status')
-  .description('Show server and tmux status')
-  .action(() => {
-    console.log('=== NexusCrew Status ===\n');
-
-    // Server
-    try {
-      const pid = execSync(`lsof -ti :41820 2>/dev/null`).toString().trim();
-      console.log(`Server: RUNNING (pid ${pid})`);
-    } catch {
-      console.log('Server: STOPPED');
-    }
+  .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)' : ''}`);
+    });
 
-    // tmux
-    try {
-      const windows = execSync(`tmux list-windows -t ${TMUX_SESSION} -F '#{window_name} #{?window_active,*, }' 2>/dev/null`).toString().trim();
-      console.log(`\ntmux session "${TMUX_SESSION}":`);
-      windows.split('\n').forEach(w => console.log(`  ${w}`));
-    } catch {
-      console.log(`\ntmux session "${TMUX_SESSION}": NOT FOUND`);
-    }
+    console.log('Hosts:');
+    readHosts().forEach((host) => {
+      const status = host.type === 'local' ? 'local' : (tmux.testHost(host) ? 'OK' : 'UNREACHABLE');
+      console.log(`  ${host.name}: ${status}`);
+    });
 
-    // Hosts
-    if (fs.existsSync(HOSTS_PATH)) {
-      const hosts = JSON.parse(fs.readFileSync(HOSTS_PATH, 'utf8'));
-      console.log('\nHosts:');
-      hosts.forEach(h => {
-        if (h.type === 'local') {
-          console.log(`  ${h.name}: local`);
-        } else {
-          const status = testSSH(h) ? 'OK' : 'UNREACHABLE';
-          console.log(`  ${h.name}: ${h.user}@${h.host}${h.port ? ':' + h.port : ''} [${status}]`);
-        }
-      });
+    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}`);
+      }
     }
   });
 
-// --- attach ---
 program.command('attach')
-  .description('Attach to tmux session')
-  .option('-w, --window <name>', 'Attach to specific window')
+  .description('Attach to local tmux session')
+  .option('-w, --window <name>', 'Window name')
   .action((opts) => {
-    const target = opts.window ? `${TMUX_SESSION}:${opts.window}` : TMUX_SESSION;
-    try {
-      execSync(`tmux attach -t ${target}`, { stdio: 'inherit' });
-    } catch {
-      console.error(`Session/window not found: ${target}`);
-    }
+    const tmuxSession = getConfig().tmuxSession || 'nexuscrew';
+    const target = opts.window ? `${tmuxSession}:${opts.window}` : tmuxSession;
+    execSync(`tmux attach -t ${target}`, { stdio: 'inherit' });
   });
 
-// --- sessions ---
 program.command('sessions')
-  .description('List tmux windows')
+  .description('List local tmux windows')
   .action(() => {
-    try {
-      const out = execSync(
-        `tmux list-windows -t ${TMUX_SESSION} -F '#{window_index}: #{window_name} [#{window_width}x#{window_height}] #{?window_active,(active),}' 2>/dev/null`
-      ).toString().trim();
-      console.log(out);
-    } catch {
+    const tmux = new TmuxManager(getConfig());
+    const windows = tmux.listWindows('local');
+    if (windows.length === 0) {
       console.log('No tmux session found');
+      return;
     }
+    windows.forEach((window) => {
+      console.log(`${window.index}: ${window.name} [${window.size}] ${window.active ? '(active)' : ''}`);
+    });
   });
 
-// --- config ---
 program.command('config')
-  .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');
+  .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));
       return;
     }
-    const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
-
-    if (opts.set) {
-      const [key, ...rest] = opts.set.split('=');
-      const value = rest.join('=');
-      config[key] = isNaN(value) ? value : Number(value);
-      fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
-      console.log(`Set ${key} = ${value}`);
-    } else {
-      console.log(JSON.stringify(config, null, 2));
+    if (action === 'set' && payload) {
+      const [key, ...rest] = payload.split('=');
+      setConfigValue(key, rest.join('='));
+      console.log(`Updated ${key}`);
+      return;
     }
+    console.log(JSON.stringify(getConfig(), null, 2));
   });
 
-// --- hosts ---
-const hostsCmd = program.command('hosts').description('Manage remote hosts');
+const hostsCmd = program.command('hosts').description('Manage SSH hosts');
 
 hostsCmd.command('list')
-  .description('List configured hosts')
   .action(() => {
-    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((h, i) => {
-      const status = h.type === 'local' ? 'local' : (testSSH(h) ? 'OK' : 'UNREACHABLE');
-      console.log(`[${i}] ${h.name} (${h.type}) ${h.host || ''} [${status}]${h.default ? ' *default*' : ''}`);
+    readHosts().forEach((host) => {
+      console.log(`${host.name} ${host.type === 'local' ? '(local)' : `${host.user}@${host.host}:${host.port}`}`);
     });
   });
 
 hostsCmd.command('add')
-  .description('Add a remote host')
-  .requiredOption('-n, --name <name>', 'Host name')
-  .requiredOption('-h, --host <host>', 'Hostname or IP')
+  .requiredOption('-n, --name <name>')
+  .requiredOption('-h, --host <host>')
   .option('-u, --user <user>', 'SSH user', 'dag')
   .option('-p, --port <port>', 'SSH port', '22')
   .option('-k, --key <path>', 'SSH key path')
   .action((opts) => {
-    const hosts = fs.existsSync(HOSTS_PATH)
-      ? JSON.parse(fs.readFileSync(HOSTS_PATH, 'utf8'))
-      : [];
+    const hosts = readHosts().filter((host) => host.name !== opts.name);
     hosts.push({
       name: opts.name,
       type: 'ssh',
       host: opts.host,
       user: opts.user,
       port: opts.port,
-      key: opts.key || undefined
+      key: opts.key || null,
+      default: false
     });
-    fs.writeFileSync(HOSTS_PATH, JSON.stringify(hosts, null, 2));
+    writeHosts(hosts);
     console.log(`Added host: ${opts.name}`);
   });
 
 hostsCmd.command('remove')
-  .description('Remove a host')
-  .requiredOption('-n, --name <name>', 'Host name')
+  .requiredOption('-n, --name <name>')
   .action((opts) => {
-    let hosts = fs.existsSync(HOSTS_PATH)
-      ? JSON.parse(fs.readFileSync(HOSTS_PATH, 'utf8'))
-      : [];
-    hosts = hosts.filter(h => h.name !== opts.name);
-    fs.writeFileSync(HOSTS_PATH, JSON.stringify(hosts, null, 2));
+    writeHosts(readHosts().filter((host) => host.name !== opts.name));
     console.log(`Removed host: ${opts.name}`);
   });
 
-// --- engines ---
-program.command('engines')
-  .description('Discover available AI CLIs')
-  .action(() => {
-    const engines = discoverEngines();
-    console.log('\nDiscovered Engines:\n');
-    for (const [name, info] of Object.entries(engines)) {
-      console.log(`  ${name}: ${info.available ? 'OK' : 'NOT FOUND'}`);
-      if (info.path) console.log(`    path: ${info.path}`);
-      if (info.aliases.length) {
-        console.log(`    aliases: ${info.aliases.join(', ')}`);
-      }
-    }
-    console.log('');
+hostsCmd.command('test')
+  .argument('[name]', 'Host name', 'local')
+  .action((name) => {
+    const tmux = new TmuxManager(getConfig());
+    console.log(tmux.testHost(name) ? 'OK' : 'UNREACHABLE');
   });
 
-// --- helpers ---
-function testSSH(host) {
-  try {
-    const keyOpt = host.key ? `-i ${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;
-  }
-}
+const sttCmd = program.command('stt').description('Local speech-to-text tools');
 
-function discoverEngines() {
-  const engines = {
-    claude: { available: false, path: null, aliases: [], type: 'interactive' },
-    codex: { available: false, path: null, aliases: [], type: 'exec' },
-    gemini: { available: false, path: null, aliases: [], type: 'interactive' },
-    qwen: { available: false, path: null, aliases: [], type: 'interactive' }
-  };
-
-  // Direct CLI discovery
-  const cliPaths = {
-    claude: [
-      path.join(process.env.HOME, '.local/bin/claude'),
-      path.join(process.env.HOME, '.claude/local/claude'),
-      '/usr/local/bin/claude'
-    ],
-    codex: [
-      path.join(process.env.HOME, '.local/codex-lts/bin/codex'),
-      path.join(process.env.HOME, '.local/codex-lts/node_modules/.bin/codex')
-    ],
-    gemini: [
-      path.join(process.env.HOME, '.local/bin/gemini'),
-      path.join(process.env.HOME, '.gemini/bin/gemini')
-    ],
-    qwen: [
-      path.join(process.env.HOME, '.local/bin/qwen'),
-      path.join(process.env.HOME, '.qwen/bin/qwen')
-    ]
-  };
-
-  for (const [engine, paths] of Object.entries(cliPaths)) {
-    for (const p of paths) {
-      try {
-        if (fs.existsSync(p) && fs.statSync(p).mode & 0o111) {
-          engines[engine].available = true;
-          engines[engine].path = p;
-          break;
-        }
-      } catch {}
-    }
-    // Fallback: check PATH
-    if (!engines[engine].available) {
-      try {
-        const which = execSync(`which ${engine} 2>/dev/null`).toString().trim();
-        if (which) {
-          engines[engine].available = true;
-          engines[engine].path = which;
-        }
-      } catch {}
-    }
-  }
-
-  // Parse providers file for aliases (if configured)
-  const configPath = path.join(process.env.HOME || '', '.nexuscrew', 'config.json');
-  let providersPath = '';
-  try {
-    const cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    providersPath = cfg.providersPath || '';
-  } catch {}
-  if (providersPath && fs.existsSync(providersPath)) {
-    const content = fs.readFileSync(providersPath, 'utf8');
-    const funcRegex = /^(codex-[a-z0-9-]+|claude-[a-z0-9-]+|gemini-[a-z0-9-]+|qwen-[a-z0-9-]+)\(\)/gm;
-    let match;
-    while ((match = funcRegex.exec(content)) !== null) {
-      const alias = match[1];
-      const baseEngine = alias.split('-')[0];
-      const engine = baseEngine === 'codex' ? 'codex' : baseEngine === 'claude' ? 'claude' : baseEngine === 'gemini' ? 'gemini' : 'qwen';
-      if (engines[engine]) {
-        engines[engine].aliases.push(alias);
-      }
-    }
-  }
+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));
+  });
 
-  return engines;
-}
+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}` : ''}`);
+    });
+  });
 
-program.parse();
+program.parseAsync();