@aifabrix/builder 2.45.0 → 2.46.0

package/lib/commands/repair-datasource-test-payload.js

@@ -0,0 +1,259 @@
+/**
+ * Schema-aware testPayload repair (payloadTemplate / expectedResult).
+ *
+ * @fileoverview Helpers for repair-datasource testPayload generation
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+/**
+ * @param {string|string[]|undefined} type - JSON Schema type
+ * @returns {string}
+ */
+function primarySchemaType(type) {
+  if (Array.isArray(type)) {
+    const nonNull = type.filter(t => t !== 'null');
+    return nonNull[0] || 'string';
+  }
+  return type || 'string';
+}
+
+/**
+ * @param {Object|null|undefined} schema - JSON Schema node
+ * @param {string} key - Property name
+ * @returns {Object|null}
+ */
+function getSchemaProperty(schema, key) {
+  if (!schema || typeof schema !== 'object') return null;
+  const props = schema.properties;
+  if (props && typeof props === 'object' && Object.prototype.hasOwnProperty.call(props, key)) {
+    return props[key];
+  }
+  if (schema.additionalProperties === true) {
+    return { type: 'string' };
+  }
+  if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+    return schema.additionalProperties;
+  }
+  return null;
+}
+
+/**
+ * @param {Object|null|undefined} rootSchema - metadataSchema root
+ * @param {string[]} pathParts - Dot path under raw payload (no raw. prefix)
+ * @returns {Object|null}
+ */
+function getSchemaNodeAtPath(rootSchema, pathParts) {
+  if (!rootSchema || !pathParts.length) return rootSchema;
+  let node = rootSchema;
+  for (const part of pathParts) {
+    if (!part) continue;
+    const next = getSchemaProperty(node, part);
+    if (!next) return null;
+    node = next;
+  }
+  return node;
+}
+
+/**
+ * @param {Object|null|undefined} node - JSON Schema node
+ * @returns {*}
+ */
+function placeholderFromSchemaNode(node) {
+  if (!node || typeof node !== 'object') return '';
+  const type = primarySchemaType(node.type);
+  if (node.format === 'date-time') return '2025-01-15T10:30:00Z';
+  if (node.format === 'date') return '2025-01-15';
+  if (node.format === 'uuid') return '00000000-0000-4000-8000-000000000001';
+  if (type === 'boolean') return false;
+  if (type === 'integer' || type === 'number') return 0;
+  if (type === 'array') return [];
+  if (type === 'object') {
+    if (node.properties && typeof node.properties === 'object') {
+      const out = {};
+      for (const [k, sub] of Object.entries(node.properties)) {
+        out[k] = placeholderFromSchemaNode(sub);
+      }
+      return out;
+    }
+    return {};
+  }
+  return '';
+}
+
+/**
+ * @param {string} type - Legacy attribute type
+ * @returns {*}
+ */
+function placeholderForType(type) {
+  if (type === 'number' || type === 'integer') return 0;
+  if (type === 'boolean') return false;
+  if (type === 'array') return [];
+  if (type === 'object') return {};
+  return '';
+}
+
+/**
+ * @param {Object} parsed - Datasource config
+ * @param {string[]} pathParts - Path under raw payload
+ * @param {Object} [attrConfig] - Attribute config (optional type fallback)
+ * @returns {*}
+ */
+function resolvePlaceholderForPath(parsed, pathParts, attrConfig) {
+  const node = getSchemaNodeAtPath(parsed?.metadataSchema, pathParts);
+  if (node) return placeholderFromSchemaNode(node);
+  return placeholderForType(attrConfig?.type || 'string');
+}
+
+/**
+ * @param {Object} obj - Target object (mutated)
+ * @param {string[]} pathParts - Path segments
+ * @param {*} value - Value to set
+ */
+function setNestedValue(obj, pathParts, value) {
+  const parts = pathParts.filter(Boolean);
+  if (!parts.length) return;
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const p = parts[i];
+    if (!(p in cur) || typeof cur[p] !== 'object' || cur[p] === null || Array.isArray(cur[p])) {
+      cur[p] = {};
+    }
+    cur = cur[p];
+  }
+  const last = parts[parts.length - 1];
+  const existing = cur[last];
+  if (
+    existing &&
+    typeof existing === 'object' &&
+    !Array.isArray(existing) &&
+    value &&
+    typeof value === 'object' &&
+    !Array.isArray(value)
+  ) {
+    cur[last] = { ...existing, ...value };
+    return;
+  }
+  cur[last] = value;
+}
+
+/**
+ * @param {Object} parsed - Datasource config
+ * @param {Array<{ path: string, config: Object }>} pathEntries - Sorted deepest-first
+ * @param {Object} payloadTemplate - payloadTemplate (mutated)
+ */
+function enrichObjectLeavesFromNestedPaths(parsed, pathEntries, payloadTemplate) {
+  const propertiesNode = getSchemaNodeAtPath(parsed?.metadataSchema, ['properties']);
+  for (const { path } of pathEntries) {
+    if (!path.startsWith('properties.')) continue;
+    const leaf = path.slice('properties.'.length);
+    if (!leaf || leaf.includes('.')) continue;
+    if (!payloadTemplate.properties || typeof payloadTemplate.properties !== 'object') {
+      payloadTemplate.properties = placeholderFromSchemaNode(propertiesNode);
+    }
+    if (payloadTemplate.properties[leaf] === undefined || payloadTemplate.properties[leaf] === '') {
+      const leafNode = getSchemaNodeAtPath(parsed?.metadataSchema, ['properties', leaf]);
+      payloadTemplate.properties[leaf] = leafNode
+        ? placeholderFromSchemaNode(leafNode)
+        : 'sample';
+    }
+  }
+}
+
+/**
+ * @param {string} expressionPath - Path from {{ ... }} token
+ * @returns {string|null}
+ */
+function stripExpressionPathPrefix(expressionPath) {
+  const path = expressionPath.trim();
+  if (path.startsWith('raw.')) return path.slice(4);
+  if (path.startsWith('metadata.')) return path.slice(9);
+  return path;
+}
+
+/**
+ * @param {Object} parsed - Datasource config
+ * @param {Object} attrs - fieldMappings.attributes
+ * @returns {Array<{ attrKey: string, path: string|null, config: Object, expectedOnly: *|null }>}
+ */
+function buildPathEntriesFromAttributes(parsed, attrs) {
+  const pathEntries = [];
+  for (const [attrKey, config] of Object.entries(attrs)) {
+    const match = config?.expression?.match(/\{\{\s*([^}|]+)/);
+    if (!match) {
+      const metaNode = parsed.metadataSchema?.properties?.[attrKey];
+      const expected = metaNode
+        ? placeholderFromSchemaNode(metaNode)
+        : placeholderForType(config?.type || 'string');
+      pathEntries.push({ attrKey, path: null, config, expectedOnly: expected });
+      continue;
+    }
+    pathEntries.push({
+      attrKey,
+      path: stripExpressionPathPrefix(match[1]),
+      config,
+      expectedOnly: null
+    });
+  }
+  return pathEntries.sort((a, b) => {
+    const depthA = a.path ? a.path.split('.').length : 0;
+    const depthB = b.path ? b.path.split('.').length : 0;
+    return depthB - depthA;
+  });
+}
+
+/**
+ * @param {Object} parsed - Datasource config
+ * @param {Array} pathEntries - From buildPathEntriesFromAttributes
+ * @returns {{ payloadTemplate: Object, expectedResult: Object }}
+ */
+function buildTemplatesFromPathEntries(parsed, pathEntries) {
+  const payloadTemplate = {};
+  const expectedResult = {};
+  for (const entry of pathEntries) {
+    const { attrKey, path, config, expectedOnly } = entry;
+    const metaNode = parsed.metadataSchema?.properties?.[attrKey];
+    expectedResult[attrKey] = metaNode
+      ? placeholderFromSchemaNode(metaNode)
+      : (expectedOnly ?? placeholderForType(config?.type || 'string'));
+    if (!path) continue;
+    const parts = path.split('.');
+    setNestedValue(payloadTemplate, parts, resolvePlaceholderForPath(parsed, parts, config));
+  }
+  enrichObjectLeavesFromNestedPaths(parsed, pathEntries, payloadTemplate);
+  return { payloadTemplate, expectedResult };
+}
+
+/**
+ * Builds minimal payloadTemplate and expectedResult from attributes + metadataSchema.
+ *
+ * @param {Object} parsed - Parsed datasource (mutated)
+ * @param {string[]} changes - Change log
+ * @returns {boolean} True if testPayload was added or updated
+ */
+function repairTestPayload(parsed, changes) {
+  const attrs = parsed?.fieldMappings?.attributes;
+  if (!attrs || typeof attrs !== 'object') return false;
+
+  const pathEntries = buildPathEntriesFromAttributes(parsed, attrs);
+  const { payloadTemplate, expectedResult } = buildTemplatesFromPathEntries(parsed, pathEntries);
+
+  if (!parsed.testPayload) parsed.testPayload = {};
+  parsed.testPayload.payloadTemplate = payloadTemplate;
+  parsed.testPayload.expectedResult = expectedResult;
+  changes.push(
+    'Generated testPayload.payloadTemplate and testPayload.expectedResult from attributes and metadataSchema'
+  );
+  return true;
+}
+
+module.exports = {
+  primarySchemaType,
+  getSchemaNodeAtPath,
+  placeholderFromSchemaNode,
+  placeholderForType,
+  resolvePlaceholderForPath,
+  repairTestPayload
+};

package/lib/commands/repair-datasource.js

@@ -11,6 +11,7 @@
 
 const { repairOpenapiSection } = require('./repair-datasource-openapi');
 const { normalizeAutoRbacOperationKeys } = require('./repair-datasource-auto-rbac');
+const { repairTestPayload } = require('./repair-datasource-test-payload');
 
 const DEFAULT_SYNC = {
   mode: 'pull',
@@ -358,25 +359,6 @@ function repairSyncSection(parsed, changes) {
   return true;
 }
 
-function placeholderForType(type) {
-  if (type === 'number' || type === 'integer') return 0;
-  if (type === 'boolean') return false;
-  if (type === 'array') return [];
-  if (type === 'object') return {};
-  return '';
-}
-
-function setNested(obj, pathParts, value) {
-  let cur = obj;
-  for (let i = 0; i < pathParts.length - 1; i++) {
-    const p = pathParts[i];
-    if (!(p in cur) || typeof cur[p] !== 'object') cur[p] = {};
-    cur = cur[p];
-  }
-  const last = pathParts[pathParts.length - 1];
-  if (last) cur[last] = value;
-}
-
 /**
  * Removes unknown top-level keys from testPayload (v2.4.1 closed root).
  * @param {Object} parsed - Parsed datasource (mutated)
@@ -398,38 +380,6 @@ function sanitizeTestPayloadTopLevel(parsed, changes) {
   return true;
 }
 
-/**
- * Builds minimal payloadTemplate and expectedResult from attribute expression paths.
- *
- * @param {Object} parsed - Parsed datasource (mutated)
- * @param {string[]} changes - Change log
- * @returns {boolean} True if testPayload was added or updated
- */
-function repairTestPayload(parsed, changes) {
-  const attrs = parsed?.fieldMappings?.attributes;
-  if (!attrs || typeof attrs !== 'object') return false;
-  const payloadTemplate = {};
-  const expectedResult = {};
-  for (const [key, config] of Object.entries(attrs)) {
-    const type = config?.type || 'string';
-    const placeholder = placeholderForType(type);
-    expectedResult[key] = placeholder;
-    const match = config?.expression?.match(/\{\{\s*([^}|]+)/);
-    if (match) {
-      let path = match[1].trim();
-      if (path.startsWith('raw.')) {
-        path = path.slice(4);
-      }
-      setNested(payloadTemplate, path.split('.'), placeholder);
-    }
-  }
-  if (!parsed.testPayload) parsed.testPayload = {};
-  parsed.testPayload.payloadTemplate = payloadTemplate;
-  parsed.testPayload.expectedResult = expectedResult;
-  changes.push('Generated testPayload.payloadTemplate and testPayload.expectedResult from attributes');
-  return true;
-}
-
 /**
  * Runs all requested datasource repairs.
  *

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

@@ -10,9 +10,11 @@
 const path = require('path');
 const fs = require('fs');
 const { backupIntegrationFile } = require('../utils/integration-file-backup');
+const { trackRepairWrite } = require('./repair-changed-files');
 const { systemKeyToKvPrefix, kvEnvKeyToPath, securityKeyToVar } = require('../utils/credential-secrets-env');
 const { extractEnvTemplate } = require('../generator/split');
 const { generateExternalEnvTemplateContent } = require('../utils/external-env-template');
+const { commentOrphanKvEnvLines } = require('../utils/env-kv-orphan-lines');
 
 /**
  * Normalizes a keyvault config entry to canonical KV_* name and path-style value.
@@ -136,7 +138,7 @@ function buildExpectedByKey(effective) {
  * @param {Object} [systemParsed] - Parsed system config for template context (preferred)
  * @returns {boolean}
  */
-function createEnvTemplateIfMissing(envPath, expectedByKey, dryRun, changes, systemParsed) {
+function createEnvTemplateIfMissing(envPath, expectedByKey, dryRun, changes, systemParsed, backupCtx) {
   if (fs.existsSync(envPath)) return false;
   if (expectedByKey.size === 0) return false;
   const content = systemParsed
@@ -145,6 +147,7 @@ function createEnvTemplateIfMissing(envPath, expectedByKey, dryRun, changes, sys
   if (!content || !content.trim()) return false;
   const hasKeyValueLine = /^[A-Z_][A-Z0-9_]*=/m.test(content);
   if (!hasKeyValueLine) return false;
+  trackRepairWrite(envPath, backupCtx);
   if (!dryRun) {
     fs.writeFileSync(envPath, content + (content.endsWith('\n') ? '' : '\n'), { mode: 0o644, encoding: 'utf8' });
   }
@@ -229,6 +232,51 @@ function mergeEnvTemplateContent(content, expectedByKey) {
   return { output, changed: changedRef.value };
 }
 
+/**
+ * Comments active KV_* lines whose env key is not in the system-derived expected set.
+ * @param {string} content
+ * @param {Map<string, string>} expectedByKey
+ * @param {{ value: boolean }} changedRef
+ * @returns {string}
+ */
+function commentOrphanKvLines(content, expectedByKey, changedRef) {
+  const { content: next, changed } = commentOrphanKvEnvLines(content, expectedByKey);
+  if (changed) {
+    changedRef.value = true;
+  }
+  return next;
+}
+
+/**
+ * @param {string} envPath
+ * @param {string} output
+ * @param {boolean} dryRun
+ * @param {Object} [backupCtx]
+ */
+function persistEnvTemplate(envPath, output, dryRun, backupCtx) {
+  trackRepairWrite(envPath, backupCtx);
+  if (!dryRun) {
+    backupIntegrationFile(envPath, backupCtx);
+    fs.writeFileSync(envPath, output, { mode: 0o644, encoding: 'utf8' });
+  }
+}
+
+/**
+ * @param {string} content
+ * @param {Map<string, string>} expectedByKey
+ * @returns {{ output: string, mergeChanged: boolean, pruneChanged: boolean }}
+ */
+function mergeAndPruneEnvTemplate(content, expectedByKey) {
+  const mergeResult = mergeEnvTemplateContent(content, expectedByKey);
+  const pruneChanged = { value: false };
+  const output = commentOrphanKvLines(mergeResult.output, expectedByKey, pruneChanged);
+  return {
+    output,
+    mergeChanged: mergeResult.changed,
+    pruneChanged: pruneChanged.value
+  };
+}
+
 /**
  * Repairs env.template so KV_ names and path-style kv:// values match the system file.
  * @param {string} appPath - Application directory path
@@ -240,29 +288,32 @@ function mergeEnvTemplateContent(content, expectedByKey) {
  * @returns {boolean} True if env.template was repaired or created
  */
 function repairEnvTemplate(appPath, systemParsed, systemKey, dryRun, changes, backupCtx) {
-  const effective = buildEffectiveConfiguration(systemParsed, systemKey);
-  const expectedByKey = buildExpectedByKey(effective);
+  const expectedByKey = buildExpectedByKey(buildEffectiveConfiguration(systemParsed, systemKey));
   const envPath = path.join(appPath, 'env.template');
 
-  if (createEnvTemplateIfMissing(envPath, expectedByKey, dryRun, changes, systemParsed)) {
+  if (createEnvTemplateIfMissing(envPath, expectedByKey, dryRun, changes, systemParsed, backupCtx)) {
     return true;
   }
   if (!fs.existsSync(envPath)) {
     return false;
   }
 
-  const content = fs.readFileSync(envPath, 'utf8');
-  const { output, changed } = mergeEnvTemplateContent(content, expectedByKey);
-
-  if (changed && !dryRun) {
-    backupIntegrationFile(envPath, backupCtx);
-    fs.writeFileSync(envPath, output, { mode: 0o644, encoding: 'utf8' });
+  const { output, mergeChanged, pruneChanged } = mergeAndPruneEnvTemplate(
+    fs.readFileSync(envPath, 'utf8'),
+    expectedByKey
+  );
+  if (!mergeChanged && !pruneChanged) {
+    return false;
   }
-  if (changed) {
+
+  persistEnvTemplate(envPath, output, dryRun, backupCtx);
+  if (mergeChanged) {
     changes.push('Repaired env.template (KV_* names and path-style kv:// values)');
-    return true;
   }
-  return false;
+  if (pruneChanged) {
+    changes.push('Commented stale env.template KV_* lines (not in system authentication)');
+  }
+  return true;
 }
 
 /**

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

@@ -0,0 +1,216 @@
+/**
+ * External integration repair orchestration (local file updates, manifest, README).
+ *
+ * @fileoverview Repair external integration run pipeline
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { normalizeDatasourceKeysAndFilenames } = require('./repair-datasource-keys');
+const { resolveSystemContext } = require('./repair-system-alignment');
+const { persistChangesAndRegenerate, regenerateReadmeIfRequested } = require('./repair-persist');
+const { runRepairSteps } = require('./repair-steps');
+const { runDatasourceRepairs } = require('./repair-datasource-run');
+const { maybeRepairRbac } = require('./repair-rbac');
+const { maybeRunOpenApiSyncForMcp } = require('./repair-openapi-sync');
+
+/**
+ * @param {Object} steps
+ * @param {boolean} anyUpdated
+ * @param {boolean} manifestRegenerated
+ * @param {boolean} readmeRegenerated
+ * @param {Object} ctx
+ * @returns {Object}
+ */
+function buildRepairResult(steps, anyUpdated, manifestRegenerated, readmeRegenerated, ctx) {
+  return Object.assign(
+    {
+      updated: anyUpdated,
+      actionsPerformed: ctx.actionsPerformed === true,
+      changes: ctx.changes,
+      warnings: ctx.warnings || [],
+      changedFiles: ctx.changedFiles || [],
+      systemFiles: ctx.systemFiles,
+      datasourceFiles: ctx.datasourceFiles,
+      backupPaths: ctx.backupPaths || []
+    },
+    {
+      appKeyFixed: steps.appKeyFixed,
+      datasourceKeysFixed: steps.datasourceKeysFixed,
+      rbacFileCreated: steps.rbacFileCreated,
+      envTemplateRepaired: steps.envTemplateRepaired,
+      manifestRegenerated,
+      readmeRegenerated
+    }
+  );
+}
+
+/**
+ * @param {Object} params
+ * @returns {Object}
+ */
+function prepareRepairWorkspace(params) {
+  const {
+    options,
+    appPath,
+    configPath,
+    dryRun,
+    authOption,
+    backupCtx,
+    variables,
+    systemFiles,
+    datasourceFiles: initialDatasourceFiles
+  } = params;
+  const changes = [];
+  const warnings = [];
+  const { systemFilePath, systemParsed, systemKey } = resolveSystemContext(appPath, systemFiles);
+  const rbacFmt = options.format === 'json' ? 'json' : 'yaml';
+  const { updated: keysNormalized, datasourceFiles } = normalizeDatasourceKeysAndFilenames(
+    appPath,
+    initialDatasourceFiles,
+    systemKey,
+    { variables, dryRun, changes, backupCtx }
+  );
+  return {
+    options,
+    appPath,
+    configPath,
+    dryRun,
+    authOption,
+    backupCtx,
+    variables,
+    systemFiles,
+    changes,
+    warnings,
+    systemFilePath,
+    systemParsed,
+    systemKey,
+    rbacFmt,
+    keysNormalized,
+    datasourceFiles
+  };
+}
+
+/**
+ * @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
+  });
+  const datasourceRepairUpdated = runDatasourceRepairs(
+    ws.appPath,
+    ws.datasourceFiles,
+    {
+      expose: Boolean(ws.options.expose),
+      sync: Boolean(ws.options.sync),
+      test: Boolean(ws.options.test),
+      backupCtx: ws.backupCtx
+    },
+    ws.dryRun,
+    ws.changes
+  );
+  const openapiActionsPerformed = await maybeRunOpenApiSyncForMcp({
+    options: ws.options,
+    dryRun: ws.dryRun,
+    appPath: ws.appPath,
+    systemKey: ws.systemKey,
+    datasourceFiles: ws.datasourceFiles,
+    changes: ws.changes
+  });
+  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 }
+  );
+  const anyLocalUpdated =
+    ws.keysNormalized || steps.updated || datasourceRepairUpdated || rbacMigratedFromSystem || rbacMergeUpdated;
+  return {
+    steps,
+    anyLocalUpdated,
+    changes: ws.changes,
+    warnings: ws.warnings,
+    openapiActionsPerformed,
+    systemFiles: ws.systemFiles,
+    datasourceFiles: ws.datasourceFiles
+  };
+}
+
+/**
+ * @param {Object} params
+ * @returns {Promise<Object>}
+ */
+async function runRepairLocalUpdates(params) {
+  const ws = prepareRepairWorkspace(params);
+  return runRepairIntegrationFileSteps(ws);
+}
+
+/**
+ * @param {Object} params
+ * @param {Object} local
+ * @returns {Promise<Object>}
+ */
+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;
+  let manifestRegenerated = false;
+  if (anyLocalUpdated && !dryRun) {
+    manifestRegenerated = await persistChangesAndRegenerate({
+      configPath,
+      variables,
+      appName,
+      appPath,
+      changes,
+      originalYamlContent,
+      backupCtx
+    });
+  }
+  const readmeRegenerated = await regenerateReadmeIfRequested(
+    appName,
+    appPath,
+    { ...options, backupCtx },
+    changes
+  );
+  const changedFiles = dryRun ? backupCtx.wouldChangeFiles : backupCtx.changedFiles;
+  return buildRepairResult(steps, anyLocalUpdated, manifestRegenerated, readmeRegenerated, {
+    actionsPerformed: openapiActionsPerformed,
+    changes,
+    warnings,
+    changedFiles,
+    systemFiles,
+    datasourceFiles,
+    backupPaths
+  });
+}
+
+/**
+ * @param {Object} params
+ * @returns {Promise<Object>}
+ */
+async function runRepairExternalIntegration(params) {
+  const local = await runRepairLocalUpdates(params);
+  return finalizeRepairIntegration(params, local);
+}
+
+module.exports = {
+  runRepairExternalIntegration
+};

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

@@ -164,9 +164,32 @@ async function maybeSyncOpenApiFilesForMcp(opts) {
   return lines;
 }
 
+/**
+ * @param {Object} args
+ * @returns {Promise<boolean>}
+ */
+async function maybeRunOpenApiSyncForMcp({ options, dryRun, appPath, systemKey, datasourceFiles, changes }) {
+  if (!options.api) return false;
+  try {
+    const openapiLines = await maybeSyncOpenApiFilesForMcp({
+      enabled: true,
+      dryRun,
+      appPath,
+      systemKey,
+      datasourceFiles
+    });
+    openapiLines.forEach((l) => changes.push(l));
+    return openapiLines.length > 0;
+  } catch (err) {
+    changes.push(`OpenAPI upload for MCP failed: ${err.message}`);
+    return false;
+  }
+}
+
 module.exports = {
   documentKeyToLocalOpenApiPath,
   maybeSyncOpenApiFilesForMcp,
+  maybeRunOpenApiSyncForMcp,
   syncOpenApiFilesForMcp
 };