@push.rocks/smartmta 5.1.3 → 5.2.1

package/dist_ts/mail/delivery/classes.delivery.system.js

@@ -0,0 +1,630 @@
+import * as plugins from '../../plugins.js';
+import { EventEmitter } from 'node:events';
+import { logger } from '../../logger.js';
+import { SecurityLogger, SecurityLogLevel, SecurityEventType } from '../../security/index.js';
+import { UnifiedDeliveryQueue } from './classes.delivery.queue.js';
+import { Email } from '../core/classes.email.js';
+import { RustSecurityBridge } from '../../security/classes.rustsecuritybridge.js';
+const dns = plugins.dns;
+/**
+ * Delivery status enumeration
+ */
+export var DeliveryStatus;
+(function (DeliveryStatus) {
+    DeliveryStatus["PENDING"] = "pending";
+    DeliveryStatus["DELIVERING"] = "delivering";
+    DeliveryStatus["DELIVERED"] = "delivered";
+    DeliveryStatus["DEFERRED"] = "deferred";
+    DeliveryStatus["FAILED"] = "failed";
+})(DeliveryStatus || (DeliveryStatus = {}));
+/**
+ * Handles delivery for all email processing modes
+ */
+export class MultiModeDeliverySystem extends EventEmitter {
+    queue;
+    options;
+    stats;
+    deliveryTimes = [];
+    activeDeliveries = new Set();
+    running = false;
+    throttled = false;
+    rateLimitLastCheck = Date.now();
+    rateLimitCounter = 0;
+    emailServer;
+    /**
+     * Create a new multi-mode delivery system
+     * @param queue Unified delivery queue
+     * @param options Delivery options
+     * @param emailServer Optional reference to unified email server for outbound delivery
+     */
+    constructor(queue, options, emailServer) {
+        super();
+        this.queue = queue;
+        this.emailServer = emailServer;
+        // Set default options
+        this.options = {
+            connectionPoolSize: options.connectionPoolSize || 10,
+            socketTimeout: options.socketTimeout || 30000, // 30 seconds
+            concurrentDeliveries: options.concurrentDeliveries || 10,
+            sendTimeout: options.sendTimeout || 60000, // 1 minute
+            verifyCertificates: options.verifyCertificates !== false, // Default to true
+            tlsMinVersion: options.tlsMinVersion || 'TLSv1.2',
+            forwardHandler: options.forwardHandler || {
+                deliver: this.handleForwardDelivery.bind(this)
+            },
+            deliveryHandler: options.deliveryHandler || {
+                deliver: this.handleMtaDelivery.bind(this)
+            },
+            processHandler: options.processHandler || {
+                deliver: this.handleProcessDelivery.bind(this)
+            },
+            globalRateLimit: options.globalRateLimit || 100, // 100 emails per minute
+            perPatternRateLimit: options.perPatternRateLimit || {},
+            processBounces: options.processBounces !== false, // Default to true
+            bounceHandler: options.bounceHandler || null,
+            onDeliveryStart: options.onDeliveryStart || (async () => { }),
+            onDeliverySuccess: options.onDeliverySuccess || (async () => { }),
+            onDeliveryFailed: options.onDeliveryFailed || (async () => { })
+        };
+        // Initialize statistics
+        this.stats = {
+            activeDeliveries: 0,
+            totalSuccessful: 0,
+            totalFailed: 0,
+            avgDeliveryTime: 0,
+            byMode: {
+                forward: {
+                    successful: 0,
+                    failed: 0
+                },
+                mta: {
+                    successful: 0,
+                    failed: 0
+                },
+                process: {
+                    successful: 0,
+                    failed: 0
+                }
+            },
+            rateLimiting: {
+                currentRate: 0,
+                globalLimit: this.options.globalRateLimit,
+                throttled: 0
+            }
+        };
+        // Set up event listeners
+        this.queue.on('itemsReady', this.processItems.bind(this));
+    }
+    /**
+     * Start the delivery system
+     */
+    async start() {
+        logger.log('info', 'Starting MultiModeDeliverySystem');
+        if (this.running) {
+            logger.log('warn', 'MultiModeDeliverySystem is already running');
+            return;
+        }
+        this.running = true;
+        // Emit started event
+        this.emit('started');
+        logger.log('info', 'MultiModeDeliverySystem started successfully');
+    }
+    /**
+     * Stop the delivery system
+     */
+    async stop() {
+        logger.log('info', 'Stopping MultiModeDeliverySystem');
+        if (!this.running) {
+            logger.log('warn', 'MultiModeDeliverySystem is already stopped');
+            return;
+        }
+        this.running = false;
+        // Wait for active deliveries to complete
+        if (this.activeDeliveries.size > 0) {
+            logger.log('info', `Waiting for ${this.activeDeliveries.size} active deliveries to complete`);
+            // Wait for a maximum of 30 seconds
+            await new Promise(resolve => {
+                const checkInterval = setInterval(() => {
+                    if (this.activeDeliveries.size === 0) {
+                        clearInterval(checkInterval);
+                        clearTimeout(forceTimeout);
+                        resolve();
+                    }
+                }, 1000);
+                // Force resolve after 30 seconds
+                const forceTimeout = setTimeout(() => {
+                    clearInterval(checkInterval);
+                    resolve();
+                }, 30000);
+            });
+        }
+        // Emit stopped event
+        this.emit('stopped');
+        logger.log('info', 'MultiModeDeliverySystem stopped successfully');
+    }
+    /**
+     * Process ready items from the queue
+     * @param items Queue items ready for processing
+     */
+    async processItems(items) {
+        if (!this.running) {
+            return;
+        }
+        // Check if we're already at max concurrent deliveries
+        if (this.activeDeliveries.size >= this.options.concurrentDeliveries) {
+            logger.log('debug', `Already at max concurrent deliveries (${this.activeDeliveries.size})`);
+            return;
+        }
+        // Check rate limiting
+        if (this.checkRateLimit()) {
+            logger.log('debug', 'Rate limit exceeded, throttling deliveries');
+            return;
+        }
+        // Calculate how many more deliveries we can start
+        const availableSlots = this.options.concurrentDeliveries - this.activeDeliveries.size;
+        const itemsToProcess = items.slice(0, availableSlots);
+        if (itemsToProcess.length === 0) {
+            return;
+        }
+        logger.log('info', `Processing ${itemsToProcess.length} items for delivery`);
+        // Process each item
+        for (const item of itemsToProcess) {
+            // Mark as processing
+            await this.queue.markProcessing(item.id);
+            // Add to active deliveries
+            this.activeDeliveries.add(item.id);
+            this.stats.activeDeliveries = this.activeDeliveries.size;
+            // Deliver asynchronously
+            this.deliverItem(item).catch(err => {
+                logger.log('error', `Unhandled error in delivery: ${err.message}`);
+            });
+        }
+        // Update statistics
+        this.emit('statsUpdated', this.stats);
+    }
+    /**
+     * Deliver an item from the queue
+     * @param item Queue item to deliver
+     */
+    async deliverItem(item) {
+        const startTime = Date.now();
+        try {
+            // Call delivery start hook
+            await this.options.onDeliveryStart(item);
+            // Emit delivery start event
+            this.emit('deliveryStart', item);
+            logger.log('info', `Starting delivery of item ${item.id}, mode: ${item.processingMode}`);
+            // Choose the appropriate handler based on mode
+            let result;
+            switch (item.processingMode) {
+                case 'forward':
+                    result = await this.options.forwardHandler.deliver(item);
+                    break;
+                case 'mta':
+                    result = await this.options.deliveryHandler.deliver(item);
+                    break;
+                case 'process':
+                    result = await this.options.processHandler.deliver(item);
+                    break;
+                default:
+                    throw new Error(`Unknown processing mode: ${item.processingMode}`);
+            }
+            // Mark as delivered
+            await this.queue.markDelivered(item.id);
+            // Update statistics
+            this.stats.totalSuccessful++;
+            this.stats.byMode[item.processingMode].successful++;
+            // Calculate delivery time
+            const deliveryTime = Date.now() - startTime;
+            this.deliveryTimes.push(deliveryTime);
+            this.updateDeliveryTimeStats();
+            // Call delivery success hook
+            await this.options.onDeliverySuccess(item, result);
+            // Emit delivery success event
+            this.emit('deliverySuccess', item, result);
+            logger.log('info', `Item ${item.id} delivered successfully in ${deliveryTime}ms`);
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.INFO,
+                type: SecurityEventType.EMAIL_DELIVERY,
+                message: 'Email delivery successful',
+                details: {
+                    itemId: item.id,
+                    mode: item.processingMode,
+                    routeName: item.route?.name || 'unknown',
+                    deliveryTime
+                },
+                success: true
+            });
+        }
+        catch (error) {
+            // Calculate delivery attempt time even for failures
+            const deliveryTime = Date.now() - startTime;
+            // Mark as failed
+            await this.queue.markFailed(item.id, error.message);
+            // Update statistics
+            this.stats.totalFailed++;
+            this.stats.byMode[item.processingMode].failed++;
+            // Call delivery failed hook
+            await this.options.onDeliveryFailed(item, error.message);
+            // Process as bounce if enabled and we have a bounce handler
+            if (this.options.processBounces && this.options.bounceHandler) {
+                try {
+                    const email = item.processingResult;
+                    // Extract recipient and error message
+                    // For multiple recipients, we'd need more sophisticated parsing
+                    const recipient = email.to.length > 0 ? email.to[0] : '';
+                    if (recipient) {
+                        logger.log('info', `Processing delivery failure as bounce for recipient ${recipient}`);
+                        // Process SMTP failure through bounce handler
+                        await this.options.bounceHandler.processSmtpFailure(recipient, error.message, {
+                            sender: email.from,
+                            originalEmailId: item.id,
+                            headers: email.headers
+                        });
+                        logger.log('info', `Bounce record created for failed delivery to ${recipient}`);
+                    }
+                }
+                catch (bounceError) {
+                    logger.log('error', `Failed to process bounce: ${bounceError.message}`);
+                }
+            }
+            // Emit delivery failed event
+            this.emit('deliveryFailed', item, error);
+            logger.log('error', `Item ${item.id} delivery failed: ${error.message}`);
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.ERROR,
+                type: SecurityEventType.EMAIL_DELIVERY,
+                message: 'Email delivery failed',
+                details: {
+                    itemId: item.id,
+                    mode: item.processingMode,
+                    routeName: item.route?.name || 'unknown',
+                    error: error.message,
+                    deliveryTime
+                },
+                success: false
+            });
+        }
+        finally {
+            // Remove from active deliveries
+            this.activeDeliveries.delete(item.id);
+            this.stats.activeDeliveries = this.activeDeliveries.size;
+            // Update statistics
+            this.emit('statsUpdated', this.stats);
+        }
+    }
+    /**
+     * Default handler for forward mode delivery
+     * @param item Queue item
+     */
+    async handleForwardDelivery(item) {
+        logger.log('info', `Forward delivery for item ${item.id}`);
+        const email = item.processingResult;
+        const route = item.route;
+        // Get target server information
+        const targetServer = route?.action.forward?.host;
+        const targetPort = route?.action.forward?.port || 25;
+        if (!targetServer) {
+            throw new Error('No target server configured for forward mode');
+        }
+        logger.log('info', `Forwarding email to ${targetServer}:${targetPort}`);
+        try {
+            if (!this.emailServer) {
+                throw new Error('No email server available for forward delivery');
+            }
+            // Build DKIM options from route config
+            const dkimDomain = item.route?.action.options?.mtaOptions?.dkimSign
+                ? (item.route.action.options.mtaOptions.dkimOptions?.domainName || email.from.split('@')[1])
+                : undefined;
+            const dkimSelector = item.route?.action.options?.mtaOptions?.dkimOptions?.keySelector || 'default';
+            // Build auth options from route forward config
+            const auth = route?.action.forward?.auth;
+            // Send via Rust SMTP client
+            const result = await this.emailServer.sendOutboundEmail(targetServer, targetPort, email, {
+                auth,
+                dkimDomain,
+                dkimSelector,
+            });
+            logger.log('info', `Email forwarded successfully to ${targetServer}:${targetPort}`);
+            return {
+                targetServer,
+                targetPort,
+                recipients: result.accepted.length,
+                messageId: result.messageId,
+                rejectedRecipients: result.rejected,
+            };
+        }
+        catch (error) {
+            logger.log('error', `Failed to forward email: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Resolve MX records for a domain, sorted by priority (lowest first).
+     * Falls back to the domain itself as an A record per RFC 5321.
+     */
+    async resolveMxForDomain(domain) {
+        const resolver = new dns.promises.Resolver();
+        try {
+            const mxRecords = await resolver.resolveMx(domain);
+            return mxRecords.sort((a, b) => a.priority - b.priority);
+        }
+        catch (err) {
+            logger.log('warn', `No MX records for ${domain}, falling back to A record`);
+            return [{ exchange: domain, priority: 0 }];
+        }
+    }
+    /**
+     * Group recipient addresses by their domain part.
+     */
+    groupRecipientsByDomain(recipients) {
+        const groups = new Map();
+        for (const rcpt of recipients) {
+            const domain = rcpt.split('@')[1]?.toLowerCase();
+            if (!domain)
+                continue;
+            const list = groups.get(domain) || [];
+            list.push(rcpt);
+            groups.set(domain, list);
+        }
+        return groups;
+    }
+    /**
+     * Default handler for MTA mode delivery
+     * @param item Queue item
+     */
+    async handleMtaDelivery(item) {
+        logger.log('info', `MTA delivery for item ${item.id}`);
+        const email = item.processingResult;
+        if (!this.emailServer) {
+            throw new Error('No email server available for MTA delivery');
+        }
+        // Build DKIM options from route config
+        const dkimDomain = item.route?.action.options?.mtaOptions?.dkimSign
+            ? (item.route.action.options.mtaOptions.dkimOptions?.domainName || email.from.split('@')[1])
+            : undefined;
+        const dkimSelector = item.route?.action.options?.mtaOptions?.dkimOptions?.keySelector || 'default';
+        const allRecipients = email.getAllRecipients();
+        if (allRecipients.length === 0) {
+            throw new Error('No recipients specified for MTA delivery');
+        }
+        const domainGroups = this.groupRecipientsByDomain(allRecipients);
+        const results = [];
+        for (const [domain, recipients] of domainGroups) {
+            const mxHosts = await this.resolveMxForDomain(domain);
+            let delivered = false;
+            let lastError;
+            for (const mx of mxHosts) {
+                try {
+                    logger.log('info', `MTA: trying MX ${mx.exchange}:25 for domain ${domain} (priority ${mx.priority})`);
+                    // Create a temporary Email scoped to this domain's recipients
+                    const domainEmail = new Email({
+                        from: email.from,
+                        to: recipients.filter(r => email.to.includes(r)),
+                        cc: recipients.filter(r => (email.cc || []).includes(r)),
+                        bcc: recipients.filter(r => (email.bcc || []).includes(r)),
+                        subject: email.subject,
+                        text: email.text,
+                        html: email.html,
+                    });
+                    const result = await this.emailServer.sendOutboundEmail(mx.exchange, 25, domainEmail, {
+                        dkimDomain,
+                        dkimSelector,
+                    });
+                    results.push({
+                        domain,
+                        success: true,
+                        accepted: result.accepted,
+                        rejected: result.rejected,
+                    });
+                    delivered = true;
+                    logger.log('info', `MTA: delivered to ${domain} via ${mx.exchange}`);
+                    break;
+                }
+                catch (err) {
+                    lastError = err.message;
+                    logger.log('warn', `MTA: MX ${mx.exchange} failed for ${domain}: ${err.message}`);
+                }
+            }
+            if (!delivered) {
+                results.push({ domain, success: false, error: lastError });
+                logger.log('error', `MTA: all MX hosts failed for ${domain}`);
+            }
+        }
+        const allFailed = results.every(r => !r.success);
+        if (allFailed) {
+            const summary = results.map(r => `${r.domain}: ${r.error}`).join('; ');
+            throw new Error(`MTA delivery failed for all domains: ${summary}`);
+        }
+        return {
+            recipients: allRecipients.length,
+            domainResults: results,
+        };
+    }
+    /**
+     * Default handler for process mode delivery
+     * @param item Queue item
+     */
+    async handleProcessDelivery(item) {
+        logger.log('info', `Process delivery for item ${item.id}`);
+        const email = item.processingResult;
+        const route = item.route;
+        try {
+            // Apply content scanning if enabled
+            if (route?.action.options?.contentScanning && route?.action.options?.scanners && route.action.options.scanners.length > 0) {
+                logger.log('info', 'Performing content scanning');
+                // Apply each scanner
+                for (const scanner of route.action.options.scanners) {
+                    switch (scanner.type) {
+                        case 'spam':
+                            logger.log('info', 'Scanning for spam content');
+                            // Implement spam scanning
+                            break;
+                        case 'virus':
+                            logger.log('info', 'Scanning for virus content');
+                            // Implement virus scanning
+                            break;
+                        case 'attachment':
+                            logger.log('info', 'Scanning attachments');
+                            // Check for blocked extensions
+                            if (scanner.blockedExtensions && scanner.blockedExtensions.length > 0) {
+                                for (const attachment of email.attachments) {
+                                    const ext = this.getFileExtension(attachment.filename);
+                                    if (scanner.blockedExtensions.includes(ext)) {
+                                        if (scanner.action === 'reject') {
+                                            throw new Error(`Blocked attachment type: ${ext}`);
+                                        }
+                                        else { // tag
+                                            email.addHeader('X-Attachment-Warning', `Potentially unsafe attachment: ${attachment.filename}`);
+                                        }
+                                    }
+                                }
+                            }
+                            break;
+                    }
+                }
+            }
+            // Apply transformations if defined
+            if (route?.action.options?.transformations && route?.action.options?.transformations.length > 0) {
+                logger.log('info', 'Applying email transformations');
+                for (const transform of route.action.options.transformations) {
+                    switch (transform.type) {
+                        case 'addHeader':
+                            if (transform.header && transform.value) {
+                                email.addHeader(transform.header, transform.value);
+                            }
+                            break;
+                    }
+                }
+            }
+            // Apply DKIM signing if configured (after all transformations)
+            if (item.route?.action.options?.mtaOptions?.dkimSign || item.route?.action.process?.dkim) {
+                await this.applyDkimSigning(email, item.route.action.options?.mtaOptions || {});
+            }
+            logger.log('info', `Email successfully processed in store-and-forward mode, delivering via MTA`);
+            // After scanning + transformations, deliver via MTA
+            return await this.handleMtaDelivery(item);
+        }
+        catch (error) {
+            logger.log('error', `Failed to process email: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Get file extension from filename
+     */
+    getFileExtension(filename) {
+        return filename.substring(filename.lastIndexOf('.')).toLowerCase();
+    }
+    /**
+     * Apply DKIM signing to an email
+     */
+    async applyDkimSigning(email, mtaOptions) {
+        if (!this.emailServer) {
+            logger.log('warn', 'Cannot apply DKIM signing without email server reference');
+            return;
+        }
+        const domainName = mtaOptions.dkimOptions?.domainName || email.from.split('@')[1];
+        const keySelector = mtaOptions.dkimOptions?.keySelector || 'default';
+        try {
+            // Ensure DKIM keys exist for the domain
+            await this.emailServer.dkimCreator.handleDKIMKeysForDomain(domainName);
+            // Get the private key
+            const dkimPrivateKey = (await this.emailServer.dkimCreator.readDKIMKeys(domainName)).privateKey;
+            // Convert Email to raw format for signing
+            const rawEmail = email.toRFC822String();
+            // Sign via Rust bridge
+            const bridge = RustSecurityBridge.getInstance();
+            const signResult = await bridge.signDkim({
+                rawMessage: rawEmail,
+                domain: domainName,
+                selector: keySelector,
+                privateKey: dkimPrivateKey,
+            });
+            if (signResult.header) {
+                email.addHeader('DKIM-Signature', signResult.header);
+                logger.log('info', `Successfully added DKIM signature for ${domainName}`);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Failed to apply DKIM signature: ${error.message}`);
+            // Don't throw - allow email to be sent without DKIM if signing fails
+        }
+    }
+    /**
+     * Update delivery time statistics
+     */
+    updateDeliveryTimeStats() {
+        if (this.deliveryTimes.length === 0)
+            return;
+        // Keep only the last 1000 delivery times
+        if (this.deliveryTimes.length > 1000) {
+            this.deliveryTimes = this.deliveryTimes.slice(-1000);
+        }
+        // Calculate average
+        const sum = this.deliveryTimes.reduce((acc, time) => acc + time, 0);
+        this.stats.avgDeliveryTime = sum / this.deliveryTimes.length;
+    }
+    /**
+     * Check if rate limit is exceeded
+     * @returns True if rate limited, false otherwise
+     */
+    checkRateLimit() {
+        const now = Date.now();
+        const elapsed = now - this.rateLimitLastCheck;
+        // Reset counter if more than a minute has passed
+        if (elapsed >= 60000) {
+            this.rateLimitLastCheck = now;
+            this.rateLimitCounter = 0;
+            this.throttled = false;
+            this.stats.rateLimiting.currentRate = 0;
+            return false;
+        }
+        // Check if we're already throttled
+        if (this.throttled) {
+            return true;
+        }
+        // Increment counter
+        this.rateLimitCounter++;
+        // Calculate current rate (emails per minute)
+        const rate = (this.rateLimitCounter / elapsed) * 60000;
+        this.stats.rateLimiting.currentRate = rate;
+        // Check if rate limit is exceeded
+        if (rate > this.options.globalRateLimit) {
+            this.throttled = true;
+            this.stats.rateLimiting.throttled++;
+            // Schedule throttle reset
+            const resetDelay = 60000 - elapsed;
+            setTimeout(() => {
+                this.throttled = false;
+                this.rateLimitLastCheck = Date.now();
+                this.rateLimitCounter = 0;
+                this.stats.rateLimiting.currentRate = 0;
+            }, resetDelay);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Update delivery options
+     * @param options New options
+     */
+    updateOptions(options) {
+        this.options = {
+            ...this.options,
+            ...options
+        };
+        // Update rate limit statistics
+        if (options.globalRateLimit) {
+            this.stats.rateLimiting.globalLimit = options.globalRateLimit;
+        }
+        logger.log('info', 'MultiModeDeliverySystem options updated');
+    }
+    /**
+     * Get delivery statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.delivery.system.js","sourceRoot":"","sources":["../../../ts/mail/delivery/classes.delivery.system.ts"],"names":[],"mappings":"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"}