@aifabrix/builder 2.0.0 → 2.0.2

package/lib/secrets.js

@@ -13,6 +13,9 @@ 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');
 
 /**
  * Loads environment configuration for docker/local context
@@ -81,12 +84,16 @@ async function resolveKvReferences(envTemplate, secrets, environment = 'local')
   const envConfig = loadEnvConfig();
   const envVars = envConfig.environments[environment] || envConfig.environments.local;
 
-  let resolved = envTemplate;
+  // First, replace ${VAR} references in the template itself (for variables like DB_HOST=${DB_HOST})
+  let resolved = envTemplate.replace(/\$\{([A-Z_]+)\}/g, (match, envVar) => {
+    return envVars[envVar] || match;
+  });
+
   const kvPattern = /kv:\/\/([a-zA-Z0-9-_]+)/g;
   const missingSecrets = [];
 
   let match;
-  while ((match = kvPattern.exec(envTemplate)) !== null) {
+  while ((match = kvPattern.exec(resolved)) !== null) {
     const secretKey = match[1];
     if (!(secretKey in secrets)) {
       missingSecrets.push(`kv://${secretKey}`);
@@ -97,9 +104,11 @@ async function resolveKvReferences(envTemplate, secrets, environment = 'local')
     throw new Error(`Missing secrets: ${missingSecrets.join(', ')}`);
   }
 
+  // Now replace kv:// references, and handle ${VAR} inside the secret values
   resolved = resolved.replace(kvPattern, (match, secretKey) => {
     let value = secrets[secretKey];
     if (typeof value === 'string') {
+      // Replace ${VAR} references inside the secret value
       value = value.replace(/\$\{([A-Z_]+)\}/g, (m, envVar) => {
         return envVars[envVar] || m;
       });
@@ -110,6 +119,197 @@ 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
+ * @param {string} templatePath - Path to env.template
+ * @returns {string} Template content
+ * @throws {Error} If file not found
+ */
+function loadEnvTemplate(templatePath) {
+  if (!fs.existsSync(templatePath)) {
+    throw new Error(`env.template not found: ${templatePath}`);
+  }
+  return fs.readFileSync(templatePath, 'utf8');
+}
+
+/**
+ * Processes environment variables and copies to output path if needed
+ * @function processEnvVariables
+ * @param {string} envPath - Path to generated .env file
+ * @param {string} variablesPath - Path to variables.yaml
+ * @throws {Error} If processing fails
+ */
+function processEnvVariables(envPath, variablesPath) {
+  if (!fs.existsSync(variablesPath)) {
+    return;
+  }
+
+  const variablesContent = fs.readFileSync(variablesPath, 'utf8');
+  const variables = yaml.load(variablesContent);
+
+  if (!variables?.build?.envOutputPath || variables.build.envOutputPath === null) {
+    return;
+  }
+
+  let outputPath = path.resolve(process.cwd(), variables.build.envOutputPath);
+  if (!outputPath.endsWith('.env')) {
+    if (fs.existsSync(outputPath) && fs.statSync(outputPath).isDirectory()) {
+      outputPath = path.join(outputPath, '.env');
+    } else {
+      outputPath = path.join(outputPath, '.env');
+    }
+  }
+
+  const outputDir = path.dirname(outputPath);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  fs.copyFileSync(envPath, outputPath);
+  logger.log(chalk.green(`✓ Copied .env to: ${variables.build.envOutputPath}`));
+}
+
 /**
  * Generates .env file from template and secrets
  * Creates environment file for local development
@@ -119,44 +319,32 @@ async function resolveKvReferences(envTemplate, secrets, environment = 'local')
  * @param {string} appName - Name of the application
  * @param {string} [secretsPath] - Path to secrets file (optional)
  * @param {string} [environment='local'] - Environment context
+ * @param {boolean} [force=false] - Generate missing secret keys in secrets file
  * @returns {Promise<string>} Path to generated .env file
  * @throws {Error} If generation fails
  *
  * @example
- * const envPath = await generateEnvFile('myapp', '../../secrets.local.yaml');
+ * const envPath = await generateEnvFile('myapp', '../../secrets.local.yaml', 'local', true);
  * // Returns: './builder/myapp/.env'
  */
-async function generateEnvFile(appName, secretsPath, environment = 'local') {
+async function generateEnvFile(appName, secretsPath, environment = 'local', force = false) {
   const builderPath = path.join(process.cwd(), 'builder', appName);
   const templatePath = path.join(builderPath, 'env.template');
   const variablesPath = path.join(builderPath, 'variables.yaml');
   const envPath = path.join(builderPath, '.env');
 
-  if (!fs.existsSync(templatePath)) {
-    throw new Error(`env.template not found: ${templatePath}`);
+  const template = loadEnvTemplate(templatePath);
+
+  if (force) {
+    const resolvedSecretsPath = secretsPath || path.join(os.homedir(), '.aifabrix', 'secrets.yaml');
+    await generateMissingSecrets(template, resolvedSecretsPath);
   }
 
-  const template = fs.readFileSync(templatePath, 'utf8');
   const secrets = await loadSecrets(secretsPath);
   const resolved = await resolveKvReferences(template, secrets, environment);
 
   fs.writeFileSync(envPath, resolved, { mode: 0o600 });
-
-  if (fs.existsSync(variablesPath)) {
-    const variablesContent = fs.readFileSync(variablesPath, 'utf8');
-    const variables = yaml.load(variablesContent);
-
-    if (variables?.build?.envOutputPath) {
-      const outputPath = path.resolve(builderPath, variables.build.envOutputPath);
-      const outputDir = path.dirname(outputPath);
-
-      if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir, { recursive: true });
-      }
-
-      fs.copyFileSync(envPath, outputPath);
-    }
-  }
+  processEnvVariables(envPath, variablesPath);
 
   return envPath;
 }
@@ -176,7 +364,23 @@ async function generateEnvFile(appName, secretsPath, environment = 'local') {
  * // Returns: '~/.aifabrix/admin-secrets.env'
  */
 async function generateAdminSecretsEnv(secretsPath) {
-  const secrets = await loadSecrets(secretsPath);
+  let secrets;
+
+  try {
+    secrets = await loadSecrets(secretsPath);
+  } catch (error) {
+    // If secrets file doesn't exist, create default secrets
+    const defaultSecretsPath = secretsPath || path.join(os.homedir(), '.aifabrix', 'secrets.yaml');
+
+    if (!fs.existsSync(defaultSecretsPath)) {
+      logger.log('Creating default secrets file...');
+      await createDefaultSecrets(defaultSecretsPath);
+      secrets = await loadSecrets(secretsPath);
+    } else {
+      throw error;
+    }
+  }
+
   const aifabrixDir = path.join(os.homedir(), '.aifabrix');
   const adminEnvPath = path.join(aifabrixDir, 'admin-secrets.env');
 
@@ -276,6 +480,7 @@ module.exports = {
   loadSecrets,
   resolveKvReferences,
   generateEnvFile,
+  generateMissingSecrets,
   generateAdminSecretsEnv,
   validateSecrets,
   createDefaultSecrets

package/lib/template-validator.js

@@ -0,0 +1,205 @@
+/**
+ * AI Fabrix Builder Template Validation and Management
+ *
+ * Validates template folders and copies template files to application directories
+ *
+ * @fileoverview Template validation and file copying utilities
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs').promises;
+const fsSync = require('fs');
+const path = require('path');
+
+/**
+ * Validates that a template exists and contains files
+ * @param {string} templateName - Template name to validate
+ * @returns {Promise<boolean>} True if template is valid
+ * @throws {Error} If template folder doesn't exist or is empty
+ */
+async function validateTemplate(templateName) {
+  if (!templateName || typeof templateName !== 'string') {
+    throw new Error('Template name is required and must be a string');
+  }
+
+  const templatePath = path.join(__dirname, '..', 'templates', 'applications', templateName);
+
+  // Check if template folder exists
+  if (!fsSync.existsSync(templatePath)) {
+    throw new Error(`Template '${templateName}' not found. Expected folder: templates/applications/${templateName}/`);
+  }
+
+  // Check if it's a directory
+  const stats = fsSync.statSync(templatePath);
+  if (!stats.isDirectory()) {
+    throw new Error(`Template '${templateName}' exists but is not a directory`);
+  }
+
+  // Check if folder contains at least one file
+  const entries = await fs.readdir(templatePath);
+  const files = entries.filter(entry => {
+    const entryPath = path.join(templatePath, entry);
+    const entryStats = fsSync.statSync(entryPath);
+    return entryStats.isFile() && !entry.startsWith('.');
+  });
+
+  if (files.length === 0) {
+    throw new Error(`Template '${templateName}' folder exists but contains no files`);
+  }
+
+  return true;
+}
+
+/**
+ * Copies all files from template folder to application directory
+ * Preserves directory structure and skips hidden files
+ * @param {string} templateName - Template name to copy
+ * @param {string} appPath - Target application directory path
+ * @returns {Promise<string[]>} Array of copied file paths
+ * @throws {Error} If template validation fails or copying fails
+ */
+async function copyTemplateFiles(templateName, appPath) {
+  // Validate template first
+  await validateTemplate(templateName);
+
+  const templatePath = path.join(__dirname, '..', 'templates', 'applications', templateName);
+  const copiedFiles = [];
+
+  async function copyDirectory(sourceDir, targetDir) {
+    // Ensure target directory exists
+    await fs.mkdir(targetDir, { recursive: true });
+
+    const entries = await fs.readdir(sourceDir);
+
+    for (const entry of entries) {
+      // Skip hidden files and directories
+      if (entry.startsWith('.')) {
+        continue;
+      }
+
+      const sourcePath = path.join(sourceDir, entry);
+      const targetPath = path.join(targetDir, entry);
+
+      const stats = await fs.stat(sourcePath);
+
+      if (stats.isDirectory()) {
+        // Recursively copy subdirectories
+        await copyDirectory(sourcePath, targetPath);
+      } else if (stats.isFile()) {
+        // Copy file
+        await fs.copyFile(sourcePath, targetPath);
+        copiedFiles.push(targetPath);
+      }
+    }
+  }
+
+  await copyDirectory(templatePath, appPath);
+
+  return copiedFiles;
+}
+
+/**
+ * Copies application files from language template directory
+ * Copies files like package.json, index.ts, requirements.txt, main.py from templates/{language}/
+ * @param {string} language - Language name (typescript or python)
+ * @param {string} appPath - Target application directory path
+ * @returns {Promise<string[]>} Array of copied file paths
+ * @throws {Error} If language template doesn't exist or copying fails
+ */
+async function copyAppFiles(language, appPath) {
+  if (!language || typeof language !== 'string') {
+    throw new Error('Language is required and must be a string');
+  }
+
+  const normalizedLanguage = language.toLowerCase();
+  const languageTemplatePath = path.join(__dirname, '..', 'templates', normalizedLanguage);
+
+  // Check if language template folder exists
+  if (!fsSync.existsSync(languageTemplatePath)) {
+    throw new Error(`Language template '${normalizedLanguage}' not found. Expected folder: templates/${normalizedLanguage}/`);
+  }
+
+  const stats = fsSync.statSync(languageTemplatePath);
+  if (!stats.isDirectory()) {
+    throw new Error(`Language template '${normalizedLanguage}' exists but is not a directory`);
+  }
+
+  const copiedFiles = [];
+  const entries = await fs.readdir(languageTemplatePath);
+
+  // 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('.')) {
+      return false;
+    }
+    return true;
+  });
+
+  for (const entry of appFiles) {
+    const sourcePath = path.join(languageTemplatePath, entry);
+    const targetPath = path.join(appPath, entry);
+
+    const entryStats = await fs.stat(sourcePath);
+    if (entryStats.isFile()) {
+      await fs.copyFile(sourcePath, targetPath);
+      copiedFiles.push(targetPath);
+    }
+  }
+
+  return copiedFiles;
+}
+
+/**
+ * Lists available templates
+ * @returns {Promise<string[]>} Array of available template names
+ */
+async function listAvailableTemplates() {
+  const templatesDir = path.join(__dirname, '..', 'templates', 'applications');
+
+  if (!fsSync.existsSync(templatesDir)) {
+    return [];
+  }
+
+  const entries = await fs.readdir(templatesDir);
+  const templates = [];
+
+  for (const entry of entries) {
+    const entryPath = path.join(templatesDir, entry);
+    const stats = fsSync.statSync(entryPath);
+
+    if (stats.isDirectory()) {
+      // Check if directory contains at least one file
+      const subEntries = await fs.readdir(entryPath);
+      const hasFiles = subEntries.some(subEntry => {
+        const subPath = path.join(entryPath, subEntry);
+        const subStats = fsSync.statSync(subPath);
+        return subStats.isFile() && !subEntry.startsWith('.');
+      });
+
+      if (hasFiles) {
+        templates.push(entry);
+      }
+    }
+  }
+
+  return templates.sort();
+}
+
+module.exports = {
+  validateTemplate,
+  copyTemplateFiles,
+  copyAppFiles,
+  listAvailableTemplates
+};