@aifabrix/builder 2.31.1 → 2.32.2

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

@@ -107,12 +107,79 @@ function handleStatusCodeError(statusCode, errorData) {
     return handleSpecificClientErrors(statusCode, errorData);
   }
   // Handle 5xx server errors
+  // Use generic "Server error" message for consistency (specific details shown in formatted output)
   if (statusCode >= 500) {
     return createErrorResult('server', 'Server error', formatServerError(errorData), errorData);
   }
   return null;
 }
 
+/**
+ * Checks if error response is a plain string (not JSON)
+ * @param {string|Object} errorResponse - Error response
+ * @returns {boolean} True if plain string
+ */
+function isPlainStringError(errorResponse) {
+  if (typeof errorResponse !== 'string') {
+    return false;
+  }
+  const trimmed = errorResponse.trim();
+  return !(trimmed.startsWith('{') || trimmed.startsWith('['));
+}
+
+/**
+ * Handles null or undefined error response
+ * @param {number} statusCode - HTTP status code
+ * @returns {Object} Error result object
+ */
+function handleNullError(statusCode) {
+  return createErrorResult('generic', 'Unknown error', formatGenericError({ message: 'Unknown error' }, statusCode), { message: 'Unknown error' });
+}
+
+/**
+ * Handles non-string, non-object error response
+ * @param {*} errorResponse - Error response
+ * @param {number} statusCode - HTTP status code
+ * @returns {Object} Error result object
+ */
+function handleNonStringObjectError(errorResponse, statusCode) {
+  const errorMessage = String(errorResponse);
+  return createErrorResult('generic', errorMessage, formatGenericError({ message: errorMessage }, statusCode), { message: errorMessage });
+}
+
+/**
+ * Handles network errors
+ * @param {Object} errorData - Error data object
+ * @param {string|Object} errorResponse - Original error response
+ * @returns {Object} Error result object
+ */
+function handleNetworkError(errorData, errorResponse) {
+  const errorMessage = errorData.message || errorResponse || 'Network error';
+  return createErrorResult('network', errorMessage, formatNetworkError(errorMessage, errorData), errorData);
+}
+
+/**
+ * Handles plain string errors without specific status code handling
+ * @param {Object} errorData - Error data object
+ * @param {string} errorResponse - Original error response
+ * @param {number} statusCode - HTTP status code
+ * @returns {Object} Error result object
+ */
+function handlePlainStringError(errorData, errorResponse, statusCode) {
+  const errorMessage = errorData.message || errorResponse || 'Unknown error';
+  return createErrorResult('generic', errorMessage, formatGenericError(errorData, statusCode), errorData);
+}
+
+/**
+ * Handles generic errors
+ * @param {Object} errorData - Error data object
+ * @param {number} statusCode - HTTP status code
+ * @returns {Object} Error result object
+ */
+function handleGenericError(errorData, statusCode) {
+  return createErrorResult('generic', errorData.message || errorData.error || 'Unknown error', formatGenericError(errorData, statusCode), errorData);
+}
+
 /**
  * Parses error response and determines error type
  * @param {string|Object} errorResponse - Error response (string or parsed JSON)
@@ -121,6 +188,17 @@ function handleStatusCodeError(statusCode, errorData) {
  * @returns {Object} Parsed error object with type, message, and formatted output
  */
 function parseErrorResponse(errorResponse, statusCode, isNetworkError) {
+  // For null, undefined, treat as generic regardless of status code
+  if (errorResponse === null || errorResponse === undefined) {
+    return handleNullError(statusCode);
+  }
+
+  // For non-string, non-object errors (numbers, booleans, etc.), treat as generic
+  if (typeof errorResponse !== 'string' && typeof errorResponse !== 'object') {
+    return handleNonStringObjectError(errorResponse, statusCode);
+  }
+
+  const isPlainString = isPlainStringError(errorResponse);
   let errorData = parseErrorData(errorResponse);
 
   // Handle nested response structure (some APIs wrap errors in data field)
@@ -130,18 +208,26 @@ function parseErrorResponse(errorResponse, statusCode, isNetworkError) {
 
   // Handle network errors
   if (isNetworkError) {
-    const errorMessage = errorData.message || errorResponse || 'Network error';
-    return createErrorResult('network', errorMessage, formatNetworkError(errorMessage, errorData), errorData);
+    return handleNetworkError(errorData, errorResponse);
   }
 
-  // Handle HTTP status codes
+  // Handle HTTP status codes first (even for plain strings, status code takes precedence)
   const statusError = handleStatusCodeError(statusCode, errorData);
   if (statusError) {
+    // For plain string errors, preserve the original message instead of formatted message
+    if (isPlainString && typeof errorResponse === 'string') {
+      return createErrorResult(statusError.type, errorResponse, statusError.formatted, statusError.data);
+    }
     return statusError;
   }
 
+  // For plain string errors (not JSON) without specific status code handling, treat as generic
+  if (isPlainString) {
+    return handlePlainStringError(errorData, errorResponse, statusCode);
+  }
+
   // Generic error
-  return createErrorResult('generic', errorData.message || errorData.error || 'Unknown error', formatGenericError(errorData, statusCode), errorData);
+  return handleGenericError(errorData, statusCode);
 }
 
 module.exports = {

package/lib/utils/error-formatters/http-status-errors.js

@@ -21,17 +21,26 @@ const chalk = require('chalk');
  * @param {string} [errorData.correlationId] - Correlation ID
  * @returns {string} Formatted authentication error message
  */
-function formatAuthenticationError(errorData) {
-  const lines = [];
-  lines.push(chalk.red('❌ Authentication Failed\n'));
-
-  // Show controller URL prominently if available
+/**
+ * Adds controller URL information to error lines
+ * @function addControllerUrlInfo
+ * @param {string[]} lines - Error message lines
+ * @param {Object} errorData - Error data
+ */
+function addControllerUrlInfo(lines, errorData) {
   if (errorData.controllerUrl) {
     lines.push(chalk.yellow(`Controller URL: ${errorData.controllerUrl}`));
     lines.push('');
   }
+}
 
-  // Show attempted URLs if multiple were tried
+/**
+ * Adds attempted URLs information
+ * @function addAttemptedUrlsInfo
+ * @param {string[]} lines - Error message lines
+ * @param {Object} errorData - Error data
+ */
+function addAttemptedUrlsInfo(lines, errorData) {
   if (errorData.attemptedUrls && errorData.attemptedUrls.length > 1) {
     lines.push(chalk.gray('Attempted controller URLs:'));
     errorData.attemptedUrls.forEach(url => {
@@ -39,28 +48,46 @@ function formatAuthenticationError(errorData) {
     });
     lines.push('');
   }
+}
 
-  // Check if error message contains specific information
-  const errorMessage = errorData.message || errorData.error || errorData.detail || '';
+/**
+ * Checks if error message is generic
+ * @function isGenericErrorMessage
+ * @param {string} errorMessage - Error message
+ * @returns {boolean} True if generic
+ */
+function isGenericErrorMessage(errorMessage) {
   const lowerMessage = errorMessage.toLowerCase();
+  return lowerMessage.includes('authentication required') ||
+         lowerMessage.includes('unauthorized') ||
+         lowerMessage === '';
+}
 
-  // Only show error message if it provides useful information beyond generic messages
-  const isGenericMessage = lowerMessage.includes('authentication required') ||
-                          lowerMessage.includes('unauthorized') ||
-                          lowerMessage === '';
-
-  if (errorMessage && !isGenericMessage) {
-    // Show specific error message if it provides useful details
+/**
+ * Adds error message if not generic
+ * @function addErrorMessageIfNotGeneric
+ * @param {string[]} lines - Error message lines
+ * @param {Object} errorData - Error data
+ */
+function addErrorMessageIfNotGeneric(lines, errorData) {
+  const errorMessage = errorData.message || errorData.error || errorData.detail || '';
+  if (errorMessage && !isGenericErrorMessage(errorMessage)) {
     lines.push(chalk.yellow(errorMessage));
     lines.push('');
   }
+}
 
-  // Always show general, actionable guidance
+/**
+ * Adds authentication guidance
+ * @function addAuthenticationGuidance
+ * @param {string[]} lines - Error message lines
+ * @param {Object} errorData - Error data
+ */
+function addAuthenticationGuidance(lines, errorData) {
   lines.push(chalk.gray('Your authentication token is invalid or has expired.'));
   lines.push('');
   lines.push(chalk.gray('To authenticate, run:'));
 
-  // Use real controller URL if provided, otherwise show placeholder
   const controllerUrl = errorData.controllerUrl;
   if (controllerUrl && controllerUrl.trim()) {
     lines.push(chalk.gray(`  aifabrix login --method device --controller ${controllerUrl}`));
@@ -72,6 +99,16 @@ function formatAuthenticationError(errorData) {
     lines.push('');
     lines.push(chalk.gray(`Correlation ID: ${errorData.correlationId}`));
   }
+}
+
+function formatAuthenticationError(errorData) {
+  const lines = [];
+  lines.push(chalk.red('❌ Authentication Failed\n'));
+
+  addControllerUrlInfo(lines, errorData);
+  addAttemptedUrlsInfo(lines, errorData);
+  addErrorMessageIfNotGeneric(lines, errorData);
+  addAuthenticationGuidance(lines, errorData);
 
   return lines.join('\n');
 }

package/lib/utils/error-formatters/network-errors.js

@@ -11,51 +11,128 @@
 const chalk = require('chalk');
 
 /**
- * Formats network error
+ * Normalizes error message to string
+ * @function normalizeErrorMessage
  * @param {string} errorMessage - Error message
- * @param {Object} errorData - Error response data (optional)
- * @param {string} [errorData.controllerUrl] - Controller URL
- * @returns {string} Formatted network error message
+ * @returns {string} Normalized error message
  */
-function formatNetworkError(errorMessage, errorData) {
-  const lines = [];
-  lines.push(chalk.red('❌ Network Error\n'));
+function normalizeErrorMessage(errorMessage) {
+  return typeof errorMessage === 'string' ? errorMessage : String(errorMessage || 'Network error');
+}
 
-  // Show controller URL prominently if available
+/**
+ * Adds controller URL header to error lines
+ * @function addControllerUrlHeader
+ * @param {Array<string>} lines - Error message lines
+ * @param {Object} errorData - Error response data
+ */
+function addControllerUrlHeader(lines, errorData) {
   if (errorData && errorData.controllerUrl) {
     lines.push(chalk.yellow(`Controller URL: ${errorData.controllerUrl}`));
     lines.push('');
   }
+}
+
+/**
+ * Adds controller URL to error message
+ * @function addControllerUrlToMessage
+ * @param {Array<string>} lines - Error message lines
+ * @param {Object} errorData - Error response data
+ */
+function addControllerUrlToMessage(lines, errorData) {
+  if (errorData && errorData.controllerUrl) {
+    lines.push(chalk.gray(`Controller URL: ${errorData.controllerUrl}`));
+  }
+}
+
+/**
+ * Formats connection refused error
+ * @function formatConnectionRefusedError
+ * @param {Array<string>} lines - Error message lines
+ * @param {Object} errorData - Error response data
+ */
+function formatConnectionRefusedError(lines, errorData) {
+  lines.push(chalk.yellow('Cannot connect to controller.'));
+  addControllerUrlToMessage(lines, errorData);
+  lines.push(chalk.gray('Check if the controller is running.'));
+}
+
+/**
+ * Formats hostname not found error
+ * @function formatHostnameNotFoundError
+ * @param {Array<string>} lines - Error message lines
+ * @param {Object} errorData - Error response data
+ */
+function formatHostnameNotFoundError(lines, errorData) {
+  lines.push(chalk.yellow('Controller hostname not found.'));
+  addControllerUrlToMessage(lines, errorData);
+  lines.push(chalk.gray('Check your controller URL.'));
+}
 
-  // Ensure errorMessage is a string
-  const message = typeof errorMessage === 'string' ? errorMessage : String(errorMessage || 'Network error');
+/**
+ * Formats timeout error
+ * @function formatTimeoutError
+ * @param {Array<string>} lines - Error message lines
+ * @param {Object} errorData - Error response data
+ */
+function formatTimeoutError(lines, errorData) {
+  lines.push(chalk.yellow('Request timed out.'));
+  addControllerUrlToMessage(lines, errorData);
+  lines.push(chalk.gray('The controller may be overloaded.'));
+}
 
-  if (message.includes('ECONNREFUSED') || message.includes('Cannot connect')) {
-    lines.push(chalk.yellow('Cannot connect to controller.'));
-    if (errorData && errorData.controllerUrl) {
-      lines.push(chalk.gray(`Controller URL: ${errorData.controllerUrl}`));
-    }
-    lines.push(chalk.gray('Check if the controller is running.'));
+/**
+ * Formats error message based on error type
+ * @function formatErrorMessageByType
+ * @param {string} message - Normalized error message
+ * @param {Array<string>} lines - Error message lines
+ * @param {Object} errorData - Error response data
+ */
+function formatErrorMessageByType(message, lines, errorData) {
+  if (!message || message.trim() === '') {
+    // Empty message gets normalized to 'Network error' and displayed as generic error
+    lines.push(chalk.yellow('Network error'));
+  } else if (message.includes('ECONNREFUSED') || message.includes('Cannot connect')) {
+    formatConnectionRefusedError(lines, errorData);
   } else if (message.includes('ENOTFOUND') || message.includes('hostname not found')) {
-    lines.push(chalk.yellow('Controller hostname not found.'));
-    if (errorData && errorData.controllerUrl) {
-      lines.push(chalk.gray(`Controller URL: ${errorData.controllerUrl}`));
-    }
-    lines.push(chalk.gray('Check your controller URL.'));
+    formatHostnameNotFoundError(lines, errorData);
   } else if (message.includes('timeout') || message.includes('timed out')) {
-    lines.push(chalk.yellow('Request timed out.'));
-    if (errorData && errorData.controllerUrl) {
-      lines.push(chalk.gray(`Controller URL: ${errorData.controllerUrl}`));
-    }
-    lines.push(chalk.gray('The controller may be overloaded.'));
+    formatTimeoutError(lines, errorData);
   } else {
     lines.push(chalk.yellow(message));
   }
+}
 
+/**
+ * Adds correlation ID if present
+ * @function addCorrelationId
+ * @param {Array<string>} lines - Error message lines
+ * @param {Object} errorData - Error response data
+ */
+function addCorrelationId(lines, errorData) {
   if (errorData && errorData.correlationId) {
     lines.push('');
     lines.push(chalk.gray(`Correlation ID: ${errorData.correlationId}`));
   }
+}
+
+/**
+ * Formats network error
+ * @param {string} errorMessage - Error message
+ * @param {Object} errorData - Error response data (optional)
+ * @param {string} [errorData.controllerUrl] - Controller URL
+ * @returns {string} Formatted network error message
+ */
+function formatNetworkError(errorMessage, errorData) {
+  const lines = [];
+  lines.push(chalk.red('❌ Network Error\n'));
+
+  addControllerUrlHeader(lines, errorData);
+
+  const message = normalizeErrorMessage(errorMessage);
+  formatErrorMessageByType(message, lines, errorData);
+
+  addCorrelationId(lines, errorData);
 
   return lines.join('\n');
 }