@mmmbuto/nexuscrew 0.7.7 → 0.8.2

package/lib/decks/store.js

@@ -0,0 +1,123 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+
+const SCHEMA_VERSION = 1;
+const MAX_DECKS = 24;
+const MAX_TILES = 9;
+const NAME_RE = /^[a-z0-9-]{1,32}$/;
+const NODE_RE = /^[a-z0-9-]{1,32}(?:\/[a-z0-9-]{1,32}){0,3}$/;
+
+function validNodeRoute(node) {
+  if (!NODE_RE.test(node)) return false;
+  const parts = node.split('/');
+  return new Set(parts).size === parts.length;
+}
+
+function defaultDecksPath(home) {
+  return path.join(home || os.homedir(), '.nexuscrew', 'decks.json');
+}
+
+function emptyLayout() { return { columns: [] }; }
+function emptyStore() {
+  return { schemaVersion: SCHEMA_VERSION, decks: [{ name: 'main', revision: 0, layout: emptyLayout() }] };
+}
+
+function validText(s, max) {
+  if (typeof s !== 'string' || !s || s.length > max) return false;
+  for (let i = 0; i < s.length; i += 1) {
+    const c = s.charCodeAt(i);
+    if (c <= 0x1f || c === 0x7f) return false;
+  }
+  return true;
+}
+
+function parseLayout(raw) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw) || !Array.isArray(raw.columns)) return null;
+  if (raw.columns.length > MAX_TILES) return null;
+  const seen = new Set();
+  const columns = [];
+  let count = 0;
+  for (const c of raw.columns) {
+    if (!c || typeof c !== 'object' || Array.isArray(c) || !Array.isArray(c.tiles) || !c.tiles.length) return null;
+    const width = Number(c.width);
+    if (!Number.isFinite(width) || width < 0.2 || width > 100) return null;
+    const tiles = [];
+    for (const t of c.tiles) {
+      if (!t || typeof t !== 'object' || Array.isArray(t) || !validText(t.session, 128)) return null;
+      if (t.node !== undefined && (typeof t.node !== 'string' || !validNodeRoute(t.node))) return null;
+      const height = Number(t.height);
+      const fontSize = Number(t.fontSize);
+      if (!Number.isFinite(height) || height < 0.2 || height > 100) return null;
+      if (!Number.isFinite(fontSize) || fontSize < 9 || fontSize > 24) return null;
+      const key = t.node ? `${t.node}:${t.session}` : t.session;
+      if (seen.has(key) || ++count > MAX_TILES) return null;
+      seen.add(key);
+      const tile = { session: t.session, height, fontSize };
+      if (t.node) tile.node = t.node;
+      tiles.push(tile);
+    }
+    columns.push({ width, tiles });
+  }
+  return { columns };
+}
+
+function parseStore(raw) {
+  try {
+    const obj = typeof raw === 'string' ? JSON.parse(raw) : raw;
+    if (!obj || typeof obj !== 'object' || Array.isArray(obj)
+      || obj.schemaVersion !== SCHEMA_VERSION || !Array.isArray(obj.decks)
+      || obj.decks.length < 1 || obj.decks.length > MAX_DECKS) return null;
+    const names = new Set();
+    const decks = [];
+    for (const d of obj.decks) {
+      if (!d || typeof d !== 'object' || !NAME_RE.test(d.name) || names.has(d.name)) return null;
+      if (!Number.isSafeInteger(d.revision) || d.revision < 0) return null;
+      const layout = parseLayout(d.layout);
+      if (!layout) return null;
+      names.add(d.name);
+      decks.push({ name: d.name, revision: d.revision, layout });
+    }
+    if (!names.has('main')) return null;
+    decks.sort((a, b) => (a.name === 'main' ? -1 : b.name === 'main' ? 1 : a.name.localeCompare(b.name)));
+    return { schemaVersion: SCHEMA_VERSION, decks };
+  } catch (_) { return null; }
+}
+
+function loadStore(p) {
+  try {
+    const st = fs.lstatSync(p);
+    if (!st.isFile() || st.isSymbolicLink()) return null;
+    return parseStore(fs.readFileSync(p, 'utf8'));
+  } catch (_) { return null; }
+}
+
+function atomicWrite(p, data) {
+  try {
+    if (fs.lstatSync(p).isSymbolicLink()) throw new Error('refuse symlink decks.json');
+  } catch (e) { if (e.code !== 'ENOENT') throw e; }
+  const parsed = parseStore(data);
+  if (!parsed) throw new Error('decks.json non valido');
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  const tmp = path.join(path.dirname(p), `.${path.basename(p)}.${crypto.randomBytes(6).toString('hex')}.tmp`);
+  try {
+    fs.writeFileSync(tmp, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+    fs.chmodSync(tmp, 0o600);
+    fs.renameSync(tmp, p);
+  } catch (e) { try { fs.unlinkSync(tmp); } catch (_) {} throw e; }
+  return parsed;
+}
+
+function loadOrCreate(p) {
+  const found = loadStore(p);
+  if (found) return found;
+  try { if (fs.existsSync(p)) throw new Error('decks.json presente ma invalido'); } catch (e) { throw e; }
+  return atomicWrite(p, emptyStore());
+}
+
+module.exports = {
+  SCHEMA_VERSION, MAX_DECKS, MAX_TILES, NAME_RE,
+  defaultDecksPath, emptyStore, parseLayout, parseStore, loadStore, loadOrCreate, atomicWrite,
+};

package/lib/files/routes.js

@@ -1,10 +1,15 @@
 'use strict';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const express = require('express');
 const { Router } = require('express');
 const multer = require('multer');
 const store = require('./store.js');
 
 // Router file-exchange. Nessuno stato: tutto deriva da cfg + filesystem.
-function filesRoutes({ cfg, sessionExists, paste }) {
+// notifier (opzionale, MCP bridge): emette la notify di consegna file outbox.
+function filesRoutes({ cfg, sessionExists, paste, notifier, readonly = () => false }) {
   const router = Router();
   const upload = multer({
     storage: multer.memoryStorage(),
@@ -12,6 +17,7 @@ function filesRoutes({ cfg, sessionExists, paste }) {
   });
 
   router.post('/upload', (req, res) => {
+    if (readonly()) return res.status(403).json({ error: 'READONLY: upload bloccato' });
     upload.single('file')(req, res, async (err) => {
       if (err) {
         const status = err.code === 'LIMIT_FILE_SIZE' ? 413 : 400;
@@ -31,6 +37,55 @@ function filesRoutes({ cfg, sessionExists, paste }) {
     });
   });
 
+  // Consegna deliverable dal MCP bridge (nc_send_file): copia un file locale
+  // nell'outbox della sessione mittente. Path sorgente fail-closed: stringa
+  // assoluta, realpath ESISTENTE sotto HOME (i symlink si risolvono PRIMA del
+  // check: un link che esce da HOME viene rifiutato), file regolare.
+  // F3 (audit): gated READONLY — la copia e' una scrittura su disco; il gate
+  // sta PRIMA di ogni altro check (nessun probe di sessione/path in READONLY).
+  const bridgeReadonly = () => (cfg.readonlyDefault === true || process.env.NEXUSCREW_READONLY === '1');
+  router.post('/outbox', express.json({ limit: '8kb' }), (req, res) => {
+    try {
+      if (bridgeReadonly()) {
+        return res.status(403).json({ error: 'READONLY: consegna file bloccata' });
+      }
+      const b = req.body || {};
+      const session = String(b.session || '');
+      if (!store.isValidSession(session) || !sessionExists(session)) {
+        return res.status(404).json({ error: 'sessione tmux inesistente' });
+      }
+      if (typeof b.path !== 'string' || !path.isAbsolute(b.path)) {
+        return res.status(400).json({ error: 'path deve essere assoluto' });
+      }
+      if (b.caption !== undefined && (typeof b.caption !== 'string' || b.caption.length > 500)) {
+        return res.status(400).json({ error: 'caption deve essere una stringa (max 500)' });
+      }
+      const home = cfg.home || os.homedir();
+      let src;
+      try { src = fs.realpathSync(b.path); } catch (_) {
+        return res.status(404).json({ error: 'file sorgente inesistente' });
+      }
+      const homeReal = fs.realpathSync(home);
+      if (src !== homeReal && !src.startsWith(homeReal + path.sep)) {
+        return res.status(400).json({ error: 'path fuori da HOME' });
+      }
+      if (!fs.statSync(src).isFile()) {
+        return res.status(400).json({ error: 'path non e\' un file regolare' });
+      }
+      const saved = store.saveDeliverable(cfg.filesRoot, session, src);
+      if (!saved) return res.status(400).json({ error: 'sessione invalida' });
+      // Notify best-effort (il badge outbox lo genera comunque il watcher).
+      if (notifier) {
+        notifier.emit({
+          title: `file da ${session}`,
+          body: b.caption ? `${saved.name} — ${b.caption}` : saved.name,
+          session,
+        }).catch(() => {});
+      }
+      res.json({ name: saved.name, box: 'outbox', size: saved.size });
+    } catch (e) { res.status(500).json({ error: String(e.message || e) }); }
+  });
+
   router.get('/', (req, res) => {
     const session = String(req.query.session || '');
     if (!store.isValidSession(session)) return res.status(400).json({ error: 'sessione invalida' });
@@ -50,6 +105,7 @@ function filesRoutes({ cfg, sessionExists, paste }) {
   });
 
   router.delete('/', (req, res) => {
+    if (readonly()) return res.status(403).json({ error: 'READONLY: eliminazione file bloccata' });
     const ok = store.removeFile(
       cfg.filesRoot, String(req.query.session || ''), String(req.query.box || ''), String(req.query.name || ''),
     );

package/lib/files/store.js

@@ -77,6 +77,21 @@ function saveUpload(root, session, buffer, origName, now = new Date()) {
   return { name, path: full, size: buffer.length };
 }
 
+// Consegna MCP bridge: copia un file gia' su disco nell'outbox della sessione
+// (badge/watcher scattano da soli). Naming identico a saveUpload (stamp +
+// sanitize + dedup) e COPYFILE_EXCL: mai overwrite. La validazione del path
+// sorgente (assoluto, sotto HOME, realpath) sta nella route, non qui.
+function saveDeliverable(root, session, srcPath, now = new Date()) {
+  const dir = ensureBox(root, session, 'outbox');
+  if (!dir) return null;
+  const base = `${stamp(now)}_${sanitizeName(path.basename(srcPath))}`;
+  let name = base;
+  for (let i = 1; fs.existsSync(path.join(dir, name)); i += 1) name = `${i}-${base}`;
+  const full = path.join(dir, name);
+  fs.copyFileSync(srcPath, full, fs.constants.COPYFILE_EXCL);
+  return { name, path: full, size: fs.statSync(full).size };
+}
+
 function listBox(root, session, box) {
   const dir = boxDir(root, session, box);
   if (!dir) return null;
@@ -123,5 +138,5 @@ function removeFile(root, session, box, name) {
 
 module.exports = {
   isValidSession, sanitizeName, stamp, boxDir, ensureBox,
-  saveUpload, listBox, resolveExisting, removeFile, BOXES,
+  saveUpload, saveDeliverable, listBox, resolveExisting, removeFile, BOXES,
 };

package/lib/fleet/builtin.js

@@ -28,6 +28,9 @@ const {
   parseDefinitions, validateCommandTrust, resolveCwd,
   loadDefinitions, atomicWrite, CAPS,
 } = require('./definitions.js');
+const {
+  publicCatalog, describeManaged, resolveManagedEngine, discoverOllamaModels, discoverPiModels,
+} = require('./managed.js');
 
 const STATUS_TTL_MS = 2000;
 
@@ -183,11 +186,34 @@ async function injectPrompt(tmuxBin, session, prompt, { env, readyMs = 400, targ
 function draftFrom(defs) {
   return {
     schemaVersion: defs.schemaVersion,
-    engines: defs.engines.map((e) => ({ ...e })),
-    cells: defs.cells.map((c) => ({ ...c })),
+    engines: defs.engines.map((e) => ({
+      ...e,
+      ...(e.managed ? { managed: { ...e.managed } } : {}),
+      ...(e.args ? { args: [...e.args] } : {}),
+      ...(e.env ? { env: { ...e.env } } : {}),
+      ...(e.model ? { model: { ...e.model } } : {}),
+    })),
+    cells: defs.cells.map((c) => ({ ...c, ...(c.models ? { models: { ...c.models } } : {}) })),
   };
 }
 
+// Applica engine + modello come un'unica transizione. Ogni engine ricorda il
+// proprio ultimo modello; passando a un altro engine il modello vecchio non
+// attraversa mai il confine.
+function applyCellEngineModel(target, engineId, model, hasModel) {
+  const remembered = { ...(target.models || {}) };
+  target.engine = engineId;
+  if (hasModel) {
+    if (typeof model === 'string' && model) remembered[engineId] = model;
+    else delete remembered[engineId];
+  }
+  const selected = hasModel
+    ? (typeof model === 'string' ? model : '')
+    : (remembered[engineId] || '');
+  if (Object.keys(remembered).length) target.models = remembered; else delete target.models;
+  if (selected) target.model = selected; else delete target.model;
+}
+
 // ---------------------------------------------------------------------------
 // createBuiltinFleet(cfg) — async per parita' di contratto con createFleet.
 // cfg: { fleetDefsPath?, tmuxBin?, home?, builtinEnabled?, readonlyDefault?,
@@ -240,11 +266,28 @@ async function createBuiltinFleet(cfg = {}) {
       const alive = sessions.has(c.tmuxSession);
       return {
         cell: c.id, tmuxSession: c.tmuxSession, engine: c.engine,
+        model: c.model || '', models: { ...(c.models || {}) },
         active: alive, boot: c.boot, tmux: alive,
         rc: '', key: '', degraded: false, // builtin: cella "up" <=> sessione tmux viva
       };
     });
-    const engines = cache.defs.engines.map((e) => ({ id: e.id, label: e.label, rc: !!e.rc }));
+    const needsOllama = cache.defs.engines.some((e) => e.managed?.provider === 'ollama-cloud');
+    const ollamaModels = needsOllama ? await discoverOllamaModels({ ...cfg, home }) : [];
+    const needsPi = cache.defs.engines.some((e) => e.managed?.client === 'pi');
+    const piModels = needsPi ? await discoverPiModels({ ...cfg, home }) : {};
+    const engines = cache.defs.engines.map((e) => {
+      const managed = e.managed ? describeManaged(e.managed, { ...cfg, home }) : null;
+      return {
+        id: e.id, label: e.label, rc: !!e.rc,
+        ...(managed ? {
+          kind: 'managed', client: managed.client, provider: managed.provider,
+          model: e.managed.model || managed.defaultModel || '',
+          models: managed.provider === 'ollama-cloud' ? ollamaModels
+            : (managed.client === 'pi' ? (e.managed.provider === 'custom' ? [e.managed.model] : (piModels[e.managed.provider] || [])) : managed.models),
+          configured: managed.configured, reason: managed.reason,
+        } : { kind: 'custom', configured: true, model: e.model?.value || '', models: [] }),
+      };
+    });
     return {
       available: true,
       provider: 'builtin',
@@ -269,10 +312,16 @@ async function createBuiltinFleet(cfg = {}) {
     if (!cell) throw httpError(400, `cella sconosciuta: ${cellId}`);
     const engine = findEngine(defs, cell.engine);
     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 });
+      if (!resolved.ok) throw httpError(400, `engine managed non configurato (${engine.id}): ${resolved.reason}`);
+      launchEngine = resolved.engine;
+    }
 
     // (2) trust del command PRIMA di lanciare
-    const trust = validateCommandTrust(engine.command);
-    if (!trust.ok) throw httpError(400, `command non trusted (${engine.command}): ${trust.reason}`);
+    const trust = validateCommandTrust(launchEngine.command);
+    if (!trust.ok) throw httpError(400, `command non trusted (${launchEngine.command}): ${trust.reason}`);
     // (3) cwd reale sotto la home
     const realCwd = resolveCwd(cell.cwd, home);
     if (!realCwd) throw httpError(400, `cwd non valida (deve esistere sotto la home): ${cell.cwd}`);
@@ -281,28 +330,28 @@ async function createBuiltinFleet(cfg = {}) {
     // '-P -F #{pane_id}': tmux stampa il pane id della sessione appena creata,
     // cosi' l'iniezione del prompt bersaglia ESATTAMENTE quel pane (audit impl
     // #5: elimina la race di riuso del nome sessione tra waitAlive e paste).
-    const argv = composeLaunchArgv({ tmuxSession: cell.tmuxSession, realCwd, engine, cell });
+    const argv = composeLaunchArgv({ tmuxSession: cell.tmuxSession, realCwd, engine: launchEngine, cell });
     argv.splice(2, 0, '-P', '-F', '#{pane_id}');
     const launch = await tmuxExec(tmuxBin, argv, { env: minimalEnv() });
     if (launch.err) {
       // Redazione (§9h): lo stderr di tmux puo' ecoare argv/env del comando lanciato.
       const why = /duplicate session/i.test(launch.stderr)
         ? 'sessione già in esecuzione'
-        : `tmux new-session failed: ${redactSecrets(launch.stderr.trim() || launch.err.message, engine, cell)}`;
+        : `tmux new-session failed: ${redactSecrets(launch.stderr.trim() || launch.err.message, launchEngine, cell)}`;
       throw httpError(/duplicate/i.test(launch.stderr) ? 409 : 500, why);
     }
 
     // (6) prompt send-keys: bracketed-paste best-effort, target = pane id esatto
     // (fallback al nome sessione con match esatto '=' se tmux non ha stampato l'id).
     let prompt = null;
-    if (engine.promptMode === 'send-keys' && cell.prompt) {
+    if (launchEngine.promptMode === 'send-keys' && cell.prompt) {
       const paneId = launch.stdout.trim().split('\n')[0] || '';
       const target = paneId.startsWith('%') ? paneId : `=${cell.tmuxSession}`;
       prompt = await injectPrompt(tmuxBin, cell.tmuxSession, cell.prompt, {
         env: minimalEnv(),
         readyMs: cfg.sendKeysReadyMs != null ? cfg.sendKeysReadyMs : 400,
         target,
-        engine, cell, // per la redazione del reason se paste-buffer fallisce (§9h)
+        engine: launchEngine, cell, // per la redazione del reason se paste-buffer fallisce (§9h)
       });
     }
     cache = { ...cache, at: 0 };              // invalida: prossimo status rilegge tmux
@@ -332,13 +381,14 @@ async function createBuiltinFleet(cfg = {}) {
     return up(cellId);
   }
 
-  async function setEngine(cellId, engId) {
+  async function setEngine(cellId, engId, opts = {}) {
     if (readonly()) throw httpError(403, 'READONLY: engine bloccato');
     const defs = reloadDefs();
     if (!findCell(defs, cellId)) throw httpError(400, `cella sconosciuta: ${cellId}`);
     if (!findEngine(defs, engId)) throw httpError(400, `engine non valido: ${engId}`);
-    await mutate(defs, (d) => { findCell(d, cellId).engine = engId; });
-    return { ok: true };
+    await mutate(defs, (d) => applyCellEngineModel(findCell(d, cellId), engId, opts.model, typeof opts.model === 'string' && opts.model !== ''));
+    const saved = reloadDefs(); const target = findCell(saved, cellId);
+    return { ok: true, engine: engId, model: target.model || '' };
   }
 
   async function setBoot(cellId, enabled) {
@@ -359,13 +409,31 @@ async function createBuiltinFleet(cfg = {}) {
     await mutate(reloadDefs(), (d) => { d.engines.push(def); });
     return { ok: true, id: def.id };
   }
-  async function editEngine(id, patch) {
+  async function editEngine(id, patch, envChanges) {
     if (readonly()) throw httpError(403, 'READONLY: edit-engine bloccato');
     if (!id) throw httpError(400, 'id engine mancante');
     const defs = reloadDefs();
     if (!findEngine(defs, id)) throw httpError(400, `engine inesistente: ${id}`);
-    await mutate(defs, (d) => { Object.assign(findEngine(d, id), patch || {}); });
-    return { ok: true };
+    if (patch && (Object.prototype.hasOwnProperty.call(patch, 'id') || Object.prototype.hasOwnProperty.call(patch, 'env'))) {
+      throw httpError(400, 'id ed env non sono modificabili tramite patch generica');
+    }
+    await mutate(defs, (d) => {
+      const target = findEngine(d, id);
+      for (const [key, value] of Object.entries(patch || {})) {
+        if (value === null) delete target[key]; else target[key] = value;
+      }
+      if (envChanges !== undefined) {
+        if (!envChanges || typeof envChanges !== 'object' || Array.isArray(envChanges)) throw httpError(400, 'envChanges non valido');
+        const next = { ...(target.env || {}) };
+        for (const key of Array.isArray(envChanges.remove) ? envChanges.remove : []) delete next[key];
+        if (envChanges.set && typeof envChanges.set === 'object' && !Array.isArray(envChanges.set)) {
+          for (const [key, value] of Object.entries(envChanges.set)) next[key] = value;
+        }
+        target.env = next;
+      }
+    });
+    const sessions = await refreshSessions();
+    return { ok: true, activeCells: defs.cells.filter((c) => c.engine === id && sessions.has(c.tmuxSession)).map((c) => c.id) };
   }
   async function removeEngine(id) {
     if (readonly()) throw httpError(403, 'READONLY: remove-engine bloccato');
@@ -373,7 +441,14 @@ async function createBuiltinFleet(cfg = {}) {
     if (!findEngine(defs, id)) throw httpError(400, `engine inesistente: ${id}`);
     const used = defs.cells.filter((c) => c.engine === id);
     if (used.length) throw httpError(400, `engine in uso da ${used.length} cella/e: rimuovi prima la cella`);
-    await mutate(defs, (d) => { d.engines = d.engines.filter((e) => e.id !== id); });
+    await mutate(defs, (d) => {
+      d.engines = d.engines.filter((e) => e.id !== id);
+      for (const cell of d.cells) {
+        if (!cell.models || !Object.prototype.hasOwnProperty.call(cell.models, id)) continue;
+        delete cell.models[id];
+        if (!Object.keys(cell.models).length) delete cell.models;
+      }
+    });
     return { ok: true };
   }
 
@@ -389,17 +464,54 @@ async function createBuiltinFleet(cfg = {}) {
     if (!id) throw httpError(400, 'id cell mancante');
     const defs = reloadDefs();
     if (!findCell(defs, id)) throw httpError(400, `cell inesistente: ${id}`);
-    await mutate(defs, (d) => { Object.assign(findCell(d, id), patch || {}); });
-    return { ok: true };
+    if (patch && (Object.prototype.hasOwnProperty.call(patch, 'id') || Object.prototype.hasOwnProperty.call(patch, 'tmuxSession'))) {
+      throw httpError(400, 'id e tmuxSession sono immutabili');
+    }
+    await mutate(defs, (d) => {
+      const target = findCell(d, id);
+      const hasEngine = typeof patch?.engine === 'string';
+      const hasModel = Object.prototype.hasOwnProperty.call(patch || {}, 'model');
+      for (const [key, value] of Object.entries(patch || {})) {
+        if (key === 'engine' || key === 'model') continue;
+        if (value === null) delete target[key]; else target[key] = value;
+      }
+      if (hasEngine || hasModel) applyCellEngineModel(target, hasEngine ? patch.engine : target.engine, patch?.model, hasModel);
+    });
+    const sessions = await refreshSessions();
+    return { ok: true, active: sessions.has(findCell(defs, id).tmuxSession) };
   }
-  async function removeCell(id) {
+  async function removeCell(id, opts = {}) {
     if (readonly()) throw httpError(403, 'READONLY: remove-cell bloccato');
-    const defs = reloadDefs();
-    if (!findCell(defs, id)) throw httpError(400, `cell inesistente: ${id}`);
+    let defs = reloadDefs();
+    const cell = findCell(defs, id);
+    if (!cell) throw httpError(400, `cell inesistente: ${id}`);
+    const sessions = await refreshSessions();
+    if (sessions.has(cell.tmuxSession)) {
+      if (opts.stop !== true) throw httpError(409, 'cell attiva: conferma stop e rimozione');
+      await down(id);
+      defs = reloadDefs();
+    }
     await mutate(defs, (d) => { d.cells = d.cells.filter((c) => c.id !== id); });
     return { ok: true };
   }
 
+  // Vista editabile ma secret-safe: gli env values restano write-only.
+  function definitions() {
+    const defs = reloadDefs();
+    return {
+      schemaVersion: defs.schemaVersion,
+      engines: defs.engines.map((e) => {
+        const out = { ...e, envKeys: Object.keys(e.env || {}).sort() };
+        delete out.env;
+        if (e.managed) out.managedInfo = describeManaged(e.managed, { ...cfg, home });
+        return out;
+      }),
+      cells: defs.cells.map((c) => ({ ...c, ...(c.models ? { models: { ...c.models } } : {}) })),
+      managedCatalog: publicCatalog(),
+      managedConfig: { providerSecretsPath: cfg.providerSecretsPath || path.join(home, '.nexuscrew', 'providers.env') },
+    };
+  }
+
   // Scrive il draft mutato; atomicWrite valida PRIMA (fail-closed). Su input
   // invalido: backup predecessore + throw -> httpError(400) (mai garbage).
   async function mutate(defs, mutator) {
@@ -421,10 +533,24 @@ async function createBuiltinFleet(cfg = {}) {
       schemaVersion: 1,
       caps: CAPS,
       engine: {
+        kind: { type: 'enum', values: ['managed', 'custom'], default: 'managed' },
         id: { type: 'string', required: true, pattern: '^[a-z0-9._-]{1,32}$', max: 32 },
         label: { type: 'string', required: false, max: CAPS.MAX_LABEL_LEN, default: '<id>' },
         rc: { type: 'boolean', required: false, default: false },
-        command: { type: 'string', required: true, max: CAPS.MAX_COMMAND_LEN, absolute: true },
+        managed: {
+          type: 'object', requiredFor: 'managed',
+          client: { type: 'enum', values: ['claude', 'codex', 'codex-vl', 'pi'] },
+          provider: { type: 'catalog', source: 'managedCatalog' },
+          credentialProfile: { type: 'string', required: false, max: 32 },
+          model: { type: 'string', required: false, max: CAPS.MAX_MODEL_VAL_LEN },
+          permissionPolicy: { type: 'enum', values: ['standard', 'unsafe'], default: 'standard' },
+          displayName: { type: 'string', requiredFor: 'provider=custom', max: CAPS.MAX_LABEL_LEN },
+          protocol: { type: 'catalog', source: 'managedCatalog.protocol' },
+          baseUrl: { type: 'string', requiredFor: 'provider=custom', max: CAPS.MAX_COMMAND_LEN },
+          envKey: { type: 'string', requiredFor: 'provider=custom', pattern: '^[A-Za-z_][A-Za-z0-9_]{0,63}$' },
+          providerId: { type: 'string', requiredFor: 'provider=custom', pattern: '^[a-z][a-z0-9_-]{0,31}$' },
+        },
+        command: { type: 'string', requiredFor: 'custom', max: CAPS.MAX_COMMAND_LEN, absolute: true },
         args: { type: 'array', of: 'string', required: false, max: CAPS.MAX_ARGS, itemMax: CAPS.MAX_ARG_LEN },
         env: {
           type: 'object', required: false, maxKeys: CAPS.MAX_ENV_KEYS,
@@ -448,13 +574,14 @@ async function createBuiltinFleet(cfg = {}) {
         engine: { type: 'string', required: true, ref: 'engine.id' },
         boot: { type: 'boolean', required: false, default: false },
         model: { type: 'string', required: false, max: CAPS.MAX_MODEL_VAL_LEN },
+        models: { type: 'object', required: false, keyRef: 'engine.id', valueMax: CAPS.MAX_MODEL_VAL_LEN },
         prompt: { type: 'string', required: false, max: CAPS.MAX_PROMPT_LEN },
       },
     };
   }
 
   function capabilities() {
-    return ['status', 'up', 'down', 'restart', 'engine', 'boot', 'define', 'edit', 'remove', 'schema'];
+    return ['status', 'up', 'down', 'restart', 'engine', 'boot', 'define', 'edit', 'remove', 'schema', 'definitions'];
   }
 
   return {
@@ -463,7 +590,7 @@ async function createBuiltinFleet(cfg = {}) {
     status, up, down, restart, engine: setEngine, boot: setBoot, isCellSession,
     defineEngine, editEngine, removeEngine,
     defineCell, editCell, removeCell,
-    schema, capabilities,
+    schema, definitions, capabilities,
   };
 }
 

package/lib/fleet/definitions.js

@@ -11,6 +11,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
+const { normalizeManagedSpec } = require('./managed.js');
 
 // --- Cap + identita' (dichiarati; ragionevoli per un file di flotta locale) ---
 const SCHEMA_VERSION = 1;
@@ -145,6 +146,17 @@ function parseEngine(e) {
     rc = e.rc;
   }
 
+  // Managed: NexusCrew conosce client/provider e compone internamente il
+  // processo. Nessun command/env/argv o segreto vive nella definizione.
+  if (e.managed !== undefined) {
+    const managed = normalizeManagedSpec(e.managed);
+    if (!managed) return null;
+    for (const key of ['command', 'args', 'env', 'promptMode', 'promptFlag', 'model']) {
+      if (e[key] !== undefined) return null;
+    }
+    return { id: e.id, label, rc, managed };
+  }
+
   // command (obbligatorio, stringa non vuota; il trust si verifica a parte)
   if (typeof e.command !== 'string' || !e.command || e.command.length > MAX_COMMAND_LEN) return null;
 
@@ -229,6 +241,19 @@ function parseCell(c, engineIds) {
     model = c.model;
   }
 
+  // Ultimo modello per engine, persistito per cella. Consente di tornare a un
+  // provider e ritrovare la scelta precedente senza trascinarla su altri engine.
+  let models = {};
+  if (c.models !== undefined) {
+    if (!c.models || typeof c.models !== 'object' || Array.isArray(c.models)) return null;
+    const entries = Object.entries(c.models);
+    if (entries.length > MAX_ENGINES) return null;
+    for (const [engineId, value] of entries) {
+      if (!engineIds.has(engineId) || typeof value !== 'string' || !value || value.length > MAX_MODEL_VAL_LEN) return null;
+      models[engineId] = value;
+    }
+  }
+
   // prompt (opzionale, cap)
   let prompt;
   if (c.prompt !== undefined) {
@@ -254,6 +279,7 @@ function parseCell(c, engineIds) {
 
   const out = { id: c.id, cwd: c.cwd, engine: c.engine, boot, tmuxSession };
   if (model !== undefined) out.model = model;
+  if (Object.keys(models).length) out.models = models;
   if (prompt !== undefined) out.prompt = prompt;
   return out;
 }