npm - @mmmbuto/nexuscrew - Versions diffs - 0.9.5 → 0.9.7 - Mend

@mmmbuto/nexuscrew 0.9.5 → 0.9.7

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 (16) hide show

package/CHANGELOG.md +97 -0
package/frontend/dist/assets/index-DDAwkwKR.css +32 -0
package/frontend/dist/assets/index-YpDRVy-I.js +93 -0
package/frontend/dist/index.html +2 -2
package/frontend/dist/version.json +1 -1
package/lib/cli/init.js +22 -2
package/lib/cli/service.js +11 -3
package/lib/cli/stable-alias.js +117 -0
package/lib/nodes/pubkey-format.js +69 -0
package/lib/nodes/tunnel-supervisor.js +14 -17
package/lib/nodes/tunnel.js +66 -12
package/lib/settings/pairing-coordinator.js +10 -4
package/lib/settings/routes.js +11 -0
package/package.json +1 -1
package/frontend/dist/assets/index-BUbgwJsU.js +0 -93
package/frontend/dist/assets/index-BzmGsXBy.css +0 -32

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-BUbgwJsU.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-BzmGsXBy.css">
+  <script type="module" crossorigin src="/assets/index-YpDRVy-I.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-DDAwkwKR.css">
 </head>
 <body>
   <div id="root"></div>

package/frontend/dist/version.json CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":"0.9.5"}
1	+ {"version":"0.9.7"}

package/lib/cli/init.js CHANGED Viewed

@@ -17,6 +17,7 @@ const {
   generateFleetService, installFleetService, migrationGate,
   selectProviderModeSync, fleetFileMode,
 } = require('./fleet-service.js');
+const { resolveBootPaths } = require('./stable-alias.js');
 const { aggiornaDefinizioni } = require('../fleet/definitions.js');
 const { defaultDefinitions } = require('../fleet/managed.js');
 const { commandExists, resolveCommand } = require('./path.js');
@@ -234,6 +235,17 @@ function runInit(opts = {}) {
     port, home, uid: uid(),
     installPath: opts.installPath,
   };
+  // 1-bis (R23): la STESSA classe di difetto del companion di boot — nodeBin
+  // e entry finiscono versionati nell'unit/plist del servizio per-nodo. Si
+  // risolve qui, alla scrittura, e si dichiara cio' che non ha alias stabile:
+  // i due punti di scrittura non devono divergere (correggerne uno solo
+  // lascerebbe il difetto vivo).
+  const svcBoot = resolveBootPaths({
+    nodeBin: svcCtx.nodeBin,
+    entryPath: path.join(svcCtx.repoRoot, 'bin', 'nexuscrew.js'),
+  });
+  svcCtx.nodeBin = svcBoot.nodeBin;
+  svcCtx.entryPath = svcBoot.entryPath;
   const content = generateService(platform, svcCtx);
   if (!installBoot) {
@@ -250,6 +262,7 @@ function runInit(opts = {}) {
       : 'tmux non trovato su PATH (installa tmux)';
     actions.push(`WARN: ${reason} -> service NON installato (ri-runna init)`);
   } else {
+    for (const w of svcBoot.warnings) actions.push(`WARN service: ${w}`);
     try {
       const r = installService(platform, content, svcCtx, { execImpl: opts.execImpl });
       if (r.failures && r.failures.length) {
@@ -301,10 +314,17 @@ function runInit(opts = {}) {
         } else if (dryRun) {
           actions.push('DRY-RUN fleet companion generato, NON installato');
         } else {
+          // R23: i path del boot si risolvono alla SCRITTURA del servizio (mai
+          // a ogni avvio): un alias stabile che risolva allo stesso file, se
+          // c'e'; altrimenti il path attuale, DICHIARATO — un avviso adesso e'
+          // meglio di un path che scade in silenzio (vedi stable-alias.js).
+          const bootEntry = path.join(svcCtx.repoRoot, 'bin', 'nexuscrew.js');
+          const boot = resolveBootPaths({ nodeBin: svcCtx.nodeBin, entryPath: bootEntry });
+          for (const w of boot.warnings) actions.push(`WARN fleet companion: ${w}`);
           const fleetContent = generateFleetService({
             platform,
-            nodeBin: svcCtx.nodeBin,
-            entryPath: path.join(svcCtx.repoRoot, 'bin', 'nexuscrew.js'),
+            nodeBin: boot.nodeBin,
+            entryPath: boot.entryPath,
             repoRoot: svcCtx.repoRoot,
             home,
           });

package/lib/cli/service.js CHANGED Viewed

@@ -53,6 +53,14 @@ function assertSystemdSafe(label, p) {
 // --- Templates ---
+// Entry del servizio: di norma derivato da repoRoot; i punti di scrittura
+// che risolvono l'alias stabile (R23/1-bis, stable-alias.js) passano
+// l'entryPath gia' risolto. Contratto vecchio intatto: senza entryPath si
+// deriva da repoRoot come prima.
+function serviceEntryPath(ctx) {
+  return ctx.entryPath || path.join(ctx.repoRoot, 'bin', 'nexuscrew.js');
+}
 function generateService(platform, ctx) {
   if (platform === 'linux') return generateLinux(ctx);
   if (platform === 'mac') return generateMac(ctx);
@@ -70,7 +78,7 @@ function generateLinux(ctx) {
   assertSystemdSafe('home', ctx.home);
   const runtime = escapeSystemdPath(ctx.home);
   const node = escapeSystemdExec(ctx.nodeBin);
-  const repoBin = escapeSystemdExec(path.join(ctx.repoRoot, 'bin', 'nexuscrew.js'));
+  const repoBin = escapeSystemdExec(serviceEntryPath(ctx));
   const nodeDir = escapeSystemdPath(path.dirname(ctx.nodeBin));
   return `# NexusCrew service (systemd --user, loopback, solo tunnel SSH/VPN)
 [Unit]
@@ -96,7 +104,7 @@ WantedBy=default.target
 function generateMac(ctx) {
   const nodeXml = escapeXml(ctx.nodeBin);
-  const repoBinXml = escapeXml(path.join(ctx.repoRoot, 'bin', 'nexuscrew.js'));
+  const repoBinXml = escapeXml(serviceEntryPath(ctx));
   // HOME remains stable when init or repair atomically replaces the runtime
   // directory; launchd must not retain an unlinked runtime-directory cwd.
   const runtimeXml = escapeXml(ctx.home);
@@ -146,7 +154,7 @@ function generateMac(ctx) {
 function generateTermux(ctx) {
   const nodeQ = shellQuote(ctx.nodeBin);
-  const repoBinQ = shellQuote(path.join(ctx.repoRoot, 'bin', 'nexuscrew.js'));
+  const repoBinQ = shellQuote(serviceEntryPath(ctx));
   return `#!/data/data/com.termux/files/usr/bin/sh
 # NexusCrew boot (Termux) - loopback, localhost del telefono
 export PATH=/data/data/com.termux/files/usr/bin:$PATH

package/lib/cli/stable-alias.js ADDED Viewed

@@ -0,0 +1,117 @@
+'use strict';
+// R23 — alias stabili per i path del servizio di boot.
+//
+// Il companion di boot scrive nodeBin e entryPath LETTERALMENTE nel plist
+// launchd (ProgramArguments[0]) e nell'unit systemd (ExecStart=). Quei path
+// possono essere VERSIONATI:
+//   node  -> /opt/homebrew/Cellar/node/<ver>/bin/node   (Homebrew)
+//            ~/.nvm/versions/node/<ver>/bin/node        (nvm)
+//   entry -> ~/.nvm/versions/node/<ver>/lib/node_modules/<pkg>/bin/nexuscrew.js
+// Homebrew rompe all'upgrade (sostituisce il Cellar), nvm rompe a
+// `nvm uninstall` della vecchia versione: il servizio punta a un file che non
+// esiste piu' e la cella non parte, con un sintomo confuso (il node c'e', il
+// file no — o viceversa).
+//
+// La cura, per CIASCUNO dei due path: fra candidati noti, cercare un alias
+// stabile che risolva (realpath) allo STESSO IDENTICO FILE che sta girando.
+// Se c'e', scrivere quello; se no, scrivere il path attuale e DICHIARARLO:
+// un avviso alla scrittura e' meglio di un path che scade in silenzio.
+//
+// Tre vincoli non negoziabili (briefing R23):
+// 1. La verifica «e' lo stesso file» si fa alla SCRITTURA del servizio, MAI a
+//    ogni avvio: dopo l'upgrade il symlink DEVE puntare a un node diverso —
+//    e' l'effetto voluto. Un controllo di identita' permanente si
+//    autoannullerebbe.
+// 2. Su nvm NON esiste un alias stabile (~/.nvm/current non c'e',
+//    ~/.nvm/alias/default e' un file di testo, `command -v node` risolve al
+//    path versionato): qui il risolutore non trova nulla e il ramo che conta
+//    e' quello che lo dichiara. Non inventare un alias nvm.
+// 3. Il PATH del plist che include /opt/homebrew/bin NON e' una protezione:
+//    ProgramArguments[0] e' assoluto. Non contarci.
+const fs = require('node:fs');
+const path = require('node:path');
+// Prefissi stabili noti (ordinati per probabilita'), senza $PREFIX che viene
+// aggiunto solo se presente (Termux).
+const STABLE_ROOTS = ['/opt/homebrew', '/usr/local', '/usr'];
+function rootsWithPrefix(env = process.env) {
+  const roots = [...STABLE_ROOTS];
+  if (env && env.PREFIX) roots.push(env.PREFIX);
+  return roots;
+}
+// Candidati stabili per il BINARIO node. Almeno tre per costruzione —
+// requisito del briefing: con uno solo «prova tutti i candidati» e «prova il
+// primo» coincidono.
+function nodeAliasCandidates(env = process.env) {
+  const c = rootsWithPrefix(env).map((r) => path.join(r, 'bin', 'node'));
+  return [...new Set(c)];
+}
+// Candidati stabili per l'ENTRY del pacchetto. Il suffisso dopo node_modules/
+// (es. '@mmmbuto/nexuscrew/bin/nexuscrew.js') e' DERIVATO dal path che sta
+// girando, non inventato: se il path non attraversa un node_modules (checkout
+// di sviluppo) non ci sono candidati e il risolutore dichiarera' il path
+// attuale — un checkout di sviluppo non scade, ma l'avviso e' il prezzo
+// dell'onestà.
+function entryAliasCandidates(entryPath, env = process.env) {
+  if (!entryPath || typeof entryPath !== 'string') return [];
+  const marker = `${path.sep}node_modules${path.sep}`;
+  const i = entryPath.lastIndexOf(marker);
+  if (i < 0) return [];
+  const rel = entryPath.slice(i + marker.length);
+  if (!rel) return [];
+  const c = rootsWithPrefix(env).map((r) => path.join(r, 'lib', 'node_modules', rel));
+  return [...new Set(c)];
+}
+// Risolutore: { path, alias, warning }.
+//   alias    — il candidato scelto (realpath === realpath del path attuale),
+//              oppure null se nessuno risolve allo stesso file;
+//   path     — l'alias se trovato, altrimenti il path attuale intatto;
+//   warning  — null se trovato, altrimenti la dichiarazione scritta.
+// realpathImpl e' iniettabile per i test deterministici; di default
+// fs.realpathSync. Un candidato assente si salta (realpath lancia): l'assenza
+// non e' un errore, e' solo un candidato in meno.
+function resolveStableAlias(currentPath, candidates, opts = {}) {
+  const realpathImpl = typeof opts.realpath === 'function' ? opts.realpath : fs.realpathSync;
+  let currentReal = null;
+  try { currentReal = realpathImpl(currentPath); } catch (_) { currentReal = null; }
+  for (const cand of Array.isArray(candidates) ? candidates : []) {
+    let candReal;
+    try { candReal = realpathImpl(cand); } catch (_) { continue; } // assente: avanti
+    if (currentReal !== null && candReal === currentReal) {
+      return { path: cand, alias: cand, warning: null };
+    }
+  }
+  return {
+    path: currentPath,
+    alias: null,
+    warning: `nessun alias stabile per ${currentPath}: il servizio punta al path attuale; se l'installazione cambia (upgrade/uninstall di node) il path scade — rilancia l'installazione per rigenerare il servizio`,
+  };
+}
+// Composizione per il servizio di boot: risolve ENTRAMBI i path (node ed
+// entry) e raccoglie le dichiarazioni. E' il punto che il flusso di
+// installazione chiama alla SCRITTURA del servizio (vincolo 1: mai a ogni
+// avvio). `env` e `realpath` iniettabili per test.
+function resolveBootPaths({ nodeBin, entryPath, env = process.env, realpath } = {}) {
+  const opts = {};
+  if (typeof realpath === 'function') opts.realpath = realpath;
+  const node = resolveStableAlias(nodeBin, nodeAliasCandidates(env), opts);
+  const entry = resolveStableAlias(entryPath, entryAliasCandidates(entryPath, env), opts);
+  return {
+    nodeBin: node.path,
+    entryPath: entry.path,
+    warnings: [node.warning, entry.warning].filter((w) => w !== null),
+  };
+}
+module.exports = {
+  nodeAliasCandidates,
+  entryAliasCandidates,
+  resolveStableAlias,
+  resolveBootPaths,
+};

package/lib/nodes/pubkey-format.js ADDED Viewed

@@ -0,0 +1,69 @@
+'use strict';
+// Un SOLO formatter al confine UI/log per gli esiti del resolver della
+// pubblica (job 5, strutturale). Prima le frasi si componevano in basso —
+// nel supervisor e nella route — dove non si sa abbastanza per scriverle:
+// meta' della 0.9.5 e' nata cosi' (promesse false, cause enumerate «a caso»,
+// silenzi). Ora il resolver produce DATI enumerati (resolvePublicKey in
+// tunnel.js) e QUESTO punto unico li trasforma in frasi. Un test per ogni
+// causa.
+const path = require('node:path');
+const {
+  PUBKEY_DERIVED, PUBKEY_NO_IDENTITY, PUBKEY_ACTUAL_KEY_UNKNOWN,
+  PUBKEY_TOOL_UNAVAILABLE, PUBKEY_ENCRYPTED_OR_UNREADABLE,
+} = require('./tunnel.js');
+// La frase della CAUSA per ogni esito — il «perche'» che chi guarda deve
+// leggere. `resolution` e' il dato del risolutore; `identityFile` il path
+// dichiarato, per nominare l'oggetto giusto. Non inventare mai una causa che
+// il dato non porta: l'ignosciuto si dice sconosciuto, non si indovina.
+function pubkeyCauseText(resolution, { identityFile } = {}) {
+  const nome = identityFile ? path.basename(identityFile) : null;
+  switch (resolution && resolution.outcome) {
+    case PUBKEY_DERIVED:
+      // Nessuna causa da dichiarare: la riga c'e'.
+      return null;
+    case PUBKEY_NO_IDENTITY:
+      return `la chiave dichiarata${nome ? ` (${nome})` : ''} non esiste dove dovrebbe`;
+    case PUBKEY_ACTUAL_KEY_UNKNOWN:
+      return 'nessun -i: ssh usa le chiavi di default, un agent o la config, e da qui non si sa quale';
+    case PUBKEY_TOOL_UNAVAILABLE:
+      return 'ssh-keygen non e\' disponibile su questa macchina: la pubblica non si puo\' derivare';
+    case PUBKEY_ENCRYPTED_OR_UNREADABLE:
+      return `non riesco a derivare la pubblica da ${nome || 'quella chiave'}: e' cifrata o illeggibile`;
+    default:
+      // Al confine, l'ignosciuto si NOMINA: un silenzio qui sarebbe lo stesso
+      // difetto che questo modulo chiude.
+      return `esito non riconosciuto: ${resolution && resolution.outcome}`;
+  }
+}
+// L'AZIONE suggerita per ogni esito — il «cosa fare» accanto al perche'.
+// Aspettare non serve dove bisogna concedere; riprovare non serve dove la
+// condizione dipende da una decisione altrove.
+function pubkeyActionText(resolution) {
+  switch (resolution && resolution.outcome) {
+    case PUBKEY_DERIVED:
+      return 'sostituisci la riga in ~/.ssh/authorized_keys del nodo con questa';
+    case PUBKEY_NO_IDENTITY:
+      return 'verifica il path della chiave dichiarata per questo nodo';
+    case PUBKEY_ACTUAL_KEY_UNKNOWN:
+      return 'individua la chiave che ssh usa davvero e modifica A MANO la sua riga';
+    case PUBKEY_TOOL_UNAVAILABLE:
+      return 'installa ssh-keygen (openssh-client), poi riprova';
+    case PUBKEY_ENCRYPTED_OR_UNREADABLE:
+      return 'usa una chiave dedicata non cifrata per questo nodo, o modifica A MANO la riga';
+    default:
+      return 'verifica la configurazione del nodo';
+  }
+}
+// La nota del pairing quando la riga c'e': il testo che accompagnava la
+// risposta, ora composto qui (l'unico punto) e non nella route.
+function pubkeyPairingNote(resolution, { panelPort } = {}) {
+  if (!resolution || resolution.outcome !== PUBKEY_DERIVED) return null;
+  return 'il peer ha un pannello sulla propria porta ' + panelPort
+    + ': SOSTITUISCI la riga già installata in ~/.ssh/authorized_keys del NODO con questa (due destinazioni), altrimenti il canale del pannello sarà rifiutato. È la riga della chiave DICHIARATA per questo nodo (-i), non un\'eventuale chiave "jump" dello stesso nodo. Se ssh sceglie un\'altra identità (agent o config), la riga giusta è quella della chiave che usa davvero.';
+}
+module.exports = { pubkeyCauseText, pubkeyActionText, pubkeyPairingNote };

package/lib/nodes/tunnel-supervisor.js CHANGED Viewed

@@ -178,28 +178,24 @@ function probeForwardChannels({ ports, graceMs = CHANNEL_GRACE_MS, connect = net
 // A MANO della riga esistente, mostrando solo le destinazioni da aggiungere.
 function refusalDetails({ remoteDestinations, identityFile } = {}) {
   const dests = (remoteDestinations || []).join('",permitopen="');
-  const pub = require('./tunnel.js').readPublicKey(identityFile);
+  // Esito enumerato (resolver) + frase composta al confine UI/log — il punto
+  // unico pubkey-format. Prima qui si sceglieva fra cause che non si potevano
+  // distinguere e le si enumerava «a caso»; ora il dato distingue, e il
+  // testo dice la causa ESATTA: mai inventarne una che il dato non porta.
+  const resolution = require('./tunnel.js').resolvePublicKey(identityFile);
+  const { pubkeyCauseText, pubkeyActionText } = require('./pubkey-format.js');
   const premessa = 'canale rifiutato dal NODO remoto: la chiave in ~/.ssh/authorized_keys non autorizza queste destinazioni.';
-  if (!pub) {
-    // Due situazioni diverse, e il messaggio non deve confonderle — ne'
-    // inventare una causa che non conosce. Senza `-i` la chiave non e'
-    // dichiarata affatto. Con `-i`, la derivazione dalla privata puo' fallire
-    // per piu' motivi (privata assente o illeggibile, protetta da passphrase,
-    // `ssh-keygen` non disponibile) e da qui non si distinguono: si elencano,
-    // invece di sceglierne uno a caso. Dire «la parte pubblica non e'
-    // leggibile» a chi ha una chiave cifrata col suo `.pub` accanto e' falso,
-    // e manda a cercare il problema dove non e'.
-    const causa = identityFile
-      ? `non riesco a derivare la chiave pubblica da ${path.basename(identityFile)}`
-        + ' (privata assente o illeggibile, protetta da passphrase, oppure ssh-keygen non disponibile)'
-      : 'nessun -i: ssh usa le chiavi di default, un agent o la config, e da qui non si sa quale';
+  if (resolution.outcome !== require('./tunnel.js').PUBKEY_DERIVED) {
+    const causa = pubkeyCauseText(resolution, { identityFile });
+    const azione = pubkeyActionText(resolution);
     return {
-      hint: `${premessa} NON posso identificare la chiave da correggere — ${causa}`
-        + `. Modifica A MANO la riga di quella chiave aggiungendo queste destinazioni: permitopen="${dests}"`,
+      hint: `${premessa} NON posso identificare la chiave da correggere — ${causa}. ${azione}`
+        + `: aggiungi queste destinazioni: permitopen="${dests}"`,
       authorizedKeys: '',
+      outcome: resolution.outcome,
     };
   }
-  const riga = `restrict,port-forwarding,permitopen="${dests}",command="/bin/false" ${pub}`;
+  const riga = `restrict,port-forwarding,permitopen="${dests}",command="/bin/false" ${resolution.line}`;
   // NON diciamo «quella con cui il supervisor si autentica»: `-i` DICHIARA
   // un'identita', non la impone — senza `IdentitiesOnly=yes` OpenSSH puo'
   // comunque usare l'agent o la config, e il canale essere autenticato da
@@ -209,6 +205,7 @@ function refusalDetails({ remoteDestinations, identityFile } = {}) {
   return {
     hint: `${premessa} Riga da usare (SOSTITUISCI quella esistente, non aggiungerne una seconda)${quale}: ${riga}`,
     authorizedKeys: riga,
+    outcome: resolution.outcome,
   };
 }

package/lib/nodes/tunnel.js CHANGED Viewed

@@ -732,8 +732,37 @@ function authorizedKeysLine({ remotePort, panelRemotePort, pub } = {}) {
 // Torna null se la privata non e' leggibile, e' protetta da passphrase (in
 // batch non si puo' sbloccare) o `ssh-keygen` non c'e': senza poterla derivare
 // non si compone nessuna riga.
-function readPublicKey(identityFile, impl = {}) {
-  if (!identityFile || typeof identityFile !== 'string') return null;
+// Esiti ENUMERATI della derivazione della pubblica (difetto strutturale
+// registrato dall'auditor: `null | stringa` comprimeva stati DIVERSI, e il
+// livello basso componeva frasi su fatti che non conosce — meta' della 0.9.5
+// e' nata li'). Gli esiti sono DATI, senza testo per l'utente: le frasi si
+// compongono al confine UI/log, mai qui. Si aggancia a P4: una chiave cifrata
+// dava `null`, indistinguibile da «file illeggibile», e il pairing ometteva
+// la riga in silenzio.
+//
+//   derived                 — pubblica derivata; `line` e' la riga
+//   no-identity             — identityFile dichiarata ma il file NON esiste
+//   actual-key-unknown      — identityFile non dichiarata: la chiave che ssh
+//                             usera' DAVVERO (default, agent, config) non e'
+//                             sapibile da qui; nessun altro canale ripara
+//   tool-unavailable        — ssh-keygen assente sulla macchina
+//   encrypted-or-unreadable — ssh-keygen non riesce sul file (cifrata,
+//                             permessi, formato) o l'output non e' una riga
+//                             pubblica valida
+const PUBKEY_DERIVED = 'derived';
+const PUBKEY_NO_IDENTITY = 'no-identity';
+const PUBKEY_ACTUAL_KEY_UNKNOWN = 'actual-key-unknown';
+const PUBKEY_TOOL_UNAVAILABLE = 'tool-unavailable';
+const PUBKEY_ENCRYPTED_OR_UNREADABLE = 'encrypted-or-unreadable';
+function resolvePublicKey(identityFile, impl = {}) {
+  if (!identityFile || typeof identityFile !== 'string' || identityFile.trim() === '') {
+    return { outcome: PUBKEY_ACTUAL_KEY_UNKNOWN };
+  }
+  const existsImpl = impl.existsSync || require('node:fs').existsSync;
+  if (!existsImpl(identityFile)) {
+    return { outcome: PUBKEY_NO_IDENTITY, path: identityFile };
+  }
   const exec = impl.execImpl || require('node:child_process').execFileSync;
   // Timeout iniettabile (test): il default 5000 ms e' la RETE, non il
   // meccanismo — il meccanismo e' l'ambiente controllato qui sotto.
@@ -757,7 +786,7 @@ function readPublicKey(identityFile, impl = {}) {
     // chiave cifrata (misurato: 0.11 s contro gli 8 s dell'attesa su tty) e
     // non puo' lasciare helper. Un path inesistente vince su /bin/false: su
     // Termux i binari stanno sotto $PREFIX, e un path assoluto sbagliato e'
-    // una scommessa.
+    // una scommessa; e non `setsid`, che su macOS non esiste.
     // LIMITE DA SAPERE: SSH_ASKPASS_REQUIRE esiste da OpenSSH 8.4. Le versioni
     // piu' vecchie lo ignorano e tornano al tty: li' il timeout qui sopra
     // resta come rete — il degrado e' «lento», non «appeso».
@@ -770,14 +799,32 @@ function readPublicKey(identityFile, impl = {}) {
         SSH_ASKPASS: path.join(process.env.HOME || os.homedir(), '.nexuscrew', 'askpass-inesistente'),
       },
     });
-  } catch (_) { return null; }   // assente, passphrase, privata illeggibile
+  } catch (e) {
+    // ENOENT dello SPAWN = il binario ssh-keygen non esiste: un'altra causa
+    // rispetto al file che non si deriva, e chi compone il messaggio deve
+    // poterle distinguere (prima erano lo stesso null).
+    if (e && e.code === 'ENOENT') return { outcome: PUBKEY_TOOL_UNAVAILABLE };
+    return { outcome: PUBKEY_ENCRYPTED_OR_UNREADABLE };
+  }
   const righe = String(out || '').split('\n').filter((r) => r.trim() !== '');
-  if (righe.length !== 1) return null;
+  if (righe.length !== 1) return { outcome: PUBKEY_ENCRYPTED_OR_UNREADABLE };
   const riga = righe[0].trim();
-  if (/[\u0000-\u0008\u000b-\u001f\u007f]/.test(riga)) return null;
+  if (riga.length === 0 || /[\u0000-\u0008\u000b-\u001f\u007f]/.test(riga)) {
+    return { outcome: PUBKEY_ENCRYPTED_OR_UNREADABLE };
+  }
   const campi = riga.split(/[ \t]+/);
-  if (campi.length < 2 || !/^[A-Za-z0-9+/]+={0,2}$/.test(campi[1])) return null;
-  return riga;
+  if (campi.length < 2 || !/^[A-Za-z0-9+/]+={0,2}$/.test(campi[1])) {
+    return { outcome: PUBKEY_ENCRYPTED_OR_UNREADABLE };
+  }
+  return { outcome: PUBKEY_DERIVED, line: riga };
+}
+// Contratto storico (supervisor e chiamanti esistenti): null | stringa.
+// Sopra resolvePublicKey per gli esiti enumerati; questo resta per chi
+// compone ancora sul contratto vecchio — il confine UI/log migrera'.
+function readPublicKey(identityFile, impl = {}) {
+  const r = resolvePublicKey(identityFile, impl);
+  return r.outcome === PUBKEY_DERIVED ? r.line : null;
 }
 // La riga per UN nodo, dal nodo. Sta qui e non nella route perche' la stessa
@@ -796,14 +843,21 @@ function readPublicKey(identityFile, impl = {}) {
 // provisionare un'identita' per peer — lavoro suo, non un ramo di questa
 // funzione.
 function authorizedKeysForNode(nodo, panelRemotePort) {
-  const pub = readPublicKey(nodo && nodo.identityFile);
-  if (!pub) return null;
-  return authorizedKeysLine({ remotePort: nodo.remotePort, panelRemotePort, pub });
+  // Esito enumerato, non piu' null|stringa: chi risponde (pairing) porta il
+  // DATO fino al confine, e li' — non qui — si compone cio' che si dice.
+  const r = resolvePublicKey(nodo && nodo.identityFile);
+  if (r.outcome !== PUBKEY_DERIVED) return { outcome: r.outcome, line: null };
+  return {
+    outcome: r.outcome,
+    line: authorizedKeysLine({ remotePort: nodo.remotePort, panelRemotePort, pub: r.line }),
+  };
 }
 module.exports = {
   SSH_BASE_OPTS,
-  authorizedKeysLine, readPublicKey, authorizedKeysForNode,
+  authorizedKeysLine, readPublicKey, resolvePublicKey, authorizedKeysForNode,
+  PUBKEY_DERIVED, PUBKEY_NO_IDENTITY, PUBKEY_ACTUAL_KEY_UNKNOWN,
+  PUBKEY_TOOL_UNAVAILABLE, PUBKEY_ENCRYPTED_OR_UNREADABLE,
   buildForwardArgs, buildReverseArgs, backoffDelay,
   tunnelDir, tunnelPidPath, tunnelLogPath, tunnelStatePath, readTunnelState,
   prepareTunnelDir, openTunnelLog,

package/lib/settings/pairing-coordinator.js CHANGED Viewed

@@ -423,11 +423,17 @@ function createPairHandler(deps) {
       }
       send(res, 200, {
         paired: true, name: b.name, instanceId: joined.instanceId, transport: 'auto', health: { status: health.status },
-        ...(authorizedKeysPayload ? {
-          authorizedKeys: authorizedKeysPayload,
-          authorizedKeysNote: 'il peer ha un pannello sulla propria porta ' + peerPanelPort
-            + ': SOSTITUISCI la riga già installata in ~/.ssh/authorized_keys del NODO con questa (due destinazioni), altrimenti il canale del pannello sarà rifiutato. È la riga della chiave DICHIARATA per questo nodo (-i), non un\'eventuale chiave "jump" dello stesso nodo. Se ssh sceglie un\'altra identità (agent o config), la riga giusta è quella della chiave che usa davvero.',
+        ...(authorizedKeysPayload && authorizedKeysPayload.outcome === 'derived' ? {
+          authorizedKeys: authorizedKeysPayload.line,
+          // La nota si compone al confine UI/log (pubkey-format), non qui.
+          authorizedKeysNote: require('../nodes/pubkey-format.js')
+            .pubkeyPairingNote(authorizedKeysPayload, { panelPort: peerPanelPort }),
         } : {}),
+        // Esito enumerato come DATO (resolver a cinque esiti): prima una
+        // chiave cifrata era indistinguibile da «file illeggibile» e la riga
+        // spariva in silenzio. Il confine UI/log compone le frasi su questo;
+        // qui si porta il fatto, non il testo.
+        ...(authorizedKeysPayload ? { authorizedKeysOutcome: authorizedKeysPayload.outcome } : {}),
       });
     } catch (e) {
       await rollback();

package/lib/settings/routes.js CHANGED Viewed

@@ -57,6 +57,7 @@ const {
 } = require('../proxy/federation.js');
 const { rotateToken } = require('../auth/token.js');
 const { generateService, installService, installPath: svcInstallPath } = require('../cli/service.js');
+const { resolveBootPaths } = require('../cli/stable-alias.js');
 const { detectPlatform, nodeBin, repoRoot, uid } = require('../cli/platform.js');
 const { isServiceRunning, readRoles, bootState } = require('../cli/commands.js');
 const { configJsonPath } = require('../config.js');
@@ -993,6 +994,15 @@ function settingsRoutes(deps = {}) {
         uid: seams.uid || uid(),
         installPath: seams.serviceInstallPath,
       };
+      // 1-bis (R23): come in init — il path del boot si risolve alla
+      // scrittura e cio' che non ha alias stabile torna DICHIARATO. Le
+      // warnings sono DATI nella risposta, non testo composto qui.
+      const svcBoot = resolveBootPaths({
+        nodeBin: ctx.nodeBin,
+        entryPath: path.join(ctx.repoRoot, 'bin', 'nexuscrew.js'),
+      });
+      ctx.nodeBin = svcBoot.nodeBin;
+      ctx.entryPath = svcBoot.entryPath;
       const content = generateService(platform, ctx);
       const out = installService(platform, content, ctx, { activate: false });
       send(res, 200, {
@@ -1000,6 +1010,7 @@ function settingsRoutes(deps = {}) {
         target: out.target,
         note: 'unit rigenerata; nessun restart automatico — riavvia il service per applicarla',
         skippedActivation: out.skippedActivation,
+        warnings: svcBoot.warnings,
       });
     } catch (e) { send(res, 500, { error: String(e.message || e) }); }
   });

package/package.json CHANGED Viewed

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