@mmmbuto/nexuscrew 0.9.52 → 0.9.54

package/lib/notify/event-feed-routes.js

@@ -118,7 +118,21 @@ function createEventFeedRoutes(deps) {
 
     const timeout = new Promise((resolve) => setTimeout(() => resolve('timeout'), SNAPSHOT_TIMEOUT_MS));
     const work = buildSnapshot(g);
-    const built = await Promise.race([work, timeout]);
+    let built;
+    try {
+      built = await Promise.race([work, timeout]);
+    } catch (e) {
+      // buildSnapshot rifiuta con un errore tipizzato quando non ha potuto
+      // leggere gli asks: nessun elenco è un elenco autorevole, quindi non
+      // si spedisce Nessuno snapshot — 503 con corpo minimo. Un 200, con
+      // qualunque corpo o marcatore, verrebbe deciso dai riceventi che non
+      // conoscono il validatore (0.9.51/0.9.52 decidono solo su res.ok).
+      if (e && e.reason === 'asks-unreadable') {
+        return res.status(503).json({ error: 'asks-unreadable' });
+      }
+      if (!res.headersSent) return res.status(503).json({ error: 'snapshot failed', reason: 'snapshot-error' });
+      return;
+    }
     if (built === 'timeout') {
       return res.status(503).json({ error: 'snapshot timeout', reason: 'snapshot-timeout' });
     }
@@ -188,8 +202,27 @@ function createEventFeedRoutes(deps) {
     const viewEpoch = st ? st.viewEpoch : null;
 
     // Asks: open asks of VISIBLE cells only, capped.
+    // Fail closed: se la LETTURA dello store lancia, il produttore non ha un
+    // elenco — ha un'assenza di informazione. Spedire asks:[] (con o senza
+    // marcatore) farebbe di quell'assenza un elenco AUTOREVOLE: i riceventi
+    // senza validatore (0.9.51/0.9.52: `if (!res.ok) continue;` e nient'altro)
+    // lo accetterebbero e reconcileImportedAsks chiuderebbe come 'dismissed'
+    // alias ancora aperti. Non si spedisce Nessuno snapshot: si rilancia un
+    // errore tipizzato che l'handler traduce in 503 {error:"asks-unreadable"}.
     let asks = [];
     try {
+      // Health gate PRIMA di list(): un asks.json ESISTENTE ma MALFORMATO
+      // (virgola finale, asks non array) produce un list() [] SILENZIOSO — senza
+      // eccezione. Quel vuoto viaggerebbe come elenco AUTOREVOLE e i riceventi
+      // senza validatore (0.9.51/0.9.52) chiuderebbero alias ancora aperti.
+      // Se lo store non e' leggibile, nessuno snapshot: stesso percorso del
+      // ramo che lancia sotto (503 asks-unreadable).
+      const h = deps.asksStore.health && deps.asksStore.health();
+      if (h && !h.readable) {
+        const err = new Error(`asks-unreadable: ${h.reason || 'store illeggibile'}`);
+        err.reason = 'asks-unreadable';
+        throw err;
+      }
       const self = typeof deps.localNodeId === 'function' ? deps.localNodeId() : null;
       const open = deps.asksStore.list({ open: true }) || [];
       const visible = open
@@ -204,7 +237,14 @@ function createEventFeedRoutes(deps) {
         .filter((a) => peer.allows({ scope: 'cell', cellId: deps.cellForSession(a.session) }))
         .slice(0, SNAPSHOT_MAX_ASKS);
       asks = visible;
-    } catch (_) { asks = []; }
+    } catch (e) {
+      // Una riga, nessun dato sensibile: il messaggio dello store e' gia'
+      // limitato a nome file e causa (v. persist.js readJsonSafe).
+      log(`event-feed: asks non leggibili, snapshot non autorevole per il peer ${peer.nodeId}: ${String((e && e.message) || e)}`);
+      const err = new Error('asks-unreadable');
+      err.reason = 'asks-unreadable';
+      throw err;
+    }
 
     // Notify history: local-only, ACL-filtered per envelope, capped.
     const notifications = deps.history.list()
@@ -251,7 +291,8 @@ function createEventFeedRoutes(deps) {
     if (asks.length >= SNAPSHOT_MAX_ASKS
       || notifications.length >= SNAPSHOT_MAX_NOTIFY
       || (fleetState.cells || []).length >= SNAPSHOT_MAX_CELLS) {
-      built.resyncRequired = true; // at a cap: the client must treat this as a floor, not a whole
+      // at a cap: the client must treat this as a floor, not a whole.
+      built.resyncRequired = true;
     }
     return built;
   }

package/lib/notify/persist.js

@@ -14,17 +14,21 @@ const crypto = require('node:crypto');
 // deve emergere, non essere nascosto da un chmod automatico).
 // Restano NON-errori: file assente ({} — stato iniziale legittimo) e JSON
 // malformato ({} — garbage non deve crashare il server, e non e' un leak).
-function readJsonSafe(p) {
-  let fd;
-  try {
-    fd = fs.openSync(p, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
-  } catch (e) {
-    if (e.code === 'ENOENT') return {};
-    if (e.code === 'ELOOP') {
-      throw new Error(`refuse to read ${path.basename(p)}: symlink (atteso file regolare)`);
-    }
-    throw e;
-  }
+
+// Apre il file segreto con le guardie di sicurezza (O_NOFOLLOW + fstat sullo
+// STESSO fd, owner, mode 0600). Le guardie LANCIANO come in readJsonSafe: un
+// symlink, un tipo non regolare, un owner inatteso o permessi larghi devono
+// emergere, non essere riparati in silenzio. Ritorna l'fd aperto; il chiamante
+// chiude. Propaga ENOENT/ELOOP dal openSync (gestiti dai due read).
+function openSecured(p) {
+  const fd = fs.openSync(p, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+  // Le guardie dopo l'open (fstat, tipo, owner, mode) possono lanciare. L'fd e'
+  // gia' aperto: se uscissimo senza chiuderlo qui, i finally dei reader non lo
+  // vedrebbero (openSecured e' lanciata prima dell'assegnazione del loro `fd`),
+  // e ogni rifiuto lascerebbe un fd aperto. Con 20 rifiuti di fila (file 0644,
+  // p.es. un asks.json ripristinato da un backup senz'0600) sono 20 fd persi.
+  // Chiudiamo su OGNI errore delle guardie e rilanciamo: il contratto (apre o
+  // lancia, mai mezzo) resta, senza leak.
   try {
     const st = fs.fstatSync(fd);
     if (!st.isFile()) {
@@ -39,6 +43,25 @@ function readJsonSafe(p) {
     if ((st.mode & 0o077) !== 0) {
       throw new Error(`refuse to read ${path.basename(p)}: permessi troppo larghi (mode ${(st.mode & 0o777).toString(8)}, atteso 0600)`);
     }
+  } catch (e) {
+    try { fs.closeSync(fd); } catch (_) { /* best-effort */ }
+    throw e;
+  }
+  return fd;
+}
+
+function readJsonSafe(p) {
+  let fd;
+  try {
+    fd = openSecured(p);
+  } catch (e) {
+    if (e.code === 'ENOENT') return {};
+    if (e.code === 'ELOOP') {
+      throw new Error(`refuse to read ${path.basename(p)}: symlink (atteso file regolare)`);
+    }
+    throw e;
+  }
+  try {
     let obj;
     try { obj = JSON.parse(fs.readFileSync(fd, 'utf8')); }
     catch (_) { return {}; } // garbage JSON: non un problema di sicurezza
@@ -48,6 +71,40 @@ function readJsonSafe(p) {
   }
 }
 
+// Variante STRETTA di readJsonSafe: distingue assente / valido / malformato.
+// Stesse guardie di sicurezza (lanciano come readJsonSafe). Diverso trattamento
+// di ENOENT e JSON malformato/non-oggetto: NON collassano in {} — restituiscono
+// uno stato esplicito, cosi' il chiamante (asks.js) puo' rifiutare le mutazioni
+// invece di sovrascrivere un file malformato con un defaults vuoto (che
+// cancellerebbe le domande aperte).
+//   absent    -> { state: 'absent' }                  (file non esiste)
+//   ok        -> { state: 'ok', value }               (JSON valido, oggetto)
+//   malformed -> { state: 'malformed', reason }       (parse error o non-oggetto)
+function readJsonStrict(p) {
+  let fd;
+  try {
+    fd = openSecured(p);
+  } catch (e) {
+    if (e.code === 'ENOENT') return { state: 'absent' };
+    if (e.code === 'ELOOP') {
+      throw new Error(`refuse to read ${path.basename(p)}: symlink (atteso file regolare)`);
+    }
+    throw e;
+  }
+  try {
+    let obj;
+    try { obj = JSON.parse(fs.readFileSync(fd, 'utf8')); }
+    catch (e) { return { state: 'malformed', reason: `JSON malformato: ${String((e && e.message) || e)}` }; }
+    if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
+      const tipo = obj === null ? 'null' : Array.isArray(obj) ? 'array' : typeof obj;
+      return { state: 'malformed', reason: `non e' un oggetto JSON (tipo ${tipo})` };
+    }
+    return { state: 'ok', value: obj };
+  } finally {
+    try { fs.closeSync(fd); } catch (_) { /* best-effort */ }
+  }
+}
+
 // Scrittura atomica 0600. Rifiuta un target symlink preesistente (ENOENT ok).
 function atomicWriteJson(p, obj) {
   try {
@@ -70,4 +127,4 @@ function atomicWriteJson(p, obj) {
   }
 }
 
-module.exports = { readJsonSafe, atomicWriteJson };
+module.exports = { readJsonSafe, readJsonStrict, atomicWriteJson };

package/lib/notify/routes.js

@@ -451,6 +451,20 @@ function notifyRoutes({
           const closed = asks.closeImported({
             ownerId: owner, ownerAskId: b.askId, outcome: b.closeOutcome,
           });
+          // closeImported rifiuta ({ok:false, reason:'store-unreadable'}) se lo
+          // store locale e' illeggibile: l'alias NON e' stato chiuso. Rispondere
+          // comunque 200 'delivered' nasconderebbe il fallimento al mittente: il
+          // dispatcher (lib/audio/dispatch.js:91) traduce un 5xx in
+          // {status:'unreachable'} — FUORI da DONE/FINAL (closure-retry.js:37-38)
+          // — cosi' la coda di recapito lato owner ritenta dopo la riparazione.
+          // 'refused' (403/404/409 -> dispatch.js:88) e' FINALE e non va usato:
+          // il tempo non ripara un ACL deny, ma ripara uno store illeggibile.
+          // No-op idempotente (closed.ok && !closed.changed, store leggibile,
+          // alias gia' chiuso o assente) resta 200 delivered come oggi.
+          if (closed.ok === false) {
+            const reason = closed.reason || 'store-unreadable';
+            return res.status(503).json({ status: 'unavailable', reason });
+          }
           if (closed.changed && closed.ask) {
             // Il frame porta l'id LOCALE: e' quello con cui questa UI identifica
             // la card, e senza di esso la card resterebbe a schermo.
@@ -573,7 +587,11 @@ function notifyRoutes({
       // chiusura mai recapitata (peer spento mentre l'owner chiudeva): senza,
       // l'alias resta aperto per sempre e la card mente. Best-effort: un owner
       // irraggiungibile non chiude nulla e non fa fallire la lettura.
-      if (reconcileImported) { try { await reconcileImported(); } catch (_) {} }
+      // Best-effort resta il contratto (un owner irraggiungibile non fa
+      // fallire la lettura), ma NON in silenzio: la causa si logga.
+      if (reconcileImported) {
+        try { await reconcileImported(); } catch (e) { try { log(`riconciliazione ask importate fallita: ${String((e && e.message) || e)}`); } catch (_) {} }
+      }
       // Recapito recuperabile, lato OWNER: i peer che erano spenti quando la
       // chiusura e' partita vengono ritentati ADESSO. Chi legge lo stato sta
       // guardando le card, ed e' esattamente il momento in cui una card

package/lib/prefs/routes.js

@@ -0,0 +1,52 @@
+'use strict';
+const express = require('express');
+const store = require('./store.js');
+
+function httpError(status, message, extra) { const e = new Error(message); e.status = status; e.extra = extra; return e; }
+
+// Montato sotto /api (gia' dietro il bearer). Ogni richiesta porta anche X-NC-Device: l'id emesso dal server.
+function prefsRoutes({ cfg = {}, prefsPath }) {
+  const r = express.Router();
+  r.use(express.json({ limit: '64kb' }));
+  const readonly = () => cfg.readonlyDefault === true || process.env.NEXUSCREW_READONLY === '1';
+  const wrap = (fn, { write = false } = {}) => (req, res) => {
+    if (write && readonly()) return res.status(403).json({ error: 'READONLY: mutazione preferenze bloccata' });
+    try { return fn(req, res); } catch (e) { return res.status(e.status || 500).json({ error: String(e.message || e), ...(e.code ? { code: e.code } : {}), ...(e.extra || {}) }); }
+  };
+  const deviceOf = (req, st) => {
+    const id = String(req.get('x-nc-device') || '');
+    if (!store.DEVICE_RE.test(id)) throw httpError(400, 'dispositivo mancante o non valido', { code: 'bad-device' });
+    if (!st.devices[id]) throw httpError(404, 'dispositivo sconosciuto', { code: 'unknown-device' });
+    return id;
+  };
+
+  r.post('/devices', wrap((_req, res) => {
+    res.status(201).json({ deviceId: store.issueDevice(prefsPath) });
+  }, { write: true }));
+
+  r.get('/', wrap((req, res) => {
+    const st = store.loadStore(prefsPath); const id = deviceOf(req, st); const d = st.devices[id];
+    res.set('ETag', `"${d.revision}"`);
+    res.json({ deviceId: id, revision: d.revision, updatedAt: d.updatedAt, data: d.data });
+  }));
+
+  r.put('/', wrap((req, res) => {
+    const st = store.loadStore(prefsPath); const id = deviceOf(req, st); const d = st.devices[id];
+    const match = String(req.get('if-match') || '').match(/^"(\d+)"$/);
+    if (!match) throw httpError(428, 'If-Match richiesto', { code: 'if-match-required' });
+    if (Number(match[1]) !== d.revision) throw httpError(409, 'preferenze modificate altrove', { code: 'revision-conflict', current: { revision: d.revision, data: d.data } });
+    const data = store.parseData(req.body && req.body.data);
+    if (!data) throw httpError(422, 'preferenze non valide', { code: 'bad-schema' });
+    // Mai default vuoti sopra valori esistenti: una copia vuota non sostituisce una piena.
+    if (store.isEmpty(data) && !store.isEmpty(d.data)) throw httpError(422, 'copia vuota sopra preferenze esistenti', { code: 'refuse-empty-overwrite' });
+    const now = Date.now();
+    d.revision += 1; d.updatedAt = now; d.lastSeenAt = now; d.data = data;
+    store.atomicWrite(prefsPath, st);
+    res.set('ETag', `"${d.revision}"`);
+    res.json({ deviceId: id, revision: d.revision, updatedAt: d.updatedAt });
+  }, { write: true }));
+
+  return r;
+}
+
+module.exports = { prefsRoutes };

package/lib/prefs/store.js

@@ -0,0 +1,112 @@
+'use strict';
+// Preferenze di interfaccia (pin, ordine, viste, ordine nodi) per DISPOSITIVO, ospitate dal nodo.
+// Servono a ritrovarle quando lo storage del browser viene svuotato. Non contengono mai token ne' diario:
+// lo schema e' una whitelist. Un dispositivo e' un id opaco emesso DAL SERVER (non scelto dal client) e si
+// presenta insieme al bearer: due telefoni con lo stesso token restano isolati.
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const SCHEMA_VERSION = 1;
+const MAX_DEVICES = 64;
+const DEVICE_RE = /^[a-f0-9]{32}$/;
+const MAX_KEY = 192; const MAX_LIST = 256; const MAX_POSITIONS = 128;
+
+function defaultPrefsPath(home) { return path.join(home || os.homedir(), '.nexuscrew', 'prefs.json'); }
+
+const text = (s, max) => {
+  if (typeof s !== 'string' || !s || s.length > max) return false;
+  for (let i = 0; i < s.length; i += 1) { const c = s.charCodeAt(i); if (c <= 0x1f || c === 0x7f) return false; }
+  return true;
+};
+const keyList = (v, max = MAX_LIST) => Array.isArray(v) && v.length <= max && v.every((k) => text(k, MAX_KEY));
+const plain = (v) => v && typeof v === 'object' && !Array.isArray(v);
+
+// Ritorna i dati normalizzati oppure null. Chiavi sconosciute => rifiuto (niente campi liberi).
+function parseData(raw) {
+  if (!plain(raw)) return null;
+  const allowed = new Set(['pins', 'orders', 'views', 'nodeOrder']);
+  if (Object.keys(raw).some((k) => !allowed.has(k))) return null;
+  const out = { pins: [], orders: {}, views: {}, nodeOrder: [] };
+  if (raw.pins !== undefined) { if (!keyList(raw.pins)) return null; out.pins = [...new Set(raw.pins)]; }
+  if (raw.nodeOrder !== undefined) { if (!keyList(raw.nodeOrder, 128)) return null; out.nodeOrder = [...new Set(raw.nodeOrder)]; }
+  if (raw.orders !== undefined) {
+    if (!plain(raw.orders) || Object.keys(raw.orders).length > MAX_POSITIONS) return null;
+    for (const [pos, list] of Object.entries(raw.orders)) {
+      if (!text(pos, 96) || !keyList(list)) return null;
+      out.orders[pos] = [...new Set(list)];
+    }
+  }
+  if (raw.views !== undefined) {
+    if (!plain(raw.views) || Object.keys(raw.views).length > MAX_POSITIONS) return null;
+    for (const [pos, v] of Object.entries(raw.views)) {
+      if (!text(pos, 96) || !plain(v)) return null;
+      const view = {};
+      if (v.open !== undefined) { if (typeof v.open !== 'boolean') return null; view.open = v.open; }
+      if (v.filter !== undefined) { if (!text(v.filter, 16)) return null; view.filter = v.filter; }
+      out.views[pos] = view;
+    }
+  }
+  return out;
+}
+
+const isEmpty = (d) => !d || (!d.pins.length && !d.nodeOrder.length && !Object.keys(d.orders).length && !Object.keys(d.views).length);
+
+function emptyStore() { return { schemaVersion: SCHEMA_VERSION, devices: {} }; }
+
+function parseStore(raw) {
+  try {
+    const obj = typeof raw === 'string' ? JSON.parse(raw) : raw;
+    if (!plain(obj) || obj.schemaVersion !== SCHEMA_VERSION || !plain(obj.devices)) return null;
+    const devices = {};
+    for (const [id, d] of Object.entries(obj.devices)) {
+      if (!DEVICE_RE.test(id) || !plain(d) || !Number.isSafeInteger(d.revision) || d.revision < 0) return null;
+      const data = d.data === null || d.data === undefined ? null : parseData(d.data);
+      if (d.data && !data) return null;
+      devices[id] = { createdAt: Number(d.createdAt) || 0, lastSeenAt: Number(d.lastSeenAt) || 0,
+        revision: d.revision, updatedAt: Number(d.updatedAt) || 0, data };
+    }
+    return { schemaVersion: SCHEMA_VERSION, devices };
+  } catch (_) { return null; }
+}
+
+function loadStore(p) {
+  let raw;
+  try { raw = fs.readFileSync(p, 'utf8'); } catch (e) { if (e.code === 'ENOENT') return emptyStore(); throw e; }
+  const parsed = parseStore(raw);
+  if (!parsed) { const e = new Error('prefs.json non valido'); e.status = 503; throw e; }
+  return parsed;
+}
+
+function atomicWrite(p, st) {
+  try { if (fs.lstatSync(p).isSymbolicLink()) throw new Error('refuse symlink prefs.json'); } catch (e) { if (e.code !== 'ENOENT') throw e; }
+  const parsed = parseStore(st);
+  if (!parsed) throw new Error('prefs.json non valido');
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  const tmp = path.join(path.dirname(p), `.${path.basename(p)}.${crypto.randomBytes(6).toString('hex')}.tmp`);
+  try {
+    fs.writeFileSync(tmp, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+    fs.chmodSync(tmp, 0o600);
+    fs.renameSync(tmp, p);
+  } catch (e) { try { fs.unlinkSync(tmp); } catch (_) { /* best effort */ } throw e; }
+  return parsed;
+}
+
+// Emette un nuovo id dispositivo. Al limite fa posto scartando il piu' vecchio MAI USATO (nessun dato);
+// se tutti hanno dati, rifiuta: mai cancellare preferenze di qualcuno per fare spazio.
+function issueDevice(p, now = Date.now()) {
+  const st = loadStore(p);
+  const ids = Object.keys(st.devices);
+  if (ids.length >= MAX_DEVICES) {
+    const unused = ids.filter((id) => st.devices[id].revision === 0).sort((a, b) => st.devices[a].createdAt - st.devices[b].createdAt);
+    if (!unused.length) { const e = new Error('limite dispositivi raggiunto'); e.status = 409; e.code = 'device-limit'; throw e; }
+    delete st.devices[unused[0]];
+  }
+  const id = crypto.randomBytes(16).toString('hex');
+  st.devices[id] = { createdAt: now, lastSeenAt: now, revision: 0, updatedAt: 0, data: null };
+  atomicWrite(p, st);
+  return id;
+}
+
+module.exports = { SCHEMA_VERSION, MAX_DEVICES, DEVICE_RE, defaultPrefsPath, parseData, isEmpty, emptyStore, loadStore, atomicWrite, issueDevice };

package/lib/proxy/federation.js

@@ -469,7 +469,15 @@ function liveHostLedgerCapture({ ledger, ownerId, resource }) {
   };
 }
 
-function proxyHttp(req, res, { port, path, credential, visited = null, hopProof = null, setCookiePrefix = null, panelCookie = null, capture = null, getTimeoutMs = 10000 }) {
+// An SSE stream is idle BY DESIGN between events. Past the response head the
+// forward timeout must stop applying: the peer's heartbeat is 20 s apart and the
+// GET forward timeout is 10 s, which used to destroy the upstream before the
+// first beat and leave the client hanging on a dead stream until its own idle.
+// What replaces it measures the STREAM's silence, not the socket's.
+const SSE_IDLE_TIMEOUT_MS = 90000;
+const SSE_CONTENT_TYPE_RE = /^text\/event-stream/i;
+
+function proxyHttp(req, res, { port, path, credential, visited = null, hopProof = null, setCookiePrefix = null, panelCookie = null, capture = null, getTimeoutMs = 10000, sseIdleMs = SSE_IDLE_TIMEOUT_MS }) {
   // A body a local middleware has already read is no longer in the stream: the
   // headers would announce bytes that nothing sends, and the peer would wait for
   // a body that never arrives. Say it at once, with a name, instead of letting
@@ -477,9 +485,39 @@ function proxyHttp(req, res, { port, path, credential, visited = null, hopProof
   if (Number(req.headers['content-length'] || 0) > 0 && req.readableEnded) {
     return res.status(502).json({ error: 'request body already read by a local middleware', reason: 'federation-body-consumed' });
   }
+  let streamWatchdog = null;
+  const clearStreamWatchdog = () => {
+    if (streamWatchdog) { clearTimeout(streamWatchdog); streamWatchdog = null; }
+  };
   const up = http.request({ host: '127.0.0.1', port, method: req.method, path, headers: cleanHeaders(req.headers, credential, visited, hopProof, panelCookie) }, (r) => {
     const headers = setCookiePrefix ? rewriteSetCookiePath(r.headers, setCookiePrefix) : r.headers;
-    if (!capture) { res.writeHead(r.statusCode, sanitizeResponseHeaders(headers)); r.pipe(res); return; }
+    if (!capture) {
+      res.writeHead(r.statusCode, sanitizeResponseHeaders(headers));
+      if (SSE_CONTENT_TYPE_RE.test(String(r.headers['content-type'] || ''))) {
+        // The response is open: no inactivity timeout any more (the 504 below
+        // still covers a peer that never answers), and the watchdog is rearmed
+        // on every chunk, so only a stream that really went quiet is ended.
+        up.setTimeout(0);
+        const rearm = () => {
+          clearStreamWatchdog();
+          streamWatchdog = setTimeout(() => {
+            clearStreamWatchdog();
+            // End BOTH sides: leaving the client on a silent stream only makes
+            // it wait for its own idle and reconnect anyway.
+            try { up.destroy(); } catch (_) { /* already gone */ }
+            try { if (!res.writableEnded) res.end(); } catch (_) { /* client gone */ }
+          }, sseIdleMs);
+          if (typeof streamWatchdog.unref === 'function') streamWatchdog.unref();
+        };
+        rearm();
+        r.on('data', rearm);
+        // The client leaving first must take the upstream with it, or the peer
+        // keeps a writer on a socket nobody reads.
+        res.on('close', () => { clearStreamWatchdog(); try { up.destroy(); } catch (_) { /* gone */ } });
+      }
+      r.pipe(res);
+      return;
+    }
     // Buffered only where a capture asks for it (the two live-host mutations):
     // the owner's answer carries the revision that has to be recorded.
     const chunks = [];
@@ -505,11 +543,16 @@ function proxyHttp(req, res, { port, path, credential, visited = null, hopProof
     }
     up.destroy();
   });
-  up.on('error', () => { if (!res.headersSent) res.status(502).json({ error: 'peer non raggiungibile', reason: 'federation-peer-unreachable' }); else res.destroy(); });
+  up.on('close', clearStreamWatchdog);
+  up.on('error', () => {
+    clearStreamWatchdog();
+    if (!res.headersSent) res.status(502).json({ error: 'peer non raggiungibile', reason: 'federation-peer-unreachable' });
+    else res.destroy();
+  });
   req.pipe(up);
 }
 
-function routeHandler({ nodesPath, localPort, localCredential, ingress = null, readonly = () => false, hopSecret = null, liveHostLedger = null, forwardGetTimeoutMs = 10000 }) {
+function routeHandler({ nodesPath, localPort, localCredential, ingress = null, readonly = () => false, hopSecret = null, liveHostLedger = null, forwardGetTimeoutMs = 10000, forwardSseIdleMs = SSE_IDLE_TIMEOUT_MS }) {
   return (req, res) => {
     const parsed = parseRoute(req.url);
     // Prima dell'allowlist: un peer senza permesso non deve nemmeno sapere se la
@@ -558,6 +601,7 @@ function routeHandler({ nodesPath, localPort, localCredential, ingress = null, r
         hopProof: signHop(secret, { method: req.method, path, visited }),
         panelCookie,
         getTimeoutMs: forwardGetTimeoutMs,
+        sseIdleMs: forwardSseIdleMs,
       });
     }
     const next = st && store.getNode(st, parsed.route[0]);
@@ -578,7 +622,7 @@ function routeHandler({ nodesPath, localPort, localCredential, ingress = null, r
     const capture = liveHostLedger && (parsed.resource === '/live-host/designate' || parsed.resource === '/live-host/clear')
       ? liveHostLedgerCapture({ ledger: liveHostLedger, ownerId: next.nodeId, resource: parsed.resource })
       : null;
-    proxyHttp(req, res, { port: next.localPort, path, credential: next.token, visited, setCookiePrefix, panelCookie, capture, getTimeoutMs: forwardGetTimeoutMs });
+    proxyHttp(req, res, { port: next.localPort, path, credential: next.token, visited, setCookiePrefix, panelCookie, capture, getTimeoutMs: forwardGetTimeoutMs, sseIdleMs: forwardSseIdleMs });
   };
 }
 
@@ -1576,6 +1620,22 @@ function forwardUpgrade({ req, socket, head, nodesPath, localPort, localCredenti
     }
   }
   const up = net.connect({ host: '127.0.0.1', port });
+  // ECONNREFUSED sull'hop locale (tunnel che si riavvia) arriva PRIMA del
+  // 'connect': nel ramo hubMode il listener 'error' era registrato solo dentro
+  // up.once('connect', …) e l'evento restava senza gestore → Unhandled 'error'
+  // event → crash del processo (caduto 5 volte su un nodo Termux). Lo
+  // registriamo QUI, sincrono, prima che qualunque I/O possa fallire, valido
+  // per entrambi i rami. Idempotente con i listener registrati dopo il connect:
+  // destroy() e upstreamGone() sono gia' protetti da flag.
+  let heldRecord = null;
+  up.on('error', () => {
+    if (hubMode) {
+      if (heldRecord) hubAttaches.destroy(heldRecord);
+      else acceptWsThenClose(socket, req, 4402, 'upstream gone');
+    } else {
+      upstreamGone();
+    }
+  });
   // Osservatore NON consumante della testa di risposta dell'upstream: serve
   // solo a sapere se il 101 e' transitato (client in stato WebSocket) o se
   // l'hop e' morto prima. La pipe resta l'unico trasporto dei byte: il
@@ -1635,6 +1695,7 @@ function forwardUpgrade({ req, socket, head, nodesPath, localPort, localCredenti
       const record = hubAttaches.hold({
         attachId, tokenHash: tokenFingerprint(attachToken), route: attachRoute, session: attachSession, up,
       });
+      heldRecord = record;
       up.on('data', (chunk) => hubAttaches.feed(record, chunk));
       up.on('close', () => hubAttaches.destroy(record));
       up.on('error', () => hubAttaches.destroy(record));