@mmmbuto/nexuscrew 0.8.52-rc.9 → 0.8.53

package/lib/cells/scope.js

@@ -0,0 +1,144 @@
+'use strict';
+// lib/cells/scope.js — quali celle di QUESTO nodo un peer federato puo' vedere.
+//
+// Gemello di lib/audio/acl.js, e per le stesse ragioni:
+//   * la sorgente della decisione e' il node store locale, mai il corpo della
+//     richiesta. Un peer non dichiara il proprio scope: lo subisce.
+//   * l'identita' arriva dalla catena `visited` che costruisce il server
+//     (controlledVisited), non da un campo dichiarato.
+//
+// Due invarianti che una versione semplificata romperebbe in silenzio:
+//
+//   1. In multi-hop lo scope e' l'INTERSEZIONE fra chi consegna e chi origina.
+//      `canTransit` autorizza il transito, non l'accesso: un peer B puo'
+//      instradare una richiesta di C. Guardare solo B lascerebbe C ereditare i
+//      permessi di B. lib/audio/acl.js risolve lo stesso caso controllando
+//      entrambi, e qui va replicato invece che semplificato.
+//   2. Una sessione tmux e' concessa solo se lo e' la CELLA a cui appartiene, e
+//      una sessione che non appartiene a nessuna cella non e' "libera": e'
+//      fuori scope. Altrimenti basterebbe una tmux creata a mano per aggirare
+//      il permesso — e `/ws` attacca proprio per nome di sessione.
+//
+// Il permesso e' indicizzato per `nodeId`, non per `name`: il name e' uno slug
+// locale rinominabile, il nodeId e' l'identita' stabile provata dal pairing.
+const nodesStore = require('../nodes/store.js');
+
+// Scope di un singolo nodo, normalizzato. `all` non elenca nulla di proposito:
+// una lista che significa "tutte" invecchierebbe a ogni cella nuova.
+function scopeOf(node) {
+  if (!node) return { mode: 'none', cells: new Set() };
+  const mode = node.cellVisibility || 'all';
+  if (mode === 'all') return { mode: 'all', cells: null };
+  if (mode === 'none') return { mode: 'none', cells: new Set() };
+  return { mode: 'selected', cells: new Set(Array.isArray(node.cells) ? node.cells : []) };
+}
+
+// Intersezione di due scope. `all` e' l'elemento neutro; `none` assorbe.
+function intersect(a, b) {
+  if (a.mode === 'none' || b.mode === 'none') return { mode: 'none', cells: new Set() };
+  if (a.mode === 'all') return b;
+  if (b.mode === 'all') return a;
+  return { mode: 'selected', cells: new Set([...a.cells].filter((c) => b.cells.has(c))) };
+}
+
+function findByNodeId(st, nodeId) {
+  if (!st || !Array.isArray(st.nodes) || !nodeId) return null;
+  return st.nodes.find((n) => n && n.nodeId === nodeId) || null;
+}
+
+// createCellScope(): deps esplicite, nessun accesso globale.
+//   nodesPath       percorso del node store
+//   loadStoreImpl   iniettabile nei test
+//   cellForSession  mappa tmuxSession -> id cella (null se non e' di una cella)
+function createCellScope({ nodesPath, loadStoreImpl = nodesStore.loadStore, cellForSession = () => null } = {}) {
+  // Scope "tutto", usato dal percorso locale: il proprietario della macchina
+  // non si limita da solo, e questo modulo non e' il posto dove decidere
+  // altrimenti.
+  function openScope() {
+    return buildApi({ mode: 'all', cells: null });
+  }
+
+  function buildApi(resolved, localNodeId = null) {
+    const allowsCell = (cell) => {
+      if (resolved.mode === 'all') return true;
+      if (resolved.mode === 'none') return false;
+      return typeof cell === 'string' && resolved.cells.has(cell);
+    };
+    const allowsSession = (session) => {
+      if (resolved.mode === 'all') return true;
+      const cell = cellForSession(session);
+      // Nessuna cella dietro la sessione => fuori scope. Vedi invariante 2.
+      if (!cell) return false;
+      return allowsCell(cell);
+    };
+    // Un tile di deck che punta a un ALTRO nodo non e' una cella di questo
+    // hub: lo scope celle governa le celle locali, e la topologia ha gia' le
+    // sue regole (canTransit, allowlist federata). Quando pero' non sappiamo
+    // chi siamo, un `ownerId` non confrontabile si tratta come LOCALE: e' il
+    // verso fail-closed, perche' l'errore costa un tile in meno invece di un
+    // nome di cella in piu'.
+    const tileIsRemote = (tile) => {
+      if (!tile || typeof tile !== 'object') return false;
+      if (typeof tile.node === 'string' && tile.node) return true;
+      if (typeof tile.ownerId === 'string' && tile.ownerId) {
+        return localNodeId ? tile.ownerId !== localNodeId : false;
+      }
+      return false;
+    };
+    return {
+      mode: resolved.mode,
+      cells: resolved.cells ? [...resolved.cells] : null,
+      allowsCell,
+      allowsSession,
+      allowsTile: (tile) => tileIsRemote(tile) || allowsSession(tile && tile.session),
+      // Filtri: gli elenchi si restringono con lo STESSO predicato che decide
+      // le azioni. Due implementazioni divergenti sarebbero un bug latente.
+      filterCells: (list) => (Array.isArray(list) ? list.filter((c) => allowsCell(c && (c.cell ?? c.id))) : []),
+      filterSessions: (list) => (Array.isArray(list) ? list.filter((s) => allowsSession(s && (s.name ?? s.tmuxSession))) : []),
+    };
+  }
+
+  // resolve({trust, visited}) -> api dello scope.
+  //   trust 'local-bridge' (o assente e non federato) : nessuna restrizione
+  //   trust 'federated'                                : intersezione consegnante ∩ origine
+  function resolve({ trust, visited } = {}) {
+    if (trust !== 'federated') return openScope();
+    const chain = Array.isArray(visited) ? visited : [];
+    // Serve almeno origine + questo nodo. Una catena piu' corta non identifica
+    // nessun peer: fail-closed.
+    if (chain.length < 2) return buildApi({ mode: 'none', cells: new Set() });
+
+    let st;
+    try { st = loadStoreImpl(nodesPath); } catch (_) { st = null; }
+    if (!st) return buildApi({ mode: 'none', cells: new Set() });
+
+    const deliveringId = chain[chain.length - 2];
+    const originId = chain[0];
+    // Il CONSEGNANTE deve essere un mio peer: mi ha consegnato la richiesta
+    // autenticandosi. Se non lo trovo nello store, fail-closed.
+    const delivering = scopeOf(findByNodeId(st, deliveringId));
+    // L'ORIGINE no. Un peer transitivo arriva attraverso un hub che io ho
+    // autorizzato a instradare, e non ho alcun motivo di conoscerlo: e' il caso
+    // normale di una rete a tre nodi (A chiede a C passando per B).
+    //
+    // Trattare un'origine sconosciuta come `none` sembrava prudente ed era
+    // invece una porta chiusa in faccia al traffico legittimo: nella rete reale
+    // il terzo nodo smetteva di vedere QUALSIASI cella, senza errore, appena
+    // questo codice e' arrivato sui peer. Lo scope celle governa i MIEI peer
+    // diretti; chi non e' mio non ha una restrizione mia da subire.
+    //
+    // Non e' un ampliamento: `all` e' l'elemento neutro dell'intersezione, e la
+    // restrizione del consegnante — che e' mio e che ho configurato io —
+    // continua a valere per intero. L'invariante resta: un'origine che E' nel
+    // mio store porta con se' la propria restrizione anche in multi-hop.
+    const originNode = originId === deliveringId ? null : findByNodeId(st, originId);
+    const origin = originId === deliveringId
+      ? delivering
+      : (originNode ? scopeOf(originNode) : { mode: 'all', cells: null });
+    return buildApi(intersect(delivering, origin), st.nodeId || null);
+  }
+
+  return { resolve };
+}
+
+module.exports = { createCellScope, scopeOf, intersect };

package/lib/cli/commands.js

@@ -7,6 +7,7 @@ const { execFileSync, spawn } = require('node:child_process');
 const fs = require('node:fs');
 const path = require('node:path');
 const net = require('node:net');
+const crypto = require('node:crypto');
 const { detectPlatform, nodeBin, repoRoot, uid } = require('./platform.js');
 const { installPath: serviceInstallPath, ensureLinuxTmuxSurvival } = require('./service.js');
 const { fleetInstallPath } = require('./fleet-service.js');
@@ -37,7 +38,8 @@ Usage:
   nexuscrew boot     enable startup at boot (use: boot off|status)
   nexuscrew status   show service, port, roles and node status
   nexuscrew stop     stop the background service
-  nexuscrew restart  restart the background service
+  nexuscrew restart  restart the background service (verifies it came back)
+  nexuscrew autoupdate  turn automatic updates on or off (use: autoupdate on|off|status)
   nexuscrew doctor   run local diagnostics
   nexuscrew nodes    list and manage connected peers (use: nodes help)
   nexuscrew help     show this help
@@ -61,6 +63,7 @@ Usage:
                          [--persist]
   nexuscrew nodes rename <name|nodeId> --label TEXT
   nexuscrew nodes visibility <name|nodeId> network|relay-only|selected
+  nexuscrew nodes cells <name|nodeId> all|none|Cella1,Cella2
                          [--selected NODE_ID,...]
   nexuscrew nodes share <name|nodeId> on|off [--json]
   nexuscrew nodes invite --ssh TARGET [--ssh-port PORT] [--name SLUG]
@@ -543,6 +546,25 @@ async function probeNexusCrew(port, token, opts = {}) {
   } catch (_) { return false; }
 }
 
+// probeNexusCrew restituisce un BOOLEANO e collassa ogni non-200 su `false`:
+// per i suoi molti chiamanti va bene, e cambiarne il contratto ripercuoterebbe
+// ovunque. Ma «non risponde» e «risponde 401» sono due cose opposte — un 401
+// dice che il servizio E' IN PIEDI e che il token locale non vale — e chi deve
+// spiegare un riavvio ha bisogno di distinguerle, altrimenti dichiara fallito
+// un riavvio riuscito e manda a cercare un processo morto che e' vivo.
+// Rilievo dell'audit: il caso token-assente era gia' coperto, questo no.
+async function probeNexusCrewStatus(port, token, opts = {}) {
+  const fetchImpl = opts.fetchImpl || globalThis.fetch;
+  if (typeof fetchImpl !== 'function') return null;
+  try {
+    const r = await fetchImpl(`http://127.0.0.1:${port}/api/config`, {
+      headers: { authorization: `Bearer ${token || ''}` },
+      signal: AbortSignal.timeout?.(700),
+    });
+    return r.status;
+  } catch (_) { return null; } // nessuna risposta: e' un altro guasto
+}
+
 async function waitForNexusCrew(port, token, opts = {}) {
   const probe = opts.probeImpl || probeNexusCrew;
   const attempts = opts.waitAttempts === undefined ? 30 : opts.waitAttempts;
@@ -810,6 +832,113 @@ function logs(opts = {}) {
   return { platform, bin, args, follow, keepAlive: true };
 }
 
+// autoupdate on|off|status — l'aggiornamento automatico si spegne anche da qui.
+//
+// PERCHE' NEL CLI, visto che la casella esiste gia' in Settings. Perche' il
+// momento in cui serve spegnerlo e' quello in cui la PWA non si apre: il nodo
+// si e' aggiornato, il servizio non e' tornato su, e la riga di comando e'
+// l'unica superficie rimasta. Un controllo che vive solo dove il guasto lo
+// rende irraggiungibile e' mezzo assente.
+//
+// A SERVIZIO ACCESO PASSA DALL'API, e non e' un dettaglio: scrivere il file
+// mentre il processo vive lascerebbe il manager in memoria con il vecchio
+// valore, e continuerebbe ad aggiornare all'ora prevista. Un interruttore che
+// risulta spento e non spegne e' peggio di un interruttore che manca. La route
+// invece persiste E chiama `setEnabled`, quindi vale subito.
+function autoUpdateCommand(args, opts = {}) {
+  const log = opts.log || console.log;
+  const azione = String(args[0] || 'status').toLowerCase();
+  if (!['on', 'off', 'status'].includes(azione)) {
+    log('uso: nexuscrew autoupdate on|off|status');
+    return { code: 1 };
+  }
+  const { configPath, tokenPath } = urlmod.resolvePaths(opts);
+  const port = urlmod.loadPort(opts);
+  const token = urlmod.readToken(tokenPath);
+  const attivo = (opts.isServiceRunningImpl || isServiceRunning)({ ...opts });
+  const fetchImpl = opts.fetchImpl || fetch;
+
+  const daFile = () => {
+    try {
+      const cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      return cfg.autoUpdate !== false;
+    } catch (_) { return true; } // default ON, come la configurazione
+  };
+
+  if (azione === 'status') {
+    // A servizio acceso vince cio' che il processo sta DAVVERO facendo, non
+    // cio' che il file dice: se i due divergono, e' il primo a spegnere o
+    // accendere gli aggiornamenti.
+    if (!attivo) {
+      log(`autoupdate: ${daFile() ? 'on' : 'off'} (da configurazione; servizio non attivo)`);
+      return { code: 0 };
+    }
+    return fetchImpl(`http://127.0.0.1:${port}/api/settings`, {
+      headers: { authorization: `Bearer ${token}` },
+    }).then(async (r) => {
+      if (!r.ok) throw new Error(`HTTP ${r.status}`);
+      const j = await r.json();
+      const acceso = j.autoUpdate !== false;
+      log(`autoupdate: ${acceso ? 'on' : 'off'}`);
+      if (j.update && j.update.latest) log(`  ultima versione vista su npm latest: ${j.update.latest}`);
+      return { code: 0 };
+    }).catch((e) => {
+      log(`autoupdate: ${daFile() ? 'on' : 'off'} (da configurazione; servizio non interrogabile: ${e.message})`);
+      return { code: 0 };
+    });
+  }
+
+  const acceso = azione === 'on';
+  if (!attivo) {
+    // Servizio spento: si scrive il file, e si DICE che vale al prossimo avvio.
+    // Tacerlo lascerebbe credere che abbia gia' effetto.
+    let cfg = {};
+    try { cfg = JSON.parse(fs.readFileSync(configPath, 'utf8')); } catch (_) { /* file nuovo */ }
+    // Scrittura atomica e rifiuto dei symlink, come fa la route che scrive lo
+    // stesso file: tmp nella stessa directory, 0600, rename. Un `writeFileSync`
+    // diretto puo' lasciare un config.json troncato se il processo muore a
+    // meta' — e un config.json illeggibile e' un nodo che non riparte, cioe'
+    // proprio il guasto che questo comando serve a evitare. Rilievo dell'audit.
+    try {
+      if (fs.lstatSync(configPath).isSymbolicLink()) {
+        log('autoupdate: config.json e\' un symlink, non lo scrivo');
+        return { code: 1 };
+      }
+    } catch (e) { if (e.code !== 'ENOENT') throw e; }
+    const dir = path.dirname(configPath);
+    fs.mkdirSync(dir, { recursive: true });
+    const tmp = path.join(dir, `.${path.basename(configPath)}.${crypto.randomBytes(6).toString('hex')}.tmp`);
+    try {
+      fs.writeFileSync(tmp, `${JSON.stringify({ ...cfg, autoUpdate: acceso }, null, 2)}\n`, { mode: 0o600 });
+      fs.chmodSync(tmp, 0o600);
+      fs.renameSync(tmp, configPath);
+    } catch (e) {
+      try { fs.unlinkSync(tmp); } catch (_) { /* best-effort */ }
+      throw e;
+    }
+    log(`autoupdate: ${azione} (scritto in configurazione; vale al prossimo avvio del servizio)`);
+    return { code: 0 };
+  }
+  return fetchImpl(`http://127.0.0.1:${port}/api/settings/config`, {
+    method: 'POST',
+    headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+    body: JSON.stringify({ autoUpdate: acceso }),
+  }).then(async (r) => {
+    if (!r.ok) {
+      const j = await r.json().catch(() => ({}));
+      log(`autoupdate: non applicato — ${j.error || `HTTP ${r.status}`}`);
+      return { code: 1 };
+    }
+    log(`autoupdate: ${azione} (applicato subito e salvato)`);
+    return { code: 0 };
+  }).catch((e) => {
+    log(`autoupdate: non applicato — ${e.message}`);
+    log('  il servizio risulta attivo ma non risponde: non scrivo il file, perche\' resterebbe');
+    log('  un valore che il processo vivo non conosce.');
+    return { code: 1 };
+  });
+}
+
 // update: npm i -g @latest + restart se attivo. Fallimento npm -> messaggio chiaro, code 1.
 function update(opts = {}) {
   const execImpl = opts.execImpl || execFileSync;
@@ -985,11 +1114,32 @@ async function dispatchNodes(rest, flags, opts = {}) {
       : String(flags.selected).split(',').map((value) => value.trim()).filter(Boolean);
     return { code: nodesCmds.nodesEdit({ ...opts, log, ref, patch: { visibility, selected } }).code };
   }
+  // Scope celle (NC-E): quali celle di QUESTO nodo il peer puo' vedere.
+  // Diverso da `visibility`, che governa il transito e non l'accesso.
+  if (sub === 'cells') {
+    const arg = rest[3];
+    if (!arg) {
+      log('nodes cells: uso `nodes cells <nodo> all|none|Cella1,Cella2`');
+      return { code: 1 };
+    }
+    if (arg === 'all' || arg === 'none') {
+      return { code: nodesCmds.nodesEdit({ ...opts, log, ref, patch: { cellVisibility: arg, cells: undefined } }).code };
+    }
+    const cells = String(arg).split(',').map((v) => v.trim()).filter(Boolean);
+    if (!cells.length) { log('nodes cells: elenco vuoto — usa `none` se intendi nessuna cella'); return { code: 1 }; }
+    return { code: nodesCmds.nodesEdit({ ...opts, log, ref, patch: { cellVisibility: 'selected', cells } }).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 };
+  // Senza riferimento non e' un errore: e' la domanda "quali nodi sono davvero
+  // condivisi?", che prima si poteva fare solo un nodo alla volta.
+  if (sub === 'test') {
+    return ref
+      ? { code: (await nodesCmds.nodesTest({ ...opts, log, ref })).code }
+      : { code: (await nodesCmds.nodesTestAll({ ...opts, log })).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;
@@ -1136,9 +1286,134 @@ function dispatch(argv, opts = {}) {
     const result = stop({ ...opts, log });
     return { code: result.stopped || ['not running', 'stale pidfile'].includes(result.reason) ? 0 : 1 };
   }
+  if (cmd === 'autoupdate') {
+    return autoUpdateCommand(rest.slice(1), { ...opts, log });
+  }
   if (cmd === 'restart') {
-    const result = restart({ ...opts, log });
-    return { code: result.restarted ? 0 : 1 };
+    // Seam come negli altri punti del file (`opts.restartImpl || restart`):
+    // serve a poter dichiarare in prova QUALE runtime e' in piedi, perche' il
+    // ritentativo si comporta in modo diverso fra gestito e portatile — e senza
+    // il seam un test finisce per esercitare il ramo che non intendeva.
+    const result = (opts.restartImpl || restart)({ ...opts, log });
+    if (!result.restarted) return { code: 1 };
+    // IL RIAVVIO ORA VERIFICA DI ESSERE TORNATO SU, e prima no. `restart`
+    // dichiarava successo appena `systemctl restart` (o launchctl, o l'avvio
+    // portatile) ritornava: quella e' la conferma che il COMANDO e' partito,
+    // non che il servizio risponda. Su Termux, il 2026-08-07, ha restituito 0
+    // con il servizio morto, e il nodo e' rimasto giu' oltre quattro ore senza
+    // che nessuno lo sapesse — da fuori si vedeva solo un KO generico.
+    //
+    // La verifica esisteva gia' e veniva usata dal percorso di auto-update e
+    // dal bootstrap Fleet («serve un restart verificato»); mancava proprio sul
+    // comando che una persona digita a mano. Con l'auto-update acceso questo
+    // riavvio avviene DA SOLO su ogni nodo, quindi un esito non verificato si
+    // moltiplica per la flotta.
+    //
+    // Il ramo restituisce una PROMESSA e `dispatch` resta sincrona: e' il
+    // disegno che il file ha gia' (dispatchNodes fa lo stesso) e il chiamante
+    // avvolge in `Promise.resolve`. Cambiare la firma di dispatch avrebbe
+    // rotto ottanta test che la chiamano in modo sincrono, per una verifica
+    // che riguarda un comando solo.
+    const { tokenPath } = urlmod.resolvePaths(opts);
+    const port = urlmod.loadPort(opts);
+    const token = urlmod.readToken(tokenPath);
+    // SENZA TOKEN NON SI PUO' DIRE NIENTE SULLA SALUTE, e soprattutto non si
+    // deve dire qualcosa di sbagliato: la sonda fallirebbe per autenticazione e
+    // il messaggio incolperebbe la porta o il processo, mandando a cercare dove
+    // il problema non e'. Rilievo dell'audit. Il riavvio e' comunque partito,
+    // quindi non e' un fallimento: e' una verifica che non si e' potuta fare, e
+    // si dice cosi'.
+    if (!token) {
+      log('restart: comando eseguito, ma la salute NON e\' verificabile senza token locale.');
+      log('  Controlla a mano che il servizio risponda.');
+      return { code: 0 };
+    }
+    const attesa = (sano) => {
+      if (sano) {
+        log(`restart: servizio verificato su 127.0.0.1:${port}`);
+        return { code: 0 };
+      }
+      // NON E' ANCORA UN FALLIMENTO: si prova a capire PERCHE' e, se e' la
+      // causa nota, si rimedia una volta sola.
+      //
+      // LA CAUSA NOTA. Sul percorso portatile — quello di Termux, dove non c'e'
+      // un gestore di servizi che rialzi il processo — `restart` avvia il
+      // nuovo processo SUBITO dopo aver fermato il vecchio, senza aspettare che
+      // muoia ne' che la porta si liberi. Il nuovo non riesce ad ascoltare,
+      // esce, e nessuno se ne accorge: servizio giu', tunnel su (e' un
+      // processo SSH separato), nessun auto-recupero. Misurato il 2026-08-07:
+      // oltre venti minuti in quello stato.
+      //
+      // Il percorso dell'AUTO-UPDATE fa gia' la cosa giusta — aspetta che il
+      // processo sia morto E che la porta sia libera, fino a sei secondi, e
+      // solo allora avvia. Le due strade erano divergenti, e quella che una
+      // persona digita a mano era la meno prudente.
+      //
+      // PRIMA DI DARE LA COLPA A QUALCUNO, si guarda se il servizio risponde
+      // affatto. Un 401 significa che E' IN PIEDI e che il token locale non
+      // vale: il riavvio e' riuscito, e dichiararlo fallito manderebbe a
+      // cercare un processo morto che invece e' vivo.
+      return (opts.probeStatusImpl || probeNexusCrewStatus)(port, token, opts).then((stato) => {
+        if (stato === 401 || stato === 403) {
+          log(`restart: il servizio RISPONDE su 127.0.0.1:${port}, ma il token locale non e' valido.`);
+          log('  Il riavvio e\' riuscito; e\' la credenziale a non funzionare.');
+          log('  Rigenera il token locale, poi riprova a collegarti.');
+          return { code: 1 };
+        }
+        return continua();
+      });
+    };
+    const continua = () => {
+      // SOLO SUL RUNTIME PORTATILE. E' li' che manca un supervisore — ed e'
+      // esattamente la ragione per cui il difetto esiste: su Termux nessuno
+      // rialza il processo. Dove il servizio e' gestito (systemd, launchd) il
+      // supervisore c'e' ed e' suo il compito: avviare noi un processo
+      // portatile accanto significherebbe metterne in piedi uno che il gestore
+      // non conosce, mentre il gestore puo' rialzare la propria unita' — due
+      // processi sulla stessa porta, e il nostro sopravvivrebbe allo stop del
+      // servizio. Li' si riferisce e basta.
+      //
+      // Difetto mio, trovato rileggendo prima dell'audit: la prima stesura
+      // chiamava `startPortable` in ogni caso.
+      if (result.runtimeOwner === 'managed') {
+        log(`restart: il servizio NON risponde su 127.0.0.1:${port} dopo il riavvio.`);
+        log('  Il runtime e\' gestito dal servizio di sistema: non avvio un processo accanto.');
+        log('  Controlla lo stato e i log dell\'unita\' di sistema.');
+        return { code: 1 };
+      }
+      // UN SOLO RITENTATIVO, e solo a porta libera. Se la porta e' ancora
+      // occupata il problema e' un altro (un processo che non muore) e
+      // riprovare lo nasconderebbe; se e' libera e il servizio non c'e', il
+      // nuovo processo e' uscito e riavviarlo e' esattamente il rimedio.
+      // Ripetere all'infinito trasformerebbe un guasto in un ciclo.
+      return (opts.portAvailableImpl || portAvailable)(port, '127.0.0.1').then((libera) => {
+        if (!libera) {
+          log(`restart: il servizio NON risponde su 127.0.0.1:${port} e la porta e' ancora occupata.`);
+          log('  Qualcosa tiene la porta senza servire: non riavvio a vuoto.');
+          log('  Controlla i log del servizio e i processi rimasti.');
+          return { code: 1 };
+        }
+        log(`restart: nessun servizio su ${port} e porta libera — il processo e' uscito. Riprovo una volta.`);
+        (opts.startPortableImpl || startPortable)({ ...opts, spawnImpl: opts.spawnImpl });
+        return (opts.waitForRuntimeImpl || waitForNexusCrew)(port, token, {
+          ...opts, waitAttempts: opts.waitAttempts === undefined ? 60 : opts.waitAttempts,
+          waitDelayMs: opts.waitDelayMs === undefined ? 250 : opts.waitDelayMs,
+        }).then((sanoOra) => {
+          if (sanoOra) {
+            log(`restart: servizio verificato su 127.0.0.1:${port} al secondo tentativo`);
+            return { code: 0 };
+          }
+          log(`restart: il servizio NON risponde su 127.0.0.1:${port} nemmeno dopo un secondo avvio.`);
+          log('  Il comando di riavvio e\' partito, il processo non resta su.');
+          log('  Controlla i log del servizio; su Termux puo\' servire riavviare il dispositivo.');
+          return { code: 1 };
+        });
+      });
+    };
+    return (opts.waitForRuntimeImpl || waitForNexusCrew)(port, token, {
+      ...opts, waitAttempts: opts.waitAttempts === undefined ? 60 : opts.waitAttempts,
+      waitDelayMs: opts.waitDelayMs === undefined ? 250 : opts.waitDelayMs,
+    }).then(attesa);
   }
   // Internal runtime commands used by service managers and MCP clients. They
   // are intentionally omitted from HELP and are not configuration surfaces.