@mmmbuto/nexuscrew 0.9.19 → 0.9.21

package/lib/mcp/server.js

@@ -30,12 +30,25 @@ const VERSION = require('../../package.json').version;
 const MCP_COMPANIONS = require('../../mcp-companions.json');
 const { TOOLS, IDENTITY_CODE, IDENTITY_REMEDIATION } = require('./tools.js');
 const cells = require('./cells.js');
+const {
+  normalizeIdentityContext, IDENTITY_CONTEXT_AUTHORITY_UNAVAILABLE,
+} = require('./identity-schema.js');
+const { persistIdentityChannel } = require('./identity-provider.js');
 
 // Versione protocollo di fallback se il client non ne dichiara una valida.
 const PROTOCOL_FALLBACK = '2025-03-26';
 const HTTP_TIMEOUT_MS = 10000;
 const HTTP_TIMEOUT_CODE = 'NEXUSCREW_HTTP_TIMEOUT';
 const HTTP_UNREACHABLE_CODE = 'NEXUSCREW_HTTP_UNREACHABLE';
+const IDENTITY_CONTEXT_MISSING = 'NEXUSCREW_MCP_IDENTITY_CONTEXT_MISSING';
+const IDENTITY_CONTEXT_UNVERIFIED = 'NEXUSCREW_MCP_IDENTITY_CONTEXT_UNVERIFIED';
+const IDENTITY_CONTEXT_FROM_MISMATCH = 'NEXUSCREW_MCP_IDENTITY_CONTEXT_FROM_MISMATCH';
+
+function identityContextError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
 
 // Trasporta la causa in forma strutturata tra bridge e directory celle. Il
 // messaggio resta per l'operatore, ma la classificazione non dipende dalla
@@ -188,6 +201,9 @@ function resolveSession(opts) {
   return resolveIdentity(opts).then((i) => i.session);
 }
 
+// Contratto del resolver online iniettato dal processo NexusCrew autenticato.
+// La normalizzazione condivisa rifiuta contesto incompleto, incoerente o scaduto.
+
 // --- server --------------------------------------------------------------------
 function createMcpServer(opts = {}) {
   const input = opts.input || process.stdin;
@@ -202,7 +218,7 @@ function createMcpServer(opts = {}) {
   const cfg = opts.config || loadConfig();
   const baseUrl = `http://127.0.0.1:${cfg.port}`;
 
-  // Identita' risolta una volta e cacheata — ma solo se riesce.
+  // Identita' locale storica: risolta una volta e cacheata — ma solo se riesce.
   //
   // Perche' il successo e il fallimento hanno vita diversa: una sessione
   // risolta non cambia per la vita del processo (cache storica, invariata);
@@ -213,7 +229,8 @@ function createMcpServer(opts = {}) {
   // fallimento viene quindi ri-tentato, con anti-hammering: al piu' una
   // risoluzione ogni IDENTITY_RETRY_MS finche' non riesce (un tmux rotto non
   // puo' trasformare ogni tool call in una execFile da 3 s).
-  // `identity()` per la diagnostica completa (source/code/presence),
+  // `localIdentity()` serve alla diagnostica completa (source/code/presence),
+  // mentre `identity()` puo' essere il resolver online per gli handler nc_*;
   // `session()` estrae solo il nome per gli handler storici (compatibilita').
   // Nessuna API/token coinvolta qui.
   // Iniettabile nei test per non attendere 30 s reali (opts.identityRetryMs).
@@ -221,7 +238,7 @@ function createMcpServer(opts = {}) {
   let identityP = null;          // promise condivisa in corso/cacheata
   let identityOk = false;        // solo un esito OK resta cacheato a vita
   let identityAttemptAt = 0;     // istante dell'ultimo tentativo (anti-spam)
-  const identity = () => {
+  const localIdentity = () => {
     if (identityOk) return identityP;
     const now = Date.now();
     if (identityP && now - identityAttemptAt < IDENTITY_RETRY_MS) return identityP;
@@ -233,7 +250,49 @@ function createMcpServer(opts = {}) {
       });
     return identityP;
   };
-  const session = () => identity().then((i) => i.session);
+  const identityContextProvider = typeof opts.identityContextProvider === 'function'
+    ? opts.identityContextProvider : null;
+
+  // Il percorso online non cachea mai un successo: ogni tools/call ripete il
+  // resolver e quindi vede revoche/rotazioni del binding. L'assenza del
+  // provider mantiene il comportamento embedded/legacy di D.
+  async function identityContext({ tool = 'unknown', sharedRequired = !!identityContextProvider } = {}) {
+    if (!identityContextProvider) {
+      if (sharedRequired) {
+        throw identityContextError(IDENTITY_CONTEXT_MISSING,
+          'contesto identita online assente: binding condiviso richiesto');
+      }
+      const id = await localIdentity();
+      if (!id.session) return Object.freeze({ verified: false, mode: 'legacy', ...id, from: null });
+      return Object.freeze({
+        verified: false, mode: 'legacy', bindingId: null, ownerInstanceId: null,
+        cellId: null, tmuxSession: id.session, from: null, ...id,
+      });
+    }
+    let raw;
+    try {
+      raw = await identityContextProvider({ tool });
+    } catch (e) {
+      if (e && e.code === IDENTITY_CONTEXT_AUTHORITY_UNAVAILABLE) throw e;
+      throw identityContextError(IDENTITY_CONTEXT_MISSING,
+        'contesto identita online non disponibile: binding condiviso rifiutato');
+    }
+    return normalizeIdentityContext(raw);
+  }
+
+  const identity = ({ tool = 'unknown' } = {}) => {
+    if (!identityContextProvider) return localIdentity();
+    return identityContext({ tool, sharedRequired: true }).then((context) => ({
+      session: context.tmuxSession,
+      source: 'online',
+      code: IDENTITY_CODE.OK,
+      envPresence: envPresenceOf(env),
+      requiredEnvVars: IDENTITY_REQUIRED_ENV_VARS,
+      remediation: IDENTITY_REMEDIATION,
+      context,
+    }));
+  };
+  const session = (options = {}) => identity(options).then((i) => i.session);
 
   // Token letto ad OGNI chiamata (rotazione-friendly), MAI incluso negli errori.
   function readToken() {
@@ -267,6 +326,8 @@ function createMcpServer(opts = {}) {
         throw new Error('segreto bridge audio non leggibile: il server e\' inizializzato? (nexuscrew init)');
       }
     }
+    const identityBinding = opts.identityBinding
+      ? { 'x-nexuscrew-identity-binding': JSON.stringify(opts.identityBinding) } : {};
     let r;
     try {
       r = await fetchImpl(`${baseUrl}${apiPath}`, {
@@ -274,6 +335,7 @@ function createMcpServer(opts = {}) {
         headers: {
           authorization: `Bearer ${token}`,
           ...signed,
+          ...identityBinding,
           ...(payload !== undefined ? { 'content-type': 'application/json' } : {}),
         },
         ...(payload !== undefined ? { body: payload } : {}),
@@ -318,10 +380,30 @@ function createMcpServer(opts = {}) {
     }
   }
 
+  // Persistenza del canale identity: solo una response authority con proof
+  // child puo aggiornarlo. Il canale resta assente nel percorso legacy.
+  const persistIdentity = (session, out) => {
+    if (!session || !out || out.identityMode !== 'authority' || !out.proof) return false;
+    try {
+      return persistIdentityChannel({
+        tokenPath: cfg.tokenPath,
+        session,
+        cellId: out.proof.cellId,
+        proof: out.proof,
+        expiresAt: out.proof.expiresAt,
+      });
+    } catch (_) {
+      return false;
+    }
+  };
+
   const ctx = {
     session,
     identity,
+    localIdentity,
+    identityContext,
     api,
+    persistIdentityChannel: persistIdentity,
     home: () => env.HOME || os.homedir(),
     fileExists: (p) => { try { return require('node:fs').statSync(p).isFile(); } catch (_) { return false; } },
     messageId: () => String(idFactory()).toLowerCase(),
@@ -351,7 +433,40 @@ function createMcpServer(opts = {}) {
     const args = (params && params.arguments && typeof params.arguments === 'object'
       && !Array.isArray(params.arguments)) ? params.arguments : {};
     try {
-      const out = await tool.handler(args, ctx);
+      // Resolve once, before the handler, and reuse the immutable result for
+      // every helper it calls. This makes the provider mandatory for every
+      // shared tools/call, including read-only diagnostics.
+      const sharedContext = identityContextProvider
+        ? await identityContext({ tool: name, sharedRequired: true }) : null;
+      const sharedProof = sharedContext && typeof identityContextProvider.currentProof === 'function'
+        ? identityContextProvider.currentProof() : null;
+      const sharedIdentity = sharedContext ? Object.freeze({
+        session: sharedContext.tmuxSession,
+        source: 'online', code: IDENTITY_CODE.OK,
+        envPresence: envPresenceOf(env),
+        requiredEnvVars: IDENTITY_REQUIRED_ENV_VARS,
+        remediation: IDENTITY_REMEDIATION,
+        context: sharedContext,
+        ...(sharedProof ? { proof: sharedProof } : {}),
+      }) : null;
+      const requestCtx = {
+        ...ctx,
+        identity: sharedIdentity ? () => Promise.resolve(sharedIdentity)
+          : (options = {}) => ctx.identity({ ...options, tool: name }),
+        session: sharedIdentity ? () => Promise.resolve(sharedIdentity.session)
+          : (options = {}) => ctx.session({ ...options, tool: name }),
+        identityContext: sharedContext ? () => Promise.resolve(sharedContext)
+          : (options = {}) => ctx.identityContext({ ...options, tool: name }),
+        ...(sharedContext ? {
+          // Il binding verificato viaggia con ogni chiamata API della richiesta:
+          // il confine server lo ricontrolla prima degli effetti.
+          api: (method, apiPath, body, options = {}) => ctx.api(method, apiPath, body, {
+            ...options,
+            identityBinding: { context: sharedContext, ...(sharedProof ? { proof: sharedProof } : {}) },
+          }),
+        } : {}),
+      };
+      const out = await tool.handler(args, requestCtx);
       reply(id, { content: [{ type: 'text', text: JSON.stringify(out) }] });
     } catch (e) {
       // Errore di ESECUZIONE tool: per contratto MCP e' un result con isError,
@@ -461,12 +576,14 @@ function startMcp(opts = {}) {
 }
 
 module.exports = {
-  createMcpServer, startMcp, resolveSession, resolveIdentity, TOOLS,
+  createMcpServer, startMcp, resolveSession, resolveIdentity, normalizeIdentityContext, TOOLS,
   // V-69: il ramo vl di resolveManagedEngine compone le istruzioni companion
   // nel file di prompt per-cella — vl non ha client MCP, questo e' l'unica
   // superficie attraverso cui il testo lo raggiunge.
   companionInstructions,
   PROTOCOL_FALLBACK, HTTP_TIMEOUT_MS, HTTP_TIMEOUT_CODE, HTTP_UNREACHABLE_CODE, transportError,
+  IDENTITY_CONTEXT_MISSING, IDENTITY_CONTEXT_UNVERIFIED, IDENTITY_CONTEXT_FROM_MISMATCH,
+  IDENTITY_CONTEXT_AUTHORITY_UNAVAILABLE,
   parseCellTarget: cells.parseCellTarget,
   normalizeCellPayload: cells.normalizeCellPayload,
   readCellDirectory: cells.readCellDirectory,

package/lib/mcp/tools.js

@@ -678,6 +678,9 @@ const TOOLS = [
     async handler(args, ctx) {
       const targetRef = parseCellTarget(argString(args, 'target', { required: true, max: 128 }));
       if (!targetRef) throw new Error('target non valido: usa l\'id esatto restituito da nc_cells');
+      if (Object.prototype.hasOwnProperty.call(args, 'from')) {
+        throw new Error('nc_send_cell: from e\' derivato dal contesto identita online, non e\' un input');
+      }
       const message = argString(args, 'message', { required: true, max: 8000 });
       for (let i = 0; i < message.length; i += 1) {
         const code = message.charCodeAt(i);
@@ -687,7 +690,10 @@ const TOOLS = [
       const identity = await ctx.identity();
       const callerSession = requireSession(identity.session, 'nc_send_cell', identity.code);
       const directory = await readCellDirectory(ctx, callerSession);
-      const sender = directory.cells.find((cell) => cell.self && cell.active);
+      const onlineFrom = identity.context && identity.context.from;
+      const sender = directory.cells.find((cell) => cell.self && cell.active
+        && (!onlineFrom || (cell.instanceId === onlineFrom.instanceId
+          && cell.cell === onlineFrom.cell && cell.tmuxSession === onlineFrom.tmuxSession)));
       if (!sender) throw new Error('nc_send_cell: la sessione chiamante non e\' una cella Fleet attiva locale');
       const target = directory.cells.find((cell) => cell.instanceId === targetRef.instanceId
         && cell.cell === targetRef.cell);
@@ -699,7 +705,10 @@ const TOOLS = [
       const id = ctx.messageId();
       const receipt = await ctx.api('POST', apiPath, {
         id,
-        from: { instanceId: sender.instanceId, cell: sender.cell, tmuxSession: sender.tmuxSession },
+        // In modalita' online questo e' il valore gia' derivato e verificato
+        // dal server MCP; il directory lookup sopra verifica che sia ancora
+        // una cella locale attiva. Il fallback mantiene il sender storico.
+        from: onlineFrom || { instanceId: sender.instanceId, cell: sender.cell, tmuxSession: sender.tmuxSession },
         to: { instanceId: target.instanceId, cell: target.cell, tmuxSession: target.tmuxSession },
         message,
       });
@@ -730,18 +739,31 @@ const TOOLS = [
     inputSchema: { type: 'object', properties: {} },
     annotations: { readOnlyHint: true },
     async handler(_args, ctx) {
+      // In shared mode this is the same verified per-request context used by
+      // every other tool. Without a provider it remains the legacy local
+      // diagnostic for bootstrapping and troubleshooting.
       const id = await ctx.identity();
       // Output bounded e non sensibile: nessun valore/env, solo presence e codice.
       // `session` solo se validata; `source` sempre fra i tre valori ammessi.
       const out = {
         identified: !!id.session,
         source: id.source,
+        verified: !!(id.context && id.context.verified === true),
         envPresence: id.envPresence,
         requiredEnvVars: id.requiredEnvVars,
         code: id.code,
         remediation: id.remediation,
       };
       if (id.session) out.session = id.session;
+      if (id.context) {
+        out.bindingId = id.context.bindingId;
+        out.ownerInstanceId = id.context.ownerInstanceId;
+        out.cellId = id.context.cellId;
+        out.origin = id.context.origin;
+        out.kind = id.context.kind;
+        out.expiresAt = id.context.expiresAt;
+        out.threadId = id.context.kind === 'connection-v1' ? null : (id.context.threadId ?? null);
+      }
       return out;
     },
   },
@@ -897,11 +919,19 @@ const TOOLS = [
   {
     name: 'nc_lease_register',
     description: 'Registra questa cella al lease Live del nodo: crea una registration con incarnationId propria e consegna il primo proof child. Risponde {status:"pending"} se la cella non e\' ancora tracciata dal lease del supervisore: riprova dopo retryAfterMs.',
-    inputSchema: { type: 'object', properties: {} },
-    async handler(_args, ctx) {
+    inputSchema: { type: 'object', properties: {
+      proof: { type: 'object', description: 'proof identity ricevuto dal bootstrap authority, se disponibile' },
+    } },
+    async handler(args, ctx) {
       const identity = await ctx.identity();
       const session = requireSession(identity.session, 'nc_lease_register', identity.code);
-      return ctx.api('POST', '/api/lease/register', { session });
+      const proof = args.proof && typeof args.proof === 'object' && !Array.isArray(args.proof)
+        ? args.proof : null;
+      const out = await ctx.api('POST', '/api/lease/register', { session, ...(proof ? { proof } : {}) });
+      // Una registration authority consegna il canale shared del bridge: lo si
+      // persiste appena ricevuto, cosi il prossimo avvio parte gia verificato.
+      if (typeof ctx.persistIdentityChannel === 'function') ctx.persistIdentityChannel(session, out);
+      return out;
     },
   },
   {
@@ -918,7 +948,9 @@ const TOOLS = [
       const proof = args.proof && typeof args.proof === 'object' && !Array.isArray(args.proof)
         ? args.proof : null;
       if (!proof) throw new Error('parametro "proof" obbligatorio (oggetto ricevuto da register/refresh)');
-      return ctx.api('POST', '/api/lease/refresh', { session, proof });
+      const out = await ctx.api('POST', '/api/lease/refresh', { session, proof });
+      if (typeof ctx.persistIdentityChannel === 'function') ctx.persistIdentityChannel(session, out);
+      return out;
     },
   },
   {

package/lib/notify/asks.js

@@ -87,6 +87,7 @@ function createAsksStore(opts = {}) {
       session: String(session),
       ts: now(),
       answered: false,
+      dismissed: false,
     };
     load().push(ask);
     save();

package/lib/notify/routes.js

@@ -21,6 +21,7 @@ const express = require('express');
 const { isValidSession } = require('../files/store.js');
 const { normalizeNotificationLang } = require('./language.js');
 const { HOP_HEADER } = require('../proxy/hop-proof.js');
+const { createIdentityBindingGuard, expectedFromSession } = require('../identity/binding-guard.js');
 
 const TARGET_RE = /^[a-f0-9]{32}$/i;
 
@@ -103,6 +104,7 @@ function replyLabel(cfg) {
 
 function notifyRoutes({
   cfg, notifier, push, asks, paste, sessionExists,
+  fleetP = null, instanceId = null, identityMode = 'legacy',
   // Federazione delle notifiche. Assenti (test unitari, montaggi parziali) la
   // route resta esattamente quella locale di prima: nessun percorso nuovo si
   // apre per omissione.
@@ -111,6 +113,22 @@ function notifyRoutes({
 }) {
   const r = express.Router();
   const json = express.json({ limit: '16kb' });
+  const bindingGuard = createIdentityBindingGuard({
+    fleetP, instanceId, now: () => Date.now(), sharedRequired: identityMode === 'authority',
+  });
+
+  async function guardBinding(req, session = null) {
+    try {
+      const expected = expectedFromSession(session, instanceId);
+      return await bindingGuard.verify(req, { expected, localOnly: true });
+    } catch (e) {
+      return e;
+    }
+  }
+
+  function bindingRejected(res, error) {
+    return res.status(403).json({ error: error.message, code: error.code });
+  }
 
   const readonly = () => (cfg.readonlyDefault === true || process.env.NEXUSCREW_READONLY === '1');
   const mutGate = (_req, res, next) => {
@@ -209,6 +227,8 @@ function notifyRoutes({
         return res.json(out);
       }
 
+      const binding = await guardBinding(req, b.session);
+      if (binding instanceof Error) return bindingRejected(res, binding);
       const sender = b.session || 'unknown';
       if (!allowNotify(sender)) {
         return res.status(429).json({ error: 'rate limit notify superato (limite globale per token + per sessione)' });
@@ -267,6 +287,8 @@ function notifyRoutes({
       // non consumano budget; il rate scatta solo su richieste ben formate.
       const v = asks.validate({ question: b.question, options: b.options });
       if (!v.ok) return res.status(400).json({ error: v.error });
+      const binding = await guardBinding(req, b.session);
+      if (binding instanceof Error) return bindingRejected(res, binding);
       if (!allowAsk(b.session)) {
         return res.status(429).json({ error: 'rate limit ask superato (limite globale per token + per sessione)' });
       }
@@ -298,9 +320,12 @@ function notifyRoutes({
   // Idempotente; 404 se id inesistente; 409 se answering (claim attivo: non si
   // scarta una risposta in corso). Emette il frame per le UI aperte come fa
   // POST /asks con emitRaw: la card sparisce senza aspettare il poll.
-  r.delete('/asks/:id', mutGate, (req, res) => {
+  r.delete('/asks/:id', mutGate, async (req, res) => {
     try {
       const id = String(req.params.id || '');
+      const ask = asks.get(id);
+      const binding = await guardBinding(req, ask && ask.session);
+      if (binding instanceof Error) return bindingRejected(res, binding);
       const out = asks.dismiss(id);
       if (!out.ok) {
         if (out.reason === 'unknown') return res.status(404).json({ error: 'ask inesistente' });
@@ -339,6 +364,9 @@ function notifyRoutes({
       }
       const text = sanitized;
       if (!text && asks.get(id)) return res.status(400).json({ error: 'text vuoto dopo la sanificazione' });
+      const ask = asks.get(id);
+      const binding = await guardBinding(req, ask && ask.session);
+      if (binding instanceof Error) return bindingRejected(res, binding);
       const claim = asks.claim(id);
       if (!claim.ok) {
         if (claim.reason === 'unknown') return res.status(404).json({ error: 'ask inesistente' });

package/lib/server.js

@@ -165,13 +165,16 @@ function createServer(opts = {}) {
   // selectProvider sceglie UNA volta (startup) builtin|disabled e ritorna
   // {mode,reason,fleet}; routes consumano il .fleet,
   // quindi fleetP resta una Promise<Fleet> (createServer non diventa async).
-  const fleetP = selectProvider({ ...cfg, ensureTmuxProtection }).then((p) => p.fleet);
+  // L'owner identity e' la stessa fonte autorevole del node store usata dalle
+  // route API: nessuna cella puo dichiararla dal body.
+  const nodesPath = cfg.nodesPath || nodesStore.defaultNodesPath(cfg.home || os.homedir());
+  const identityOwnerInstanceId = () => (nodesStore.loadStore(nodesPath) || {}).nodeId || null;
+  const fleetP = selectProvider({ ...cfg, ensureTmuxProtection, identityOwnerInstanceId }).then((p) => p.fleet);
 
   // Multi-node (B1): nodes.json e' la fonte dati (B0). Il proxy risolve <name>
   // -> {localPort, token} leggendo lo store ad ogni richiesta (fresh: rotazione
   // token / add-remove nodi visibili senza restart). token MAI redatto qui: e'
   // il valore che il proxy inietta upstream, non esce mai verso il browser.
-  const nodesPath = cfg.nodesPath || nodesStore.defaultNodesPath(cfg.home || os.homedir());
   const vlNodesPath = cfg.vlNodesPath || vlNodeStore.defaultPath(cfg.home || os.homedir());
   const vlNodeBroker = opts.vlNodeBroker || createVlNodeBroker();
   const vlOwnerId = () => (nodesStore.loadStore(nodesPath) || {}).nodeId || null;
@@ -830,12 +833,17 @@ function createServer(opts = {}) {
     nodePanelPorts: nodePanelPorts(),
     presets: ['shell', 'claude', 'codex-vl', 'pi', ...Object.keys(cfg.sessionPresets || {})],
   }));
+  const apiNodeId = () => (nodesStore.loadStore(nodesPath) || {}).nodeId || null;
+  const identityMode = cfg.fleetIdentityMode || cfg.fleet?.identity?.mode || 'legacy';
   api.use('/files', filesRoutes({
     cfg,
     sessionExists: (name) => sessionExists(cfg.tmuxBin, name),
     paste: (session, text) => pasteToSession(cfg.tmuxBin, session, text),
     notifier,
     readonly: proxyReadonly,
+    fleetP,
+    instanceId: apiNodeId,
+    identityMode,
   }));
   // MCP bridge (design §2): /notify, /push/*, /asks — dietro lo stesso Bearer
   // del router /api; gate READONLY sui mutanti dentro notifyRoutes.
@@ -859,6 +867,9 @@ function createServer(opts = {}) {
     asks: asksStore,
     paste: (session, text) => pasteToSession(cfg.tmuxBin, session, text),
     sessionExists: (name) => sessionExists(cfg.tmuxBin, name),
+    fleetP,
+    instanceId: apiNodeId,
+    identityMode,
     localNodeId: federatedNodeId,
     // requireCell resta true: una notifica federata porta sempre una cella
     // attestata, che serve ad attribuirla e a calcolarne il budget.
@@ -884,7 +895,13 @@ function createServer(opts = {}) {
   // Fetta 2b (D3): superficie child del lease Live via canale nativo del
   // bridge (HTTP loopback + Bearer). La cella e' derivata dalla sessione; il
   // proof firmato dal verifier per-installazione autorizza refresh/recovery.
-  api.use('/lease', leaseRoutes({ fleetP, readonly: proxyReadonly }));
+  api.use('/lease', leaseRoutes({
+    fleetP, readonly: proxyReadonly,
+    identityMode,
+    // Fonte autorevole del node id: node store vivo, gia condiviso con files,
+    // notify e cells. Non e' un dato dichiarato dal chiamante né da cfg.
+    instanceId: apiNodeId,
+  }));
   // Audio Share. L'identita' del nodo NON e' un campo di cfg: si legge dal node
   // store, la stessa fonte usata da /api/cells e /api/peers. Lo stato Fleet e'
   // asincrono e va atteso: leggerlo come se fosse sincrono lascerebbe la
@@ -906,6 +923,8 @@ function createServer(opts = {}) {
   api.use('/audio', audioRoutes({
     readonly: proxyReadonly,
     localNodeId: audioNodeId,
+    fleetP,
+    identityMode,
     receiptStore: audioReceipts,
     adapter: audioAdapter,
     queue: audioQueue,
@@ -946,7 +965,8 @@ function createServer(opts = {}) {
   api.use('/cells', cellsRoutes({
     fleetP,
     diagnostics,
-    instanceId: () => (nodesStore.loadStore(nodesPath) || {}).nodeId || null,
+    instanceId: apiNodeId,
+    identityMode,
     submit: opts.cellSubmit || ((session, text, meta) => submitToSession(cfg.tmuxBin, session, text, {
       engine: meta && meta.engine,
     })),

package/package.json

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