platformservice/ts/dcrouter/classes.dcrouter.ts

import * as plugins from '../plugins.js';
import * as paths from '../paths.js';
import { SmtpPortConfig, type ISmtpPortSettings } from './classes.smtp.portconfig.js';
import { EmailDomainRouter, type IEmailDomainRoutingConfig } from './classes.email.domainrouter.js';
import { type IMtaConfig, MtaService } from '../mta/classes.mta.js';

// Import SMTP store-and-forward components
import { SmtpServer } from './classes.smtp.server.js';
import { EmailProcessor, type IProcessingResult } from './classes.email.processor.js';
import { DeliveryQueue } from './classes.delivery.queue.js';
import { DeliverySystem } from './classes.delivery.system.js';

// Certificate types are available via plugins.tsclass

/**
 * Configuration for SMTP forwarding functionality
 */
export interface ISmtpForwardingConfig {
  /** Whether SMTP forwarding is enabled */
  enabled?: boolean;
  /** SMTP ports to listen on */
  ports?: number[];
  /** Default SMTP server hostname */
  defaultServer: string;
  /** Default SMTP server port */
  defaultPort?: number;
  /** Whether to use TLS when connecting to the default server */
  useTls?: boolean;
  /** Preserve source IP address when forwarding */
  preserveSourceIp?: boolean;
  /** Domain-specific routing rules */
  domainRoutes?: Array<{
    domain: string;
    server: string;
    port?: number;
  }>;
}


import type { ISmtpConfig } from './classes.smtp.config.js';

export interface IDcRouterOptions {
  /** 
   * Direct SmartProxy configuration - gives full control over HTTP/HTTPS and TCP/SNI traffic
   * This is the preferred way to configure HTTP/HTTPS and general TCP/SNI traffic 
   */
  smartProxyConfig?: plugins.smartproxy.ISmartProxyOptions;
  
  
  /**
   * SMTP store-and-forward configuration
   * This enables advanced email processing capabilities (complementary to smartProxyConfig)
   */
  smtpConfig?: ISmtpConfig;
  
  /** 
   * Legacy SMTP forwarding configuration
   * If smtpConfig is provided, this will be ignored 
   */
  smtpForwarding?: ISmtpForwardingConfig;
  
  /** MTA service configuration (if not using SMTP forwarding) */
  mtaConfig?: IMtaConfig;
  
  /** Existing MTA service instance to use (if not using SMTP forwarding) */
  mtaServiceInstance?: MtaService;
  
  /** TLS/certificate configuration */
  tls?: {
    /** Contact email for ACME certificates */
    contactEmail: string;
    /** Domain for main certificate */
    domain?: string;
    /** Path to certificate file (if not using auto-provisioning) */
    certPath?: string;
    /** Path to key file (if not using auto-provisioning) */
    keyPath?: string;
  };
  
  /** DNS server configuration */
  dnsServerConfig?: plugins.smartdns.IDnsServerOptions;
}

/**
 * DcRouter can be run on ingress and egress to and from a datacenter site.
 */
/**
 * Context passed to HTTP routing rules
 */
/**
 * Context passed to port proxy (SmartProxy) routing rules
 */
export interface PortProxyRuleContext {
  proxy: plugins.smartproxy.SmartProxy;
  configs: plugins.smartproxy.IPortProxySettings['domainConfigs'];
}

export class DcRouter {
  public options: IDcRouterOptions;
  
  // Core services
  public smartProxy?: plugins.smartproxy.SmartProxy;
  public mta?: MtaService;
  public dnsServer?: plugins.smartdns.DnsServer;
  
  // SMTP store-and-forward components
  public smtpServer?: SmtpServer;
  public emailProcessor?: EmailProcessor;
  public deliveryQueue?: DeliveryQueue;
  public deliverySystem?: DeliverySystem;
  
  // Environment access 
  private qenv = new plugins.qenv.Qenv('./', '.nogit/');
  
  constructor(optionsArg: IDcRouterOptions) {
    // Set defaults in options
    this.options = {
      ...optionsArg
    };
  }

  public async start() {
    console.log('Starting DcRouter services...');
    
    try {
      // Set up SmartProxy for HTTP/HTTPS and general TCP/SNI traffic
      if (this.options.smartProxyConfig) {
        await this.setupSmartProxy();
      }
      
      // 2. Set up SMTP handling
      if (this.options.smtpConfig) {
        // Set up store-and-forward SMTP processing
        await this.setupSmtpProcessing();
      } else if (this.options.smtpForwarding?.enabled) {
        // Fallback to simple SMTP forwarding for backward compatibility
        await this.setupSmtpForwarding();
      } else {
        // Set up MTA service if no SMTP handling is configured
        await this.setupMtaService();
      }
      
      // 3. Set up DNS server if configured
      if (this.options.dnsServerConfig) {
        this.dnsServer = new plugins.smartdns.DnsServer(this.options.dnsServerConfig);
        await this.dnsServer.start();
        console.log('DNS server started');
      }
      
      console.log('DcRouter started successfully');
    } catch (error) {
      console.error('Error starting DcRouter:', error);
      // Try to clean up any services that may have started
      await this.stop();
      throw error;
    }
  }
  
  /**
   * Set up SmartProxy with direct configuration
   */
  private async setupSmartProxy(): Promise<void> {
    if (!this.options.smartProxyConfig) {
      return;
    }
    
    console.log('Setting up SmartProxy with direct configuration');
    
    // Create SmartProxy instance with full configuration
    this.smartProxy = new plugins.smartproxy.SmartProxy(this.options.smartProxyConfig);
    
    // Set up event listeners
    this.smartProxy.on('error', (err) => {
      console.error('SmartProxy error:', err);
    });
    
    if (this.options.smartProxyConfig.acme) {
      this.smartProxy.on('certificate-issued', (event) => {
        console.log(`Certificate issued for ${event.domain}, expires ${event.expiryDate}`);
      });
      
      this.smartProxy.on('certificate-renewed', (event) => {
        console.log(`Certificate renewed for ${event.domain}, expires ${event.expiryDate}`);
      });
    }
    
    // Start SmartProxy
    await this.smartProxy.start();
    
    console.log('SmartProxy started successfully');
  }
  
  
  /**
   * Set up the MTA service
   */
  private async setupMtaService() {
    // Use existing MTA service if provided
    if (this.options.mtaServiceInstance) {
      this.mta = this.options.mtaServiceInstance;
      console.log('Using provided MTA service instance');
    } else if (this.options.mtaConfig) {
      // Create new MTA service with the provided configuration
      this.mta = new MtaService(undefined, this.options.mtaConfig);
      console.log('Created new MTA service instance');
      
      // Start the MTA service
      await this.mta.start();
      console.log('MTA service started');
    }
  }
  
  /**
   * Set up SMTP forwarding with SmartProxy
   */
  private async setupSmtpForwarding() {
    if (!this.options.smtpForwarding) {
      return;
    }
    
    const forwarding = this.options.smtpForwarding;
    console.log('Setting up SMTP forwarding');
    
    // Determine which ports to listen on
    const smtpPorts = forwarding.ports || [25, 587, 465];
    
    // Create SmartProxy instance for SMTP forwarding
    const smtpProxyConfig: plugins.smartproxy.ISmartProxyOptions = {
      // Listen on the first SMTP port
      fromPort: smtpPorts[0],
      // Forward to the default server
      toPort: forwarding.defaultPort || 25,
      targetIP: forwarding.defaultServer,
      // Enable SNI if port 465 is included (implicit TLS)
      sniEnabled: smtpPorts.includes(465),
      // Preserve source IP if requested
      preserveSourceIP: forwarding.preserveSourceIp || false,
      // Create domain configs for SMTP routing
      domainConfigs: forwarding.domainRoutes?.map(route => ({
        domains: [route.domain],
        allowedIPs: ['0.0.0.0/0'], // Allow from anywhere by default
        targetIPs: [route.server]
      })) || [],
      // Include all SMTP ports in the global port ranges
      globalPortRanges: smtpPorts.map(port => ({ from: port, to: port }))
    };
    
    // Create a separate SmartProxy instance for SMTP
    const smtpProxy = new plugins.smartproxy.SmartProxy(smtpProxyConfig);
    
    // Start the SMTP proxy
    await smtpProxy.start();
    
    // Store the SMTP proxy reference
    this.smartProxy = smtpProxy;
    
    console.log(`SMTP forwarding configured on ports ${smtpPorts.join(', ')}`);
  }

  /**
   * Check if a domain matches a pattern (including wildcard support)
   * @param domain The domain to check
   * @param pattern The pattern to match against (e.g., "*.example.com")
   * @returns Whether the domain matches the pattern
   */
  private isDomainMatch(domain: string, pattern: string): boolean {
    // Normalize inputs
    domain = domain.toLowerCase();
    pattern = pattern.toLowerCase();
    
    // Check for exact match
    if (domain === pattern) {
      return true;
    }
    
    // Check for wildcard match (*.example.com)
    if (pattern.startsWith('*.')) {
      const patternSuffix = pattern.slice(2); // Remove the "*." prefix
      
      // Check if domain ends with the pattern suffix and has at least one character before it
      return domain.endsWith(patternSuffix) && domain.length > patternSuffix.length;
    }
    
    // No match
    return false;
  }

  public async stop() {
    console.log('Stopping DcRouter services...');
    
    try {
      // Stop all services in parallel for faster shutdown
      await Promise.all([
        // Stop SMTP components
        this.stopSmtpComponents().catch(err => console.error('Error stopping SMTP components:', err)),
        
        // Stop HTTP SmartProxy if running
        this.smartProxy ? this.smartProxy.stop().catch(err => console.error('Error stopping SmartProxy:', err)) : Promise.resolve(),
        
        // Stop MTA service if it's our own (not an external instance)
        (this.mta && !this.options.mtaServiceInstance) ? 
          this.mta.stop().catch(err => console.error('Error stopping MTA service:', err)) : 
          Promise.resolve(),
        
        // Stop DNS server if running
        this.dnsServer ? 
          this.dnsServer.stop().catch(err => console.error('Error stopping DNS server:', err)) : 
          Promise.resolve()
      ]);
      
      console.log('All DcRouter services stopped');
    } catch (error) {
      console.error('Error during DcRouter shutdown:', error);
      throw error;
    }
  }

  /**
   * Update SmartProxy configuration
   * @param config New SmartProxy configuration
   */
  public async updateSmartProxyConfig(config: plugins.smartproxy.ISmartProxyOptions): Promise<void> {
    // Stop existing SmartProxy if running
    if (this.smartProxy) {
      await this.smartProxy.stop();
      this.smartProxy = undefined;
    }
    
    // Update configuration
    this.options.smartProxyConfig = config;
    
    // Start new SmartProxy with updated configuration
    await this.setupSmartProxy();
    
    console.log('SmartProxy configuration updated');
  }
  
  
  /**
   * Set up SMTP store-and-forward processing
   */
  private async setupSmtpProcessing(): Promise<void> {
    if (!this.options.smtpConfig) {
      return;
    }
    
    console.log('Setting up SMTP store-and-forward processing');
    
    try {
      // 1. Create SMTP server
      this.smtpServer = new SmtpServer(this.options.smtpConfig);
      
      // 2. Create email processor
      this.emailProcessor = new EmailProcessor(this.options.smtpConfig);
      
      // 3. Create delivery queue
      this.deliveryQueue = new DeliveryQueue(this.options.smtpConfig.queue || {});
      await this.deliveryQueue.initialize();
      
      // 4. Create delivery system
      this.deliverySystem = new DeliverySystem(this.deliveryQueue);
      
      // 5. Connect components
      
      // When a message is received by the SMTP server, process it
      this.smtpServer.on('message', async ({ session, mail, rawData }) => {
        try {
          // Process the message
          const processingResult = await this.emailProcessor.processEmail(mail, rawData, session);
          
          // If action is queue, add to delivery queue
          if (processingResult.action === 'queue') {
            await this.deliveryQueue.enqueue(processingResult);
          }
        } catch (error) {
          console.error('Error processing message:', error);
        }
      });
      
      // 6. Start components
      await this.smtpServer.start();
      await this.deliverySystem.start();
      
      console.log(`SMTP processing started on ports ${this.options.smtpConfig.ports.join(', ')}`);
    } catch (error) {
      console.error('Error setting up SMTP processing:', error);
      
      // Clean up any components that were started
      if (this.deliverySystem) {
        await this.deliverySystem.stop().catch(e => console.error('Error stopping delivery system:', e));
      }
      
      if (this.deliveryQueue) {
        await this.deliveryQueue.shutdown().catch(e => console.error('Error shutting down delivery queue:', e));
      }
      
      if (this.smtpServer) {
        await this.smtpServer.stop().catch(e => console.error('Error stopping SMTP server:', e));
      }
      
      throw error;
    }
  }
  
  /**
   * Update SMTP forwarding configuration
   * @param config New SMTP forwarding configuration
   */
  public async updateSmtpForwarding(config: ISmtpForwardingConfig): Promise<void> {
    // Stop existing SMTP components
    await this.stopSmtpComponents();
    
    // Update configuration
    this.options.smtpForwarding = config;
    this.options.smtpConfig = undefined; // Clear any store-and-forward config
    
    // Restart SMTP forwarding if enabled
    if (config.enabled) {
      await this.setupSmtpForwarding();
    }
    
    console.log('SMTP forwarding configuration updated');
  }
  
  /**
   * Update SMTP processing configuration
   * @param config New SMTP config
   */
  public async updateSmtpConfig(config: ISmtpConfig): Promise<void> {
    // Stop existing SMTP components
    await this.stopSmtpComponents();
    
    // Update configuration
    this.options.smtpConfig = config;
    this.options.smtpForwarding = undefined; // Clear any forwarding config
    
    // Start SMTP processing
    await this.setupSmtpProcessing();
    
    console.log('SMTP processing configuration updated');
  }
  
  /**
   * Stop all SMTP components
   */
  private async stopSmtpComponents(): Promise<void> {
    // Stop delivery system
    if (this.deliverySystem) {
      await this.deliverySystem.stop().catch(e => console.error('Error stopping delivery system:', e));
      this.deliverySystem = undefined;
    }
    
    // Stop delivery queue
    if (this.deliveryQueue) {
      await this.deliveryQueue.shutdown().catch(e => console.error('Error shutting down delivery queue:', e));
      this.deliveryQueue = undefined;
    }
    
    // Stop SMTP server
    if (this.smtpServer) {
      await this.smtpServer.stop().catch(e => console.error('Error stopping SMTP server:', e));
      this.smtpServer = undefined;
    }
    
    // For backward compatibility: legacy SMTP proxy implementation
    // This is no longer used with the new implementation
  }
}

export default DcRouter;