@mmmbuto/nexuscrew 0.9.58 → 0.9.59

package/lib/notify/routes.js

@@ -44,7 +44,7 @@ const ASK_KEYS = new Set(['question', 'options', 'session', 'target']);
 // del nodo di origine, non un chiamante locale (stessa regola di FEDERATED_KEYS).
 // `ownerNode`/`originNode` qualificano l'identita', `askId` e' l'id con cui
 // l'owner conosce la domanda (serve alla risposta per tornare sul bersaglio).
-const FEDERATED_ASK_KEYS = new Set(['askId', 'ownerNode', 'originNode', 'originCell', 'closeOutcome']);
+const FEDERATED_ASK_KEYS = new Set(['askId', 'ownerNode', 'originNode', 'originCell', 'closeOutcome', 'ownerAskTs']);
 const RATE_MAX = 6;
 const RATE_WINDOW_MS = 60 * 1000;
 const RATE_MAX_BUCKETS = 64;
@@ -481,12 +481,13 @@ function notifyRoutes({
             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.
+            // Preserve the local alias id for older clients and the canonical
+            // owner ask id for clients that merge aliases with feed cards.
             notifier.deliverOnlyRaw({
               type: b.closeOutcome === 'dismissed' ? 'ask-dismissed' : 'ask-answered',
               id: closed.ask.id,
               ownerId: owner,
+              ownerAskId: closed.ask.ownerAskId,
             });
           }
           return res.json({ status: 'delivered', closed: closed.changed });
@@ -506,12 +507,14 @@ function notifyRoutes({
           // L'id con cui l'OWNER conosce la domanda: e' quello che la risposta
           // deve citare. Il nostro `id` locale resta nostro.
           ownerAskId: b.askId,
+          ownerAskTs: b.ownerAskTs,
           originNode: owner,
           originCell: resolved.origin.cell,
         });
         if (!out.ok) {
           return res.status(out.reason === 'cap' ? 429 : 400).json({ status: 'refused', reason: out.reason, error: out.error });
         }
+        if (out.suppressed) return res.json({ status: 'delivered', suppressed: true, ownerId: owner });
         const ask = out.ask;
         // deliverOnly: consegna locale alla UI, NIENTE pubblicazione sul feed e
         // niente ri-esportazione. E' l'invariante che uccide il loop A->B->A per
@@ -565,6 +568,7 @@ function notifyRoutes({
               ...(ask.options ? { options: ask.options } : {}),
               session: ask.session,
               askId: ask.id,
+              ownerAskTs: ask.ts,
               ownerNode: self,
             },
           });

package/lib/server.js

@@ -85,6 +85,7 @@ const { createAskReceipts } = require('./notify/ask-receipts.js');
 const { createAskAnswerService } = require('./notify/ask-answer-service.js');
 const { createEventFeedAsksRoutes } = require('./notify/event-feed-asks-routes.js');
 const { createAskRelay } = require('./notify/ask-relay.js');
+const { createImportedDismissalDrainer } = require('./notify/imported-dismissals.js');
 const { createAskSlotVerifier } = require('./nodes/ask-slot-verifier.js');
 const { readFederationEventsEnabled } = require('./config.js');
 
@@ -372,7 +373,7 @@ function createServer(opts = {}) {
           if (cellId) {
             recordAndPublish({
               producer: 'ask', cellId,
-              payload: { askId: ask.id, revision: ask.revision || 0, question: ask.question, options: ask.options, session: ask.session, ts: Date.now() },
+              payload: { askId: ask.id, revision: ask.revision || 0, question: ask.question, options: ask.options, session: ask.session, askTs: ask.ts, ts: Date.now() },
             });
           }
         } else if (frame && (frame.type === 'ask-answered' || frame.type === 'ask-dismissed')) {
@@ -1224,7 +1225,7 @@ function createServer(opts = {}) {
         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 (_) {}
+            try { notifier.deliverOnlyRaw({ type: 'ask-dismissed', id: closed.ask.id, ownerId, ownerAskId: closed.ask.ownerAskId }); } catch (_) {}
           }
         } catch (_) { /* un alias non chiudibile non ferma gli altri */ }
       }
@@ -1321,6 +1322,7 @@ function createServer(opts = {}) {
   // resolves the owner from the authorized store and forwards with the peer's
   // own pair token. Uncertain outcomes are parked, never retried silently.
   const askRelay = createAskRelay({
+    availabilityBinding: dismissalBinding,
     nodesPath, slotVerifier: askReverseVerifier,
     loadStore: () => nodesStore.loadStore(nodesPath),
     peers: federatedPeers,
@@ -1334,9 +1336,94 @@ function createServer(opts = {}) {
   // 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.
+  function dismissalBinding(ownerId) {
+      const st = nodesStore.loadStore(nodesPath);
+      if (!st) return null;
+      const direct = st.nodes.filter(node => node.nodeId === ownerId);
+      const cached = topologyCache.loadCache(topologyCachePath);
+      const route = cached && cached.nodes.find(node => node.instanceId === ownerId)?.route;
+      const relevant = direct.length ? direct : st.nodes.filter(node => route && route.includes(node.name));
+      return require('node:crypto').createHash('sha256').update(JSON.stringify(relevant.map(node => ({ nodeId: node.nodeId, direction: node.direction,
+        shared: node.shared, pairingRevision: node.pairingRevision || 0, localPort: node.localPort, reversePool: node.reversePool,
+        configured: accessPresets.grantsOf(node).configured, grants: accessPresets.grantsOf(node).grants }))) + JSON.stringify(route || [])).digest('hex');
+  }
+  function dismissalPeer(ownerId) {
+    const st = nodesStore.loadStore(nodesPath);
+    if (!st) return null;
+    const direct = st.nodes.filter(node => node.nodeId === ownerId);
+    if (direct.length) return direct.length === 1 ? direct[0] : null;
+    // A cached route identifies the first hop, never authorizes it or proves
+    // an outage. The current local grants and channel are checked separately.
+    const cached = topologyCache.loadCache(topologyCachePath);
+    const routes = cached && cached.nodes.filter(node => node.instanceId === ownerId);
+    if (!routes || routes.length !== 1) return null;
+    const first = st.nodes.filter(node => node.name === routes[0].route[0]);
+    return first.length === 1 ? first[0] : null;
+  }
+  function localDismissalEligibility(ownerId, askId) {
+    const peer = dismissalPeer(ownerId);
+    const storedAlias = asksStore.findImported(ownerId, askId);
+    const previous = asksStore.getImportedDismissal(ownerId, askId);
+    const view = eventFeedClient.state().views.find(item => item.ownerId === ownerId);
+    const feedAsk = view && view.asks.find(item => (item.ownerAskId || item.id) === askId);
+    const tsOf = item => { const ts = item && (Object.hasOwn(item, 'ownerAskTs') ? item.ownerAskTs : item.originNode ? null : item.ts); return Number.isSafeInteger(ts) && ts > 0 ? ts : null; };
+    let ask = storedAlias || feedAsk, ambiguous = false;
+    if (storedAlias && feedAsk) {
+      const aliasTs = tsOf(storedAlias), feedTs = tsOf(feedAsk);
+      const sameContent = asksStore.askFingerprint(storedAlias) === asksStore.askFingerprint(feedAsk);
+      if (aliasTs !== null && feedTs !== null && aliasTs !== feedTs) {
+        ask = feedTs > aliasTs ? feedAsk : storedAlias;
+        // An older visible feed cannot be acknowledged through a newer closed
+        // alias. Its current generation needs an authoritative refresh.
+        if (ask === storedAlias && (storedAlias.dismissed || storedAlias.answered)) ambiguous = true;
+      }
+      else if (!sameContent) ambiguous = true;
+      else ask = feedTs !== null && aliasTs === null ? feedAsk : storedAlias;
+    }
+    // Guards and alias mutation belong only to the selected generation.
+    const alias = storedAlias && ask && asksStore.sameImportedGeneration(storedAlias, ask) ? storedAlias : null;
+    const grants = peer && accessPresets.grantsOf(peer);
+    const cellId = ask ? cellIdFromTmuxSession(ask.session) : previous && previous.cellId;
+    const visible = !!((ask || previous) && cellId && grants && grants.configured && grants.grants.eventsAccess === true
+      && eventFeedAcl.visibilityAllows(grants.grants, cellId));
+    const blocked = !!((ask && ask.answered) || (alias && (asksStore.isAnswering(alias.id) || askReceipts.isBlocked(alias.id)))
+      || askRelay.state().some(attempt => attempt.ownerId === ownerId && attempt.askId === askId && ['sent', 'uncertain'].includes(attempt.state)));
+    const slot = peer && peer.reversePool && peer.reversePool.slots && peer.reversePool.slots[peer.reversePool.activeSlot];
+    const unavailable = !!(peer && peer.direction === 'inbound' && (!peer.shared || !slot || !Number.isInteger(slot.port)))
+      || askRelay.channelState(ownerId).unavailable;
+    return { peer, alias, previous, ask, grants, cellId, visible, blocked: blocked || ambiguous, unavailable, ambiguous };
+  }
   api.post('/asks-relay', express.json({ limit: '8kb' }), async (req, res) => {
     try {
       const b = req.body || {};
+      if (b.action === 'dismiss-local') {
+        if (proxyReadonly()) return res.status(403).json({ error: 'READONLY: mutation blocked' });
+        if (req.headers[HOP_HEADER]) return res.status(403).json({ error: 'local operator required' });
+        if (!b || Array.isArray(b) || Object.keys(b).some(key => !['action', 'ownerId', 'askId'].includes(key))
+          || !/^[a-f0-9]{32}$/.test(b.ownerId) || !/^[a-f0-9]{8}$/.test(b.askId) || b.ownerId === federatedNodeId()) {
+          return res.status(400).json({ error: 'invalid local dismissal body' });
+        }
+        try { if (!asksStore.health().readable) return res.status(503).json({ error: 'dismissal store unavailable' }); }
+        catch (_) { return res.status(503).json({ error: 'dismissal store unavailable' }); }
+        const { peer, alias, previous, ask, grants, cellId, visible, unavailable, ambiguous } = localDismissalEligibility(b.ownerId, b.askId);
+        if (!visible) return res.status(404).json({ error: 'unknown or invisible ask' });
+        if (ambiguous) return res.status(409).json({ error: 'ask generation is ambiguous; refresh the owner view', reason: 'generation-ambiguous' });
+        if (ask && ask.answered) return res.status(409).json({ error: 'ask already answered', reason: 'answered' });
+        if ((alias && (asksStore.isAnswering(alias.id) || askReceipts.isBlocked(alias.id)))
+          || askRelay.state().some(attempt => attempt.ownerId === b.ownerId && attempt.askId === b.askId && ['sent', 'uncertain'].includes(attempt.state))) {
+          return res.status(409).json({ error: 'answer requires reconciliation', reason: 'delivery-unknown-block' });
+        }
+        if (!ask && previous) return res.json({ dismissed: true, scope: 'local', ownerSync: previous.syncState === 'blocked' ? 'blocked' : 'pending' });
+        if (!unavailable) return res.status(409).json({ error: 'owner channel is not known unavailable', reason: 'owner-availability-unknown' });
+        const out = asksStore.dismissImported({ ownerId: b.ownerId, ownerAskId: b.askId, ask, cellId, retryBinding: dismissalBinding(b.ownerId),
+          syncState: grants.grants.askReplyAccess === true ? 'pending' : 'blocked' });
+        if (!out.ok) return res.status(out.reason === 'dismissal-cap' ? 429 : 503).json({ error: 'local dismissal refused', reason: out.reason });
+        notifier.deliverOnlyRaw({ type: 'ask-dismissed', id: alias ? alias.id : b.askId, ownerId: b.ownerId, ownerAskId: b.askId, scope: 'local',
+          // UI-only context also distinguishes changed content before the first snapshot.
+          askGeneration: { question: ask.question, options: ask.options || [], session: ask.session },
+          ownerAskTs: out.record.ownerAskTs, ownerSync: out.record.syncState === 'blocked' ? 'blocked' : 'pending' });
+        return res.json({ dismissed: true, scope: 'local', ownerSync: out.record.syncState === 'blocked' ? 'blocked' : 'pending' });
+      }
       if (b.action === 'dismiss') {
         const out = await askRelay.relayDismiss({ ownerId: b.ownerId, askId: b.askId });
         // Dismiss CONFERMATO dall'owner (2xx): la view del feed lo dimentica
@@ -1367,7 +1454,16 @@ function createServer(opts = {}) {
     const ownerId = typeof req.query.ownerId === 'string' ? req.query.ownerId : '';
     const askId = typeof req.query.askId === 'string' ? req.query.askId : '';
     if (!/^[a-f0-9]{32}$/.test(ownerId) || !/^[a-f0-9]{8}$/.test(askId)) return res.status(400).json({ error: 'ownerId e askId richiesti' });
-    try { res.json(await askRelay.replyCapability({ ownerId, askId })); }
+    try {
+      const remote = await askRelay.replyCapability({ ownerId, askId });
+      if (req.query.dismissals !== '1') return res.json(remote);
+      const local = localDismissalEligibility(ownerId, askId);
+      const mutable = !proxyReadonly() && !req.headers[HOP_HEADER];
+      let readable = false;
+      try { readable = asksStore.health().readable; } catch (_) {}
+      res.json({ ...remote, canDismissRemote: mutable && remote.canReply === true,
+        canDismissLocal: mutable && readable && local.visible && !local.blocked && (local.unavailable || !!local.previous) });
+    }
     catch (_) { res.json({ ownerId, askId, canReply: false, status: 'unreachable' }); }
   });
   api.get('/asks-relay/state', (_req, res) => {
@@ -1392,6 +1488,8 @@ function createServer(opts = {}) {
     }
   }
   const eventFeedClient = createEventFeedClient({
+    isAskDismissed: (ownerId, ask) => asksStore.isImportedDismissed(ownerId, ask),
+    onAskClosed: (ownerId, ownerAskId, outcome) => asksStore.closeImported({ ownerId, ownerAskId, outcome }),
     loadStore: () => nodesStore.loadStore(nodesPath),
     token: () => tokenHolder.value,
     eventsHub: importHub,
@@ -1404,6 +1502,11 @@ function createServer(opts = {}) {
     pollMs: cfg.eventFeedClientPollMs,
   });
   eventFeedClient.start();
+  const importedDismissalDrainer = createImportedDismissalDrainer({
+    store: asksStore, relay: askRelay, readonly: proxyReadonly, log: opts.log || console.log,
+    bindingForOwner: dismissalBinding,
+  });
+
   // Local aggregated read for the UI: connected views only, with the cursor
   // watermark so the first fetch cannot race the live stream. Local
   // authenticated route, NOT in the federation allowlist.
@@ -1617,6 +1720,7 @@ function createServer(opts = {}) {
       });
       // Store-root revision of the peer access policy: the CAS value the UI
       // must send back with every preset write (stale revision -> 409).
+      importedDismissalDrainer.nudge();
       res.json({ nodeId: view.nodeId, nodes, accessRevision: nodesStore.accessRevisionOf(st) });
     } catch (e) { res.status(500).json({ error: String(e.message || e) }); }
   });
@@ -1748,13 +1852,14 @@ function createServer(opts = {}) {
     diagnostics.record('info', 'server', 'SERVER_STARTED', 'NexusCrew server started', {
       port: runtimePort(), platform: cfg.platform || process.platform,
     });
-    updater.start(); startManagedTunnels();
+    updater.start(); startManagedTunnels(); importedDismissalDrainer.start();
   });
   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 (_) {} }
+    importedDismissalDrainer.stop(); eventFeedClient.stop();
     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.58",
+  "version": "0.9.59",
   "description": "Faithful browser tmux client — attach to live sessions over a real PTY, localhost-only, mobile-easy",
   "main": "lib/server.js",
   "bin": {