@mmmbuto/nexuscrew 0.9.32 → 0.9.34

package/lib/fleet/managed.js

@@ -1612,6 +1612,188 @@ function cellMcpArgs(home, cell) {
   return [`--settings=${JSON.stringify({ permissions: { deny } })}`];
 }
 
+// Definizioni MCP note, per NOME -> definizione (la prima sorgente che dichiara
+// il nome vince). Le SORGENTI sono le stesse dei nomi in `knownMcpServerNames`
+// (config utente, suo ramo per-progetto, .mcp.json della cwd), precedute da
+// eventuali file extra — per i profili Claude isolati la propria config, che
+// altrimenti sparirebbe dall'enumerazione. Solo LETTURA: le definizioni non
+// vengono mai modificate, riprese e ridistribuite tali quali.
+function collectMcpServerDefs(home, cwd, extraFiles = []) {
+  const leggi = (file) => {
+    try {
+      const st = fs.lstatSync(file);
+      if (st.isSymbolicLink() || !st.isFile() || st.size > 8 * 1024 * 1024) return null;
+      const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+      return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    } catch (_) { return null; /* assente o illeggibile non e' un errore qui */ }
+  };
+  const defs = new Map();
+  const raccogli = (servers) => {
+    if (servers && typeof servers === 'object' && !Array.isArray(servers)) {
+      for (const [nome, def] of Object.entries(servers)) {
+        if (def && typeof def === 'object' && !Array.isArray(def) && !defs.has(nome)) defs.set(nome, def);
+      }
+    }
+  };
+  for (const file of extraFiles) {
+    const parsed = typeof file === 'string' ? leggi(file) : null;
+    if (parsed) raccogli(parsed.mcpServers);
+  }
+  const utente = leggi(path.join(home, '.claude.json'));
+  if (utente) {
+    raccogli(utente.mcpServers);
+    const progetti = utente.projects;
+    if (typeof cwd === 'string' && cwd && progetti && typeof progetti === 'object' && !Array.isArray(progetti)) {
+      const voce = progetti[cwd];
+      if (voce && typeof voce === 'object' && !Array.isArray(voce)) raccogli(voce.mcpServers);
+    }
+  }
+  if (typeof cwd === 'string' && cwd) {
+    const progetto = leggi(path.join(cwd, '.mcp.json'));
+    if (progetto) raccogli(progetto.mcpServers);
+  }
+  return defs;
+}
+
+// Il file MCP PER CELLA del materializzatore: contiene le definizioni dei SOLO
+// server concessi, copiate tali quali dalle sorgenti (che portano `env` con
+// credenziali per alcuni server). Duplicare quelle definizioni e' il prezzo
+// del sottoinsieme esatto — il file per profilo unico non puo' esprimere un
+// sottoinsieme per cella senza un allowlist del client, e l'allowlist esclusiva
+// vuole proprio un file. Il prezzo si paga nel regime di permessi piu' stretto
+// che esiste fuori dallo store credenziali: directory 0700, file 0600, tutto
+// sotto ~/.nexuscrew (la stessa classe di privacy di providers.env), scritto
+// atomicamente e RIGENERATO a ogni up (nessun valore accumulato, nessuna
+// copia stantia), mai loggato: il contenuto non tocca nessun log né output.
+// DICHARIAZIONE DI PROVENIENZA: questo file e' DERIVATO — la fonte di verita'
+// restano le sorgenti originali, e la provenienza delle credenziali (doctor)
+// non lo elenca e non lo considerera' mai una sorgente di conflitto.
+function writeCellMcpConfig(cellId, concessi, home, defs) {
+  const dir = path.join(home, '.nexuscrew', 'cell-mcp');
+  try {
+    const st = fs.lstatSync(dir);
+    if (st.isSymbolicLink() || !st.isDirectory()) throw new Error('unsafe per-cell MCP directory');
+    // Strettisce, mai allarga: permessi piu' larghi di 0700 tornano a 0700; una
+    // directory resa NON scrivibile (operatore, manutenzione) resta tale — e
+    // il fallimento di scrittura e' il rifiuto del launch, non un launch con
+    // la superficie sbagliata.
+    if (st.mode & 0o077) fs.chmodSync(dir, 0o700);
+  } catch (e) {
+    if (e.code === 'ENOENT') fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    else throw e;
+  }
+  const servers = {};
+  // Il canale operatore (nexuscrew) e' CORE: entra nel file anche se la cella
+  // non lo ha nominato — senza, la cella dichiarata perderebbe `nc_*`.
+  const nomi = new Set(concessi);
+  if (defs.has('nexuscrew')) nomi.add('nexuscrew');
+  for (const nome of [...nomi].sort()) {
+    const def = defs.get(nome);
+    if (!def) continue; // difesa residua: il preflight ora rifiuta i nomi dichiarati sconosciuti prima di arrivare qui
+    servers[nome] = def;
+  }
+  const target = path.join(dir, `${cellId}.json`);
+  const tmp = path.join(dir, `.${cellId}.${crypto.randomBytes(6).toString('hex')}.tmp`);
+  try {
+    fs.writeFileSync(tmp, `${JSON.stringify({ mcpServers: servers }, null, 2)}\n`, { mode: 0o600 });
+    fs.chmodSync(tmp, 0o600);
+    fs.renameSync(tmp, target);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch (_) {}
+    throw e;
+  }
+  return target;
+}
+
+// La superficie codex NOTA alla config utente, letta con un parse TOML
+// minimale e DELIBERATAMENTE superficie: servono solo i NOMI dei server
+// (`[mcp_servers.<nome>]`) e delle skill (`[[skills.config]]` con name) da
+// poter spegnere nel profilo per cella. La config utente non viene mai
+// toccata: il profilo e' un LAYER di riduzione che la legge e basta.
+function codexSurfaceNames(configToml) {
+  const testo = typeof configToml === 'string' ? configToml : '';
+  const servers = [...testo.matchAll(/^[ \t]*\[mcp_servers\.([A-Za-z0-9_-]+)\][ \t]*$/gm)].map((m) => m[1]);
+  const skills = [...testo.matchAll(/\[\[skills\.config\]\]([^[]*)/g)]
+    .map((m) => (m[1].match(/^[ \t]*name[ \t]*=[ \t]*"([^"]+)"/m) || [])[1])
+    .filter(Boolean);
+  return { servers: [...new Set(servers)], skills: [...new Set(skills)] };
+}
+
+// Il profilo per cella di codex/codex-vl (profilo v2: <CODEX_HOME>/<nome>
+// .config.toml, lanciato con -p). STESSA SEMANTICA DEL CLAUDE, tradotta nei
+// meccanismi nativi del client: la chiave `mcp` spegne i server NON concessi
+// (enabled = false — i concessi non si ridichiarano, ereditano dal layer
+// base); `ondemand` mette omit_tools_from = ["direct"] (scopribili via tool
+// search, non attivi); `skills` spegne le skill NON concesse enumerate nella
+// config. Chiave assente = nessuna riduzione per quella chiave. RESIDUO
+// DICHIARATO: server/skill definiti fuori dalla config utente (config di
+// progetto, config gestita) non sono enumerabili da qui e restano — come per
+// il claude legacy, chi vuole il caso esatto dichiara e verifica. Il file e'
+// atomico, 0600, rigenerato a ogni up, mai loggato; la config utente non e'
+// mai modificata.
+// La config utente di codex letta con gli stessi criteri del materializzatore:
+// mai modificata, mai loggata; assente/symlink/oversize = catalogo vuoto.
+function readCodexUserToml(codexHome) {
+  try {
+    const st = fs.lstatSync(path.join(codexHome, 'config.toml'));
+    if (!st.isSymbolicLink() && st.isFile() && st.size <= 8 * 1024 * 1024) {
+      return fs.readFileSync(path.join(codexHome, 'config.toml'), 'utf8');
+    }
+  } catch (_) { /* config assente: niente da enumerare, il profilo e' vuoto */ }
+  return '';
+}
+
+function writeCellCodexProfile(cellId, declared, codexHome) {
+  const nome = `nexuscrew-${String(cellId).replace(/\./g, '_')}`;
+  const target = path.join(codexHome, `${nome}.config.toml`);
+  const configToml = readCodexUserToml(codexHome);
+  const { servers, skills } = codexSurfaceNames(configToml);
+  const mcpConcessi = new Set(declared.mcp || []);
+  const ondemand = new Set(declared.ondemand || []);
+  const skillConcesse = new Set(declared.skills || []);
+  const righe = [
+    '# Generated by NexusCrew for this cell: reduces (never widens) the surface',
+    '# declared in config.toml, which NexusCrew never modifies.',
+  ];
+  if (declared.mcp !== undefined) {
+    for (const s of servers.filter((n) => !mcpConcessi.has(n)).sort()) {
+      righe.push('', `[mcp_servers.${s}]`, 'enabled = false');
+    }
+  }
+  // `omit_tools_from` NON e' una chiave di root: in codex e' un campo della
+  // tabella del SINGOLO server (codex-rs/config/src/mcp_types.rs:223/:364) —
+  // a root viene ignorato in silenzio e l'on-demand non funzionerebbe mai.
+  // Un server on-demand e' CONCESSO ma differito: enabled resta il default e
+  // si scrive solo la chiave di differimento; uno spento (non concesso con
+  // `mcp` dichiarata) non prende una seconda tabella: TOML vieta i duplicati
+  // e enabled = false resta il volere piu' restrittivo. Nomi ondemand non
+  // presenti nella config utente non generano tabelle (ignorati; la vista li
+  // segnala).
+  if (ondemand.size) {
+    const spenti = declared.mcp !== undefined
+      ? new Set(servers.filter((n) => !mcpConcessi.has(n)))
+      : new Set();
+    for (const s of servers.filter((n) => ondemand.has(n) && !spenti.has(n)).sort()) {
+      righe.push('', `[mcp_servers.${s}]`, 'omit_tools_from = ["direct"]');
+    }
+  }
+  if (declared.skills !== undefined) {
+    for (const s of skills.filter((n) => !skillConcesse.has(n)).sort()) {
+      righe.push('', '[[skills.config]]', `name = "${s}"`, 'enabled = false');
+    }
+  }
+  const tmp = path.join(codexHome, `.${nome}.${crypto.randomBytes(6).toString('hex')}.tmp`);
+  try {
+    fs.writeFileSync(tmp, `${righe.join('\n')}\n`, { mode: 0o600 });
+    fs.chmodSync(tmp, 0o600);
+    fs.renameSync(tmp, target);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch (_) {}
+    throw e;
+  }
+  return target;
+}
+
 function ensurePrivateClaudeConfig(home, profileId, label, penguinMode) {
   const nexusDir = path.join(home, '.nexuscrew');
   const profilesDir = path.join(nexusDir, 'claude-profiles');
@@ -2082,9 +2264,43 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
     // In coda di proposito: `--mcp-config` e' variadico e consuma ogni token
     // che non inizi per `-`. Messo qui non ha nulla da inghiottire.
     if (privateProfile) args.push(...sharedMcpArgs(home));
-    // Vale per OGNI cella Claude, non solo per i profili isolati: il filtro
-    // agisce sui nomi dei tool, non su dove i server sono definiti.
-    args.push(...cellMcpArgs(home, cell));
+    // Tre strade. LEGACY (niente capabilities, niente profilo): il filtro per
+    // NEGAZIONE di oggi, che agisce sui nomi dei tool e lascia le sorgenti
+    // dove sono. CELLA DICHIARATA con `mcp` (anche vuoto): allowlist ESCLUSIVA
+    // — un file per cella con i soli server concessi (+ il canale operatore,
+    // sempre) e `--strict-mcp-config`, che esclude anche cio' che il deny non
+    // sa enumerare (plugin, connettori). CHIAVE `mcp` ASSENTE ma cella
+    // dichiarata (solo skills/ondemand): comportamento di sempre per QUESTA
+    // chiave — l'alias `cell.mcp` resta il filtro per negazione, in linea con
+    // l'override sostitutivo per chiave del modello.
+    // FAIL-CLOSED: se il file per cella non si scrive la cella NON parte.
+    // Partire senza la allowlist esporrebbe l'intera superficie proprio dove
+    // l'operatore l'ha ristretta: peggio della legacy, e senza che nessuno
+    // l'abbia chiesto.
+    const { effectiveCapabilities } = require('./definitions.js');
+    const eff = effectiveCapabilities(cell || {}, { capabilityProfiles: cfg.capabilityProfiles || null });
+    if (eff.legacy || eff.declared.mcp === undefined) {
+      args.push(...cellMcpArgs(home, cell));
+    } else {
+      let file;
+      try {
+        const extraFiles = typeof env.CLAUDE_CONFIG_DIR === 'string'
+          ? [path.join(env.CLAUDE_CONFIG_DIR, '.claude.json')] : [];
+        const defs = collectMcpServerDefs(home, cell?.cwd, extraFiles);
+        // Un nome dichiarato che il client non definisce sparisce in silenzio
+        // dal file strict: rifiuta qui, prima di scrivere qualsiasi cosa.
+        const sconosciute = eff.declared.mcp.filter((n) => !defs.has(n));
+        if (sconosciute.length) {
+          const motivo = `capability mcp sconosciuta al client: ${sconosciute.join(', ')}`;
+          return { ok: false, reason: motivo, mcpCellRefused: motivo, mcpCellRefusedCode: 'CAPABILITY_UNKNOWN_NAME' };
+        }
+        file = writeCellMcpConfig(String(cell?.id || 'cella'), eff.declared.mcp, home, defs);
+      } catch (e) {
+        const motivo = `file MCP per cella non scrivibile: ${e.message}`;
+        return { ok: false, reason: motivo, mcpCellRefused: motivo };
+      }
+      args.push('--strict-mcp-config', `--mcp-config=${file}`);
+    }
   } else if (spec.client === 'codex' || spec.client === 'codex-vl') {
     if (profile.localProvider) args.push('--oss', '--local-provider', profile.localProvider);
     else if (spec.provider === 'openai-api') env.OPENAI_API_KEY = cred.value;
@@ -2180,6 +2396,43 @@ function resolveManagedEngine(engine, cell, cfg = {}) {
       }
     }
     if (model) args.push('-m', model);
+    // Materializzatore per cella (stesse regole del ramo claude, meccanismi
+    // nativi del client): profilo v2 sotto CODEX_HOME lanciato con -p. Il
+    // profilo RIDUCE la superficie della config utente (mai toccata);
+    // FAIL-CLOSED come il claude: profilo non scrivibile = launch rifiutato,
+    // mai una cella con la superficie intera dove l'operatore ha ristretto.
+    {
+      const { effectiveCapabilities } = require('./definitions.js');
+      const eff = effectiveCapabilities(cell || {}, { capabilityProfiles: cfg.capabilityProfiles || null });
+      const daMaterializzare = eff.declared.mcp !== undefined || eff.declared.skills !== undefined || eff.declared.ondemand !== undefined;
+      if (!eff.legacy && daMaterializzare) {
+        // Stessa regola del ramo claude: un nome dichiarato che la config
+        // utente non definisce sparisce in silenzio dal profilo — rifiuta
+        // qui, prima di scrivere qualsiasi cosa. Catalogo vuoto (config
+        // assente/vuota) + nomi dichiarati = nomi sconosciuti; `mcp: []`
+        // resta valido (niente nomi da confrontare).
+        const { servers, skills } = codexSurfaceNames(readCodexUserToml(path.join(home, '.codex')));
+        const parti = [];
+        const sconosciuteMcp = (eff.declared.mcp || []).filter((n) => !servers.includes(n));
+        const sconosciuteOndemand = (eff.declared.ondemand || []).filter((n) => !servers.includes(n));
+        const sconosciuteSkills = (eff.declared.skills || []).filter((n) => !skills.includes(n));
+        if (sconosciuteMcp.length) parti.push(`capability mcp sconosciuta al client: ${sconosciuteMcp.join(', ')}`);
+        if (sconosciuteOndemand.length) parti.push(`capability ondemand sconosciuta al client: ${sconosciuteOndemand.join(', ')}`);
+        if (sconosciuteSkills.length) parti.push(`capability skills sconosciuta al client: ${sconosciuteSkills.join(', ')}`);
+        if (parti.length) {
+          const motivo = parti.join('; ');
+          return { ok: false, reason: motivo, mcpCellRefused: motivo, mcpCellRefusedCode: 'CAPABILITY_UNKNOWN_NAME' };
+        }
+        let file;
+        try {
+          file = writeCellCodexProfile(String(cell?.id || 'cella'), eff.declared, path.join(home, '.codex'));
+        } catch (e) {
+          const motivo = `profilo per cella non scrivibile: ${e.message}`;
+          return { ok: false, reason: motivo, mcpCellRefused: motivo, mcpCellRefusedCode: 'CAPABILITY_PROFILE_UNWRITABLE' };
+        }
+        args.push('-p', path.basename(file).replace(/\.config\.toml$/, ''));
+      }
+    }
   } else if (spec.client === 'pi') {
     if (profile.auth !== 'none' && profile.auth !== 'login' && cred.value) env[cred.envKey] = cred.value;
     if (spec.provider === 'custom') args.push('--extension', writePiProviderExtension(spec, home, declaredModels));
@@ -2434,6 +2687,7 @@ module.exports = {
   CLIENT_LABELS, normalizeManagedSpec, profileFor,
   defaultDefinitions, defaultShellEngine, defaultAgyEngine, defaultKimiEngine, defaultGrokEngine, defaultVlEngine, describeManaged, describeCatalogCredential, discoverOllamaModels, resolveManagedEngine, needsExplicitNode,
   discoverPiModels, EXTERNAL_DISCOVERY_TIMEOUT_MS, parseEnvFile, parseProviderShellFile, findBinary, publicCatalog, writePiProviderExtension, customCatalogFor,
+  codexSurfaceNames, writeCellCodexProfile,
   writeVlCellPrompt, vlSystemAppendGate,
   extraModelsFrom, declaredModelsFor, declaredFor,
   providerKeyPaths, parseProviderKeyFiles, credentialSources, credential, CREDENTIAL_SOURCE_VALUES,

package/lib/fleet/routes.js

@@ -188,6 +188,11 @@ function fleetRoutes(fleetP, cfg = {}) {
     if (typeof f.removeModel !== 'function') { const e = new Error('not supported by this fleet provider'); e.status = 501; throw e; }
     return f.removeModel(String(b.id || ''), String(b.engine || ''));
   }, { mutate: true }));
+  r.post('/edit-model', guard((f, b) => {
+    requireCap(f, 'edit-model');
+    if (typeof f.editModel !== 'function') { const e = new Error('not supported by this fleet provider'); e.status = 501; throw e; }
+    return f.editModel(String(b.id || ''), String(b.engine || ''), b.patch);
+  }, { mutate: true }));
   r.post('/define-engine', guard((f, b) => { requireCap(f, 'define'); return f.defineEngine(b.def); }, { mutate: true }));
   r.post('/edit-engine', guard((f, b) => { requireCap(f, 'edit'); return f.editEngine(b.id, b.patch, b.envChanges); }, { mutate: true }));
   r.post('/remove-engine', guard((f, b) => { requireCap(f, 'remove'); return f.removeEngine(b.id); }, { mutate: true }));

package/lib/fleet/runtime.js

@@ -241,7 +241,13 @@ function createBuiltinRuntime(ctx) {
     if (!engine) throw httpError(400, `engine dangling per cella ${cellId}: ${cell.engine}`);
     let launchEngine = engine;
     if (engine.managed) {
-      const resolved = resolveManagedEngine(engine, cell, { ...cfg, home, extraModels: extraModelsFrom(defs) });
+      const resolved = resolveManagedEngine(engine, cell, { ...cfg, home, extraModels: extraModelsFrom(defs), capabilityProfiles: defs.capabilityProfiles || null });
+      // Il materializzatore MCP per cella e' FAIL-CLOSED: se il file per cella
+      // non si scrive, la cella non parte — mai con la superficie intera dove
+      // l'operatore l'ha ristretta.
+      if (resolved.mcpCellRefused) {
+        throw httpError(500, resolved.mcpCellRefused, null, { phase: 'preflight', code: resolved.mcpCellRefusedCode || 'MCP_CELL_FILE_UNWRITABLE' });
+      }
       if (!resolved.ok) {
         const code = engine.managed.client === 'shell' ? 'SHELL_NOT_AVAILABLE' : 'ENGINE_UNCONFIGURED';
         throw httpError(400, `engine managed non configurato (${engine.id}): ${resolved.reason}`, null, { phase: 'preflight', code });

package/lib/mcp/cells.js

@@ -75,6 +75,10 @@ function topologyOwners(payload) {
       route: [...node.route],
       label: typeof node.label === 'string' && node.label ? node.label : (node.name || node.route.join(' › ')),
       stale: node.stale === true,
+      // Serve alla directory per dire QUANDO un nodo stale e' stato visto
+      // l'ultima volta: senza, la voce in unavailable parlerebbe dello stato
+      // senza dire da quanto.
+      lastSeen: Number.isFinite(node.lastSeen) ? node.lastSeen : null,
     });
   }
   return out;
@@ -162,10 +166,26 @@ async function readCellDirectory(ctx, callerSession = null) {
   ]);
   const localId = String(config && config.instanceId || '');
   if (!NODE_ID_RE.test(localId)) throw new Error('instanceId locale non disponibile');
+  const candidati = topologyOwners(topology).filter((owner) => owner.instanceId !== localId);
   const owners = [{ instanceId: localId, route: [], label: 'Local', stale: false },
-    ...topologyOwners(topology).filter((owner) => !owner.stale && owner.instanceId !== localId)];
+    ...candidati.filter((owner) => !owner.stale)];
   const cells = [];
   const unavailable = [];
+  // Un owner STALE resta nel gate (non si interroga un nodo che la topologia
+  // dichiara stantio) ma non SPARISCE dalla directory: chi legge `nc_cells`
+  // deve distinguere «questo nodo non risponde da X» da «questo nodo non
+  // esiste». Stesso shape di unavailableOwner, failure 'stale' + lastSeen.
+  for (const owner of candidati) {
+    if (!owner.stale) continue;
+    unavailable.push({
+      instanceId: owner.instanceId,
+      owner: owner.label,
+      route: owner.route.length ? owner.route.join('/') : 'local',
+      ...(owner.route.length === 0 ? { local: true } : {}),
+      failure: 'stale',
+      lastSeen: Number.isFinite(owner.lastSeen) ? owner.lastSeen : null,
+    });
+  }
   await Promise.all(owners.map(async (owner) => {
     const apiPath = owner.route.length ? routePath(owner.route, 'cells') : '/api/cells';
     if (!apiPath) return;

package/lib/proxy/federation.js

@@ -207,7 +207,7 @@ function knownResource(resource) {
     || /^\/event-feed\/[A-Za-z0-9._-]{1,32}$/.test(resource)
     || /^\/event-feed\/node\/[a-f0-9]{32}$/.test(resource)
     || isPanelResource(resource)
-    || /^\/fleet\/(status|schema|definitions|credentials\/status|credentials\/(?:set|remove)|up|down|restart|engine|boot|define-engine|edit-engine|remove-engine|define-model|remove-model|model-test|define-cell|edit-cell|remove-cell|restore-cells|restore-engines)$/.test(resource);
+    || /^\/fleet\/(status|schema|definitions|credentials\/status|credentials\/(?:set|remove)|up|down|restart|engine|boot|define-engine|edit-engine|remove-engine|define-model|edit-model|remove-model|model-test|define-cell|edit-cell|remove-cell|restore-cells|restore-engines)$/.test(resource);
 }
 
 // Il pannello di una cella e' l'unica risorsa federata con un gate PER-PEER a
@@ -293,7 +293,7 @@ function allowedResource(resource, method = 'GET') {
   // enum. Non genera testo, quindi non consuma token. Resta comunque una
   // mutazione ai fini di READONLY (sotto): un nodo dichiarato di sola lettura
   // non emette richieste autenticate su comando di un peer.
-  if (/^\/fleet\/(credentials\/(?:set|remove)|up|down|restart|engine|boot|define-engine|edit-engine|remove-engine|define-model|remove-model|model-test|define-cell|edit-cell|remove-cell|restore-cells|restore-engines)$/.test(resource)) return method === 'POST';
+  if (/^\/fleet\/(credentials\/(?:set|remove)|up|down|restart|engine|boot|define-engine|edit-engine|remove-engine|define-model|edit-model|remove-model|model-test|define-cell|edit-cell|remove-cell|restore-cells|restore-engines)$/.test(resource)) return method === 'POST';
   // Notify: solo POST. `/events` e `/push/*` restano NON federati — SSE non
   // puo' autenticarsi col Bearer.
   //

package/lib/proxy/resource-acl.js

@@ -90,7 +90,7 @@ function classifyResource(resource, method = 'GET') {
   if (/^\/fleet\/(status|schema|definitions|credentials\/status)$/.test(resource)) {
     return m === 'GET' ? 'operator' : null;
   }
-  if (/^\/fleet\/(credentials\/(?:set|remove)|up|down|restart|engine|boot|define-engine|edit-engine|remove-engine|define-model|remove-model|model-test|define-cell|edit-cell|remove-cell|restore-cells|restore-engines)$/.test(resource)) {
+  if (/^\/fleet\/(credentials\/(?:set|remove)|up|down|restart|engine|boot|define-engine|edit-engine|remove-engine|define-model|edit-model|remove-model|model-test|define-cell|edit-cell|remove-cell|restore-cells|restore-engines)$/.test(resource)) {
     return m === 'POST' ? 'operator' : null;
   }
   if (resource === '/decks') return m === 'GET' || m === 'POST' ? 'operator' : null;

package/package.json

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