@aifabrix/builder 2.0.0 → 2.0.3

package/lib/utils/api.js

@@ -0,0 +1,329 @@
+/**
+ * AI Fabrix Builder API Utilities
+ *
+ * Helper functions for making API calls to the controller
+ * Supports both bearer token and ClientId/Secret authentication
+ * Supports OAuth2 Device Code Flow (RFC 8628)
+ *
+ * @fileoverview API calling utilities for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+/**
+ * Make an API call with proper error handling
+ * @param {string} url - API endpoint URL
+ * @param {Object} options - Fetch options
+ * @returns {Promise<Object>} Response object with success flag
+ */
+async function makeApiCall(url, options = {}) {
+  try {
+    const response = await fetch(url, options);
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorMessage;
+      try {
+        const errorJson = JSON.parse(errorText);
+        errorMessage = errorJson.error || errorJson.message || 'Unknown error';
+      } catch {
+        errorMessage = errorText || `HTTP ${response.status}: ${response.statusText}`;
+      }
+      return {
+        success: false,
+        error: errorMessage,
+        status: response.status
+      };
+    }
+
+    const contentType = response.headers.get('content-type');
+    if (contentType && contentType.includes('application/json')) {
+      const data = await response.json();
+      return {
+        success: true,
+        data,
+        status: response.status
+      };
+    }
+
+    const text = await response.text();
+    return {
+      success: true,
+      data: text,
+      status: response.status
+    };
+
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message,
+      network: true
+    };
+  }
+}
+
+/**
+ * Make an authenticated API call with bearer token
+ * @param {string} url - API endpoint URL
+ * @param {Object} options - Fetch options
+ * @param {string} token - Bearer token
+ * @returns {Promise<Object>} Response object
+ */
+async function authenticatedApiCall(url, options = {}, token) {
+  const headers = {
+    'Content-Type': 'application/json',
+    ...options.headers
+  };
+
+  if (token) {
+    headers['Authorization'] = `Bearer ${token}`;
+  }
+
+  return makeApiCall(url, {
+    ...options,
+    headers
+  });
+}
+
+/**
+ * Parses device code response from API
+ * @function parseDeviceCodeResponse
+ * @param {Object} response - API response object
+ * @returns {Object} Parsed device code response
+ * @throws {Error} If response is invalid
+ */
+function parseDeviceCodeResponse(response) {
+  const apiResponse = response.data;
+  const responseData = apiResponse.data || apiResponse;
+
+  const deviceCode = responseData.deviceCode || responseData.device_code;
+  const userCode = responseData.userCode || responseData.user_code;
+  const verificationUri = responseData.verificationUri || responseData.verification_uri;
+  const expiresIn = responseData.expiresIn || responseData.expires_in || 600;
+  const interval = responseData.interval || 5;
+
+  if (!deviceCode || !userCode || !verificationUri) {
+    throw new Error('Invalid device code response: missing required fields');
+  }
+
+  return {
+    device_code: deviceCode,
+    user_code: userCode,
+    verification_uri: verificationUri,
+    expires_in: expiresIn,
+    interval: interval
+  };
+}
+
+/**
+ * Initiates OAuth2 Device Code Flow
+ * Calls the device code endpoint to get device_code and user_code
+ *
+ * @async
+ * @function initiateDeviceCodeFlow
+ * @param {string} controllerUrl - Base URL of the controller
+ * @param {string} environment - Environment key (e.g., 'dev', 'tst', 'pro')
+ * @returns {Promise<Object>} Device code response with device_code, user_code, verification_uri, expires_in, interval
+ * @throws {Error} If initiation fails
+ */
+async function initiateDeviceCodeFlow(controllerUrl, environment) {
+  if (!environment || typeof environment !== 'string') {
+    throw new Error('Environment key is required');
+  }
+
+  const url = `${controllerUrl}/api/v1/auth/login?environment=${encodeURIComponent(environment)}`;
+  const response = await makeApiCall(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    }
+  });
+
+  if (!response.success) {
+    throw new Error(`Device code initiation failed: ${response.error || 'Unknown error'}`);
+  }
+
+  return parseDeviceCodeResponse(response);
+}
+
+/**
+ * Checks if token has expired based on elapsed time
+ * @function checkTokenExpiration
+ * @param {number} startTime - Start time in milliseconds
+ * @param {number} expiresIn - Expiration time in seconds
+ * @throws {Error} If token has expired
+ */
+function checkTokenExpiration(startTime, expiresIn) {
+  const maxWaitTime = (expiresIn + 30) * 1000;
+  if (Date.now() - startTime > maxWaitTime) {
+    throw new Error('Device code expired: Maximum polling time exceeded');
+  }
+}
+
+/**
+ * Parses token response from API
+ * @function parseTokenResponse
+ * @param {Object} response - API response object
+ * @returns {Object|null} Parsed token response or null if pending
+ */
+function parseTokenResponse(response) {
+  const apiResponse = response.data;
+  const responseData = apiResponse.data || apiResponse;
+
+  const error = responseData.error || apiResponse.error;
+  if (error === 'authorization_pending' || error === 'slow_down') {
+    return null;
+  }
+
+  const accessToken = responseData.accessToken || responseData.access_token;
+  const refreshToken = responseData.refreshToken || responseData.refresh_token;
+  const expiresIn = responseData.expiresIn || responseData.expires_in || 3600;
+
+  if (!accessToken) {
+    throw new Error('Invalid token response: missing accessToken');
+  }
+
+  return {
+    access_token: accessToken,
+    refresh_token: refreshToken,
+    expires_in: expiresIn
+  };
+}
+
+/**
+ * Handles polling errors
+ * @function handlePollingErrors
+ * @param {string} error - Error code
+ * @param {number} status - HTTP status code
+ * @throws {Error} For fatal errors
+ * @returns {boolean} True if should continue polling
+ */
+function handlePollingErrors(error, status) {
+  if (error === 'authorization_pending' || status === 202) {
+    return true;
+  }
+
+  // Check error field first, then status code
+  if (error === 'authorization_declined') {
+    throw new Error('Authorization declined: User denied the request');
+  }
+
+  if (error === 'expired_token' || status === 410) {
+    throw new Error('Device code expired: Please restart the authentication process');
+  }
+
+  if (error === 'slow_down') {
+    return true;
+  }
+
+  throw new Error(`Token polling failed: ${error}`);
+}
+
+/**
+ * Waits for next polling interval
+ * @async
+ * @function waitForNextPoll
+ * @param {number} interval - Polling interval in seconds
+ * @param {boolean} slowDown - Whether to slow down
+ */
+async function waitForNextPoll(interval, slowDown) {
+  const waitInterval = slowDown ? interval * 2 : interval;
+  await new Promise(resolve => setTimeout(resolve, waitInterval * 1000));
+}
+
+/**
+ * Polls for token during Device Code Flow
+ * Continuously polls the token endpoint until user approves or flow expires
+ *
+ * @async
+ * @function pollDeviceCodeToken
+ * @param {string} controllerUrl - Base URL of the controller
+ * @param {string} deviceCode - Device code from initiation
+ * @param {number} interval - Polling interval in seconds
+ * @param {number} expiresIn - Expiration time in seconds
+ * @param {Function} [onPoll] - Optional callback called on each poll attempt
+ * @returns {Promise<Object>} Token response with access_token, refresh_token, expires_in
+ * @throws {Error} If polling fails or token is expired/declined
+ */
+async function pollDeviceCodeToken(controllerUrl, deviceCode, interval, expiresIn, onPoll) {
+  if (!deviceCode || typeof deviceCode !== 'string') {
+    throw new Error('Device code is required');
+  }
+
+  const url = `${controllerUrl}/api/v1/auth/login/device/token`;
+  const startTime = Date.now();
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    checkTokenExpiration(startTime, expiresIn);
+
+    if (onPoll) {
+      onPoll();
+    }
+
+    const response = await makeApiCall(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        deviceCode: deviceCode
+      })
+    });
+
+    if (response.success) {
+      const tokenResponse = parseTokenResponse(response);
+      if (tokenResponse) {
+        return tokenResponse;
+      }
+
+      const apiResponse = response.data;
+      const responseData = apiResponse.data || apiResponse;
+      const error = responseData.error || apiResponse.error;
+      const slowDown = error === 'slow_down';
+      await waitForNextPoll(interval, slowDown);
+      continue;
+    }
+
+    const apiResponse = response.data || {};
+    const errorData = typeof apiResponse === 'object' ? apiResponse : {};
+    const error = errorData.error || response.error || 'Unknown error';
+    const shouldContinue = handlePollingErrors(error, response.status);
+
+    if (shouldContinue) {
+      const slowDown = error === 'slow_down';
+      await waitForNextPoll(interval, slowDown);
+      continue;
+    }
+  }
+}
+
+/**
+ * Displays device code information to the user
+ * Formats user code and verification URL for easy reading
+ *
+ * @function displayDeviceCodeInfo
+ * @param {string} userCode - User code to display
+ * @param {string} verificationUri - Verification URL
+ * @param {Object} logger - Logger instance with log method
+ * @param {Object} chalk - Chalk instance for colored output
+ */
+function displayDeviceCodeInfo(userCode, verificationUri, logger, chalk) {
+  logger.log(chalk.cyan('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  logger.log(chalk.cyan('  Device Code Flow Authentication'));
+  logger.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+  logger.log(chalk.yellow('To complete authentication:'));
+  logger.log(chalk.gray('  1. Visit: ') + chalk.blue.underline(verificationUri));
+  logger.log(chalk.gray('  2. Enter code: ') + chalk.bold.cyan(userCode));
+  logger.log(chalk.gray('  3. Approve the request\n'));
+  logger.log(chalk.gray('Waiting for approval...'));
+}
+
+module.exports = {
+  makeApiCall,
+  authenticatedApiCall,
+  initiateDeviceCodeFlow,
+  pollDeviceCodeToken,
+  displayDeviceCodeInfo
+};
+

package/lib/utils/cli-utils.js

@@ -0,0 +1,97 @@
+/**
+ * CLI Utility Functions
+ *
+ * Utility functions for CLI command handling and validation.
+ *
+ * @fileoverview CLI utilities for error handling and validation
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const logger = require('./logger');
+
+/**
+ * Validates a command and its options
+ * @param {string} _command - Command name
+ * @param {Object} _options - Command options
+ * @returns {boolean} True if valid
+ */
+function validateCommand(_command, _options) {
+  // TODO: Implement command validation
+  // TODO: Add helpful error messages for common issues
+  return true;
+}
+
+/**
+ * Formats error message based on error type
+ * @function formatError
+ * @param {Error} error - The error that occurred
+ * @returns {string[]} Array of error message lines
+ */
+function formatError(error) {
+  const messages = [];
+  const errorMsg = error.message || '';
+
+  // Check for specific error patterns first (most specific to least specific)
+  if (errorMsg.includes('Configuration not found')) {
+    messages.push(`   ${errorMsg}`);
+  } else if (errorMsg.includes('not found locally') || (errorMsg.includes('Docker image') && errorMsg.includes('not found'))) {
+    messages.push('   Docker image not found.');
+    messages.push('   Run: aifabrix build <app> first');
+  } else if (errorMsg.includes('Docker') && (errorMsg.includes('not running') || errorMsg.includes('not installed') || errorMsg.includes('Cannot connect'))) {
+    messages.push('   Docker is not running or not installed.');
+    messages.push('   Please start Docker Desktop and try again.');
+  } else if (errorMsg.includes('port')) {
+    messages.push('   Port conflict detected.');
+    messages.push('   Run "aifabrix doctor" to check which ports are in use.');
+  } else if (errorMsg.includes('permission')) {
+    messages.push('   Permission denied.');
+    messages.push('   Make sure you have the necessary permissions to run Docker commands.');
+  } else if (errorMsg.includes('Azure CLI') || errorMsg.includes('az --version')) {
+    messages.push('   Azure CLI is not installed.');
+    messages.push('   Install from: https://docs.microsoft.com/cli/azure/install-azure-cli');
+    messages.push('   Run: az login');
+  } else if (errorMsg.includes('authenticate') || errorMsg.includes('ACR')) {
+    messages.push('   Azure Container Registry authentication failed.');
+    messages.push('   Run: az acr login --name <registry-name>');
+    messages.push('   Or login to Azure: az login');
+  } else if (errorMsg.includes('Invalid ACR URL') || errorMsg.includes('Expected format')) {
+    messages.push('   Invalid registry URL format.');
+    messages.push('   Use format: *.azurecr.io (e.g., myacr.azurecr.io)');
+  } else if (errorMsg.includes('Registry URL is required')) {
+    messages.push('   Registry URL is required.');
+    messages.push('   Provide via --registry flag or configure in variables.yaml under image.registry');
+  } else {
+    messages.push(`   ${errorMsg}`);
+  }
+
+  return messages;
+}
+
+/**
+ * Logs error messages
+ * @function logError
+ * @param {string} command - Command that failed
+ * @param {string[]} errorMessages - Error message lines
+ */
+function logError(command, errorMessages) {
+  logger.error(`\n❌ Error in ${command} command:`);
+  errorMessages.forEach(msg => logger.error(msg));
+  logger.error('\n💡 Run "aifabrix doctor" for environment diagnostics.\n');
+}
+
+/**
+ * Handles command errors with user-friendly messages
+ * @param {Error} error - The error that occurred
+ * @param {string} command - Command that failed
+ */
+function handleCommandError(error, command) {
+  const errorMessages = formatError(error);
+  logError(command, errorMessages);
+}
+
+module.exports = {
+  validateCommand,
+  handleCommandError
+};
+

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