@serve.zone/dcrouter 2.12.4

package/dist_ts/mail/routing/classes.unified.email.server.js

@@ -0,0 +1,1454 @@
+import * as plugins from '../../plugins.js';
+import * as paths from '../../paths.js';
+import { EventEmitter } from 'events';
+import { logger } from '../../logger.js';
+import { SecurityLogger, SecurityLogLevel, SecurityEventType } from '../../security/index.js';
+import { DKIMCreator } from '../security/classes.dkimcreator.js';
+import { IPReputationChecker } from '../../security/classes.ipreputationchecker.js';
+import { IPWarmupManager, SenderReputationMonitor } from '../../deliverability/index.js';
+import { EmailRouter } from './classes.email.router.js';
+import { Email } from '../core/classes.email.js';
+import { DomainRegistry } from './classes.domain.registry.js';
+import { DnsManager } from './classes.dns.manager.js';
+import { BounceManager, BounceType, BounceCategory } from '../core/classes.bouncemanager.js';
+import { createSmtpServer } from '../delivery/smtpserver/index.js';
+import { createPooledSmtpClient } from '../delivery/smtpclient/create-client.js';
+import { MultiModeDeliverySystem } from '../delivery/classes.delivery.system.js';
+import { UnifiedDeliveryQueue } from '../delivery/classes.delivery.queue.js';
+import { UnifiedRateLimiter } from '../delivery/classes.unified.rate.limiter.js';
+import { SmtpState } from '../delivery/interfaces.js';
+/**
+ * Unified email server that handles all email traffic with pattern-based routing
+ */
+export class UnifiedEmailServer extends EventEmitter {
+    constructor(dcRouter, options) {
+        super();
+        this.servers = [];
+        this.dkimKeys = new Map(); // domain -> private key
+        this.smtpClients = new Map(); // host:port -> client
+        this.dcRouter = dcRouter;
+        // Set default options
+        this.options = {
+            ...options,
+            banner: options.banner || `${options.hostname} ESMTP UnifiedEmailServer`,
+            maxMessageSize: options.maxMessageSize || 10 * 1024 * 1024, // 10MB
+            maxClients: options.maxClients || 100,
+            maxConnections: options.maxConnections || 1000,
+            connectionTimeout: options.connectionTimeout || 60000, // 1 minute
+            socketTimeout: options.socketTimeout || 60000 // 1 minute
+        };
+        // Initialize DKIM creator with storage manager
+        this.dkimCreator = new DKIMCreator(paths.keysDir, dcRouter.storageManager);
+        // Initialize IP reputation checker with storage manager
+        this.ipReputationChecker = IPReputationChecker.getInstance({
+            enableLocalCache: true,
+            enableDNSBL: true,
+            enableIPInfo: true
+        }, dcRouter.storageManager);
+        // Initialize bounce manager with storage manager
+        this.bounceManager = new BounceManager({
+            maxCacheSize: 10000,
+            cacheTTL: 30 * 24 * 60 * 60 * 1000, // 30 days
+            storageManager: dcRouter.storageManager
+        });
+        // Initialize IP warmup manager
+        this.ipWarmupManager = IPWarmupManager.getInstance(options.ipWarmupConfig || {
+            enabled: true,
+            ipAddresses: [],
+            targetDomains: []
+        });
+        // Initialize sender reputation monitor with storage manager
+        this.senderReputationMonitor = SenderReputationMonitor.getInstance(options.reputationMonitorConfig || {
+            enabled: true,
+            domains: []
+        }, dcRouter.storageManager);
+        // Initialize domain registry
+        this.domainRegistry = new DomainRegistry(options.domains, options.defaults);
+        // Initialize email router with routes and storage manager
+        this.emailRouter = new EmailRouter(options.routes || [], {
+            storageManager: dcRouter.storageManager,
+            persistChanges: true
+        });
+        // Initialize rate limiter
+        this.rateLimiter = new UnifiedRateLimiter(options.rateLimits || {
+            global: {
+                maxConnectionsPerIP: 10,
+                maxMessagesPerMinute: 100,
+                maxRecipientsPerMessage: 50,
+                maxErrorsPerIP: 10,
+                maxAuthFailuresPerIP: 5,
+                blockDuration: 300000 // 5 minutes
+            }
+        });
+        // Initialize delivery components
+        const queueOptions = {
+            storageType: 'memory', // Default to memory storage
+            maxRetries: 3,
+            baseRetryDelay: 300000, // 5 minutes
+            maxRetryDelay: 3600000 // 1 hour
+        };
+        this.deliveryQueue = new UnifiedDeliveryQueue(queueOptions);
+        const deliveryOptions = {
+            globalRateLimit: 100, // Default to 100 emails per minute
+            concurrentDeliveries: 10,
+            processBounces: true,
+            bounceHandler: {
+                processSmtpFailure: this.processSmtpFailure.bind(this)
+            },
+            onDeliverySuccess: async (item, _result) => {
+                // Record delivery success event for reputation monitoring
+                const email = item.processingResult;
+                const senderDomain = email.from.split('@')[1];
+                if (senderDomain) {
+                    this.recordReputationEvent(senderDomain, {
+                        type: 'delivered',
+                        count: email.to.length
+                    });
+                }
+            }
+        };
+        this.deliverySystem = new MultiModeDeliverySystem(this.deliveryQueue, deliveryOptions, this);
+        // Initialize statistics
+        this.stats = {
+            startTime: new Date(),
+            connections: {
+                current: 0,
+                total: 0
+            },
+            messages: {
+                processed: 0,
+                delivered: 0,
+                failed: 0
+            },
+            processingTime: {
+                avg: 0,
+                max: 0,
+                min: 0
+            }
+        };
+        // We'll create the SMTP servers during the start() method
+    }
+    /**
+     * Get or create an SMTP client for the given host and port
+     * Uses connection pooling for efficiency
+     */
+    getSmtpClient(host, port = 25) {
+        const clientKey = `${host}:${port}`;
+        // Check if we already have a client for this destination
+        let client = this.smtpClients.get(clientKey);
+        if (!client) {
+            // Create a new pooled SMTP client
+            client = createPooledSmtpClient({
+                host,
+                port,
+                secure: port === 465,
+                connectionTimeout: this.options.outbound?.connectionTimeout || 30000,
+                socketTimeout: this.options.outbound?.socketTimeout || 120000,
+                maxConnections: this.options.outbound?.maxConnections || 10,
+                maxMessages: 1000, // Messages per connection before reconnect
+                pool: true,
+                debug: false
+            });
+            this.smtpClients.set(clientKey, client);
+            logger.log('info', `Created new SMTP client pool for ${clientKey}`);
+        }
+        return client;
+    }
+    /**
+     * Start the unified email server
+     */
+    async start() {
+        logger.log('info', `Starting UnifiedEmailServer on ports: ${this.options.ports.join(', ')}`);
+        try {
+            // Initialize the delivery queue
+            await this.deliveryQueue.initialize();
+            logger.log('info', 'Email delivery queue initialized');
+            // Start the delivery system
+            await this.deliverySystem.start();
+            logger.log('info', 'Email delivery system started');
+            // Set up DKIM for all domains
+            await this.setupDkimForDomains();
+            logger.log('info', 'DKIM configuration completed for all domains');
+            // Create DNS manager and ensure all DNS records are created
+            const dnsManager = new DnsManager(this.dcRouter);
+            await dnsManager.ensureDnsRecords(this.domainRegistry.getAllConfigs(), this.dkimCreator);
+            logger.log('info', 'DNS records ensured for all configured domains');
+            // Apply per-domain rate limits
+            this.applyDomainRateLimits();
+            logger.log('info', 'Per-domain rate limits configured');
+            // Check and rotate DKIM keys if needed
+            await this.checkAndRotateDkimKeys();
+            logger.log('info', 'DKIM key rotation check completed');
+            // Skip server creation in socket-handler mode
+            if (this.options.useSocketHandler) {
+                logger.log('info', 'UnifiedEmailServer started in socket-handler mode (no port listening)');
+                this.emit('started');
+                return;
+            }
+            // Ensure we have the necessary TLS options
+            const hasTlsConfig = this.options.tls?.keyPath && this.options.tls?.certPath;
+            // Prepare the certificate and key if available
+            let key;
+            let cert;
+            if (hasTlsConfig) {
+                try {
+                    key = plugins.fs.readFileSync(this.options.tls.keyPath, 'utf8');
+                    cert = plugins.fs.readFileSync(this.options.tls.certPath, 'utf8');
+                    logger.log('info', 'TLS certificates loaded successfully');
+                }
+                catch (error) {
+                    logger.log('warn', `Failed to load TLS certificates: ${error.message}`);
+                }
+            }
+            // Create a SMTP server for each port
+            for (const port of this.options.ports) {
+                // Create a reference object to hold the MTA service during setup
+                const mtaRef = {
+                    config: {
+                        smtp: {
+                            hostname: this.options.hostname
+                        },
+                        security: {
+                            checkIPReputation: false,
+                            verifyDkim: true,
+                            verifySpf: true,
+                            verifyDmarc: true
+                        }
+                    },
+                    // These will be implemented in the real integration:
+                    dkimVerifier: {
+                        verify: async () => ({ isValid: true, domain: '' })
+                    },
+                    spfVerifier: {
+                        verifyAndApply: async () => true
+                    },
+                    dmarcVerifier: {
+                        verify: async () => ({}),
+                        applyPolicy: () => true
+                    },
+                    processIncomingEmail: async (email) => {
+                        // Process email using the new route-based system
+                        await this.processEmailByMode(email, {
+                            id: 'session-' + Math.random().toString(36).substring(2),
+                            state: SmtpState.FINISHED,
+                            mailFrom: email.from,
+                            rcptTo: email.to,
+                            emailData: email.toRFC822String(), // Use the proper method to get the full email content
+                            useTLS: false,
+                            connectionEnded: true,
+                            remoteAddress: '127.0.0.1',
+                            clientHostname: '',
+                            secure: false,
+                            authenticated: false,
+                            envelope: {
+                                mailFrom: { address: email.from, args: {} },
+                                rcptTo: email.to.map(recipient => ({ address: recipient, args: {} }))
+                            }
+                        });
+                        return true;
+                    }
+                };
+                // Create server options
+                const serverOptions = {
+                    port,
+                    hostname: this.options.hostname,
+                    key,
+                    cert
+                };
+                // Create and start the SMTP server
+                const smtpServer = createSmtpServer(mtaRef, serverOptions);
+                this.servers.push(smtpServer);
+                // Start the server
+                await new Promise((resolve, reject) => {
+                    try {
+                        // Leave this empty for now, smtpServer.start() is handled by the SMTPServer class internally
+                        // The server is started when it's created
+                        logger.log('info', `UnifiedEmailServer listening on port ${port}`);
+                        // Event handlers are managed internally by the SmtpServer class
+                        // No need to access the private server property
+                        resolve();
+                    }
+                    catch (err) {
+                        if (err.code === 'EADDRINUSE') {
+                            logger.log('error', `Port ${port} is already in use`);
+                            reject(new Error(`Port ${port} is already in use`));
+                        }
+                        else {
+                            logger.log('error', `Error starting server on port ${port}: ${err.message}`);
+                            reject(err);
+                        }
+                    }
+                });
+            }
+            logger.log('info', 'UnifiedEmailServer started successfully');
+            this.emit('started');
+        }
+        catch (error) {
+            logger.log('error', `Failed to start UnifiedEmailServer: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Handle a socket from smartproxy in socket-handler mode
+     * @param socket The socket to handle
+     * @param port The port this connection is for (25, 587, 465)
+     */
+    async handleSocket(socket, port) {
+        if (!this.options.useSocketHandler) {
+            logger.log('error', 'handleSocket called but useSocketHandler is not enabled');
+            socket.destroy();
+            return;
+        }
+        logger.log('info', `Handling socket for port ${port}`);
+        // Create a temporary SMTP server instance for this connection
+        // We need a full server instance because the SMTP protocol handler needs all components
+        const smtpServerOptions = {
+            port,
+            hostname: this.options.hostname,
+            key: this.options.tls?.keyPath ? plugins.fs.readFileSync(this.options.tls.keyPath, 'utf8') : undefined,
+            cert: this.options.tls?.certPath ? plugins.fs.readFileSync(this.options.tls.certPath, 'utf8') : undefined
+        };
+        // Create the SMTP server instance
+        const smtpServer = createSmtpServer(this, smtpServerOptions);
+        // Get the connection manager from the server
+        const connectionManager = smtpServer.connectionManager;
+        if (!connectionManager) {
+            logger.log('error', 'Could not get connection manager from SMTP server');
+            socket.destroy();
+            return;
+        }
+        // Determine if this is a secure connection
+        // Port 465 uses implicit TLS, so the socket is already secure
+        const isSecure = port === 465 || socket instanceof plugins.tls.TLSSocket;
+        // Pass the socket to the connection manager
+        try {
+            await connectionManager.handleConnection(socket, isSecure);
+        }
+        catch (error) {
+            logger.log('error', `Error handling socket connection: ${error.message}`);
+            socket.destroy();
+        }
+    }
+    /**
+     * Stop the unified email server
+     */
+    async stop() {
+        logger.log('info', 'Stopping UnifiedEmailServer');
+        try {
+            // Clear the servers array - servers will be garbage collected
+            this.servers = [];
+            // Stop the delivery system
+            if (this.deliverySystem) {
+                await this.deliverySystem.stop();
+                logger.log('info', 'Email delivery system stopped');
+            }
+            // Shut down the delivery queue
+            if (this.deliveryQueue) {
+                await this.deliveryQueue.shutdown();
+                logger.log('info', 'Email delivery queue shut down');
+            }
+            // Close all SMTP client connections
+            for (const [clientKey, client] of this.smtpClients) {
+                try {
+                    await client.close();
+                    logger.log('info', `Closed SMTP client pool for ${clientKey}`);
+                }
+                catch (error) {
+                    logger.log('warn', `Error closing SMTP client for ${clientKey}: ${error.message}`);
+                }
+            }
+            this.smtpClients.clear();
+            logger.log('info', 'UnifiedEmailServer stopped successfully');
+            this.emit('stopped');
+        }
+        catch (error) {
+            logger.log('error', `Error stopping UnifiedEmailServer: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Process email based on routing rules
+     */
+    async processEmailByMode(emailData, session) {
+        // Convert Buffer to Email if needed
+        let email;
+        if (Buffer.isBuffer(emailData)) {
+            // Parse the email data buffer into an Email object
+            try {
+                const parsed = await plugins.mailparser.simpleParser(emailData);
+                email = new Email({
+                    from: parsed.from?.value[0]?.address || session.envelope.mailFrom.address,
+                    to: session.envelope.rcptTo[0]?.address || '',
+                    subject: parsed.subject || '',
+                    text: parsed.text || '',
+                    html: parsed.html || undefined,
+                    attachments: parsed.attachments?.map(att => ({
+                        filename: att.filename || '',
+                        content: att.content,
+                        contentType: att.contentType
+                    })) || []
+                });
+            }
+            catch (error) {
+                logger.log('error', `Error parsing email data: ${error.message}`);
+                throw new Error(`Error parsing email data: ${error.message}`);
+            }
+        }
+        else {
+            email = emailData;
+        }
+        // First check if this is a bounce notification email
+        // Look for common bounce notification subject patterns
+        const subject = email.subject || '';
+        const isBounceLike = /mail delivery|delivery (failed|status|notification)|failure notice|returned mail|undeliverable|delivery problem/i.test(subject);
+        if (isBounceLike) {
+            logger.log('info', `Email subject matches bounce notification pattern: "${subject}"`);
+            // Try to process as a bounce
+            const isBounce = await this.processBounceNotification(email);
+            if (isBounce) {
+                logger.log('info', 'Successfully processed as bounce notification, skipping regular processing');
+                return email;
+            }
+            logger.log('info', 'Not a valid bounce notification, continuing with regular processing');
+        }
+        // Find matching route
+        const context = { email, session };
+        const route = await this.emailRouter.evaluateRoutes(context);
+        if (!route) {
+            // No matching route - reject
+            throw new Error('No matching route for email');
+        }
+        // Store matched route in session
+        session.matchedRoute = route;
+        // Execute action based on route
+        await this.executeAction(route.action, email, context);
+        // Return the processed email
+        return email;
+    }
+    /**
+     * Execute action based on route configuration
+     */
+    async executeAction(action, email, context) {
+        switch (action.type) {
+            case 'forward':
+                await this.handleForwardAction(action, email, context);
+                break;
+            case 'process':
+                await this.handleProcessAction(action, email, context);
+                break;
+            case 'deliver':
+                await this.handleDeliverAction(action, email, context);
+                break;
+            case 'reject':
+                await this.handleRejectAction(action, email, context);
+                break;
+            default:
+                throw new Error(`Unknown action type: ${action.type}`);
+        }
+    }
+    /**
+     * Handle forward action
+     */
+    async handleForwardAction(_action, email, context) {
+        if (!_action.forward) {
+            throw new Error('Forward action requires forward configuration');
+        }
+        const { host, port = 25, auth, addHeaders } = _action.forward;
+        logger.log('info', `Forwarding email to ${host}:${port}`);
+        // Add forwarding headers
+        if (addHeaders) {
+            for (const [key, value] of Object.entries(addHeaders)) {
+                email.headers[key] = value;
+            }
+        }
+        // Add standard forwarding headers
+        email.headers['X-Forwarded-For'] = context.session.remoteAddress || 'unknown';
+        email.headers['X-Forwarded-To'] = email.to.join(', ');
+        email.headers['X-Forwarded-Date'] = new Date().toISOString();
+        // Get SMTP client
+        const client = this.getSmtpClient(host, port);
+        try {
+            // Send email
+            await client.sendMail(email);
+            logger.log('info', `Successfully forwarded email to ${host}:${port}`);
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.INFO,
+                type: SecurityEventType.EMAIL_FORWARDING,
+                message: 'Email forwarded successfully',
+                ipAddress: context.session.remoteAddress,
+                details: {
+                    sessionId: context.session.id,
+                    routeName: context.session.matchedRoute?.name,
+                    targetHost: host,
+                    targetPort: port,
+                    recipients: email.to
+                },
+                success: true
+            });
+        }
+        catch (error) {
+            logger.log('error', `Failed to forward email: ${error.message}`);
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.ERROR,
+                type: SecurityEventType.EMAIL_FORWARDING,
+                message: 'Email forwarding failed',
+                ipAddress: context.session.remoteAddress,
+                details: {
+                    sessionId: context.session.id,
+                    routeName: context.session.matchedRoute?.name,
+                    targetHost: host,
+                    targetPort: port,
+                    error: error.message
+                },
+                success: false
+            });
+            // Handle as bounce
+            for (const recipient of email.getAllRecipients()) {
+                await this.bounceManager.processSmtpFailure(recipient, error.message, {
+                    sender: email.from,
+                    originalEmailId: email.headers['Message-ID']
+                });
+            }
+            throw error;
+        }
+    }
+    /**
+     * Handle process action
+     */
+    async handleProcessAction(action, email, context) {
+        logger.log('info', `Processing email with action options`);
+        // Apply scanning if requested
+        if (action.process?.scan) {
+            // Use existing content scanner
+            // Note: ContentScanner integration would go here
+            logger.log('info', 'Content scanning requested');
+        }
+        // Note: DKIM signing will be applied at delivery time to ensure signature validity
+        // Queue for delivery
+        const queue = action.process?.queue || 'normal';
+        await this.deliveryQueue.enqueue(email, 'process', context.session.matchedRoute);
+        logger.log('info', `Email queued for delivery in ${queue} queue`);
+    }
+    /**
+     * Handle deliver action
+     */
+    async handleDeliverAction(_action, email, context) {
+        logger.log('info', `Delivering email locally`);
+        // Queue for local delivery
+        await this.deliveryQueue.enqueue(email, 'mta', context.session.matchedRoute);
+        logger.log('info', 'Email queued for local delivery');
+    }
+    /**
+     * Handle reject action
+     */
+    async handleRejectAction(action, email, context) {
+        const code = action.reject?.code || 550;
+        const message = action.reject?.message || 'Message rejected';
+        logger.log('info', `Rejecting email with code ${code}: ${message}`);
+        SecurityLogger.getInstance().logEvent({
+            level: SecurityLogLevel.WARN,
+            type: SecurityEventType.EMAIL_PROCESSING,
+            message: 'Email rejected by routing rule',
+            ipAddress: context.session.remoteAddress,
+            details: {
+                sessionId: context.session.id,
+                routeName: context.session.matchedRoute?.name,
+                rejectCode: code,
+                rejectMessage: message,
+                from: email.from,
+                to: email.to
+            },
+            success: false
+        });
+        // Throw error with SMTP code and message
+        const error = new Error(message);
+        error.responseCode = code;
+        throw error;
+    }
+    /**
+     * Handle email in MTA mode (programmatic processing)
+     */
+    async _handleMtaMode(email, session) {
+        logger.log('info', `Handling email in MTA mode for session ${session.id}`);
+        try {
+            // Apply MTA rule options if provided
+            if (session.matchedRoute?.action.options?.mtaOptions) {
+                const options = session.matchedRoute.action.options.mtaOptions;
+                // Apply DKIM signing if enabled
+                if (options.dkimSign && options.dkimOptions) {
+                    // Sign the email with DKIM
+                    logger.log('info', `Signing email with DKIM for domain ${options.dkimOptions.domainName}`);
+                    try {
+                        // Ensure DKIM keys exist for the domain
+                        await this.dkimCreator.handleDKIMKeysForDomain(options.dkimOptions.domainName);
+                        // Convert Email to raw format for signing
+                        const rawEmail = email.toRFC822String();
+                        // Create headers object
+                        const headers = {};
+                        for (const [key, value] of Object.entries(email.headers)) {
+                            headers[key] = value;
+                        }
+                        // Sign the email
+                        const signResult = await plugins.dkimSign(rawEmail, {
+                            canonicalization: 'relaxed/relaxed',
+                            algorithm: 'rsa-sha256',
+                            signTime: new Date(),
+                            signatureData: [
+                                {
+                                    signingDomain: options.dkimOptions.domainName,
+                                    selector: options.dkimOptions.keySelector || 'mta',
+                                    privateKey: (await this.dkimCreator.readDKIMKeys(options.dkimOptions.domainName)).privateKey,
+                                    algorithm: 'rsa-sha256',
+                                    canonicalization: 'relaxed/relaxed'
+                                }
+                            ]
+                        });
+                        // Add the DKIM-Signature header to the email
+                        if (signResult.signatures) {
+                            email.addHeader('DKIM-Signature', signResult.signatures);
+                            logger.log('info', `Successfully added DKIM signature for ${options.dkimOptions.domainName}`);
+                        }
+                    }
+                    catch (error) {
+                        logger.log('error', `Failed to sign email with DKIM: ${error.message}`);
+                    }
+                }
+            }
+            // Get email content for logging/processing
+            const subject = email.subject;
+            const recipients = email.getAllRecipients().join(', ');
+            logger.log('info', `Email processed by MTA: ${subject} to ${recipients}`);
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.INFO,
+                type: SecurityEventType.EMAIL_PROCESSING,
+                message: 'Email processed by MTA',
+                ipAddress: session.remoteAddress,
+                details: {
+                    sessionId: session.id,
+                    ruleName: session.matchedRoute?.name || 'default',
+                    subject,
+                    recipients
+                },
+                success: true
+            });
+        }
+        catch (error) {
+            logger.log('error', `Failed to process email in MTA mode: ${error.message}`);
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.ERROR,
+                type: SecurityEventType.EMAIL_PROCESSING,
+                message: 'MTA processing failed',
+                ipAddress: session.remoteAddress,
+                details: {
+                    sessionId: session.id,
+                    ruleName: session.matchedRoute?.name || 'default',
+                    error: error.message
+                },
+                success: false
+            });
+            throw error;
+        }
+    }
+    /**
+     * Handle email in process mode (store-and-forward with scanning)
+     */
+    async _handleProcessMode(email, session) {
+        logger.log('info', `Handling email in process mode for session ${session.id}`);
+        try {
+            const route = session.matchedRoute;
+            // 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;
+                    }
+                }
+            }
+            logger.log('info', `Email successfully processed in store-and-forward mode`);
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.INFO,
+                type: SecurityEventType.EMAIL_PROCESSING,
+                message: 'Email processed and queued',
+                ipAddress: session.remoteAddress,
+                details: {
+                    sessionId: session.id,
+                    ruleName: route?.name || 'default',
+                    contentScanning: route?.action.options?.contentScanning || false,
+                    subject: email.subject
+                },
+                success: true
+            });
+        }
+        catch (error) {
+            logger.log('error', `Failed to process email: ${error.message}`);
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.ERROR,
+                type: SecurityEventType.EMAIL_PROCESSING,
+                message: 'Email processing failed',
+                ipAddress: session.remoteAddress,
+                details: {
+                    sessionId: session.id,
+                    ruleName: session.matchedRoute?.name || 'default',
+                    error: error.message
+                },
+                success: false
+            });
+            throw error;
+        }
+    }
+    /**
+     * Get file extension from filename
+     */
+    getFileExtension(filename) {
+        return filename.substring(filename.lastIndexOf('.')).toLowerCase();
+    }
+    /**
+     * Set up DKIM configuration for all domains
+     */
+    async setupDkimForDomains() {
+        const domainConfigs = this.domainRegistry.getAllConfigs();
+        if (domainConfigs.length === 0) {
+            logger.log('warn', 'No domains configured for DKIM');
+            return;
+        }
+        for (const domainConfig of domainConfigs) {
+            const domain = domainConfig.domain;
+            const selector = domainConfig.dkim?.selector || 'default';
+            try {
+                // Check if DKIM keys already exist for this domain
+                let keyPair;
+                try {
+                    // Try to read existing keys
+                    keyPair = await this.dkimCreator.readDKIMKeys(domain);
+                    logger.log('info', `Using existing DKIM keys for domain: ${domain}`);
+                }
+                catch (error) {
+                    // Generate new keys if they don't exist
+                    keyPair = await this.dkimCreator.createDKIMKeys();
+                    // Store them for future use
+                    await this.dkimCreator.createAndStoreDKIMKeys(domain);
+                    logger.log('info', `Generated new DKIM keys for domain: ${domain}`);
+                }
+                // Store the private key for signing
+                this.dkimKeys.set(domain, keyPair.privateKey);
+                // DNS record creation is now handled by DnsManager
+                logger.log('info', `DKIM keys loaded for domain: ${domain} with selector: ${selector}`);
+            }
+            catch (error) {
+                logger.log('error', `Failed to set up DKIM for domain ${domain}: ${error.message}`);
+            }
+        }
+    }
+    /**
+     * Apply per-domain rate limits from domain configurations
+     */
+    applyDomainRateLimits() {
+        const domainConfigs = this.domainRegistry.getAllConfigs();
+        for (const domainConfig of domainConfigs) {
+            if (domainConfig.rateLimits) {
+                const domain = domainConfig.domain;
+                const rateLimitConfig = {};
+                // Convert domain-specific rate limits to the format expected by UnifiedRateLimiter
+                if (domainConfig.rateLimits.outbound) {
+                    if (domainConfig.rateLimits.outbound.messagesPerMinute) {
+                        rateLimitConfig.maxMessagesPerMinute = domainConfig.rateLimits.outbound.messagesPerMinute;
+                    }
+                    // Note: messagesPerHour and messagesPerDay would need additional implementation in rate limiter
+                }
+                if (domainConfig.rateLimits.inbound) {
+                    if (domainConfig.rateLimits.inbound.messagesPerMinute) {
+                        rateLimitConfig.maxMessagesPerMinute = domainConfig.rateLimits.inbound.messagesPerMinute;
+                    }
+                    if (domainConfig.rateLimits.inbound.connectionsPerIp) {
+                        rateLimitConfig.maxConnectionsPerIP = domainConfig.rateLimits.inbound.connectionsPerIp;
+                    }
+                    if (domainConfig.rateLimits.inbound.recipientsPerMessage) {
+                        rateLimitConfig.maxRecipientsPerMessage = domainConfig.rateLimits.inbound.recipientsPerMessage;
+                    }
+                }
+                // Apply the rate limits if we have any
+                if (Object.keys(rateLimitConfig).length > 0) {
+                    this.rateLimiter.applyDomainLimits(domain, rateLimitConfig);
+                    logger.log('info', `Applied rate limits for domain ${domain}:`, rateLimitConfig);
+                }
+            }
+        }
+    }
+    /**
+     * Check and rotate DKIM keys if needed
+     */
+    async checkAndRotateDkimKeys() {
+        const domainConfigs = this.domainRegistry.getAllConfigs();
+        for (const domainConfig of domainConfigs) {
+            const domain = domainConfig.domain;
+            const selector = domainConfig.dkim?.selector || 'default';
+            const rotateKeys = domainConfig.dkim?.rotateKeys || false;
+            const rotationInterval = domainConfig.dkim?.rotationInterval || 90;
+            const keySize = domainConfig.dkim?.keySize || 2048;
+            if (!rotateKeys) {
+                logger.log('debug', `DKIM key rotation disabled for ${domain}`);
+                continue;
+            }
+            try {
+                // Check if keys need rotation
+                const needsRotation = await this.dkimCreator.needsRotation(domain, selector, rotationInterval);
+                if (needsRotation) {
+                    logger.log('info', `DKIM keys need rotation for ${domain} (selector: ${selector})`);
+                    // Rotate the keys
+                    const newSelector = await this.dkimCreator.rotateDkimKeys(domain, selector, keySize);
+                    // Update the domain config with new selector
+                    domainConfig.dkim = {
+                        ...domainConfig.dkim,
+                        selector: newSelector
+                    };
+                    // Re-register DNS handler for new selector if internal-dns mode
+                    if (domainConfig.dnsMode === 'internal-dns' && this.dcRouter.dnsServer) {
+                        // Get new public key
+                        const keyPair = await this.dkimCreator.readDKIMKeysForSelector(domain, newSelector);
+                        const publicKeyBase64 = keyPair.publicKey
+                            .replace(/-----BEGIN PUBLIC KEY-----/g, '')
+                            .replace(/-----END PUBLIC KEY-----/g, '')
+                            .replace(/\s/g, '');
+                        const ttl = domainConfig.dns?.internal?.ttl || 3600;
+                        // Register new selector
+                        this.dcRouter.dnsServer.registerHandler(`${newSelector}._domainkey.${domain}`, ['TXT'], () => ({
+                            name: `${newSelector}._domainkey.${domain}`,
+                            type: 'TXT',
+                            class: 'IN',
+                            ttl: ttl,
+                            data: `v=DKIM1; k=rsa; p=${publicKeyBase64}`
+                        }));
+                        logger.log('info', `DKIM DNS handler registered for new selector: ${newSelector}._domainkey.${domain}`);
+                        // Store the updated public key in storage
+                        await this.dcRouter.storageManager.set(`/email/dkim/${domain}/public.key`, keyPair.publicKey);
+                    }
+                    // Clean up old keys after grace period (async, don't wait)
+                    this.dkimCreator.cleanupOldKeys(domain, 30).catch(error => {
+                        logger.log('warn', `Failed to cleanup old DKIM keys for ${domain}: ${error.message}`);
+                    });
+                }
+                else {
+                    logger.log('debug', `DKIM keys for ${domain} are up to date`);
+                }
+            }
+            catch (error) {
+                logger.log('error', `Failed to check/rotate DKIM keys for ${domain}: ${error.message}`);
+            }
+        }
+    }
+    /**
+     * Generate SmartProxy routes for email ports
+     */
+    generateProxyRoutes(portMapping) {
+        const routes = [];
+        const defaultPortMapping = {
+            25: 10025,
+            587: 10587,
+            465: 10465
+        };
+        const actualPortMapping = portMapping || defaultPortMapping;
+        // Generate routes for each configured port
+        for (const externalPort of this.options.ports) {
+            const internalPort = actualPortMapping[externalPort] || externalPort + 10000;
+            let routeName = 'email-route';
+            let tlsMode = 'passthrough';
+            // Configure based on port
+            switch (externalPort) {
+                case 25:
+                    routeName = 'smtp-route';
+                    tlsMode = 'passthrough'; // STARTTLS
+                    break;
+                case 587:
+                    routeName = 'submission-route';
+                    tlsMode = 'passthrough'; // STARTTLS
+                    break;
+                case 465:
+                    routeName = 'smtps-route';
+                    tlsMode = 'terminate'; // Implicit TLS
+                    break;
+                default:
+                    routeName = `email-port-${externalPort}-route`;
+            }
+            routes.push({
+                name: routeName,
+                match: {
+                    ports: [externalPort]
+                },
+                action: {
+                    type: 'forward',
+                    target: {
+                        host: 'localhost',
+                        port: internalPort
+                    },
+                    tls: {
+                        mode: tlsMode
+                    }
+                }
+            });
+        }
+        return routes;
+    }
+    /**
+     * Update server configuration
+     */
+    updateOptions(options) {
+        // Stop the server if changing ports
+        const portsChanged = options.ports &&
+            (!this.options.ports ||
+                JSON.stringify(options.ports) !== JSON.stringify(this.options.ports));
+        if (portsChanged) {
+            this.stop().then(() => {
+                this.options = { ...this.options, ...options };
+                this.start();
+            });
+        }
+        else {
+            // Update options without restart
+            this.options = { ...this.options, ...options };
+            // Update domain registry if domains changed
+            if (options.domains) {
+                this.domainRegistry = new DomainRegistry(options.domains, options.defaults || this.options.defaults);
+            }
+            // Update email router if routes changed
+            if (options.routes) {
+                this.emailRouter.updateRoutes(options.routes);
+            }
+        }
+    }
+    /**
+     * Update email routes
+     */
+    updateEmailRoutes(routes) {
+        this.options.routes = routes;
+        this.emailRouter.updateRoutes(routes);
+    }
+    /**
+     * Get server statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Get domain registry
+     */
+    getDomainRegistry() {
+        return this.domainRegistry;
+    }
+    /**
+     * Update email routes dynamically
+     */
+    updateRoutes(routes) {
+        this.emailRouter.setRoutes(routes);
+        logger.log('info', `Updated email routes with ${routes.length} routes`);
+    }
+    /**
+     * Send an email through the delivery system
+     * @param email The email to send
+     * @param mode The processing mode to use
+     * @param rule Optional rule to apply
+     * @param options Optional sending options
+     * @returns The ID of the queued email
+     */
+    async sendEmail(email, mode = 'mta', route, options) {
+        logger.log('info', `Sending email: ${email.subject} to ${email.to.join(', ')}`);
+        try {
+            // Validate the email
+            if (!email.from) {
+                throw new Error('Email must have a sender address');
+            }
+            if (!email.to || email.to.length === 0) {
+                throw new Error('Email must have at least one recipient');
+            }
+            // Check if any recipients are on the suppression list (unless explicitly skipped)
+            if (!options?.skipSuppressionCheck) {
+                const suppressedRecipients = email.to.filter(recipient => this.isEmailSuppressed(recipient));
+                if (suppressedRecipients.length > 0) {
+                    // Filter out suppressed recipients
+                    const originalCount = email.to.length;
+                    const suppressed = suppressedRecipients.map(recipient => {
+                        const info = this.getSuppressionInfo(recipient);
+                        return {
+                            email: recipient,
+                            reason: info?.reason || 'Unknown',
+                            until: info?.expiresAt ? new Date(info.expiresAt).toISOString() : 'permanent'
+                        };
+                    });
+                    logger.log('warn', `Filtering out ${suppressedRecipients.length} suppressed recipient(s)`, { suppressed });
+                    // If all recipients are suppressed, throw an error
+                    if (suppressedRecipients.length === originalCount) {
+                        throw new Error('All recipients are on the suppression list');
+                    }
+                    // Filter the recipients list to only include non-suppressed addresses
+                    email.to = email.to.filter(recipient => !this.isEmailSuppressed(recipient));
+                }
+            }
+            // IP warmup handling
+            let ipAddress = options?.ipAddress;
+            // If no specific IP was provided, use IP warmup manager to find the best IP
+            if (!ipAddress) {
+                const domain = email.from.split('@')[1];
+                ipAddress = this.getBestIPForSending({
+                    from: email.from,
+                    to: email.to,
+                    domain,
+                    isTransactional: options?.isTransactional
+                });
+                if (ipAddress) {
+                    logger.log('info', `Selected IP ${ipAddress} for sending based on warmup status`);
+                }
+            }
+            // If an IP is provided or selected by warmup manager, check its capacity
+            if (ipAddress) {
+                // Check if the IP can send more today
+                if (!this.canIPSendMoreToday(ipAddress)) {
+                    logger.log('warn', `IP ${ipAddress} has reached its daily sending limit, email will be queued for later delivery`);
+                }
+                // Check if the IP can send more this hour
+                if (!this.canIPSendMoreThisHour(ipAddress)) {
+                    logger.log('warn', `IP ${ipAddress} has reached its hourly sending limit, email will be queued for later delivery`);
+                }
+                // Record the send for IP warmup tracking
+                this.recordIPSend(ipAddress);
+                // Add IP header to the email
+                email.addHeader('X-Sending-IP', ipAddress);
+            }
+            // Check if the sender domain has DKIM keys and sign the email if needed
+            if (mode === 'mta' && route?.action.options?.mtaOptions?.dkimSign) {
+                const domain = email.from.split('@')[1];
+                await this.handleDkimSigning(email, domain, route.action.options.mtaOptions.dkimOptions?.keySelector || 'mta');
+            }
+            // Generate a unique ID for this email
+            const id = plugins.uuid.v4();
+            // Queue the email for delivery
+            await this.deliveryQueue.enqueue(email, mode, route);
+            // Record 'sent' event for domain reputation monitoring
+            const senderDomain = email.from.split('@')[1];
+            if (senderDomain) {
+                this.recordReputationEvent(senderDomain, {
+                    type: 'sent',
+                    count: email.to.length
+                });
+            }
+            logger.log('info', `Email queued with ID: ${id}`);
+            return id;
+        }
+        catch (error) {
+            logger.log('error', `Failed to send email: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Handle DKIM signing for an email
+     * @param email The email to sign
+     * @param domain The domain to sign with
+     * @param selector The DKIM selector
+     */
+    async handleDkimSigning(email, domain, selector) {
+        try {
+            // Ensure we have DKIM keys for this domain
+            await this.dkimCreator.handleDKIMKeysForDomain(domain);
+            // Get the private key
+            const { privateKey } = await this.dkimCreator.readDKIMKeys(domain);
+            // Convert Email to raw format for signing
+            const rawEmail = email.toRFC822String();
+            // Sign the email
+            const signResult = await plugins.dkimSign(rawEmail, {
+                canonicalization: 'relaxed/relaxed',
+                algorithm: 'rsa-sha256',
+                signTime: new Date(),
+                signatureData: [
+                    {
+                        signingDomain: domain,
+                        selector: selector,
+                        privateKey: privateKey,
+                        algorithm: 'rsa-sha256',
+                        canonicalization: 'relaxed/relaxed'
+                    }
+                ]
+            });
+            // Add the DKIM-Signature header to the email
+            if (signResult.signatures) {
+                email.addHeader('DKIM-Signature', signResult.signatures);
+                logger.log('info', `Successfully added DKIM signature for ${domain}`);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Failed to sign email with DKIM: ${error.message}`);
+            // Continue without DKIM rather than failing the send
+        }
+    }
+    /**
+     * Process a bounce notification email
+     * @param bounceEmail The email containing bounce notification information
+     * @returns Processed bounce record or null if not a bounce
+     */
+    async processBounceNotification(bounceEmail) {
+        logger.log('info', 'Processing potential bounce notification email');
+        try {
+            // Process as a bounce notification (no conversion needed anymore)
+            const bounceRecord = await this.bounceManager.processBounceEmail(bounceEmail);
+            if (bounceRecord) {
+                logger.log('info', `Successfully processed bounce notification for ${bounceRecord.recipient}`, {
+                    bounceType: bounceRecord.bounceType,
+                    bounceCategory: bounceRecord.bounceCategory
+                });
+                // Notify any registered listeners about the bounce
+                this.emit('bounceProcessed', bounceRecord);
+                // Record bounce event for domain reputation tracking
+                if (bounceRecord.domain) {
+                    this.recordReputationEvent(bounceRecord.domain, {
+                        type: 'bounce',
+                        hardBounce: bounceRecord.bounceCategory === BounceCategory.HARD,
+                        receivingDomain: bounceRecord.recipient.split('@')[1]
+                    });
+                }
+                // Log security event
+                SecurityLogger.getInstance().logEvent({
+                    level: SecurityLogLevel.INFO,
+                    type: SecurityEventType.EMAIL_VALIDATION,
+                    message: `Bounce notification processed for recipient`,
+                    domain: bounceRecord.domain,
+                    details: {
+                        recipient: bounceRecord.recipient,
+                        bounceType: bounceRecord.bounceType,
+                        bounceCategory: bounceRecord.bounceCategory
+                    },
+                    success: true
+                });
+                return true;
+            }
+            else {
+                logger.log('info', 'Email not recognized as a bounce notification');
+                return false;
+            }
+        }
+        catch (error) {
+            logger.log('error', `Error processing bounce notification: ${error.message}`);
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.ERROR,
+                type: SecurityEventType.EMAIL_VALIDATION,
+                message: 'Failed to process bounce notification',
+                details: {
+                    error: error.message,
+                    subject: bounceEmail.subject
+                },
+                success: false
+            });
+            return false;
+        }
+    }
+    /**
+     * Process an SMTP failure as a bounce
+     * @param recipient Recipient email that failed
+     * @param smtpResponse SMTP error response
+     * @param options Additional options for bounce processing
+     * @returns Processed bounce record
+     */
+    async processSmtpFailure(recipient, smtpResponse, options = {}) {
+        logger.log('info', `Processing SMTP failure for ${recipient}: ${smtpResponse}`);
+        try {
+            // Process the SMTP failure through the bounce manager
+            const bounceRecord = await this.bounceManager.processSmtpFailure(recipient, smtpResponse, options);
+            logger.log('info', `Successfully processed SMTP failure for ${recipient} as ${bounceRecord.bounceCategory} bounce`, {
+                bounceType: bounceRecord.bounceType
+            });
+            // Notify any registered listeners about the bounce
+            this.emit('bounceProcessed', bounceRecord);
+            // Record bounce event for domain reputation tracking
+            if (bounceRecord.domain) {
+                this.recordReputationEvent(bounceRecord.domain, {
+                    type: 'bounce',
+                    hardBounce: bounceRecord.bounceCategory === BounceCategory.HARD,
+                    receivingDomain: bounceRecord.recipient.split('@')[1]
+                });
+            }
+            // Log security event
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.INFO,
+                type: SecurityEventType.EMAIL_VALIDATION,
+                message: `SMTP failure processed for recipient`,
+                domain: bounceRecord.domain,
+                details: {
+                    recipient: bounceRecord.recipient,
+                    bounceType: bounceRecord.bounceType,
+                    bounceCategory: bounceRecord.bounceCategory,
+                    smtpResponse
+                },
+                success: true
+            });
+            return true;
+        }
+        catch (error) {
+            logger.log('error', `Error processing SMTP failure: ${error.message}`);
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.ERROR,
+                type: SecurityEventType.EMAIL_VALIDATION,
+                message: 'Failed to process SMTP failure',
+                details: {
+                    recipient,
+                    smtpResponse,
+                    error: error.message
+                },
+                success: false
+            });
+            return false;
+        }
+    }
+    /**
+     * Check if an email address is suppressed (has bounced previously)
+     * @param email Email address to check
+     * @returns Whether the email is suppressed
+     */
+    isEmailSuppressed(email) {
+        return this.bounceManager.isEmailSuppressed(email);
+    }
+    /**
+     * Get suppression information for an email
+     * @param email Email address to check
+     * @returns Suppression information or null if not suppressed
+     */
+    getSuppressionInfo(email) {
+        return this.bounceManager.getSuppressionInfo(email);
+    }
+    /**
+     * Get bounce history information for an email
+     * @param email Email address to check
+     * @returns Bounce history or null if no bounces
+     */
+    getBounceHistory(email) {
+        return this.bounceManager.getBounceInfo(email);
+    }
+    /**
+     * Get all suppressed email addresses
+     * @returns Array of suppressed email addresses
+     */
+    getSuppressionList() {
+        return this.bounceManager.getSuppressionList();
+    }
+    /**
+     * Get all hard bounced email addresses
+     * @returns Array of hard bounced email addresses
+     */
+    getHardBouncedAddresses() {
+        return this.bounceManager.getHardBouncedAddresses();
+    }
+    /**
+     * Add an email to the suppression list
+     * @param email Email address to suppress
+     * @param reason Reason for suppression
+     * @param expiresAt Optional expiration time (undefined for permanent)
+     */
+    addToSuppressionList(email, reason, expiresAt) {
+        this.bounceManager.addToSuppressionList(email, reason, expiresAt);
+        logger.log('info', `Added ${email} to suppression list: ${reason}`);
+    }
+    /**
+     * Remove an email from the suppression list
+     * @param email Email address to remove from suppression
+     */
+    removeFromSuppressionList(email) {
+        this.bounceManager.removeFromSuppressionList(email);
+        logger.log('info', `Removed ${email} from suppression list`);
+    }
+    /**
+     * Get the status of IP warmup process
+     * @param ipAddress Optional specific IP to check
+     * @returns Status of IP warmup
+     */
+    getIPWarmupStatus(ipAddress) {
+        return this.ipWarmupManager.getWarmupStatus(ipAddress);
+    }
+    /**
+     * Add a new IP address to the warmup process
+     * @param ipAddress IP address to add
+     */
+    addIPToWarmup(ipAddress) {
+        this.ipWarmupManager.addIPToWarmup(ipAddress);
+    }
+    /**
+     * Remove an IP address from the warmup process
+     * @param ipAddress IP address to remove
+     */
+    removeIPFromWarmup(ipAddress) {
+        this.ipWarmupManager.removeIPFromWarmup(ipAddress);
+    }
+    /**
+     * Update metrics for an IP in the warmup process
+     * @param ipAddress IP address
+     * @param metrics Metrics to update
+     */
+    updateIPWarmupMetrics(ipAddress, metrics) {
+        this.ipWarmupManager.updateMetrics(ipAddress, metrics);
+    }
+    /**
+     * Check if an IP can send more emails today
+     * @param ipAddress IP address to check
+     * @returns Whether the IP can send more today
+     */
+    canIPSendMoreToday(ipAddress) {
+        return this.ipWarmupManager.canSendMoreToday(ipAddress);
+    }
+    /**
+     * Check if an IP can send more emails in the current hour
+     * @param ipAddress IP address to check
+     * @returns Whether the IP can send more this hour
+     */
+    canIPSendMoreThisHour(ipAddress) {
+        return this.ipWarmupManager.canSendMoreThisHour(ipAddress);
+    }
+    /**
+     * Get the best IP to use for sending an email based on warmup status
+     * @param emailInfo Information about the email being sent
+     * @returns Best IP to use or null
+     */
+    getBestIPForSending(emailInfo) {
+        return this.ipWarmupManager.getBestIPForSending(emailInfo);
+    }
+    /**
+     * Set the active IP allocation policy for warmup
+     * @param policyName Name of the policy to set
+     */
+    setIPAllocationPolicy(policyName) {
+        this.ipWarmupManager.setActiveAllocationPolicy(policyName);
+    }
+    /**
+     * Record that an email was sent using a specific IP
+     * @param ipAddress IP address used for sending
+     */
+    recordIPSend(ipAddress) {
+        this.ipWarmupManager.recordSend(ipAddress);
+    }
+    /**
+     * Get reputation data for a domain
+     * @param domain Domain to get reputation for
+     * @returns Domain reputation metrics
+     */
+    getDomainReputationData(domain) {
+        return this.senderReputationMonitor.getReputationData(domain);
+    }
+    /**
+     * Get summary reputation data for all monitored domains
+     * @returns Summary data for all domains
+     */
+    getReputationSummary() {
+        return this.senderReputationMonitor.getReputationSummary();
+    }
+    /**
+     * Add a domain to the reputation monitoring system
+     * @param domain Domain to add
+     */
+    addDomainToMonitoring(domain) {
+        this.senderReputationMonitor.addDomain(domain);
+    }
+    /**
+     * Remove a domain from the reputation monitoring system
+     * @param domain Domain to remove
+     */
+    removeDomainFromMonitoring(domain) {
+        this.senderReputationMonitor.removeDomain(domain);
+    }
+    /**
+     * Record an email event for domain reputation tracking
+     * @param domain Domain sending the email
+     * @param event Event details
+     */
+    recordReputationEvent(domain, event) {
+        this.senderReputationMonitor.recordSendEvent(domain, event);
+    }
+    /**
+     * Check if DKIM key exists for a domain
+     * @param domain Domain to check
+     */
+    hasDkimKey(domain) {
+        return this.dkimKeys.has(domain);
+    }
+    /**
+     * Record successful email delivery
+     * @param domain Sending domain
+     */
+    recordDelivery(domain) {
+        this.recordReputationEvent(domain, {
+            type: 'delivered',
+            count: 1
+        });
+    }
+    /**
+     * Record email bounce
+     * @param domain Sending domain
+     * @param receivingDomain Receiving domain that bounced
+     * @param bounceType Type of bounce (hard/soft)
+     * @param reason Bounce reason
+     */
+    recordBounce(domain, receivingDomain, bounceType, reason) {
+        // Record bounce in bounce manager
+        const bounceRecord = {
+            id: `bounce_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+            recipient: `user@${receivingDomain}`,
+            sender: `user@${domain}`,
+            domain: domain,
+            bounceType: bounceType === 'hard' ? BounceType.INVALID_RECIPIENT : BounceType.TEMPORARY_FAILURE,
+            bounceCategory: bounceType === 'hard' ? BounceCategory.HARD : BounceCategory.SOFT,
+            timestamp: Date.now(),
+            smtpResponse: reason,
+            diagnosticCode: reason,
+            statusCode: bounceType === 'hard' ? '550' : '450',
+            processed: false
+        };
+        // Process the bounce
+        this.bounceManager.processBounce(bounceRecord);
+        // Record reputation event
+        this.recordReputationEvent(domain, {
+            type: 'bounce',
+            count: 1,
+            hardBounce: bounceType === 'hard',
+            receivingDomain
+        });
+    }
+    /**
+     * Get the rate limiter instance
+     * @returns The unified rate limiter
+     */
+    getRateLimiter() {
+        return this.rateLimiter;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.unified.email.server.js","sourceRoot":"","sources":["../../../ts/mail/routing/classes.unified.email.server.ts"],"names":[],"mappings":"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"}