@push.rocks/smartmta 5.1.3 → 5.2.0

package/ts/mail/delivery/classes.delivery.system.ts

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