@aifabrix/builder 2.49.2 → 2.50.0

package/lib/external-system/deploy.js

@@ -19,7 +19,7 @@ const { logOfflinePathWhenType } = require('../utils/cli-utils');
 const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
 const { getExternalSystem } = require('../api/external-systems.api');
 const { listDatasources } = require('../api/datasources-core.api');
-const { testSystemViaPipeline } = require('../api/pipeline.api');
+const { testSystemViaPipeline, validatePipelineConfig } = require('../api/pipeline.api');
 const { extractDatasources } = require('../datasource/list');
 const { unwrapApiData } = require('../utils/external-system-readiness-core');
 const { logDeployReadinessSummary } = require('../utils/external-system-readiness-deploy-display');
@@ -27,48 +27,91 @@ const { parseControllerDeploymentOutcome } = require('../utils/controller-deploy
 const { generateControllerManifest } = require('../generator/external-controller-manifest');
 const { validateExternalSystemComplete } = require('../validation/validate');
 const { displayValidationResults } = require('../validation/validate-display');
-const { maybeSyncSystemCertificationFromDataplane } = require('../certification/sync-system-certification');
-const { cliOptsSkipCertSync } = require('../certification/cli-cert-sync-skip');
 const { syncDeployJsonFromSources } = require('./sync-deploy-manifest');
+const { runDeployGateOrchestrator } = require('../commands/deploy-gate-orchestrator');
+const { runPostPublishDataSync } = require('../commands/run-post-publish-data-sync');
 
 /**
- * Lists datasources for a system and loads system record for docs URLs.
+ * Validates manifest on dataplane (dry-run) before controller deploy.
  * @async
- * @param {string} controllerUrl - Controller base URL
- * @param {string} environment - Environment key
- * @param {Object} authConfig - Auth config
- * @param {string} systemKey - System key
- * @returns {Promise<{ dataplaneUrl: string, datasources: Object[], system: Object|null, error: Error|null }>}
+ * @param {Object} manifest
+ * @param {Object} authConfig
+ * @param {string} dataplaneUrl
  */
-async function fetchDataplaneDeployReadiness(controllerUrl, environment, authConfig, systemKey) {
-  let dataplaneUrl;
-  try {
-    dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig);
-  } catch (err) {
-    return { dataplaneUrl: null, datasources: [], system: null, error: err };
+async function validateManifestOnDataplane(manifest, authConfig, dataplaneUrl) {
+  const config = {
+    version: manifest.version || '1.0.0',
+    application: manifest.system,
+    dataSources: manifest.dataSources || []
+  };
+  const res = await validatePipelineConfig(dataplaneUrl, authConfig, { config });
+  if (res?.success === false) {
+    throw new Error(res.formattedError || res.error || 'Dataplane pipeline validation failed');
+  }
+  const data = res?.data && typeof res.data === 'object' ? res.data : res;
+  if (data?.isValid === false) {
+    const errors = Array.isArray(data.errors) ? data.errors : [];
+    const summary = errors.slice(0, 3).map((e) => (typeof e === 'string' ? e : e.message || String(e))).join('; ');
+    throw new Error(
+      summary ? `Dataplane validation failed: ${summary}` : 'Dataplane pipeline validation failed'
+    );
   }
+}
 
-  let datasources = [];
+/**
+ * @async
+ * @returns {Promise<{ datasources: Object[], error: Error|null }>}
+ */
+async function listDeployReadinessDatasources(dataplaneUrl, authConfig, systemKey) {
   try {
     const listRes = await listDatasources(dataplaneUrl, authConfig, {
       sourceSystemIdOrKey: systemKey,
       pageSize: 100
     });
-    if (listRes.success && listRes.data) {
-      try {
-        datasources = extractDatasources(listRes);
-      } catch (e) {
-        logger.log(
-          chalk.yellow(
-            `⚠ Unable to parse datasources list from dataplane response: ${e && e.message ? e.message : 'unknown error'}`
-          )
-        );
-        datasources = [];
-      }
+    if (!listRes.success || !listRes.data) {
+      return { datasources: [], error: null };
+    }
+    try {
+      return { datasources: extractDatasources(listRes), error: null };
+    } catch (e) {
+      logger.log(
+        chalk.yellow(
+          `⚠ Unable to parse datasources list from dataplane response: ${e && e.message ? e.message : 'unknown error'}`
+        )
+      );
+      return { datasources: [], error: null };
     }
   } catch (err) {
-    return { dataplaneUrl, datasources: [], system: null, error: err };
+    return { datasources: [], error: err };
   }
+}
+
+/**
+ * @async
+ * @param {string} controllerUrl - Controller base URL
+ * @param {string} environment - Environment key
+ * @param {Object} authConfig - Auth config
+ * @param {string} systemKey - System key
+ * @returns {Promise<{ dataplaneUrl: string, datasources: Object[], system: Object|null, error: Error|null }>}
+ */
+async function fetchDataplaneDeployReadiness(controllerUrl, environment, authConfig, systemKey, opts = {}) {
+  let dataplaneUrl = opts.dataplaneUrl;
+  if (!dataplaneUrl) {
+    try {
+      dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig, {
+        silent: opts.silent === true
+      });
+    } catch (err) {
+      return { dataplaneUrl: null, datasources: [], system: null, error: err };
+    }
+  }
+
+  let datasources = [];
+  const dsResult = await listDeployReadinessDatasources(dataplaneUrl, authConfig, systemKey);
+  if (dsResult.error) {
+    return { dataplaneUrl, datasources: [], system: null, error: dsResult.error };
+  }
+  datasources = dsResult.datasources;
 
   try {
     const getRes = await getExternalSystem(dataplaneUrl, systemKey, authConfig);
@@ -111,43 +154,29 @@ async function fetchDataplaneDeployReadiness(controllerUrl, environment, authCon
  */
 async function runOptionalExternalDeployProbe(ctx, systemKey, authConfig, options) {
   if (!options.probe || !ctx.dataplaneUrl || ctx.error) return null;
-  logger.log(chalk.blue('\nRunning runtime checks (--probe)...'));
+  const compact = options.verbose !== true;
+  if (!compact) {
+    logger.log(chalk.blue('\nRunning runtime checks (--probe)...'));
+  }
   try {
     const pr = await testSystemViaPipeline(ctx.dataplaneUrl, systemKey, authConfig, {}, {
       timeout: options.probeTimeout || 120000
     });
     if (pr.success === false) {
-      logger.log(chalk.yellow(`⚠ Probe request failed: ${pr.formattedError || pr.error || 'unknown error'}`));
+      if (!compact) {
+        logger.log(chalk.yellow(`⚠ Probe request failed: ${pr.formattedError || pr.error || 'unknown error'}`));
+      }
       return null;
     }
     return unwrapApiData(pr);
   } catch (e) {
-    logger.log(chalk.yellow(`⚠ Probe failed: ${e.message}`));
+    if (!compact) {
+      logger.log(chalk.yellow(`⚠ Probe failed: ${e.message}`));
+    }
     return null;
   }
 }
 
-/**
- * @param {Object} deploymentOutcome
- * @param {{ dataplaneUrl: string|null, error: Error|null }} ctx
- * @param {Object} manifest
- * @param {Object} options
- * @param {Object} authConfig
- * @returns {Promise<void>}
- */
-async function maybeSyncCertificationAfterExternalDeploy(deploymentOutcome, ctx, manifest, options, authConfig) {
-  if (!deploymentOutcome.ok || !ctx.dataplaneUrl || ctx.error) return;
-  const dsKeys = (manifest.dataSources || []).map((ds) => ds && ds.key).filter(Boolean);
-  await maybeSyncSystemCertificationFromDataplane({
-    label: 'deploy',
-    noCertSync: cliOptsSkipCertSync(options),
-    systemKey: manifest.key,
-    dataplaneUrl: ctx.dataplaneUrl,
-    authConfig,
-    datasourceKeys: dsKeys
-  });
-}
-
 function logImmediateControllerDeploymentOutcome(deploymentOutcome) {
   if (deploymentOutcome.ok) {
     logger.log(formatSuccessParagraph('Controller deployment OK'));
@@ -172,52 +201,136 @@ function logImmediateControllerDeploymentOutcome(deploymentOutcome) {
   logger.log(chalk.gray('   Check the controller deployment job or logs for details.'));
 }
 
-async function executeDeployAndDisplay(manifest, controllerUrl, environment, authConfig, options) {
-  const deployer = require('../deployment/deployer');
-  const pollOpts = {
-    poll: options.poll,
+function buildExternalDeployPollOpts(options) {
+  return {
+    ...options,
+    poll: true,
     pollInterval: options.pollInterval !== undefined ? options.pollInterval : 500,
-    // External-system deploy only: ~10s poll window (matches controller→dataplane publish timeout). Not used for Azure/webapp deploy polling.
     pollMaxAttempts: options.pollMaxAttempts !== undefined ? options.pollMaxAttempts : 22,
-    ...options
+    silentPoll: options.silentPoll === true
   };
-  const result = await deployer.deployToController(
-    manifest,
-    controllerUrl,
-    environment,
+}
+
+async function promoteExternalSystemLifecycleAfterDeploy(manifest, dataplaneUrl, authConfig) {
+  const { buildUploadPayload } = require('../commands/upload');
+  const { uploadApplicationViaPipelineWithAuthRetry } = require('../utils/pipeline-upload-auth-retry');
+  const payload = buildUploadPayload(manifest, { status: 'published' });
+  const res = await uploadApplicationViaPipelineWithAuthRetry(
+    dataplaneUrl,
     authConfig,
-    pollOpts
+    payload,
+    manifest.key
   );
-
-  const deploymentOutcome = parseControllerDeploymentOutcome(result);
-  logImmediateControllerDeploymentOutcome(deploymentOutcome);
-
-  if (!deploymentOutcome.ok) {
-    return result;
+  if (res?.success === false) {
+    throw new Error(
+      res.formattedError || res.error || 'Failed to promote external system lifecycle after deploy'
+    );
   }
+  return res;
+}
 
+async function finalizeExternalDeployDataplaneWork(manifest, controllerUrl, environment, authConfig, options) {
+  const compact = options.verbose !== true;
+  const silent = compact;
   const ctx = await fetchDataplaneDeployReadiness(
     controllerUrl,
     environment,
     authConfig,
-    manifest.key
+    manifest.key,
+    { dataplaneUrl: options.knownDataplaneUrl, silent }
   );
 
-  const probeData = await runOptionalExternalDeployProbe(ctx, manifest.key, authConfig, options);
+  if (ctx.dataplaneUrl && !ctx.error) {
+    await promoteExternalSystemLifecycleAfterDeploy(manifest, ctx.dataplaneUrl, authConfig);
+  }
+
+  const refreshedCtx =
+    ctx.dataplaneUrl && !ctx.error
+      ? await fetchDataplaneDeployReadiness(
+        controllerUrl,
+        environment,
+        authConfig,
+        manifest.key,
+        { dataplaneUrl: ctx.dataplaneUrl, silent: true }
+      )
+      : ctx;
+
+  const probeData = await runOptionalExternalDeployProbe(refreshedCtx, manifest.key, authConfig, options);
+  return { refreshedCtx, probeData };
+}
+
+async function runPostDeployExternalSystemSteps(manifest, controllerUrl, environment, authConfig, options) {
+  const { runWithDeployPollSpinner } = require('../deployment/deploy-poll-ui');
+
+  const { refreshedCtx, probeData } = await runWithDeployPollSpinner(
+    'Finalizing deployment on dataplane…',
+    () => finalizeExternalDeployDataplaneWork(manifest, controllerUrl, environment, authConfig, options),
+    { silent: options.silentPoll === true }
+  );
 
   logDeployReadinessSummary({
     environment,
-    dataplaneUrl: ctx.dataplaneUrl,
+    dataplaneUrl: refreshedCtx.dataplaneUrl,
     manifest,
-    datasources: ctx.datasources,
-    systemFromDataplane: ctx.system,
-    fetchError: ctx.error,
-    deploymentOk: deploymentOutcome.ok,
-    deploymentDetail: deploymentOutcome.ok ? null : deploymentOutcome,
-    probeData
+    datasources: refreshedCtx.datasources,
+    systemFromDataplane: refreshedCtx.system,
+    fetchError: refreshedCtx.error,
+    deploymentOk: true,
+    deploymentDetail: null,
+    probeData,
+    verbose: options.verbose === true,
+    gateOutcomes: options.gateOutcomes || null,
+    draftDeploymentId: options.draftDeploymentId || null
   });
 
-  await maybeSyncCertificationAfterExternalDeploy(deploymentOutcome, ctx, manifest, options, authConfig);
+  const { trySyncCertificationFromDataplaneForExternalApp } = require('../certification/sync-after-external-command');
+  await trySyncCertificationFromDataplaneForExternalApp(manifest.key, 'deploy');
+
+  await runPostPublishDataSync({
+    dataplaneUrl: refreshedCtx.dataplaneUrl,
+    authConfig,
+    datasourceKeys: (manifest.dataSources || []).map((ds) => ds && ds.key).filter(Boolean),
+    options,
+    label: 'Deploy data sync'
+  });
+}
+
+async function executeDeployAndDisplay(manifest, controllerUrl, environment, authConfig, options) {
+  const compact = options.verbose !== true;
+  const deployer = require('../deployment/deployer');
+  const result = await deployer.deployToController(
+    manifest,
+    controllerUrl,
+    environment,
+    authConfig,
+    buildExternalDeployPollOpts(options)
+  );
+
+  const deploymentOutcome = parseControllerDeploymentOutcome(result);
+  if (!compact) {
+    logImmediateControllerDeploymentOutcome(deploymentOutcome);
+  }
+
+  if (!deploymentOutcome.ok) {
+    if (compact) {
+      logDeployReadinessSummary({
+        environment,
+        dataplaneUrl: null,
+        manifest,
+        deploymentOk: false,
+        deploymentDetail: deploymentOutcome,
+        verbose: false,
+        gateOutcomes: options.gateOutcomes || null,
+        draftDeploymentId: result?.deploymentId || null
+      });
+    }
+    return result;
+  }
+
+  await runPostDeployExternalSystemSteps(manifest, controllerUrl, environment, authConfig, {
+    ...options,
+    draftDeploymentId: result?.deploymentId || null
+  });
 
   return result;
 }
@@ -242,6 +355,100 @@ async function prepareDeploymentConfig(appName, _options) {
   return { environment, controllerUrl, authConfig };
 }
 
+/**
+ * @param {Error} error
+ * @param {string} appName
+ * @returns {Error}
+ */
+function wrapDeployExternalSystemError(error, appName) {
+  let message = `Failed to deploy external system: ${error.message}`;
+  if (error.message && error.message.includes('Application not found')) {
+    message += `\n\n💡 Register the app in the controller first: aifabrix app register ${appName}`;
+  }
+  return new Error(message);
+}
+
+/**
+ * @async
+ * @param {string} appName
+ * @param {Object} options
+ * @returns {Promise<Object>}
+ */
+/**
+ * @param {string} appName
+ * @param {Object} options
+ * @param {boolean} compact
+ */
+async function validateExternalSystemForDeploy(appName, options, compact) {
+  if (!compact) {
+    logger.log(chalk.blue('🔍 Validating external system before deployment...'));
+  }
+  const validationResult = await validateExternalSystemComplete(appName, options);
+  if (!validationResult.valid) {
+    displayValidationResults(validationResult);
+    throw new Error('Validation failed. Fix errors before deploying.');
+  }
+  if (!compact) {
+    logger.log(formatSuccessLine('Local validation passed, proceeding with deployment...'));
+  }
+}
+
+/**
+ * @param {Object} manifest
+ * @param {Object} authConfig
+ * @param {string} dataplaneUrl
+ * @param {boolean} compact
+ */
+async function validateDataplaneManifestForDeploy(manifest, authConfig, dataplaneUrl, compact) {
+  if (!compact) {
+    logger.log(chalk.blue('🔍 Validating manifest on dataplane...'));
+  }
+  await validateManifestOnDataplane(manifest, authConfig, dataplaneUrl);
+  if (!compact) {
+    logger.log(formatSuccessLine('Dataplane validation passed'));
+  }
+}
+
+async function runExternalSystemDeployFlow(appName, options) {
+  const compact = options.verbose !== true;
+  const { appPath } = await detectAppType(appName);
+  logOfflinePathWhenType(appPath);
+
+  if (!compact) {
+    logger.log(chalk.blue(`\n🚀 Deploying external system: ${appName}`));
+  }
+
+  await validateExternalSystemForDeploy(appName, options, compact);
+
+  const gateOutcomes = await runDeployGateOrchestrator(appName, {
+    ...options,
+    quietDeployUi: compact
+  });
+
+  await syncDeployJsonFromSources(appName);
+
+  const manifest = await generateControllerManifest(appName, options);
+
+  const { environment, controllerUrl, authConfig } = await prepareDeploymentConfig(appName, options);
+
+  let dataplaneUrl;
+  try {
+    dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig, {
+      silent: compact
+    });
+  } catch (err) {
+    throw new Error(`Failed to resolve dataplane URL before deploy: ${err.message}`);
+  }
+
+  await validateDataplaneManifestForDeploy(manifest, authConfig, dataplaneUrl, compact);
+
+  return executeDeployAndDisplay(manifest, controllerUrl, environment, authConfig, {
+    ...options,
+    gateOutcomes,
+    knownDataplaneUrl: dataplaneUrl
+  });
+}
+
 /**
  * Deploys external system via controller pipeline (same as regular apps)
  *
@@ -255,41 +462,12 @@ async function prepareDeploymentConfig(appName, _options) {
  */
 async function deployExternalSystem(appName, options = {}) {
   try {
-    const { appPath } = await detectAppType(appName);
-    logOfflinePathWhenType(appPath);
-
-    logger.log(chalk.blue(`\n🚀 Deploying external system: ${appName}`));
-
-    logger.log(chalk.blue('🔍 Validating external system before deployment...'));
-    const validationResult = await validateExternalSystemComplete(appName, options);
-
-    if (!validationResult.valid) {
-      displayValidationResults(validationResult);
-      throw new Error('Validation failed. Fix errors before deploying.');
-    }
-
-    logger.log(formatSuccessLine('Local validation passed, proceeding with deployment...'));
-
-    await syncDeployJsonFromSources(appName);
-
-    const manifest = await generateControllerManifest(appName, options);
-
-    const { environment, controllerUrl, authConfig } = await prepareDeploymentConfig(appName, options);
-
-    const result = await executeDeployAndDisplay(
-      manifest,
-      controllerUrl,
-      environment,
-      authConfig,
-      options
-    );
-    return result;
+    return await runExternalSystemDeployFlow(appName, options);
   } catch (error) {
-    let message = `Failed to deploy external system: ${error.message}`;
-    if (error.message && error.message.includes('Application not found')) {
-      message += `\n\n💡 Register the app in the controller first: aifabrix app register ${appName}`;
+    if (error && error.gateFailure === true) {
+      throw error;
     }
-    throw new Error(message);
+    throw wrapDeployExternalSystemError(error, appName);
   }
 }
 

package/lib/external-system/download.js

@@ -86,9 +86,13 @@ async function setupAuthenticationAndDataplane(systemKey, _options, _config) {
  * @returns {Promise<{application: Object, dataSources: Array, version?: string}>} Full manifest
  * @throws {Error} If download fails
  */
-async function downloadFullManifest(dataplaneUrl, systemKey, authConfig) {
+async function downloadFullManifest(dataplaneUrl, systemKey, authConfig, options = {}) {
   logger.log(formatProgress(`Downloading manifest for ${systemKey}…`));
-  const response = await getExternalSystemConfig(dataplaneUrl, systemKey, authConfig);
+  const { normalizeVersionTarget } = require('../utils/test-target-cli-options');
+  const versionTarget = normalizeVersionTarget(options.version, 'running');
+  const response = await getExternalSystemConfig(dataplaneUrl, systemKey, authConfig, {
+    versionTarget: versionTarget === 'running' ? undefined : versionTarget
+  });
 
   if (!response.success || !response.data) {
     throw new Error(`Failed to download system configuration: ${response.error || response.formattedError || 'Unknown error'}`);
@@ -402,7 +406,7 @@ async function downloadExternalSystem(systemKey, options = {}) {
       return;
     }
 
-    const manifest = await downloadFullManifest(dataplaneUrl, systemKey, authConfig);
+    const manifest = await downloadFullManifest(dataplaneUrl, systemKey, authConfig, options);
     validateAndLogDownloadedData(manifest.application, manifest.dataSources);
     const finalPath = getIntegrationPath(systemKey);
     await processDownloadedSystem(

package/lib/external-system/test-execution.js

@@ -33,7 +33,7 @@ async function executeDatasourceTest(systemKey, datasourceKey, payloadTemplate,
       payloadTemplate,
       dataplaneUrl,
       authConfig,
-      timeout: parseInt(options.timeout, 10) || 30000,
+      timeout: parseInt(options.timeout, 10) || 60000,
       includeDebug: !!options.debug
     });
     return datasourceResult;

package/lib/external-system/test-system-level.js

@@ -25,6 +25,8 @@ async function runOneDatasourceKey(appName, datasourceKey, opts) {
       debug,
       verbose: false,
       timeout: timeoutMs,
+      version: opts.version,
+      syncMode: opts.syncMode,
       async: true,
       noAsync: false,
       authConfig,
@@ -72,7 +74,7 @@ async function maybeWriteSystemRunLog(appName, systemKey, datasourceKeys, runTyp
   const integrationDir = path.dirname(appPath);
   const logPath = await writeTestLog(
     appName,
-    { request: { systemKey, datasourceKeys, runType, includeDebug: true }, response: payload },
+    { request: { systemKey, datasourceKeys, runType, includeDebug: true, explainCertification: true }, response: payload },
     runType === 'e2e' ? 'test-e2e' : 'test-integration',
     integrationDir
   );
@@ -99,13 +101,16 @@ async function runSystemLevelTest({
   runType,
   debug,
   timeout,
+  version,
+  syncMode,
   authConfig,
   dataplaneUrl
 }) {
   if (!Array.isArray(datasourceKeys) || datasourceKeys.length === 0) {
     return { success: true, datasourceResults: [] };
   }
-  const timeoutMs = Number.isFinite(timeout) ? timeout : 30000;
+  const timeoutMs = Number.isFinite(timeout) ? timeout : 60000;
+  const runOpts = { environment, runType, debug, timeoutMs, version, syncMode, authConfig, dataplaneUrl };
 
   const results = [];
   for (const key of datasourceKeys) {
@@ -113,14 +118,7 @@ async function runSystemLevelTest({
     // (Plan allows parallel later, but UX needs stable logs first.)
     // eslint-disable-next-line no-await-in-loop -- intentional sequential execution
     results.push(
-      await runOneDatasourceKey(appName, key, {
-        environment,
-        runType,
-        debug,
-        timeoutMs,
-        authConfig,
-        dataplaneUrl
-      })
+      await runOneDatasourceKey(appName, key, runOpts)
     );
   }
 

package/lib/external-system/test.js

@@ -37,7 +37,7 @@ const {
 } = require('./test-execution');
 const { runSystemLevelTest } = require('./test-system-level');
 const { shouldUseSystemLevelIntegrationCall } = require('./integration-test-dispatch');
-const { cliOptsSkipSync } = require('../utils/cli-sync-options');
+const { cliOptsSkipPublish } = require('../utils/cli-sync-options');
 
 /**
  * Loads and parses application config file
@@ -408,8 +408,8 @@ function determineDatasourcesToTest(datasourceFiles, datasourceFilter) {
  * @param {string} [options.controller] - Controller URL
  * @param {boolean} [options.verbose] - Show detailed test output
  * @param {number} [options.timeout] - Request timeout in milliseconds
- * @param {boolean} [options.noSync] - When true, skip publish (exercise dataplane config already deployed)
- * @param {boolean} [options.sync] - Legacy explicit sync; ignored when `noSync` / `--no-sync` is set
+ * @param {boolean} [options.noPublish] - When true, skip publish (exercise dataplane config already deployed)
+ * @param {boolean} [options.sync] - Explicit sync; ignored when `noPublish` / `--no-publish` is set
  * @returns {Promise<Object>} Integration test results
  * @throws {Error} If testing fails
  */
@@ -454,11 +454,15 @@ async function testExternalSystemIntegration(appName, options = {}) {
 
     const { systemKey, authConfig, dataplaneUrl, datasourcesToTest, customPayload } = await prepareIntegrationTestEnvironment(appName, options);
 
-    if (!cliOptsSkipSync(options)) {
+    if (!cliOptsSkipPublish(options)) {
       logger.log(chalk.cyan('Syncing local config to dataplane…'));
       const { uploadExternalSystem } = require('../commands/upload');
       const { buildMinimalUploadSyncOptions } = require('../utils/upload-sync-options');
-      await uploadExternalSystem(systemKey, buildMinimalUploadSyncOptions(options));
+      const uploadOpts = buildMinimalUploadSyncOptions(options);
+      if (options.uploadStatus === 'published') {
+        uploadOpts.uploadStatus = 'published';
+      }
+      await uploadExternalSystem(systemKey, uploadOpts);
       logger.log(formatSuccessLine('Sync complete'));
     }
 
@@ -468,7 +472,7 @@ async function testExternalSystemIntegration(appName, options = {}) {
       datasourceResults: []
     };
 
-    const timeout = parseInt(options.timeout, 10) || 30000;
+    const timeout = parseInt(options.timeout, 10) || 60000;
     const useSystemLevel = shouldUseSystemLevelIntegrationCall(options, datasourcesToTest, customPayload);
 
     if (useSystemLevel) {
@@ -482,6 +486,8 @@ async function testExternalSystemIntegration(appName, options = {}) {
           runType: 'integration',
           debug: options.debug,
           timeout,
+          version: options.version,
+          syncMode: options.syncMode,
           authConfig,
           dataplaneUrl
         });