@aifabrix/builder 2.45.0 → 2.46.0

package/lib/commands/teardown.js

@@ -118,6 +118,37 @@ function cleanAifabrixSystemDir() {
   return { removed, failed };
 }
 
+/**
+ * Remove materialized `builder/` trees (aifabrix-work, aifabrix-home / config dir, cwd).
+ * Complements {@link cleanAifabrixSystemDir} when `builder/` lives under `aifabrix-work` outside
+ * the config directory.
+ *
+ * @returns {{ removed: string[], failed: string[] }}
+ */
+function cleanMaterializedBuilderTrees() {
+  const candidates = [
+    pathsUtil.getBuilderRoot(),
+    path.join(pathsUtil.getAifabrixSystemDir(), 'builder'),
+    path.join(process.cwd(), 'builder')
+  ];
+  const seen = new Set();
+  const removed = [];
+  const failed = [];
+  for (const candidate of candidates) {
+    const resolved = path.resolve(candidate);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    if (!fs.existsSync(resolved)) continue;
+    try {
+      fs.rmSync(resolved, { recursive: true, force: true });
+      removed.push(resolved);
+    } catch {
+      failed.push(resolved);
+    }
+  }
+  return { removed, failed };
+}
+
 /**
  * Stop infra with `down-infra -v` semantics. Tolerates already-down state.
  * @async
@@ -259,6 +290,13 @@ async function handleTeardown(options = {}) {
   try {
     await stopInfraQuietly();
     const { removed, failed } = cleanFilesWithSpinner();
+    const builderClean = cleanMaterializedBuilderTrees();
+    for (const p of builderClean.removed) {
+      removed.push(p);
+    }
+    for (const p of builderClean.failed) {
+      failed.push(p);
+    }
     const devStr = await buildDeveloperLabel();
     logTeardownFooter({ devStr, removedCount: removed.length, failedCount: failed.length });
 
@@ -271,6 +309,7 @@ async function handleTeardown(options = {}) {
 module.exports = {
   handleTeardown,
   cleanAifabrixSystemDir,
+  cleanMaterializedBuilderTrees,
   stopInfraQuietly,
   PRESERVE_FILE,
   PRESERVE_CERTS_DIR

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

@@ -18,6 +18,10 @@ const { resolveApplicationConfigPath } = require('../utils/app-config-resolver')
 const { loadConfigFile } = require('../utils/config-format');
 const { discoverIntegrationFiles, buildEffectiveDatasourceFiles } = require('./repair-internal');
 const { runDatasourceTestE2E } = require('../datasource/test-e2e');
+const { cliOptsSkipSync } = require('../utils/cli-sync-options');
+const { buildMinimalUploadSyncOptions, isQuietMinimalSync } = require('../utils/upload-sync-options');
+const { getConfig } = require('../core/config');
+const { setupIntegrationTestAuth } = require('../external-system/test-auth');
 
 /**
  * Derives datasource key from filename when file has no key (same logic as repair).
@@ -89,17 +93,17 @@ function getDatasourceKeys(appPath, configPath, variables, systemKey, systemPars
  * unless ``options.noSync`` is true.
  * @param {string} systemKey
  * @param {Object} options
- * @returns {Promise<void>}
+ * @returns {Promise<{ authConfig: Object, dataplaneUrl: string, environment?: string }|null>}
  */
 async function syncLocalIfRequested(systemKey, options) {
-  if (options.noSync === true) return;
-  logger.log(chalk.cyan('Syncing local config to dataplane…'));
+  if (cliOptsSkipSync(options)) return null;
   const { uploadExternalSystem } = require('./upload');
-  await uploadExternalSystem(systemKey, {
-    verbose: !!options.verbose,
-    minimal: true
-  });
-  logger.log(formatSuccessLine('Sync complete'));
+  const uploadOpts = buildMinimalUploadSyncOptions(options);
+  const uploadCtx = await uploadExternalSystem(systemKey, uploadOpts);
+  if (uploadCtx?.uploadSkipped !== true && !isQuietMinimalSync(uploadOpts)) {
+    logger.log(formatSuccessLine('Sync complete'));
+  }
+  return uploadCtx && uploadCtx.dataplaneUrl && uploadCtx.authConfig ? uploadCtx : null;
 }
 
 /* eslint-disable max-lines-per-function, max-statements -- Load context, then loop over keys */
@@ -116,7 +120,12 @@ async function syncLocalIfRequested(systemKey, options) {
  * @param {boolean} [options.noSync] - When true, skip upload (E2E uses dataplane config already deployed)
  * @returns {Promise<{ success: boolean, results: Array<{ key: string, success: boolean, error?: string }> }>}
  */
-async function runTestE2EForExternalSystem(externalSystem, options = {}) {
+/**
+ * Resolve integration folder, system key, and datasource keys for system-level tests.
+ * @param {string} externalSystem
+ * @returns {{ systemKey: string, keys: string[] }}
+ */
+function resolveExternalIntegrationContext(externalSystem) {
   if (!externalSystem || typeof externalSystem !== 'string') {
     throw new Error('External system name is required');
   }
@@ -140,9 +149,9 @@ async function runTestE2EForExternalSystem(externalSystem, options = {}) {
   );
   const systemPath = path.join(appPath, systemFiles[0]);
   const systemParsed = loadConfigFile(systemPath);
-  const systemKey = systemParsed.key ||
+  const systemKey =
+    systemParsed.key ||
     path.basename(systemFiles[0], path.extname(systemFiles[0])).replace(/-system$/, '');
-
   const keys = getDatasourceKeys(
     appPath,
     configPath,
@@ -151,12 +160,37 @@ async function runTestE2EForExternalSystem(externalSystem, options = {}) {
     systemParsed,
     datasourceFiles
   );
+  return { systemKey, keys };
+}
+
+async function runTestE2EForExternalSystem(externalSystem, options = {}) {
+  const { systemKey, keys } = resolveExternalIntegrationContext(externalSystem);
   if (keys.length === 0) {
     logger.log(chalk.yellow(`No datasources found for ${externalSystem}. Add datasource files and run aifabrix repair.`));
     return { success: true, results: [] };
   }
 
-  await syncLocalIfRequested(systemKey, options);
+  const uploadCtx = await syncLocalIfRequested(systemKey, options);
+
+  let authConfig;
+  let dataplaneUrl;
+  if (uploadCtx) {
+    ({ authConfig, dataplaneUrl } = uploadCtx);
+  } else if (options.authConfig && options.dataplaneUrl) {
+    ({ authConfig, dataplaneUrl } = options);
+  } else {
+    const configObj = await getConfig();
+    ({ authConfig, dataplaneUrl } = await setupIntegrationTestAuth(
+      externalSystem,
+      {
+        environment: options.env,
+        authConfig: options.authConfig,
+        dataplaneUrl: options.dataplaneUrl,
+        silentResolve: options.silentResolve === true
+      },
+      configObj
+    ));
+  }
 
   const results = [];
   const opts = {
@@ -164,9 +198,20 @@ async function runTestE2EForExternalSystem(externalSystem, options = {}) {
     environment: options.env,
     debug: options.debug,
     verbose: options.verbose,
-    async: options.async !== false
+    async: options.async !== false,
+    authConfig,
+    dataplaneUrl,
+    quietPollUi: options.quietPollUi === true,
+    onPollProgress: options.onPollProgress
   };
   for (const key of keys) {
+    if (typeof options.onDatasourceProgress === 'function') {
+      options.onDatasourceProgress({
+        key,
+        index: results.length,
+        total: keys.length
+      });
+    }
     try {
       const data = await runDatasourceTestE2E(key, opts);
       const steps = data.steps || data.completedActions || [];
@@ -187,5 +232,7 @@ async function runTestE2EForExternalSystem(externalSystem, options = {}) {
 
 module.exports = {
   runTestE2EForExternalSystem,
-  getDatasourceKeys
+  getDatasourceKeys,
+  resolveExternalIntegrationContext,
+  syncLocalIfRequested
 };

package/lib/commands/test-governance-cli-options.js

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview Normalize test-governance Commander flags
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { cliOptsSkipSync } = require('../utils/cli-sync-options');
+
+/**
+ * @param {string[]} [raw]
+ * @param {string[]} [fallback]
+ * @returns {string[]|undefined}
+ */
+function collectScenarioIds(raw, fallback) {
+  const list = Array.isArray(raw) && raw.length > 0 ? raw : fallback;
+  if (!list || list.length === 0) {
+    return undefined;
+  }
+  return list.map(id => String(id).trim()).filter(Boolean);
+}
+
+/**
+ * @param {Object} options
+ * @param {import('commander').Command} [cmd]
+ * @returns {Object}
+ */
+function normalizeTestGovernanceCliOptions(options, cmd) {
+  const raw = cmd && Array.isArray(cmd.rawArgs) ? cmd.rawArgs : [];
+  const has = flag => raw.includes(flag);
+  return {
+    ...options,
+    env: options.env || 'dev',
+    verbose: options.verbose === true || has('-v') || has('--verbose'),
+    json: options.json === true || has('--json'),
+    noSync: cliOptsSkipSync(options, cmd),
+    pack: options.pack,
+    app: options.app,
+    scenarioIds: collectScenarioIds(options.scenario)
+  };
+}
+
+module.exports = {
+  normalizeTestGovernanceCliOptions,
+  collectScenarioIds
+};

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

@@ -0,0 +1,67 @@
+/**
+ * @fileoverview test-governance — run governance scenario pack via dataplane API
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { getConfig } = require('../core/config');
+const { setupIntegrationTestAuth } = require('../external-system/test-auth');
+const { runGovernanceScenarios } = require('../api/governance-scenarios.api');
+const {
+  resolveGovernancePackPath,
+  loadGovernancePackYaml
+} = require('../governance/governance-pack-loader');
+const { syncLocalIfRequested } = require('./test-e2e-external');
+
+/**
+ * @async
+ * @param {string} externalSystem
+ * @param {Object} options
+ * @returns {Promise<{ result: Object, packPath: string, systemKey: string }>}
+ */
+async function runTestGovernanceForExternalSystem(externalSystem, options = {}) {
+  const pathsUtil = require('../utils/paths');
+  const appType = await pathsUtil.detectAppType(externalSystem).catch(() => null);
+  if (!appType || appType.baseDir !== 'integration') {
+    throw new Error(
+      'verify-governance applies to external integration folders only (integration/<systemKey>/).'
+    );
+  }
+
+  const systemKey = externalSystem;
+  const packPath = resolveGovernancePackPath(systemKey, {
+    pack: options.pack,
+    app: options.app
+  });
+  const pack = loadGovernancePackYaml(packPath);
+
+  const uploadCtx = await syncLocalIfRequested(systemKey, options);
+
+  let authConfig;
+  let dataplaneUrl;
+  if (uploadCtx) {
+    ({ authConfig, dataplaneUrl } = uploadCtx);
+  } else {
+    const configObj = await getConfig();
+    ({ authConfig, dataplaneUrl } = await setupIntegrationTestAuth(
+      externalSystem,
+      { environment: options.env },
+      configObj
+    ));
+  }
+
+  const body = {
+    systemKey,
+    pack,
+    scenarios: options.scenarioIds
+  };
+  const result = await runGovernanceScenarios(dataplaneUrl, authConfig, body);
+  return { result, packPath, systemKey, packDocument: pack };
+}
+
+module.exports = {
+  runTestGovernanceForExternalSystem,
+  syncLocalIfRequested
+};

package/lib/commands/test-trust-cli-options.js

@@ -0,0 +1,32 @@
+/**
+ * @fileoverview Normalize test-trust Commander flags (defensive for -d/-v/--revalidate).
+ */
+
+'use strict';
+
+const { cliOptsSkipSync } = require('../utils/cli-sync-options');
+
+/**
+ * @param {Object} options - Commander-parsed options
+ * @param {import('commander').Command} [cmd]
+ * @returns {Object}
+ */
+function normalizeTestTrustCliOptions(options, cmd) {
+  const raw = cmd && Array.isArray(cmd.rawArgs) ? cmd.rawArgs : [];
+  const has = flag => raw.includes(flag);
+  return {
+    ...options,
+    debug: options.debug === true || has('-d') || has('--debug'),
+    verbose: options.verbose === true || has('-v') || has('--verbose'),
+    revalidate: options.revalidate === true || has('--revalidate'),
+    noSync: cliOptsSkipSync(options, cmd),
+    strict: options.strict === true || has('--strict'),
+    summary: options.summary === true || has('--summary'),
+    json: options.json === true || has('--json'),
+    warningsAsErrors: options.warningsAsErrors === true || has('--warnings-as-errors')
+  };
+}
+
+module.exports = {
+  normalizeTestTrustCliOptions
+};

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

@@ -0,0 +1,126 @@
+/**
+ * @fileoverview verify-trust <systemKey> — semantic agent metadata validation for all datasources.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { getConfig } = require('../core/config');
+const { setupIntegrationTestAuth } = require('../external-system/test-auth');
+const { runDatasourceAgentTrust } = require('../datasource/agent-trust-run');
+const {
+  resolveExternalIntegrationContext,
+  syncLocalIfRequested
+} = require('./test-e2e-external');
+
+function pushTrustResult(results, key, trustRun, apiError) {
+  const failed =
+    apiError ||
+    !trustRun ||
+    trustRun.trustDecision === 'notTrusted' ||
+    trustRun.validationStatus === 'failed';
+  results.push({
+    key,
+    success: !failed,
+    error: failed
+      ? apiError
+        ? apiError.message || String(apiError)
+        : trustRun.summary || 'Trust validation failed'
+      : undefined,
+    trustRun
+  });
+}
+
+/**
+ * @async
+ * @param {Object|null} uploadCtx
+ * @param {string} externalSystem
+ * @param {Object} options
+ * @returns {Promise<{ authConfig: Object, dataplaneUrl: string }>}
+ */
+async function resolveTrustAuthContext(uploadCtx, externalSystem, options) {
+  if (uploadCtx) {
+    return { authConfig: uploadCtx.authConfig, dataplaneUrl: uploadCtx.dataplaneUrl };
+  }
+  const configObj = await getConfig();
+  return setupIntegrationTestAuth(
+    externalSystem,
+    {
+      environment: options.env,
+      authConfig: options.authConfig,
+      dataplaneUrl: options.dataplaneUrl,
+      silentResolve: options.silentResolve === true
+    },
+    configObj
+  );
+}
+
+/**
+ * @async
+ * @param {string[]} keys
+ * @param {Object} runOpts
+ * @param {Array<Object>} results
+ */
+async function runTrustForDatasourceKeys(keys, runOpts, results) {
+  for (const key of keys) {
+    try {
+      const { trustRun, apiError } = await runDatasourceAgentTrust(key, runOpts);
+      pushTrustResult(results, key, trustRun, apiError);
+    } catch (err) {
+      results.push({ key, success: false, error: err.message, trustRun: null });
+    }
+  }
+}
+
+/**
+ * @async
+ * @param {string} externalSystem
+ * @param {Object} options
+ * @returns {Promise<{ success: boolean, results: Array<Object>, systemKey: string }>}
+ */
+async function runTestTrustForExternalSystem(externalSystem, options = {}) {
+  const { systemKey, keys } = resolveExternalIntegrationContext(externalSystem);
+  if (keys.length === 0) {
+    logger.log(chalk.yellow(`No datasources found for ${externalSystem}.`));
+    return { success: true, results: [], systemKey };
+  }
+
+  const uploadCtx = await syncLocalIfRequested(systemKey, options);
+  if (uploadCtx?.authConfig && uploadCtx?.dataplaneUrl) {
+    options.authConfig = uploadCtx.authConfig;
+    options.dataplaneUrl = uploadCtx.dataplaneUrl;
+    options.silentResolve = true;
+  }
+  if (options.revalidate === true) {
+    logger.log(chalk.cyan('Forcing revalidation (cache bypass) for each datasource…'));
+  }
+
+  const { authConfig, dataplaneUrl } = await resolveTrustAuthContext(
+    uploadCtx,
+    externalSystem,
+    options
+  );
+  const results = [];
+  await runTrustForDatasourceKeys(
+    keys,
+    {
+      app: externalSystem,
+      environment: options.env,
+      noSync: true,
+      revalidate: options.revalidate === true,
+      summary: options.summary === true,
+      timeout: options.timeout,
+      authConfig,
+      dataplaneUrl
+    },
+    results
+  );
+  return { success: results.every(r => r.success), results, systemKey };
+}
+
+module.exports = {
+  runTestTrustForExternalSystem
+};

package/lib/commands/up-common.js

@@ -14,7 +14,7 @@ const fs = require('fs');
 const chalk = require('chalk');
 const logger = require('../utils/logger');
 const config = require('../core/config');
-const { getDefaultControllerUrl } = require('../utils/controller-url');
+const { resolvePlatformControllerUrl } = require('../utils/platform-controller-url');
 const pathsUtil = require('../utils/paths');
 const { loadConfigFile, writeConfigFile } = require('../utils/config-format');
 const { isYamlPath } = require('../utils/config-format');
@@ -189,19 +189,29 @@ function patchEnvOutputPathForDeployOnly(appName) {
 
 /**
  * For ``up-platform --force`` only: clear all stored auth tokens, set ``environment`` to ``dev``,
- * set ``controller`` to the default URL for the current ``developer-id`` (``http://localhost`` +
- * app port = 3000 + developerId × 100), and persist config. Does not change ``developer-id``.
+ * set ``controller`` and ``platform-controller`` to the default URL (or ``defaultControllerUrl`` when
+ * provided), and persist config. Does not change ``developer-id``. Pass ``clearTokens: false`` to
+ * keep device/client tokens (setup when already logged in to the platform controller).
  * Builder dirs (keycloak, miso-controller, dataplane) are cleaned separately.
  *
  * @returns {Promise<void>}
  */
 async function applyUpPlatformForceConfig(opts = {}) {
   const silent = Boolean(opts.silent);
-  const deviceCleared = await config.clearAllDeviceTokens();
-  const clientCleared = await config.clearAllClientTokens();
+  const clearTokens = opts.clearTokens !== false;
+  let deviceCleared = 0;
+  let clientCleared = 0;
+  if (clearTokens) {
+    deviceCleared = await config.clearAllDeviceTokens();
+    clientCleared = await config.clearAllClientTokens();
+  }
   await config.setCurrentEnvironment('dev');
-  const defaultControllerUrl = await getDefaultControllerUrl();
+  const defaultControllerUrl =
+    opts.defaultControllerUrl && typeof opts.defaultControllerUrl === 'string'
+      ? String(opts.defaultControllerUrl).replace(/\/+$/, '')
+      : await resolvePlatformControllerUrl();
   await config.setControllerUrl(defaultControllerUrl);
+  await config.setPlatformControllerUrl(defaultControllerUrl);
 
   const summary = { deviceCleared, clientCleared, defaultControllerUrl, environment: 'dev' };
   if (!silent) {
@@ -287,14 +297,15 @@ async function cleanBuilderAppDirs(appNames, opts = {}) {
  * @example
  * await ensureAppFromTemplate('keycloak');
  */
-async function ensureAppFromTemplate(appName) {
+async function ensureAppFromTemplate(appName, opts = {}) {
   if (!appName || typeof appName !== 'string') {
     throw new Error('Application name is required and must be a string');
   }
+  const silent = Boolean(opts.silent);
 
   const appPath = pathsUtil.getBuilderPath(appName);
   const primaryCopied = await ensureTemplateAtPath(appName, appPath);
-  if (primaryCopied) {
+  if (primaryCopied && !silent) {
     logger.log(chalk.blue(`Creating builder/${appName} from template...`));
     logger.log(formatSuccessLine(`Copied template for ${appName}`));
   }
@@ -307,7 +318,7 @@ async function ensureAppFromTemplate(appName) {
     !pathsUtil.isSystemBuilderAppName(appName)
   ) {
     const cwdCopied = await ensureTemplateAtPath(appName, cwdBuilderPath);
-    if (cwdCopied) {
+    if (cwdCopied && !silent) {
       logger.log(chalk.blue(`Creating builder/${appName} in project (from template)...`));
       logger.log(formatSuccessLine(`Copied template for ${appName} into builder/`));
     }
@@ -339,10 +350,11 @@ function refreshUrlsLocalRegistryForCurrentProject() {
  *
  * @returns {Promise<void>}
  */
-async function prepareUrlsLocalRegistryForUpPlatform() {
-  await ensureAppFromTemplate('keycloak');
-  await ensureAppFromTemplate('miso-controller');
-  await ensureAppFromTemplate('dataplane');
+async function prepareUrlsLocalRegistryForUpPlatform(opts = {}) {
+  const templateOpts = { silent: Boolean(opts.silent) };
+  await ensureAppFromTemplate('keycloak', templateOpts);
+  await ensureAppFromTemplate('miso-controller', templateOpts);
+  await ensureAppFromTemplate('dataplane', templateOpts);
   refreshUrlsLocalRegistryForCurrentProject();
 }
 

package/lib/commands/up-dataplane.js

@@ -103,6 +103,22 @@ async function resolveControllerUrlWithHealthCheck() {
   return normalizedNew;
 }
 
+async function resolveUpDataplaneAuthContext(options, environmentKey) {
+  if (options.skipInfraCheck !== true) {
+    await assertDevInfraUp();
+  }
+
+  const controllerUrl = await resolveControllerUrlWithHealthCheck();
+  const authConfig = await checkAuthentication(controllerUrl, environmentKey, { throwOnFailure: true });
+
+  const cfg = await config.getConfig();
+  if (options.allowNonDev !== true) {
+    assertDevEnvironmentForDataplane(cfg);
+  }
+  logger.log(formatSuccessLine(`Logged in (environment: ${environmentKey})`));
+  return { controllerUrl, authConfig };
+}
+
 /**
  * Register or rotate dataplane: if app exists in controller, rotate secret; otherwise register.
  * @async
@@ -118,7 +134,12 @@ async function registerOrRotateDataplane(options, controllerUrl, environmentKey,
     await rotateSecret('dataplane', options);
   } else {
     const imageOverride = options.image || buildDataplaneImageRef(options);
-    const registerOpts = { imageOverride, image: imageOverride, registryMode: options.registryMode };
+    const registerOpts = {
+      imageOverride,
+      image: imageOverride,
+      registryMode: options.registryMode,
+      envKey: environmentKey
+    };
     await registerApplication('dataplane', registerOpts);
   }
 }
@@ -134,6 +155,7 @@ async function deployDataplaneToController(options) {
     imageOverride,
     image: imageOverride,
     registryMode: options.registryMode,
+    envKey: options.envKey ? String(options.envKey).trim().toLowerCase() : undefined,
     // Guided up-platform already shows a top-level spinner for the dataplane step.
     // Avoid nested deploy polling spinners/logs.
     silentPoll: options.platformInstall === true
@@ -172,6 +194,14 @@ function emitDataplaneManifestLineFromBuilder() {
   emitSystemBuilderAppManifestLineIfTTY(logger, 'dataplane');
 }
 
+function computeDataplanePortOverride(runEnvKey, developerIdNum) {
+  if (runEnvKey !== 'dev' && runEnvKey !== 'tst') {
+    return undefined;
+  }
+  const baseHostPort = 3001 + (Number.isFinite(developerIdNum) ? developerIdNum : 0) * 100;
+  return runEnvKey === 'dev' ? baseHostPort + 10 : baseHostPort + 20;
+}
+
 function assertDevEnvironmentForDataplane(cfg) {
   const environment = (cfg && cfg.environment) ? cfg.environment : 'dev';
   if (environment !== 'dev') {
@@ -181,6 +211,14 @@ function assertDevEnvironmentForDataplane(cfg) {
   }
 }
 
+async function computeDataplaneRunOverrides(options) {
+  const runEnvKey = options.runEnvKey ? String(options.runEnvKey).trim().toLowerCase() : undefined;
+  const developerIdRaw = await config.getDeveloperId();
+  const developerIdNum = typeof developerIdRaw === 'string' ? parseInt(developerIdRaw, 10) : developerIdRaw;
+  const portOverride = computeDataplanePortOverride(runEnvKey, developerIdNum);
+  return { runEnvKey, portOverride };
+}
+
 /**
  * Handle up-dataplane command: ensure logged in, environment dev, ensure dataplane,
  * register or rotate (if already registered), deploy (send manifest to controller),
@@ -199,17 +237,11 @@ function assertDevEnvironmentForDataplane(cfg) {
 async function handleUpDataplane(options = {}) {
   logger.log(chalk.blue('Starting up-dataplane (register/rotate, deploy, then run dataplane locally)...\n'));
 
-  if (options.skipInfraCheck !== true) {
-    await assertDevInfraUp();
-  }
-
-  const controllerUrl = await resolveControllerUrlWithHealthCheck();
-  const environmentKey = await resolveEnvironment();
-  const authConfig = await checkAuthentication(controllerUrl, environmentKey, { throwOnFailure: true });
-
-  const cfg = await config.getConfig();
-  assertDevEnvironmentForDataplane(cfg);
-  logger.log(formatSuccessLine('Logged in and environment is dev'));
+  const environmentKey =
+    options && options.envKey
+      ? String(options.envKey).trim().toLowerCase()
+      : await resolveEnvironment();
+  const { controllerUrl, authConfig } = await resolveUpDataplaneAuthContext(options, environmentKey);
 
   await ensureAppFromTemplate('dataplane');
   // If envOutputPath target folder does not exist, set envOutputPath to null
@@ -223,10 +255,15 @@ async function handleUpDataplane(options = {}) {
 
   await registerOrRotateDataplane(options, controllerUrl, environmentKey, authConfig);
 
-  await deployDataplaneToController(options);
+  await deployDataplaneToController({ ...options, envKey: environmentKey });
   logger.log('');
+
+  const { runEnvKey, portOverride } = await computeDataplaneRunOverrides(options);
+
   await app.runApp('dataplane', {
     skipEnvOutputPath: true,
+    env: runEnvKey,
+    port: portOverride,
     registry: options.registry || undefined,
     base: options.base !== false,
     skipManifestMetadataLine: true