@aifabrix/builder 2.10.1 → 2.20.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/deployment-errors.js

@@ -18,8 +18,17 @@ const { parseErrorResponse } = require('./api-error-handler');
  * @returns {Object} Structured error information
  */
 function handleDeploymentError(error) {
+  if (!error) {
+    return {
+      message: 'Unknown error',
+      code: 'UNKNOWN',
+      timeout: false,
+      status: undefined,
+      data: undefined
+    };
+  }
   const safeError = {
-    message: error.message,
+    message: error.message || 'Unknown error',
     code: error.code || 'UNKNOWN',
     timeout: error.code === 'ECONNABORTED',
     status: error.status || error.response?.status,
@@ -42,6 +51,38 @@ function handleDeploymentError(error) {
  * @throws {Error} User-friendly error message
  */
 async function handleDeploymentErrors(error, appName, url, alreadyLogged = false) {
+  // For validation errors (like URL validation), just re-throw them directly
+  // They already have user-friendly messages
+  // Handle both Error objects and strings
+  let errorMessage = '';
+  if (error instanceof Error) {
+    errorMessage = error.message || '';
+  } else if (typeof error === 'string') {
+    errorMessage = error;
+  } else if (error && typeof error === 'object' && error.message) {
+    errorMessage = error.message;
+  }
+
+  if (errorMessage && (
+    errorMessage.includes('Controller URL must use HTTPS') ||
+    errorMessage.includes('Invalid environment key') ||
+    errorMessage.includes('Environment key is required') ||
+    errorMessage.includes('Authentication configuration is required') ||
+    errorMessage.includes('Invalid controller URL format') ||
+    errorMessage.includes('Controller URL is required')
+  )) {
+    // If error is a string, convert to Error object
+    if (typeof error === 'string') {
+      throw new Error(error);
+    }
+    // If it's already an Error object, re-throw it directly
+    if (error instanceof Error) {
+      throw error;
+    }
+    // Otherwise, create a new Error with the message
+    throw new Error(errorMessage);
+  }
+
   // Log to audit log if not already logged
   if (!alreadyLogged) {
     try {
@@ -63,7 +104,17 @@ async function handleDeploymentErrors(error, appName, url, alreadyLogged = false
 
   // Ensure errorData is not undefined before parsing
   // If errorData is undefined, use the error message instead
-  const errorResponse = errorData !== undefined ? errorData : safeError.message;
+  let errorResponse = errorData !== undefined ? errorData : safeError.message;
+
+  // Ensure errorResponse is a string or object, not an Error object
+  if (errorResponse instanceof Error) {
+    errorResponse = errorResponse.message || 'Unknown error occurred';
+  }
+
+  // Ensure errorResponse is not null or undefined
+  if (errorResponse === null || errorResponse === undefined) {
+    errorResponse = safeError.message || 'Unknown error occurred';
+  }
 
   // Determine if this is a network error
   const isNetworkError = safeError.code === 'ECONNREFUSED' ||
@@ -72,13 +123,44 @@ async function handleDeploymentErrors(error, appName, url, alreadyLogged = false
     safeError.timeout;
 
   // Parse error using error handler
-  const parsedError = parseErrorResponse(errorResponse, safeError.status || 0, isNetworkError);
+  let parsedError;
+  try {
+    parsedError = parseErrorResponse(errorResponse, safeError.status || 0, isNetworkError);
+    // Ensure parsedError is a valid object
+    if (!parsedError || typeof parsedError !== 'object') {
+      throw new Error('parseErrorResponse returned invalid result');
+    }
+  } catch (parseErr) {
+    // If parsing fails, use the safe error message
+    parsedError = {
+      message: safeError.message || 'Unknown error occurred',
+      formatted: safeError.message || 'Unknown error occurred',
+      data: undefined
+    };
+  }
+
+  // Ensure parsedError is always a valid object with required properties
+  if (!parsedError || typeof parsedError !== 'object') {
+    parsedError = {
+      message: safeError.message || 'Unknown error occurred',
+      formatted: safeError.message || 'Unknown error occurred',
+      data: undefined
+    };
+  }
+
+  // Ensure we have a message - handle case where parsedError.message might be undefined
+  const finalErrorMessage = (parsedError && parsedError.message) ? parsedError.message : (safeError.message || 'Unknown error occurred');
+
+  // Validate finalErrorMessage is a string
+  if (typeof finalErrorMessage !== 'string') {
+    throw new Error(`Invalid error message type: ${typeof finalErrorMessage}. Error: ${JSON.stringify(error)}`);
+  }
 
   // Throw clean error message (without emoji) - CLI will format it
-  const formattedError = new Error(parsedError.message);
-  formattedError.formatted = parsedError.formatted;
+  const formattedError = new Error(finalErrorMessage);
+  formattedError.formatted = parsedError?.formatted || finalErrorMessage;
   formattedError.status = safeError.status;
-  formattedError.data = parsedError.data;
+  formattedError.data = parsedError?.data;
   formattedError._logged = true; // Mark as logged to prevent double-logging
   throw formattedError;
 }

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'