@aifabrix/builder 2.32.3 → 2.33.0

package/lib/utils/compose-generator.js

@@ -15,6 +15,8 @@ const path = require('path');
 const handlebars = require('handlebars');
 const config = require('../core/config');
 const buildCopy = require('./build-copy');
+const { formatMissingDbPasswordError } = require('./error-formatter');
+const { getContainerPort } = require('./port-resolver');
 
 // Register commonly used helpers
 handlebars.registerHelper('eq', (a, b) => a === b);
@@ -150,6 +152,71 @@ function buildHealthCheckConfig(config) {
   };
 }
 
+/**
+ * Derives base path from routing pattern by removing trailing wildcards
+ * @param {string} pattern - URL pattern (e.g., '/app/*', '/api/v1/*')
+ * @returns {string} Base path for routing
+ */
+function derivePathFromPattern(pattern) {
+  if (!pattern || typeof pattern !== 'string') {
+    return '/';
+  }
+  const trimmed = pattern.trim();
+  if (trimmed === '/' || trimmed === '') {
+    return '/';
+  }
+  const withoutWildcards = trimmed.replace(/\*+$/g, '');
+  const withoutTrailingSlashes = withoutWildcards.replace(/\/+$/g, '');
+  return withoutTrailingSlashes || '/';
+}
+
+/**
+ * Builds developer username from developer ID
+ * @param {string|number} devId - Developer ID
+ * @returns {string} Developer username (dev, dev01, dev02, ...)
+ */
+function buildDevUsername(devId) {
+  if (devId === undefined || devId === null) {
+    return 'dev';
+  }
+  const devIdString = String(devId);
+  if (devIdString === '0') {
+    return 'dev';
+  }
+  const paddedId = devIdString.length === 1 ? devIdString.padStart(2, '0') : devIdString;
+  return `dev${paddedId}`;
+}
+
+/**
+ * Builds Traefik ingress configuration from frontDoorRouting
+ * Resolves ${DEV_USERNAME} variable interpolation in host field
+ * @param {Object} config - Application configuration
+ * @param {string|number} devId - Developer ID
+ * @returns {Object} Traefik configuration object
+ */
+function buildTraefikConfig(config, devId) {
+  const frontDoor = config.frontDoorRouting;
+  if (!frontDoor || frontDoor.enabled !== true) {
+    return { enabled: false };
+  }
+
+  if (!frontDoor.host || typeof frontDoor.host !== 'string') {
+    throw new Error('frontDoorRouting.host is required when frontDoorRouting.enabled is true');
+  }
+
+  const devUsername = buildDevUsername(devId);
+  const host = frontDoor.host.replace(/\$\{DEV_USERNAME\}/g, devUsername);
+  const path = derivePathFromPattern(frontDoor.pattern);
+
+  return {
+    enabled: true,
+    host,
+    path,
+    tls: frontDoor.tls !== false,
+    certStore: frontDoor.certStore || null
+  };
+}
+
 /**
  * Builds requires configuration section
  * @param {Object} config - Application configuration
@@ -169,17 +236,12 @@ function buildRequiresConfig(config) {
  * @param {string} appName - Application name
  * @param {Object} config - Application configuration
  * @param {number} port - Application port
+ * @param {string|number} devId - Developer ID
  * @returns {Object} Service configuration
  */
-function buildServiceConfig(appName, config, port) {
-  // Container port: build.containerPort > config.port (NEVER use host port parameter)
-  // Container port should remain unchanged regardless of developer ID
-  const containerPortValue = config.build?.containerPort || config.port || 3000;
-
-  // Host port: use port parameter (already calculated from CLI --port or config.port in generateDockerCompose)
-  // Note: build.localPort is ONLY used for .env file PORT variable (for local PC dev), NOT for Docker Compose
+function buildServiceConfig(appName, config, port, devId) {
+  const containerPortValue = getContainerPort(config, 3000);
   const hostPort = port;
-
   return {
     app: buildAppConfig(appName, config),
     image: buildImageConfig(config, appName),
@@ -190,6 +252,7 @@ function buildServiceConfig(appName, config, port) {
       localPort: config.build?.localPort || null // Only used for .env file PORT variable, not for Docker Compose
     },
     healthCheck: buildHealthCheckConfig(config),
+    traefik: buildTraefikConfig(config, devId),
     ...buildRequiresConfig(config)
   };
 }
@@ -200,11 +263,7 @@ function buildServiceConfig(appName, config, port) {
  * @returns {Object} Volumes configuration
  */
 function buildVolumesConfig(appName) {
-  // Use forward slashes for Docker paths (works on both Windows and Unix)
-  const volumePath = path.join(process.cwd(), 'data', appName);
-  return {
-    mountVolume: volumePath.replace(/\\/g, '/')
-  };
+  return { mountVolume: path.join(process.cwd(), 'data', appName).replace(/\\/g, '/') };
 }
 
 /**
@@ -213,23 +272,9 @@ function buildVolumesConfig(appName) {
  * @returns {Object} Networks configuration
  */
 function buildNetworksConfig(config) {
-  // Get databases from requires.databases or top-level databases
-  const databases = config.requires?.databases || config.databases || [];
-  return {
-    databases: databases
-  };
+  return { databases: config.requires?.databases || config.databases || [] };
 }
 
-/**
- * Reads database passwords from .env file
- * Requires DB_0_PASSWORD, DB_1_PASSWORD, etc. to be set in .env file
- * @async
- * @param {string} envPath - Path to .env file
- * @param {Array<Object>} databases - Array of database configurations
- * @param {string} appKey - Application key (fallback for single database)
- * @returns {Promise<Object>} Object with passwords array and lookup map
- * @throws {Error} If required password variables are missing
- */
 /**
  * Reads and parses .env file
  * @async
@@ -276,17 +321,21 @@ async function readEnvFile(envPath) {
  * @function extractPassword
  * @param {Object} envVars - Environment variables
  * @param {string} passwordKey - Password key to look up
+ * @param {Object} [context] - Optional: { appKey, multi } for clearer error messages
  * @returns {string} Password value
  * @throws {Error} If password is missing or empty
  */
-function extractPassword(envVars, passwordKey) {
+function extractPassword(envVars, passwordKey, context = {}) {
+  const { appKey, multi } = context;
+  const appSuffix = appKey ? ` for application '${appKey}'` : '';
+
   if (!(passwordKey in envVars)) {
-    throw new Error(`Missing required password variable ${passwordKey} in .env file`);
+    throw new Error(multi && appKey ? formatMissingDbPasswordError(appKey, { multiDb: true, passwordKey }) : 'Missing required password variable ' + passwordKey + ' in .env file' + appSuffix + '. Add ' + passwordKey + '=your_secret to your .env file.');
   }
 
   const password = envVars[passwordKey].trim();
   if (!password || password.length === 0) {
-    throw new Error(`Password variable ${passwordKey} is empty in .env file`);
+    throw new Error('Password variable ' + passwordKey + ' is empty in .env file' + appSuffix + '. Set a non-empty value.');
   }
 
   return password;
@@ -303,17 +352,14 @@ function extractPassword(envVars, passwordKey) {
 function processMultipleDatabases(databases, envVars, appKey) {
   const passwords = {};
   const passwordsArray = [];
-
   for (let i = 0; i < databases.length; i++) {
     const db = databases[i];
     const dbName = db.name || appKey;
     const passwordKey = `DB_${i}_PASSWORD`;
-    const password = extractPassword(envVars, passwordKey);
-
+    const password = extractPassword(envVars, passwordKey, { appKey, multi: true });
     passwords[dbName] = password;
     passwordsArray.push(password);
   }
-
   return { passwords, passwordsArray };
 }
 
@@ -327,47 +373,36 @@ function processMultipleDatabases(databases, envVars, appKey) {
 function processSingleDatabase(envVars, appKey) {
   const passwords = {};
   const passwordsArray = [];
-
-  // Single database case - use DB_0_PASSWORD or DB_PASSWORD
   const passwordKey = ('DB_0_PASSWORD' in envVars) ? 'DB_0_PASSWORD' : 'DB_PASSWORD';
-
   if (!(passwordKey in envVars)) {
-    throw new Error(`Missing required password variable ${passwordKey} in .env file. Add DB_0_PASSWORD or DB_PASSWORD to your .env file.`);
+    throw new Error(formatMissingDbPasswordError(appKey));
   }
-
-  const password = extractPassword(envVars, passwordKey);
+  const password = extractPassword(envVars, passwordKey, { appKey });
   passwords[appKey] = password;
   passwordsArray.push(password);
-
   return { passwords, passwordsArray };
 }
 
+/**
+ * Reads database passwords from .env file
+ * @async
+ * @function readDatabasePasswords
+ * @param {string} envPath - Path to .env file
+ * @param {Array<Object>} databases - Array of database configurations
+ * @param {string} appKey - Application key (fallback for single database)
+ * @returns {Promise<Object>} Object with passwords map and array
+ * @throws {Error} If required password variables are missing
+ */
 async function readDatabasePasswords(envPath, databases, appKey) {
   const envVars = await readEnvFile(envPath);
-
-  // Process each database
   if (databases && databases.length > 0) {
     const { passwords, passwordsArray } = processMultipleDatabases(databases, envVars, appKey);
-    return {
-      map: passwords,
-      array: passwordsArray
-    };
+    return { map: passwords, array: passwordsArray };
   }
-
   const { passwords, passwordsArray } = processSingleDatabase(envVars, appKey);
-  return {
-    map: passwords,
-    array: passwordsArray
-  };
+  return { map: passwords, array: passwordsArray };
 }
 
-/**
- * Generates Docker Compose configuration from template
- * @param {string} appName - Application name
- * @param {Object} appConfig - Application configuration
- * @param {Object} options - Run options
- * @returns {Promise<string>} Generated compose content
- */
 /**
  * Gets developer ID and calculates numeric ID
  * @async
@@ -376,8 +411,7 @@ async function readDatabasePasswords(envPath, databases, appKey) {
  */
 async function getDeveloperIdAndNumeric() {
   const devId = await config.getDeveloperId();
-  const idNum = typeof devId === 'string' ? parseInt(devId, 10) : devId;
-  return { devId, idNum };
+  return { devId, idNum: typeof devId === 'string' ? parseInt(devId, 10) : devId };
 }
 
 /**
@@ -411,15 +445,22 @@ async function readDatabasePasswordsIfNeeded(requiresDatabase, databases, envFil
   return { map: {}, array: [] };
 }
 
+/**
+ * Generates Docker Compose configuration from template
+ * @async
+ * @function generateDockerCompose
+ * @param {string} appName - Application name
+ * @param {Object} appConfig - Application configuration
+ * @param {Object} options - Run options
+ * @returns {Promise<string>} Generated compose content
+ */
 async function generateDockerCompose(appName, appConfig, options) {
   const language = appConfig.build?.language || appConfig.language || 'typescript';
   const template = loadDockerComposeTemplate(language);
   const port = options.port || appConfig.port || 3000;
-
   const { devId, idNum } = await getDeveloperIdAndNumeric();
   const { networkName, containerName } = buildNetworkAndContainerNames(appName, devId, idNum);
-
-  const serviceConfig = buildServiceConfig(appName, appConfig, port);
+  const serviceConfig = buildServiceConfig(appName, appConfig, port, devId);
   const volumesConfig = buildVolumesConfig(appName);
   const networksConfig = buildNetworksConfig(appConfig);
 
@@ -439,17 +480,19 @@ async function generateDockerCompose(appName, appConfig, options) {
     ...volumesConfig,
     ...networksConfig,
     envFile: envFileAbsolutePath,
-    databasePasswords: databasePasswords,
+    databasePasswords,
     devId: idNum,
-    networkName: networkName,
-    containerName: containerName
+    networkName,
+    containerName
   };
-
   return template(templateData);
 }
 
 module.exports = {
   generateDockerCompose,
-  getImageName
+  getImageName,
+  derivePathFromPattern,
+  buildTraefikConfig,
+  buildDevUsername
 };
 

package/lib/utils/controller-url.js

@@ -11,6 +11,7 @@
 
 const { getDeveloperIdNumber } = require('./env-map');
 const devConfig = require('./dev-config');
+const config = require('../core/config');
 
 /**
  * Calculate default controller URL based on developer ID
@@ -28,33 +29,78 @@ async function getDefaultControllerUrl() {
   return `http://localhost:${ports.app}`;
 }
 
+/**
+ * Normalize controller URL (remove trailing slashes)
+ * @param {string} url - Controller URL to normalize
+ * @returns {string} Normalized controller URL
+ */
+function normalizeUrl(url) {
+  if (!url || typeof url !== 'string') {
+    return url;
+  }
+  return url.trim().replace(/\/+$/, '');
+}
+
+/**
+ * Get controller URL from logged-in user's device tokens
+ * Returns the first available controller URL from device tokens stored in config
+ * @async
+ * @function getControllerUrlFromLoggedInUser
+ * @returns {Promise<string|null>} Controller URL from logged-in user, or null if not found
+ */
+async function getControllerUrlFromLoggedInUser() {
+  try {
+    const userConfig = await config.getConfig();
+    if (!userConfig.device || typeof userConfig.device !== 'object') {
+      return null;
+    }
+
+    const deviceUrls = Object.keys(userConfig.device);
+    if (deviceUrls.length === 0) {
+      return null;
+    }
+
+    // Return the first available controller URL (normalized)
+    const firstControllerUrl = deviceUrls[0];
+    return normalizeUrl(firstControllerUrl);
+  } catch (error) {
+    // If config doesn't exist or can't be read, return null
+    return null;
+  }
+}
+
+/**
+ * Get controller URL from config.yaml
+ * @async
+ * @function getControllerFromConfig
+ * @returns {Promise<string|null>} Controller URL from config or null
+ */
+async function getControllerFromConfig() {
+  const { getControllerUrl } = require('../core/config');
+  return await getControllerUrl();
+}
+
 /**
  * Resolve controller URL with fallback chain
  * Priority:
- * 1. options.controller (explicit option)
- * 2. config.deployment?.controllerUrl (from config)
+ * 1. config.controller (from config.yaml)
+ * 2. getControllerUrlFromLoggedInUser() (from logged-in device tokens)
  * 3. getDefaultControllerUrl() (developer ID-based default)
  * @async
  * @function resolveControllerUrl
- * @param {Object} options - Command options
- * @param {string} [options.controller] - Explicit controller URL option
- * @param {Object} config - Configuration object
- * @param {Object} [config.deployment] - Deployment configuration
- * @param {string} [config.deployment.controllerUrl] - Controller URL from config
  * @returns {Promise<string>} Resolved controller URL
  */
-async function resolveControllerUrl(options, config) {
-  // Priority 1: Explicit option
-  if (options && (options.controller || options.url)) {
-    const explicitUrl = options.controller || options.url;
-    if (explicitUrl) {
-      return explicitUrl.replace(/\/$/, '');
-    }
+async function resolveControllerUrl() {
+  // Priority 1: config.controller (from config.yaml)
+  const configController = await getControllerFromConfig();
+  if (configController) {
+    return configController.replace(/\/+$/, '');
   }
 
-  // Priority 2: Config file
-  if (config?.deployment?.controllerUrl) {
-    return config.deployment.controllerUrl.replace(/\/$/, '');
+  // Priority 2: Logged-in user's device tokens
+  const loggedInControllerUrl = await getControllerUrlFromLoggedInUser();
+  if (loggedInControllerUrl) {
+    return loggedInControllerUrl;
   }
 
   // Priority 3: Developer ID-based default
@@ -63,5 +109,7 @@ async function resolveControllerUrl(options, config) {
 
 module.exports = {
   getDefaultControllerUrl,
+  getControllerUrlFromLoggedInUser,
+  getControllerFromConfig,
   resolveControllerUrl
 };

package/lib/utils/dataplane-health.js

@@ -0,0 +1,115 @@
+/**
+ * Dataplane Health Check Utilities
+ *
+ * Provides utilities for checking dataplane URL health and reachability
+ *
+ * @fileoverview Dataplane health check utilities
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+/**
+ * Tests a single endpoint for reachability
+ * @async
+ * @function testEndpoint
+ * @param {string} testUrl - URL to test
+ * @param {number} timeoutMs - Timeout in milliseconds
+ * @returns {Promise<boolean>} True if endpoint is reachable
+ */
+async function testEndpoint(testUrl, timeoutMs) {
+  try {
+    const controller = new AbortController();
+    const abortTimeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    let raceTimeoutId;
+
+    const response = await Promise.race([
+      fetch(testUrl, {
+        method: 'GET',
+        signal: controller.signal,
+        headers: { 'Accept': 'application/json' }
+      }),
+      new Promise((_, reject) => {
+        raceTimeoutId = setTimeout(() => reject(new Error('Timeout')), timeoutMs);
+      })
+    ]).catch(() => null);
+
+    clearTimeout(abortTimeoutId);
+    if (raceTimeoutId) {
+      clearTimeout(raceTimeoutId);
+    }
+
+    // If we get any response (even 404 or 401), the service is reachable
+    // 401 is OK because it means the API is working, just needs auth
+    if (response && (response.ok || response.status === 404 || response.status === 401)) {
+      return true;
+    }
+
+    // If we get a 500 or other server error, the service is up but broken
+    // Still consider it "reachable" - the wizard will handle the actual error
+    if (response && response.status >= 500) {
+      return true;
+    }
+
+    // If response is null (timeout/error), endpoint is not reachable
+    return false;
+  } catch (error) {
+    // Timeout or abort means endpoint is not reachable
+    return false;
+  }
+}
+
+/**
+ * Checks if dataplane URL is reachable and API is functional
+ * @async
+ * @function checkDataplaneHealth
+ * @param {string} dataplaneUrl - Dataplane URL to check
+ * @param {number} timeoutMs - Timeout in milliseconds (default: 5000)
+ * @returns {Promise<boolean>} True if dataplane is reachable and functional
+ */
+async function checkDataplaneHealth(dataplaneUrl, timeoutMs = 5000) {
+  if (!dataplaneUrl) {
+    return false;
+  }
+
+  const baseUrl = dataplaneUrl.replace(/\/+$/, '');
+  const endpointsToTest = ['/health', '/api/v1/health', '/api/health', ''];
+
+  for (const endpoint of endpointsToTest) {
+    const testUrl = endpoint ? `${baseUrl}${endpoint}` : baseUrl;
+    const isReachable = await testEndpoint(testUrl, timeoutMs);
+    if (isReachable) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Validates dataplane health before running wizard
+ * @async
+ * @function validateDataplaneHealth
+ * @param {string} dataplaneUrl - Dataplane URL to check
+ * @returns {Promise<Error|null>} Error if unhealthy, null if healthy
+ */
+async function validateDataplaneHealth(dataplaneUrl) {
+  try {
+    const isHealthy = await checkDataplaneHealth(dataplaneUrl, 5000);
+    if (!isHealthy) {
+      return new Error(
+        `Dataplane is not reachable at ${dataplaneUrl}.\n\n` +
+        'Please ensure the dataplane service is running and accessible, then try again.\n' +
+        `You can check dataplane status with: curl ${dataplaneUrl}/health`
+      );
+    }
+    return null;
+  } catch (error) {
+    return new Error(`Failed to check dataplane health: ${error.message}`);
+  }
+}
+
+module.exports = {
+  checkDataplaneHealth,
+  validateDataplaneHealth,
+  testEndpoint
+};

package/lib/utils/dataplane-resolver.js

@@ -0,0 +1,29 @@
+/**
+ * Dataplane URL Resolver
+ *
+ * Resolves dataplane URL by discovering from controller
+ *
+ * @fileoverview Dataplane URL resolution utilities
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { discoverDataplaneUrl } = require('../commands/wizard-dataplane');
+
+/**
+ * Resolve dataplane URL by discovering from controller
+ * @async
+ * @function resolveDataplaneUrl
+ * @param {string} controllerUrl - Controller URL
+ * @param {string} environment - Environment key
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<string>} Resolved dataplane URL
+ * @throws {Error} If dataplane URL cannot be resolved
+ */
+async function resolveDataplaneUrl(controllerUrl, environment, authConfig) {
+  return await discoverDataplaneUrl(controllerUrl, environment, authConfig);
+}
+
+module.exports = {
+  resolveDataplaneUrl
+};

package/lib/utils/dev-config.js

@@ -18,7 +18,9 @@ const BASE_PORTS = {
   postgres: 5432,
   redis: 6379,
   pgadmin: 5050,
-  redisCommander: 8081
+  redisCommander: 8081,
+  traefikHttp: 80,
+  traefikHttps: 443
 };
 
 /**
@@ -65,7 +67,9 @@ function getDevPorts(developerId) {
     postgres: BASE_PORTS.postgres + offset,
     redis: BASE_PORTS.redis + offset,
     pgadmin: BASE_PORTS.pgadmin + offset,
-    redisCommander: BASE_PORTS.redisCommander + offset
+    redisCommander: BASE_PORTS.redisCommander + offset,
+    traefikHttp: BASE_PORTS.traefikHttp + offset,
+    traefikHttps: BASE_PORTS.traefikHttps + offset
   };
 }
 

package/lib/utils/env-copy.js

@@ -18,6 +18,7 @@ const devConfig = require('../utils/dev-config');
 const { rewriteInfraEndpoints } = require('./env-endpoints');
 const { buildEnvVarMap } = require('./env-map');
 const { interpolateEnvVars } = require('./secrets-helpers');
+const { getLocalPort } = require('./port-resolver');
 
 /**
  * Read developer ID from config file synchronously
@@ -157,7 +158,7 @@ function extractEnvVarsFromContent(envContent, envVars) {
  * @returns {Promise<string>} Patched env content
  */
 async function patchEnvContentForLocal(envContent, variables) {
-  const baseAppPort = variables.build?.localPort || variables.port || 3000;
+  const baseAppPort = getLocalPort(variables, 3000);
   const appPort = calculateDevAppPort(baseAppPort);
   const devIdNum = readDeveloperIdFromConfig(config) || 0;
   const infraPorts = devConfig.getDevPorts(devIdNum);

package/lib/utils/env-ports.js

@@ -11,6 +11,7 @@
 const fs = require('fs');
 const yaml = require('js-yaml');
 const config = require('../core/config');
+const { getLocalPort } = require('./port-resolver');
 
 /**
  * Update PORT in the container's .env file to use variables.port (+offset)
@@ -66,7 +67,7 @@ function updateContainerPortInEnvFile(envPath, variablesPath) {
   }
   const variablesContent = fs.readFileSync(variablesPath, 'utf8');
   const variables = yaml.load(variablesContent);
-  const basePort = variables?.port || 3000;
+  const basePort = getLocalPort(variables, 3000);
   const devIdNum = getDeveloperIdFromEnvOrConfig();
   const port = calculatePortWithDevId(basePort, devIdNum);
   let envContent = fs.readFileSync(envPath, 'utf8');

package/lib/utils/env-template.js

@@ -20,7 +20,7 @@ const logger = require('../utils/logger');
  * @param {string} appKey - Application key
  * @param {string} clientIdKey - Secret key for client ID (e.g., 'myapp-client-idKeyVault')
  * @param {string} clientSecretKey - Secret key for client secret (e.g., 'myapp-client-secretKeyVault')
- * @param {string} _controllerUrl - Controller URL (e.g., 'http://localhost:3010' or 'https://controller.aifabrix.ai')
+ * @param {string} _controllerUrl - Controller URL (e.g., 'http://localhost:3010' or 'https://controller.aifabrix.dev')
  *   Note: This parameter is accepted for compatibility but the template format http://${MISO_HOST}:${MISO_PORT} is used instead
  * @returns {Promise<void>} Resolves when template is updated
  */