@mmmbuto/nexuscrew 0.9.63 → 0.9.64

package/lib/mcp/cells.js

@@ -100,12 +100,49 @@ function parseCellTarget(value) {
   return NODE_ID_RE.test(instanceId) && CELL_ID_RE.test(cell) ? { instanceId, cell } : null;
 }
 
+const LIVE_MODES = new Set(['native', 'tmux']);
+const LIVE_STATES = new Set(['present', 'active', 'tmux']);
+const LIVE_REASONS = new Set(['live-not-addressable', 'tmux-mode']);
+
+function normalizeLiveEntry(raw, owner, route) {
+  if (raw.instanceId !== owner.instanceId || raw.cell !== 'Live'
+    || !LIVE_MODES.has(raw.mode) || !LIVE_STATES.has(raw.state)) return null;
+  return {
+    id: `${owner.instanceId}:Live`,
+    instanceId: owner.instanceId,
+    owner: owner.label,
+    route,
+    cell: 'Live',
+    kind: 'live',
+    label: 'Live',
+    labelReported: false,
+    mode: raw.mode,
+    state: raw.state,
+    reason: LIVE_REASONS.has(raw.reason) ? raw.reason : 'live-not-addressable',
+    engine: '',
+    model: '',
+    active: raw.active === true,
+    // Not receivable until a dedicated delivery exists.
+    canReceive: false,
+    lastSeen: Number.isFinite(raw.lastSeen) ? raw.lastSeen : null,
+    self: false,
+  };
+}
+
 function normalizeCellPayload(payload, owner, callerSession = null) {
   if (!payload || payload.instanceId !== owner.instanceId || !Array.isArray(payload.cells)) return [];
   const route = owner.route.length ? owner.route.join('/') : 'local';
   const seen = new Set();
   const out = [];
   for (const raw of payload.cells) {
+    if (raw && raw.kind === 'live') {
+      // The Live is not a cell: it has no tmux session. A federated payload is
+      // untrusted, so the entry is rebuilt from known values only and is never
+      // receivable, whatever the peer says.
+      const live = normalizeLiveEntry(raw, owner, route);
+      if (live && !seen.has('\0live')) { seen.add('\0live'); out.push(live); }
+      continue;
+    }
     if (!raw || raw.instanceId !== owner.instanceId || !CELL_ID_RE.test(String(raw.cell || ''))
       || typeof raw.tmuxSession !== 'string' || !isValidSession(raw.tmuxSession)
       || seen.has(raw.cell)) continue;

package/lib/mcp/server.js

@@ -255,6 +255,11 @@ function createMcpServer(opts = {}) {
   // (config.json + env NEXUSCREW_CONFIG_FILE/PORT/TOKEN_FILE). opts.config per test.
   const cfg = opts.config || loadConfig();
   const baseUrl = `http://127.0.0.1:${cfg.port}`;
+  // The Live declares the reference of its own thread; the server decides
+  // whether the declaration holds (registry, host cell, live thread). A value
+  // that is not a well-formed reference is never sent.
+  const liveRefRaw = typeof env.NEXUSCREW_MCP_LIVE_THREAD === 'string' ? env.NEXUSCREW_MCP_LIVE_THREAD.trim() : '';
+  const liveThreadHeader = /^[a-f0-9]{32}$/.test(liveRefRaw) ? { 'x-nexuscrew-live-thread': liveRefRaw } : {};
 
   // Identita' locale storica: risolta una volta e cacheata — ma solo se riesce.
   //
@@ -375,6 +380,7 @@ function createMcpServer(opts = {}) {
           authorization: `Bearer ${token}`,
           ...signed,
           ...identityBinding,
+          ...liveThreadHeader,
           ...(payload !== undefined ? { 'content-type': 'application/json' } : {}),
         },
         ...(payload !== undefined ? { body: payload } : {}),
@@ -389,7 +395,7 @@ function createMcpServer(opts = {}) {
     return j;
   }
 
-  // NC-R. Aggiornare NexusCrew NON cambia il codice gia' caricato dai bridge
+  // Aggiornare NexusCrew NON cambia il codice gia' caricato dai bridge
   // MCP delle celle attive: ogni processo resta sulla versione con cui e' stato
   // avviato fino al riavvio della cella. Dopo una correzione installata, un
   // bridge ancora attivo puo' quindi restituire l'errore precedente; prima di

package/lib/mcp/tools.js

@@ -656,6 +656,7 @@ const TOOLS = [
       const target = directory.cells.find((cell) => cell.instanceId === targetRef.instanceId
         && cell.cell === targetRef.cell);
       if (!target) throw new Error('nc_cell_diagnostics: cella locale non trovata');
+      if (target.kind === 'live') throw new Error('nc_cell_diagnostics: la Live non e\' una cella e non ha diagnostica');
 
       const [definitions, diagnostics] = await Promise.all([
         ctx.api('GET', '/api/fleet/definitions'), recentDiagnostics(ctx),
@@ -712,6 +713,11 @@ const TOOLS = [
       const target = directory.cells.find((cell) => cell.instanceId === targetRef.instanceId
         && cell.cell === targetRef.cell);
       if (!target) throw new Error(cellLookupFailure(directory, targetRef));
+      // The Live is addressable by id but has no delivery yet: say so, and never
+      // let the message land on its host cell or any other.
+      if (target.kind === 'live') {
+        throw new Error(`live-not-addressable: la Live non riceve ancora messaggi da nc_send_cell (${target.reason || 'live-not-addressable'}); nessun messaggio inviato`);
+      }
       if (!target.canReceive) throw new Error('cella destinataria non attiva; nessun messaggio accodato');
       const apiPath = target.route === 'local'
         ? '/api/cells/send' : routePath(target.route.split('/'), 'cells/send');
@@ -923,7 +929,7 @@ const TOOLS = [
       return { receipt };
     },
   },
-  // -- lease Live del child (fetta 2b, contratto rev1) ----------------------
+  // -- lease Live del child (fetta 2b) ----------------------
   // Tre metodi DISTINTI perche' i valori di ritorno non mentono l'uno con l'altro:
   // solo register puo' rispondere {status:'pending'} (join non ancora tracciato);
   // refresh su registration viva risponde {status:'live', proof} e non ha stati

package/lib/server.js

@@ -31,6 +31,9 @@ const { cellsRoutes, publicCells } = require('./cells/routes.js');
 const { liveHostRoutes } = require('./live-host/routes.js');
 const { createLiveHostStore, liveHostPath } = require('./live-host/store.js');
 const { createLiveBridge } = require('./live-host/bridge.js');
+const { createLiveThreadRegistry, liveThreadsPath } = require('./live-host/registry.js');
+const { createLiveAttestation } = require('./live-host/attest.js');
+const { buildLiveEntry } = require('./live-host/entry.js');
 const { createLiveHostFederation } = require('./live-host/federation.js');
 const { fsRoutes } = require('./fs/routes.js');
 const nodesStore = require('./nodes/store.js');
@@ -1017,7 +1020,7 @@ function createServer(opts = {}) {
       return cellScoper.resolve({ trust: 'federated', visited: [] });
     }
   };
-  // Scope celle (NC-E): un punto solo decide cosa un peer federato vede e puo'
+  // Scope celle: un punto solo decide cosa un peer federato vede e puo'
   // toccare. Sta qui, prima di ogni route, perche' i canali da cui una cella
   // trapela sono molti e crescono: filtrarli uno per uno significa dimenticarne
   // uno, e un permesso che vale su quasi tutti i canali non e' un permesso.
@@ -1691,6 +1694,23 @@ function createServer(opts = {}) {
     }),
     getGroup: (name) => audioGroups.getGroup(audioCfg, name, audioHome),
   }));
+  // One store and one bridge serve the cell directory (the Live entry and the
+  // verified label), the live-host routes and the federation forwarder. The
+  // registry of Live threads is persisted next to the designation so a restart
+  // does not make a living Live look absent.
+  const liveHostStore = createLiveHostStore({ filePath: liveHostPath(cfg) });
+  const liveRegistry = createLiveThreadRegistry({ filePath: liveThreadsPath(cfg) });
+  const liveBridge = createLiveBridge({
+    cfg,
+    fleetP,
+    tokenGet: () => tokenHolder.value,
+    filesRoot: cfg.filesRoot,
+    log: opts.log || console.log,
+    registry: liveRegistry,
+  });
+  // Startup reconciliation never blocks the server and never throws: it only
+  // drops entries the daemon definitely reports as gone.
+  Promise.resolve().then(() => liveBridge.reconcile()).catch(() => {});
   api.use('/cells', cellsRoutes({
     fleetP,
     diagnostics,
@@ -1700,6 +1720,10 @@ function createServer(opts = {}) {
       engine: meta && meta.engine,
     })),
     readonly: proxyReadonly,
+    liveEntry: ({ instanceId: id, now: clock }) => buildLiveEntry({
+      store: liveHostStore, bridge: liveBridge, fleetP, instanceId: id, now: clock,
+    }),
+    liveAttest: createLiveAttestation({ registry: liveRegistry, bridge: liveBridge }),
   }));
   // Live host cell: one hostCell per node with CAS. The store
   // lives next to the token (same isolated dir in tests); the proxy refuses
@@ -1707,22 +1731,15 @@ function createServer(opts = {}) {
   // behind a per-peer permission denied by default (liveHostAccess).
   // Fetta 3: il ponte risolve il puntamento all'avvio di una Live (POST /bridge
   // nello stesso gruppo, stessa auth, stesso local-only). Isolabile da cfg
-  // (rev5): spento non crea connessioni e la Live resta standard.
+  // Spento non crea connessioni e la Live resta standard.
   // One store instance serves both sides of a remote designation: the routes
   // (owner side) and the forwarder that records the pointer to a peer (client
   // side). Two instances over the same file would work, one is honest.
-  const liveHostStore = createLiveHostStore({ filePath: liveHostPath(cfg) });
   api.use('/live-host', liveHostRoutes({
     fleetP,
     store: liveHostStore,
     readonly: proxyReadonly,
-    bridge: createLiveBridge({
-      cfg,
-      fleetP,
-      tokenGet: () => tokenHolder.value,
-      filesRoot: cfg.filesRoot,
-      log: opts.log || console.log,
-    }),
+    bridge: liveBridge,
     // Client side: read the owner's state and forward the bridge resolution to
     // the node the designation points at. Owner side: accept a forwarded
     // resolution behind the same per-peer gate and the same rate limiting as

package/lib/tmux/actions.js

@@ -161,7 +161,7 @@ async function submitToSession(tmuxBin, session, text, opts = {}) {
     // then the pane is revalidated before the separate Enter. Other clients
     // still receive a short separation between paste and submit.
     //
-    // NC-Q: L'ATTESA SCALA COL PAYLOAD, e prima era una costante. Il tempo che
+    // L'ATTESA SCALA COL PAYLOAD, e prima era una costante. Il tempo che
     // un TUI impiega a ingerire un bracketed paste cresce con la lunghezza —
     // Claude Code sopra una certa taglia lo COLLASSA («paste again to expand»)
     // — mentre l'attesa era fissa. Oltre quella soglia l'Enter arriva mentre il

package/package.json

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