@aifabrix/builder 2.6.3 → 2.8.0

package/lib/diff.js

@@ -0,0 +1,266 @@
+/**
+ * File Comparison Utilities
+ *
+ * Compares two configuration files and identifies differences.
+ * Used for deployment pipeline validation and schema migration detection.
+ *
+ * @fileoverview File comparison utilities for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const logger = require('./utils/logger');
+
+/**
+ * Performs deep comparison of two objects
+ * Returns differences as structured result
+ *
+ * @function compareObjects
+ * @param {Object} obj1 - First object
+ * @param {Object} obj2 - Second object
+ * @param {string} [path=''] - Current path in object (for nested fields)
+ * @returns {Object} Comparison result with added, removed, changed fields
+ */
+function compareObjects(obj1, obj2, currentPath = '') {
+  const result = {
+    added: [],
+    removed: [],
+    changed: [],
+    identical: true
+  };
+
+  const allKeys = new Set([...Object.keys(obj1 || {}), ...Object.keys(obj2 || {})]);
+
+  for (const key of allKeys) {
+    const newPath = currentPath ? `${currentPath}.${key}` : key;
+    const val1 = obj1 && obj1[key];
+    const val2 = obj2 && obj2[key];
+
+    if (!(key in obj1)) {
+      result.added.push({
+        path: newPath,
+        value: val2,
+        type: typeof val2
+      });
+      result.identical = false;
+    } else if (!(key in obj2)) {
+      result.removed.push({
+        path: newPath,
+        value: val1,
+        type: typeof val1
+      });
+      result.identical = false;
+    } else if (typeof val1 === 'object' && typeof val2 === 'object' && val1 !== null && val2 !== null && !Array.isArray(val1) && !Array.isArray(val2)) {
+      // Recursively compare nested objects
+      const nestedResult = compareObjects(val1, val2, newPath);
+      result.added.push(...nestedResult.added);
+      result.removed.push(...nestedResult.removed);
+      result.changed.push(...nestedResult.changed);
+      if (!nestedResult.identical) {
+        result.identical = false;
+      }
+    } else if (JSON.stringify(val1) !== JSON.stringify(val2)) {
+      result.changed.push({
+        path: newPath,
+        oldValue: val1,
+        newValue: val2,
+        oldType: typeof val1,
+        newType: typeof val2
+      });
+      result.identical = false;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Identifies breaking changes in comparison result
+ * Breaking changes include: removed required fields, type changes
+ *
+ * @function identifyBreakingChanges
+ * @param {Object} comparison - Comparison result from compareObjects
+ * @param {Object} schema1 - First file schema (optional, for required fields check)
+ * @param {Object} schema2 - Second file schema (optional, for required fields check)
+ * @returns {Array} Array of breaking change descriptions
+ */
+function identifyBreakingChanges(comparison) {
+  const breaking = [];
+
+  // Removed fields are potentially breaking
+  comparison.removed.forEach(removed => {
+    breaking.push({
+      type: 'removed_field',
+      path: removed.path,
+      description: `Field removed: ${removed.path} (${removed.type})`
+    });
+  });
+
+  // Type changes are breaking
+  comparison.changed.forEach(change => {
+    if (change.oldType !== change.newType) {
+      breaking.push({
+        type: 'type_change',
+        path: change.path,
+        description: `Type changed: ${change.path} (${change.oldType} → ${change.newType})`
+      });
+    }
+  });
+
+  return breaking;
+}
+
+/**
+ * Compares two configuration files
+ * Loads files, parses JSON, and performs deep comparison
+ *
+ * @async
+ * @function compareFiles
+ * @param {string} file1 - Path to first file
+ * @param {string} file2 - Path to second file
+ * @returns {Promise<Object>} Comparison result with differences
+ * @throws {Error} If files cannot be read or parsed
+ *
+ * @example
+ * const result = await compareFiles('./old.json', './new.json');
+ * // Returns: { identical: false, added: [...], removed: [...], changed: [...] }
+ */
+async function compareFiles(file1, file2) {
+  if (!file1 || typeof file1 !== 'string') {
+    throw new Error('First file path is required');
+  }
+  if (!file2 || typeof file2 !== 'string') {
+    throw new Error('Second file path is required');
+  }
+
+  // Validate files exist
+  if (!fs.existsSync(file1)) {
+    throw new Error(`File not found: ${file1}`);
+  }
+  if (!fs.existsSync(file2)) {
+    throw new Error(`File not found: ${file2}`);
+  }
+
+  // Read and parse files
+  let content1, content2;
+  let parsed1, parsed2;
+
+  try {
+    content1 = fs.readFileSync(file1, 'utf8');
+    parsed1 = JSON.parse(content1);
+  } catch (error) {
+    throw new Error(`Failed to parse ${file1}: ${error.message}`);
+  }
+
+  try {
+    content2 = fs.readFileSync(file2, 'utf8');
+    parsed2 = JSON.parse(content2);
+  } catch (error) {
+    throw new Error(`Failed to parse ${file2}: ${error.message}`);
+  }
+
+  // Compare objects
+  const comparison = compareObjects(parsed1, parsed2);
+
+  // Check for version changes
+  const version1 = parsed1.version || parsed1.metadata?.version || 'unknown';
+  const version2 = parsed2.version || parsed2.metadata?.version || 'unknown';
+  const versionChanged = version1 !== version2;
+
+  // Identify breaking changes
+  const breakingChanges = identifyBreakingChanges(comparison);
+
+  return {
+    identical: comparison.identical && !versionChanged,
+    file1: path.basename(file1),
+    file2: path.basename(file2),
+    version1,
+    version2,
+    versionChanged,
+    added: comparison.added,
+    removed: comparison.removed,
+    changed: comparison.changed,
+    breakingChanges,
+    summary: {
+      totalAdded: comparison.added.length,
+      totalRemoved: comparison.removed.length,
+      totalChanged: comparison.changed.length,
+      totalBreaking: breakingChanges.length
+    }
+  };
+}
+
+/**
+ * Formats and displays diff output
+ * Shows differences in a user-friendly format with color coding
+ *
+ * @function formatDiffOutput
+ * @param {Object} diffResult - Comparison result from compareFiles
+ */
+function formatDiffOutput(diffResult) {
+  logger.log(chalk.blue(`\nComparing: ${diffResult.file1} ↔ ${diffResult.file2}`));
+
+  if (diffResult.identical) {
+    logger.log(chalk.green('\n✓ Files are identical'));
+    return;
+  }
+
+  logger.log(chalk.yellow('\nFiles are different'));
+
+  // Version information
+  if (diffResult.versionChanged) {
+    logger.log(chalk.blue(`\nVersion: ${diffResult.version1} → ${diffResult.version2}`));
+  }
+
+  // Breaking changes
+  if (diffResult.breakingChanges.length > 0) {
+    logger.log(chalk.red('\n⚠️  Breaking Changes:'));
+    diffResult.breakingChanges.forEach(change => {
+      logger.log(chalk.red(`  • ${change.description}`));
+    });
+  }
+
+  // Added fields
+  if (diffResult.added.length > 0) {
+    logger.log(chalk.green('\nAdded Fields:'));
+    diffResult.added.forEach(field => {
+      logger.log(chalk.green(`  + ${field.path}: ${JSON.stringify(field.value)}`));
+    });
+  }
+
+  // Removed fields
+  if (diffResult.removed.length > 0) {
+    logger.log(chalk.red('\nRemoved Fields:'));
+    diffResult.removed.forEach(field => {
+      logger.log(chalk.red(`  - ${field.path}: ${JSON.stringify(field.value)}`));
+    });
+  }
+
+  // Changed fields
+  if (diffResult.changed.length > 0) {
+    logger.log(chalk.yellow('\nChanged Fields:'));
+    diffResult.changed.forEach(change => {
+      logger.log(chalk.yellow(`  ~ ${change.path}:`));
+      logger.log(chalk.gray(`    Old: ${JSON.stringify(change.oldValue)}`));
+      logger.log(chalk.gray(`    New: ${JSON.stringify(change.newValue)}`));
+    });
+  }
+
+  // Summary
+  logger.log(chalk.blue('\nSummary:'));
+  logger.log(chalk.blue(`  Added: ${diffResult.summary.totalAdded}`));
+  logger.log(chalk.blue(`  Removed: ${diffResult.summary.totalRemoved}`));
+  logger.log(chalk.blue(`  Changed: ${diffResult.summary.totalChanged}`));
+  logger.log(chalk.blue(`  Breaking: ${diffResult.summary.totalBreaking}`));
+}
+
+module.exports = {
+  compareFiles,
+  formatDiffOutput,
+  compareObjects,
+  identifyBreakingChanges
+};
+

package/lib/environment-deploy.js

@@ -0,0 +1,305 @@
+/**
+ * AI Fabrix Builder Environment Deployment Module
+ *
+ * Handles environment deployment/setup in Miso Controller.
+ * Sets up environment infrastructure before applications can be deployed.
+ *
+ * @fileoverview Environment deployment for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const logger = require('./utils/logger');
+const config = require('./config');
+const { validateControllerUrl, validateEnvironmentKey } = require('./utils/deployment-validation');
+const { getOrRefreshDeviceToken } = require('./utils/token-manager');
+const { authenticatedApiCall } = require('./utils/api');
+const { handleDeploymentErrors } = require('./utils/deployment-errors');
+const auditLogger = require('./audit-logger');
+
+/**
+ * Validates environment deployment prerequisites
+ * @param {string} envKey - Environment key
+ * @param {string} controllerUrl - Controller URL
+ * @throws {Error} If prerequisites are not met
+ */
+function validateEnvironmentPrerequisites(envKey, controllerUrl) {
+  if (!envKey || typeof envKey !== 'string') {
+    throw new Error('Environment key is required');
+  }
+
+  if (!controllerUrl || typeof controllerUrl !== 'string') {
+    throw new Error('Controller URL is required');
+  }
+
+  // Validate environment key format
+  validateEnvironmentKey(envKey);
+
+  // Validate controller URL
+  validateControllerUrl(controllerUrl);
+}
+
+/**
+ * Gets authentication for environment deployment
+ * Uses device token (not app-specific client credentials)
+ * @async
+ * @param {string} controllerUrl - Controller URL
+ * @returns {Promise<Object>} Authentication configuration
+ * @throws {Error} If authentication is not available
+ */
+async function getEnvironmentAuth(controllerUrl) {
+  const validatedUrl = validateControllerUrl(controllerUrl);
+
+  // Get or refresh device token
+  const deviceToken = await getOrRefreshDeviceToken(validatedUrl);
+
+  if (!deviceToken || !deviceToken.token) {
+    throw new Error('Device token is required for environment deployment. Run "aifabrix login" first to authenticate.');
+  }
+
+  return {
+    type: 'device',
+    token: deviceToken.token,
+    controller: deviceToken.controller || validatedUrl
+  };
+}
+
+/**
+ * Sends environment deployment request to controller
+ * @async
+ * @param {string} controllerUrl - Controller URL
+ * @param {string} envKey - Environment key
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} options - Deployment options
+ * @returns {Promise<Object>} Deployment result
+ * @throws {Error} If deployment fails
+ */
+async function sendEnvironmentDeployment(controllerUrl, envKey, authConfig, options = {}) {
+  const validatedUrl = validateControllerUrl(controllerUrl);
+  const validatedEnvKey = validateEnvironmentKey(envKey);
+
+  // Build environment deployment request
+  const deploymentRequest = {
+    key: validatedEnvKey,
+    displayName: `${validatedEnvKey.charAt(0).toUpperCase() + validatedEnvKey.slice(1)} Environment`,
+    description: `${validatedEnvKey.charAt(0).toUpperCase() + validatedEnvKey.slice(1)} environment for application deployments`
+  };
+
+  // Add configuration if provided
+  if (options.config) {
+    // TODO: Load and parse config file if provided
+    // For now, just include the config path in description
+    deploymentRequest.description += ` (config: ${options.config})`;
+  }
+
+  // API endpoint: POST /api/v1/environments/{env}/deploy
+  // Alternative: POST /api/v1/environments/deploy with environment in body
+  const endpoint = `${validatedUrl}/api/v1/environments/${validatedEnvKey}/deploy`;
+
+  // Log deployment attempt for audit
+  await auditLogger.logDeploymentAttempt(validatedEnvKey, validatedUrl, options);
+
+  try {
+    const response = await authenticatedApiCall(
+      endpoint,
+      {
+        method: 'POST',
+        body: JSON.stringify(deploymentRequest)
+      },
+      authConfig.token
+    );
+
+    if (!response.success) {
+      const error = new Error(response.formattedError || response.error || 'Environment deployment failed');
+      error.status = response.status;
+      error.data = response.errorData;
+      throw error;
+    }
+
+    // Handle response structure
+    const responseData = response.data || {};
+    return {
+      success: true,
+      environment: validatedEnvKey,
+      deploymentId: responseData.deploymentId || responseData.id,
+      status: responseData.status || 'initiated',
+      url: responseData.url || `${validatedUrl}/environments/${validatedEnvKey}`,
+      message: responseData.message
+    };
+  } catch (error) {
+    // Use unified error handler
+    await handleDeploymentErrors(error, validatedEnvKey, validatedUrl, false);
+    throw error;
+  }
+}
+
+/**
+ * Polls environment deployment status
+ * @async
+ * @param {string} deploymentId - Deployment ID
+ * @param {string} controllerUrl - Controller URL
+ * @param {string} envKey - Environment key
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} options - Polling options
+ * @returns {Promise<Object>} Final deployment status
+ */
+async function pollEnvironmentStatus(deploymentId, controllerUrl, envKey, authConfig, options = {}) {
+  const validatedUrl = validateControllerUrl(controllerUrl);
+  const validatedEnvKey = validateEnvironmentKey(envKey);
+
+  const pollInterval = options.pollInterval || 5000;
+  const maxAttempts = options.maxAttempts || 60;
+  const statusEndpoint = `${validatedUrl}/api/v1/environments/${validatedEnvKey}/status`;
+
+  logger.log(chalk.blue(`⏳ Polling environment status (${pollInterval}ms intervals)...`));
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+
+      const response = await authenticatedApiCall(
+        statusEndpoint,
+        {
+          method: 'GET'
+        },
+        authConfig.token
+      );
+
+      if (response.success && response.data) {
+        const status = response.data.status || response.data.ready;
+        const isReady = status === 'ready' || status === 'completed' || response.data.ready === true;
+
+        if (isReady) {
+          return {
+            success: true,
+            environment: validatedEnvKey,
+            status: 'ready',
+            message: 'Environment is ready for application deployments'
+          };
+        }
+
+        // Check for terminal failure states
+        if (status === 'failed' || status === 'error') {
+          throw new Error(`Environment deployment failed: ${response.data.message || 'Unknown error'}`);
+        }
+      }
+    } catch (error) {
+      // If it's a terminal error (not a timeout), throw it
+      if (error.message && error.message.includes('failed')) {
+        throw error;
+      }
+      // Otherwise, continue polling
+    }
+
+    if (attempt < maxAttempts) {
+      logger.log(chalk.gray(`   Attempt ${attempt}/${maxAttempts}...`));
+    }
+  }
+
+  // Timeout
+  throw new Error(`Environment deployment timeout after ${maxAttempts} attempts. Check controller logs for status.`);
+}
+
+/**
+ * Displays environment deployment results
+ * @param {Object} result - Deployment result
+ */
+function displayDeploymentResults(result) {
+  logger.log(chalk.green('\n✅ Environment deployed successfully'));
+  logger.log(chalk.blue(`   Environment: ${result.environment}`));
+  logger.log(chalk.blue(`   Status: ${result.status === 'ready' ? '✅ ready' : result.status}`));
+  if (result.url) {
+    logger.log(chalk.blue(`   URL: ${result.url}`));
+  }
+  if (result.deploymentId) {
+    logger.log(chalk.blue(`   Deployment ID: ${result.deploymentId}`));
+  }
+  logger.log(chalk.green('\n✓ Environment is ready for application deployments'));
+}
+
+/**
+ * Deploys/setups an environment in the controller
+ * @async
+ * @function deployEnvironment
+ * @param {string} envKey - Environment key (miso, dev, tst, pro)
+ * @param {Object} options - Deployment options
+ * @param {string} options.controller - Controller URL (required)
+ * @param {string} [options.config] - Environment configuration file (optional)
+ * @param {boolean} [options.skipValidation] - Skip validation checks
+ * @param {boolean} [options.poll] - Poll for deployment status (default: true)
+ * @param {boolean} [options.noPoll] - Do not poll for status
+ * @returns {Promise<Object>} Deployment result
+ * @throws {Error} If deployment fails
+ *
+ * @example
+ * await deployEnvironment('dev', { controller: 'https://controller.aifabrix.ai' });
+ */
+async function deployEnvironment(envKey, options = {}) {
+  try {
+    // 1. Input validation
+    if (!envKey || typeof envKey !== 'string' || envKey.trim().length === 0) {
+      throw new Error('Environment key is required');
+    }
+
+    const controllerUrl = options.controller || options['controller-url'];
+    if (!controllerUrl) {
+      throw new Error('Controller URL is required. Use --controller flag');
+    }
+
+    // 2. Validate prerequisites
+    if (!options.skipValidation) {
+      validateEnvironmentPrerequisites(envKey, controllerUrl);
+    }
+
+    // 3. Update root-level environment in config.yaml
+    await config.setCurrentEnvironment(envKey);
+
+    // 4. Get authentication (device token)
+    logger.log(chalk.blue(`\n📋 Deploying environment '${envKey}' to ${controllerUrl}...`));
+    const authConfig = await getEnvironmentAuth(controllerUrl);
+    logger.log(chalk.green('✓ Environment validated'));
+    logger.log(chalk.green('✓ Authentication successful'));
+
+    // 5. Send environment deployment request
+    logger.log(chalk.blue('\n🚀 Deploying environment infrastructure...'));
+    const validatedControllerUrl = validateControllerUrl(authConfig.controller);
+    const result = await sendEnvironmentDeployment(validatedControllerUrl, envKey, authConfig, options);
+
+    logger.log(chalk.blue(`📤 Sending deployment request to ${validatedControllerUrl}/api/v1/environments/${envKey}/deploy...`));
+
+    // 6. Poll for status if enabled
+    const shouldPoll = options.poll !== false && !options.noPoll;
+    if (shouldPoll && result.deploymentId) {
+      const pollResult = await pollEnvironmentStatus(
+        result.deploymentId,
+        validatedControllerUrl,
+        envKey,
+        authConfig,
+        {
+          pollInterval: 5000,
+          maxAttempts: 60
+        }
+      );
+      result.status = pollResult.status;
+      result.message = pollResult.message;
+    }
+
+    // 7. Display results
+    displayDeploymentResults(result);
+
+    return result;
+  } catch (error) {
+    // Error handling is done in sendEnvironmentDeployment and pollEnvironmentStatus
+    // Re-throw with context
+    if (error._logged !== true) {
+      logger.error(chalk.red(`\n❌ Environment deployment failed: ${error.message}`));
+    }
+    throw error;
+  }
+}
+
+module.exports = {
+  deployEnvironment
+};
+