@aifabrix/builder 2.48.0 → 2.49.0

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,

package/lib/utils/refresh-remote-settings.js

@@ -0,0 +1,67 @@
+/**
+ * Refresh ~/.aifabrix/config.yaml from GET /api/dev/settings when remote dev auth is available.
+ *
+ * @fileoverview Merge builder-server settings (developer-root-domain, sync paths, etc.)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const config = require('../core/config');
+const devApi = require('../api/dev.api');
+const { getRemoteDevAuth } = require('./remote-dev-auth');
+const { getCertDir, readClientKeyPem } = require('./dev-cert-helper');
+const { getConfigDirForPaths } = require('./paths');
+const logger = require('./logger');
+
+/**
+ * @typedef {Object} RefreshRemoteSettingsResult
+ * @property {boolean} refreshed
+ * @property {string} [reason]
+ * @property {Object} [settings]
+ * @property {Error} [error]
+ */
+
+/**
+ * Fetch GET /api/dev/settings and merge into config when remote-server + client cert exist.
+ *
+ * @async
+ * @param {{ quiet?: boolean }} [opts]
+ * @returns {Promise<RefreshRemoteSettingsResult>}
+ */
+async function refreshRemoteSettingsFromBuilderIfPossible(opts = {}) {
+  const quiet = opts.quiet !== false;
+  const auth = await getRemoteDevAuth();
+  if (!auth) {
+    return { refreshed: false, reason: 'no-remote-auth' };
+  }
+
+  const devId = await config.getDeveloperId();
+  const certDir = getCertDir(getConfigDirForPaths(), devId);
+  const clientKeyPem = readClientKeyPem(certDir);
+
+  try {
+    const settings = await devApi.getSettings(
+      auth.serverUrl,
+      auth.clientCertPem,
+      clientKeyPem || undefined,
+      auth.serverCaPem || undefined
+    );
+    await config.mergeRemoteSettings(settings);
+    if (!quiet) {
+      logger.log(chalk.gray('Synced developer settings from Builder Server'));
+    }
+    return { refreshed: true, settings };
+  } catch (error) {
+    if (!quiet) {
+      logger.warn(
+        chalk.yellow(`Could not refresh settings from Builder Server: ${error.message}`)
+      );
+    }
+    return { refreshed: false, reason: 'fetch-failed', error };
+  }
+}
+
+module.exports = { refreshRemoteSettingsFromBuilderIfPossible };

package/lib/utils/remote-host-for-front-door.js

@@ -0,0 +1,43 @@
+/**
+ * Resolve hostname for `${REMOTE_HOST}` in frontDoorRouting.host templates.
+ * Prefers `developer-root-domain` from builder-server settings over `remote-server` hostname.
+ *
+ * @fileoverview App public hostname root (separate from builder API host)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { hostnameFromUrl } = require('./config-paths');
+
+/**
+ * Hostname for `${REMOTE_HOST}` expansion (Traefik labels, url:// public, setup health).
+ *
+ * @param {Object} [input]
+ * @param {string|null|undefined} input.remoteServer - Builder API base URL
+ * @param {string|null|undefined} input.developerRootDomain - App hostname root from GET /api/dev/settings
+ * @returns {string}
+ */
+function resolveRemoteHostForFrontDoor(input = {}) {
+  const root = String(input.developerRootDomain || '').trim();
+  if (root) {
+    return root.replace(/^\.+|\.+$/g, '');
+  }
+  return hostnameFromUrl(input.remoteServer) || '';
+}
+
+/**
+ * Whether front-door host expansion can resolve `${REMOTE_HOST}` (root domain or remote-server).
+ *
+ * @param {Object} [input]
+ * @returns {boolean}
+ */
+function hasFrontDoorRemoteHostContext(input = {}) {
+  return Boolean(resolveRemoteHostForFrontDoor(input));
+}
+
+module.exports = {
+  resolveRemoteHostForFrontDoor,
+  hasFrontDoorRemoteHostContext
+};

package/lib/utils/run-cli-flags.js

@@ -24,6 +24,42 @@ function isRunCliNoProxy(options) {
   return options.noProxy === true;
 }
 
+/**
+ * Whether `aifabrix run` should persist `applications.<app>.proxy: true`.
+ * Proxy / front-door URL hints require infra Traefik (`traefik: true` in config).
+ * Direct-port (`setupPlatformMode: single`) always persists false even though Commander defaults `--proxy` on.
+ *
+ * @param {Object} [options] - Commander action options
+ * @param {Object|null|undefined} [userCfg] - Parsed `~/.aifabrix/config.yaml`
+ * @returns {boolean}
+ */
+function resolveRunProxyPersistEnabled(options, userCfg) {
+  if (isRunCliNoProxy(options)) {
+    return false;
+  }
+  return Boolean(userCfg && userCfg.traefik === true);
+}
+
+/**
+ * Effective no-proxy for env/url expansion during run.
+ *
+ * @param {Object} [options]
+ * @param {Object|null|undefined} [userCfg]
+ * @param {boolean} savedProxyHint - `applications.<app>.proxy` from config
+ * @returns {boolean}
+ */
+function resolveRunEffectiveNoProxy(options, userCfg, savedProxyHint) {
+  if (isRunCliNoProxy(options)) {
+    return true;
+  }
+  if (!userCfg || userCfg.traefik !== true) {
+    return true;
+  }
+  return !savedProxyHint;
+}
+
 module.exports = {
-  isRunCliNoProxy
+  isRunCliNoProxy,
+  resolveRunProxyPersistEnabled,
+  resolveRunEffectiveNoProxy
 };

package/lib/utils/url-declarative-public-base.js

@@ -9,6 +9,7 @@
 'use strict';
 
 const { expandFrontDoorHostPlaceholders } = require('./compose-generator');
+const { hasFrontDoorRemoteHostContext } = require('./remote-host-for-front-door');
 const { publishedHostPort, localHostPort } = require('./declarative-url-ports');
 const {
   normalizeSetupPlatformMode,
@@ -23,11 +24,12 @@ const { isLocalhostPublicSchemeHostname } = require('./localhost-public-host');
  * @param {Object} opts
  * @param {string|number|null|undefined} opts.developerIdRaw
  * @param {string|null|undefined} opts.remoteServer
+ * @param {string|null|undefined} [opts.developerRootDomain]
  * @returns {string}
  */
 function expandFrontDoorHostTemplateForUrls(template, opts) {
-  const { developerIdRaw, remoteServer } = opts || {};
-  return expandFrontDoorHostPlaceholders(template, developerIdRaw, remoteServer);
+  const { developerIdRaw, remoteServer, developerRootDomain } = opts || {};
+  return expandFrontDoorHostPlaceholders(template, developerIdRaw, remoteServer, developerRootDomain);
 }
 
 function hostPortForProfile(profile, listenPort, developerIdNum) {
@@ -174,6 +176,7 @@ function buildTraefikPublicBaseIfApplicable(opts) {
     hostTemplate,
     developerIdRaw,
     remoteServer,
+    developerRootDomain,
     profile,
     developerIdNum
   } = opts;
@@ -181,7 +184,10 @@ function buildTraefikPublicBaseIfApplicable(opts) {
   if (!traefik || !pathActive || !hostTemplate || !String(hostTemplate).trim()) {
     return null;
   }
-  if (templateUsesRemoteHostPlaceholder(hostTemplate) && !String(remoteServer || '').trim()) {
+  if (
+    templateUsesRemoteHostPlaceholder(hostTemplate) &&
+    !hasFrontDoorRemoteHostContext({ remoteServer, developerRootDomain })
+  ) {
     // Local full-platform (no remote domain): use the single localhost front door port (3000 + devId×100).
     return localhostFrontDoorBaseForMissingRemote({
       profile,
@@ -190,7 +196,8 @@ function buildTraefikPublicBaseIfApplicable(opts) {
   }
   const expanded = expandFrontDoorHostTemplateForUrls(hostTemplate, {
     developerIdRaw,
-    remoteServer
+    remoteServer,
+    developerRootDomain
   });
   if (!expanded) {
     return null;

package/lib/utils/url-declarative-resolve-build-urls.js

@@ -12,6 +12,7 @@ const {
   computePublicUrlBaseString,
   resolveHostPortForDeclarativePublic
 } = require('./url-declarative-public-base');
+const { hasFrontDoorRemoteHostContext } = require('./remote-host-for-front-door');
 
 /**
  * Join base URL origin with path segments (no duplicate slashes).
@@ -38,6 +39,7 @@ function buildPublicUrlString(opts) {
     listenPort,
     developerIdNum,
     remoteServer,
+    developerRootDomain,
     pathPrefix,
     patternPath,
     traefik,
@@ -57,6 +59,7 @@ function buildPublicUrlString(opts) {
     tls: tls !== false,
     developerIdRaw,
     remoteServer,
+    developerRootDomain,
     profile,
     listenPort,
     developerIdNum,
@@ -90,6 +93,7 @@ function buildPublicHostOriginString(opts) {
     listenPort,
     developerIdNum,
     remoteServer,
+    developerRootDomain,
     traefik,
     hostTemplate,
     tls,
@@ -107,6 +111,7 @@ function buildPublicHostOriginString(opts) {
     tls: tls !== false,
     developerIdRaw,
     remoteServer,
+    developerRootDomain,
     profile,
     listenPort,
     developerIdNum,
@@ -140,6 +145,7 @@ function buildInternalHostOriginString(opts) {
     listenPort,
     targetAppKey,
     remoteServer,
+    developerRootDomain,
     pathPrefix,
     patternPath,
     developerIdNum,
@@ -156,12 +162,13 @@ function buildInternalHostOriginString(opts) {
   if (profile === 'docker') {
     return `http://${targetAppKey}:${listenPort}`;
   }
-  if (remoteServer && String(remoteServer).trim()) {
+  if (hasFrontDoorRemoteHostContext({ remoteServer, developerRootDomain })) {
     const pub = buildPublicUrlString({
       profile: 'local',
       listenPort,
       developerIdNum,
       remoteServer,
+      developerRootDomain,
       pathPrefix,
       patternPath,
       traefik,
@@ -190,6 +197,7 @@ function buildInternalUrlString(opts) {
     targetAppKey,
     runtimeBasePath,
     remoteServer,
+    developerRootDomain,
     pathPrefix,
     patternPath,
     developerIdNum,
@@ -207,12 +215,13 @@ function buildInternalUrlString(opts) {
     const origin = `http://${targetAppKey}:${listenPort}`;
     return runtimeBasePath ? joinUrlPath(origin, runtimeBasePath) : origin;
   }
-  if (remoteServer && String(remoteServer).trim()) {
+  if (hasFrontDoorRemoteHostContext({ remoteServer, developerRootDomain })) {
     return buildPublicUrlString({
       profile: 'local',
       listenPort,
       developerIdNum,
       remoteServer,
+      developerRootDomain,
       pathPrefix,
       patternPath,
       traefik,