@mmmbuto/nexuscrew 0.9.33 → 0.9.35

package/lib/mcp/cells.js

@@ -75,6 +75,10 @@ function topologyOwners(payload) {
       route: [...node.route],
       label: typeof node.label === 'string' && node.label ? node.label : (node.name || node.route.join(' › ')),
       stale: node.stale === true,
+      // Serve alla directory per dire QUANDO un nodo stale e' stato visto
+      // l'ultima volta: senza, la voce in unavailable parlerebbe dello stato
+      // senza dire da quanto.
+      lastSeen: Number.isFinite(node.lastSeen) ? node.lastSeen : null,
     });
   }
   return out;
@@ -162,10 +166,26 @@ async function readCellDirectory(ctx, callerSession = null) {
   ]);
   const localId = String(config && config.instanceId || '');
   if (!NODE_ID_RE.test(localId)) throw new Error('instanceId locale non disponibile');
+  const candidati = topologyOwners(topology).filter((owner) => owner.instanceId !== localId);
   const owners = [{ instanceId: localId, route: [], label: 'Local', stale: false },
-    ...topologyOwners(topology).filter((owner) => !owner.stale && owner.instanceId !== localId)];
+    ...candidati.filter((owner) => !owner.stale)];
   const cells = [];
   const unavailable = [];
+  // Un owner STALE resta nel gate (non si interroga un nodo che la topologia
+  // dichiara stantio) ma non SPARISCE dalla directory: chi legge `nc_cells`
+  // deve distinguere «questo nodo non risponde da X» da «questo nodo non
+  // esiste». Stesso shape di unavailableOwner, failure 'stale' + lastSeen.
+  for (const owner of candidati) {
+    if (!owner.stale) continue;
+    unavailable.push({
+      instanceId: owner.instanceId,
+      owner: owner.label,
+      route: owner.route.length ? owner.route.join('/') : 'local',
+      ...(owner.route.length === 0 ? { local: true } : {}),
+      failure: 'stale',
+      lastSeen: Number.isFinite(owner.lastSeen) ? owner.lastSeen : null,
+    });
+  }
   await Promise.all(owners.map(async (owner) => {
     const apiPath = owner.route.length ? routePath(owner.route, 'cells') : '/api/cells';
     if (!apiPath) return;

package/lib/mcp/tools.js

@@ -252,7 +252,7 @@ async function readVlDirectory(ctx) {
   const localId = String(config && config.instanceId || '');
   if (!NODE_ID_RE.test(localId)) throw new Error('instanceId locale non disponibile');
   const owners = [{ instanceId: localId, route: [], label: 'Local', stale: false },
-    ...topologyOwners(topology).filter((owner) => !owner.stale && owner.instanceId !== localId)];
+    ...topologyOwners(topology).filter((owner) => owner.instanceId !== localId)];
   const nodes = [];
   const availableOwners = [];
   const unavailable = [];
@@ -455,7 +455,9 @@ const TOOLS = [
       if (!NODE_ID_RE.test(localNodeId)) throw new Error('instanceId locale non disponibile');
       if (!localDecks || !Array.isArray(localDecks.decks)) throw new Error('risposta deck non valida');
 
-      const remotes = topologyOwners(topology).filter((owner) => !owner.stale && owner.instanceId !== localNodeId);
+      // Gli owner stale restano interrogabili con la loro route (best-effort):
+      // un ramo lento degrada a stale, non sparisce dalla directory dei deck.
+      const remotes = topologyOwners(topology).filter((owner) => owner.instanceId !== localNodeId);
       const viewerById = new Map([[localNodeId, []], ...remotes.map((owner) => [owner.instanceId, owner.route])]);
       const sources = [{
         owner: { instanceId: localNodeId, route: [], label: 'Local' },

package/lib/proxy/federation.js

@@ -19,6 +19,24 @@ const { COOKIE_NAME: PANEL_COOKIE_NAME } = require('./panel-auth.js');
 const MAX_HOPS = 4;
 const ROUTE_DELIMITER = '_';
 const TOPOLOGY_PEER_TIMEOUT_MS = 1500;
+// Budget per hop della topologia federata: quando la richiesta arriva da un
+// peer, il fan-out verso i propri figli si tiene questo margine sotto il
+// budget del chiamante, cosi' la risposta rientra sempre in chi chiama.
+const HOP_MARGIN_MS = 500;
+const CHILD_BUDGET_FLOOR_MS = 300;
+// Ultimo snapshot riuscito per figlio diretto (cache in memoria, chiave
+// store+figlio): serve i rami lenti come stale invece di farli sparire dal
+// ramo del chiamante.
+const CHILD_SNAPSHOT_MAX = 64;
+const childSnapshotsByNodeId = new Map();
+
+function recordChildSnapshot(nodesPath, nodeId, nodes) {
+  childSnapshotsByNodeId.set(`${nodesPath}::${nodeId}`, { ts: Date.now(), nodes });
+  if (childSnapshotsByNodeId.size <= CHILD_SNAPSHOT_MAX) return;
+  let oldest = null;
+  for (const [id, snap] of childSnapshotsByNodeId) if (!oldest || snap.ts < oldest[1].ts) oldest = [id, snap];
+  if (oldest) childSnapshotsByNodeId.delete(oldest[0]);
+}
 // Finestra di attesa del reverse channel su Share ON: limitata per non
 // diventare un retry storm, ma sufficiente al bind subito dopo un pairing.
 const SHARE_HEALTH_ATTEMPTS = 10;
@@ -959,7 +977,7 @@ async function fetchPeerTopology({ node, ttl, seen, fetchImpl, timeoutMs }) {
     }, budget);
   });
   const request = (async () => {
-    const u = `http://127.0.0.1:${node.localPort}/federation/topology?ttl=${ttl - 1}&visited=${encodeURIComponent([...seen].join(','))}`;
+    const u = `http://127.0.0.1:${node.localPort}/federation/topology?ttl=${ttl - 1}&visited=${encodeURIComponent([...seen].join(','))}&budget=${budget}`;
     const response = await fetchImpl(u, {
       headers: { authorization: `Bearer ${node.token}` }, signal: ctrl.signal,
     });
@@ -969,14 +987,49 @@ async function fetchPeerTopology({ node, ttl, seen, fetchImpl, timeoutMs }) {
   finally { clearTimeout(timer); }
 }
 
+// Validazione dei nodi figli riportati da un peer (stesso gate del loop
+// storico): identita' strict, route valida e aciclica verso il padre, nome
+// coerente con l'ultimo hop. Le entry valide sono relative al figlio.
+// Lo stato stale/lastSeen che il salto precedente aveva gia' calcolato
+// VIAGGIA con il figlio (ben formato: stale===true, lastSeen intero): senza
+// questa propagazione l'ultimo hop ricompatterebbe tutto come fresco e il
+// badge veritiero non arriverebbe mai a chi guarda.
+function validatedChildNodes(n, seen, ttl, body) {
+  if (!body || body.instanceId !== n.nodeId || !Array.isArray(body.nodes)) return null;
+  const out = [];
+  for (const child of body.nodes) {
+    if (!child || !store.NODE_ID_RE.test(child.instanceId) || child.instanceId === n.nodeId || seen.has(child.instanceId)
+      || !store.NODE_NAME_RE.test(child.name)
+      || !Array.isArray(child.route) || child.route.length < 1 || child.route.length >= ttl
+      || child.route.some((x) => !store.NODE_NAME_RE.test(x))
+      || new Set(child.route).size !== child.route.length
+      || child.name !== child.route[child.route.length - 1]
+      || child.route.includes(n.name)) continue;
+    out.push({
+      instanceId: child.instanceId, name: child.name, route: [...child.route],
+      label: store.validLabel(child.label) ? child.label.trim() : '',
+      ...(child.stale === true
+        ? { stale: true, ...(Number.isSafeInteger(child.lastSeen) ? { lastSeen: child.lastSeen } : {}) }
+        : {}),
+    });
+  }
+  return out;
+}
+
 async function collectTopologyDetailed({
   nodesPath, ingress = null, ttl = MAX_HOPS, visited = [], fetchImpl = fetch,
-  timeoutMs = TOPOLOGY_PEER_TIMEOUT_MS,
+  timeoutMs = TOPOLOGY_PEER_TIMEOUT_MS, childSnapshots = true,
 }) {
   const st = store.loadStore(nodesPath);
   if (!st) return { instanceId: null, nodes: [], authoritative: [] };
   const seen = new Set(visited.filter((x) => store.NODE_ID_RE.test(x)));
   seen.add(st.nodeId);
+  const budget = Number.isFinite(timeoutMs)
+    ? Math.max(1, Math.min(30000, Math.floor(timeoutMs))) : TOPOLOGY_PEER_TIMEOUT_MS;
+  // Richiesta da un peer: il fan-out verso i figli usa un budget inferiore a
+  // quello del chiamante, cosi' questa risposta rientra sempre nel suo budget.
+  const childBudget = ingress
+    ? Math.max(CHILD_BUDGET_FLOOR_MS, budget - HOP_MARGIN_MS) : budget;
   const out = [];
   const authoritative = [];
   const probes = [];
@@ -995,22 +1048,17 @@ async function collectTopologyDetailed({
       label: store.validLabel(n.label) ? n.label.trim() : '',
     });
     if (ttl <= 1 || !n.token) continue;
-    probes.push({ n, pending: fetchPeerTopology({ node: n, ttl, seen, fetchImpl, timeoutMs }) });
+    probes.push({ n, pending: fetchPeerTopology({ node: n, ttl, seen, fetchImpl, timeoutMs: childBudget }) });
   }
   const results = await Promise.all(probes.map(async ({ n, pending }) => {
     try { return { n, ...(await pending) }; } catch (_) { return { n, response: null, body: null }; }
   }));
   for (const { n, response, body } of results) {
-    if (!response || !response.ok || body.instanceId !== n.nodeId || !Array.isArray(body.nodes)) continue;
-    authoritative.push(n.name);
-    for (const child of body.nodes) {
-        if (!child || !store.NODE_ID_RE.test(child.instanceId) || child.instanceId === n.nodeId || seen.has(child.instanceId)
-          || !store.NODE_NAME_RE.test(child.name)
-          || !Array.isArray(child.route) || child.route.length < 1 || child.route.length >= ttl
-          || child.route.some((x) => !store.NODE_NAME_RE.test(x))
-          || new Set(child.route).size !== child.route.length
-          || child.name !== child.route[child.route.length - 1]
-          || child.route.includes(n.name)) continue;
+    const children = response && response.ok ? validatedChildNodes(n, seen, ttl, body) : null;
+    if (children) {
+      authoritative.push(n.name);
+      recordChildSnapshot(nodesPath, n.nodeId, children);
+      for (const child of children) {
         // La label di un nodo in transito e' testo AUTO-DICHIARATO da un altro
         // nodo: si accetta solo se rispetta la stessa forma di una label locale,
         // altrimenti si resta senza nome invece di propagare qualcosa di
@@ -1018,8 +1066,37 @@ async function collectTopologyDetailed({
         out.push({
           instanceId: child.instanceId, name: child.name,
           route: [n.name, ...child.route], direct: false,
-          label: store.validLabel(child.label) ? child.label.trim() : '',
+          label: child.label,
+          ...(child.stale === true
+            ? { stale: true, ...(Number.isSafeInteger(child.lastSeen) ? { lastSeen: child.lastSeen } : {}) }
+            : {}),
         });
+      }
+      continue;
+    }
+    // Figlio che non ha risposto in tempo (failure di trasporto: response null):
+    // si serve l'ultimo snapshot riuscito marcando le entry stale con lastSeen,
+    // invece di far sparire l'intero ramo dalla topologia di chi chiama. Una
+    // risposta ARRIVATA ma non valida (binding instanceId sbagliato, errore
+    // HTTP) non resuscita nulla: il ramo resta assente, come prima. (Raccolta
+    // locale esclusa: la sua cache su disco ha gia' questa semantica con il
+    // proprio clock.)
+    const snapshot = childSnapshots && !response
+      ? childSnapshotsByNodeId.get(`${nodesPath}::${n.nodeId}`) : null;
+    if (!snapshot) continue;
+    const lastSeen = Math.floor(snapshot.ts / 1000);
+    for (const child of snapshot.nodes) {
+      if (child.instanceId === n.nodeId || seen.has(child.instanceId)) continue;
+      if (!Array.isArray(child.route) || child.route.length < 1 || child.route.length >= ttl
+        || child.route.includes(n.name)) continue;
+      out.push({
+        instanceId: child.instanceId, name: child.name,
+        route: [n.name, ...child.route], direct: false,
+        label: child.label, stale: true,
+        // il lastSeen piu' veritiero e' quello che il figlio stesso aveva
+        // riportato (se era gia' stale); altrimenti il momento dello snapshot
+        lastSeen: Number.isSafeInteger(child.lastSeen) ? child.lastSeen : lastSeen,
+      });
     }
   }
   const ids = new Set(); const routes = new Set(); const unique = [];
@@ -1037,12 +1114,14 @@ async function collectTopology(opts) {
 }
 
 // Local roster: live topology plus a credential-free cache of previously seen
-// transitive nodes. Stale entries are never returned by the peer endpoint.
+// transitive nodes. Slow children fall back to the last good in-memory
+// snapshot (stale:true); the peer endpoint returns them too, so a branch that
+// misses one poll degrades to stale instead of disappearing.
 async function collectLocalTopology({
   nodesPath, cachePath, fetchImpl = fetch, now = Math.floor(Date.now() / 1000),
   timeoutMs = TOPOLOGY_PEER_TIMEOUT_MS,
 }) {
-  const live = await collectTopologyDetailed({ nodesPath, fetchImpl, timeoutMs });
+  const live = await collectTopologyDetailed({ nodesPath, fetchImpl, timeoutMs, childSnapshots: false });
   const st = store.loadStore(nodesPath);
   const directNames = new Set(((st && st.nodes) || [])
     .filter((n) => n.direction !== 'inbound' || n.shared === true)
@@ -1063,11 +1142,14 @@ async function collectLocalTopology({
   for (const n of live.nodes) {
     // La cache conserva anche la label: senza, un nodo che torna stale perde il
     // nome e ricompare come slug, cioe' esattamente il difetto che si voleva
-    // togliere. Resta un dato riferito, non una prova.
+    // togliere. Resta un dato riferito, non una prova. Per i nodi arrivati
+    // gia' stale dal salto precedente, il lastSeen ORIGINALE e' il dato vero:
+    // "ora" mentirebbe su quando sono stati visti l'ultima volta.
     if (n.route.length > 1) {
       next.set(n.instanceId, {
         instanceId: n.instanceId, name: n.name, route: [...n.route],
-        ...(n.label ? { label: n.label } : {}), lastSeen: now,
+        ...(n.label ? { label: n.label } : {}),
+        lastSeen: n.stale === true && Number.isSafeInteger(n.lastSeen) ? n.lastSeen : now,
       });
     }
   }
@@ -1077,7 +1159,13 @@ async function collectLocalTopology({
     try { topologyCache.atomicWriteCache(cacheFile, serialized); } catch (_) {}
   }
 
-  const nodes = live.nodes.map((n) => ({ ...n, stale: false, lastSeen: now }));
+  // Solo i nodi visti DIRETTAMENTE vivi prendono stale:false + lastSeen=now:
+  // un nodo che il peer aveva gia' marcato stale resta stale col suo lastSeen.
+  const nodes = live.nodes.map((n) => ({
+    ...n,
+    stale: n.stale === true,
+    lastSeen: n.stale === true && Number.isSafeInteger(n.lastSeen) ? n.lastSeen : now,
+  }));
   for (const n of cached) {
     if (!liveIds.has(n.instanceId) && !liveRoutes.has(n.route.join('/'))) nodes.push({ ...n, direct: false, stale: true });
   }
@@ -1302,7 +1390,12 @@ function peerRouter({ nodesPath, localPort, localCredential, fetchImpl, readonly
   r.get('/topology', async (req, res) => {
     const ttl = Math.max(0, Math.min(MAX_HOPS, Number(req.query.ttl) || MAX_HOPS));
     const visited = String(req.query.visited || '').split(',');
-    res.json(await collectTopology({ nodesPath, ingress: req.peer, ttl, visited, fetchImpl }));
+    // Il budget residuo del chiamante viaggia nella richiesta: il fan-out
+    // interno se ne tiene un margine (budget per hop) per rispondere in tempo.
+    const rawBudget = Number(req.query.budget);
+    const timeoutMs = Number.isFinite(rawBudget)
+      ? Math.max(CHILD_BUDGET_FLOOR_MS, Math.min(30000, Math.floor(rawBudget))) : TOPOLOGY_PEER_TIMEOUT_MS;
+    res.json(await collectTopology({ nodesPath, ingress: req.peer, ttl, visited, fetchImpl, timeoutMs }));
   });
   // A connected client publishes itself through the SAME SSH connection by
   // toggling its optional -R channel. The hub records that intent only after a

package/package.json

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