@aifabrix/builder 2.0.0 → 2.0.3

package/lib/app-run.js

@@ -15,24 +15,30 @@ const path = require('path');
 const net = require('net');
 const chalk = require('chalk');
 const yaml = require('js-yaml');
-const handlebars = require('handlebars');
 const { exec } = require('child_process');
 const { promisify } = require('util');
 const validator = require('./validator');
 const infra = require('./infra');
 const secrets = require('./secrets');
+const logger = require('./utils/logger');
+const { waitForHealthCheck } = require('./utils/health-check');
+const composeGenerator = require('./utils/compose-generator');
 
 const execAsync = promisify(exec);
 
 /**
  * Checks if Docker image exists for the application
- * @param {string} appName - Application name
+ * @param {string} imageName - Image name (can include repository prefix)
+ * @param {string} tag - Image tag (default: latest)
  * @returns {Promise<boolean>} True if image exists
  */
-async function checkImageExists(appName) {
+async function checkImageExists(imageName, tag = 'latest') {
   try {
-    const { stdout } = await execAsync(`docker images --format "{{.Repository}}:{{.Tag}}" | grep "^${appName}:latest$"`);
-    return stdout.trim() === `${appName}:latest`;
+    const fullImageName = `${imageName}:${tag}`;
+    // Use Docker's native filtering for cross-platform compatibility (Windows-safe)
+    const { stdout } = await execAsync(`docker images --format "{{.Repository}}:{{.Tag}}" --filter "reference=${fullImageName}"`);
+    const lines = stdout.trim().split('\n').filter(line => line.trim() !== '');
+    return lines.some(line => line.trim() === fullImageName);
   } catch (error) {
     return false;
   }
@@ -58,13 +64,13 @@ async function checkContainerRunning(appName) {
  */
 async function stopAndRemoveContainer(appName) {
   try {
-    console.log(chalk.yellow(`Stopping existing container aifabrix-${appName}...`));
+    logger.log(chalk.yellow(`Stopping existing container aifabrix-${appName}...`));
     await execAsync(`docker stop aifabrix-${appName}`);
     await execAsync(`docker rm aifabrix-${appName}`);
-    console.log(chalk.green(`✓ Container aifabrix-${appName} stopped and removed`));
+    logger.log(chalk.green(`✓ Container aifabrix-${appName} stopped and removed`));
   } catch (error) {
     // Container might not exist, which is fine
-    console.log(chalk.gray(`Container aifabrix-${appName} was not running`));
+    logger.log(chalk.gray(`Container aifabrix-${appName} was not running`));
   }
 }
 
@@ -84,87 +90,227 @@ async function checkPortAvailable(port) {
 }
 
 /**
- * Generates Docker Compose configuration from template
+ * Extracts image name from configuration (same logic as build.js)
+ * @param {Object} config - Application configuration
+ * @param {string} appName - Application name (fallback)
+ * @returns {string} Image name
+ */
+function getImageName(config, appName) {
+  return composeGenerator.getImageName(config, appName);
+}
+
+/**
+ * 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) {
+  // Validate app name
+  if (!appName || typeof appName !== 'string') {
+    throw new Error('Application name is required');
+  }
+
+  // Check if we're running from inside the builder directory
+  const currentDir = process.cwd();
+  const normalizedPath = currentDir.replace(/\\/g, '/');
+  const expectedBuilderPath = `builder/${appName}`;
+
+  // If inside builder/{appName}, suggest moving to project root
+  if (normalizedPath.endsWith(expectedBuilderPath)) {
+    const projectRoot = path.resolve(currentDir, '../..');
+    throw new Error(
+      'You\'re running from inside the builder directory.\n' +
+      `Current directory: ${currentDir}\n` +
+      'Please change to the project root and try again:\n' +
+      `  cd ${projectRoot}\n` +
+      `  aifabrix run ${appName}`
+    );
+  }
+
+  // Load and validate app configuration
+  const configPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
+  if (!fsSync.existsSync(configPath)) {
+    const expectedDir = path.join(currentDir, 'builder', appName);
+    throw new Error(
+      `Application configuration not found: ${configPath}\n` +
+      `Current directory: ${currentDir}\n` +
+      `Expected location: ${expectedDir}\n` +
+      'Make sure you\'re running from the project root (where \'builder\' directory exists)\n' +
+      `Run 'aifabrix create ${appName}' first if configuration doesn't exist`
+    );
+  }
+
+  const configContent = fsSync.readFileSync(configPath, 'utf8');
+  const config = yaml.load(configContent);
+
+  // Validate configuration
+  const validation = await validator.validateApplication(appName);
+  if (!validation.valid) {
+    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 (allErrors.length === 0) {
+      throw new Error('Configuration validation failed');
+    }
+
+    throw new Error(`Configuration validation failed:\n${allErrors.join('\n')}`);
+  }
+
+  return config;
+}
+
+/**
+ * Checks prerequisites: Docker image and infrastructure
+ * @async
  * @param {string} appName - Application name
  * @param {Object} config - Application configuration
- * @param {Object} options - Run options
- * @returns {Promise<string>} Generated compose content
+ * @throws {Error} If prerequisites are not met
  */
-async function generateDockerCompose(appName, config, options) {
-  const language = config.build?.language || config.language || 'typescript';
-  const templatePath = path.join(__dirname, '..', 'templates', language, 'docker-compose.hbs');
-  if (!fsSync.existsSync(templatePath)) {
-    throw new Error(`Docker Compose template not found for language: ${language}`);
+async function checkPrerequisites(appName, config) {
+  // Extract image name from configuration (same logic as build process)
+  const imageName = getImageName(config, appName);
+  const imageTag = config.image?.tag || 'latest';
+  const fullImageName = `${imageName}:${imageTag}`;
+
+  // Check if Docker image exists
+  logger.log(chalk.blue(`Checking if image ${fullImageName} exists...`));
+  const imageExists = await checkImageExists(imageName, imageTag);
+  if (!imageExists) {
+    throw new Error(`Docker image ${fullImageName} not found\nRun 'aifabrix build ${appName}' first`);
   }
+  logger.log(chalk.green(`✓ Image ${fullImageName} found`));
 
-  const templateContent = fsSync.readFileSync(templatePath, 'utf8');
-  const template = handlebars.compile(templateContent);
-
-  const port = options.port || config.build?.localPort || config.port || 3000;
-
-  const templateData = {
-    app: {
-      key: appName,
-      name: config.displayName || appName
-    },
-    image: {
-      name: appName,
-      tag: 'latest'
-    },
-    port: config.port || 3000,
-    build: {
-      localPort: port
-    },
-    healthCheck: {
-      path: config.healthCheck?.path || '/health',
-      interval: config.healthCheck?.interval || 30
-    },
-    requiresDatabase: config.services?.database || false,
-    requiresStorage: config.services?.storage || false,
-    requiresRedis: config.services?.redis || false,
-    mountVolume: path.join(process.cwd(), 'data', appName),
-    databases: config.databases || []
-  };
+  // Check infrastructure health
+  logger.log(chalk.blue('Checking infrastructure health...'));
+  const infraHealth = await infra.checkInfraHealth();
+  const unhealthyServices = Object.entries(infraHealth)
+    .filter(([_, status]) => status !== 'healthy')
+    .map(([service, _]) => service);
 
-  return template(templateData);
+  if (unhealthyServices.length > 0) {
+    throw new Error(`Infrastructure services not healthy: ${unhealthyServices.join(', ')}\nRun 'aifabrix up' first`);
+  }
+  logger.log(chalk.green('✓ Infrastructure is running'));
 }
 
 /**
- * Waits for container health check to pass
+ * Prepares environment: ensures .env file and generates Docker Compose
+ * @async
  * @param {string} appName - Application name
- * @param {number} timeout - Timeout in seconds
+ * @param {Object} config - Application configuration
+ * @param {Object} options - Run options
+ * @returns {Promise<string>} Path to generated compose file
  */
-async function waitForHealthCheck(appName, timeout = 60) {
-  const maxAttempts = timeout / 2; // Check every 2 seconds
-  let attempts = 0;
+async function prepareEnvironment(appName, config, options) {
+  // Ensure .env file exists with 'docker' environment context (for running in Docker)
+  const envPath = path.join(process.cwd(), 'builder', appName, '.env');
+  if (!fsSync.existsSync(envPath)) {
+    logger.log(chalk.yellow('Generating .env file from template...'));
+    await secrets.generateEnvFile(appName, null, 'docker');
+  } else {
+    // Re-generate with 'docker' context to ensure correct hostnames for Docker
+    logger.log(chalk.blue('Updating .env file for Docker environment...'));
+    await secrets.generateEnvFile(appName, null, 'docker');
+  }
 
-  while (attempts < maxAttempts) {
-    try {
-      const { stdout } = await execAsync(`docker inspect --format='{{.State.Health.Status}}' aifabrix-${appName}`);
-      const status = stdout.trim();
-
-      if (status === 'healthy') {
-        return;
-      } else if (status === 'unhealthy') {
-        throw new Error(`Container aifabrix-${appName} is unhealthy`);
-      }
-
-      attempts++;
-      if (attempts < maxAttempts) {
-        console.log(chalk.yellow(`Waiting for health check... (${attempts}/${maxAttempts})`));
-        await new Promise(resolve => setTimeout(resolve, 2000));
-      }
-    } catch (error) {
-      attempts++;
-      if (attempts < maxAttempts) {
-        await new Promise(resolve => setTimeout(resolve, 2000));
-      }
+  // Also ensure .env file in apps/ directory is updated (for Docker build context)
+  const variablesPath = path.join(process.cwd(), 'builder', appName, '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) {
+      // The generateEnvFile already copies to apps/, but ensure it's using docker context
+      logger.log(chalk.blue('Ensuring .env file in apps/ directory is updated for Docker...'));
+      await secrets.generateEnvFile(appName, null, 'docker');
     }
   }
 
-  throw new Error(`Health check timeout after ${timeout} seconds`);
+  // Generate Docker Compose configuration
+  logger.log(chalk.blue('Generating Docker Compose configuration...'));
+  const composeContent = await composeGenerator.generateDockerCompose(appName, config, options);
+  // Write compose file to temporary location
+  const tempComposePath = path.join(process.cwd(), 'builder', appName, 'docker-compose.yaml');
+  await fs.writeFile(tempComposePath, composeContent);
+
+  return tempComposePath;
+}
+
+/**
+ * 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
+ * @throws {Error} If container fails to start or become healthy
+ */
+async function startContainer(appName, composePath, port, config = null) {
+  logger.log(chalk.blue(`Starting ${appName}...`));
+
+  // Ensure ADMIN_SECRETS_PATH is set for db-init service
+  const adminSecretsPath = await infra.ensureAdminSecrets();
+
+  // Load POSTGRES_PASSWORD from admin-secrets.env
+  const adminSecretsContent = fsSync.readFileSync(adminSecretsPath, 'utf8');
+  const postgresPasswordMatch = adminSecretsContent.match(/^POSTGRES_PASSWORD=(.+)$/m);
+  const postgresPassword = postgresPasswordMatch ? postgresPasswordMatch[1] : '';
+
+  // Set environment variables for docker-compose
+  const env = {
+    ...process.env,
+    ADMIN_SECRETS_PATH: adminSecretsPath,
+    POSTGRES_PASSWORD: postgresPassword
+  };
+
+  await execAsync(`docker-compose -f "${composePath}" up -d`, { env });
+  logger.log(chalk.green(`✓ Container aifabrix-${appName} started`));
+
+  // Wait for health check
+  const healthCheckPath = config?.healthCheck?.path || '/health';
+  const healthCheckUrl = `http://localhost:${port}${healthCheckPath}`;
+  logger.log(chalk.blue(`Waiting for application to be healthy at ${healthCheckUrl}...`));
+  await waitForHealthCheck(appName, 90, port, config);
+}
+
+/**
+ * Displays run status after successful start
+ * @param {string} appName - Application name
+ * @param {number} port - Application port
+ * @param {Object} config - Application configuration
+ */
+function displayRunStatus(appName, port, config) {
+  const healthCheckPath = config?.healthCheck?.path || '/health';
+  const healthCheckUrl = `http://localhost:${port}${healthCheckPath}`;
+
+  logger.log(chalk.green(`\n✓ App running at http://localhost:${port}`));
+  logger.log(chalk.blue(`Health check: ${healthCheckUrl}`));
+  logger.log(chalk.gray(`Container: aifabrix-${appName}`));
 }
 
+/**
+ * Waits for container health check to pass
+ * @param {string} appName - Application name
+ * @param {number} timeout - Timeout in seconds
+ * @param {number} port - Application port (optional, will be detected if not provided)
+ * @param {Object} config - Application configuration (optional)
+ */
+
 /**
  * Runs the application locally using Docker
  * Starts container with proper port mapping and environment
@@ -183,50 +329,16 @@ async function waitForHealthCheck(appName, timeout = 60) {
  */
 async function runApp(appName, options = {}) {
   try {
-    // Validate app name
-    if (!appName || typeof appName !== 'string') {
-      throw new Error('Application name is required');
-    }
-
-    // Load and validate app configuration
-    const configPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
-    if (!fsSync.existsSync(configPath)) {
-      throw new Error(`Application configuration not found: ${configPath}\nRun 'aifabrix create ${appName}' first`);
-    }
-
-    const configContent = fsSync.readFileSync(configPath, 'utf8');
-    const config = yaml.load(configContent);
-
-    // Validate configuration
-    const validation = await validator.validateApplication(appName);
-    if (!validation.valid) {
-      throw new Error(`Configuration validation failed:\n${validation.variables.errors.join('\n')}`);
-    }
-
-    // Check if Docker image exists
-    console.log(chalk.blue(`Checking if image ${appName}:latest exists...`));
-    const imageExists = await checkImageExists(appName);
-    if (!imageExists) {
-      throw new Error(`Docker image ${appName}:latest not found\nRun 'aifabrix build ${appName}' first`);
-    }
-    console.log(chalk.green(`✓ Image ${appName}:latest found`));
+    // Validate app name and load configuration
+    const config = await validateAppConfiguration(appName);
 
-    // Check infrastructure health
-    console.log(chalk.blue('Checking infrastructure health...'));
-    const infraHealth = await infra.checkInfraHealth();
-    const unhealthyServices = Object.entries(infraHealth)
-      .filter(([_, status]) => status !== 'healthy')
-      .map(([service, _]) => service);
-
-    if (unhealthyServices.length > 0) {
-      throw new Error(`Infrastructure services not healthy: ${unhealthyServices.join(', ')}\nRun 'aifabrix up' first`);
-    }
-    console.log(chalk.green('✓ Infrastructure is running'));
+    // Check prerequisites: image and infrastructure
+    await checkPrerequisites(appName, config);
 
     // Check if container is already running
     const containerRunning = await checkContainerRunning(appName);
     if (containerRunning) {
-      console.log(chalk.yellow(`Container aifabrix-${appName} is already running`));
+      logger.log(chalk.yellow(`Container aifabrix-${appName} is already running`));
       await stopAndRemoveContainer(appName);
     }
 
@@ -237,42 +349,21 @@ async function runApp(appName, options = {}) {
       throw new Error(`Port ${port} is already in use. Try --port <alternative>`);
     }
 
-    // Ensure .env file exists
-    const envPath = path.join(process.cwd(), 'builder', appName, '.env');
-    if (!fsSync.existsSync(envPath)) {
-      console.log(chalk.yellow('Generating .env file from template...'));
-      await secrets.generateEnvFile(appName);
-    }
-
-    // Generate Docker Compose configuration
-    console.log(chalk.blue('Generating Docker Compose configuration...'));
-    const composeContent = await generateDockerCompose(appName, config, options);
-    // Write compose file to temporary location
-    const tempComposePath = path.join(process.cwd(), 'builder', appName, 'docker-compose.yaml');
-    await fs.writeFile(tempComposePath, composeContent);
+    // Prepare environment: ensure .env file and generate Docker Compose
+    const tempComposePath = await prepareEnvironment(appName, config, options);
 
     try {
-      // Start container
-      console.log(chalk.blue(`Starting ${appName}...`));
-      await execAsync(`docker-compose -f "${tempComposePath}" up -d`);
-      console.log(chalk.green(`✓ Container aifabrix-${appName} started`));
-
-      // Wait for health check
-      console.log(chalk.blue('Waiting for application to be healthy...'));
-      await waitForHealthCheck(appName);
+      // Start container and wait for health check
+      await startContainer(appName, tempComposePath, port, config);
 
       // Display success message
-      console.log(chalk.green(`\n✓ App running at http://localhost:${port}`));
-      console.log(chalk.gray(`Container: aifabrix-${appName}`));
-      console.log(chalk.gray('Health check: /health'));
-
-    } finally {
-      // Clean up temporary compose file
-      try {
-        await fs.unlink(tempComposePath);
-      } catch (error) {
-        // Ignore cleanup errors
-      }
+      displayRunStatus(appName, port, config);
+
+    } catch (error) {
+      // Keep the compose file for debugging - don't delete on error
+      logger.log(chalk.yellow(`\n⚠️  Compose file preserved at: ${tempComposePath}`));
+      logger.log(chalk.yellow('   Review the file to debug issues'));
+      throw error;
     }
 
   } catch (error) {
@@ -286,6 +377,6 @@ module.exports = {
   checkContainerRunning,
   stopAndRemoveContainer,
   checkPortAvailable,
-  generateDockerCompose,
+  generateDockerCompose: composeGenerator.generateDockerCompose,
   waitForHealthCheck
 };