@mmmbuto/nexuscrew 0.9.6 → 0.9.8

package/lib/update/runner.js

@@ -10,6 +10,219 @@ const {
   stableRuntimeDir,
 } = require('./core.js');
 
+// R28 — rigenerazione delle definizioni di boot dopo l'installazione.
+//
+// L'aggiornamento del pacchetto sposta i path versionati che le unit/plist
+// scrivono LETTERALMENTE (node del Cellar su Homebrew, pacchetto in
+// lib/node_modules): senza questo passo il servizio riparte sulle definizioni
+// vecchie e la companion di boot — che nessun altro percorso sana, se non
+// `nexuscrew init` — resta puntata a un binario che non esiste più, con exit
+// 78 EX_CONFIG e le celle boot:true mute (misurato sul campo 2026-08-18).
+//
+// Il criterio R23 resta intatto («alias stabile che realpath allo stesso
+// file», verificato alla SCRITTURA, mai a ogni avvio) con una estensione
+// dichiarata per il caso del runner: il processo dell'update può girare con
+// un node già unlinkato su disco, e in quel caso si sceglie il primo percorso
+// stabile VIVO (resolveLiveBootPaths).
+//
+// Contratto: sana SOLO le definizioni che ESISTONO già (il boot è opt-in:
+// l'update non installa un companion mai chiesto); attivazione differita
+// (activate:false) perché il companion RunAtLoad/oneshot non va eseguito a
+// metà update — R28-rimedio: l'attivazione la APPLICA healBootDefinitions
+// nel percorso di update (daemon-reload / bootout+bootstrap), non un restart
+// che non carica le definizioni; un fallimento NON blocca l'aggiornamento
+// (il comportamento senza questo passo era proprio quello) ma viene LOGGATO
+// e riportato: il silenzio era il difetto, non il fallimento.
+function regenBootDefinitions(opts = {}) {
+  const readFileImpl = opts.readFileImpl || fs.readFileSync;
+  const serviceMod = opts.serviceMod || require('../cli/service.js');
+  const fleetMod = opts.fleetMod || require('../cli/fleet-service.js');
+  const aliasMod = opts.aliasMod || require('../cli/stable-alias.js');
+  const platformMod = opts.platformMod || require('../cli/platform.js');
+  const home = opts.home || os.homedir();
+  const platform = opts.platform || platformMod.detectPlatform();
+  const log = opts.log || console.log;
+  const out = { regenerated: [], skipped: [], warnings: [], errors: [] };
+
+  const revive = aliasMod.resolveLiveBootPaths({
+    nodeBin: platformMod.nodeBin(),
+    entryPath: path.resolve(__dirname, '..', '..', 'bin', 'nexuscrew.js'),
+    ...(opts.realpath ? { realpath: opts.realpath } : {}),
+    ...(opts.exists ? { exists: opts.exists } : {}),
+  });
+  out.warnings.push(...revive.warnings);
+
+  const targets = [
+    {
+      component: 'service',
+      path: () => serviceMod.installPath(platform, home),
+      isOurs: (content) => serviceMod.isOurService(platform, content),
+      exists: () => {
+        try { return fs.lstatSync(serviceMod.installPath(platform, home)).isFile(); } catch (_) { return false; }
+      },
+      install: () => {
+        const content = serviceMod.generateService(platform, {
+          repoRoot: platformMod.repoRoot(),
+          nodeBin: revive.nodeBin,
+          entryPath: revive.entryPath,
+          port: opts.port,
+          home,
+          uid: platformMod.uid(),
+        });
+        return serviceMod.installService(platform, content, {
+          repoRoot: platformMod.repoRoot(),
+          nodeBin: revive.nodeBin,
+          entryPath: revive.entryPath,
+          port: opts.port,
+          home,
+          uid: platformMod.uid(),
+        }, { activate: false });
+      },
+    },
+    {
+      component: 'fleet-companion',
+      path: () => fleetMod.fleetInstallPath(platform, home),
+      isOurs: (content) => fleetMod.isOurFleetService(platform, content),
+      exists: () => {
+        try { return fs.lstatSync(fleetMod.fleetInstallPath(platform, home)).isFile(); } catch (_) { return false; }
+      },
+      install: () => fleetMod.installFleetService(platform, fleetMod.generateFleetService({
+        platform,
+        nodeBin: revive.nodeBin,
+        entryPath: revive.entryPath,
+        repoRoot: platformMod.repoRoot(),
+        home,
+      }), { home, uid: platformMod.uid() }, { activate: false }),
+    },
+  ];
+
+  for (const target of targets) {
+    let present;
+    try { present = target.exists(); } catch (e) { present = false; }
+    if (!present) {
+      out.skipped.push(`${target.component}: nessuna definizione installata, nulla da sanare`);
+      continue;
+    }
+    // R28-rimedio, difetto 3 (audit): symlink e directory al posto del target
+    // erano già saltati, ma un FILE REGOLARE DI TERZI veniva sovrascritto. Le
+    // definizioni che generiamo portano tutte il nome del progetto nell'header
+    // (systemd: «# NexusCrew service», plist: Label com.mmmbuto.nexuscrew):
+    // se il contenuto non lo contiene, il file non è nostro e non lo tocchiamo
+    // — lo skip è dichiarato, non silenzioso. Un file illeggibile non blocca
+    // la sanazione (si presume nostro: il caso terzi è il contenuto leggibile
+    // che dichiara altro).
+    // R28 (audit rev2): la proprieta' si riconosce da un'ancora STRUTTURALE del
+    // nostro generatore (isOurService/isOurFleetService), non dalla parola
+    // «nexuscrew» presente nel file: un unit di terzi che ci nomina in un
+    // commento veniva sovrascritto. E cio' che NON si riesce a leggere non si
+    // presume nostro: si salta e si dichiara — l'unica direzione sicura, perche'
+    // l'errore costa una sanazione mancata invece del file di qualcun altro.
+    let content = null;
+    let why = null;
+    try { content = readFileImpl(target.path(), 'utf8'); }
+    catch (e) {
+      why = `${target.component}: definizione esistente non leggibile (${target.path()}, ${(e && e.code) || 'errore'}) — non identificabile, non la tocco; rilancia nexuscrew init`;
+    }
+    if (!why && !target.isOurs(content)) {
+      why = `${target.component}: file esistente non nostro al target (${target.path()}) — nessuna ancora delle nostre definizioni, possibile file di terzi, non lo tocco`;
+    }
+    if (why) {
+      out.skipped.push(why);
+      log(`WARN boot definitions: ${why}`);
+      continue;
+    }
+    try {
+      const result = target.install();
+      out.regenerated.push(target.component);
+      out.warnings.push(...(Array.isArray(result.skippedActivation)
+        ? result.skippedActivation.map((cmd) => `${target.component}: attivazione differita (${cmd}) — il passo di attivazione dell'update la applica`)
+        : []));
+      log(`boot definitions: ${target.component} rigenerata su ${result.target}`);
+    } catch (e) {
+      out.errors.push(`${target.component}: ${String((e && e.message) || e)}`);
+      log(`WARN boot definitions: rigenerazione di ${target.component} fallita: ${(e && e.message) || e} (aggiornamento proseguito; rilancia nexuscrew init)`);
+    }
+  }
+  for (const w of out.warnings) log(`WARN boot definitions: ${w}`);
+  return out;
+}
+
+// R28-rimedio, difetto 2 (audit): l'attivazione differita dichiarata dalla
+// regen era una promessa FALSA in silenzio. `restart` fa `systemctl --user
+// restart` SENZA daemon-reload (systemd riavvia con la definizione VECCHIA
+// in memoria) e `launchctl kickstart` riusa la definizione già caricata; col
+// runtime spento non c'è restart affatto. L'attivazione va APPLICATA qui,
+// nel percorso di update, subito dopo la regen. È UN SOLO CERVELLO per
+// «reinstalla ⇒ sana le definizioni ⇒ rendile note al service manager»:
+// la usa il runner dell'auto-update e la usa `update()` manuale (difetto 1:
+// la via manuale bypassava la sanazione).
+//
+// Cosa applica, per piattaforma, dopo la regen:
+// - linux: `systemctl --user daemon-reload` — rende note le unit riscritte
+//   SENZA avviare nulla (il companion oneshot resta fermo; il restart
+//   dell'update carica davvero la definizione nuova).
+// - mac, runtime attivo: bootout+bootstrap del principale (RunAtLoad lo
+//   riparte subito sul nuovo codice: coincide col restart che l'update farebbe
+//   comunque) e POI della companion (le celle boot:true partono col servizio
+//   già nuovo). Il kickstart del restart successivo è ridondante e innocuo.
+// - mac, runtime SPENTO: NESSUN bootstrap — non si accende ciò che l'utente
+//   ha spento, e start/restart non caricano definizioni (kickstart). Limite
+//   DICHIARATO in activation.skipped: launchd prende le definizioni scritte
+//   al prossimo boot della macchina o con `nexuscrew init`.
+// - termux: nessun service manager — skipped dichiarato.
+//
+// Best-effort come la regen: un fallimento non blocca l'aggiornamento, viene
+// loggato e riportato in activation.errors.
+function healBootDefinitions(opts = {}) {
+  const platformMod = opts.platformMod || require('../cli/platform.js');
+  const platform = opts.platform || platformMod.detectPlatform();
+  const home = opts.home || os.homedir();
+  const execImpl = opts.execImpl || execFileSync;
+  const log = opts.log || console.log;
+  const regen = (opts.regenImpl || regenBootDefinitions)({ ...opts });
+  const out = { ...regen, activation: { applied: [], skipped: [], errors: [] } };
+  if (!Array.isArray(regen.regenerated) || regen.regenerated.length === 0) {
+    out.activation.skipped.push('nessuna definizione rigenerata: nulla da attivare');
+    return out;
+  }
+  const run = (bin, args) => {
+    const cmd = `${bin} ${args.join(' ')}`;
+    try { execImpl(bin, args, { stdio: 'ignore' }); out.activation.applied.push(cmd); }
+    catch (e) { out.activation.errors.push(`${cmd}: ${(e && e.message) || e}`); }
+  };
+  if (platform === 'linux') {
+    run('systemctl', ['--user', 'daemon-reload']);
+  } else if (platform === 'mac') {
+    if (opts.running !== true) {
+      const limit = 'runtime spento: definizioni scritte e NON attivate — launchd le carica al prossimo boot della macchina o con nexuscrew init (start/restart usano kickstart sulla definizione già in memoria)';
+      out.activation.skipped.push(limit);
+      out.warnings.push(`attivazione non applicata: ${limit}`);
+    } else {
+      const uid = opts.uid !== undefined ? opts.uid : platformMod.uid();
+      const domain = `gui/${uid}`;
+      const serviceMod = opts.serviceMod || require('../cli/service.js');
+      const fleetMod = opts.fleetMod || require('../cli/fleet-service.js');
+      const boot = (label, target) => {
+        // bootout best-effort: non caricato è l'esito atteso del primo giro
+        try { execImpl('launchctl', ['bootout', `${domain}/${label}`], { stdio: 'ignore' }); } catch (_) {}
+        run('launchctl', ['bootstrap', domain, target]);
+      };
+      if (regen.regenerated.includes('service')) {
+        boot('com.mmmbuto.nexuscrew', serviceMod.installPath(platform, home));
+      }
+      if (regen.regenerated.includes('fleet-companion')) {
+        boot('com.mmmbuto.nexuscrew-fleet', fleetMod.fleetInstallPath(platform, home));
+      }
+    }
+  } else {
+    out.activation.skipped.push(`platform ${platform}: nessun service manager, attivazione non applicabile`);
+  }
+  for (const a of out.activation.applied) log(`boot definitions: attivazione applicata (${a})`);
+  for (const s of out.activation.skipped) log(`WARN boot definitions: ${s}`);
+  for (const e of out.activation.errors) log(`WARN boot definitions: attivazione fallita: ${e}`);
+  return out;
+}
+
 function args(argv) {
   const out = {};
   for (let i = 0; i < argv.length; i += 2) {
@@ -132,6 +345,16 @@ async function runUpdate(opts = {}) {
   const previous = readState(statusPath);
   const previousVersion = String(readInstalledVersion() || '');
   let installedNew = false;
+  // wasRunning serve solo a mac (decide se bootout+bootstrap è lecito: col
+  // runtime spento non si accende nulla): su linux daemon-reload non esegue
+  // servizi e non serve saperlo. Calcolato PRIMA del try perché vale per il
+  // percorso di aggiornamento e per quello di rollback.
+  const regenPlatform = opts.regenSeams && opts.regenSeams.platformMod
+    ? opts.regenSeams.platformMod.detectPlatform()
+    : require('../cli/platform.js').detectPlatform();
+  const wasRunning = regenPlatform === 'mac'
+    ? ((opts.isRunningImpl || ((o) => require('../cli/commands.js').isServiceRunning(o)))({ home }))
+    : undefined;
   try {
     writeState(statusPath, { ...previous, phase: 'installing', targetVersion: version, updaterPid: process.pid, lastError: '' });
     execImpl('npm', ['install', '--global', `${PACKAGE_NAME}@${version}`, '--no-audit', '--no-fund'], {
@@ -142,12 +365,23 @@ async function runUpdate(opts = {}) {
     installedNew = true;
     await preflightImpl({ version, home });
     writeState(statusPath, { ...readState(statusPath), phase: 'restarting', updaterPid: process.pid, lastError: '' });
+    // R28: sana le definizioni di boot PRIMA del riavvio — è il passo che
+    // manca al percorso di upgrade e che lasciava la companion puntata a un
+    // binario morto (exit 78, silenzio). R28-rimedio: la sanazione ora
+    // APPLICA anche l'attivazione differita (healBootDefinitions) — il
+    // restart da solo non caricava le definizioni riscritte. Best-effort
+    // DICHIARATO: un errore qui non blocca l'aggiornamento, viene loggato e
+    // riportato nel risultato.
+    const bootDefinitions = (opts.healBootImpl || healBootDefinitions)({
+      home, running: wasRunning, execImpl, ...(opts.regenSeams || {}),
+      ...(opts.regenBootImpl ? { regenImpl: opts.regenBootImpl } : {}),
+    });
     const restartMode = await restartImpl({ home, ...(opts.runtimeSeams || {}) });
     writeState(statusPath, {
       ...readState(statusPath), phase: 'installed', current: version, latest: version,
       available: false, blockedVersion: '', lastUpdatedAt: new Date().toISOString(), lastError: '',
     });
-    return { updated: true, version, restartMode };
+    return { updated: true, version, restartMode, bootDefinitions };
   } catch (e) {
     let rollbackError = null; let rolledBack = false;
     if (installedNew && parseVersion(previousVersion) && previousVersion !== version) {
@@ -157,6 +391,14 @@ async function runUpdate(opts = {}) {
         });
         if (String(readInstalledVersion() || '') !== previousVersion) throw new Error(`rollback verify: attesa ${previousVersion}`);
         await preflightImpl({ version: previousVersion, home, rollback: true });
+        // R28: il rollback riparte dalle stesse definizioni sane — il
+        // downgrade reinstalla il pacchetto nel prefix attuale e i path
+        // vivi valgono anche per la versione precedente. R28-rimedio:
+        // anche qui sanazione+attivazione (heal), non la sola regen.
+        (opts.healBootImpl || healBootDefinitions)({
+          home, running: wasRunning, execImpl, ...(opts.regenSeams || {}),
+          ...(opts.regenBootImpl ? { regenImpl: opts.regenBootImpl } : {}),
+        });
         await restartImpl({ home, ...(opts.runtimeSeams || {}) });
         rolledBack = true;
       } catch (rollbackFailure) { rollbackError = rollbackFailure; }
@@ -183,4 +425,4 @@ if (require.main === module) {
     .catch(() => { process.exitCode = 1; });
 }
 
-module.exports = { args, restartRuntime, runUpdate };
+module.exports = { args, restartRuntime, runUpdate, regenBootDefinitions, healBootDefinitions };

package/package.json

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