@aifabrix/builder 2.0.0 → 2.0.3

package/lib/utils/docker-build.js

@@ -0,0 +1,173 @@
+/**
+ * Docker Build Utilities
+ *
+ * This module handles Docker image building with progress indicators.
+ * Separated from build.js to maintain file size limits.
+ *
+ * @fileoverview Docker build execution utilities
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { spawn } = require('child_process');
+const ora = require('ora');
+
+/**
+ * Checks if error indicates Docker is not running or not installed
+ * @param {string} errorMessage - Error message to check
+ * @returns {boolean} True if Docker is not available
+ */
+function isDockerNotAvailableError(errorMessage) {
+  return errorMessage.includes('docker: command not found') ||
+         errorMessage.includes('Cannot connect to the Docker daemon') ||
+         errorMessage.includes('Is the docker daemon running') ||
+         errorMessage.includes('Cannot connect to Docker');
+}
+
+/**
+ * Parses Docker build output to extract progress information
+ * @param {string} line - Single line of Docker build output
+ * @returns {string|null} Progress message or null if no progress info
+ */
+function parseDockerBuildProgress(line) {
+  // Match step progress: "Step 1/10 : FROM node:20-alpine"
+  const stepMatch = line.match(/^Step\s+(\d+)\/(\d+)\s*:/i);
+  if (stepMatch) {
+    return `Step ${stepMatch[1]}/${stepMatch[2]}`;
+  }
+
+  // Match layer pulling: "Pulling from library/node"
+  const pullingMatch = line.match(/^Pulling\s+(.+)$/i);
+  if (pullingMatch) {
+    return `Pulling ${pullingMatch[1]}`;
+  }
+
+  // Match layer extracting: "Extracting [====>     ]"
+  const extractingMatch = line.match(/^Extracting/i);
+  if (extractingMatch) {
+    return 'Extracting layers';
+  }
+
+  // Match build progress: " => [internal] load build context"
+  const buildMatch = line.match(/^=>\s*\[(.*?)\]\s*(.+)$/i);
+  if (buildMatch) {
+    return buildMatch[2].substring(0, 50);
+  }
+
+  // Match progress bars: "[====>     ] 10.5MB/50MB"
+  const progressMatch = line.match(/\[.*?\]\s+([\d.]+(MB|KB|GB))\/([\d.]+(MB|KB|GB))/i);
+  if (progressMatch) {
+    return `${progressMatch[1]}/${progressMatch[3]}`;
+  }
+
+  return null;
+}
+
+/**
+ * Executes Docker build command with progress indicator
+ * @param {string} imageName - Image name to build
+ * @param {string} dockerfilePath - Path to Dockerfile
+ * @param {string} contextPath - Build context path
+ * @param {string} tag - Image tag
+ * @returns {Promise<void>} Resolves when build completes
+ * @throws {Error} If build fails
+ */
+async function executeDockerBuild(imageName, dockerfilePath, contextPath, tag) {
+  const spinner = ora({
+    text: 'Starting Docker build...',
+    spinner: 'dots'
+  }).start();
+
+  return new Promise((resolve, reject) => {
+    // Use spawn for streaming output
+    const dockerProcess = spawn('docker', [
+      'build',
+      '-t', `${imageName}:${tag}`,
+      '-f', dockerfilePath,
+      contextPath
+    ], {
+      shell: process.platform === 'win32'
+    });
+
+    let stdoutBuffer = '';
+    let stderrBuffer = '';
+    let lastProgressUpdate = Date.now();
+
+    dockerProcess.stdout.on('data', (data) => {
+      const output = data.toString();
+      stdoutBuffer += output;
+
+      // Parse progress from output lines
+      const lines = output.split('\n');
+      for (const line of lines) {
+        const progress = parseDockerBuildProgress(line.trim());
+        if (progress) {
+          // Update spinner text with progress (throttle updates)
+          const now = Date.now();
+          if (now - lastProgressUpdate > 200) {
+            spinner.text = `Building image... ${progress}`;
+            lastProgressUpdate = now;
+          }
+        }
+      }
+    });
+
+    dockerProcess.stderr.on('data', (data) => {
+      const output = data.toString();
+      stderrBuffer += output;
+
+      // Check for warnings vs errors
+      if (!output.toLowerCase().includes('warning')) {
+        // Parse progress from stderr too (Docker outputs progress to stderr)
+        const lines = output.split('\n');
+        for (const line of lines) {
+          const progress = parseDockerBuildProgress(line.trim());
+          if (progress) {
+            const now = Date.now();
+            if (now - lastProgressUpdate > 200) {
+              spinner.text = `Building image... ${progress}`;
+              lastProgressUpdate = now;
+            }
+          }
+        }
+      }
+    });
+
+    dockerProcess.on('close', (code) => {
+      if (code === 0) {
+        spinner.succeed(`Image built: ${imageName}:${tag}`);
+        resolve();
+      } else {
+        spinner.fail('Build failed');
+
+        const errorMessage = stderrBuffer || stdoutBuffer || 'Docker build failed';
+
+        if (isDockerNotAvailableError(errorMessage)) {
+          reject(new Error('Docker is not running or not installed. Please start Docker Desktop and try again.'));
+        } else {
+          // Show last few lines of error output
+          const errorLines = errorMessage.split('\n').filter(line => line.trim());
+          const lastError = errorLines.slice(-5).join('\n');
+          reject(new Error(`Docker build failed: ${lastError}`));
+        }
+      }
+    });
+
+    dockerProcess.on('error', (error) => {
+      spinner.fail('Build failed');
+      const errorMessage = error.message || String(error);
+
+      if (isDockerNotAvailableError(errorMessage)) {
+        reject(new Error('Docker is not running or not installed. Please start Docker Desktop and try again.'));
+      } else {
+        reject(new Error(`Docker build failed: ${errorMessage}`));
+      }
+    });
+  });
+}
+
+module.exports = {
+  executeDockerBuild,
+  isDockerNotAvailableError
+};
+

package/lib/utils/dockerfile-utils.js

@@ -0,0 +1,131 @@
+/**
+ * Dockerfile Utility Functions
+ *
+ * This module handles Dockerfile template loading, rendering,
+ * and path resolution. Separated from build.js to maintain
+ * file size limits and improve code organization.
+ *
+ * @fileoverview Dockerfile utility functions for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fsSync = require('fs');
+const path = require('path');
+const handlebars = require('handlebars');
+
+/**
+ * Loads Dockerfile template for language
+ * @function loadDockerfileTemplate
+ * @param {string} language - Language ('typescript' or 'python')
+ * @returns {Function} Compiled Handlebars template
+ * @throws {Error} If template not found
+ */
+function loadDockerfileTemplate(language) {
+  const templatePath = path.join(__dirname, '..', '..', 'templates', language, 'Dockerfile.hbs');
+
+  if (!fsSync.existsSync(templatePath)) {
+    throw new Error(`Template not found for language: ${language}`);
+  }
+
+  const templateContent = fsSync.readFileSync(templatePath, 'utf8');
+  return handlebars.compile(templateContent);
+}
+
+/**
+ * Renders Dockerfile with template variables
+ * @function renderDockerfile
+ * @param {Function} template - Compiled Handlebars template
+ * @param {Object} templateVars - Template variables
+ * @param {string} language - Language ('typescript' or 'python')
+ * @param {boolean} isAppFlag - Whether --app flag was used
+ * @param {string} appSourcePath - Application source path
+ * @returns {string} Rendered Dockerfile content
+ */
+function renderDockerfile(template, templateVars, language, isAppFlag, appSourcePath) {
+  let dockerfileContent = template(templateVars);
+
+  if (!isAppFlag) {
+    return dockerfileContent;
+  }
+
+  dockerfileContent = dockerfileContent.replace(
+    /^COPY \. \./gm,
+    `COPY ${appSourcePath} .`
+  );
+
+  if (language === 'python') {
+    // Replace COPY requirements*.txt with app-specific path
+    dockerfileContent = dockerfileContent.replace(
+      /^COPY requirements\*\.txt \./gm,
+      `COPY ${appSourcePath}requirements*.txt ./`
+    );
+    // Also handle case where it might be COPY requirements.txt
+    dockerfileContent = dockerfileContent.replace(
+      /^COPY requirements\.txt \./gm,
+      `COPY ${appSourcePath}requirements.txt ./`
+    );
+  }
+
+  if (language === 'typescript') {
+    dockerfileContent = dockerfileContent.replace(
+      /^COPY package\*\.json \./gm,
+      `COPY ${appSourcePath}package*.json ./`
+    );
+  }
+
+  return dockerfileContent;
+}
+
+/**
+ * Checks for template Dockerfile in builder directory
+ * @function checkTemplateDockerfile
+ * @param {string} builderPath - Builder directory path
+ * @param {string} appName - Application name
+ * @param {boolean} forceTemplate - Force template flag
+ * @returns {string|null} Dockerfile path or null
+ */
+function checkTemplateDockerfile(builderPath, appName, forceTemplate) {
+  const appDockerfilePath = path.join(builderPath, 'Dockerfile');
+  if (fsSync.existsSync(appDockerfilePath) && !forceTemplate) {
+    return appDockerfilePath;
+  }
+  return null;
+}
+
+/**
+ * Checks for custom Dockerfile from variables.yaml
+ * @function checkProjectDockerfile
+ * @param {string} builderPath - Builder directory path
+ * @param {string} appName - Application name
+ * @param {Object} buildConfig - Build configuration
+ * @param {string} contextPath - Build context path
+ * @param {boolean} forceTemplate - Force template flag
+ * @returns {string|null} Dockerfile path or null
+ */
+function checkProjectDockerfile(builderPath, appName, buildConfig, contextPath, forceTemplate) {
+  const customDockerfile = buildConfig.dockerfile;
+  if (!customDockerfile || forceTemplate) {
+    return null;
+  }
+
+  const customPath = path.resolve(contextPath, customDockerfile);
+  if (fsSync.existsSync(customPath)) {
+    return customPath;
+  }
+
+  const builderCustomPath = path.join(process.cwd(), 'builder', appName, customDockerfile);
+  if (fsSync.existsSync(builderCustomPath)) {
+    return builderCustomPath;
+  }
+
+  return null;
+}
+
+module.exports = {
+  loadDockerfileTemplate,
+  renderDockerfile,
+  checkTemplateDockerfile,
+  checkProjectDockerfile
+};
+

package/lib/utils/environment-checker.js

@@ -0,0 +1,125 @@
+/**
+ * Environment Checking Utilities
+ *
+ * Checks the development environment for common issues
+ * Validates Docker, ports, secrets, and other requirements
+ *
+ * @fileoverview Environment checking utilities for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Checks if Docker is installed and available
+ *
+ * @async
+ * @function checkDocker
+ * @returns {Promise<string>} 'ok' if Docker is available, 'error' otherwise
+ */
+async function checkDocker() {
+  try {
+    const { exec } = require('child_process');
+    const { promisify } = require('util');
+    const execAsync = promisify(exec);
+
+    await execAsync('docker --version');
+    await execAsync('docker-compose --version');
+    return 'ok';
+  } catch (error) {
+    return 'error';
+  }
+}
+
+/**
+ * Checks if required ports are available
+ *
+ * @async
+ * @function checkPorts
+ * @returns {Promise<string>} 'ok' if all ports are available, 'warning' otherwise
+ */
+async function checkPorts() {
+  const requiredPorts = [5432, 6379, 5050, 8081];
+  const netstat = require('net');
+  let portIssues = 0;
+
+  for (const port of requiredPorts) {
+    try {
+      await new Promise((resolve, reject) => {
+        const server = netstat.createServer();
+        server.listen(port, () => {
+          server.close(resolve);
+        });
+        server.on('error', reject);
+      });
+    } catch (error) {
+      portIssues++;
+    }
+  }
+
+  return portIssues === 0 ? 'ok' : 'warning';
+}
+
+/**
+ * Checks if secrets file exists
+ *
+ * @function checkSecrets
+ * @returns {string} 'ok' if secrets file exists, 'missing' otherwise
+ */
+function checkSecrets() {
+  const secretsPath = path.join(os.homedir(), '.aifabrix', 'secrets.yaml');
+  return fs.existsSync(secretsPath) ? 'ok' : 'missing';
+}
+
+/**
+ * Checks the development environment for common issues
+ * Validates Docker, ports, secrets, and other requirements
+ *
+ * @async
+ * @function checkEnvironment
+ * @returns {Promise<Object>} Environment check result
+ * @throws {Error} If critical issues are found
+ *
+ * @example
+ * const result = await checkEnvironment();
+ * // Returns: { docker: 'ok', ports: 'ok', secrets: 'missing', recommendations: [...] }
+ */
+async function checkEnvironment() {
+  const result = {
+    docker: 'unknown',
+    ports: 'unknown',
+    secrets: 'unknown',
+    recommendations: []
+  };
+
+  // Check Docker
+  result.docker = await checkDocker();
+  if (result.docker === 'error') {
+    result.recommendations.push('Install Docker and Docker Compose');
+  }
+
+  // Check ports
+  result.ports = await checkPorts();
+  if (result.ports === 'warning') {
+    result.recommendations.push('Some required ports (5432, 6379, 5050, 8081) are in use');
+  }
+
+  // Check secrets
+  result.secrets = checkSecrets();
+  if (result.secrets === 'missing') {
+    result.recommendations.push('Create secrets file: ~/.aifabrix/secrets.yaml');
+  }
+
+  return result;
+}
+
+module.exports = {
+  checkDocker,
+  checkPorts,
+  checkSecrets,
+  checkEnvironment
+};
+

package/lib/utils/error-formatter.js

@@ -0,0 +1,61 @@
+/**
+ * Error Formatting Utilities
+ *
+ * Formats validation errors into developer-friendly messages
+ * Converts technical schema errors into actionable advice
+ *
+ * @fileoverview Error formatting utilities for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+/**
+ * Formats a single validation error into a developer-friendly message
+ *
+ * @function formatSingleError
+ * @param {Object} error - Raw validation error from Ajv
+ * @returns {string} Formatted error message
+ */
+function formatSingleError(error) {
+  const path = error.instancePath ? error.instancePath.slice(1) : 'root';
+  const field = path ? `Field "${path}"` : 'Configuration';
+
+  const errorMessages = {
+    required: `${field}: Missing required property "${error.params.missingProperty}"`,
+    type: `${field}: Expected ${error.params.type}, got ${typeof error.data}`,
+    minimum: `${field}: Value must be at least ${error.params.limit}`,
+    maximum: `${field}: Value must be at most ${error.params.limit}`,
+    minLength: `${field}: Must be at least ${error.params.limit} characters`,
+    maxLength: `${field}: Must be at most ${error.params.limit} characters`,
+    pattern: `${field}: Invalid format`,
+    enum: `${field}: Must be one of: ${error.params.allowedValues?.join(', ') || 'unknown'}`
+  };
+
+  return errorMessages[error.keyword] || `${field}: ${error.message}`;
+}
+
+/**
+ * Formats validation errors into developer-friendly messages
+ * Converts technical schema errors into actionable advice
+ *
+ * @function formatValidationErrors
+ * @param {Array} errors - Raw validation errors from Ajv
+ * @returns {Array} Formatted error messages
+ *
+ * @example
+ * const messages = formatValidationErrors(ajvErrors);
+ * // Returns: ['Port must be between 1 and 65535', 'Missing required field: displayName']
+ */
+function formatValidationErrors(errors) {
+  if (!Array.isArray(errors)) {
+    return ['Unknown validation error'];
+  }
+
+  return errors.map(formatSingleError);
+}
+
+module.exports = {
+  formatSingleError,
+  formatValidationErrors
+};
+

package/lib/utils/health-check.js

@@ -0,0 +1,187 @@
+/**
+ * Health Check Utilities
+ *
+ * Handles health check functionality for application containers
+ *
+ * @fileoverview Health check utilities for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const http = require('http');
+const chalk = require('chalk');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const logger = require('./logger');
+
+const execAsync = promisify(exec);
+
+/**
+ * Checks if db-init container exists and waits for it to complete
+ * @async
+ * @function waitForDbInit
+ * @param {string} appName - Application name
+ * @throws {Error} If db-init fails
+ */
+async function waitForDbInit(appName) {
+  const dbInitContainer = `aifabrix-${appName}-db-init`;
+  try {
+    const { stdout } = await execAsync(`docker ps -a --filter "name=${dbInitContainer}" --format "{{.Names}}"`);
+    if (stdout.trim() !== dbInitContainer) {
+      return;
+    }
+
+    const { stdout: status } = await execAsync(`docker inspect --format='{{.State.Status}}' ${dbInitContainer}`);
+    if (status.trim() === 'exited') {
+      const { stdout: exitCode } = await execAsync(`docker inspect --format='{{.State.ExitCode}}' ${dbInitContainer}`);
+      if (exitCode.trim() === '0') {
+        logger.log(chalk.green('✓ Database initialization already completed'));
+      } else {
+        logger.log(chalk.yellow(`⚠ Database initialization exited with code ${exitCode.trim()}`));
+      }
+      return;
+    }
+
+    logger.log(chalk.blue('Waiting for database initialization to complete...'));
+    const maxDbInitAttempts = 30;
+    for (let dbInitAttempts = 0; dbInitAttempts < maxDbInitAttempts; dbInitAttempts++) {
+      const { stdout: currentStatus } = await execAsync(`docker inspect --format='{{.State.Status}}' ${dbInitContainer}`);
+      if (currentStatus.trim() === 'exited') {
+        const { stdout: exitCode } = await execAsync(`docker inspect --format='{{.State.ExitCode}}' ${dbInitContainer}`);
+        if (exitCode.trim() === '0') {
+          logger.log(chalk.green('✓ Database initialization completed'));
+        } else {
+          logger.log(chalk.yellow(`⚠ Database initialization exited with code ${exitCode.trim()}`));
+        }
+        return;
+      }
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+  } catch (error) {
+    // db-init container might not exist, which is fine
+  }
+}
+
+/**
+ * Gets container port from Docker inspect
+ * @async
+ * @function getContainerPort
+ * @param {string} appName - Application name
+ * @returns {Promise<number>} Container port
+ */
+async function getContainerPort(appName) {
+  try {
+    const { stdout: portMapping } = await execAsync(`docker inspect --format='{{range .NetworkSettings.Ports}}{{range .}}{{.HostPort}}{{end}}{{end}}' aifabrix-${appName}`);
+    const ports = portMapping.trim().split('\n').filter(p => p);
+    if (ports.length > 0) {
+      return parseInt(ports[0], 10);
+    }
+  } catch (error) {
+    // Fall through to default
+  }
+  return 3000;
+}
+
+/**
+ * Parses health check response
+ * @function parseHealthResponse
+ * @param {string} data - Response data
+ * @param {number} statusCode - HTTP status code
+ * @returns {boolean} True if healthy
+ */
+function parseHealthResponse(data, statusCode) {
+  try {
+    const health = JSON.parse(data);
+    if (health.status === 'UP') {
+      return true;
+    }
+    if (health.status === 'ok') {
+      return health.database === 'connected' || !health.database;
+    }
+    return false;
+  } catch (error) {
+    return statusCode === 200;
+  }
+}
+
+/**
+ * Checks health endpoint
+ * @async
+ * @function checkHealthEndpoint
+ * @param {string} healthCheckUrl - Health check URL
+ * @returns {Promise<boolean>} True if healthy
+ * @throws {Error} If request fails with exception
+ */
+async function checkHealthEndpoint(healthCheckUrl) {
+  return new Promise((resolve, reject) => {
+    try {
+      const req = http.get(healthCheckUrl, { timeout: 5000 }, (res) => {
+        let data = '';
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+        res.on('end', () => {
+          resolve(parseHealthResponse(data, res.statusCode));
+        });
+      });
+      req.on('error', () => resolve(false));
+      req.on('timeout', () => {
+        req.destroy();
+        resolve(false);
+      });
+    } catch (error) {
+      // Re-throw exceptions (not just network errors)
+      reject(error);
+    }
+  });
+}
+
+/**
+ * Waits for application health check to pass
+ * Checks HTTP endpoint and waits for healthy response
+ *
+ * @async
+ * @function waitForHealthCheck
+ * @param {string} appName - Application name
+ * @param {number} timeout - Timeout in seconds (default: 90)
+ * @param {number} [port] - Application port (auto-detected if not provided)
+ * @param {Object} [config] - Application configuration
+ * @returns {Promise<void>} Resolves when health check passes
+ * @throws {Error} If health check times out
+ */
+async function waitForHealthCheck(appName, timeout = 90, port = null, config = null) {
+  await waitForDbInit(appName);
+
+  if (!port) {
+    port = await getContainerPort(appName);
+  }
+
+  const healthCheckPath = config?.healthCheck?.path || '/health';
+  const healthCheckUrl = `http://localhost:${port}${healthCheckPath}`;
+  const maxAttempts = timeout / 2;
+
+  for (let attempts = 0; attempts < maxAttempts; attempts++) {
+    try {
+      const healthCheckPassed = await checkHealthEndpoint(healthCheckUrl);
+      if (healthCheckPassed) {
+        logger.log(chalk.green('✓ Application is healthy'));
+        return;
+      }
+    } catch (error) {
+      // If exception occurs, continue retrying until timeout
+      // The error will be handled by timeout error below
+    }
+
+    if (attempts < maxAttempts - 1) {
+      logger.log(chalk.yellow(`Waiting for health check... (${attempts + 1}/${maxAttempts}) ${healthCheckUrl}`));
+      await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+  }
+
+  throw new Error(`Health check timeout after ${timeout} seconds`);
+}
+
+module.exports = {
+  waitForHealthCheck
+};
+