@mmmbuto/nexuscrew 0.8.19 → 0.8.20

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

@@ -46,7 +46,7 @@ function publicPeeringRoutes(deps = {}) {
     if (!st || !nodesStore.NODE_ID_RE.test(st.nodeId)) return res.status(503).json({ error: 'identita nodo non disponibile' });
     return res.json({ ok: true, instanceId: st.nodeId, proof });
   });
-  r.post('/join', (req, res) => {
+  r.post('/join', async (req, res) => {
     const key = `join:${String(req.socket && req.socket.remoteAddress || 'local')}`;
     const now = Date.now();
     const recent = (attempts.get(key) || []).filter((x) => now - x < 60_000);
@@ -65,21 +65,42 @@ function publicPeeringRoutes(deps = {}) {
     if (b.label !== undefined && !nodesStore.validLabel(b.label)) {
       return res.status(400).json({ error: 'label non valida' });
     }
-    if (!peering.consumeInvite({ invitesPath, invite: b.invite })) return res.status(410).json({ error: 'invito scaduto o gia usato' });
+    // Validate the one-time capability before conflict checks without burning
+    // it: a duplicate/stale peer must not destroy an otherwise reusable invite.
+    if (!peering.hasInvite({ invitesPath, invite: b.invite, now })) return res.status(410).json({ error: 'invito scaduto o gia usato' });
+    let credential = null;
     try {
-      const st = nodesStore.loadOrInitStore(nodesPath);
-      if (st.nodeId === b.instanceId || st.nodes.some((n) => n.nodeId === b.instanceId)) return res.status(409).json({ error: 'peer duplicato' });
-      let name = b.name;
-      for (let i = 2; nodesStore.getNode(st, name); i += 1) name = `${b.name.slice(0, 28)}-${i}`;
-      const reversePort = peering.allocateReversePort(st.nodes);
-      const credential = peering.createPending({ pendingPath, data: {
+      const st = nodesStore.loadStoreStrict(nodesPath);
+      const pending = peering.readInvites(pendingPath, now);
+      if (st.nodeId === b.instanceId || st.nodes.some((n) => n.nodeId === b.instanceId)
+        || pending.some((row) => row.instanceId === b.instanceId)) return res.status(409).json({ error: 'peer duplicato' });
+      const reservedNames = new Set(pending.map((row) => row.name).filter(validPeerName));
+      if (nodesStore.getNode(st, b.name) || reservedNames.has(b.name)) {
+        return res.status(409).json({
+          error: `nome peer gia' in uso: ${b.name}`,
+          code: 'peer-name-conflict',
+          hint: 'rimuovi il record stale oppure scegli un nome univoco e riprova con lo stesso invito',
+        });
+      }
+      const name = b.name;
+      const reversePort = await peering.allocateAvailableReversePort(st.nodes, pending, {
+        ...(deps.createServerImpl ? { createServerImpl: deps.createServerImpl } : {}),
+      });
+      credential = peering.createPending({ pendingPath, data: {
         name, remotePort: b.port, reversePort, instanceId: b.instanceId, acceptToken: b.acceptToken,
         shared: false,
         label: nodesStore.sanitizeLabel(b.label, name),
         ...(peerRoles ? { roles: { ...peerRoles, node: false }, rolesKnown: true } : { rolesKnown: false }),
       } });
+      if (!peering.consumeInvite({ invitesPath, invite: b.invite, now })) {
+        peering.consumePending({ pendingPath, credential, now });
+        return res.status(410).json({ error: 'invito scaduto o gia usato' });
+      }
       res.json({ paired: true, instanceId: st.nodeId, reversePort, credential, roles: readRoles(configPath) });
-    } catch (e) { res.status(500).json({ error: String(e.message || e) }); }
+    } 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 } : {}) });
+    }
   });
   r.post('/confirm', (req, res) => {
     const b = req.body || {};
@@ -91,8 +112,15 @@ function publicPeeringRoutes(deps = {}) {
       return res.status(410).json({ error: 'pairing pending scaduto o gia usato' });
     }
     try {
-      let st = nodesStore.loadOrInitStore(nodesPath);
+      let st = nodesStore.loadStoreStrict(nodesPath);
       if (st.nodeId === pending.instanceId || st.nodes.some((n) => n.nodeId === pending.instanceId)) return res.status(409).json({ error: 'peer duplicato' });
+      if (st.nodes.some((n) => n.name === pending.name || n.localPort === pending.reversePort)) {
+        return res.status(409).json({
+          error: 'allocazione pairing non piu disponibile',
+          code: 'pairing-allocation-conflict',
+          hint: 'ripeti il pairing: verra negoziata una nuova porta reverse',
+        });
+      }
       st = nodesStore.addNode(st, {
         name: pending.name, remotePort: pending.remotePort, localPort: pending.reversePort,
         direction: 'inbound', transport: 'inbound', autostart: true,
@@ -104,7 +132,7 @@ function publicPeeringRoutes(deps = {}) {
       });
       nodesStore.atomicWriteStore(nodesPath, st);
       res.json({ confirmed: true });
-    } catch (e) { res.status(500).json({ error: String(e.message || e) }); }
+    } catch (e) { res.status(e.status || 500).json({ error: String(e.message || e), ...(e.code ? { code: e.code } : {}) }); }
   });
   r.post('/cancel', (req, res) => {
     const b = req.body || {};

package/lib/settings/routes.js

@@ -47,7 +47,7 @@ const nodesStore = require('../nodes/store.js');
 const nodesCmds = require('../nodes/commands.js');
 const nodesTunnel = require('../nodes/tunnel.js');
 const peering = require('../nodes/peering.js');
-const { waitForHealthyPeer } = require('../proxy/federation.js');
+const { waitForHealthyPeer, notifyHubShare } = 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');
@@ -215,7 +215,7 @@ function settingsRoutes(deps = {}) {
       };
       if (updateStatus) out.update = updateStatus;
       send(res, 200, out);
-    } catch (e) { send(res, 500, { error: String(e.message || e) }); }
+    } catch (e) { send(res, e.status || 500, { error: String(e.message || e), ...(e.code ? { code: e.code } : {}) }); }
   });
 
   // --- POST /config — scrittura atomica, subset whitelisted ------------------
@@ -333,7 +333,7 @@ function settingsRoutes(deps = {}) {
     try {
       const b = req.body || {};
       const label = nodesStore.sanitizeLabel(b.label, defaultDeviceName());
-      const st = nodesStore.loadOrInitStore(nodesPath);
+      const st = nodesStore.loadStoreStrict(nodesPath);
       const extra = {};
       if (typeof b.ssh === 'string' && b.ssh.trim()) {
         const ssh = nodesStore.parseSshTarget(b.ssh.trim());
@@ -359,7 +359,7 @@ function settingsRoutes(deps = {}) {
       send(res, 200, peering.createInvite({
         invitesPath, instanceId: st.nodeId, port: remotePort, linkPort: runtimePort(), label, ...extra,
       }));
-    } catch (e) { send(res, 500, { error: String(e.message || e) }); }
+    } catch (e) { send(res, e.status || 500, { error: String(e.message || e), ...(e.code ? { code: e.code } : {}) }); }
   });
 
   // --- POST /nodes/pair — hydra join in stadi espliciti ---------------------
@@ -413,7 +413,7 @@ function settingsRoutes(deps = {}) {
         // impossibile (validata sopra), ma non facciamo mai fallire l'add per lei.
         if (b.label !== undefined) {
           try {
-            let st = nodesStore.loadOrInitStore(nodesPath);
+            let st = nodesStore.loadStoreStrict(nodesPath);
             st = nodesStore.updateNode(st, out.name, { label: nodesStore.sanitizeLabel(b.label, out.name) });
             nodesStore.atomicWriteStore(nodesPath, st);
           } catch (_) { /* best-effort: il nodo e' gia' creato */ }
@@ -435,7 +435,11 @@ function settingsRoutes(deps = {}) {
         const status = /duplicato|self-reference/.test(msg) ? 409 : 400;
         return send(res, status, { error: msg });
       }
-      // store invalido / keygen fallita / write fallita: errore lato server.
+      // Store mancante/invalido e' indisponibilita operativa, mai un invito a
+      // ricrearlo implicitamente. Gli altri errori restano 500.
+      if (out.reason === 'store invalido') {
+        return send(res, out.status || 503, { error: msg, ...(out.errorCode ? { code: out.errorCode } : {}) });
+      }
       return send(res, 500, { error: msg });
     } catch (e) { send(res, 500, { error: String(e.message || e) }); }
   });
@@ -522,25 +526,15 @@ function settingsRoutes(deps = {}) {
     if (body.shared && !nodesStore.isPort(node.reversePort)) {
       return send(res, 409, { error: 'canale share non negoziato: ripeti il pairing' });
     }
-    if (node.shared === body.shared) return send(res, 200, { name, shared: body.shared, unchanged: true });
-
+    const wasShared = node.shared === true;
+    let persistedDesired = wasShared;
     const fetchImpl = seams.fetchImpl || fetch;
-    const notifyHub = async (shared) => {
-      const ctrl = new AbortController();
-      const timer = setTimeout(() => ctrl.abort(), 5000);
-      try {
-        const response = await fetchImpl(`http://127.0.0.1:${node.localPort}/federation/share`, {
-          method: 'POST', signal: ctrl.signal,
-          headers: { authorization: `Bearer ${node.token}`, 'content-type': 'application/json' },
-          body: JSON.stringify({ shared }),
-        });
-        if (!response.ok) throw new Error(`hub HTTP ${response.status}`);
-      } finally { clearTimeout(timer); }
-    };
+    const notifyHub = (shared) => notifyHubShare({ node, shared, fetchImpl, timeoutMs: 5000 });
     const applyLocal = async (shared) => {
-      st = nodesStore.loadOrInitStore(nodesPath);
+      st = nodesStore.loadStoreStrict(nodesPath);
       st = nodesStore.updateNode(st, name, { shared });
       nodesStore.atomicWriteStore(nodesPath, st);
+      persistedDesired = shared;
       node = nodesStore.getNode(st, name);
       nodesTunnel.stopTunnel({ home, name });
       const started = nodesTunnel.startForward({
@@ -563,23 +557,31 @@ function settingsRoutes(deps = {}) {
     };
 
     try {
+      if (node.shared === body.shared) {
+        await notifyHub(body.shared);
+        return send(res, 200, { name, shared: body.shared, unchanged: true, reconciled: true });
+      }
       if (body.shared) {
         await applyLocal(true);
         await notifyHub(true);
       } else {
-        // Revoke at the hub while -R is still alive, then remove -R locally.
-        await notifyHub(false);
+        // Persist OFF first. If the process dies before the hub ACK, the next
+        // boot starts only -L and reconciles the stored false state.
         await applyLocal(false);
+        await notifyHub(false);
       }
       return send(res, 200, { name, shared: body.shared });
     } catch (e) {
       // 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) {
+      if (body.shared && !wasShared) {
         try { await applyLocal(false); } catch (_) { /* best-effort safe rollback */ }
       }
+      const offPersisted = body.shared === false && persistedDesired === false;
       return send(res, 502, {
-        error: body.shared ? 'Share non attivato' : 'Share non disattivato',
+        error: body.shared ? 'Share non attivato'
+          : offPersisted ? 'Share disattivato localmente; hub non riconciliato' : 'Share non disattivato',
+        ...(offPersisted ? { shared: false, reconcilePending: true } : {}),
         detail: String(e && e.message || e).replace(/Bearer\s+\S+/gi, 'Bearer ***'),
       });
     }
@@ -593,11 +595,11 @@ function settingsRoutes(deps = {}) {
       if (!validName(name) || !['network', 'relay-only', 'selected'].includes(visibility)) {
         return send(res, 400, { error: 'visibility non valida' });
       }
-      let st = nodesStore.loadOrInitStore(nodesPath);
+      let st = nodesStore.loadStoreStrict(nodesPath);
       st = nodesStore.updateNode(st, name, { visibility, selected: visibility === 'selected' ? selected : [] });
       nodesStore.atomicWriteStore(nodesPath, st);
       send(res, 200, { saved: true, name, visibility });
-    } catch (e) { send(res, 400, { error: String(e.message || e) }); }
+    } catch (e) { send(res, e.status || 400, { error: String(e.message || e), ...(e.code ? { code: e.code } : {}) }); }
   });
   // Rinomina la label umana di un nodo SENZA toccare il name (route/URL stabili).
   r.patch('/nodes/:name/label', mutGate, (req, res) => {
@@ -606,12 +608,12 @@ function settingsRoutes(deps = {}) {
       const label = req.body && req.body.label;
       if (!validName(name)) return send(res, 400, { error: 'name non valido (^[a-z0-9-]{1,32}$)' });
       if (!nodesStore.validLabel(label)) return send(res, 400, { error: 'label non valida (max 64 char, niente a capo)' });
-      let st = nodesStore.loadOrInitStore(nodesPath);
+      let st = nodesStore.loadStoreStrict(nodesPath);
       if (!nodesStore.getNode(st, name)) return send(res, 404, { error: `nodo sconosciuto "${name}"` });
       st = nodesStore.updateNode(st, name, { label: nodesStore.sanitizeLabel(label, name) });
       nodesStore.atomicWriteStore(nodesPath, st);
       send(res, 200, { saved: true, name, label: nodesStore.nodeLabel(nodesStore.getNode(st, name)) });
-    } catch (e) { send(res, 400, { error: String(e.message || e) }); }
+    } catch (e) { send(res, e.status || 400, { error: String(e.message || e), ...(e.code ? { code: e.code } : {}) }); }
   });
 
   // Legacy compatibility endpoint: the old node-role/rendezvous flow opened a

package/lib/tmux/list.js

@@ -52,6 +52,15 @@ function parseSessions(raw) {
     .filter((session) => session.windows > 0);
 }
 
+// tmux uses different expected "no server" errors across platforms. Linux
+// commonly prints "no server running" while macOS reports the missing socket
+// path. Both mean an empty inventory, not a broken NexusCrew node.
+function isNoTmuxServerError(raw) {
+  const message = String(raw || '');
+  return /no server running/i.test(message)
+    || /error connecting to .*(?:No such file or directory|Connection refused)/i.test(message);
+}
+
 function setSessionVisibility(tmuxBin = 'tmux', name, technical = false) {
   return new Promise((resolve, reject) => {
     if (typeof name !== 'string' || !/^[\w.@%:+-]{1,128}$/.test(name) || name.startsWith('-')) {
@@ -73,7 +82,7 @@ function listSessions(tmuxBin = 'tmux') {
   return new Promise((resolve, reject) => {
     execFile(tmuxBin, ['list-sessions', '-F', FMT], (err, stdout, stderr) => {
       if (err) {
-        if (/no server running/i.test(stderr || '')) return resolve([]);
+        if (isNoTmuxServerError(stderr || err.message)) return resolve([]);
         return reject(new Error(`tmux list-sessions failed: ${stderr || err.message}`));
       }
       resolve(parseSessions(stdout));
@@ -95,5 +104,5 @@ function attachedClients(tmuxBin = 'tmux', session) {
 }
 
 module.exports = {
-  parsePaneTitle, parseSessions, listSessions, attachedClients, setSessionVisibility, FMT,
+  parsePaneTitle, parseSessions, isNoTmuxServerError, listSessions, attachedClients, setSessionVisibility, FMT,
 };

package/package.json

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