@aifabrix/builder 2.48.0 → 2.49.1

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/teardown.js

@@ -120,17 +120,15 @@ function cleanAifabrixSystemDir() {
 }
 
 /**
- * Remove materialized `builder/` trees (aifabrix-work, aifabrix-home / config dir, cwd).
- * Complements {@link cleanAifabrixSystemDir} when `builder/` lives under `aifabrix-work` outside
- * the config directory.
+ * Remove materialized `builder/` trees under home/work and config dir only.
+ * Does not remove `cwd/builder` in product repos (e.g. aifabrix-dataplane/builder/dataplane).
  *
  * @returns {{ removed: string[], failed: string[] }}
  */
 function cleanMaterializedBuilderTrees() {
   const candidates = [
     pathsUtil.getBuilderRoot(),
-    path.join(pathsUtil.getAifabrixSystemDir(), 'builder'),
-    path.join(process.cwd(), 'builder')
+    path.join(pathsUtil.getAifabrixSystemDir(), 'builder')
   ];
   const seen = new Set();
   const removed = [];

package/lib/commands/up-common.js

@@ -242,26 +242,21 @@ function isUnderAllowedBuilderRoot(resolvedAppPath, allowedRoots) {
 }
 
 /**
- * Removes builder app directories for the given app names. Only removes paths under an allowed
- * builder root (project `builder/` or `~/.aifabrix/builder/`) to prevent path traversal.
- * Uses {@link pathsUtil.getBuilderPath} for each app (system apps may resolve under the config dir).
+ * Removes platform app directories under the home/work materialized `builder/` root only.
+ * Never deletes `cwd/builder` trees in product repos (e.g. aifabrix-miso/builder/miso-controller).
  *
  * @param {string[]} appNames - Application names (e.g. ['keycloak', 'miso-controller', 'dataplane'])
  * @returns {Promise<void>}
- * @throws {Error} If any path is outside allowed builder roots (path traversal attempt)
+ * @throws {Error} If any path is outside the home builder root (path traversal attempt)
  */
 async function cleanBuilderAppDirs(appNames, opts = {}) {
   const silent = Boolean(opts.silent);
   if (!Array.isArray(appNames) || appNames.length === 0) return;
-  const allowedRoots = uniqueResolvedRoots([
-    path.join(process.cwd(), 'builder'),
-    pathsUtil.getBuilderRoot(),
-    pathsUtil.getSystemBuilderRoot()
-  ]);
+  const allowedRoots = uniqueResolvedRoots([pathsUtil.getSystemBuilderRoot()]);
   const cleaned = [];
   for (const appName of appNames) {
     if (!appName || typeof appName !== 'string') continue;
-    const appPath = path.resolve(pathsUtil.getBuilderPath(appName));
+    const appPath = path.resolve(pathsUtil.getHomeBuilderAppPath(appName));
     if (!isUnderAllowedBuilderRoot(appPath, allowedRoots)) {
       throw new Error(
         `Path ${appPath} is outside allowed builder roots (${allowedRoots.join(', ')}); refusing to clean`
@@ -303,7 +298,9 @@ async function ensureAppFromTemplate(appName, opts = {}) {
   }
   const silent = Boolean(opts.silent);
 
-  const appPath = pathsUtil.getBuilderPath(appName);
+  const appPath = pathsUtil.isSystemBuilderAppName(appName)
+    ? pathsUtil.getHomeBuilderAppPath(appName)
+    : pathsUtil.getBuilderPath(appName);
   const primaryCopied = await ensureTemplateAtPath(appName, appPath);
   if (primaryCopied && !silent) {
     logger.log(chalk.blue(`Creating builder/${appName} from template...`));

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);