@mmmbuto/nexuscrew 0.9.40 → 0.9.41

package/frontend/dist/index.html

@@ -11,8 +11,8 @@
   <meta name="apple-mobile-web-app-title" content="NexusCrew" />
   <link rel="manifest" href="/manifest.json" />
   <title>NexusCrew</title>
-  <script type="module" crossorigin src="/assets/index-BJBurY16.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-Csz8VaFz.css">
+  <script type="module" crossorigin src="/assets/index-DGa2FEN2.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-Ca1Rl40n.css">
 </head>
 <body>
   <div id="root"></div>

package/frontend/dist/version.json

@@ -1 +1 @@
-{"version":"0.9.40"}
+{"version":"0.9.41"}

package/lib/files/activity.js

@@ -0,0 +1,294 @@
+'use strict';
+// Attivita' per-cella: lo stato del turno pubblicato dagli HOOK di Claude Code.
+//
+// Perche' un file proprio e non telemetry.json: la statusline e gli hook sono
+// due scrittori indipendenti. Un read-modify-write non coordinato perde gli
+// aggiornamenti dell'altro, e un timestamp unico farebbe sembrare fresco uno
+// stato attività vecchio quando arrivano nuove percentuali. Due file, due
+// contratti, un solo scrittore ciascuno.
+//
+// Il file NON contiene il payload dell'hook: quello porta il testo del prompt e
+// i percorsi della sessione, che allo stato non servono. Solo l'evento, il
+// timestamp, l'identita' della sessione e la generazione.
+//
+// Quattro regole, le stesse di telemetry.js ma con esito diverso:
+//   1. TIMESTAMP OBBLIGATORIO e guardato nei DUE versi — oltre la finestra il
+//      dato e' morto, e un ts nel futuro non deve restare fresco per sempre.
+//   2. SCADUTO NON E' IDLE: oltre la finestra si torna `null`, che la UI mostra
+//      come «non verificato». Mai affermare «ferma» su un dato che non
+//      verifica nulla: e' l'unico modo di coprire l'interruzione con Ctrl-C,
+//      che (misurato su Claude Code 2.1.280) NON emette alcun evento.
+//   3. GENERAZIONE: lo stato di un lancio precedente della stessa cella non
+//      vale per quello corrente. La generazione corrente la scrive il launcher
+//      (activity.gen); un file che ne porta un'altra viene scartato.
+//   4. LETTURA TOLLERANTE: file assente, illeggibile o JSON rotto -> null, mai
+//      un'eccezione: la lista delle sessioni non deve fallire per questo.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const NOME_FILE = 'activity.json';
+const NOME_GENERAZIONE = 'activity.gen';
+
+// Un turno che usa tool rinnova la freschezza a ogni PreToolUse/PostToolUse,
+// quindi la finestra copre l'attesa fra un tool e il successivo. Un turno lungo
+// SENZA tool puo' invece superarla: in quel caso lo stato diventa «non
+// verificato», che e' l'esito voluto — meglio un'incertezza dichiarata di un
+// «al lavoro» affermato senza prova.
+const MASSIMA_ETA_MS = 5 * 60 * 1000;
+const FUTURO_TOLLERATO_MS = 2 * 60 * 1000;
+
+const LAVORA = 'lavora';
+const FERMA = 'ferma';
+const ATTESA = 'attesa';
+
+// La matrice evento -> stato e' quella MISURATA nel Gate A su Claude Code
+// 2.1.280, non quella attesa sulla carta. In particolare:
+//  - `SubagentStop` NON chiude il turno: il principale sta ancora lavorando,
+//    quindi rinnova la freschezza restando su «lavora». Usarlo come «ferma»
+//    sarebbe un falso negativo (il figlio finisce, il padre no).
+//  - `SessionEnd` non afferma «ferma»: quella sessione non esiste piu', e
+//    quello che resta da dire e' che il dato non e' piu' verificabile.
+//  - `Notification` vale solo se il tipo e' la richiesta di permesso: gli altri
+//    tipi non sono stati misurati e non autorizzano nessuna transizione.
+const STATO_PER_EVENTO = Object.freeze({
+  SessionStart: FERMA,
+  UserPromptSubmit: LAVORA,
+  PreToolUse: LAVORA,
+  PostToolUse: LAVORA,
+  SubagentStop: LAVORA,
+  Stop: FERMA,
+  PermissionRequest: ATTESA,
+});
+
+const TIPO_PERMESSO = 'permission_prompt';
+
+/**
+ * Stato dichiarato da un evento, oppure null se l'evento non autorizza nessuna
+ * transizione (o non e' un evento noto). Non lancia mai.
+ */
+function statoDaEvento(evento, tipoNotifica) {
+  if (typeof evento !== 'string' || !evento) return null;
+  if (evento === 'Notification') {
+    return tipoNotifica === TIPO_PERMESSO ? ATTESA : null;
+  }
+  if (evento === 'SessionEnd') return null;
+  return Object.prototype.hasOwnProperty.call(STATO_PER_EVENTO, evento)
+    ? STATO_PER_EVENTO[evento]
+    : null;
+}
+
+/**
+ * Se questo evento debba essere SCRITTO sul file, oppure no.
+ *
+ * Non e' la stessa domanda di `statoDaEvento`. Due casi la separano:
+ *  - `SessionEnd` non dichiara uno stato, ma DEVE essere scritto: e' cosi' che
+ *    si invalida il dato di una sessione che non esiste piu' (il lettore,
+ *    trovandolo, torna null). Non scriverlo lascerebbe in giro lo stato
+ *    precedente — «lavora» o «ferma» — per tutta la finestra.
+ *  - una `Notification` di tipo diverso da `permission_prompt` non deve
+ *    TOCCARE il file: se scrivesse, sovrascriverebbe uno stato fresco e
+ *    legittimo («al lavoro») con un evento che il lettore non sa mappare, e la
+ *    cella diventerebbe «non verificata» mentre sta lavorando. Il caso e'
+ *    COSTRUITO, non misurato: di `notification_type` e' stato osservato un solo
+ *    valore (`permission_prompt`), gli altri non sono enumerati. La prudenza
+ *    sta proprio qui — non si mappa cio' che non si e' misurato, e non si
+ *    scrive un evento che poi il lettore scarterebbe.
+ *
+ * Un evento sconosciuto non scrive: non si tocca cio' che non si sa leggere.
+ */
+function daRegistrare(evento, tipoNotifica) {
+  if (typeof evento !== 'string' || !evento) return false;
+  if (evento === 'SessionEnd') return true;
+  if (evento === 'Notification') return tipoNotifica === TIPO_PERMESSO;
+  return Object.prototype.hasOwnProperty.call(STATO_PER_EVENTO, evento);
+}
+
+function leggiGenerazioneCorrente(dirSessione) {
+  try {
+    const raw = fs.readFileSync(path.join(dirSessione, NOME_GENERAZIONE), 'utf8').trim();
+    return raw || null;
+  } catch (_) { return null; }
+}
+
+/**
+ * Scrive la generazione corrente della cella. Chiamata dal launcher al momento
+ * del lancio: e' l'unico scrittore di questo file.
+ */
+function scriviGenerazione(dirSessione, generazione) {
+  if (typeof generazione !== 'string' || !generazione) return false;
+  const destinazione = path.join(dirSessione, NOME_GENERAZIONE);
+  let tmp = null;
+  try {
+    fs.mkdirSync(dirSessione, { recursive: true });
+    // Stessa ragione di `scriviStato`: un nome di temporaneo condiviso perde la
+    // scrittura di chi arriva secondo. Qui il rischio e' piu' basso (il
+    // launcher e' l'unico scrittore), ma il difetto sarebbe identico.
+    tmp = tmpUnivoco(dirSessione, NOME_GENERAZIONE);
+    fs.writeFileSync(tmp, generazione, { encoding: 'utf8', mode: 0o600 });
+    fs.renameSync(tmp, destinazione);
+    return true;
+  } catch (_) {
+    if (tmp) { try { fs.unlinkSync(tmp); } catch (_) {} }
+    return false;
+  }
+}
+
+/**
+ * Nome di un temporaneo ESCLUSIVO di questo processo.
+ *
+ * Non basta `file.tmp`: gli hook sono processi distinti che possono scrivere
+ * nello stesso istante, e con un nome condiviso si sovrascrivono il temporaneo
+ * a vicenda — il secondo `rename` trova il file gia' consumato e fallisce con
+ * ENOENT, e quella scrittura e' persa. Uno `Stop` perso lascia la cella su
+ * «lavora» fino alla scadenza: e' il sintomo che questo modulo esiste per
+ * togliere. Stessa forma gia' usata per il profilo MCP di cella.
+ */
+function tmpUnivoco(dirSessione, nome) {
+  return path.join(dirSessione, `${nome}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`);
+}
+
+// Sezione critica per cella, con un lock di file.
+//
+// Perche' non basta il ri-controllo prima del `rename`: due scrittori possono
+// leggere lo stesso ts vecchio, scrivere i propri temporanei e pubblicare
+// entrambi — l'ultimo `rename` vince, e puo' essere il piu' VECCHIO. Misurato:
+// con ts ravvicinati l'evento piu' recente perdeva il confronto nel 12-20% dei
+// giri. Il confronto e la pubblicazione devono stare nella stessa sezione
+// critica, o l'ordinamento non e' garantito.
+//
+// Il lock ha un guasto proprio — un processo ucciso dentro la sezione critica
+// lo lascia orfano — e per questo NON puo' bloccare nulla per sempre:
+//  - un lock piu' vecchio di un secondo si considera orfano e viene scavalcato
+//    (la sezione critica sono due syscall: un lock di un secondo non e' lavoro
+//    in corso, e' un morto);
+//  - se entro il budget non lo si ottiene, si scrive COMUNQUE. Nel caso
+//    peggiore si torna al comportamento senza lock, che perde l'ordine in una
+//    corsa stretta ma non perde mai una scrittura: marcire in silenzio sarebbe
+//    peggio, perche' la cella resterebbe «al lavoro» per sempre.
+const BUDGET_LOCK_MS = 2000;
+const ETA_ORFANO_MS = 1000;
+
+function conLock(dirSessione, fn) {
+  const lock = path.join(dirSessione, `${NOME_FILE}.lock`);
+  const scadenza = Date.now() + BUDGET_LOCK_MS;
+  for (;;) {
+    try {
+      const fd = fs.openSync(lock, 'wx', 0o600);
+      fs.closeSync(fd);
+      try { return fn(); } finally { try { fs.unlinkSync(lock); } catch (_) {} }
+    } catch (e) {
+      if (e.code !== 'EEXIST') return fn(); // lock non praticabile: si scrive lo stesso
+      try {
+        if (Date.now() - fs.statSync(lock).mtimeMs > ETA_ORFANO_MS) { fs.unlinkSync(lock); continue; }
+      } catch (_) { continue; } // sparito mentre lo si guardava
+      if (Date.now() > scadenza) return fn();
+      const fine = Date.now() + 2; while (Date.now() < fine); // attesa breve
+    }
+  }
+}
+
+// Il ts gia' pubblicato, o null se non c'e' / non e' leggibile.
+function tsPubblicato(dirSessione) {
+  try {
+    const dato = JSON.parse(fs.readFileSync(path.join(dirSessione, NOME_FILE), 'utf8'));
+    const ts = Number(dato && dato.ts);
+    return Number.isFinite(ts) ? ts : null;
+  } catch (_) { return null; }
+}
+
+/**
+ * Scrittura atomica dello stato: temporaneo ESCLUSIVO + rename nella stessa
+ * directory. Piu' hook possono scattare a raffica (PreToolUse/PostToolUse) e in
+ * PROCESSI diversi, e un lettore non deve mai vedere un file a meta'.
+ *
+ * ORDINAMENTO: due hook possono arrivare invertiti — il processo di un evento
+ * piu' vecchio puo' essere schedulato dopo quello di uno piu' recente. Decide
+ * il `ts`: un evento piu' vecchio non riporta indietro lo stato, altrimenti una
+ * `Stop` gia' registrata verrebbe cancellata da un `PreToolUse` in ritardo.
+ *
+ * Ritorna `true` quando il deposito riflette ALMENO questo evento — scritto, o
+ * superato da uno piu' recente — e `false` solo su un guasto reale. La
+ * differenza conta per chi chiama: `false` significa «il tuo evento non e' nel
+ * deposito», mai «il tuo evento era vecchio».
+ *
+ * LIMITE DICHIARATO: se il lock non e' ottenibile entro il budget — caso
+ * patologico, non misurato in esercizio — si scrive comunque, e allora resta la
+ * corsa stretta fra due scrittori (l'evento piu' recente puo' perdere). Il
+ * temporaneo esclusivo fa si' che anche in quel caso non si perda nessuna
+ * scrittura e non si veda mai un file a meta': cambia solo CHI vince.
+ */
+function scriviStato(dirSessione, { evento, tipo, sessionId, generazione, ora = Date.now() } = {}) {
+  if (typeof evento !== 'string' || !evento) return false;
+  const dato = { event: evento, ts: ora };
+  if (typeof sessionId === 'string' && sessionId) dato.session_id = sessionId;
+  if (typeof generazione === 'string' && generazione) dato.generation = generazione;
+  if (typeof tipo === 'string' && tipo) dato.notification_type = tipo;
+  const destinazione = path.join(dirSessione, NOME_FILE);
+  try {
+    fs.mkdirSync(dirSessione, { recursive: true });
+  } catch (_) { return false; }
+  // Confronto e pubblicazione nella STESSA sezione critica: e' l'unico modo in
+  // cui «l'evento piu' recente vince» e' una garanzia invece di una speranza.
+  return conLock(dirSessione, () => {
+    let tmp = null;
+    try {
+      const pubblicato = tsPubblicato(dirSessione);
+      if (pubblicato !== null && pubblicato > ora) return true;
+      tmp = tmpUnivoco(dirSessione, NOME_FILE);
+      fs.writeFileSync(tmp, `${JSON.stringify(dato)}\n`, { encoding: 'utf8', mode: 0o600 });
+      fs.renameSync(tmp, destinazione);
+      return true;
+    } catch (_) {
+      if (tmp) { try { fs.unlinkSync(tmp); } catch (_) {} }
+      return false;
+    }
+  });
+}
+
+/**
+ * Legge lo stato di attivita' di una sessione. Ritorna
+ * `{ stato, ts, sessionId, generazione }`, oppure null per assenza,
+ * dato scaduto, generazione superata, evento che non autorizza transizioni o
+ * qualsiasi rottura. Non lancia MAI.
+ */
+function leggiAttivita(root, sessione, ora = Date.now()) {
+  try {
+    if (typeof sessione !== 'string' || !sessione) return null;
+    // Un nome con separatori non deve poter uscire dalla root.
+    if (sessione.includes('/') || sessione.includes('\\') || sessione === '..') return null;
+    const dir = path.join(root, sessione);
+    let raw;
+    try {
+      raw = fs.readFileSync(path.join(dir, NOME_FILE), 'utf8');
+    } catch (_) { return null; }
+    const dato = JSON.parse(raw);
+    if (!dato || typeof dato !== 'object' || Array.isArray(dato)) return null;
+    const ts = Number(dato.ts);
+    if (!Number.isFinite(ts)) return null;
+    if (ora - ts > MASSIMA_ETA_MS) return null;
+    if (ts - ora > FUTURO_TOLLERATO_MS) return null;
+
+    // Generazione: se il launcher ne ha dichiarata una e il file ne porta
+    // un'altra, lo stato appartiene a un lancio precedente della stessa cella.
+    const corrente = leggiGenerazioneCorrente(dir);
+    const dalFile = typeof dato.generation === 'string' && dato.generation ? dato.generation : null;
+    if (corrente && dalFile && corrente !== dalFile) return null;
+
+    const stato = statoDaEvento(dato.event, dato.notification_type);
+    if (!stato) return null;
+    return {
+      stato,
+      ts,
+      sessionId: typeof dato.session_id === 'string' ? dato.session_id : null,
+      generazione: dalFile,
+    };
+  } catch (_) { return null; }
+}
+
+module.exports = {
+  leggiAttivita, scriviStato, scriviGenerazione, statoDaEvento, daRegistrare,
+  NOME_FILE, NOME_GENERAZIONE, MASSIMA_ETA_MS, FUTURO_TOLLERATO_MS,
+  LAVORA, FERMA, ATTESA, TIPO_PERMESSO, STATO_PER_EVENTO,
+};

package/lib/fleet/cell-exec.js

@@ -71,17 +71,37 @@ function promptCharsOk(prompt) {
   return true;
 }
 
+// Gate readiness MCP nel payload. I nomi attesi sono quelli del file
+// cell-mcp materializzato (qualsiasi stringa safe <=64: la charset stretta
+// vale solo sui valori che finiscono nell'opzione pane @nc_mcp_list).
+function validMcpReadiness(value) {
+  if (value === undefined) return true;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  if (Object.keys(value).some((key) => !['cwd', 'expectedServers', 'budgetMs', 'pollMs', 'cacheRoot'].includes(key))) return false;
+  return typeof value.cwd === 'string' && value.cwd.length > 0 && value.cwd.length <= 4096
+    && !/[\0\r\n]/.test(value.cwd)
+    && Array.isArray(value.expectedServers) && value.expectedServers.length > 0
+    && value.expectedServers.length <= 64
+    && value.expectedServers.every((n) => typeof n === 'string' && n.length >= 1
+      && n.length <= 64 && !/[\0\r\n]/.test(n))
+    && (value.budgetMs === undefined || validInteger(value.budgetMs, 0, 120000))
+    && (value.pollMs === undefined || validInteger(value.pollMs, 50, 5000))
+    && (value.cacheRoot === undefined || (typeof value.cacheRoot === 'string'
+      && value.cacheRoot.length > 0 && value.cacheRoot.length <= 4096 && !/[\0\r\n]/.test(value.cacheRoot)));
+}
+
 function validRestartPrompt(value) {
   if (value === undefined) return true;
   if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-  if (Object.keys(value).some((key) => !['tmuxBin', 'tmuxSession', 'prompt', 'readyMs', 'client', 'readyWaitMs'].includes(key))) return false;
+  if (Object.keys(value).some((key) => !['tmuxBin', 'tmuxSession', 'prompt', 'readyMs', 'client', 'readyWaitMs', 'mcpReadiness'].includes(key))) return false;
   return typeof value.tmuxBin === 'string' && value.tmuxBin.length > 0 && value.tmuxBin.length <= 4096
     && !/[\0\r\n]/.test(value.tmuxBin)
     && typeof value.tmuxSession === 'string' && /^[\w.@%:+-]{1,128}$/.test(value.tmuxSession)
     && promptCharsOk(value.prompt)
     && (value.readyMs === undefined || validInteger(value.readyMs, 0, 30000))
     && (value.client === undefined || value.client === '' || value.client === 'kimi' || value.client === 'claude')
-    && (value.readyWaitMs === undefined || validInteger(value.readyWaitMs, 0, 120000));
+    && (value.readyWaitMs === undefined || validInteger(value.readyWaitMs, 0, 120000))
+    && (value.mcpReadiness === undefined || validMcpReadiness(value.mcpReadiness));
 }
 
 function validIdentity(value) {
@@ -428,10 +448,36 @@ function waitChild(child) {
 // post-paste incerto (delivery-unknown / staged-not-submitted) — il main loop
 // NON auto-restarta in quel caso (leftover bytes potenzialmente residui nel PTY del
 // pane riusato; fermo bounded + restart operatore).
+// Gate readiness MCP per le claude.* (config.mcpReadiness dal payload).
+// La deadline e' COMPOSTA sullo stesso orologio del launch (notBeforeMs =
+// avvio della GENERAZIONE corrente, mai handshake di una generazione
+// precedente; budgetMs dal tetto approvato) e la cancellazione ferma il polling
+// prima del respawn (isCancelled valutato ad ogni poll dalla deliver).
+function buildMcpWait(config, seams) {
+  const mr = config && config.mcpReadiness;
+  if (!mr || !Array.isArray(mr.expectedServers) || mr.expectedServers.length === 0) return null;
+  const now = seams.nowImpl || Date.now;
+  const startedAt = now();
+  const budget = Math.max(0, Number(mr.budgetMs) || 20000);
+  const waitImpl = seams.waitMcpReadiness || require('./mcp-cache-readiness.js').waitMcpReadiness;
+  return async ({ isCancelled }) => waitImpl({
+    params: { cacheRoot: mr.cacheRoot, cwd: mr.cwd, expectedServers: mr.expectedServers, notBeforeMs: startedAt },
+    deadlineMs: startedAt + budget,
+    pollMs: mr.pollMs || 500,
+    sleepImpl: seams.sleepImpl,
+    nowImpl: seams.nowImpl,
+    isCancelled,
+  });
+}
+
+const MCP_DELIVERY_STATES = ['ready', 'degraded'];
+const MCP_NAME_RE = /^[A-Za-z0-9_-]{1,64}$/;
+
 function startGenerationPrompt(config, generation, childState, seams = {}) {
   if (!config) return null;
   const classified = config.client === 'kimi' || config.client === 'claude';
   if (!classified && generation === 0) return null;  // legacy: gen0 resta al runtime
+  const mcpWait = buildMcpWait(config, seams);
   const setTimer = seams.setTimeout || setTimeout;
   const clearTimer = seams.clearTimeout || clearTimeout;
   const runTmux = seams.tmuxExec || ((bin, args, opts = {}) => new Promise((resolve) => {
@@ -444,6 +490,19 @@ function startGenerationPrompt(config, generation, childState, seams = {}) {
     try { await runTmux(config.tmuxBin, ['set-option', '-p', '-t', paneTarget, '@nc_delivery', value], {}); }
     catch (_) { /* best-effort: il report timeout di up() resta onesto */ }
   };
+  // Elenco bounded dei server non pronti su @nc_mcp_list (solo nomi
+  // validati e cap 16 per classe; muore col pane come @nc_delivery).
+  const markMcpList = async (mcp) => {
+    if (!classified || !mcp) return;
+    const valida = (arr) => (Array.isArray(arr) ? arr : [])
+      .filter((n) => typeof n === 'string' && MCP_NAME_RE.test(n)).slice(0, 16).sort();
+    const f = valida(mcp.failed);
+    const p = valida(mcp.pending);
+    if (!f.length && !p.length) return;
+    const value = `${f.length ? `failed=${f.join(',')}` : ''}${f.length && p.length ? '|' : ''}${p.length ? `pending=${p.join(',')}` : ''}`;
+    try { await runTmux(config.tmuxBin, ['set-option', '-p', '-t', paneTarget, '@nc_mcp_list', value], {}); }
+    catch (_) { /* best-effort come @nc_delivery */ }
+  };
   let timer = null; let cancelled = false;
   let settledDone = false; let settleResolve = null;
   const settled = new Promise((resolve) => { settleResolve = resolve; });
@@ -470,6 +529,7 @@ function startGenerationPrompt(config, generation, childState, seams = {}) {
             paneTarget: process.env.TMUX_PANE || undefined,
             readyWaitMs: config.readyWaitMs,
             isCancelled,
+            ...(mcpWait ? { mcpWait } : {}),
           });
           const state = result && typeof result.state === 'string' ? result.state : '';
           const uncertain = state === 'delivery-unknown' || state === 'staged-not-submitted';
@@ -480,7 +540,10 @@ function startGenerationPrompt(config, generation, childState, seams = {}) {
           }
           if (state) {
             const kind = state === 'skipped-not-ready' && result.notReady ? `:${result.notReady}` : '';
-            await markDelivery(`${state}${kind}`);
+            const mcpState = result && result.mcp && MCP_DELIVERY_STATES.includes(result.mcp.state)
+              ? `:mcp${result.mcp.state}` : '';
+            await markDelivery(`${state}${kind}${mcpState}`);
+            if (mcpState) await markMcpList(result.mcp);
           }
           // L'esito post-paste incerto va conservato ANCHE se il child
           // era vivo al ritorno di deliver: i byte possono restare nel PTY del