indusagi-coding-agent 0.1.22 → 0.1.24

package/dist/utils/error-handler.js

@@ -0,0 +1,726 @@
+/**
+ * @fileoverview Error Handling and Recovery Utilities
+ *
+ * This module provides robust error handling utilities for transforming technical
+ * errors into user-friendly messages, categorizing errors, and providing recovery
+ * suggestions. Error handling is critical for:
+ *
+ * 1. **User Experience**: Transform cryptic technical errors into actionable messages
+ * 2. **Error Categorization**: Classify errors by type (TypeError, FileNotFound, etc.)
+ * 3. **Recovery Suggestions**: Provide users with steps to resolve issues
+ * 4. **Security**: Avoid leaking sensitive information in error messages
+ * 5. **Logging and Debugging**: Format errors for logs and debugging
+ * 6. **Error Codes**: Standardize error codes for programmatic error handling
+ *
+ * ## Error Code Conventions
+ *
+ * ### System Errors (E-prefix)
+ * - E001: Unknown error
+ * - E002: Validation error
+ * - E003: Configuration error
+ * - E004: Permission denied
+ * - E005: Resource not found
+ * - E006: Timeout error
+ * - E007: Network error
+ * - E008: Parse error
+ *
+ * ### Node.js System Errors (POSIX)
+ * - EACCES: Permission denied
+ * - EEXIST: File already exists
+ * - EISDIR: Is a directory
+ * - ENOENT: No such file or directory
+ * - ENOTDIR: Not a directory
+ * - EPERM: Operation not permitted
+ * - ETIMEDOUT: Connection timed out
+ * - ECONNREFUSED: Connection refused
+ *
+ * ## Error Type Hierarchy
+ *
+ * JavaScript error types provide context about what went wrong:
+ * - **Error**: Generic error, safe fallback
+ * - **TypeError**: Type mismatch or invalid operation
+ * - **ReferenceError**: Undefined variable or property
+ * - **RangeError**: Value out of valid range
+ * - **SyntaxError**: Malformed code or JSON
+ * - **EvalError**: eval() function error (rarely thrown)
+ * - **URIError**: Invalid URI function argument
+ *
+ * ## Security Considerations
+ *
+ * Error messages can leak sensitive information:
+ * - File system paths
+ * - Internal variable names
+ * - API endpoints
+ * - Database structure
+ * - Configuration secrets
+ *
+ * Always sanitize error messages before displaying to users.
+ *
+ * @author Coding Agent
+ * @version 1.0.0
+ */
+/**
+ * Standard error code enum for consistent error identification.
+ *
+ * Error codes allow programmatic error handling and localization.
+ * Each code corresponds to an error category and recovery strategy.
+ *
+ * @example
+ * ```typescript
+ * if (error.code === ErrorCode.EACCES) {
+ *   // Show permission error UI
+ *   showPermissionError();
+ * }
+ * ```
+ */
+export var ErrorCode;
+(function (ErrorCode) {
+    // Generic errors
+    ErrorCode["UNKNOWN"] = "E001";
+    ErrorCode["VALIDATION"] = "E002";
+    ErrorCode["CONFIG"] = "E003";
+    ErrorCode["PERMISSION"] = "E004";
+    ErrorCode["NOT_FOUND"] = "E005";
+    ErrorCode["TIMEOUT"] = "E006";
+    ErrorCode["NETWORK"] = "E007";
+    ErrorCode["PARSE_ERROR"] = "E008";
+    // Node.js system errors
+    ErrorCode["EACCES"] = "EACCES";
+    ErrorCode["EEXIST"] = "EEXIST";
+    ErrorCode["EISDIR"] = "EISDIR";
+    ErrorCode["ENOENT"] = "ENOENT";
+    ErrorCode["ENOTDIR"] = "ENOTDIR";
+    ErrorCode["EPERM"] = "EPERM";
+    ErrorCode["ETIMEDOUT"] = "ETIMEDOUT";
+    ErrorCode["ECONNREFUSED"] = "ECONNREFUSED";
+})(ErrorCode || (ErrorCode = {}));
+/**
+ * Categorizes an error into a standard error type.
+ *
+ * Error type identification enables targeted error handling and appropriate
+ * UI/messaging responses.
+ *
+ * @param error - The error to categorize
+ * @returns Standard error type name
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const value: any = null;
+ *   value.property.nested = 123; // TypeError: Cannot read property 'property'
+ * } catch (error) {
+ *   const type = categorizeError(error);
+ *   // type === 'TypeError'
+ *   if (type === 'TypeError') {
+ *     showTypeErrorRecovery();
+ *   }
+ * }
+ * ```
+ *
+ * @usage
+ * ```typescript
+ * // Error type routing
+ * function handleError(error: unknown) {
+ *   const errorType = categorizeError(error);
+ *
+ *   switch (errorType) {
+ *     case 'TypeError':
+ *       logMetric('type_error');
+ *       break;
+ *     case 'ReferenceError':
+ *       logMetric('reference_error');
+ *       break;
+ *     case 'SyntaxError':
+ *       logMetric('syntax_error');
+ *       break;
+ *     default:
+ *       logMetric('unknown_error');
+ *   }
+ * }
+ * ```
+ */
+export function categorizeError(error) {
+    if (error instanceof TypeError)
+        return 'TypeError';
+    if (error instanceof ReferenceError)
+        return 'ReferenceError';
+    if (error instanceof RangeError)
+        return 'RangeError';
+    if (error instanceof SyntaxError)
+        return 'SyntaxError';
+    if (error instanceof URIError)
+        return 'URIError';
+    if (error instanceof EvalError)
+        return 'EvalError';
+    if (error instanceof Error)
+        return error.constructor.name || 'Error';
+    return 'UnknownError';
+}
+/**
+ * Extracts and formats stack trace from an error.
+ *
+ * Stack traces are essential for debugging but should never be shown to
+ * end users due to security concerns. Use for logging and diagnostics.
+ *
+ * @param error - The error to extract stack from
+ * @returns Formatted stack trace string or empty string
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   riskyOperation();
+ * } catch (error) {
+ *   const stack = extractStackTrace(error);
+ *   // stack:
+ *   // "Error: Something went wrong
+ *   //  at riskyOperation (/path/to/file.ts:42:10)
+ *   //  at main (/path/to/file.ts:1:5)"
+ *   logger.error(stack);
+ * }
+ * ```
+ *
+ * @usage
+ * ```typescript
+ * // Log error details without exposing to users
+ * function logErrorForSupport(error: unknown): void {
+ *   const stack = extractStackTrace(error);
+ *   const timestamp = new Date().toISOString();
+ *   const entry = `[${timestamp}] ${String(error)}\n${stack}`;
+ *
+ *   fs.appendFileSync('error.log', entry + '\n');
+ * }
+ *
+ * // Send to error tracking service
+ * function reportToSentry(error: unknown): void {
+ *   const stack = extractStackTrace(error);
+ *   Sentry.captureException(error, {
+ *     extra: { stack }
+ *   });
+ * }
+ * ```
+ */
+export function extractStackTrace(error) {
+    if (error instanceof Error && error.stack) {
+        return error.stack;
+    }
+    if (typeof error === 'object' && error !== null && 'stack' in error) {
+        const stack = error.stack;
+        return typeof stack === 'string' ? stack : '';
+    }
+    return '';
+}
+/**
+ * Sanitizes error messages to prevent information leakage.
+ *
+ * Removes sensitive information like:
+ * - File system paths
+ * - Environment variables
+ * - Internal file names
+ * - Memory addresses
+ * - API endpoints
+ *
+ * @param message - Raw error message
+ * @returns Sanitized error message safe for user display
+ *
+ * @example
+ * ```typescript
+ * // Input (dangerous):
+ * const raw = 'Error reading /home/user/secret.key: EACCES';
+ * const safe = sanitizeErrorMessage(raw);
+ * // Output: 'Error reading file: Permission denied'
+ *
+ * // Input (dangerous):
+ * const raw2 = 'Failed to connect to DATABASE_URL=postgres://user:pass@host';
+ * const safe2 = sanitizeErrorMessage(raw2);
+ * // Output: 'Failed to connect to database'
+ * ```
+ *
+ * @usage
+ * ```typescript
+ * // Safe error display in UI
+ * function showUserError(error: unknown): void {
+ *   const message = extractErrorMessage(error);
+ *   const safe = sanitizeErrorMessage(message);
+ *
+ *   showNotification({
+ *     type: 'error',
+ *     message: safe,
+ *     duration: 5000
+ *   });
+ * }
+ *
+ * // Log technical details separately
+ * function logErrorSecurely(error: unknown): void {
+ *   const technical = extractErrorMessage(error);
+ *   const safe = sanitizeErrorMessage(technical);
+ *
+ *   // Log full details to secure server log
+ *   internalLogger.error(technical);
+ *
+ *   // Show safe version to user
+ *   userNotification.error(safe);
+ * }
+ * ```
+ */
+export function sanitizeErrorMessage(message) {
+    let sanitized = message;
+    // Remove file paths (Unix/Windows)
+    sanitized = sanitized.replace(/\/[^\s]*\//g, '/.../')
+        .replace(/C:\\[^\s]*/g, 'path\\...');
+    // Remove URLs and credentials
+    sanitized = sanitized.replace(/https?:\/\/[^\s]*/g, 'URL')
+        .replace(/([a-zA-Z0-9_-]+):([a-zA-Z0-9_-]+)@/g, 'credentials@');
+    // Remove environment variable patterns
+    sanitized = sanitized.replace(/\w+=.*?(?=\s|$)/g, (match) => {
+        if (match.includes('://') || match.includes('token') || match.includes('key')) {
+            return '[REDACTED]';
+        }
+        return match;
+    });
+    // Remove process/memory information
+    sanitized = sanitized.replace(/0x[0-9a-f]+/gi, 'address');
+    sanitized = sanitized.replace(/pid\s*\d+/gi, 'pid');
+    return sanitized;
+}
+/**
+ * Extracts the error message from various error types.
+ *
+ * Handles Error objects, plain objects with message property, and stringified errors.
+ *
+ * @param error - The error to extract message from
+ * @returns Error message string
+ *
+ * @example
+ * ```typescript
+ * extractErrorMessage(new Error('File not found'))
+ * // 'File not found'
+ *
+ * extractErrorMessage({ message: 'Custom error' })
+ * // 'Custom error'
+ *
+ * extractErrorMessage('Simple string error')
+ * // 'Simple string error'
+ *
+ * extractErrorMessage(null)
+ * // 'An unknown error occurred'
+ * ```
+ *
+ * @usage
+ * ```typescript
+ * // Unified error message extraction
+ * async function executeWithErrorHandling<T>(
+ *   fn: () => Promise<T>
+ * ): Promise<T> {
+ *   try {
+ *     return await fn();
+ *   } catch (error) {
+ *     const message = extractErrorMessage(error);
+ *     throw new Error(`Operation failed: ${message}`);
+ *   }
+ * }
+ * ```
+ */
+export function extractErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'object' && error !== null && 'message' in error) {
+        const msg = error.message;
+        if (typeof msg === 'string')
+            return msg;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    return 'An unknown error occurred';
+}
+/**
+ * Gets recovery suggestions based on error type.
+ *
+ * Provides users with actionable steps to resolve common errors.
+ *
+ * @param error - The error to get suggestions for
+ * @param errorCode - Optional error code for more specific suggestions
+ * @returns Array of suggestion strings
+ *
+ * @example
+ * ```typescript
+ * const error = new Error('ENOENT: no such file or directory');
+ * const suggestions = getRecoverySuggestions(error, ErrorCode.ENOENT);
+ * // [
+ * //   'Check that the file path is correct',
+ * //   'Verify the file exists in the specified location',
+ * //   'Try using an absolute file path instead of relative'
+ * // ]
+ * ```
+ *
+ * @usage
+ * ```typescript
+ * // Show recovery steps in UI
+ * function showDetailedError(error: unknown) {
+ *   const message = extractErrorMessage(error);
+ *   const suggestions = getRecoverySuggestions(error);
+ *
+ *   showErrorDialog({
+ *     title: 'Operation Failed',
+ *     message: sanitizeErrorMessage(message),
+ *     suggestions: suggestions,
+ *     actions: [
+ *       { label: 'Try Again', handler: retry },
+ *       { label: 'Cancel', handler: cancel }
+ *     ]
+ *   });
+ * }
+ * ```
+ */
+export function getRecoverySuggestions(error, errorCode) {
+    const suggestions = [];
+    const message = extractErrorMessage(error);
+    const errorType = categorizeError(error);
+    // Code-based suggestions
+    if (errorCode === ErrorCode.ENOENT) {
+        suggestions.push('Check that the file path is correct');
+        suggestions.push('Verify the file exists in the specified location');
+        suggestions.push('Try using an absolute file path instead of relative');
+    }
+    else if (errorCode === ErrorCode.EACCES || errorCode === ErrorCode.PERMISSION) {
+        suggestions.push('Check file/directory permissions');
+        suggestions.push('Try running with elevated privileges if necessary');
+        suggestions.push('Ensure the file owner allows read/write access');
+    }
+    else if (errorCode === ErrorCode.ETIMEDOUT || errorCode === ErrorCode.TIMEOUT) {
+        suggestions.push('Check your internet connection');
+        suggestions.push('Try again in a few moments');
+        suggestions.push('Verify the server is online');
+    }
+    else if (errorCode === ErrorCode.ECONNREFUSED || errorCode === ErrorCode.NETWORK) {
+        suggestions.push('Verify the server address and port');
+        suggestions.push('Check your network connection');
+        suggestions.push('Ensure firewall is not blocking the connection');
+    }
+    else if (errorCode === ErrorCode.VALIDATION) {
+        suggestions.push('Check that all required fields are filled');
+        suggestions.push('Verify data formats match requirements');
+        suggestions.push('Review any validation error details above');
+    }
+    // Type-based suggestions
+    if (errorType === 'TypeError') {
+        suggestions.push('Verify that variables are initialized before use');
+        suggestions.push('Check that function arguments are of correct type');
+        suggestions.push('Ensure objects have expected properties');
+    }
+    else if (errorType === 'ReferenceError') {
+        suggestions.push('Check variable name spelling');
+        suggestions.push('Ensure variable is declared before use');
+        suggestions.push('Verify variable scope and imports');
+    }
+    else if (errorType === 'RangeError') {
+        suggestions.push('Check that values are within acceptable range');
+        suggestions.push('Verify numeric limits are not exceeded');
+    }
+    else if (errorType === 'SyntaxError') {
+        suggestions.push('Check file syntax for errors');
+        suggestions.push('Verify JSON structure if parsing JSON');
+        suggestions.push('Review recent changes to the file');
+    }
+    // Message-based suggestions
+    if (message.includes('memory')) {
+        suggestions.push('Close other applications to free memory');
+        suggestions.push('Increase available system memory');
+        suggestions.push('Break operation into smaller chunks');
+    }
+    else if (message.includes('timeout')) {
+        suggestions.push('Increase timeout duration');
+        suggestions.push('Check network connectivity');
+        suggestions.push('Optimize operation performance');
+    }
+    // Default suggestion if none matched
+    if (suggestions.length === 0) {
+        suggestions.push('Check the error message for more details');
+        suggestions.push('Try the operation again');
+        suggestions.push('Contact support if the problem persists');
+    }
+    return suggestions;
+}
+/**
+ * Main error formatting function for user-friendly error display.
+ *
+ * Transforms a raw error into a structured, sanitized error object suitable
+ * for display to end users while preserving technical details for logging.
+ *
+ * @param error - The error to format
+ * @param options - Optional formatting options
+ * @param options.code - Override error code
+ * @param options.includeStack - Include stack trace in output (default: false for users)
+ * @param options.sanitize - Sanitize message for user display (default: true)
+ * @returns Formatted error object with user-friendly message
+ *
+ * @throws Never throws, always returns a valid FormattedError
+ *
+ * @example
+ * ```typescript
+ * // File system error
+ * try {
+ *   fs.readFileSync('/etc/shadow'); // EACCES
+ * } catch (error) {
+ *   const formatted = formatErrorForUser(error, { code: ErrorCode.EACCES });
+ *   // {
+ *   //   code: 'EACCES',
+ *   //   message: 'Permission denied. Check file permissions.',
+ *   //   technicalDetails: 'Error: EACCES: permission denied, open ...',
+ *   //   suggestions: [
+ *   //     'Check file/directory permissions',
+ *   //     'Try running with elevated privileges if necessary',
+ *   //     'Ensure the file owner allows read/write access'
+ *   //   ],
+ *   //   timestamp: 2024-01-15T10:30:45.123Z
+ *   // }
+ * }
+ * ```
+ *
+ * ```typescript
+ * // API validation error
+ * const error = new TypeError('Cannot read property "name" of undefined');
+ * const formatted = formatErrorForUser(error);
+ * // {
+ * //   code: 'E002',
+ * //   message: 'Invalid input provided',
+ * //   technicalDetails: 'TypeError: Cannot read property "name" of undefined',
+ * //   suggestions: [
+ * //     'Verify that variables are initialized before use',
+ * //     'Check that function arguments are of correct type',
+ * //     'Ensure objects have expected properties'
+ * //   ],
+ * //   timestamp: 2024-01-15T10:30:45.123Z
+ * // }
+ * ```
+ *
+ * ```typescript
+ * // Network timeout
+ * const error = new Error('ETIMEDOUT: connection timed out');
+ * const formatted = formatErrorForUser(error, { code: ErrorCode.ETIMEDOUT });
+ * // {
+ * //   code: 'ETIMEDOUT',
+ * //   message: 'Request timed out. Please try again.',
+ * //   suggestions: [
+ * //     'Check your internet connection',
+ * //     'Try again in a few moments',
+ * //     'Verify the server is online'
+ * //   ],
+ * //   timestamp: 2024-01-15T10:30:45.123Z
+ * // }
+ * ```
+ *
+ * @usage
+ * ```typescript
+ * // In Express middleware
+ * app.use((err, req, res, next) => {
+ *   const formatted = formatErrorForUser(err);
+ *
+ *   // Log full technical details
+ *   internalLogger.error(formatted.technicalDetails);
+ *
+ *   // Send user-friendly response
+ *   res.status(500).json({
+ *     error: formatted.message,
+ *     code: formatted.code,
+ *     suggestions: formatted.suggestions
+ *   });
+ * });
+ *
+ * // In CLI applications
+ * async function main() {
+ *   try {
+ *     await performAction();
+ *   } catch (error) {
+ *     const formatted = formatErrorForUser(error);
+ *     console.error(`Error: ${formatted.message}`);
+ *     console.error('Recovery steps:');
+ *     formatted.suggestions.forEach((s, i) => {
+ *       console.error(`  ${i + 1}. ${s}`);
+ *     });
+ *     process.exit(1);
+ *   }
+ * }
+ *
+ * // In React components
+ * function ErrorBoundary(props: any) {
+ *   const [error, setError] = React.useState<FormattedError | null>(null);
+ *
+ *   if (error) {
+ *     const formatted = formatErrorForUser(error.originalError);
+ *     return (
+ *       <ErrorDisplay
+ *         message={formatted.message}
+ *         suggestions={formatted.suggestions}
+ *         onRetry={retry}
+ *       />
+ *     );
+ *   }
+ * }
+ * ```
+ */
+export function formatErrorForUser(error, options) {
+    const sanitize = options?.sanitize !== false;
+    const includeStack = options?.includeStack ?? false;
+    const rawMessage = extractErrorMessage(error);
+    const errorType = categorizeError(error);
+    const stack = extractStackTrace(error);
+    const suggestions = getRecoverySuggestions(error, options?.code);
+    // Determine error code
+    let code = options?.code ?? ErrorCode.UNKNOWN;
+    if (!options?.code) {
+        // Try to infer code from error
+        if (error instanceof Error) {
+            if (rawMessage.includes('ENOENT'))
+                code = ErrorCode.ENOENT;
+            else if (rawMessage.includes('EACCES'))
+                code = ErrorCode.EACCES;
+            else if (rawMessage.includes('EISDIR'))
+                code = ErrorCode.EISDIR;
+            else if (rawMessage.includes('EEXIST'))
+                code = ErrorCode.EEXIST;
+            else if (rawMessage.includes('ETIMEDOUT'))
+                code = ErrorCode.ETIMEDOUT;
+            else if (rawMessage.includes('ECONNREFUSED'))
+                code = ErrorCode.ECONNREFUSED;
+            else if (errorType === 'TypeError')
+                code = ErrorCode.VALIDATION;
+            else if (errorType === 'SyntaxError')
+                code = ErrorCode.PARSE_ERROR;
+        }
+    }
+    // Create user-friendly message
+    let userMessage = sanitize ? sanitizeErrorMessage(rawMessage) : rawMessage;
+    // Enhance message with context if it's too generic
+    if (userMessage === 'An unknown error occurred' || userMessage.length < 5) {
+        if (code === ErrorCode.EACCES)
+            userMessage = 'Permission denied. Check your access rights.';
+        else if (code === ErrorCode.ENOENT)
+            userMessage = 'The requested file or resource was not found.';
+        else if (code === ErrorCode.TIMEOUT)
+            userMessage = 'The operation timed out. Please try again.';
+        else if (code === ErrorCode.NETWORK)
+            userMessage = 'A network error occurred. Check your connection.';
+        else if (code === ErrorCode.VALIDATION)
+            userMessage = 'The provided input is invalid.';
+        else if (code === ErrorCode.PARSE_ERROR)
+            userMessage = 'Failed to parse data. Check the format.';
+        else
+            userMessage = `An error occurred (${errorType}). Please try again.`;
+    }
+    return {
+        code,
+        message: userMessage,
+        technicalDetails: `${errorType}: ${rawMessage}${stack ? '\n' + stack : ''}`,
+        stack: includeStack ? stack : undefined,
+        suggestions,
+        originalError: error,
+        timestamp: new Date(),
+    };
+}
+/**
+ * Wraps a promise to handle errors gracefully.
+ *
+ * Returns [data, error] tuple similar to Go's error handling pattern.
+ * Makes error handling explicit and type-safe.
+ *
+ * @param promise - Promise to wrap
+ * @returns Tuple of [data, error]
+ *
+ * @example
+ * ```typescript
+ * const [data, error] = await handlePromise(fetch('/api/users'));
+ *
+ * if (error) {
+ *   const formatted = formatErrorForUser(error);
+ *   showErrorNotification(formatted.message);
+ *   return;
+ * }
+ *
+ *   // data is guaranteed to exist here
+ * processUsers(data);
+ * ```
+ *
+ * @usage
+ * ```typescript
+ * // Cleaner async/await error handling
+ * async function loadUserData(userId: string) {
+ *   const [user, error] = await handlePromise(
+ *     fetch(`/api/users/${userId}`).then(r => r.json())
+ *   );
+ *
+ *   if (error) {
+ *     return { success: false, error: formatErrorForUser(error) };
+ *   }
+ *
+ *   return { success: true, data: user };
+ * }
+ * ```
+ */
+export async function handlePromise(promise) {
+    try {
+        const data = await promise;
+        return [data, null];
+    }
+    catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        return [null, err];
+    }
+}
+/**
+ * Retries an operation with exponential backoff.
+ *
+ * Useful for transient failures (network issues, temporary unavailability).
+ *
+ * @param fn - Async function to retry
+ * @param maxAttempts - Maximum number of attempts (default: 3)
+ * @param baseDelay - Base delay in milliseconds (default: 1000)
+ * @returns Promise that resolves with function result or rejects with last error
+ *
+ * @example
+ * ```typescript
+ * const data = await retryWithBackoff(
+ *   () => fetch('/api/data').then(r => r.json()),
+ *   3,
+ *   1000
+ * );
+ * // Attempts:
+ * // 1. Immediately
+ * // 2. After ~1000ms
+ * // 3. After ~2000ms
+ * ```
+ *
+ * @usage
+ * ```typescript
+ * // Resilient API calls
+ * async function fetchUserWithRetry(userId: string) {
+ *   return retryWithBackoff(
+ *     async () => {
+ *       const response = await fetch(`/api/users/${userId}`);
+ *       if (!response.ok) throw new Error('API error');
+ *       return response.json();
+ *     },
+ *     3,
+ *     1000
+ *   );
+ * }
+ * ```
+ */
+export async function retryWithBackoff(fn, maxAttempts = 3, baseDelay = 1000) {
+    let lastError = null;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt < maxAttempts - 1) {
+                const delay = baseDelay * Math.pow(2, attempt);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
+    throw lastError || new Error('Operation failed after retries');
+}
+//# sourceMappingURL=error-handler.js.map