@mmmbuto/nexuscrew 0.8.57 → 0.9.0

package/lib/fleet/cell-exec.js

@@ -19,6 +19,11 @@ const DEFAULT_SUPERVISE = Object.freeze({
   maxRapidRestarts: 8,
 });
 
+// F-B (audit 2a, correzione escalation): limite ESPLICITO fra SIGTERM e
+// SIGKILL quando la lease e' persa (onLost, main()). Un figlio che ignora
+// SIGTERM non deve restare appeso a tempo indeterminato.
+const LEASE_LOST_KILL_ESCALATION_MS = 5000;
+
 function parseArgs(argv) {
   const out = {};
   for (let i = 0; i < argv.length; i += 2) {
@@ -75,24 +80,40 @@ function validRestartPrompt(value) {
     && (value.readyWaitMs === undefined || validInteger(value.readyWaitMs, 0, 120000));
 }
 
+function validLease(value) {
+  if (value === undefined) return true;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  // 2b (A2): la capability statica e' revocata e non esiste piu' nel payload.
+  // Il proof supervisore NON transita qui: arriva sul canale lease dal server.
+  if (Object.keys(value).some((k) => !['cellId', 'launchEpoch', 'stablePath'].includes(k))) return false;
+  return (value.cellId === undefined || (typeof value.cellId === 'string' && value.cellId.length > 0 && value.cellId.length <= 128))
+    && typeof value.launchEpoch === 'string' && value.launchEpoch.length > 0 && value.launchEpoch.length <= 128
+    && typeof value.stablePath === 'string' && value.stablePath.length > 0 && value.stablePath.length <= 4096;
+}
+
 function validPayload(payload) {
   if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return false;
-  if (Object.keys(payload).some((key) => !['command', 'args', 'env', 'supervise', 'restartPrompt'].includes(key))) return false;
+  if (Object.keys(payload).some((key) => !['command', 'args', 'env', 'supervise', 'restartPrompt', 'lease'].includes(key))) return false;
   if (typeof payload.command !== 'string' || !payload.command || !Array.isArray(payload.args)) return false;
   if (!payload.env || typeof payload.env !== 'object' || Array.isArray(payload.env)) return false;
   return payload.args.every((v) => typeof v === 'string')
     && Object.entries(payload.env).every(([k, v]) => /^[A-Za-z_][A-Za-z0-9_]{0,63}$/.test(k) && typeof v === 'string')
     && validSupervise(payload.supervise)
-    && validRestartPrompt(payload.restartPrompt);
+    && validRestartPrompt(payload.restartPrompt)
+    && validLease(payload.lease);
 }
 
-function receivePayload(socketPath, nonce, timeoutMs = 5000) {
+function receivePayload(socketPath, nonce, timeoutMs = 5000, opts = {}) {
   return new Promise((resolve, reject) => {
     const socket = net.createConnection(socketPath);
     let data = Buffer.alloc(0); let expected = null; let done = false;
     const finish = (error, payload) => {
-      if (done) return; done = true; socket.destroy();
-      if (error) reject(error); else resolve(payload);
+      if (done) return; done = true;
+      if (error) { socket.destroy(); reject(error); return; }
+      // R3.1.1 (opt-in): keepOpen restituisce il socket APERTO al caller (broker
+      // lease); il caller lo passa al lease-client. Default: destroy (one-shot).
+      if (opts.keepOpen) { resolve({ payload, socket }); return; }
+      socket.destroy(); resolve(payload);
     };
     socket.setTimeout(timeoutMs, () => finish(new Error('launch broker timed out')));
     socket.once('connect', () => socket.write(`${JSON.stringify({ nonce })}\n`));
@@ -256,7 +277,14 @@ function startGenerationPrompt(config, generation, childState, seams = {}) {
 async function main(argv = process.argv.slice(2), seams = {}) {
   const parsed = parseArgs(argv);
   if (!parsed) throw new Error('usage: cell-exec --socket <path> --nonce <hex>');
-  const payload = await (seams.receivePayload || receivePayload)(parsed.socketPath, parsed.nonce);
+  const received = await (seams.receivePayload || receivePayload)(parsed.socketPath, parsed.nonce, 5000, { keepOpen: true });
+  // Compat: il seam di test puo' restituire un payload direttamente; la forma
+  // produttiva restituisce { payload, socket } con socket APERTO (broker lease).
+  const payload = received && typeof received === 'object' && received.payload ? received.payload : received;
+  const leaseSocket = received && typeof received === 'object' && received.socket ? received.socket : null;
+  // Se il payload non porta lease (cella non-ospite), rilascia subito il socket
+  // broker: niente canale lease, e il supervisore non deve trattenere il loop.
+  if (!payload.lease && leaseSocket) { try { leaseSocket.destroy(); } catch (_) {} }
   const supervise = normalizeSupervise(payload.supervise);
   const spawnImpl = seams.spawn || spawn;
   const now = seams.now || Date.now;
@@ -269,7 +297,58 @@ async function main(argv = process.argv.slice(2), seams = {}) {
   if (process.env.TMUX) childEnv.TMUX = process.env.TMUX;
   if (process.env.TMUX_PANE) childEnv.TMUX_PANE = process.env.TMUX_PANE;
 
+  // R3.1.2: nessun bearer di lease transita al child. childEnv deriva SOLO da
+  // payload.env (piu' TMUX); payload.lease (cellId/launchEpoch/stablePath) resta
+  // nel supervisore e alimenta il lease-client. spawnImpl passa env + stdio
+  // inherit. Il proof (2b) vive nel lease-client, MAI nell'env del child.
+  let generation = 0;
+  let leaseCtl = null;
+  // F-B (audit 2a): current/stopping vivono QUI (prima del lease-client) perche'
+  // la callback onLost qui sotto li riferisce dalla closure.
   let current = null; let stopping = false;
+  if (payload.lease && leaseSocket && !leaseSocket.destroyed) {
+    const { startLeaseClient } = require('./lease-client.js');
+    leaseCtl = startLeaseClient(leaseSocket, {
+      stablePath: payload.lease.stablePath,
+      launchEpoch: payload.lease.launchEpoch,
+      // R3.3.4: la generation AVANZA coi restart del supervisore (loop sotto,
+      // generation += 1). Passiamo un getter cosicche' il reconnect presenti
+      // sempre la generation corrente, non 0 fisso (riconcilia :301 con :381).
+      generation: () => generation,
+      // F-B (audit 2a @ 142e272): lease persa per tutta la grace senza un
+      // reconnect riuscito. Prima il lease-client desisteva in silenzio dopo
+      // 60s e il child restava un orfano senza lease per tutta la sua vita.
+      // Ora il supervisore viene avvisato: ferma il child (stopping + SIGTERM)
+      // e il main loop termina con lui — mai un child vivo oltre la lease.
+      //
+      // Correzione (seconda riconsegna): un SOLO SIGTERM senza escalation
+      // lascia appeso un child che lo ignora (misurato sul percorso reale:
+      // {spawned:1, kills:['SIGTERM'], state:'pending'}) — l'orfano non NASCE
+      // piu' (F-B originale chiuso davvero), ma un figlio gia' vivo che non
+      // collabora non muore. LEASE_LOST_KILL_ESCALATION_MS e' il limite
+      // ESPLICITO, scritto qui: se il child non e' uscito entro questa
+      // finestra dal SIGTERM, si passa a SIGKILL. `target` fissa il processo
+      // di QUESTA generazione: se nel frattempo e' gia' uscito (current
+      // azzerato a null dal loop principale dopo waitChild), l'escalation e'
+      // no-op — mai un kill fantasma su un pid riusato.
+      onLost: () => {
+        writeError('nexuscrew cell supervisor stopped: lease lost (reconnect grace expired)\n');
+        stopping = true;
+        const target = current;
+        try { if (target) target.kill('SIGTERM'); } catch (_) {}
+        if (target) {
+          const escalate = seams.setTimeout || setTimeout;
+          const timer = escalate(() => {
+            if (current === target) {
+              try { target.kill('SIGKILL'); } catch (_) {}
+            }
+          }, LEASE_LOST_KILL_ESCALATION_MS);
+          if (timer && typeof timer.unref === 'function') timer.unref();
+        }
+      },
+    }, seams);
+  }
+
   const handlers = new Map();
   for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP']) {
     const handler = () => {
@@ -283,7 +362,6 @@ async function main(argv = process.argv.slice(2), seams = {}) {
     for (const [signal, handler] of handlers) proc.off?.(signal, handler);
   };
 
-  let generation = 0;
   let delayMs = supervise.restartDelayMs;
   let rapid = [];
   try {
@@ -343,7 +421,7 @@ async function main(argv = process.argv.slice(2), seams = {}) {
       delayMs = Math.min(supervise.maxRestartDelayMs, Math.max(supervise.restartDelayMs, delayMs * 2));
       generation += 1;
     }
-  } finally { cleanup(); }
+  } finally { if (leaseCtl) { try { leaseCtl.stop(); } catch (_) {} } cleanup(); }
 }
 
 if (require.main === module) {
@@ -353,6 +431,6 @@ if (require.main === module) {
 }
 
 module.exports = {
-  DEFAULT_SUPERVISE, parseArgs, validSupervise, validRestartPrompt, validPayload,
+  DEFAULT_SUPERVISE, LEASE_LOST_KILL_ESCALATION_MS, parseArgs, validSupervise, validRestartPrompt, validPayload, validLease,
   receivePayload, sanitizeSpawnError, normalizeSupervise, waitChild, startGenerationPrompt, main,
 };