@mmmbuto/nexuscrew 0.9.30 → 0.9.32

package/lib/server.js

@@ -87,7 +87,8 @@ function sanitizeReplyLabel(raw) {
   return String(raw === undefined || raw === null ? 'human' : raw)
     .replace(/[\x00-\x1f\x7f\]]/g, '').slice(0, 32) || 'human';
 }
-const { notifyRoutes } = require('./notify/routes.js');
+const { notifyRoutes, createClosureFanout } = require('./notify/routes.js');
+const { createClosureRetryQueue } = require('./notify/closure-retry.js');
 const { createNpmUpdater } = require('./update/manager.js');
 const { createDiagnostics } = require('./diagnostics/store.js');
 const { createDropCounter } = require('./ws/drop-counter.js');
@@ -200,11 +201,36 @@ function createServer(opts = {}) {
   // federated ask surface. The closure event flows through the notifier
   // wrapper so the feed gets a qualified ask-closed envelope.
   const askReceipts = createAskReceipts({ filePath: path.join(notifyDir, 'ask-receipts.json') });
+  // Recapito della chiusura di un ask verso i peer che ne hanno un alias.
+  // Assegnato piu' sotto, quando esistono dispatcher e topologia; l'hook lo
+  // legge a runtime, quindi la dichiarazione in avanti basta.
+  let closureFanout = null;
+  // Recapito recuperabile della chiusura (lato owner): la voce si crea dove
+  // esiste il fan-out, ma la coda serve prima, sulla lettura degli ask.
+  let closureRetry = null;
   const askAnswerService = createAskAnswerService({
     asks: asksStore,
     paste: cfg.pasteSeam || ((session, text) => pasteToSession(cfg.tmuxBin, session, text)),
     receipts: askReceipts,
-    onClosure: (kind, info) => { try { notifier.emitRaw({ type: kind, id: info.askId }); } catch (_) {} },
+    // La chiusura esce da QUI: e' il punto in cui OGNI transizione autorevole
+    // passa — risposta e scarto, rotta locale e rotta federata. Emetterla dalle
+    // due route locali lasciava fuori proprio il caso normale, la risposta che
+    // arriva da un altro nodo. Il fan-out e' lo stesso dell'andata e NON parte
+    // per un ask importato: la chiusura di quello la decide il suo owner.
+    onClosure: (kind, info) => {
+      try { notifier.emitRaw({ type: kind, id: info.askId }); } catch (_) {}
+      try {
+        const ask = asksStore.get(info.askId);
+        if (ask && !ask.originNode && closureFanout) {
+          return closureFanout.dispatch({
+            askId: info.askId,
+            outcome: kind === 'ask-dismissed' ? 'dismissed' : 'answered',
+            session: (ask && ask.session) || info.cellSession,
+          });
+        }
+      } catch (_) {}
+      return null;
+    },
     labelPrefix: sanitizeReplyLabel(cfg && cfg.replyLabel),
   });
   const feedSignatures = new Map(); // peerNodeId -> grant signature last seen
@@ -1037,6 +1063,86 @@ function createServer(opts = {}) {
       topology: topology && Array.isArray(topology.nodes) ? topology.nodes : [],
     });
   };
+  // UN SOLO dispatcher per le domande e per le chiusure: sono la stessa strada
+  // percorsa in due momenti, e il recapito della chiusura deve usare lo stesso
+  // instradamento dell'andata, non una copia con la sua topologia.
+  const askDispatcher = createDispatcher({
+    localNodeId: federatedNodeId,
+    peers: federatedPeers,
+    localPort: () => (server && server.address() ? server.address().port : cfg.port),
+    localToken: () => tokenHolder.value,
+    // 'no-delivery' (-): esito legittimo del target — richiesta accettata
+    // ma nessun canale raggiunto (0 UI, 0 push). Senza questa voce forward()
+    // lo degraderebbe a 'unknown/unreadable-endpoint-result', nascondendo
+    // proprio il silenzio che l'esito esiste per rivelare.
+    statuses: new Set(['delivered', 'no-delivery', 'refused', 'unreachable', 'unknown']),
+  });
+  const askPeerTargets = async () => {
+    const list = await federatedPeers();
+    return (Array.isArray(list) ? list : []).map((p) => p && (p.nodeId || p.instanceId)).filter(Boolean);
+  };
+  // Riconciliazione del RICEVENTE: per ogni alias ancora aperto si chiede
+  // all'owner quali domande sono ancora aperte. Se l'alias non c'e' piu' la'
+  // (l'owner ha risposto o scartato mentre questo nodo era spento), l'alias si
+  // chiude qui. E' la via minima al recapito recuperabile: niente coda
+  // persistente con backoff, un confronto con la fonte autorevole. Sotto il
+  // tetto dello snapshot non si conclude nulla, perche' un'assenza potrebbe
+  // essere un taglio della lista e non una chiusura.
+  const SNAPSHOT_FULL = 100;
+  async function reconcileImportedAsks() {
+    const store = nodesStore.loadStore(nodesPath);
+    if (!store) return;
+    const open = asksStore.list({ open: true }).filter((a) => a.originNode && a.ownerId && a.ownerAskId);
+    if (!open.length) return;
+    const byOwner = new Map();
+    for (const a of open) {
+      if (!byOwner.has(a.ownerId)) byOwner.set(a.ownerId, []);
+      byOwner.get(a.ownerId).push(a);
+    }
+    for (const [ownerId, aliases] of byOwner) {
+      const peer = (store.nodes || []).find((n) => n && n.nodeId === ownerId && n.token && n.localPort);
+      if (!peer) continue;
+      let snap = null;
+      try {
+        const res = await fetch(`http://127.0.0.1:${peer.localPort}/federation/route/_/event-feed/snapshot`, {
+          headers: { authorization: `Bearer ${peer.token}` }, signal: AbortSignal.timeout(3000),
+        });
+        if (!res.ok) continue;
+        snap = await res.json();
+      } catch (_) { continue; }
+      const live = new Set((snap && Array.isArray(snap.asks) ? snap.asks : []).map((x) => String(x.id)));
+      if (live.size >= SNAPSHOT_FULL) continue;
+      for (const alias of aliases) {
+        if (live.has(String(alias.ownerAskId))) continue;
+        try {
+          const closed = asksStore.closeImported({ ownerId, ownerAskId: alias.ownerAskId, outcome: 'dismissed' });
+          if (closed.changed && closed.ask) {
+            try { notifier.deliverOnlyRaw({ type: 'ask-dismissed', id: closed.ask.id, ownerId }); } catch (_) {}
+          }
+        } catch (_) { /* un alias non chiudibile non ferma gli altri */ }
+      }
+    }
+  }
+  // Assegnato ORA che dispatcher e topologia esistono (l'hook lo legge a runtime).
+  closureRetry = createClosureRetryQueue({
+    log: opts.log || console.log,
+    // Il tentativo nasce DALLA coda: non si riaccoda (sarebbe autoalimentata).
+    // `targets` e' l'insieme dei pendenti della voce: il ritentativo va SOLO
+    // verso quelli. Senza, ogni ritentativo rimanderebbe la chiusura anche a chi
+    // l'ha gia' ricevuta — rumore, non danno, ma nemmeno una coda che sa cosa
+    // le manca.
+    run: ({ askId, outcome, session, targets }) => (closureFanout
+      ? closureFanout.dispatch({ askId, outcome, session, retryOnFailure: false, targets })
+      : Promise.resolve([])),
+  });
+  closureFanout = createClosureFanout({
+    dispatcher: askDispatcher,
+    peerTargets: askPeerTargets,
+    localNodeId: federatedNodeId,
+    log: opts.log || console.log,
+    retry: closureRetry,
+  });
+
   api.use(notifyRoutes({
     cfg,
     notifier,
@@ -1056,20 +1162,24 @@ function createServer(opts = {}) {
       hopSecret: () => hopSecret,
     }),
     acl: createAudioAcl({ nodesPath }),
-    dispatcher: createDispatcher({
-      localNodeId: federatedNodeId,
-      peers: federatedPeers,
-      localPort: () => (server && server.address() ? server.address().port : cfg.port),
-      localToken: () => tokenHolder.value,
-      // 'no-delivery' (-): esito legittimo del target — richiesta accettata
-      // ma nessun canale raggiunto (0 UI, 0 push). Senza questa voce forward()
-      // lo degraderebbe a 'unknown/unreadable-endpoint-result', nascondendo
-      // proprio il silenzio che l'esito esiste per rivelare.
-      statuses: new Set(['delivered', 'no-delivery', 'refused', 'unreachable', 'unknown']),
-    }),
+    dispatcher: askDispatcher,
+    closureFanout,
+    peerTargets: askPeerTargets,
+    reconcileImported: reconcileImportedAsks,
+    closureRetry,
     federatedRate: createSpeakRateLimiter(),
     answerService: askAnswerService,
     receipts: askReceipts,
+    // Elenco dei peer autorizzati per il fan-out di default della domanda
+    // (nessun `target` → tutti i nodi dell'owner). Il
+    // dispatcher resta a target esatto: l'enumerazione la fa la route.
+    peerTargets: async () => {
+      const list = await federatedPeers();
+      return (Array.isArray(list) ? list : [])
+        .map((p) => p && (p.nodeId || p.instanceId))
+        .filter(Boolean);
+    },
+    log: opts.log || console.log,
   }));
   // Event feed: the closed SSE/JSON surface, mounted inside the
   // authenticated API. Its own gate demands a proven federated origin and an
@@ -1113,7 +1223,13 @@ function createServer(opts = {}) {
     loadStore: () => nodesStore.loadStore(nodesPath),
     log: opts.log || console.log,
   });
-  api.post('/asks-relay', async (req, res) => {
+  // Il body va parsato QUI: il router `api` non monta un parser globale, ogni
+  // rotta porta il suo (`express.json`) — vedi /sessions, /notify, /asks.
+  // Senza, `req.body` e' undefined, il relay legge un body vuoto e risponde
+  // 400 «ownerId, askId e text richiesti» a OGNI richiesta: la risposta
+  // federata non ha mai potuto attraversare, e nessun test copriva questa
+  // rotta. Difetto preesistente, trovato scrivendo il test del ritorno federato.
+  api.post('/asks-relay', express.json({ limit: '8kb' }), async (req, res) => {
     try {
       const b = req.body || {};
       if (b.action === 'dismiss') {
@@ -1500,6 +1616,8 @@ function createServer(opts = {}) {
   server.on('close', () => {
     diagnostics.record('info', 'server', 'SERVER_STOPPED', 'NexusCrew server stopped', { reason: 'close' });
     watcher.close(); previews.close(); eventsHub.closeAll(); updater.close(); ptyGrace.close();
+    // Nessun timer di ritentativo sopravvive alla chiusura del server.
+    if (closureRetry) { try { closureRetry.stop(); } catch (_) {} }
     for (const timer of reverseWatchers.values()) clearInterval(timer);
     reverseWatchers.clear(); rotatableReverse.clear(); void reverseSlotListeners?.closeAll();
     // Il pannello non sopravvive al control plane: senza requireToken sopra,

package/package.json

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