@aifabrix/builder 2.43.0 → 2.44.1

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

@@ -0,0 +1,188 @@
+/**
+ * Public URL base for url:// expansion when Traefik + frontDoorRouting.host (plan 122 phase 2).
+ *
+ * @fileoverview Traefik host template vs remote-server vs localhost+port (no app-specific rules)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { expandFrontDoorHostPlaceholders } = require('./compose-generator');
+const { publishedHostPort, localHostPort } = require('./declarative-url-ports');
+
+/**
+ * Expand frontDoorRouting.host placeholders for url:// (same rules as Traefik labels in compose-generator).
+ *
+ * @param {string} template
+ * @param {Object} opts
+ * @param {string|number|null|undefined} opts.developerIdRaw
+ * @param {string|null|undefined} opts.remoteServer
+ * @returns {string}
+ */
+function expandFrontDoorHostTemplateForUrls(template, opts) {
+  const { developerIdRaw, remoteServer } = opts || {};
+  return expandFrontDoorHostPlaceholders(template, developerIdRaw, remoteServer);
+}
+
+function hostPortForProfile(profile, listenPort, developerIdNum) {
+  return profile === 'docker'
+    ? publishedHostPort(listenPort, developerIdNum)
+    : localHostPort(listenPort, developerIdNum);
+}
+
+/**
+ * Local profile: workstation `+10` applies only to the app being resolved (`currentAppKey`).
+ * Cross-app tokens (e.g. `url://keycloak-public` from miso-controller) use `publishedHostPort`
+ * (manifest + dev*100, no +10) so sibling services keep compose-published offsets only.
+ *
+ * @param {Object} opts
+ * @param {'docker'|'local'} opts.profile
+ * @param {number} opts.listenPort - published/manifest basis for public URLs
+ * @param {number} opts.developerIdNum
+ * @param {string|undefined} opts.declarativeTargetAppKey - target of the url:// token
+ * @param {string|undefined} opts.declarativeCurrentAppKey - app whose env is being generated
+ * @returns {number}
+ */
+function resolveHostPortForDeclarativePublic(opts) {
+  const {
+    profile,
+    listenPort,
+    developerIdNum,
+    declarativeTargetAppKey,
+    declarativeCurrentAppKey
+  } = opts;
+  if (profile !== 'local') {
+    return hostPortForProfile(profile, listenPort, developerIdNum);
+  }
+  const cur = String(declarativeCurrentAppKey || '').trim();
+  const tgt = String(declarativeTargetAppKey || '').trim();
+  const isCurrentApp = !cur || !tgt || tgt === cur;
+  return isCurrentApp ? localHostPort(listenPort, developerIdNum) : publishedHostPort(listenPort, developerIdNum);
+}
+
+/**
+ * Without Traefik, `remote-server` is the dev machine host. Apps bind published host ports, not 443 + path.
+ * If the URL already has an explicit port, keep host:port but **scheme follows `infraTlsEnabled`**, not the
+ * literal `https://` in `remote-server` when TLS is off (`up-infra` without `--tls`).
+ * If `remote-server` omits a port, append the profile-specific published/listen-derived port.
+ *
+ * @param {string} rawRemote
+ * @param {'docker'|'local'} profile
+ * @param {number} listenPort
+ * @param {number} developerIdNum
+ * @param {boolean} infraTlsEnabled
+ * @returns {string}
+ */
+function remotePublicBaseWithoutTraefik(
+  rawRemote,
+  profile,
+  listenPort,
+  developerIdNum,
+  infraTlsEnabled,
+  declarativePortOpts
+) {
+  const raw = String(rawRemote || '').trim().replace(/\/+$/, '');
+  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(raw) ? raw : (infraTlsEnabled ? `https://${raw}` : `http://${raw}`);
+  const u = new URL(withScheme);
+  const scheme = infraTlsEnabled ? 'https' : 'http';
+
+  if (u.port !== '') {
+    return `${scheme}://${u.host}`;
+  }
+
+  const hostPort = resolveHostPortForDeclarativePublic({
+    profile,
+    listenPort,
+    developerIdNum,
+    declarativeTargetAppKey: declarativePortOpts && declarativePortOpts.declarativeTargetAppKey,
+    declarativeCurrentAppKey: declarativePortOpts && declarativePortOpts.declarativeCurrentAppKey
+  });
+  const defaultPort = scheme === 'https' ? 443 : 80;
+  if (Number(hostPort) === defaultPort) {
+    return `${scheme}://${u.hostname}`;
+  }
+  return `${scheme}://${u.hostname}:${hostPort}`;
+}
+
+/**
+ * @param {Object} opts - same shape as computePublicUrlBaseString
+ * @returns {string|null}
+ */
+function buildTraefikPublicBaseIfApplicable(opts) {
+  const { traefik, pathActive, hostTemplate, tls, developerIdRaw, remoteServer, infraTlsEnabled } =
+    opts;
+  // Plan 124: Traefik host authority only when pathActive (traefik ∧ frontDoorRouting.enabled)
+  if (!traefik || !pathActive || !hostTemplate || !String(hostTemplate).trim()) {
+    return null;
+  }
+  const expanded = expandFrontDoorHostTemplateForUrls(hostTemplate, {
+    developerIdRaw,
+    remoteServer
+  });
+  if (!expanded) {
+    return null;
+  }
+  const useHttps = Boolean(infraTlsEnabled) || tls !== false;
+  const scheme = useHttps ? 'https' : 'http';
+  return `${scheme}://${expanded}`.replace(/\/+$/, '');
+}
+
+/**
+ * Scheme + authority (no path) for public url://* when Traefik, remote, or localhost.
+ *
+ * @param {Object} opts
+ * @param {boolean} [opts.traefik]
+ * @param {string|null|undefined} opts.hostTemplate
+ * @param {boolean} [opts.tls]
+ * @param {string|number|null|undefined} opts.developerIdRaw
+ * @param {string|null|undefined} opts.remoteServer
+ * @param {'docker'|'local'} opts.profile
+ * @param {number} opts.listenPort
+ * @param {number} opts.developerIdNum
+ * @param {boolean} [opts.infraTlsEnabled] - `tlsEnabled` from ~/.aifabrix/config.yaml (`up-infra --tls`); when true, Traefik front-door public URLs use https even if application.yaml has `frontDoorRouting.tls: false`
+ * @param {boolean} [opts.pathActive] - traefik ∧ frontDoorRouting.enabled; required for Traefik host branch (plan 124)
+ * @returns {string}
+ */
+function computePublicUrlBaseString(opts) {
+  const { remoteServer, profile, listenPort, developerIdNum, infraTlsEnabled } = opts;
+  const declarativePortOpts = {
+    declarativeTargetAppKey: opts.declarativeTargetAppKey,
+    declarativeCurrentAppKey: opts.declarativeCurrentAppKey
+  };
+
+  const traefikBase = buildTraefikPublicBaseIfApplicable({
+    ...opts,
+    pathActive: Boolean(opts.pathActive)
+  });
+  if (traefikBase) {
+    return traefikBase;
+  }
+
+  if (remoteServer && String(remoteServer).trim()) {
+    return remotePublicBaseWithoutTraefik(
+      remoteServer,
+      profile,
+      listenPort,
+      developerIdNum,
+      Boolean(infraTlsEnabled),
+      declarativePortOpts
+    );
+  }
+
+  const hostPort = resolveHostPortForDeclarativePublic({
+    profile,
+    listenPort,
+    developerIdNum,
+    declarativeTargetAppKey: declarativePortOpts.declarativeTargetAppKey,
+    declarativeCurrentAppKey: declarativePortOpts.declarativeCurrentAppKey
+  });
+  const scheme = infraTlsEnabled ? 'https' : 'http';
+  return `${scheme}://localhost:${hostPort}`;
+}
+
+module.exports = {
+  expandFrontDoorHostTemplateForUrls,
+  computePublicUrlBaseString,
+  resolveHostPortForDeclarativePublic
+};

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

@@ -0,0 +1,493 @@
+/**
+ * URL string builders and token expansion for declarative url:// resolution (plan 122).
+ *
+ * @fileoverview Split from url-declarative-resolve.js for ESLint max-lines limits
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { getRegistryEntryForApp } = require('./urls-local-registry');
+const { DECLARATIVE_URL_INFRA_DEFAULTS } = require('./infra-env-defaults');
+const { getContainerPort, getLocalPort } = require('./port-resolver');
+const pathsUtil = require('./paths');
+const {
+  computePublicUrlBaseString,
+  resolveHostPortForDeclarativePublic
+} = require('./url-declarative-public-base');
+const { computePathActive } = require('./url-declarative-url-flags');
+const { loadApplicationYamlDocForUrlResolve } = require('./url-declarative-resolve-load-doc');
+const { parseUrlToken } = require('./url-declarative-token-parse');
+
+/**
+ * Plan 122: **Developer subdomain `devNN` + remote hostname is not derived from envKey `tst`.** It comes only from
+ * expanding **`frontDoorRouting.host`** (e.g. `${DEV_USERNAME}.${REMOTE_HOST}`) when **`traefik`** is on.
+ * Kept as a no-op for backward compatibility; callers must not rely on tst-based host mutation.
+ *
+ * @param {string} absoluteUrl
+ * @returns {string}
+ */
+function applyTstRemoteDeveloperHost(absoluteUrl) {
+  return absoluteUrl;
+}
+
+/**
+ * @param {string} origin
+ * @returns {string}
+ */
+function applyTstRemoteDeveloperHostToOrigin(origin) {
+  return origin;
+}
+
+/**
+ * Join base URL origin with path segments (no duplicate slashes).
+ * @param {string} originOrBase - https://host or https://host:port
+ * @param {string} suffixPath - /dev/data
+ * @returns {string}
+ */
+function joinUrlPath(originOrBase, suffixPath) {
+  const base = String(originOrBase || '').replace(/\/+$/, '');
+  let suf = suffixPath || '';
+  if (!suf.startsWith('/')) {
+    suf = `/${suf}`;
+  }
+  return `${base}${suf}`.replace(/([^:]\/)\/+/g, '$1');
+}
+
+/**
+ * @param {Object} opts
+ * @returns {string}
+ */
+function buildPublicUrlString(opts) {
+  const {
+    profile,
+    listenPort,
+    developerIdNum,
+    remoteServer,
+    pathPrefix,
+    patternPath,
+    traefik,
+    hostTemplate,
+    tls,
+    developerIdRaw,
+    infraTlsEnabled,
+    frontDoorIngressActive,
+    declarativeTargetAppKey,
+    declarativeCurrentAppKey
+  } = opts;
+  const base = computePublicUrlBaseString({
+    traefik: Boolean(traefik),
+    pathActive: Boolean(frontDoorIngressActive),
+    hostTemplate: hostTemplate || null,
+    tls: tls !== false,
+    developerIdRaw,
+    remoteServer,
+    profile,
+    listenPort,
+    developerIdNum,
+    infraTlsEnabled: Boolean(infraTlsEnabled),
+    declarativeTargetAppKey,
+    declarativeCurrentAppKey
+  });
+  const patternSegment =
+    frontDoorIngressActive === false
+      ? ''
+      : patternPath === '/' || patternPath === ''
+        ? ''
+        : patternPath;
+  const rawSuffix = `${pathPrefix}${patternSegment}`.replace(/\/{2,}/g, '/');
+  if (!rawSuffix || rawSuffix === '/') {
+    return String(base).replace(/\/+$/, '');
+  }
+  const normalizedSuffix = rawSuffix.startsWith('/') ? rawSuffix : `/${rawSuffix}`;
+  return joinUrlPath(base, normalizedSuffix);
+}
+
+/**
+ * Public reachability origin only (no env path prefix, no front-door pattern path).
+ * @param {Object} opts
+ * @returns {string}
+ */
+function buildPublicHostOriginString(opts) {
+  const {
+    profile,
+    listenPort,
+    developerIdNum,
+    remoteServer,
+    traefik,
+    hostTemplate,
+    tls,
+    developerIdRaw,
+    infraTlsEnabled,
+    frontDoorIngressActive,
+    declarativeTargetAppKey,
+    declarativeCurrentAppKey
+  } = opts;
+  const base = computePublicUrlBaseString({
+    traefik: Boolean(traefik),
+    pathActive: Boolean(frontDoorIngressActive),
+    hostTemplate: hostTemplate || null,
+    tls: tls !== false,
+    developerIdRaw,
+    remoteServer,
+    profile,
+    listenPort,
+    developerIdNum,
+    infraTlsEnabled: Boolean(infraTlsEnabled),
+    declarativeTargetAppKey,
+    declarativeCurrentAppKey
+  });
+  try {
+    return new URL(base).origin;
+  } catch {
+    const hostPort = resolveHostPortForDeclarativePublic({
+      profile,
+      listenPort,
+      developerIdNum,
+      declarativeTargetAppKey,
+      declarativeCurrentAppKey
+    });
+    return `http://localhost:${hostPort}`;
+  }
+}
+
+/**
+ * Internal service origin only (scheme + host + port), no path suffix.
+ * @param {Object} opts
+ * @returns {string}
+ */
+function buildInternalHostOriginString(opts) {
+  const {
+    profile,
+    listenPort,
+    targetAppKey,
+    remoteServer,
+    pathPrefix,
+    patternPath,
+    developerIdNum,
+    traefik,
+    hostTemplate,
+    tls,
+    developerIdRaw,
+    infraTlsEnabled,
+    frontDoorIngressActive,
+    declarativeTargetAppKey,
+    declarativeCurrentAppKey
+  } = opts;
+  if (profile === 'docker') {
+    return `http://${targetAppKey}:${listenPort}`;
+  }
+  if (remoteServer && String(remoteServer).trim()) {
+    const pub = buildPublicUrlString({
+      profile: 'local',
+      listenPort,
+      developerIdNum,
+      remoteServer,
+      pathPrefix,
+      patternPath,
+      traefik,
+      hostTemplate,
+      tls,
+      developerIdRaw,
+      infraTlsEnabled,
+      frontDoorIngressActive,
+      declarativeTargetAppKey: declarativeTargetAppKey || targetAppKey,
+      declarativeCurrentAppKey: declarativeCurrentAppKey
+    });
+    try {
+      return new URL(pub).origin;
+    } catch {
+      return `http://${targetAppKey}:${listenPort}`;
+    }
+  }
+  return `http://${targetAppKey}:${listenPort}`;
+}
+
+function buildInternalUrlString(opts) {
+  const {
+    profile,
+    listenPort,
+    targetAppKey,
+    remoteServer,
+    pathPrefix,
+    patternPath,
+    developerIdNum,
+    traefik,
+    hostTemplate,
+    tls,
+    developerIdRaw,
+    infraTlsEnabled,
+    frontDoorIngressActive,
+    declarativeTargetAppKey,
+    declarativeCurrentAppKey
+  } = opts;
+  if (profile === 'docker') {
+    return `http://${targetAppKey}:${listenPort}`;
+  }
+  if (remoteServer && String(remoteServer).trim()) {
+    return buildPublicUrlString({
+      profile: 'local',
+      listenPort,
+      developerIdNum,
+      remoteServer,
+      pathPrefix,
+      patternPath,
+      traefik,
+      hostTemplate,
+      tls,
+      developerIdRaw,
+      infraTlsEnabled,
+      frontDoorIngressActive,
+      declarativeTargetAppKey: declarativeTargetAppKey || targetAppKey,
+      declarativeCurrentAppKey: declarativeCurrentAppKey
+    });
+  }
+  return `http://${targetAppKey}:${listenPort}`;
+}
+
+/**
+ * @param {object|null|undefined} doc
+ * @returns {{ hostTemplate: string|null, tls: boolean }}
+ */
+function readFrontDoorHostTlsFromDoc(doc) {
+  if (!doc || !doc.frontDoorRouting) {
+    return { hostTemplate: null, tls: true };
+  }
+  const fd = doc.frontDoorRouting;
+  const hostTemplate =
+    typeof fd.host === 'string' && fd.host.trim() ? fd.host.trim() : null;
+  return { hostTemplate, tls: fd.tls !== false };
+}
+
+/**
+ * Ports from application.yaml: `listenPort` = container/process listen ({@link getContainerPort});
+ * `publicPortBasis` = manifest root `port` ({@link getLocalPort}) for browser-published host URLs
+ * (url://host-public, url://public origin) when Traefik is not serving the app — not the internal
+ * container port (e.g. Keycloak 8082 published vs 8080 in-container).
+ *
+ * @param {object|null|undefined} doc
+ * @param {{ port: number, containerPort: number|null, pattern: string }|null} entry
+ * @returns {{ listenPort: number, publicPortBasis: number, patternStr: string }|null}
+ */
+function resolveListenPortAndPatternFromDoc(doc, entry) {
+  if (doc) {
+    const listenPort = getContainerPort(doc);
+    const publicPortBasis = getLocalPort(doc);
+    const raw = doc.frontDoorRouting && doc.frontDoorRouting.pattern;
+    const patternStr =
+      typeof raw === 'string'
+        ? raw
+        : entry && typeof entry.pattern === 'string'
+          ? entry.pattern
+          : DECLARATIVE_URL_INFRA_DEFAULTS.frontDoorPatternWhenUnspecified;
+    return { listenPort, publicPortBasis, patternStr };
+  }
+  if (entry) {
+    const c = entry.containerPort;
+    const listenPort = typeof c === 'number' && c > 0 ? c : entry.port;
+    return { listenPort, publicPortBasis: entry.port, patternStr: entry.pattern };
+  }
+  return null;
+}
+
+/**
+ * Port + pattern + optional Traefik host template for a url:// token.
+ * @param {string} token
+ * @param {Object} ctx
+ * @param {Object} registry
+ * @returns {{ appKey: string, listenPort: number, publicPortBasis: number, patternStr: string, hostTemplate: string|null, tls: boolean, frontDoorIngressActive: boolean }|null}
+ */
+function resolveListenPortPatternForToken(token, ctx, registry) {
+  const { targetKey } = parseUrlToken(token);
+  const currentAppKey = ctx.currentAppKey || '';
+  const appKey = targetKey || currentAppKey;
+  if (!appKey) {
+    return null;
+  }
+  const doc = loadApplicationYamlDocForUrlResolve(appKey, ctx, pathsUtil);
+  const entry = getRegistryEntryForApp(appKey, registry);
+  const portPattern = resolveListenPortAndPatternFromDoc(doc, entry);
+  if (!portPattern) {
+    return null;
+  }
+  const { listenPort, publicPortBasis, patternStr } = portPattern;
+  const meta = readFrontDoorHostTlsFromDoc(doc);
+  const frontDoorIngressActive = computePathActive(
+    Boolean(ctx.traefik),
+    Boolean(doc && doc.frontDoorRouting && doc.frontDoorRouting.enabled === true)
+  );
+  return {
+    appKey,
+    listenPort,
+    publicPortBasis,
+    patternStr,
+    hostTemplate: meta.hostTemplate,
+    tls: meta.tls,
+    frontDoorIngressActive
+  };
+}
+
+/**
+ * Published/browser origin port basis for url:// public surfaces (manifest `port`), not container listen.
+ * @param {Object} r
+ * @returns {number}
+ */
+function publishedOriginPortBasis(r) {
+  const b = r.publicPortBasis;
+  if (b !== undefined && b !== null && Number.isFinite(Number(b))) {
+    return Number(b);
+  }
+  return r.listenPort;
+}
+
+/**
+ * @param {Object} r - resolved app + patternPath + pathPrefix + remoteServer + profile + devNum + derivedEnvKey
+ * @returns {string}
+ */
+function expandHostSurfacePublic(r) {
+  return buildPublicHostOriginString({
+    profile: r.profile,
+    listenPort: publishedOriginPortBasis(r),
+    developerIdNum: r.devNum,
+    remoteServer: r.remoteServer,
+    traefik: r.traefik,
+    hostTemplate: r.hostTemplate,
+    tls: r.tls,
+    developerIdRaw: r.developerIdRaw,
+    infraTlsEnabled: r.infraTlsEnabled,
+    frontDoorIngressActive: r.frontDoorIngressActive,
+    declarativeTargetAppKey: r.appKey,
+    declarativeCurrentAppKey: r.currentAppKey
+  });
+}
+
+/**
+ * Local workstation `.env` (no remote-server): browser-reachable URLs only — internal tokens match public.
+ * Remote dev keeps internal = public mirroring via {@link buildInternalUrlString} when `remoteServer` is set.
+ *
+ * @param {Object} r
+ * @returns {boolean}
+ */
+function isLocalProfileWithoutRemoteServer(r) {
+  return r.profile === 'local' && !String(r.remoteServer || '').trim();
+}
+
+/**
+ * @param {Object} r
+ * @returns {string}
+ */
+function expandHostSurfaceInternal(r) {
+  if (isLocalProfileWithoutRemoteServer(r)) {
+    return expandHostSurfacePublic(r);
+  }
+  return buildInternalHostOriginString({
+    profile: r.profile,
+    listenPort: r.listenPort,
+    targetAppKey: r.appKey,
+    remoteServer: r.remoteServer,
+    pathPrefix: r.pathPrefix,
+    patternPath: r.patternPath,
+    developerIdNum: r.devNum,
+    derivedEnvKey: r.derivedEnvKey,
+    traefik: r.traefik,
+    hostTemplate: r.hostTemplate,
+    tls: r.tls,
+    developerIdRaw: r.developerIdRaw,
+    infraTlsEnabled: r.infraTlsEnabled,
+    frontDoorIngressActive: r.frontDoorIngressActive,
+    declarativeTargetAppKey: r.appKey,
+    declarativeCurrentAppKey: r.currentAppKey
+  });
+}
+
+/**
+ * @param {Object} r
+ * @returns {string}
+ */
+function expandFullSurfacePublic(r) {
+  return buildPublicUrlString({
+    profile: r.profile,
+    listenPort: publishedOriginPortBasis(r),
+    developerIdNum: r.devNum,
+    remoteServer: r.remoteServer,
+    pathPrefix: r.pathPrefix,
+    patternPath: r.patternPath,
+    traefik: r.traefik,
+    hostTemplate: r.hostTemplate,
+    tls: r.tls,
+    developerIdRaw: r.developerIdRaw,
+    infraTlsEnabled: r.infraTlsEnabled,
+    frontDoorIngressActive: r.frontDoorIngressActive,
+    declarativeTargetAppKey: r.appKey,
+    declarativeCurrentAppKey: r.currentAppKey
+  });
+}
+
+/**
+ * @param {Object} r
+ * @returns {string}
+ */
+function expandFullSurfaceInternal(r) {
+  if (isLocalProfileWithoutRemoteServer(r)) {
+    return expandFullSurfacePublic(r);
+  }
+  return buildInternalUrlString({
+    profile: r.profile,
+    listenPort: r.listenPort,
+    targetAppKey: r.appKey,
+    remoteServer: r.remoteServer,
+    pathPrefix: r.pathPrefix,
+    patternPath: r.patternPath,
+    developerIdNum: r.devNum,
+    derivedEnvKey: r.derivedEnvKey,
+    traefik: r.traefik,
+    hostTemplate: r.hostTemplate,
+    tls: r.tls,
+    developerIdRaw: r.developerIdRaw,
+    infraTlsEnabled: r.infraTlsEnabled,
+    frontDoorIngressActive: r.frontDoorIngressActive,
+    declarativeTargetAppKey: r.appKey,
+    declarativeCurrentAppKey: r.currentAppKey
+  });
+}
+
+/**
+ * @param {{ kind: string, surface: string }} parsed
+ * @param {Object} r
+ * @returns {string}
+ */
+function expandResolvedUrlToken(parsed, r) {
+  if (parsed.surface === 'vdir') {
+    if (!r.frontDoorIngressActive) {
+      return '';
+    }
+    // Plan 124: docker PRIVATEVDIR is always empty; public vdir still carries pattern
+    if (parsed.kind === 'internal' && r.profile === 'docker') {
+      return '';
+    }
+    const prefix = String(r.pathPrefix || '');
+    const pat = r.patternPath || '/';
+    if (!pat || pat === '/') {
+      return prefix || '';
+    }
+    const joined = `${prefix}${pat}`.replace(/\/{2,}/g, '/');
+    return joined.startsWith('/') ? joined : `/${joined}`;
+  }
+  if (parsed.surface === 'host') {
+    return parsed.kind === 'public' ? expandHostSurfacePublic(r) : expandHostSurfaceInternal(r);
+  }
+  return parsed.kind === 'public' ? expandFullSurfacePublic(r) : expandFullSurfaceInternal(r);
+}
+
+module.exports = {
+  applyTstRemoteDeveloperHost,
+  applyTstRemoteDeveloperHostToOrigin,
+  buildPublicUrlString,
+  buildPublicHostOriginString,
+  buildInternalUrlString,
+  buildInternalHostOriginString,
+  parseUrlToken,
+  expandResolvedUrlToken,
+  resolveListenPortPatternForToken
+};