@mmmbuto/nexuscrew 0.8.58 → 0.9.1

package/lib/live-host/routes.js

@@ -0,0 +1,190 @@
+'use strict';
+// lib/live-host/routes.js — route /api/live-host (control plane della designazione).
+//
+// Montate dietro requireToken (come /api/cells, /api/fleet): solo il token del nodo
+// passa. NON sono proxabili via /node/<name>: il blocklist local-only del proxy nega
+// /api/live-host li' (v. lib/proxy/node-proxy.js). Sono pero' raggiungibili via
+// /api/route (0.9.1), la via allowlistata della federazione, dietro un permesso
+// per-peer negato di default (liveHostAccess, v. lib/proxy/federation.js) — sullo
+// stesso modello del pannello: concesso dal nodo che POSSIEDE la cella, mai da chi
+// chiede. Senza quel permesso il peer riceve un rifiuto che nomina la causa
+// (`live-host-not-granted`), non un silenzio.
+//
+// Invarianti (contratto rev6 §2, §9):
+//   - hostCell unico per nodo, CAS su revision (due designazioni concorrenti non
+//     lasciano due celle rosse).
+//   - API-first: la route e' l'unica autorita'; il frontend riflette la risposta e
+//     su errore resta sullo stato precedente (nessun ottimismo qui — la logica UI
+//     sta nel modulo frontend host-designation.js).
+//   - Cella inattiva PRESERVA la designazione: lo store non cancella mai hostCell per
+//     inattivita; `eligible` e' derivato dal roster al momento del GET.
+//   - readonly => 403 su designate/clear.
+
+const express = require('express');
+const { CELL_ID_RE } = require('./store.js');
+
+// Ricava l'elenco celle LOCALI dal fleet (definizioni, attive e non). Una cella
+// federata non compare qui: e' il check che chiude "designa solo una cella di questo
+// nodo". Ritorna null se il fleet non e' interrogabile (la route decide come gestirlo).
+async function localCells(fleetP) {
+  const fleet = await fleetP;
+  if (!fleet || fleet.available !== true) return null;
+  const statusFn = fleet && (typeof fleet.status === 'function' ? fleet.status : fleet.cellStatus);
+  if (typeof statusFn !== 'function') return null;
+  const st = await statusFn.call(fleet);
+  return Array.isArray(st && st.cells) ? st.cells : [];
+}
+
+function isActive(cell) {
+  return !!(cell && cell.active === true && cell.tmux !== false);
+}
+
+// --- Seam lease↔designazione (2026-08-15, decisione di Dev: grace = false) -----
+//
+// L'idoneita' dell'host designato non e' piu' solo «sessione tmux viva»: con
+// remain-on-exit la sessione sopravvive alla morte del supervisore, e la
+// garanzia «l'host designato e' vivo» la puo' dare SOLO il lease (fetta 2b: il
+// leaseId e' FIRMATO nel proof, quindi lo stato del lease identifica senza
+// ambiguita' chi lo detiene). Regole:
+//   - eligible = attiva AND lease 'live'. In grace NON c'e' garanzia: eligible
+//     false, ma host.lease='grace' dice «recupero in corso» — chi legge
+//     distingue «non idonea perche' morta» da «non idonea perche' in recupero».
+//   - I cinque stati (live|grace|expired|none|unavailable) restano DISTINCTI
+//     fino a chi legge: collassarli e' rifare il difetto a un piano piu' su.
+//   - FALLBACK FAIL-OPEN DICHIARATO: senza fleet.lease (installazione senza
+//     lease) eligible torna tmux-only e host.lease='unavailable'. Non e' «va
+//     bene lo stesso»: e' «la garanzia non e' disponibile qui», detto esplicito
+//     perche' un eligible=true silenzioso verrebbe letto come confermata.
+//   - hostCell resta PRESERVATO in ogni caso (invariante dello store): oscilla
+//     l'idoneita', non la scelta dell'operatore.
+function hostLeaseState(fleet, hostCell) {
+  if (hostCell == null) return null;
+  const lease = fleet && fleet.lease;
+  if (!lease || typeof lease.status !== 'function') return 'unavailable';
+  const st = lease.status(hostCell);
+  return (st && typeof st.state === 'string') ? st.state : 'none';
+}
+
+function eligibleOf(fleet, cell, hostCell) {
+  const leaseState = hostLeaseState(fleet, hostCell);
+  if (leaseState === null) return false; // senza soggetto non c'e' idoneita'
+  if (leaseState === 'unavailable') return isActive(cell); // fail-open dichiarato
+  return isActive(cell) && leaseState === 'live';
+}
+
+function liveHostRoutes({ fleetP, store, readonly = () => false, now = () => Date.now(), bridge = null }) {
+  const r = express.Router();
+
+  // GET /api/live-host — { hostCell, revision, eligible, host: {lease}, at }.
+  // hostCell e revision vengono dallo store (preservato); eligible e' la verita'
+  // COMPOSTA roster+lease (si veda hostLeaseState sopra); host.lease espone lo
+  // stato del lease della cella designata, distinto, perche' chi legge distingue.
+  r.get('/', async (_req, res) => {
+    try {
+      const snap = store.snapshot();
+      let eligible = false;
+      let lease = null;
+      if (snap.hostCell != null) {
+        const fleet = await fleetP.catch(() => null);
+        const cells = await localCells(fleetP).catch(() => []);
+        const cell = Array.isArray(cells) ? cells.find((c) => c && c.cell === snap.hostCell) : null;
+        lease = hostLeaseState(fleet, snap.hostCell);
+        eligible = eligibleOf(fleet, cell, snap.hostCell);
+      }
+      res.json({ hostCell: snap.hostCell, revision: snap.revision, eligible, host: { lease }, at: now() });
+    } catch (e) {
+      res.status(500).json({ error: String(e && e.message || e) });
+    }
+  });
+
+  // POST /api/live-host/designate { cellId, expectedRevision }.
+  // expectedRevision e' OBBLIGATORIO e integer (>=0): nessun CAS permissivo, la UI
+  // legge sempre la revision dal GET prima di scrivere (stato iniziale = 0).
+  // cellId deve appartenere al roster LOCALE di questo nodo — chiamante locale
+  // o peer federato con liveHostAccess, la cella designabile e' sempre e solo
+  // una di QUESTO nodo, mai una del chiamante.
+  r.post('/designate', express.json({ limit: '4kb' }), async (req, res) => {
+    if (readonly()) return res.status(403).json({ error: 'READONLY: designazione cella ospite bloccata' });
+    const body = req.body || {};
+    if (Object.keys(body).some((k) => !['cellId', 'expectedRevision'].includes(k))
+      || typeof body.cellId !== 'string' || !CELL_ID_RE.test(body.cellId)
+      || !(Number.isInteger(body.expectedRevision) && body.expectedRevision >= 0)) {
+      return res.status(400).json({ error: 'designazione non valida' });
+    }
+    try {
+      const fleet = await fleetP.catch(() => null);
+      const cells = await localCells(fleetP);
+      if (cells === null) return res.status(503).json({ error: 'fleet non disponibile, riprova' });
+      const cell = cells.find((c) => c && c.cell === body.cellId);
+      if (!cell) return res.status(404).json({ error: 'cella non appartiene a questo nodo' });
+      const result = await store.compareAndSet(body.expectedRevision, body.cellId);
+      if (!result.ok) return res.status(409).json({
+        error: 'revision superata: rileggi e riprova', revision: result.revision, hostCell: result.hostCell,
+      });
+      res.json({
+        hostCell: result.hostCell, revision: result.revision,
+        eligible: eligibleOf(fleet, cell, result.hostCell),
+        host: { lease: hostLeaseState(fleet, result.hostCell) },
+        at: now(),
+      });
+    } catch (e) {
+      res.status(500).json({ error: String(e && e.message || e) });
+    }
+  });
+
+  // POST /api/live-host/clear { expectedRevision } — rimuove la designazione (CAS).
+  r.post('/clear', express.json({ limit: '4kb' }), async (req, res) => {
+    if (readonly()) return res.status(403).json({ error: 'READONLY: rimozione cella ospite bloccata' });
+    const body = req.body || {};
+    if (Object.keys(body).some((k) => k !== 'expectedRevision')
+      || !(Number.isInteger(body.expectedRevision) && body.expectedRevision >= 0)) {
+      return res.status(400).json({ error: 'rimozione non valida' });
+    }
+    try {
+      const result = await store.compareAndSet(body.expectedRevision, null);
+      if (!result.ok) return res.status(409).json({
+        error: 'revision superata: rileggi e riprova', revision: result.revision, hostCell: result.hostCell,
+      });
+      res.json({ hostCell: null, revision: result.revision, at: now() });
+    } catch (e) {
+      res.status(500).json({ error: String(e && e.message || e) });
+    }
+  });
+
+  // POST /api/live-host/bridge — risolve il puntamento per l'avvio di una Live
+  // (fetta 3). La richiesta NON è parametrizzabile: la designazione è la
+  // condizione (LC3) e nessun chiamante può scegliere il target (MC3.4). Il
+  // ponte risponde sempre 200: i `none` con reason sono esiti legittimi e
+  // distinti (nessuna designazione / cella non idonea / fallback), non errori.
+  // Body opzionale e vuoto: un body con campi è un 400, non viene ignorato.
+  r.post('/bridge', express.json({ limit: '1kb' }), async (req, res) => {
+    const body = req.body || {};
+    if (Object.keys(body).length > 0) return res.status(400).json({ error: 'la risoluzione non accetta parametri' });
+    if (readonly()) return res.json({ mode: 'none', reason: 'readonly', at: now() });
+    if (!bridge) return res.status(503).json({ error: 'ponte Live non configurato su questo nodo' });
+    try {
+      const result = await bridge.resolveForLive();
+      res.json(result);
+    } catch (e) {
+      // Il contratto (MC1.5) vuole che un guasto del ponte non fermi la Live:
+      // anche l'inaspettato collassa in `none` dichiarato, mai un 500.
+      // `bridge-error` e' l'ultima rete: un'eccezione che nessun ramo previsto ha
+      // classificato. Va NOMINATA come le altre, non lasciata fuori dall'elenco
+      // — una causa non dichiarata e' una causa che nessuno cerchera'.
+      res.json({ mode: 'none', reason: 'bridge-error', detail: String(e && e.message || e), at: now() });
+    }
+  });
+
+  // Stesso body-error handling di cellsRoutes: payload troppo grande / JSON invalido.
+  r.use((err, _req, res, _next) => {
+    if (err && (err.type === 'entity.too.large' || err.status === 413)) {
+      return res.status(413).json({ error: 'body troppo grande' });
+    }
+    if (err instanceof SyntaxError) return res.status(400).json({ error: 'JSON non valido' });
+    return res.status(err.status || 400).json({ error: String(err.message || err) });
+  });
+
+  return r;
+}
+
+module.exports = { liveHostRoutes };

package/lib/live-host/store.js

@@ -0,0 +1,96 @@
+'use strict';
+// lib/live-host/store.js — stato della designazione "cella ospite Live" di un nodo.
+//
+// Un solo hostCell per nodo (contratto rev6 §2.2): chiave unica, non una convenzione
+// ripetuta in N punti. Lo stato vive su disco (sopravvive a riavvii di cella e di
+// NexusCrew) e l'aggiornamento e' un CAS su `revision`: due designazioni concorrenti
+// non possono lasciare due celle rosse — il perdente rilegge la revision e rinuncia.
+//
+// La designazione e' PURAMENTE un marker di scelta del nodo. L'eligibilita' (la cella
+// e' anche attiva in questo momento?) e' derivata dal roster Fleet e non si persiste
+// qui: `active` resta `sessions.has(tmuxSession)` (runtime.js), la marcatura non lo
+// tocca. Una cella spenta PRESERVA la designazione — resta hostCell, semplicemente
+// ineligible finche' non torna attiva.
+
+const path = require('node:path');
+const os = require('node:os');
+const { readJsonSafe, atomicWriteJson } = require('../notify/persist.js');
+
+const CELL_ID_RE = /^[A-Za-z0-9._-]{1,32}$/;
+
+// Path del file di stato: override esplicito -> dir del token (~/.nexuscrew) -> home.
+// Stessa convenzione di consentPath/groupsPath, cosi' i test isolano lo stato via
+// cfg.tokenPath senza toccare la home reale.
+function liveHostPath(cfg = {}, home = (cfg.home || os.homedir())) {
+  if (cfg.liveHostPath) return cfg.liveHostPath;
+  if (cfg.tokenPath) return path.join(path.dirname(cfg.tokenPath), 'live-host.json');
+  return path.join(home, '.nexuscrew', 'live-host.json');
+}
+
+// Normalizza il grezzo letto da disco in {revision, hostCell}. Un file assente o
+// garbage (readJsonSafe -> {}) e' lo stato iniziale legittimo {0, null}; un hostCell
+// non-string o fuori formato viene chiuso a null senza promuovere garbage.
+function normalize(raw) {
+  const revision = raw && Number.isInteger(raw.revision) && raw.revision >= 0 ? raw.revision : 0;
+  const hostCell = raw && typeof raw.hostCell === 'string' && CELL_ID_RE.test(raw.hostCell)
+    ? raw.hostCell : null;
+  return { revision, hostCell };
+}
+
+function readLiveHost(filePath) {
+  return normalize(readJsonSafe(filePath));
+}
+
+// createLiveHostStore({filePath, now}) — CAS store.
+//
+// read+compare+write sono sincroni, ma le route sono async e due richieste concorrenti
+// possono entrambe aver letto la stessa revision prima che una delle due scriva. La
+// promise-chain serializza la sezione read-modify-write: nessun await dentro la
+// callback, quindi il check e la scrittura sono una sola transazione atomica rispetto
+// agli altri CAS in volo. Esattamente uno dei due CAS concorrenti avanza la revision.
+function createLiveHostStore({ filePath, now = () => Date.now() } = {}) {
+  if (!filePath || typeof filePath !== 'string') {
+    throw new Error('createLiveHostStore: filePath richiesto');
+  }
+  let chain = Promise.resolve();
+
+  function serialize(fn) {
+    const run = chain.then(fn);
+    // La catena non si rompe mai su un errore di un CAS: un fallimento non deve
+    // bloccare i successivi (un CAS che lancia risolve comunque il run).
+    chain = run.then(() => {}, () => {});
+    return run;
+  }
+
+  // Snapshot read-only corrente (dopo normalizzazione).
+  function snapshot() {
+    return readLiveHost(filePath);
+  }
+
+  // CAS: scrive nextHostCell (stringa valida | null) solo se la revision corrente
+  // coincide con expectedRevision. Ritorna:
+  //   { ok:true, revision:<nuova>, hostCell:<nuovo>, at }
+  //   { ok:false, conflict:true, revision:<corrente>, hostCell:<corrente> }
+  // Fail-closed: expectedRevision deve essere un integer che coincide con la
+  // revision corrente. Uno expected non-integer (es. undefined) NON e' un
+  // lasciapassare: e' un conflitto. Lo stato iniziale e' revision 0 ed e'
+  // conoscibile (la UI lo legge dal GET), quindi non esiste un "primo scrittore
+  // senza revision" legittimo: l'assenza del campo va rifiutata, non tollerata.
+  function compareAndSet(expectedRevision, nextHostCell) {
+    return serialize(() => {
+      const cur = readLiveHost(filePath);
+      if (!Number.isInteger(expectedRevision) || cur.revision !== expectedRevision) {
+        return { ok: false, conflict: true, revision: cur.revision, hostCell: cur.hostCell };
+      }
+      const hostCell = nextHostCell === null ? null
+        : (typeof nextHostCell === 'string' && CELL_ID_RE.test(nextHostCell) ? nextHostCell : null);
+      const revised = { revision: cur.revision + 1, hostCell, updatedAt: now() };
+      atomicWriteJson(filePath, revised);
+      return { ok: true, revision: revised.revision, hostCell: revised.hostCell, at: revised.updatedAt };
+    });
+  }
+
+  return { snapshot, compareAndSet, filePath };
+}
+
+module.exports = { createLiveHostStore, liveHostPath, readLiveHost, normalize, CELL_ID_RE };

package/lib/mcp/tools.js

@@ -863,6 +863,57 @@ const TOOLS = [
       return { receipt };
     },
   },
+  // --- lease Live del child (fetta 2b, contratto rev1 B5) ----------------------
+  // Tre metodi DISTINTI perche' i valori di ritorno non mentono l'uno con l'altro:
+  // solo register puo' rispondere {status:'pending'} (join non ancora tracciato);
+  // refresh su registration viva risponde {status:'live', proof} e non ha stati
+  // pendenti; recovery riprende la STESSA incarnazione con un proof scaduto da
+  // poco. L'authorizer di refresh/recovery e' il proof HMAC firmato dal verifier
+  // per-installazione del server; la cella e' la sessione del chiamante.
+  {
+    name: 'nc_lease_register',
+    description: 'Registra questa cella al lease Live del nodo: crea una registration con incarnationId propria e consegna il primo proof child. Risponde {status:"pending"} se la cella non e\' ancora tracciata dal lease del supervisore: riprova dopo retryAfterMs.',
+    inputSchema: { type: 'object', properties: {} },
+    async handler(_args, ctx) {
+      const identity = await ctx.identity();
+      const session = requireSession(identity.session, 'nc_lease_register', identity.code);
+      return ctx.api('POST', '/api/lease/register', { session });
+    },
+  },
+  {
+    name: 'nc_lease_refresh',
+    description: 'Rinnova la registration child presentando l\'ultimo proof detenuto: risponde {status:"live"} con un proof nuovo. Mai pending: senza registration risponde {status:"no-registration"} (usa nc_lease_register).',
+    inputSchema: {
+      type: 'object',
+      properties: { proof: { type: 'object', description: 'ultimo proof ricevuto (register o refresh precedente), tale e quale' } },
+      required: ['proof'],
+    },
+    async handler(args, ctx) {
+      const identity = await ctx.identity();
+      const session = requireSession(identity.session, 'nc_lease_refresh', identity.code);
+      const proof = args.proof && typeof args.proof === 'object' && !Array.isArray(args.proof)
+        ? args.proof : null;
+      if (!proof) throw new Error('parametro "proof" obbligatorio (oggetto ricevuto da register/refresh)');
+      return ctx.api('POST', '/api/lease/refresh', { session, proof });
+    },
+  },
+  {
+    name: 'nc_lease_recovery',
+    description: 'Riprende la registration child dopo un gap: presenta l\'ultimo proof (accettato anche scaduto da poco) e riceve un proof nuovo con la STESSA incarnazione. Ogni presentazione conta come attempt: oltre il cap serve nc_lease_register.',
+    inputSchema: {
+      type: 'object',
+      properties: { proof: { type: 'object', description: 'ultimo proof detenuto, anche scaduto da poco' } },
+      required: ['proof'],
+    },
+    async handler(args, ctx) {
+      const identity = await ctx.identity();
+      const session = requireSession(identity.session, 'nc_lease_recovery', identity.code);
+      const proof = args.proof && typeof args.proof === 'object' && !Array.isArray(args.proof)
+        ? args.proof : null;
+      if (!proof) throw new Error('parametro "proof" obbligatorio (oggetto ricevuto in precedenza)');
+      return ctx.api('POST', '/api/lease/recovery', { session, proof });
+    },
+  },
 ];
 
 module.exports = {

package/lib/nodes/commands.js

@@ -99,8 +99,14 @@ function bindLocalPort(port, createServerImpl = net.createServer) {
 // Selezione OS-aware per il pairing: nodes.json evita collisioni logiche, il
 // bind reale evita porte gia' occupate da processi estranei. La socket resta
 // riservata fino all'avvio del supervisor SSH e viene poi rilasciata una volta.
+// Ogni LISTENER locale conta: localPort di controllo e panelLocalPort inoltrata
+// condividono lo stesso loopback, e la stessa regola di univocita' dello store.
 async function reserveLocalPort(st, opts = {}) {
-  const used = new Set((st.nodes || []).map((n) => n.localPort));
+  const used = new Set();
+  for (const n of st.nodes || []) {
+    if (Number.isInteger(n.localPort)) used.add(n.localPort);
+    if (Number.isInteger(n.panelLocalPort)) used.add(n.panelLocalPort);
+  }
   const createServerImpl = opts.createServerImpl || net.createServer;
   for (let port = opts.start || LOCAL_PORT_BASE; port <= 65535; port += 1) {
     if (used.has(port)) continue;
@@ -279,15 +285,27 @@ function nodesEdit(opts) {
   // Lo scope celle vale per QUALUNQUE peer accoppiato, in entrambe le
   // direzioni: riguarda chi accede alle celle di questo nodo, non chi ha
   // aperto il tunnel.
+  // `panelAccess` segue la stessa regola dello scope celle: riguarda chi accede
+  // ai PANNELLI di questo nodo, non chi ha aperto il tunnel — quindi vale in
+  // entrambe le direzioni. `liveHostAccess` e' identica: riguarda chi puo'
+  // designare la cella ospite Live di QUESTO nodo, non chi ha aperto il tunnel.
   const allowed = node.direction === 'inbound'
-    ? new Set(['label', 'visibility', 'selected', 'cellVisibility', 'cells'])
-    : new Set(['label', 'ssh', 'sshPort', 'autostart', 'cellVisibility', 'cells']);
+    ? new Set(['label', 'visibility', 'selected', 'cellVisibility', 'cells', 'panelAccess', 'liveHostAccess'])
+    : new Set(['label', 'ssh', 'sshPort', 'autostart', 'cellVisibility', 'cells', 'panelAccess', 'liveHostAccess']);
   const keys = Object.keys(supplied);
   const invalid = keys.find((key) => !allowed.has(key));
   if (invalid) {
     log(`nodes edit: campo "${invalid}" non modificabile per un peer ${node.direction}`);
     return { code: 1, reason: 'field-not-editable' };
   }
+  if (Object.hasOwn(supplied, 'panelAccess') && typeof supplied.panelAccess !== 'boolean') {
+    log('nodes edit: panelAccess vuole un booleano');
+    return { code: 1, reason: 'invalid-panel-access' };
+  }
+  if (Object.hasOwn(supplied, 'liveHostAccess') && typeof supplied.liveHostAccess !== 'boolean') {
+    log('nodes edit: liveHostAccess vuole un booleano');
+    return { code: 1, reason: 'invalid-live-host-access' };
+  }
   if (keys.length === 0) { log('nodes edit: nessuna modifica richiesta'); return { code: 1, reason: 'empty-patch' }; }
   const patch = { ...supplied };
   if (Object.hasOwn(patch, 'label')) {

package/lib/nodes/store.js

@@ -112,6 +112,19 @@ const NODE_KEYS = new Set([
   // Quali CELLE di questo nodo il peer puo' vedere. Distinto da `visibility`,
   // che governa il TRANSITO (attraverso chi passa il traffico) e non l'accesso.
   'cellVisibility', 'cells',
+  // Se questo peer puo' aprire i PANNELLI delle celle di questo nodo. Distinto
+  // da `cellVisibility`, che dice quali celle il peer VEDE: dietro un pannello
+  // c'e' un browser con sessioni gia' autenticate, e un accesso di quel tipo non
+  // si revoca cambiando una chiave. Il resto del modello tratta un peer pairato
+  // come l'operatore stesso; qui no, e di proposito: default NEGATO, si concede
+  // per singolo nodo.
+  'panelAccess',
+  // Se questo peer puo' designare/leggere/rimuovere la cella ospite Live di
+  // questo nodo. Stessa forma di panelAccess e stessa ragione: la designazione
+  // e' un'azione del nodo che POSSIEDE la cella, non di chi la chiede — un peer
+  // pairato non la acquisisce diventando "trusted come l'operatore". Default
+  // NEGATO, si concede per singolo nodo.
+  'liveHostAccess',
   // Identita' crittografica del peer — passo 1 del modello di autorita'. Oggi
   // NON governa niente: si osserva e si registra. `keySource` distingue una
   // chiave legata al pairing (nello stesso atto in cui si e' deciso di fidarsi)
@@ -119,6 +132,13 @@ const NODE_KEYS = new Set([
   // grant potra' pretendere la prima. `keyConflict` conserva una chiave DIVERSA
   // vista dopo il legame, senza sostituire quella legata.
   'publicKey', 'keySource', 'keyBoundAt', 'keyConflict',
+  // P0 stessa-origin, meta' remota: la porta pannello del peer inoltrata sul
+  // NOSTRO loopback (panelLocalPort) e la sua origine remota (panelRemotePort).
+  // COPPIA obbligatoria: un -L ha due estremita', mezza coppia e' un forward
+  // impossibile, non "meno pannello". Campi assenti = peer accoppiato prima di
+  // questa negoziazione: via storica, nessun comportamento nuovo. Le porte non
+  // sono segreti (come localPort/remotePort, che stanno qui accanto).
+  'panelLocalPort', 'panelRemotePort',
 ]);
 
 // Nome di cella: stessa forma usata da fleet/definitions.js, cells/routes.js e
@@ -257,6 +277,14 @@ function parseNode(n, schemaVersion = SCHEMA_VERSION) {
     // requests the optional reverse (-R) channel. Old stores therefore migrate
     // safely to private without a schema bump.
     shared: n.shared === undefined ? false : n.shared,
+    // Default negato: un record esistente, scritto quando questo campo non
+    // c'era, NON acquisisce l'accesso ai pannelli per il fatto di essere gia'
+    // pairato. Migrazione silenziosa verso il permesso e' esattamente cio' che
+    // non deve succedere.
+    panelAccess: n.panelAccess === undefined ? false : n.panelAccess,
+    // Stessa regola, stesso motivo: un record senza il campo non acquisisce la
+    // designazione live per anzianita' del pairing.
+    liveHostAccess: n.liveHostAccess === undefined ? false : n.liveHostAccess,
     visibility: n.visibility || 'network',
   };
   if (!['auto', 'ssh', 'autossh', 'inbound'].includes(out.transport)) return null;
@@ -264,6 +292,8 @@ function parseNode(n, schemaVersion = SCHEMA_VERSION) {
   if (direction === 'outbound' && out.transport === 'inbound') return null;
   if (typeof out.autostart !== 'boolean') return null;
   if (typeof out.shared !== 'boolean') return null;
+  if (typeof out.panelAccess !== 'boolean') return null;
+  if (typeof out.liveHostAccess !== 'boolean') return null;
   if (!['network', 'relay-only', 'selected'].includes(out.visibility)) return null;
   if (identityFile) out.identityFile = identityFile;
   // Keep the old public field while reading v1 so old callers/tests and a
@@ -273,6 +303,16 @@ function parseNode(n, schemaVersion = SCHEMA_VERSION) {
     if (!isPort(n.reversePort)) return null;
     out.reversePort = n.reversePort;
   }
+  // Coppia pannello (P0 stessa-origin remota): o entrambe le porte o nessuna.
+  // Una sola meta' non viene indovinata — sarebbe un -L monco. E la porta
+  // locale del pannello non puo' stare su quella del control plane: ssh
+  // cadrebbe con ExitOnForwardFailure portandosi via il tunnel intero.
+  if (n.panelLocalPort !== undefined || n.panelRemotePort !== undefined) {
+    if (!isPort(n.panelLocalPort) || !isPort(n.panelRemotePort)) return null;
+    if (n.panelLocalPort === n.localPort) return null;
+    out.panelLocalPort = n.panelLocalPort;
+    out.panelRemotePort = n.panelRemotePort;
+  }
   if (n.reversePool !== undefined) {
     if (schemaVersion < SCHEMA_VERSION) return null;
     const parsedPool = parseReversePool(n.reversePool);
@@ -404,6 +444,13 @@ function parseStore(raw) {
       names.add(node.name);
       if (localPorts.has(node.localPort)) return null;   // ogni listener locale ha un solo owner
       localPorts.add(node.localPort);
+      if (node.panelLocalPort !== undefined) {
+        // La porta pannello inoltrata e' un ALTRO listener locale: stessa
+        // regola di localPort. Due nodi sulla stessa porta farebbero fallire
+        // il bind del secondo ssh al prossimo riavvio.
+        if (localPorts.has(node.panelLocalPort)) return null;
+        localPorts.add(node.panelLocalPort);
+      }
       if (node.nodeId) {
         if (node.nodeId === d.nodeId) return null;        // self-reference nei dati salvati
         if (ids.has(node.nodeId)) return null;            // nodeId remoto univoco
@@ -645,6 +692,8 @@ function redactNode(n) {
     transport: n.transport || 'ssh',
     autostart: !!n.autostart,
     shared: n.shared === true,
+    panelAccess: n.panelAccess === true,
+    liveHostAccess: n.liveHostAccess === true,
     visibility: n.visibility || 'network',
     hasToken: !!n.token, // presenza, non il valore
     paired: !!(n.token && n.acceptToken),
@@ -680,6 +729,14 @@ function redactNode(n) {
       ...(n.reversePool.lastAutoRotationAt === undefined ? {} : { lastAutoRotationAt: n.reversePool.lastAutoRotationAt }),
     };
   }
+  // La coppia pannello non e' un segreto (sono porte, come localPort): e' cio'
+  // che il frontend usa per mettere il frame del pannello remoto su un'origin
+  // diversa. Il nodo senza coppia non mostra campi: l'assenza SI' vede, perche'
+  // e' la via storica.
+  if (n.panelLocalPort !== undefined) {
+    out.panelLocalPort = n.panelLocalPort;
+    out.panelRemotePort = n.panelRemotePort;
+  }
   return out;
 }
 

package/lib/nodes/tunnel.js

@@ -44,6 +44,17 @@ function assertForwardSpec(node) {
   if (node.keyPath !== undefined && !store.isAbsPath(node.keyPath)) throw new Error('tunnel: keyPath non valido');
   if (node.reversePort !== undefined && !store.isPort(node.reversePort)) throw new Error('tunnel: reversePort non valida');
   if (node.localAppPort !== undefined && !store.isPort(node.localAppPort)) throw new Error('tunnel: localAppPort non valida');
+  // Coppia pannello (P0 stessa-origin remota): o entrambe o nessuna, e mai
+  // sulla porta locale del control plane — il bind conflitto abbatterebbe il
+  // tunnel intero con ExitOnForwardFailure.
+  if (node.panelLocalPort !== undefined || node.panelRemotePort !== undefined) {
+    if (!store.isPort(node.panelLocalPort) || !store.isPort(node.panelRemotePort)) {
+      throw new Error('tunnel: coppia pannello incompleta (panelLocalPort/panelRemotePort)');
+    }
+    if (node.panelLocalPort === node.localPort) {
+      throw new Error('tunnel: panelLocalPort coincide con localPort (bind conflitto)');
+    }
+  }
   if (node.shared === true && node.reversePort !== undefined && !node.reversePool && !store.isPort(node.localAppPort)) {
     throw new Error('tunnel: Share richiede localAppPort esplicita');
   }
@@ -64,8 +75,16 @@ function buildForwardArgs(node) {
   const reverse = node.shared === true && node.reversePort !== undefined && !node.reversePool ? [
     '-R', `127.0.0.1:${node.reversePort}:127.0.0.1:${node.localAppPort}`,
   ] : [];
+  // Second forward, same supervisor: the peer's panel port lands on our
+  // loopback so the browser gets a DIFFERENT origin for the panel. Absent pair
+  // (peer paired before this negotiation) emits nothing — the tunnel stays
+  // byte-identical to what it was.
+  const panel = node.panelLocalPort !== undefined && node.panelRemotePort !== undefined ? [
+    '-L', `127.0.0.1:${node.panelLocalPort}:127.0.0.1:${node.panelRemotePort}`,
+  ] : [];
   return SSH_BASE_OPTS.concat(transport, identity ? ['-i', identity] : [], [
     '-L', `127.0.0.1:${node.localPort}:127.0.0.1:${node.remotePort}`,
+    ...panel,
     ...reverse,
     node.ssh,
   ]);
@@ -568,7 +587,10 @@ function startTunnel(opts) {
   let pid = child && child.pid;
   const cleanupIfOwned = () => {
     const current = pidf.readPidfile(pidPath);
-    if (current && current.pid === pid && current.runId === runId) pidf.removePidfile(pidPath);
+    // allowLive: la garanzia e' il match pid+runId del NOSTRO spawn — il pidfile
+    // e' quello che questa via ha appena scritto per un figlio suo, che in questi
+    // rami d'errore e' stato appena segnato o non e' mai partito.
+    if (current && current.pid === pid && current.runId === runId) pidf.removePidfile(pidPath, { allowLive: true });
     removeStateIfOwned(home, name, { pid, runId });
   };
   if (child && typeof child.on === 'function') {