@mmmbuto/nexuscrew 0.9.52 → 0.9.53

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/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 };