@mmmbuto/nexuscrew 0.8.52-rc.8 → 0.8.52

package/frontend/dist/index.html

@@ -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-DHmXeaJX.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-_kotgT8Z.css">
+  <script type="module" crossorigin src="/assets/index-Cxwpa2Y_.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-CYi_lhCg.css">
 </head>
 <body>
   <div id="root"></div>

package/frontend/dist/sw.js

@@ -2,6 +2,17 @@ self.addEventListener('install', () => self.skipWaiting());
 self.addEventListener('activate', () => self.clients.claim());
 self.addEventListener('fetch', (e) => e.respondWith(fetch(e.request)));
 
+// applyUpdate() (lib/sw-update.js) manda questo messaggio a un worker in
+// waiting e aspetta il `controllerchange`. Senza un listener il messaggio
+// cadeva nel vuoto: scattava il reload di fallback, il worker restava in
+// waiting, e al ricaricamento `reg.waiting` faceva ricomparire il banner —
+// "nuova versione disponibile" per sempre, e il bottone non poteva spegnerlo.
+// Un worker installato da una versione precedente di questo file resta in
+// waiting fino a che non lo si attiva: e' quello il caso che si incastrava.
+self.addEventListener('message', (e) => {
+  if (e && e.data && e.data.type === 'SKIP_WAITING') self.skipWaiting();
+});
+
 // Web Push del MCP bridge: payload JSON {title, body?, lang?, url?} dal server.
 // tag fisso 'nexuscrew': le notifiche si sostituiscono invece di accumularsi.
 self.addEventListener('push', (e) => {

package/frontend/dist/version.json

@@ -1 +1 @@
-{"version":"0.8.52-rc.8"}
+{"version":"0.8.52"}

package/lib/audio/dispatch.js

@@ -25,6 +25,11 @@ function createDispatcher(opts = {}) {
   const localToken = opts.localToken || (() => '');
   const fetchImpl = opts.fetchImpl || fetch;
   const timeoutMs = Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : DISPATCH_TIMEOUT_MS;
+  // Gli esiti che un endpoint puo' legittimamente restituire. Parametrizzato
+  // perche' l'instradamento non e' audio-specifico: le notifiche riusano lo
+  // stesso percorso e rispondono `delivered`. Il default resta quello audio,
+  // cosi' nessun chiamante esistente cambia comportamento.
+  const statuses = opts.statuses instanceof Set ? opts.statuses : PER_ENDPOINT_STATUS;
 
   function isLocal(target) {
     const self = localNodeId();
@@ -84,7 +89,7 @@ function createDispatcher(opts = {}) {
       return { status: 'refused', reason: 'route-denied', httpStatus: res.status };
     }
     if (res.status >= 500) return { status: 'unreachable', reason: 'peer-error', httpStatus: res.status };
-    if (!payload || typeof payload !== 'object' || !PER_ENDPOINT_STATUS.has(payload.status)) {
+    if (!payload || typeof payload !== 'object' || !statuses.has(payload.status)) {
       // Il peer ha risposto qualcosa che non e' un esito per endpoint: non si
       // indovina. `unknown` e' esattamente questo caso.
       return { status: 'unknown', reason: 'unreadable-endpoint-result', httpStatus: res.status };

package/lib/cells/scope-guard.js

@@ -0,0 +1,239 @@
+'use strict';
+// lib/cells/scope-guard.js — il punto in cui lo scope celle diventa effettivo.
+//
+// Sta in testa al router /api perche' i canali da cui una cella puo' trapelare
+// sono tredici, e un permesso che vale su dodici di essi non e' un permesso:
+// e' un'etichetta. Gli elenchi (cosa esce) e le azioni (cosa si puo' toccare)
+// passano dallo stesso predicato di lib/cells/scope.js.
+//
+// Due scelte deliberate:
+//
+//  * il bersaglio di ogni route e' DICHIARATO in una tabella, non indovinato.
+//    Una regola magica sbaglia in silenzio quando qualcuno aggiunge una route;
+//    un elenco esplicito, quando qualcuno lo dimentica, fa scattare la rete di
+//    sicurezza qui sotto.
+//  * fail-closed sulle route sconosciute che nominano una cella: se un corpo
+//    porta `cell`, `to.cell` o `session` e la route non e' dichiarata, si nega.
+//    E' l'unico modo perche' una route aggiunta domani non nasca scoperta.
+const { createCellScope } = require('./scope.js');
+
+
+// Chiavi da cui, in una RISPOSTA, esce un elenco di celle o di sessioni.
+// Coprono /cells, /fleet/status, /fleet/definitions, /sessions.
+const CELL_LIST_KEYS = ['cells'];
+const SESSION_LIST_KEYS = ['sessions', 'unmanaged'];
+
+// I deck sono il quarto elenco, e non lo sembrava: non contengono celle ne'
+// sessioni sotto quei nomi, ma TILE, e ogni tile porta il nome della sessione
+// tmux. Filtrare tre chiavi su quattro lasciava passare a un peer ristretto
+// l'esistenza e il nome di ogni cella dell'hub — non il contenuto, ma la mappa.
+// Trovato dall'audit indipendente di NC-E, non da questo codice.
+function filterDecks(decks, scope) {
+  if (!Array.isArray(decks)) return decks;
+  const out = [];
+  for (const deck of decks) {
+    const layout = deck && deck.layout;
+    const columns = Array.isArray(layout && layout.columns) ? layout.columns : null;
+    // Forma inattesa: non si inventa un filtro su una struttura che non si
+    // riconosce. Meglio lasciarla passare qui e vederla rompere un test, che
+    // svuotarla in silenzio.
+    if (!columns) { out.push(deck); continue; }
+    const kept = [];
+    for (const column of columns) {
+      const tiles = Array.isArray(column && column.tiles)
+        ? column.tiles.filter((tile) => scope.allowsTile(tile))
+        : [];
+      if (tiles.length) kept.push({ ...column, tiles });
+    }
+    // Un deck rimasto senza tile era fatto solo di celle non concesse: sparisce
+    // invece di comparire vuoto, che sarebbe la stessa rivelazione in negativo.
+    if (kept.length) out.push({ ...deck, layout: { ...layout, columns: kept } });
+  }
+  return out;
+}
+
+// Route che AGISCONO su una cella o su una sessione, con il punto esatto in cui
+// leggere il bersaglio. `null` = la route e' nota e non ha un bersaglio cella.
+function declaredTarget(req) {
+  const p = req.path || '';
+  const b = (req.body && typeof req.body === 'object') ? req.body : {};
+  const q = req.query || {};
+
+  // Azioni sul ciclo di vita di una cella: il bersaglio e' `body.cell`.
+  if (/^\/fleet\/(up|down|restart|engine|boot)$/.test(p)) return { cell: b.cell };
+  // Definire/modificare/rimuovere celle e' una capacita' a se': chi ha uno
+  // scope ristretto non deve poter creare la cella che gli manca.
+  if (/^\/fleet\/(define-cell|edit-cell|remove-cell|restore-cells|import-cell)$/.test(p)) return { deny: 'scope-cannot-define-cells' };
+  // Messaggio a una cella: il bersaglio e' dichiarato due volte, e devono
+  // valere entrambe (il codice a valle le confronta gia' fra loro).
+  if (p === '/cells/send') return { cell: b.to && b.to.cell, session: b.to && b.to.tmuxSession };
+  // Sessioni: creazione, eliminazione, visibilita', file.
+  if (p === '/sessions' && req.method === 'POST') return { session: b.name };
+  if (/^\/sessions\/[^/]+/.test(p)) return { session: decodeURIComponent(p.split('/')[2] || '') };
+  if (p === '/files' || p.startsWith('/files/')) return { session: q.session || b.session };
+  // Route note che NON agiscono su una cella: la notifica arriva all'operatore
+  // e la voce passa dal suo ACL per-nodo (lib/audio/acl.js). Vanno dichiarate
+  // esplicitamente, altrimenti la rete di sicurezza qui sotto le scambia per
+  // route dimenticate — cosa che e' successa davvero: entrambe portano
+  // `originCell`, che e' la PROVENIENZA attestata dal server, non un bersaglio.
+  if (p === '/notify' || p.startsWith('/notify/')) return null;
+  if (p === '/audio' || p.startsWith('/audio/')) return null;
+  return undefined; // route non dichiarata
+}
+
+// Rete di sicurezza: un corpo che nomina una cella o una sessione su una route
+// non dichiarata. Meglio un 403 su qualcosa di legittimo — che si nota subito e
+// si aggiunge alla tabella — di un canale aperto che nessuno vede.
+//
+// La prima versione elencava sei chiavi esatte (`cell`, `session`,
+// `tmuxSession`, `to.cell`, `to.tmuxSession`, `?session`) e l'audit ha mostrato
+// il limite: una route dimenticata che chiama il suo bersaglio `cellId` passava
+// liscia. Si riconosce quindi la FORMA del nome — qualunque chiave che parli di
+// celle o di sessioni — invece di un elenco che invecchia a ogni sinonimo.
+//
+// Limite residuo, dichiarato invece che nascosto: un bersaglio chiamato `name`
+// o `target` non e' riconoscibile senza sapere quali celle esistono, e negare
+// ogni `name` renderebbe la rete di sicurezza un muro. Le route reali che
+// agiscono su una cella sono tutte nella tabella qui sopra; questa e' la
+// seconda linea, non la prima.
+const TARGET_KEY_RE = /cell|session/i;
+// Una chiave che dichiara da DOVE viene la richiesta non e' un bersaglio, ed e'
+// il caso che ha fatto scattare la rete di sicurezza su /notify e /audio/speak:
+// il loro corpo federato porta `originCell`, scritto dal server come
+// provenienza attestata. Negarlo bloccava due funzioni sane per ogni peer
+// ristretto. La provenienza si controlla altrove — dalla catena `visited`, che
+// il peer non puo' scrivere — e qui non va nemmeno guardata.
+const ORIGIN_KEY_RE = /^(origin|from|sender|source)/i;
+
+function scanTargets(source) {
+  if (!source || typeof source !== 'object' || Array.isArray(source)) return null;
+  for (const [key, value] of Object.entries(source)) {
+    if (typeof value !== 'string' || !value) continue;
+    if (ORIGIN_KEY_RE.test(key)) continue;
+    if (TARGET_KEY_RE.test(key)) return value;
+  }
+  return null;
+}
+
+function undeclaredTarget(req) {
+  const b = (req.body && typeof req.body === 'object') ? req.body : {};
+  const q = req.query || {};
+  // `to` e' il solo annidamento noto (il destinatario di /cells/send); piu' a
+  // fondo non si scende: un corpo arbitrariamente profondo diventerebbe una
+  // scansione senza fine su ogni richiesta federata.
+  const named = scanTargets(b) || scanTargets(b.to) || scanTargets(q);
+  return named ? { target: named } : null;
+}
+
+function filterPayload(payload, scope) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return payload;
+  const out = { ...payload };
+  for (const key of CELL_LIST_KEYS) {
+    if (Array.isArray(out[key])) out[key] = scope.filterCells(out[key]);
+  }
+  for (const key of SESSION_LIST_KEYS) {
+    if (Array.isArray(out[key])) out[key] = scope.filterSessions(out[key]);
+  }
+  if (Array.isArray(out.decks)) out.decks = filterDecks(out.decks, scope);
+  if (Array.isArray(out.records)) out.records = filterRecords(out.records, scope);
+  return out;
+}
+
+// I record diagnostici (/diagnostics/logs, federata in lettura) portano
+// `meta.cell`: il quinto canale, e di nuovo non somigliava a un elenco di
+// celle. Un record che NON nomina una cella passa: lo scope celle governa le
+// celle, e i diagnostici di sistema non appartengono a nessuna. Il resto del
+// record e' gia' bounded per contratto — i diagnostici rifiutano contenuto
+// grezzo di terminale — quindi qui basta il bersaglio dichiarato.
+function filterRecords(records, scope) {
+  return records.filter((entry) => {
+    const cell = entry && entry.meta && entry.meta.cell;
+    if (typeof cell !== 'string' || !cell) return true;
+    return scope.allowsCell(cell);
+  });
+}
+
+// Parser JSON usato SOLO sulle richieste federate. Non si puo' montare un
+// parser globale: le route locali catturano `rawBody` con `verify` per la firma
+// del bridge, e `verify` non viene chiamato se il corpo e' gia' stato
+// consumato; inoltre i limiti di dimensione per-route (16kb per notify, 8kb per
+// i comandi VL) verrebbero saltati, perche' express.json esce subito quando
+// `req.body` esiste gia'. Le richieste locali devono arrivare INTATTE ai loro
+// parser.
+function federatedBodyParser(limit) {
+  const parse = require('express').json({ limit });
+  return (req, res, next) => {
+    if (req.body !== undefined) return next();
+    const method = (req.method || 'GET').toUpperCase();
+    if (method === 'GET' || method === 'HEAD' || method === 'DELETE') return next();
+    return parse(req, res, () => next());
+  };
+}
+
+function createCellScopeGuard({
+  nodesPath, loadStoreImpl, cellForSession,
+  // resolveOrigin(req) -> {ok, trust, visited}. In produzione e' l'origin
+  // resolver basato sulla prova di hop; nei test e' un seam, cosi' questo
+  // modulo prova il GUARD e non di nuovo la firma (che ha i suoi test).
+  resolveOrigin,
+  bodyLimit = '1mb',
+} = {}) {
+  const scoper = createCellScope({ nodesPath, loadStoreImpl, cellForSession });
+  const parseFederatedBody = federatedBodyParser(bodyLimit);
+
+  return async function cellScopeGuard(req, res, next) {
+    let origin;
+    try {
+      origin = await resolveOrigin(req);
+    } catch (_) {
+      origin = null;
+    }
+    // Un hop che non verifica NON e' una richiesta federata, e questo guard non
+    // e' il posto dove deciderne l'esito: le route che sanno rifiutarlo lo
+    // fanno gia' con il loro codice (401 su audio, non 403), e sostituirlo qui
+    // cambierebbe una risposta di sicurezza esistente senza migliorarla.
+    // Non e' nemmeno una scappatoia: `cleanHeaders` cancella gli header di hop
+    // in ingresso e il proxy li riscrive lui, quindi un peer non puo' ne'
+    // toglierli ne' falsificarli. Chi puo' inventarne uno possiede gia' il
+    // Bearer locale — e' il proprietario della macchina, che non si limita da
+    // solo.
+    if (!origin || origin.ok !== true) return next();
+    if (origin.trust !== 'federated') return next();
+
+    const scope = scoper.resolve({ trust: 'federated', visited: origin.visited });
+    req.cellScope = scope;
+    if (scope.mode === 'all') return next();
+
+    // Il bersaglio di molte azioni sta nel corpo: qui, e solo per le federate,
+    // va parsato prima di poterlo guardare.
+    return parseFederatedBody(req, res, () => applyScope(req, res, next, scope));
+  };
+
+  function applyScope(req, res, next, scope) {
+    // --- azioni ---------------------------------------------------------
+    const declared = declaredTarget(req);
+    if (declared === undefined) {
+      const sneaky = undeclaredTarget(req);
+      if (sneaky) {
+        return res.status(403).json({ error: 'route non dichiarata per lo scope celle', reason: 'undeclared-cell-route' });
+      }
+    } else if (declared) {
+      if (declared.deny) return res.status(403).json({ error: 'fuori dallo scope celle', reason: declared.deny });
+      if (declared.cell !== undefined && !scope.allowsCell(declared.cell)) {
+        return res.status(403).json({ error: 'fuori dallo scope celle', reason: 'cell-not-granted' });
+      }
+      if (declared.session !== undefined && !scope.allowsSession(declared.session)) {
+        return res.status(403).json({ error: 'fuori dallo scope celle', reason: 'session-not-granted' });
+      }
+    }
+
+    // --- letture --------------------------------------------------------
+    // Si avvolge res.json invece di riscrivere ogni handler: gli elenchi sono
+    // quattro e crescono, e un handler nuovo nascerebbe scoperto.
+    const json = res.json.bind(res);
+    res.json = (payload) => json(filterPayload(payload, scope));
+    return next();
+  }
+}
+
+module.exports = { createCellScopeGuard, declaredTarget, filterPayload, filterDecks, filterRecords };

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

@@ -61,6 +61,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]
@@ -985,11 +986,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;