@aifabrix/builder 2.48.0 → 2.49.1

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 };
     }
@@ -311,31 +331,39 @@ async function performHealthCheckAttemptForUrls(urlsToTry, attempt, maxAttempts,
   return { ok: false, resolvedIndex: -1 };
 }
 
-async function waitForHealthCheck(appName, timeout = 90, port = null, config = null, debug = false, runOptions = {}) {
-  await waitForDbInit(appName);
-
-  const healthCheckPort = await determineHealthCheckPort(port, appName, debug);
-  const { maxAttempts } = buildHealthCheckConfig(healthCheckPort, config, timeout, debug);
-  const { urlsToTry, skippedPublicHealthUrl } = await computePreferredHealthCheckUrls(
-    appName,
-    healthCheckPort,
-    config,
-    runOptions,
-    debug
-  );
-
-  if (skippedPublicHealthUrl && urlsToTry.length === 1) {
-    logger.log(
-      chalk.gray(
-        `ℹ Health check: public URL not used (DNS): ${skippedPublicHealthUrl}. ` +
-          `Probing ${urlsToTry[0]} only until the app responds.`
-      )
-    );
+function resolveHealthCheckPollOptions(runOptions = {}) {
+  const pollOptions = {};
+  if (runOptions.silentPoll === true) {
+    pollOptions.silent = true;
+  }
+  if (typeof runOptions.onPollText === 'function') {
+    pollOptions.onPollText = runOptions.onPollText;
   }
+  return pollOptions;
+}
+
+async function pollUntilHealthCheckPasses({
+  urlsToTry,
+  maxAttempts,
+  timeout,
+  debug,
+  skippedPublicHealthUrl,
+  pollOptions = {}
+}) {
+  const poll = createHealthCheckPollHandlers(maxAttempts, pollOptions);
+  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,23 +373,51 @@ 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`));
   }
   throw new Error(`Health check timeout after ${timeout} seconds`);
 }
 
+async function waitForHealthCheck(appName, timeout = 90, port = null, config = null, debug = false, runOptions = {}) {
+  await waitForDbInit(appName);
+
+  const healthCheckPort = await determineHealthCheckPort(port, appName, debug);
+  const { maxAttempts } = buildHealthCheckConfig(healthCheckPort, config, timeout, debug);
+  const { urlsToTry, skippedPublicHealthUrl } = await computePreferredHealthCheckUrls(
+    appName,
+    healthCheckPort,
+    config,
+    runOptions,
+    debug
+  );
+
+  if (skippedPublicHealthUrl && urlsToTry.length === 1 && debug) {
+    logger.log(
+      chalk.gray(
+        `ℹ Health check: public URL not used (DNS): ${skippedPublicHealthUrl}. ` +
+          `Probing ${urlsToTry[0]} only until the app responds.`
+      )
+    );
+  }
+
+  await pollUntilHealthCheckPasses({
+    urlsToTry,
+    maxAttempts,
+    timeout,
+    debug,
+    skippedPublicHealthUrl,
+    pollOptions: resolveHealthCheckPollOptions(runOptions)
+  });
+}
+
 /**
  * Checks if port is available
  * @param {number} port - Port number to check

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

@@ -459,13 +459,23 @@ function isSystemBuilderAppName(appName) {
 }
 
 /**
- * `builder/<appName>` under {@link getAppsMaterializationParent} (same tree as {@link getSystemBuilderRoot}).
+ * Home / work materialization path: `(aifabrix-work | aifabrix-home)/builder/<appName>`.
+ * Used by setup, teardown, and template copy — never the product-repo `cwd/builder` tree.
  *
  * @param {string} appName
  * @returns {string}
  */
+function getHomeBuilderAppPath(appName) {
+  return path.join(getAppsMaterializationParent(), 'builder', appName);
+}
+
+/**
+ * @deprecated Prefer {@link getHomeBuilderAppPath}; same path.
+ * @param {string} appName
+ * @returns {string}
+ */
 function getProjectBuilderAppPath(appName) {
-  return path.join(getIntegrationBuilderBaseDir(), 'builder', appName);
+  return getHomeBuilderAppPath(appName);
 }
 
 /**
@@ -630,38 +640,25 @@ function resolveBuildContext(configDir, buildContext) {
 }
 
 /**
- * `cwd/builder/<appName>` when present as a directory and allowed (platform empty stubs skipped).
+ * `cwd/builder/<appName>` when the running folder has a resolvable application manifest.
  *
  * @param {string} appName
  * @returns {string|null}
  */
-function tryCwdBuilderPathOrNull(appName) {
-  const cwdApp = path.join(path.resolve(process.cwd()), 'builder', appName);
-  try {
-    if (!nodeFs().existsSync(cwdApp)) {
-      return null;
-    }
-    const st = nodeFs().statSync(cwdApp);
-    if (!st || typeof st.isDirectory !== 'function' || !st.isDirectory()) {
-      return null;
-    }
-    if (isSystemBuilderAppName(appName) && !isProjectBuilderAppDirectory(cwdApp)) {
-      return null;
-    }
-    return cwdApp;
-  } catch {
+function getCwdBuilderAppPath(appName) {
+  if (!appName || typeof appName !== 'string') {
     return null;
   }
+  const cwdApp = path.join(path.resolve(process.cwd()), 'builder', appName);
+  return isProjectBuilderAppDirectory(cwdApp) ? cwdApp : null;
 }
 
 /**
- * Gets the builder folder path:
- * 1. Plan 141 Tier‑1: `cwd/builder/<app>` or `cwd/integration/<app>` when a resolvable application manifest exists.
- * 2. Else **`cwd/builder/<app>`** when that directory exists. For **platform** apps (`keycloak`,
- *    `miso-controller`, `dataplane`), an **empty** cwd stub is ignored so materialization under
- *    `(work|home)/builder` still wins.
- * 3. Else **`(aifabrix-work or aifabrix-home)/builder/<appName>`** — used by setup / `up-platform` /
- *    `up-miso` / `up-dataplane` for template materialization.
+ * Gets the builder folder path for run/deploy/register:
+ * 1. **`cwd/builder/<app>`** when a resolvable application manifest exists in the running folder.
+ * 2. Else **`(aifabrix-work | aifabrix-home)/builder/<app>`** (setup materializes templates there).
+ *
+ * Teardown and setup `--force` clean use {@link getHomeBuilderAppPath} only (never product-repo trees).
  *
  * @param {string} appName - Application name
  * @returns {string} Absolute path to builder directory
@@ -670,20 +667,11 @@ function getBuilderPath(appName) {
   if (!appName || typeof appName !== 'string') {
     throw new Error('App name is required and must be a string');
   }
-  const { resolveApplicationManifestPathSync } = require('./manifest-location');
-  const manifestHit = resolveApplicationManifestPathSync({
-    targetKey: appName,
-    mode: 'auto',
-    cwd: process.cwd()
-  });
-  if (manifestHit && (manifestHit.tier === 'cwd-builder' || manifestHit.tier === 'cwd-integration')) {
-    return manifestHit.absolutePath;
-  }
-  const cwdHit = tryCwdBuilderPathOrNull(appName);
+  const cwdHit = getCwdBuilderAppPath(appName);
   if (cwdHit) {
     return cwdHit;
   }
-  return path.join(getAppsMaterializationParent(), 'builder', appName);
+  return getHomeBuilderAppPath(appName);
 }
 
 /**
@@ -918,6 +906,8 @@ module.exports = {
   getIntegrationBuilderBaseDir,
   SYSTEM_BUILDER_APP_KEYS,
   isSystemBuilderAppName,
+  getHomeBuilderAppPath,
+  getCwdBuilderAppPath,
   getProjectBuilderAppPath,
   getSystemPlatformMaterializationParent,
   getSystemBuilderRoot,

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;