@aifabrix/builder 2.22.2 → 2.31.0

package/lib/app-run-helpers.js

@@ -25,119 +25,21 @@ const logger = require('./utils/logger');
 const { waitForHealthCheck } = require('./utils/health-check');
 const composeGenerator = require('./utils/compose-generator');
 const dockerUtils = require('./utils/docker');
+const containerHelpers = require('./utils/app-run-containers');
 
 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;
-  }
-}
+// Re-export container helper functions
+const checkImageExists = containerHelpers.checkImageExists;
+const checkContainerRunning = containerHelpers.checkContainerRunning;
+const stopAndRemoveContainer = containerHelpers.stopAndRemoveContainer;
 
 /**
- * Stops and removes existing container
+ * Check if running from builder directory
  * @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
+ * @throws {Error} If running from builder directory
  */
-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`));
-  }
-}
-
-/**
- * Validates app name and loads configuration
- * @async
- * @param {string} appName - Application name
- * @returns {Promise<Object>} Application configuration
- * @throws {Error} If validation fails
- */
-async function validateAppConfiguration(appName) {
-  if (!appName || typeof appName !== 'string') {
-    throw new Error('Application name is required');
-  }
-
+function checkBuilderDirectory(appName) {
   const currentDir = process.cwd();
   const normalizedPath = currentDir.replace(/\\/g, '/');
   const expectedBuilderPath = `builder/${appName}`;
@@ -152,8 +54,17 @@ async function validateAppConfiguration(appName) {
       `  aifabrix run ${appName}`
     );
   }
+}
 
-  const configPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
+/**
+ * Load and validate config file exists
+ * @param {string} appName - Application name
+ * @returns {Object} Application configuration
+ * @throws {Error} If config file not found
+ */
+function loadAppConfig(appName) {
+  const currentDir = process.cwd();
+  const configPath = path.join(currentDir, 'builder', appName, 'variables.yaml');
   if (!fsSync.existsSync(configPath)) {
     const expectedDir = path.join(currentDir, 'builder', appName);
     throw new Error(
@@ -166,29 +77,58 @@ async function validateAppConfiguration(appName) {
   }
 
   const configContent = fsSync.readFileSync(configPath, 'utf8');
-  const appConfig = yaml.load(configContent);
+  return yaml.load(configContent);
+}
 
-  const validation = await validator.validateApplication(appName);
-  if (!validation.valid) {
-    const allErrors = [];
+/**
+ * Format validation errors
+ * @param {Object} validation - Validation result
+ * @returns {Array<string>} Formatted error messages
+ */
+function formatValidationErrors(validation) {
+  const allErrors = [];
 
-    if (validation.variables && validation.variables.errors && validation.variables.errors.length > 0) {
-      allErrors.push('variables.yaml:');
-      allErrors.push(...validation.variables.errors.map(err => `  ${err}`));
-    }
-    if (validation.rbac && validation.rbac.errors && validation.rbac.errors.length > 0) {
-      allErrors.push('rbac.yaml:');
-      allErrors.push(...validation.rbac.errors.map(err => `  ${err}`));
-    }
-    if (validation.env && validation.env.errors && validation.env.errors.length > 0) {
-      allErrors.push('env.template:');
-      allErrors.push(...validation.env.errors.map(err => `  ${err}`));
-    }
+  if (validation.variables && validation.variables.errors && validation.variables.errors.length > 0) {
+    allErrors.push('variables.yaml:');
+    allErrors.push(...validation.variables.errors.map(err => `  ${err}`));
+  }
+  if (validation.rbac && validation.rbac.errors && validation.rbac.errors.length > 0) {
+    allErrors.push('rbac.yaml:');
+    allErrors.push(...validation.rbac.errors.map(err => `  ${err}`));
+  }
+  if (validation.env && validation.env.errors && validation.env.errors.length > 0) {
+    allErrors.push('env.template:');
+    allErrors.push(...validation.env.errors.map(err => `  ${err}`));
+  }
+
+  return allErrors;
+}
+
+/**
+ * Validates app name and loads configuration
+ * @async
+ * @param {string} appName - Application name
+ * @returns {Promise<Object>} Application configuration
+ * @throws {Error} If validation fails
+ */
+async function validateAppConfiguration(appName) {
+  if (!appName || typeof appName !== 'string') {
+    throw new Error('Application name is required');
+  }
 
+  // Check if running from builder directory
+  checkBuilderDirectory(appName);
+
+  // Load config
+  const appConfig = loadAppConfig(appName);
+
+  // Validate configuration
+  const validation = await validator.validateApplication(appName);
+  if (!validation.valid) {
+    const allErrors = formatValidationErrors(validation);
     if (allErrors.length === 0) {
       throw new Error('Configuration validation failed');
     }
-
     throw new Error(`Configuration validation failed:\n${allErrors.join('\n')}`);
   }
 
@@ -235,22 +175,27 @@ async function checkPrerequisites(appName, appConfig, debug = false) {
 }
 
 /**
- * Prepares environment: ensures .env file and generates Docker Compose
+ * Ensure dev directory exists
  * @async
  * @param {string} appName - Application name
- * @param {Object} appConfig - Application configuration
- * @param {Object} options - Run options
- * @returns {Promise<string>} Path to generated compose file
+ * @param {string} developerId - Developer ID
+ * @returns {Promise<string>} Dev directory path
  */
-async function prepareEnvironment(appName, appConfig, options) {
-  const developerId = await config.getDeveloperId();
+async function ensureDevDirectory(appName, developerId) {
   const devDir = buildCopy.getDevDirectory(appName, developerId);
-
   if (!fsSync.existsSync(devDir)) {
     await buildCopy.copyBuilderToDevDirectory(appName, developerId);
   }
+  return devDir;
+}
 
-  const builderEnvPath = path.join(process.cwd(), 'builder', appName, '.env');
+/**
+ * Generate or update .env file for Docker
+ * @async
+ * @param {string} appName - Application name
+ * @param {string} builderEnvPath - Path to builder .env file
+ */
+async function ensureEnvFile(appName, builderEnvPath) {
   if (!fsSync.existsSync(builderEnvPath)) {
     logger.log(chalk.yellow('Generating .env file from template...'));
     await secrets.generateEnvFile(appName, null, 'docker');
@@ -258,60 +203,113 @@ async function prepareEnvironment(appName, appConfig, options) {
     logger.log(chalk.blue('Updating .env file for Docker environment...'));
     await secrets.generateEnvFile(appName, null, 'docker');
   }
+}
 
-  const devEnvPath = path.join(devDir, '.env');
+/**
+ * Copy .env file to dev directory
+ * @async
+ * @param {string} builderEnvPath - Path to builder .env file
+ * @param {string} devEnvPath - Path to dev .env file
+ */
+async function copyEnvToDev(builderEnvPath, devEnvPath) {
   if (fsSync.existsSync(builderEnvPath)) {
     await fs.copyFile(builderEnvPath, devEnvPath);
   }
+}
 
-  const variablesPath = path.join(devDir, 'variables.yaml');
-  if (fsSync.existsSync(variablesPath)) {
-    const variablesContent = fsSync.readFileSync(variablesPath, 'utf8');
-    const variables = yaml.load(variablesContent);
-
-    if (variables?.build?.envOutputPath && variables.build.envOutputPath !== null) {
-      logger.log(chalk.blue('Ensuring .env file in apps/ directory is updated for Docker...'));
-      await secrets.generateEnvFile(appName, null, 'docker');
-      if (fsSync.existsSync(builderEnvPath)) {
-        await fs.copyFile(builderEnvPath, devEnvPath);
-      }
-    }
+/**
+ * Handle envOutputPath configuration
+ * @async
+ * @param {string} appName - Application name
+ * @param {string} variablesPath - Path to variables.yaml
+ * @param {string} builderEnvPath - Path to builder .env file
+ * @param {string} devEnvPath - Path to dev .env file
+ */
+async function handleEnvOutputPath(appName, variablesPath, builderEnvPath, devEnvPath) {
+  if (!fsSync.existsSync(variablesPath)) {
+    return;
   }
 
-  logger.log(chalk.blue('Generating Docker Compose configuration...'));
-  const composeOptions = { ...options };
-  if (!composeOptions.port) {
-    const basePort = appConfig.port || 3000;
-    const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
-    composeOptions.port = idNum === 0 ? basePort : basePort + (idNum * 100);
+  const variablesContent = fsSync.readFileSync(variablesPath, 'utf8');
+  const variables = yaml.load(variablesContent);
+
+  if (variables?.build?.envOutputPath && variables.build.envOutputPath !== null) {
+    logger.log(chalk.blue('Ensuring .env file in apps/ directory is updated for Docker...'));
+    await secrets.generateEnvFile(appName, null, 'docker');
+    await copyEnvToDev(builderEnvPath, devEnvPath);
   }
-  const composeContent = await composeGenerator.generateDockerCompose(appName, appConfig, composeOptions);
+}
 
-  if (!fsSync.existsSync(devDir)) {
-    await buildCopy.copyBuilderToDevDirectory(appName, developerId);
+/**
+ * Calculate compose port from options or app config
+ * @param {Object} options - Run options
+ * @param {Object} appConfig - Application configuration
+ * @param {string} developerId - Developer ID
+ * @returns {number} Port number
+ */
+function calculateComposePort(options, appConfig, developerId) {
+  if (options.port) {
+    return options.port;
   }
+  const basePort = appConfig.port || 3000;
+  const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
+  return idNum === 0 ? basePort : basePort + (idNum * 100);
+}
+
+/**
+ * Generate and write Docker Compose file
+ * @async
+ * @param {string} appName - Application name
+ * @param {Object} appConfig - Application configuration
+ * @param {Object} composeOptions - Compose options
+ * @param {string} devDir - Dev directory path
+ * @returns {Promise<string>} Path to compose file
+ */
+async function generateComposeFile(appName, appConfig, composeOptions, devDir) {
+  logger.log(chalk.blue('Generating Docker Compose configuration...'));
+  const composeContent = await composeGenerator.generateDockerCompose(appName, appConfig, composeOptions);
   const tempComposePath = path.join(devDir, 'docker-compose.yaml');
   await fs.writeFile(tempComposePath, composeContent);
-
   return tempComposePath;
 }
 
 /**
- * Starts the container and waits for health check
+ * Prepares environment: ensures .env file and generates Docker Compose
  * @async
  * @param {string} appName - Application name
- * @param {string} composePath - Path to Docker Compose file
- * @param {number} port - Application port
  * @param {Object} appConfig - Application configuration
- * @param {boolean} [debug=false] - Enable debug logging
- * @throws {Error} If container fails to start or become healthy
+ * @param {Object} options - Run options
+ * @returns {Promise<string>} Path to generated compose file
  */
-async function startContainer(appName, composePath, port, appConfig = null, debug = false) {
-  logger.log(chalk.blue(`Starting ${appName}...`));
+async function prepareEnvironment(appName, appConfig, options) {
+  const developerId = await config.getDeveloperId();
+  const devDir = await ensureDevDirectory(appName, developerId);
 
-  // Ensure Docker + Compose available and determine correct compose command
-  const composeCmdBase = await dockerUtils.ensureDockerAndCompose().then(() => dockerUtils.getComposeCommand());
+  // Generate/update .env file
+  const builderEnvPath = path.join(process.cwd(), 'builder', appName, '.env');
+  await ensureEnvFile(appName, builderEnvPath);
 
+  // Copy .env to dev directory
+  const devEnvPath = path.join(devDir, '.env');
+  await copyEnvToDev(builderEnvPath, devEnvPath);
+
+  // Handle envOutputPath if configured
+  const variablesPath = path.join(devDir, 'variables.yaml');
+  await handleEnvOutputPath(appName, variablesPath, builderEnvPath, devEnvPath);
+
+  // Generate Docker Compose
+  const composeOptions = { ...options };
+  composeOptions.port = calculateComposePort(composeOptions, appConfig, developerId);
+  return await generateComposeFile(appName, appConfig, composeOptions, devDir);
+}
+
+/**
+ * Prepare environment variables from admin secrets
+ * @async
+ * @param {boolean} debug - Enable debug logging
+ * @returns {Promise<Object>} Environment variables object
+ */
+async function prepareContainerEnv(debug) {
   const adminSecretsPath = await infra.ensureAdminSecrets();
   if (debug) {
     logger.log(chalk.gray(`[DEBUG] Admin secrets path: ${adminSecretsPath}`));
@@ -331,25 +329,55 @@ async function startContainer(appName, composePath, port, appConfig = null, debu
     logger.log(chalk.gray(`[DEBUG] Environment variables: ADMIN_SECRETS_PATH=${adminSecretsPath}, POSTGRES_PASSWORD=${postgresPassword ? '***' : '(not set)'}`));
   }
 
+  return env;
+}
+
+/**
+ * Execute docker-compose up command
+ * @async
+ * @param {string} composeCmdBase - Base compose command
+ * @param {string} composePath - Path to compose file
+ * @param {Object} env - Environment variables
+ * @param {boolean} debug - Enable debug logging
+ */
+async function executeComposeUp(composeCmdBase, composePath, env, debug) {
   const composeCmd = `${composeCmdBase} -f "${composePath}" up -d`;
   if (debug) {
     logger.log(chalk.gray(`[DEBUG] Executing: ${composeCmd}`));
     logger.log(chalk.gray(`[DEBUG] Compose file: ${composePath}`));
   }
   await execAsync(composeCmd, { env });
+}
 
+/**
+ * Starts the container and waits for health check
+ * @async
+ * @param {string} appName - Application name
+ * @param {string} composePath - Path to Docker Compose file
+ * @param {number} port - Application port
+ * @param {Object} appConfig - Application configuration
+ * @param {boolean} [debug=false] - Enable debug logging
+ * @throws {Error} If container fails to start or become healthy
+ */
+async function startContainer(appName, composePath, port, appConfig = null, debug = false) {
+  logger.log(chalk.blue(`Starting ${appName}...`));
+
+  // Ensure Docker + Compose available and determine correct compose command
+  const composeCmdBase = await dockerUtils.ensureDockerAndCompose().then(() => dockerUtils.getComposeCommand());
+
+  // Prepare environment variables
+  const env = await prepareContainerEnv(debug);
+
+  // Execute compose up
+  await executeComposeUp(composeCmdBase, composePath, env, debug);
+
+  // Get container name and log status
   const idNum = typeof appConfig.developerId === 'string' ? parseInt(appConfig.developerId, 10) : appConfig.developerId;
   const containerName = idNum === 0 ? `aifabrix-${appName}` : `aifabrix-dev${appConfig.developerId}-${appName}`;
   logger.log(chalk.green(`✓ Container ${containerName} started`));
-  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()}`));
-  }
+  await containerHelpers.logContainerStatus(containerName, debug);
 
+  // Wait for health check
   const healthCheckPath = appConfig?.healthCheck?.path || '/health';
   logger.log(chalk.blue(`Waiting for application to be healthy at http://localhost:${port}${healthCheckPath}...`));
   await waitForHealthCheck(appName, 90, port, appConfig, debug);