@aifabrix/builder 2.0.2 → 2.0.4

package/lib/secrets.js

@@ -13,9 +13,12 @@ const fs = require('fs');
 const path = require('path');
 const yaml = require('js-yaml');
 const os = require('os');
-const crypto = require('crypto');
 const chalk = require('chalk');
 const logger = require('./utils/logger');
+const {
+  generateMissingSecrets,
+  createDefaultSecrets
+} = require('./utils/secrets-generator');
 
 /**
  * Loads environment configuration for docker/local context
@@ -42,13 +45,7 @@ function loadEnvConfig() {
  * // Returns: { 'postgres-passwordKeyVault': 'admin123', ... }
  */
 async function loadSecrets(secretsPath) {
-  let resolvedPath = secretsPath;
-
-  if (!resolvedPath) {
-    resolvedPath = path.join(os.homedir(), '.aifabrix', 'secrets.yaml');
-  } else if (secretsPath.startsWith('..')) {
-    resolvedPath = path.resolve(process.cwd(), secretsPath);
-  }
+  const resolvedPath = resolveSecretsPath(secretsPath);
 
   if (!fs.existsSync(resolvedPath)) {
     throw new Error(`Secrets file not found: ${resolvedPath}`);
@@ -64,6 +61,45 @@ async function loadSecrets(secretsPath) {
   return secrets;
 }
 
+/**
+ * Resolves secrets file path (same logic as loadSecrets)
+ * Also checks common locations if path is not provided
+ * @function resolveSecretsPath
+ * @param {string} [secretsPath] - Path to secrets file (optional)
+ * @returns {string} Resolved secrets file path
+ */
+function resolveSecretsPath(secretsPath) {
+  let resolvedPath = secretsPath;
+
+  if (!resolvedPath) {
+    // Check common locations for secrets.local.yaml
+    const commonLocations = [
+      path.join(process.cwd(), '..', 'aifabrix-setup', 'secrets.local.yaml'),
+      path.join(process.cwd(), '..', '..', 'aifabrix-setup', 'secrets.local.yaml'),
+      path.join(process.cwd(), 'secrets.local.yaml'),
+      path.join(process.cwd(), '..', 'secrets.local.yaml'),
+      path.join(os.homedir(), '.aifabrix', 'secrets.yaml')
+    ];
+
+    // Find first existing file
+    for (const location of commonLocations) {
+      if (fs.existsSync(location)) {
+        resolvedPath = location;
+        break;
+      }
+    }
+
+    // If none found, use default location
+    if (!resolvedPath) {
+      resolvedPath = path.join(os.homedir(), '.aifabrix', 'secrets.yaml');
+    }
+  } else if (secretsPath.startsWith('..')) {
+    resolvedPath = path.resolve(process.cwd(), secretsPath);
+  }
+
+  return resolvedPath;
+}
+
 /**
  * Resolves kv:// references in environment template
  * Replaces kv://keyName with actual values from secrets
@@ -73,6 +109,7 @@ async function loadSecrets(secretsPath) {
  * @param {string} envTemplate - Environment template content
  * @param {Object} secrets - Secrets object from loadSecrets()
  * @param {string} [environment='local'] - Environment context (docker/local)
+ * @param {string} [secretsFilePath] - Path to secrets file (for error messages)
  * @returns {Promise<string>} Resolved environment content
  * @throws {Error} If kv:// reference cannot be resolved
  *
@@ -80,7 +117,7 @@ async function loadSecrets(secretsPath) {
  * const resolved = await resolveKvReferences(template, secrets, 'local');
  * // Returns: 'DATABASE_URL=postgresql://user:pass@localhost:5432/db'
  */
-async function resolveKvReferences(envTemplate, secrets, environment = 'local') {
+async function resolveKvReferences(envTemplate, secrets, environment = 'local', secretsFilePath = null) {
   const envConfig = loadEnvConfig();
   const envVars = envConfig.environments[environment] || envConfig.environments.local;
 
@@ -101,7 +138,8 @@ async function resolveKvReferences(envTemplate, secrets, environment = 'local')
   }
 
   if (missingSecrets.length > 0) {
-    throw new Error(`Missing secrets: ${missingSecrets.join(', ')}`);
+    const fileInfo = secretsFilePath ? `\n\nSecrets file location: ${secretsFilePath}` : '';
+    throw new Error(`Missing secrets: ${missingSecrets.join(', ')}${fileInfo}`);
   }
 
   // Now replace kv:// references, and handle ${VAR} inside the secret values
@@ -119,146 +157,6 @@ async function resolveKvReferences(envTemplate, secrets, environment = 'local')
   return resolved;
 }
 
-/**
- * Finds missing secret keys from template
- * @function findMissingSecretKeys
- * @param {string} envTemplate - Environment template content
- * @param {Object} existingSecrets - Existing secrets object
- * @returns {string[]} Array of missing secret keys
- */
-function findMissingSecretKeys(envTemplate, existingSecrets) {
-  const kvPattern = /kv:\/\/([a-zA-Z0-9-_]+)/g;
-  const missingKeys = [];
-  const seenKeys = new Set();
-
-  let match;
-  while ((match = kvPattern.exec(envTemplate)) !== null) {
-    const secretKey = match[1];
-    if (!seenKeys.has(secretKey) && !(secretKey in existingSecrets)) {
-      missingKeys.push(secretKey);
-      seenKeys.add(secretKey);
-    }
-  }
-
-  return missingKeys;
-}
-
-/**
- * Generates secret value based on key name
- * @function generateSecretValue
- * @param {string} key - Secret key name
- * @returns {string} Generated secret value
- */
-function generateSecretValue(key) {
-  const keyLower = key.toLowerCase();
-
-  if (keyLower.includes('password')) {
-    const dbPasswordMatch = key.match(/^databases-([a-z0-9-_]+)-\d+-passwordKeyVault$/i);
-    if (dbPasswordMatch) {
-      const appName = dbPasswordMatch[1];
-      const dbName = appName.replace(/-/g, '_');
-      return `${dbName}_pass123`;
-    }
-    return crypto.randomBytes(32).toString('base64');
-  }
-
-  if (keyLower.includes('url') || keyLower.includes('uri')) {
-    const dbUrlMatch = key.match(/^databases-([a-z0-9-_]+)-\d+-urlKeyVault$/i);
-    if (dbUrlMatch) {
-      const appName = dbUrlMatch[1];
-      const dbName = appName.replace(/-/g, '_');
-      return `postgresql://${dbName}_user:${dbName}_pass123@\${DB_HOST}:5432/${dbName}`;
-    }
-    return '';
-  }
-
-  if (keyLower.includes('key') || keyLower.includes('secret') || keyLower.includes('token')) {
-    return crypto.randomBytes(32).toString('base64');
-  }
-
-  return '';
-}
-
-/**
- * Loads existing secrets from file
- * @function loadExistingSecrets
- * @param {string} resolvedPath - Path to secrets file
- * @returns {Object} Existing secrets object
- */
-function loadExistingSecrets(resolvedPath) {
-  if (!fs.existsSync(resolvedPath)) {
-    return {};
-  }
-
-  try {
-    const content = fs.readFileSync(resolvedPath, 'utf8');
-    const secrets = yaml.load(content) || {};
-    return typeof secrets === 'object' ? secrets : {};
-  } catch (error) {
-    logger.warn(`Warning: Could not read existing secrets file: ${error.message}`);
-    return {};
-  }
-}
-
-/**
- * Saves secrets file
- * @function saveSecretsFile
- * @param {string} resolvedPath - Path to secrets file
- * @param {Object} secrets - Secrets object to save
- * @throws {Error} If save fails
- */
-function saveSecretsFile(resolvedPath, secrets) {
-  const dir = path.dirname(resolvedPath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-  }
-
-  const yamlContent = yaml.dump(secrets, {
-    indent: 2,
-    lineWidth: 120,
-    noRefs: true,
-    sortKeys: false
-  });
-
-  fs.writeFileSync(resolvedPath, yamlContent, { mode: 0o600 });
-}
-
-/**
- * Generates missing secret keys in secrets file
- * Scans env.template for kv:// references and adds missing keys with secure defaults
- *
- * @async
- * @function generateMissingSecrets
- * @param {string} envTemplate - Environment template content
- * @param {string} secretsPath - Path to secrets file
- * @returns {Promise<string[]>} Array of newly generated secret keys
- * @throws {Error} If generation fails
- *
- * @example
- * const newKeys = await generateMissingSecrets(template, '~/.aifabrix/secrets.yaml');
- * // Returns: ['new-secret-key', 'another-secret']
- */
-async function generateMissingSecrets(envTemplate, secretsPath) {
-  const resolvedPath = secretsPath || path.join(os.homedir(), '.aifabrix', 'secrets.yaml');
-  const existingSecrets = loadExistingSecrets(resolvedPath);
-  const missingKeys = findMissingSecretKeys(envTemplate, existingSecrets);
-
-  if (missingKeys.length === 0) {
-    return [];
-  }
-
-  const newSecrets = {};
-  for (const key of missingKeys) {
-    newSecrets[key] = generateSecretValue(key);
-  }
-
-  const updatedSecrets = { ...existingSecrets, ...newSecrets };
-  saveSecretsFile(resolvedPath, updatedSecrets);
-
-  logger.log(`✓ Generated ${missingKeys.length} missing secret key(s): ${missingKeys.join(', ')}`);
-  return missingKeys;
-}
-
 /**
  * Loads environment template from file
  * @function loadEnvTemplate
@@ -335,13 +233,15 @@ async function generateEnvFile(appName, secretsPath, environment = 'local', forc
 
   const template = loadEnvTemplate(templatePath);
 
+  // Resolve secrets path to show in error messages
+  const resolvedSecretsPath = resolveSecretsPath(secretsPath);
+
   if (force) {
-    const resolvedSecretsPath = secretsPath || path.join(os.homedir(), '.aifabrix', 'secrets.yaml');
     await generateMissingSecrets(template, resolvedSecretsPath);
   }
 
   const secrets = await loadSecrets(secretsPath);
-  const resolved = await resolveKvReferences(template, secrets, environment);
+  const resolved = await resolveKvReferences(template, secrets, environment, resolvedSecretsPath);
 
   fs.writeFileSync(envPath, resolved, { mode: 0o600 });
   processEnvVariables(envPath, variablesPath);
@@ -434,48 +334,6 @@ function validateSecrets(envTemplate, secrets) {
   };
 }
 
-/**
- * Creates default secrets file if it doesn't exist
- * Generates template with common secrets for local development
- *
- * @async
- * @function createDefaultSecrets
- * @param {string} secretsPath - Path where to create secrets file
- * @returns {Promise<void>} Resolves when file is created
- * @throws {Error} If file creation fails
- *
- * @example
- * await createDefaultSecrets('~/.aifabrix/secrets.yaml');
- * // Default secrets file is created
- */
-async function createDefaultSecrets(secretsPath) {
-  const resolvedPath = secretsPath.startsWith('~')
-    ? path.join(os.homedir(), secretsPath.slice(1))
-    : secretsPath;
-
-  const dir = path.dirname(resolvedPath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-  }
-
-  const defaultSecrets = `# Local Development Secrets
-# Production uses Azure KeyVault
-
-# Database Secrets
-postgres-passwordKeyVault: "admin123"
-
-# Redis Secrets
-redis-passwordKeyVault: ""
-redis-urlKeyVault: "redis://\${REDIS_HOST}:6379"
-
-# Keycloak Secrets
-keycloak-admin-passwordKeyVault: "admin123"
-keycloak-auth-server-urlKeyVault: "http://\${KEYCLOAK_HOST}:8082"
-`;
-
-  fs.writeFileSync(resolvedPath, defaultSecrets, { mode: 0o600 });
-}
-
 module.exports = {
   loadSecrets,
   resolveKvReferences,

package/lib/utils/compose-generator.js

@@ -0,0 +1,185 @@
+/**
+ * Docker Compose Generation Utilities
+ *
+ * This module handles Docker Compose configuration generation for application running.
+ * Separated from app-run.js to maintain file size limits.
+ *
+ * @fileoverview Docker Compose generation utilities
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fsSync = require('fs');
+const path = require('path');
+const handlebars = require('handlebars');
+
+/**
+ * Loads and compiles Docker Compose template
+ * @param {string} language - Language type
+ * @returns {Function} Compiled Handlebars template
+ * @throws {Error} If template not found
+ */
+function loadDockerComposeTemplate(language) {
+  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}`);
+  }
+
+  const templateContent = fsSync.readFileSync(templatePath, 'utf8');
+  return handlebars.compile(templateContent);
+}
+
+/**
+ * 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) {
+  if (typeof config.image === 'string') {
+    return config.image.split(':')[0];
+  } else if (config.image?.name) {
+    return config.image.name;
+  } else if (config.app?.key) {
+    return config.app.key;
+  }
+  return appName;
+}
+
+/**
+ * Builds app configuration section
+ * @param {string} appName - Application name
+ * @param {Object} config - Application configuration
+ * @returns {Object} App configuration
+ */
+function buildAppConfig(appName, config) {
+  return {
+    key: appName,
+    name: config.displayName || appName
+  };
+}
+
+/**
+ * Builds image configuration section
+ * @param {Object} config - Application configuration
+ * @param {string} appName - Application name
+ * @returns {Object} Image configuration
+ */
+function buildImageConfig(config, appName) {
+  const imageName = getImageName(config, appName);
+  const imageTag = config.image?.tag || 'latest';
+  return {
+    name: imageName,
+    tag: imageTag
+  };
+}
+
+/**
+ * Builds health check configuration section
+ * @param {Object} config - Application configuration
+ * @returns {Object} Health check configuration
+ */
+function buildHealthCheckConfig(config) {
+  return {
+    path: config.healthCheck?.path || '/health',
+    interval: config.healthCheck?.interval || 30
+  };
+}
+
+/**
+ * Builds requires configuration section
+ * @param {Object} config - Application configuration
+ * @returns {Object} Requires configuration
+ */
+function buildRequiresConfig(config) {
+  return {
+    requiresDatabase: config.requires?.database || config.services?.database || false,
+    requiresStorage: config.requires?.storage || config.services?.storage || false,
+    requiresRedis: config.requires?.redis || config.services?.redis || false
+  };
+}
+
+/**
+ * Builds service configuration for template data
+ * @param {string} appName - Application name
+ * @param {Object} config - Application configuration
+ * @param {number} port - Application port
+ * @returns {Object} Service configuration
+ */
+function buildServiceConfig(appName, config, port) {
+  const containerPort = config.build?.containerPort || config.port || 3000;
+
+  return {
+    app: buildAppConfig(appName, config),
+    image: buildImageConfig(config, appName),
+    port: containerPort,
+    build: {
+      localPort: port
+    },
+    healthCheck: buildHealthCheckConfig(config),
+    ...buildRequiresConfig(config)
+  };
+}
+
+/**
+ * Builds volumes configuration for template data
+ * @param {string} appName - Application name
+ * @returns {Object} Volumes configuration
+ */
+function buildVolumesConfig(appName) {
+  // Use forward slashes for Docker paths (works on both Windows and Unix)
+  const volumePath = path.join(process.cwd(), 'data', appName);
+  return {
+    mountVolume: volumePath.replace(/\\/g, '/')
+  };
+}
+
+/**
+ * Builds networks configuration for template data
+ * @param {Object} config - Application configuration
+ * @returns {Object} Networks configuration
+ */
+function buildNetworksConfig(config) {
+  // Get databases from requires.databases or top-level databases
+  const databases = config.requires?.databases || config.databases || [];
+  return {
+    databases: databases
+  };
+}
+
+/**
+ * Generates Docker Compose configuration from template
+ * @param {string} appName - Application name
+ * @param {Object} config - Application configuration
+ * @param {Object} options - Run options
+ * @returns {Promise<string>} Generated compose content
+ */
+async function generateDockerCompose(appName, config, options) {
+  const language = config.build?.language || config.language || 'typescript';
+  const template = loadDockerComposeTemplate(language);
+
+  const port = options.port || config.build?.localPort || config.port || 3000;
+
+  const serviceConfig = buildServiceConfig(appName, config, port);
+  const volumesConfig = buildVolumesConfig(appName);
+  const networksConfig = buildNetworksConfig(config);
+
+  // Get absolute path to .env file for docker-compose
+  const envFilePath = path.join(process.cwd(), 'builder', appName, '.env');
+  const envFileAbsolutePath = envFilePath.replace(/\\/g, '/'); // Use forward slashes for Docker
+
+  const templateData = {
+    ...serviceConfig,
+    ...volumesConfig,
+    ...networksConfig,
+    envFile: envFileAbsolutePath
+  };
+
+  return template(templateData);
+}
+
+module.exports = {
+  generateDockerCompose,
+  getImageName
+};
+

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
+};
+