@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/classes.dcrouter.js

@@ -0,0 +1,1008 @@
+import * as plugins from './plugins.js';
+import * as paths from './paths.js';
+// Certificate types are available via plugins.tsclass
+// Import the email server and its configuration
+import { UnifiedEmailServer } from './mail/routing/classes.unified.email.server.js';
+import { logger } from './logger.js';
+// Import the email configuration helpers directly from mail/delivery
+import { configureEmailStorage, configureEmailServer } from './mail/delivery/index.js';
+// Import storage manager
+import { StorageManager } from './storage/index.js';
+import { OpsServer } from './opsserver/index.js';
+export class DcRouter {
+    constructor(optionsArg) {
+        // TypedRouter for API endpoints
+        this.typedrouter = new plugins.typedrequest.TypedRouter();
+        // Environment access 
+        this.qenv = new plugins.qenv.Qenv('./', '.nogit/');
+        // Set defaults in options
+        this.options = {
+            ...optionsArg
+        };
+        // Initialize storage manager
+        this.storageManager = new StorageManager(this.options.storage);
+    }
+    async start() {
+        console.log('╔═══════════════════════════════════════════════════════════════════╗');
+        console.log('║                     Starting DcRouter Services                    ║');
+        console.log('╚═══════════════════════════════════════════════════════════════════╝');
+        this.opsServer = new OpsServer(this);
+        await this.opsServer.start();
+        try {
+            // Set up SmartProxy for HTTP/HTTPS and all traffic including email routes
+            await this.setupSmartProxy();
+            // Set up unified email handling if configured
+            if (this.options.emailConfig) {
+                await this.setupUnifiedEmailHandling();
+                // Apply custom email storage configuration if available
+                if (this.emailServer && this.options.emailPortConfig?.receivedEmailsPath) {
+                    logger.log('info', 'Applying custom email storage configuration');
+                    configureEmailStorage(this.emailServer, this.options);
+                }
+            }
+            // Set up DNS server if configured with nameservers and scopes
+            if (this.options.dnsNsDomains && this.options.dnsNsDomains.length > 0 &&
+                this.options.dnsScopes && this.options.dnsScopes.length > 0) {
+                await this.setupDnsWithSocketHandler();
+            }
+            this.logStartupSummary();
+        }
+        catch (error) {
+            console.error('❌ Error starting DcRouter:', error);
+            // Try to clean up any services that may have started
+            await this.stop();
+            throw error;
+        }
+    }
+    /**
+     * Log comprehensive startup summary
+     */
+    logStartupSummary() {
+        console.log('\n╔═══════════════════════════════════════════════════════════════════╗');
+        console.log('║                    DcRouter Started Successfully                   ║');
+        console.log('╚═══════════════════════════════════════════════════════════════════╝\n');
+        // SmartProxy summary
+        if (this.smartProxy) {
+            console.log('🌐 SmartProxy Service:');
+            const routeCount = this.options.smartProxyConfig?.routes?.length || 0;
+            console.log(`   ├─ Routes configured: ${routeCount}`);
+            console.log(`   ├─ ACME enabled: ${this.options.smartProxyConfig?.acme?.enabled || false}`);
+            if (this.options.smartProxyConfig?.acme?.enabled) {
+                console.log(`   ├─ ACME email: ${this.options.smartProxyConfig.acme.email || 'not set'}`);
+                console.log(`   └─ ACME mode: ${this.options.smartProxyConfig.acme.useProduction ? 'production' : 'staging'}`);
+            }
+            else {
+                console.log('   └─ ACME: disabled');
+            }
+        }
+        // Email service summary
+        if (this.emailServer && this.options.emailConfig) {
+            console.log('\n📧 Email Service:');
+            const ports = this.options.emailConfig.ports || [];
+            console.log(`   ├─ Ports: ${ports.join(', ')}`);
+            console.log(`   ├─ Hostname: ${this.options.emailConfig.hostname || 'localhost'}`);
+            console.log(`   ├─ Domains configured: ${this.options.emailConfig.domains?.length || 0}`);
+            if (this.options.emailConfig.domains && this.options.emailConfig.domains.length > 0) {
+                this.options.emailConfig.domains.forEach((domain, index) => {
+                    const isLast = index === this.options.emailConfig.domains.length - 1;
+                    console.log(`   ${isLast ? '└─' : '├─'} ${domain.domain} (${domain.dnsMode || 'default'})`);
+                });
+            }
+            console.log(`   └─ DKIM: Initialized for all domains`);
+        }
+        // DNS service summary
+        if (this.dnsServer && this.options.dnsNsDomains && this.options.dnsScopes) {
+            console.log('\n🌍 DNS Service:');
+            console.log(`   ├─ Nameservers: ${this.options.dnsNsDomains.join(', ')}`);
+            console.log(`   ├─ Primary NS: ${this.options.dnsNsDomains[0]}`);
+            console.log(`   ├─ Authoritative for: ${this.options.dnsScopes.length} domains`);
+            console.log(`   ├─ UDP Port: 53`);
+            console.log(`   ├─ DNS-over-HTTPS: Enabled via socket handler`);
+            console.log(`   └─ DNSSEC: ${this.options.dnsNsDomains[0] ? 'Enabled' : 'Disabled'}`);
+            // Show authoritative domains
+            if (this.options.dnsScopes.length > 0) {
+                console.log('\n   Authoritative Domains:');
+                this.options.dnsScopes.forEach((domain, index) => {
+                    const isLast = index === this.options.dnsScopes.length - 1;
+                    console.log(`   ${isLast ? '└─' : '├─'} ${domain}`);
+                });
+            }
+        }
+        // Storage summary
+        if (this.storageManager && this.options.storage) {
+            console.log('\n💾 Storage:');
+            console.log(`   └─ Path: ${this.options.storage.fsPath || 'default'}`);
+        }
+        console.log('\n✅ All services are running\n');
+    }
+    /**
+     * Set up SmartProxy with direct configuration and automatic email routes
+     */
+    async setupSmartProxy() {
+        console.log('[DcRouter] Setting up SmartProxy...');
+        let routes = [];
+        let acmeConfig;
+        // If user provides full SmartProxy config, use it directly
+        if (this.options.smartProxyConfig) {
+            routes = this.options.smartProxyConfig.routes || [];
+            acmeConfig = this.options.smartProxyConfig.acme;
+            console.log(`[DcRouter] Found ${routes.length} routes in config`);
+            console.log(`[DcRouter] ACME config present: ${!!acmeConfig}`);
+        }
+        // If email config exists, automatically add email routes
+        if (this.options.emailConfig) {
+            const emailRoutes = this.generateEmailRoutes(this.options.emailConfig);
+            console.log(`Email Routes are:`);
+            console.log(emailRoutes);
+            routes = [...routes, ...emailRoutes]; // Enable email routing through SmartProxy
+        }
+        // If DNS is configured, add DNS routes
+        if (this.options.dnsNsDomains && this.options.dnsNsDomains.length > 0) {
+            const dnsRoutes = this.generateDnsRoutes();
+            console.log(`DNS Routes for nameservers ${this.options.dnsNsDomains.join(', ')}:`, dnsRoutes);
+            routes = [...routes, ...dnsRoutes];
+        }
+        // Merge TLS/ACME configuration if provided at root level
+        if (this.options.tls && !acmeConfig) {
+            acmeConfig = {
+                accountEmail: this.options.tls.contactEmail,
+                enabled: true,
+                useProduction: true,
+                autoRenew: true,
+                renewThresholdDays: 30
+            };
+        }
+        // Configure DNS challenge if available
+        let challengeHandlers = [];
+        if (this.options.dnsChallenge?.cloudflareApiKey) {
+            console.log('Configuring Cloudflare DNS challenge for ACME');
+            const cloudflareAccount = new plugins.cloudflare.CloudflareAccount(this.options.dnsChallenge.cloudflareApiKey);
+            const dns01Handler = new plugins.smartacme.handlers.Dns01Handler(cloudflareAccount);
+            challengeHandlers.push(dns01Handler);
+        }
+        // If we have routes or need a basic SmartProxy instance, create it
+        if (routes.length > 0 || this.options.smartProxyConfig) {
+            console.log('Setting up SmartProxy with combined configuration');
+            // Create SmartProxy configuration
+            const smartProxyConfig = {
+                ...this.options.smartProxyConfig,
+                routes,
+                acme: acmeConfig
+            };
+            // If we have DNS challenge handlers, enhance the config
+            if (challengeHandlers.length > 0) {
+                // We'll need to pass this to SmartProxy somehow
+                // For now, we'll set it as a property
+                smartProxyConfig.acmeChallengeHandlers = challengeHandlers;
+                smartProxyConfig.acmeChallengePriority = ['dns-01', 'http-01'];
+            }
+            // Create SmartProxy instance
+            console.log('[DcRouter] Creating SmartProxy instance with config:', JSON.stringify({
+                routeCount: smartProxyConfig.routes?.length,
+                acmeEnabled: smartProxyConfig.acme?.enabled,
+                acmeEmail: smartProxyConfig.acme?.email,
+                certProvisionFunction: !!smartProxyConfig.certProvisionFunction
+            }, null, 2));
+            this.smartProxy = new plugins.smartproxy.SmartProxy(smartProxyConfig);
+            // Set up event listeners
+            this.smartProxy.on('error', (err) => {
+                console.error('[DcRouter] SmartProxy error:', err);
+                console.error('[DcRouter] Error stack:', err.stack);
+            });
+            if (acmeConfig) {
+                this.smartProxy.on('certificate-issued', (event) => {
+                    console.log(`[DcRouter] Certificate issued for ${event.domain}, expires ${event.expiryDate}`);
+                });
+                this.smartProxy.on('certificate-renewed', (event) => {
+                    console.log(`[DcRouter] Certificate renewed for ${event.domain}, expires ${event.expiryDate}`);
+                });
+                this.smartProxy.on('certificate-failed', (event) => {
+                    console.error(`[DcRouter] Certificate failed for ${event.domain}:`, event.error);
+                });
+            }
+            // Start SmartProxy
+            console.log('[DcRouter] Starting SmartProxy...');
+            await this.smartProxy.start();
+            console.log('[DcRouter] SmartProxy started successfully');
+            console.log(`SmartProxy started with ${routes.length} routes`);
+        }
+    }
+    /**
+     * Generate SmartProxy routes for email configuration
+     */
+    generateEmailRoutes(emailConfig) {
+        const emailRoutes = [];
+        // Create routes for each email port
+        for (const port of emailConfig.ports) {
+            // Create a descriptive name for the route based on the port
+            let routeName = 'email-route';
+            let tlsMode = 'passthrough';
+            // Handle different email ports differently
+            switch (port) {
+                case 25: // SMTP
+                    routeName = 'smtp-route';
+                    tlsMode = 'passthrough'; // STARTTLS handled by email server
+                    break;
+                case 587: // Submission
+                    routeName = 'submission-route';
+                    tlsMode = 'passthrough'; // STARTTLS handled by email server
+                    break;
+                case 465: // SMTPS
+                    routeName = 'smtps-route';
+                    tlsMode = 'terminate'; // Terminate TLS and re-encrypt to email server
+                    break;
+                default:
+                    routeName = `email-port-${port}-route`;
+                    tlsMode = 'passthrough';
+                    // Check if we have specific settings for this port
+                    if (this.options.emailPortConfig?.portSettings &&
+                        this.options.emailPortConfig.portSettings[port]) {
+                        const portSettings = this.options.emailPortConfig.portSettings[port];
+                        // If this port requires TLS termination, set the mode accordingly
+                        if (portSettings.terminateTls) {
+                            tlsMode = 'terminate';
+                        }
+                        // Override the route name if specified
+                        if (portSettings.routeName) {
+                            routeName = portSettings.routeName;
+                        }
+                    }
+                    break;
+            }
+            // Create action based on mode
+            let action;
+            if (emailConfig.useSocketHandler) {
+                // Socket-handler mode
+                action = {
+                    type: 'socket-handler',
+                    socketHandler: this.createMailSocketHandler(port)
+                };
+            }
+            else {
+                // Traditional forwarding mode
+                const defaultPortMapping = {
+                    25: 10025, // SMTP
+                    587: 10587, // Submission
+                    465: 10465 // SMTPS
+                };
+                const portMapping = this.options.emailPortConfig?.portMapping || defaultPortMapping;
+                const internalPort = portMapping[port] || port + 10000;
+                action = {
+                    type: 'forward',
+                    target: {
+                        host: 'localhost', // Forward to internal email server
+                        port: internalPort
+                    },
+                    tls: {
+                        mode: tlsMode
+                    }
+                };
+            }
+            // For TLS terminate mode, add certificate info
+            if (tlsMode === 'terminate' && action.tls) {
+                action.tls.certificate = 'auto';
+            }
+            // Create the route configuration
+            const routeConfig = {
+                name: routeName,
+                match: {
+                    ports: [port]
+                },
+                action: action
+            };
+            // Add the route to our list
+            emailRoutes.push(routeConfig);
+        }
+        // Add email domain-based routes if configured
+        if (emailConfig.routes) {
+            for (const route of emailConfig.routes) {
+                emailRoutes.push({
+                    name: route.name,
+                    match: {
+                        ports: emailConfig.ports,
+                        domains: route.match.recipients ? [route.match.recipients.toString().split('@')[1]] : []
+                    },
+                    action: {
+                        type: 'forward',
+                        target: route.action.type === 'forward' && route.action.forward ? {
+                            host: route.action.forward.host,
+                            port: route.action.forward.port || 25
+                        } : undefined,
+                        tls: {
+                            mode: 'passthrough'
+                        }
+                    }
+                });
+            }
+        }
+        return emailRoutes;
+    }
+    /**
+     * Generate SmartProxy routes for DNS configuration
+     */
+    generateDnsRoutes() {
+        if (!this.options.dnsNsDomains || this.options.dnsNsDomains.length === 0) {
+            return [];
+        }
+        const dnsRoutes = [];
+        // Create routes for DNS-over-HTTPS paths
+        const dohPaths = ['/dns-query', '/resolve'];
+        // Use the first nameserver domain for DoH routes
+        const primaryNameserver = this.options.dnsNsDomains[0];
+        for (const path of dohPaths) {
+            const dohRoute = {
+                name: `dns-over-https-${path.replace('/', '')}`,
+                match: {
+                    ports: [443], // HTTPS port for DoH
+                    domains: [primaryNameserver],
+                    path: path
+                },
+                action: {
+                    type: 'socket-handler',
+                    socketHandler: this.createDnsSocketHandler()
+                }
+            };
+            dnsRoutes.push(dohRoute);
+        }
+        return dnsRoutes;
+    }
+    /**
+     * 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
+     */
+    isDomainMatch(domain, pattern) {
+        // 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;
+    }
+    async stop() {
+        console.log('Stopping DcRouter services...');
+        await this.opsServer.stop();
+        try {
+            // Stop all services in parallel for faster shutdown
+            await Promise.all([
+                // Stop unified email server if running
+                this.emailServer ? this.emailServer.stop().catch(err => console.error('Error stopping email server:', err)) : Promise.resolve(),
+                // Stop HTTP SmartProxy if running
+                this.smartProxy ? this.smartProxy.stop().catch(err => console.error('Error stopping SmartProxy:', 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
+     */
+    async updateSmartProxyConfig(config) {
+        // 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 (will include email routes if configured)
+        await this.setupSmartProxy();
+        console.log('SmartProxy configuration updated');
+    }
+    /**
+     * Set up unified email handling with pattern-based routing
+     * This implements the consolidated emailConfig approach
+     */
+    async setupUnifiedEmailHandling() {
+        if (!this.options.emailConfig) {
+            throw new Error('Email configuration is required for unified email handling');
+        }
+        // Apply port mapping if behind SmartProxy
+        const portMapping = this.options.emailPortConfig?.portMapping || {
+            25: 10025, // SMTP
+            587: 10587, // Submission
+            465: 10465 // SMTPS
+        };
+        // Create config with mapped ports
+        const emailConfig = {
+            ...this.options.emailConfig,
+            ports: this.options.emailConfig.ports.map(port => portMapping[port] || port + 10000),
+            hostname: 'localhost' // Listen on localhost for SmartProxy forwarding
+        };
+        // Create unified email server
+        this.emailServer = new UnifiedEmailServer(this, emailConfig);
+        // Set up error handling
+        this.emailServer.on('error', (err) => {
+            logger.log('error', `UnifiedEmailServer error: ${err.message}`);
+        });
+        // Start the server
+        await this.emailServer.start();
+        logger.log('info', `Email server started on ports: ${emailConfig.ports.join(', ')}`);
+    }
+    /**
+     * Update the unified email configuration
+     * @param config New email configuration
+     */
+    async updateEmailConfig(config) {
+        // Stop existing email components
+        await this.stopUnifiedEmailComponents();
+        // Update configuration
+        this.options.emailConfig = config;
+        // Start email handling with new configuration
+        await this.setupUnifiedEmailHandling();
+        console.log('Unified email configuration updated');
+    }
+    /**
+     * Stop all unified email components
+     */
+    async stopUnifiedEmailComponents() {
+        try {
+            // Stop the unified email server which contains all components
+            if (this.emailServer) {
+                await this.emailServer.stop();
+                logger.log('info', 'Unified email server stopped');
+                this.emailServer = undefined;
+            }
+            logger.log('info', 'All unified email components stopped');
+        }
+        catch (error) {
+            logger.log('error', `Error stopping unified email components: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Update domain rules for email routing
+     * @param rules New domain rules to apply
+     */
+    async updateEmailRoutes(routes) {
+        // Validate that email config exists
+        if (!this.options.emailConfig) {
+            throw new Error('Email configuration is required before updating routes');
+        }
+        // Update the configuration
+        this.options.emailConfig.routes = routes;
+        // Update the unified email server if it exists
+        if (this.emailServer) {
+            this.emailServer.updateRoutes(routes);
+        }
+        console.log(`Email routes updated with ${routes.length} routes`);
+    }
+    /**
+     * Get statistics from all components
+     */
+    getStats() {
+        const stats = {
+            emailServer: this.emailServer?.getStats()
+        };
+        return stats;
+    }
+    /**
+     * Configure MTA for email handling with custom port and storage settings
+     * @param config Configuration for the MTA service
+     */
+    async configureEmailMta(config) {
+        logger.log('info', 'Configuring MTA service with custom settings');
+        // Update email port configuration
+        if (!this.options.emailPortConfig) {
+            this.options.emailPortConfig = {};
+        }
+        // Configure storage paths for received emails
+        if (config.storagePath) {
+            // Set the storage path for received emails
+            this.options.emailPortConfig.receivedEmailsPath = config.storagePath;
+        }
+        // Apply port mapping if provided
+        if (config.portMapping) {
+            this.options.emailPortConfig.portMapping = {
+                ...this.options.emailPortConfig.portMapping,
+                ...config.portMapping
+            };
+            logger.log('info', `Updated MTA port mappings: ${JSON.stringify(this.options.emailPortConfig.portMapping)}`);
+        }
+        // Use the dedicated helper to configure the email server
+        // Pass through the options specified by the implementation
+        if (this.emailServer) {
+            configureEmailServer(this.emailServer, {
+                ports: [config.internalPort], // Use whatever port the implementation specifies
+                hostname: config.host,
+                tls: config.secure ? {
+                    // Basic TLS settings if secure mode is enabled
+                    certPath: this.options.tls?.certPath,
+                    keyPath: this.options.tls?.keyPath,
+                    caPath: this.options.tls?.caPath
+                } : undefined,
+                storagePath: config.storagePath
+            });
+        }
+        // If email handling is already set up, restart it to apply changes
+        if (this.emailServer) {
+            logger.log('info', 'Restarting unified email handling to apply MTA configuration changes');
+            await this.stopUnifiedEmailComponents();
+            await this.setupUnifiedEmailHandling();
+        }
+        return true;
+    }
+    /**
+     * Register DNS records with the DNS server
+     * @param records Array of DNS records to register
+     */
+    registerDnsRecords(records) {
+        if (!this.dnsServer)
+            return;
+        // Register a separate handler for each record
+        // This ensures multiple records of the same type (like NS records) are all served
+        for (const record of records) {
+            // Register handler for this specific record
+            this.dnsServer.registerHandler(record.name, [record.type], (question) => {
+                // Check if this handler matches the question
+                if (question.name === record.name && question.type === record.type) {
+                    return {
+                        name: record.name,
+                        type: record.type,
+                        class: 'IN',
+                        ttl: record.ttl || 300,
+                        data: this.parseDnsRecordData(record.type, record.value)
+                    };
+                }
+                return null;
+            });
+        }
+        logger.log('info', `Registered ${records.length} DNS handlers (one per record)`);
+    }
+    /**
+     * Parse DNS record data based on record type
+     * @param type DNS record type
+     * @param value DNS record value
+     * @returns Parsed data for the DNS response
+     */
+    parseDnsRecordData(type, value) {
+        switch (type) {
+            case 'A':
+                return value; // IP address as string
+            case 'MX':
+                const [priority, exchange] = value.split(' ');
+                return { priority: parseInt(priority), exchange };
+            case 'TXT':
+                return value;
+            case 'NS':
+                return value;
+            case 'SOA':
+                // SOA format: primary-ns admin-email serial refresh retry expire minimum
+                const parts = value.split(' ');
+                return {
+                    mname: parts[0],
+                    rname: parts[1],
+                    serial: parseInt(parts[2]),
+                    refresh: parseInt(parts[3]),
+                    retry: parseInt(parts[4]),
+                    expire: parseInt(parts[5]),
+                    minimum: parseInt(parts[6])
+                };
+            default:
+                return value;
+        }
+    }
+    /**
+     * Set up DNS server with socket handler for DoH
+     */
+    async setupDnsWithSocketHandler() {
+        if (!this.options.dnsNsDomains || this.options.dnsNsDomains.length === 0) {
+            throw new Error('dnsNsDomains is required for DNS server setup');
+        }
+        if (!this.options.dnsScopes || this.options.dnsScopes.length === 0) {
+            throw new Error('dnsScopes is required for DNS server setup');
+        }
+        const primaryNameserver = this.options.dnsNsDomains[0];
+        logger.log('info', `Setting up DNS server with primary nameserver: ${primaryNameserver}`);
+        // Get VM IP address for UDP binding
+        const networkInterfaces = plugins.os.networkInterfaces();
+        let vmIpAddress = '0.0.0.0'; // Default to all interfaces
+        // Try to find the VM's internal IP address
+        for (const [_name, interfaces] of Object.entries(networkInterfaces)) {
+            if (interfaces) {
+                for (const iface of interfaces) {
+                    if (!iface.internal && iface.family === 'IPv4') {
+                        vmIpAddress = iface.address;
+                        break;
+                    }
+                }
+            }
+        }
+        // Create DNS server instance with manual HTTPS mode
+        this.dnsServer = new plugins.smartdns.dnsServerMod.DnsServer({
+            udpPort: 53,
+            udpBindInterface: vmIpAddress,
+            httpsPort: 443, // Required but won't bind due to manual mode
+            manualHttpsMode: true, // Enable manual HTTPS socket handling
+            dnssecZone: primaryNameserver,
+            primaryNameserver: primaryNameserver, // Automatically generates correct SOA records
+            // For now, use self-signed cert until we integrate with Let's Encrypt
+            httpsKey: '',
+            httpsCert: ''
+        });
+        // Start the DNS server (UDP only)
+        await this.dnsServer.start();
+        logger.log('info', `DNS server started on UDP ${vmIpAddress}:53`);
+        // Validate DNS configuration
+        await this.validateDnsConfiguration();
+        // Generate and register authoritative records
+        const authoritativeRecords = await this.generateAuthoritativeRecords();
+        // Generate email DNS records
+        const emailDnsRecords = await this.generateEmailDnsRecords();
+        // Initialize DKIM for all email domains
+        await this.initializeDkimForEmailDomains();
+        // Load DKIM records from JSON files (they should now exist)
+        const dkimRecords = await this.loadDkimRecords();
+        // Combine all records: authoritative, email, DKIM, and user-defined
+        const allRecords = [...authoritativeRecords, ...emailDnsRecords, ...dkimRecords];
+        if (this.options.dnsRecords && this.options.dnsRecords.length > 0) {
+            allRecords.push(...this.options.dnsRecords);
+        }
+        // Apply proxy IP replacement if configured
+        await this.applyProxyIpReplacement(allRecords);
+        // Register all DNS records
+        if (allRecords.length > 0) {
+            this.registerDnsRecords(allRecords);
+            logger.log('info', `Registered ${allRecords.length} DNS records (${authoritativeRecords.length} authoritative, ${emailDnsRecords.length} email, ${dkimRecords.length} DKIM, ${this.options.dnsRecords?.length || 0} user-defined)`);
+        }
+    }
+    /**
+     * Create DNS socket handler for DoH
+     */
+    createDnsSocketHandler() {
+        return async (socket) => {
+            if (!this.dnsServer) {
+                logger.log('error', 'DNS socket handler called but DNS server not initialized');
+                socket.end();
+                return;
+            }
+            logger.log('debug', 'DNS socket handler: passing socket to DnsServer');
+            try {
+                // Use the built-in socket handler from smartdns
+                // This handles HTTP/2, DoH protocol, etc.
+                await this.dnsServer.handleHttpsSocket(socket);
+            }
+            catch (error) {
+                logger.log('error', `DNS socket handler error: ${error.message}`);
+                socket.destroy();
+            }
+        };
+    }
+    /**
+     * Validate DNS configuration
+     */
+    async validateDnsConfiguration() {
+        if (!this.options.dnsNsDomains || !this.options.dnsScopes) {
+            return;
+        }
+        logger.log('info', 'Validating DNS configuration...');
+        // Check if email domains with internal-dns are in dnsScopes
+        if (this.options.emailConfig?.domains) {
+            for (const domainConfig of this.options.emailConfig.domains) {
+                if (domainConfig.dnsMode === 'internal-dns' &&
+                    !this.options.dnsScopes.includes(domainConfig.domain)) {
+                    logger.log('warn', `Email domain '${domainConfig.domain}' with internal-dns mode is not in dnsScopes. It should be added to dnsScopes.`);
+                }
+            }
+        }
+        // Validate user-provided DNS records are within scopes
+        if (this.options.dnsRecords) {
+            for (const record of this.options.dnsRecords) {
+                const recordDomain = this.extractDomain(record.name);
+                const isInScope = this.options.dnsScopes.some(scope => recordDomain === scope || recordDomain.endsWith(`.${scope}`));
+                if (!isInScope) {
+                    logger.log('warn', `DNS record for '${record.name}' is outside defined scopes [${this.options.dnsScopes.join(', ')}]`);
+                }
+            }
+        }
+    }
+    /**
+     * Generate email DNS records for domains with internal-dns mode
+     */
+    async generateEmailDnsRecords() {
+        const records = [];
+        if (!this.options.emailConfig?.domains) {
+            return records;
+        }
+        // Filter domains with internal-dns mode
+        const internalDnsDomains = this.options.emailConfig.domains.filter(domain => domain.dnsMode === 'internal-dns');
+        for (const domainConfig of internalDnsDomains) {
+            const domain = domainConfig.domain;
+            const ttl = domainConfig.dns?.internal?.ttl || 3600;
+            const mxPriority = domainConfig.dns?.internal?.mxPriority || 10;
+            // MX record - points to the domain itself for email handling
+            records.push({
+                name: domain,
+                type: 'MX',
+                value: `${mxPriority} ${domain}`,
+                ttl
+            });
+            // SPF record - using sensible defaults
+            const spfRecord = 'v=spf1 a mx ~all';
+            records.push({
+                name: domain,
+                type: 'TXT',
+                value: spfRecord,
+                ttl
+            });
+            // DMARC record - using sensible defaults
+            const dmarcPolicy = 'none'; // Start with 'none' policy for monitoring
+            const dmarcEmail = `dmarc@${domain}`;
+            records.push({
+                name: `_dmarc.${domain}`,
+                type: 'TXT',
+                value: `v=DMARC1; p=${dmarcPolicy}; rua=mailto:${dmarcEmail}`,
+                ttl
+            });
+            // Note: DKIM records will be generated later when DKIM keys are available
+            // They require the DKIMCreator which is part of the email server
+        }
+        logger.log('info', `Generated ${records.length} email DNS records for ${internalDnsDomains.length} internal-dns domains`);
+        return records;
+    }
+    /**
+     * Load DKIM records from JSON files
+     * Reads all *.dkimrecord.json files from the DNS records directory
+     */
+    async loadDkimRecords() {
+        const records = [];
+        try {
+            // Ensure paths are imported
+            const dnsDir = paths.dnsRecordsDir;
+            // Check if directory exists
+            if (!plugins.fs.existsSync(dnsDir)) {
+                logger.log('debug', 'No DNS records directory found, skipping DKIM record loading');
+                return records;
+            }
+            // Read all files in the directory
+            const files = plugins.fs.readdirSync(dnsDir);
+            const dkimFiles = files.filter(f => f.endsWith('.dkimrecord.json'));
+            logger.log('info', `Found ${dkimFiles.length} DKIM record files`);
+            // Load each DKIM record
+            for (const file of dkimFiles) {
+                try {
+                    const filePath = plugins.path.join(dnsDir, file);
+                    const fileContent = plugins.fs.readFileSync(filePath, 'utf8');
+                    const dkimRecord = JSON.parse(fileContent);
+                    // Validate record structure
+                    if (dkimRecord.name && dkimRecord.type === 'TXT' && dkimRecord.value) {
+                        records.push({
+                            name: dkimRecord.name,
+                            type: 'TXT',
+                            value: dkimRecord.value,
+                            ttl: 3600 // Standard DKIM TTL
+                        });
+                        logger.log('info', `Loaded DKIM record for ${dkimRecord.name}`);
+                    }
+                    else {
+                        logger.log('warn', `Invalid DKIM record structure in ${file}`);
+                    }
+                }
+                catch (error) {
+                    logger.log('error', `Failed to load DKIM record from ${file}: ${error.message}`);
+                }
+            }
+        }
+        catch (error) {
+            logger.log('error', `Failed to load DKIM records: ${error.message}`);
+        }
+        return records;
+    }
+    /**
+     * Initialize DKIM keys for all configured email domains
+     * This ensures DKIM records are available immediately at startup
+     */
+    async initializeDkimForEmailDomains() {
+        if (!this.options.emailConfig?.domains || !this.emailServer) {
+            return;
+        }
+        logger.log('info', 'Initializing DKIM keys for email domains...');
+        // Get DKIMCreator instance from email server
+        const dkimCreator = this.emailServer.dkimCreator;
+        if (!dkimCreator) {
+            logger.log('warn', 'DKIMCreator not available, skipping DKIM initialization');
+            return;
+        }
+        // Ensure necessary directories exist
+        paths.ensureDirectories();
+        // Generate DKIM keys for each email domain
+        for (const domainConfig of this.options.emailConfig.domains) {
+            try {
+                // Generate DKIM keys for all domains, regardless of DNS mode
+                // This ensures keys are ready even if DNS mode changes later
+                await dkimCreator.handleDKIMKeysForDomain(domainConfig.domain);
+                logger.log('info', `DKIM keys initialized for ${domainConfig.domain}`);
+            }
+            catch (error) {
+                logger.log('error', `Failed to initialize DKIM for ${domainConfig.domain}: ${error.message}`);
+            }
+        }
+        logger.log('info', 'DKIM initialization complete');
+    }
+    /**
+     * Generate authoritative DNS records (NS only) for all domains in dnsScopes
+     * SOA records are now automatically generated by smartdns with primaryNameserver setting
+     */
+    async generateAuthoritativeRecords() {
+        const records = [];
+        if (!this.options.dnsNsDomains || !this.options.dnsScopes) {
+            return records;
+        }
+        // Determine the public IP for nameserver A records
+        let publicIp = null;
+        // Use proxy IPs if configured (these should be public IPs)
+        if (this.options.proxyIps && this.options.proxyIps.length > 0) {
+            publicIp = this.options.proxyIps[0]; // Use first proxy IP
+            logger.log('info', `Using proxy IP for nameserver A records: ${publicIp}`);
+        }
+        else if (this.options.publicIp) {
+            // Use explicitly configured public IP
+            publicIp = this.options.publicIp;
+            logger.log('info', `Using configured public IP for nameserver A records: ${publicIp}`);
+        }
+        else {
+            // Auto-discover public IP using smartnetwork
+            try {
+                logger.log('info', 'Auto-discovering public IP address...');
+                const smartNetwork = new plugins.smartnetwork.SmartNetwork();
+                const publicIps = await smartNetwork.getPublicIps();
+                if (publicIps.v4) {
+                    publicIp = publicIps.v4;
+                    logger.log('info', `Auto-discovered public IPv4: ${publicIp}`);
+                }
+                else {
+                    logger.log('warn', 'Could not auto-discover public IPv4 address');
+                }
+            }
+            catch (error) {
+                logger.log('error', `Failed to auto-discover public IP: ${error.message}`);
+            }
+            if (!publicIp) {
+                logger.log('warn', 'No public IP available. Nameserver A records require either proxyIps, publicIp, or successful auto-discovery.');
+            }
+        }
+        // Generate A records for nameservers if we have a public IP
+        if (publicIp) {
+            for (const nsDomain of this.options.dnsNsDomains) {
+                records.push({
+                    name: nsDomain,
+                    type: 'A',
+                    value: publicIp,
+                    ttl: 3600
+                });
+            }
+            logger.log('info', `Generated A records for ${this.options.dnsNsDomains.length} nameservers`);
+        }
+        // Generate NS records for each domain in scopes
+        for (const domain of this.options.dnsScopes) {
+            // Add NS records for all nameservers
+            for (const nsDomain of this.options.dnsNsDomains) {
+                records.push({
+                    name: domain,
+                    type: 'NS',
+                    value: nsDomain,
+                    ttl: 3600
+                });
+            }
+            // SOA records are now automatically generated by smartdns DnsServer
+            // with the primaryNameserver configuration option
+        }
+        logger.log('info', `Generated ${records.length} total records (A + NS) for ${this.options.dnsScopes.length} domains`);
+        return records;
+    }
+    /**
+     * Extract the base domain from a DNS record name
+     */
+    extractDomain(recordName) {
+        // Handle wildcards
+        if (recordName.startsWith('*.')) {
+            recordName = recordName.substring(2);
+        }
+        return recordName;
+    }
+    /**
+     * Apply proxy IP replacement logic to DNS records
+     */
+    async applyProxyIpReplacement(records) {
+        if (!this.options.proxyIps || this.options.proxyIps.length === 0) {
+            return; // No proxy IPs configured, skip replacement
+        }
+        // Get server's public IP
+        const serverIp = await this.detectServerPublicIp();
+        if (!serverIp) {
+            logger.log('warn', 'Could not detect server public IP, skipping proxy IP replacement');
+            return;
+        }
+        logger.log('info', `Applying proxy IP replacement. Server IP: ${serverIp}, Proxy IPs: ${this.options.proxyIps.join(', ')}`);
+        let proxyIndex = 0;
+        for (const record of records) {
+            if (record.type === 'A' &&
+                record.value === serverIp &&
+                record.useIngressProxy !== false) {
+                // Round-robin through proxy IPs
+                const proxyIp = this.options.proxyIps[proxyIndex % this.options.proxyIps.length];
+                logger.log('info', `Replacing A record for ${record.name}: ${record.value} → ${proxyIp}`);
+                record.value = proxyIp;
+                proxyIndex++;
+            }
+        }
+    }
+    /**
+     * Detect the server's public IP address
+     */
+    async detectServerPublicIp() {
+        try {
+            const smartNetwork = new plugins.smartnetwork.SmartNetwork();
+            const publicIps = await smartNetwork.getPublicIps();
+            if (publicIps.v4) {
+                return publicIps.v4;
+            }
+            return null;
+        }
+        catch (error) {
+            logger.log('warn', `Failed to detect public IP: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * Create mail socket handler for email traffic
+     */
+    createMailSocketHandler(port) {
+        return async (socket) => {
+            if (!this.emailServer) {
+                logger.log('error', 'Mail socket handler called but email server not initialized');
+                socket.end();
+                return;
+            }
+            logger.log('debug', `Mail socket handler: handling connection for port ${port}`);
+            try {
+                // Port 465 requires immediate TLS
+                if (port === 465) {
+                    // Wrap the socket in TLS
+                    const tlsOptions = {
+                        isServer: true,
+                        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
+                    };
+                    const tlsSocket = new plugins.tls.TLSSocket(socket, tlsOptions);
+                    tlsSocket.on('secure', () => {
+                        // Pass the secure socket to the email server
+                        this.emailServer.handleSocket(tlsSocket, port);
+                    });
+                    tlsSocket.on('error', (err) => {
+                        logger.log('error', `TLS handshake error on port ${port}: ${err.message}`);
+                        socket.destroy();
+                    });
+                }
+                else {
+                    // For ports 25 and 587, pass raw socket (STARTTLS handled by email server)
+                    await this.emailServer.handleSocket(socket, port);
+                }
+            }
+            catch (error) {
+                logger.log('error', `Mail socket handler error on port ${port}: ${error.message}`);
+                socket.destroy();
+            }
+        };
+    }
+}
+export default DcRouter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dcrouter.js","sourceRoot":"","sources":["../../ts/classes.dcrouter.ts"],"names":[],"mappings":"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"}