@aifabrix/builder 2.49.2 → 2.51.0

package/lib/commands/upload-probe.js

@@ -0,0 +1,66 @@
+/**
+ * @fileoverview Optional upload-time runtime probe (--probe).
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const { testSystemViaPipeline } = require('../api/pipeline.api');
+const { unwrapApiData } = require('../utils/external-system-readiness-core');
+const { logProbeRuntimeBlock, SEP } = require('../utils/external-system-readiness-display');
+const { formatProgress, sectionTitle } = require('../utils/cli-test-layout-chalk');
+const logger = require('../utils/logger');
+
+/** Omit payloadTemplate so POST /validation/run uses the validation-engine path. */
+const UPLOAD_PROBE_TEST_DATA = {};
+
+/**
+ * @param {string} dataplaneUrl
+ * @param {string} systemKey
+ * @param {Object} authConfig
+ * @param {number|undefined} probeTimeoutMs
+ * @param {{ compact?: boolean }} [opts]
+ * @returns {Promise<Object|null>}
+ */
+async function maybeRunUploadProbe(dataplaneUrl, systemKey, authConfig, probeTimeoutMs, opts = {}) {
+  const compact = opts.compact === true;
+  if (!compact) {
+    logger.log('');
+    logger.log(sectionTitle('Runtime checks (--probe)'));
+    logger.log(SEP);
+    logger.log(formatProgress('Running runtime checks...'));
+  }
+  const timeoutMs = probeTimeoutMs === undefined || probeTimeoutMs === null ? 120000 : probeTimeoutMs;
+  try {
+    const pr = await testSystemViaPipeline(
+      dataplaneUrl,
+      systemKey,
+      authConfig,
+      UPLOAD_PROBE_TEST_DATA,
+      { timeout: timeoutMs }
+    );
+    if (pr.success === false) {
+      if (!compact) {
+        logger.log(chalk.yellow(`⚠ Probe request failed: ${pr.formattedError || pr.error || 'unknown error'}`));
+      }
+      return null;
+    }
+    const probeData = unwrapApiData(pr);
+    if (!compact) {
+      logProbeRuntimeBlock(probeData, systemKey);
+    }
+    return probeData;
+  } catch (e) {
+    if (!compact) {
+      logger.log(chalk.yellow(`⚠ Probe failed: ${e.message}`));
+    }
+    return null;
+  }
+}
+
+module.exports = {
+  maybeRunUploadProbe,
+  UPLOAD_PROBE_TEST_DATA
+};

package/lib/commands/upload-publish-context.js

@@ -51,7 +51,10 @@ async function resolveUploadPublishContext(
   payload
 ) {
   const resolved = await resolveDataplaneAndAuth(systemKey, {
-    silent: options.silentResolve === true
+    silent: options.silentResolve === true,
+    authConfig: options.authConfig,
+    dataplaneUrl: options.dataplaneUrl,
+    environment: options.environment
   });
   requireBearerForDataplanePipeline(resolved.authConfig);
   if (options.force === true) {

package/lib/commands/upload-sidecar-followups.js

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Upload sidecar follow-ups (governance packs, certification sync).
+ * @fileoverview Upload sidecar follow-ups (governance scenario packs).
  * @author AI Fabrix Team
  * @version 1.0.0
  */
@@ -10,19 +10,16 @@ const logger = require('../utils/logger');
 const { formatWarningLine } = require('../utils/cli-test-layout-chalk');
 const { unwrapPublicationResult, isPublicationUnchanged } = require('../utils/external-system-readiness-core');
 const { logUploadReadinessSummary } = require('../utils/external-system-readiness-display');
-const { maybeSyncSystemCertificationFromDataplane } = require('../certification/sync-system-certification');
-const { cliOptsSkipCertSync } = require('../certification/cli-cert-sync-skip');
 const { isQuietMinimalSync } = require('../utils/upload-sync-options');
 
 /**
- * Sidecar follow-ups that are independent of pipeline publish hash (scenario packs, cert sync).
+ * Sidecar follow-ups that are independent of pipeline publish hash (scenario packs).
  * @param {Object} ctx
  * @returns {Promise<void>}
  */
 async function runUploadSidecarFollowups(ctx) {
-  const { systemKey, options, payload, dataplaneUrl, authConfig } = ctx;
+  const { systemKey, options, dataplaneUrl, authConfig } = ctx;
   const quietSidecar = isQuietMinimalSync(options);
-  const dsKeys = (payload.dataSources || []).map((ds) => ds && ds.key).filter(Boolean);
   try {
     const { uploadGovernanceScenarioPacks } = require('../lifecycle/scenario-upload');
     await uploadGovernanceScenarioPacks(systemKey, dataplaneUrl, authConfig, { silent: quietSidecar });
@@ -31,15 +28,30 @@ async function runUploadSidecarFollowups(ctx) {
       logger.log(formatWarningLine(`Governance scenario upload skipped: ${err.message}`));
     }
   }
-  await maybeSyncSystemCertificationFromDataplane({
-    label: 'upload',
-    noCertSync: cliOptsSkipCertSync(options),
-    systemKey,
-    dataplaneUrl,
-    authConfig,
-    datasourceKeys: dsKeys,
-    silent: quietSidecar
-  });
+}
+
+/**
+ * @param {Object} ctx
+ * @param {Function} maybeRunUploadProbeFn
+ * @returns {Promise<{ probeData: Object|null, compact: boolean }>}
+ */
+async function resolveUploadProbeData(ctx, maybeRunUploadProbeFn) {
+  const { systemKey, options, dataplaneUrl, authConfig } = ctx;
+  const compact = !!options.minimal && options.verbose !== true;
+  if (!options.probe) {
+    return { probeData: null, compact };
+  }
+  if (compact) {
+    const probeData = await maybeRunUploadProbeFn(
+      dataplaneUrl,
+      systemKey,
+      authConfig,
+      options.probeTimeout,
+      { compact: true }
+    );
+    return { probeData, compact };
+  }
+  return { probeData: null, compact };
 }
 
 /**
@@ -56,7 +68,9 @@ async function handlePublicationAndFollowups(ctx, maybeRunUploadProbe) {
     environment,
     dataplaneUrl,
     authConfig,
-    rawRes
+    rawRes,
+    credentialPush,
+    configPush
   } = ctx;
   const publication = unwrapPublicationResult(rawRes);
   if (!publication) {
@@ -68,18 +82,32 @@ async function handlePublicationAndFollowups(ctx, maybeRunUploadProbe) {
     await runUploadSidecarFollowups({ systemKey, options, payload, dataplaneUrl, authConfig });
     return;
   }
-  logUploadReadinessSummary({
-    environment,
-    dataplaneUrl,
-    systemKey,
-    publication,
-    manifest,
-    minimal: !!options.minimal,
-    willProbe: !!options.probe
-  });
-  if (options.probe) {
-    await maybeRunUploadProbe(dataplaneUrl, systemKey, authConfig, options.probeTimeout);
+
+  const suppressSummary = options.suppressSummary === true;
+  const { probeData, compact } = await resolveUploadProbeData(ctx, maybeRunUploadProbe);
+
+  if (!suppressSummary) {
+    logUploadReadinessSummary({
+      environment,
+      dataplaneUrl,
+      systemKey,
+      publication,
+      manifest,
+      minimal: !!options.minimal,
+      willProbe: false,
+      credentialPush,
+      configPush,
+      forcePublish: options.force === true,
+      probeData
+    });
   }
+
+  if (options.probe && !compact) {
+    await maybeRunUploadProbe(dataplaneUrl, systemKey, authConfig, options.probeTimeout, {
+      compact: false
+    });
+  }
+
   await runUploadSidecarFollowups({ systemKey, options, payload, dataplaneUrl, authConfig });
 }
 

package/lib/commands/upload.js

@@ -1,7 +1,6 @@
 const {
   formatSuccessLine,
   formatWarningLine,
-  formatProgress,
   sectionTitle,
   headerKeyValue,
   metadata
@@ -15,7 +14,6 @@ const {
  * @version 2.0.0
  */
 
-const path = require('path');
 const chalk = require('chalk');
 const logger = require('../utils/logger');
 
@@ -23,38 +21,32 @@ const SEP = chalk.gray('──────────────────
 const { resolveControllerUrl } = require('../utils/controller-url');
 const { getDeploymentAuth } = require('../utils/token-manager');
 const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
-const { getIntegrationPath } = require('../utils/paths');
-const { pushCredentialSecrets } = require('../utils/credential-secrets-env');
-const { runWithCredentialPushSpinner } = require('../utils/credential-push-ui');
+const { resolveExternalSystemPath } = require('../utils/app-path-resolve');
 const { runWithUploadPipelineSpinner } = require('../utils/upload-pipeline-ui');
 const {
   buildResolvedEnvMapForIntegration,
-  resolveConfigurationValues,
-  collectResolvedVariableConfigurationNames
+  resolveConfigurationValues
 } = require('../utils/configuration-env-resolver');
-const { pushRuntimeConfigurationValues } = require('../utils/runtime-configuration-values');
 const { validateExternalSystemComplete } = require('../validation/validate');
 const { displayValidationResults } = require('../validation/validate-display');
 const { generateControllerManifest } = require('../generator/external-controller-manifest');
 const {
-  validatePipelineConfig,
-  testSystemViaPipeline
+  validatePipelineConfig
 } = require('../api/pipeline.api');
 const { uploadApplicationViaPipelineWithAuthRetry } = require('../utils/pipeline-upload-auth-retry');
 const { formatApiError } = require('../utils/api-error-handler');
 const { unwrapPublicationResult, unwrapApiData, isPublicationUnchanged } = require('../utils/external-system-readiness-core');
 const {
-  logServerValidationWarnings,
-  logProbeRuntimeBlock
+  logServerValidationWarnings
 } = require('../utils/external-system-readiness-display');
+const { maybeRunUploadProbe } = require('./upload-probe');
 const { maybeSyncOpenApiFilesForMcp } = require('./repair-openapi-sync');
+const { exportProgrammaticOpenApiForRepair } = require('./repair-openapi-export');
 const { resolveUploadPublishContext } = require('./upload-publish-context');
 const { syncDeployJsonFromSources } = require('../external-system/sync-deploy-manifest');
-const { isQuietMinimalSync } = require('../utils/upload-sync-options');
-const {
-  runUploadSidecarFollowups,
-  handlePublicationAndFollowups
-} = require('./upload-sidecar-followups');
+const { handlePublicationAndFollowups } = require('./upload-sidecar-followups');
+const { finalizeUploadPublishResult, finishUnchangedUploadPublication } = require('./upload-data-sync-finalize');
+const { pushAndLogCredentialSecrets } = require('./upload-credential-push-log');
 
 /**
  * Validates system-key format (same as download).
@@ -72,21 +64,22 @@ function validateSystemKeyFormat(systemKey) {
 
 /**
  * Builds pipeline upload payload from controller manifest.
- * Payload: { version, application, dataSources, status }; Builder always uses status "draft".
+ * Payload: { version, application, dataSources, status }; upload uses "draft", deploy preflight uses "published".
  * @param {Object} manifest - Controller manifest from generateControllerManifest
- * @returns {Object} { version, application, dataSources, status: "draft" }
+ * @returns {Object} { version, application, dataSources, status }
  */
 /**
  * @param {Object} manifest - Controller manifest from generateControllerManifest
- * @param {{ force?: boolean }} [opts]
+ * @param {{ force?: boolean, status?: 'draft'|'published' }} [opts]
  * @returns {Object}
  */
 function buildUploadPayload(manifest, opts = {}) {
+  const lifecycleStatus = opts.status === 'published' ? 'published' : 'draft';
   const payload = {
     version: manifest.version || '1.0.0',
     application: manifest.system,
     dataSources: manifest.dataSources || [],
-    status: 'draft'
+    status: lifecycleStatus
   };
   if (opts.force === true) {
     payload.force = true;
@@ -101,6 +94,13 @@ function buildUploadPayload(manifest, opts = {}) {
  * @returns {Promise<{ dataplaneUrl: string, authConfig: Object, environment: string }>}
  */
 async function resolveDataplaneAndAuth(systemKey, opts = {}) {
+  if (opts.authConfig && opts.dataplaneUrl && opts.environment) {
+    return {
+      dataplaneUrl: opts.dataplaneUrl,
+      authConfig: opts.authConfig,
+      environment: opts.environment
+    };
+  }
   const silent = opts.silent === true;
   const { resolveEnvironment } = require('../core/config');
   const environment = await resolveEnvironment();
@@ -170,8 +170,11 @@ function throwIfValidationFailed(validationResult) {
  * @param {string} systemKey - System key
  * @param {Object} payload - Upload payload (mutated)
  */
-async function resolvePayloadConfiguration(systemKey, payload) {
-  const { envMap, secrets } = await buildResolvedEnvMapForIntegration(systemKey);
+async function resolvePayloadConfiguration(systemKey, payload, pathOptions = {}) {
+  const { envMap, secrets } = await buildResolvedEnvMapForIntegration(systemKey, {
+    dataplaneRuntime: true,
+    ...pathOptions
+  });
   if (Array.isArray(payload.application?.configuration) && payload.application.configuration.length > 0) {
     resolveConfigurationValues(payload.application.configuration, envMap, secrets, systemKey);
   }
@@ -182,64 +185,6 @@ async function resolvePayloadConfiguration(systemKey, payload) {
   }
 }
 
-/**
- * Pushes credential secrets from .env and payload to dataplane; logs result or warning.
- * @param {string} dataplaneUrl - Dataplane URL
- * @param {Object} authConfig - Auth config
- * @param {string} systemKey - System key
- * @param {Object} payload - Upload payload
- */
-async function pushAndLogCredentialSecrets(dataplaneUrl, authConfig, systemKey, payload, uiOpts = {}) {
-  const envFilePath = path.join(getIntegrationPath(systemKey), '.env');
-  const pushResult = await runWithCredentialPushSpinner(
-    () =>
-      pushCredentialSecrets(dataplaneUrl, authConfig, {
-        envFilePath,
-        appName: systemKey,
-        payload
-      }),
-    { systemKey, json: uiOpts.json === true }
-  );
-  if (pushResult.pushed > 0) {
-    const keyList = pushResult.keys?.length ? ` (${pushResult.keys.join(', ')})` : '';
-    logger.log(
-      formatSuccessLine(`Pushed ${pushResult.pushed} credential secret(s) to dataplane${keyList}.`)
-    );
-  } else {
-    logger.log(chalk.yellow('Secret push skipped'));
-  }
-  const resolvedParamNames = collectResolvedVariableConfigurationNames(payload);
-  if (resolvedParamNames.length > 0) {
-    const nameList = ` (${resolvedParamNames.join(', ')})`;
-    logger.log(
-      formatSuccessLine(
-        `Resolved ${resolvedParamNames.length} integration parameter(s) from .env for publish${nameList}.`
-      )
-    );
-  }
-  if (pushResult.warning) {
-    logger.log(chalk.yellow(`Warning: ${pushResult.warning}`));
-  }
-  try {
-    const configPush = await pushRuntimeConfigurationValues(
-      dataplaneUrl,
-      authConfig,
-      systemKey,
-      payload
-    );
-    if (configPush.pushed > 0) {
-      const nameList = configPush.names.length ? ` (${configPush.names.join(', ')})` : '';
-      logger.log(
-        formatSuccessLine(
-          `Stored ${configPush.pushed} runtime configuration value(s) in dataplane${nameList}.`
-        )
-      );
-    }
-  } catch (err) {
-    logger.log(chalk.yellow(`Warning: runtime configuration store skipped: ${err.message}`));
-  }
-}
-
 /**
  * Optional server-side pipeline validate when --verbose.
  * @param {string} dataplaneUrl
@@ -261,46 +206,6 @@ async function maybeRunVerboseServerValidation(dataplaneUrl, authConfig, payload
   logServerValidationWarnings(body);
 }
 
-/**
- * Omit payloadTemplate so POST /validation/run uses the **validation-engine** path
- * (same as deploy --probe). Needed for certification and dataplane auto-issue of integration
- * certificates after a successful run. If RBAC/live checks fail right after upload until the
- * controller syncs permissions, skip --probe or retry once permissions are visible.
- */
-const UPLOAD_PROBE_TEST_DATA = {};
-
-/**
- * Optional POST validation/run after successful upload.
- * @param {string} dataplaneUrl
- * @param {string} systemKey
- * @param {Object} authConfig
- * @param {number|undefined} probeTimeoutMs
- */
-async function maybeRunUploadProbe(dataplaneUrl, systemKey, authConfig, probeTimeoutMs) {
-  logger.log('');
-  logger.log(sectionTitle('Runtime checks (--probe)'));
-  logger.log(SEP);
-  logger.log(formatProgress('Running runtime checks...'));
-  const timeoutMs = probeTimeoutMs === undefined || probeTimeoutMs === null ? 120000 : probeTimeoutMs;
-  try {
-    const pr = await testSystemViaPipeline(
-      dataplaneUrl,
-      systemKey,
-      authConfig,
-      UPLOAD_PROBE_TEST_DATA,
-      { timeout: timeoutMs }
-    );
-    if (pr.success === false) {
-      logger.log(chalk.yellow(`⚠ Probe request failed: ${pr.formattedError || pr.error || 'unknown error'}`));
-      return;
-    }
-    const probeData = unwrapApiData(pr);
-    logProbeRuntimeBlock(probeData, systemKey);
-  } catch (e) {
-    logger.log(chalk.yellow(`⚠ Probe failed: ${e.message}`));
-  }
-}
-
 /**
  * Local validation, manifest, payload, and configuration resolution.
  * Regenerates integration/<systemKey>/<systemKey>-deploy.json from sources (same as `aifabrix json`).
@@ -311,15 +216,22 @@ async function maybeRunUploadProbe(dataplaneUrl, systemKey, authConfig, probeTim
  */
 async function buildValidatedUploadManifestPayload(systemKey, opts = {}) {
   const quiet = opts.minimal === true || opts.quiet === true;
-  const validationResult = await validateExternalSystemComplete(systemKey, { type: 'external' });
+  const pathOptions = opts.pathOptions || {};
+  const validationResult = await validateExternalSystemComplete(systemKey, {
+    type: 'external',
+    ...pathOptions
+  });
   throwIfValidationFailed(validationResult);
   if (!quiet) {
     logger.log(formatSuccessLine('Local validation passed'));
   }
-  await syncDeployJsonFromSources(systemKey, { quiet });
-  const manifest = await generateControllerManifest(systemKey, { type: 'external' });
-  const payload = buildUploadPayload(manifest, { force: opts.force === true });
-  await resolvePayloadConfiguration(systemKey, payload);
+  await syncDeployJsonFromSources(systemKey, { quiet, ...pathOptions });
+  const manifest = await generateControllerManifest(systemKey, { type: 'external', ...pathOptions });
+  const payload = buildUploadPayload(manifest, {
+    force: opts.force === true,
+    status: opts.uploadStatus === 'published' ? 'published' : 'draft'
+  });
+  await resolvePayloadConfiguration(systemKey, payload, pathOptions);
   return { manifest, payload };
 }
 
@@ -334,9 +246,17 @@ async function buildValidatedUploadManifestPayload(systemKey, opts = {}) {
  * @returns {Promise<void>}
  */
 async function logAndSyncLocalOpenApiForUpload(systemKey, manifest, uploadContext = {}) {
-  const appPath = getIntegrationPath(systemKey);
+  const pathOptions = uploadContext.pathOptions || {};
+  const appPath = resolveExternalSystemPath(systemKey, pathOptions);
   const ei = manifest && manifest.externalIntegration;
   const datasourceFiles = ei && Array.isArray(ei.dataSources) ? ei.dataSources : [];
+  await exportProgrammaticOpenApiForRepair({
+    appPath,
+    systemKey,
+    datasourceFiles,
+    dryRun: false,
+    backupCtx: { dryRun: false, changedFiles: [] }
+  });
   const openapiSyncLines = await maybeSyncOpenApiFilesForMcp({
     enabled: true,
     dryRun: false,
@@ -346,11 +266,55 @@ async function logAndSyncLocalOpenApiForUpload(systemKey, manifest, uploadContex
     dataplaneUrl: uploadContext.dataplaneUrl,
     authConfig: uploadContext.authConfig
   });
-  for (const line of openapiSyncLines) {
-    logger.log(line.startsWith('Skipped') ? formatWarningLine(line) : formatSuccessLine(line));
+  if (!uploadContext.quiet) {
+    for (const line of openapiSyncLines) {
+      logger.log(line.startsWith('Skipped') ? formatWarningLine(line) : formatSuccessLine(line));
+    }
   }
 }
 
+/**
+ * @param {string} systemKey
+ * @param {Object} options
+ * @param {Object} manifest
+ * @param {Object} payload
+ * @param {{ dataplaneUrl: string, authConfig: Object, environment: string, rawRes: Object }} ctx
+ */
+async function completeUploadAfterPublish(systemKey, options, manifest, payload, ctx) {
+  const quietCompact = options.minimal === true && options.verbose !== true;
+  const pushMeta = await pushAndLogCredentialSecrets(ctx.dataplaneUrl, ctx.authConfig, systemKey, payload, {
+    json: options.json === true,
+    pathOptions: options.pathOptions,
+    suppressCredentialLog: quietCompact
+  });
+  await logAndSyncLocalOpenApiForUpload(systemKey, manifest, {
+    dataplaneUrl: ctx.dataplaneUrl,
+    authConfig: ctx.authConfig,
+    pathOptions: options.pathOptions,
+    quiet: quietCompact
+  });
+  await handlePublicationAndFollowups(
+    {
+      systemKey,
+      options,
+      manifest,
+      payload,
+      environment: ctx.environment,
+      dataplaneUrl: ctx.dataplaneUrl,
+      authConfig: ctx.authConfig,
+      rawRes: ctx.rawRes,
+      credentialPush: pushMeta.credentialPush,
+      configPush: pushMeta.configPush
+    },
+    maybeRunUploadProbe
+  );
+  return finalizeUploadPublishResult(
+    { dataplaneUrl: ctx.dataplaneUrl, authConfig: ctx.authConfig, environment: ctx.environment, uploadSkipped: false },
+    payload,
+    options
+  );
+}
+
 /**
  * Upload path after dry-run check.
  * @param {string} systemKey
@@ -377,37 +341,22 @@ async function runUploadPublishAndSummary(systemKey, options, manifest, payload)
   );
   const publication = unwrapPublicationResult(rawRes);
   if (isPublicationUnchanged(publication)) {
-    if (!isQuietMinimalSync(options)) {
-      logger.log(formatSuccessLine('Config unchanged on dataplane — upload skipped.'));
-    }
-    await runUploadSidecarFollowups({
+    return finishUnchangedUploadPublication({
       systemKey,
       options,
       payload,
       dataplaneUrl,
-      authConfig
+      authConfig,
+      environment
     });
-    return { dataplaneUrl, authConfig, environment, uploadSkipped: true };
   }
 
-  await pushAndLogCredentialSecrets(dataplaneUrl, authConfig, systemKey, payload, {
-    json: options.json === true
+  return completeUploadAfterPublish(systemKey, options, manifest, payload, {
+    dataplaneUrl,
+    authConfig,
+    environment,
+    rawRes
   });
-  await logAndSyncLocalOpenApiForUpload(systemKey, manifest, { dataplaneUrl, authConfig });
-  await handlePublicationAndFollowups(
-    {
-      systemKey,
-      options,
-      manifest,
-      payload,
-      environment,
-      dataplaneUrl,
-      authConfig,
-      rawRes
-    },
-    maybeRunUploadProbe
-  );
-  return { dataplaneUrl, authConfig, environment, uploadSkipped: false };
 }
 
 /**
@@ -415,16 +364,23 @@ async function runUploadPublishAndSummary(systemKey, options, manifest, payload)
  * @param {string} systemKey - External system key (integration/<systemKey>/)
  * @param {Object} [options] - Options
  * @param {boolean} [options.dryRun] - Validate and build payload only; no API calls
- * @param {boolean} [options.verbose] - POST pipeline/validate for server warnings
+ * @param {boolean} [options.verbose] - Expanded summary and server-side pipeline validate warnings
  * @param {boolean} [options.probe] - POST validation/run after publish
  * @param {number} [options.probeTimeout] - Probe timeout ms (default 120000)
- * @param {boolean} [options.minimal] - Short summary only
+ * @param {boolean} [options.minimal] - Short summary (default: compact unless --verbose)
  * @returns {Promise<{ dataplaneUrl: string, authConfig: Object, environment: string }|void>}
  * @throws {Error} If validation or API calls fail
  */
 async function uploadExternalSystem(systemKey, options = {}) {
   validateSystemKeyFormat(systemKey);
-  const minimal = options.minimal === true;
+  const pathOptions = options.pathOptions || {};
+  const minimal =
+    options.minimal === true
+      ? true
+      : options.minimal === false
+        ? false
+        : options.verbose !== true;
+  const uploadOptions = { ...options, minimal };
   if (!minimal) {
     logger.log('');
     logger.log(sectionTitle('Upload external system'));
@@ -434,7 +390,9 @@ async function uploadExternalSystem(systemKey, options = {}) {
   const { manifest, payload } = await buildValidatedUploadManifestPayload(systemKey, {
     dryRun: !!options.dryRun,
     force: options.force === true,
-    minimal
+    minimal,
+    pathOptions,
+    uploadStatus: options.uploadStatus
   });
   if (options.dryRun) {
     logger.log(chalk.yellow('Dry run: would upload payload (no API calls).'));
@@ -443,11 +401,12 @@ async function uploadExternalSystem(systemKey, options = {}) {
     );
     return undefined;
   }
-  return runUploadPublishAndSummary(systemKey, options, manifest, payload);
+  return runUploadPublishAndSummary(systemKey, uploadOptions, manifest, payload);
 }
 
 module.exports = {
   uploadExternalSystem,
+  buildValidatedUploadManifestPayload,
   buildUploadPayload,
   resolveDataplaneAndAuth,
   runUploadValidatePublish,