@mmmbuto/nexuscrew 0.9.51 → 0.9.53

package/lib/update/runner.js

@@ -9,6 +9,7 @@ const {
   PACKAGE_NAME, parseVersion, scrubError, adoptUpdateLock, releaseUpdateLock, readState, writeState,
   stableRuntimeDir,
 } = require('./core.js');
+const npmEnv = require('./npm-env.js');
 
 // da revisione — rigenerazione delle definizioni di boot dopo l'installazione.
 //
@@ -233,6 +234,21 @@ function args(argv) {
   return out;
 }
 
+// Versione del processo che ascolta su `port`, dal suo /api/config. null = non leggibile (non si presume).
+async function readRuntimeVersion(port, token, opts = {}) {
+  if (typeof opts.runtimeVersionImpl === 'function') return opts.runtimeVersionImpl(port, token);
+  const fetchImpl = opts.fetchImpl || globalThis.fetch;
+  if (typeof fetchImpl !== 'function') return null;
+  try {
+    const r = await fetchImpl(`http://127.0.0.1:${port}/api/config`, {
+      headers: { authorization: `Bearer ${token}` }, signal: AbortSignal.timeout?.(5000),
+    });
+    if (r.status !== 200) return null;
+    const v = (await r.json()).version;
+    return typeof v === 'string' && v ? v : null;
+  } catch (_) { return null; }
+}
+
 async function restartRuntime(opts = {}) {
   const home = opts.home || os.homedir();
   const commands = opts.commands || require('../cli/commands.js');
@@ -298,7 +314,15 @@ async function restartRuntime(opts = {}) {
         await wait(100);
       }
       if (!released) throw new Error(`restart portatile fallito: porta ${port} non liberata`);
-      commands.startPortable({ platform, home });
+      const launched = commands.startPortable({ platform, home });
+      if (launched && launched.started === false) {
+        // «già in esecuzione»/non avviato NON e' un successo: lo e' solo se il processo che risponde e' gia' alla
+        // versione attesa (verificato), altrimenti l'update ha installato codice che nessuno esegue.
+        const running = opts.expectedVersion ? await readRuntimeVersion(port, token, opts) : null;
+        if (!opts.expectedVersion || running !== opts.expectedVersion) {
+          throw new Error(`avvio portatile non riuscito (${launched.reason || 'started:false'}); versione in esecuzione ${running || 'non leggibile'}${opts.expectedVersion ? `, attesa ${opts.expectedVersion}` : ''}`);
+        }
+      }
       mode = 'portable';
     }
   }
@@ -309,6 +333,12 @@ async function restartRuntime(opts = {}) {
       ...(opts.healthProbeImpl ? { probeImpl: opts.healthProbeImpl } : {}),
     });
     if (!healthy) throw new Error(`NexusCrew ${mode} non healthy su 127.0.0.1:${port} dopo il restart`);
+    if (opts.expectedVersion) {
+      const running = await readRuntimeVersion(port, token, opts);
+      if (running !== opts.expectedVersion) {
+        throw new Error(`NexusCrew ${mode} risponde ma esegue la versione ${running || 'non leggibile'}, attesa ${opts.expectedVersion}`);
+      }
+    }
   }
   return mode;
 }
@@ -320,10 +350,20 @@ async function runUpdate(opts = {}) {
   const statusPath = opts.statusPath || path.join(home, '.nexuscrew', 'npm-update.json');
   const workDir = opts.cwd || stableRuntimeDir(home);
   const execImpl = opts.execImpl || execFileSync;
-  const readInstalledVersion = opts.readInstalledVersion || (() => {
-    const p = path.resolve(__dirname, '..', '..', 'package.json');
-    return JSON.parse(fs.readFileSync(p, 'utf8')).version;
+  const packageRoot = opts.packageRoot || path.resolve(__dirname, '..', '..');
+  const log = opts.log || console.log;
+  // La versione si legge dal package.json del percorso ESEGUITO (realpath), non con `npm ls`: e' il codice che il
+  // riavvio caricherebbe davvero.
+  const readInstalledVersion = opts.readInstalledVersion || (() => npmEnv.readInstalledFrom(packageRoot).version);
+  const installedPath = () => { try { return npmEnv.redact((opts.readInstalledFromImpl || (() => npmEnv.readInstalledFrom(packageRoot)))().path, home); } catch (_) { return ''; } };
+  // npm = STESSO node del demone; la preflight prova, prima di installare, che `npm -g` scriverebbe dove il codice vive.
+  const invocation = (opts.npmInvocationImpl || npmEnv.resolveNpmInvocation)({ execPath: opts.execPath || process.execPath });
+  const runNpm = (npmArgs) => execImpl(invocation.bin, [...invocation.argvPrefix, ...npmArgs], {
+    stdio: 'inherit', timeout: 5 * 60 * 1000, cwd: workDir, ...(invocation.env ? { env: invocation.env } : {}),
   });
+  const logEnv = (phase) => log(`env-check[${phase}] ${npmEnv.describeEnv({
+    execPath: opts.execPath || process.execPath, envPath: opts.envPath !== undefined ? opts.envPath : process.env.PATH, home,
+  })} npm=${invocation.kind}${invocation.npmCli ? `:${npmEnv.redact(invocation.npmCli, home)}` : ''} pkg=${npmEnv.redact(packageRoot, home)}`);
   const preflightImpl = opts.preflightImpl || (({ version: expectedVersion = version } = {}) => {
     const bin = path.resolve(__dirname, '..', '..', 'bin', 'nexuscrew.js');
     const output = execFileSync(process.execPath, [bin, 'version'], {
@@ -357,11 +397,11 @@ async function runUpdate(opts = {}) {
     : undefined;
   try {
     writeState(statusPath, { ...previous, phase: 'installing', targetVersion: version, updaterPid: process.pid, lastError: '' });
-    execImpl('npm', ['install', '--global', `${PACKAGE_NAME}@${version}`, '--no-audit', '--no-fund'], {
-      stdio: 'inherit', timeout: 5 * 60 * 1000, cwd: workDir,
-    });
+    logEnv('pre-install');
+    await (opts.npmPreflightImpl || npmEnv.npmPreflight)({ invocation, packageRoot, home });
+    runNpm(['install', '--global', `${PACKAGE_NAME}@${version}`, '--no-audit', '--no-fund']);
     const installed = String(readInstalledVersion() || '');
-    if (installed !== version) throw new Error(`verifica installazione fallita: attesa ${version}, trovata ${installed || 'sconosciuta'}`);
+    if (installed !== version) throw new Error(`verifica installazione fallita: attesa ${version}, trovata ${installed || 'sconosciuta'}${installedPath() ? ` in ${installedPath()}` : ''}`);
     installedNew = true;
     await preflightImpl({ version, home });
     writeState(statusPath, { ...readState(statusPath), phase: 'restarting', updaterPid: process.pid, lastError: '' });
@@ -376,7 +416,8 @@ async function runUpdate(opts = {}) {
       home, running: wasRunning, execImpl, ...(opts.regenSeams || {}),
       ...(opts.regenBootImpl ? { regenImpl: opts.regenBootImpl } : {}),
     });
-    const restartMode = await restartImpl({ home, ...(opts.runtimeSeams || {}) });
+    const restartMode = await restartImpl({ home, expectedVersion: version, ...(opts.runtimeSeams || {}) });
+    logEnv('post-restart');
     writeState(statusPath, {
       ...readState(statusPath), phase: 'installed', current: version, latest: version,
       available: false, blockedVersion: '', lastUpdatedAt: new Date().toISOString(), lastError: '',
@@ -386,9 +427,8 @@ async function runUpdate(opts = {}) {
     let rollbackError = null; let rolledBack = false;
     if (installedNew && parseVersion(previousVersion) && previousVersion !== version) {
       try {
-        execImpl('npm', ['install', '--global', `${PACKAGE_NAME}@${previousVersion}`, '--no-audit', '--no-fund'], {
-          stdio: 'inherit', timeout: 5 * 60 * 1000, cwd: workDir,
-        });
+        logEnv('pre-rollback');
+        runNpm(['install', '--global', `${PACKAGE_NAME}@${previousVersion}`, '--no-audit', '--no-fund']);
         if (String(readInstalledVersion() || '') !== previousVersion) throw new Error(`rollback verify: attesa ${previousVersion}`);
         await preflightImpl({ version: previousVersion, home, rollback: true });
         // da revisione: il rollback riparte dalle stesse definizioni sane — il
@@ -399,7 +439,7 @@ async function runUpdate(opts = {}) {
           home, running: wasRunning, execImpl, ...(opts.regenSeams || {}),
           ...(opts.regenBootImpl ? { regenImpl: opts.regenBootImpl } : {}),
         });
-        await restartImpl({ home, ...(opts.runtimeSeams || {}) });
+        await restartImpl({ home, expectedVersion: previousVersion, ...(opts.runtimeSeams || {}) });
         rolledBack = true;
       } catch (rollbackFailure) { rollbackError = rollbackFailure; }
     }
@@ -425,4 +465,4 @@ if (require.main === module) {
     .catch(() => { process.exitCode = 1; });
 }
 
-module.exports = { args, restartRuntime, runUpdate, regenBootDefinitions, healBootDefinitions };
+module.exports = { args, readRuntimeVersion, restartRuntime, runUpdate, regenBootDefinitions, healBootDefinitions };

package/lib/update/start-lock.js

@@ -0,0 +1,106 @@
+'use strict';
+// Lock di avvio condiviso: serializza chi EMETTE un avvio/riavvio del nodo (boot via start, `show`, `start`,
+// `restart`, runner dell'update). Due avviatori simultanei creavano un nodo che ne uccideva un altro appena partito.
+//
+// Contro il deadlock:
+//  - sezione critica breve: si tiene solo mentre si EMETTE il comando (spawn/systemctl/launchctl), mai mentre si
+//    attende la salute del nodo, quindi il processo appena avviato non ha nulla da attendere;
+//  - rientrante nello STESSO processo (smartUp -> restart -> startPortable non si blocca da solo);
+//  - proprietario VERIFICATO: pid vivo e, se noto, stessa nascita del processo (pid riassegnato = lock orfano);
+//  - SCADENZA: oltre ttlMs il lock si considera stantio anche con il proprietario vivo, e si riprende;
+//  - attesa limitata: allo scadere errore chiaro `start-lock-timeout` (con chi lo tiene), mai attesa infinita;
+//  - si rilascia/toglie solo un lock col PROPRIO token.
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const DEFAULT_TTL_MS = 60 * 1000;
+const DEFAULT_WAIT_MS = 20 * 1000;
+const POLL_MS = 100;
+const held = new Map(); // file -> { depth, token }
+
+const sleepSync = (ms) => { try { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); } catch (_) { /* best effort */ } };
+
+function lockPath(home) { return path.join(home || os.homedir(), '.nexuscrew', 'start.lock'); }
+
+function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid < 1) return false;
+  try { process.kill(pid, 0); return true; } catch (e) { return e.code === 'EPERM'; }
+}
+
+function processStartOf(pid, impl) {
+  try { return (impl || require('../cli/pidfile.js').readProcessStart)(pid) || ''; } catch (_) { return ''; }
+}
+
+function readLock(file) {
+  try {
+    const st = fs.lstatSync(file);
+    if (!st.isFile() || st.isSymbolicLink()) return { corrupt: true };
+    const v = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return v && Number.isInteger(v.pid) && typeof v.token === 'string' ? v : { corrupt: true };
+  } catch (e) { return e.code === 'ENOENT' ? null : { corrupt: true }; }
+}
+
+function isStale(meta, now, ttlMs, impl = {}) {
+  if (!meta || meta.corrupt) return true;
+  if (!pidAlive(meta.pid)) return true;
+  if (meta.processStart) {
+    const live = processStartOf(meta.pid, impl.readProcessStartImpl);
+    if (live && live !== meta.processStart) return true; // pid riassegnato a un altro processo
+  }
+  return now - Number(meta.createdAt || 0) > ttlMs;
+}
+
+function unlinkIfToken(file, token) {
+  const cur = readLock(file);
+  if (cur && !cur.corrupt && cur.token !== token) return false;
+  try { fs.unlinkSync(file); return true; } catch (e) { return e.code === 'ENOENT'; }
+}
+
+// Ritorna un handle {release()}. Sincrono: chi lo chiama (spawn, execFileSync) lo e' gia'.
+function acquireStartLock({ home, ttlMs = DEFAULT_TTL_MS, waitMs = DEFAULT_WAIT_MS, label = '', impl = {} } = {}) {
+  const file = lockPath(home);
+  const mine = held.get(file);
+  if (mine) { mine.depth += 1; return { release: () => releaseHeld(file) }; }
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  const deadline = Date.now() + waitMs;
+  for (;;) {
+    const token = crypto.randomBytes(12).toString('hex');
+    try {
+      fs.writeFileSync(file, `${JSON.stringify({ pid: process.pid, token, createdAt: Date.now(), label, processStart: processStartOf(process.pid, impl.readProcessStartImpl) })}\n`, { flag: 'wx', mode: 0o600 });
+      held.set(file, { depth: 1, token });
+      return { release: () => releaseHeld(file) };
+    } catch (e) {
+      if (e.code !== 'EEXIST') throw e;
+    }
+    const meta = readLock(file);
+    if (isStale(meta, Date.now(), ttlMs, impl)) {
+      // ripresa: solo se il file e' ancora quello che abbiamo giudicato stantio
+      const again = readLock(file);
+      if (!again || again.corrupt || again.token === (meta && meta.token)) { unlinkIfToken(file, meta && !meta.corrupt ? meta.token : undefined); continue; }
+    }
+    if (Date.now() >= deadline) {
+      const error = new Error(`avvio gia' in corso (${meta && meta.label ? meta.label : 'altro avviatore'}, pid ${meta && meta.pid}): riprova fra poco`);
+      error.code = 'start-lock-timeout'; error.holder = meta && !meta.corrupt ? { pid: meta.pid, label: meta.label || '', ageMs: Date.now() - Number(meta.createdAt || 0) } : null;
+      throw error;
+    }
+    sleepSync(POLL_MS);
+  }
+}
+
+function releaseHeld(file) {
+  const mine = held.get(file);
+  if (!mine) return;
+  mine.depth -= 1;
+  if (mine.depth > 0) return;
+  held.delete(file);
+  unlinkIfToken(file, mine.token);
+}
+
+function withStartLock(fn, opts = {}) {
+  const handle = acquireStartLock(opts);
+  try { return fn(); } finally { handle.release(); }
+}
+
+module.exports = { DEFAULT_TTL_MS, DEFAULT_WAIT_MS, lockPath, acquireStartLock, withStartLock, isStale, readLock };

package/package.json

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