@mmmbuto/nexuscrew 0.9.51 → 0.9.53

package/lib/server.js

@@ -7,7 +7,6 @@ const { execFileSync } = require('node:child_process');
 const express = require('express');
 const { WebSocketServer } = require('ws');
 const { defaults, loadConfig, assertLoopback, configJsonPath } = require('./config.js');
-const { writeConfigAtomic } = require('./cli/init.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');
@@ -68,6 +67,9 @@ const { parseVisitedChain } = require('./audio/origin.js');
 const { settingsRoutes, publicPeeringRoutes } = require('./settings/routes.js');
 const decksStore = require('./decks/store.js');
 const { decksRoutes } = require('./decks/routes.js');
+const prefsStore = require('./prefs/store.js');
+const messages = require('./cli/messages.js');
+const { prefsRoutes } = require('./prefs/routes.js');
 const { createEventsHub } = require('./notify/events.js');
 const { createPushService } = require('./notify/push.js');
 const { createPushRelay, createPushDedup } = require('./notify/push-relay.js');
@@ -407,6 +409,7 @@ function createServer(opts = {}) {
   const healthFetch = cfg.fetchImpl || fetch;
   const topologyCachePath = cfg.topologyCachePath || topologyCache.defaultPath(cfg.home || os.homedir());
   const decksPath = cfg.decksPath || decksStore.defaultDecksPath(cfg.home || os.homedir());
+  const prefsPath = cfg.prefsPath || prefsStore.defaultPrefsPath(cfg.home || os.homedir());
   const proxyReadonly = () => (cfg.readonlyDefault === true || process.env.NEXUSCREW_READONLY === '1');
   const audioHome = cfg.home || os.homedir();
   // Stato audio ancorato alla directory del token (come notifyDir): server,
@@ -1146,6 +1149,8 @@ function createServer(opts = {}) {
   // tetto dello snapshot non si conclude nulla, perche' un'assenza potrebbe
   // essere un taglio della lista e non una chiusura.
   const SNAPSHOT_FULL = 100;
+  // Retry programmati della riconciliazione: uno per owner, senza duplicati.
+  const reconcileRetryArmed = new Set();
   async function reconcileImportedAsks() {
     const store = nodesStore.loadStore(nodesPath);
     if (!store) return;
@@ -1156,18 +1161,38 @@ function createServer(opts = {}) {
       if (!byOwner.has(a.ownerId)) byOwner.set(a.ownerId, []);
       byOwner.get(a.ownerId).push(a);
     }
+    // Porta unica; SOLO 'ok' è autorevole: uno skip, un pending, una finestra
+    // chiusa, un errore o un timeout non chiudono MAI un alias aperto. Su
+    // skipped/pending UN tentativo programmato alla scadenza della finestra,
+    // per owner, senza duplicati: senza, una GET caduta in finestra lascerebbe
+    // la card aperta fino alla prossima lettura dell'operatore.
     for (const [ownerId, aliases] of byOwner) {
-      const peer = (store.nodes || []).find((n) => n && n.nodeId === ownerId && n.token && n.localPort);
-      if (!peer) continue;
-      let snap = null;
+      let door = null;
       try {
-        const res = await fetch(`http://127.0.0.1:${peer.localPort}/federation/route/_/event-feed/snapshot`, {
-          headers: { authorization: `Bearer ${peer.token}` }, signal: AbortSignal.timeout(3000),
-        });
-        if (!res.ok) continue;
-        snap = await res.json();
-      } catch (_) { continue; }
-      const live = new Set((snap && Array.isArray(snap.asks) ? snap.asks : []).map((x) => String(x.id)));
+        door = eventFeedClient && typeof eventFeedClient.ownerSnapshotAsks === 'function'
+          ? await eventFeedClient.ownerSnapshotAsks(ownerId) : null;
+      } catch (_) { door = null; }
+      if (!door || door.status !== 'ok') {
+        if (door && (door.status === 'skipped' || door.status === 'pending') && !reconcileRetryArmed.has(ownerId)) {
+          reconcileRetryArmed.add(ownerId);
+          const delay = Math.max(250, (door.retryAt || (Date.now() + 1000)) - Date.now());
+          const t = setTimeout(() => {
+            reconcileRetryArmed.delete(ownerId);
+            void reconcileImportedAsks();
+          }, delay);
+          if (typeof t.unref === 'function') t.unref();
+        }
+        continue;
+      }
+      // 'ok' dalla porta implica asks Array: lo richiede il validatore unico.
+      // Se NON lo è, il contratto è rotto — è un bug, non una chiusura: si
+      // logga e non si tocca NESSUN alias. Prima il .map() lanciava e la
+      // route sopprimeva l'eccezione in silenzio.
+      if (!Array.isArray(door.asks)) {
+        (opts.log || console.log)(`reconcile-imported-asks: snapshot 'ok' senza asks array per l'owner ${String(ownerId).slice(0, 8)}…: contratto rotto, nessuna chiusura`);
+        continue;
+      }
+      const live = new Set(door.asks.map((x) => String(x.id)));
       if (live.size >= SNAPSHOT_FULL) continue;
       for (const alias of aliases) {
         if (live.has(String(alias.ownerAskId))) continue;
@@ -1268,6 +1293,9 @@ function createServer(opts = {}) {
     fleetP,
     cellForSession: (session) => cellIdFromTmuxSession(session),
     eventsEnabled,
+    // Il produttore dello snapshot logga la lettura fallita degli asks: senza
+    // questo wiring la riga finiva nel noop di default delle routes.
+    log: opts.log || console.log,
   }));
   // Client-side subscriber: for every outbound peer the
   // operator flagged eventsReceive, pull the owner's feed (snapshot first),
@@ -1291,6 +1319,13 @@ function createServer(opts = {}) {
       const b = req.body || {};
       if (b.action === 'dismiss') {
         const out = await askRelay.relayDismiss({ ownerId: b.ownerId, askId: b.askId });
+        // Dismiss CONFERMATO dall'owner (2xx): la view del feed lo dimentica
+        // subito — drop + tombstone — che lo stream sia vivo o no. Senza
+        // questo, una view stale o gated (resync-exhausted) ripresenta la
+        // card a ogni feed-state: la card che l'operatore vede tornare dopo lo scarto.
+        if (out.ok && typeof eventFeedClient.dismissConfirmed === 'function') {
+          eventFeedClient.dismissConfirmed(b.ownerId, b.askId);
+        }
         return res.status(out.ok ? 200 : out.code || 500).json(out.ok ? { dismissed: true } : { error: out.error || 'unknown' });
       }
       if (b.action === 'verify') {
@@ -1327,6 +1362,11 @@ function createServer(opts = {}) {
     loadStore: () => nodesStore.loadStore(nodesPath),
     token: () => tokenHolder.value,
     eventsHub: importHub,
+    // Gradini del cooldown post-resync-exhausted: default nel client,
+    // overridabile da config per test e installazioni particolari.
+    resyncCooldownStepsMs: cfg.eventFeedClientResyncCooldownStepsMs,
+    // Finestra minima fra snapshot (invariante anti-storm): stessa via.
+    minSnapshotIntervalMs: cfg.eventFeedClientMinSnapshotIntervalMs,
     log: opts.log || console.log,
     pollMs: cfg.eventFeedClientPollMs,
   });
@@ -1511,6 +1551,7 @@ function createServer(opts = {}) {
     storePath: vlNodesPath, broker: vlNodeBroker, ownerId: vlOwnerId, readonly: proxyReadonly,
   }));
   api.use('/decks', decksRoutes({ cfg, decksPath }));
+  api.use('/prefs', prefsRoutes({ cfg, prefsPath }));
   api.use('/fs', fsRoutes({ home: os.homedir() }));  // folder-picker del dialog new session
   // /nodes (read-only, per la settings UI): stesso formato di `nodes list --json`
   // (token SEMPRE redatti via redactStore) + health federato per-nodo. Il campo
@@ -1851,24 +1892,41 @@ function start(opts = {}) {
     });
     panelServerV6.listen(cfg.panelPort, '::1');
   };
+  // Il ripiego del pannello si scrive nel log UNA volta per coppia richiesta/scelta: un nodo che si riavvia spesso
+  // (aggiornamenti, servizio) non deve riempire il log con la stessa riga a ogni avvio e nascondere il resto.
+  const panelNotePath = () => path.join(opts.configDir || path.join(cfg.home || os.homedir(), '.nexuscrew'), 'panel-port.note');
+  const notePanelFallback = (requested, selected) => {
+    const line = `${requested}>${selected}`;
+    try { if (fs.readFileSync(panelNotePath(), 'utf8').trim() === line) return; } catch (_) { /* nessuna nota */ }
+    log(`panel port ${requested} busy; selected ${selected}`);
+    try { fs.mkdirSync(path.dirname(panelNotePath()), { recursive: true }); fs.writeFileSync(panelNotePath(), `${line}\n`); } catch (_) { /* best effort */ }
+  };
   const startPanelServer = () => {
+    // Il pannello non puo' condividere la porta del control plane: se la scelta cade li' (default 41821 con
+    // port=41821, o un ripiego), si parte dalla successiva.
+    const mainPort = cfg.port;
     const requestedPanelPort = cfg.panelPort;
+    const skipMain = (p) => (p === mainPort ? (p >= 65535 ? 41821 : p + 1) : p);
     const tryPanelFallback = (candidate, remaining) => {
       panelServer.once('error', (error) => {
         if (error && error.code === 'EADDRINUSE' && remaining > 1) {
-          tryPanelFallback(candidate >= 65535 ? 41821 : candidate + 1, remaining - 1);
+          tryPanelFallback(skipMain(candidate >= 65535 ? 41821 : candidate + 1), remaining - 1);
           return;
         }
         log(`panel: preferred port ${requestedPanelPort} busy and no fallback available (${(error && error.code) || error}); panel disabled this run.`);
       });
       panelServer.listen(candidate, cfg.bind, () => {
         cfg.panelPort = panelServer.address().port;
-        log(`panel port ${requestedPanelPort} busy; selected ${cfg.panelPort}`);
+        notePanelFallback(requestedPanelPort, cfg.panelPort);
         startPanelV6();
       });
     };
+    if (requestedPanelPort !== 0 && requestedPanelPort === mainPort) {
+      tryPanelFallback(skipMain(requestedPanelPort >= 65535 ? 41821 : requestedPanelPort + 1), 200);
+      return;
+    }
     panelServer.once('error', (error) => {
-      if (error && error.code === 'EADDRINUSE') { tryPanelFallback(requestedPanelPort >= 65535 ? 41821 : requestedPanelPort + 1, 200); return; }
+      if (error && error.code === 'EADDRINUSE') { tryPanelFallback(skipMain(requestedPanelPort >= 65535 ? 41821 : requestedPanelPort + 1), 200); return; }
       log(`panel: failed to start (${(error && error.code) || error}); panel disabled this run.`);
     });
     panelServer.listen(requestedPanelPort, cfg.bind, () => {
@@ -1884,43 +1942,63 @@ function start(opts = {}) {
     log('localhost-only — reach it via a user-controlled SSH or VPN channel.');
     startPanelServer();
   };
-  const persistFallback = () => {
-    const selected = server.address().port;
-    const configPath = opts.configPath || configJsonPath();
-    let current = {};
+  // il ripiego automatico della porta principale NON si fa piu'. Un nodo che si sposta di porta cambia
+  // origin: la PWA gia' installata resta sull'origin vecchia e quella nuova parte senza token, pin ne' ordine.
+  // Se la porta e' occupata: (1) se e' il PROPRIO processo orfano (pidfile vivo) lo si aspetta, con un limite,
+  // e si riprende la STESSA porta; (2) altrimenti errore chiaro. Una porta diversa la sceglie l'utente (--port).
+  const ownPortWaitMs = opts.ownPortWaitMs === undefined ? 15000 : opts.ownPortWaitMs;
+  const ownPortRetryMs = opts.ownPortRetryMs === undefined ? 500 : opts.ownPortRetryMs;
+  const isOwnRuntime = typeof opts.isOwnRuntimeImpl === 'function' ? opts.isOwnRuntimeImpl : () => {
     try {
-      const parsed = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) current = parsed;
-    } catch (_) {}
-    writeConfigAtomic(configPath, { ...current, port: selected });
-    log(`preferred port ${requestedPort} busy; selected ${selected}`);
-    onListening();
+      const pidf = require('./cli/pidfile.js');
+      const meta = pidf.readPidfile(pidf.defaultPidfilePath(cfg.home || os.homedir()));
+      return !!meta && meta.pid !== process.pid && pidf.isAlive(meta) && (meta.port === undefined || Number(meta.port) === Number(requestedPort));
+    } catch (_) { return false; }
+  };
+  const busyError = (cause) => {
+    const e = new Error(messages.portMessage('busy-other', { port: requestedPort }, { lang: opts.lang }));
+    e.code = 'EADDRINUSE'; e.cause = cause; return e;
+  };
+  const listenAfterOwn = (cause) => {
+    const deadline = Date.now() + ownPortWaitMs;
+    const attempt = () => {
+      if (!isOwnRuntime()) { listenError(busyError(cause)); return; }
+      if (Date.now() >= deadline) { listenError(busyError(cause)); return; }
+      setTimeout(() => {
+        server.once('error', (error) => {
+          if (error && error.code === 'EADDRINUSE') attempt(); else listenError(error);
+        });
+        server.listen(requestedPort, cfg.bind, onListening);
+      }, ownPortRetryMs);
+    };
+    attempt();
   };
-  const tryFallback = (candidate, remaining) => {
+  const legacyFallback = (candidate, remaining) => {
+    // Solo su richiesta esplicita (autoPort: true): gira su un'altra porta, senza scrivere config.json.
     server.once('error', (error) => {
-      if (error && error.code === 'EADDRINUSE' && remaining > 1) {
-        tryFallback(candidate >= 65535 ? 41820 : candidate + 1, remaining - 1);
-        return;
-      }
-      throw error;
+      if (error && error.code === 'EADDRINUSE' && remaining > 1) { legacyFallback(candidate >= 65535 ? 41820 : candidate + 1, remaining - 1); return; }
+      listenError(error);
     });
-    server.listen(candidate, cfg.bind, persistFallback);
+    server.listen(candidate, cfg.bind, () => { log(`preferred port ${requestedPort} busy; running on ${server.address().port} for this run only`); onListening(); });
   };
   server.once('error', (error) => {
-    if (error && error.code === 'EADDRINUSE' && requestedPort !== 0 && opts.autoPort !== false) {
+    if (error && error.code === 'EADDRINUSE' && requestedPort !== 0) {
       if (pairedPeers) {
-        const refused = new Error(`preferred port ${requestedPort} is busy; paired peers exist, refusing automatic port change`);
+        const refused = new Error(messages.portMessage('busy-paired', { port: requestedPort }, { lang: opts.lang }));
         refused.code = 'EADDRINUSE_PAIRED';
         refused.cause = error;
         listenError(refused);
         return;
       }
-      tryFallback(requestedPort >= 65535 ? 41820 : requestedPort + 1, 200);
+      if (opts.autoPort === true) { legacyFallback(requestedPort >= 65535 ? 41820 : requestedPort + 1, 200); return; }
+      listenAfterOwn(error);
       return;
     }
     listenError(error);
   });
   server.listen(requestedPort, cfg.bind, onListening);
+  server.panelServer = panelServer;
+  server.cfg = cfg;
   return server;
 }
 

package/lib/update/core.js

@@ -177,7 +177,52 @@ function writeState(file, value) {
   }
 }
 
+// Freni contro il ciclo install -> restart -> reinstall. Stato persistito nel file di stato:
+//   installs: { <versione>: [epochMs, ...] }  lastInstallAt: epochMs
+const MAX_INSTALLS_PER_VERSION = 2;
+const INSTALL_WINDOW_MS = 24 * 60 * 60 * 1000;
+const MIN_BETWEEN_INSTALLS_MS = 60 * 60 * 1000;
+
+function recentInstalls(state, version, now) {
+  const list = state && state.installs && Array.isArray(state.installs[version]) ? state.installs[version] : [];
+  return list.filter((t) => Number.isFinite(t) && now - t < INSTALL_WINDOW_MS && t <= now + 60_000);
+}
+
+// {ok:true} oppure {ok:false, reason}. Solo per gli aggiornamenti automatici: l'apply manuale non e' frenato.
+function installGate(state, version, now = Date.now()) {
+  const recent = recentInstalls(state, version, now);
+  if (recent.length >= MAX_INSTALLS_PER_VERSION) {
+    return { ok: false, reason: `backoff: ${recent.length} installazioni di ${version} nelle ultime 24 h, nessun'altra automatica` };
+  }
+  const last = Number(state && state.lastInstallAt);
+  if (Number.isFinite(last) && last <= now + 60_000 && now - last < MIN_BETWEEN_INSTALLS_MS) {
+    return { ok: false, reason: `backoff: ultimo aggiornamento ${Math.round((now - last) / 60000)} min fa, ne servono almeno 60 fra due` };
+  }
+  return { ok: true };
+}
+
+// Registra un tentativo di install (versione + istante) potando cio' che e' fuori finestra.
+function recordInstall(state, version, now = Date.now()) {
+  const installs = {};
+  for (const [v, list] of Object.entries((state && state.installs) || {})) {
+    const kept = recentInstalls(state, v, now);
+    if (kept.length) installs[v] = kept;
+  }
+  installs[version] = [...(installs[version] || []), now];
+  return { ...state, installs, lastInstallAt: now };
+}
+
+// Ritardo del PRIMO check dopo l'avvio: un demone che riparte spesso non deve richiamare il registry ogni volta.
+// Se l'ultimo check e' recente (e non nel futuro) si aspetta il resto dell'intervallo.
+function initialCheckDelayMs({ lastCheckedAt, now = Date.now(), intervalMs, initialDelayMs }) {
+  const at = Date.parse(lastCheckedAt || '');
+  if (!Number.isFinite(at) || at > now) return initialDelayMs;
+  const age = now - at;
+  return age < intervalMs ? Math.max(initialDelayMs, intervalMs - age) : initialDelayMs;
+}
+
 module.exports = {
+  MAX_INSTALLS_PER_VERSION, INSTALL_WINDOW_MS, MIN_BETWEEN_INSTALLS_MS, installGate, recordInstall, initialCheckDelayMs,
   PACKAGE_NAME, VERSION_RE, parseVersion, compareVersions, registryVersion,
   scrubError, pidAlive, readLock, acquireUpdateLock, adoptUpdateLock, releaseUpdateLock,
   readState, writeState, stableRuntimeDir,

package/lib/update/manager.js

@@ -7,7 +7,9 @@ const { execFile, spawn } = require('node:child_process');
 const {
   PACKAGE_NAME, compareVersions, parseVersion, registryVersion, scrubError, pidAlive, readLock,
   acquireUpdateLock, releaseUpdateLock, readState, writeState, stableRuntimeDir,
+  installGate, recordInstall, initialCheckDelayMs,
 } = require('./core.js');
+const npmEnv = require('./npm-env.js');
 
 const DEFAULT_INITIAL_DELAY_MS = 60 * 1000;
 const DEFAULT_INTERVAL_MS = 6 * 60 * 60 * 1000;
@@ -24,11 +26,13 @@ function isNewer(candidate, current) {
   try { return compareVersions(candidate, current) > 0; } catch (_) { return false; }
 }
 
-function lookupLatestNpm({ execFileImpl = execFile, timeoutMs = 20_000, home = os.homedir(), cwd } = {}) {
+function lookupLatestNpm({ execFileImpl = execFile, timeoutMs = 20_000, home = os.homedir(), cwd, npmInvocationImpl } = {}) {
+  // Stesso npm dell'installazione: node del demone + npm-cli accanto (mai `npm` nudo dal PATH).
+  const invocation = (npmInvocationImpl || npmEnv.resolveNpmInvocation)({ execPath: process.execPath });
   return new Promise((resolve, reject) => {
-    execFileImpl('npm', ['view', `${PACKAGE_NAME}@latest`, 'version', '--json'], {
+    execFileImpl(invocation.bin, [...invocation.argvPrefix, 'view', `${PACKAGE_NAME}@latest`, 'version', '--json'], {
       encoding: 'utf8', timeout: timeoutMs, maxBuffer: 64 * 1024,
-      cwd: cwd || stableRuntimeDir(home),
+      cwd: cwd || stableRuntimeDir(home), ...(invocation.env ? { env: invocation.env } : {}),
     }, (error, stdout) => {
       if (error) return reject(error);
       try { resolve(registryVersion(stdout)); } catch (e) { reject(e); }
@@ -75,6 +79,16 @@ function createNpmUpdater(opts = {}) {
     state = { ...state, phase: 'idle', available: false, latest: currentVersion, lastError: '' };
     writeState(statusPath, state);
   }
+  // un update dato per riuscito ma il processo in esecuzione NON e' alla versione target (ha ricaricato codice
+  // vecchio, o e' un altro albero): la versione si blocca, altrimenti ogni riavvio reinstalla lo stesso target.
+  if (state.phase === 'installed' && state.targetVersion && state.targetVersion !== currentVersion
+    && isNewer(state.targetVersion, currentVersion)) {
+    state = {
+      ...state, phase: 'error', available: true, blockedVersion: state.targetVersion,
+      lastError: `dopo l'aggiornamento il processo esegue la versione ${currentVersion}, attesa ${state.targetVersion}: versione bloccata`,
+    };
+    writeState(statusPath, state);
+  }
   const activeLock = () => { const lock = readLock(lockPath); return !!(lock && pidAlive(lock.pid)); };
   if ((state.phase === 'installing' || state.phase === 'restarting') && !pidAlive(state.updaterPid) && !activeLock()) {
     state = { ...state, phase: 'error', lastError: 'aggiornamento precedente interrotto' };
@@ -111,7 +125,7 @@ function createNpmUpdater(opts = {}) {
     };
   };
 
-  const launch = (version) => {
+  const launch = (version, { manual = false } = {}) => {
     if (!supported) throw new Error('auto-update disponibile solo nell’installazione npm globale');
     if (readonly) throw new Error('READONLY: auto-update bloccato');
     if (!isNewer(version, currentVersion)) return status();
@@ -122,6 +136,13 @@ function createNpmUpdater(opts = {}) {
     if (state.blockedVersion === version) {
       const error = new Error(`versione ${version} bloccata dopo un rollback fallito/necessario`); error.status = 409; error.code = 'update-blocked'; throw error;
     }
+    if (!manual) {
+      const gate = installGate(state, version);
+      if (!gate.ok) {
+        persist({ phase: 'available', available: true, lastError: gate.reason });
+        const error = new Error(gate.reason); error.status = 409; error.code = 'update-backoff'; throw error;
+      }
+    }
     const reservation = acquireUpdateLock(lockPath);
     if (!reservation.ok) {
       const error = new Error('aggiornamento già in corso'); error.status = 409; error.code = 'update-busy'; throw error;
@@ -141,7 +162,7 @@ function createNpmUpdater(opts = {}) {
     const fd = fs.openSync(logPath, 'a', 0o600);
     let child;
     try {
-      persist({ phase: 'installing', targetVersion: version, latest: version, available: true, lastError: '' });
+      persist({ ...recordInstall(state, version), phase: 'installing', targetVersion: version, latest: version, available: true, lastError: '' });
       const runnerArgs = [runnerPath, '--version', version, '--status', statusPath, '--home', home,
         '--lock', lockPath, '--lock-token', reservation.token];
       const bin = useSystemdRun ? 'systemd-run' : process.execPath;
@@ -212,7 +233,9 @@ function createNpmUpdater(opts = {}) {
           lastCheckedAt: new Date().toISOString(),
           lastError: blocked ? (state.lastError || `versione ${latest} bloccata dopo rollback`) : '',
         });
-        if (available && !blocked && autoApply && enabled) return launch(latest);
+        if (available && !blocked && autoApply && enabled) {
+          try { return launch(latest); } catch (error) { if (error && error.code === 'update-backoff') return status(); throw error; }
+        }
         return status();
       } catch (e) {
         return persist({ phase: 'error', lastCheckedAt: new Date().toISOString(), lastError: scrubError(e) });
@@ -231,7 +254,7 @@ function createNpmUpdater(opts = {}) {
     const latest = state.latest && isNewer(state.latest, currentVersion)
       ? state.latest : (await check()).latest;
     if (!latest || !isNewer(latest, currentVersion)) return status();
-    return launch(latest);
+    return launch(latest, { manual: true });
   };
 
   const schedule = (delay) => {
@@ -244,7 +267,7 @@ function createNpmUpdater(opts = {}) {
     if (typeof timer.unref === 'function') timer.unref();
   };
 
-  const start = () => schedule(initialDelayMs);
+  const start = () => schedule(initialCheckDelayMs({ lastCheckedAt: readState(statusPath).lastCheckedAt, intervalMs, initialDelayMs }));
   const close = () => { if (timer) clearTimeout(timer); timer = null; };
   const setEnabled = (value) => {
     enabled = value === true && !readonly;

package/lib/update/npm-env.js

@@ -0,0 +1,109 @@
+'use strict';
+// npm dell'aggiornamento: lo STESSO node che esegue il demone, con la prova che installerebbe dove il codice vive.
+//
+// Il difetto che questo modulo chiude: `npm` chiamato nudo dal PATH del processo. Con piu' node sulla macchina
+// (proot vs Termux, Homebrew vs sistema, nvm) quello che risponde a `npm` puo' appartenere a un altro node/prefix:
+// `npm install --global` esce 0 ma scrive in un ALTRO albero, e il processo riavviato ricarica codice vecchio.
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { PACKAGE_NAME } = require('./core.js');
+
+// Redazione per il log: mai home, mai segreti. Le stringhe lunghe alfanumeriche (token, chiavi) diventano ***.
+function redact(text, home = os.homedir()) {
+  let out = String(text == null ? '' : text);
+  if (home && home.length > 1) out = out.split(home).join('~');
+  return out.replace(/[A-Za-z0-9_-]{32,}/g, '***').slice(0, 600);
+}
+
+function describeEnv({ execPath = process.execPath, envPath = process.env.PATH || '', home = os.homedir(), nodeVersion = process.version } = {}) {
+  const entries = String(envPath).split(path.delimiter).filter(Boolean).slice(0, 25).map((e) => redact(e, home).slice(0, 120));
+  return `node=${redact(execPath, home)} v=${nodeVersion} PATH=${entries.join(':')}`;
+}
+
+// npm-cli.js accanto al node: bin/node -> ../lib/node_modules/npm (Linux/macOS/Termux/Homebrew/nvm),
+// oppure node_modules/npm accanto al binario (Windows e alcuni tarball).
+function findNpmCli(execPath, { exists = fs.existsSync, realpath = fs.realpathSync } = {}) {
+  const dirs = [path.dirname(execPath)];
+  try { const real = path.dirname(realpath(execPath)); if (!dirs.includes(real)) dirs.push(real); } catch (_) { /* binario non risolvibile */ }
+  for (const dir of dirs) {
+    for (const rel of [['..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'], ['node_modules', 'npm', 'bin', 'npm-cli.js']]) {
+      const candidate = path.join(dir, ...rel);
+      if (exists(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+// Mini-verifica di un range `engines.node` (clausole con `||`, congiunzioni con spazio; >=, >, <=, <, =, ^, ~).
+// Un range che non si sa leggere non blocca: e' un controllo di sicurezza, non un veto.
+function parseV(v) { const m = /^v?(\d+)(?:\.(\d+|x))?(?:\.(\d+|x))?/.exec(String(v).trim()); return m ? [Number(m[1]), m[2] === undefined || m[2] === 'x' ? null : Number(m[2]), m[3] === undefined || m[3] === 'x' ? null : Number(m[3])] : null; }
+function cmp(a, b) { for (let i = 0; i < 3; i += 1) { const x = a[i] || 0; const y = (b[i] === null || b[i] === undefined) ? 0 : b[i]; if (x !== y) return x > y ? 1 : -1; } return 0; }
+function comparatorOk(version, token) {
+  const m = /^(>=|<=|>|<|=|\^|~)?\s*(v?[\d.x]+)$/.exec(token);
+  if (!m) return null;
+  const op = m[1] || '='; const t = parseV(m[2]); if (!t) return null;
+  const c = cmp(version, t);
+  if (op === '>=') return c >= 0; if (op === '>') return c > 0; if (op === '<=') return c <= 0; if (op === '<') return c < 0;
+  if (op === '=') return t.every((n, i) => n === null || n === version[i]);
+  if (op === '^') { if (c < 0) return false; if (t[0] > 0) return version[0] === t[0]; if ((t[1] || 0) > 0) return version[0] === 0 && version[1] === t[1]; return version[0] === 0 && version[1] === 0 && version[2] === (t[2] || 0); }
+  if (op === '~') return c >= 0 && version[0] === t[0] && (t[1] === null || version[1] === t[1]);
+  return null;
+}
+function nodeRangeOk(nodeVersion, range) {
+  const v = parseV(nodeVersion); if (!v || !range) return true;
+  let unknown = false;
+  for (const clause of String(range).split('||')) {
+    const tokens = clause.trim().replace(/(>=|<=|>|<|=|\^|~)\s+/g, '$1').split(/\s+/).filter(Boolean);
+    if (!tokens.length) continue;
+    const results = tokens.map((tk) => comparatorOk(v, tk));
+    if (results.some((r) => r === null)) { unknown = true; continue; }
+    if (results.every(Boolean)) return true;
+  }
+  return unknown; // se nessuna clausola e' soddisfatta ma qualcuna non era leggibile, non si blocca
+}
+
+// Come lanciare npm: { bin, argvPrefix, env, kind, npmCli }.
+function resolveNpmInvocation({ execPath = process.execPath, exists, realpath, env = process.env } = {}) {
+  const npmCli = findNpmCli(execPath, { exists, realpath });
+  const withNodeFirst = { ...env, PATH: `${path.dirname(execPath)}${path.delimiter}${env.PATH || ''}` };
+  if (npmCli) return { kind: 'node-npm-cli', bin: execPath, argvPrefix: [npmCli], env: withNodeFirst, npmCli };
+  // npm non trovato accanto al node: si ripiega su `npm` del PATH, ma SOLO se la preflight prova dove scrive.
+  return { kind: 'path-npm', bin: 'npm', argvPrefix: [], env: withNodeFirst, npmCli: null };
+}
+
+function realpathSafe(p, realpath = fs.realpathSync) { try { return realpath(p); } catch (_) { return path.resolve(p); } }
+
+// Prova, PRIMA di toccare qualcosa, che l'install globale andrebbe dove il processo in esecuzione vive.
+function npmPreflight({
+  invocation, packageRoot = path.resolve(__dirname, '..', '..'), home = os.homedir(), nodeVersion = process.version,
+  execImpl = execFileSync, realpath = fs.realpathSync, readFile = fs.readFileSync,
+} = {}) {
+  if (invocation.npmCli) {
+    let engines = '';
+    try { engines = JSON.parse(readFile(path.join(path.dirname(path.dirname(invocation.npmCli)), 'package.json'), 'utf8')).engines?.node || ''; } catch (_) { /* nessun engines leggibile */ }
+    if (engines && !nodeRangeOk(nodeVersion, engines)) {
+      throw new Error(`npm richiede node ${engines} ma il demone esegue node ${nodeVersion}: aggiornamento annullato prima di installare`);
+    }
+  }
+  let globalRoot = '';
+  try {
+    globalRoot = String(execImpl(invocation.bin, [...invocation.argvPrefix, 'root', '-g'], { encoding: 'utf8', timeout: 20_000, env: invocation.env, stdio: ['ignore', 'pipe', 'pipe'] }) || '').trim();
+  } catch (e) { throw new Error(`npm root -g non riuscito (${redact(e && e.message, home).slice(0, 160)}): aggiornamento annullato prima di installare`); }
+  if (!globalRoot) throw new Error('npm root -g vuoto: aggiornamento annullato prima di installare');
+  const target = realpathSafe(path.join(globalRoot, PACKAGE_NAME), realpath);
+  const running = realpathSafe(packageRoot, realpath);
+  if (target !== running) {
+    throw new Error(`npm -g installerebbe in ${redact(target, home)} ma il processo esegue ${redact(running, home)} (installazione portatile, locale o node diverso): aggiornamento annullato prima di installare`);
+  }
+  return { globalRoot, packageRoot: running };
+}
+
+// Versione del pacchetto nel percorso ESEGUITO (realpath), con il percorso per il messaggio d'errore.
+function readInstalledFrom(root, { realpath = fs.realpathSync, readFile = fs.readFileSync } = {}) {
+  const real = realpathSafe(root, realpath);
+  return { path: real, version: JSON.parse(readFile(path.join(real, 'package.json'), 'utf8')).version };
+}
+
+module.exports = { redact, describeEnv, findNpmCli, nodeRangeOk, resolveNpmInvocation, npmPreflight, readInstalledFrom };