@push.rocks/smartmta 5.1.3 → 5.2.1

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

@@ -0,0 +1,935 @@
+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 { RustSecurityBridge } from '../../security/classes.rustsecuritybridge.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 { 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';
+import { EmailActionExecutor } from './classes.email.action.executor.js';
+import { DkimManager } from './classes.dkim.manager.js';
+/**
+ * Unified email server that handles all email traffic with pattern-based routing
+ */
+export class UnifiedEmailServer extends EventEmitter {
+    dcRouter;
+    options;
+    emailRouter;
+    domainRegistry;
+    servers = [];
+    stats;
+    // Add components needed for sending and securing emails
+    dkimCreator;
+    rustBridge;
+    bounceManager;
+    deliveryQueue;
+    deliverySystem;
+    rateLimiter; // TODO: Implement rate limiting in SMTP server handlers
+    // Extracted subsystems
+    actionExecutor;
+    dkimManager;
+    constructor(dcRouter, options) {
+        super();
+        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 Rust security bridge (singleton)
+        this.rustBridge = RustSecurityBridge.getInstance();
+        // Initialize DKIM creator with storage manager
+        this.dkimCreator = new DKIMCreator(paths.keysDir, 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 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) => {
+                // Delivery success recorded via delivery system
+            }
+        };
+        this.deliverySystem = new MultiModeDeliverySystem(this.deliveryQueue, deliveryOptions, this);
+        // Initialize action executor
+        this.actionExecutor = new EmailActionExecutor({
+            sendOutboundEmail: this.sendOutboundEmail.bind(this),
+            bounceManager: this.bounceManager,
+            deliveryQueue: this.deliveryQueue,
+        });
+        // Initialize DKIM manager
+        this.dkimManager = new DkimManager(this.dkimCreator, this.domainRegistry, dcRouter, this.rustBridge);
+        // 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
+    }
+    /**
+     * Send an outbound email via the Rust SMTP client.
+     * Uses connection pooling in the Rust binary for efficiency.
+     */
+    async sendOutboundEmail(host, port, email, options) {
+        // Build DKIM config if domain has keys
+        let dkim;
+        if (options?.dkimDomain) {
+            try {
+                const { privateKey } = await this.dkimCreator.readDKIMKeys(options.dkimDomain);
+                dkim = { domain: options.dkimDomain, selector: options.dkimSelector || 'default', privateKey };
+            }
+            catch (err) {
+                logger.log('warn', `Failed to read DKIM keys for ${options.dkimDomain}: ${err.message}`);
+            }
+        }
+        // Serialize the Email to the outbound format
+        const outboundEmail = {
+            from: email.from,
+            to: email.to,
+            cc: email.cc || [],
+            bcc: email.bcc || [],
+            subject: email.subject || '',
+            text: email.text || '',
+            html: email.html || undefined,
+            headers: email.headers || {},
+        };
+        return this.rustBridge.sendOutboundEmail({
+            host,
+            port,
+            secure: port === 465,
+            domain: this.options.hostname,
+            auth: options?.auth,
+            email: outboundEmail,
+            dkim,
+            connectionTimeoutSecs: Math.floor((this.options.outbound?.connectionTimeout || 30000) / 1000),
+            socketTimeoutSecs: Math.floor((this.options.outbound?.socketTimeout || 120000) / 1000),
+            poolKey: `${host}:${port}`,
+            maxPoolConnections: this.options.outbound?.maxConnections || 10,
+            tlsOpportunistic: options?.tlsOpportunistic ?? (port === 25),
+        });
+    }
+    /**
+     * Start the unified email server
+     */
+    async start() {
+        logger.log('info', `Starting UnifiedEmailServer on ports: ${this.options.ports.join(', ')}`);
+        try {
+            await this.startDeliveryPipeline();
+            await this.startRustBridge();
+            await this.initializeDkimAndDns();
+            this.registerBridgeEventHandlers();
+            await this.startSmtpServer();
+            logger.log('info', 'UnifiedEmailServer started successfully');
+            this.emit('started');
+        }
+        catch (error) {
+            logger.log('error', `Failed to start UnifiedEmailServer: ${error.message}`);
+            throw error;
+        }
+    }
+    async startDeliveryPipeline() {
+        await this.deliveryQueue.initialize();
+        logger.log('info', 'Email delivery queue initialized');
+        await this.deliverySystem.start();
+        logger.log('info', 'Email delivery system started');
+    }
+    async startRustBridge() {
+        const bridgeOk = await this.rustBridge.start();
+        if (!bridgeOk) {
+            throw new Error('Rust security bridge failed to start. The mailer-bin binary is required. Run "pnpm build" to compile it.');
+        }
+        logger.log('info', 'Rust security bridge started — Rust is the primary security backend');
+        this.rustBridge.on('stateChange', ({ oldState, newState }) => {
+            if (newState === 'failed')
+                this.emit('bridgeFailed');
+            else if (newState === 'restarting')
+                this.emit('bridgeRestarting');
+            else if (newState === 'running' && oldState === 'restarting')
+                this.emit('bridgeRecovered');
+        });
+    }
+    async initializeDkimAndDns() {
+        await this.dkimManager.setupDkimForDomains();
+        logger.log('info', 'DKIM configuration completed for all domains');
+        const dnsManager = new DnsManager(this.dcRouter);
+        await dnsManager.ensureDnsRecords(this.domainRegistry.getAllConfigs(), this.dkimCreator);
+        logger.log('info', 'DNS records ensured for all configured domains');
+        this.applyDomainRateLimits();
+        logger.log('info', 'Per-domain rate limits configured');
+        await this.dkimManager.checkAndRotateDkimKeys();
+        logger.log('info', 'DKIM key rotation check completed');
+    }
+    registerBridgeEventHandlers() {
+        this.rustBridge.onEmailReceived(async (data) => {
+            try {
+                await this.handleRustEmailReceived(data);
+            }
+            catch (err) {
+                logger.log('error', `Error handling email from Rust SMTP: ${err.message}`);
+                try {
+                    await this.rustBridge.sendEmailProcessingResult({
+                        correlationId: data.correlationId,
+                        accepted: false,
+                        smtpCode: 451,
+                        smtpMessage: 'Internal processing error',
+                    });
+                }
+                catch (sendErr) {
+                    logger.log('warn', `Could not send rejection back to Rust: ${sendErr.message}`);
+                }
+            }
+        });
+        this.rustBridge.onAuthRequest(async (data) => {
+            try {
+                await this.handleRustAuthRequest(data);
+            }
+            catch (err) {
+                logger.log('error', `Error handling auth from Rust SMTP: ${err.message}`);
+                try {
+                    await this.rustBridge.sendAuthResult({
+                        correlationId: data.correlationId,
+                        success: false,
+                        message: 'Internal auth error',
+                    });
+                }
+                catch (sendErr) {
+                    logger.log('warn', `Could not send auth rejection back to Rust: ${sendErr.message}`);
+                }
+            }
+        });
+        this.rustBridge.onScramCredentialRequest(async (data) => {
+            try {
+                await this.handleScramCredentialRequest(data);
+            }
+            catch (err) {
+                logger.log('error', `Error handling SCRAM credential request: ${err.message}`);
+                try {
+                    await this.rustBridge.sendScramCredentialResult({
+                        correlationId: data.correlationId,
+                        found: false,
+                    });
+                }
+                catch (sendErr) {
+                    logger.log('warn', `Could not send SCRAM credential rejection: ${sendErr.message}`);
+                }
+            }
+        });
+    }
+    async startSmtpServer() {
+        const hasTlsConfig = this.options.tls?.keyPath && this.options.tls?.certPath;
+        let tlsCertPem;
+        let tlsKeyPem;
+        if (hasTlsConfig) {
+            try {
+                tlsKeyPem = plugins.fs.readFileSync(this.options.tls.keyPath, 'utf8');
+                tlsCertPem = 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}`);
+            }
+        }
+        const smtpPorts = this.options.ports.filter(p => p !== 465);
+        const securePort = this.options.ports.find(p => p === 465);
+        const started = await this.rustBridge.startSmtpServer({
+            hostname: this.options.hostname,
+            ports: smtpPorts,
+            securePort: securePort,
+            tlsCertPem,
+            tlsKeyPem,
+            maxMessageSize: this.options.maxMessageSize || 10 * 1024 * 1024,
+            maxConnections: this.options.maxConnections || this.options.maxClients || 100,
+            maxRecipients: 100,
+            connectionTimeoutSecs: this.options.connectionTimeout ? Math.floor(this.options.connectionTimeout / 1000) : 30,
+            dataTimeoutSecs: 60,
+            authEnabled: !!this.options.auth?.required || !!(this.options.auth?.users?.length),
+            maxAuthFailures: 3,
+            socketTimeoutSecs: this.options.socketTimeout ? Math.floor(this.options.socketTimeout / 1000) : 300,
+            processingTimeoutSecs: 30,
+            rateLimits: this.options.rateLimits ? {
+                maxConnectionsPerIp: this.options.rateLimits.global?.maxConnectionsPerIP || 50,
+                maxMessagesPerSender: this.options.rateLimits.global?.maxMessagesPerMinute || 100,
+                maxAuthFailuresPerIp: this.options.rateLimits.global?.maxAuthFailuresPerIP || 5,
+                windowSecs: 60,
+            } : undefined,
+        });
+        if (!started) {
+            throw new Error('Failed to start Rust SMTP server');
+        }
+        logger.log('info', `Rust SMTP server listening on ports: ${smtpPorts.join(', ')}${securePort ? ` + ${securePort} (TLS)` : ''}`);
+    }
+    /**
+     * Stop the unified email server
+     */
+    async stop() {
+        logger.log('info', 'Stopping UnifiedEmailServer');
+        try {
+            // Stop the Rust SMTP server first
+            try {
+                await this.rustBridge.stopSmtpServer();
+                logger.log('info', 'Rust SMTP server stopped');
+            }
+            catch (err) {
+                logger.log('warn', `Error stopping Rust SMTP server: ${err.message}`);
+            }
+            // Clear the servers array - servers will be garbage collected
+            this.servers = [];
+            // Remove bridge state change listener and stop bridge
+            this.rustBridge.removeAllListeners('stateChange');
+            await this.rustBridge.stop();
+            // 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 Rust SMTP client connection pools
+            try {
+                await this.rustBridge.closeSmtpPool();
+            }
+            catch {
+                // Bridge may already be stopped
+            }
+            logger.log('info', 'UnifiedEmailServer stopped successfully');
+            this.emit('stopped');
+        }
+        catch (error) {
+            logger.log('error', `Error stopping UnifiedEmailServer: ${error.message}`);
+            throw error;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Rust SMTP server event handlers
+    // -----------------------------------------------------------------------
+    /**
+     * Handle an emailReceived event from the Rust SMTP server.
+     */
+    async handleRustEmailReceived(data) {
+        const { correlationId, mailFrom, rcptTo, remoteAddr, clientHostname, secure, authenticatedUser } = data;
+        logger.log('info', `Rust SMTP received email from=${mailFrom} to=${rcptTo.join(',')} remote=${remoteAddr}`);
+        try {
+            // Decode the email data
+            let rawMessageBuffer;
+            if (data.data.type === 'inline' && data.data.base64) {
+                rawMessageBuffer = Buffer.from(data.data.base64, 'base64');
+            }
+            else if (data.data.type === 'file' && data.data.path) {
+                rawMessageBuffer = plugins.fs.readFileSync(data.data.path);
+                // Clean up temp file
+                try {
+                    plugins.fs.unlinkSync(data.data.path);
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+            }
+            else {
+                throw new Error('Invalid email data transport');
+            }
+            // Build a session-like object for processEmailByMode
+            const session = {
+                id: data.sessionId || 'rust-' + Math.random().toString(36).substring(2),
+                state: SmtpState.FINISHED,
+                mailFrom: mailFrom,
+                rcptTo: rcptTo,
+                emailData: rawMessageBuffer.toString('utf8'),
+                useTLS: secure,
+                connectionEnded: false,
+                remoteAddress: remoteAddr,
+                clientHostname: clientHostname || '',
+                secure: secure,
+                authenticated: !!authenticatedUser,
+                envelope: {
+                    mailFrom: { address: mailFrom, args: {} },
+                    rcptTo: rcptTo.map(addr => ({ address: addr, args: {} })),
+                },
+            };
+            if (authenticatedUser) {
+                session.user = { username: authenticatedUser };
+            }
+            // Attach pre-computed security results from Rust in-process pipeline
+            if (data.securityResults) {
+                session._precomputedSecurityResults = data.securityResults;
+            }
+            // Process the email through the routing system
+            await this.processEmailByMode(rawMessageBuffer, session);
+            // Send acceptance back to Rust
+            await this.rustBridge.sendEmailProcessingResult({
+                correlationId,
+                accepted: true,
+                smtpCode: 250,
+                smtpMessage: '2.0.0 Message accepted for delivery',
+            });
+        }
+        catch (err) {
+            logger.log('error', `Failed to process email from Rust SMTP: ${err.message}`);
+            await this.rustBridge.sendEmailProcessingResult({
+                correlationId,
+                accepted: false,
+                smtpCode: 550,
+                smtpMessage: `5.0.0 Processing failed: ${err.message}`,
+            });
+        }
+    }
+    /**
+     * Handle an authRequest event from the Rust SMTP server.
+     */
+    async handleRustAuthRequest(data) {
+        const { correlationId, username, password, remoteAddr } = data;
+        logger.log('info', `Rust SMTP auth request for user=${username} from=${remoteAddr}`);
+        // Check against configured users
+        const users = this.options.auth?.users || [];
+        const matched = users.find(u => u.username === username && u.password === password);
+        if (matched) {
+            await this.rustBridge.sendAuthResult({
+                correlationId,
+                success: true,
+            });
+        }
+        else {
+            logger.log('warn', `Auth failed for user=${username} from=${remoteAddr}`);
+            await this.rustBridge.sendAuthResult({
+                correlationId,
+                success: false,
+                message: 'Invalid credentials',
+            });
+        }
+    }
+    /**
+     * Handle a SCRAM credential request from the Rust SMTP server.
+     * Computes SCRAM-SHA-256 credentials from the stored password for the given user.
+     */
+    async handleScramCredentialRequest(data) {
+        const { correlationId, username, remoteAddr } = data;
+        const crypto = await import('crypto');
+        logger.log('info', `SCRAM credential request for user=${username} from=${remoteAddr}`);
+        const users = this.options.auth?.users || [];
+        const matched = users.find(u => u.username === username);
+        if (!matched) {
+            await this.rustBridge.sendScramCredentialResult({
+                correlationId,
+                found: false,
+            });
+            return;
+        }
+        // Compute SCRAM-SHA-256 credentials from plaintext password
+        const salt = crypto.randomBytes(16);
+        const iterations = 4096;
+        // SaltedPassword = PBKDF2-HMAC-SHA256(password, salt, iterations, 32)
+        const saltedPassword = crypto.pbkdf2Sync(matched.password, salt, iterations, 32, 'sha256');
+        // ClientKey = HMAC-SHA256(SaltedPassword, "Client Key")
+        const clientKey = crypto.createHmac('sha256', saltedPassword).update('Client Key').digest();
+        // StoredKey = SHA256(ClientKey)
+        const storedKey = crypto.createHash('sha256').update(clientKey).digest();
+        // ServerKey = HMAC-SHA256(SaltedPassword, "Server Key")
+        const serverKey = crypto.createHmac('sha256', saltedPassword).update('Server Key').digest();
+        await this.rustBridge.sendScramCredentialResult({
+            correlationId,
+            found: true,
+            salt: salt.toString('base64'),
+            iterations,
+            storedKey: storedKey.toString('base64'),
+            serverKey: serverKey.toString('base64'),
+        });
+    }
+    /**
+     * Verify inbound email security (DKIM/SPF/DMARC) using pre-computed Rust results
+     * or falling back to IPC call if no pre-computed results are available.
+     */
+    async verifyInboundSecurity(email, session) {
+        try {
+            // Check for pre-computed results from Rust in-process security pipeline
+            const precomputed = session._precomputedSecurityResults;
+            let result;
+            if (precomputed) {
+                logger.log('info', 'Using pre-computed security results from Rust in-process pipeline');
+                result = precomputed;
+            }
+            else {
+                // Fallback: IPC round-trip to Rust (for backward compat)
+                const rawMessage = session.emailData || email.toRFC822String();
+                result = await this.rustBridge.verifyEmail({
+                    rawMessage,
+                    ip: session.remoteAddress,
+                    heloDomain: session.clientHostname || '',
+                    hostname: this.options.hostname,
+                    mailFrom: session.envelope?.mailFrom?.address || session.mailFrom || '',
+                });
+            }
+            // Apply DKIM result headers
+            if (result.dkim && result.dkim.length > 0) {
+                const dkimSummary = result.dkim
+                    .map((d) => `${d.status}${d.domain ? ` (${d.domain})` : ''}`)
+                    .join(', ');
+                email.addHeader('X-DKIM-Result', dkimSummary);
+            }
+            // Apply SPF result header
+            if (result.spf) {
+                email.addHeader('Received-SPF', `${result.spf.result} (domain: ${result.spf.domain}, ip: ${result.spf.ip})`);
+                // Mark as spam on SPF hard fail
+                if (result.spf.result === 'fail') {
+                    email.mightBeSpam = true;
+                    logger.log('warn', `SPF fail for ${session.remoteAddress} — marking as potential spam`);
+                }
+            }
+            // Apply DMARC result header and policy
+            if (result.dmarc) {
+                email.addHeader('X-DMARC-Result', `${result.dmarc.action} (policy=${result.dmarc.policy}, dkim=${result.dmarc.dkim_result}, spf=${result.dmarc.spf_result})`);
+                if (result.dmarc.action === 'reject') {
+                    email.mightBeSpam = true;
+                    logger.log('warn', `DMARC reject for domain ${result.dmarc.domain} — marking as spam`);
+                }
+                else if (result.dmarc.action === 'quarantine') {
+                    email.mightBeSpam = true;
+                    logger.log('info', `DMARC quarantine for domain ${result.dmarc.domain} — marking as potential spam`);
+                }
+            }
+            // Apply content scan results (from pre-computed pipeline)
+            if (result.contentScan) {
+                const scan = result.contentScan;
+                if (scan.threatScore > 0) {
+                    email.addHeader('X-Spam-Score', String(scan.threatScore));
+                    if (scan.threatType) {
+                        email.addHeader('X-Spam-Type', scan.threatType);
+                    }
+                    if (scan.threatScore >= 50) {
+                        email.mightBeSpam = true;
+                        logger.log('warn', `Content scan threat score ${scan.threatScore} (${scan.threatType}) — marking as potential spam`);
+                    }
+                }
+            }
+            // Apply IP reputation results (from pre-computed pipeline)
+            if (result.ipReputation) {
+                const rep = result.ipReputation;
+                email.addHeader('X-IP-Reputation-Score', String(rep.score));
+                if (rep.is_spam) {
+                    email.mightBeSpam = true;
+                    logger.log('warn', `IP ${rep.ip} flagged by reputation check (score=${rep.score}) — marking as potential spam`);
+                }
+            }
+            logger.log('info', `Inbound security verified for email from ${session.remoteAddress}: DKIM=${result.dkim?.[0]?.status ?? 'none'}, SPF=${result.spf?.result ?? 'none'}, DMARC=${result.dmarc?.action ?? 'none'}`);
+        }
+        catch (err) {
+            logger.log('warn', `Inbound security verification failed: ${err.message} — accepting email`);
+        }
+    }
+    /**
+     * 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;
+        }
+        // Run inbound security verification (DKIM/SPF/DMARC) via Rust bridge
+        if (session.remoteAddress && session.remoteAddress !== '127.0.0.1') {
+            await this.verifyInboundSecurity(email, session);
+        }
+        // First check if this is a bounce notification email
+        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}"`);
+            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) {
+            throw new Error('No matching route for email');
+        }
+        // Store matched route in session
+        session.matchedRoute = route;
+        // Execute action based on route
+        await this.actionExecutor.executeAction(route.action, email, context);
+        // Return the processed email
+        return email;
+    }
+    /**
+     * 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 = {};
+                if (domainConfig.rateLimits.outbound) {
+                    if (domainConfig.rateLimits.outbound.messagesPerMinute) {
+                        rateLimitConfig.maxMessagesPerMinute = domainConfig.rateLimits.outbound.messagesPerMinute;
+                    }
+                }
+                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;
+                    }
+                }
+                if (Object.keys(rateLimitConfig).length > 0) {
+                    this.rateLimiter.applyDomainLimits(domain, rateLimitConfig);
+                    logger.log('info', `Applied rate limits for domain ${domain}:`, rateLimitConfig);
+                }
+            }
+        }
+    }
+    /**
+     * Generate SmartProxy routes for email ports
+     */
+    generateProxyRoutes(portMapping) {
+        const routes = [];
+        const defaultPortMapping = {
+            25: 10025,
+            587: 10587,
+            465: 10465
+        };
+        const actualPortMapping = portMapping || defaultPortMapping;
+        for (const externalPort of this.options.ports) {
+            const internalPort = actualPortMapping[externalPort] || externalPort + 10000;
+            let routeName = 'email-route';
+            let tlsMode = 'passthrough';
+            switch (externalPort) {
+                case 25:
+                    routeName = 'smtp-route';
+                    tlsMode = 'passthrough';
+                    break;
+                case 587:
+                    routeName = 'submission-route';
+                    tlsMode = 'passthrough';
+                    break;
+                case 465:
+                    routeName = 'smtps-route';
+                    tlsMode = 'terminate';
+                    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) {
+        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 {
+            this.options = { ...this.options, ...options };
+            if (options.domains) {
+                this.domainRegistry = new DomainRegistry(options.domains, options.defaults || this.options.defaults);
+            }
+            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;
+    }
+    /**
+     * Send an email through the delivery system
+     */
+    async sendEmail(email, mode = 'mta', route, options) {
+        logger.log('info', `Sending email: ${email.subject} to ${email.to.join(', ')}`);
+        try {
+            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
+            if (!options?.skipSuppressionCheck) {
+                const suppressedRecipients = email.to.filter(recipient => this.isEmailSuppressed(recipient));
+                if (suppressedRecipients.length > 0) {
+                    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 (suppressedRecipients.length === originalCount) {
+                        throw new Error('All recipients are on the suppression list');
+                    }
+                    email.to = email.to.filter(recipient => !this.isEmailSuppressed(recipient));
+                }
+            }
+            // Sign with DKIM if configured
+            if (mode === 'mta' && route?.action.options?.mtaOptions?.dkimSign) {
+                const domain = email.from.split('@')[1];
+                await this.dkimManager.handleDkimSigning(email, domain, route.action.options.mtaOptions.dkimOptions?.keySelector || 'mta');
+            }
+            const id = plugins.uuid.v4();
+            await this.deliveryQueue.enqueue(email, mode, route);
+            logger.log('info', `Email queued with ID: ${id}`);
+            return id;
+        }
+        catch (error) {
+            logger.log('error', `Failed to send email: ${error.message}`);
+            throw error;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Bounce/suppression methods
+    // -----------------------------------------------------------------------
+    async processBounceNotification(bounceEmail) {
+        logger.log('info', 'Processing potential bounce notification email');
+        try {
+            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
+                });
+                this.emit('bounceProcessed', bounceRecord);
+                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;
+        }
+    }
+    async processSmtpFailure(recipient, smtpResponse, options = {}) {
+        logger.log('info', `Processing SMTP failure for ${recipient}: ${smtpResponse}`);
+        try {
+            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
+            });
+            this.emit('bounceProcessed', bounceRecord);
+            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;
+        }
+    }
+    isEmailSuppressed(email) {
+        return this.bounceManager.isEmailSuppressed(email);
+    }
+    getSuppressionInfo(email) {
+        return this.bounceManager.getSuppressionInfo(email);
+    }
+    getBounceHistory(email) {
+        return this.bounceManager.getBounceInfo(email);
+    }
+    getSuppressionList() {
+        return this.bounceManager.getSuppressionList();
+    }
+    getHardBouncedAddresses() {
+        return this.bounceManager.getHardBouncedAddresses();
+    }
+    addToSuppressionList(email, reason, expiresAt) {
+        this.bounceManager.addToSuppressionList(email, reason, expiresAt);
+        logger.log('info', `Added ${email} to suppression list: ${reason}`);
+    }
+    removeFromSuppressionList(email) {
+        this.bounceManager.removeFromSuppressionList(email);
+        logger.log('info', `Removed ${email} from suppression list`);
+    }
+    recordBounce(domain, receivingDomain, bounceType, reason) {
+        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
+        };
+        this.bounceManager.processBounce(bounceRecord);
+    }
+    /**
+     * Get the rate limiter instance
+     */
+    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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"}