@aifabrix/builder 2.44.2 → 2.44.4

package/lib/cli/setup-utility.js

@@ -118,7 +118,7 @@ function setupResolveCommand(program) {
         );
         logger.log(`✔ Generated .env file: ${envPath}`);
         if (envOnly) {
-          logger.log(chalk.gray('  (env-only mode: validation skipped; no application.yaml)'));
+          logger.log(chalk.gray('  (env-only mode: validation skipped; no application config file)'));
         } else if (!options.skipValidation) {
           const validate = require('../validation/validate');
           const result = await validate.validateAppOrFile(appName);

package/lib/commands/datasource-unified-test-cli.js

@@ -94,7 +94,7 @@ async function runDatasourceUnifiedTestOnceForWatch(datasourceKey, runOpts, disp
   try {
     const result = await runUnifiedDatasourceValidation(datasourceKey, runOpts);
     const exitCode = finalizeUnifiedValidationResult(result, displayOpts);
-    await afterUnifiedValidationCertSync(exitCode, datasourceKey, certCliOptions, 'datasource test');
+    await afterUnifiedValidationCertSync(exitCode, datasourceKey, certCliOptions, 'datasource test', result.envelope);
     return {
       exitCode,
       envelope: result.envelope
@@ -121,7 +121,7 @@ async function datasourceTestCommandAction(datasourceKey, options) {
           const result = await runUnifiedDatasourceValidation(datasourceKey, runOpts);
           await writeDatasourceTestDebugLogIfRequested(appKey, datasourceKey, result, options);
           const exitCode = finalizeUnifiedValidationResult(result, displayOpts);
-          await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test (watch)');
+          await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test (watch)', result.envelope);
           return {
             exitCode,
             envelope: result.envelope
@@ -140,7 +140,7 @@ async function datasourceTestCommandAction(datasourceKey, options) {
       }
     }
     const exitCode = finalizeUnifiedValidationResult(result, displayOpts);
-    await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test');
+    await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test', result.envelope);
     process.exit(exitCode);
   } catch (error) {
     logger.error(formatBlockingError('Datasource test failed:'), error.message);
@@ -195,7 +195,13 @@ async function runIntegrationOnceForWatch(datasourceKey, integOpts, options, uni
     if (unifiedModes) {
       const uni = unifiedCliResultFromIntegrationReturn(result);
       const exitCode = finalizeUnifiedValidationResult(uni, unifiedDisplayOpts);
-      await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test-integration (watch)');
+      await afterUnifiedValidationCertSync(
+        exitCode,
+        datasourceKey,
+        options,
+        'datasource test-integration (watch)',
+        uni.envelope
+      );
       return { exitCode, envelope: uni.envelope };
     }
     displayIntegrationTestResults(
@@ -211,7 +217,13 @@ async function runIntegrationOnceForWatch(datasourceKey, integOpts, options, uni
       warningsAsErrors: unifiedDisplayOpts.warningsAsErrors === true,
       requireCert: unifiedDisplayOpts.requireCert === true
     });
-    await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test-integration (watch)');
+    await afterUnifiedValidationCertSync(
+      exitCode,
+      datasourceKey,
+      options,
+      'datasource test-integration (watch)',
+      result.datasourceTestRun || null
+    );
     return { exitCode, envelope: result.datasourceTestRun || null };
   } catch (err) {
     logger.error(formatBlockingError('Integration test failed:'), err.message);
@@ -219,49 +231,67 @@ async function runIntegrationOnceForWatch(datasourceKey, integOpts, options, uni
   }
 }
 
+async function integrationTestCommandActionWatch(datasourceKey, options, integOpts, unifiedDisplayOpts) {
+  const { appKey } = await resolveAppKeyForDatasource(datasourceKey, options.app);
+  await runDatasourceValidationWatchLoop({
+    appKey,
+    extraPaths: options.watchPath || [],
+    includeApplicationYaml: options.watchApplicationYaml === true,
+    watchCi: options.watchCi === true,
+    watchFullDiff: options.watchFullDiff === true,
+    runOnce: () => runIntegrationOnceForWatch(datasourceKey, integOpts, options, unifiedDisplayOpts)
+  });
+}
+
+async function integrationTestCommandActionNonWatch(datasourceKey, integOpts, options, unifiedDisplayOpts) {
+  const result = await runDatasourceTestIntegration(datasourceKey, integOpts);
+  const unifiedModes =
+    options.json || options.summary || options.warningsAsErrors || options.requireCert;
+  if (unifiedModes) {
+    const uni = unifiedCliResultFromIntegrationReturn(result);
+    const exitCode = finalizeUnifiedValidationResult(uni, unifiedDisplayOpts);
+    await afterUnifiedValidationCertSync(
+      exitCode,
+      datasourceKey,
+      options,
+      'datasource test-integration',
+      uni.envelope
+    );
+    process.exit(exitCode);
+    return;
+  }
+  displayIntegrationTestResults(
+    {
+      systemKey: result.systemKey || 'unknown',
+      datasourceResults: [result],
+      success: result.success
+    },
+    options.verbose,
+    { debug: options.debug, runType: 'integration' }
+  );
+  const integExit = finalizeAfterIntegrationDisplay(result, {
+    warningsAsErrors: unifiedDisplayOpts.warningsAsErrors === true,
+    requireCert: unifiedDisplayOpts.requireCert === true
+  });
+  await afterUnifiedValidationCertSync(
+    integExit,
+    datasourceKey,
+    options,
+    'datasource test-integration',
+    result.datasourceTestRun || null
+  );
+  process.exit(integExit);
+}
+
 async function integrationTestCommandAction(datasourceKey, options) {
   const integOpts = buildIntegrationTestOpts(options);
   const unifiedDisplayOpts = buildIntegrationUnifiedDisplayOpts(options);
   try {
     if (options.watch) {
-      const { appKey } = await resolveAppKeyForDatasource(datasourceKey, options.app);
-      await runDatasourceValidationWatchLoop({
-        appKey,
-        extraPaths: options.watchPath || [],
-        includeApplicationYaml: options.watchApplicationYaml === true,
-        watchCi: options.watchCi === true,
-        watchFullDiff: options.watchFullDiff === true,
-        runOnce: () => runIntegrationOnceForWatch(datasourceKey, integOpts, options, unifiedDisplayOpts)
-      });
-      return;
-    }
-    const result = await runDatasourceTestIntegration(datasourceKey, integOpts);
-    const unifiedModes =
-      options.json || options.summary || options.warningsAsErrors || options.requireCert;
-    if (unifiedModes) {
-      const exitCode = finalizeUnifiedValidationResult(
-        unifiedCliResultFromIntegrationReturn(result),
-        unifiedDisplayOpts
-      );
-      await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test-integration');
-      process.exit(exitCode);
+      await integrationTestCommandActionWatch(datasourceKey, options, integOpts, unifiedDisplayOpts);
       return;
     }
-    displayIntegrationTestResults(
-      {
-        systemKey: result.systemKey || 'unknown',
-        datasourceResults: [result],
-        success: result.success
-      },
-      options.verbose,
-      { debug: options.debug, runType: 'integration' }
-    );
-    const integExit = finalizeAfterIntegrationDisplay(result, {
-      warningsAsErrors: unifiedDisplayOpts.warningsAsErrors === true,
-      requireCert: unifiedDisplayOpts.requireCert === true
-    });
-    await afterUnifiedValidationCertSync(integExit, datasourceKey, options, 'datasource test-integration');
-    process.exit(integExit);
+    await integrationTestCommandActionNonWatch(datasourceKey, integOpts, options, unifiedDisplayOpts);
   } catch (error) {
     logger.error(formatBlockingError('Integration test failed:'), error.message);
     process.exit(4);
@@ -296,9 +326,8 @@ async function runDatasourceTestE2ECliOnce(datasourceKey, options) {
     debug: options.debug,
     verbose: options.verbose,
     async: options.async !== false,
-    testCrud: options.testCrud,
-    recordId: options.recordId,
     cleanup: options.cleanup,
+    runScenarios: options.runScenarios,
     primaryKeyValue: options.primaryKeyValue,
     minVectorHits: options.minVectorHits,
     minProcessed: options.minProcessed,
@@ -340,8 +369,8 @@ async function runDatasourceTestE2ECliOnce(datasourceKey, options) {
 }
 
 async function runDatasourceTestE2ECliAction(datasourceKey, options) {
-  const { exitCode } = await runDatasourceTestE2ECliOnce(datasourceKey, options);
-  await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test-e2e');
+  const { exitCode, envelope } = await runDatasourceTestE2ECliOnce(datasourceKey, options);
+  await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test-e2e', envelope);
   process.exit(exitCode);
 }
 
@@ -371,7 +400,13 @@ async function e2eTestCommandAction(datasourceKey, capabilityKey, options) {
         runOnce: async() => {
           try {
             const r = await runDatasourceTestE2ECliOnce(datasourceKey, mergedOptions);
-            await afterUnifiedValidationCertSync(r.exitCode, datasourceKey, mergedOptions, 'datasource test-e2e (watch)');
+            await afterUnifiedValidationCertSync(
+              r.exitCode,
+              datasourceKey,
+              mergedOptions,
+              'datasource test-e2e (watch)',
+              r.envelope
+            );
             return r;
           } catch (err) {
             logger.error(formatBlockingError('E2E test failed:'), err.message);

package/lib/commands/datasource-unified-test-cli.options.js

@@ -166,8 +166,10 @@ function attachDatasourceTestE2eExclusiveOptions(cmd) {
       'Minimum record count assertion (e2eOptions.minRecordCount)',
       (v) => parseInt(String(v), 10)
     )
-    .option('--test-crud', 'Enable CRUD lifecycle test (e2eOptions.testCrud)')
-    .option('--record-id <id>', 'Record ID for test (e2eOptions.recordId)')
+    .option(
+      '--no-run-scenarios',
+      'Do not expand testPayload.scenarios in capacity step (e2eOptions.runScenarios: false)'
+    )
     .option('--no-cleanup', 'Disable cleanup after test (e2eOptions.cleanup: false)')
     .option(
       '--primary-key-value <value|@path>',

package/lib/commands/datasource.js

@@ -10,10 +10,10 @@
  */
 
 const path = require('path');
-const chalk = require('chalk');
 const logger = require('../utils/logger');
-const { sectionTitle, headerKeyValue, metadata, formatSuccessLine, formatBlockingError } = require('../utils/cli-test-layout-chalk');
+const { formatBlockingError } = require('../utils/cli-test-layout-chalk');
 const { validateDatasourceFile } = require('../datasource/validate');
+const { logDatasourceValidateOutcome } = require('../datasource/datasource-validate-display');
 const { listDatasources } = require('../datasource/list');
 const { compareDatasources } = require('../datasource/diff');
 const { deployDatasource } = require('../datasource/deploy');
@@ -53,34 +53,6 @@ Examples:
   $ af ds upload ../integration/hubspot/hubspot-datasource-deals.json
 `;
 
-/**
- * TTY layout for local datasource JSON validation (aligned with cli-test-layout-chalk).
- * @param {{ valid: boolean, errors: string[], resolvedPath: string }} result
- * @param {string} trimmed - original CLI argument
- * @param {boolean} showMapping - show Key + File when key resolved to a path
- */
-function logDatasourceValidateOutcome(result, trimmed, showMapping) {
-  logger.log('');
-  logger.log(sectionTitle('Datasource validation'));
-  logger.log(metadata('Offline — JSON schema and integration wiring'));
-  logger.log('');
-  if (!result.valid) {
-    logger.log(headerKeyValue('File:', result.resolvedPath));
-    logger.log('');
-    logger.log(formatBlockingError('Datasource file has errors:'));
-    result.errors.forEach(error => logger.log(chalk.red(`  • ${error}`)));
-    return;
-  }
-  if (showMapping) {
-    logger.log(headerKeyValue('Key:', trimmed));
-    logger.log(headerKeyValue('File:', result.resolvedPath));
-  } else {
-    logger.log(headerKeyValue('File:', result.resolvedPath));
-  }
-  logger.log('');
-  logger.log(formatSuccessLine('Datasource file is valid.'));
-}
-
 function setupDatasourceValidateCommand(datasource) {
   datasource.command('validate <file-or-key>')
     .description('Validate datasource JSON (file path or datasource key under integration/<app>/)')
@@ -97,7 +69,7 @@ function setupDatasourceValidateCommand(datasource) {
           process.exit(1);
         }
       } catch (error) {
-        logger.error(formatBlockingError('Validation failed:'), error.message);
+        logger.error(formatBlockingError(`Validation failed: ${error.message}`));
         process.exit(1);
       }
     });

package/lib/commands/repair-datasource-keys.js

@@ -193,7 +193,7 @@ function normalizeDatasourceKeysAndFilenames(appPath, datasourceFiles, systemKey
   }
 
   if (updated && variables.externalIntegration && Array.isArray(variables.externalIntegration.dataSources)) {
-    variables.externalIntegration.dataSources = [...newDatasourceFiles].sort();
+    variables.externalIntegration.dataSources = [...newDatasourceFiles];
   }
 
   return { updated, datasourceFiles: newDatasourceFiles };

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

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview Repair OpenAPI block on external datasource JSON.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+function hasNonEmptyObject(v) {
+  return !!v && typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length > 0;
+}
+
+/**
+ * Repair `openapi` section:
+ * - If operations exist, ensure `openapi.enabled=true`
+ * - If enabled/operations and missing documentKey/fileId, default documentKey to datasource key (common convention)
+ * - If enabled+operations and autoRbac missing, default to true (wizard/fixtures expectation)
+ *
+ * @param {Object} parsed - Parsed datasource (mutated)
+ * @param {string[]} changes - Change log
+ * @returns {boolean} True if updated
+ */
+function repairOpenapiSection(parsed, changes) {
+  const openapi = parsed?.openapi;
+  if (!openapi || typeof openapi !== 'object') {
+    return false;
+  }
+
+  const hasOps = hasNonEmptyObject(openapi.operations);
+  const enabled = openapi.enabled === true;
+  let updated = false;
+
+  if (hasOps && openapi.enabled !== true) {
+    openapi.enabled = true;
+    changes.push('Set openapi.enabled=true (operations present)');
+    updated = true;
+  }
+
+  if ((enabled || hasOps) && !openapi.documentKey && !openapi.fileId) {
+    if (typeof parsed.key === 'string' && parsed.key.trim()) {
+      openapi.documentKey = parsed.key.trim();
+      changes.push(`Set openapi.documentKey=${openapi.documentKey}`);
+      updated = true;
+    }
+  }
+
+  if ((enabled || hasOps) && hasOps && openapi.autoRbac === undefined) {
+    openapi.autoRbac = true;
+    changes.push('Set openapi.autoRbac=true (enabled operations, default)');
+    updated = true;
+  }
+
+  return updated;
+}
+
+module.exports = { repairOpenapiSection };
+

package/lib/commands/repair-datasource.js

@@ -9,6 +9,8 @@
 
 'use strict';
 
+const { repairOpenapiSection } = require('./repair-datasource-openapi');
+
 const DEFAULT_SYNC = {
   mode: 'pull',
   batchSize: 500
@@ -446,6 +448,8 @@ function repairDatasourceFile(parsed, options = {}, changes = []) {
     updated = repairMetadataSchemaFromAttributes(parsed, out) || updated;
   }
 
+  updated = repairOpenapiSection(parsed, out) || updated;
+
   if (options.expose) {
     updated = repairExposeFromAttributes(parsed, out) || updated;
   }
@@ -472,6 +476,7 @@ module.exports = {
   repairExposeFromAttributes,
   repairSyncSection,
   repairTestPayload,
+  repairOpenapiSection,
   sanitizeTestPayloadTopLevel,
   repairDatasourceFile,
   DEFAULT_SYNC,

package/lib/commands/repair-internal.js

@@ -40,7 +40,6 @@ function discoverIntegrationFiles(appPath) {
     }
   }
   systemFiles.sort();
-  datasourceFiles.sort();
   return { systemFiles, datasourceFiles };
 }
 
@@ -48,8 +47,8 @@ function discoverIntegrationFiles(appPath) {
  * Builds the effective datasource file list from application.yaml and discovered files.
  * @param {string} appPath - Application directory path
  * @param {string[]} discoveredDatasourceFiles - Filenames from discoverIntegrationFiles
- * @param {string[]} [existingDataSources] - externalIntegration.dataSources from application.yaml
- * @returns {string[]} Sorted, deduplicated list of datasource filenames
+ * @param {string[]} [existingDataSources] - externalIntegration.dataSources from application config
+ * @returns {string[]} Deduplicated list of datasource filenames (application order first, then remaining discovered files in directory order)
  */
 function buildEffectiveDatasourceFiles(appPath, discoveredDatasourceFiles, existingDataSources) {
   const existing = Array.isArray(existingDataSources) ? existingDataSources : [];
@@ -75,7 +74,6 @@ function buildEffectiveDatasourceFiles(appPath, discoveredDatasourceFiles, exist
       seen.add(name);
     }
   }
-  result.sort();
   return result;
 }
 

package/lib/commands/repair.js

@@ -204,8 +204,7 @@ function alignSystemFileDataSources(appPath, systemParsed, datasourceFiles, syst
       keys.push(deriveDatasourceKeyFromFileName(fileName, systemKey));
     }
   }
-  keys.sort();
-  const prev = Array.isArray(systemParsed.dataSources) ? [...systemParsed.dataSources].sort() : [];
+  const prev = Array.isArray(systemParsed.dataSources) ? [...systemParsed.dataSources] : [];
   if (JSON.stringify(prev) === JSON.stringify(keys)) return false;
   systemParsed.dataSources = keys;
   changes.push(`dataSources: [${prev.join(', ') || '(none)'}] → [${keys.join(', ')}] (keys from each datasource file's "key" or filename)`);

package/lib/commands/test-e2e-external.js

@@ -42,8 +42,8 @@ function deriveDatasourceKeyFromFileName(fileName, systemKey) {
  * @param {Object} variables - Loaded application variables (externalIntegration.dataSources = filenames)
  * @param {string} systemKey - System key from system file
  * @param {Object} systemParsed - Parsed system config (may have dataSources array of keys)
- * @param {string[]} datasourceFiles - Discovered datasource filenames
- * @returns {string[]} Sorted list of datasource keys
+ * @param {string[]} datasourceFiles - Discovered datasource filenames (application order when built via repair)
+ * @returns {string[]} Datasource keys in declaration order (system JSON or file list — never sort; FK targets must run first)
  */
 function getDatasourceKeys(appPath, configPath, variables, systemKey, systemParsed, datasourceFiles) {
   const fromSystem = Array.isArray(systemParsed.dataSources) && systemParsed.dataSources.length > 0
@@ -54,11 +54,11 @@ function getDatasourceKeys(appPath, configPath, variables, systemKey, systemPars
   if (fromSystem) {
     fromSystem.forEach(k => {
       if (k && typeof k === 'string' && !seen.has(k)) {
-        keys.push(k.trim());
-        seen.add(k.trim());
+        const trimmed = k.trim();
+        keys.push(trimmed);
+        seen.add(trimmed);
       }
     });
-    keys.sort();
     return keys;
   }
   for (const fileName of datasourceFiles) {
@@ -81,7 +81,6 @@ function getDatasourceKeys(appPath, configPath, variables, systemKey, systemPars
       }
     }
   }
-  keys.sort();
   return keys;
 }
 

package/lib/commands/upload.js

@@ -17,7 +17,8 @@ const { getIntegrationPath } = require('../utils/paths');
 const { pushCredentialSecrets } = require('../utils/credential-secrets-env');
 const {
   buildResolvedEnvMapForIntegration,
-  resolveConfigurationValues
+  resolveConfigurationValues,
+  collectResolvedVariableConfigurationNames
 } = require('../utils/configuration-env-resolver');
 const { validateExternalSystemComplete } = require('../validation/validate');
 const { displayValidationResults } = require('../validation/validate-display');
@@ -70,9 +71,11 @@ function buildUploadPayload(manifest) {
 /**
  * Resolves dataplane URL and auth (same pattern as download).
  * @param {string} systemKey - System key
+ * @param {{ silent?: boolean }} [opts] - silent: omit “Resolving dataplane URL…” and discovery success lines
  * @returns {Promise<{ dataplaneUrl: string, authConfig: Object, environment: string }>}
  */
-async function resolveDataplaneAndAuth(systemKey) {
+async function resolveDataplaneAndAuth(systemKey, opts = {}) {
+  const silent = opts.silent === true;
   const { resolveEnvironment } = require('../core/config');
   const environment = await resolveEnvironment();
   const controllerUrl = await resolveControllerUrl();
@@ -82,8 +85,10 @@ async function resolveDataplaneAndAuth(systemKey) {
     throw new Error('Authentication required. Run "aifabrix login" or "aifabrix app register <systemKey>" first.');
   }
 
-  logger.log(chalk.gray('Resolving dataplane URL...'));
-  const dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig);
+  if (!silent) {
+    logger.log(chalk.gray('Resolving dataplane URL...'));
+  }
+  const dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig, { silent });
   return { dataplaneUrl, authConfig, environment };
 }
 
@@ -167,6 +172,15 @@ async function pushAndLogCredentialSecrets(dataplaneUrl, authConfig, systemKey,
   } 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}`));
   }

package/lib/commands/wizard-dataplane.js

@@ -73,10 +73,12 @@ function createDataplaneNotFoundError() {
  * @returns {Promise<string>} Dataplane URL
  * @throws {Error} If dataplane URL cannot be retrieved
  */
-async function tryFallbackDataplaneUrl(controllerUrl, environment, authConfig) {
+async function tryFallbackDataplaneUrl(controllerUrl, environment, authConfig, silent) {
   try {
     const fallbackUrl = await getDataplaneUrl(controllerUrl, 'dataplane', environment, authConfig);
-    logger.log(formatSuccessLine(`Dataplane URL: ${fallbackUrl}`));
+    if (!silent) {
+      logger.log(formatSuccessLine(`Dataplane URL: ${fallbackUrl}`));
+    }
     return fallbackUrl;
   } catch (fallbackError) {
     if (isNotFoundError(fallbackError)) {
@@ -93,19 +95,25 @@ async function tryFallbackDataplaneUrl(controllerUrl, environment, authConfig) {
  * @param {string} controllerUrl - Controller URL
  * @param {string} environment - Environment key
  * @param {Object} authConfig - Authentication configuration
+ * @param {{ silent?: boolean }} [opts] - When silent, skip progress/success lines (e.g. cert sync right after a run).
  * @returns {Promise<string>} Dataplane URL
  * @throws {Error} If dataplane URL cannot be discovered
  */
-async function discoverDataplaneUrl(controllerUrl, environment, authConfig) {
-  logger.log(infoLine('🌐 Getting dataplane URL from controller...'));
+async function discoverDataplaneUrl(controllerUrl, environment, authConfig, opts = {}) {
+  const silent = opts.silent === true;
+  if (!silent) {
+    logger.log(infoLine('🌐 Getting dataplane URL from controller...'));
+  }
   try {
     const dataplaneAppKey = await findDataplaneServiceAppKey(controllerUrl, environment, authConfig);
     if (dataplaneAppKey) {
       const dataplaneUrl = await getDataplaneUrl(controllerUrl, dataplaneAppKey, environment, authConfig);
-      logger.log(formatSuccessLine(`Dataplane URL: ${dataplaneUrl}`));
+      if (!silent) {
+        logger.log(formatSuccessLine(`Dataplane URL: ${dataplaneUrl}`));
+      }
       return dataplaneUrl;
     }
-    return await tryFallbackDataplaneUrl(controllerUrl, environment, authConfig);
+    return await tryFallbackDataplaneUrl(controllerUrl, environment, authConfig, silent);
   } catch (error) {
     if (error.message.includes('Could not discover dataplane URL')) {
       throw error;