@aifabrix/builder 2.47.0 → 2.47.2

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

@@ -0,0 +1,114 @@
+/**
+ * HTTP(S) health probe request helpers.
+ *
+ * @fileoverview Low-level health endpoint HTTP client
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const http = require('http');
+const https = require('https');
+const chalk = require('chalk');
+const logger = require('./logger');
+const { shouldAllowInsecureDevPlatformTls } = require('./dev-platform-tls');
+
+/**
+ * @param {string} data
+ * @param {number} statusCode
+ * @returns {boolean}
+ */
+function parseHealthResponse(data, statusCode) {
+  try {
+    const health = JSON.parse(data);
+    if (health.status === 'UP') {
+      return true;
+    }
+    if (health.status === 'ok') {
+      return health.database === 'connected' || !health.database;
+    }
+    if (health.status === 'healthy') {
+      return true;
+    }
+    if (health.success === true) {
+      return true;
+    }
+    return false;
+  } catch {
+    return statusCode === 200;
+  }
+}
+
+function handleHealthResponse(res, data, debug, resolve) {
+  const isHealthy = parseHealthResponse(data, res.statusCode);
+  if (debug) {
+    const truncatedData = data.length > 200 ? data.substring(0, 200) + '...' : data;
+    logger.log(chalk.gray(`[DEBUG] Response body: ${truncatedData}`));
+    logger.log(chalk.gray(`[DEBUG] Health check result: ${isHealthy ? 'healthy' : 'unhealthy'}`));
+  }
+  resolve(isHealthy);
+}
+
+function doHealthCheckRequest(healthCheckUrl, debug, resolve, reject, allowInsecureTls = false) {
+  try {
+    const urlObj = new URL(healthCheckUrl);
+    const transport = urlObj.protocol === 'https:' ? https : http;
+    const options = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
+      path: urlObj.pathname + urlObj.search,
+      method: 'GET',
+      ...(allowInsecureTls ? { rejectUnauthorized: false } : {})
+    };
+    if (debug) {
+      logger.log(chalk.gray(`[DEBUG] Health check request: ${healthCheckUrl}`));
+      logger.log(chalk.gray(`[DEBUG] Request options: ${JSON.stringify(options, null, 2)}`));
+    }
+    const timer = { id: null };
+    const req = transport.request(options, (res) => {
+      clearTimeout(timer.id);
+      let data = '';
+      if (debug) {
+        logger.log(chalk.gray(`[DEBUG] Response status code: ${res.statusCode}`));
+        logger.log(chalk.gray(`[DEBUG] Response headers: ${JSON.stringify(res.headers, null, 2)}`));
+      }
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+      res.on('end', () => handleHealthResponse(res, data, debug, resolve));
+    });
+    timer.id = setTimeout(() => {
+      if (debug) logger.log(chalk.gray('[DEBUG] Health check request timeout after 5 seconds'));
+      req.destroy();
+      resolve(false);
+    }, 5000);
+    req.on('error', (error) => {
+      clearTimeout(timer.id);
+      if (debug) logger.log(chalk.gray(`[DEBUG] Health check request error: ${error.message}`));
+      resolve(false);
+    });
+    req.end();
+  } catch (error) {
+    if (debug) logger.log(chalk.gray(`[DEBUG] Health check exception: ${error.message}`));
+    reject(error);
+  }
+}
+
+/**
+ * @async
+ * @param {string} healthCheckUrl
+ * @param {boolean} [debug=false]
+ * @returns {Promise<boolean>}
+ */
+async function checkHealthEndpoint(healthCheckUrl, debug = false) {
+  const allowInsecureTls = await shouldAllowInsecureDevPlatformTls(healthCheckUrl);
+  return new Promise((resolve, reject) => {
+    doHealthCheckRequest(healthCheckUrl, debug, resolve, reject, allowInsecureTls);
+  });
+}
+
+module.exports = {
+  parseHealthResponse,
+  checkHealthEndpoint
+};

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

@@ -92,6 +92,7 @@ async function computeTraefikPublicAppUrl(_appName, _healthCheckPort, appConfig)
   const remoteServer = await coreConfig.getRemoteServer();
   const developerIdRaw = await coreConfig.getDeveloperId();
   const developerIdNum = parseDeveloperIdNum(developerIdRaw);
+  const setupPlatformMode = await coreConfig.getSetupPlatformMode();
 
   // URLs are resolved for the CLI on the host, not from inside a container.
   const profile = 'local';
@@ -107,7 +108,8 @@ async function computeTraefikPublicAppUrl(_appName, _healthCheckPort, appConfig)
     profile,
     listenPort,
     developerIdNum,
-    infraTlsEnabled
+    infraTlsEnabled,
+    setupPlatformMode
   });
 
   return joinUrlPath(publicBase, mountPath);

package/lib/utils/health-check.js

@@ -9,9 +9,8 @@ const { formatSuccessLine } = require('./cli-test-layout-chalk');
  * @version 2.0.0
  */
 
-const http = require('http');
-const https = require('https');
 const net = require('net');
+const { checkHealthEndpoint } = require('./health-check-request');
 const dns = require('dns');
 const chalk = require('chalk');
 const logger = require('./logger');
@@ -192,117 +191,6 @@ async function getContainerPort(appName, debug = false) {
   return 3000;
 }
 
-/**
- * Parses health check response
- * @function parseHealthResponse
- * @param {string} data - Response data
- * @param {number} statusCode - HTTP status code
- * @returns {boolean} True if healthy
- */
-function parseHealthResponse(data, statusCode) {
-  try {
-    const health = JSON.parse(data);
-    if (health.status === 'UP') {
-      return true;
-    }
-    if (health.status === 'ok') {
-      return health.database === 'connected' || !health.database;
-    }
-    if (health.status === 'healthy') {
-      return true;
-    }
-    if (health.success === true) {
-      return true;
-    }
-    return false;
-  } catch (error) {
-    return statusCode === 200;
-  }
-}
-
-function handleHealthResponse(res, data, debug, resolve) {
-  const isHealthy = parseHealthResponse(data, res.statusCode);
-  if (debug) {
-    const truncatedData = data.length > 200 ? data.substring(0, 200) + '...' : data;
-    logger.log(chalk.gray(`[DEBUG] Response body: ${truncatedData}`));
-    logger.log(chalk.gray(`[DEBUG] Health check result: ${isHealthy ? 'healthy' : 'unhealthy'}`));
-  }
-  resolve(isHealthy);
-}
-
-function doHealthCheckRequest(healthCheckUrl, debug, resolve, reject) {
-  try {
-    const urlObj = new URL(healthCheckUrl);
-    const transport = urlObj.protocol === 'https:' ? https : http;
-    const options = {
-      hostname: urlObj.hostname,
-      port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
-      path: urlObj.pathname + urlObj.search,
-      method: 'GET'
-    };
-    if (debug) {
-      logger.log(chalk.gray(`[DEBUG] Health check request: ${healthCheckUrl}`));
-      logger.log(chalk.gray(`[DEBUG] Request options: ${JSON.stringify(options, null, 2)}`));
-    }
-    const timer = { id: null };
-    const req = transport.request(options, (res) => {
-      clearTimeout(timer.id);
-      let data = '';
-      if (debug) {
-        logger.log(chalk.gray(`[DEBUG] Response status code: ${res.statusCode}`));
-        logger.log(chalk.gray(`[DEBUG] Response headers: ${JSON.stringify(res.headers, null, 2)}`));
-      }
-      res.on('data', (chunk) => {
-        data += chunk;
-      });
-      res.on('end', () => handleHealthResponse(res, data, debug, resolve));
-    });
-    timer.id = setTimeout(() => {
-      if (debug) logger.log(chalk.gray('[DEBUG] Health check request timeout after 5 seconds'));
-      req.destroy();
-      resolve(false);
-    }, 5000);
-    req.on('error', (error) => {
-      clearTimeout(timer.id);
-      if (debug) logger.log(chalk.gray(`[DEBUG] Health check request error: ${error.message}`));
-      resolve(false);
-    });
-    req.end();
-  } catch (error) {
-    if (debug) logger.log(chalk.gray(`[DEBUG] Health check exception: ${error.message}`));
-    reject(error);
-  }
-}
-
-/**
- * Checks health endpoint
- * @async
- * @function checkHealthEndpoint
- * @param {string} healthCheckUrl - Health check URL
- * @param {boolean} [debug=false] - Enable debug logging
- * @returns {Promise<boolean>} True if healthy
- * @throws {Error} If request fails with exception
- */
-async function checkHealthEndpoint(healthCheckUrl, debug = false) {
-  return new Promise((resolve, reject) => {
-    doHealthCheckRequest(healthCheckUrl, debug, resolve, reject);
-  });
-}
-
-/**
- * Waits for application health check to pass
- * Checks HTTP endpoint and waits for healthy response
- *
- * @async
- * @function waitForHealthCheck
- * @param {string} appName - Application name
- * @param {number} timeout - Timeout in seconds (default: 90)
- * @param {number} [port] - Application port (auto-detected if not provided)
- * @param {Object} [config] - Application configuration
- * @param {boolean} [debug=false] - Enable debug logging
- * @returns {Promise<void>} Resolves when health check passes
- * @throws {Error} If health check times out
- */
 /**
  * Determines health check port
  * @async

package/lib/utils/help-builder.js

@@ -121,6 +121,7 @@ const CATEGORIES = [
     commands: [
       { name: 'dev' },
       { name: 'secret' },
+      { name: 'npm', term: 'npm config' },
       { name: 'secure' }
     ]
   }

package/lib/utils/keycloak-realm-ready.js

@@ -31,7 +31,11 @@ async function probeRealmWellKnown(url) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), 8000);
   try {
-    const res = await fetch(url, { method: 'GET', signal: controller.signal });
+    const { fetchWithOptionalDevPlatformTls } = require('./dev-platform-tls');
+    const res = await fetchWithOptionalDevPlatformTls(url, {
+      method: 'GET',
+      signal: controller.signal
+    });
     return res.ok;
   } catch {
     return false;

package/lib/utils/localhost-public-host.js

@@ -0,0 +1,31 @@
+/**
+ * Loopback hostnames always use http for declarative public URLs.
+ *
+ * @fileoverview Localhost hostname detection for public URL scheme
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+/**
+ * @param {string} hostname
+ * @returns {boolean}
+ */
+function isLocalhostPublicSchemeHostname(hostname) {
+  const h = String(hostname || '').trim().toLowerCase();
+  if (!h) {
+    return false;
+  }
+  if (h === 'localhost') {
+    return true;
+  }
+  if (h === '127.0.0.1') {
+    return true;
+  }
+  return h === '::1';
+}
+
+module.exports = {
+  isLocalhostPublicSchemeHostname
+};

package/lib/utils/npm-user-config.js

@@ -0,0 +1,145 @@
+/**
+ * Merge npm user-global auth lines from BASH_NPM_TOKEN / NPM_TOKEN.
+ *
+ * @fileoverview User-level ~/.npmrc auth for @aifabrix scope (not repo .npmrc)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+/**
+ * Keys managed by aifabrix npm config (replaced or removed on each run).
+ * `always-auth` is legacy — npm 11+ warns at userconfig; auth uses scoped registry + _authToken.
+ */
+const MANAGED_KEYS = new Set([
+  '@aifabrix:registry',
+  'always-auth',
+  '//registry.npmjs.org/:_authToken'
+]);
+
+const REGISTRY_URL = 'https://registry.npmjs.org/';
+
+/**
+ * Resolve npm userconfig file path (~/.npmrc by default).
+ *
+ * @returns {string}
+ */
+function getUserNpmrcPath() {
+  const fromEnv = process.env.npm_config_userconfig || process.env.NPM_CONFIG_USERCONFIG;
+  if (fromEnv && typeof fromEnv === 'string' && fromEnv.trim()) {
+    return path.resolve(fromEnv.trim());
+  }
+  return path.join(os.homedir(), '.npmrc');
+}
+
+/**
+ * Parse a single .npmrc line into key/value (ignores comments and blanks).
+ *
+ * @param {string} line
+ * @returns {{ key: string, value: string }|null}
+ */
+function parseNpmrcLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith(';')) {
+    return null;
+  }
+  const eq = trimmed.indexOf('=');
+  if (eq === -1) {
+    return { key: trimmed, value: '' };
+  }
+  return {
+    key: trimmed.slice(0, eq).trim(),
+    value: trimmed.slice(eq + 1).trim()
+  };
+}
+
+/**
+ * Build managed auth lines for @aifabrix private registry.
+ *
+ * @param {string} token - Bare npm automation token (never logged by callers)
+ * @returns {string[]}
+ */
+function buildManagedLines(token) {
+  return [
+    `@aifabrix:registry=${REGISTRY_URL}`,
+    `//registry.npmjs.org/:_authToken=${token}`
+  ];
+}
+
+/**
+ * Merge managed lines into existing .npmrc content (idempotent).
+ *
+ * @param {string} existingContent
+ * @param {string} token
+ * @returns {string}
+ */
+function mergeNpmrcContent(existingContent, token) {
+  const kept = [];
+  const lines = (existingContent || '').split(/\r?\n/);
+  for (const line of lines) {
+    const parsed = parseNpmrcLine(line);
+    if (parsed && MANAGED_KEYS.has(parsed.key)) {
+      continue;
+    }
+    kept.push(line);
+  }
+  while (kept.length > 0 && kept[kept.length - 1] === '') {
+    kept.pop();
+  }
+  const managed = buildManagedLines(token);
+  if (kept.length > 0) {
+    return `${kept.join('\n')}\n${managed.join('\n')}\n`;
+  }
+  return `${managed.join('\n')}\n`;
+}
+
+/**
+ * Write merged user-global npm auth from token.
+ *
+ * @param {string} token
+ * @param {{ dryRun?: boolean, npmrcPath?: string }} [options]
+ * @returns {{ npmrcPath: string, managedKeys: string[], dryRun: boolean, wrote: boolean }}
+ */
+function writeUserNpmrcFromToken(token, options = {}) {
+  const npmrcPath = options.npmrcPath || getUserNpmrcPath();
+  const dryRun = Boolean(options.dryRun);
+  const managedKeys = [...MANAGED_KEYS];
+  if (!token || !String(token).trim()) {
+    throw new Error('NPM token is required to update user npm config');
+  }
+  const existing = fs.existsSync(npmrcPath) ? fs.readFileSync(npmrcPath, 'utf8') : '';
+  const merged = mergeNpmrcContent(existing, String(token).trim());
+  if (!dryRun) {
+    const dir = path.dirname(npmrcPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(npmrcPath, merged, { mode: 0o600 });
+    try {
+      fs.chmodSync(npmrcPath, 0o600);
+    } catch {
+      // best-effort on platforms that restrict chmod
+    }
+  }
+  return {
+    npmrcPath,
+    managedKeys,
+    dryRun,
+    wrote: !dryRun
+  };
+}
+
+module.exports = {
+  MANAGED_KEYS,
+  REGISTRY_URL,
+  getUserNpmrcPath,
+  parseNpmrcLine,
+  buildManagedLines,
+  mergeNpmrcContent,
+  writeUserNpmrcFromToken
+};

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

@@ -103,12 +103,12 @@ async function computeAppBaseUrl(appName) {
   const userCfg = await config.getConfig();
   const remoteServer = await config.getRemoteServer();
   const infraTlsEnabled = Boolean(userCfg && userCfg.tlsEnabled);
+  const setupPlatformMode = await config.getSetupPlatformMode();
 
   const fd = variables.frontDoorRouting || null;
   const frontDoorEnabled = Boolean(fd && fd.enabled === true);
   const traefikOn = Boolean(userCfg && userCfg.traefik);
   const pathActive = Boolean(traefikOn && frontDoorEnabled);
-  const setupPlatformMode = await config.getSetupPlatformMode();
 
   const publicBase = computePublicUrlBaseString({
     traefik: traefikOn,
@@ -120,7 +120,8 @@ async function computeAppBaseUrl(appName) {
     profile: 'docker',
     listenPort: basePort,
     developerIdNum,
-    infraTlsEnabled
+    infraTlsEnabled,
+    setupPlatformMode
   });
 
   if (pathActive) {
@@ -148,10 +149,62 @@ async function resolvePlatformControllerUrl() {
   return computeAppBaseUrl(MISO_CONTROLLER_APP);
 }
 
+/**
+ * Direct localhost controller URL (published Docker port + optional front-door mount).
+ * Used when the CLI runs on the builder host but the public Traefik URL is unreachable.
+ *
+ * @async
+ * @param {string} [appName]
+ * @returns {Promise<string>}
+ */
+async function resolveLocalhostPlatformControllerUrl(appName = MISO_CONTROLLER_APP) {
+  const variables = loadAppVariables(appName);
+  const developerIdRaw = await config.getDeveloperId();
+  const developerIdNum =
+    typeof developerIdRaw === 'string' ? parseInt(developerIdRaw, 10) : developerIdRaw;
+  const basePort = Number(variables.port || 3000);
+  const hostPort = basePort + (Number.isFinite(developerIdNum) ? developerIdNum : 0) * 100;
+  const fd = variables.frontDoorRouting;
+  if (fd && fd.enabled === true && fd.pattern) {
+    const mount = normalizeFrontDoorPatternForHealth(fd.pattern);
+    if (mount && mount !== '/') {
+      return joinUrlPath(`http://localhost:${hostPort}`, mount).replace(/\/+$/, '');
+    }
+  }
+  return `http://localhost:${hostPort}`;
+}
+
+/**
+ * Controller URL for CLI HTTP calls on a remote dev host (builder-server).
+ * Keeps the public Traefik URL when reachable; otherwise falls back to localhost.
+ *
+ * @async
+ * @returns {Promise<string>}
+ */
+async function resolveCliPlatformControllerUrl() {
+  const publicUrl = await resolvePlatformControllerUrl();
+  const remoteServer = await config.getRemoteServer();
+  if (!remoteServer || !String(remoteServer).trim()) {
+    return publicUrl;
+  }
+  try {
+    const { checkHealthEndpoint } = require('./health-check-request');
+    const healthUrl = `${String(publicUrl).replace(/\/+$/, '')}/health`;
+    if (await checkHealthEndpoint(healthUrl)) {
+      return publicUrl;
+    }
+  } catch {
+    // fall through to localhost
+  }
+  return resolveLocalhostPlatformControllerUrl(MISO_CONTROLLER_APP);
+}
+
 module.exports = {
   MISO_CONTROLLER_APP,
   loadAppVariables,
   loadBundledApplicationVariables,
   computeAppBaseUrl,
-  resolvePlatformControllerUrl
+  resolvePlatformControllerUrl,
+  resolveLocalhostPlatformControllerUrl,
+  resolveCliPlatformControllerUrl
 };

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

@@ -10,26 +10,11 @@
 
 const { expandFrontDoorHostPlaceholders } = require('./compose-generator');
 const { publishedHostPort, localHostPort } = require('./declarative-url-ports');
-
-/**
- * Public URL authorities that must use `http://` (browsers hit loopback without TLS in practice).
- *
- * @param {string} hostname - Parsed URL hostname
- * @returns {boolean}
- */
-function isLocalhostPublicSchemeHostname(hostname) {
-  const h = String(hostname || '').trim().toLowerCase();
-  if (!h) {
-    return false;
-  }
-  if (h === 'localhost') {
-    return true;
-  }
-  if (h === '127.0.0.1') {
-    return true;
-  }
-  return h === '::1';
-}
+const {
+  normalizeSetupPlatformMode,
+  SETUP_PLATFORM_MODE
+} = require('../core/setup-platform-mode');
+const { isLocalhostPublicSchemeHostname } = require('./localhost-public-host');
 
 /**
  * Expand frontDoorRouting.host placeholders for url:// (same rules as Traefik labels in compose-generator).
@@ -156,6 +141,28 @@ function templateUsesRemoteHostPlaceholder(hostTemplate) {
   return /\$\{REMOTE_HOST\}/.test(String(hostTemplate || ''));
 }
 
+/**
+ * HTTPS for Traefik front-door public host when infra TLS is on, remote-server is https,
+ * or setup mode is single-traefik/full (builder-server nginx edge TLS).
+ *
+ * @param {Object} opts
+ * @param {boolean} [opts.infraTlsEnabled]
+ * @param {string|null|undefined} [opts.remoteServer]
+ * @param {string|null|undefined} [opts.setupPlatformMode]
+ * @returns {boolean}
+ */
+function traefikFrontDoorUsesHttps(opts = {}) {
+  if (opts.infraTlsEnabled) {
+    return true;
+  }
+  const remote = String(opts.remoteServer || '').trim();
+  if (remote && /^https:\/\//i.test(remote)) {
+    return true;
+  }
+  const mode = normalizeSetupPlatformMode(opts.setupPlatformMode);
+  return mode === SETUP_PLATFORM_MODE.SINGLE_TRAEFIK || mode === SETUP_PLATFORM_MODE.FULL;
+}
+
 /**
  * @param {Object} opts - same shape as computePublicUrlBaseString
  * @returns {string|null}
@@ -167,7 +174,6 @@ function buildTraefikPublicBaseIfApplicable(opts) {
     hostTemplate,
     developerIdRaw,
     remoteServer,
-    infraTlsEnabled,
     profile,
     developerIdNum
   } = opts;
@@ -189,8 +195,7 @@ function buildTraefikPublicBaseIfApplicable(opts) {
   if (!expanded) {
     return null;
   }
-  // Scheme follows global `tlsEnabled` (`up-infra --tls`) only — not `frontDoorRouting.tls` when infra TLS is off.
-  const useHttps = Boolean(infraTlsEnabled);
+  const useHttps = traefikFrontDoorUsesHttps(opts);
   let scheme = useHttps ? 'https' : 'http';
   if (isLocalhostPublicSchemeHostname(expanded)) {
     scheme = 'http';
@@ -210,7 +215,8 @@ function buildTraefikPublicBaseIfApplicable(opts) {
  * @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`); Traefik front-door public bases use **`https`** only when this is **true** (even if `frontDoorRouting.tls` is **false**). When **false**, front-door bases use **`http`** regardless of `frontDoorRouting.tls`. Loopback hostnames stay **http** always.
+ * @param {boolean} [opts.infraTlsEnabled] - `tlsEnabled` from ~/.aifabrix/config.yaml (`up-infra --tls`). Traefik front-door public bases also use **`https`** when `remote-server` is **`https://`** or `setupPlatformMode` is **`single-traefik`** / **`full`** (builder-server nginx edge TLS). Loopback hostnames stay **http** always.
+ * @param {string|null|undefined} [opts.setupPlatformMode] - From config; used with remote-server for edge TLS scheme
  * @param {boolean} [opts.pathActive] - traefik ∧ frontDoorRouting.enabled; required for Traefik host branch (plan 124)
  * @param {boolean|undefined} [opts.declarativePublicUrlsUseLocalhost] - **`true`**: force localhost authority (+ port rules below). **`false`**: allow `remote-server` as authority when Traefik is on, or when global `traefik` is not `false` and per-app `proxy` opts in without Traefik. **`undefined`**: default — omit `remote-server` when Traefik is off so published services use `http://localhost:<port>` (e.g. `af setup` / device login URLs). When user config has **`traefik: false`**, expansion forces localhost for public bases regardless of per-app `proxy`.
  * @returns {string}
@@ -270,5 +276,7 @@ function computePublicUrlBaseString(opts) {
 module.exports = {
   expandFrontDoorHostTemplateForUrls,
   computePublicUrlBaseString,
-  resolveHostPortForDeclarativePublic
+  resolveHostPortForDeclarativePublic,
+  isLocalhostPublicSchemeHostname,
+  traefikFrontDoorUsesHttps
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aifabrix/builder",
-  "version": "2.47.0",
+  "version": "2.47.2",
   "description": "AI Fabrix Local Fabric & Deployment SDK",
   "main": "lib/index.js",
   "bin": {

package/.npmrc.token

@@ -1 +0,0 @@
-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

package/.temp/jest-protection-convert/run-IFN2nv/.protection/hubspot-companies.json

@@ -1 +0,0 @@
-{"apiVersion":"dataplane.aifabrix.ai/v1","kind":"Protection","metadata":{"key":"hubspot-country-sales","displayName":"HubSpot Country Sales Access"},"spec":{"enabled":true,"datasourceKey":"hubspot-companies","mode":"replaceForSource","rules":[{"key":"sales-country-users","principal":{"type":"group","expression":"Sales {{fk.country.metadata.iso3}} Users"},"grants":[{"dimensionKey":"country","valueExpression":"{{fk.country.metadata.iso2}}"}]}]}}

package/.temp/jest-protection-convert/run-IvmKLO/.protection/hubspot-companies.yaml

@@ -1,17 +0,0 @@
-apiVersion: dataplane.aifabrix.ai/v1
-kind: Protection
-metadata:
-  key: hubspot-country-sales
-  displayName: HubSpot Country Sales Access
-spec:
-  enabled: true
-  datasourceKey: hubspot-companies
-  mode: replaceForSource
-  rules:
-    - key: sales-country-users
-      principal:
-        type: group
-        expression: "Sales {{fk.country.metadata.iso3}} Users"
-      grants:
-        - dimensionKey: country
-          valueExpression: "{{fk.country.metadata.iso2}}"

package/.temp/jest-protection-convert/run-SdvblF/.protection/hubspot-companies.json

@@ -1 +0,0 @@
-{"kind":"Protection"}

package/.temp/jest-protection-convert/run-b51TsW/.protection/hubspot-companies.json

@@ -1 +0,0 @@
-{"apiVersion":"dataplane.aifabrix.ai/v1","kind":"Protection","metadata":{"key":"hubspot-country-sales","displayName":"HubSpot Country Sales Access"},"spec":{"enabled":true,"datasourceKey":"hubspot-companies","mode":"replaceForSource","rules":[{"key":"sales-country-users","principal":{"type":"group","expression":"Sales {{fk.country.metadata.iso3}} Users"},"grants":[{"dimensionKey":"country","valueExpression":"{{fk.country.metadata.iso2}}"}]}]}}