@mmmbuto/nexuscrew 0.9.53 → 0.9.55

package/frontend/dist/index.html

@@ -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-DBlFdkZn.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-Da4oBb4f.css">
+  <script type="module" crossorigin src="/assets/index-H557UWX-.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-CvMkwRD1.css">
 </head>
 <body>
   <div id="root"></div>

package/frontend/dist/version.json

@@ -1 +1 @@
-{"version":"0.9.53"}
+{"version":"0.9.55"}

package/lib/cli/commands.js

@@ -957,8 +957,8 @@ function autoUpdateCommand(args, opts = {}) {
   const daFile = () => {
     try {
       const cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-      return cfg.autoUpdate !== false;
-    } catch (_) { return true; } // default ON, come la configurazione
+      return cfg.autoUpdate === true;
+    } catch (_) { return false; } // default OFF, come la configurazione
   };
 
   if (azione === 'status') {
@@ -974,7 +974,7 @@ function autoUpdateCommand(args, opts = {}) {
     }).then(async (r) => {
       if (!r.ok) throw new Error(`HTTP ${r.status}`);
       const j = await r.json();
-      const acceso = j.autoUpdate !== false;
+      const acceso = j.autoUpdate === true;
       log(`autoupdate: ${acceso ? 'on' : 'off'}`);
       if (j.update && j.update.latest) log(`  ultima versione vista su npm latest: ${j.update.latest}`);
       return { code: 0 };
@@ -988,8 +988,16 @@ function autoUpdateCommand(args, opts = {}) {
   if (!attivo) {
     // Servizio spento: si scrive il file, e si DICE che vale al prossimo avvio.
     // Tacerlo lascerebbe credere che abbia gia' effetto.
-    let cfg = {};
-    try { cfg = JSON.parse(fs.readFileSync(configPath, 'utf8')); } catch (_) { /* file nuovo */ }
+    // Se la config esiste ma non si legge, NON si riscrive: partire da un
+    // oggetto vuoto cancellerebbe le chiavi dell'operatore (wizardDone e le
+    // altre) per salvarne una sola. Motivo categorico, mai il messaggio del
+    // parser (contiene un estratto del file).
+    const letta = require('../config.js').readConfigForWrite(configPath);
+    if (!letta.ok) {
+      log(`autoupdate: config illeggibile ${letta.path} (${letta.motivo}) — non la riscrivo; ripara o rimuovi il file`);
+      return { code: 1 };
+    }
+    const cfg = letta.cfg;
     // Scrittura atomica e rifiuto dei symlink, come fa la route che scrive lo
     // stesso file: tmp nella stessa directory, 0600, rename. Un `writeFileSync`
     // diretto puo' lasciare un config.json troncato se il processo muore a

package/lib/cli/init.js

@@ -18,6 +18,7 @@ const {
   selectProviderModeSync, fleetFileMode,
 } = require('./fleet-service.js');
 const { resolveBootPaths } = require('./stable-alias.js');
+const { readConfigForWrite } = require('../config.js');
 const { aggiornaDefinizioni } = require('../fleet/definitions.js');
 const { defaultDefinitions } = require('../fleet/managed.js');
 const { commandExists, resolveCommand } = require('./path.js');
@@ -169,17 +170,26 @@ function runInit(opts = {}) {
       writeConfigAtomic(configPath, { port });
       actions.push(`created config ${configPath} (port ${port})`);
     } else {
-      let current;
-      try {
-        current = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-      } catch (_) { current = {}; }
-      if (opts.port) {
+      // Fail-closed come per fleet.json (vedi ensureFleetDefaults): un file
+      // PRESENTE ma illeggibile NON si riscrive. Riscriverlo con la sola porta
+      // cancellerebbe le chiavi dell'operatore (autoUpdate, wizardDone) e
+      // riporterebbe i default: e' il guasto osservato sulle macchine, dove
+      // l'opzione autoUpdate tornava a true da sola dopo essere stata spenta.
+      // La lettura e' la stessa usata dagli altri scrittori di config
+      // (readConfigForWrite): una sola regola, un solo motivo categorico.
+      const letta = readConfigForWrite(configPath);
+      const current = letta.ok ? letta.cfg : null;
+      const illeggibile = letta.ok ? null : letta.motivo;
+      if (!current) {
+        actions.push(`WARN: config illeggibile ${configPath} (${illeggibile}): non la riscrivo, il file resta com'e' (fail-closed)`);
+        if (opts.port) actions.push(`WARN: porta ${opts.port} non applicata alla config illeggibile`);
+      } else if (opts.port) {
         current.port = opts.port;
         port = opts.port;
         writeConfigAtomic(configPath, current);
         actions.push(`updated config ${configPath} (port ${port})`);
-      } else if (current && current.port) port = current.port;
-      actions.push(`preserved config ${configPath} (port ${port})`);
+      } else if (current.port) port = current.port;
+      if (current) actions.push(`preserved config ${configPath} (port ${port})`);
     }
   }
 

package/lib/config.js

@@ -81,7 +81,9 @@ function baseDefaults() {
     credentialsPath: path.join(os.homedir(), '.nexuscrew', 'credentials.json'),
     // Installazioni npm globali controllano periodicamente il dist-tag latest.
     // Il manager aggiorna solo verso una semver superiore: mai downgrade.
-    autoUpdate: true,
+    // SPENTO di default: chiave assente = false. Si accende da Impostazioni o
+    // con `nexuscrew autoupdate on`, e resta spento finche' non lo si accende.
+    autoUpdate: false,
     sessionPresets: {},
     // Ponte Live (fetta 3, rev5): isolabile — a false il ponte non si
     // connette mai e ogni avvio di Live resta sul comportamento standard.
@@ -147,6 +149,37 @@ function readConfigJson() {
   } catch (_) { return {}; }
 }
 
+// Lettura della config per una SCRITTURA (merge). Distingue tre casi, e i tre
+// non collassano in uno: chi scrive deve poter dire «assente» (legittimo: si
+// parte da zero) da «presente ma illeggibile» (mai partire da zero: si
+// perderebbero le chiavi dell'operatore, e i default tornerebbero — e' il
+// guasto per cui autoUpdate si riaccendeva da solo).
+// Il motivo e' una CATEGORIA fissa — 'parse-error', 'not-object',
+// 'read-error:<codice errno>' — MAI il messaggio del parser: su Node recenti
+// JSON.parse include un estratto dell'input, cioe' contenuto della config, e
+// questi messaggi finiscono in risposte HTTP e log.
+// -> { ok: true, cfg } | { ok: false, motivo, path }
+function readConfigForWrite(filePath, { fsImpl = fs } = {}) {
+  const target = filePath || configJsonPath();
+  let testo;
+  try {
+    testo = fsImpl.readFileSync(target, 'utf8');
+  } catch (e) {
+    if (e && e.code === 'ENOENT') return { ok: true, cfg: {} };   // assente: si parte da zero
+    return { ok: false, motivo: `read-error${e && e.code ? `:${e.code}` : ''}`, path: target };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(testo);
+  } catch (_) {
+    return { ok: false, motivo: 'parse-error', path: target };
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    return { ok: false, motivo: 'not-object', path: target };
+  }
+  return { ok: true, cfg: parsed };
+}
+
 // Override da env (precedence più alta di config.json).
 function envOverrides() {
   const e = {};
@@ -259,4 +292,4 @@ function defaults() {
   return { ...base, ...env, terminal: resolveTerminal(base, env) };
 }
 
-module.exports = { assertLoopback, baseDefaults, readConfigJson, loadConfig, defaults, LOOPBACK, configJsonPath, eventsEnabledFlag, readFederationEventsEnabled, TERMINAL_DEFAULTS, resolveTerminal };
+module.exports = { assertLoopback, baseDefaults, readConfigJson, readConfigForWrite, loadConfig, defaults, LOOPBACK, configJsonPath, eventsEnabledFlag, readFederationEventsEnabled, TERMINAL_DEFAULTS, resolveTerminal };

package/lib/fleet/identity-provision.js

@@ -10,6 +10,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
+const { readConfigForWrite } = require('../config.js');
 
 const CREDENTIAL_FILES = Object.freeze({
   identityDaemonCredential: 'daemon.credential',
@@ -61,6 +62,23 @@ function provisionIdentityAuthority({
   fsImpl = fs,
   now = new Date,
 } = {}) {
+  // PRIMA di qualunque scrittura (cartella compresa): se la config esiste ma
+  // non si legge, si rifiuta senza aver toccato NULLA. Motivo categorico, mai
+  // il messaggio del parser: contiene un estratto del file e finirebbe nel
+  // referto del comando.
+  const resolvedConfigPath = configPath
+    || (process.env.NEXUSCREW_CONFIG_FILE
+      || path.join(home || require('node:os').homedir(), '.nexuscrew', 'config.json'));
+  const lettaConfig = writeConfig
+    ? readConfigForWrite(resolvedConfigPath, { fsImpl })
+    : { ok: true, cfg: {} };
+  if (!lettaConfig.ok) {
+    return {
+      ok: false, code: 'CONFIG_UNREADABLE', dir: dir || defaultAuthorityDir(home),
+      message: `config illeggibile ${lettaConfig.path} (${lettaConfig.motivo}): non la riscrivo, niente e' stato scritto`,
+    };
+  }
+
   const targetDir = dir || defaultAuthorityDir(home);
   fsImpl.mkdirSync(targetDir, { recursive: true, mode: 0o700 });
 
@@ -104,18 +122,10 @@ function provisionIdentityAuthority({
   for (const filePath of written) fsImpl.chmodSync(filePath, 0o600);
   for (const filePath of written) assertSafeMode(filePath, 0o600);
 
-  const resolvedConfigPath = configPath
-    || (process.env.NEXUSCREW_CONFIG_FILE
-      || path.join(home || require('node:os').homedir(), '.nexuscrew', 'config.json'));
-
   let configUpdated = false;
   let configInstructions = null;
   if (writeConfig) {
-    let config = {};
-    try {
-      config = JSON.parse(fsImpl.readFileSync(resolvedConfigPath, 'utf8'));
-      if (!config || typeof config !== 'object' || Array.isArray(config)) config = {};
-    } catch (_) { config = {}; }
+    const config = lettaConfig.cfg;
     config.fleet = { ...(config.fleet || {}), identity: { ...(config.fleet?.identity || {}), mode: 'authority' } };
     fsImpl.mkdirSync(path.dirname(resolvedConfigPath), { recursive: true });
     fsImpl.writeFileSync(resolvedConfigPath, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });

package/lib/proxy/federation.js

@@ -1620,6 +1620,22 @@ function forwardUpgrade({ req, socket, head, nodesPath, localPort, localCredenti
     }
   }
   const up = net.connect({ host: '127.0.0.1', port });
+  // ECONNREFUSED sull'hop locale (tunnel che si riavvia) arriva PRIMA del
+  // 'connect': nel ramo hubMode il listener 'error' era registrato solo dentro
+  // up.once('connect', …) e l'evento restava senza gestore → Unhandled 'error'
+  // event → crash del processo (caduto 5 volte su un nodo Termux). Lo
+  // registriamo QUI, sincrono, prima che qualunque I/O possa fallire, valido
+  // per entrambi i rami. Idempotente con i listener registrati dopo il connect:
+  // destroy() e upstreamGone() sono gia' protetti da flag.
+  let heldRecord = null;
+  up.on('error', () => {
+    if (hubMode) {
+      if (heldRecord) hubAttaches.destroy(heldRecord);
+      else acceptWsThenClose(socket, req, 4402, 'upstream gone');
+    } else {
+      upstreamGone();
+    }
+  });
   // Osservatore NON consumante della testa di risposta dell'upstream: serve
   // solo a sapere se il 101 e' transitato (client in stato WebSocket) o se
   // l'hop e' morto prima. La pipe resta l'unico trasporto dei byte: il
@@ -1679,6 +1695,7 @@ function forwardUpgrade({ req, socket, head, nodesPath, localPort, localCredenti
       const record = hubAttaches.hold({
         attachId, tokenHash: tokenFingerprint(attachToken), route: attachRoute, session: attachSession, up,
       });
+      heldRecord = record;
       up.on('data', (chunk) => hubAttaches.feed(record, chunk));
       up.on('close', () => hubAttaches.destroy(record));
       up.on('error', () => hubAttaches.destroy(record));

package/lib/server.js

@@ -379,7 +379,7 @@ function createServer(opts = {}) {
   const updater = opts.updateManager || createNpmUpdater({
     currentVersion: VERSION,
     home: cfg.home || os.homedir(),
-    enabled: cfg.autoUpdate !== false,
+    enabled: cfg.autoUpdate === true,
     readonly: bridgeReadonly(),
     diagnostics,
     ...(cfg.updateSeams || {}),

package/lib/settings/routes.js

@@ -44,6 +44,7 @@ const crypto = require('node:crypto');
 const express = require('express');
 
 const nodesStore = require('../nodes/store.js');
+const { readConfigForWrite } = require('../config.js');
 const nodeAliases = require('../nodes/aliases.js');
 const { setConsent: setAudioConsent, isConsent: isAudioConsent } = require('../audio/consent.js');
 const { describeCapability } = require('../audio/capability.js');
@@ -285,7 +286,7 @@ function settingsRoutes(deps = {}) {
         platform,
         service,
         version: VERSION,
-        autoUpdate: updateStatus ? updateStatus.enabled : fileCfg.autoUpdate !== false,
+        autoUpdate: updateStatus ? updateStatus.enabled : fileCfg.autoUpdate === true,
         // Valore effettivo: l'env mantiene la precedenza sul file e il runtime
         // Fleet legge lo stesso oggetto cfg alla prossima creazione di cella.
         alternateScreen: cfg.alternateScreen === true,
@@ -360,8 +361,14 @@ function settingsRoutes(deps = {}) {
         return send(res, 400, { error: 'aiDesktop deve essere boolean' });
       }
 
-      // merge sul config esistente (preserva le chiavi non gestite qui)
-      const { cfg: current } = readConfigFile(configPath);
+      // merge sul config esistente (preserva le chiavi non gestite qui).
+      // Se il file ESISTE ma non si legge, NON si parte da un oggetto vuoto: si
+      // risponderebbe 200 avendo appena cancellato le chiavi dell'operatore.
+      const letta = readConfigForWrite(configPath);
+      if (!letta.ok) {
+        return send(res, 409, { error: 'config-unreadable', reason: letta.motivo, path: letta.path });
+      }
+      const current = letta.cfg;
       const next = { ...current };
       if (b.roles !== undefined) {
         const prev = (current.roles && typeof current.roles === 'object') ? current.roles : {};
@@ -387,7 +394,7 @@ function settingsRoutes(deps = {}) {
         saved: true,
         config: {
           roles: next.roles, port: next.port, wizardDone: next.wizardDone,
-          autoUpdate: next.autoUpdate !== false, alternateScreen: next.alternateScreen === true,
+          autoUpdate: next.autoUpdate === true, alternateScreen: next.alternateScreen === true,
         },
       };
       // Il server legge la porta SOLO allo startup: il cambio vale al prossimo
@@ -425,9 +432,12 @@ function settingsRoutes(deps = {}) {
     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);
+    const letta = readConfigForWrite(configPath);
+    if (!letta.ok) {
+      return send(res, 409, { error: 'config-unreadable', reason: letta.motivo, path: letta.path });
+    }
     try {
-      atomicWriteConfig(configPath, { ...cfgNow, aiDesktop: b.enabled });
+      atomicWriteConfig(configPath, { ...letta.cfg, aiDesktop: b.enabled });
     } catch (e) {
       return send(res, 500, { error: `config non salvata: ${e.message}` });
     }

package/lib/update/manager.js

@@ -59,7 +59,10 @@ function createNpmUpdater(opts = {}) {
   const intervalMs = opts.intervalMs === undefined ? DEFAULT_INTERVAL_MS : opts.intervalMs;
   const maxLogBytes = opts.maxLogBytes === undefined ? DEFAULT_MAX_LOG_BYTES : opts.maxLogBytes;
   const diagnostics = opts.diagnostics || null;
-  let enabled = opts.enabled !== false && !readonly;
+  // Spento se non richiesto esplicitamente: l'unico chiamante di produzione
+  // passa `enabled: cfg.autoUpdate === true`, quindi la chiave assente non
+  // avvia il daemon. Stesso criterio di setEnabled (`value === true`).
+  let enabled = opts.enabled === true && !readonly;
   let checking = null;
   let timer = null;
   let state = readState(statusPath);

package/package.json

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