@aifabrix/builder 2.10.0 → 2.11.0

package/lib/utils/app-register-config.js

@@ -0,0 +1,205 @@
+/**
+ * AI Fabrix Builder - App Register Configuration Utilities
+ *
+ * Configuration extraction and loading for application registration
+ *
+ * @fileoverview Configuration utilities for app registration
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const yaml = require('js-yaml');
+const logger = require('./logger');
+const { detectAppType } = require('./paths');
+
+// Import createApp to auto-generate config if missing
+let createApp;
+try {
+  createApp = require('../app').createApp;
+} catch {
+  createApp = null;
+}
+
+/**
+ * Load variables.yaml file for an application
+ * @async
+ * @param {string} appKey - Application key
+ * @returns {Promise<{variables: Object, created: boolean}>} Variables and creation flag
+ */
+async function loadVariablesYaml(appKey) {
+  // Detect app type and get correct path (integration or builder)
+  const { appPath } = await detectAppType(appKey);
+  const variablesPath = path.join(appPath, 'variables.yaml');
+
+  try {
+    const variablesContent = await fs.readFile(variablesPath, 'utf-8');
+    return { variables: yaml.load(variablesContent), created: false };
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      logger.log(chalk.yellow(`⚠️  variables.yaml not found for ${appKey}`));
+      logger.log(chalk.yellow('📝 Creating minimal configuration...\n'));
+      return { variables: null, created: true };
+    }
+    throw new Error(`Failed to read variables.yaml: ${error.message}`);
+  }
+}
+
+/**
+ * Create minimal application configuration if needed
+ * @async
+ * @param {string} appKey - Application key
+ * @param {Object} options - Registration options
+ * @returns {Promise<Object>} Variables after creation
+ */
+async function createMinimalAppIfNeeded(appKey, options) {
+  if (!createApp) {
+    throw new Error('Cannot auto-create application: createApp function not available');
+  }
+
+  await createApp(appKey, {
+    port: options.port,
+    language: 'typescript',
+    database: false,
+    redis: false,
+    storage: false,
+    authentication: false
+  });
+
+  // Detect app type and get correct path (integration or builder)
+  const { appPath } = await detectAppType(appKey);
+  const variablesPath = path.join(appPath, 'variables.yaml');
+  const variablesContent = await fs.readFile(variablesPath, 'utf-8');
+  return yaml.load(variablesContent);
+}
+
+/**
+ * Builds image reference string from variables
+ * Format: repository:tag (e.g., aifabrix/miso-controller:latest or myregistry.azurecr.io/miso-controller:v1.0.0)
+ * @param {Object} variables - Variables from YAML file
+ * @param {string} appKey - Application key (fallback)
+ * @returns {string} Image reference string
+ */
+function buildImageReference(variables, appKey) {
+  const imageName = variables.image?.name || variables.app?.key || appKey;
+  const registry = variables.image?.registry;
+  const tag = variables.image?.tag || 'latest';
+  return registry ? `${registry}/${imageName}:${tag}` : `${imageName}:${tag}`;
+}
+
+/**
+ * Extract URL from external system JSON file for registration
+ * @async
+ * @param {string} appKey - Application key
+ * @param {Object} externalIntegration - External integration config from variables.yaml
+ * @returns {Promise<{url: string, apiKey?: string}>} URL and optional API key
+ */
+async function extractExternalIntegrationUrl(appKey, externalIntegration) {
+  if (!externalIntegration || !externalIntegration.systems || externalIntegration.systems.length === 0) {
+    throw new Error('externalIntegration.systems is required for external type applications');
+  }
+
+  // Detect app type and get correct path (integration or builder)
+  const { appPath } = await detectAppType(appKey);
+  const schemaBasePath = externalIntegration.schemaBasePath || './';
+  const systemFileName = externalIntegration.systems[0];
+
+  // Resolve system file path (handle both relative and absolute paths)
+  const systemFilePath = path.isAbsolute(schemaBasePath)
+    ? path.join(schemaBasePath, systemFileName)
+    : path.join(appPath, schemaBasePath, systemFileName);
+
+  try {
+    const systemContent = await fs.readFile(systemFilePath, 'utf-8');
+    const systemJson = JSON.parse(systemContent);
+
+    // Extract URL from environment.baseUrl
+    const url = systemJson.environment?.baseUrl;
+    if (!url) {
+      throw new Error(`Missing environment.baseUrl in ${systemFileName}`);
+    }
+
+    // Extract optional API key from authentication if present
+    let apiKey;
+    if (systemJson.authentication?.apikey?.key) {
+      // If it's a kv:// reference, we can't resolve it here, so leave it undefined
+      // The API will handle kv:// references
+      const keyValue = systemJson.authentication.apikey.key;
+      if (!keyValue.startsWith('kv://') && !keyValue.startsWith('{{')) {
+        apiKey = keyValue;
+      }
+    }
+
+    return { url, apiKey };
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      throw new Error(`External system file not found: ${systemFilePath}`);
+    }
+    throw new Error(`Failed to read external system file: ${error.message}`);
+  }
+}
+
+/**
+ * Extract application configuration from variables.yaml
+ * @async
+ * @param {Object} variables - Variables from YAML file
+ * @param {string} appKey - Application key
+ * @param {Object} options - Registration options
+ * @returns {Promise<Object>} Extracted configuration
+ */
+async function extractAppConfiguration(variables, appKey, options) {
+  const appKeyFromFile = variables.app?.key || appKey;
+  const displayName = variables.app?.name || options.name || appKey;
+  const description = variables.app?.description || '';
+
+  // Handle external type
+  if (variables.app?.type === 'external') {
+    // Extract URL from external system JSON file
+    const { url, apiKey } = await extractExternalIntegrationUrl(appKey, variables.externalIntegration);
+
+    // Build simplified externalIntegration object for registration API
+    const externalIntegration = { url };
+    if (apiKey) {
+      externalIntegration.apiKey = apiKey;
+    }
+
+    return {
+      appKey: appKeyFromFile,
+      displayName,
+      description,
+      appType: 'external',
+      externalIntegration,
+      port: null, // External systems don't need ports
+      image: null, // External systems don't need images
+      language: null // External systems don't need language
+    };
+  }
+
+  const appType = variables.build?.language === 'typescript' ? 'webapp' : 'service';
+  const registryMode = variables.image?.registryMode || 'external';
+  const port = variables.build?.port || options.port || 3000;
+  const language = variables.build?.language || 'typescript';
+  const image = buildImageReference(variables, appKeyFromFile);
+
+  return {
+    appKey: appKeyFromFile,
+    displayName,
+    description,
+    appType,
+    registryMode,
+    port,
+    image,
+    language
+  };
+}
+
+module.exports = {
+  loadVariablesYaml,
+  createMinimalAppIfNeeded,
+  buildImageReference,
+  extractAppConfiguration,
+  extractExternalIntegrationUrl
+};
+

package/lib/utils/app-register-display.js

@@ -0,0 +1,69 @@
+/**
+ * AI Fabrix Builder - App Register Display Utilities
+ *
+ * Display and formatting utilities for application registration results
+ *
+ * @fileoverview Display utilities for app registration
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const logger = require('./logger');
+
+/**
+ * Get environment prefix for GitHub Secrets
+ * @param {string} environment - Environment key (e.g., 'dev', 'tst', 'pro', 'miso')
+ * @returns {string} Uppercase prefix (e.g., 'DEV', 'TST', 'PRO', 'MISO')
+ */
+function getEnvironmentPrefix(environment) {
+  if (!environment) {
+    return 'DEV';
+  }
+  // Convert to uppercase and handle common variations
+  const env = environment.toLowerCase();
+  if (env === 'dev' || env === 'development') {
+    return 'DEV';
+  }
+  if (env === 'tst' || env === 'test' || env === 'staging') {
+    return 'TST';
+  }
+  if (env === 'pro' || env === 'prod' || env === 'production') {
+    return 'PRO';
+  }
+  // For other environments (e.g., 'miso'), uppercase the entire string
+  // Use full string if 4 characters or less, otherwise use first 4 characters
+  const upper = environment.toUpperCase();
+  return upper.length <= 4 ? upper : upper.substring(0, 4);
+}
+
+/**
+ * Display registration success and credentials
+ * @param {Object} data - Registration response data
+ * @param {string} apiUrl - API URL
+ * @param {string} environment - Environment key
+ */
+function displayRegistrationResults(data, apiUrl, environment) {
+  logger.log(chalk.green('✅ Application registered successfully!\n'));
+  logger.log(chalk.bold('📋 Application Details:'));
+  logger.log(`   ID:           ${data.application.id}`);
+  logger.log(`   Key:          ${data.application.key}`);
+  logger.log(`   Display Name: ${data.application.displayName}\n`);
+
+  logger.log(chalk.bold.yellow('🔑 CREDENTIALS (save these immediately):'));
+  logger.log(chalk.yellow(`   Client ID:     ${data.credentials.clientId}`));
+  logger.log(chalk.yellow(`   Client Secret: ${data.credentials.clientSecret}\n`));
+
+  logger.log(chalk.red('⚠️  IMPORTANT: Client Secret will not be shown again!\n'));
+
+  const envPrefix = getEnvironmentPrefix(environment);
+  logger.log(chalk.bold('📝 Add to GitHub Secrets:'));
+  logger.log(chalk.cyan('   Repository level:'));
+  logger.log(chalk.cyan(`     MISO_CONTROLLER_URL = ${apiUrl}`));
+  logger.log(chalk.cyan(`\n   Environment level (${environment}):`));
+  logger.log(chalk.cyan(`     ${envPrefix}_MISO_CLIENTID = ${data.credentials.clientId}`));
+  logger.log(chalk.cyan(`     ${envPrefix}_MISO_CLIENTSECRET = ${data.credentials.clientSecret}\n`));
+}
+
+module.exports = { displayRegistrationResults, getEnvironmentPrefix };
+

package/lib/utils/app-register-validator.js

@@ -0,0 +1,143 @@
+/**
+ * AI Fabrix Builder - App Register Validation Utilities
+ *
+ * Validation logic for application registration
+ *
+ * @fileoverview Validation utilities for app registration
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const path = require('path');
+const chalk = require('chalk');
+const logger = require('./logger');
+const { detectAppType } = require('./paths');
+const applicationSchema = require('../schema/application-schema.json');
+
+// Extract valid enum values from application schema
+const validTypes = applicationSchema.properties.type.enum || [];
+const validRegistryModes = applicationSchema.properties.registryMode.enum || [];
+const portConstraints = {
+  minimum: applicationSchema.properties.port?.minimum || 1,
+  maximum: applicationSchema.properties.port?.maximum || 65535
+};
+const imagePattern = applicationSchema.properties.image?.pattern || /^[a-zA-Z0-9._/-]+:[a-zA-Z0-9._-]+$/;
+
+/**
+ * Validation schema for application registration
+ * Validates according to application-schema.json
+ */
+const registerApplicationSchema = {
+  environmentId: (val) => {
+    if (!val || val.length < 1) {
+      throw new Error('Invalid environment ID format');
+    }
+    return val;
+  },
+  key: (val) => {
+    if (!val || val.length < 1) {
+      throw new Error('Application key is required');
+    }
+    const keyPattern = applicationSchema.properties.key.pattern;
+    const keyMaxLength = applicationSchema.properties.key.maxLength || 50;
+    if (val.length > keyMaxLength) {
+      throw new Error(`Application key must be at most ${keyMaxLength} characters`);
+    }
+    if (keyPattern && !new RegExp(keyPattern).test(val)) {
+      throw new Error('Application key must contain only lowercase letters, numbers, and hyphens');
+    }
+    return val;
+  },
+  displayName: (val) => {
+    if (!val || val.length < 1) {
+      throw new Error('Display name is required');
+    }
+    const displayNameMaxLength = applicationSchema.properties.displayName.maxLength || 100;
+    if (val.length > displayNameMaxLength) {
+      throw new Error(`Display name must be at most ${displayNameMaxLength} characters`);
+    }
+    return val;
+  },
+  description: (val) => val || undefined,
+  image: (val, appType) => {
+    // Image is required for non-external types
+    if (appType !== 'external') {
+      if (!val || typeof val !== 'string') {
+        throw new Error('Image is required for non-external application types');
+      }
+      // Validate image format: repository:tag
+      const pattern = typeof imagePattern === 'string' ? new RegExp(imagePattern) : imagePattern;
+      if (!pattern.test(val)) {
+        throw new Error('Image must be in format repository:tag (e.g., aifabrix/miso-controller:latest or myregistry.azurecr.io/miso-controller:v1.0.0)');
+      }
+    }
+    return val || undefined;
+  },
+  configuration: (val) => {
+    if (!val || !val.type || !validTypes.includes(val.type)) {
+      throw new Error(`Configuration type must be one of: ${validTypes.join(', ')}`);
+    }
+
+    // For external type: require externalIntegration, skip registryMode/port validation
+    if (val.type === 'external') {
+      if (!val.externalIntegration) {
+        throw new Error('externalIntegration is required for external application type');
+      }
+      // External type should not have registryMode, port, or image
+      return val;
+    }
+
+    // For non-external types: require registryMode, port, image
+    if (!val.registryMode || !validRegistryModes.includes(val.registryMode)) {
+      throw new Error(`Registry mode must be one of: ${validRegistryModes.join(', ')}`);
+    }
+    if (val.port === undefined || val.port === null) {
+      throw new Error('Port is required for non-external application types');
+    }
+    if (!Number.isInteger(val.port) || val.port < portConstraints.minimum || val.port > portConstraints.maximum) {
+      throw new Error(`Port must be an integer between ${portConstraints.minimum} and ${portConstraints.maximum}`);
+    }
+    return val;
+  }
+};
+
+/**
+ * Validate application registration data
+ * @async
+ * @param {Object} config - Application configuration
+ * @param {string} originalAppKey - Original app key for error messages
+ * @throws {Error} If validation fails
+ */
+async function validateAppRegistrationData(config, originalAppKey) {
+  const missingFields = [];
+  if (!config.appKey) missingFields.push('app.key');
+  if (!config.displayName) missingFields.push('app.name');
+
+  if (missingFields.length > 0) {
+    logger.error(chalk.red('❌ Missing required fields in variables.yaml:'));
+    missingFields.forEach(field => logger.error(chalk.red(`   - ${field}`)));
+    // Detect app type to show correct path
+    const { appPath } = await detectAppType(originalAppKey);
+    const relativePath = path.relative(process.cwd(), appPath);
+    logger.error(chalk.red(`\n   Please update ${relativePath}/variables.yaml and try again.`));
+    process.exit(1);
+  }
+
+  try {
+    registerApplicationSchema.key(config.appKey);
+    registerApplicationSchema.displayName(config.displayName);
+    registerApplicationSchema.image(config.image, config.appType);
+    registerApplicationSchema.configuration({
+      type: config.appType,
+      registryMode: config.registryMode,
+      port: config.port,
+      externalIntegration: config.externalIntegration
+    });
+  } catch (error) {
+    logger.error(chalk.red(`❌ Invalid configuration: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+module.exports = { registerApplicationSchema, validateAppRegistrationData };
+

package/lib/utils/device-code.js

@@ -388,7 +388,7 @@ async function refreshDeviceToken(controllerUrl, refreshToken) {
   }
 
   const url = `${controllerUrl}/api/v1/auth/login/device/refresh`;
-  const response = await makeApiCall(url, {
+  const response = await getMakeApiCall()(url, {
     method: 'POST',
     headers: {
       'Content-Type': 'application/json'

package/lib/utils/error-formatters/error-parser.js

@@ -0,0 +1,150 @@
+/**
+ * Error Parser Utilities
+ *
+ * Parses error responses and determines error types
+ *
+ * @fileoverview Error parsing utilities
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { formatPermissionError } = require('./permission-errors');
+const { formatValidationError } = require('./validation-errors');
+const {
+  formatAuthenticationError,
+  formatServerError,
+  formatConflictError,
+  formatNotFoundError,
+  formatGenericError
+} = require('./http-status-errors');
+const { formatNetworkError } = require('./network-errors');
+
+/**
+ * Parses error response into error data object
+ * @param {string|Object} errorResponse - Error response (string or parsed JSON)
+ * @returns {Object} Parsed error data object
+ */
+function parseErrorData(errorResponse) {
+  if (errorResponse === undefined || errorResponse === null) {
+    return { message: 'Unknown error occurred' };
+  }
+  if (typeof errorResponse === 'string') {
+    try {
+      return JSON.parse(errorResponse);
+    } catch {
+      return { message: errorResponse };
+    }
+  }
+  return typeof errorResponse === 'object' ? errorResponse : { message: String(errorResponse) };
+}
+
+/**
+ * Creates error result object
+ * @param {string} type - Error type
+ * @param {string} message - Error message
+ * @param {string} formatted - Formatted error message
+ * @param {Object} data - Error data
+ * @returns {Object} Error result object
+ */
+function createErrorResult(type, message, formatted, data) {
+  return { type, message, formatted, data };
+}
+
+/**
+ * Gets error message from error data
+ * @param {Object} errorData - Error data object
+ * @param {string} defaultMessage - Default message if not found
+ * @returns {string} Error message
+ */
+function getErrorMessage(errorData, defaultMessage) {
+  return errorData.detail || errorData.title || errorData.errorDescription ||
+    errorData.message || errorData.error || defaultMessage;
+}
+
+/**
+ * Handles 400 validation error
+ * @param {Object} errorData - Error data object
+ * @returns {Object} Error result object
+ */
+function handleValidationError(errorData) {
+  const errorMessage = getErrorMessage(errorData, 'Validation error');
+  return createErrorResult('validation', errorMessage, formatValidationError(errorData), errorData);
+}
+
+/**
+ * Handles specific 4xx client error codes
+ * @param {number} statusCode - HTTP status code
+ * @param {Object} errorData - Error data object
+ * @returns {Object|null} Error result object or null if not handled
+ */
+function handleSpecificClientErrors(statusCode, errorData) {
+  switch (statusCode) {
+  case 403:
+    return createErrorResult('permission', 'Permission denied', formatPermissionError(errorData), errorData);
+  case 401:
+    return createErrorResult('authentication', 'Authentication failed', formatAuthenticationError(errorData), errorData);
+  case 400:
+  case 422:
+    return handleValidationError(errorData);
+  case 404:
+    return createErrorResult('notfound', getErrorMessage(errorData, 'Not found'), formatNotFoundError(errorData), errorData);
+  case 409:
+    return createErrorResult('conflict', getErrorMessage(errorData, 'Conflict'), formatConflictError(errorData), errorData);
+  default:
+    return null;
+  }
+}
+
+/**
+ * Handles HTTP status code errors
+ * @param {number} statusCode - HTTP status code
+ * @param {Object} errorData - Error data object
+ * @returns {Object|null} Error result object or null if not handled
+ */
+function handleStatusCodeError(statusCode, errorData) {
+  // Handle 4xx client errors
+  if (statusCode >= 400 && statusCode < 500) {
+    return handleSpecificClientErrors(statusCode, errorData);
+  }
+  // Handle 5xx server errors
+  if (statusCode >= 500) {
+    return createErrorResult('server', 'Server error', formatServerError(errorData), errorData);
+  }
+  return null;
+}
+
+/**
+ * Parses error response and determines error type
+ * @param {string|Object} errorResponse - Error response (string or parsed JSON)
+ * @param {number} statusCode - HTTP status code
+ * @param {boolean} isNetworkError - Whether this is a network error
+ * @returns {Object} Parsed error object with type, message, and formatted output
+ */
+function parseErrorResponse(errorResponse, statusCode, isNetworkError) {
+  let errorData = parseErrorData(errorResponse);
+
+  // Handle nested response structure (some APIs wrap errors in data field)
+  if (errorData.data && typeof errorData.data === 'object') {
+    errorData = errorData.data;
+  }
+
+  // Handle network errors
+  if (isNetworkError) {
+    const errorMessage = errorData.message || errorResponse || 'Network error';
+    return createErrorResult('network', errorMessage, formatNetworkError(errorMessage, errorData), errorData);
+  }
+
+  // Handle HTTP status codes
+  const statusError = handleStatusCodeError(statusCode, errorData);
+  if (statusError) {
+    return statusError;
+  }
+
+  // Generic error
+  return createErrorResult('generic', errorData.message || errorData.error || 'Unknown error', formatGenericError(errorData, statusCode), errorData);
+}
+
+module.exports = {
+  parseErrorResponse
+};
+