@aifabrix/builder 2.48.0 → 2.49.0

package/lib/cli/setup-platform.js

@@ -29,6 +29,8 @@ What this command does:
       2) Wipe data — drop every database and DB user, then up-infra + up-platform --force.
       3) Clean installation files — remove user-local secrets, then up-infra + up-platform --force.
       4) Update images — pull the latest infra and platform images, then up-infra + up-platform.
+  - With --mode fresh: first-time install when no infra is running (non-interactive; use with --admin-email and --admin-password).
+  - With --mode update-images: refresh images when infra is already running (non-interactive).
 
 AI tool keys are read from the user-local file (~/.aifabrix/secrets.local.yaml) merged with the shared aifabrix-secrets file. If either source already provides keys, the AI tool prompt is skipped.
 
@@ -59,6 +61,7 @@ function registerSetup(program) {
     .option('--pro-password-mode <mode>', 'Pro profile only: autogen or manual')
     .option('--admin-email <email>', 'Admin email (non-interactive fresh install)')
     .option('--admin-password <password>', 'Admin password for dev or pro manual-single (non-interactive)')
+    .option('--mode <mode>', 'Non-interactive mode: fresh (no infra) or update-images (infra running)')
     .option('-y, --yes', 'Skip destructive confirmation prompts (re-install, wipe data, teardown)')
     .addHelpText('after', SETUP_HELP_AFTER)
     .action(async(options) => {

package/lib/commands/login-device.js

@@ -96,7 +96,7 @@ async function saveTokenAndDisplaySuccess(controllerUrl, token, refreshToken, ex
       logger.log(chalk.gray(`Environment: ${envKey}`));
     }
     logger.log(chalk.gray('Token stored securely in ~/.aifabrix/config.yaml\n'));
-  } else {
+  } else if (!opts.suppressSuccessLine && !opts.guidedInstall) {
     logger.log(formatSuccessLine('Authentication successful'));
   }
 }
@@ -116,8 +116,10 @@ async function pollAndSaveDeviceCodeToken(controllerUrl, deviceCode, interval, e
   const spinner = useSpinner
     ? ora({ text: 'Waiting for approval', spinner: 'dots' }).start()
     : null;
-  if (!useSpinner) {
+  if (!useSpinner && !opts.onProgressText) {
     logger.log('Waiting for approval...');
+  } else if (opts.onProgressText) {
+    opts.onProgressText('Waiting for approval...');
   }
 
   let pollCount = 0;
@@ -125,6 +127,8 @@ async function pollAndSaveDeviceCodeToken(controllerUrl, deviceCode, interval, e
     pollCount++;
     if (spinner) {
       spinner.text = `Waiting for approval (attempt ${pollCount})...`;
+    } else if (opts.onProgressText) {
+      opts.onProgressText(`Waiting for approval (attempt ${pollCount})...`);
     }
   };
 

package/lib/commands/login.js

@@ -163,7 +163,10 @@ async function handleDeviceCodeLoginFlow(controllerUrl, environment, options) {
   return await handleDeviceCodeLogin(controllerUrl, environment, options.online, options.scope, {
     compact: Boolean(options.compact),
     exitOnFailure: options.exitOnFailure !== false,
-    tokenControllerUrl: options.tokenControllerUrl
+    tokenControllerUrl: options.tokenControllerUrl,
+    guidedInstall: options.guidedInstall === true,
+    onProgressText: options.onProgressText,
+    suppressSuccessLine: options.suppressSuccessLine === true
   });
 }
 

package/lib/commands/setup-modes.js

@@ -42,11 +42,19 @@ const postgresBootstrap = require('../utils/postgres-platform-bootstrap');
 const appLib = require('../app');
 const setupPrompts = require('./setup-prompts');
 const { ensureSetupPlatformAuth, syncPlatformControllerUrlsInConfig } = require('./setup-platform-auth');
+const {
+  refreshRemoteSettingsFromBuilderIfPossible
+} = require('../utils/refresh-remote-settings');
 const { handleLogin } = require('./login');
 const infraGuided = require('../cli/infra-guided');
+const {
+  applyPlatformTopologyFlagsToConfig,
+  platformTopologyNeedsReconcile
+} = require('../core/setup-platform-mode');
 const {
   computeEffectiveInfraOptionalFlags,
-  persistMissingInfraOptionalServiceFlags
+  persistMissingInfraOptionalServiceFlags,
+  topologyFlagsForConfig
 } = require('../utils/infra-optional-service-flags');
 
 /** Builder app keys touched by `up-platform --force`. */
@@ -197,11 +205,19 @@ async function maybePromptForExistingBuilderDir({ force, skipBuilderConflictProm
  */
 async function startInfraFromConfig(overrides = {}) {
   await config.ensureSecretsEncryptionKey();
-  const cfg = await config.getConfig();
+  await refreshRemoteSettingsFromBuilderIfPossible({ quiet: true });
+  let cfg = await config.getConfig();
+  if (platformTopologyNeedsReconcile(cfg)) {
+    applyPlatformTopologyFlagsToConfig(cfg, cfg.setupPlatformMode);
+    await config.saveConfig(cfg);
+    cfg = await config.getConfig();
+  }
   const emailOverride = String(overrides.adminEmail || '').trim();
   const emailFromConfig = typeof cfg.adminEmail === 'string' ? cfg.adminEmail.trim() : '';
   const adminEmailMerged = emailOverride || emailFromConfig || undefined;
   const effective = computeEffectiveInfraOptionalFlags(cfg, {});
+  const topology = topologyFlagsForConfig(cfg);
+  const tlsEnabled = topology ? topology.tlsEnabled : cfg.tlsEnabled === true;
   const legacyPwd =
     overrides.passwordBundle && overrides.passwordBundle.mode === 'single'
       ? overrides.passwordBundle.password
@@ -215,7 +231,7 @@ async function startInfraFromConfig(overrides = {}) {
       adminPwd: legacyPwd,
       adminEmail: adminEmailMerged,
       passwordBundle: overrides.passwordBundle,
-      tlsEnabled: cfg.tlsEnabled === true
+      tlsEnabled
     });
   });
   await persistMissingInfraOptionalServiceFlags(cfg, effective);

package/lib/commands/setup-platform-auth.js

@@ -14,6 +14,14 @@ const { resolvePlatformControllerUrl } = require('../utils/platform-controller-u
 const { isPlatformAuthValidForController } = require('../utils/controller-url');
 const { infoLine } = require('../utils/cli-test-layout-chalk');
 const logger = require('../utils/logger');
+const chalk = require('chalk');
+const {
+  refreshRemoteSettingsFromBuilderIfPossible
+} = require('../utils/refresh-remote-settings');
+const {
+  applyPlatformTopologyFlagsToConfig,
+  platformTopologyNeedsReconcile
+} = require('../core/setup-platform-mode');
 
 /**
  * Recompute `controller` and `platform-controller` from traefik / setupPlatformMode / front-door config.
@@ -24,6 +32,23 @@ const logger = require('../utils/logger');
  * @returns {Promise<string>} Normalized platform controller URL
  */
 async function syncPlatformControllerUrlsInConfig() {
+  const refresh = await refreshRemoteSettingsFromBuilderIfPossible({ quiet: true });
+  const cfg = await config.getConfig();
+  if (platformTopologyNeedsReconcile(cfg)) {
+    applyPlatformTopologyFlagsToConfig(cfg, cfg.setupPlatformMode);
+    await config.saveConfig(cfg);
+  }
+  const remoteServer = await config.getRemoteServer();
+  const rootDomain = await config.getDeveloperRootDomain();
+  if (remoteServer && !rootDomain && !refresh.refreshed) {
+    logger.warn(
+      chalk.yellow(
+        'Platform URLs may be wrong: developer-root-domain is missing. ' +
+          'Run "aifabrix dev refresh" (or "aifabrix dev init") to sync from the Builder Server.'
+      )
+    );
+  }
+
   const platformControllerUrl = await resolvePlatformControllerUrl();
   await config.setPlatformControllerUrl(platformControllerUrl);
   await config.setControllerUrl(platformControllerUrl);

package/lib/commands/setup-prompts-admin.js

@@ -225,6 +225,15 @@ async function promptAdminCredentialsWithProfile(options = {}) {
   await config.setSetupInstallationProfile(profile);
 
   const adminEmail = await promptAdminEmail(options);
+  const cliPassword = String(options.adminPassword || '').trim();
+  if (cliPassword) {
+    validatePassword(cliPassword);
+    const passwordBundle = isProInstallationProfile(profile)
+      ? singlePasswordBundle(cliPassword)
+      : singlePasswordBundle(cliPassword);
+    return { adminEmail, passwordBundle, profile };
+  }
+
   const passwordBundle = isProInstallationProfile(profile)
     ? await promptProPasswordBundle(options)
     : await promptDevPasswordBundle();

package/lib/commands/setup.js

@@ -29,7 +29,9 @@ const {
 
 const setupPrompts = require('./setup-prompts');
 const setupPlatformModePrompts = require('./setup-prompts-platform-mode');
-const { flagsForSetupPlatformMode } = require('../core/setup-platform-mode');
+const {
+  applyPlatformTopologyFlagsToConfig
+} = require('../core/setup-platform-mode');
 const setupModes = require('./setup-modes');
 const { syncPlatformControllerUrlsInConfig } = require('./setup-platform-auth');
 const installationLog = require('../utils/installation-log');
@@ -37,6 +39,11 @@ const { beginSetupCommandFlow, endSetupCommandFlow } = require('./setup-run-cont
 
 const MODE = setupPrompts.MODE;
 
+const CLI_SETUP_MODES = Object.freeze({
+  FRESH: 'fresh',
+  UPDATE_IMAGES: 'update-images'
+});
+
 const SEPARATOR = '────────────────────────────────────────';
 
 function title(text) {
@@ -58,15 +65,53 @@ async function maybePinDeveloperIdForFreshInstall(rawDeveloper) {
   logger.log(infoLine(`Developer ID pinned to ${dev}.`));
 }
 
+/**
+ * @param {Object} options
+ * @returns {'fresh'|'update-images'|null}
+ */
+function normalizeCliMode(options) {
+  const raw = options.mode ?? options.setupMode;
+  if (raw === undefined || raw === null || String(raw).trim() === '') {
+    return null;
+  }
+  const mode = String(raw).trim().toLowerCase();
+  if (mode === CLI_SETUP_MODES.FRESH || mode === CLI_SETUP_MODES.UPDATE_IMAGES) {
+    return mode;
+  }
+  throw new Error(`Invalid --mode "${raw}". Use fresh or update-images.`);
+}
+
+/**
+ * Non-interactive path when --mode is set (af-server automation).
+ * @param {Object} options
+ * @param {'fresh'|'update-images'} cliMode
+ * @returns {Promise<{ outcome: string, setupMode: string }>}
+ */
+async function runSetupWithCliMode(options, cliMode) {
+  logSetupHeader();
+  logger.log(formatProgress('Detecting current installation state...'));
+  const running = await isInfraRunning();
+  if (cliMode === CLI_SETUP_MODES.FRESH) {
+    if (running) {
+      throw new Error(
+        'Infrastructure is already running; use --mode update-images or run teardown first.'
+      );
+    }
+    await runFreshInstallFlow(options);
+    return { outcome: 'success', setupMode: CLI_SETUP_MODES.FRESH };
+  }
+  if (!running) {
+    throw new Error('No infrastructure running; use --mode fresh for first-time install.');
+  }
+  await dispatchMode(MODE.UPDATE_IMAGES);
+  logger.log(formatSuccessParagraph(`aifabrix setup complete (mode: ${cliMode}).`));
+  return { outcome: 'success', setupMode: cliMode };
+}
+
 async function applySetupPlatformMode(options) {
   const mode = await setupPlatformModePrompts.promptSetupPlatformMode(options);
-  await config.setSetupPlatformMode(mode);
-  const derived = flagsForSetupPlatformMode(mode);
-  // These are the user gates that control full-mode behavior.
   const cfg = await config.getConfig();
-  cfg.traefik = derived.traefik;
-  cfg.tlsEnabled = derived.tlsEnabled;
-  cfg.useEnvironmentScopedResources = derived.useEnvironmentScopedResources;
+  applyPlatformTopologyFlagsToConfig(cfg, mode);
   await config.saveConfig(cfg);
   await syncPlatformControllerUrlsInConfig();
   return mode;
@@ -150,6 +195,11 @@ async function dispatchMode(mode) {
  * @returns {Promise<{ outcome: string, setupMode: string|null }>}
  */
 async function runSetupMainPath(options, assumeYes) {
+  const cliMode = normalizeCliMode(options);
+  if (cliMode) {
+    return runSetupWithCliMode(options, cliMode);
+  }
+
   logSetupHeader();
   logger.log(formatProgress('Detecting current installation state...'));
   const running = await isInfraRunning();
@@ -273,5 +323,7 @@ async function handleSetup(options = {}) {
 module.exports = {
   handleSetup,
   isInfraRunning,
-  dispatchMode
+  dispatchMode,
+  normalizeCliMode,
+  CLI_SETUP_MODES
 };

package/lib/commands/up-dataplane-bootstrap.js

@@ -0,0 +1,149 @@
+/**
+ * Headless dataplane bootstrap provisioning (plan 197.0).
+ *
+ * @fileoverview up-dataplane bootstrap path when Docker + ENCRYPTION_KEY available
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const config = require('../core/config');
+const dockerUtils = require('../utils/docker');
+const { loadSecrets } = require('../core/secrets-load');
+const { callBootstrapApi } = require('../utils/app-bootstrap-api');
+const {
+  loadVariablesYaml,
+  extractAppConfiguration
+} = require('../utils/app-register-config');
+const { buildRegistrationData, saveLocalCredentials, applyLocalhostPortAdjustment } = require('../app/register');
+const { loadDataplanePipelineCredentialsFromSecretsFile } = require('./up-dataplane-credentials');
+const { formatSuccessLine } = require('../utils/cli-test-layout-chalk');
+
+const ENCRYPTION_VAULT_KEYS = [
+  'miso-controller-secrets-encryptionKeyVault',
+  'secrets-encryptionKeyVault'
+];
+
+/**
+ * @param {Record<string, unknown>} secrets
+ * @returns {string|null}
+ */
+function pickBootstrapEncryptionKeyFromSecrets(secrets) {
+  if (!secrets || typeof secrets !== 'object') {
+    return null;
+  }
+  for (const vaultKey of ENCRYPTION_VAULT_KEYS) {
+    const raw = secrets[vaultKey];
+    if (raw === undefined || raw === null) {
+      continue;
+    }
+    const trimmed = String(raw).trim();
+    if (trimmed) {
+      return trimmed;
+    }
+  }
+  return null;
+}
+
+/**
+ * Resolve shared ENCRYPTION_KEY for bootstrap header (never log).
+ * Uses the same merged secrets store as kv:// resolution (local + aifabrix-secrets / remote API).
+ * Must match miso-controller `ENCRYPTION_KEY` (kv://miso-controller-secrets-encryptionKeyVault),
+ * not `secrets-encryption` in config.yaml (CLI file-encryption key only).
+ *
+ * @async
+ * @returns {Promise<string|null>}
+ */
+async function resolveBootstrapEncryptionKey() {
+  await config.ensureSecretsEncryptionKey();
+  const secrets = await loadSecrets(undefined);
+  return pickBootstrapEncryptionKeyFromSecrets(secrets);
+}
+
+/**
+ * True when bootstrap path is eligible (dev + Docker + encryption key).
+ * @async
+ * @param {Object} [options]
+ * @returns {Promise<boolean>}
+ */
+async function canUseBootstrapProvision(options = {}) {
+  if (options.allowNonDev === true) {
+    return false;
+  }
+  const cfg = await config.getConfig();
+  const environment = cfg && cfg.environment ? cfg.environment : 'dev';
+  if (environment !== 'dev') {
+    return false;
+  }
+  try {
+    await dockerUtils.ensureDockerAndCompose();
+  } catch {
+    return false;
+  }
+  const encryptionKey = await resolveBootstrapEncryptionKey();
+  return Boolean(encryptionKey);
+}
+
+/**
+ * Register dataplane via bootstrap endpoint (idempotent).
+ * @async
+ * @param {Object} options - up-dataplane options
+ * @param {string} controllerUrl
+ * @param {string} environmentKey
+ * @param {Function} buildDataplaneImageRefFn
+ * @returns {Promise<void>}
+ */
+async function bootstrapDataplaneApplication(options, controllerUrl, environmentKey, buildDataplaneImageRefFn) {
+  const encryptionKey = await resolveBootstrapEncryptionKey();
+  if (!encryptionKey) {
+    throw new Error(
+      'Bootstrap encryption key is not available. Ensure miso-controller-secrets-encryptionKeyVault ' +
+        'exists in merged secrets (local secrets.local.yaml or aifabrix-secrets remote store) after up-miso resolve.'
+    );
+  }
+
+  const { variables } = await loadVariablesYaml('dataplane');
+  const appConfig = await extractAppConfiguration(variables, 'dataplane', options);
+  await applyLocalhostPortAdjustment(appConfig, controllerUrl, options);
+
+  const imageOverride = options.image || buildDataplaneImageRefFn(options);
+  const registerOpts = {
+    imageOverride,
+    image: imageOverride,
+    registryMode: options.registryMode,
+    envKey: environmentKey
+  };
+  const registrationData = buildRegistrationData(appConfig, registerOpts);
+
+  logger.log(chalk.blue('Provisioning dataplane via bootstrap (no device login)...'));
+  const responseData = await callBootstrapApi(
+    controllerUrl,
+    encryptionKey,
+    environmentKey,
+    registrationData
+  );
+
+  if (responseData.credentials && responseData.credentials.clientSecret) {
+    await saveLocalCredentials(responseData, controllerUrl);
+    logger.log(formatSuccessLine('Dataplane bootstrap credentials saved locally'));
+  } else if (responseData.status === 'already_provisioned') {
+    logger.log(formatSuccessLine('Dataplane already provisioned (bootstrap idempotent)'));
+    const localCredentials = await loadDataplanePipelineCredentialsFromSecretsFile();
+    if (!localCredentials) {
+      throw new Error(
+        'Dataplane is registered on the controller but pipeline credentials are missing locally. ' +
+          'Run fresh setup with volume wipe, or: aifabrix login && aifabrix app rotate-secret dataplane'
+      );
+    }
+  }
+}
+
+module.exports = {
+  canUseBootstrapProvision,
+  resolveBootstrapEncryptionKey,
+  bootstrapDataplaneApplication,
+  pickBootstrapEncryptionKeyFromSecrets
+};

package/lib/commands/up-dataplane-credentials.js

@@ -26,6 +26,12 @@ const MISALIGN_ERROR =
   'Dataplane pipeline credentials are not aligned with the controller. ' +
   'Run: aifabrix app rotate-secret dataplane && aifabrix run dataplane';
 
+const BOOTSTRAP_MISALIGN_ERROR =
+  'Dataplane bootstrap credentials are not accepted by the controller after deploy. ' +
+  'Ensure miso-controller has BOOTSTRAP_APPKEYS=dataplane and ENCRYPTION_KEY set, then re-run: aifabrix up-dataplane';
+
+const BOOTSTRAP_PROBE_RETRY = { maxAttempts: 15, delayMs: 3000 };
+
 /**
  * @param {string} controllerUrl
  * @returns {string}
@@ -120,9 +126,10 @@ async function credentialsAcceptTokenWithRetry(controllerUrl, maxAttempts = 5, d
 
 function resolveCredentialProbeRetry(options = {}) {
   const retry = options.credentialProbeRetry || {};
+  const bootstrapDefaults = options.useBootstrap === true ? BOOTSTRAP_PROBE_RETRY : { maxAttempts: 5, delayMs: 2000 };
   return {
-    maxAttempts: Number.isFinite(retry.maxAttempts) ? retry.maxAttempts : 5,
-    delayMs: Number.isFinite(retry.delayMs) ? retry.delayMs : 2000
+    maxAttempts: Number.isFinite(retry.maxAttempts) ? retry.maxAttempts : bootstrapDefaults.maxAttempts,
+    delayMs: Number.isFinite(retry.delayMs) ? retry.delayMs : bootstrapDefaults.delayMs
   };
 }
 
@@ -155,7 +162,12 @@ async function credentialsAcceptToken(controllerUrl) {
  */
 async function alignDataplaneCredentialsAfterDeploy(options, controllerUrl) {
   const quiet = options.platformInstall === true || options.quiet === true;
-  const aligned = await credentialsAcceptToken(controllerUrl);
+  const bootstrapPath = options.useBootstrap === true;
+  const { maxAttempts, delayMs } = resolveCredentialProbeRetry(options);
+
+  const aligned = bootstrapPath
+    ? await credentialsAcceptTokenWithRetry(controllerUrl, maxAttempts, delayMs)
+    : await credentialsAcceptToken(controllerUrl);
   if (aligned) {
     if (!quiet) {
       logger.log(formatSuccessLine('Dataplane pipeline credentials verified.'));
@@ -163,12 +175,15 @@ async function alignDataplaneCredentialsAfterDeploy(options, controllerUrl) {
     return;
   }
 
+  if (bootstrapPath) {
+    throw new Error(BOOTSTRAP_MISALIGN_ERROR);
+  }
+
   if (!quiet) {
     logger.log(chalk.blue('Aligning dataplane pipeline credentials with controller...'));
   }
   await rotateSecret(DATAPLANE_APP_KEY, { ...options, quiet, exitOnFailure: false });
 
-  const { maxAttempts, delayMs } = resolveCredentialProbeRetry(options);
   const stillMisaligned = !(await credentialsAcceptTokenWithRetry(controllerUrl, maxAttempts, delayMs));
   if (stillMisaligned) {
     throw new Error(MISALIGN_ERROR);

package/lib/commands/up-dataplane.js

@@ -35,6 +35,10 @@ const {
   refreshUrlsLocalRegistryForCurrentProject
 } = require('./up-common');
 const { alignDataplaneCredentialsAfterDeploy } = require('./up-dataplane-credentials');
+const {
+  canUseBootstrapProvision,
+  bootstrapDataplaneApplication
+} = require('./up-dataplane-bootstrap');
 
 const CONTROLLER_HEALTH_PATH = '/health';
 
@@ -120,7 +124,9 @@ async function resolveUpDataplaneAuthContext(options, environmentKey) {
   if (options.allowNonDev !== true) {
     assertDevEnvironmentForDataplane(cfg);
   }
-  logger.log(formatSuccessLine(`Logged in (environment: ${environmentKey})`));
+  if (options.platformInstall !== true) {
+    logger.log(formatSuccessLine(`Logged in (environment: ${environmentKey})`));
+  }
   return { controllerUrl, authConfig };
 }
 
@@ -223,6 +229,57 @@ async function computeDataplaneRunOverrides(options) {
   return { runEnvKey, portOverride };
 }
 
+/**
+ * Resolve controller URL and auth for bootstrap vs device-login paths.
+ * @async
+ * @param {Object} options
+ * @param {string} environmentKey
+ * @returns {Promise<{ controllerUrl: string, authConfig: Object|null, useBootstrap: boolean }>}
+ */
+async function resolveUpDataplaneControllerContext(options, environmentKey) {
+  const useBootstrap = await canUseBootstrapProvision(options);
+  if (useBootstrap) {
+    if (options.skipInfraCheck !== true) {
+      await assertDevInfraUp();
+    }
+    const controllerUrl = await resolveControllerUrlWithHealthCheck();
+    const cfg = await config.getConfig();
+    if (options.allowNonDev !== true) {
+      assertDevEnvironmentForDataplane(cfg);
+    }
+    if (options.platformInstall !== true) {
+      logger.log(formatSuccessLine('Using bootstrap provision (no device login)'));
+    }
+    return { controllerUrl, authConfig: null, useBootstrap: true };
+  }
+
+  const authContext = await resolveUpDataplaneAuthContext(options, environmentKey);
+  return {
+    controllerUrl: authContext.controllerUrl,
+    authConfig: authContext.authConfig,
+    useBootstrap: false
+  };
+}
+
+/**
+ * Register/bootstrap, deploy manifest, align credentials.
+ * @async
+ */
+async function provisionAndDeployDataplane(options, environmentKey, controllerUrl, useBootstrap, authConfig) {
+  if (useBootstrap) {
+    await bootstrapDataplaneApplication(options, controllerUrl, environmentKey, buildDataplaneImageRef);
+  } else {
+    await registerOrRotateDataplane(options, controllerUrl, environmentKey, authConfig);
+  }
+
+  await deployDataplaneToController({
+    ...options,
+    envKey: environmentKey,
+    ...(useBootstrap ? { deploymentAuth: 'client-credentials' } : {})
+  });
+  logger.log('');
+}
+
 /**
  * Handle up-dataplane command: ensure logged in, environment dev, ensure dataplane,
  * register or rotate (if already registered), deploy (send manifest to controller),
@@ -239,30 +296,34 @@ async function computeDataplaneRunOverrides(options) {
  * @throws {Error} If infra not up, controller unavailable, not logged in, environment not dev, or any step fails
  */
 async function handleUpDataplane(options = {}) {
-  logger.log(chalk.blue('Starting up-dataplane (register/rotate, deploy, then run dataplane locally)...\n'));
+  if (options.platformInstall !== true) {
+    logger.log(chalk.blue('Starting up-dataplane (register/rotate, deploy, then run dataplane locally)...\n'));
+  }
 
   const environmentKey =
     options && options.envKey
       ? String(options.envKey).trim().toLowerCase()
       : await resolveEnvironment();
-  const { controllerUrl, authConfig } = await resolveUpDataplaneAuthContext(options, environmentKey);
+
+  const { controllerUrl, authConfig, useBootstrap } = await resolveUpDataplaneControllerContext(
+    options,
+    environmentKey
+  );
 
   await ensureDataplaneAppsFromTemplate();
-  // If envOutputPath target folder does not exist, set envOutputPath to null
   validateEnvOutputPathFolderOrNull('dataplane');
-
   refreshUrlsLocalRegistryForCurrentProject();
 
   if (options.platformInstall !== true) {
     emitDataplaneManifestLineFromBuilder();
   }
 
-  await registerOrRotateDataplane(options, controllerUrl, environmentKey, authConfig);
+  await provisionAndDeployDataplane(options, environmentKey, controllerUrl, useBootstrap, authConfig);
 
-  await deployDataplaneToController({ ...options, envKey: environmentKey });
-  logger.log('');
-
-  await alignDataplaneCredentialsAfterDeploy(options, controllerUrl);
+  await alignDataplaneCredentialsAfterDeploy(
+    { ...options, useBootstrap },
+    controllerUrl
+  );
 
   const { runEnvKey, portOverride } = await computeDataplaneRunOverrides(options);
 
@@ -275,7 +336,9 @@ async function handleUpDataplane(options = {}) {
     skipManifestMetadataLine: true
   });
 
-  logger.log(formatSuccessParagraph('up-dataplane complete. Dataplane is registered, deployed in dev, and running locally.'));
+  if (options.platformInstall !== true) {
+    logger.log(formatSuccessParagraph('up-dataplane complete. Dataplane is registered, deployed in dev, and running locally.'));
+  }
 }
 
 module.exports = { handleUpDataplane, buildDataplaneImageRef };