npm - @mmmbuto/nexuscrew - Versions diffs - 0.9.2 → 0.9.4 - Mend

@mmmbuto/nexuscrew 0.9.2 → 0.9.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/CHANGELOG.md +157 -0
package/frontend/dist/assets/index-CbMytNmg.css +32 -0
package/frontend/dist/assets/index-DFI1J-u5.js +93 -0
package/frontend/dist/index.html +2 -2
package/frontend/dist/version.json +1 -1
package/lib/cli/commands.js +11 -3
package/lib/cli/init.js +18 -3
package/lib/cli/pidfile.js +27 -1
package/lib/cli/runtime-lifecycle.js +31 -1
package/lib/files/telemetry.js +89 -0
package/lib/fleet/builtin.js +218 -64
package/lib/fleet/definitions.js +226 -0
package/lib/live-host/bridge.js +82 -22
package/lib/nodes/peer-transitions.js +81 -0
package/lib/proxy/panel-proxy.js +30 -3
package/lib/server.js +15 -0
package/lib/update/runner.js +32 -31
package/package.json +1 -1
package/skills/live/SKILL.md +8 -0
package/frontend/dist/assets/index-0vuhL1YP.css +0 -32
package/frontend/dist/assets/index-uRh_hSop.js +0 -93

package/frontend/dist/index.html CHANGED Viewed

@@ -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-uRh_hSop.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-0vuhL1YP.css">
+  <script type="module" crossorigin src="/assets/index-DFI1J-u5.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-CbMytNmg.css">
 </head>
 <body>
   <div id="root"></div>

package/frontend/dist/version.json CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":"0.9.2"}
1	+ {"version":"0.9.4"}

package/lib/cli/commands.js CHANGED Viewed

@@ -23,7 +23,7 @@ const peering = require('../nodes/peering.js');
 // Service/portable runtime ownership + start/stop lifecycle (Phase 3 extraction).
 const runtimeLifecycle = require('./runtime-lifecycle.js');
 const {
-  start, stop, isServiceRunning, bootState, stopManagedTunnels,
+  start, stop, isServiceRunning, bootState, stopManagedTunnels, fermaTunnelPrimaDiRiavviare,
   managedRuntimeState, portableRuntimeState, resolveRuntimeOwner,
   refusePairedPortRelocation, stopPortableRuntime, unlinkRegular,
 } = runtimeLifecycle;
@@ -350,12 +350,18 @@ function restart(opts = {}) {
       if (!portable.killed) return { platform, owner: before.owner, restarted: false, reason: portable.reason };
     }
     try {
+      // I tunnel si fermano PRIMA, dal punto unico condiviso con ogni altro
+      // percorso di riavvio. Qui la policy è fail-closed: se il passo non
+      // riesce, il riavvio gestito non parte — un tunnel vivo sopra un
+      // servizio riavviato è il guasto misurato sul campo (2026-08-07).
+      const tunnels = fermaTunnelPrimaDiRiavviare(opts);
+      if (tunnels.error) {
+        return { platform, owner: before.owner, runtimeOwner: 'managed', restarted: false, reason: `stop tunnel: ${tunnels.error}` };
+      }
       if (platform === 'linux') {
-        (opts.stopTunnelsImpl || stopManagedTunnels)(opts);
         execImpl('systemctl', ['--user', 'restart', 'nexuscrew'], { stdio: 'ignore' });
         log('restart: systemctl --user restart nexuscrew');
       } else {
-        (opts.stopTunnelsImpl || stopManagedTunnels)(opts);
         const label = `gui/${opts.uid || uid()}/com.mmmbuto.nexuscrew`;
         execImpl('launchctl', ['kickstart', '-k', label], { stdio: 'ignore' });
         log(`restart: launchctl kickstart -k ${label}`);
@@ -1505,6 +1511,8 @@ module.exports = {
   isServiceRunning, readRoles,
   bootState, bootOn, bootOff, quickSummary,
   stopManagedTunnels,
+  fermaTunnelPrimaDiRiavviare,
+  stopPortableRuntime,
   managedRuntimeState, portableRuntimeState, resolveRuntimeOwner,
   runFleetBoot, dispatchFleetBoot,
 };

package/lib/cli/init.js CHANGED Viewed

@@ -17,7 +17,7 @@ const {
   generateFleetService, installFleetService, migrationGate,
   selectProviderModeSync, fleetFileMode,
 } = require('./fleet-service.js');
-const { atomicWrite: writeFleet } = require('../fleet/definitions.js');
+const { aggiornaDefinizioni } = require('../fleet/definitions.js');
 const { defaultDefinitions } = require('../fleet/managed.js');
 const { commandExists, resolveCommand } = require('./path.js');
@@ -83,8 +83,23 @@ function ensureFleetDefaults(opts = {}) {
     if (e.code !== 'ENOENT') throw e;
   }
-  writeFleet(fleetDefsPath, defaultDefinitions());
-  return { path: fleetDefsPath, created: true, enabled: true };
+  // Fra il controllo qui sopra e la scrittura c'e' una finestra: se un altro
+  // processo crea le definizioni nel frattempo, scrivere i default sopra le sue
+  // significa cancellare una configurazione intera — non perdere una modifica.
+  // La creazione avviene quindi sotto lock, con l'esistenza RIVERIFICATA
+  // dentro: `seMancante` viene chiamata solo se il file davvero non c'e'.
+  // `propaga` perche' `created` dica il vero: senza, una rinuncia del lock
+  // restituiva lo stato riletto — truthy — e l'init dichiarava `created: true`
+  // per un file che non aveva creato.
+  let creato = null;
+  try {
+    creato = aggiornaDefinizioni(fleetDefsPath, () => null, {
+      seMancante: () => defaultDefinitions(),
+      propaga: true,
+      log: opts.log,
+    });
+  } catch (_) { creato = null; }
+  return { path: fleetDefsPath, created: Boolean(creato), enabled: true };
 }
 // Migration rule (B2): se non c'è config.json, parse la porta dal service file esistente.

package/lib/cli/pidfile.js CHANGED Viewed

@@ -112,12 +112,26 @@ function cmdMatches(savedCmd, liveCmd) {
   return liveCmd.includes(savedCmd) || savedCmd.includes(liveCmd);
 }
-// true se il pid appartiene a questo UID E il cmd matcha (o non verificabile).
+// true se il pid appartiene a questo UID, la NASCITA è ancora quella attestata
+// dal pidfile e il cmd matcha (o non è verificabile).
 // EPERM is deliberately false: NexusCrew must neither adopt nor signal a
 // process owned by another Android/Linux user.
+// La nascita (processStart, già scritta da writePidfile) decide PRIMA del cmd:
+// cmdMatches è per inclusioni, quindi un comando più lungo del salvato matcha
+// — due supervisor dello stesso tunnel, due serve, il restart di ieri. Se il
+// numero è nato in un istante diverso da quello attestato, il proprietario è
+// morto e il numero è di un altro: il pidfile è stale anche se il cmd «quadra».
+// Non calcolabile (meta senza processStart: pidfile vecchio o /proc nascosto;
+// lettura che ora non riesce: macOS senza ps) → nel dubbio vale il cmd, come
+// sempre: mai dichiarare morto un vivo. Stessa identità e stessa asimmetria
+// del lock delle definizioni (pid + nascita; il falso-morto non esiste).
 function isAlive(meta, impl = {}) {
   if (!meta || !Number.isFinite(meta.pid)) return false;
   if (pidOwnership(meta.pid, impl.killImpl || process.kill) !== 'owned') return false;
+  if (meta.processStart) {
+    const liveStart = (impl.readProcessStartImpl || readProcessStart)(meta.pid);
+    if (liveStart && liveStart !== meta.processStart) return false; // riassegnato
+  }
   if (meta.cmd) {
     const live = (impl.readCmdlineImpl || readCmdline)(meta.pid);
     if (live) return cmdMatches(meta.cmd, live);
@@ -171,6 +185,18 @@ function killPidfile(p, signal = 'SIGTERM', impl = {}) {
       return { killed: false, reason: 'pid reuse (cmd mismatch)', liveCmd: live };
     }
   }
+  // PID reuse che il cmd NON vede: due processi con lo stesso comando (o un
+  // comando che lo contiene). La nascita li distingue: se il numero è nato in
+  // un istante diverso da quello attestato, il segnale andrebbe al processo
+  // SBAGLIATO — vivo, nostro, magari legittimo. Non si segnala; il pidfile è
+  // stale e si toglie (allowLive: garanzia verificata QUI, come dopo il kill).
+  if (meta.processStart) {
+    const liveStart = (impl.readProcessStartImpl || readProcessStart)(meta.pid);
+    if (liveStart && liveStart !== meta.processStart) {
+      removePidfile(p, { allowLive: true });
+      return { killed: false, reason: 'pid reuse (start mismatch)' };
+    }
+  }
   try {
     killImpl(meta.pid, signal);
     // allowLive: il segnale e' partito verso il pid VERIFICATO del file (cmd

package/lib/cli/runtime-lifecycle.js CHANGED Viewed

@@ -103,6 +103,31 @@ function stopManagedTunnels(opts = {}) {
   return stopped;
 }
+// IL PASSO «I TUNNEL SI FERMANO PRIMA», una volta sola. Ogni percorso di
+// riavvio — commands.restart (sincrona, mano), stop() e il ramo portatile
+// dell'aggiornamento automatico — attraversa QUESTO ingresso: è il posto
+// unico dove un domani si aggiunge un passo al riavvio, invece di scriverlo
+// in una copia e dimenticarlo nell'altra (la divergenza trovata tre volte,
+// una per guasto).
+//
+// Non lancia MAI: il passo è intrinsecamente best-effort (un tunnel che non
+// si ferma non deve lasciare il riavvio a metà in modo diverso a seconda del
+// chiamante) — ma non tace: l'esito torna a chi chiama, e la POLICY (abort
+// fail-closed per il riavvio gestito, proseguire per l'aggiornamento il cui
+// compito principale è aggiornare) resta a chi la possiede.
+function fermaTunnelPrimaDiRiavviare(opts = {}) {
+  const log = opts.log || (() => {});
+  try {
+    const stopped = (opts.stopTunnelsImpl || stopManagedTunnels)(opts);
+    return { stopped, error: null };
+  } catch (e) {
+    const reason = String(e && e.message ? e.message : e);
+    // Tacerlo lo renderebbe irrintracciabile la prossima volta.
+    log(`stop tunnel non riuscito — ${reason}`);
+    return { stopped: [], error: reason };
+  }
+}
 function refusePairedPortRelocation(opts, from, to) {
   if (Number(from) === Number(to)) return;
   const { configDir } = urlmod.resolvePaths(opts);
@@ -240,7 +265,11 @@ function stop(opts = {}) {
   // Detached tunnel supervisors are outside both server owners. A real stop
   // closes them once; the next start restores only autostart:true links.
-  (opts.stopTunnelsImpl || stopManagedTunnels)(opts);
+  // Attraverso lo STESSO ingresso del riavvio (fermaTunnelPrimaDiRiavviare):
+  // prima un fallimento qui sfuggiva come eccezione non gestita al chiamante
+  // sincrono; ora è esito del stop, come ogni altro errore qui sopra.
+  const tunnels = fermaTunnelPrimaDiRiavviare(opts);
+  if (tunnels.error) errors.push(`stop tunnel: ${tunnels.error}`);
   if (platform === 'termux') {
     try { execImpl('termux-wake-lock-release', [], { stdio: 'ignore' }); } catch (_) {}
   }
@@ -286,6 +315,7 @@ function unlinkRegular(target) {
 module.exports = {
   start,
   stopManagedTunnels,
+  fermaTunnelPrimaDiRiavviare,
   refusePairedPortRelocation,
   managedRuntimeState,
   portableRuntimeState,

package/lib/files/telemetry.js ADDED Viewed

@@ -0,0 +1,89 @@
+'use strict';
+// Telemetria per-cella: contesto LIBERO e tier 5h/7d USATI, letti dal file che
+// la statusline di Claude Code scrive in <root>/<sessione>/telemetry.json
+// (snippet documentato in docs/STATUSLINE_TELEMETRY.md, NON applicato: la
+// statusline e' dell'operatore). Il verso dei due dati e' OPPOSTO e i nomi del file lo
+// portano scritto dentro: `contextFreePct` e' quanto RESTA, `tier*UsedPct` e'
+// quanto e' STATO CONSUMATO. Confondere i versi produce una riga che dice il
+// contrario del vero e fa prendere la decisione opposta a quella giusta.
+//
+// Tre regole non opinabili, tutte implementate qui:
+//   1. TIMESTAMP OBBLIGATORIO: oltre MASSIMA_ETA_MS il dato e' morto e viene
+//      restituito null — un numero stantio che sembra fresco e' peggio di un
+//      numero assente.
+//   2. ASSENZA LEGITTIMA: le celle non-Claude (codex-vl, agy, grok, shell) non
+//      hanno quella statusline e non avranno mai questo file. File assente =
+//      null, e la riga della lista resta com'era: niente campo, niente
+//      trattino, niente «n/d».
+//   3. LETTURA TOLLERANTE: file illeggibile, JSON rotto, campi mancanti o
+//      fuori contratto — si degrada a null senza mai far fallire la lista.
+//
+// CONTRATTO del file: valori INTERI 0..100 (gia' percentuali — la
+// normalizzazione frazione→percentuale e' compito di chi scrive, vedi lo
+// snippet). Il lettore accetta SOLO interi: una frazione scritta per errore
+// (0.5 che voleva essere 50%) viene rifiutata, non arrotondata a 1% — un
+// numero sbagliato mostrato con sicurezza e' il difetto che conta, meglio
+// nessun numero.
+const fs = require('node:fs');
+const path = require('node:path');
+// La statusline aggiorna a ogni evento del modello: in una cella viva il file
+// e' sempre piu' fresco di cosi'. Cinque minuti coprono una pausa pranzo senza
+// mostrare come attuale il dato di ieri.
+const MASSIMA_ETA_MS = 5 * 60 * 1000;
+// La soglia guarda in ENTRAMBI i versi. Un ts nel futuro farebbe `ora - ts`
+// negativo: la differenza non supera MAI la massima eta' e il dato resterebbe
+// «fresco» per sempre — un orologio avanti, o uno ts scritto male, e la riga
+// mostra un numero morto che non scadra' mai. Due minuti di skew sono il
+// margine che un orologio legittimamente sforato puo' avere; oltre, il ts e'
+// rotto e il dato non esiste.
+const FUTURO_TOLLERATO_MS = 2 * 60 * 1000;
+const NOME_FILE = 'telemetry.json';
+// Accetta SOLO interi 0..100 gia' numeri. Tutto il resto e' fuori contratto
+// e non viene mostrato — in particolare null e i booleani: `Number(null)` e'
+// 0 e `Number(true)` e' 1, e un campo assente letto come «0% usato» e'
+// esattamente il numero sbagliato-mostrato-con-sicurezza che questo modulo
+// esiste per evitare.
+function percentualeIntera(valore) {
+  if (typeof valore !== 'number' || !Number.isInteger(valore)) return null;
+  if (valore < 0 || valore > 100) return null;
+  return valore;
+}
+/**
+ * Legge la telemetria di una sessione. Ritorna `{ ts, contextFreePct?,
+ * tier5hUsedPct?, tier7dUsedPct? }` con solo i campi validi, oppure null per
+ * assenza legittima, dato stantio o qualsiasi rotture. Non lancia MAI.
+ */
+function leggiTelemetria(root, sessione, ora = Date.now()) {
+  try {
+    let raw;
+    try {
+      raw = fs.readFileSync(path.join(root, String(sessione), NOME_FILE), 'utf8');
+    } catch (_) {
+      return null; // assente (o non leggibile): cella non-Claude o primo avvio
+    }
+    const dato = JSON.parse(raw);
+    if (!dato || typeof dato !== 'object' || Array.isArray(dato)) return null;
+    const ts = Number(dato.ts);
+    // Senza timestamp non c'e' freschezza da verificare: il dato non esiste.
+    if (!Number.isFinite(ts)) return null;
+    if (ora - ts > MASSIMA_ETA_MS) return null; // stantio = assente
+    if (ts - ora > FUTURO_TOLLERATO_MS) return null; // ts rotto: «fresco per sempre» non e' fresco
+    const campi = {};
+    const libero = percentualeIntera(dato.contextFreePct);
+    const t5 = percentualeIntera(dato.tier5hUsedPct);
+    const t7 = percentualeIntera(dato.tier7dUsedPct);
+    if (libero !== null) campi.contextFreePct = libero;
+    if (t5 !== null) campi.tier5hUsedPct = t5;
+    if (t7 !== null) campi.tier7dUsedPct = t7;
+    return Object.keys(campi).length ? { ts, ...campi } : null;
+  } catch (_) {
+    return null; // JSON rotto o altro: la lista non fallisce per questo
+  }
+}
+module.exports = { leggiTelemetria, MASSIMA_ETA_MS, FUTURO_TOLLERATO_MS, NOME_FILE };