@mmmbuto/nexuscrew 0.8.0 → 0.8.3

package/lib/cli/commands.js

@@ -6,8 +6,10 @@
 const { execFileSync, spawn } = require('node:child_process');
 const fs = require('node:fs');
 const path = require('node:path');
+const net = require('node:net');
 const { detectPlatform, nodeBin, repoRoot, uid } = require('./platform.js');
 const { installPath: serviceInstallPath } = require('./service.js');
+const { fleetInstallPath } = require('./fleet-service.js');
 const pidf = require('./pidfile.js');
 const { runInit } = require('./init.js');
 const { rotateToken } = require('../auth/token.js');
@@ -20,35 +22,22 @@ const nodesTunnel = require('../nodes/tunnel.js');
 // Flag CLI che consumano il token successivo (forma "--k v", oltre a "--k=v").
 // Solo flag esclusivi dei subcomandi nodes/node: non collidono con gli altri.
 const VALUE_FLAGS = new Set([
-  'ssh', 'remote-port', 'key', 'local-port', 'node-id', 'rendezvous', 'published-port', 'token',
+  'ssh', 'ssh-port', 'remote-port', 'key', 'local-port', 'node-id', 'rendezvous', 'published-port', 'token',
 ]);
 
-const HELP = `NexusCrew (portable) — browser tmux client.
+const HELP = `NexusCrew — PWA for local and remote AI workers.
 
 Usage:
-  nexuscrew                               smart-up: init se serve -> start -> URL + QR
-  nexuscrew init [--dry-run] [--port N]   setup: detect + config + token + service + URL
-  nexuscrew serve [--pidfile]             HTTP server foreground (dev / ExecStart)
-  nexuscrew start | up                    avvia il servizio (systemctl / launchctl / nohup+pidfile)
-  nexuscrew stop | down                   stop del servizio (service manager / pidfile verificato)
-  nexuscrew status [--json]               stato: platform + service + porta + URL + ruoli + nodi
-  nexuscrew url [--qr]                    ristampa URL con #token (+ QR ASCII) — UNICO posto col token
-  nexuscrew token rotate                  ruota il token (atomico) + invalida le sessioni attive
-  nexuscrew logs [-f]                     journalctl-user / logfile (-f = segue)
-  nexuscrew doctor                        auto-diagnosi: node, tmux, PTY, service, boot, token, ssh
-  nexuscrew mcp                           server MCP stdio per sessioni AI (notify/ask/file/status)
-  nexuscrew update                        npm i -g @mmmbuto/nexuscrew@latest + restart
-  nexuscrew fleet-boot                    companion di boot: avvia le celle boot:true (config-driven)
-  nexuscrew nodes add <name> --ssh u@h    aggiunge un nodo (genera chiave dedicata + authorized_keys)
-  nexuscrew nodes list [--json]           elenca i nodi + stato tunnel (token redatti)
-  nexuscrew nodes remove|test <name>      rimuove / testa un nodo (test: tunnel/health/token remoto)
-  nexuscrew nodes up|down|restart <name>  lifecycle del singolo tunnel (non tocca la config)
-  nexuscrew nodes set-token <name>        aggiorna il token remoto (da stdin/env, mai argv)
-  nexuscrew node on|off                   ruolo "nodo raggiungibile" (reverse tunnel)
-
-Piattaforme: linux (systemd --user), mac (launchd), termux (nohup + pidfile).
-Bind loopback 127.0.0.1 — raggiungibile via tunnel SSH/VPN.
-Il token appare SOLO in \`url\`/\`url --qr\` — mai in status, logs, service output.`;
+  nexuscrew          start in background; show status and quick guide
+  nexuscrew show     start when needed and open the authenticated PWA
+  nexuscrew show token  print the clickable authenticated URL
+  nexuscrew boot     enable startup at boot (use: boot off|status)
+  nexuscrew doctor   run local diagnostics
+  nexuscrew help     show this help
+  nexuscrew version  show the installed version
+
+Configuration, nodes, engines, providers, models and lifecycle live in the PWA.
+NexusCrew binds only to 127.0.0.1 and automatically selects a free port.`;
 
 // valueFlags (Set|array opzionale): flag che consumano il token successivo nella
 // forma "--k v". Omesso -> comportamento storico (solo "--k" bool o "--k=v").
@@ -79,7 +68,7 @@ function parseFlags(argv, valueFlags) {
 function serve(opts = {}) {
   const serverStart = opts.serverStart || require('../server.js').start;
   if (opts.pidfile) {
-    const pidPath = pidf.defaultPidfilePath();
+    const pidPath = pidf.defaultPidfilePath(opts.home);
     // already-running check
     const meta = pidf.readPidfile(pidPath);
     if (meta && pidf.isAlive(meta)) {
@@ -129,8 +118,9 @@ function start(opts = {}) {
     return { platform, started: true };
   }
   if (platform === 'termux') {
+    const home = opts.home || require('node:os').homedir();
     // already-running?
-    const pidPath = pidf.defaultPidfilePath();
+    const pidPath = pidf.defaultPidfilePath(opts.home);
     const meta = pidf.readPidfile(pidPath);
     if (meta && pidf.isAlive(meta)) {
       log(`already running (pid ${meta.pid}) — pidfile ${pidPath}`);
@@ -138,12 +128,24 @@ function start(opts = {}) {
     }
     pidf.cleanStale(pidPath);
     const repoBin = path.join(repoRoot(), 'bin', 'nexuscrew.js');
-    const logPath = path.join(require('node:os').homedir(), '.nexuscrew', 'nexuscrew.log');
+    const logPath = path.join(home, '.nexuscrew', 'nexuscrew.log');
     fs.mkdirSync(path.dirname(logPath), { recursive: true });
     const logFd = fs.openSync(logPath, 'a');
-    const child = spawnImpl(nodeBin(), [repoBin, 'serve', '--pidfile'], {
-      detached: true, stdio: ['ignore', logFd, logFd],
-    });
+    const resolved = urlmod.resolvePaths(opts);
+    const childEnv = {
+      ...process.env,
+      HOME: home,
+      NEXUSCREW_CONFIG_FILE: resolved.configPath,
+      NEXUSCREW_TOKEN_FILE: resolved.tokenPath,
+    };
+    // config.json is authoritative after automatic port fallback.
+    delete childEnv.NEXUSCREW_PORT;
+    let child;
+    try {
+      child = spawnImpl(nodeBin(), [repoBin, 'serve', '--pidfile'], {
+        detached: true, stdio: ['ignore', logFd, logFd], env: childEnv,
+      });
+    } finally { try { fs.closeSync(logFd); } catch (_) {} }
     if (child && typeof child.unref === 'function') child.unref();
     log(`start: nohup ${nodeBin()} ${repoBin} serve --pidfile (>> ${logPath})`);
     return { platform, started: true, pid: child && child.pid };
@@ -176,7 +178,7 @@ function stop(opts = {}) {
   }
   if (platform === 'termux') {
     // kill via pidfile verificato (no broad match) + wake-lock-release
-    const pidPath = pidf.defaultPidfilePath();
+    const pidPath = pidf.defaultPidfilePath(opts.home);
     const r = pidf.killPidfile(pidPath);
     try { execImpl('termux-wake-lock-release', [], { stdio: 'ignore' }); } catch (_) {}
     log(`stop: ${r.killed ? `killed pid ${r.pid}` : r.reason}`);
@@ -198,12 +200,93 @@ function isServiceRunning(opts = {}) {
     catch (_) { return false; }
   }
   if (platform === 'termux') {
-    const meta = pidf.readPidfile(pidf.defaultPidfilePath());
+    const meta = pidf.readPidfile(pidf.defaultPidfilePath(opts.home));
     return !!(meta && pidf.isAlive(meta));
   }
   return false;
 }
 
+function bootState(opts = {}) {
+  const platform = opts.platform || detectPlatform();
+  const execImpl = opts.execImpl || execFileSync;
+  const home = opts.home || require('node:os').homedir();
+  if (platform === 'linux') {
+    try { return { platform, enabled: execImpl('systemctl', ['--user', 'is-enabled', 'nexuscrew'], { encoding: 'utf8' }).trim() === 'enabled' }; }
+    catch (_) { return { platform, enabled: false }; }
+  }
+  try { return { platform, enabled: fs.lstatSync(serviceInstallPath(platform, home)).isFile() }; }
+  catch (_) { return { platform, enabled: false }; }
+}
+
+function unlinkRegular(target) {
+  try {
+    const st = fs.lstatSync(target);
+    if (st.isSymbolicLink() || !st.isFile()) throw new Error(`refusing unsafe boot target: ${target}`);
+    fs.unlinkSync(target); return true;
+  } catch (e) { if (e.code === 'ENOENT') return false; throw e; }
+}
+
+async function bootOn(opts = {}) {
+  const platform = opts.platform || detectPlatform();
+  const quiet = opts.lifecycleLog || (() => {});
+  const { configPath, tokenPath } = urlmod.resolvePaths(opts);
+  if (!fs.existsSync(configPath) || !urlmod.readToken(tokenPath)) {
+    const selected = await findAvailablePort(opts.port || urlmod.loadPort(opts), opts);
+    (opts.runInitImpl || runInit)({ ...opts, platform, port: selected, installBoot: false, printUrl: false, log: quiet });
+  }
+  try { pidf.killPidfile(pidf.defaultPidfilePath(opts.home)); } catch (_) {}
+  (opts.runInitImpl || runInit)({ ...opts, platform, installBoot: true, printUrl: false, log: quiet });
+  const result = await smartUp({ ...opts, platform });
+  return { ...result, boot: bootState({ ...opts, platform }).enabled };
+}
+
+async function bootOff(opts = {}) {
+  const platform = opts.platform || detectPlatform();
+  const execImpl = opts.execImpl || execFileSync;
+  const home = opts.home || require('node:os').homedir();
+  if (platform === 'linux') {
+    try { execImpl('systemctl', ['--user', 'disable', 'nexuscrew'], { stdio: 'ignore' }); } catch (_) {}
+    try { execImpl('systemctl', ['--user', 'disable', 'nexuscrew-fleet.service'], { stdio: 'ignore' }); } catch (_) {}
+  } else if (platform === 'mac') {
+    const domain = `gui/${opts.uid || uid()}`;
+    try { execImpl('launchctl', ['bootout', `${domain}/com.mmmbuto.nexuscrew`], { stdio: 'ignore' }); } catch (_) {}
+    try { execImpl('launchctl', ['bootout', `${domain}/com.mmmbuto.nexuscrew-fleet`], { stdio: 'ignore' }); } catch (_) {}
+    unlinkRegular(serviceInstallPath(platform, home));
+    try { unlinkRegular(fleetInstallPath(platform, home)); } catch (_) {}
+    const { tokenPath } = urlmod.resolvePaths(opts); const port = urlmod.loadPort(opts); const token = urlmod.readToken(tokenPath);
+    if (!(await probeNexusCrew(port, token, opts))) {
+      startPortable({ ...opts, platform });
+      await waitForNexusCrew(port, token, opts);
+    }
+  } else if (platform === 'termux') {
+    unlinkRegular(serviceInstallPath(platform, home));
+    try { unlinkRegular(fleetInstallPath(platform, home)); } catch (_) {}
+  }
+  return { platform, enabled: false, running: isServiceRunning({ ...opts, platform }) || !!pidf.readPidfile(pidf.defaultPidfilePath(home)) };
+}
+
+function quickSummary(result, opts = {}) {
+  const log = opts.log || console.log;
+  const platform = result.platform || opts.platform || detectPlatform();
+  const home = opts.home || require('node:os').homedir();
+  const { configDir } = urlmod.resolvePaths(opts);
+  const st = nodesStore.loadStore(opts.nodesPath || path.join(configDir, 'nodes.json'));
+  let cached = [];
+  try { cached = (require('../nodes/topology-cache.js').loadCache(opts.topologyCachePath || require('../nodes/topology-cache.js').defaultPath(home)) || {}).nodes || []; } catch (_) {}
+  const direct = (st && st.nodes) || [];
+  const online = direct.filter((n) => nodesTunnel.readTunnelState(home, n.name).status === 'up').length;
+  const known = direct.length + cached.filter((n) => !direct.some((d) => d.nodeId && d.nodeId === n.instanceId)).length;
+  log(`NexusCrew ${require('../../package.json').version}`);
+  log(`server  ${result.running ? '● running' : '○ stopped'} · 127.0.0.1:${result.port}`);
+  log(`boot    ${bootState({ ...opts, platform }).enabled ? 'on' : 'off'} · ${platform}`);
+  log(`nodes   ${known} known · ${online}/${direct.length} direct tunnels up`);
+  log('');
+  log('open    nexuscrew show');
+  log('link    nexuscrew show token');
+  log('boot    nexuscrew boot');
+  log('check   nexuscrew doctor');
+}
+
 // Ruoli client/node dal config.json (default entrambi off — B0 li popola dal wizard UI).
 function readRoles(configPath) {
   try {
@@ -238,7 +321,7 @@ function status(opts = {}) {
     // boot-script installed vs server running (pidfile vivo)
     const bootScript = path.join(home, '.termux', 'boot', 'nexuscrew.sh');
     out.bootScriptInstalled = fs.existsSync(bootScript);
-    const meta = pidf.readPidfile(pidf.defaultPidfilePath());
+    const meta = pidf.readPidfile(pidf.defaultPidfilePath(home));
     out.running = !!(meta && pidf.isAlive(meta));
     out.service = out.bootScriptInstalled ? 'boot-script installed' : 'no boot-script';
   }
@@ -304,43 +387,169 @@ function restart(opts = {}) {
   throw new Error(`restart: platform ${platform} non supportata`);
 }
 
-// smart-up (design §3.2): nexuscrew nudo. init minimale (zero domande) se mai
-// inizializzato -> start service (se non gia' attivo) -> stampa URL con #token + QR.
-// Idempotente: se gia' attivo stampa solo l'URL. Seam iniettabili per test.
-function smartUp(opts = {}) {
-  const log = opts.log || console.log;
+function wizardComplete(configPath) {
+  try {
+    const cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    return cfg && cfg.wizardDone === true;
+  } catch (_) { return false; }
+}
+
+function servicePinsLegacyPort(platform, home, installPath) {
+  let target;
+  try { target = installPath || serviceInstallPath(platform, home); } catch (_) { return false; }
+  try { return /NEXUSCREW_PORT/.test(fs.readFileSync(target, 'utf8')); } catch (_) { return false; }
+}
+
+function portAvailable(port, host = '127.0.0.1') {
+  return new Promise((resolve) => {
+    const s = net.createServer();
+    s.unref();
+    s.once('error', () => resolve(false));
+    s.listen(port, host, () => s.close(() => resolve(true)));
+  });
+}
+
+async function findAvailablePort(startPort, opts = {}) {
+  const available = opts.portAvailableImpl || portAvailable;
+  const first = Number(startPort);
+  if (!Number.isInteger(first) || first < 1 || first > 65535) throw new Error(`invalid port: ${startPort}`);
+  for (let port = first; port <= Math.min(65535, first + 200); port += 1) {
+    if (await available(port, '127.0.0.1')) return port;
+  }
+  throw new Error(`no free loopback port found from ${first}`);
+}
+
+async function probeNexusCrew(port, token, opts = {}) {
+  if (!token) return false;
+  const fetchImpl = opts.fetchImpl || globalThis.fetch;
+  if (typeof fetchImpl !== 'function') return false;
+  try {
+    const r = await fetchImpl(`http://127.0.0.1:${port}/api/config`, {
+      headers: { authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout?.(700),
+    });
+    return r.status === 200;
+  } catch (_) { return false; }
+}
+
+async function waitForNexusCrew(port, token, opts = {}) {
+  const probe = opts.probeImpl || probeNexusCrew;
+  const attempts = opts.waitAttempts === undefined ? 30 : opts.waitAttempts;
+  const delay = opts.waitDelayMs === undefined ? 100 : opts.waitDelayMs;
+  for (let i = 0; i < attempts; i += 1) {
+    if (await probe(port, token, opts)) return true;
+    if (i + 1 < attempts) await new Promise((resolve) => setTimeout(resolve, delay));
+  }
+  return false;
+}
+
+function startPortable(opts = {}) {
+  const spawnImpl = opts.spawnImpl || spawn;
+  const home = opts.home || require('node:os').homedir();
+  const logPath = path.join(home, '.nexuscrew', 'nexuscrew.log');
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  const logFd = fs.openSync(logPath, 'a');
+  const resolved = urlmod.resolvePaths(opts);
+  const childEnv = {
+    ...process.env,
+    HOME: home,
+    NEXUSCREW_CONFIG_FILE: resolved.configPath,
+    NEXUSCREW_TOKEN_FILE: resolved.tokenPath,
+    ...(opts.filesRoot ? { NEXUSCREW_FILES_ROOT: opts.filesRoot } : {}),
+  };
+  // config.json is authoritative after automatic port fallback.
+  delete childEnv.NEXUSCREW_PORT;
+  let child;
+  try {
+    child = spawnImpl(nodeBin(), [path.join(repoRoot(), 'bin', 'nexuscrew.js'), 'serve', '--pidfile'], {
+      detached: true, stdio: ['ignore', logFd, logFd], env: childEnv,
+    });
+  } finally { try { fs.closeSync(logFd); } catch (_) {} }
+  if (child && typeof child.unref === 'function') child.unref();
+  return { started: true, pid: child && child.pid, portable: true };
+}
+
+function openPwa(fullUrl, opts = {}) {
+  if (opts.openImpl) return opts.openImpl(fullUrl);
+  const platform = opts.platform || detectPlatform();
+  const commandExists = opts.commandExists || require('./path.js').commandExists;
+  const candidates = platform === 'termux'
+    ? ['termux-open-url']
+    : platform === 'mac' ? ['open'] : ['xdg-open', 'gio'];
+  const bin = candidates.find((candidate) => commandExists(candidate, opts.env || process.env));
+  if (!bin) throw new Error('no URL opener found; install termux-tools or xdg-utils');
+  const args = bin === 'gio' ? ['open', fullUrl] : [fullUrl];
+  const child = (opts.spawnImpl || spawn)(bin, args, { detached: true, stdio: 'ignore' });
+  if (child && typeof child.on === 'function') child.on('error', () => {});
+  if (child && typeof child.unref === 'function') child.unref();
+  return true;
+}
+
+// Normal entry point. It is deliberately quiet and returns after starting the
+// background service. Only first-run opens the wizard; `show` always opens it.
+async function smartUp(opts = {}) {
+  const quiet = opts.lifecycleLog || (() => {});
   const platform = opts.platform || detectPlatform();
-  const { configPath, tokenPath } = urlmod.resolvePaths(opts);
   const runInitImpl = opts.runInitImpl || runInit;
   const startImpl = opts.startImpl || start;
+  const restartImpl = opts.restartImpl || restart;
+  const portableStart = opts.startPortableImpl || startPortable;
+  const probe = opts.probeImpl || probeNexusCrew;
+  const { configPath, tokenPath } = urlmod.resolvePaths(opts);
+  let initialized = fs.existsSync(configPath) && !!urlmod.readToken(tokenPath);
+  let port;
 
-  const initialized = fs.existsSync(configPath) && !!urlmod.readToken(tokenPath);
   if (!initialized) {
-    log('smart-up: mai inizializzato -> init minimale (zero domande; il resto dal wizard UI)');
-    // printUrl:false -> init non stampa il token; l'URL/QR lo presenta smart-up sotto.
-    runInitImpl({ ...opts, log, platform, printUrl: false });
+    const requested = opts.port || urlmod.loadPort(opts);
+    const selected = await findAvailablePort(requested, opts);
+    runInitImpl({ ...opts, port: selected, log: quiet, platform, installBoot: false, printUrl: false });
+    port = selected;
+    initialized = true;
   }
 
-  const running = isServiceRunning({ ...opts, platform });
+  // 0.8.0 services embedded NEXUSCREW_PORT in their environment, overriding
+  // config.json forever. Regenerate once so config.json becomes authoritative.
+  const home = opts.home || require('node:os').homedir();
+  const persistent = bootState({ ...opts, platform }).enabled;
+  if (persistent && servicePinsLegacyPort(platform, home, opts.installPath)) {
+    runInitImpl({ ...opts, log: quiet, platform, installBoot: true, printUrl: false });
+  }
+
+  if (!port) port = urlmod.loadPort(opts);
+  let token = urlmod.readToken(tokenPath);
+  let running = await probe(port, token, opts);
+  let portableAttempted = false;
+  const managedRunning = isServiceRunning({ ...opts, platform });
+  if (!running && managedRunning) running = await waitForNexusCrew(port, token, opts);
+
   if (!running) {
-    startImpl({ execImpl: opts.execImpl, spawnImpl: opts.spawnImpl, log, platform, uid: opts.uid });
-  } else {
-    log('smart-up: servizio gia\' attivo');
+    if (!(await (opts.portAvailableImpl || portAvailable)(port, '127.0.0.1'))) {
+      port = await findAvailablePort(port + 1, opts);
+      runInitImpl({ ...opts, port, log: quiet, platform, installBoot: persistent, printUrl: false });
+      token = urlmod.readToken(tokenPath);
+    } else {
+      try {
+        const started = persistent
+          ? (managedRunning ? restartImpl({ ...opts, platform, log: quiet }) : startImpl({ ...opts, platform, log: quiet }))
+          : portableStart({ ...opts, platform });
+        if (started && started.started === false) {
+          portableStart({ ...opts, platform }); portableAttempted = true;
+        }
+      } catch (_) {
+        portableStart({ ...opts, platform }); portableAttempted = true;
+      }
+    }
+    running = await waitForNexusCrew(port, token, opts);
+    if (!running && !portableAttempted) {
+      try { portableStart({ ...opts, platform }); portableAttempted = true; } catch (_) {}
+      running = await waitForNexusCrew(port, token, opts);
+    }
+    if (!running) throw new Error(`server did not become ready on 127.0.0.1:${port}`);
   }
 
-  // Output: URL base (SENZA token in chiaro — smart-up puo' girare al boot/service)
-  // + QR che INCORPORA il token (scan-to-login, killer feature Termux). Il token in
-  // chiaro resta esclusivo di `nexuscrew url` (§3, invariante "token mai in output servizio").
-  const port = urlmod.loadPort(opts);
-  const token = urlmod.readToken(tokenPath);
-  const baseUrl = urlmod.buildUrl(port, null, { withToken: false });
-  const fullUrl = urlmod.buildUrl(port, token, { withToken: true });
-  log(baseUrl);
-  if (token) {
-    log(urlmod.renderQr(fullUrl, { qrcode: opts.qrcode }));
-    log('scansiona il QR (contiene il token) o usa `nexuscrew url` per l\'URL completo');
-  }
-  return { platform, initialized, running, url: baseUrl, port };
+  const shouldOpen = !opts.noOpen && (!!opts.forceOpen || !wizardComplete(configPath));
+  if (shouldOpen) openPwa(urlmod.buildUrl(port, token, { withToken: true }), { ...opts, platform });
+  return { platform, initialized, running, opened: shouldOpen, port, url: urlmod.buildUrl(port, null) };
 }
 
 // url [--qr]: ristampa URL completo con #token — UNICO comando che mostra il token.
@@ -378,7 +587,7 @@ function tokenRotate(opts = {}) {
   } else {
     // il service manager non lo vede, ma un `serve` manuale (pidfile) puo' essere
     // vivo col VECCHIO token cachato allo startup: avvisa esplicitamente.
-    const meta = pidf.readPidfile(pidf.defaultPidfilePath());
+    const meta = pidf.readPidfile(pidf.defaultPidfilePath(opts.home));
     if (meta && pidf.isAlive(meta)) {
       log(`token rotate: ATTENZIONE — server manuale attivo (pid ${meta.pid}): il vecchio token resta valido finche' non lo riavvii`);
     } else {
@@ -485,66 +694,64 @@ function dispatchFleetBoot(opts) {
 }
 
 function dispatch(argv, opts = {}) {
+  const log = opts.log || console.log;
+  if (argv.length === 1 && (argv[0] === '--help' || argv[0] === '-h')) {
+    log(HELP);
+    return { code: 0 };
+  }
+  if (argv.length === 1 && (argv[0] === '--version' || argv[0] === '-v')) {
+    log(require('../../package.json').version);
+    return { code: 0 };
+  }
   const { flags, rest } = parseFlags(argv, VALUE_FLAGS);
   const cmd = rest[0];
-  const log = opts.log || console.log;
 
   // help esplicito
   if (cmd === 'help' || cmd === '--help' || cmd === '-h') {
     log(HELP);
     return { code: 0 };
   }
-  // nexuscrew nudo = smart-up (design §3.2)
+  // Public surface: normal start, show, boot, doctor, help, version.
   if (!cmd) {
-    smartUp({ ...opts, log });
-    return { code: 0 };
+    if (Object.keys(flags).length) {
+      log(`unknown option: --${Object.keys(flags)[0]}\n\n${HELP}`);
+      return { code: 1 };
+    }
+    return smartUp({ ...opts, log: opts.lifecycleLog || (() => {}) }).then((r) => { quickSummary(r, { ...opts, log }); return { code: 0 }; });
+  }
+  if (cmd === 'show') {
+    if (rest[1] === 'token') {
+      return smartUp({ ...opts, noOpen: true, log: opts.lifecycleLog || (() => {}) }).then((r) => {
+        const { tokenPath } = urlmod.resolvePaths(opts); const token = urlmod.readToken(tokenPath);
+        log(urlmod.buildUrl(r.port, token, { withToken: true })); return { code: 0 };
+      });
+    }
+    if (rest[1]) { log('usage: nexuscrew show [token]'); return { code: 1 }; }
+    return smartUp({ ...opts, forceOpen: true, log: opts.lifecycleLog || (() => {}) }).then(() => ({ code: 0 }));
+  }
+  if (cmd === 'boot') {
+    const sub = rest[1] || 'on';
+    if (sub === 'status') {
+      const b = bootState(opts); log(`boot: ${b.enabled ? 'on' : 'off'} · ${b.platform}`); return { code: 0 };
+    }
+    if (sub === 'off') return bootOff(opts).then((r) => { log(`boot: off · ${r.platform}`); return { code: 0 }; });
+    if (sub === 'on') return bootOn(opts).then((r) => { quickSummary(r, { ...opts, log }); return { code: r.boot ? 0 : 1 }; });
+    log('usage: nexuscrew boot [on|off|status]'); return { code: 1 };
   }
-  if (cmd === 'init') {
-    runInit({ ...opts, dryRun: flags['dry-run'], port: flags.port ? Number(flags.port) : undefined, log });
+  if (cmd === 'version' || cmd === '--version' || cmd === '-v') {
+    log(require('../../package.json').version);
     return { code: 0 };
   }
+  // Internal runtime commands used by service managers and MCP clients. They
+  // are intentionally omitted from HELP and are not configuration surfaces.
   if (cmd === 'serve') {
     serve({ pidfile: flags.pidfile, serverStart: opts.serverStart });
     return { code: 0, keepAlive: true }; // server.listen tiene il processo vivo; non exit
   }
-  if (cmd === 'start' || cmd === 'up') {
-    const r = start({ execImpl: opts.execImpl, spawnImpl: opts.spawnImpl, log,
-      platform: opts.platform, uid: opts.uid, home: opts.home, installPath: opts.installPath });
-    return { code: r.started === false ? 1 : 0 };
-  }
-  if (cmd === 'stop' || cmd === 'down') {
-    const r = stop({ execImpl: opts.execImpl, log, platform: opts.platform, uid: opts.uid });
-    return { code: r.stopped === false ? 1 : 0 };
-  }
-  if (cmd === 'status') {
-    status({ ...opts, json: !!flags.json, log });
-    return { code: 0 };
-  }
-  if (cmd === 'url') {
-    url({ ...opts, qr: !!flags.qr, log });
-    return { code: 0 };
-  }
-  if (cmd === 'token') {
-    if (rest[1] === 'rotate') {
-      tokenRotate({ ...opts, log });
-      return { code: 0 };
-    }
-    log('usage: nexuscrew token rotate');
-    return { code: 1 };
-  }
-  if (cmd === 'logs') {
-    const follow = !!(flags.f || flags.follow) || rest.includes('-f');
-    const r = logs({ ...opts, follow, log });
-    return { code: 0, keepAlive: !!r.keepAlive };
-  }
   if (cmd === 'doctor') {
     const r = doctor({ ...opts, log });
     return { code: r.code };
   }
-  if (cmd === 'update') {
-    const r = update({ ...opts, log });
-    return { code: r.code || 0 };
-  }
   if (cmd === 'mcp') {
     // Server MCP stdio (bridge cella→operatore): stdout e' il canale JSON-RPC, quindi
     // NESSUN log qui. keepAlive: resta vivo finche' il client tiene aperto stdin.
@@ -555,13 +762,7 @@ function dispatch(argv, opts = {}) {
   if (cmd === 'fleet-boot') {
     return dispatchFleetBoot({ ...opts, log });
   }
-  if (cmd === 'nodes') {
-    return dispatchNodes(rest, flags, { ...opts, log });
-  }
-  if (cmd === 'node') {
-    return dispatchNode(rest, flags, { ...opts, log });
-  }
-  log(`unknown command: ${cmd}\n\n${HELP}`);
+  log(`"${cmd}" is not a public CLI command. Open the PWA with: nexuscrew show\n\n${HELP}`);
   return { code: 1 };
 }
 
@@ -574,7 +775,7 @@ function dispatchNodes(rest, flags, opts) {
   switch (sub) {
     case 'add':
       return { code: nodesCmds.nodesAdd({
-        ...common, ssh: flags.ssh, remotePort: flags['remote-port'],
+        ...common, ssh: flags.ssh, sshPort: flags['ssh-port'], remotePort: flags['remote-port'],
         key: flags.key, localPort: flags['local-port'], nodeId: flags['node-id'],
       }).code };
     case undefined:
@@ -624,6 +825,9 @@ function dispatchNode(rest, flags, opts) {
 module.exports = {
   dispatch, serve, start, stop, status, parseFlags, HELP,
   smartUp, url, tokenRotate, logs, doctor, update, restart,
+  portAvailable, findAvailablePort, probeNexusCrew, waitForNexusCrew, openPwa, startPortable, wizardComplete,
+  servicePinsLegacyPort,
   isServiceRunning, readRoles,
+  bootState, bootOn, bootOff, quickSummary,
   runFleetBoot, dispatchFleetBoot,
 };

package/lib/cli/doctor.js

@@ -51,7 +51,7 @@ function checkService(platform, home, execImpl, uidVal, installPathOverride) {
       active = true;
     } else if (platform === 'termux') {
       const pidf = require('./pidfile.js');
-      const meta = pidf.readPidfile(pidf.defaultPidfilePath());
+      const meta = pidf.readPidfile(pidf.defaultPidfilePath(home));
       active = !!(meta && pidf.isAlive(meta));
     }
   } catch (_) { active = false; }