@aifabrix/builder 2.0.0 → 2.0.2

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/dockerfile-utils.js

@@ -0,0 +1,131 @@
+/**
+ * Dockerfile Utility Functions
+ *
+ * This module handles Dockerfile template loading, rendering,
+ * and path resolution. Separated from build.js to maintain
+ * file size limits and improve code organization.
+ *
+ * @fileoverview Dockerfile utility functions for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fsSync = require('fs');
+const path = require('path');
+const handlebars = require('handlebars');
+
+/**
+ * Loads Dockerfile template for language
+ * @function loadDockerfileTemplate
+ * @param {string} language - Language ('typescript' or 'python')
+ * @returns {Function} Compiled Handlebars template
+ * @throws {Error} If template not found
+ */
+function loadDockerfileTemplate(language) {
+  const templatePath = path.join(__dirname, '..', '..', 'templates', language, 'Dockerfile.hbs');
+
+  if (!fsSync.existsSync(templatePath)) {
+    throw new Error(`Template not found for language: ${language}`);
+  }
+
+  const templateContent = fsSync.readFileSync(templatePath, 'utf8');
+  return handlebars.compile(templateContent);
+}
+
+/**
+ * Renders Dockerfile with template variables
+ * @function renderDockerfile
+ * @param {Function} template - Compiled Handlebars template
+ * @param {Object} templateVars - Template variables
+ * @param {string} language - Language ('typescript' or 'python')
+ * @param {boolean} isAppFlag - Whether --app flag was used
+ * @param {string} appSourcePath - Application source path
+ * @returns {string} Rendered Dockerfile content
+ */
+function renderDockerfile(template, templateVars, language, isAppFlag, appSourcePath) {
+  let dockerfileContent = template(templateVars);
+
+  if (!isAppFlag) {
+    return dockerfileContent;
+  }
+
+  dockerfileContent = dockerfileContent.replace(
+    /^COPY \. \./gm,
+    `COPY ${appSourcePath} .`
+  );
+
+  if (language === 'python') {
+    // Replace COPY requirements*.txt with app-specific path
+    dockerfileContent = dockerfileContent.replace(
+      /^COPY requirements\*\.txt \./gm,
+      `COPY ${appSourcePath}requirements*.txt ./`
+    );
+    // Also handle case where it might be COPY requirements.txt
+    dockerfileContent = dockerfileContent.replace(
+      /^COPY requirements\.txt \./gm,
+      `COPY ${appSourcePath}requirements.txt ./`
+    );
+  }
+
+  if (language === 'typescript') {
+    dockerfileContent = dockerfileContent.replace(
+      /^COPY package\*\.json \./gm,
+      `COPY ${appSourcePath}package*.json ./`
+    );
+  }
+
+  return dockerfileContent;
+}
+
+/**
+ * Checks for template Dockerfile in builder directory
+ * @function checkTemplateDockerfile
+ * @param {string} builderPath - Builder directory path
+ * @param {string} appName - Application name
+ * @param {boolean} forceTemplate - Force template flag
+ * @returns {string|null} Dockerfile path or null
+ */
+function checkTemplateDockerfile(builderPath, appName, forceTemplate) {
+  const appDockerfilePath = path.join(builderPath, 'Dockerfile');
+  if (fsSync.existsSync(appDockerfilePath) && !forceTemplate) {
+    return appDockerfilePath;
+  }
+  return null;
+}
+
+/**
+ * Checks for custom Dockerfile from variables.yaml
+ * @function checkProjectDockerfile
+ * @param {string} builderPath - Builder directory path
+ * @param {string} appName - Application name
+ * @param {Object} buildConfig - Build configuration
+ * @param {string} contextPath - Build context path
+ * @param {boolean} forceTemplate - Force template flag
+ * @returns {string|null} Dockerfile path or null
+ */
+function checkProjectDockerfile(builderPath, appName, buildConfig, contextPath, forceTemplate) {
+  const customDockerfile = buildConfig.dockerfile;
+  if (!customDockerfile || forceTemplate) {
+    return null;
+  }
+
+  const customPath = path.resolve(contextPath, customDockerfile);
+  if (fsSync.existsSync(customPath)) {
+    return customPath;
+  }
+
+  const builderCustomPath = path.join(process.cwd(), 'builder', appName, customDockerfile);
+  if (fsSync.existsSync(builderCustomPath)) {
+    return builderCustomPath;
+  }
+
+  return null;
+}
+
+module.exports = {
+  loadDockerfileTemplate,
+  renderDockerfile,
+  checkTemplateDockerfile,
+  checkProjectDockerfile
+};
+

package/lib/utils/environment-checker.js

@@ -0,0 +1,125 @@
+/**
+ * Environment Checking Utilities
+ *
+ * Checks the development environment for common issues
+ * Validates Docker, ports, secrets, and other requirements
+ *
+ * @fileoverview Environment checking utilities for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Checks if Docker is installed and available
+ *
+ * @async
+ * @function checkDocker
+ * @returns {Promise<string>} 'ok' if Docker is available, 'error' otherwise
+ */
+async function checkDocker() {
+  try {
+    const { exec } = require('child_process');
+    const { promisify } = require('util');
+    const execAsync = promisify(exec);
+
+    await execAsync('docker --version');
+    await execAsync('docker-compose --version');
+    return 'ok';
+  } catch (error) {
+    return 'error';
+  }
+}
+
+/**
+ * Checks if required ports are available
+ *
+ * @async
+ * @function checkPorts
+ * @returns {Promise<string>} 'ok' if all ports are available, 'warning' otherwise
+ */
+async function checkPorts() {
+  const requiredPorts = [5432, 6379, 5050, 8081];
+  const netstat = require('net');
+  let portIssues = 0;
+
+  for (const port of requiredPorts) {
+    try {
+      await new Promise((resolve, reject) => {
+        const server = netstat.createServer();
+        server.listen(port, () => {
+          server.close(resolve);
+        });
+        server.on('error', reject);
+      });
+    } catch (error) {
+      portIssues++;
+    }
+  }
+
+  return portIssues === 0 ? 'ok' : 'warning';
+}
+
+/**
+ * Checks if secrets file exists
+ *
+ * @function checkSecrets
+ * @returns {string} 'ok' if secrets file exists, 'missing' otherwise
+ */
+function checkSecrets() {
+  const secretsPath = path.join(os.homedir(), '.aifabrix', 'secrets.yaml');
+  return fs.existsSync(secretsPath) ? 'ok' : 'missing';
+}
+
+/**
+ * Checks the development environment for common issues
+ * Validates Docker, ports, secrets, and other requirements
+ *
+ * @async
+ * @function checkEnvironment
+ * @returns {Promise<Object>} Environment check result
+ * @throws {Error} If critical issues are found
+ *
+ * @example
+ * const result = await checkEnvironment();
+ * // Returns: { docker: 'ok', ports: 'ok', secrets: 'missing', recommendations: [...] }
+ */
+async function checkEnvironment() {
+  const result = {
+    docker: 'unknown',
+    ports: 'unknown',
+    secrets: 'unknown',
+    recommendations: []
+  };
+
+  // Check Docker
+  result.docker = await checkDocker();
+  if (result.docker === 'error') {
+    result.recommendations.push('Install Docker and Docker Compose');
+  }
+
+  // Check ports
+  result.ports = await checkPorts();
+  if (result.ports === 'warning') {
+    result.recommendations.push('Some required ports (5432, 6379, 5050, 8081) are in use');
+  }
+
+  // Check secrets
+  result.secrets = checkSecrets();
+  if (result.secrets === 'missing') {
+    result.recommendations.push('Create secrets file: ~/.aifabrix/secrets.yaml');
+  }
+
+  return result;
+}
+
+module.exports = {
+  checkDocker,
+  checkPorts,
+  checkSecrets,
+  checkEnvironment
+};
+