@aifabrix/builder 2.4.0 → 2.5.1

package/lib/utils/env-endpoints.js

@@ -0,0 +1,209 @@
+/**
+ * Environment endpoint rewriting utilities
+ *
+ * @fileoverview Rewrites infra endpoints using env-config and developer offsets
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+const config = require('../config');
+const devConfig = require('../utils/dev-config');
+const { loadEnvConfig } = require('./env-config-loader');
+
+/**
+ * Returns the environment hosts mapping from env-config.yaml
+ * @async
+ * @param {'docker'|'local'} context
+ * @returns {Promise<Object>}
+ */
+async function getEnvHosts(context) {
+  const envCfg = await loadEnvConfig();
+  const envs = envCfg && envCfg.environments ? envCfg.environments : {};
+  return envs[context] || {};
+}
+
+/**
+ * Rewrites infra endpoints (REDIS_URL/REDIS_HOST/REDIS_PORT, DB_HOST/DB_PORT, etc.) based on env-config and context
+ * Uses getEnvHosts() to get all service values dynamically, avoiding hardcoded values
+ * @async
+ * @function rewriteInfraEndpoints
+ * @param {string} envContent - .env file content
+ * @param {'docker'|'local'} context - Environment context
+ * @param {{redis:number, postgres:number}} [devPorts] - Ports object with developer-id adjusted ports (optional)
+ * @returns {Promise<string>} Updated content
+ */
+async function rewriteInfraEndpoints(envContent, context, devPorts) {
+  // Get all service values from config system (includes env-config.yaml + user env-config file)
+  let hosts = await getEnvHosts(context);
+
+  // Apply config.yaml → environments.{context} override (if exists)
+  try {
+    const os = require('os');
+    const cfgPath = path.join(os.homedir(), '.aifabrix', 'config.yaml');
+    if (fs.existsSync(cfgPath)) {
+      const cfgContent = fs.readFileSync(cfgPath, 'utf8');
+      const cfg = yaml.load(cfgContent) || {};
+      if (cfg && cfg.environments && cfg.environments[context]) {
+        hosts = { ...hosts, ...cfg.environments[context] };
+      }
+    }
+  } catch {
+    // Ignore config.yaml read errors, continue with env-config values
+  }
+
+  // Helper to split host:port values
+  const splitHost = (value) => {
+    if (typeof value !== 'string') return { host: undefined, port: undefined };
+    const m = value.match(/^([^:]+):(\d+)$/);
+    if (m) return { host: m[1], port: parseInt(m[2], 10) };
+    return { host: value, port: undefined };
+  };
+
+  // Get aifabrix-localhost override for local context
+  let localhostOverride = null;
+  if (context === 'local') {
+    try {
+      const os = require('os');
+      const cfgPath = path.join(os.homedir(), '.aifabrix', 'config.yaml');
+      if (fs.existsSync(cfgPath)) {
+        const cfgContent = fs.readFileSync(cfgPath, 'utf8');
+        const cfg = yaml.load(cfgContent) || {};
+        if (typeof cfg['aifabrix-localhost'] === 'string' && cfg['aifabrix-localhost'].trim().length > 0) {
+          localhostOverride = cfg['aifabrix-localhost'].trim();
+        }
+      }
+    } catch {
+      // ignore override errors
+    }
+  }
+
+  // Helper to get port value from config or devPorts, with developer-id adjustment
+  const getServicePort = async(portKey, serviceName) => {
+    // If devPorts provided, use it (already has developer-id adjustment)
+    if (devPorts && typeof devPorts[serviceName] === 'number') {
+      return devPorts[serviceName];
+    }
+
+    // Get base port from config
+    let basePort = null;
+    if (hosts[portKey] !== undefined && hosts[portKey] !== null) {
+      const portVal = typeof hosts[portKey] === 'number' ? hosts[portKey] : parseInt(hosts[portKey], 10);
+      if (!Number.isNaN(portVal)) {
+        basePort = portVal;
+      }
+    }
+
+    // Last resort fallback to devConfig (only if not in config)
+    if (basePort === null || basePort === undefined) {
+      const basePorts = devConfig.getBasePorts();
+      basePort = basePorts[serviceName];
+    }
+
+    // Apply developer-id adjustment
+    try {
+      const devId = await config.getDeveloperId();
+      let devIdNum = 0;
+      if (devId !== null && devId !== undefined) {
+        const parsed = parseInt(devId, 10);
+        if (!Number.isNaN(parsed)) {
+          devIdNum = parsed;
+        }
+      }
+      return devIdNum === 0 ? basePort : (basePort + (devIdNum * 100));
+    } catch {
+      return basePort;
+    }
+  };
+
+  // Get Redis configuration
+  const redisParts = splitHost(hosts.REDIS_HOST);
+  let redisHost = redisParts.host || hosts.REDIS_HOST;
+  // Fallback to default if not in config
+  if (!redisHost) {
+    redisHost = context === 'docker' ? 'redis' : 'localhost';
+  }
+  if (context === 'local' && localhostOverride && redisHost === 'localhost') {
+    redisHost = localhostOverride;
+  }
+  const redisPort = await getServicePort('REDIS_PORT', 'redis');
+
+  // Get DB configuration
+  let dbHost = hosts.DB_HOST;
+  // Fallback to default if not in config
+  if (!dbHost) {
+    dbHost = context === 'docker' ? 'postgres' : 'localhost';
+  }
+  const finalDbHost = (context === 'local' && localhostOverride && dbHost === 'localhost') ? localhostOverride : dbHost;
+  const dbPort = await getServicePort('DB_PORT', 'postgres');
+
+  let updated = envContent;
+
+  // Update REDIS_URL if present
+  if (/^REDIS_URL\s*=.*$/m.test(updated)) {
+    const m = updated.match(/^REDIS_URL\s*=\s*redis:\/\/([^:\s]+):\d+/m);
+    const currentHost = m && m[1] ? m[1] : null;
+    const targetHost = redisHost || currentHost;
+    if (targetHost) {
+      updated = updated.replace(
+        /^REDIS_URL\s*=\s*.*$/m,
+        `REDIS_URL=redis://${targetHost}:${redisPort}`
+      );
+    }
+  }
+
+  // Update REDIS_HOST if present
+  if (/^REDIS_HOST\s*=.*$/m.test(updated)) {
+    const hostPortMatch = updated.match(/^REDIS_HOST\s*=\s*([a-zA-Z0-9_.-]+):\d+$/m);
+    const hasPortPattern = !!hostPortMatch;
+    if (hasPortPattern) {
+      updated = updated.replace(
+        /^REDIS_HOST\s*=\s*.*$/m,
+        `REDIS_HOST=${redisHost}:${redisPort}`
+      );
+    } else {
+      updated = updated.replace(/^REDIS_HOST\s*=\s*.*$/m, `REDIS_HOST=${redisHost}`);
+    }
+  }
+
+  // Update REDIS_PORT if present
+  if (/^REDIS_PORT\s*=.*$/m.test(updated)) {
+    updated = updated.replace(
+      /^REDIS_PORT\s*=\s*.*$/m,
+      `REDIS_PORT=${redisPort}`
+    );
+  }
+
+  // Update DB_HOST if present
+  if (/^DB_HOST\s*=.*$/m.test(updated)) {
+    updated = updated.replace(/^DB_HOST\s*=\s*.*$/m, `DB_HOST=${finalDbHost}`);
+  }
+
+  // Update DB_PORT if present
+  if (/^DB_PORT\s*=.*$/m.test(updated)) {
+    updated = updated.replace(
+      /^DB_PORT\s*=\s*.*$/m,
+      `DB_PORT=${dbPort}`
+    );
+  }
+
+  // Update DATABASE_PORT if present (some templates use DATABASE_PORT instead of DB_PORT)
+  if (/^DATABASE_PORT\s*=.*$/m.test(updated)) {
+    updated = updated.replace(
+      /^DATABASE_PORT\s*=\s*.*$/m,
+      `DATABASE_PORT=${dbPort}`
+    );
+  }
+
+  return updated;
+}
+
+module.exports = {
+  rewriteInfraEndpoints,
+  getEnvHosts
+};
+

package/lib/utils/env-map.js

@@ -0,0 +1,116 @@
+/**
+ * Environment variable mapping utilities
+ *
+ * @fileoverview Build interpolation map from env-config.yaml and config overrides
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+const { loadEnvConfig } = require('./env-config-loader');
+
+/**
+ * Build environment variable map for interpolation based on env-config.yaml
+ * - Supports values like "host:port" by splitting into *_HOST (host) and *_PORT (port)
+ * - Merges overrides from ~/.aifabrix/config.yaml under environments.{env}
+ * - Applies aifabrix-localhost override for local context if configured
+ * @async
+ * @function buildEnvVarMap
+ * @param {'docker'|'local'} context - Environment context
+ * @param {Object} [osModule] - Optional os module (for testing). If not provided, requires 'os'
+ * @returns {Promise<Object>} Map of variables for interpolation
+ */
+async function buildEnvVarMap(context, osModule = null) {
+  // Load env-config (base + user override if configured)
+  let baseVars = {};
+  try {
+    const envCfg = await loadEnvConfig();
+    const envs = envCfg && envCfg.environments ? envCfg.environments : {};
+    baseVars = { ...(envs[context] || {}) };
+  } catch {
+    baseVars = {};
+  }
+
+  // Get os module - use provided one or require it
+  const os = osModule || require('os');
+
+  // Merge overrides from ~/.aifabrix/config.yaml
+  let overrideVars = {};
+  try {
+    const cfgPath = path.join(os.homedir(), '.aifabrix', 'config.yaml');
+    if (fs.existsSync(cfgPath)) {
+      const cfgContent = fs.readFileSync(cfgPath, 'utf8');
+      const cfg = yaml.load(cfgContent) || {};
+      if (cfg && cfg.environments && cfg.environments[context]) {
+        overrideVars = { ...cfg.environments[context] };
+      }
+    }
+  } catch {
+    // ignore overrides on error
+  }
+
+  // Apply aifabrix-localhost override for local hostnames
+  let localhostOverride = null;
+  if (context === 'local') {
+    try {
+      const cfgPath = path.join(os.homedir(), '.aifabrix', 'config.yaml');
+      if (fs.existsSync(cfgPath)) {
+        const cfgContent = fs.readFileSync(cfgPath, 'utf8');
+        const cfg = yaml.load(cfgContent) || {};
+        if (typeof cfg['aifabrix-localhost'] === 'string' && cfg['aifabrix-localhost'].trim().length > 0) {
+          localhostOverride = cfg['aifabrix-localhost'].trim();
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  const merged = { ...baseVars, ...overrideVars };
+
+  // Normalize map: if VAR value is "host:port" and VAR ends with "_HOST",
+  // expose VAR as host only and also provide "<ROOT>_PORT"
+  // If VAR value is "host:port" but VAR doesn't end with "_HOST", still split to VAR_HOST/VAR_PORT
+  const result = {};
+  for (const [key, rawVal] of Object.entries(merged)) {
+    if (typeof rawVal !== 'string') {
+      result[key] = rawVal;
+      continue;
+    }
+    const hostPortMatch = rawVal.match(/^([A-Za-z0-9._-]+):(\d+)$/);
+    if (hostPortMatch) {
+      const host = hostPortMatch[1];
+      const port = hostPortMatch[2];
+      if (/_HOST$/.test(key)) {
+        // Example: DB_HOST: "postgres:5432" -> DB_HOST="postgres", DB_PORT="5432"
+        const root = key.replace(/_HOST$/, '');
+        const hostValue = context === 'local' && host === 'localhost' && localhostOverride ? localhostOverride : host;
+        result[key] = hostValue;
+        result[`${root}_PORT`] = port;
+      } else {
+        // Generic key with host:port -> expose KEY_HOST and KEY_PORT, and keep KEY as host
+        const hostValue = context === 'local' && host === 'localhost' && localhostOverride ? localhostOverride : host;
+        result[`${key}_HOST`] = hostValue;
+        result[`${key}_PORT`] = port;
+        result[key] = hostValue;
+      }
+    } else {
+      // Plain value
+      let val = rawVal;
+      if (context === 'local' && /_HOST$/.test(key) && rawVal === 'localhost' && localhostOverride) {
+        val = localhostOverride;
+      }
+      result[key] = val;
+    }
+  }
+  return result;
+}
+
+module.exports = {
+  buildEnvVarMap
+};
+

package/lib/utils/env-ports.js

@@ -0,0 +1,60 @@
+/**
+ * Environment port utilities
+ *
+ * @fileoverview Update container PORT based on variables.yaml and developer-id offset
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const yaml = require('js-yaml');
+const config = require('../config');
+
+/**
+ * Update PORT in the container's .env file to use variables.port (+offset)
+ * @function updateContainerPortInEnvFile
+ * @param {string} envPath - Path to .env
+ * @param {string} variablesPath - Path to variables.yaml
+ */
+function updateContainerPortInEnvFile(envPath, variablesPath) {
+  if (!fs.existsSync(variablesPath)) {
+    return;
+  }
+  const variablesContent = fs.readFileSync(variablesPath, 'utf8');
+  const variables = yaml.load(variablesContent);
+  // Base port from variables
+  const basePort = variables?.port || 3000;
+  // Determine developer-id (prefer env var for sync context, fallback to config file)
+  let devIdNum = 0;
+  const devIdRaw = process.env.AIFABRIX_DEVELOPERID;
+  if (devIdRaw && /^[0-9]+$/.test(devIdRaw)) {
+    devIdNum = parseInt(devIdRaw, 10);
+  } else {
+    try {
+      const cfgPath = config && config.CONFIG_FILE ? config.CONFIG_FILE : null;
+      if (cfgPath && fs.existsSync(cfgPath)) {
+        const cfgContent = fs.readFileSync(cfgPath, 'utf8');
+        const cfg = yaml.load(cfgContent) || {};
+        const raw = cfg['developer-id'];
+        if (typeof raw === 'number') {
+          devIdNum = raw;
+        } else if (typeof raw === 'string' && /^[0-9]+$/.test(raw)) {
+          devIdNum = parseInt(raw, 10);
+        }
+      }
+    } catch {
+      // ignore, will use 0
+    }
+  }
+  const port = devIdNum > 0 ? (basePort + devIdNum * 100) : basePort;
+  let envContent = fs.readFileSync(envPath, 'utf8');
+  envContent = envContent.replace(/^PORT\s*=\s*.*$/m, `PORT=${port}`);
+  fs.writeFileSync(envPath, envContent, { mode: 0o600 });
+}
+
+module.exports = {
+  updateContainerPortInEnvFile
+};
+

package/lib/utils/environment-checker.js

@@ -13,6 +13,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const dockerUtils = require('./docker');
+const { getActualSecretsPath } = require('./secrets-path');
 
 /**
  * Checks if Docker is installed and available
@@ -62,13 +63,42 @@ async function checkPorts() {
 
 /**
  * Checks if secrets file exists
+ * Checks both the default path and the path configured in config.yaml (aifabrix-secrets)
  *
+ * @async
  * @function checkSecrets
- * @returns {string} 'ok' if secrets file exists, 'missing' otherwise
+ * @returns {Promise<Object>} Object with status ('ok' or 'missing') and paths checked
+ * @returns {string} returns.status - 'ok' if secrets file exists, 'missing' otherwise
+ * @returns {string[]} returns.paths - Array of paths that were checked
  */
-function checkSecrets() {
-  const secretsPath = path.join(os.homedir(), '.aifabrix', 'secrets.yaml');
-  return fs.existsSync(secretsPath) ? 'ok' : 'missing';
+async function checkSecrets() {
+  try {
+    const { userPath, buildPath } = await getActualSecretsPath();
+    const pathsChecked = [];
+
+    // Check user path (default: ~/.aifabrix/secrets.local.yaml)
+    if (fs.existsSync(userPath)) {
+      return { status: 'ok', paths: [userPath] };
+    }
+    pathsChecked.push(userPath);
+
+    // Check build path (from config.yaml aifabrix-secrets)
+    if (buildPath && fs.existsSync(buildPath)) {
+      return { status: 'ok', paths: [buildPath] };
+    }
+    if (buildPath) {
+      pathsChecked.push(buildPath);
+    }
+
+    return { status: 'missing', paths: pathsChecked };
+  } catch (error) {
+    // Fallback to default path if there's an error
+    const defaultPath = path.join(os.homedir(), '.aifabrix', 'secrets.yaml');
+    return {
+      status: fs.existsSync(defaultPath) ? 'ok' : 'missing',
+      paths: [defaultPath]
+    };
+  }
 }
 
 /**
@@ -105,9 +135,12 @@ async function checkEnvironment() {
   }
 
   // Check secrets
-  result.secrets = checkSecrets();
+  const secretsCheck = await checkSecrets();
+  result.secrets = secretsCheck.status;
   if (result.secrets === 'missing') {
-    result.recommendations.push('Create secrets file: ~/.aifabrix/secrets.yaml');
+    // Show the actual paths that were checked
+    const pathsList = secretsCheck.paths.map(p => p).join(' or ');
+    result.recommendations.push(`Create secrets file: ${pathsList}`);
   }
 
   return result;

package/lib/utils/image-name.js

@@ -0,0 +1,49 @@
+/**
+ * Image name utilities
+ *
+ * @fileoverview Helper functions for computing developer-scoped Docker image names
+ * based on the current developer identifier. Ensures consistent local build naming.
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+/**
+ * Builds a developer-scoped image name for local Docker builds.
+ * Format: "<base>-dev<developerId>".
+ * If developerId is missing, non-numeric, or 0 → "<base>-extra".
+ *
+ * @function buildDevImageName
+ * @param {string} baseName - Base image name (no registry), e.g., "myapp"
+ * @param {(string|number|null|undefined)} developerId - Developer identifier
+ * @returns {string} Developer-scoped image name
+ *
+ * @example
+ * buildDevImageName('myapp', 123) // "myapp-dev123"
+ * buildDevImageName('myapp', '0') // "myapp-extra"
+ * buildDevImageName('myapp') // "myapp-extra"
+ */
+function buildDevImageName(baseName, developerId) {
+  const id =
+    typeof developerId === 'number'
+      ? developerId
+      : typeof developerId === 'string'
+        ? parseInt(developerId, 10)
+        : NaN;
+
+  if (!baseName || typeof baseName !== 'string') {
+    throw new Error('Base image name is required and must be a string');
+  }
+
+  if (!Number.isFinite(id) || id === 0) {
+    return `${baseName}-extra`;
+  }
+
+  return `${baseName}-dev${id}`;
+}
+
+module.exports = {
+  buildDevImageName
+};
+

package/lib/utils/paths.js

@@ -12,14 +12,14 @@
 'use strict';
 
 const path = require('path');
-const os = require('os');
 const fs = require('fs');
 const yaml = require('js-yaml');
 
 function safeHomedir() {
   try {
-    if (typeof os.homedir === 'function') {
-      const hd = os.homedir();
+    const osMod = require('os');
+    if (typeof osMod.homedir === 'function') {
+      const hd = osMod.homedir();
       if (typeof hd === 'string' && hd.length > 0) {
         return hd;
       }
@@ -38,18 +38,21 @@ function safeHomedir() {
  * @returns {string} Absolute path to the AI Fabrix home directory
  */
 function getAifabrixHome() {
-  try {
-    const configPath = path.join(safeHomedir(), '.aifabrix', 'config.yaml');
-    if (fs.existsSync(configPath)) {
-      const content = fs.readFileSync(configPath, 'utf8');
-      const config = yaml.load(content) || {};
-      const homeOverride = config && typeof config['aifabrix-home'] === 'string' ? config['aifabrix-home'].trim() : '';
-      if (homeOverride) {
-        return path.resolve(homeOverride);
+  const isTestEnv = process.env.NODE_ENV === 'test' || process.env.JEST_WORKER_ID !== undefined;
+  if (!isTestEnv) {
+    try {
+      const configPath = path.join(safeHomedir(), '.aifabrix', 'config.yaml');
+      if (fs.existsSync(configPath)) {
+        const content = fs.readFileSync(configPath, 'utf8');
+        const config = yaml.load(content) || {};
+        const homeOverride = config && typeof config['aifabrix-home'] === 'string' ? config['aifabrix-home'].trim() : '';
+        if (homeOverride) {
+          return path.resolve(homeOverride);
+        }
       }
+    } catch {
+      // Ignore errors and fall back to default
     }
-  } catch {
-    // Ignore errors and fall back to default
   }
   return path.join(safeHomedir(), '.aifabrix');
 }
@@ -73,20 +76,19 @@ function getApplicationsBaseDir(developerId) {
 
 /**
  * Returns the developer-specific application directory.
- * Dev 0: points to applications/ (no app subdirectory)
- * Dev > 0: <home>/applications-dev-{id}/{appName}-dev-{id}
+ * Dev 0: points to applications/ (root)
+ * Dev > 0: <home>/applications-dev-{id} (root)
  *
  * @param {string} appName - Application name
  * @param {number|string} developerId - Developer ID
  * @returns {string} Absolute path to developer-specific app directory
  */
 function getDevDirectory(appName, developerId) {
-  const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
   const baseDir = getApplicationsBaseDir(developerId);
-  if (idNum === 0) {
-    return baseDir;
-  }
-  return path.join(baseDir, `${appName}-dev-${developerId}`);
+  // All files should be generated at the root of the applications folder
+  // Dev 0: <home>/applications
+  // Dev > 0: <home>/applications-dev-{id}
+  return baseDir;
 }
 
 module.exports = {

package/lib/utils/secrets-generator.js

@@ -64,7 +64,7 @@ function generateSecretValue(key) {
     if (dbUrlMatch) {
       const appName = dbUrlMatch[1];
       const dbName = appName.replace(/-/g, '_');
-      return `postgresql://${dbName}_user:${dbName}_pass123@\${DB_HOST}:5432/${dbName}`;
+      return `postgresql://${dbName}_user:${dbName}_pass123@\${DB_HOST}:\${DB_PORT}/${dbName}`;
     }
     return '';
   }
@@ -188,11 +188,11 @@ postgres-passwordKeyVault: "admin123"
 
 # Redis Secrets
 redis-passwordKeyVault: ""
-redis-urlKeyVault: "redis://\${REDIS_HOST}:6379"
+redis-urlKeyVault: "redis://\${REDIS_HOST}:\${REDIS_PORT}"
 
 # Keycloak Secrets
 keycloak-admin-passwordKeyVault: "admin123"
-keycloak-auth-server-urlKeyVault: "http://\${KEYCLOAK_HOST}:8082"
+keycloak-auth-server-urlKeyVault: "http://\${KEYCLOAK_HOST}:\${KEYCLOAK_PORT}"
 `;
 
   fs.writeFileSync(resolvedPath, defaultSecrets, { mode: 0o600 });