@push.rocks/smartmta 5.1.3 → 5.2.0

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

@@ -0,0 +1,569 @@
+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 { RustSecurityBridge } from '../../security/classes.rustsecuritybridge.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 = {}));
+/**
+ * Manager for handling email bounces
+ */
+export class BounceManager {
+    // Retry strategy with exponential backoff
+    retryStrategy = {
+        maxRetries: 5,
+        initialDelay: 15 * 60 * 1000, // 15 minutes
+        maxDelay: 24 * 60 * 60 * 1000, // 24 hours
+        backoffFactor: 2
+    };
+    // Store of bounced emails
+    bounceStore = [];
+    // Cache of recently bounced email addresses to avoid sending to known bad addresses
+    bounceCache;
+    // Suppression list for addresses that should not receive emails
+    suppressionList = new Map();
+    storageManager; // StorageManager instance
+    constructor(options) {
+        // 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 via Rust bridge if not provided
+            if (!bounceData.bounceType || bounceData.bounceType === BounceType.UNKNOWN) {
+                const bridge = RustSecurityBridge.getInstance();
+                const rustResult = await bridge.detectBounce({
+                    smtpResponse: bounce.smtpResponse,
+                    diagnosticCode: bounce.diagnosticCode,
+                    statusCode: bounce.statusCode,
+                });
+                bounce.bounceType = rustResult.bounce_type;
+                bounce.bounceCategory = rustResult.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
+                await plugins.smartfs.file(plugins.path.join(paths.dataDir, 'emails', 'suppression_list.json')).write(suppressionData);
+            }
+        }
+        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');
+                await plugins.smartfs.directory(bounceDir).recursive().create();
+                await plugins.smartfs.file(bouncePath).write(bounceData);
+            }
+        }
+        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;
+    }
+    /**
+     * 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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"}