@aifabrix/builder 2.0.0

package/lib/infra.js

@@ -0,0 +1,300 @@
+/**
+ * AI Fabrix Builder Infrastructure Management
+ *
+ * This module manages local infrastructure services using Docker Compose.
+ * Handles starting/stopping Postgres, Redis, Keycloak, and Controller services.
+ *
+ * @fileoverview Local infrastructure management for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const secrets = require('./secrets');
+
+const execAsync = promisify(exec);
+
+/**
+ * Starts local infrastructure services
+ * Launches Postgres, Redis, Keycloak, and Controller in Docker containers
+ *
+ * @async
+ * @function startInfra
+ * @returns {Promise<void>} Resolves when infrastructure is started
+ * @throws {Error} If Docker is not running or compose fails
+ *
+ * @example
+ * await startInfra();
+ * // Infrastructure services are now running
+ */
+async function checkDockerAvailability() {
+  try {
+    await execAsync('docker --version');
+    await execAsync('docker-compose --version');
+  } catch (error) {
+    throw new Error('Docker or Docker Compose is not available. Please install and start Docker.');
+  }
+}
+
+async function ensureAdminSecrets() {
+  const adminSecretsPath = path.join(os.homedir(), '.aifabrix', 'admin-secrets.env');
+  if (!fs.existsSync(adminSecretsPath)) {
+    console.log('Generating admin-secrets.env...');
+    await secrets.generateAdminSecretsEnv();
+  }
+  return adminSecretsPath;
+}
+
+async function startInfra() {
+  await checkDockerAvailability();
+  const adminSecretsPath = await ensureAdminSecrets();
+
+  // Load compose template
+  const templatePath = path.join(__dirname, '..', 'templates', 'infra', 'compose.yaml');
+  if (!fs.existsSync(templatePath)) {
+    throw new Error(`Compose template not found: ${templatePath}`);
+  }
+
+  const template = fs.readFileSync(templatePath, 'utf8');
+  const tempComposePath = path.join(os.tmpdir(), 'aifabrix-compose.yaml');
+  fs.writeFileSync(tempComposePath, template);
+
+  try {
+    console.log('Starting infrastructure services...');
+    await execAsync(`docker-compose -f "${tempComposePath}" --env-file "${adminSecretsPath}" up -d`);
+    console.log('Infrastructure services started successfully');
+
+    await waitForServices();
+    console.log('All services are healthy and ready');
+  } finally {
+    if (fs.existsSync(tempComposePath)) {
+      fs.unlinkSync(tempComposePath);
+    }
+  }
+}
+
+/**
+ * Stops and removes local infrastructure services
+ * Cleanly shuts down all infrastructure containers
+ *
+ * @async
+ * @function stopInfra
+ * @returns {Promise<void>} Resolves when infrastructure is stopped
+ * @throws {Error} If Docker compose fails
+ *
+ * @example
+ * await stopInfra();
+ * // All infrastructure containers are stopped and removed
+ */
+async function stopInfra() {
+  const templatePath = path.join(__dirname, '..', 'templates', 'infra', 'compose.yaml');
+  const adminSecretsPath = path.join(os.homedir(), '.aifabrix', 'admin-secrets.env');
+
+  if (!fs.existsSync(templatePath) || !fs.existsSync(adminSecretsPath)) {
+    console.log('Infrastructure not running or not properly configured');
+    return;
+  }
+
+  const tempComposePath = path.join(os.tmpdir(), 'aifabrix-compose.yaml');
+  fs.writeFileSync(tempComposePath, fs.readFileSync(templatePath, 'utf8'));
+
+  try {
+    console.log('Stopping infrastructure services...');
+    await execAsync(`docker-compose -f "${tempComposePath}" --env-file "${adminSecretsPath}" down`);
+    console.log('Infrastructure services stopped');
+  } finally {
+    if (fs.existsSync(tempComposePath)) {
+      fs.unlinkSync(tempComposePath);
+    }
+  }
+}
+
+/**
+ * Stops and removes local infrastructure services with volumes
+ * Cleanly shuts down all infrastructure containers and removes all data
+ *
+ * @async
+ * @function stopInfraWithVolumes
+ * @returns {Promise<void>} Resolves when infrastructure is stopped and volumes removed
+ * @throws {Error} If Docker compose fails
+ *
+ * @example
+ * await stopInfraWithVolumes();
+ * // All infrastructure containers and data are removed
+ */
+async function stopInfraWithVolumes() {
+  const templatePath = path.join(__dirname, '..', 'templates', 'infra', 'compose.yaml');
+  const adminSecretsPath = path.join(os.homedir(), '.aifabrix', 'admin-secrets.env');
+
+  if (!fs.existsSync(templatePath) || !fs.existsSync(adminSecretsPath)) {
+    console.log('Infrastructure not running or not properly configured');
+    return;
+  }
+
+  const tempComposePath = path.join(os.tmpdir(), 'aifabrix-compose.yaml');
+  fs.writeFileSync(tempComposePath, fs.readFileSync(templatePath, 'utf8'));
+
+  try {
+    console.log('Stopping infrastructure services and removing all data...');
+    await execAsync(`docker-compose -f "${tempComposePath}" --env-file "${adminSecretsPath}" down -v`);
+    console.log('Infrastructure services stopped and all data removed');
+  } finally {
+    if (fs.existsSync(tempComposePath)) {
+      fs.unlinkSync(tempComposePath);
+    }
+  }
+}
+
+/**
+ * Checks if infrastructure services are running
+ * Validates that all required services are healthy and accessible
+ *
+ * @async
+ * @function checkInfraHealth
+ * @returns {Promise<Object>} Health status of each service
+ * @throws {Error} If health check fails
+ *
+ * @example
+ * const health = await checkInfraHealth();
+ * // Returns: { postgres: 'healthy', redis: 'healthy', keycloak: 'healthy', controller: 'healthy' }
+ */
+async function checkInfraHealth() {
+  const services = ['postgres', 'redis', 'pgadmin', 'redis-commander'];
+  const health = {};
+
+  for (const service of services) {
+    try {
+      const { stdout } = await execAsync(`docker inspect --format='{{.State.Health.Status}}' aifabrix-${service}`);
+      health[service] = stdout.trim();
+    } catch (error) {
+      health[service] = 'unknown';
+    }
+  }
+
+  return health;
+}
+
+/**
+ * Gets the status of infrastructure services
+ * Returns detailed information about running containers
+ *
+ * @async
+ * @function getInfraStatus
+ * @returns {Promise<Object>} Status information for each service
+ *
+ * @example
+ * const status = await getInfraStatus();
+ * // Returns: { postgres: { status: 'running', port: 5432, url: 'localhost:5432' }, ... }
+ */
+async function getInfraStatus() {
+  const services = {
+    postgres: { port: 5432, url: 'localhost:5432' },
+    redis: { port: 6379, url: 'localhost:6379' },
+    pgadmin: { port: 5050, url: 'http://localhost:5050' },
+    'redis-commander': { port: 8081, url: 'http://localhost:8081' }
+  };
+
+  const status = {};
+
+  for (const [serviceName, config] of Object.entries(services)) {
+    try {
+      const { stdout } = await execAsync(`docker inspect --format='{{.State.Status}}' aifabrix-${serviceName}`);
+      status[serviceName] = {
+        status: stdout.trim(),
+        port: config.port,
+        url: config.url
+      };
+    } catch (error) {
+      status[serviceName] = {
+        status: 'not running',
+        port: config.port,
+        url: config.url
+      };
+    }
+  }
+
+  return status;
+}
+
+/**
+ * Restarts a specific infrastructure service
+ * Useful for applying configuration changes
+ *
+ * @async
+ * @function restartService
+ * @param {string} serviceName - Name of service to restart
+ * @returns {Promise<void>} Resolves when service is restarted
+ * @throws {Error} If service doesn't exist or restart fails
+ *
+ * @example
+ * await restartService('keycloak');
+ * // Keycloak service is restarted
+ */
+async function restartService(serviceName) {
+  if (!serviceName || typeof serviceName !== 'string') {
+    throw new Error('Service name is required and must be a string');
+  }
+
+  const validServices = ['postgres', 'redis', 'pgadmin', 'redis-commander'];
+  if (!validServices.includes(serviceName)) {
+    throw new Error(`Invalid service name. Must be one of: ${validServices.join(', ')}`);
+  }
+
+  const templatePath = path.join(__dirname, '..', 'templates', 'infra', 'compose.yaml');
+  const adminSecretsPath = path.join(os.homedir(), '.aifabrix', 'admin-secrets.env');
+
+  if (!fs.existsSync(templatePath) || !fs.existsSync(adminSecretsPath)) {
+    throw new Error('Infrastructure not properly configured');
+  }
+
+  const tempComposePath = path.join(os.tmpdir(), 'aifabrix-compose.yaml');
+  fs.writeFileSync(tempComposePath, fs.readFileSync(templatePath, 'utf8'));
+
+  try {
+    console.log(`Restarting ${serviceName} service...`);
+    await execAsync(`docker-compose -f "${tempComposePath}" --env-file "${adminSecretsPath}" restart ${serviceName}`);
+    console.log(`${serviceName} service restarted successfully`);
+  } finally {
+    if (fs.existsSync(tempComposePath)) {
+      fs.unlinkSync(tempComposePath);
+    }
+  }
+}
+
+/**
+ * Waits for services to be healthy
+ * @private
+ */
+async function waitForServices() {
+  const maxAttempts = 30;
+  const delay = 2000; // 2 seconds
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const health = await checkInfraHealth();
+    const allHealthy = Object.values(health).every(status => status === 'healthy');
+
+    if (allHealthy) {
+      return;
+    }
+
+    if (attempt < maxAttempts) {
+      console.log(`Waiting for services to be healthy... (${attempt}/${maxAttempts})`);
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+  }
+
+  throw new Error('Services failed to become healthy within timeout period');
+}
+
+module.exports = {
+  startInfra,
+  stopInfra,
+  stopInfraWithVolumes,
+  checkInfraHealth,
+  getInfraStatus,
+  restartService
+};

package/lib/key-generator.js

@@ -0,0 +1,93 @@
+/**
+ * AI Fabrix Builder Deployment Key Generator
+ *
+ * This module generates SHA256-based deployment keys for controller authentication.
+ * Keys are computed from variables.yaml content to ensure deployment integrity.
+ *
+ * @fileoverview Deployment key generation for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Generates deployment key from variables.yaml content
+ * Creates SHA256 hash for controller authentication and deployment integrity
+ *
+ * @async
+ * @function generateDeploymentKey
+ * @param {string} appName - Name of the application
+ * @returns {Promise<string>} SHA256 hash of variables.yaml content
+ * @throws {Error} If variables.yaml cannot be read
+ *
+ * @example
+ * const key = await generateDeploymentKey('myapp');
+ * // Returns: 'a1b2c3d4e5f6...' (64-character SHA256 hash)
+ */
+async function generateDeploymentKey(appName) {
+  if (!appName || typeof appName !== 'string') {
+    throw new Error('App name is required and must be a string');
+  }
+
+  const variablesPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
+
+  if (!fs.existsSync(variablesPath)) {
+    throw new Error(`variables.yaml not found: ${variablesPath}`);
+  }
+
+  const content = fs.readFileSync(variablesPath, 'utf8');
+  return generateDeploymentKeyFromContent(content);
+}
+
+/**
+ * Generates deployment key from raw variables.yaml content
+ * Useful for testing or when content is already loaded
+ *
+ * @function generateDeploymentKeyFromContent
+ * @param {string} content - Raw variables.yaml content
+ * @returns {string} SHA256 hash of content
+ *
+ * @example
+ * const key = generateDeploymentKeyFromContent(yamlContent);
+ * // Returns: 'a1b2c3d4e5f6...' (64-character SHA256 hash)
+ */
+function generateDeploymentKeyFromContent(content) {
+  if (typeof content !== 'string') {
+    throw new Error('Content is required and must be a string');
+  }
+
+  const hash = crypto.createHash('sha256');
+  hash.update(content, 'utf8');
+  return hash.digest('hex');
+}
+
+/**
+ * Validates deployment key format
+ * Ensures key is a valid SHA256 hash
+ *
+ * @function validateDeploymentKey
+ * @param {string} key - Deployment key to validate
+ * @returns {boolean} True if key is valid SHA256 hash
+ *
+ * @example
+ * const isValid = validateDeploymentKey('a1b2c3d4e5f6...');
+ * // Returns: true
+ */
+function validateDeploymentKey(key) {
+  if (!key || typeof key !== 'string') {
+    return false;
+  }
+
+  // SHA256 produces 64-character hex string
+  const sha256Pattern = /^[a-f0-9]{64}$/i;
+  return sha256Pattern.test(key);
+}
+
+module.exports = {
+  generateDeploymentKey,
+  generateDeploymentKeyFromContent,
+  validateDeploymentKey
+};

package/lib/push.js

@@ -0,0 +1,141 @@
+/**
+ * AI Fabrix Builder Push Utilities
+ *
+ * This module handles pushing Docker images to Azure Container Registry.
+ * Includes authentication, tagging, and push operations.
+ *
+ * @fileoverview Push utilities for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const chalk = require('chalk');
+
+const execAsync = promisify(exec);
+
+/**
+ * Check if Azure CLI is installed
+ * @returns {Promise<boolean>} True if Azure CLI is available
+ */
+async function checkAzureCLIInstalled() {
+  try {
+    await execAsync('az --version');
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Extract registry name from ACR URL
+ * @param {string} registryUrl - Registry URL (e.g., myacr.azurecr.io)
+ * @returns {string} Registry name (e.g., myacr)
+ * @throws {Error} If URL format is invalid
+ */
+function extractRegistryName(registryUrl) {
+  const match = registryUrl.match(/^([^/]+)\.azurecr\.io$/);
+  if (!match) {
+    throw new Error(`Invalid ACR URL format: ${registryUrl}. Expected format: *.azurecr.io`);
+  }
+  return match[1];
+}
+
+/**
+ * Validate registry URL format
+ * @param {string} registryUrl - Registry URL to validate
+ * @returns {boolean} True if valid
+ */
+function validateRegistryURL(registryUrl) {
+  return /^[^.]+\.azurecr\.io$/.test(registryUrl);
+}
+
+/**
+ * Check if already authenticated with ACR
+ * @param {string} registry - Registry URL
+ * @returns {Promise<boolean>} True if authenticated
+ */
+async function checkACRAuthentication(registry) {
+  try {
+    const registryName = extractRegistryName(registry);
+    await execAsync(`az acr show --name ${registryName}`);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Authenticate with Azure Container Registry
+ * @param {string} registry - Registry URL
+ * @throws {Error} If authentication fails
+ */
+async function authenticateACR(registry) {
+  try {
+    const registryName = extractRegistryName(registry);
+    console.log(chalk.blue(`Authenticating with ${registry}...`));
+    await execAsync(`az acr login --name ${registryName}`);
+    console.log(chalk.green(`✓ Authenticated with ${registry}`));
+  } catch (error) {
+    throw new Error(`Failed to authenticate with Azure Container Registry: ${error.message}`);
+  }
+}
+
+/**
+ * Check if Docker image exists locally
+ * @param {string} imageName - Image name
+ * @param {string} tag - Image tag (default: latest)
+ * @returns {Promise<boolean>} True if image exists
+ */
+async function checkLocalImageExists(imageName, tag = 'latest') {
+  try {
+    const { stdout } = await execAsync(`docker images --format "{{.Repository}}:{{.Tag}}" | grep "^${imageName}:${tag}$"`);
+    return stdout.trim() === `${imageName}:${tag}`;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Tag Docker image for ACR
+ * @param {string} sourceImage - Source image tag
+ * @param {string} targetImage - Target image tag
+ * @throws {Error} If tagging fails
+ */
+async function tagImage(sourceImage, targetImage) {
+  try {
+    console.log(chalk.blue(`Tagging ${sourceImage} as ${targetImage}...`));
+    await execAsync(`docker tag ${sourceImage} ${targetImage}`);
+    console.log(chalk.green(`✓ Tagged: ${targetImage}`));
+  } catch (error) {
+    throw new Error(`Failed to tag image: ${error.message}`);
+  }
+}
+
+/**
+ * Push Docker image to registry
+ * @param {string} imageWithTag - Image with full tag
+ * @throws {Error} If push fails
+ */
+async function pushImage(imageWithTag) {
+  try {
+    console.log(chalk.blue(`Pushing ${imageWithTag}...`));
+    await execAsync(`docker push ${imageWithTag}`);
+    console.log(chalk.green(`✓ Pushed: ${imageWithTag}`));
+  } catch (error) {
+    throw new Error(`Failed to push image: ${error.message}`);
+  }
+}
+
+module.exports = {
+  checkAzureCLIInstalled,
+  extractRegistryName,
+  validateRegistryURL,
+  checkACRAuthentication,
+  authenticateACR,
+  checkLocalImageExists,
+  tagImage,
+  pushImage
+};
+