@mmmbuto/nexuscrew 0.9.15 → 0.9.16

package/lib/server.js

@@ -71,6 +71,7 @@ const { createNotifier } = require('./notify/notifier.js');
 const { notifyRoutes } = require('./notify/routes.js');
 const { createNpmUpdater } = require('./update/manager.js');
 const { createDiagnostics } = require('./diagnostics/store.js');
+const { createDropCounter } = require('./ws/drop-counter.js');
 const { diagnosticsRoutes } = require('./diagnostics/routes.js');
 const vlNodeStore = require('./vl-nodes/store.js');
 const { createBroker: createVlNodeBroker } = require('./vl-nodes/broker.js');
@@ -146,6 +147,8 @@ function createServer(opts = {}) {
   const asksStore = createAsksStore({ dir: notifyDir });
   const notifier = createNotifier({ hub: eventsHub, push: pushSvc });
   const diagnostics = opts.diagnostics || createDiagnostics();
+  // Contatore cadute WS (rolling 10 min): alimenta i meta dei log di bridge.
+  const wsDropCounter = createDropCounter();
   const updater = opts.updateManager || createNpmUpdater({
     currentVersion: VERSION,
     home: cfg.home || os.homedir(),
@@ -942,6 +945,7 @@ function createServer(opts = {}) {
   }));
   api.use('/cells', cellsRoutes({
     fleetP,
+    diagnostics,
     instanceId: () => (nodesStore.loadStore(nodesPath) || {}).nodeId || null,
     submit: opts.cellSubmit || ((session, text, meta) => submitToSession(cfg.tmuxBin, session, text, {
       engine: meta && meta.engine,
@@ -1139,7 +1143,13 @@ function createServer(opts = {}) {
   // lato browser, che il client riconnette senza richiedere refresh pagina.
   const heartbeat = setInterval(() => {
     for (const client of wss.clients) {
-      if (client.isAlive === false) { try { client.terminate(); } catch (_) {} continue; }
+      if (client.isAlive === false) {
+        // Marca il motivo PRIMA del terminate: il close event (1006) nel bridge
+        // lo classifichera' come heartbeat-timeout invece di «drop TCP generico».
+        try { client.__ncCloseReason = 'heartbeat-timeout'; } catch (_) {}
+        try { client.terminate(); } catch (_) {}
+        continue;
+      }
       client.isAlive = false;
       try { client.ping(); } catch (_) { try { client.terminate(); } catch (_e) {} }
     }
@@ -1234,6 +1244,8 @@ function createServer(opts = {}) {
       defaults: { readonlyDefault: cfg.readonlyDefault, tmuxBin: cfg.tmuxBin },
       ptyGrace,
       onAttach: (sess) => attachedWs.set(ws, sess),
+      diagnostics,
+      dropCounter: wsDropCounter,
     });
     ws.on('close', () => attachedWs.delete(ws));
   });

package/lib/ws/bridge.js

@@ -118,10 +118,24 @@ function sendJson(ws, value) {
 }
 
 function bindWs(ws, deps) {
-  const { openAttach, verifyToken, isValidSession = () => true, runAction = () => false, countClients = () => 0, defaults = {}, onAttach = () => {}, ptyGrace = null } = deps;
+  const { openAttach, verifyToken, isValidSession = () => true, runAction = () => false, countClients = () => 0, defaults = {}, onAttach = () => {}, ptyGrace = null, diagnostics = null, dropCounter = null } = deps;
   let record = null;
   let attached = false;
   let session = null;
+  let closeLogged = false;
+  // UNA sola riga diagnostica per socket: la prima chiusura vince. Le
+  // successive (close + error sullo stesso socket) non generano rumore.
+  const logClose = (level, event, message, meta = {}) => {
+    if (closeLogged) return;
+    closeLogged = true;
+    if (!diagnostics) return;
+    try { diagnostics.record(level, 'ws', event, message, { cell: session || undefined, ...meta }); } catch (_) {}
+  };
+  const countDrop = () => {
+    if (!dropCounter) return {};
+    const snap = dropCounter.recordDrop(session);
+    return { drops: snap.drops };
+  };
 
   const detach = () => {
     if (!record || record.ws !== ws) return;
@@ -144,6 +158,11 @@ function bindWs(ws, deps) {
     // fino al close event tiene in piedi un handle senza scopo.
     clearAttachTimer();
     sendJson(ws, { type: 'error', reason });
+    // Chiusura INITIATA DAL SERVER: il motivo e' qui, non nel close event.
+    // Level warn = sempre visibile (non richiede verbose).
+    logClose('warn', 'WS_SERVER_CLOSE', `Server closed socket: ${reason}`, {
+      reason: String(reason).slice(0, 48), closeCode: Number(code) || undefined, ...countDrop(),
+    });
     try { ws.close(code, reason); } catch (_) {}
   }
 
@@ -197,12 +216,14 @@ function bindWs(ws, deps) {
         attached = true;
         session = record.session;
         onAttach(session, ws);
+        logReattach();
         sendJson(ws, { type: 'attached', reconnectToken: record.resumeToken });
         return;
       }
       attached = true;
       clearAttachTimer();
       session = msg.session;
+      logReattach();
       // Resize default: when nobody else is attached, drive the session size so a
       // small phone gets a usable (non-clipped) view and clean line editing. When a
       // real terminal is already attached, default to ignore-size so we don't shrink
@@ -250,6 +271,9 @@ function bindWs(ws, deps) {
       record.pty.onExit((info) => {
         record.ended = true;
         record.exitCode = info && info.exitCode;
+        logClose('notice', 'PTY_EXIT', 'Sessione terminata dal PTY', {
+          exitCode: typeof record.exitCode === 'number' ? record.exitCode : undefined,
+        });
         if (!record.ws) return;
         sendJson(record.ws, { type: 'exit', code: record.exitCode });
         try { record.ws.close(1000, 'exit'); } catch (_) {}
@@ -272,8 +296,37 @@ function bindWs(ws, deps) {
     else if (msg.type === 'action') runAction(session, msg.name); // nav window/pane server-side
   }
 
+  // Alla riconnessione la DURATA della caduta e' il gap close->reopen della
+  // stessa sessione. Ritorni con gap = notice (sempre visibili); un primo
+  // attach senza storia e' debug (solo verbose).
+  function logReattach() {
+    if (!diagnostics) return;
+    if (!dropCounter) return;
+    try {
+      const reopen = dropCounter.recordReopen(session);
+      if (reopen.gapMs != null) {
+        diagnostics.record('notice', 'ws', 'WS_REATTACHED', 'Riconnesso dopo una caduta', {
+          cell: session, gapMs: reopen.gapMs, drops: reopen.drops,
+        });
+      } else {
+        diagnostics.record('debug', 'ws', 'WS_ATTACHED', 'Attach completato', { cell: session });
+      }
+    } catch (_) {}
+  }
+
   ws.on('message', onMessage);
-  ws.on('close', () => { clearAttachTimer(); detach(); });
+  ws.on('close', (code) => {
+    clearAttachTimer(); detach();
+    if (closeLogged) return;
+    const closeCode = Number(code) || undefined;
+    if (ws.__ncCloseReason === 'heartbeat-timeout') {
+      logClose('warn', 'WS_HEARTBEAT_DROPPED', 'Heartbeat scaduto: connessione mezzo-aperta terminata', { closeCode, ...countDrop() });
+    } else if (closeCode === 1006) {
+      logClose('warn', 'WS_ABNORMAL_CLOSE', 'Chiusura senza handshake (drop TCP o terminate)', { closeCode, ...countDrop() });
+    } else {
+      logClose('notice', 'WS_CLIENT_CLOSE', 'Il client ha chiuso la connessione', { closeCode, ...countDrop() });
+    }
+  });
   ws.on('error', () => { clearAttachTimer(); detach(); });
 }
 module.exports = { bindWs, clamp, createPtyGraceStore, PTY_GRACE_MS };

package/lib/ws/drop-counter.js

@@ -0,0 +1,37 @@
+'use strict';
+// Contatore di cadute WebSocket: trasforma «celle che vanno e vengono»
+// in numeri — quante cadute nella finestra (default 10 minuti) e, alla
+// riconnessione, quanto è durata la caduta (gap tra close e reopen).
+// In memoria, zero I/O: i valori viaggiano nei meta dei log di bridge.js.
+function createDropCounter({ windowMs = 10 * 60 * 1000, now = Date.now } = {}) {
+  const drops = []; // { ts, sessionId }
+  const lastClose = new Map(); // sessionId -> ts
+  const key = (s) => String(s == null ? '' : s);
+  function prune(ts) {
+    const cutoff = ts - windowMs;
+    while (drops.length && drops[0].ts < cutoff) drops.shift();
+  }
+  return {
+    recordDrop(session, ts = now()) {
+      const k = key(session);
+      drops.push({ ts, sessionId: k });
+      if (k) lastClose.set(k, ts);
+      prune(ts);
+      return { drops: drops.length, windowSeconds: Math.round(windowMs / 1000) };
+    },
+    // Alla riconnessione: la durata della caduta e' il gap close->reopen.
+    // Consuma il last close: una connessione lunga e sana non e' «ritorno».
+    recordReopen(session, ts = now()) {
+      const k = key(session);
+      const last = lastClose.get(k);
+      lastClose.delete(k);
+      prune(ts);
+      return { gapMs: last == null ? null : Math.max(0, ts - last), drops: drops.length };
+    },
+    snapshot(ts = now()) {
+      prune(ts);
+      return { drops: drops.length, windowSeconds: Math.round(windowMs / 1000) };
+    },
+  };
+}
+module.exports = { createDropCounter };

package/package.json

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

package/skills/nexuscrew/SKILL.md

@@ -23,7 +23,7 @@ Five nouns carry almost everything:
 - **Node** — one installation on one machine. Its identity is an opaque
   `instanceId`; the human-readable name is a **label**, and two nodes may
   legitimately carry the same one. **Address things by id, never by name.**
-- **Cell** — one stable working identity (`Dev`, `Research`, …) bound to one
+- **Cell** — one stable working identity (`Alpha`, `Beta`, …) bound to one
   tmux session and one engine. A cell is not a process: it survives restarts of
   the service, and stopping it does not end the work it was doing.
 - **Engine** — what a cell runs: an AI CLI, a plain shell, a command in a