@mmmbuto/nexuscrew 0.8.58 → 0.9.1

package/lib/server.js

@@ -23,7 +23,11 @@ const VERSION = require('../package.json').version;
 const { transcribe } = require('./voice/transcribe.js');
 const { selectProvider } = require('./fleet/provider.js');
 const { fleetRoutes } = require('./fleet/routes.js');
+const { leaseRoutes } = require('./fleet/lease-routes.js');
 const { cellsRoutes } = require('./cells/routes.js');
+const { liveHostRoutes } = require('./live-host/routes.js');
+const { createLiveHostStore, liveHostPath } = require('./live-host/store.js');
+const { createLiveBridge } = require('./live-host/bridge.js');
 const { fsRoutes } = require('./fs/routes.js');
 const nodesStore = require('./nodes/store.js');
 const nodesTunnel = require('./nodes/tunnel.js');
@@ -33,6 +37,8 @@ const { createReverseSlotListeners } = require('./nodes/reverse-slot-listeners.j
 const reverseRotation = require('./nodes/reverse-rotation.js');
 const topologyCache = require('./nodes/topology-cache.js');
 const { createNodeProxy, handleNodeUpgrade } = require('./proxy/node-proxy.js');
+const { createPanelProxy, handlePanelUpgrade } = require('./proxy/panel-proxy.js');
+const { createPanelAuth } = require('./proxy/panel-auth.js');
 const federation = require('./proxy/federation.js');
 const { audioRoutes } = require('./audio/routes.js');
 const { isConsent: isAudioConsent } = require('./audio/consent.js');
@@ -526,6 +532,14 @@ function createServer(opts = {}) {
   }
 
   const app = express();
+  // CSP frame-ancestors (P0 sicurezza 2026-08-16, rimedio 4 del report): la
+  // pagina dell'app non deve poter essere incorporata in un iframe altrui —
+  // clickjacking sul control plane. Ortogonale alla porta pannello: quello
+  // difende CHI E' NEL FRAME, questo difende l'app dall'ESSERE il frame.
+  app.use((_req, res, next) => {
+    res.setHeader('Content-Security-Policy', "frame-ancestors 'none'");
+    next();
+  });
   reverseSlotListeners = createReverseSlotListeners({
     app, diagnostics, createServerImpl: cfg.reverseSlotCreateServerImpl,
     // `routeUpgrade` e' hoisted: qui si cattura solo il riferimento, la
@@ -535,7 +549,19 @@ function createServer(opts = {}) {
   const distDir = path.join(__dirname, '..', 'frontend', 'dist');
   // no-store on everything (HTML+assets+API): this is a local, token-adjacent tool.
   app.use((_req, res, next) => { res.set('Cache-Control', 'no-store'); next(); });
-  app.use('/pair', publicPeeringRoutes({ cfg, nodesPath }));
+  // Il panelServer nasce piu' avanti nella stessa funzione: il pairing legge
+  // la sua porta VIVA tramite questo ref, risolto a ogni join (pattern dello
+  // stesso tipo dell'hoisting di routeUpgrade qui sopra).
+  const panelListenerRef = { server: null };
+  app.use('/pair', publicPeeringRoutes({
+    cfg, nodesPath,
+    panelPort: () => {
+      const srv = panelListenerRef.server;
+      if (!srv || !srv.listening) return null;
+      const addr = srv.address();
+      return addr && Number.isInteger(addr.port) && addr.port > 0 ? addr.port : null;
+    },
+  }));
   // VL micro-device nodes use a separate, scoped credential surface.  These
   // routes never accept the NexusCrew UI bearer and expose only pair, poll and
   // self-unpair.  Operator management remains behind /api + federation ACL.
@@ -549,9 +575,121 @@ function createServer(opts = {}) {
     if (!reverseSlotListeners.respond(req, res)) res.status(404).json({ error: 'reverse slot non disponibile' });
   });
 
-  // Tutte le /api dietro Bearer: sul loopback il gate vero è il tunnel,
+  // Pannello per-cella (D8): inoltra il traffico verso il `panelUrl` di UNA cella
+  // LOCALE. La destinazione non arriva mai dal chiamante — si risolve dallo stato
+  // della cella — e il token di NexusCrew non prosegue verso il pannello, che e'
+  // un servizio terzo e non un nodo. Local-only come /api/live-host: il pass-through
+  // /node/<name>/ NON deve portarci un peer qualsiasi (vedi LOCAL_ONLY_PREFIXES in
+  // proxy/node-proxy.js). L'attraversamento verso i nodi del proprietario passera'
+  // dalla via allowlistata della federazione, dietro il gate di proprieta'.
+  async function resolveCellPanel(cellId) {
+    const fleet = await fleetP;
+    if (!fleet || fleet.available !== true) return null;          // fleet non interrogabile
+    const statusFn = typeof fleet.status === 'function' ? fleet.status : fleet.cellStatus;
+    if (typeof statusFn !== 'function') return null;
+    const st = await statusFn.call(fleet);
+    const cells = Array.isArray(st && st.cells) ? st.cells : [];
+    // La chiave e' `cell`, non `id`: e' cio' che cellStatus PRODUCE
+    // (fleet/runtime.js scrive `cell: c.id`, dove `id` e' il nome interno della
+    // definizione). Cercare `c.id` qui non trovava MAI nulla, quindi ogni cella
+    // con un pannello configurato rispondeva «pannello non disponibile» — e la
+    // UI mostrava una causa col nome sbagliato. Tutti gli altri consumatori di
+    // cellStatus usano gia' `c.cell` (cells/routes.js, live-host/bridge.js,
+    // live-host/routes.js): questo era l'unico fuori posto.
+    const cell = cells.find((c) => c && c.cell === cellId);
+    if (!cell) return undefined;                                   // cella sconosciuta
+    return typeof cell.panelUrl === 'string' ? cell.panelUrl.trim() : '';
+  }
+  // Tutte le altre /api dietro Bearer: sul loopback il gate vero è il tunnel,
   // ma il token chiude anche altri processi locali della stessa macchina.
   const api = express.Router();
+  // L'INGRESSO al pannello sta PRIMA del requireToken generale: un <iframe> e'
+  // una navigazione del browser e non porta header, quindi l'autenticazione
+  // qui e' dedicata — Bearer per la PWA, ticket monouso + cookie di visione
+  // per l'iframe (proxy/panel-auth.js, misura 2026-08-15). Il cookie vale
+  // SOLO sul path della cella che lo ha emesso: non e' e non diventa
+  // un'autenticazione dell'origine.
+  const panelAuth = createPanelAuth({
+    verifyToken: (t) => verify(tokenHolder.value, t),
+    resolveCellPanel,
+    // Senza questo segreto il pannello non saprebbe distinguere la PWA
+    // dall'ultimo hop di una route federata — che entra qui col Bearer che il
+    // proxy si e' iniettato da se'. E' lo stesso segreto per-processo che
+    // firma gli hop di sotto: due valori diversi renderebbero ogni federata
+    // 'sospetta', cioe' chiuderebbero il pannello remoto invece di proteggerlo.
+    hopSecret: () => hopSecret,
+    log: (entry) => diagnostics.record('panel-auth', 'info', entry.outcome, {
+      cell: entry.cell, reason: entry.reason, state: entry.outcome,
+    }),
+  });
+  api.use('/panel', panelAuth.panelAuthMiddleware, createPanelProxy({
+    resolveCellPanel,
+    log: (entry) => diagnostics.record('panel-proxy', 'info', entry.outcome, {
+      cell: entry.cell, reason: entry.reason, state: entry.outcome,
+    }),
+  }));
+  // Porta pannello dedicata (P0 sicurezza 2026-08-16): un iframe
+  // same-origin senza sandbox legge il localStorage del padre — il JS di un
+  // pannello ostile puo' prendersi il token e agire come l'operatore. La
+  // porta fa parte dell'origin: spostando SOLO il consumo (ticket in query,
+  // cookie di visione) su una porta sua, il browser vede un'origin diversa e
+  // non c'e' piu' nulla da rubare. Nessuna API di controllo qui, nessun
+  // Bearer verificato: l'emissione del ticket resta sopra, dietro
+  // requireToken — e' l'unica operazione che richiede provare CHI chiede.
+  const panelApp = express();
+  panelApp.use('/panel', panelAuth.consumeMiddleware, createPanelProxy({
+    resolveCellPanel,
+    log: (entry) => diagnostics.record('panel-proxy', 'info', entry.outcome, {
+      cell: entry.cell, reason: entry.reason, state: entry.outcome,
+    }),
+  }));
+  // Qualunque altra cosa (niente /api, niente SPA): 404 secco. Questa porta
+  // non ha nient'altro da offrire, e non deve mai imparare a offrirlo per
+  // errore — un catch-all che rispondesse con l'app sarebbe esattamente il
+  // difetto che questa porta esiste per chiudere.
+  panelApp.use((_req, res) => res.status(404).json({ error: 'not found' }));
+  const panelServer = http.createServer(panelApp);
+  const panelServerV6 = http.createServer(panelApp);
+  panelListenerRef.server = panelServer;
+  function routePanelUpgrade(req, socket, head) {
+    let pathname;
+    try { pathname = new URL(req.url, 'http://127.0.0.1').pathname; }
+    catch (_) { try { socket.destroy(); } catch (_e) {} return; }
+    if (!pathname.startsWith('/panel/')) { try { socket.destroy(); } catch (_) {} return; }
+    handlePanelUpgrade({
+      req, socket, head, resolveCellPanel,
+      verifyToken: (t) => verify(tokenHolder.value, t),
+      authorize: panelAuth.authorizeUpgrade,
+      log: (entry) => diagnostics.record('panel-proxy', 'info', entry.outcome, {
+        cell: entry.cell, reason: entry.reason, state: entry.outcome,
+      }),
+    });
+  }
+  panelServer.on('upgrade', routePanelUpgrade);
+  panelServerV6.on('upgrade', routePanelUpgrade);
+  panelServer.on('close', () => { try { panelServerV6.close(); } catch (_) {} });
+  // L'ingresso ai pannelli REMOTI ha la stessa malattia dell'iframe locale: la
+  // via federata /api/route/<nodi>/_/panel/... sta per finire sotto requireToken
+  // e una navigazione del browser non porta header. QUI il ticket non si può
+  // validare — è del nodo che lo ha emesso — quindi per le panel-resource
+  // federate il requireToken NON si applica: decide il nodo proprietario (gate
+  // panelAccess + panelAuth col ticket/cookie, e l'ultimo hop lo riconosce
+  // dalla prova di hop: di là il Bearer non apre più il pannello, altrimenti
+  // il contenuto uscirebbe per ogni peer con panelAccess senza che nessuno
+  // abbia mai preso un ticket). Resta della PWA autenticata l'EMISSIONE: il POST
+  // .../panel/<cella>/ticket transita di sotto, col Bearer, come ogni altra /api.
+  const panelFederatoRouter = federation.localRouter({
+    nodesPath, localPort: () => (server && server.address() ? server.address().port : cfg.port), localCredential: () => tokenHolder.value, readonly: proxyReadonly,
+    hopSecret: () => hopSecret,
+  });
+  api.use('/route', (req, res, next) => {
+    const i = req.url.indexOf('/_/');
+    if (i === -1) return next();
+    const resource = req.url.slice(i + 2);
+    if (!/^\/panel\/[A-Za-z0-9._-]{1,32}(?:\/.*)?$/.test(resource)) return next();
+    if (req.method === 'POST' && /^\/panel\/[A-Za-z0-9._-]{1,32}\/ticket\/?$/.test(resource)) return next();
+    panelFederatoRouter(req, res, next);
+  });
   api.use(requireToken(tokenStore));
   // Origine per lo scope celle: stessa prova di hop usata da audio e notify.
   // requireCell:false perche' qui interessa QUALE NODO parla, non quale cella
@@ -656,11 +794,26 @@ function createServer(opts = {}) {
       res.json(await setSessionVisibility(cfg.tmuxBin, name, req.body?.technical === true));
     } catch (e) { res.status(e.status || 500).json({ error: String(e.message || e) }); }
   });
+  // Mappa nome-nodo -> porta pannello inoltrata sul NOSTRO loopback (coppia
+  // panel negoziata nel pairing). E' la fonte con cui il frontend mette il
+  // frame di una cella REMOTA su un'origin diversa: la lettura e' questa, non
+  // /api/nodes, perche' qui non c'e' nessun probe di health federato — la
+  // mappa costa quanto la lettura dello store. Un nodo assente dalla mappa e
+  // un peer accoppiato prima di questa negoziazione: via storica.
+  const nodePanelPorts = () => {
+    const st = nodesStore.loadStore(nodesPath);
+    const out = {};
+    if (st) for (const n of st.nodes) {
+      if (n.panelLocalPort !== undefined) out[n.name] = n.panelLocalPort;
+    }
+    return out;
+  };
   api.get('/config', (_req, res) => res.json({
     readonlyDefault: cfg.readonlyDefault, version: VERSION, uiVersion: uiBuildVersion(distDir),
-    bind: cfg.bind, port: cfg.port,
+    bind: cfg.bind, port: cfg.port, panelPort: cfg.panelPort,
     protectSharedTmuxServer: cfg.protectSharedTmuxServer !== false,
     instanceId: (nodesStore.loadStore(nodesPath) || {}).nodeId || null,
+    nodePanelPorts: nodePanelPorts(),
     presets: ['shell', 'claude', 'codex-vl', 'pi', ...Object.keys(cfg.sessionPresets || {})],
   }));
   api.use('/files', filesRoutes({
@@ -710,6 +863,10 @@ function createServer(opts = {}) {
     federatedRate: createSpeakRateLimiter(),
   }));
   api.use('/fleet', fleetRoutes(fleetP, { ...cfg, diagnostics }));
+  // Fetta 2b (D3): superficie child del lease Live via canale nativo del
+  // bridge (HTTP loopback + Bearer). La cella e' derivata dalla sessione; il
+  // proof firmato dal verifier per-installazione autorizza refresh/recovery.
+  api.use('/lease', leaseRoutes({ fleetP, readonly: proxyReadonly }));
   // Audio Share. L'identita' del nodo NON e' un campo di cfg: si legge dal node
   // store, la stessa fonte usata da /api/cells e /api/peers. Lo stato Fleet e'
   // asincrono e va atteso: leggerlo come se fosse sincrono lascerebbe la
@@ -776,6 +933,28 @@ function createServer(opts = {}) {
     })),
     readonly: proxyReadonly,
   }));
+  // Cella ospite Live (contratto rev6 §2): hostCell unico per nodo con CAS. Lo store
+  // vive accanto al token (stessa dir isolata nei test); il proxy nega /api/live-host
+  // via /node (local-only), ma la via /api/route la instrada (0.9.1) dietro un
+  // permesso per-peer negato di default (liveHostAccess, v. lib/proxy/federation.js).
+  // Fetta 3: il ponte risolve il puntamento all'avvio di una Live (POST /bridge
+  // nello stesso gruppo, stessa auth, stesso local-only). Isolabile da cfg
+  // (rev5 MC0): spento non crea connessioni e la Live resta standard.
+  api.use('/live-host', liveHostRoutes({
+    fleetP,
+    store: createLiveHostStore({ filePath: liveHostPath(cfg) }),
+    readonly: proxyReadonly,
+    bridge: createLiveBridge({
+      cfg,
+      fleetP,
+      tokenGet: () => tokenHolder.value,
+      filesRoot: cfg.filesRoot,
+      log: opts.log || console.log,
+    }),
+  }));
+  // Pannello per-cella: montato con il suo ingresso dedicato (ticket+cookie)
+  // PRIMA del requireToken generale — vedi il blocco sopra, dove nascono
+  // `panelAuth` e `resolveCellPanel`.
   api.use('/vl-nodes', vlNodeApiRoutes({
     storePath: vlNodesPath, broker: vlNodeBroker, ownerId: vlOwnerId, readonly: proxyReadonly,
   }));
@@ -920,6 +1099,10 @@ function createServer(opts = {}) {
     watcher.close(); previews.close(); eventsHub.closeAll(); updater.close();
     for (const timer of reverseWatchers.values()) clearInterval(timer);
     reverseWatchers.clear(); rotatableReverse.clear(); void reverseSlotListeners?.closeAll();
+    // Il pannello non sopravvive al control plane: senza requireToken sopra,
+    // non c'e' un secondo lifecycle da tenere in vita da soli. panelServerV6
+    // si chiude a cascata dal listener 'close' gia' registrato su panelServer.
+    try { panelServer.close(); } catch (_) {}
   });
   // noServer: gestiamo l'upgrade a mano per instradare /ws (locale) e /node/*
   // (proxy). Il WS locale resta identico; il proxy WS applica gli STESSI check
@@ -954,7 +1137,14 @@ function createServer(opts = {}) {
     if (pathname.startsWith('/api/route/')) {
       let u; try { u = new URL(req.url, 'http://127.0.0.1'); } catch (_) { return socket.destroy(); }
       const given = bearerFrom(req) || u.searchParams.get('token') || '';
-      if (!verify(tokenHolder.value, given)) return socket.destroy();
+      // Le WebSocket di un pannello REMOTO partono dalla pagina nel frame e
+      // portano solo il cookie di visione: il token qui non c'è e non deve
+      // esserci. L'HUB non può validarle (il cookie è del nodo che lo ha
+      // emesso): transita e decide il proprietario, gate panelAccess compreso
+      // — stessa forma del bypass HTTP sulle panel-resource federate.
+      const panelFederato = /^\/api\/route\/[^?#]*\/_\/panel\/[A-Za-z0-9._-]{1,32}(?:\/.*)?$/.test(pathname)
+        && /(?:^|;\s*)npanel=/.test(String(req.headers.cookie || ''));
+      if (!panelFederato && !verify(tokenHolder.value, given)) return socket.destroy();
       federation.forwardUpgrade({ req, socket, head, nodesPath, localPort: runtimePort, localCredential: () => tokenHolder.value, ingress: null, readonly: proxyReadonly, activeSockets: proxySockets, hopSecret: () => hopSecret });
       return;
     }
@@ -964,6 +1154,19 @@ function createServer(opts = {}) {
       federation.forwardUpgrade({ req, socket, head, nodesPath, localPort: runtimePort, localCredential: () => tokenHolder.value, ingress, readonly: proxyReadonly, activeSockets: proxySockets, hopSecret: () => hopSecret });
       return;
     }
+    if (pathname.startsWith('/api/panel/')) {
+      handlePanelUpgrade({
+        req, socket, head, resolveCellPanel,
+        verifyToken: (t) => verify(tokenHolder.value, t),
+        // Il cookie di visione apre le WS del pannello (la pagina nel frame
+        // non puo' mettere header); Bearer e ?token= restano validi come prima.
+        authorize: panelAuth.authorizeUpgrade,
+        log: (entry) => diagnostics.record('panel-proxy', 'info', entry.outcome, {
+          cell: entry.cell, reason: entry.reason, state: entry.outcome,
+        }),
+      });
+      return;
+    }
     if (pathname === '/node' || pathname.startsWith('/node/')) {
       handleNodeUpgrade({
         req, socket, head, resolveNode,
@@ -991,7 +1194,7 @@ function createServer(opts = {}) {
     // async questo handler rischierebbe di perdere i frame che arrivano prima
     // di bindWs. `/ws` attacca per NOME DI SESSIONE e senza questo gate ogni
     // filtro sugli elenchi sarebbe decorativo — basterebbe indovinare
-    // `cloud-Dev`.
+    // `cloud-X`.
     const wsScope = wsCellScope(req);
     bindWs(ws, {
       openAttach,
@@ -1020,11 +1223,14 @@ function createServer(opts = {}) {
     fleetP.then((fleet) => (typeof fleet.close === 'function' ? fleet.close() : null)).catch(() => {});
   });
 
-  return { app, server, wss, cfg, token: tokenHolder.value, tokenStore, watcher, fleetP, updater, diagnostics };
+  return {
+    app, server, wss, cfg, token: tokenHolder.value, tokenStore, watcher, fleetP, updater, diagnostics,
+    panelApp, panelServer, panelServerV6,
+  };
 }
 
 function start(opts = {}) {
-  const { server, cfg } = createServer(opts);
+  const { server, cfg, panelServer, panelServerV6 } = createServer({ ...opts, cellLeaseEnabled: true });
   const log = opts.log || console.log;
   const requestedPort = cfg.port;
   const nodesPath = opts.nodesPath || nodesStore.defaultNodesPath(cfg.home || os.homedir());
@@ -1033,12 +1239,51 @@ function start(opts = {}) {
     if (typeof opts.onListenError === 'function') return opts.onListenError(error);
     throw error;
   };
+  // Porta pannello (P0 sicurezza 2026-08-16): scelta libera con lo STESSO
+  // meccanismo di fallback della principale, ma piu' leggero — nessun peer
+  // dipende ancora da un valore stabile persistito (a differenza di cfg.port,
+  // che i tunnel pairati referenziano), quindi niente scrittura su
+  // config.json: il frontend la scopre da /api/config a ogni avvio. Un
+  // fallimento qui non deve MAI abbattere il control plane: e' un log, non
+  // un throw — il pannello resta un'estensione, non un requisito di avvio.
+  const startPanelV6 = () => {
+    panelServerV6.once('error', (error) => {
+      log(`panel: IPv6 loopback listener not available (${(error && error.code) || error}); IPv4 still serves the panel.`);
+    });
+    panelServerV6.listen(cfg.panelPort, '::1');
+  };
+  const startPanelServer = () => {
+    const requestedPanelPort = cfg.panelPort;
+    const tryPanelFallback = (candidate, remaining) => {
+      panelServer.once('error', (error) => {
+        if (error && error.code === 'EADDRINUSE' && remaining > 1) {
+          tryPanelFallback(candidate >= 65535 ? 41821 : candidate + 1, remaining - 1);
+          return;
+        }
+        log(`panel: preferred port ${requestedPanelPort} busy and no fallback available (${(error && error.code) || error}); panel disabled this run.`);
+      });
+      panelServer.listen(candidate, cfg.bind, () => {
+        cfg.panelPort = panelServer.address().port;
+        log(`panel port ${requestedPanelPort} busy; selected ${cfg.panelPort}`);
+        startPanelV6();
+      });
+    };
+    panelServer.once('error', (error) => {
+      if (error && error.code === 'EADDRINUSE') { tryPanelFallback(requestedPanelPort >= 65535 ? 41821 : requestedPanelPort + 1, 200); return; }
+      log(`panel: failed to start (${(error && error.code) || error}); panel disabled this run.`);
+    });
+    panelServer.listen(requestedPanelPort, cfg.bind, () => {
+      cfg.panelPort = panelServer.address().port;
+      startPanelV6();
+    });
+  };
   const onListening = () => {
     cfg.port = server.address().port;
     // Il token NON si stampa allo startup: finirebbe nei log del servizio
     // (journalctl/logfile). L'apertura autenticata passa da `nexuscrew show`.
     log(`nexuscrew on http://${cfg.bind}:${cfg.port}  (open with \`nexuscrew show\`)`);
     log('localhost-only — reach it via a user-controlled SSH or VPN channel.');
+    startPanelServer();
   };
   const persistFallback = () => {
     const selected = server.address().port;

package/lib/settings/pairing-coordinator.js

@@ -87,6 +87,7 @@ function createPairHandler(deps) {
 
     let provisionalPort = null;
     let portReservation = null;
+    let panelPortReservation = null;
     let rollbackCredential = null;
     let created = false;
     let rolledBack = false;
@@ -98,6 +99,10 @@ function createPairHandler(deps) {
         try { await portReservation.release(); } catch (_) { /* best-effort */ }
         portReservation = null;
       }
+      if (panelPortReservation) {
+        try { await panelPortReservation.release(); } catch (_) { /* best-effort */ }
+        panelPortReservation = null;
+      }
       if (rollbackCredential && provisionalPort) {
         try {
           await pairFetch(`http://127.0.0.1:${provisionalPort}/pair/cancel`, {
@@ -296,6 +301,26 @@ function createPairHandler(deps) {
       // --- tunnel-final: connessione privata, solo -L -------------------------
       // reversePort resta negoziata per un futuro Share opt-in, ma il builder
       // non emette -R finche' shared non diventa true.
+      //
+      // Porta pannello del peer (P0 stessa-origin, meta' remota): se il peer
+      // l'ha annunciata nel join, si riserva una controparte locale e la
+      // coppia entra nel record — il supervisor finale inoltrera' entrambe.
+      // Nessuna porta disponibile NON fa fallire il pairing: il pannello e
+      // un'estensione, il legame viene prima. Stesso patto di publicKey: un
+      // peer piu' vecchio non annuncia e si accoppia esattamente come prima.
+      const peerPanelPort = nodesStore.isPort(joined.panelPort) ? joined.panelPort : null;
+      let panelLocalPort = null;
+      if (peerPanelPort) {
+        try {
+          panelPortReservation = await nodesCmds.reserveLocalPort(
+            nodesStore.loadStoreStrict(nodesPath),
+            { createServerImpl: seams.createPanelPortServer || seams.createPortServer },
+          );
+          panelLocalPort = panelPortReservation.port;
+        } catch (_) {
+          panelPortReservation = null; panelLocalPort = null; // fail-open dichiarato: via storica
+        }
+      }
       st = nodesStore.loadStoreStrict(nodesPath);
       if (joinedPool && st.schemaVersion < nodesStore.SCHEMA_VERSION) {
         // This device is a client of the hub-owned pool.  It persists the
@@ -313,8 +338,15 @@ function createPairHandler(deps) {
           : {}),
         ...(joinedPool ? { reversePool: joinedPool } : {}),
         ...(joinedRoles ? { roles: joinedRoles, rolesKnown: true } : {}),
+        ...(panelLocalPort ? { panelLocalPort, panelRemotePort: peerPanelPort } : {}),
       });
       nodesStore.atomicWriteStore(nodesPath, st);
+      // La riserva della porta pannello ha protetto la scelta fino alla
+      // scrittura: come la porta di controllo, si rilascia prima dello spawn.
+      if (panelPortReservation) {
+        try { await panelPortReservation.release(); } catch (_) { /* best-effort */ }
+        panelPortReservation = null;
+      }
       nodesTunnel.stopTunnel({ home, name: b.name });
       const finalStart = nodesTunnel.startForward({
         home, node: nodesStore.getNode(st, b.name), localAppPort: runtimePort(),

package/lib/settings/public-peering-routes.js

@@ -28,6 +28,12 @@ function publicPeeringRoutes(deps = {}) {
   const invitesPath = cfg.invitesPath || peering.defaultInvitesPath(home);
   const pendingPath = cfg.pendingPairingsPath || peering.defaultPendingPath(home);
   const reversePoolLedgerPath = deps.reversePoolLedgerPath || cfg.reversePoolLedgerPath || reversePool.defaultLedgerPath(home);
+  // Porta pannello di QUESTA installazione, letta al momento del join: non
+  // cfg.panelPort (che resta al valore richiesto anche quando il listener non
+  // e' mai partito), ma la porta su cui il panelServer ascolta ADESSO. Null
+  // quando il pannello e' spento per questo run: meglio il silenzio che far
+  // inoltrare al client una porta che nessuno ascolta.
+  const panelPortLive = typeof deps.panelPort === 'function' ? deps.panelPort : () => null;
   // La pubblica di questa installazione, per il passo 1 del modello di
   // autorita'. Si legge PIGRAMENTE e non all'avvio del router: un errore sul
   // file di chiave non deve impedire di montare le route di pairing — il passo
@@ -170,13 +176,19 @@ function publicPeeringRoutes(deps = {}) {
         return res.status(410).json({ error: 'invito scaduto o gia usato' });
       }
       const mia = localPublicKey();
+      const pannello = panelPortLive();
       res.json({ paired: true, instanceId: poolStore.nodeId, reversePort,
         reversePool: { base: assignedPool.base, slots: assignedPool.slots.map((slot) => slot.port) },
         credential, roles: readRoles(configPath),
         // Lo scambio e' simmetrico e avviene QUI, dentro l'atto che consuma
         // l'invito monouso: e' il solo momento in cui l'operatore ha deciso,
         // su entrambe le macchine, che questi due nodi si conoscono.
-        ...(mia ? { publicKey: mia } : {}) });
+        ...(mia ? { publicKey: mia } : {}),
+        // Stesso patto della pubblica: la porta pannello si annuncia nel
+        // join, e un peer piu' vecchio che non la capisce si accoppia come
+        // sempre. Il campo assente non e' un errore, e' una versione (o un
+        // pannello spento per questo run).
+        ...(pannello ? { panelPort: pannello } : {}) });
     } catch (e) {
       if (credential) try { peering.consumePending({ pendingPath, credential, now }); } catch (_) {}
       res.status(e.status || 500).json({ error: String(e.message || e), ...(e.code ? { code: e.code } : {}) });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/nexuscrew",
-  "version": "0.8.58",
+  "version": "0.9.1",
   "description": "Faithful browser tmux client — attach to live sessions over a real PTY, localhost-only, mobile-easy",
   "main": "lib/server.js",
   "bin": {