@mmmbuto/nexuscrew 0.9.52 → 0.9.54

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

package/frontend/dist/version.json

@@ -1 +1 @@
-{"version":"0.9.52"}
+{"version":"0.9.54"}

package/lib/cli/commands.js

@@ -22,12 +22,21 @@ const nodesCmds = require('../nodes/commands.js');
 const peering = require('../nodes/peering.js');
 // Service/portable runtime ownership + start/stop lifecycle (Phase 3 extraction).
 const runtimeLifecycle = require('./runtime-lifecycle.js');
+const { withStartLock } = require('../update/start-lock.js');
+const { portMessage } = require('./messages.js');
 const {
-  start, stop, isServiceRunning, bootState, stopManagedTunnels, fermaTunnelPrimaDiRiavviare,
+  start: startUnlocked, stop, isServiceRunning, bootState, stopManagedTunnels, fermaTunnelPrimaDiRiavviare,
   managedRuntimeState, portableRuntimeState, resolveRuntimeOwner,
   refusePairedPortRelocation, stopPortableRuntime, unlinkRegular,
 } = runtimeLifecycle;
 
+// Lock di avvio condiviso (boot/show/start/restart/runner): serializza chi EMETTE un avvio, mai chi attende la salute.
+// Rientrante nello stesso processo; scadenza e proprietario verificato in lib/update/start-lock.js.
+function locked(label, opts, fn) {
+  return withStartLock(fn, { home: opts.home, label, waitMs: opts.startLockWaitMs, ttlMs: opts.startLockTtlMs });
+}
+function start(opts = {}) { return locked('start', opts, () => startUnlocked(opts)); }
+
 const HELP = `NexusCrew — PWA for local and remote AI workers.
 
 Usage:
@@ -158,7 +167,9 @@ function serve(opts = {}) {
     }
     pidf.cleanStale(pidPath);
     const cmd = [process.execPath].concat(process.argv.slice(1)).join(' ');
-    pidf.writePidfile(pidPath, process.pid, cmd);
+    // La porta entra nel pidfile: chi trova la porta occupata riconosce il PROPRIO processo (e sa su quale porta era).
+    let servedPort; try { servedPort = Number(opts.port || urlmod.loadPort(opts)); } catch (_) { servedPort = undefined; }
+    pidf.writePidfile(pidPath, process.pid, cmd, Number.isInteger(servedPort) ? { port: servedPort } : {});
     const cleanup = () => pidf.removePidfile(pidPath);
     process.on('SIGINT', () => { cleanup(); process.exit(0); });
     process.on('SIGTERM', () => { cleanup(); process.exit(0); });
@@ -310,7 +321,8 @@ function status(opts = {}) {
 }
 
 // restart per-platform (shared da token rotate / update). execImpl per test.
-function restart(opts = {}) {
+function restart(opts = {}) { return locked('restart', opts, () => restartUnlocked(opts)); }
+function restartUnlocked(opts = {}) {
   const platform = opts.platform || detectPlatform();
   const execImpl = opts.execImpl || execFileSync;
   const log = opts.log || console.log;
@@ -575,13 +587,29 @@ async function probeNexusCrew(port, token, opts = {}) {
 // spiegare un riavvio ha bisogno di distinguerle, altrimenti dichiara fallito
 // un riavvio riuscito e manda a cercare un processo morto che e' vivo.
 // Rilievo della revisione: il caso token-assente era gia' coperto, questo no.
+// Chiede al nodo un id dispositivo per il link che sta per aprire/stampare. Best-effort: senza risposta il link
+// resta quello di sempre (il client ne chiedera' uno da se').
+async function issueDeviceId(port, token, opts = {}) {
+  if (typeof opts.deviceIdImpl === 'function') { try { return await opts.deviceIdImpl(port, token); } catch (_) { return null; } }
+  const fetchImpl = opts.fetchImpl || globalThis.fetch;
+  if (!token || typeof fetchImpl !== 'function') return null;
+  try {
+    const r = await fetchImpl(`http://127.0.0.1:${port}/api/prefs/devices`, {
+      method: 'POST', headers: { authorization: `Bearer ${token}` }, signal: AbortSignal.timeout?.(1500),
+    });
+    if (r.status !== 201) return null;
+    const j = await r.json();
+    return typeof j.deviceId === 'string' ? j.deviceId : null;
+  } catch (_) { return null; }
+}
+
 async function probeNexusCrewStatus(port, token, opts = {}) {
   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?.(700),
+      signal: AbortSignal.timeout?.(opts.probeTimeoutMs || 700),
     });
     return r.status;
   } catch (_) { return null; } // nessuna risposta: e' un altro guasto
@@ -598,7 +626,8 @@ async function waitForNexusCrew(port, token, opts = {}) {
   return false;
 }
 
-function startPortable(opts = {}) {
+function startPortable(opts = {}) { return locked('start', opts, () => startPortableUnlocked(opts)); }
+function startPortableUnlocked(opts = {}) {
   const spawnImpl = opts.spawnImpl || spawn;
   const home = opts.home || require('node:os').homedir();
   const existing = portableRuntimeState({ home });
@@ -670,6 +699,23 @@ function openPwa(fullUrl, opts = {}) {
 
 // Normal entry point. It is deliberately quiet and returns after starting the
 // background service. Only first-run opens the wizard; `show` always opens it.
+// Porta occupata all'avvio: decide senza mai muovere la porta. 200 (anche lento) = il nodo c'e'; 401/403 = un
+// NexusCrew che non accetta questo token; nessuna risposta = o e' il nostro processo che sta partendo (si attende)
+// o e' un altro processo. Ogni esito negativo e' un errore chiaro; una porta diversa la sceglie l'utente (--port).
+async function settleBusyPort(port, token, runtime, opts = {}) {
+  const status = await (opts.probeStatusImpl || probeNexusCrewStatus)(port, token, { ...opts, probeTimeoutMs: opts.patientProbeMs || 3000 });
+  if (status === 200) return true;
+  if (status === 401 || status === 403) {
+    throw new Error(portMessage('busy-token', { port }, { lang: opts.lang }));
+  }
+  if (runtime && runtime.owner !== 'stopped') {
+    const waited = await waitForNexusCrew(port, token, { ...opts, waitAttempts: opts.busyWaitAttempts || 100, waitDelayMs: opts.busyWaitDelayMs || 100 });
+    if (waited) return true;
+    throw new Error(portMessage('busy-own-slow', { port }, { lang: opts.lang }));
+  }
+  throw new Error(portMessage('busy-other', { port }, { lang: opts.lang }));
+}
+
 async function smartUp(opts = {}) {
   const quiet = opts.lifecycleLog || (() => {});
   const platform = opts.platform || detectPlatform();
@@ -756,11 +802,10 @@ async function smartUp(opts = {}) {
 
   if (!running) {
     if (!(await (opts.portAvailableImpl || portAvailable)(port, '127.0.0.1'))) {
-      const previousPort = port;
-      port = await findAvailablePort(port + 1, opts);
-      refusePairedPortRelocation(opts, previousPort, port);
-      runInitImpl({ ...opts, port, log: quiet, platform, installBoot: persistent, printUrl: false });
-      token = urlmod.readToken(tokenPath);
+      // La porta e' occupata e il probe rapido (700 ms) non ha avuto 200: NON e' una prova che il nodo sia spento
+      // (telefono lento, nodo sotto carico). Mai spostare la porta ne' riscrivere config.json da qui: un nodo che
+      // cambia porta cambia origin e la PWA installata perde token e preferenze.
+      running = await settleBusyPort(port, token, runtime, opts);
     } else {
       try {
         runtime = resolveRuntimeOwner({ ...opts, platform });
@@ -776,7 +821,7 @@ async function smartUp(opts = {}) {
         portableStart({ ...opts, platform }); portableAttempted = true;
       }
     }
-    running = await waitForNexusCrew(port, token, opts);
+    if (!running) running = await waitForNexusCrew(port, token, opts);
     if (!running && !portableAttempted) {
       try { portableStart({ ...opts, platform }); portableAttempted = true; } catch (_) {}
       running = await waitForNexusCrew(port, token, opts);
@@ -785,7 +830,10 @@ async function smartUp(opts = {}) {
   }
 
   const shouldOpen = !opts.noOpen && (!!opts.forceOpen || !wizardComplete(configPath));
-  if (shouldOpen) openPwa(urlmod.buildUrl(port, token, { withToken: true }), { ...opts, platform });
+  if (shouldOpen) {
+    const deviceId = await issueDeviceId(port, token, opts);
+    openPwa(urlmod.buildUrl(port, token, { withToken: true, deviceId }), { ...opts, platform });
+  }
   return { platform, initialized, running, opened: shouldOpen, port, url: urlmod.buildUrl(port, null) };
 }
 
@@ -940,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
@@ -1389,9 +1445,10 @@ function dispatch(argv, opts = {}) {
   }
   if (cmd === 'show') {
     if (rest[1] === 'token') {
-      return smartUp({ ...opts, noOpen: true, log: opts.lifecycleLog || (() => {}) }).then((r) => {
+      return smartUp({ ...opts, noOpen: true, log: opts.lifecycleLog || (() => {}) }).then(async (r) => {
         const { tokenPath } = urlmod.resolvePaths(opts); const token = urlmod.readToken(tokenPath);
-        log(urlmod.buildUrl(r.port, token, { withToken: true })); return { code: 0 };
+        const deviceId = await issueDeviceId(r.port, token, opts);
+        log(urlmod.buildUrl(r.port, token, { withToken: true, deviceId })); return { code: 0 };
       });
     }
     if (rest[1]) { log('usage: nexuscrew show [token]'); return { code: 1 }; }

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/cli/messages.js

@@ -0,0 +1,55 @@
+'use strict';
+// Messaggi per chi sta al terminale (o legge il log del servizio) quando la porta e' occupata. Il nodo NON si sposta
+// piu' da solo su un'altra porta: dev'essere chiaro cosa fare. Lingue: it, en, es. Se la lingua non si puo'
+// determinare (servizio senza LANG) escono tutte e tre, una per riga: cosi' si legge comunque.
+const LANGS = ['it', 'en', 'es'];
+
+const WHY = {
+  en: 'A new port is a new address: the installed app would lose its token and settings.',
+  it: 'Una porta nuova è un indirizzo nuovo: l\'app installata perderebbe token e impostazioni.',
+  es: 'Un puerto nuevo es una dirección nueva: la app instalada perdería el token y los ajustes.',
+};
+
+const CATALOG = {
+  'busy-other': {
+    en: ({ port }) => `Port ${port} is in use by another process. The node does not move to another port on its own. ${WHY.en} Free port ${port}, or choose another one explicitly: nexuscrew init --port <N>.`,
+    it: ({ port }) => `La porta ${port} è occupata da un altro processo. Il nodo non passa da solo a un'altra porta. ${WHY.it} Libera la porta ${port}, oppure scegline un'altra in modo esplicito: nexuscrew init --port <N>.`,
+    es: ({ port }) => `El puerto ${port} está ocupado por otro proceso. El nodo no cambia de puerto por su cuenta. ${WHY.es} Libera el puerto ${port} o elige otro de forma explícita: nexuscrew init --port <N>.`,
+  },
+  'busy-paired': {
+    en: ({ port }) => `Port ${port} is busy and paired peers exist: refusing automatic port change (the peers point at this port). Free port ${port}, or choose another one explicitly and re-pair the peers: nexuscrew init --port <N>.`,
+    it: ({ port }) => `La porta ${port} è occupata e ci sono nodi accoppiati: cambio automatico di porta rifiutato (i nodi puntano a questa porta). Libera la porta ${port}, oppure scegline un'altra in modo esplicito e riaccoppia i nodi: nexuscrew init --port <N>.`,
+    es: ({ port }) => `El puerto ${port} está ocupado y hay nodos emparejados: cambio automático de puerto rechazado (los nodos apuntan a este puerto). Libera el puerto ${port} o elige otro de forma explícita y vuelve a emparejar los nodos: nexuscrew init --port <N>.`,
+  },
+  'busy-token': {
+    en: ({ port }) => `Port ${port} answers as a NexusCrew node that rejects this token. The port is not changed. Check ~/.nexuscrew/token or the instance running there.`,
+    it: ({ port }) => `La porta ${port} risponde come un nodo NexusCrew che rifiuta questo token. La porta non viene cambiata. Controlla ~/.nexuscrew/token o l'istanza che gira lì.`,
+    es: ({ port }) => `El puerto ${port} responde como un nodo NexusCrew que rechaza este token. El puerto no se cambia. Revisa ~/.nexuscrew/token o la instancia que corre allí.`,
+  },
+  'busy-own-slow': {
+    en: ({ port }) => `The NexusCrew process on port ${port} is running but does not answer yet. The port is not changed. Retry in a moment (nexuscrew show) or check the log (nexuscrew logs).`,
+    it: ({ port }) => `Il processo NexusCrew sulla porta ${port} è avviato ma non risponde ancora. La porta non viene cambiata. Riprova fra poco (nexuscrew show) o controlla il log (nexuscrew logs).`,
+    es: ({ port }) => `El proceso NexusCrew en el puerto ${port} está en marcha pero aún no responde. El puerto no se cambia. Reintenta en un momento (nexuscrew show) o revisa el log (nexuscrew logs).`,
+  },
+};
+
+// NEXUSCREW_LANG, poi LC_ALL, LC_MESSAGES, LANG: la prima variabile impostata decide; se non e' it/en/es -> 'all'.
+function pickLang(env = process.env) {
+  for (const name of ['NEXUSCREW_LANG', 'LC_ALL', 'LC_MESSAGES', 'LANG']) {
+    const value = String(env[name] || '').trim();
+    if (!value || value === 'C' || value === 'POSIX' || /^C\./.test(value)) continue;
+    const base = value.slice(0, 2).toLowerCase();
+    return LANGS.includes(base) ? base : 'all';
+  }
+  return 'all';
+}
+
+function portMessage(key, params, { lang, env } = {}) {
+  const entry = CATALOG[key];
+  if (!entry) throw new Error(`messaggio sconosciuto: ${key}`);
+  const chosen = lang || pickLang(env);
+  if (chosen === 'all') return ['en', 'it', 'es'].map((l) => entry[l](params)).join('\n');
+  return (entry[chosen] || entry.en)(params);
+}
+
+module.exports = { LANGS, pickLang, portMessage };

package/lib/cli/url.js

@@ -46,9 +46,13 @@ function loadPort(opts = {}) {
 }
 
 // URL loopback. withToken=true e token presente -> aggiunge #token=… (mai altrove).
-function buildUrl(port, token, { withToken = false } = {}) {
+// deviceId (opzionale, 32 hex emesso dal nodo): identifica il profilo di preferenze del dispositivo che apre il
+// link. Viaggia solo accanto al token e mai da solo.
+function buildUrl(port, token, { withToken = false, deviceId } = {}) {
   const base = `http://127.0.0.1:${port}/`;
-  return withToken && token ? `${base}#token=${token}` : base;
+  if (!(withToken && token)) return base;
+  const device = typeof deviceId === 'string' && /^[a-f0-9]{32}$/.test(deviceId) ? `&device=${deviceId}` : '';
+  return `${base}#token=${token}${device}`;
 }
 
 // QR ASCII del testo. Generazione locale (qrcode-terminal), callback sincrona.

package/lib/config.js

@@ -147,6 +147,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 +290,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/notify/ask-answer-service.js

@@ -45,6 +45,7 @@ function createAskAnswerService({ asks, paste, receipts, onClosure, labelPrefix
       // for a paste that never happened.
       if (request && receipts) receipts.finalize(request.peerId, askId, request.requestId, 'failed', `refused:${claim.reason}`);
       if (claim.reason === 'unknown') return { ok: false, code: 404, error: 'ask inesistente', reason: 'unknown' };
+      if (claim.reason === 'store-unreadable') return { ok: false, code: 503, error: 'store delle ask illeggibile: risposta non accettata', reason: 'store-unreadable' };
       if (claim.reason === 'dismissed') return { ok: false, code: 409, error: 'ask gia\' scartato (dismissed)', reason: 'dismissed' };
       if (claim.reason === 'answering') return { ok: false, code: 409, error: 'risposta gia\' in corso da un\'altra richiesta', reason: 'answering' };
       return { ok: false, code: 409, error: 'ask gia\' risposto', reason: 'answered' };

package/lib/notify/asks.js

@@ -6,7 +6,7 @@
 // claim -> (paste) -> commit/release (da revisione: una sola answer puo' vincere).
 const path = require('node:path');
 const crypto = require('node:crypto');
-const { readJsonSafe, atomicWriteJson } = require('./persist.js');
+const { readJsonStrict, atomicWriteJson } = require('./persist.js');
 
 const ASKS_FILE = 'asks.json';
 // da revisione: MAX_OPEN e' un cap DURO sugli ask aperti — al cap il nuovo ask viene
@@ -28,17 +28,56 @@ function createAsksStore(opts = {}) {
   const now = opts.now || (() => Date.now());
 
   // Carica lazy al primo accesso (niente I/O in createServer per i path reali).
+  // Tre esiti:
+  //  - leggibile (assente => [], oppure oggetto con `asks` array => filtrato per
+  //    id stringa): si CACHEA come oggi, perche' e' uno stato legittimo e stabile.
+  //  - illeggibile (JSON malformato, oppure oggetto senza `asks` o con `asks`
+  //    non array): NON si cachea. Ogni accesso rilegge il file, cosicche' se
+  //    l'operatore ripara asks.json lo store torna sano senza riavvio. I reader
+  //    (list/get/openCount/findImported) vedono [] — le superfici LOCALI non
+  //    cambiano comportamento — mentre le MUTAZIONI rifiutano (v. unreadableGuard)
+  //    per non sovrascrivere il file malformato con un defaults vuoto, che
+  //    cancellerebbe le domande aperte.
   let asks = null;
   function load() {
     if (asks) return asks;
-    const cur = readJsonSafe(filePath);
-    asks = Array.isArray(cur.asks)
-      ? cur.asks.filter((a) => a && typeof a === 'object' && typeof a.id === 'string')
-      : [];
-    return asks;
+    const r = readJsonStrict(filePath);
+    if (r.state === 'absent') { asks = []; return asks; }
+    if (r.state === 'ok' && Array.isArray(r.value.asks)) {
+      asks = r.value.asks.filter((a) => a && typeof a === 'object' && typeof a.id === 'string');
+      return asks;
+    }
+    // illeggibile: NON cacheare (reload al prossimo accesso se il file viene riparato).
+    return [];
+  }
+
+  // Health leggibile dal produttore dello snapshot: distingue un vuoto
+  // LEGITTIMO (store leggibile, nessuna domanda aperta) da un vuoto NON
+  // autorevole (store illeggibile). Non muta stato.
+  function health() {
+    if (asks) return { readable: true };
+    const r = readJsonStrict(filePath);
+    if (r.state === 'absent') return { readable: true };
+    if (r.state === 'ok' && Array.isArray(r.value.asks)) return { readable: true };
+    const reason = r.state === 'malformed'
+      ? r.reason
+      : `forma invalida: 'asks' non e' un array (${r.value && r.value.asks !== undefined ? typeof r.value.asks : 'assente'})`;
+    return { readable: false, reason };
+  }
+
+  // Null se lo store e' leggibile (e le mutazioni possono procedere), altrimenti
+  // la reason. Si usa all'inizio di ogni mutazione: uno store illeggibile non
+  // viene MAI scritto, cosi' il file malformato non viene sovrascritto.
+  function unreadableGuard() {
+    if (asks) return null;
+    const h = health();
+    return h.readable ? null : (h.reason || 'store-unreadable');
   }
 
   function save() {
+    // Difensivo: mai sovrascrivere uno store illeggibile. Le mutazioni hanno
+    // gia' il guard, ma questo impedisce un overwrite se una via lo saltasse.
+    if (unreadableGuard()) return;
     // prune: mai piu' di MAX_KEEP; si scartano prima gli answered piu' vecchi.
     const list = load();
     if (list.length > MAX_KEEP) {
@@ -90,6 +129,8 @@ function createAsksStore(opts = {}) {
   // riga resta nello storico marcata, quindi non ricompare a un reload e non
   // torna risponibile.
   function closeImported({ ownerId, ownerAskId, outcome }) {
+    const ur = unreadableGuard();
+    if (ur) return { ok: false, reason: 'store-unreadable', changed: false, ask: null };
     const ask = findImported(ownerId, ownerAskId);
     if (!ask) return { ok: true, changed: false, ask: null };
     if (ask.answered || ask.dismissed) return { ok: true, changed: false, ask };
@@ -101,6 +142,8 @@ function createAsksStore(opts = {}) {
   }
 
   function create({ question, options, session, ownerId, ownerAskId, originNode, originCell }) {
+    const ur = unreadableGuard();
+    if (ur) return { ok: false, reason: 'store-unreadable', error: `store illeggibile (${ur}): creazione rifiutata` };
     const v = validate({ question, options });
     if (!v.ok) return { ok: false, reason: 'invalid', error: v.error };
     // DEDUP: la stessa domanda puo' arrivare due volte allo stesso nodo (import
@@ -174,6 +217,8 @@ function createAsksStore(opts = {}) {
   const answering = new Set();
 
   function claim(id) {
+    const ur = unreadableGuard();
+    if (ur) return { ok: false, reason: 'store-unreadable' };
     const ask = get(id);
     if (!ask) return { ok: false, reason: 'unknown' };
     // Un ask dismissato non e' piu' risponibile: senza questa guardia la
@@ -197,6 +242,8 @@ function createAsksStore(opts = {}) {
 
   // Commit: paste riuscito -> answered persistito, claim rilasciato.
   function commit(id, text) {
+    const ur = unreadableGuard();
+    if (ur) return false;
     const ask = get(id);
     answering.delete(id);
     if (!ask || ask.answered) return false;
@@ -214,6 +261,8 @@ function createAsksStore(opts = {}) {
   // volte non e' un errore. Un ask dismissato non e' piu' open (non appare in
   // list({open:true})/openCount) ma resta nello storico (list({open:false})).
   function dismiss(id) {
+    const ur = unreadableGuard();
+    if (ur) return { ok: false, reason: 'store-unreadable' };
     const ask = get(id);
     if (!ask) return { ok: false, reason: 'unknown' };
     if (answering.has(id)) return { ok: false, reason: 'answering' };
@@ -230,6 +279,8 @@ function createAsksStore(opts = {}) {
   // `allow-new-attempt` leaves it open. Both advance the revision, so the token
   // the operator reconciled with can never be reused on the same generation.
   function markReconciled(id, decision) {
+    const ur = unreadableGuard();
+    if (ur) return { ok: false, reason: 'store-unreadable' };
     const ask = get(id);
     if (!ask) return { ok: false, reason: 'unknown' };
     answering.delete(id);
@@ -250,7 +301,7 @@ function createAsksStore(opts = {}) {
     return commit(id, text);
   }
 
-  return { create, get, list, openCount, isImported, findImported, closeImported, claim, release, commit, markAnswered, markReconciled, isAnswering, dismiss, validate, filePath, MAX_OPEN, MAX_OPEN_IMPORTED };
+  return { create, get, list, openCount, isImported, findImported, closeImported, claim, release, commit, markAnswered, markReconciled, isAnswering, dismiss, validate, health, filePath, MAX_OPEN, MAX_OPEN_IMPORTED };
 }
 
 module.exports = { createAsksStore };