@aifabrix/builder 2.22.1 → 2.31.0

package/lib/schema/env-config.yaml

@@ -1,16 +1,23 @@
 # Environment Configuration
 # Defines host values for different deployment contexts
+#
+# Public Port Support (Docker Context):
+# For docker context, any *_PORT variable automatically gets a corresponding *_PUBLIC_PORT
+# calculated as: *_PUBLIC_PORT = *_PORT + (developer-id * 100)
+# This enables developer-specific host access ports while maintaining internal container ports.
+# Example: MISO_PORT=3000 (internal) -> MISO_PUBLIC_PORT=3100 (for developer-id 1)
+# The pattern applies to all services (MISO, KEYCLOAK, DB, REDIS, etc.) automatically.
 
 environments:
   docker:
     DB_HOST: postgres
-    DB_PORT: 5432
+    DB_PORT: 5432  # Internal port (container-to-container). DB_PUBLIC_PORT calculated automatically.
     REDIS_HOST: redis
-    REDIS_PORT: 6379
+    REDIS_PORT: 6379  # Internal port (container-to-container). REDIS_PUBLIC_PORT calculated automatically.
     MISO_HOST: miso-controller
-    MISO_PORT: 3000
+    MISO_PORT: 3000  # Internal port (container-to-container). MISO_PUBLIC_PORT calculated automatically.
     KEYCLOAK_HOST: keycloak
-    KEYCLOAK_PORT: 8082
+    KEYCLOAK_PORT: 8082  # Internal port (container-to-container). KEYCLOAK_PUBLIC_PORT calculated automatically.
     NODE_ENV: production
     PYTHONUNBUFFERED: 1
     PYTHONDONTWRITEBYTECODE: 1

package/lib/template-validator.js

@@ -11,6 +11,7 @@
 const fs = require('fs').promises;
 const fsSync = require('fs');
 const path = require('path');
+const { getProjectRoot } = require('./utils/paths');
 
 /**
  * Validates that a template exists and contains files
@@ -23,7 +24,9 @@ async function validateTemplate(templateName) {
     throw new Error('Template name is required and must be a string');
   }
 
-  const templatePath = path.join(__dirname, '..', 'templates', 'applications', templateName);
+  // Use getProjectRoot to reliably find templates in all environments (including CI)
+  const projectRoot = getProjectRoot();
+  const templatePath = path.join(projectRoot, 'templates', 'applications', templateName);
 
   // Check if template folder exists
   if (!fsSync.existsSync(templatePath)) {
@@ -63,7 +66,9 @@ async function copyTemplateFiles(templateName, appPath) {
   // Validate template first
   await validateTemplate(templateName);
 
-  const templatePath = path.join(__dirname, '..', 'templates', 'applications', templateName);
+  // Use getProjectRoot to reliably find templates in all environments (including CI)
+  const projectRoot = getProjectRoot();
+  const templatePath = path.join(projectRoot, 'templates', 'applications', templateName);
   const copiedFiles = [];
 
   async function copyDirectory(sourceDir, targetDir) {
@@ -113,7 +118,9 @@ async function copyAppFiles(language, appPath) {
   }
 
   const normalizedLanguage = language.toLowerCase();
-  const languageTemplatePath = path.join(__dirname, '..', 'templates', normalizedLanguage);
+  // Use getProjectRoot to reliably find templates in all environments (including CI)
+  const projectRoot = getProjectRoot();
+  const languageTemplatePath = path.join(projectRoot, 'templates', normalizedLanguage);
 
   // Check if language template folder exists
   if (!fsSync.existsSync(languageTemplatePath)) {
@@ -166,7 +173,9 @@ async function copyAppFiles(language, appPath) {
  * @returns {Promise<string[]>} Array of available template names
  */
 async function listAvailableTemplates() {
-  const templatesDir = path.join(__dirname, '..', 'templates', 'applications');
+  // Use getProjectRoot to reliably find templates in all environments (including CI)
+  const projectRoot = getProjectRoot();
+  const templatesDir = path.join(projectRoot, 'templates', 'applications');
 
   if (!fsSync.existsSync(templatesDir)) {
     return [];

package/lib/utils/api.js

@@ -27,14 +27,14 @@ async function logApiPerformance(params) {
   // Log all API calls (both success and failure) to audit log for troubleshooting
   // This helps track what API calls were made when errors occur
   try {
-    await auditLogger.logApiCall(
-      params.url,
-      params.options,
-      params.statusCode,
-      params.duration,
-      params.success,
-      params.errorInfo || {}
-    );
+    await auditLogger.logApiCall({
+      url: params.url,
+      options: params.options,
+      statusCode: params.statusCode,
+      duration: params.duration,
+      success: params.success,
+      errorInfo: params.errorInfo || {}
+    });
   } catch (logError) {
     // Don't fail the API call if audit logging fails
     // Silently continue - audit logging should never break functionality

package/lib/utils/app-register-auth.js

@@ -47,6 +47,38 @@ function displayAuthenticationError(error = null, controllerUrlOrData = null) {
   process.exit(1);
 }
 
+/**
+ * Find device token from config by trying each stored URL
+ * @async
+ * @param {Object} deviceConfig - Device configuration object
+ * @param {Array} attemptedUrls - Array to track attempted URLs
+ * @returns {Promise<Object|null>} Token result with token and controllerUrl, or null if not found
+ */
+async function findDeviceTokenFromConfig(deviceConfig, attemptedUrls) {
+  const deviceUrls = Object.keys(deviceConfig);
+  if (deviceUrls.length === 0) {
+    return null;
+  }
+
+  for (const storedUrl of deviceUrls) {
+    attemptedUrls.push(storedUrl);
+    try {
+      const normalizedStoredUrl = normalizeControllerUrl(storedUrl);
+      const deviceToken = await getOrRefreshDeviceToken(normalizedStoredUrl);
+      if (deviceToken && deviceToken.token) {
+        return {
+          token: deviceToken.token,
+          controllerUrl: deviceToken.controller || normalizedStoredUrl
+        };
+      }
+    } catch (error) {
+      // Continue to next URL
+    }
+  }
+
+  return null;
+}
+
 /**
  * Check if user is authenticated and get token
  * @async
@@ -83,24 +115,10 @@ async function checkAuthentication(controllerUrl, environment) {
 
     // If no token yet, try to find any device token in config
     if (!token && config.device) {
-      const deviceUrls = Object.keys(config.device);
-      if (deviceUrls.length > 0) {
-        // Try each device token until we find a valid one
-        for (const storedUrl of deviceUrls) {
-          attemptedUrls.push(storedUrl);
-          try {
-            const normalizedStoredUrl = normalizeControllerUrl(storedUrl);
-            const deviceToken = await getOrRefreshDeviceToken(normalizedStoredUrl);
-            if (deviceToken && deviceToken.token) {
-              token = deviceToken.token;
-              finalControllerUrl = deviceToken.controller || normalizedStoredUrl;
-              break;
-            }
-          } catch (error) {
-            lastError = error;
-            // Continue to next URL
-          }
-        }
+      const tokenResult = await findDeviceTokenFromConfig(config.device, attemptedUrls);
+      if (tokenResult) {
+        token = tokenResult.token;
+        finalControllerUrl = tokenResult.controllerUrl;
       }
     }
 

package/lib/utils/app-run-containers.js

@@ -0,0 +1,140 @@
+/**
+ * AI Fabrix Builder - App Run Container Helpers
+ *
+ * Container-related helper functions for application run workflow.
+ * Extracted from app-run-helpers.js to reduce file size.
+ *
+ * @fileoverview Container helper functions for application run workflow
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const chalk = require('chalk');
+const logger = require('./logger');
+
+const execAsync = promisify(exec);
+
+/**
+ * Checks if Docker image exists for the application
+ * @param {string} imageName - Image name (can include repository prefix)
+ * @param {string} tag - Image tag (default: latest)
+ * @param {boolean} [debug=false] - Enable debug logging
+ * @returns {Promise<boolean>} True if image exists
+ */
+async function checkImageExists(imageName, tag = 'latest', debug = false) {
+  try {
+    const fullImageName = `${imageName}:${tag}`;
+    const cmd = `docker images --format "{{.Repository}}:{{.Tag}}" --filter "reference=${fullImageName}"`;
+    if (debug) {
+      logger.log(chalk.gray(`[DEBUG] Executing: ${cmd}`));
+    }
+    const { stdout } = await execAsync(cmd);
+    const lines = stdout.trim().split('\n').filter(line => line.trim() !== '');
+    const exists = lines.some(line => line.trim() === fullImageName);
+    if (debug) {
+      logger.log(chalk.gray(`[DEBUG] Image ${fullImageName} exists: ${exists}`));
+    }
+    return exists;
+  } catch (error) {
+    if (debug) {
+      logger.log(chalk.gray(`[DEBUG] Image check failed: ${error.message}`));
+    }
+    return false;
+  }
+}
+
+/**
+ * Checks if container is already running
+ * @param {string} appName - Application name
+ * @param {number|string} developerId - Developer ID (0 = default infra, > 0 = developer-specific; string allowed)
+ * @param {boolean} [debug=false] - Enable debug logging
+ * @returns {Promise<boolean>} True if container is running
+ */
+async function checkContainerRunning(appName, developerId, debug = false) {
+  try {
+    const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
+    const containerName = idNum === 0 ? `aifabrix-${appName}` : `aifabrix-dev${developerId}-${appName}`;
+    const cmd = `docker ps --filter "name=${containerName}" --format "{{.Names}}"`;
+    if (debug) {
+      logger.log(chalk.gray(`[DEBUG] Executing: ${cmd}`));
+    }
+    const { stdout } = await execAsync(cmd);
+    const isRunning = stdout.trim() === containerName;
+    if (debug) {
+      logger.log(chalk.gray(`[DEBUG] Container ${containerName} running: ${isRunning}`));
+      if (isRunning) {
+        const statusCmd = `docker ps --filter "name=${containerName}" --format "{{.Status}}"`;
+        const { stdout: status } = await execAsync(statusCmd);
+        const portsCmd = `docker ps --filter "name=${containerName}" --format "{{.Ports}}"`;
+        const { stdout: ports } = await execAsync(portsCmd);
+        logger.log(chalk.gray(`[DEBUG] Container status: ${status.trim()}`));
+        logger.log(chalk.gray(`[DEBUG] Container ports: ${ports.trim()}`));
+      }
+    }
+    return isRunning;
+  } catch (error) {
+    if (debug) {
+      logger.log(chalk.gray(`[DEBUG] Container check failed: ${error.message}`));
+    }
+    return false;
+  }
+}
+
+/**
+ * Stops and removes existing container
+ * @param {string} appName - Application name
+ * @param {number|string} developerId - Developer ID (0 = default infra, > 0 = developer-specific; string allowed)
+ * @param {boolean} [debug=false] - Enable debug logging
+ */
+async function stopAndRemoveContainer(appName, developerId, debug = false) {
+  try {
+    const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
+    const containerName = idNum === 0 ? `aifabrix-${appName}` : `aifabrix-dev${developerId}-${appName}`;
+    logger.log(chalk.yellow(`Stopping existing container ${containerName}...`));
+    const stopCmd = `docker stop ${containerName}`;
+    if (debug) {
+      logger.log(chalk.gray(`[DEBUG] Executing: ${stopCmd}`));
+    }
+    await execAsync(stopCmd);
+    const rmCmd = `docker rm ${containerName}`;
+    if (debug) {
+      logger.log(chalk.gray(`[DEBUG] Executing: ${rmCmd}`));
+    }
+    await execAsync(rmCmd);
+    logger.log(chalk.green(`✓ Container ${containerName} stopped and removed`));
+  } catch (error) {
+    if (debug) {
+      logger.log(chalk.gray(`[DEBUG] Stop/remove container error: ${error.message}`));
+    }
+    const idNum2 = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
+    const containerName = idNum2 === 0 ? `aifabrix-${appName}` : `aifabrix-dev${developerId}-${appName}`;
+    logger.log(chalk.gray(`Container ${containerName} was not running`));
+  }
+}
+
+/**
+ * Log container status for debugging
+ * @async
+ * @param {string} containerName - Container name
+ * @param {boolean} debug - Enable debug logging
+ */
+async function logContainerStatus(containerName, debug) {
+  if (debug) {
+    const statusCmd = `docker ps --filter "name=${containerName}" --format "{{.Status}}"`;
+    const { stdout: status } = await execAsync(statusCmd);
+    const portsCmd = `docker ps --filter "name=${containerName}" --format "{{.Ports}}"`;
+    const { stdout: ports } = await execAsync(portsCmd);
+    logger.log(chalk.gray(`[DEBUG] Container status: ${status.trim()}`));
+    logger.log(chalk.gray(`[DEBUG] Container ports: ${ports.trim()}`));
+  }
+}
+
+module.exports = {
+  checkImageExists,
+  checkContainerRunning,
+  stopAndRemoveContainer,
+  logContainerStatus
+};
+

package/lib/utils/auth-headers.js

@@ -47,10 +47,10 @@ function createClientCredentialsHeaders(clientId, clientSecret) {
  * Supports both Bearer token and client credentials authentication
  *
  * @param {Object} authConfig - Authentication configuration
- * @param {string} authConfig.type - Auth type: 'bearer' or 'credentials'
+ * @param {string} authConfig.type - Auth type: 'bearer' or 'client-credentials'
  * @param {string} [authConfig.token] - Bearer token (for type 'bearer')
- * @param {string} [authConfig.clientId] - Client ID (for type 'credentials')
- * @param {string} [authConfig.clientSecret] - Client secret (for type 'credentials')
+ * @param {string} [authConfig.clientId] - Client ID (for type 'client-credentials')
+ * @param {string} [authConfig.clientSecret] - Client secret (for type 'client-credentials')
  * @returns {Object} Headers object with authentication
  * @throws {Error} If auth config is invalid
  */
@@ -66,14 +66,14 @@ function createAuthHeaders(authConfig) {
     return createBearerTokenHeaders(authConfig.token);
   }
 
-  if (authConfig.type === 'credentials') {
+  if (authConfig.type === 'client-credentials') {
     if (!authConfig.clientId || !authConfig.clientSecret) {
-      throw new Error('Client ID and Client Secret are required for credentials authentication');
+      throw new Error('Client ID and Client Secret are required for client-credentials authentication');
     }
     return createClientCredentialsHeaders(authConfig.clientId, authConfig.clientSecret);
   }
 
-  throw new Error(`Invalid authentication type: ${authConfig.type}. Must be 'bearer' or 'credentials'`);
+  throw new Error(`Invalid authentication type: ${authConfig.type}. Must be 'bearer' or 'client-credentials'`);
 }
 
 module.exports = {

package/lib/utils/build-copy.js

@@ -31,7 +31,7 @@ const paths = require('./paths');
  * // Returns: '~/.aifabrix/applications-dev-1'
  */
 async function copyBuilderToDevDirectory(appName, developerId) {
-  const builderPath = path.join(process.cwd(), 'builder', appName);
+  const builderPath = paths.getBuilderPath(appName);
 
   // Ensure builder directory exists
   if (!fsSync.existsSync(builderPath)) {
@@ -140,10 +140,68 @@ function devDirectoryExists(appName, developerId) {
   return fsSync.existsSync(devDir);
 }
 
+/**
+ * Copies application template files to dev directory
+ * Used when apps directory doesn't exist to ensure build can proceed
+ * @async
+ * @param {string} templatePath - Path to template directory
+ * @param {string} devDir - Target dev directory
+ * @param {string} _language - Language (typescript/python) - currently unused but kept for future use
+ * @throws {Error} If copying fails
+ */
+async function copyTemplateFilesToDevDir(templatePath, devDir, _language) {
+  if (!fsSync.existsSync(templatePath)) {
+    throw new Error(`Template path not found: ${templatePath}`);
+  }
+
+  // Ensure dev directory exists before copying files
+  await fs.mkdir(devDir, { recursive: true });
+
+  const entries = await fs.readdir(templatePath);
+
+  // Copy only application files, skip Dockerfile and docker-compose templates
+  const appFiles = entries.filter(entry => {
+    const lowerEntry = entry.toLowerCase();
+    // Include .gitignore, exclude .hbs files and docker-related files
+    if (entry === '.gitignore') {
+      return true;
+    }
+    if (lowerEntry.endsWith('.hbs')) {
+      return false;
+    }
+    if (lowerEntry.startsWith('dockerfile') || lowerEntry.includes('docker-compose')) {
+      return false;
+    }
+    if (entry.startsWith('.') && entry !== '.gitignore') {
+      return false;
+    }
+    return true;
+  });
+
+  for (const entry of appFiles) {
+    const sourcePath = path.join(templatePath, entry);
+    const targetPath = path.join(devDir, entry);
+
+    // Skip if source file doesn't exist (e.g., .gitignore might not be in template)
+    try {
+      const entryStats = await fs.stat(sourcePath);
+      if (entryStats.isFile()) {
+        await fs.copyFile(sourcePath, targetPath);
+      }
+    } catch (error) {
+      // Skip files that don't exist (e.g., .gitignore might not be in template)
+      if (error.code !== 'ENOENT') {
+        throw error;
+      }
+    }
+  }
+}
+
 module.exports = {
   copyBuilderToDevDirectory,
   copyAppSourceFiles,
   getDevDirectory,
-  devDirectoryExists
+  devDirectoryExists,
+  copyTemplateFilesToDevDir
 };
 

package/lib/utils/build-helpers.js

@@ -0,0 +1,94 @@
+/**
+ * Build Helper Functions
+ *
+ * Helper functions for build operations.
+ * Separated from build.js to maintain file size limits.
+ *
+ * @fileoverview Build helper functions
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const path = require('path');
+const dockerfileUtils = require('./dockerfile-utils');
+const logger = require('./logger');
+const chalk = require('chalk');
+
+/**
+ * Determine Dockerfile path (template, custom, or generate)
+ * @async
+ * @param {string} appName - Application name
+ * @param {Object} options - Options with language, config, buildConfig, contextPath, forceTemplate, devDir
+ * @param {Function} generateDockerfileFn - Function to generate Dockerfile
+ * @returns {Promise<string>} Path to Dockerfile
+ */
+async function determineDockerfile(appName, options, generateDockerfileFn) {
+  // Use dev directory if provided, otherwise fall back to builder directory
+  const searchPath = options.devDir || path.join(process.cwd(), 'builder', appName);
+
+  const templateDockerfile = dockerfileUtils.checkTemplateDockerfile(searchPath, appName, options.forceTemplate);
+  if (templateDockerfile) {
+    const relativePath = path.relative(process.cwd(), templateDockerfile);
+    logger.log(chalk.green(`✓ Using existing Dockerfile: ${relativePath}`));
+    return templateDockerfile;
+  }
+
+  const customDockerfile = dockerfileUtils.checkProjectDockerfile(searchPath, appName, options.buildConfig, options.contextPath, options.forceTemplate);
+  if (customDockerfile) {
+    logger.log(chalk.green(`✓ Using custom Dockerfile: ${options.buildConfig.dockerfile}`));
+    return customDockerfile;
+  }
+
+  // Generate Dockerfile in dev directory if provided
+  const dockerfilePath = await generateDockerfileFn(appName, options.language, options.config, options.buildConfig, options.devDir);
+  const relativePath = path.relative(process.cwd(), dockerfilePath);
+  logger.log(chalk.green(`✓ Generated Dockerfile from template: ${relativePath}`));
+  return dockerfilePath;
+}
+
+/**
+ * Loads and validates configuration for build
+ * @async
+ * @param {string} appName - Application name
+ * @returns {Promise<Object>} Configuration object with config, imageName, and buildConfig
+ * @throws {Error} If configuration cannot be loaded or validated
+ */
+async function loadAndValidateConfig(appName) {
+  const { loadVariablesYaml } = require('../build');
+  const validator = require('../validator');
+
+  const variables = await loadVariablesYaml(appName);
+
+  // Validate configuration
+  const validation = await validator.validateVariables(appName);
+  if (!validation.valid) {
+    throw new Error(`Configuration validation failed:\n${validation.errors.join('\n')}`);
+  }
+
+  // Extract image name
+  let imageName;
+  if (typeof variables.image === 'string') {
+    imageName = variables.image.split(':')[0];
+  } else if (variables.image?.name) {
+    imageName = variables.image.name;
+  } else if (variables.app?.key) {
+    imageName = variables.app.key;
+  } else {
+    imageName = appName;
+  }
+
+  // Extract build config
+  const buildConfig = variables.build || {};
+
+  return {
+    config: variables,
+    imageName,
+    buildConfig
+  };
+}
+
+module.exports = {
+  determineDockerfile,
+  loadAndValidateConfig
+};
+