@aifabrix/builder 2.47.4 → 2.49.0

package/lib/utils/docker-reload-mount.js

@@ -101,6 +101,7 @@ function hostnameMatchesDockerHost(dockerHost) {
   const hnShort = hn.split('.')[0];
   const hShort = h.split('.')[0];
   if (h === hnShort || hn === hShort) return true;
+  if (hShort && hnShort && hShort === hnShort) return true;
   return false;
 }
 
@@ -120,8 +121,18 @@ function isReloadBindMountOnEngineHost(dockerEndpoint) {
   return hostnameMatchesDockerHost(host);
 }
 
+/**
+ * True when host refers to this machine (loopback, FQDN, or short hostname match).
+ * @param {string} host
+ * @returns {boolean}
+ */
+function isHostOnThisMachine(host) {
+  return hostnameMatchesDockerHost(host);
+}
+
 module.exports = {
   extractHostFromDockerEndpoint,
   isReloadBindMountOnEngineHost,
-  isLocalhostSyncSshHost
+  isLocalhostSyncSshHost,
+  isHostOnThisMachine
 };

package/lib/utils/ensure-dev-certs-for-remote-docker.js

@@ -27,6 +27,7 @@ const {
   normalizePemNewlines
 } = require('./dev-cert-helper');
 const { isSslUntrustedError, fetchInstallCa } = require('./dev-ca-install');
+const { augmentAndSaveCaPemForRemoteDocker } = require('./dev-ca-docker-augment');
 
 /**
  * Read one-time issue-cert PIN from env or first non-empty line of AIFABRIX_DEV_ISSUE_PIN_FILE.
@@ -184,6 +185,10 @@ async function ensureDevCertsIfNeededForRemoteDocker() {
   const issueResponse = await requestIssueCert(ctx.baseUrl, ctx.devId, pin, csrPem, serverCaPem);
   const caPem = mergeCaPemBlocks(serverCaPem, issueResponse.caCertificate, issueResponse.ca);
   await saveDevCertMaterial(ctx.configDir, ctx.devId, issueResponse.certificate, keyPem, caPem);
+  await augmentAndSaveCaPemForRemoteDocker(ctx.configDir, ctx.devId, caPem, {
+    remoteServerUrl: ctx.baseUrl,
+    warn: (msg) => logger.log(chalk.yellow(`  ⚠ ${msg}`))
+  });
   logger.log(
     formatSuccessLine('Saved TLS material to ') + chalk.cyan(ctx.certDir) + chalk.green(' for remote Docker.\n')
   );

package/lib/utils/external-env-template.js

@@ -54,6 +54,36 @@ const FALLBACK_SECURITY_BY_AUTH = {
   none: []
 };
 
+/**
+ * @param {Array<{name: string, value: string}>} authSecureVars
+ * @param {Record<string, unknown>} security
+ * @param {string} prefix
+ * @param {string} systemKey
+ */
+function pushSecureVarsFromSecurityMap(authSecureVars, security, prefix, systemKey) {
+  for (const key of Object.keys(security)) {
+    const envName = `KV_${prefix}_${securityKeyToVar(key)}`;
+    const pathVal = kvEnvKeyToPath(envName, systemKey);
+    authSecureVars.push({ name: envName, value: pathVal || `kv://${systemKey}/${key}` });
+  }
+}
+
+/**
+ * @param {Array<{name: string, value: string}>} authSecureVars
+ * @param {string} authMethod
+ * @param {string} prefix
+ * @param {string} systemKey
+ */
+function pushFallbackSecureVars(authSecureVars, authMethod, prefix, systemKey) {
+  const keys = FALLBACK_SECURITY_BY_AUTH[authMethod] || FALLBACK_SECURITY_BY_AUTH.apikey;
+  for (const key of keys) {
+    authSecureVars.push({
+      name: `KV_${prefix}_${securityKeyToVar(key)}`,
+      value: `kv://${systemKey}/${key}`
+    });
+  }
+}
+
 /**
  * Builds authSecureVars array from system authentication.security (or fallback by auth type).
  * @param {Object} system - System object with key and authentication
@@ -65,6 +95,9 @@ function buildAuthSecureVarsFromSystem(system) {
   const prefix = systemKeyToKvPrefix(systemKey);
   if (!prefix) return authSecureVars;
   const authBlock = system?.authentication || system?.auth;
+  if (authBlock?.authType === 'apiProvider' || authBlock?.authType === 'none') {
+    return authSecureVars;
+  }
   const credential = getAuthCredentialTemplate(authBlock);
   const security = credential?.security || authBlock?.security;
   const authMethod = (
@@ -74,19 +107,9 @@ function buildAuthSecureVarsFromSystem(system) {
     'apikey'
   ).toLowerCase();
   if (security && typeof security === 'object' && Object.keys(security).length > 0) {
-    for (const key of Object.keys(security)) {
-      const envName = `KV_${prefix}_${securityKeyToVar(key)}`;
-      const pathVal = kvEnvKeyToPath(envName, systemKey);
-      authSecureVars.push({ name: envName, value: pathVal || `kv://${systemKey}/${key}` });
-    }
+    pushSecureVarsFromSecurityMap(authSecureVars, security, prefix, systemKey);
   } else {
-    const keys = FALLBACK_SECURITY_BY_AUTH[authMethod] || FALLBACK_SECURITY_BY_AUTH.apikey;
-    for (const key of keys) {
-      authSecureVars.push({
-        name: `KV_${prefix}_${securityKeyToVar(key)}`,
-        value: `kv://${systemKey}/${key}`
-      });
-    }
+    pushFallbackSecureVars(authSecureVars, authMethod, prefix, systemKey);
   }
   return authSecureVars;
 }
@@ -116,13 +139,25 @@ function buildConfigurationEntries(system) {
  * @returns {{ authMethod: string, authSecureVars: Array<{name: string, value: string}>, authNonSecureVarNames: string[], configuration: Array<{name: string, value: string, comment: string}> }}
  */
 function buildExternalEnvTemplateContext(system) {
-  const authMethod = (system?.authentication?.method ||
-    system?.authentication?.type ||
-    system?.auth?.method ||
-    system?.auth?.type ||
-    'apikey').toLowerCase();
+  const authBlock = system?.authentication || system?.auth;
+  const credential = getAuthCredentialTemplate(authBlock);
+  let authMethod = 'apikey';
+  if (authBlock?.authType === 'apiProvider') {
+    authMethod = 'apiprovider';
+  } else if (authBlock?.authType === 'none') {
+    authMethod = 'none';
+  } else {
+    authMethod = (
+      credential?.method ||
+      authBlock?.method ||
+      authBlock?.type ||
+      'apikey'
+    ).toLowerCase();
+  }
   const authSecureVars = buildAuthSecureVarsFromSystem(system);
-  const authVars = system?.authentication?.variables || system?.auth?.variables || {};
+  const authVars =
+    (credential?.variables && typeof credential.variables === 'object' ? credential.variables : null) ||
+    (authBlock?.variables && typeof authBlock.variables === 'object' ? authBlock.variables : {});
   const authNonSecureVarNames = Object.keys(authVars);
   const configuration = buildConfigurationEntries(system);
   return {

package/lib/utils/health-check-poll-ui.js

@@ -0,0 +1,84 @@
+/**
+ * In-place health-check wait line (TTY ora or carriage-return refresh).
+ *
+ * @fileoverview Health check poll presentation helpers
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('./logger');
+
+function shouldUseHealthCheckPollSpinner() {
+  return Boolean(process && process.stdout && process.stdout.isTTY);
+}
+
+/**
+ * @param {number} attemptIndex - Zero-based attempt index after a failed probe
+ * @param {number} maxAttempts
+ * @returns {string}
+ */
+function buildHealthCheckPollText(attemptIndex, maxAttempts) {
+  return chalk.yellow(
+    `Waiting for health check… (${attemptIndex + 1}/${maxAttempts})`
+  );
+}
+
+/**
+ * @param {number} maxAttempts
+ * @returns {{ usesSpinner: boolean, onWaiting: (attemptIndex: number) => void, finish: () => void }}
+ */
+function createHealthCheckPollHandlers(maxAttempts) {
+  if (shouldUseHealthCheckPollSpinner()) {
+    const ora = require('ora');
+    const spinner = ora({
+      text: buildHealthCheckPollText(0, maxAttempts),
+      spinner: 'dots'
+    });
+    let started = false;
+    return {
+      usesSpinner: true,
+      onWaiting: (attemptIndex) => {
+        if (!started) {
+          spinner.start();
+          started = true;
+        }
+        spinner.text = buildHealthCheckPollText(attemptIndex, maxAttempts);
+      },
+      finish: () => {
+        if (started) {
+          spinner.stop();
+          process.stdout.write('\n');
+        }
+      }
+    };
+  }
+
+  let lastLine = '';
+  return {
+    usesSpinner: false,
+    onWaiting: (attemptIndex) => {
+      const line = buildHealthCheckPollText(attemptIndex, maxAttempts);
+      if (process.stdout && process.stdout.isTTY) {
+        process.stdout.write(`\r${line}`);
+        lastLine = line;
+        return;
+      }
+      logger.log(line);
+    },
+    finish: () => {
+      if (lastLine && process.stdout && process.stdout.isTTY) {
+        process.stdout.write('\n');
+        lastLine = '';
+      }
+    }
+  };
+}
+
+module.exports = {
+  buildHealthCheckPollText,
+  createHealthCheckPollHandlers,
+  shouldUseHealthCheckPollSpinner
+};

package/lib/utils/health-check-url.js

@@ -63,56 +63,76 @@ function frontDoorPattern(appConfig) {
 }
 
 /**
- * Public app URL (Traefik + frontDoor mount path), without the health path — for CLI summaries.
- * Requires infra Traefik on, `frontDoorRouting.enabled`, host, and pattern.
- *
- * @async
- * @param {string} appName
- * @param {number} healthCheckPort
  * @param {Object|null} appConfig
- * @returns {Promise<string|null>}
+ * @returns {{ fd: Object, mountPath: string }|null}
  */
-async function computeTraefikPublicAppUrl(_appName, _healthCheckPort, appConfig) {
+function readTraefikFrontDoorMount(appConfig) {
   if (!appConfig || !frontDoorEnabled(appConfig)) return null;
   const pattern = frontDoorPattern(appConfig);
   if (!pattern) return null;
-
-  const coreConfig = require('../core/config');
-  const userCfg = await coreConfig.getConfig();
-  if (!(userCfg && userCfg.traefik)) return null;
-
   const fd = appConfig.frontDoorRouting;
-  if (!fd || typeof fd !== 'object') return null;
   const hostTemplate = typeof fd.host === 'string' ? fd.host.trim() : '';
   if (!hostTemplate) return null;
+  return { fd, mountPath: normalizeFrontDoorPatternForHealth(pattern) };
+}
 
-  const mountPath = normalizeFrontDoorPatternForHealth(pattern);
-
-  const infraTlsEnabled = Boolean(userCfg && userCfg.tlsEnabled);
-  const remoteServer = await coreConfig.getRemoteServer();
-  const developerIdRaw = await coreConfig.getDeveloperId();
-  const developerIdNum = parseDeveloperIdNum(developerIdRaw);
-  const setupPlatformMode = await coreConfig.getSetupPlatformMode();
+/**
+ * @param {Object} appConfig
+ * @returns {Promise<Object|null>}
+ */
+async function loadTraefikPublicUrlContext(appConfig) {
+  const coreConfig = require('../core/config');
+  const userCfg = await coreConfig.getConfig();
+  if (!(userCfg && userCfg.traefik)) return null;
+  const [remoteServer, developerRootDomain, developerIdRaw, setupPlatformMode] = await Promise.all([
+    coreConfig.getRemoteServer(),
+    coreConfig.getDeveloperRootDomain(),
+    coreConfig.getDeveloperId(),
+    coreConfig.getSetupPlatformMode()
+  ]);
+  return {
+    infraTlsEnabled: Boolean(userCfg && userCfg.tlsEnabled),
+    remoteServer,
+    developerRootDomain,
+    developerIdRaw,
+    developerIdNum: parseDeveloperIdNum(developerIdRaw),
+    setupPlatformMode,
+    listenPort: Number(appConfig?.port || 3000)
+  };
+}
 
-  // URLs are resolved for the CLI on the host, not from inside a container.
-  const profile = 'local';
-  const listenPort = Number(appConfig?.port || 3000);
+/**
+ * Public app URL (Traefik + frontDoor mount path), without the health path — for CLI summaries.
+ * Requires infra Traefik on, `frontDoorRouting.enabled`, host, and pattern.
+ *
+ * @async
+ * @param {string} appName
+ * @param {number} healthCheckPort
+ * @param {Object|null} appConfig
+ * @returns {Promise<string|null>}
+ */
+async function computeTraefikPublicAppUrl(_appName, _healthCheckPort, appConfig) {
+  const frontDoor = readTraefikFrontDoorMount(appConfig);
+  if (!frontDoor) return null;
+  const ctx = await loadTraefikPublicUrlContext(appConfig);
+  if (!ctx) return null;
 
   const publicBase = computePublicUrlBaseString({
     traefik: true,
     pathActive: true,
-    hostTemplate: fd.host,
-    tls: fd.tls,
-    developerIdRaw,
-    remoteServer,
-    profile,
-    listenPort,
-    developerIdNum,
-    infraTlsEnabled,
-    setupPlatformMode
+    hostTemplate: frontDoor.fd.host,
+    tls: frontDoor.fd.tls,
+    developerIdRaw: ctx.developerIdRaw,
+    remoteServer: ctx.remoteServer,
+    developerRootDomain: ctx.developerRootDomain,
+    profile: 'local',
+    listenPort: ctx.listenPort,
+    developerIdNum: ctx.developerIdNum,
+    infraTlsEnabled: ctx.infraTlsEnabled,
+    setupPlatformMode: ctx.setupPlatformMode
   });
 
-  return joinUrlPath(publicBase, mountPath);
+  return joinUrlPath(publicBase, frontDoor.mountPath);
 }
 
 /**

package/lib/utils/health-check.js

@@ -24,6 +24,7 @@ const {
   filterTraefikUrlByDns,
   logPublicHealthUrlWarningIfNeeded
 } = require('./health-check-public-warn');
+const { createHealthCheckPollHandlers } = require('./health-check-poll-ui');
 
 /**
  * Compute the health check URL for an app.
@@ -228,6 +229,13 @@ function buildHealthCheckConfig(healthCheckPort, config, timeout, debug) {
   return { maxAttempts };
 }
 
+function logHealthCheckSuccessIfAllowed() {
+  const { isSetupQuietOutput } = require('./setup-quiet-output');
+  if (!isSetupQuietOutput()) {
+    logger.log(formatSuccessLine('Application is healthy'));
+  }
+}
+
 /**
  * Performs a single health check attempt
  * @async
@@ -236,18 +244,24 @@ function buildHealthCheckConfig(healthCheckPort, config, timeout, debug) {
  * @param {number} attempt - Attempt number
  * @param {number} maxAttempts - Maximum attempts
  * @param {boolean} debug - Debug flag
+ * @param {{ suppressSuccessLog?: boolean }} [attemptOpts]
  * @returns {Promise<boolean>} True if health check passed
  */
-async function performHealthCheckAttempt(healthCheckUrl, attempt, maxAttempts, debug) {
+async function performHealthCheckAttempt(
+  healthCheckUrl,
+  attempt,
+  maxAttempts,
+  debug,
+  attemptOpts = {}
+) {
   try {
     if (debug) {
       logger.log(chalk.gray(`[DEBUG] Health check attempt ${attempt + 1}/${maxAttempts}`));
     }
     const healthCheckPassed = await checkHealthEndpoint(healthCheckUrl, debug);
     if (healthCheckPassed) {
-      const { isSetupQuietOutput } = require('./setup-quiet-output');
-      if (!isSetupQuietOutput()) {
-        logger.log(formatSuccessLine('Application is healthy'));
+      if (!attemptOpts.suppressSuccessLog) {
+        logHealthCheckSuccessIfAllowed();
       }
       if (debug) {
         logger.log(chalk.gray(`[DEBUG] Health check passed after ${attempt + 1} attempt(s)`));
@@ -287,7 +301,7 @@ async function computePreferredHealthCheckUrls(appName, healthCheckPort, config,
   skippedPublicHealthUrl = filtered.skippedPublicHealthUrl;
 
   const urlsToTry = traefikUrl ? [traefikUrl, localhostUrl] : [localhostUrl];
-  if (urlsToTry.length > 1) {
+  if (urlsToTry.length > 1 && debug) {
     logger.log(
       chalk.gray(
         `ℹ Health check order: Traefik/DNS (${urlsToTry[0]}), then localhost (${urlsToTry[1]}).`
@@ -300,10 +314,16 @@ async function computePreferredHealthCheckUrls(appName, healthCheckPort, config,
   return { urlsToTry, skippedPublicHealthUrl };
 }
 
-async function performHealthCheckAttemptForUrls(urlsToTry, attempt, maxAttempts, debug) {
+async function performHealthCheckAttemptForUrls(
+  urlsToTry,
+  attempt,
+  maxAttempts,
+  debug,
+  attemptOpts = {}
+) {
   for (let i = 0; i < urlsToTry.length; i++) {
     const url = urlsToTry[i];
-    const passed = await performHealthCheckAttempt(url, attempt, maxAttempts, debug);
+    const passed = await performHealthCheckAttempt(url, attempt, maxAttempts, debug, attemptOpts);
     if (passed) {
       return { ok: true, resolvedIndex: i };
     }
@@ -324,7 +344,7 @@ async function waitForHealthCheck(appName, timeout = 90, port = null, config = n
     debug
   );
 
-  if (skippedPublicHealthUrl && urlsToTry.length === 1) {
+  if (skippedPublicHealthUrl && urlsToTry.length === 1 && debug) {
     logger.log(
       chalk.gray(
         `ℹ Health check: public URL not used (DNS): ${skippedPublicHealthUrl}. ` +
@@ -333,9 +353,20 @@ async function waitForHealthCheck(appName, timeout = 90, port = null, config = n
     );
   }
 
+  const poll = createHealthCheckPollHandlers(maxAttempts);
+  const pollAttemptOpts = { suppressSuccessLog: true };
+
   for (let attempts = 0; attempts < maxAttempts; attempts++) {
-    const attemptResult = await performHealthCheckAttemptForUrls(urlsToTry, attempts, maxAttempts, debug);
+    const attemptResult = await performHealthCheckAttemptForUrls(
+      urlsToTry,
+      attempts,
+      maxAttempts,
+      debug,
+      pollAttemptOpts
+    );
     if (attemptResult.ok) {
+      poll.finish();
+      logHealthCheckSuccessIfAllowed();
       logPublicHealthUrlWarningIfNeeded({
         skippedPublicHealthUrl,
         urlsToTry,
@@ -345,17 +376,13 @@ async function waitForHealthCheck(appName, timeout = 90, port = null, config = n
     }
 
     if (attempts < maxAttempts - 1) {
-      const probeHint =
-        urlsToTry.length > 1
-          ? `trying ${urlsToTry[0]}, then ${urlsToTry[1]}`
-          : (urlsToTry[0] || 'health URL');
-      logger.log(
-        chalk.yellow(`Waiting for health check… (${attempts + 1}/${maxAttempts}) (${probeHint})`)
-      );
+      poll.onWaiting(attempts);
       await new Promise(resolve => setTimeout(resolve, 2000));
     }
   }
 
+  poll.finish();
+
   if (debug) {
     logger.log(chalk.gray(`[DEBUG] Health check failed after ${maxAttempts} attempts`));
   }

package/lib/utils/infra-optional-service-flags.js

@@ -9,6 +9,7 @@
 'use strict';
 
 const config = require('../core/config');
+const { flagsForSetupPlatformMode } = require('../core/setup-platform-mode');
 
 /**
  * Resolves effective boolean from CLI option vs config.
@@ -30,14 +31,40 @@ function resolveInfraOptionalFlag(optValue, cfgValue, defaultWhenUndef = true) {
  * @param {Object} [options] - Commander options (omit for setup-modes)
  * @returns {{ traefik: boolean, pgadmin: boolean, redisCommander: boolean }}
  */
+function topologyFlagsForConfig(cfg) {
+  if (!cfg || !cfg.setupPlatformMode) {
+    return null;
+  }
+  return flagsForSetupPlatformMode(cfg.setupPlatformMode);
+}
+
 function computeEffectiveInfraOptionalFlags(cfg, options = {}) {
+  const topology = topologyFlagsForConfig(cfg);
+  const traefikCandidate = resolveInfraOptionalFlag(options.traefik, cfg.traefik, false);
+  const traefik =
+    topology && !topology.traefik && options.traefik !== true ? false : traefikCandidate;
   return {
-    traefik: resolveInfraOptionalFlag(options.traefik, cfg.traefik, false),
+    traefik,
     pgadmin: resolveInfraOptionalFlag(options.pgAdmin, cfg.pgadmin, true),
     redisCommander: resolveInfraOptionalFlag(options.redisAdmin, cfg.redisCommander, true)
   };
 }
 
+/**
+ * Effective TLS flag for infra start: setup platform mode is authoritative when Traefik/TLS mode is off.
+ *
+ * @param {Object} cfg
+ * @param {Object} [options] - Commander options (`tls` / `--no-tls`)
+ * @returns {boolean}
+ */
+function resolveEffectiveTlsEnabled(cfg, options = {}) {
+  if (options.tls === true) return true;
+  if (options.tls === false) return false;
+  const topology = topologyFlagsForConfig(cfg);
+  if (topology && !topology.tlsEnabled) return false;
+  return cfg.tlsEnabled === true;
+}
+
 /**
  * Writes `traefik` / `pgadmin` / `redisCommander` when missing so config matches compose defaults.
  *
@@ -65,5 +92,7 @@ async function persistMissingInfraOptionalServiceFlags(cfg, effective) {
 module.exports = {
   resolveInfraOptionalFlag,
   computeEffectiveInfraOptionalFlags,
-  persistMissingInfraOptionalServiceFlags
+  resolveEffectiveTlsEnabled,
+  persistMissingInfraOptionalServiceFlags,
+  topologyFlagsForConfig
 };

package/lib/utils/mutagen.js

@@ -104,10 +104,13 @@ function getSyncSshUrl(syncSshUser, syncSshHost, remotePath) {
  * @returns {Promise<string[]>}
  */
 async function listSyncSessionNames(mutagenPath) {
-  const { stdout } = await execAsync(`"${mutagenPath}" sync list --template '{{.Name}}'`, {
-    encoding: 'utf8',
-    timeout: 5000
-  });
+  const { stdout } = await execAsync(
+    `"${mutagenPath}" sync list --template '{{range .}}{{.Name}}{{"\\n"}}{{end}}'`,
+    {
+      encoding: 'utf8',
+      timeout: 5000
+    }
+  );
   return (stdout || '').trim().split('\n').filter(Boolean);
 }
 

package/lib/utils/platform-controller-url.js

@@ -43,6 +43,25 @@ function loadBundledApplicationVariables(appName) {
   return variables && typeof variables === 'object' ? variables : null;
 }
 
+/**
+ * Merge platform routing defaults from bundled template when builder copy omits them.
+ *
+ * @param {string} appName
+ * @param {Object} variables
+ * @returns {Object}
+ */
+function mergeBundledPlatformRoutingDefaults(appName, variables) {
+  const bundled = loadBundledApplicationVariables(appName);
+  if (!bundled || typeof bundled !== 'object') {
+    return variables;
+  }
+  const merged = { ...variables };
+  if (!merged.frontDoorRouting && bundled.frontDoorRouting) {
+    merged.frontDoorRouting = bundled.frontDoorRouting;
+  }
+  return merged;
+}
+
 /**
  * Load platform app variables from materialized builder config, or from bundled template
  * when `aifabrix setup` runs before `up-platform` has copied templates.
@@ -55,7 +74,8 @@ function loadAppVariables(appName) {
   if (fs.existsSync(builderPath)) {
     try {
       const configPath = pathsUtil.resolveApplicationConfigPath(builderPath);
-      return loadConfigFile(configPath) || {};
+      const fromBuilder = loadConfigFile(configPath) || {};
+      return mergeBundledPlatformRoutingDefaults(appName, fromBuilder);
     } catch (err) {
       const msg = err && err.message ? String(err.message) : '';
       if (!msg.includes('Application config not found')) {
@@ -102,6 +122,7 @@ async function computeAppBaseUrl(appName) {
     typeof developerIdRaw === 'string' ? parseInt(developerIdRaw, 10) : developerIdRaw;
   const userCfg = await config.getConfig();
   const remoteServer = await config.getRemoteServer();
+  const developerRootDomain = await config.getDeveloperRootDomain();
   const infraTlsEnabled = Boolean(userCfg && userCfg.tlsEnabled);
   const setupPlatformMode = await config.getSetupPlatformMode();
 
@@ -117,6 +138,7 @@ async function computeAppBaseUrl(appName) {
     tls: fd ? fd.tls : true,
     developerIdRaw,
     remoteServer,
+    developerRootDomain,
     profile: 'docker',
     listenPort: basePort,
     developerIdNum,