@serve.zone/dcrouter 2.12.4

package/dist_ts/mail/core/classes.bouncemanager.js

@@ -0,0 +1,778 @@
+import * as plugins from '../../plugins.js';
+import * as paths from '../../paths.js';
+import { logger } from '../../logger.js';
+import { SecurityLogger, SecurityLogLevel, SecurityEventType } from '../../security/index.js';
+import { LRUCache } from 'lru-cache';
+/**
+ * Bounce types for categorizing the reasons for bounces
+ */
+export var BounceType;
+(function (BounceType) {
+    // Hard bounces (permanent failures)
+    BounceType["INVALID_RECIPIENT"] = "invalid_recipient";
+    BounceType["DOMAIN_NOT_FOUND"] = "domain_not_found";
+    BounceType["MAILBOX_FULL"] = "mailbox_full";
+    BounceType["MAILBOX_INACTIVE"] = "mailbox_inactive";
+    BounceType["BLOCKED"] = "blocked";
+    BounceType["SPAM_RELATED"] = "spam_related";
+    BounceType["POLICY_RELATED"] = "policy_related";
+    // Soft bounces (temporary failures)
+    BounceType["SERVER_UNAVAILABLE"] = "server_unavailable";
+    BounceType["TEMPORARY_FAILURE"] = "temporary_failure";
+    BounceType["QUOTA_EXCEEDED"] = "quota_exceeded";
+    BounceType["NETWORK_ERROR"] = "network_error";
+    BounceType["TIMEOUT"] = "timeout";
+    // Special cases
+    BounceType["AUTO_RESPONSE"] = "auto_response";
+    BounceType["CHALLENGE_RESPONSE"] = "challenge_response";
+    BounceType["UNKNOWN"] = "unknown";
+})(BounceType || (BounceType = {}));
+/**
+ * Hard vs soft bounce classification
+ */
+export var BounceCategory;
+(function (BounceCategory) {
+    BounceCategory["HARD"] = "hard";
+    BounceCategory["SOFT"] = "soft";
+    BounceCategory["AUTO_RESPONSE"] = "auto_response";
+    BounceCategory["UNKNOWN"] = "unknown";
+})(BounceCategory || (BounceCategory = {}));
+/**
+ * Email bounce patterns to identify bounce types in SMTP responses and bounce messages
+ */
+const BOUNCE_PATTERNS = {
+    // Hard bounce patterns
+    [BounceType.INVALID_RECIPIENT]: [
+        /no such user/i,
+        /user unknown/i,
+        /does not exist/i,
+        /invalid recipient/i,
+        /unknown recipient/i,
+        /no mailbox/i,
+        /user not found/i,
+        /recipient address rejected/i,
+        /550 5\.1\.1/i
+    ],
+    [BounceType.DOMAIN_NOT_FOUND]: [
+        /domain not found/i,
+        /unknown domain/i,
+        /no such domain/i,
+        /host not found/i,
+        /domain invalid/i,
+        /550 5\.1\.2/i
+    ],
+    [BounceType.MAILBOX_FULL]: [
+        /mailbox full/i,
+        /over quota/i,
+        /quota exceeded/i,
+        /552 5\.2\.2/i
+    ],
+    [BounceType.MAILBOX_INACTIVE]: [
+        /mailbox disabled/i,
+        /mailbox inactive/i,
+        /account disabled/i,
+        /mailbox not active/i,
+        /account suspended/i
+    ],
+    [BounceType.BLOCKED]: [
+        /blocked/i,
+        /rejected/i,
+        /denied/i,
+        /blacklisted/i,
+        /prohibited/i,
+        /refused/i,
+        /550 5\.7\./i
+    ],
+    [BounceType.SPAM_RELATED]: [
+        /spam/i,
+        /bulk mail/i,
+        /content rejected/i,
+        /message rejected/i,
+        /550 5\.7\.1/i
+    ],
+    // Soft bounce patterns
+    [BounceType.SERVER_UNAVAILABLE]: [
+        /server unavailable/i,
+        /service unavailable/i,
+        /try again later/i,
+        /try later/i,
+        /451 4\.3\./i,
+        /421 4\.3\./i
+    ],
+    [BounceType.TEMPORARY_FAILURE]: [
+        /temporary failure/i,
+        /temporary error/i,
+        /temporary problem/i,
+        /try again/i,
+        /451 4\./i
+    ],
+    [BounceType.QUOTA_EXCEEDED]: [
+        /quota temporarily exceeded/i,
+        /mailbox temporarily full/i,
+        /452 4\.2\.2/i
+    ],
+    [BounceType.NETWORK_ERROR]: [
+        /network error/i,
+        /connection error/i,
+        /connection timed out/i,
+        /routing error/i,
+        /421 4\.4\./i
+    ],
+    [BounceType.TIMEOUT]: [
+        /timed out/i,
+        /timeout/i,
+        /450 4\.4\.2/i
+    ],
+    // Auto-responses
+    [BounceType.AUTO_RESPONSE]: [
+        /auto[- ]reply/i,
+        /auto[- ]response/i,
+        /vacation/i,
+        /out of office/i,
+        /away from office/i,
+        /on vacation/i,
+        /automatic reply/i
+    ],
+    [BounceType.CHALLENGE_RESPONSE]: [
+        /challenge[- ]response/i,
+        /verify your email/i,
+        /confirm your email/i,
+        /email verification/i
+    ]
+};
+/**
+ * Manager for handling email bounces
+ */
+export class BounceManager {
+    constructor(options) {
+        // Retry strategy with exponential backoff
+        this.retryStrategy = {
+            maxRetries: 5,
+            initialDelay: 15 * 60 * 1000, // 15 minutes
+            maxDelay: 24 * 60 * 60 * 1000, // 24 hours
+            backoffFactor: 2
+        };
+        // Store of bounced emails
+        this.bounceStore = [];
+        // Suppression list for addresses that should not receive emails
+        this.suppressionList = new Map();
+        // Set retry strategy with defaults
+        if (options?.retryStrategy) {
+            this.retryStrategy = {
+                ...this.retryStrategy,
+                ...options.retryStrategy
+            };
+        }
+        // Initialize bounce cache with LRU (least recently used) caching
+        this.bounceCache = new LRUCache({
+            max: options?.maxCacheSize || 10000,
+            ttl: options?.cacheTTL || 30 * 24 * 60 * 60 * 1000, // 30 days default
+        });
+        // Store storage manager reference
+        this.storageManager = options?.storageManager;
+        // Load suppression list from storage
+        // Note: This is async but we can't await in constructor
+        // The suppression list will be loaded asynchronously
+        this.loadSuppressionList().catch(error => {
+            logger.log('error', `Failed to load suppression list on startup: ${error.message}`);
+        });
+    }
+    /**
+     * Process a bounce notification
+     * @param bounceData Bounce data to process
+     * @returns Processed bounce record
+     */
+    async processBounce(bounceData) {
+        try {
+            // Add required fields if missing
+            const bounce = {
+                id: bounceData.id || plugins.uuid.v4(),
+                recipient: bounceData.recipient,
+                sender: bounceData.sender,
+                domain: bounceData.domain || bounceData.recipient.split('@')[1],
+                subject: bounceData.subject,
+                bounceType: bounceData.bounceType || BounceType.UNKNOWN,
+                bounceCategory: bounceData.bounceCategory || BounceCategory.UNKNOWN,
+                timestamp: bounceData.timestamp || Date.now(),
+                smtpResponse: bounceData.smtpResponse,
+                diagnosticCode: bounceData.diagnosticCode,
+                statusCode: bounceData.statusCode,
+                headers: bounceData.headers,
+                processed: false,
+                originalEmailId: bounceData.originalEmailId,
+                retryCount: bounceData.retryCount || 0,
+                nextRetryTime: bounceData.nextRetryTime
+            };
+            // Determine bounce type and category if not provided
+            if (!bounceData.bounceType || bounceData.bounceType === BounceType.UNKNOWN) {
+                const bounceInfo = this.detectBounceType(bounce.smtpResponse || '', bounce.diagnosticCode || '', bounce.statusCode || '');
+                bounce.bounceType = bounceInfo.type;
+                bounce.bounceCategory = bounceInfo.category;
+            }
+            // Process the bounce based on category
+            switch (bounce.bounceCategory) {
+                case BounceCategory.HARD:
+                    // Handle hard bounce - add to suppression list
+                    await this.handleHardBounce(bounce);
+                    break;
+                case BounceCategory.SOFT:
+                    // Handle soft bounce - schedule retry if eligible
+                    await this.handleSoftBounce(bounce);
+                    break;
+                case BounceCategory.AUTO_RESPONSE:
+                    // Handle auto-response - typically no action needed
+                    logger.log('info', `Auto-response detected for ${bounce.recipient}`);
+                    break;
+                default:
+                    // Unknown bounce type - log for investigation
+                    logger.log('warn', `Unknown bounce type for ${bounce.recipient}`, {
+                        bounceType: bounce.bounceType,
+                        smtpResponse: bounce.smtpResponse
+                    });
+                    break;
+            }
+            // Store the bounce record
+            bounce.processed = true;
+            this.bounceStore.push(bounce);
+            // Update the bounce cache
+            this.updateBounceCache(bounce);
+            // Log the bounce
+            logger.log(bounce.bounceCategory === BounceCategory.HARD ? 'warn' : 'info', `Email bounce processed: ${bounce.bounceCategory} bounce for ${bounce.recipient}`, {
+                bounceType: bounce.bounceType,
+                domain: bounce.domain,
+                category: bounce.bounceCategory
+            });
+            // Enhanced security logging
+            SecurityLogger.getInstance().logEvent({
+                level: bounce.bounceCategory === BounceCategory.HARD
+                    ? SecurityLogLevel.WARN
+                    : SecurityLogLevel.INFO,
+                type: SecurityEventType.EMAIL_VALIDATION,
+                message: `Email bounce detected: ${bounce.bounceCategory} bounce for recipient`,
+                domain: bounce.domain,
+                details: {
+                    recipient: bounce.recipient,
+                    bounceType: bounce.bounceType,
+                    smtpResponse: bounce.smtpResponse,
+                    diagnosticCode: bounce.diagnosticCode,
+                    statusCode: bounce.statusCode
+                },
+                success: false
+            });
+            return bounce;
+        }
+        catch (error) {
+            logger.log('error', `Error processing bounce: ${error.message}`, {
+                error: error.message,
+                bounceData
+            });
+            throw error;
+        }
+    }
+    /**
+     * Process an SMTP failure as a bounce
+     * @param recipient Recipient email
+     * @param smtpResponse SMTP error response
+     * @param options Additional options
+     * @returns Processed bounce record
+     */
+    async processSmtpFailure(recipient, smtpResponse, options = {}) {
+        // Create bounce data from SMTP failure
+        const bounceData = {
+            recipient,
+            sender: options.sender || '',
+            domain: recipient.split('@')[1],
+            smtpResponse,
+            statusCode: options.statusCode,
+            headers: options.headers,
+            originalEmailId: options.originalEmailId,
+            timestamp: Date.now()
+        };
+        // Process as a regular bounce
+        return this.processBounce(bounceData);
+    }
+    /**
+     * Process a bounce notification email
+     * @param bounceEmail The email containing bounce information
+     * @returns Processed bounce record or null if not a bounce
+     */
+    async processBounceEmail(bounceEmail) {
+        try {
+            // Check if this is a bounce notification
+            const subject = bounceEmail.getSubject();
+            const body = bounceEmail.getBody();
+            // Check for common bounce notification subject patterns
+            const isBounceSubject = /mail delivery|delivery (failed|status|notification)|failure notice|returned mail|undeliverable|delivery problem/i.test(subject);
+            if (!isBounceSubject) {
+                // Not a bounce notification based on subject
+                return null;
+            }
+            // Extract original recipient from the body or headers
+            let recipient = '';
+            let originalMessageId = '';
+            // Extract recipient from common bounce formats
+            const recipientMatch = body.match(/(?:failed recipient|to[:=]\s*|recipient:|delivery failed:)\s*<?([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})>?/i);
+            if (recipientMatch && recipientMatch[1]) {
+                recipient = recipientMatch[1];
+            }
+            // Extract diagnostic code
+            let diagnosticCode = '';
+            const diagnosticMatch = body.match(/diagnostic(?:-|\\s+)code:\s*(.+)(?:\n|$)/i);
+            if (diagnosticMatch && diagnosticMatch[1]) {
+                diagnosticCode = diagnosticMatch[1].trim();
+            }
+            // Extract SMTP status code
+            let statusCode = '';
+            const statusMatch = body.match(/status(?:-|\\s+)code:\s*([0-9.]+)/i);
+            if (statusMatch && statusMatch[1]) {
+                statusCode = statusMatch[1].trim();
+            }
+            // If recipient not found in standard patterns, try DSN (Delivery Status Notification) format
+            if (!recipient) {
+                // Look for DSN format with Original-Recipient or Final-Recipient fields
+                const originalRecipientMatch = body.match(/original-recipient:.*?([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/i);
+                const finalRecipientMatch = body.match(/final-recipient:.*?([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/i);
+                if (originalRecipientMatch && originalRecipientMatch[1]) {
+                    recipient = originalRecipientMatch[1];
+                }
+                else if (finalRecipientMatch && finalRecipientMatch[1]) {
+                    recipient = finalRecipientMatch[1];
+                }
+            }
+            // If still no recipient, can't process as bounce
+            if (!recipient) {
+                logger.log('warn', 'Could not extract recipient from bounce notification', {
+                    subject,
+                    sender: bounceEmail.from
+                });
+                return null;
+            }
+            // Extract original message ID if available
+            const messageIdMatch = body.match(/original[ -]message[ -]id:[ \t]*<?([^>]+)>?/i);
+            if (messageIdMatch && messageIdMatch[1]) {
+                originalMessageId = messageIdMatch[1].trim();
+            }
+            // Create bounce data
+            const bounceData = {
+                recipient,
+                sender: bounceEmail.from,
+                domain: recipient.split('@')[1],
+                subject: bounceEmail.getSubject(),
+                diagnosticCode,
+                statusCode,
+                timestamp: Date.now(),
+                headers: {}
+            };
+            // Process as a regular bounce
+            return this.processBounce(bounceData);
+        }
+        catch (error) {
+            logger.log('error', `Error processing bounce email: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * Handle a hard bounce by adding to suppression list
+     * @param bounce The bounce record
+     */
+    async handleHardBounce(bounce) {
+        // Add to suppression list permanently (no expiry)
+        this.addToSuppressionList(bounce.recipient, `Hard bounce: ${bounce.bounceType}`, undefined);
+        // Increment bounce count in cache
+        this.updateBounceCache(bounce);
+        // Save to permanent storage
+        await this.saveBounceRecord(bounce);
+        // Log hard bounce for monitoring
+        logger.log('warn', `Hard bounce for ${bounce.recipient}: ${bounce.bounceType}`, {
+            domain: bounce.domain,
+            smtpResponse: bounce.smtpResponse,
+            diagnosticCode: bounce.diagnosticCode
+        });
+    }
+    /**
+     * Handle a soft bounce by scheduling a retry if eligible
+     * @param bounce The bounce record
+     */
+    async handleSoftBounce(bounce) {
+        // Check if we've exceeded max retries
+        if (bounce.retryCount >= this.retryStrategy.maxRetries) {
+            logger.log('warn', `Max retries exceeded for ${bounce.recipient}, treating as hard bounce`);
+            // Convert to hard bounce after max retries
+            bounce.bounceCategory = BounceCategory.HARD;
+            await this.handleHardBounce(bounce);
+            return;
+        }
+        // Calculate next retry time with exponential backoff
+        const delay = Math.min(this.retryStrategy.initialDelay * Math.pow(this.retryStrategy.backoffFactor, bounce.retryCount), this.retryStrategy.maxDelay);
+        bounce.retryCount++;
+        bounce.nextRetryTime = Date.now() + delay;
+        // Add to suppression list temporarily (with expiry)
+        this.addToSuppressionList(bounce.recipient, `Soft bounce: ${bounce.bounceType}`, bounce.nextRetryTime);
+        // Log the retry schedule
+        logger.log('info', `Scheduled retry ${bounce.retryCount} for ${bounce.recipient} at ${new Date(bounce.nextRetryTime).toISOString()}`, {
+            bounceType: bounce.bounceType,
+            retryCount: bounce.retryCount,
+            nextRetry: bounce.nextRetryTime
+        });
+    }
+    /**
+     * Add an email address to the suppression list
+     * @param email Email address to suppress
+     * @param reason Reason for suppression
+     * @param expiresAt Expiration timestamp (undefined for permanent)
+     */
+    addToSuppressionList(email, reason, expiresAt) {
+        this.suppressionList.set(email.toLowerCase(), {
+            reason,
+            timestamp: Date.now(),
+            expiresAt
+        });
+        // Save asynchronously without blocking
+        this.saveSuppressionList().catch(error => {
+            logger.log('error', `Failed to save suppression list after adding ${email}: ${error.message}`);
+        });
+        logger.log('info', `Added ${email} to suppression list`, {
+            reason,
+            expiresAt: expiresAt ? new Date(expiresAt).toISOString() : 'permanent'
+        });
+    }
+    /**
+     * Remove an email address from the suppression list
+     * @param email Email address to remove
+     */
+    removeFromSuppressionList(email) {
+        const wasRemoved = this.suppressionList.delete(email.toLowerCase());
+        if (wasRemoved) {
+            // Save asynchronously without blocking
+            this.saveSuppressionList().catch(error => {
+                logger.log('error', `Failed to save suppression list after removing ${email}: ${error.message}`);
+            });
+            logger.log('info', `Removed ${email} from suppression list`);
+        }
+    }
+    /**
+     * Check if an email is on the suppression list
+     * @param email Email address to check
+     * @returns Whether the email is suppressed
+     */
+    isEmailSuppressed(email) {
+        const lowercaseEmail = email.toLowerCase();
+        const suppression = this.suppressionList.get(lowercaseEmail);
+        if (!suppression) {
+            return false;
+        }
+        // Check if suppression has expired
+        if (suppression.expiresAt && Date.now() > suppression.expiresAt) {
+            this.suppressionList.delete(lowercaseEmail);
+            // Save asynchronously without blocking
+            this.saveSuppressionList().catch(error => {
+                logger.log('error', `Failed to save suppression list after expiry cleanup: ${error.message}`);
+            });
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Get suppression information for an email
+     * @param email Email address to check
+     * @returns Suppression information or null if not suppressed
+     */
+    getSuppressionInfo(email) {
+        const lowercaseEmail = email.toLowerCase();
+        const suppression = this.suppressionList.get(lowercaseEmail);
+        if (!suppression) {
+            return null;
+        }
+        // Check if suppression has expired
+        if (suppression.expiresAt && Date.now() > suppression.expiresAt) {
+            this.suppressionList.delete(lowercaseEmail);
+            // Save asynchronously without blocking
+            this.saveSuppressionList().catch(error => {
+                logger.log('error', `Failed to save suppression list after expiry cleanup: ${error.message}`);
+            });
+            return null;
+        }
+        return suppression;
+    }
+    /**
+     * Save suppression list to disk
+     */
+    async saveSuppressionList() {
+        try {
+            const suppressionData = JSON.stringify(Array.from(this.suppressionList.entries()));
+            if (this.storageManager) {
+                // Use storage manager
+                await this.storageManager.set('/email/bounces/suppression-list.json', suppressionData);
+            }
+            else {
+                // Fall back to filesystem
+                plugins.smartfile.memory.toFsSync(suppressionData, plugins.path.join(paths.dataDir, 'emails', 'suppression_list.json'));
+            }
+        }
+        catch (error) {
+            logger.log('error', `Failed to save suppression list: ${error.message}`);
+        }
+    }
+    /**
+     * Load suppression list from disk
+     */
+    async loadSuppressionList() {
+        try {
+            let entries = null;
+            let needsMigration = false;
+            if (this.storageManager) {
+                // Try to load from storage manager first
+                const suppressionData = await this.storageManager.get('/email/bounces/suppression-list.json');
+                if (suppressionData) {
+                    entries = JSON.parse(suppressionData);
+                }
+                else {
+                    // Check if data exists in filesystem and migrate
+                    const suppressionPath = plugins.path.join(paths.dataDir, 'emails', 'suppression_list.json');
+                    if (plugins.fs.existsSync(suppressionPath)) {
+                        const data = plugins.fs.readFileSync(suppressionPath, 'utf8');
+                        entries = JSON.parse(data);
+                        needsMigration = true;
+                        logger.log('info', 'Migrating suppression list from filesystem to StorageManager');
+                    }
+                }
+            }
+            else {
+                // No storage manager, use filesystem directly
+                const suppressionPath = plugins.path.join(paths.dataDir, 'emails', 'suppression_list.json');
+                if (plugins.fs.existsSync(suppressionPath)) {
+                    const data = plugins.fs.readFileSync(suppressionPath, 'utf8');
+                    entries = JSON.parse(data);
+                }
+            }
+            if (entries) {
+                this.suppressionList = new Map(entries);
+                // Clean expired entries
+                const now = Date.now();
+                let expiredCount = 0;
+                for (const [email, info] of this.suppressionList.entries()) {
+                    if (info.expiresAt && now > info.expiresAt) {
+                        this.suppressionList.delete(email);
+                        expiredCount++;
+                    }
+                }
+                if (expiredCount > 0 || needsMigration) {
+                    logger.log('info', `Cleaned ${expiredCount} expired entries from suppression list`);
+                    await this.saveSuppressionList();
+                }
+                logger.log('info', `Loaded ${this.suppressionList.size} entries from suppression list`);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Failed to load suppression list: ${error.message}`);
+        }
+    }
+    /**
+     * Save bounce record to disk
+     * @param bounce Bounce record to save
+     */
+    async saveBounceRecord(bounce) {
+        try {
+            const bounceData = JSON.stringify(bounce, null, 2);
+            if (this.storageManager) {
+                // Use storage manager
+                await this.storageManager.set(`/email/bounces/records/${bounce.id}.json`, bounceData);
+            }
+            else {
+                // Fall back to filesystem
+                const bouncePath = plugins.path.join(paths.dataDir, 'emails', 'bounces', `${bounce.id}.json`);
+                // Ensure directory exists
+                const bounceDir = plugins.path.join(paths.dataDir, 'emails', 'bounces');
+                plugins.smartfile.fs.ensureDirSync(bounceDir);
+                plugins.smartfile.memory.toFsSync(bounceData, bouncePath);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Failed to save bounce record: ${error.message}`);
+        }
+    }
+    /**
+     * Update bounce cache with new bounce information
+     * @param bounce Bounce record to update cache with
+     */
+    updateBounceCache(bounce) {
+        const email = bounce.recipient.toLowerCase();
+        const existing = this.bounceCache.get(email);
+        if (existing) {
+            // Update existing cache entry
+            existing.lastBounce = bounce.timestamp;
+            existing.count++;
+            existing.type = bounce.bounceType;
+            existing.category = bounce.bounceCategory;
+        }
+        else {
+            // Create new cache entry
+            this.bounceCache.set(email, {
+                lastBounce: bounce.timestamp,
+                count: 1,
+                type: bounce.bounceType,
+                category: bounce.bounceCategory
+            });
+        }
+    }
+    /**
+     * Check bounce history for an email address
+     * @param email Email address to check
+     * @returns Bounce information or null if no bounces
+     */
+    getBounceInfo(email) {
+        return this.bounceCache.get(email.toLowerCase()) || null;
+    }
+    /**
+     * Analyze SMTP response and diagnostic codes to determine bounce type
+     * @param smtpResponse SMTP response string
+     * @param diagnosticCode Diagnostic code from bounce
+     * @param statusCode Status code from bounce
+     * @returns Detected bounce type and category
+     */
+    detectBounceType(smtpResponse, diagnosticCode, statusCode) {
+        // Combine all text for comprehensive pattern matching
+        const fullText = `${smtpResponse} ${diagnosticCode} ${statusCode}`.toLowerCase();
+        // Check for auto-responses first
+        if (this.matchesPattern(fullText, BounceType.AUTO_RESPONSE) ||
+            this.matchesPattern(fullText, BounceType.CHALLENGE_RESPONSE)) {
+            return {
+                type: BounceType.AUTO_RESPONSE,
+                category: BounceCategory.AUTO_RESPONSE
+            };
+        }
+        // Check for hard bounces
+        for (const bounceType of [
+            BounceType.INVALID_RECIPIENT,
+            BounceType.DOMAIN_NOT_FOUND,
+            BounceType.MAILBOX_FULL,
+            BounceType.MAILBOX_INACTIVE,
+            BounceType.BLOCKED,
+            BounceType.SPAM_RELATED,
+            BounceType.POLICY_RELATED
+        ]) {
+            if (this.matchesPattern(fullText, bounceType)) {
+                return {
+                    type: bounceType,
+                    category: BounceCategory.HARD
+                };
+            }
+        }
+        // Check for soft bounces
+        for (const bounceType of [
+            BounceType.SERVER_UNAVAILABLE,
+            BounceType.TEMPORARY_FAILURE,
+            BounceType.QUOTA_EXCEEDED,
+            BounceType.NETWORK_ERROR,
+            BounceType.TIMEOUT
+        ]) {
+            if (this.matchesPattern(fullText, bounceType)) {
+                return {
+                    type: bounceType,
+                    category: BounceCategory.SOFT
+                };
+            }
+        }
+        // Handle DSN (Delivery Status Notification) status codes
+        if (statusCode) {
+            // Format: class.subject.detail
+            const parts = statusCode.split('.');
+            if (parts.length >= 2) {
+                const statusClass = parts[0];
+                const statusSubject = parts[1];
+                // 5.X.X is permanent failure (hard bounce)
+                if (statusClass === '5') {
+                    // Try to determine specific type based on subject
+                    if (statusSubject === '1') {
+                        return { type: BounceType.INVALID_RECIPIENT, category: BounceCategory.HARD };
+                    }
+                    else if (statusSubject === '2') {
+                        return { type: BounceType.MAILBOX_FULL, category: BounceCategory.HARD };
+                    }
+                    else if (statusSubject === '7') {
+                        return { type: BounceType.BLOCKED, category: BounceCategory.HARD };
+                    }
+                    else {
+                        return { type: BounceType.UNKNOWN, category: BounceCategory.HARD };
+                    }
+                }
+                // 4.X.X is temporary failure (soft bounce)
+                if (statusClass === '4') {
+                    // Try to determine specific type based on subject
+                    if (statusSubject === '2') {
+                        return { type: BounceType.QUOTA_EXCEEDED, category: BounceCategory.SOFT };
+                    }
+                    else if (statusSubject === '3') {
+                        return { type: BounceType.SERVER_UNAVAILABLE, category: BounceCategory.SOFT };
+                    }
+                    else if (statusSubject === '4') {
+                        return { type: BounceType.NETWORK_ERROR, category: BounceCategory.SOFT };
+                    }
+                    else {
+                        return { type: BounceType.TEMPORARY_FAILURE, category: BounceCategory.SOFT };
+                    }
+                }
+            }
+        }
+        // Default to unknown
+        return {
+            type: BounceType.UNKNOWN,
+            category: BounceCategory.UNKNOWN
+        };
+    }
+    /**
+     * Check if text matches any pattern for a bounce type
+     * @param text Text to check against patterns
+     * @param bounceType Bounce type to get patterns for
+     * @returns Whether the text matches any pattern
+     */
+    matchesPattern(text, bounceType) {
+        const patterns = BOUNCE_PATTERNS[bounceType];
+        if (!patterns) {
+            return false;
+        }
+        for (const pattern of patterns) {
+            if (pattern.test(text)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Get all known hard bounced addresses
+     * @returns Array of hard bounced email addresses
+     */
+    getHardBouncedAddresses() {
+        const hardBounced = [];
+        for (const [email, info] of this.bounceCache.entries()) {
+            if (info.category === BounceCategory.HARD) {
+                hardBounced.push(email);
+            }
+        }
+        return hardBounced;
+    }
+    /**
+     * Get suppression list
+     * @returns Array of suppressed email addresses
+     */
+    getSuppressionList() {
+        return Array.from(this.suppressionList.keys());
+    }
+    /**
+     * Clear old bounce records (for maintenance)
+     * @param olderThan Timestamp to remove records older than
+     * @returns Number of records removed
+     */
+    clearOldBounceRecords(olderThan) {
+        let removed = 0;
+        this.bounceStore = this.bounceStore.filter(bounce => {
+            if (bounce.timestamp < olderThan) {
+                removed++;
+                return false;
+            }
+            return true;
+        });
+        return removed;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.bouncemanager.js","sourceRoot":"","sources":["../../../ts/mail/core/classes.bouncemanager.ts"],"names":[],"mappings":"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"}