@mmmbuto/nexuscrew 0.9.59 → 0.9.60

package/lib/server.js

@@ -7,7 +7,8 @@ const { execFileSync } = require('node:child_process');
 const express = require('express');
 const { WebSocketServer } = require('ws');
 const { defaults, loadConfig, assertLoopback, configJsonPath } = require('./config.js');
-const { listSessions, listPanes, attachedClients, setSessionVisibility } = require('./tmux/list.js');
+const { attachedClients, setSessionVisibility, listFleetPanes, sessionsFromPanes } = require('./tmux/list.js');
+const { createTmuxReadWindow } = require('./tmux-reads.js');
 const { statiSupervisore: statiSupervisoreDi, senzaSupervisore } = require('./tmux/supervisor-pane.js');
 const { runAction, pasteToSession, submitToSession } = require('./tmux/actions.js');
 const { createSession, killSession, isProtectedSession } = require('./tmux/lifecycle.js');
@@ -53,6 +54,7 @@ const { createDispatcher } = require('./audio/dispatch.js');
 const { createCellScopeGuard } = require('./cells/scope-guard.js');
 const { createCellScope } = require('./cells/scope.js');
 const { cellIdFromTmuxSession } = require('./fleet/definitions.js');
+const { createOwnerAskScope } = require('./notify/owner-ask-scope.js');
 // Budget a tre finestre, riusato dalle notifiche federate: e' gia' scritto per
 // limitare il danno di un nodo che mente sulla propria cella (il tetto per
 // target si calcola sul NODO, che la catena visited verifica).
@@ -75,6 +77,8 @@ const { createPushService } = require('./notify/push.js');
 const { createPushRelay, createPushDedup } = require('./notify/push-relay.js');
 const { createAsksStore } = require('./notify/asks.js');
 const { createNotifier } = require('./notify/notifier.js');
+const { createAskAlertRegistry } = require('./notify/ask-alert-registry.js');
+const { canonicalAskAlert } = require('./notify/ask-alert-identity.js');
 const { createEventFeed } = require('./notify/event-feed.js');
 const { createEventFeedHistory } = require('./notify/event-feed-history.js');
 const { buildEnvelope } = require('./notify/event-feed-producers.js');
@@ -196,18 +200,21 @@ function createServer(opts = {}) {
   // alert budget and a durable (owner, eventId) registry — an event already
   // alerted never rings twice, across a replay or a restart. It is fed only by
   // the import hub below, so a local emission never takes this path.
+  const askAlertRegistry = createAskAlertRegistry({ filePath: path.join(notifyDir, 'ask-alerts.json') });
   const pushRelay = createPushRelay({
+    alertRegistry: askAlertRegistry,
     pushDedup: createPushDedup({ filePath: path.join(notifyDir, 'push-relay-dedup.json') }),
     send: (payload) => pushSvc.sendToAll(payload),
     log: opts.log || console.log,
   });
   const asksStore = createAsksStore({ dir: notifyDir });
+  const ownerAskScope = createOwnerAskScope(cfg);
   // --- Event feed (owner side) -------------------------------------------------
   // The notifier stays the single emission point; the feed is a SIDE EFFECT of
   // a local emission, never a separate path. Federated ingress and feed import
   // call deliverOnly(): local delivery that does NOT re-enter the publisher —
   // an imported event can never be re-exported, so A→B→A dies by construction.
-  const notifierBase = createNotifier({ hub: eventsHub, push: pushSvc });
+  const notifierBase = createNotifier({ hub: eventsHub, push: pushSvc, alertRegistry: askAlertRegistry });
   const feedHistory = createEventFeedHistory({
     filePath: path.join(notifyDir, 'event-feed-history.json'),
   });
@@ -265,12 +272,17 @@ function createServer(opts = {}) {
     // 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);
+        const ownerAskTs = ask && (ask.originNode ? ask.ownerAskTs : ask.ts);
+        notifier.emitRaw({ type: kind, id: info.askId,
+          ...(Number.isSafeInteger(ownerAskTs) && ownerAskTs > 0 ? { ownerAskTs } : {}) });
+      } catch (_) {}
       try {
         const ask = asksStore.get(info.askId);
         if (ask && !ask.originNode && closureFanout) {
           return closureFanout.dispatch({
-            askId: info.askId,
+            askId: info.askId, ownerAskTs: ask.ts,
             outcome: kind === 'ask-dismissed' ? 'dismissed' : 'answered',
             session: (ask && ask.session) || info.cellSession,
           });
@@ -369,7 +381,7 @@ function createServer(opts = {}) {
       try {
         if (frame && frame.type === 'ask' && frame.ask) {
           const ask = frame.ask;
-          const cellId = cellIdFromTmuxSession(ask.session);
+          const cellId = ownerAskScope.cellForSession(ask.session);
           if (cellId) {
             recordAndPublish({
               producer: 'ask', cellId,
@@ -379,11 +391,11 @@ function createServer(opts = {}) {
         } else if (frame && (frame.type === 'ask-answered' || frame.type === 'ask-dismissed')) {
           const all = asksStore.list({ open: false }).concat(asksStore.list({ open: true }));
           const ask = all.find((a) => a && a.id === frame.id);
-          const cellId = ask ? cellIdFromTmuxSession(ask.session) : null;
+          const cellId = ask ? ownerAskScope.cellForSession(ask.session) : null;
           if (cellId) {
             recordAndPublish({
               producer: 'ask-closed', cellId,
-              payload: { askId: frame.id, revision: (ask && ask.revision) || 0, outcome: frame.type === 'ask-dismissed' ? 'dismissed' : 'answered', ts: Date.now() },
+              payload: { askId: frame.id, askTs: ask.ts, revision: (ask && ask.revision) || 0, outcome: frame.type === 'ask-dismissed' ? 'dismissed' : 'answered', ts: Date.now() },
             });
           }
         }
@@ -393,7 +405,23 @@ function createServer(opts = {}) {
     // Delivery-only: federated ingress and feed import land here. NO history,
     // NO publisher — an imported event is never re-exported.
     async deliverOnly(frame) { return notifierBase.emit(frame); },
-    deliverOnlyRaw(frame) { return notifierBase.emitRaw(frame); },
+    deliverOnlyRaw(frame) {
+      if (frame.type === 'ask' && frame.ask && frame.ask.ownerId) {
+        eventFeedClient.rememberLiveAsk(frame.ask.ownerId, frame.ask);
+      }
+      // An authenticated owner closure must reach the SAME exported view the
+      // live ask entered, even when the store alias was already closed or
+      // absent: a fresh page rebuilds its cards from that view. scope:'local'
+      // is a local dismissal, not the owner speaking — it keeps its own path.
+      if ((frame.type === 'ask-answered' || frame.type === 'ask-dismissed')
+        && frame.ownerId && frame.ownerAskId && frame.scope !== 'local') {
+        eventFeedClient.applyOwnerClosure(frame.ownerId, frame.ownerAskId, {
+          ownerAskTs: Number.isSafeInteger(frame.ownerAskTs) && frame.ownerAskTs > 0 ? frame.ownerAskTs : undefined,
+          outcome: frame.type === 'ask-answered' ? 'answered' : 'dismissed',
+        });
+      }
+      return notifierBase.emitRaw(frame);
+    },
     publishState: (producer, payload) => recordAndPublish({ producer, cellId: null, payload }),
   };
   const diagnostics = opts.diagnostics || createDiagnostics();
@@ -1000,13 +1028,24 @@ function createServer(opts = {}) {
     cellForSession: (session) => cellIdFromTmuxSession(session),
     resolveOrigin: (req) => cellScopeOrigin.resolve(req, { requireCell: false }),
   }));
+  // UNO spawn per giro. La list-panes -a del fleet snapshot porta
+  // sessioni E supervisori insieme (lib/tmux/list.js), e lo snapshot TMUX
+  // viene coalescato entro la finestra (2 s): letture vicine di finestre o
+  // client diversi condividono lo stesso giro, chi arriva mentre il giro e'
+  // in volo aspetta quello. Oltre la finestra si rilegge. L'ENRICHMENT
+  // (outbox, preview, telemetria, attivita) resta fuori dalla cache: sono
+  // file che cambiano senza toccare tmux, e restano freschi a ogni lettura.
+  const tmuxReads = createTmuxReadWindow(async () => {
+    const panesRaw = await listFleetPanes(cfg.tmuxBin);
+    const sessions = sessionsFromPanes(panesRaw);
+    // La stessa lettura dice chi ha ancora il suo supervisore: campi 0-3
+    // delle stesse righe (parsePanes), nessuna seconda chiamata.
+    const statiSupervisore = sessions.length ? statiSupervisoreDi(panesRaw) : new Map();
+    return { sessions, statiSupervisore };
+  }, cfg.sessionsCacheMs);
   api.get('/sessions', async (_req, res) => {
     try {
-      const sessions = await listSessions(cfg.tmuxBin);
-      // UNA chiamata per giro per sapere chi ha ancora il suo supervisore.
-      const statiSupervisore = sessions.length
-        ? statiSupervisoreDi(await listPanes(cfg.tmuxBin))
-        : new Map();
+      const { sessions, statiSupervisore } = await tmuxReads.read();
       const sum = watcher.getSummary();
       const enriched = await Promise.all(sessions.map(async (s) => {
         const sample = await previews.getState(s.name);
@@ -1225,7 +1264,8 @@ 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, ownerAskId: closed.ask.ownerAskId }); } catch (_) {}
+            try { notifier.deliverOnlyRaw({ type: 'ask-dismissed', id: closed.ask.id, ownerId, ownerAskId: closed.ask.ownerAskId,
+              ...(Number.isSafeInteger(closed.ask.ownerAskTs) && closed.ask.ownerAskTs > 0 ? { ownerAskTs: closed.ask.ownerAskTs } : {}) }); } catch (_) {}
           }
         } catch (_) { /* un alias non chiudibile non ferma gli altri */ }
       }
@@ -1239,8 +1279,8 @@ function createServer(opts = {}) {
     // 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 })
+    run: ({ askId, ownerAskTs, outcome, session, targets }) => (closureFanout
+      ? closureFanout.dispatch({ askId, ownerAskTs, outcome, session, retryOnFailure: false, targets })
       : Promise.resolve([])),
   });
   closureFanout = createClosureFanout({
@@ -1294,7 +1334,7 @@ function createServer(opts = {}) {
     asks: asksStore,
     answerService: askAnswerService,
     receipts: askReceipts,
-    cellForSession: (session) => cellIdFromTmuxSession(session),
+    cellForSession: ownerAskScope.cellForSession,
     readonly: proxyReadonly,
   }));
   api.use('/event-feed', createEventFeedRoutes({
@@ -1308,7 +1348,8 @@ function createServer(opts = {}) {
     history: feedHistory,
     asksStore,
     fleetP,
-    cellForSession: (session) => cellIdFromTmuxSession(session),
+    cellForSession: ownerAskScope.cellForSession,
+    askScopeResolver: ownerAskScope.snapshotResolver,
     eventsEnabled,
     // Il produttore dello snapshot logga la lettura fallita degli asks: senza
     // questo wiring la riga finiva nel noop di default delle routes.
@@ -1477,7 +1518,12 @@ function createServer(opts = {}) {
   // durable write.
   const importHub = {
     broadcast: (event) => {
-      eventsHub.broadcast(event);
+      const alert = event && event.type === 'notify' && canonicalAskAlert(event);
+      const claim = alert && !bridgeReadonly() ? askAlertRegistry.claim(event, 'ui') : { allowed: true };
+      if (claim.allowed) {
+        const count = eventsHub.broadcast(event);
+        if (alert && !bridgeReadonly()) askAlertRegistry.complete(event, 'ui', count);
+      }
       if (!bridgeReadonly()) pushRelay.considerImported(event);
     },
   };
@@ -1488,8 +1534,12 @@ function createServer(opts = {}) {
     }
   }
   const eventFeedClient = createEventFeedClient({
+    onViewChanged: ownerId => eventsHub.broadcast({ type: 'feed-state-changed', ownerId }),
+    onAuthoritativeAsks: (ownerId, asks) => {
+      if (!bridgeReadonly()) for (const ask of asks) askAlertRegistry.adopt(ownerId, ask, ask.ownerAskTs === undefined ? ask.ts : ask.ownerAskTs);
+    },
     isAskDismissed: (ownerId, ask) => asksStore.isImportedDismissed(ownerId, ask),
-    onAskClosed: (ownerId, ownerAskId, outcome) => asksStore.closeImported({ ownerId, ownerAskId, outcome }),
+    onAskClosed: (ownerId, ownerAskId, outcome, ownerAskTs) => asksStore.closeImported({ ownerId, ownerAskId, outcome, ownerAskTs }),
     loadStore: () => nodesStore.loadStore(nodesPath),
     token: () => tokenHolder.value,
     eventsHub: importHub,

package/lib/tmux/list.js

@@ -108,6 +108,50 @@ function listSessions(tmuxBin = 'tmux') {
   });
 }
 
+// Il formato "fleet snapshot": i campi del supervisore di PANES_FMT (primi
+// quattro, gli stessi che legge parsePanes) SEGUITI dai campi della sessione.
+// UNA sola chiamata list-panes -a alimenta sia lo stato dei supervisori sia
+// l'inventario sessioni di /api/sessions: due spawn per giro diventano uno.
+// L'ordine dei campi sessione rispecchia FMT (name, attached, windows,
+// created, activity, cmd, visibility, titolo), con i due marker del pane
+// attivo prima del titolo.
+const FLEET_PANES_FMT = `${PANES_FMT}\t#{session_attached}\t#{session_windows}\t#{session_created}\t#{session_activity}\t#{pane_current_command}\t#{@nexuscrew_visibility}\t#{window_active}\t#{pane_active}\t#{pane_title}`;
+
+// Dalle righe per-pane alle righe per-SESSIONE: per ogni nome tiene il pane
+// ATTIVO (window_active=1 e pane_active=1) — lo stesso pane a cui si
+// riferivano i formati pane_* di list-sessions. I campi sessione sono uguali
+// su tutte le righe dello stesso nome; cambia solo quale pane parla, e deve
+// parlare quello attivo.
+function sessionsFromPanes(raw) {
+  const rows = new Map();
+  for (const line of String(raw).split('\n')) {
+    if (!line.trim()) continue;
+    const f = line.split('\t');
+    const name = f[0];
+    if (!name) continue;
+    const attiva = f[10] === '1' && f[11] === '1';
+    const previous = rows.get(name);
+    if (previous && (!attiva || previous.attiva)) continue;
+    rows.set(name, {
+      attiva,
+      line: [f[0], f[4], f[5], f[6], f[7], f[8], f[9], f.slice(12).join('\t')].join('\t'),
+    });
+  }
+  return parseSessions([...rows.values()].map((r) => r.line).join('\n'));
+}
+
+function listFleetPanes(tmuxBin = 'tmux') {
+  return new Promise((resolve, reject) => {
+    execFile(tmuxBin, ['list-panes', '-a', '-F', FLEET_PANES_FMT], (err, stdout, stderr) => {
+      if (err) {
+        if (isNoTmuxServerError(stderr || err.message)) return resolve('');
+        return reject(new Error(`tmux list-panes failed: ${stderr || err.message}`));
+      }
+      resolve(stdout);
+    });
+  });
+}
+
 // How many clients are already attached to this session (before our attach).
 // Used to pick a sane resize default: drive the size only when no one else is watching.
 function attachedClients(tmuxBin = 'tmux', session) {
@@ -123,4 +167,5 @@ function attachedClients(tmuxBin = 'tmux', session) {
 
 module.exports = {
   parsePaneTitle, parseSessions, isNoTmuxServerError, listSessions, listPanes, attachedClients, setSessionVisibility, FMT,
+  FLEET_PANES_FMT, sessionsFromPanes, listFleetPanes,
 };

package/lib/tmux-reads.js

@@ -0,0 +1,44 @@
+'use strict';
+
+// Coalescing della risposta di /api/sessions (finestra di 2 s, decisione
+// operativa: latenza percepita al piu' pari alla finestra in cambio di spawn
+// dimezzati — anzi, di UNO spawn per finestra condiviso fra client).
+//
+// Tre comportamenti, tutti voluti:
+//  - letture entro la finestra servono la risposta gia' pronta: zero spawn;
+//  - letture che arrivano mentre il giro e' in volo aspettano QUELLO giro
+//    (mai due serie di spawn contemporanee per lo stesso endpoint);
+//  - un errore non si cache-a: il giro fallito non lascia nulla e la
+//    prossima lettura riparte da zero.
+//
+// La finestra e' breve PERCHE' la cache non deve nascondere i cambi di tmux:
+// kill, avvio e cambio finestra diventano visibili al piu' tardi al primo
+// giro dopo la finestra. Il test di freschezza custodisce esattamente questo.
+
+// Finestra di coalescing in millisecondi. Il valore e' un contratto
+// operativo (decisione approvata): al piu' 2 s di latenza aggiuntiva sulla
+// vista sessioni, in cambio di una serie sola di spawn per finestra.
+const TMUX_READS_WINDOW_MS = 2000;
+
+function createTmuxReadWindow(loader, windowMs = TMUX_READS_WINDOW_MS) {
+  let cached = null;
+  let inFlight = null;
+  return {
+    async read() {
+      if (cached && Date.now() - cached.at < windowMs) return cached.value;
+      if (inFlight) return inFlight;
+      inFlight = (async () => {
+        try {
+          const value = await loader();
+          cached = { at: Date.now(), value };
+          return value;
+        } finally {
+          inFlight = null;
+        }
+      })();
+      return inFlight;
+    },
+  };
+}
+
+module.exports = { TMUX_READS_WINDOW_MS, createTmuxReadWindow };

package/package.json

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