@mmmbuto/nexuscrew 0.9.40 → 0.9.42

package/lib/server.js

@@ -8,7 +8,8 @@ const express = require('express');
 const { WebSocketServer } = require('ws');
 const { defaults, loadConfig, assertLoopback, configJsonPath } = require('./config.js');
 const { writeConfigAtomic } = require('./cli/init.js');
-const { listSessions, attachedClients, setSessionVisibility } = require('./tmux/list.js');
+const { listSessions, listPanes, attachedClients, setSessionVisibility } = require('./tmux/list.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');
 const { createPreviewSampler } = require('./tmux/preview.js');
@@ -20,6 +21,7 @@ const { requireToken, bearerFrom } = require('./auth/middleware.js');
 const { filesRoutes } = require('./files/routes.js');
 const { createOutboxWatcher } = require('./files/watcher.js');
 const { leggiTelemetria } = require('./files/telemetry.js');
+const { leggiAttivita, leggiGenerazione } = require('./files/activity.js');
 const VERSION = require('../package.json').version;
 const { transcribe } = require('./voice/transcribe.js');
 const { selectProvider } = require('./fleet/provider.js');
@@ -975,6 +977,10 @@ function createServer(opts = {}) {
   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 sum = watcher.getSummary();
       const enriched = await Promise.all(sessions.map(async (s) => {
         const sample = await previews.getState(s.name);
@@ -982,6 +988,7 @@ function createServer(opts = {}) {
         // the capture fallback. This prevents a quoted "• Working (...)" line
         // inside another agent's transcript from becoming a false positive.
         const piTitle = /^(?:π|pi)(?:\s+-|$)/iu.test(s.paneTitle);
+        const statoDelSupervisore = statiSupervisore.get(s.name) || 'assente';
         const working = s.working === true || (piTitle && sample?.working === true);
         return {
           ...s,
@@ -993,6 +1000,33 @@ function createServer(opts = {}) {
           // Claude via statusline). Null per tutte le altre — assenza
           // legittima, non un trattino: la riga resta com'era.
           telemetry: leggiTelemetria(cfg.filesRoot, s.name),
+          // Stato del turno pubblicato dagli hook della cella: lavora /
+          // ferma / attesa. `null` NON e' «ferma»: e' «non verificato» —
+          // nessun evento entro la finestra, oppure una cella che non ha questo
+          // canale (codex-vl, pi, shell). La UI non deve dedurre «ferma» da un
+          // silenzio: e' esattamente l'errore che il titolo del pane fa oggi.
+          //
+          // E SI LEGGE SOLO SE IL SUPERVISORE DELLA CELLA ESISTE ANCORA. Con
+          // `remain-on-exit` (runtime.js) la sessione sopravvive al suo
+          // processo: un supervisore ucciso (SIGKILL, OOM) lascia la sessione
+          // «attiva», e lo `Stop` con `exit:1` scritto prima resterebbe «ferma»
+          // per sempre — mentre non c'e' nessun client a cui quello stato si
+          // riferisca. La verita' e' il pane che esegue cell-exec, marcato al
+          // lancio: `#{pane_dead}` della sessione riguarda il pane ATTIVO, e con
+          // una seconda finestra viva selezionata direbbe «vivo» a supervisore
+          // morto (misurato). La decisione completa sta in
+          // `lib/tmux/supervisor-pane.js`: qui si passa lo stato del pane e — per
+          // il solo caso «nessun marcatore» — il segno `exit:1` del file, che
+          // distingue un lancio nuovo con marcatura fallita (non si legge: il
+          // suo `Stop` non scadrebbe) da un lancio VECCHIO (si legge, e il
+          // lettore fa scadere tutto a 5 minuti). E' quello che evita di
+          // mostrare «non verificato» su ogni cella viva di ogni nodo appena
+          // aggiornato.
+          attivita: statoDelSupervisore === 'vivo'
+            ? leggiAttivita(cfg.filesRoot, s.name)
+            : (senzaSupervisore(statoDelSupervisore, leggiGenerazione(path.join(cfg.filesRoot, s.name)).uscitaGarantita)
+              ? null
+              : leggiAttivita(cfg.filesRoot, s.name)),
         };
       }));
       res.json({ sessions: enriched });
@@ -1272,6 +1306,12 @@ function createServer(opts = {}) {
       });
     } catch (e) { res.status(500).json({ error: String(e.message || e) }); }
   });
+  // Riconciliazione dopo refresh: gli esiti incerti noti al relay (solo
+  // contatori/ID, mai testo) per ricostruire lo stato «verifica» senza reinvii.
+  api.get('/asks-relay/state', (_req, res) => {
+    try { res.json({ attempts: askRelay.state() }); }
+    catch (e) { res.status(500).json({ error: String(e.message || e) }); }
+  });
   // The client re-emits imported events into the local hub (deliverOnly: the
   // notifier is bypassed on purpose). The alert relay hangs off that same call,
   // so ONLY an imported notify can ring this device, and never through the

package/lib/settings/routes.js

@@ -68,9 +68,10 @@ const { scrubError } = require('../update/core.js');
 // il transaction handler di /nodes/pair e la superficie pubblica di peering.
 const { createPairHandler } = require('./pairing-coordinator.js');
 const { publicPeeringRoutes } = require('./public-peering-routes.js');
+const aiDesktop = require('../fleet/ai-desktop.js');
 
 // Whitelist chiavi scrivibili di config.json via API (lista chiusa dal task).
-const CONFIG_KEYS = new Set(['roles', 'port', 'wizardDone', 'autoUpdate', 'alternateScreen']);
+const CONFIG_KEYS = new Set(['roles', 'port', 'wizardDone', 'autoUpdate', 'alternateScreen', 'aiDesktop']);
 const ROLE_KEYS = new Set(['client', 'node']);
 const ADD_KEYS = new Set(['name', 'ssh', 'sshPort', 'remotePort', 'localPort', 'keyPath', 'label']);
 const EDIT_KEYS = new Set([
@@ -279,10 +280,10 @@ function settingsRoutes(deps = {}) {
         return send(res, 400, { error: 'body deve essere un oggetto JSON' });
       }
       for (const k of Object.keys(b)) {
-        if (!CONFIG_KEYS.has(k)) return send(res, 400, { error: `chiave non ammessa: "${k}" (whitelist: roles, port, wizardDone, autoUpdate, alternateScreen)` });
+        if (!CONFIG_KEYS.has(k)) return send(res, 400, { error: `chiave non ammessa: "${k}" (whitelist: roles, port, wizardDone, autoUpdate, alternateScreen, aiDesktop)` });
       }
       if (Object.keys(b).length === 0) {
-        return send(res, 400, { error: 'nessuna chiave da scrivere (whitelist: roles, port, wizardDone, autoUpdate, alternateScreen)' });
+        return send(res, 400, { error: 'nessuna chiave da scrivere (whitelist: roles, port, wizardDone, autoUpdate, alternateScreen, aiDesktop)' });
       }
       if (b.roles !== undefined) {
         if (!b.roles || typeof b.roles !== 'object' || Array.isArray(b.roles)) {
@@ -315,6 +316,9 @@ function settingsRoutes(deps = {}) {
       if (b.alternateScreen !== undefined && typeof b.alternateScreen !== 'boolean') {
         return send(res, 400, { error: 'alternateScreen deve essere boolean' });
       }
+      if (b.aiDesktop !== undefined && typeof b.aiDesktop !== 'boolean') {
+        return send(res, 400, { error: 'aiDesktop deve essere boolean' });
+      }
 
       // merge sul config esistente (preserva le chiavi non gestite qui)
       const { cfg: current } = readConfigFile(configPath);
@@ -327,6 +331,7 @@ function settingsRoutes(deps = {}) {
       if (b.wizardDone !== undefined) next.wizardDone = b.wizardDone;
       if (b.autoUpdate !== undefined) next.autoUpdate = b.autoUpdate;
       if (b.alternateScreen !== undefined) next.alternateScreen = b.alternateScreen;
+      if (b.aiDesktop !== undefined) next.aiDesktop = b.aiDesktop;
       atomicWriteConfig(configPath, next);
       if (b.autoUpdate !== undefined && updater && typeof updater.setEnabled === 'function') {
         updater.setEnabled(b.autoUpdate);
@@ -353,6 +358,53 @@ function settingsRoutes(deps = {}) {
     } catch (e) { send(res, 500, { error: String(e.message || e) }); }
   });
 
+  // --- AIDesktop: la spunta che governa il container e il tasto --------------
+  // GET: la chiave esplicita comanda; se l'utente non l'ha mai toccata, il
+  // default si deriva dal container (in esecuzione → true). docker viene
+  // interrogato SOLO qui, su chiamata esplicita — mai nel percorso caldo del
+  // fleetStatus. Il binario passa dal seam per i test (finto binario).
+  r.get('/ai-desktop', async (req, res) => {
+    const { cfg: cfgNow } = readConfigFile(configPath);
+    const esplicita = aiDesktop.chiaveEsplicita(cfgNow);
+    const stato = await aiDesktop.containerRunning({ dockerBin: seams.aiDesktopDockerBin });
+    const desired = esplicita !== null ? esplicita : stato.running;
+    return send(res, 200, {
+      desired, running: stato.running, exists: stato.exists, explicit: esplicita !== null,
+      ...(stato.error ? { error: stato.error } : {}),
+    });
+  });
+
+  // POST {enabled}: salva la chiave ED esegue start o stop, restituendo
+  // l'esito VERO del comando — nessun successo ottimistico. Se docker
+  // risponde male la risposta è 500 con la causa: la chiave resta salvata
+  // (la spunta dice COSA si vuole, l'esito dice SE il mondo ci è arrivato)
+  // e il badge della UI mostra il disallineamento invece di fingere.
+  r.post('/ai-desktop', mutGate, async (req, res) => {
+    const b = req.body;
+    if (!b || typeof b !== 'object' || Array.isArray(b) || typeof b.enabled !== 'boolean') {
+      return send(res, 400, { error: 'body deve essere {enabled: boolean}' });
+    }
+    const { cfg: cfgNow } = readConfigFile(configPath);
+    try {
+      atomicWriteConfig(configPath, { ...cfgNow, aiDesktop: b.enabled });
+    } catch (e) {
+      return send(res, 500, { error: `config non salvata: ${e.message}` });
+    }
+    const dockerOpts = { dockerBin: seams.aiDesktopDockerBin };
+    const esito = b.enabled
+      ? await aiDesktop.avvia(dockerOpts)
+      : await aiDesktop.ferma(dockerOpts);
+    if (!esito.ok) {
+      return send(res, 500, {
+        error: esito.error || 'comando docker fallito',
+        desired: b.enabled,
+        running: esito.running ?? null,
+        timeout: !!esito.timeout,
+      });
+    }
+    return send(res, 200, { ok: true, desired: b.enabled, running: esito.running });
+  });
+
   // Auto-update npm: check e apply sono autenticati, READONLY-gated e non
   // accettano mai package/versione dal browser. Il manager usa esclusivamente
   // @mmmbuto/nexuscrew@latest, confronta semver e installa la versione esatta.

package/lib/tmux/list.js

@@ -1,5 +1,6 @@
 'use strict';
 const { execFile, execFileSync } = require('node:child_process');
+const { PANES_FMT } = require('./supervisor-pane.js');
 
 const FMT = "#{session_name}\t#{session_attached}\t#{session_windows}\t#{session_created}\t#{session_activity}\t#{pane_current_command}\t#{@nexuscrew_visibility}\t#{pane_title}";
 
@@ -78,6 +79,23 @@ function setSessionVisibility(tmuxBin = 'tmux', name, technical = false) {
   });
 }
 
+// I pani di TUTTE le sessioni, in UNA chiamata: da qui si ricava quale pane e'
+// il supervisore di ogni cella e se e' vivo (lib/tmux/supervisor-pane.js).
+// `#{pane_dead}` qui e' quello giusto: il pane del SUPERVISORE, non il pane
+// attivo della sessione — che con una seconda finestra viva direbbe «vivo»
+// anche con il supervisore morto.
+function listPanes(tmuxBin = 'tmux') {
+  return new Promise((resolve, reject) => {
+    execFile(tmuxBin, ['list-panes', '-a', '-F', 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);
+    });
+  });
+}
+
 function listSessions(tmuxBin = 'tmux') {
   return new Promise((resolve, reject) => {
     execFile(tmuxBin, ['list-sessions', '-F', FMT], (err, stdout, stderr) => {
@@ -104,5 +122,5 @@ function attachedClients(tmuxBin = 'tmux', session) {
 }
 
 module.exports = {
-  parsePaneTitle, parseSessions, isNoTmuxServerError, listSessions, attachedClients, setSessionVisibility, FMT,
+  parsePaneTitle, parseSessions, isNoTmuxServerError, listSessions, listPanes, attachedClients, setSessionVisibility, FMT,
 };

package/lib/tmux/supervisor-pane.js

@@ -0,0 +1,81 @@
+'use strict';
+// Chi e' il pane del SUPERVISORE di una cella, e se e' ancora vivo.
+//
+// PERCHE' NON BASTA `#{pane_dead}` DI list-sessions (misurato con tmux vero):
+// quel campo riguarda il pane ATTIVO della sessione. Con una seconda finestra
+// viva selezionata dice «vivo» anche quando il pane del supervisore e' morto, e
+// allora lo `Stop` con `exit:1` scritto prima resta «ferma» per sempre — mentre
+// la garanzia di quel segno e' che il supervisore DICHIARA l'uscita, e un
+// supervisore ucciso non l'ha dichiarata.
+//
+// La verita' e' il pane che esegue `cell-exec`: la runtime lo marca al lancio
+// con un'opzione di pane (`@nc_supervisor`), e il server lo cerca qui.
+//
+// UNA SOLA CHIAMATA PER GIRO: `list-panes -a -F <PANES_FMT>`, poi tutto si
+// calcola in memoria. Nessuna chiamata tmux per singola sessione.
+const NC_SUPERVISOR_OPT = '@nc_supervisor';
+const PANES_FMT = `#{session_name}\t#{pane_id}\t#{pane_dead}\t#{${NC_SUPERVISOR_OPT}}`;
+
+function parsePanes(raw) {
+  return String(raw)
+    .split('\n')
+    .filter((line) => line.trim() !== '')
+    .map((line) => {
+      const campi = line.split('\t');
+      return {
+        session: campi[0] || '',
+        paneId: campi[1] || '',
+        dead: campi[2] === '1',
+        marked: campi[3] === '1',
+      };
+    });
+}
+
+/**
+ * Lo stato del supervisore di ogni sessione, dalle sole righe di list-panes:
+ *   'vivo'    — il pane marcato c'e' ed e' vivo;
+ *   'morto'   — il pane marcato c'e' ed e' morto (SIGKILL/OOM del supervisore,
+ *               e la sessione e' sopravvissuta per `remain-on-exit`);
+ *   'assente' — nessun pane marcato: la cella e' stata lanciata PRIMA che il
+ *               marcatore esistesse, oppure la marcatura non e' riuscita.
+ */
+function statiSupervisore(raw) {
+  const perSessione = new Map();
+  for (const pane of parsePanes(raw)) {
+    if (!pane.session) continue;
+    const stato = perSessione.get(pane.session) || { marcato: null };
+    // Un solo pane marcato per lancio: se ne comparissero due, l'ultimo vince.
+    if (pane.marked) stato.marcato = pane;
+    perSessione.set(pane.session, stato);
+  }
+  const out = new Map();
+  for (const [nome, stato] of perSessione) {
+    if (!stato.marcato) out.set(nome, 'assente');
+    else out.set(nome, stato.marcato.dead ? 'morto' : 'vivo');
+  }
+  return out;
+}
+
+/**
+ * La decisione: di questa cella non si puo' leggere lo stato?
+ *
+ * 'morto' → si': il supervisore non c'e' piu' e nessuno dichiarera' l'uscita.
+ *
+ * 'assente' → dipende dal FILE DI GENERAZIONE, e la differenza e' la ragione
+ * della regola: un lancio NUOVO in cui la marcatura del pane e' fallita ha il
+ * segno `exit:1`, quindi il suo `Stop` non scadrebbe mai e nessuno garantisce
+ * il supervisore → non si legge. Un lancio VECCHIO (file di una riga, senza
+ * segno) non ha nessuna non-scadenza da proteggere: vale il lettore, che fa
+ * scadere `Stop` e gli eventi di lavoro a cinque minuti. Il caso peggiore e'
+ * limitato a quei cinque minuti, invece di diventare «non verificato» per ogni
+ * cella viva su ogni nodo appena aggiornato.
+ *
+ * 'vivo' → no.
+ */
+function senzaSupervisore(stato, uscitaGarantita) {
+  if (stato === 'morto') return true;
+  if (stato === 'assente') return uscitaGarantita === true;
+  return false;
+}
+
+module.exports = { NC_SUPERVISOR_OPT, PANES_FMT, parsePanes, statiSupervisore, senzaSupervisore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/nexuscrew",
-  "version": "0.9.40",
+  "version": "0.9.42",
   "description": "Faithful browser tmux client — attach to live sessions over a real PTY, localhost-only, mobile-easy",
   "main": "lib/server.js",
   "bin": {
@@ -45,15 +45,16 @@
     "express": "^4.21.0",
     "multer": "^2.2.0",
     "qrcode-terminal": "^0.12.0",
+    "smol-toml": "1.9.0",
     "web-push": "^3.6.7",
     "ws": "^8.18.0"
   },
   "optionalDependencies": {
-    "@mmmbuto/node-pty-android-arm64": "^1.1.2",
     "@lydell/node-pty-darwin-arm64": "^1.2.0-beta.14",
     "@lydell/node-pty-darwin-x64": "^1.2.0-beta.14",
     "@lydell/node-pty-linux-arm64": "^1.2.0-beta.12",
-    "@lydell/node-pty-linux-x64": "^1.2.0-beta.12"
+    "@lydell/node-pty-linux-x64": "^1.2.0-beta.12",
+    "@mmmbuto/node-pty-android-arm64": "^1.1.2"
   },
   "engines": {
     "node": ">=18"