@aifabrix/builder 2.49.2 → 2.50.0

package/lib/commands/repair-datasource-webhooks-sync-bridge.js

@@ -0,0 +1,133 @@
+/**
+ * Datasource repair helpers for webhook and syncBridge manifest sections.
+ *
+ * @fileoverview Align webhook defaults and syncBridge metadata warnings (454.11)
+ */
+
+'use strict';
+
+const AUTH_USAGE_WEBHOOK_INBOUND = 'webhookInbound';
+
+/**
+ * @param {object|null|undefined} systemParsed
+ * @returns {boolean}
+ */
+function systemHasWebhookInboundAuth(systemParsed) {
+  if (!systemParsed || typeof systemParsed !== 'object') {
+    return false;
+  }
+  const rows = systemParsed.authentications;
+  if (Array.isArray(rows)) {
+    return rows.some((row) => row && row.usage === AUTH_USAGE_WEBHOOK_INBOUND);
+  }
+  return false;
+}
+
+/**
+ * @param {object} parsed
+ * @param {string[]} changes
+ * @param {string[]} warnings
+ * @returns {boolean}
+ */
+function repairWebhookSection(parsed, changes, warnings) {
+  if (!parsed?.webhook || typeof parsed.webhook !== 'object') {
+    return false;
+  }
+  const webhook = parsed.webhook;
+  let updated = false;
+
+  if (webhook.enabled === true) {
+    if (!webhook.idPath || !String(webhook.idPath).trim()) {
+      warnings.push(
+        'webhook.enabled is true but idPath is missing — set idPath (for example $.objectId) before upload.'
+      );
+    }
+    if (!Array.isArray(webhook.events) || webhook.events.length === 0) {
+      warnings.push('webhook.enabled is true but events[] is empty — add vendor event names.');
+    }
+  }
+
+  if (webhook.enabled === true && !webhook.endpointMode) {
+    webhook.endpointMode = 'datasource';
+    changes.push('Set webhook.endpointMode default datasource');
+    updated = true;
+  }
+
+  return updated;
+}
+
+/**
+ * @param {object} parsed
+ * @param {string[]} changes
+ * @param {string[]} warnings
+ * @returns {boolean}
+ */
+function ensureSyncBridgeExternalIdMetadata(parsed, changes) {
+  const mode = parsed?.syncBridge || 'disabled';
+  if (mode === 'disabled') {
+    return false;
+  }
+  if (!parsed.metadataSchema || typeof parsed.metadataSchema !== 'object') {
+    parsed.metadataSchema = { type: 'object', additionalProperties: true, properties: {} };
+  }
+  if (!parsed.metadataSchema.properties || typeof parsed.metadataSchema.properties !== 'object') {
+    parsed.metadataSchema.properties = {};
+  }
+  const ext = parsed.metadataSchema.properties.externalId;
+  const ok =
+    ext && typeof ext === 'object' && ext.type === 'string' && ext.index === true;
+  if (ok) {
+    return false;
+  }
+  parsed.metadataSchema.properties.externalId = {
+    ...(typeof ext === 'object' && ext !== null ? ext : {}),
+    type: 'string',
+    index: true
+  };
+  changes.push('Ensured metadataSchema.properties.externalId for syncBridge participation');
+  return true;
+}
+
+/**
+ * @param {object} parsed
+ * @param {string[]} changes
+ * @param {string[]} warnings
+ * @returns {boolean}
+ */
+function repairSyncBridgeSection(parsed, changes, warnings) {
+  const mode = parsed?.syncBridge || 'disabled';
+  if (mode === 'disabled') {
+    return false;
+  }
+  if (mode === 'master' && !parsed.resourceType) {
+    warnings.push('syncBridge=master requires resourceType for propagation grouping.');
+  }
+  return ensureSyncBridgeExternalIdMetadata(parsed, changes);
+}
+
+/**
+ * @param {object} parsed
+ * @param {object|null|undefined} systemParsed
+ * @param {string[]} warnings
+ * @returns {void}
+ */
+function collectWebhookSyncBridgeSystemWarnings(parsed, systemParsed, warnings) {
+  if (!parsed?.webhook?.enabled) {
+    return;
+  }
+  if (systemHasWebhookInboundAuth(systemParsed)) {
+    return;
+  }
+  const dsKey = parsed.key || parsed.datasourceKey || 'datasource';
+  warnings.push(
+    `${dsKey}: webhook.enabled but system lacks authentications[usage=webhookInbound]. ` +
+      'Run: aifabrix repair <systemKey> --auth-webhook'
+  );
+}
+
+module.exports = {
+  repairWebhookSection,
+  repairSyncBridgeSection,
+  collectWebhookSyncBridgeSystemWarnings,
+  systemHasWebhookInboundAuth
+};

package/lib/commands/repair-datasource.js

@@ -10,9 +10,7 @@
 'use strict';
 
 const { repairOpenapiSection } = require('./repair-datasource-openapi');
-const { normalizeAutoRbacOperationKeys } = require('./repair-datasource-auto-rbac');
 const { repairTestPayload } = require('./repair-datasource-test-payload');
-const { repairComV2Manifest } = require('./repair-datasource-com-v2');
 const {
   isDeprecatedNoneLlmManifest,
   repairNoneLlmToServiceContract,
@@ -386,80 +384,26 @@ function sanitizeTestPayloadTopLevel(parsed, changes) {
   return true;
 }
 
-/**
- * @param {Object} parsed
- * @param {Object} options
- * @returns {boolean}
- */
-function shouldApplyServiceContractRepair(parsed, options) {
-  return (
-    isDeprecatedNoneLlmManifest(parsed) ||
-    (options.serviceContract && parsed?.resourceType === 'llm')
-  );
-}
-
-/**
- * @param {Object} parsed
- * @param {Object} options
- * @param {boolean} none
- * @param {string[]} changes
- * @returns {boolean}
- */
-function applyOptionalDatasourceRepairs(parsed, options, none, changes) {
-  let updated = false;
-  if (options.expose) {
-    updated = repairExposeFromAttributes(parsed, changes) || updated;
-  }
-  if (!none && options.sync) {
-    updated = repairSyncSection(parsed, changes) || updated;
-  }
-  if (options.test) {
-    sanitizeTestPayloadTopLevel(parsed, changes);
-    updated = repairTestPayload(parsed, changes) || updated;
-    updated = sanitizeTestPayloadTopLevel(parsed, changes) || updated;
-  }
-  return updated;
-}
-
 /**
  * Runs all requested datasource repairs.
  *
  * @param {Object} parsed - Parsed datasource object (mutated)
- * @param {Object} options - { expose?: boolean, sync?: boolean, test?: boolean }
+ * @param {Object} options - { expose?: boolean, sync?: boolean, test?: boolean, operations?: boolean }
  * @param {string[]} [changes] - Optional array to append change descriptions to
  * @returns {{ updated: boolean, changes: string[] }}
  */
 function repairDatasourceFile(parsed, options = {}, changes = []) {
-  const out = Array.isArray(changes) ? changes : [];
-  let updated = stripDeprecatedServiceCategory(parsed, out);
-
-  if (shouldApplyServiceContractRepair(parsed, options)) {
-    updated = repairNoneLlmToServiceContract(parsed, out) || updated;
-  }
-
-  const none = isNoneEntityType(parsed?.entityType);
-
-  updated = applyBaseDatasourceRepairs(parsed, none, out) || updated;
-  updated = applyOpenapiDatasourceRepairs(parsed, out) || updated;
-  updated = applyOptionalDatasourceRepairs(parsed, options, none, out) || updated;
-
-  return { updated, changes: out };
-}
-
-function applyBaseDatasourceRepairs(parsed, none, changes) {
-  let updated = repairComV2Manifest(parsed, changes);
-  if (none) return updated;
-  updated = repairDimensionBindingShape(parsed, changes) || updated;
-  updated = repairRootDimensionsFromAttributes(parsed, changes) || updated;
-  updated = repairMetadataSchemaFromAttributes(parsed, changes) || updated;
-  return updated;
-}
-
-function applyOpenapiDatasourceRepairs(parsed, changes) {
-  let updated = false;
-  updated = repairOpenapiSection(parsed, changes) || updated;
-  updated = normalizeAutoRbacOperationKeys(parsed, changes) || updated;
-  return updated;
+  const { runRepairDatasourceFile } = require('./repair-datasource-apply');
+  return runRepairDatasourceFile(parsed, options, changes, {
+    stripDeprecatedServiceCategory,
+    isNoneEntityType,
+    repairDimensionBindingShape,
+    repairRootDimensionsFromAttributes,
+    repairMetadataSchemaFromAttributes,
+    repairExposeFromAttributes,
+    repairSyncSection,
+    sanitizeTestPayloadTopLevel
+  });
 }
 
 module.exports = {

package/lib/commands/repair-env-template.js

@@ -15,6 +15,10 @@ const { systemKeyToKvPrefix, kvEnvKeyToPath, securityKeyToVar } = require('../ut
 const { extractEnvTemplate } = require('../generator/split');
 const { generateExternalEnvTemplateContent } = require('../utils/external-env-template');
 const { commentOrphanKvEnvLines } = require('../utils/env-kv-orphan-lines');
+const {
+  addFromAuthenticationsArray,
+  normalizeAuthenticationsSecurity
+} = require('../utils/authentication-env-template');
 
 /**
  * Normalizes a keyvault config entry to canonical KV_* name and path-style value.
@@ -114,7 +118,12 @@ function buildEffectiveConfiguration(systemParsed, systemKey) {
   const seenNames = new Set();
   const config = Array.isArray(systemParsed.configuration) ? systemParsed.configuration : [];
   addFromConfiguration(effective, config, prefix, seenNames, systemKey);
-  addFromAuthSecurity(effective, systemParsed, prefix, seenNames, systemKey);
+  addFromAuthenticationsArray(effective, systemParsed, prefix, seenNames, systemKey);
+  const hasAuthSlots =
+    Array.isArray(systemParsed.authentications) && systemParsed.authentications.length > 0;
+  if (!hasAuthSlots) {
+    addFromAuthSecurity(effective, systemParsed, prefix, seenNames, systemKey);
+  }
   return effective;
 }
 
@@ -394,6 +403,7 @@ function normalizeSystemFileAuthAndConfig(systemParsed, systemKey, changes) {
   const credential = getAuthCredentialTemplate(systemParsed.authentication);
   const security = credential?.security ?? systemParsed.authentication?.security;
   let updated = (security && typeof security === 'object' && normalizeSecuritySection(security, prefix, systemKey, changes));
+  updated = normalizeAuthenticationsSecurity(systemParsed, systemKey, changes) || updated;
   const config = systemParsed.configuration;
   if (Array.isArray(config)) {
     updated = normalizeConfigurationSection(config, prefix, systemKey, changes) || updated;

package/lib/commands/repair-external-run.js

@@ -9,12 +9,21 @@
 'use strict';
 
 const { normalizeDatasourceKeysAndFilenames } = require('./repair-datasource-keys');
-const { resolveSystemContext } = require('./repair-system-alignment');
-const { persistChangesAndRegenerate, regenerateReadmeIfRequested } = require('./repair-persist');
+const {
+  resolveSystemContext,
+  alignSystemFileDataSources,
+  ensureExternalIntegrationBlock
+} = require('./repair-system-alignment');
+const { persistChangesAndRegenerate, regenerateReadmeIfRequested, regenerateDeployScript } = require('./repair-persist');
 const { runRepairSteps } = require('./repair-steps');
 const { runDatasourceRepairs } = require('./repair-datasource-run');
+const { repairSplitOrchestrationDatasources } = require('./repair-orchestration-datasource-split');
 const { maybeRepairRbac } = require('./repair-rbac');
+const { collectCapabilityOpenApiDriftWarnings } = require('./repair-capability-openapi-warnings');
 const { maybeRunOpenApiSyncForMcp } = require('./repair-openapi-sync');
+const { writeConfigFile } = require('../utils/config-format');
+const { backupIntegrationFile } = require('../utils/integration-file-backup');
+const { trackRepairWrite } = require('./repair-changed-files');
 
 /**
  * @param {Object} steps
@@ -95,25 +104,48 @@ function prepareRepairWorkspace(params) {
 
 /**
  * @param {Object} ws
- * @returns {Promise<Object>}
+ * @returns {boolean}
  */
-async function runRepairIntegrationFileSteps(ws) {
-  const steps = runRepairSteps({
-    appPath: ws.appPath,
-    configPath: ws.configPath,
-    variables: ws.variables,
-    systemFilePath: ws.systemFilePath,
-    systemParsed: ws.systemParsed,
-    systemKey: ws.systemKey,
-    systemFiles: ws.systemFiles,
-    datasourceFiles: ws.datasourceFiles,
-    dryRun: ws.dryRun,
-    changes: ws.changes,
-    warnings: ws.warnings,
-    auth: ws.authOption,
-    format: ws.rbacFmt,
-    backupCtx: ws.backupCtx
-  });
+function reconcileManifestsAfterDatasourceSplit(ws) {
+  const dataSourcesAligned = alignSystemFileDataSources(
+    ws.appPath,
+    ws.systemParsed,
+    ws.datasourceFiles,
+    ws.systemKey,
+    ws.dryRun,
+    ws.changes
+  );
+  const extAligned = ensureExternalIntegrationBlock(
+    ws.variables,
+    ws.systemFiles,
+    ws.datasourceFiles,
+    ws.changes
+  );
+  if ((dataSourcesAligned || extAligned) && !ws.dryRun) {
+    backupIntegrationFile(ws.systemFilePath, ws.backupCtx);
+    writeConfigFile(ws.systemFilePath, ws.systemParsed);
+    trackRepairWrite(ws.systemFilePath, ws.backupCtx);
+  }
+  return dataSourcesAligned || extAligned;
+}
+
+/**
+ * @param {Object} ws
+ * @returns {Promise<{ datasourceRepairUpdated: boolean, openapiActionsPerformed: boolean }>}
+ */
+async function runDatasourceOpenApiRepairs(ws) {
+  const splitResult = repairSplitOrchestrationDatasources(
+    ws.appPath,
+    ws.systemKey,
+    ws.datasourceFiles,
+    ws.options,
+    ws.dryRun,
+    ws.changes
+  );
+  if (splitResult.updated) {
+    ws.datasourceFiles = splitResult.datasourceFiles;
+    reconcileManifestsAfterDatasourceSplit(ws);
+  }
   const datasourceRepairUpdated = runDatasourceRepairs(
     ws.appPath,
     ws.datasourceFiles,
@@ -121,10 +153,12 @@ async function runRepairIntegrationFileSteps(ws) {
       expose: Boolean(ws.options.expose),
       sync: Boolean(ws.options.sync),
       test: Boolean(ws.options.test),
+      operations: Boolean(ws.options.operations) || Boolean(ws.options.rbac),
       backupCtx: ws.backupCtx
     },
     ws.dryRun,
-    ws.changes
+    ws.changes,
+    { systemParsed: ws.systemParsed, warnings: ws.warnings }
   );
   const openapiActionsPerformed = await maybeRunOpenApiSyncForMcp({
     options: ws.options,
@@ -132,23 +166,68 @@ async function runRepairIntegrationFileSteps(ws) {
     appPath: ws.appPath,
     systemKey: ws.systemKey,
     datasourceFiles: ws.datasourceFiles,
-    changes: ws.changes
+    changes: ws.changes,
+    backupCtx: ws.backupCtx
   });
-  const { rbacMigratedFromSystem, rbacMergeUpdated } = maybeRepairRbac(
-    ws.appPath,
-    ws.systemFilePath,
-    ws.systemParsed,
-    ws.datasourceFiles,
-    { rbac: Boolean(ws.options.rbac), rbacFmt: ws.rbacFmt, dryRun: ws.dryRun, changes: ws.changes, backupCtx: ws.backupCtx }
-  );
+  return { datasourceRepairUpdated: datasourceRepairUpdated || splitResult.updated, openapiActionsPerformed };
+}
+
+/**
+ * @param {Object} ws
+ * @returns {Promise<Object>}
+ */
+async function runRepairIntegrationFileSteps(ws) {
+  const steps = runRepairSteps({
+    appPath: ws.appPath,
+    configPath: ws.configPath,
+    variables: ws.variables,
+    systemFilePath: ws.systemFilePath,
+    systemParsed: ws.systemParsed,
+    systemKey: ws.systemKey,
+    systemFiles: ws.systemFiles,
+    datasourceFiles: ws.datasourceFiles,
+    dryRun: ws.dryRun,
+    changes: ws.changes,
+    warnings: ws.warnings,
+    auth: ws.authOption,
+    format: ws.rbacFmt,
+    backupCtx: ws.backupCtx,
+    options: ws.options
+  });
+  if (ws.options.rbac) {
+    collectCapabilityOpenApiDriftWarnings(ws.appPath, ws.datasourceFiles, ws.warnings);
+  }
+  const { datasourceRepairUpdated, openapiActionsPerformed } = await runDatasourceOpenApiRepairs(ws);
+  const { rbacMigratedFromSystem, rbacMergeUpdated, rbacSyncedIntoSystem, rbacSecurityBound } =
+    maybeRepairRbac(
+      ws.appPath,
+      ws.systemFilePath,
+      ws.systemParsed,
+      ws.datasourceFiles,
+      {
+        rbac: Boolean(ws.options.rbac),
+        rbacFmt: ws.rbacFmt,
+        rbacPreset: ws.options.rbacPreset,
+        dryRun: ws.dryRun,
+        changes: ws.changes,
+        backupCtx: ws.backupCtx
+      }
+    );
   const anyLocalUpdated =
-    ws.keysNormalized || steps.updated || datasourceRepairUpdated || rbacMigratedFromSystem || rbacMergeUpdated;
+    ws.keysNormalized ||
+    steps.updated ||
+    datasourceRepairUpdated ||
+    rbacMigratedFromSystem ||
+    rbacMergeUpdated ||
+    rbacSyncedIntoSystem ||
+    rbacSecurityBound;
   return {
     steps,
     anyLocalUpdated,
     changes: ws.changes,
     warnings: ws.warnings,
     openapiActionsPerformed,
+    systemKey: ws.systemKey,
     systemFiles: ws.systemFiles,
     datasourceFiles: ws.datasourceFiles
   };
@@ -171,7 +250,8 @@ async function runRepairLocalUpdates(params) {
 async function finalizeRepairIntegration(params, local) {
   const { appName, options, appPath, configPath, dryRun, backupPaths, backupCtx, variables, originalYamlContent } =
     params;
-  const { steps, anyLocalUpdated, changes, warnings, openapiActionsPerformed, systemFiles, datasourceFiles } = local;
+  const { steps, anyLocalUpdated, changes, warnings, openapiActionsPerformed, systemKey, systemFiles, datasourceFiles } =
+    local;
   let manifestRegenerated = false;
   if (anyLocalUpdated && !dryRun) {
     manifestRegenerated = await persistChangesAndRegenerate({
@@ -190,6 +270,16 @@ async function finalizeRepairIntegration(params, local) {
     { ...options, backupCtx },
     changes
   );
+  if (!dryRun) {
+    await regenerateDeployScript(
+      appPath,
+      systemKey || appName,
+      systemFiles,
+      datasourceFiles,
+      changes,
+      backupCtx
+    );
+  }
   const changedFiles = dryRun ? backupCtx.wouldChangeFiles : backupCtx.changedFiles;
   return buildRepairResult(steps, anyLocalUpdated, manifestRegenerated, readmeRegenerated, {
     actionsPerformed: openapiActionsPerformed,

package/lib/commands/repair-internal.js

@@ -9,7 +9,7 @@
 'use strict';
 
 const path = require('path');
-const fs = require('fs');
+const fs = require('../internal/fs-real-sync');
 const chalk = require('chalk');
 const logger = require('../utils/logger');
 

package/lib/commands/repair-openapi-export.js

@@ -0,0 +1,156 @@
+/**
+ * Export full programmatic OpenAPI (components + request/response schemas) for repair --api.
+ *
+ * @fileoverview Materialize integration/<systemKey>/openapi/*.json from buildOpenApiSpec
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('../internal/fs-real-sync');
+const path = require('path');
+const { buildOpenApiSpec } = require('../programmatic/openapi-spec');
+const { loadConfigFile } = require('../utils/config-format');
+const { backupIntegrationFile } = require('../utils/integration-file-backup');
+const { trackRepairWrite } = require('./repair-changed-files');
+
+/**
+ * @param {string} appPath
+ * @param {string} systemKey
+ * @param {string} documentKey
+ * @returns {string}
+ */
+function documentKeyToLocalOpenApiPath(appPath, systemKey, documentKey) {
+  const openapiDir = path.join(appPath, 'openapi');
+  const suffix = documentKey.startsWith(`${systemKey}-`)
+    ? documentKey.slice(systemKey.length + 1)
+    : documentKey;
+  return path.join(openapiDir, `${suffix}.json`);
+}
+
+/** @type {Set<string>} */
+const PROGRAMMATIC_ORCHESTRATION_SYSTEM_KEYS = new Set(['aifabrix-builder-api']);
+
+/**
+ * @param {string} systemKey
+ * @returns {boolean}
+ */
+function isProgrammaticOrchestrationSystem(systemKey) {
+  return PROGRAMMATIC_ORCHESTRATION_SYSTEM_KEYS.has(String(systemKey || '').trim());
+}
+
+/**
+ * @param {string} appPath
+ * @param {string} fileName
+ * @returns {string|null}
+ */
+function readDatasourceDocumentKey(appPath, fileName) {
+  const dsPath = path.join(appPath, fileName);
+  if (!fs.existsSync(dsPath)) {
+    return null;
+  }
+  const parsed = loadConfigFile(dsPath);
+  const openapi = parsed && typeof parsed.openapi === 'object' && !Array.isArray(parsed.openapi) ? parsed.openapi : null;
+  return openapi && typeof openapi.documentKey === 'string' ? openapi.documentKey.trim() : null;
+}
+
+/**
+ * @param {string} appPath
+ * @param {string[]} datasourceFiles
+ * @returns {string|null}
+ */
+function resolveSharedDocumentKey(appPath, datasourceFiles) {
+  const keys = new Set();
+  for (const fileName of datasourceFiles || []) {
+    const dk = readDatasourceDocumentKey(appPath, fileName);
+    if (dk) {
+      keys.add(dk);
+    }
+  }
+  if (keys.size === 1) {
+    return [...keys][0];
+  }
+  return null;
+}
+
+/**
+ * @param {Object} spec
+ * @returns {boolean}
+ */
+function specHasComponentSchemas(spec) {
+  const schemas = spec && spec.components && spec.components.schemas;
+  return Boolean(schemas && typeof schemas === 'object' && Object.keys(schemas).length > 0);
+}
+
+/**
+ * @param {string} localPath
+ * @param {Object} spec
+ * @param {boolean} dryRun
+ * @param {Object} backupCtx
+ * @returns {Promise<void>}
+ */
+async function writeOpenApiSpecToDisk(localPath, spec, dryRun, backupCtx) {
+  if (dryRun) {
+    return;
+  }
+  const openapiDir = path.dirname(localPath);
+  fs.mkdirSync(openapiDir, { recursive: true });
+  if (fs.existsSync(localPath)) {
+    backupIntegrationFile(localPath, backupCtx);
+  }
+  fs.writeFileSync(localPath, `${JSON.stringify(spec, null, 2)}\n`, 'utf8');
+  trackRepairWrite(localPath, backupCtx);
+}
+
+/**
+ * @param {string} localPath
+ * @param {Object} spec
+ * @returns {string}
+ */
+function formatOpenApiExportSummary(localPath, spec) {
+  const rel = path.relative(process.cwd(), localPath);
+  return (
+    `Exported full OpenAPI (${Object.keys(spec.paths || {}).length} paths, `
+    + `${Object.keys(spec.components.schemas || {}).length} schemas) to ${rel}`
+  );
+}
+
+/**
+ * @param {Object} opts
+ * @param {string} opts.appPath
+ * @param {string} opts.systemKey
+ * @param {string[]} opts.datasourceFiles
+ * @param {boolean} opts.dryRun
+ * @param {Object} opts.backupCtx
+ * @returns {Promise<string[]>}
+ */
+async function exportProgrammaticOpenApiForRepair(opts) {
+  const { appPath, systemKey, datasourceFiles, dryRun, backupCtx } = opts;
+  const lines = [];
+  if (!isProgrammaticOrchestrationSystem(systemKey)) {
+    return lines;
+  }
+  const documentKey = resolveSharedDocumentKey(appPath, datasourceFiles);
+  if (!documentKey) {
+    lines.push('Skipped OpenAPI export: datasources do not share a single openapi.documentKey');
+    return lines;
+  }
+  const localPath = documentKeyToLocalOpenApiPath(appPath, systemKey, documentKey);
+  const spec = buildOpenApiSpec();
+  if (!specHasComponentSchemas(spec)) {
+    lines.push('Skipped OpenAPI export: programmatic buildOpenApiSpec() has no component schemas');
+    return lines;
+  }
+  await writeOpenApiSpecToDisk(localPath, spec, dryRun, backupCtx);
+  lines.push(formatOpenApiExportSummary(localPath, spec));
+  return lines;
+}
+
+module.exports = {
+  documentKeyToLocalOpenApiPath,
+  exportProgrammaticOpenApiForRepair,
+  isProgrammaticOrchestrationSystem,
+  resolveSharedDocumentKey,
+  specHasComponentSchemas
+};

package/lib/commands/repair-openapi-sync.js

@@ -24,6 +24,7 @@ const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
 const { uploadFileAs } = require('../utils/file-upload');
 const { listOpenAPIFiles } = require('../api/external-systems.api');
 const { resolveLabDataplaneApiKey } = require('../utils/credential-secrets-env');
+const { exportProgrammaticOpenApiForRepair } = require('./repair-openapi-export');
 
 async function fileExistsAsync(filePath) {
   try {
@@ -190,9 +191,25 @@ async function maybeSyncOpenApiFilesForMcp(opts) {
  * @param {Object} args
  * @returns {Promise<boolean>}
  */
-async function maybeRunOpenApiSyncForMcp({ options, dryRun, appPath, systemKey, datasourceFiles, changes }) {
+async function maybeRunOpenApiSyncForMcp({
+  options,
+  dryRun,
+  appPath,
+  systemKey,
+  datasourceFiles,
+  changes,
+  backupCtx
+}) {
   if (!options.api) return false;
   try {
+    const exportLines = await exportProgrammaticOpenApiForRepair({
+      appPath,
+      systemKey,
+      datasourceFiles,
+      dryRun,
+      backupCtx
+    });
+    exportLines.forEach((line) => changes.push(line));
     const openapiLines = await maybeSyncOpenApiFilesForMcp({
       enabled: true,
       dryRun,
@@ -201,7 +218,7 @@ async function maybeRunOpenApiSyncForMcp({ options, dryRun, appPath, systemKey,
       datasourceFiles
     });
     openapiLines.forEach((l) => changes.push(l));
-    return openapiLines.length > 0;
+    return exportLines.length > 0 || openapiLines.length > 0;
   } catch (err) {
     changes.push(`OpenAPI upload for MCP failed: ${err.message}`);
     return false;