@mmmbuto/nexuscrew 0.9.32 → 0.9.34

package/frontend/dist/index.html

@@ -11,7 +11,7 @@
   <meta name="apple-mobile-web-app-title" content="NexusCrew" />
   <link rel="manifest" href="/manifest.json" />
   <title>NexusCrew</title>
-  <script type="module" crossorigin src="/assets/index-CH2iAu6y.js"></script>
+  <script type="module" crossorigin src="/assets/index-5eCvm3HF.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-DqCfZFGi.css">
 </head>
 <body>

package/frontend/dist/version.json

@@ -1 +1 @@
-{"version":"0.9.32"}
+{"version":"0.9.34"}

package/lib/fleet/builtin.js

@@ -34,11 +34,12 @@ const {
   aggiornaDefinizioni,
   cellIdFromTmuxSession,
   resolveCwd, normalizeCwdRel, deriveCwdRel,
+  effectiveCapabilities,
 } = require('./definitions.js');
 const {
   publicCatalog, describeManaged, describeCatalogCredential, defaultShellEngine, defaultAgyEngine, defaultKimiEngine, defaultGrokEngine, defaultVlEngine,
   CATALOG, credential: resolveProfileCredential, extraModelsFrom, knownMcpServerNames, profileFor,
-  normalizeManagedSpec,
+  normalizeManagedSpec, codexSurfaceNames,
 } = require('./managed.js');
 const { probeModel, probeCustomEndpoint } = require('./model-probe.js');
 const { sharedProbe: defaultEndpointProbe } = require('./endpoint-probe.js');
@@ -935,6 +936,51 @@ async function createBuiltinFleet(cfg = {}) {
     return { ok: true, id: wantedId, engine: wantedEngine };
   }
 
+  // I campi non-identita' che `parseModel` ammette per una dichiarazione:
+  // id ed engine SONO l'identita' (il chiaro per cui esiste edit-model e' non
+  // doverla ritoccare), tutto il resto e' patchabile con la stessa validazione.
+  const EDIT_MODEL_FIELDS = new Set(['label', 'contextWindow', 'maxTokens', 'reasoning']);
+
+  async function editModel(id, engine, patch) {
+    if (readonly()) throw httpError(403, 'READONLY: edit-model bloccato');
+    const wantedId = String(id || '').trim();
+    const wantedEngine = String(engine || '').trim();
+    if (!wantedId || !wantedEngine) throw httpError(400, 'id e engine sono obbligatori');
+    if (!patch || typeof patch !== 'object' || Array.isArray(patch)) throw httpError(400, 'patch mancante');
+    const keys = Object.keys(patch);
+    if (!keys.length) throw httpError(400, 'patch vuota: niente da modificare');
+    for (const key of keys) {
+      if (!EDIT_MODEL_FIELDS.has(key)) throw httpError(400, `campo non ammesso per edit-model: ${key}`);
+    }
+    if (patch.label !== undefined) {
+      if (typeof patch.label !== 'string' || !patch.label.trim() || patch.label.trim().length > 64) {
+        throw httpError(400, 'label non valida: stringa non vuota, massimo 64 caratteri');
+      }
+    }
+    for (const key of ['contextWindow', 'maxTokens']) {
+      if (patch[key] !== undefined && (!Number.isSafeInteger(patch[key]) || patch[key] < 1)) {
+        throw httpError(400, `${key} non valido: intero >= 1`);
+      }
+    }
+    if (patch.reasoning !== undefined && typeof patch.reasoning !== 'boolean') {
+      throw httpError(400, 'reasoning non valido: booleano');
+    }
+    const defs = reloadDefs();
+    if (!(defs.models || []).some((m) => m.id === wantedId && m.engine === wantedEngine)) {
+      throw httpError(404, `modello non dichiarato: ${wantedId} su ${wantedEngine}`);
+    }
+    // La scrittura passa da `mutate`, che rilegge e RIVALIDA l'intero file: la
+    // validazione completa resta quella del parser (contextWindow >= 1024 fino
+    // al cap, label entro il limite) e un valore fuori schema non entra. Gli
+    // engine che risolvono questo modello NON vengono toccati: la dichiarazione
+    // e' la stessa riga del file, l'engine non ha nulla da ricaricare.
+    await mutate(defs, (d) => {
+      const target = d.models.find((m) => m.id === wantedId && m.engine === wantedEngine);
+      Object.assign(target, patch);
+    });
+    return { ok: true, id: wantedId, engine: wantedEngine, edited: keys };
+  }
+
   async function editEngine(id, patch, envChanges) {
     if (readonly()) throw httpError(403, 'READONLY: edit-engine bloccato');
     if (!id) throw httpError(400, 'id engine mancante');
@@ -1324,6 +1370,43 @@ async function createBuiltinFleet(cfg = {}) {
           ...(c.permissionPolicies ? { permissionPolicies: { ...c.permissionPolicies } } : {}),
           ...(c.commands ? { commands: { ...c.commands } } : {}),
         };
+        // Superficie dichiarata (solo vista): una cella LEGACY (niente
+        // capabilities, niente profilo) e' la cella di sempre — esce con
+        // `legacy: true` e nessun campo capabilities; una cella dichiarata
+        // esce con la fusione profilo+override (sostitutivo per chiave) e con
+        // le chiavi che il materializzatore NON copre per il suo engine
+        // segnate come `unsupported` (motivo leggibile, MAI un errore). Il
+        // materializzatore per engine arriva per fasi: qui la dichiarazione
+        // onesta di cosa viene davvero materializzato.
+        const eff = effectiveCapabilities(c, defs);
+        out.legacy = eff.legacy;
+        if (!eff.legacy) {
+          const client = (defs.engines.find((e) => e.id === c.engine) || {}).managed?.client || null;
+          const materializzaMcp = client === 'claude' || client === 'codex' || client === 'codex-vl';
+          const materializzaOndemand = client === 'codex' || client === 'codex-vl';
+          const nonMaterializzate = {
+            mcp: `nessun materializzatore MCP per questo engine in questa fase (client: ${client || 'sconosciuto'})`,
+            skills: 'le skill non sono ancora materializzate per cella (fase successiva)',
+            ondemand: 'la materializzazione on-demand arriva in una fase successiva',
+          };
+          const unsupported = Object.keys(eff.declared)
+            .filter((key) => !(key === 'mcp' && materializzaMcp) && !(key === 'ondemand' && materializzaOndemand))
+            .map((key) => ({ key, reason: nonMaterializzate[key] }));
+          // Per codex/codex-vl un nome ondemand che NON e' nella config utente
+          // del nodo viene ignorato dal profilo (TOML non scrive tabelle per
+          // server sconosciuti): la vista lo dice al punto, invece di farlo
+          // scoprire all'operatore quando la capability non risponde.
+          if ((client === 'codex' || client === 'codex-vl') && eff.declared.ondemand?.length) {
+            try {
+              const toml = fs.readFileSync(path.join(home, '.codex', 'config.toml'), 'utf8');
+              const noti = new Set(codexSurfaceNames(toml).servers);
+              for (const nome of eff.declared.ondemand.filter((n) => !noti.has(n))) {
+                unsupported.push({ key: 'ondemand', name: nome, reason: `il server on-demand "${nome}" non e' dichiarato nella config utente del nodo: ignorato dal profilo` });
+              }
+            } catch (_) { /* config utente non leggibile: nessuna nota, non e' un errore di vista */ }
+          }
+          out.capabilities = { declared: eff.declared, ...(unsupported.length ? { unsupported } : {}) };
+        }
         // cwdRel portatile derivato (solo vista): per celle valide (cwd reale
         // sotto home) espone il rel canonico; per celle persistite ma non
         // valide/fuori home espone needsRepair:true. NESSUNA mutazione di
@@ -1485,12 +1568,33 @@ async function createBuiltinFleet(cfg = {}) {
         // Nome leggibile, distinto dall'id: quest'ultimo resta la chiave di
         // indirizzamento e l'unica origine della sessione tmux.
         label: { type: 'string', required: false, max: CAPS.MAX_LABEL_LEN },
+        // Superficie operativa dichiarata della cella. Assenti entrambi = cella
+        // legacy (comportamento di sempre). Il profilo alimenta le chiavi che
+        // la cella non copre; l'override della cella sostituisce PER CHIAVE.
+        capabilities: {
+          type: 'object', required: false,
+          mcp: { type: 'array', of: 'string', required: false, max: 64, itemPattern: '^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$' },
+          skills: { type: 'array', of: 'string', required: false, max: 64, itemPattern: '^[a-z0-9][a-z0-9._-]{0,63}$' },
+          ondemand: { type: 'array', of: 'string', required: false, max: 64, itemPattern: '^[a-z0-9][a-z0-9._-]{0,63}$' },
+        },
+        capabilityProfile: { type: 'string', required: false, ref: 'capabilityProfiles.id', max: 32 },
+      },
+      // Profili di ruolo condivisi del documento (top-level, accanto a
+      // engines/cells): stessa forma del set di cella, referenziabili per nome.
+      capabilityProfiles: {
+        type: 'object', required: false, maxKeys: 32,
+        keyPattern: '^[A-Za-z0-9._-]{1,32}$',
+        valueShape: {
+          mcp: { type: 'array', of: 'string', required: false, max: 64, itemPattern: '^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$' },
+          skills: { type: 'array', of: 'string', required: false, max: 64, itemPattern: '^[a-z0-9][a-z0-9._-]{0,63}$' },
+          ondemand: { type: 'array', of: 'string', required: false, max: 64, itemPattern: '^[a-z0-9][a-z0-9._-]{0,63}$' },
+        },
       },
     };
   }
 
   function capabilities() {
-    return ['status', 'up', 'down', 'restart', 'engine', 'boot', 'define', 'edit', 'remove', 'import', 'restore', 'schema', 'definitions', 'credentials', 'model-test'];
+    return ['status', 'up', 'down', 'restart', 'engine', 'boot', 'define', 'edit', 'remove', 'import', 'restore', 'schema', 'definitions', 'credentials', 'model-test', 'edit-model'];
   }
 
   // Un engine del documento con un `baseUrl` dichiarato a mano: indirizzo e
@@ -1566,7 +1670,7 @@ async function createBuiltinFleet(cfg = {}) {
     defineCell, editCell, removeCell, importCell, restoreCells, restoreEngines,
     schema, definitions, capabilities,
     credentialStatus, setLocalCredential, removeLocalCredential, testModel,
-    defineModel, removeModel, close,
+    defineModel, editModel, removeModel, close,
     // Fetta 2b: il lease Live esposto alle route /api/lease, che il bridge
     // MCP delle celle consuma per register/refresh/recovery. Assente se il
     // lease e' disattivato: le route rispondono 501, non 500.

package/lib/fleet/causes.js

@@ -37,6 +37,9 @@ const CODES = [
   'CWD_INVALID',
   'ENGINE_UNCONFIGURED',
   'SHELL_NOT_AVAILABLE',
+  'MCP_CELL_FILE_UNWRITABLE',
+  'CAPABILITY_PROFILE_UNWRITABLE',
+  'CAPABILITY_UNKNOWN_NAME',
   // launch-broker
   'LAUNCH_BROKER_UNSAFE',
   'LAUNCH_BROKER_PAYLOAD',

package/lib/fleet/cell-exec.js

@@ -632,10 +632,10 @@ async function main(argv = process.argv.slice(2), seams = {}) {
           ? ['inherit', 'inherit', 'inherit', 'pipe', 'pipe']
           : ['inherit', 'inherit', 'inherit'],
       });
-      // R1a (fix5): exit/error del figlio contano SUBITO, prima di qualunque
-      // await — se il figlio esce durante l'handshake di generazione, l'evento
-      // non deve andare perso (prima i listener arrivavano solo con waitChild,
-      // e il supervisore restava appeso).
+      // exit/error del figlio contano SUBITO, prima di qualunque await — se
+      // il figlio esce durante l'handshake di generazione, l'evento non deve
+      // andare perso (prima i listener arrivavano solo con waitChild, e il
+      // supervisore restava appeso).
       let childSettled = false;
       const childExit = new Promise((resolve) => {
         current.once('exit', (code, signal) => {
@@ -649,16 +649,16 @@ async function main(argv = process.argv.slice(2), seams = {}) {
       });
       // Transizione di generazione comunicata al lease PRIMA di aprire il
       // canale identita' della generazione nuova. L'exit del figlio ha la
-      // precedenza sull'annuncio; FAIL-CLOSED (R1b): solo un annuncio
-      // RISOLTO con ok === true E generazione corrispondente apre il canale —
-      // ok:false (lease-down, identity-unverified), rifiuto, timeout ed exit
-      // restano tutti negativi, con sola diagnostica: il figlio parte
-      // comunque, senza identita'.
+      // precedenza sull'annuncio; fail-closed: solo un annuncio RISOLTO con
+      // ok === true E generazione corrispondente apre il canale — ok:false
+      // (lease-down, identity-unverified), rifiuto, timeout ed exit restano
+      // tutti negativi, con sola diagnostica: il figlio parte comunque,
+      // senza identita'.
       if (leaseCtl && generation > 0) {
         const raced = await Promise.race([
-          // fix 6 (R1b-bis): il valore RISOLTO va ispezionato.
-          // Prima: .then(() => 'ok', ...) scartava il valore e trattava un
-          // annuncio risolto {ok:false} come successo, aprendo il canale.
+          // Il valore RISOLTO va ispezionato: .then(() => 'ok', ...) scartava
+          // il valore e trattava un annuncio risolto {ok:false} come successo,
+          // aprendo il canale.
           leaseCtl.announceGeneration(generation).then(
             (announced) => (announced && announced.ok === true && announced.generation === generation
               ? 'ok'

package/lib/fleet/cell-lease-server.js

@@ -426,10 +426,10 @@ function createLeaseManager(cfg = {}, seams = {}) {
       writeSafe(socket, { type: 'generationDeny', generation: msg.generation });
       return;
     }
-    // R1b: l'avanzamento PRIMA dell'ACK e' voluto (at-least-once): se l'ACK
-    // si perde, il client ritenta con la STESSA generazione e qui e'
-    // idempotente (== corrente -> ACK). L'ordine inverso lascerebbe il server
-    // stantio con un client che crede di aver transizionato.
+    // L'avanzamento PRIMA dell'ACK e' voluto (at-least-once): se l'ACK si
+    // perde, il client ritenta con la STESSA generazione e qui e' idempotente
+    // (== corrente -> ACK). L'ordine inverso lascerebbe il server stantio con
+    // un client che crede di aver transizionato.
     entry.lease.generation = msg.generation;
     writeSafe(socket, { type: 'generationAck', generation: msg.generation });
   }

package/lib/fleet/definitions.js

@@ -39,6 +39,18 @@ const MCP_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/;
 const MAX_CELL_COMMAND_LEN = 4096;
 const MAX_TMUXSESSION_LEN = 64;
 
+// Capacita' dichiarate di una cella, per NOME (come `mcp`, che ne e' il caso
+// particolare e l'alias legacy). Tre chiavi: `mcp` (server MCP), `skills`,
+// `ondemand`. Profili di ruolo condivisi in `capabilityProfiles` (top-level del
+// documento); la cella riferisce un profilo e puo' sostituire SINGOLE CHIAVI
+// con il proprio set: l'override e' sostitutivo, non additivo, perche' unire
+// non saprebbe togliere.
+const MAX_CAPABILITIES = 64;       // nomi per singola chiave
+const MAX_CAPABILITY_PROFILES = 32; // profili dichiarabili nel documento
+const CAPABILITY_KEYS = ['mcp', 'skills', 'ondemand'];
+const CAPABILITY_NAME_RE = /^[a-z0-9][a-z0-9._-]{0,63}$/;  // skill/ondemand: slug
+const CAPABILITY_KEY_RES = { mcp: MCP_NAME_RE, skills: CAPABILITY_NAME_RE, ondemand: CAPABILITY_NAME_RE };
+
 const ENGINE_ID_RE = /^[a-z0-9._-]{1,32}$/;   // engine id: lowercase (design 4a/9f)
 const CELL_ID_RE = /^[A-Za-z0-9._-]{1,32}$/;   // cell id: ammette maiuscole (il punto e' un id umano valido)
 const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/; // identificatore env POSIX-like
@@ -279,6 +291,30 @@ function parseDefinitions(raw, { allowLegacyTmuxNames = true, onReject = null, o
       engines.push(eng);
     }
 
+    // I profili di capability si leggono PRIMA delle celle: una cella riferisce
+    // un profilo per NOME, e leggerli dopo la farebbe rifiutare per un dato che
+    // in realta' c'e'. `capabilityProfiles` e' opzionale: senza, il documento
+    // resta com'era (chiave assente, non vuota).
+    let capabilityProfiles;
+    if (d.capabilityProfiles !== undefined) {
+      if (!d.capabilityProfiles || typeof d.capabilityProfiles !== 'object' || Array.isArray(d.capabilityProfiles)) return null;
+      const voci = Object.entries(d.capabilityProfiles);
+      if (voci.length > MAX_CAPABILITY_PROFILES) {
+        if (typeof onIssue === 'function') onIssue({ field: 'capabilityProfiles', value: voci.length, rule: `troppi profili di capability dichiarati, cap ${MAX_CAPABILITY_PROFILES}` });
+        return reject(`fleet.json rifiutato: ${voci.length} profili di capability dichiarati, cap ${MAX_CAPABILITY_PROFILES}; riduci i profili a ${MAX_CAPABILITY_PROFILES} o meno`);
+      }
+      capabilityProfiles = {};
+      for (const [nome, profilo] of voci) {
+        // Il nome e' un identificatore (finira' in riferimento per cella e, poi,
+        // in un nome di file generato): stessa forma chiusa dell'id cella.
+        if (typeof nome !== 'string' || !CELL_ID_RE.test(nome) || capabilityProfiles[nome] !== undefined) return null;
+        const set = parseCapabilitySet(profilo, onIssue);
+        if (!set) return null;
+        capabilityProfiles[nome] = set;
+      }
+    }
+    const capabilityProfileNames = capabilityProfiles ? new Set(Object.keys(capabilityProfiles)) : null;
+
     const tmuxSeen = new Set();
     const legacyTmuxSeen = new Set();
     const legacyTmuxSessions = new Map();
@@ -286,7 +322,7 @@ function parseDefinitions(raw, { allowLegacyTmuxNames = true, onReject = null, o
     const cells = [];
     for (const c of d.cells) {
       const cell = parseCell(c, engineIds, engineMap, {
-        allowLegacyTmuxNames, extraModels, onReject: reject, onIssue,
+        allowLegacyTmuxNames, extraModels, onReject: reject, onIssue, capabilityProfileNames,
       });
       if (!cell) return null;
       if (cellIds.has(cell.id)) return null;             // id cell univoco
@@ -301,11 +337,12 @@ function parseDefinitions(raw, { allowLegacyTmuxNames = true, onReject = null, o
       cells.push(cell);
     }
 
-    // `models` compare solo se dichiarato: una configurazione senza modelli
-    // resta byte-identica a prima, e l'aggiornamento non riscrive nulla.
-    const parsed = models.length
-      ? { schemaVersion: SCHEMA_VERSION, engines, cells, models }
-      : { schemaVersion: SCHEMA_VERSION, engines, cells };
+    // `models` e `capabilityProfiles` compaiono solo se dichiarati: una
+    // configurazione senza resta byte-identica a prima, e l'aggiornamento non
+    // riscrive nulla.
+    const parsed = { schemaVersion: SCHEMA_VERSION, engines, cells };
+    if (models.length) parsed.models = models;
+    if (capabilityProfiles) parsed.capabilityProfiles = capabilityProfiles;
     // Metadato solo in memoria: serve al bootstrap per rinominare una sessione
     // legacy PRIMA di persistere il nome safe. Non entra in JSON, draft o API.
     Object.defineProperty(parsed, 'legacyTmuxSessions', {
@@ -462,8 +499,50 @@ function cellModelAllowed(engineId, model, engineMap, extraModels, onIssue) {
   return !!normalizeManagedSpec({ ...engine.managed, model }, { extraModels, engineId, onIssue });
 }
 
+// Un set di capability (di profilo o di cella): oggetto le cui chiavi ammesse
+// sono CAPABILITY_KEYS, ciascuna un array di nomi VALIDATI PER CHIAVE, senza
+// duplicati, sotto cap. Chiave non ammessa -> rifiuto dell'intero set: come
+// per panelUrl, due esiti opposti che si assomigliano non collassano in uno.
+function parseCapabilitySet(v, onIssue = null) {
+  if (!v || typeof v !== 'object' || Array.isArray(v)) return null;
+  const out = {};
+  for (const key of Object.keys(v)) {
+    if (!CAPABILITY_KEYS.includes(key)) return null;
+    const arr = v[key];
+    if (!Array.isArray(arr) || arr.length > MAX_CAPABILITIES) {
+      if (typeof onIssue === 'function') onIssue({ field: `capabilities.${key}`, value: Array.isArray(arr) ? arr.length : -1, rule: `troppi nomi, cap ${MAX_CAPABILITIES}` });
+      return null;
+    }
+    const visti = new Set();
+    for (const nome of arr) {
+      if (typeof nome !== 'string' || !CAPABILITY_KEY_RES[key].test(nome) || visti.has(nome)) return null;
+      visti.add(nome);
+    }
+    out[key] = [...visti];
+  }
+  return out;
+}
+
+// La superficie effettiva di una cella: il profilo alimenta le chiavi che la
+// cella non copre, e l'override della cella SOSTITUISCE per chiave (unire non
+// saprebbe togliere). LEGACY = nessun campo: la cella di sempre, comportamento
+// invariato. Pura: la vista e i materializzatori la usano senza toccare nulla.
+function effectiveCapabilities(cell, defs) {
+  const profili = (defs && defs.capabilityProfiles) || {};
+  const profilo = cell && cell.capabilityProfile !== undefined ? profili[cell.capabilityProfile] : undefined;
+  const declared = {};
+  let any = false;
+  for (const key of CAPABILITY_KEYS) {
+    const source = (cell && cell.capabilities && cell.capabilities[key] !== undefined) ? cell.capabilities[key]
+      : (profilo && profilo[key] !== undefined) ? profilo[key] : undefined;
+    if (source !== undefined) { declared[key] = [...source]; any = true; }
+  }
+  return { legacy: cell?.capabilities === undefined && cell?.capabilityProfile === undefined, declared };
+}
+
 function parseCell(c, engineIds, engineMap = new Map(), {
   allowLegacyTmuxNames = true, extraModels = null, onReject = null, onIssue = null,
+  capabilityProfileNames = null,
 } = {}) {
   const reject = (message) => {
     if (typeof onReject === 'function') onReject(message);
@@ -609,6 +688,26 @@ function parseCell(c, engineIds, engineMap = new Map(), {
     mcp = [...visti];
   }
 
+  // capabilities / capabilityProfile: la superficie operativa DICHIARATA della
+  // cella. `capabilities` e' un set per chiave (`mcp`/`skills`/`ondemand`,
+  // parseCapabilitySet sopra); `capabilityProfile` riferisce un profilo
+  // top-level del documento — DEVE esistere: un profilo dangling rifiuta la
+  // cella, non collassa in "niente profilo" (stesso motivo di panelUrl).
+  // Assenti entrambi = cella legacy: comportamento invariato (effectiveCapabilities).
+  let capabilities;
+  if (c.capabilities !== undefined) {
+    capabilities = parseCapabilitySet(c.capabilities, onIssue);
+    if (!capabilities) return null;
+  }
+  let capabilityProfile;
+  if (c.capabilityProfile !== undefined) {
+    if (typeof c.capabilityProfile !== 'string' || !CELL_ID_RE.test(c.capabilityProfile)) return null;
+    if (!capabilityProfileNames || !capabilityProfileNames.has(c.capabilityProfile)) {
+      return reject(`fleet.json rifiutato: la cella ${c.id} riferisce il profilo di capability "${c.capabilityProfile}" che non e' dichiarato in capabilityProfiles`);
+    }
+    capabilityProfile = c.capabilityProfile;
+  }
+
   // label (opzionale): nome LEGGIBILE della cella, distinto dall'id.
   // L'id resta la chiave stabile con cui si indirizza una cella e con cui si
   // deriva la sessione tmux; la label e' solo cio' che un umano legge. Senza
@@ -670,6 +769,8 @@ function parseCell(c, engineIds, engineMap = new Map(), {
   if (prompt !== undefined) out.prompt = prompt;
   if (panelUrl !== undefined) out.panelUrl = panelUrl;
   if (mcp !== undefined) out.mcp = mcp;
+  if (capabilities !== undefined) out.capabilities = capabilities;
+  if (capabilityProfile !== undefined) out.capabilityProfile = capabilityProfile;
   if (label !== undefined) out.label = label;
   if (legacyTmuxSession) {
     Object.defineProperty(out, 'legacyTmuxSession', {
@@ -1098,6 +1199,8 @@ const CAPS = {
 
 module.exports = {
   parseDefinitions,
+  effectiveCapabilities,
+  parseCapabilitySet,
   validateCommandTrust,
   aggiornaDefinizioni,
   proprietarioVivo,