npm - @mmmbuto/nexuscrew - Versions diffs - 0.8.21 → 0.8.23 - Mend

@mmmbuto/nexuscrew 0.8.21 → 0.8.23

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

package/README.md +27 -22
package/frontend/dist/assets/{index-DQbVJLji.css → index-77r8nzQf.css} +1 -1
package/frontend/dist/assets/index-C0QL3gEp.js +91 -0
package/frontend/dist/index.html +2 -2
package/frontend/dist/version.json +1 -1
package/lib/cells/routes.js +2 -2
package/lib/cli/commands.js +257 -10
package/lib/cli/doctor.js +65 -11
package/lib/cli/fleet-service.js +10 -41
package/lib/cli/init.js +30 -8
package/lib/config.js +7 -2
package/lib/fleet/builtin.js +17 -6
package/lib/fleet/cell-exec.js +165 -11
package/lib/fleet/definitions.js +1 -1
package/lib/fleet/provider.js +10 -90
package/lib/fleet/routes.js +8 -14
package/lib/fleet/runtime.js +44 -22
package/lib/nodes/commands.js +160 -19
package/lib/nodes/inventory.js +81 -0
package/lib/server.js +40 -6
package/lib/settings/routes.js +43 -23
package/lib/tmux/lifecycle.js +4 -2
package/lib/tmux/shared-server.js +60 -0
package/package.json +1 -1
package/frontend/dist/assets/index-DaFQbMHq.js +0 -93
package/lib/fleet/exec.js +0 -32
package/lib/fleet/index.js +0 -180

package/frontend/dist/index.html CHANGED Viewed

@@ -11,8 +11,8 @@
   <meta name="apple-mobile-web-app-title" content="NexusCrew" />
   <link rel="manifest" href="/manifest.json" />
   <title>NexusCrew</title>
-  <script type="module" crossorigin src="/assets/index-DaFQbMHq.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-DQbVJLji.css">
+  <script type="module" crossorigin src="/assets/index-C0QL3gEp.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-77r8nzQf.css">
 </head>
 <body>
   <div id="root"></div>

package/frontend/dist/version.json CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":"0.8.21"}
1	+ {"version":"0.8.23"}

package/lib/cells/routes.js CHANGED Viewed

@@ -17,8 +17,8 @@ function publicCells(status, instanceId, now = Date.now()) {
     if (!raw || !CELL_ID_RE.test(String(raw.cell || ''))
       || !isValidSession(raw.tmuxSession) || seen.has(raw.cell)) continue;
     seen.add(raw.cell);
-    // Provider external legacy may not expose `tmux`; an explicit false still
-    // wins, while the historical `active:true` contract remains compatible.
+    // Un `tmux:false` esplicito prevale su active:true: la directory globale non
+    // deve dichiarare ricevibile una cella senza sessione viva.
     const active = raw.active === true && raw.tmux !== false;
     cells.push({
       id: `${instanceId}:${raw.cell}`,

package/lib/cli/commands.js CHANGED Viewed

@@ -11,12 +11,14 @@ const { detectPlatform, nodeBin, repoRoot, uid } = require('./platform.js');
 const { installPath: serviceInstallPath, ensureLinuxTmuxSurvival } = require('./service.js');
 const { fleetInstallPath } = require('./fleet-service.js');
 const pidf = require('./pidfile.js');
-const { runInit } = require('./init.js');
+const { runInit, ensureFleetDefaults } = require('./init.js');
 const { rotateToken } = require('../auth/token.js');
 const urlmod = require('./url.js');
 const { doctor } = require('./doctor.js');
 const nodesStore = require('../nodes/store.js');
 const nodesTunnel = require('../nodes/tunnel.js');
+const nodesCmds = require('../nodes/commands.js');
+const peering = require('../nodes/peering.js');
 // Service/portable runtime ownership + start/stop lifecycle (Phase 3 extraction).
 const runtimeLifecycle = require('./runtime-lifecycle.js');
 const {
@@ -36,12 +38,50 @@ Usage:
   nexuscrew stop     stop the background service
   nexuscrew restart  restart the background service
   nexuscrew doctor   run local diagnostics
+  nexuscrew nodes    list and manage connected peers (use: nodes help)
   nexuscrew help     show this help
   nexuscrew version  show the installed version
-Configuration, nodes, engines, providers, models and lifecycle live in the PWA.
+Configuration, engines, models and advanced lifecycle also live in the PWA.
 NexusCrew binds only to 127.0.0.1 and automatically selects a free port.`;
+const NODES_HELP = `NexusCrew nodes — headless peer management.
+Usage:
+  nexuscrew nodes list [--direct|--network] [--json]
+  nexuscrew nodes inspect|show <name|nodeId> [--json]
+  nexuscrew nodes doctor [name|nodeId] [--json]
+  nexuscrew nodes edit <name|nodeId> [--label TEXT] [--ssh TARGET]
+                         [--ssh-port PORT] [--autostart on|off]
+                         [--visibility network|relay-only|selected]
+                         [--selected NODE_ID,...]
+  nexuscrew nodes remove <name|nodeId> --yes
+  nexuscrew nodes test|up|down|connect|disconnect|restart|reconnect <name|nodeId>
+                         [--persist]
+  nexuscrew nodes rename <name|nodeId> --label TEXT
+  nexuscrew nodes visibility <name|nodeId> network|relay-only|selected
+                         [--selected NODE_ID,...]
+  nexuscrew nodes share <name|nodeId> on|off [--json]
+  nexuscrew nodes invite --ssh TARGET [--ssh-port PORT] [--name SLUG]
+                         [--label TEXT] [--json]
+  printf '%s' "$PAIRING_URL" | nexuscrew nodes pair|join
+                         [--ssh TARGET] [--name SLUG] [--label TEXT]
+  nexuscrew nodes identity [--json]
+Pairing links are read from stdin, never from argv. Mutations honor
+NEXUSCREW_READONLY=1. Routed peers are inspect-only.
+Lifecycle semantics:
+  up          connect now and enable autostart
+  down        disconnect and disable autostart
+  disconnect  disconnect now without changing autostart
+  restart     reconnect now without changing autostart`;
+const CLI_VALUE_FLAGS = new Set([
+  'label', 'ssh', 'ssh-port', 'autostart', 'visibility', 'selected',
+  'name', 'local-label', 'identity-file',
+]);
 // valueFlags (Set|array opzionale): flag che consumano il token successivo nella
 // forma "--k v". Omesso -> comportamento storico (solo "--k" bool o "--k=v").
 function parseFlags(argv, valueFlags) {
@@ -70,6 +110,10 @@ function parseFlags(argv, valueFlags) {
 function serve(opts = {}) {
   const serverStart = opts.serverStart || require('../server.js').start;
+  // Service manager e Termux:Boot entrano direttamente da `serve`, senza
+  // passare per smartUp. Ripara solo fleet.json MANCANTE; un file invalido
+  // resta intatto e il provider continua a fallire chiuso.
+  (opts.ensureFleetDefaultsImpl || ensureFleetDefaults)(opts);
   if (opts.pidfile) {
     const pidPath = pidf.defaultPidfilePath(opts.home);
     // already-running check
@@ -410,6 +454,11 @@ async function smartUp(opts = {}) {
     initialized = true;
   }
+  // Config+token da soli non garantiscono un'installazione completa. Questo
+  // era il buco delle installazioni/migrazioni Termux che lasciava il provider
+  // disabilitato e l'editor Fleet irraggiungibile.
+  const fleetBootstrap = (opts.ensureFleetDefaultsImpl || ensureFleetDefaults)(opts);
   // 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();
@@ -423,6 +472,19 @@ async function smartUp(opts = {}) {
   let running = await probe(port, token, opts);
   let portableAttempted = false;
   let runtime = resolveRuntimeOwner({ ...opts, platform });
+  // selectProvider() viene risolto una volta allo startup. Se abbiamo creato
+  // fleet.json mentre un vecchio processo era gia' vivo, serve un restart
+  // verificato per fargli acquisire il provider builtin.
+  if (running && fleetBootstrap.created) {
+    const restarted = restartImpl({ ...opts, platform, log: quiet });
+    if (!restarted || restarted.restarted !== true) {
+      throw new Error(`fleet bootstrap completato ma restart fallito: ${(restarted && restarted.reason) || 'esito non verificato'}`);
+    }
+    running = await waitForNexusCrew(port, token, opts);
+    if (!running) throw new Error(`server non pronto dopo il bootstrap Fleet su 127.0.0.1:${port}`);
+    runtime = resolveRuntimeOwner({ ...opts, platform });
+  }
   if (!running && runtime.owner !== 'stopped') running = await waitForNexusCrew(port, token, opts);
   if (!running) {
@@ -594,10 +656,6 @@ async function runFleetBoot(opts = {}) {
   const cfg = opts.cfg || loadConfig();
   const sel = await selectProvider(cfg);
-  if (sel.mode === 'external') {
-    log('fleet-boot: boot gestito dal fleet esterno (nessuna azione del companion)');
-    return { code: 0, mode: 'external' };
-  }
   if (sel.mode !== 'builtin' || !sel.fleet || !sel.fleet.available) {
     // disabled (o builtin unavailable): niente da avviare, non e' un errore.
     log(`fleet-boot: nessun boot (provider ${sel.mode}${sel.reason ? ' — ' + sel.reason : ''})`);
@@ -623,6 +681,193 @@ function dispatchFleetBoot(opts) {
   return { code: 0, keepAlive: true }; // il processo resta vivo finche' runFleetBoot non chiama exit()
 }
+function boolFlag(value, name) {
+  if (value === true || value === 'on' || value === 'true' || value === '1') return true;
+  if (value === 'off' || value === 'false' || value === '0') return false;
+  throw new Error(`${name}: atteso on|off`);
+}
+function readPairingStdin(opts = {}) {
+  const clean = (value) => String(value || '').trim().replace(/[\r\n]/g, '');
+  if (typeof opts.stdin === 'function') return clean(opts.stdin());
+  if (typeof opts.stdin === 'string') return clean(opts.stdin);
+  if (process.stdin.isTTY) return '';
+  try { return clean(fs.readFileSync(0, 'utf8')); } catch (_) { return ''; }
+}
+async function localSettingsRequest(pathname, body, opts = {}) {
+  const method = opts.method || 'POST';
+  if (typeof opts.localApiImpl === 'function') return opts.localApiImpl(pathname, body, { method });
+  const up = await (opts.smartUpImpl || smartUp)({
+    ...opts, noOpen: true, log: opts.lifecycleLog || (() => {}),
+  });
+  const { tokenPath } = urlmod.resolvePaths(opts);
+  const token = urlmod.readToken(tokenPath);
+  if (!token) throw new Error('token locale assente: inizializza NexusCrew');
+  const fetchImpl = opts.fetchImpl || globalThis.fetch;
+  if (typeof fetchImpl !== 'function') throw new Error('fetch non disponibile');
+  const response = await fetchImpl(`http://127.0.0.1:${up.port || urlmod.loadPort(opts)}${pathname}`, {
+    method,
+    headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+    body: JSON.stringify(body || {}),
+  });
+  const value = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    const error = new Error(value.error || `HTTP ${response.status}`);
+    error.status = response.status;
+    error.data = value;
+    throw error;
+  }
+  return value;
+}
+async function dispatchNodes(rest, flags, opts = {}) {
+  const log = opts.log || console.log;
+  const sub = rest[1] || 'list';
+  const ref = rest[2];
+  if (sub === 'help' || sub === '--help' || sub === '-h') { log(NODES_HELP); return { code: 0 }; }
+  if (sub === 'list') return { code: nodesCmds.nodesList({
+    ...opts, log, json: flags.json === true, direct: flags.direct === true,
+  }).code };
+  if (sub === 'inspect' || sub === 'show') return { code: nodesCmds.nodesInspect({ ...opts, log, ref, json: flags.json === true }).code };
+  if (sub === 'doctor') {
+    const view = nodesCmds.loadPeerInventory(opts);
+    let peers = view.nodes;
+    if (ref) {
+      const inspected = nodesCmds.nodesInspect({ ...opts, log: () => {}, ref });
+      if (inspected.code !== 0) { log(`nodes doctor: nodo sconosciuto "${ref}"`); return { code: 1 }; }
+      peers = [inspected.peer];
+    }
+    const checks = [];
+    for (const peer of peers) {
+      if (peer.kind === 'transitive') {
+        checks.push({ name: peer.name, nodeId: peer.nodeId, ok: true, result: 'inspect-only', route: peer.route });
+        continue;
+      }
+      const lines = [];
+      const result = await nodesCmds.nodesTest({ ...opts, log: (line) => lines.push(String(line)), ref: peer.nodeId || peer.name });
+      checks.push({
+        name: peer.name, nodeId: peer.nodeId || null, ok: result.code === 0,
+        result: result.result || (result.code === 0 ? 'ok' : 'failed'),
+        detail: lines[lines.length - 1] || '',
+      });
+    }
+    if (flags.json === true) log(JSON.stringify({ nodeId: view.nodeId, checks }, null, 2));
+    else if (checks.length === 0) log('nodes doctor: nessun peer diretto');
+    else for (const check of checks) log(`${check.name}: ${check.ok ? 'OK' : 'KO'} — ${check.result}${check.detail ? ` · ${check.detail}` : ''}`);
+    return { code: checks.some((check) => !check.ok) ? 1 : 0 };
+  }
+  if (sub === 'identity') {
+    const view = nodesCmds.loadPeerInventory(opts);
+    const value = { nodeId: view.nodeId };
+    if (flags.json === true) log(JSON.stringify(value, null, 2));
+    else log(`nodeId: ${value.nodeId || '(store non inizializzato)'}`);
+    return { code: value.nodeId ? 0 : 1 };
+  }
+  if (sub === 'edit') {
+    const patch = {};
+    if (flags.label !== undefined) patch.label = flags.label;
+    if (flags.ssh !== undefined) patch.ssh = flags.ssh;
+    if (flags['ssh-port'] !== undefined) patch.sshPort = Number(flags['ssh-port']);
+    if (flags.autostart !== undefined) {
+      try { patch.autostart = boolFlag(flags.autostart, '--autostart'); }
+      catch (e) { log(e.message); return { code: 1 }; }
+    }
+    if (flags.visibility !== undefined) patch.visibility = flags.visibility;
+    if (flags.selected !== undefined) patch.selected = String(flags.selected).split(',').map((x) => x.trim()).filter(Boolean);
+    return { code: nodesCmds.nodesEdit({ ...opts, log, ref, patch }).code };
+  }
+  if (sub === 'rename') {
+    if (flags.label === undefined) { log('nodes rename: --label TEXT obbligatorio'); return { code: 1 }; }
+    return { code: nodesCmds.nodesEdit({ ...opts, log, ref, patch: { label: flags.label } }).code };
+  }
+  if (sub === 'visibility') {
+    const visibility = rest[3] || flags.visibility;
+    const selected = flags.selected === undefined ? []
+      : String(flags.selected).split(',').map((value) => value.trim()).filter(Boolean);
+    return { code: nodesCmds.nodesEdit({ ...opts, log, ref, patch: { visibility, selected } }).code };
+  }
+  if (sub === 'remove') {
+    if (flags.yes !== true) { log('nodes remove: conferma richiesta con --yes'); return { code: 1 }; }
+    return { code: nodesCmds.nodesRemove({ ...opts, log, ref }).code };
+  }
+  if (sub === 'test') return { code: (await nodesCmds.nodesTest({ ...opts, log, ref })).code };
+  if (['up', 'down', 'connect', 'disconnect', 'restart', 'reconnect'].includes(sub)) {
+    const fn = sub === 'up' || sub === 'connect' ? nodesCmds.nodesUp
+      : sub === 'restart' || sub === 'reconnect' ? nodesCmds.nodesRestart : nodesCmds.nodesDown;
+    const persistAutostart = sub === 'up' || sub === 'down' || flags.persist === true;
+    return { code: fn({ ...opts, log, ref, persistAutostart }).code };
+  }
+  if (sub === 'share') {
+    const inspected = nodesCmds.nodesInspect({ ...opts, log: () => {}, ref });
+    if (inspected.code !== 0 || inspected.peer.kind !== 'direct') {
+      log(`nodes share: peer diretto sconosciuto "${ref || ''}"`); return { code: 1 };
+    }
+    let shared;
+    try { shared = boolFlag(rest[3], 'nodes share'); }
+    catch (error) { log(error.message); return { code: 1 }; }
+    try {
+      const result = await localSettingsRequest(
+        `/api/settings/nodes/${encodeURIComponent(inspected.peer.name)}/share`,
+        { shared }, { ...opts, method: 'PATCH' },
+      );
+      if (flags.json === true) log(JSON.stringify(result, null, 2));
+      else log(`nodes share [${inspected.peer.name}]: ${shared ? 'on' : 'off'}`);
+      return { code: 0 };
+    } catch (error) { log(`nodes share: ${error.message}`); return { code: 1 }; }
+  }
+  if (sub === 'invite') {
+    const body = {
+      ...(flags.ssh !== undefined ? { ssh: flags.ssh } : {}),
+      ...(flags['ssh-port'] !== undefined ? { sshPort: Number(flags['ssh-port']) } : {}),
+      ...(flags.name !== undefined ? { name: flags.name } : {}),
+      ...(flags.label !== undefined ? { label: flags.label } : {}),
+    };
+    if (!body.ssh) { log('nodes invite: --ssh TARGET obbligatorio'); return { code: 1 }; }
+    try {
+      const result = await localSettingsRequest('/api/settings/peering/invite', body, opts);
+      if (flags.json === true) log(JSON.stringify(result, null, 2));
+      else { log(result.pairingUrl); log(`scade: ${new Date(result.expiresAt).toISOString()}`); }
+      return { code: 0 };
+    } catch (e) { log(`nodes invite: ${e.message}`); return { code: 1 }; }
+  }
+  if (sub === 'pair' || sub === 'join') {
+    const pairingUrl = readPairingStdin(opts);
+    if (!pairingUrl) {
+      log("nodes pair: passa il link via stdin (es. printf '%s' \"$PAIRING_URL\" | nexuscrew nodes pair)");
+      return { code: 1 };
+    }
+    const decoded = peering.parsePairingUrl(pairingUrl);
+    if (!decoded) { log('nodes pair: link non valido o corrotto'); return { code: 1 }; }
+    const body = {
+      pairingUrl,
+      name: flags.name || decoded.name,
+      ssh: flags.ssh || decoded.ssh,
+      ...(flags.label !== undefined || decoded.label ? { label: flags.label || decoded.label } : {}),
+      ...(flags['ssh-port'] !== undefined || decoded.sshPort ? { sshPort: Number(flags['ssh-port'] || decoded.sshPort) } : {}),
+      ...(flags['local-label'] !== undefined ? { localLabel: flags['local-label'] } : {}),
+      ...(flags['identity-file'] !== undefined ? { identityFile: flags['identity-file'] } : {}),
+    };
+    if (!body.name || !body.ssh) {
+      log('nodes pair: il link non contiene name/ssh; fornisci --name e --ssh');
+      return { code: 1 };
+    }
+    try {
+      const result = await localSettingsRequest('/api/settings/nodes/pair', body, opts);
+      if (flags.json === true) log(JSON.stringify(result, null, 2));
+      else log(`nodes pair: collegato "${result.name}" (${result.instanceId})`);
+      return { code: 0 };
+    } catch (e) {
+      const stage = e.data && e.data.stage ? ` [${e.data.stage}]` : '';
+      const hint = e.data && e.data.hint ? ` · ${e.data.hint}` : '';
+      log(`nodes pair${stage}: ${e.message}${hint}`);
+      return { code: 1 };
+    }
+  }
+  log(`comando nodes sconosciuto: ${sub}\n\n${NODES_HELP}`);
+  return { code: 1 };
+}
 function dispatch(argv, opts = {}) {
   const log = opts.log || console.log;
   if (argv.length === 1 && (argv[0] === '--help' || argv[0] === '-h')) {
@@ -633,7 +878,7 @@ function dispatch(argv, opts = {}) {
     log(require('../../package.json').version);
     return { code: 0 };
   }
-  const { flags, rest } = parseFlags(argv);
+  const { flags, rest } = parseFlags(argv, CLI_VALUE_FLAGS);
   const cmd = rest[0];
   // help esplicito
@@ -673,9 +918,10 @@ function dispatch(argv, opts = {}) {
     return { code: 0 };
   }
   if (cmd === 'status') {
-    status({ ...opts, log });
+    status({ ...opts, log, json: flags.json === true });
     return { code: 0 };
   }
+  if (cmd === 'nodes' || cmd === 'peers') return dispatchNodes(rest, flags, opts);
   if (cmd === 'stop') {
     const result = stop({ ...opts, log });
     return { code: result.stopped || ['not running', 'stale pidfile'].includes(result.reason) ? 0 : 1 };
@@ -687,10 +933,11 @@ function dispatch(argv, opts = {}) {
   // 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 });
+    serve({ ...opts, pidfile: flags.pidfile, serverStart: opts.serverStart });
     return { code: 0, keepAlive: true }; // server.listen tiene il processo vivo; non exit
   }
   if (cmd === 'doctor') {
+    if (flags.peers === true) return dispatchNodes(['nodes', 'doctor'], flags, opts);
     const r = doctor({ ...opts, log });
     return { code: r.code };
   }
@@ -709,7 +956,7 @@ function dispatch(argv, opts = {}) {
 }
 module.exports = {
-  dispatch, serve, start, stop, status, parseFlags, HELP,
+  dispatch, dispatchNodes, serve, start, stop, status, parseFlags, HELP, NODES_HELP,
   smartUp, url, tokenRotate, logs, doctor, update, restart,
   portAvailable, findAvailablePort, probeNexusCrew, waitForNexusCrew, openPwa, startPortable, wizardComplete,
   servicePinsLegacyPort,

package/lib/cli/doctor.js CHANGED Viewed

@@ -13,6 +13,7 @@ const { detectPlatform, uid } = require('./platform.js');
 const { installPath } = require('./service.js');
 const { resolvePaths } = require('./url.js');
 const { commandExists } = require('./path.js');
+const { loadDefinitions } = require('../fleet/definitions.js');
 function nodeMajor() {
   return parseInt(String(process.versions.node).split('.')[0], 10);
@@ -111,18 +112,38 @@ function checkTmuxSurvival(platform, execImpl) {
   if (platform !== 'linux') {
     return { name: 'tmux survival on service restart', ok: true, detail: `${platform}: systemd cgroup non applicabile` };
   }
-  try {
-    const value = String(execImpl('systemctl', [
-      '--user', 'show', 'nexuscrew.service', '--property=KillMode', '--value',
-    ], { encoding: 'utf8' }) || '').trim();
-    const ok = value === 'process';
-    return {
-      name: 'tmux survival on service restart', ok,
-      detail: ok ? 'KillMode=process' : `KillMode=${value || 'sconosciuto'} (restart NexusCrew puo terminare tmux)`,
-    };
-  } catch (error) {
-    return { name: 'tmux survival on service restart', ok: false, detail: `KillMode non verificabile: ${error.message || error}` };
+  const units = ['nexuscrew.service', 'nexuscrew-fleet.service'];
+  const results = [];
+  for (const unit of units) {
+    try {
+      const loadState = String(execImpl('systemctl', [
+        '--user', 'show', unit, '--property=LoadState', '--value',
+      ], { encoding: 'utf8' }) || '').trim();
+      if (loadState === 'not-found') {
+        results.push({ unit, skipped: true, detail: 'non installata' });
+        continue;
+      }
+      const value = String(execImpl('systemctl', [
+        '--user', 'show', unit, '--property=KillMode', '--value',
+      ], { encoding: 'utf8' }) || '').trim();
+      results.push({ unit, ok: value === 'process', value: value || 'sconosciuto' });
+    } catch (error) {
+      if (/not[ -]?found|could not be found|not loaded/i.test(String(error && error.message || error))) {
+        results.push({ unit, skipped: true, detail: 'non installata' });
+      } else {
+        results.push({ unit, ok: false, value: `non verificabile: ${error.message || error}` });
+      }
+    }
   }
+  const checked = results.filter((result) => !result.skipped);
+  const ok = checked.length > 0 && checked.every((result) => result.ok);
+  const detail = results.map((result) => result.skipped
+    ? `${result.unit}: ${result.detail}`
+    : `${result.unit}: KillMode=${result.value}`).join(' · ');
+  return {
+    name: 'tmux survival on service restart', ok,
+    detail: ok ? detail : `${detail} (restart/oneshot puo terminare tmux)`,
+  };
 }
 // ssh client presente su PATH: prerequisito dei tunnel multi-node (design §4).
@@ -165,6 +186,34 @@ function checkTokenPerms(tokenPath) {
   }
 }
+function checkFleetDefinitions(home, fleetDefsPath, enabled = true) {
+  const target = fleetDefsPath || path.join(home, '.nexuscrew', 'fleet.json');
+  if (!enabled) {
+    return { name: 'Fleet builtin definitions', ok: true, warn: true, detail: 'disabilitata intenzionalmente' };
+  }
+  let st;
+  try {
+    st = fs.lstatSync(target);
+  } catch (e) {
+    return {
+      name: 'Fleet builtin definitions', ok: false,
+      detail: e.code === 'ENOENT' ? `fleet.json assente (${target}); esegui nexuscrew per riparare` : e.message,
+    };
+  }
+  if (!st.isFile() || st.isSymbolicLink()) {
+    return { name: 'Fleet builtin definitions', ok: false, detail: `target non sicuro o non regolare (${target})` };
+  }
+  const defs = loadDefinitions(target);
+  if (!defs) {
+    return { name: 'Fleet builtin definitions', ok: false, detail: `fleet.json invalido (${target}); preservato, non sovrascritto` };
+  }
+  const mode = st.mode & 0o777;
+  return {
+    name: 'Fleet builtin definitions', ok: true, warn: mode !== 0o600,
+    detail: `${defs.engines.length} engine · ${defs.cells.length} celle · mode 0${mode.toString(8)}`,
+  };
+}
 // Esegue tutti i check. Seam iniettabili per test (platform, home, execImpl, ptyLoad).
 function doctor(opts = {}) {
   const platform = opts.platform || detectPlatform();
@@ -175,6 +224,9 @@ function doctor(opts = {}) {
   const ptyLoad = opts.ptyLoad || (() => require('../pty/provider.js').loadPty());
   const existsImpl = opts.commandExists || commandExists;
   const { tokenPath } = resolvePaths(opts);
+  const fleetEnabled = opts.fleetEnabled !== false
+    && opts.builtinEnabled !== false
+    && process.env.NEXUSCREW_FLEET !== '0';
   const checks = [
     checkNode(),
@@ -185,6 +237,7 @@ function doctor(opts = {}) {
     checkUserLinger(platform, execImpl, uidVal),
     checkTmuxSurvival(platform, execImpl),
     checkTokenPerms(tokenPath),
+    checkFleetDefinitions(home, opts.fleetDefsPath, fleetEnabled),
     checkSshClient(existsImpl),
     checkAutossh(existsImpl),
     checkSshPermitlisten(opts.sshVersion),
@@ -202,6 +255,7 @@ function doctor(opts = {}) {
 module.exports = {
   doctor, nodeMajor,
   checkNode, checkTmux, checkPty, checkService, checkBoot, checkTokenPerms,
+  checkFleetDefinitions,
   checkTmuxSurvival, checkUserLinger,
   checkSshClient, checkAutossh, checkSshPermitlisten,
 };

package/lib/cli/fleet-service.js CHANGED Viewed

@@ -58,6 +58,9 @@ After=network-online.target
 [Service]
 Type=oneshot
+# fleet-boot may be the process that creates the shared tmux server. Keep
+# systemd from reaping that server and its cells when this oneshot exits.
+KillMode=process
 WorkingDirectory=${repo}
 Environment=PATH=${nodeDir}:/usr/local/bin:/usr/bin:/bin
 ExecStart=${node} ${entry} fleet-boot
@@ -164,63 +167,29 @@ function migrationGate(opts = {}) {
     return {
       blocked: true,
       units,
-      remediation: 'disabilita le unit legacy cloud-cell@*.service (systemctl --user disable "cloud-cell@*") o usa il fleet esterno; il companion nexuscrew-fleet.service non va installato per evitare doppio boot',
+      remediation: 'esegui il backup, poi disabilita le unit legacy cloud-cell@*.service prima di abilitare nexuscrew-fleet.service; non devono esistere due proprietari del boot',
     };
   }
   return { blocked: false, units: [], reason: 'nessuna unit cloud-cell@*.service abilitata' };
 }
 // --- selectProviderModeSync — resolver SINCRONO del mode del provider ---
-// Speculare alla logica di selectProvider (lib/fleet/provider.js) ma SENZA spawn/await.
-// Necessario: runInit e' sync (bin/nexuscrew.js chiama process.exit subito dopo dispatch
-// per 'init'; selectProvider e' async e non sopravvive al process.exit). E' il default
-// del seam opts.selectProvider del companion (iniettabile per i test).
-//
-// Divergenza documentata vs selectProvider: la responsivita' del fleet esterno
-// (status --json) richiederebbe spawn async; qui un fleetBin FIDATO (binTrusted, sync)
-// -> external. Scelta CONSERVATIVA sicura (no-doppio-boot, §9b): se c'e' un fleet
-// esterno fidato configurato, NON installiamo il companion builtin.
-// Ritorna {mode, reason} con mode in 'external' | 'builtin' | 'disabled'.
+// Speculare alla logica builtin-only di lib/fleet/provider.js ma sincrono per
+// runInit.  Il binario legacy `fleet` non viene scoperto né eseguito.
 function selectProviderModeSync(cfg = {}) {
   if (cfg.fleetEnabled === false) {
     return { mode: 'disabled', reason: 'fleet disabilitato (fleetEnabled=false)' };
   }
-  const forced = (cfg.fleetProvider || process.env.NEXUSCREW_FLEET_PROVIDER || '').toLowerCase() || null;
-  // external: binario fidato (regular file, exec, non world-writable, no symlink).
-  // lazy-require: niente costo/accoppiamento all'import del modulo (usato solo dal companion).
-  const { binTrusted, externalFleetCandidates } = require('../fleet/index.js'); // sync (audit F3)
-  // Deve usare lo stesso insieme di path del resolver runtime asincrono. In
-  // particolare Termux installa normalmente `fleet` in $PREFIX/bin: se init
-  // guardasse soltanto cfg.fleetBin potrebbe installare il companion builtin e
-  // il runtime scegliere poi l'external, creando due proprietari del boot.
-  const trustedExternal = externalFleetCandidates(cfg).find((candidate) => binTrusted(candidate)) || null;
-  const extTrusted = !!trustedExternal;
+  if (cfg.builtinEnabled === false) return { mode: 'disabled', reason: 'fleet builtin disabilitata' };
   // builtin: fleet.json valido (loadDefinitions e' sync; garbage -> null = fail-closed).
   const { loadDefinitions } = require('../fleet/definitions.js');
   const home = cfg.home || os.homedir();
   const defsPath = cfg.fleetDefsPath || path.join(home, '.nexuscrew', 'fleet.json');
-  const builtinAvail = cfg.builtinEnabled !== false ? !!loadDefinitions(defsPath) : false;
-  // forced: fail-closed se il richiesto non e' disponibile (§9g: niente auto-fallback).
-  if (forced === 'external') {
-    return extTrusted
-      ? { mode: 'external', reason: 'forced external (binario fidato)' }
-      : { mode: 'disabled', reason: 'fail-closed: forced external non fidato (§9g)' };
-  }
-  if (forced === 'builtin') {
-    return builtinAvail
-      ? { mode: 'builtin', reason: 'forced builtin (fleet.json valido)' }
-      : { mode: 'disabled', reason: 'fail-closed: forced builtin ma fleet.json invalido/mancante (§9g)' };
-  }
-  if (forced === 'disabled') return { mode: 'disabled', reason: 'forced disabled' };
-  if (forced) return { mode: 'disabled', reason: `fail-closed: provider forzato "${forced}" non riconosciuto` };
+  const builtinAvail = !!loadDefinitions(defsPath);
-  // auto: external fidato vince (no-doppio-boot), poi builtin, poi disabled.
-  if (extTrusted) return { mode: 'external', reason: `auto: external fidato configurato (${trustedExternal}; skip companion)` };
-  if (builtinAvail) return { mode: 'builtin', reason: 'auto: builtin (fleet.json valido)' };
-  return { mode: 'disabled', reason: 'auto: nessun provider disponibile (no external fidato, no fleet.json)' };
+  if (builtinAvail) return { mode: 'builtin', reason: 'NexusCrew builtin (fleet.json valido)' };
+  return { mode: 'disabled', reason: 'fleet.json invalido o mancante (fail-closed)' };
 }
 // --- Install (speculare a installService di lib/cli/service.js) ---

package/lib/cli/init.js CHANGED Viewed

@@ -47,6 +47,30 @@ function writeConfigAtomic(configPath, value) {
   }
 }
+// Bootstrap/migration idempotente degli artefatti Fleet. Un file presente non
+// viene MAI riscritto qui: se e' invalido, il provider e doctor devono restare
+// fail-closed e mostrarne la causa. Questo helper copre anche installazioni
+// parziali in cui config+token esistono ma fleet.json non fu mai creato.
+function ensureFleetDefaults(opts = {}) {
+  const home = opts.home || os.homedir();
+  const configDir = opts.configDir || path.join(home, '.nexuscrew');
+  const fleetDefsPath = opts.fleetDefsPath || path.join(configDir, 'fleet.json');
+  const enabled = opts.fleetEnabled !== false
+    && opts.builtinEnabled !== false
+    && process.env.NEXUSCREW_FLEET !== '0';
+  if (!enabled) return { path: fleetDefsPath, created: false, enabled: false };
+  try {
+    fs.lstatSync(fleetDefsPath);
+    return { path: fleetDefsPath, created: false, enabled: true };
+  } catch (e) {
+    if (e.code !== 'ENOENT') throw e;
+  }
+  writeFleet(fleetDefsPath, defaultDefinitions());
+  return { path: fleetDefsPath, created: true, enabled: true };
+}
 // Migration rule (B2): se non c'è config.json, parse la porta dal service file esistente.
 function readExistingPort(platform, home, installPathOverride) {
   const p = installPathOverride || svcInstallPath(platform, home);
@@ -118,15 +142,15 @@ function runInit(opts = {}) {
   // Fleet app defaults: soltanto i quattro client nativi. Provider cloud/Z.AI sono
   // disponibili nel catalogo managed ma vanno aggiunti esplicitamente.
   const fleetDefsPath = opts.fleetDefsPath || path.join(configDir, 'fleet.json');
-  if (!dryRun && !fs.existsSync(fleetDefsPath)) {
+  if (!dryRun) {
     try {
-      writeFleet(fleetDefsPath, defaultDefinitions());
-      actions.push(`created fleet defaults ${fleetDefsPath} (claude.native, codex.native, codex-vl.native, pi.native)`);
+      const fleetBootstrap = ensureFleetDefaults({ ...opts, home, configDir, fleetDefsPath });
+      if (!fleetBootstrap.enabled) actions.push('fleet defaults: disabilitati intenzionalmente');
+      else if (fleetBootstrap.created) actions.push(`created fleet defaults ${fleetDefsPath} (claude.native, codex.native, codex-vl.native, pi.native)`);
+      else actions.push(`preserved fleet definitions ${fleetDefsPath}`);
     } catch (e) {
       actions.push(`WARN: fleet defaults non creati: ${e.message}`);
     }
-  } else if (!dryRun) {
-    actions.push(`preserved fleet definitions ${fleetDefsPath}`);
   }
   if (!port) port = 41820;
@@ -219,8 +243,6 @@ function runInit(opts = {}) {
       const fleetCfg = opts.fleetCfg || {
         home,
         fleetEnabled: opts.fleetEnabled !== undefined ? opts.fleetEnabled : true,
-        fleetBin: opts.fleetBin || path.join(home, '.local', 'bin', 'fleet'),
-        fleetProvider: opts.fleetProvider || process.env.NEXUSCREW_FLEET_PROVIDER,
         builtinEnabled: opts.builtinEnabled,
         fleetDefsPath,
       };
@@ -284,4 +306,4 @@ function runInit(opts = {}) {
   return { platform, port, token, url: urlWithToken, actions, tmuxOk, dryRun };
 }
-module.exports = { runInit, readExistingPort, haveTmux, nodeMajor, writeConfigAtomic };
+module.exports = { runInit, readExistingPort, haveTmux, nodeMajor, writeConfigAtomic, ensureFleetDefaults };