@aifabrix/builder 2.10.0 → 2.11.0

package/lib/utils/api-error-handler.js

@@ -11,459 +11,16 @@
  */
 
 const chalk = require('chalk');
-/**
- * Extracts missing permissions from error data
- * @param {Object} errorData - Error response data
- * @returns {Array<string>} Array of missing permissions
- */
-function extractMissingPermissions(errorData) {
-  if (errorData.missingPermissions && Array.isArray(errorData.missingPermissions)) {
-    return errorData.missingPermissions;
-  }
-  if (errorData.missing && errorData.missing.permissions && Array.isArray(errorData.missing.permissions)) {
-    return errorData.missing.permissions;
-  }
-  return [];
-}
-/**
- * Extracts required permissions from error data
- * @param {Object} errorData - Error response data
- * @returns {Array<string>} Array of required permissions
- */
-function extractRequiredPermissions(errorData) {
-  if (errorData.requiredPermissions && Array.isArray(errorData.requiredPermissions)) {
-    return errorData.requiredPermissions;
-  }
-  if (errorData.required && errorData.required.permissions && Array.isArray(errorData.required.permissions)) {
-    return errorData.required.permissions;
-  }
-  return [];
-}
-/**
- * Adds permission list to lines array
- * @param {Array<string>} lines - Lines array to append to
- * @param {Array<string>} perms - Permissions array
- * @param {string} label - Label for the permissions list
- */
-function addPermissionList(lines, perms, label) {
-  if (perms.length > 0) {
-    lines.push(chalk.yellow(`${label}:`));
-    perms.forEach(perm => {
-      lines.push(chalk.gray(`  - ${perm}`));
-    });
-    lines.push('');
-  }
-}
-/**
- * Formats permission error with missing and required permissions
- * @param {Object} errorData - Error response data
- * @returns {string} Formatted permission error message
- */
-function formatPermissionError(errorData) {
-  const lines = [];
-  lines.push(chalk.red('❌ Permission Denied\n'));
-
-  if (errorData.detail) {
-    lines.push(chalk.yellow(errorData.detail));
-    lines.push('');
-  }
-
-  const missingPerms = extractMissingPermissions(errorData);
-  addPermissionList(lines, missingPerms, 'Missing permissions');
-
-  const requiredPerms = extractRequiredPermissions(errorData);
-  addPermissionList(lines, requiredPerms, 'Required permissions');
-  const requestUrl = errorData.instance || errorData.url;
-  const method = errorData.method || 'POST';
-  if (requestUrl) {
-    lines.push(chalk.gray(`Request: ${method} ${requestUrl}`));
-  }
-  if (errorData.correlationId) {
-    lines.push(chalk.gray(`Correlation ID: ${errorData.correlationId}`));
-  }
-
-  return lines.join('\n');
-}
-/**
- * Formats validation error with field-level details
- * Handles unified error API response format (RFC 7807 Problem Details)
- * @param {Object} errorData - Error response data
- * @returns {string} Formatted validation error message
- */
-function formatValidationError(errorData) {
-  const lines = [];
-  lines.push(chalk.red('❌ Validation Error\n'));
-
-  // Handle RFC 7807 Problem Details format
-  // Priority: detail > title > errorDescription > message > error
-  if (errorData.detail) {
-    lines.push(chalk.yellow(errorData.detail));
-    lines.push('');
-  } else if (errorData.title) {
-    lines.push(chalk.yellow(errorData.title));
-    lines.push('');
-  } else if (errorData.errorDescription) {
-    // Handle Keycloak-style error format
-    lines.push(chalk.yellow(errorData.errorDescription));
-    if (errorData.error) {
-      lines.push(chalk.gray(`Error code: ${errorData.error}`));
-    }
-    lines.push('');
-  } else if (errorData.message) {
-    lines.push(chalk.yellow(errorData.message));
-    lines.push('');
-  } else if (errorData.error) {
-    lines.push(chalk.yellow(errorData.error));
-    lines.push('');
-  }
-  // Handle errors array - this is the most important part
-  if (errorData.errors && Array.isArray(errorData.errors) && errorData.errors.length > 0) {
-    lines.push(chalk.yellow('Validation errors:'));
-    errorData.errors.forEach(err => {
-      const field = err.field || err.path || 'validation';
-      const message = err.message || 'Invalid value';
-      // If field is 'validation' or generic, just show the message
-      if (field === 'validation' || field === 'unknown') {
-        lines.push(chalk.gray(`  • ${message}`));
-      } else {
-        lines.push(chalk.gray(`  • ${field}: ${message}`));
-      }
-    });
-    lines.push('');
-  }
-  // Show instance (endpoint) if available (RFC 7807)
-  if (errorData.instance) {
-    lines.push(chalk.gray(`Endpoint: ${errorData.instance}`));
-  }
-  // Show correlation ID if available
-  if (errorData.correlationId) {
-    lines.push(chalk.gray(`Correlation ID: ${errorData.correlationId}`));
-  }
-  return lines.join('\n');
-}
-/**
- * Formats authentication error
- * @param {Object} errorData - Error response data
- * @returns {string} Formatted authentication error message
- */
-function formatAuthenticationError(errorData) {
-  const lines = [];
-  lines.push(chalk.red('❌ Authentication Failed\n'));
-  if (errorData.message) {
-    lines.push(chalk.yellow(errorData.message));
-  } else {
-    lines.push(chalk.yellow('Invalid credentials or token expired.'));
-  }
-  lines.push('');
-  lines.push(chalk.gray('Run: aifabrix login'));
-  if (errorData.correlationId) {
-    lines.push(chalk.gray(`Correlation ID: ${errorData.correlationId}`));
-  }
-  return lines.join('\n');
-}
-/**
- * Formats network error
- * @param {string} errorMessage - Error message
- * @param {Object} errorData - Error response data (optional)
- * @returns {string} Formatted network error message
- */
-function formatNetworkError(errorMessage, errorData) {
-  const lines = [];
-  lines.push(chalk.red('❌ Network Error\n'));
-
-  if (errorMessage.includes('ECONNREFUSED') || errorMessage.includes('Cannot connect')) {
-    lines.push(chalk.yellow('Cannot connect to controller.'));
-    lines.push(chalk.gray('Check if the controller is running.'));
-  } else if (errorMessage.includes('ENOTFOUND') || errorMessage.includes('hostname not found')) {
-    lines.push(chalk.yellow('Controller hostname not found.'));
-    lines.push(chalk.gray('Check your controller URL.'));
-  } else if (errorMessage.includes('timeout') || errorMessage.includes('timed out')) {
-    lines.push(chalk.yellow('Request timed out.'));
-    lines.push(chalk.gray('The controller may be overloaded.'));
-  } else {
-    lines.push(chalk.yellow(errorMessage));
-  }
-
-  if (errorData && errorData.correlationId) {
-    lines.push(chalk.gray(`Correlation ID: ${errorData.correlationId}`));
-  }
-
-  return lines.join('\n');
-}
-
-/**
- * Formats server error (500+)
- * @param {Object} errorData - Error response data
- * @returns {string} Formatted server error message
- */
-function formatServerError(errorData) {
-  const lines = [];
-  lines.push(chalk.red('❌ Server Error\n'));
-
-  // Check for RFC 7807 Problem Details format (detail field)
-  if (errorData.detail) {
-    lines.push(chalk.yellow(errorData.detail));
-  } else if (errorData.message) {
-    lines.push(chalk.yellow(errorData.message));
-  } else {
-    lines.push(chalk.yellow('An internal server error occurred.'));
-  }
-  lines.push('');
-  lines.push(chalk.gray('Please try again later or contact support.'));
-
-  if (errorData.correlationId) {
-    lines.push('');
-    lines.push(chalk.gray(`Correlation ID: ${errorData.correlationId}`));
-  }
-
-  return lines.join('\n');
-}
-
-/**
- * Formats conflict error (409)
- * @param {Object} errorData - Error response data
- * @returns {string} Formatted conflict error message
- */
-function formatConflictError(errorData) {
-  const lines = [];
-  lines.push(chalk.red('❌ Conflict\n'));
-
-  // Check if it's an application already exists error
-  const detail = errorData.detail || errorData.message || '';
-  if (detail.toLowerCase().includes('application already exists')) {
-    lines.push(chalk.yellow('This application already exists in this environment.'));
-    lines.push('');
-    lines.push(chalk.gray('Options:'));
-    lines.push(chalk.gray('  • Use a different environment'));
-    lines.push(chalk.gray('  • Check existing applications: aifabrix app list -e <environment>'));
-    lines.push(chalk.gray('  • Update the existing application if needed'));
-  } else if (detail) {
-    lines.push(chalk.yellow(detail));
-  } else if (errorData.message) {
-    lines.push(chalk.yellow(errorData.message));
-  } else {
-    lines.push(chalk.yellow('A conflict occurred. The resource may already exist.'));
-  }
-
-  if (errorData.correlationId) {
-    lines.push('');
-    lines.push(chalk.gray(`Correlation ID: ${errorData.correlationId}`));
-  }
-
-  return lines.join('\n');
-}
-
-/**
- * Gets actionable guidance options based on error detail
- * @param {string} detail - Error detail message
- * @returns {Array<string>} Array of guidance options
- */
-function getNotFoundGuidance(detail) {
-  const lowerDetail = detail.toLowerCase();
-  if (lowerDetail.includes('environment')) {
-    return [
-      '  • Check the environment key spelling',
-      '  • List available environments: aifabrix app list -e <environment>',
-      '  • Verify you have access to this environment'
-    ];
-  }
-  if (lowerDetail.includes('application')) {
-    return [
-      '  • Check the application key spelling',
-      '  • List applications: aifabrix app list -e <environment>',
-      '  • Verify the application exists in this environment'
-    ];
-  }
-  return [
-    '  • Check the resource identifier',
-    '  • Verify the resource exists',
-    '  • Check your permissions'
-  ];
-}
-
-/**
- * Formats not found error (404)
- * @param {Object} errorData - Error response data
- * @returns {string} Formatted not found error message
- */
-function formatNotFoundError(errorData) {
-  const lines = [];
-  lines.push(chalk.red('❌ Not Found\n'));
-
-  const detail = errorData.detail || errorData.message || '';
-  if (detail) {
-    lines.push(chalk.yellow(detail));
-    lines.push('');
-  }
-
-  lines.push(chalk.gray('Options:'));
-  const guidance = getNotFoundGuidance(detail);
-  guidance.forEach(option => {
-    lines.push(chalk.gray(option));
-  });
-
-  if (errorData.correlationId) {
-    lines.push('');
-    lines.push(chalk.gray(`Correlation ID: ${errorData.correlationId}`));
-  }
-
-  return lines.join('\n');
-}
-
-/**
- * Formats generic error
- * @param {Object} errorData - Error response data
- * @param {number} statusCode - HTTP status code
- * @returns {string} Formatted error message
- */
-function formatGenericError(errorData, statusCode) {
-  const lines = [];
-  lines.push(chalk.red(`❌ Error (HTTP ${statusCode})\n`));
-
-  // Check for RFC 7807 Problem Details format (detail field)
-  if (errorData.detail) {
-    lines.push(chalk.yellow(errorData.detail));
-  } else if (errorData.message) {
-    lines.push(chalk.yellow(errorData.message));
-  } else if (errorData.error) {
-    lines.push(chalk.yellow(errorData.error));
-  } else {
-    lines.push(chalk.yellow('An error occurred while processing your request.'));
-  }
-
-  if (errorData.correlationId) {
-    lines.push('');
-    lines.push(chalk.gray(`Correlation ID: ${errorData.correlationId}`));
-  }
-
-  return lines.join('\n');
-}
-
-/**
- * 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 };
-    }
-  }
-  if (typeof errorResponse === 'object') {
-    return errorResponse;
-  }
-  return { 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:
-    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);
-}
+const { parseErrorResponse } = require('./error-formatters/error-parser');
+const { formatPermissionError } = require('./error-formatters/permission-errors');
+const { formatValidationError } = require('./error-formatters/validation-errors');
+const {
+  formatAuthenticationError,
+  formatServerError,
+  formatConflictError,
+  formatGenericError
+} = require('./error-formatters/http-status-errors');
+const { formatNetworkError } = require('./error-formatters/network-errors');
 
 /**
  * Formats error for display in CLI
@@ -487,6 +44,7 @@ function formatApiError(apiResponse) {
   const parsed = parseErrorResponse(errorResponse, statusCode, isNetworkError);
   return parsed.formatted;
 }
+
 module.exports = {
   parseErrorResponse,
   formatApiError,

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

@@ -0,0 +1,71 @@
+/**
+ * AI Fabrix Builder - App Register API Utilities
+ *
+ * API call utilities for application registration
+ *
+ * @fileoverview API utilities for app registration
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const logger = require('./logger');
+const { authenticatedApiCall } = require('./api');
+const { formatApiError } = require('./api-error-handler');
+
+/**
+ * Call registration API
+ * @async
+ * @param {string} apiUrl - API URL
+ * @param {string} token - Authentication token
+ * @param {string} environment - Environment ID
+ * @param {Object} registrationData - Registration data
+ * @returns {Promise<Object>} API response
+ */
+async function callRegisterApi(apiUrl, token, environment, registrationData) {
+  const response = await authenticatedApiCall(
+    `${apiUrl}/api/v1/environments/${encodeURIComponent(environment)}/applications/register`,
+    {
+      method: 'POST',
+      body: JSON.stringify(registrationData)
+    },
+    token
+  );
+
+  if (!response.success) {
+    const formattedError = response.formattedError || formatApiError(response);
+    logger.error(formattedError);
+
+    // For validation errors (400, 422), show the request payload for debugging
+    if (response.status === 400 || response.status === 422) {
+      logger.error(chalk.gray('\nRequest payload:'));
+      logger.error(chalk.gray(JSON.stringify(registrationData, null, 2)));
+      logger.error('');
+      logger.error(chalk.gray('Check your variables.yaml file and ensure all required fields are correctly set.'));
+    }
+
+    process.exit(1);
+  }
+
+  // Handle API response structure:
+  // makeApiCall returns: { success: true, data: <API response> }
+  // API response can be:
+  // 1. Direct format: { application: {...}, credentials: {...} }
+  // 2. Wrapped format: { success: true, data: { application: {...}, credentials: {...} } }
+  const apiResponse = response.data;
+  if (apiResponse && apiResponse.data && apiResponse.data.application) {
+    // Wrapped format: use apiResponse.data
+    return apiResponse.data;
+  } else if (apiResponse && apiResponse.application) {
+    // Direct format: use apiResponse directly
+    return apiResponse;
+  }
+  // Fallback: return apiResponse as-is (shouldn't happen, but handle gracefully)
+  logger.error(chalk.red('❌ Invalid response: missing application data'));
+  logger.error(chalk.gray('\nFull response for debugging:'));
+  logger.error(chalk.gray(JSON.stringify(response, null, 2)));
+  process.exit(1);
+}
+
+module.exports = { callRegisterApi };
+

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

@@ -0,0 +1,72 @@
+/**
+ * AI Fabrix Builder - App Register Authentication Utilities
+ *
+ * Authentication utilities for application registration
+ *
+ * @fileoverview Authentication utilities for app registration
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const logger = require('./logger');
+const { getConfig } = require('../config');
+const { getOrRefreshDeviceToken } = require('./token-manager');
+
+/**
+ * Check if user is authenticated and get token
+ * @async
+ * @param {string} [controllerUrl] - Optional controller URL from variables.yaml
+ * @param {string} [environment] - Optional environment key
+ * @returns {Promise<{apiUrl: string, token: string}>} Configuration with API URL and token
+ */
+async function checkAuthentication(controllerUrl, environment) {
+  const config = await getConfig();
+
+  // Try to get controller URL from parameter, config, or device tokens
+  let finalControllerUrl = controllerUrl;
+  let token = null;
+
+  // If controller URL provided, try to get device token
+  if (finalControllerUrl) {
+    const deviceToken = await getOrRefreshDeviceToken(finalControllerUrl);
+    if (deviceToken && deviceToken.token) {
+      token = deviceToken.token;
+      finalControllerUrl = deviceToken.controller;
+    }
+  }
+
+  // If no token yet, try to find any device token in config
+  if (!token && config.device) {
+    const deviceUrls = Object.keys(config.device);
+    if (deviceUrls.length > 0) {
+      // Use first available device token
+      finalControllerUrl = deviceUrls[0];
+      const deviceToken = await getOrRefreshDeviceToken(finalControllerUrl);
+      if (deviceToken && deviceToken.token) {
+        token = deviceToken.token;
+        finalControllerUrl = deviceToken.controller;
+      }
+    }
+  }
+
+  // If still no token, check for client token (requires environment and app)
+  if (!token && environment) {
+    // For app register, we don't have an app yet, so client tokens won't work
+    // This is expected - device tokens should be used for registration
+  }
+
+  if (!token || !finalControllerUrl) {
+    logger.error(chalk.red('❌ Not logged in. Run: aifabrix login'));
+    logger.error(chalk.gray('   Use device code flow: aifabrix login --method device --controller <url>'));
+    process.exit(1);
+  }
+
+  return {
+    apiUrl: finalControllerUrl,
+    token: token
+  };
+}
+
+module.exports = { checkAuthentication };
+