@mmmbuto/nexuscrew 0.8.47 → 0.8.49

package/lib/settings/routes.js

@@ -52,7 +52,9 @@ const audioGroups = require('../audio/groups.js');
 const nodesCmds = require('../nodes/commands.js');
 const nodesTunnel = require('../nodes/tunnel.js');
 const peering = require('../nodes/peering.js');
-const { waitForHealthyPeer, preflightHubReverse, notifyHubShare, reconcilePeerShare } = require('../proxy/federation.js');
+const {
+  waitForHealthyPeer, preflightHubReverse, notifyHubShare, reconcilePeerShare, SHARE_NOT_READY_CODE,
+} = require('../proxy/federation.js');
 const { rotateToken } = require('../auth/token.js');
 const { generateService, installService, installPath: svcInstallPath } = require('../cli/service.js');
 const { detectPlatform, nodeBin, repoRoot, uid } = require('../cli/platform.js');
@@ -597,8 +599,45 @@ function settingsRoutes(deps = {}) {
     const wasShared = node.shared === true;
     let persistedDesired = wasShared;
     let shareOnAttempted = false;
+    // Traccia se il rollback ha davvero spento il canale reverse. Resta true
+    // finche' non si tenta una chiusura che non riesce a dimostrarsi.
+    let reverseChannelClosed = true;
+    // `close` restituisce false quando non riesce a DIMOSTRARE la proprieta'
+    // del supervisor: il canale resta in quarantena, vivo. Una chiusura che
+    // LANCIA non e' una chiusura riuscita: stesso esito, altrimenti l'unico
+    // caso in cui non sappiamo nulla sarebbe anche l'unico che tace.
+    const closeReverseChannel = async () => {
+      if (!node.reversePool || typeof reverseSlots?.close !== 'function') return;
+      try {
+        reverseChannelClosed = (await reverseSlots.close(name)) !== false;
+      } catch (_) {
+        reverseChannelClosed = false;
+      }
+    };
     const fetchImpl = seams.fetchImpl || fetch;
-    const notifyHub = (shared) => notifyHubShare({ node, shared, fetchImpl, timeoutMs: 5000 });
+    const notifyHubOnce = (shared) => notifyHubShare({ node, shared, fetchImpl, timeoutMs: 5000 });
+    // Share ON stabilisce il reverse channel un istante prima di annunciarlo:
+    // subito dopo un pairing il bind sul hub non e' ancora pronto e l'hub
+    // risponde con un codice tipizzato ritentabile. Senza questo ritentativo
+    // limitato l'attesa diventava un fallimento definitivo, con rollback
+    // dell'intera transazione e Share che "non funziona" finche' l'operatore
+    // non riprova a mano. Qualunque altro errore resta definitivo.
+    const NOTIFY_RETRY_DELAYS_MS = [1000, 2000, 3000];
+    const notifyDelay = typeof seams.pairDelay === 'function'
+      ? seams.pairDelay
+      : (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    const notifyHub = async (shared) => {
+      if (!shared) return notifyHubOnce(false);
+      let last;
+      for (let attempt = 0; attempt <= NOTIFY_RETRY_DELAYS_MS.length; attempt += 1) {
+        try { return await notifyHubOnce(true); } catch (e) {
+          last = e;
+          if (!e || e.code !== SHARE_NOT_READY_CODE) throw e;
+          if (attempt < NOTIFY_RETRY_DELAYS_MS.length) await notifyDelay(NOTIFY_RETRY_DELAYS_MS[attempt]);
+        }
+      }
+      throw last;
+    };
     const ensureLocal = async ({ restart = false } = {}) => {
       const stopForward = seams.stopTunnelImpl || nodesTunnel.stopTunnel;
       const startForward = seams.startForwardImpl || nodesTunnel.startForward;
@@ -639,7 +678,9 @@ function settingsRoutes(deps = {}) {
       nodesStore.atomicWriteStore(nodesPath, st);
       persistedDesired = shared;
       node = nodesStore.getNode(st, name);
-      if (!shared && node.reversePool && typeof reverseSlots?.close === 'function') await reverseSlots.close(name);
+      // Lo stato persistito direbbe "privato" mentre il reverse pool e' ancora
+      // su: l'esito della chiusura va riportato a chi chiama, non ignorato.
+      if (!shared) await closeReverseChannel();
       await ensureLocal({ restart: true });
     };
     const revokeHub = () => reconcilePeerShare({
@@ -659,7 +700,10 @@ function settingsRoutes(deps = {}) {
           detail: scrubError(revokeErr),
         });
       }
-      if (node.reversePool && typeof reverseSlots?.close === 'function') await reverseSlots.close(name);
+      // Stessa regola del rollback: una chiusura non dimostrabile lascia il
+      // canale in quarantena, vivo. Qui finisce in una risposta di SUCCESSO,
+      // quindi tacerlo e' peggio: dichiarerebbe revocato cio' che e' sospeso.
+      await closeReverseChannel();
       try {
         // A changed ON->OFF spec is restarted explicitly; same-state OFF uses
         // the idempotent spec-aware path, which only replaces a stale -R.
@@ -673,6 +717,7 @@ function settingsRoutes(deps = {}) {
       }
       return send(res, 200, {
         name, shared: false, revoked: true,
+        ...(reverseChannelClosed ? {} : { reversePoolPending: true }),
         ...(unchanged ? { unchanged: true, reconciled: true } : {}),
       });
     };
@@ -742,7 +787,11 @@ function settingsRoutes(deps = {}) {
       // Share-on is transactional: a failed hub acknowledgement returns to the
       // safe private -L-only state. Never include remote response bodies/tokens.
       if (body.shared && !wasShared && shareOnAttempted) {
-        try { await applyLocal(false); } catch (_) { /* best-effort safe rollback */ }
+        // Il rollback resta best-effort — non si puo' fallire due volte — ma il
+        // suo esito NON si perde: se il canale reverse non e' stato spento in
+        // modo dimostrabile, chi chiama deve saperlo invece di leggere solo
+        // "Share non attivato" e credere che tutto sia tornato privato.
+        try { await applyLocal(false); } catch (_) { reverseChannelClosed = false; }
       }
       const offPersisted = body.shared === false && persistedDesired === false;
       const redact = (value) => String(value || '').replace(/Bearer\s+\S+/gi, 'Bearer ***');
@@ -753,6 +802,10 @@ function settingsRoutes(deps = {}) {
           : 'Share non attivato')
           : offPersisted ? 'Share disattivato localmente; hub non riconciliato' : 'Share non disattivato',
         ...(offPersisted ? { shared: false, reconcilePending: true } : {}),
+        // Segnale esplicito quando lo store dice privato ma il canale reverse
+        // non risulta spento in modo dimostrabile: e' una quarantena, non una
+        // chiusura, e va diagnosticata invece che dedotta.
+        ...(reverseChannelClosed ? {} : { reversePoolPending: true }),
         ...(e && typeof e.code === 'string' ? { code: e.code } : {}),
         detail: redact(e && e.message || e),
         ...(e && typeof e.hint === 'string' ? { hint: redact(e.hint) } : {}),

package/lib/ws/bridge.js

@@ -10,6 +10,8 @@ function clamp(n, lo, hi, def) {
   return Math.max(lo, Math.min(hi, Math.round(n)));
 }
 
+const ATTACH_TIMEOUT_MS = 15000;
+
 function bindWs(ws, deps) {
   const { openAttach, verifyToken, isValidSession = () => true, runAction = () => false, countClients = () => 0, defaults = {}, onAttach = () => {} } = deps;
   let pty = null;
@@ -17,10 +19,31 @@ function bindWs(ws, deps) {
   let session = null;
 
   function fail(code, reason) {
+    // Si spegne anche la scadenza pre-attach: un frame rifiutato (token o
+    // handshake non validi) chiude gia' il socket, e lasciare il timer vivo
+    // fino al close event tiene in piedi un handle senza scopo.
+    clearAttachTimer();
     try { ws.send(JSON.stringify({ type: 'error', reason })); } catch (_) {}
     try { ws.close(code, reason); } catch (_) {}
   }
 
+  // L'upgrade viene accettato prima dell'autenticazione: il token arriva nel
+  // primo frame. Senza una scadenza un socket che non manda MAI l'attach resta
+  // aperto e non autenticato a tempo indefinito, e il costo si moltiplica su
+  // ogni listener che serve l'app. La finestra e' generosa (un client reale
+  // manda l'attach all'apertura) ma non infinita.
+  const attachTimeoutMs = Number.isFinite(defaults.attachTimeoutMs)
+    ? Math.max(1000, defaults.attachTimeoutMs) : ATTACH_TIMEOUT_MS;
+  let attachTimer = setTimeout(() => {
+    attachTimer = null;
+    if (!attached) fail(4408, 'attach timeout');
+  }, attachTimeoutMs);
+  if (typeof attachTimer.unref === 'function') attachTimer.unref();
+  // Dichiarazione (hoisted): `fail` la chiama ed e' definita piu' sopra.
+  function clearAttachTimer() {
+    if (attachTimer) { clearTimeout(attachTimer); attachTimer = null; }
+  }
+
   function onMessage(data, isBinary) {
     if (!attached) {
       if (isBinary) return fail(1002, 'binary before attach');
@@ -30,6 +53,7 @@ function bindWs(ws, deps) {
       if (!verifyToken(msg.token)) return fail(4401, 'bad token');
       if (!isValidSession(msg.session)) return fail(4404, 'no such session');
       attached = true;
+      clearAttachTimer();
       session = msg.session;
       onAttach(session, ws);
       // Resize default: when nobody else is attached, drive the session size so a
@@ -83,7 +107,7 @@ function bindWs(ws, deps) {
   }
 
   ws.on('message', onMessage);
-  ws.on('close', () => { if (pty) pty.kill(); pty = null; });
-  ws.on('error', () => { if (pty) pty.kill(); pty = null; });
+  ws.on('close', () => { clearAttachTimer(); if (pty) pty.kill(); pty = null; });
+  ws.on('error', () => { clearAttachTimer(); if (pty) pty.kill(); pty = null; });
 }
 module.exports = { bindWs, clamp };

package/package.json

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