@mmmbuto/nexuscrew 0.8.7 → 0.8.10

package/lib/decks/store.js

@@ -9,6 +9,7 @@ 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}$/;
+const OWNER_ID_RE = /^[a-f0-9]{16,64}$/;
 
 function validNodeRoute(node) {
   if (!NODE_RE.test(node)) return false;
@@ -48,15 +49,17 @@ function parseLayout(raw) {
     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;
+      if (t.ownerId !== undefined && (typeof t.ownerId !== 'string' || !OWNER_ID_RE.test(t.ownerId))) 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;
+      const key = t.ownerId ? `${t.ownerId}:${t.session}` : 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;
+      if (t.ownerId) tile.ownerId = t.ownerId;
       tiles.push(tile);
     }
     columns.push({ width, tiles });
@@ -118,6 +121,6 @@ function loadOrCreate(p) {
 }
 
 module.exports = {
-  SCHEMA_VERSION, MAX_DECKS, MAX_TILES, NAME_RE,
+  SCHEMA_VERSION, MAX_DECKS, MAX_TILES, NAME_RE, OWNER_ID_RE,
   defaultDecksPath, emptyStore, parseLayout, parseStore, loadStore, loadOrCreate, atomicWrite,
 };

package/lib/fleet/builtin.js

@@ -26,7 +26,7 @@ const path = require('node:path');
 const { execFile } = require('node:child_process');
 const {
   parseDefinitions, validateCommandTrust, resolveCwd,
-  loadDefinitions, atomicWrite, CAPS, validTmuxName,
+  loadDefinitions, atomicWrite, CAPS, MAX_CELLS, validTmuxName,
 } = require('./definitions.js');
 const {
   publicCatalog, describeManaged, resolveManagedEngine, discoverOllamaModels, discoverPiModels,
@@ -56,7 +56,7 @@ function minimalEnv() {
   return env;
 }
 
-function httpError(status, msg) { const e = new Error(msg); e.status = status; return e; }
+function httpError(status, msg, data = null) { const e = new Error(msg); e.status = status; if (data) e.data = data; return e; }
 
 // Marcatore di redazione (design §9h): stderr/stdout dei comandi tmux falliti
 // NON devono mai ecoare i segreti delle definizioni.
@@ -371,6 +371,17 @@ async function createBuiltinFleet(cfg = {}) {
       throw httpError(/duplicate/i.test(launch.stderr) ? 409 : 500, why);
     }
 
+    // `tmux new-session -d` can return 0 even when the launched CLI exits a
+    // moment later (missing login, bad model, incompatible provider).  Without
+    // this readiness gate the PWA reported success and then showed nothing.
+    // Always verify liveness, including cells without a system prompt.
+    const readyMs = cfg.launchReadyMs != null ? cfg.launchReadyMs : 500;
+    const alive = await waitAlive(tmuxBin, cell.tmuxSession, { env: minimalEnv(), readyMs });
+    if (!alive) {
+      cache = { ...cache, at: 0 };
+      throw httpError(500, `client ${launchEngine.command} terminato subito: verifica login, provider, modello e argomenti dell'engine`);
+    }
+
     // (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;
@@ -379,7 +390,7 @@ async function createBuiltinFleet(cfg = {}) {
       const target = paneId.startsWith('%') ? paneId : `=${cell.tmuxSession}`;
       prompt = await injectPrompt(tmuxBin, cell.tmuxSession, cell.prompt, {
         env: minimalEnv(),
-        readyMs: cfg.sendKeysReadyMs != null ? cfg.sendKeysReadyMs : 400,
+        readyMs: cfg.sendKeysReadyMs != null ? cfg.sendKeysReadyMs : readyMs,
         target,
         engine: launchEngine, cell, // per la redazione del reason se paste-buffer fallisce (§9h)
       });
@@ -541,6 +552,59 @@ async function createBuiltinFleet(cfg = {}) {
     const sessions = await refreshSessions();
     return { ok: true, active: sessions.has(findCell(defs, id).tmuxSession) };
   }
+
+  // Ripristino selettivo atomico da backup PWA. Il body contiene SOLO campi
+  // cella allowlisted (mai engine.env/provider secrets). Tutte le celle vengono
+  // validate insieme da atomicWrite: un errore lascia il file precedente intatto.
+  async function restoreCells(cells) {
+    if (readonly()) throw httpError(403, 'READONLY: restore-cells bloccato');
+    if (!Array.isArray(cells) || cells.length < 1 || cells.length > MAX_CELLS) {
+      throw httpError(400, `cells deve contenere 1..${MAX_CELLS} definizioni`);
+    }
+    const allowed = new Set(['id', 'cwd', 'engine', 'boot', 'model', 'models', 'permissionPolicies', 'prompt']);
+    const seen = new Set();
+    for (const cell of cells) {
+      if (!cell || typeof cell !== 'object' || Array.isArray(cell)) throw httpError(400, 'definizione cell non valida');
+      for (const key of Object.keys(cell)) if (!allowed.has(key)) throw httpError(400, `campo backup non ammesso: ${key}`);
+      if (typeof cell.id !== 'string' || seen.has(cell.id)) throw httpError(400, `id cell duplicato o mancante: ${cell.id || '?'}`);
+      seen.add(cell.id);
+    }
+    const defs = reloadDefs();
+    const availableEngines = new Set(defs.engines.map((engine) => engine.id));
+    const referencedEngines = new Set();
+    for (const cell of cells) {
+      referencedEngines.add(cell.engine);
+      for (const id of Object.keys(cell.models || {})) referencedEngines.add(id);
+      for (const id of Object.keys(cell.permissionPolicies || {})) referencedEngines.add(id);
+    }
+    const missingEngines = [...referencedEngines].filter((id) => !availableEngines.has(id)).sort();
+    if (missingEngines.length) {
+      throw httpError(400, `engine mancanti sul target: ${missingEngines.join(', ')}`, {
+        code: 'missing-engines', missingEngines,
+        hint: 'definisci prima gli engine mancanti oppure mappa le celle su engine disponibili',
+      });
+    }
+    const replaced = cells.filter((cell) => !!findCell(defs, cell.id)).map((cell) => cell.id);
+    const created = cells.filter((cell) => !findCell(defs, cell.id)).map((cell) => cell.id);
+    await mutate(defs, (draft) => {
+      for (const cell of cells) {
+        const index = draft.cells.findIndex((current) => current.id === cell.id);
+        const next = { ...cell };
+        if (index >= 0) {
+          // tmuxSession e' identita' runtime immutabile: il backup non la porta.
+          next.tmuxSession = draft.cells[index].tmuxSession;
+          draft.cells[index] = next;
+        } else draft.cells.push(next);
+      }
+    });
+    const sessions = await refreshSessions();
+    const saved = reloadDefs();
+    return {
+      ok: true, count: cells.length, created, replaced,
+      needsRestart: cells.map((cell) => findCell(saved, cell.id))
+        .filter((cell) => cell && sessions.has(cell.tmuxSession)).map((cell) => cell.id),
+    };
+  }
   async function removeCell(id, opts = {}) {
     if (readonly()) throw httpError(403, 'READONLY: remove-cell bloccato');
     let defs = reloadDefs();
@@ -704,7 +768,7 @@ async function createBuiltinFleet(cfg = {}) {
   }
 
   function capabilities() {
-    return ['status', 'up', 'down', 'restart', 'engine', 'boot', 'define', 'edit', 'remove', 'import', 'schema', 'definitions'];
+    return ['status', 'up', 'down', 'restart', 'engine', 'boot', 'define', 'edit', 'remove', 'import', 'restore', 'schema', 'definitions'];
   }
 
   return {
@@ -712,7 +776,7 @@ async function createBuiltinFleet(cfg = {}) {
     provider: 'builtin',
     status, up, down, restart, engine: setEngine, boot: setBoot, isCellSession,
     defineEngine, editEngine, removeEngine,
-    defineCell, editCell, removeCell, importCell,
+    defineCell, editCell, removeCell, importCell, restoreCells,
     schema, definitions, capabilities,
   };
 }

package/lib/fleet/routes.js

@@ -25,7 +25,9 @@ function requireCap(fleet, cap) {
 // async): ogni handler attende la resolve; unavailable → 404 sui comandi.
 function fleetRoutes(fleetP, cfg = {}) {
   const r = express.Router();
-  r.use(express.json({ limit: '4kb' }));
+  const smallJson = express.json({ limit: '4kb' });
+  const restoreJson = express.json({ limit: '256kb' });
+  r.use((req, res, next) => (req.path === '/restore-cells' ? restoreJson : smallJson)(req, res, next));
 
   const readonly = () => (cfg.readonlyDefault === true || process.env.NEXUSCREW_READONLY === '1');
 
@@ -38,7 +40,7 @@ function fleetRoutes(fleetP, cfg = {}) {
       if (!fleet.available) return res.status(404).json({ error: 'fleet non disponibile' });
       res.json(await fn(fleet, req.body || {}));
     } catch (e) {
-      res.status(e.status || 500).json({ error: String(e.message || e) });
+      res.status(e.status || 500).json({ error: String(e.message || e), ...(e.data || {}) });
     }
   };
 
@@ -110,10 +112,19 @@ function fleetRoutes(fleetP, cfg = {}) {
   r.post('/define-cell', guard((f, b) => { requireCap(f, 'define'); return f.defineCell(b.def); }, { mutate: true }));
   r.post('/edit-cell', guard((f, b) => { requireCap(f, 'edit'); return f.editCell(b.id, b.patch); }, { mutate: true }));
   r.post('/remove-cell', guard((f, b) => { requireCap(f, 'remove'); return f.removeCell(b.id, { stop: b.stop === true }); }, { mutate: true }));
+  r.post('/restore-cells', guard((f, b) => { requireCap(f, 'restore'); return f.restoreCells(b.cells); }, { mutate: true }));
   // Riconciliazione sessione tmux esistente (cella Fleet legacy orfana) in cella
   // gestita fleet.json. Capability 'define' (solo builtin): external legacy -> 501.
   r.post('/import-cell', guard(async (f, b) => { requireCap(f, 'import'); return f.importCell(b || {}); }, { mutate: true }));
 
+  r.use((err, _req, res, _next) => {
+    if (err && (err.type === 'entity.too.large' || err.status === 413)) {
+      return res.status(413).json({ error: 'body troppo grande', code: 'body-too-large' });
+    }
+    if (err instanceof SyntaxError) return res.status(400).json({ error: 'JSON non valido', code: 'invalid-json' });
+    return res.status(err.status || 400).json({ error: String(err.message || err) });
+  });
+
   return r;
 }
 

package/lib/mcp/server.js

@@ -71,6 +71,79 @@ function requireSession(session, tool) {
   );
 }
 
+// Deck layout is stored column-major, while the UI is read row-major. Preserve
+// the visual order so an agent sees the same neighbourhood as the operator.
+function orderedDeckMembers(deck) {
+  const columns = deck && deck.layout && Array.isArray(deck.layout.columns)
+    ? deck.layout.columns : [];
+  const rows = Math.max(0, ...columns.map((column) => (
+    column && Array.isArray(column.tiles) ? column.tiles.length : 0
+  )));
+  const out = [];
+  for (let row = 0; row < rows; row += 1) {
+    for (const column of columns) {
+      const tile = column && Array.isArray(column.tiles) ? column.tiles[row] : null;
+      if (!tile || typeof tile.session !== 'string' || !tile.session) continue;
+      const member = { tmuxSession: tile.session };
+      if (typeof tile.node === 'string' && tile.node) member.node = tile.node;
+      if (typeof tile.ownerId === 'string' && NODE_ID_RE.test(tile.ownerId)) member.ownerId = tile.ownerId;
+      out.push(member);
+    }
+  }
+  return out;
+}
+
+const NODE_PART_RE = /^[a-z0-9-]{1,32}$/;
+const NODE_ID_RE = /^[a-f0-9]{16,64}$/;
+function fleetStatusPath(node) {
+  if (!node) return '/api/fleet/status';
+  const parts = String(node).split('/');
+  if (!parts.length || parts.some((part) => !NODE_PART_RE.test(part))
+    || new Set(parts).size !== parts.length) return null;
+  return `/api/route/${parts.map(encodeURIComponent).join('/')}/_/fleet/status`;
+}
+
+function fleetCellsBySession(payload) {
+  const out = new Map();
+  if (!payload || payload.available !== true || !Array.isArray(payload.cells)) return out;
+  for (const cell of payload.cells) {
+    if (!cell || typeof cell.tmuxSession !== 'string' || !cell.tmuxSession
+      || typeof cell.cell !== 'string' || !cell.cell) continue;
+    out.set(cell.tmuxSession, cell.cell);
+  }
+  return out;
+}
+
+function routePath(route, resource) {
+  if (!Array.isArray(route) || !route.length || route.length > 4
+    || route.some((part) => !NODE_PART_RE.test(part)) || new Set(route).size !== route.length) return null;
+  return `/api/route/${route.map(encodeURIComponent).join('/')}/_/${resource}`;
+}
+
+function topologyOwners(payload) {
+  const out = [];
+  const seen = new Set();
+  for (const node of (payload && Array.isArray(payload.nodes) ? payload.nodes : [])) {
+    if (!node || !NODE_ID_RE.test(String(node.instanceId || '')) || seen.has(node.instanceId)
+      || !Array.isArray(node.route) || !routePath(node.route, 'decks')) continue;
+    seen.add(node.instanceId);
+    out.push({
+      instanceId: node.instanceId,
+      route: [...node.route],
+      label: typeof node.label === 'string' && node.label ? node.label : (node.name || node.route.join(' › ')),
+      stale: node.stale === true,
+    });
+  }
+  return out;
+}
+
+function memberOwnerId(member, deckOwner, ownerTopology) {
+  if (member.ownerId && NODE_ID_RE.test(member.ownerId)) return member.ownerId;
+  if (!member.node) return deckOwner.instanceId;
+  const found = ownerTopology.find((node) => Array.isArray(node.route) && node.route.join('/') === member.node);
+  return found ? found.instanceId : null;
+}
+
 // --- definizione tool (prefisso nc_ anti-collisione) ---------------------------
 // annotations.readOnlyHint:true sui tool che non mutano nulla (§1).
 const TOOLS = [
@@ -176,6 +249,94 @@ const TOOLS = [
       return { sessions, fleet };
     },
   },
+  {
+    name: 'nc_deck',
+    description: 'Contesto read-only del deck della sessione chiamante: restituisce i deck che la contengono e i relativi membri con nome cella Fleet, sessione tmux e route.',
+    inputSchema: { type: 'object', properties: {} },
+    annotations: { readOnlyHint: true },
+    async handler(_args, ctx) {
+      const tmuxSession = requireSession(await ctx.session(), 'nc_deck');
+      const [config, topology, localDecks] = await Promise.all([
+        ctx.api('GET', '/api/config'), ctx.api('GET', '/api/topology'), ctx.api('GET', '/api/decks'),
+      ]);
+      const localNodeId = String(config && config.instanceId || '');
+      if (!NODE_ID_RE.test(localNodeId)) throw new Error('instanceId locale non disponibile');
+      if (!localDecks || !Array.isArray(localDecks.decks)) throw new Error('risposta deck non valida');
+
+      const remotes = topologyOwners(topology).filter((owner) => !owner.stale && owner.instanceId !== localNodeId);
+      const viewerById = new Map([[localNodeId, []], ...remotes.map((owner) => [owner.instanceId, owner.route])]);
+      const sources = [{
+        owner: { instanceId: localNodeId, route: [], label: 'Local' },
+        ownerTopology: topologyOwners(topology), decks: localDecks.decks,
+      }];
+      await Promise.all(remotes.map(async (owner) => {
+        const decksPath = routePath(owner.route, 'decks');
+        const topologyPath = routePath(owner.route, 'topology');
+        if (!decksPath || !topologyPath) return;
+        try {
+          const [deckPayload, ownerTopology] = await Promise.all([
+            ctx.api('GET', decksPath), ctx.api('GET', topologyPath).catch(() => ({ nodes: [] })),
+          ]);
+          if (deckPayload && Array.isArray(deckPayload.decks)) {
+            sources.push({ owner, ownerTopology: topologyOwners(ownerTopology), decks: deckPayload.decks });
+          }
+        } catch (_) { /* owner offline/withdrawn: no stale deck disclosure */ }
+      }));
+
+      const decks = [];
+      for (const source of sources) {
+        for (const deck of source.decks) {
+          if (!deck || typeof deck.name !== 'string') continue;
+          const members = orderedDeckMembers(deck).map((member) => ({
+            ...member,
+            ownerId: memberOwnerId(member, source.owner, source.ownerTopology),
+          }));
+          if (!members.some((member) => member.ownerId === localNodeId && member.tmuxSession === tmuxSession)) continue;
+          decks.push({
+            id: `${source.owner.instanceId}:${deck.name}`,
+            name: deck.name,
+            owner: { instanceId: source.owner.instanceId, route: source.owner.route.length ? source.owner.route.join('/') : 'local', label: source.owner.label },
+            members,
+          });
+        }
+      }
+      decks.sort((a, b) => a.owner.route.localeCompare(b.owner.route) || a.name.localeCompare(b.name));
+
+      if (!decks.length) return { tmuxSession, nodeId: localNodeId, decks: [] };
+
+      const routes = new Set(['']);
+      for (const deck of decks) for (const member of deck.members) {
+        const route = member.ownerId && viewerById.has(member.ownerId)
+          ? viewerById.get(member.ownerId).join('/') : null;
+        member.viewerRoute = route;
+        if (route !== null) routes.add(route);
+      }
+      const cellsByRoute = new Map();
+      await Promise.all([...routes].map(async (route) => {
+        const apiPath = fleetStatusPath(route);
+        if (!apiPath) return;
+        try { cellsByRoute.set(route, fleetCellsBySession(await ctx.api('GET', apiPath))); }
+        catch (_) { cellsByRoute.set(route, new Map()); }
+      }));
+
+      return {
+        tmuxSession, nodeId: localNodeId,
+        decks: decks.map((deck) => ({
+          id: deck.id, name: deck.name, owner: deck.owner,
+          members: deck.members.map((member) => {
+            const route = member.viewerRoute;
+            return {
+              cell: route === null ? null : (cellsByRoute.get(route)?.get(member.tmuxSession) || null),
+              tmuxSession: member.tmuxSession,
+              ownerId: member.ownerId,
+              route: route === null ? 'unavailable' : (route || 'local'),
+              self: member.ownerId === localNodeId && member.tmuxSession === tmuxSession,
+            };
+          }),
+        })),
+      };
+    },
+  },
   {
     name: 'nc_inbox',
     description: 'Elenca i file ricevuti nell\'inbox NexusCrew di questa sessione (read-only).',