erosolar-cli 1.5.2 → 1.5.4

package/dist/bin/core/errors/apiKeyErrors.js

@@ -0,0 +1,114 @@
+import { MissingSecretError, getSecretDefinitionForProvider, } from '../secretStore.js';
+export function detectApiKeyError(error, provider) {
+    if (error instanceof MissingSecretError) {
+        const primaryProvider = error.secret.providers[0] ?? null;
+        return {
+            type: 'missing',
+            provider: provider ?? primaryProvider,
+            secret: error.secret,
+            message: error.message,
+        };
+    }
+    if (isUnauthorizedError(error)) {
+        const labelProvider = provider ?? extractProviderFromError(error);
+        const secret = labelProvider ? getSecretDefinitionForProvider(labelProvider) : null;
+        return {
+            type: 'invalid',
+            provider: labelProvider,
+            secret,
+            message: extractErrorMessage(error),
+        };
+    }
+    return null;
+}
+function isUnauthorizedError(error) {
+    const status = extractStatus(error);
+    if (status === 401 || status === 403) {
+        return true;
+    }
+    const payload = extractStructuredError(error);
+    if (payload) {
+        const normalizedType = normalize(payload.type) || normalize(payload.code);
+        if (normalizedType && containsAuthKeyword(normalizedType)) {
+            return true;
+        }
+        if (payload.message && containsAuthKeyword(normalize(payload.message))) {
+            return true;
+        }
+    }
+    const message = normalize(extractErrorMessage(error));
+    if (!message) {
+        return false;
+    }
+    return containsAuthKeyword(message);
+}
+function extractStatus(error) {
+    if (!error || typeof error !== 'object') {
+        return null;
+    }
+    const directStatus = error.status;
+    if (typeof directStatus === 'number') {
+        return directStatus;
+    }
+    const response = error.response;
+    if (response && typeof response.status === 'number') {
+        return response.status;
+    }
+    return null;
+}
+function extractStructuredError(error) {
+    if (!error || typeof error !== 'object') {
+        return null;
+    }
+    if ('error' in error) {
+        const candidate = error.error;
+        if (candidate && typeof candidate === 'object') {
+            return candidate;
+        }
+    }
+    return null;
+}
+function extractProviderFromError(error) {
+    if (!error || typeof error !== 'object') {
+        return null;
+    }
+    const provider = error.provider;
+    if (typeof provider === 'string' && provider.trim()) {
+        return provider.trim();
+    }
+    return null;
+}
+function extractErrorMessage(error) {
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error instanceof Error) {
+        return error.message ?? '';
+    }
+    if (error && typeof error === 'object') {
+        const payload = extractStructuredError(error);
+        if (payload?.message) {
+            return payload.message;
+        }
+        if ('message' in error && typeof error.message === 'string') {
+            return error.message;
+        }
+    }
+    return '';
+}
+function containsAuthKeyword(value) {
+    if (!value) {
+        return false;
+    }
+    return (value.includes('api key') ||
+        value.includes('apikey') ||
+        value.includes('api-key') ||
+        value.includes('authentication') ||
+        value.includes('unauthorized'));
+}
+function normalize(value) {
+    if (!value) {
+        return null;
+    }
+    return value.toLowerCase();
+}

package/dist/bin/core/errors/errorTypes.js

@@ -0,0 +1,340 @@
+/**
+ * Comprehensive Error Classification System
+ *
+ * Provides structured error handling with:
+ * - Error categorization (dangerous, blocked, invalid, etc.)
+ * - Severity levels (critical, error, warning, info)
+ * - Auto-fixing suggestions
+ * - Recovery strategies
+ */
+export var ErrorSeverity;
+(function (ErrorSeverity) {
+    ErrorSeverity["CRITICAL"] = "critical";
+    ErrorSeverity["ERROR"] = "error";
+    ErrorSeverity["WARNING"] = "warning";
+    ErrorSeverity["INFO"] = "info";
+})(ErrorSeverity || (ErrorSeverity = {}));
+export var ErrorCategory;
+(function (ErrorCategory) {
+    ErrorCategory["DANGEROUS"] = "dangerous";
+    ErrorCategory["BLOCKED"] = "blocked";
+    ErrorCategory["INVALID"] = "invalid";
+    ErrorCategory["PERMISSION"] = "permission";
+    ErrorCategory["RESOURCE"] = "resource";
+    ErrorCategory["NETWORK"] = "network";
+    ErrorCategory["TIMEOUT"] = "timeout";
+    ErrorCategory["VALIDATION"] = "validation";
+    ErrorCategory["CONTEXT_OVERFLOW"] = "context_overflow";
+    ErrorCategory["NOT_FOUND"] = "not_found";
+    ErrorCategory["UNKNOWN"] = "unknown";
+})(ErrorCategory || (ErrorCategory = {}));
+/**
+ * Base class for all structured errors
+ */
+export class StructuredError extends Error {
+    constructor(details) {
+        super(details.message);
+        this.name = this.constructor.name;
+        this.severity = details.severity;
+        this.category = details.category;
+        this.suggestions = details.suggestions;
+        this.originalInput = details.originalInput;
+        this.metadata = details.metadata;
+        this.timestamp = details.timestamp;
+        this.recoverable = details.recoverable;
+        // Maintain proper stack trace
+        Error.captureStackTrace(this, this.constructor);
+    }
+    /**
+     * Format error for display with suggestions
+     */
+    toDisplayString() {
+        const parts = [
+            `[${this.severity.toUpperCase()}] ${this.message}`,
+        ];
+        if (this.originalInput) {
+            parts.push(`  Input: ${this.originalInput}`);
+        }
+        if (this.suggestions.length > 0) {
+            parts.push('\nSuggestions:');
+            for (const suggestion of this.suggestions) {
+                parts.push(`  • ${suggestion.action}`);
+                if (suggestion.example) {
+                    parts.push(`    Example: ${suggestion.example}`);
+                }
+                if (suggestion.autoFixable) {
+                    parts.push(`    [Auto-fixable]`);
+                }
+            }
+        }
+        return parts.join('\n');
+    }
+    /**
+     * Convert to JSON for logging/telemetry
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            severity: this.severity,
+            category: this.category,
+            message: this.message,
+            originalInput: this.originalInput,
+            suggestions: this.suggestions.map(s => ({
+                action: s.action,
+                example: s.example,
+                autoFixable: s.autoFixable,
+            })),
+            metadata: this.metadata,
+            timestamp: this.timestamp,
+            recoverable: this.recoverable,
+            stack: this.stack,
+        };
+    }
+    /**
+     * Try to auto-fix the error if possible
+     */
+    tryAutoFix() {
+        for (const suggestion of this.suggestions) {
+            if (suggestion.autoFixable && suggestion.autoFix) {
+                try {
+                    const result = suggestion.autoFix();
+                    return { fixed: true, result };
+                }
+                catch {
+                    // Continue to next suggestion
+                }
+            }
+        }
+        return { fixed: false };
+    }
+}
+/**
+ * Dangerous operation error - operation could harm the system
+ */
+export class DangerousOperationError extends StructuredError {
+    constructor(operation, reason, safeAlternative) {
+        const suggestions = [];
+        if (safeAlternative) {
+            suggestions.push({
+                action: `Use safer alternative: ${safeAlternative}`,
+                example: safeAlternative,
+                autoFixable: true,
+                autoFix: () => safeAlternative,
+            });
+        }
+        else {
+            suggestions.push({
+                action: 'Review operation for safety before retrying',
+                autoFixable: false,
+            });
+        }
+        super({
+            severity: ErrorSeverity.CRITICAL,
+            category: ErrorCategory.DANGEROUS,
+            message: `Dangerous operation blocked: ${operation}. Reason: ${reason}`,
+            originalInput: operation,
+            suggestions,
+            recoverable: safeAlternative !== undefined,
+            timestamp: new Date().toISOString(),
+        });
+    }
+}
+/**
+ * Blocked operation error - explicitly forbidden by policy
+ */
+export class BlockedOperationError extends StructuredError {
+    constructor(operation, policy, allowedAlternatives) {
+        const suggestions = [];
+        if (allowedAlternatives && allowedAlternatives.length > 0) {
+            for (const alt of allowedAlternatives) {
+                suggestions.push({
+                    action: `Try allowed alternative: ${alt}`,
+                    example: alt,
+                    autoFixable: true,
+                    autoFix: () => alt,
+                });
+            }
+        }
+        else {
+            suggestions.push({
+                action: 'This operation is not permitted by policy',
+                autoFixable: false,
+            });
+        }
+        super({
+            severity: ErrorSeverity.ERROR,
+            category: ErrorCategory.BLOCKED,
+            message: `Operation blocked by policy "${policy}": ${operation}`,
+            originalInput: operation,
+            suggestions,
+            recoverable: allowedAlternatives !== undefined && allowedAlternatives.length > 0,
+            timestamp: new Date().toISOString(),
+            metadata: { policy, allowedAlternatives },
+        });
+    }
+}
+/**
+ * Context overflow error - token/character limits exceeded
+ */
+export class ContextOverflowError extends StructuredError {
+    constructor(actual, limit, unit, truncatable = true) {
+        const percentage = Math.round((actual / limit) * 100);
+        const suggestions = [];
+        if (truncatable) {
+            suggestions.push({
+                action: `Auto-truncate to ${limit} ${unit}`,
+                example: `Content will be reduced from ${actual} to ${limit} ${unit}`,
+                autoFixable: true,
+                autoFix: () => ({ truncate: true, limit }),
+            });
+        }
+        suggestions.push({
+            action: `Reduce scope to use less than ${limit} ${unit}`,
+            autoFixable: false,
+        });
+        super({
+            severity: ErrorSeverity.CRITICAL,
+            category: ErrorCategory.CONTEXT_OVERFLOW,
+            message: `Context overflow: ${actual} ${unit} exceeds limit of ${limit} ${unit} (${percentage}%)`,
+            suggestions,
+            recoverable: truncatable,
+            timestamp: new Date().toISOString(),
+            metadata: { actual, limit, unit, percentage },
+        });
+    }
+}
+/**
+ * Validation error - with auto-fix suggestions
+ */
+export class ValidationError extends StructuredError {
+    constructor(field, value, constraint, correctExample) {
+        const suggestions = [];
+        if (correctExample) {
+            suggestions.push({
+                action: `Use correct format: ${correctExample}`,
+                example: correctExample,
+                autoFixable: true,
+                autoFix: () => correctExample,
+            });
+        }
+        super({
+            severity: ErrorSeverity.ERROR,
+            category: ErrorCategory.VALIDATION,
+            message: `Validation failed for "${field}": ${constraint}`,
+            originalInput: String(value),
+            suggestions,
+            recoverable: correctExample !== undefined,
+            timestamp: new Date().toISOString(),
+            metadata: { field, value, constraint },
+        });
+    }
+}
+/**
+ * Resource error - limits exceeded
+ */
+export class ResourceLimitError extends StructuredError {
+    constructor(resource, actual, limit, reducible = true) {
+        const suggestions = [];
+        if (reducible) {
+            const safeValue = Math.floor(limit * 0.8); // 80% of limit
+            suggestions.push({
+                action: `Reduce ${resource} to ${safeValue} (80% of limit)`,
+                example: `Set ${resource}=${safeValue}`,
+                autoFixable: true,
+                autoFix: () => safeValue,
+            });
+        }
+        super({
+            severity: ErrorSeverity.ERROR,
+            category: ErrorCategory.RESOURCE,
+            message: `Resource limit exceeded: ${resource} is ${actual}, maximum is ${limit}`,
+            suggestions,
+            recoverable: reducible,
+            timestamp: new Date().toISOString(),
+            metadata: { resource, actual, limit },
+        });
+    }
+}
+/**
+ * Format any error as a structured error
+ */
+export function toStructuredError(error) {
+    // Already structured
+    if (error instanceof StructuredError) {
+        return error;
+    }
+    // Convert standard errors
+    const message = error instanceof Error ? error.message : String(error);
+    // Detect error category from message
+    const category = detectErrorCategory(message);
+    const severity = detectErrorSeverity(category);
+    class GenericStructuredError extends StructuredError {
+    }
+    return new GenericStructuredError({
+        severity,
+        category,
+        message,
+        suggestions: [],
+        recoverable: false,
+        timestamp: new Date().toISOString(),
+    });
+}
+/**
+ * Detect error category from error message
+ */
+function detectErrorCategory(message) {
+    const lower = message.toLowerCase();
+    if (lower.includes('dangerous') || lower.includes('unsafe') || lower.includes('harmful')) {
+        return ErrorCategory.DANGEROUS;
+    }
+    if (lower.includes('blocked') || lower.includes('forbidden') || lower.includes('not allowed')) {
+        return ErrorCategory.BLOCKED;
+    }
+    if (lower.includes('invalid') || lower.includes('malformed')) {
+        return ErrorCategory.INVALID;
+    }
+    if (lower.includes('permission') || lower.includes('unauthorized') || lower.includes('access denied')) {
+        return ErrorCategory.PERMISSION;
+    }
+    if (lower.includes('limit') || lower.includes('exceeded') || lower.includes('too large')) {
+        return ErrorCategory.RESOURCE;
+    }
+    if (lower.includes('timeout') || lower.includes('timed out')) {
+        return ErrorCategory.TIMEOUT;
+    }
+    if (lower.includes('network') || lower.includes('connection')) {
+        return ErrorCategory.NETWORK;
+    }
+    if (lower.includes('validation') || lower.includes('schema')) {
+        return ErrorCategory.VALIDATION;
+    }
+    if (lower.includes('context') || lower.includes('token') || lower.includes('overflow')) {
+        return ErrorCategory.CONTEXT_OVERFLOW;
+    }
+    if (lower.includes('not found') || lower.includes('does not exist')) {
+        return ErrorCategory.NOT_FOUND;
+    }
+    return ErrorCategory.UNKNOWN;
+}
+/**
+ * Determine severity from category
+ */
+function detectErrorSeverity(category) {
+    switch (category) {
+        case ErrorCategory.DANGEROUS:
+        case ErrorCategory.CONTEXT_OVERFLOW:
+            return ErrorSeverity.CRITICAL;
+        case ErrorCategory.BLOCKED:
+        case ErrorCategory.PERMISSION:
+        case ErrorCategory.VALIDATION:
+        case ErrorCategory.INVALID:
+        case ErrorCategory.RESOURCE:
+            return ErrorSeverity.ERROR;
+        case ErrorCategory.TIMEOUT:
+        case ErrorCategory.NETWORK:
+        case ErrorCategory.NOT_FOUND:
+            return ErrorSeverity.WARNING;
+        default:
+            return ErrorSeverity.ERROR;
+    }
+}