@aifabrix/builder 2.45.5 → 2.47.0

package/lib/core/setup-platform-mode.js

@@ -0,0 +1,90 @@
+/**
+ * Setup platform topology mode (`single` | `single-traefik` | `full`).
+ *
+ * This is distinct from `setupInstallationProfile` (dev/pro password bundle) and from
+ * the login/run environment (`dev` | `tst` | `pro`).
+ *
+ * @fileoverview Setup platform mode normalization and defaults
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+/** @enum {string} */
+const SETUP_PLATFORM_MODE = Object.freeze({
+  SINGLE: 'single',
+  SINGLE_TRAEFIK: 'single-traefik',
+  FULL: 'full'
+});
+
+/** @type {readonly string[]} */
+const SETUP_PLATFORM_MODE_CLI_VALUES = Object.freeze([
+  SETUP_PLATFORM_MODE.SINGLE,
+  SETUP_PLATFORM_MODE.SINGLE_TRAEFIK,
+  SETUP_PLATFORM_MODE.FULL
+]);
+
+/**
+ * @param {unknown} value
+ * @returns {'single'|'single-traefik'|'full'}
+ */
+function normalizeSetupPlatformMode(value) {
+  const raw = String(value ?? '')
+    .trim()
+    .toLowerCase();
+  if (raw === SETUP_PLATFORM_MODE.FULL) return SETUP_PLATFORM_MODE.FULL;
+  if (raw === 'all' || raw === 'full-platform' || raw === 'platform-full') return SETUP_PLATFORM_MODE.FULL;
+  if (raw === SETUP_PLATFORM_MODE.SINGLE_TRAEFIK) return SETUP_PLATFORM_MODE.SINGLE_TRAEFIK;
+  if (raw === 'ingress' || raw === 'single-ingress' || raw === 'traefik') return SETUP_PLATFORM_MODE.SINGLE_TRAEFIK;
+  return SETUP_PLATFORM_MODE.SINGLE;
+}
+
+/**
+ * Derived config flags for a chosen platform mode.
+ *
+ * - single: direct ports, no front door ingress
+ * - single-traefik: Traefik front door (domain + TLS) for one environment only
+ * - full: Traefik ingress + env-scoped resources (multi-env; CLI only until menu returns)
+ *
+ * @param {'single'|'single-traefik'|'full'} mode
+ * @returns {{ traefik: boolean, useEnvironmentScopedResources: boolean }}
+ */
+function flagsForSetupPlatformMode(mode) {
+  const m = normalizeSetupPlatformMode(mode);
+  const traefik =
+    m === SETUP_PLATFORM_MODE.SINGLE_TRAEFIK || m === SETUP_PLATFORM_MODE.FULL;
+  return {
+    traefik,
+    useEnvironmentScopedResources: m === SETUP_PLATFORM_MODE.FULL
+  };
+}
+
+/**
+ * Interactive setup menu choices (full platform hidden until multi-env path ships).
+ *
+ * @returns {{ name: string, value: string }[]}
+ */
+function getSetupPlatformModePromptChoices() {
+  return [
+    {
+      name: 'Single environment — direct ports (no Traefik front door)',
+      value: SETUP_PLATFORM_MODE.SINGLE
+    },
+    {
+      name: 'Single environment — Traefik front door (domain + TLS)',
+      value: SETUP_PLATFORM_MODE.SINGLE_TRAEFIK
+    }
+    // Full platform — Traefik front door + miso/dev/tst/pro (shared infra) — menu returns soon.
+    // { name: 'Full platform — Traefik front door + miso/dev/tst/pro (shared infra)', value: SETUP_PLATFORM_MODE.FULL },
+  ];
+}
+
+module.exports = {
+  SETUP_PLATFORM_MODE,
+  SETUP_PLATFORM_MODE_CLI_VALUES,
+  normalizeSetupPlatformMode,
+  flagsForSetupPlatformMode,
+  getSetupPlatformModePromptChoices
+};
+

package/lib/datasource/agent-trust-debug-log.js

@@ -21,7 +21,7 @@ async function writeTrustDebugLog(appKey, datasourceKey, payload) {
   const logPath = await writeTestLog(
     appKey,
     payload,
-    `test-trust-${datasourceKey}`,
+    `verify-trust-${datasourceKey}`,
     path.dirname(getIntegrationPath(appKey))
   );
   return logPath;

package/lib/datasource/agent-trust-run.js

@@ -14,14 +14,15 @@ const { setupIntegrationTestAuth } = require('../external-system/test-auth');
 const { resolveAppKeyForDatasource } = require('./resolve-app');
 const { getSystemKeyFromAppKey } = require('./integration-context');
 const { requireBearerForDataplanePipeline } = require('../utils/token-manager');
+const { buildMinimalUploadSyncOptions } = require('../utils/upload-sync-options');
 const { fetchTrustRunFromDataplane } = require('./agent-trust-fetch');
 
-async function maybeSyncBeforeTrust({ noSync, authConfig, systemKey }) {
+async function maybeSyncBeforeTrust({ noSync, authConfig, systemKey, options = {} }) {
   if (noSync === true) return;
   requireBearerForDataplanePipeline(authConfig);
   logger.log(chalk.cyan('Syncing local config to dataplane…'));
   const { uploadExternalSystem } = require('../commands/upload');
-  await uploadExternalSystem(systemKey, { minimal: true });
+  await uploadExternalSystem(systemKey, buildMinimalUploadSyncOptions(options));
   logger.log(formatSuccessLine('Sync complete'));
 }
 
@@ -67,7 +68,8 @@ async function runDatasourceAgentTrust(datasourceKey, options = {}) {
   await maybeSyncBeforeTrust({
     noSync: options.noSync === true,
     authConfig,
-    systemKey
+    systemKey,
+    options
   });
 
   try {

package/lib/datasource/audit-evidence-extract-debug.js

@@ -6,6 +6,8 @@
 
 'use strict';
 
+const { parseCapacityDetailKey } = require('../utils/load-cip-capacity-display-config');
+
 /**
  * @param {Array<*>} ids
  * @returns {string[]}
@@ -67,32 +69,42 @@ function executionIdsFromDebugEnvelope(envelope) {
 }
 
 /**
- * CIP operation names from capacity step (insert, update, list, …).
  * @param {Object|null|undefined} envelope
- * @returns {string[]}
+ * @returns {Object|null}
  */
-function cipOperationsFromDebugEnvelope(envelope) {
-  const dbg = envelope && envelope.debug;
-  const asyncDbg = dbg && dbg.e2eAsyncDebug;
-  if (!asyncDbg || !Array.isArray(asyncDbg.stepDebug)) return [];
-  const capStep = asyncDbg.stepDebug.find(s => s && s.name === 'capacity');
-  if (!capStep || !capStep.evidence) return [];
+function getCapacityStepFromEnvelope(envelope) {
+  const asyncDbg = envelope && envelope.debug && envelope.debug.e2eAsyncDebug;
+  if (!asyncDbg || !Array.isArray(asyncDbg.stepDebug)) return null;
+  return asyncDbg.stepDebug.find(s => s && s.name === 'capacity') || null;
+}
+
+/**
+ * Operation names from CIP capacity evidence keys (`capacity:<op>#<index>`), without product aliases.
+ * @param {*} details
+ * @returns {Set<string>}
+ */
+function collectCipOpsFromCapabilityDetails(details) {
   const ops = new Set();
-  const details = capStep.evidence.datasources;
-  if (!Array.isArray(details)) return [];
+  if (!Array.isArray(details)) return ops;
   for (const ds of details) {
     if (!ds || !Array.isArray(ds.capabilityDetails)) continue;
     for (const item of ds.capabilityDetails) {
-      const key = item && item.key ? String(item.key) : '';
-      const m = key.match(/^capacity:([a-zA-Z]+)/);
-      if (m && m[1]) {
-        let op = m[1] === 'updateBasic' ? 'updatebasic' : m[1].toLowerCase();
-        if (op === 'create') op = 'insert';
-        ops.add(op);
-      }
+      const parsed = parseCapacityDetailKey(item && item.key);
+      if (parsed && parsed.op) ops.add(parsed.op);
     }
   }
-  return [...ops];
+  return ops;
+}
+
+/**
+ * CIP operation names from capacity step (insert, update, list, …).
+ * @param {Object|null|undefined} envelope
+ * @returns {string[]}
+ */
+function cipOperationsFromDebugEnvelope(envelope) {
+  const capStep = getCapacityStepFromEnvelope(envelope);
+  if (!capStep || !capStep.evidence) return [];
+  return [...collectCipOpsFromCapabilityDetails(capStep.evidence.datasources)];
 }
 
 module.exports = {

package/lib/datasource/audit-evidence-extract.js

@@ -16,6 +16,7 @@ const {
   cipOperationsFromDebugEnvelope,
   dedupeIds: dedupeIdsFromDebug
 } = require('./audit-evidence-extract-debug');
+const loadCipCapacityDisplayConfig = require('../utils/load-cip-capacity-display-config');
 
 /** @param {Array<*>} ids @returns {string[]} */
 function dedupeIds(ids) {
@@ -88,14 +89,16 @@ function correlationIdFromEnvelope(envelope) {
 function expectedOperationsFromEnvelope(envelope) {
   const fromCapacity = cipOperationsFromDebugEnvelope(envelope);
   if (fromCapacity.length) return fromCapacity;
+  const { standardOrder } = loadCipCapacityDisplayConfig.getCipCapacityDisplayConfig();
+  const allowed = new Set(
+    (standardOrder || []).map(op => String(op).trim().toLowerCase()).filter(Boolean)
+  );
   const ops = new Set();
   const caps = envelope && Array.isArray(envelope.capabilities) ? envelope.capabilities : [];
   for (const cap of caps) {
     if (!cap || cap.status === 'skipped' || !cap.key) continue;
-    const key = String(cap.key).trim();
-    if (['insert', 'update', 'get', 'delete', 'list', 'create'].includes(key)) {
-      ops.add(key === 'create' ? 'insert' : key);
-    }
+    const key = String(cap.key).trim().toLowerCase();
+    if (allowed.has(key)) ops.add(key);
   }
   const integration = envelope && envelope.integration;
   if (integration && integration.sync && integration.sync.status === 'ok') {

package/lib/datasource/audit-evidence-verify-matrix.js

@@ -113,22 +113,27 @@ async function buildListMatrixRows(ctx, polled, minExpected) {
 
 /**
  * @param {Object} ctx
- * @param {Array} executions
- * @param {string[]} executionIds
- * @returns {Promise<{ rows: import('../api/types/audit.types').AuditEvidenceMatrixRow[], execIds: string[] }>}
+ * @param {string[]} execIds
+ * @returns {Promise<import('../api/types/audit.types').AuditEvidenceMatrixRow[]>}
  */
-async function buildPerExecutionAndTailRows(ctx, executions, executionIds) {
+async function buildPerExecutionSubRows(ctx, execIds) {
   const { dataplaneUrl, authConfig } = ctx;
-  const execIds = resolveExecutionIdsForChecks(executions, executionIds);
-  const sampleId = execIds[0];
-  const base = { dataplaneUrl, authConfig, executionId: sampleId };
-  const rows = await Promise.all([
+  const base = { dataplaneUrl, authConfig, executionId: execIds[0] };
+  return Promise.all([
     checkPerExecutionSub({ ...base, rowNum: 4, label: 'rbac', fetcher: getExecutionRbac, isValid: isRbacSubResourceValid }),
     checkPerExecutionSub({ ...base, rowNum: 5, label: 'abac', fetcher: getExecutionAbac, isValid: isAbacSubResourceValid }),
     checkPerExecutionSub({ ...base, rowNum: 6, label: 'errors', fetcher: getExecutionErrors, isValid: isErrorsValid }),
     checkPerExecutionSub({ ...base, rowNum: 7, label: 'steps', fetcher: getExecutionSteps, isValid: isStepsValid })
   ]);
+}
 
+/**
+ * @param {Object} ctx
+ * @param {Array} executions
+ * @returns {Promise<Array>}
+ */
+async function resolveRow8PoolForMatrix(ctx, executions) {
+  const { dataplaneUrl, authConfig } = ctx;
   let corrQueryRows = [];
   if (ctx.correlationId) {
     const corr = await queryExecutions(dataplaneUrl, authConfig, {
@@ -137,28 +142,30 @@ async function buildPerExecutionAndTailRows(ctx, executions, executionIds) {
     });
     corrQueryRows = corr.data || [];
   }
-  let row8Pool = corrQueryRows.length ? corrQueryRows : executions;
+  const row8Pool = corrQueryRows.length ? corrQueryRows : executions;
   const expected = ctx.expectedOperations || [];
-  if (expected.length && ctx.correlationId) {
-    const byOp = await fetchCorrelationExecutionsByOperation(
-      dataplaneUrl,
-      authConfig,
-      ctx.correlationId,
-      expected
-    );
-    if (byOp.length) row8Pool = byOp;
+  if (!expected.length || !ctx.correlationId) {
+    return row8Pool;
   }
-  const row8Executions = resolveRow8Executions(ctx, executions, row8Pool);
-  rows.push(
-    checkRow8CorrelationGroup({
-      correlationId: ctx.correlationId,
-      executions: row8Executions,
-      expectedOperations: ctx.expectedOperations
-    })
+  const byOp = await fetchCorrelationExecutionsByOperation(
+    dataplaneUrl,
+    authConfig,
+    ctx.correlationId,
+    expected
   );
+  return byOp.length ? byOp : row8Pool;
+}
 
+/**
+ * @param {Object} ctx
+ * @param {string[]} execIds
+ * @returns {Promise<Set<string>>}
+ */
+async function collectTraceIdsForRow9(ctx, execIds) {
+  const { dataplaneUrl, authConfig } = ctx;
   const traceIds = new Set();
-  for (const id of execIds.slice(0, Math.min(execIds.length, 12))) {
+  const sample = execIds.slice(0, Math.min(execIds.length, 12));
+  for (const id of sample) {
     try {
       const tr = await getExecutionTrace(dataplaneUrl, authConfig, id);
       if (tr && tr.executionId) traceIds.add(String(tr.executionId));
@@ -167,7 +174,28 @@ async function buildPerExecutionAndTailRows(ctx, executions, executionIds) {
       /* row 9 may fail */
     }
   }
-  rows.push(checkRow9Traces(traceIds, execIds));
+  return traceIds;
+}
+
+/**
+ * @param {Object} ctx
+ * @param {Array} executions
+ * @param {string[]} executionIds
+ * @returns {Promise<{ rows: import('../api/types/audit.types').AuditEvidenceMatrixRow[], execIds: string[] }>}
+ */
+async function buildPerExecutionAndTailRows(ctx, executions, executionIds) {
+  const execIds = resolveExecutionIdsForChecks(executions, executionIds);
+  const rows = await buildPerExecutionSubRows(ctx, execIds);
+  const row8Pool = await resolveRow8PoolForMatrix(ctx, executions);
+  const row8Executions = resolveRow8Executions(ctx, executions, row8Pool);
+  rows.push(
+    checkRow8CorrelationGroup({
+      correlationId: ctx.correlationId,
+      executions: row8Executions,
+      expectedOperations: ctx.expectedOperations
+    })
+  );
+  rows.push(checkRow9Traces(await collectTraceIdsForRow9(ctx, execIds), execIds));
   return { rows, execIds };
 }
 

package/lib/datasource/bulk-loader-run-batches.js

@@ -34,9 +34,21 @@ function recordBatchFailure(state, index, err, batchRecords) {
  * @param {Object[]} batchRecords
  */
 function recordBatchSuccess(state, index, response, batchRecords) {
-  const inserted = response.insertedCount || 0;
-  const updated = response.updatedCount || 0;
-  const processed = response.totalProcessed || batchRecords.length;
+  if (!response || typeof response !== 'object') {
+    throw new Error('Bulk sync returned empty response');
+  }
+  if (response.success === false) {
+    throw new Error(
+      response.formattedError ||
+        response.error ||
+        `Bulk sync failed (HTTP ${response.status || 0})`
+    );
+  }
+  const payload =
+    response.data !== undefined && response.data !== null ? response.data : response;
+  const inserted = payload.insertedCount || 0;
+  const updated = payload.updatedCount || 0;
+  const processed = payload.totalProcessed || batchRecords.length;
   const failedInBatch = Math.max(0, batchRecords.length - processed);
 
   state.batches.push({

package/lib/datasource/capability/capability-diff-slice.js

@@ -7,6 +7,7 @@
  */
 
 const { deepClone } = require('./copy-operations');
+const { capabilitiesIncludes } = require('./capability-manifest');
 
 /**
  * @param {object} doc - Parsed datasource JSON
@@ -16,8 +17,7 @@ const { deepClone } = require('./copy-operations');
  */
 function extractCapabilitySliceForDiff(doc, capabilityKey, profileKey) {
   const cap = capabilityKey;
-  const listed =
-    Boolean(Array.isArray(doc.capabilities) && doc.capabilities.includes(cap));
+  const listed = capabilitiesIncludes(doc.capabilities, cap);
   const openapiOp = doc.openapi?.operations?.[cap];
   const cipOp = doc.execution?.cip?.operations?.[cap];
   let exposedProfile;

package/lib/datasource/capability/capability-manifest.js

@@ -0,0 +1,254 @@
+/**
+ * COM v2 capability object helpers for datasource manifests.
+ *
+ * @fileoverview capability-manifest
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const FORBIDDEN_ROOT_KEYS = new Set([
+  'context',
+  'origin',
+  'generatedBy',
+  'composition',
+  'generation',
+  'enterpriseResolver'
+]);
+
+const DEFAULT_RISK_BY_KEY = {
+  list: 'low',
+  get: 'low',
+  search: 'low',
+  create: 'medium',
+  update: 'medium',
+  delete: 'high'
+};
+
+const RESOURCE_TYPE_MAP = {
+  conversation: 'message',
+  user: 'employee',
+  person: 'employee',
+  record: 'document',
+  folder: 'document',
+  country: 'organization',
+  report: 'document',
+  calendar: 'event',
+  subscription: 'event'
+};
+
+/**
+ * @param {unknown} entry
+ * @returns {string}
+ */
+function capabilityKeyFromEntry(entry) {
+  if (typeof entry === 'string' && entry.trim()) {
+    return entry.trim();
+  }
+  if (entry && typeof entry === 'object' && typeof entry.key === 'string' && entry.key.trim()) {
+    return entry.key.trim();
+  }
+  return '';
+}
+
+/**
+ * @param {unknown} capabilities
+ * @returns {string[]}
+ */
+function listCapabilityKeys(capabilities) {
+  if (!Array.isArray(capabilities)) {
+    return [];
+  }
+  return capabilities.map(capabilityKeyFromEntry).filter(Boolean);
+}
+
+/**
+ * @param {unknown} capabilities
+ * @param {string} key
+ * @returns {boolean}
+ */
+function capabilitiesIncludes(capabilities, key) {
+  const target = String(key).toLowerCase();
+  return listCapabilityKeys(capabilities).some((item) => item.toLowerCase() === target);
+}
+
+/**
+ * @param {string} key
+ * @param {string} [displayName]
+ * @returns {object}
+ */
+function buildCapabilityObject(key, displayName) {
+  const normalized = String(key || '').trim();
+  const label = displayName && String(displayName).trim() ? String(displayName).trim() : 'records';
+  return {
+    key: normalized,
+    description: `${normalized} operation on ${label}`,
+    riskLevel: DEFAULT_RISK_BY_KEY[normalized.toLowerCase()] || 'medium',
+    approvalRequired: false
+  };
+}
+
+/**
+ * @param {object} parsed
+ * @returns {object[]}
+ */
+function normalizeCapabilitiesToObjects(parsed) {
+  const caps = parsed?.capabilities;
+  const displayName = parsed?.displayName || parsed?.key || 'records';
+  if (!Array.isArray(caps) || caps.length === 0) {
+    return [];
+  }
+  const out = [];
+  const seen = new Set();
+  caps.forEach((item) => {
+    if (typeof item === 'string' && item.trim()) {
+      const key = item.trim();
+      if (seen.has(key)) return;
+      seen.add(key);
+      out.push(buildCapabilityObject(key, displayName));
+      return;
+    }
+    if (!item || typeof item !== 'object') return;
+    const key = capabilityKeyFromEntry(item);
+    if (!key || seen.has(key)) return;
+    seen.add(key);
+    const row = buildCapabilityObject(key, displayName);
+    if (typeof item.description === 'string' && item.description.trim()) {
+      row.description = item.description.trim();
+    }
+    if (typeof item.riskLevel === 'string' && item.riskLevel.trim()) {
+      row.riskLevel = item.riskLevel.trim();
+    }
+    if (item.approvalRequired === true) {
+      row.approvalRequired = true;
+    }
+    out.push(row);
+  });
+  return out;
+}
+
+/**
+ * @param {object} node
+ * @returns {void}
+ */
+function stripSemanticExtras(node) {
+  if (!node || typeof node !== 'object') return;
+  const semantic = node.semantic;
+  if (semantic && typeof semantic === 'object') {
+    delete semantic.categories;
+    delete semantic.synonyms;
+    if (Object.keys(semantic).length === 0) {
+      delete node.semantic;
+    }
+  }
+  Object.values(node).forEach((value) => {
+    if (value && typeof value === 'object') {
+      if (Array.isArray(value)) {
+        value.forEach((item) => stripSemanticExtras(item));
+      } else {
+        stripSemanticExtras(value);
+      }
+    }
+  });
+}
+
+/**
+ * @param {object} parsed
+ * @param {string[]} changes
+ * @returns {boolean}
+ */
+function removeForbiddenComRootKeys(parsed, changes) {
+  let updated = false;
+  FORBIDDEN_ROOT_KEYS.forEach((key) => {
+    if (Object.prototype.hasOwnProperty.call(parsed, key)) {
+      delete parsed[key];
+      changes.push(`Removed forbidden COM v2 root key: ${key}`);
+      updated = true;
+    }
+  });
+  return updated;
+}
+
+/**
+ * @param {object} parsed
+ * @param {string[]} changes
+ * @returns {boolean}
+ */
+function stripFieldMappingSemanticExtras(parsed, changes) {
+  if (!parsed.fieldMappings) {
+    return false;
+  }
+  const before = JSON.stringify(parsed.fieldMappings);
+  stripSemanticExtras(parsed.fieldMappings);
+  if (JSON.stringify(parsed.fieldMappings) === before) {
+    return false;
+  }
+  changes.push('Removed fieldMappings.*.semantic.categories/synonyms (COM v2)');
+  return true;
+}
+
+/**
+ * @param {object} parsed
+ * @param {string[]} changes
+ * @returns {boolean}
+ */
+function applyResourceTypeCatalogMap(parsed, changes) {
+  const resourceType = parsed.resourceType;
+  if (typeof resourceType !== 'string') {
+    return false;
+  }
+  const mapped = RESOURCE_TYPE_MAP[resourceType.trim()];
+  if (!mapped) {
+    return false;
+  }
+  parsed.resourceType = mapped;
+  changes.push(`Mapped resourceType ${resourceType} → ${mapped}`);
+  return true;
+}
+
+/**
+ * @param {object} parsed
+ * @param {string[]} changes
+ * @returns {boolean}
+ */
+function migrateCapabilitiesToComObjects(parsed, changes) {
+  const caps = parsed.capabilities;
+  const needsObjectMigration = Array.isArray(caps)
+    && caps.some((item) => typeof item === 'string' || (item && typeof item === 'object' && !item.key));
+  const hasStringCapabilities = Array.isArray(caps) && caps.length > 0 && typeof caps[0] === 'string';
+  if (!needsObjectMigration && !hasStringCapabilities) {
+    return false;
+  }
+  parsed.capabilities = normalizeCapabilitiesToObjects(parsed);
+  changes.push('Migrated capabilities[] to COM v2 capability objects');
+  return true;
+}
+
+/**
+ * @param {object} parsed
+ * @param {string[]} changes
+ * @returns {boolean}
+ */
+function repairComV2Manifest(parsed, changes) {
+  if (!parsed || typeof parsed !== 'object') {
+    return false;
+  }
+  return [
+    removeForbiddenComRootKeys(parsed, changes),
+    stripFieldMappingSemanticExtras(parsed, changes),
+    applyResourceTypeCatalogMap(parsed, changes),
+    migrateCapabilitiesToComObjects(parsed, changes)
+  ].some(Boolean);
+}
+
+module.exports = {
+  FORBIDDEN_ROOT_KEYS,
+  capabilityKeyFromEntry,
+  listCapabilityKeys,
+  capabilitiesIncludes,
+  buildCapabilityObject,
+  normalizeCapabilitiesToObjects,
+  stripSemanticExtras,
+  repairComV2Manifest
+};

package/lib/datasource/capability/capability-resolve.js

@@ -6,6 +6,8 @@
  * @version 2.0.0
  */
 
+const { capabilitiesIncludes } = require('./capability-manifest');
+
 /**
  * @param {object|undefined} operations
  * @param {string} logicalKey
@@ -146,10 +148,7 @@ function resolveProfileKeyForLogical(doc, logicalKey) {
  * @returns {boolean}
  */
 function capabilityLogicalExists(doc, name) {
-  if (
-    Array.isArray(doc.capabilities) &&
-    doc.capabilities.some((c) => String(c).toLowerCase() === String(name).toLowerCase())
-  ) {
+  if (capabilitiesIncludes(doc.capabilities, name)) {
     return true;
   }
   if (findMatchingOpsKeys(doc.openapi?.operations, name).length > 0) {

package/lib/datasource/capability/copy-operations.js

@@ -7,6 +7,7 @@
  */
 
 const { rewriteCapabilityReferences } = require('./reference-rewrite');
+const { capabilityKeyFromEntry } = require('./capability-manifest');
 const { jsonPointerPath } = require('./json-pointer');
 const { buildBasicExposureProfileArray } = require('./basic-exposure');
 const {
@@ -53,9 +54,10 @@ function removeCapability(doc, logicalKey) {
   const profileKey = resolveProfileKeyForLogical(doc, logicalKey);
 
   if (Array.isArray(doc.capabilities)) {
-    doc.capabilities = doc.capabilities.filter(
-      (c) => String(c).toLowerCase() !== String(logicalKey).toLowerCase()
-    );
+    doc.capabilities = doc.capabilities.filter((c) => {
+      const key = capabilityKeyFromEntry(c);
+      return key.toLowerCase() !== String(logicalKey).toLowerCase();
+    });
   }
   if (openapiKey && oo) {
     delete oo[openapiKey];