@serve.zone/dcrouter 11.14.0 → 11.16.0

package/dist_ts/classes.dcrouter.js

@@ -0,0 +1,1697 @@
+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 from smartmta
+import { UnifiedEmailServer, } from '@push.rocks/smartmta';
+import { logger } from './logger.js';
+// Import storage manager
+import { StorageManager } from './storage/index.js';
+import { StorageBackedCertManager } from './classes.storage-cert-manager.js';
+import { CertProvisionScheduler } from './classes.cert-provision-scheduler.js';
+// Import cache system
+import { CacheDb, CacheCleaner } from './cache/index.js';
+import { OpsServer } from './opsserver/index.js';
+import { MetricsManager } from './monitoring/index.js';
+import { RadiusServer } from './radius/index.js';
+import { RemoteIngressManager, TunnelManager } from './remoteingress/index.js';
+import { VpnManager } from './vpn/index.js';
+import { RouteConfigManager, ApiTokenManager } from './config/index.js';
+import { SecurityLogger, ContentScanner, IPReputationChecker } from './security/index.js';
+import { augmentRoutesWithHttp3 } from './http3/index.js';
+export class DcRouter {
+    options;
+    resolvedPaths;
+    // Core services
+    smartProxy;
+    smartAcme;
+    dnsServer;
+    emailServer;
+    radiusServer;
+    storageManager;
+    opsServer;
+    metricsManager;
+    // Cache system (smartdata + LocalTsmDb)
+    cacheDb;
+    cacheCleaner;
+    // Remote Ingress
+    remoteIngressManager;
+    tunnelManager;
+    // VPN
+    vpnManager;
+    // Programmatic config API
+    routeConfigManager;
+    apiTokenManager;
+    // Auto-discovered public IP (populated by generateAuthoritativeRecords)
+    detectedPublicIp = null;
+    // DNS query logging rate limiter state
+    dnsLogWindowSecond = 0; // epoch second of current window
+    dnsLogWindowCount = 0; // queries logged this second
+    dnsBatchCount = 0;
+    dnsBatchTimer = null;
+    // Certificate status tracking from SmartProxy events (keyed by domain)
+    certificateStatusMap = new Map();
+    // Certificate provisioning scheduler with per-domain backoff
+    certProvisionScheduler;
+    // Service lifecycle management
+    serviceManager;
+    serviceSubjectSubscription;
+    smartAcmeReady = false;
+    // TypedRouter for API endpoints
+    typedrouter = new plugins.typedrequest.TypedRouter();
+    // Cached constructor routes (computed once during setupSmartProxy, used by RouteConfigManager)
+    constructorRoutes = [];
+    // Environment access
+    qenv = new plugins.qenv.Qenv('./', '.nogit/');
+    constructor(optionsArg) {
+        // Set defaults in options
+        this.options = {
+            ...optionsArg
+        };
+        // Resolve all data paths from baseDir
+        this.resolvedPaths = paths.resolvePaths(this.options.baseDir);
+        // Default storage to filesystem if not configured
+        if (!this.options.storage) {
+            this.options.storage = {
+                fsPath: this.resolvedPaths.defaultStoragePath,
+            };
+        }
+        // Initialize storage manager
+        this.storageManager = new StorageManager(this.options.storage);
+        // Initialize service manager and register all services
+        this.serviceManager = new plugins.taskbuffer.ServiceManager({
+            name: 'dcrouter',
+            startupTimeoutMs: 120_000,
+            shutdownTimeoutMs: 30_000,
+        });
+        this.registerServices();
+    }
+    /**
+     * Register all dcrouter services with the ServiceManager.
+     * Services are started in dependency order, with failure isolation for optional services.
+     */
+    registerServices() {
+        // OpsServer: critical, no dependencies — provides visibility
+        this.serviceManager.addService(new plugins.taskbuffer.Service('OpsServer')
+            .critical()
+            .withStart(async () => {
+            this.opsServer = new OpsServer(this);
+            await this.opsServer.start();
+        })
+            .withStop(async () => {
+            await this.opsServer?.stop();
+        })
+            .withRetry({ maxRetries: 0 }));
+        // CacheDb: optional, no dependencies
+        if (this.options.cacheConfig?.enabled !== false) {
+            this.serviceManager.addService(new plugins.taskbuffer.Service('CacheDb')
+                .optional()
+                .withStart(async () => {
+                await this.setupCacheDb();
+            })
+                .withStop(async () => {
+                if (this.cacheCleaner) {
+                    this.cacheCleaner.stop();
+                    this.cacheCleaner = undefined;
+                }
+                if (this.cacheDb) {
+                    await this.cacheDb.stop();
+                    CacheDb.resetInstance();
+                    this.cacheDb = undefined;
+                }
+            })
+                .withRetry({ maxRetries: 2, baseDelayMs: 1000, maxDelayMs: 5000 }));
+        }
+        // MetricsManager: optional, depends on OpsServer
+        this.serviceManager.addService(new plugins.taskbuffer.Service('MetricsManager')
+            .optional()
+            .dependsOn('OpsServer')
+            .withStart(async () => {
+            this.metricsManager = new MetricsManager(this);
+            await this.metricsManager.start();
+        })
+            .withStop(async () => {
+            if (this.metricsManager) {
+                await this.metricsManager.stop();
+                this.metricsManager = undefined;
+            }
+        })
+            .withRetry({ maxRetries: 1, baseDelayMs: 1000 }));
+        // SmartProxy: critical, depends on CacheDb (if enabled)
+        const smartProxyDeps = [];
+        if (this.options.cacheConfig?.enabled !== false) {
+            smartProxyDeps.push('CacheDb');
+        }
+        this.serviceManager.addService(new plugins.taskbuffer.Service('SmartProxy')
+            .critical()
+            .dependsOn(...smartProxyDeps)
+            .withStart(async () => {
+            await this.setupSmartProxy();
+        })
+            .withStop(async () => {
+            if (this.smartProxy) {
+                this.smartProxy.removeAllListeners();
+                await this.smartProxy.stop();
+                this.smartProxy = undefined;
+            }
+        })
+            .withRetry({ maxRetries: 0 }));
+        // SmartAcme: optional, depends on SmartProxy — aggressive retry for rate limits
+        // Only registered if DNS challenge is configured
+        if (this.options.dnsChallenge?.cloudflareApiKey) {
+            this.serviceManager.addService(new plugins.taskbuffer.Service('SmartAcme')
+                .optional()
+                .dependsOn('SmartProxy')
+                .withStart(async () => {
+                if (this.smartAcme) {
+                    await this.smartAcme.start();
+                    this.smartAcmeReady = true;
+                    logger.log('info', 'SmartAcme DNS-01 provider is now ready');
+                    // Re-trigger certificate provisioning for all auto-cert routes.
+                    // During startup, certProvisionFunction returned 'http01' (SmartAcme not ready),
+                    // but Rust ACME is disabled when certProvisionFunction is set — so all domains
+                    // failed silently (SmartProxy doesn't emit certificate-failed for this path).
+                    // Calling updateRoutes() re-triggers provisionCertificatesViaCallback internally,
+                    // which calls certProvisionFunction again — now with smartAcmeReady === true.
+                    if (this.smartProxy) {
+                        if (this.certProvisionScheduler) {
+                            this.certProvisionScheduler.clear();
+                        }
+                        const currentRoutes = this.smartProxy.routeManager.getRoutes();
+                        logger.log('info', `Re-triggering certificate provisioning for ${currentRoutes.length} routes`);
+                        this.smartProxy.updateRoutes(currentRoutes).catch((err) => {
+                            logger.log('warn', `Failed to re-trigger cert provisioning: ${err?.message || err}`);
+                        });
+                    }
+                }
+            })
+                .withStop(async () => {
+                this.smartAcmeReady = false;
+                if (this.smartAcme) {
+                    await this.smartAcme.stop();
+                    this.smartAcme = undefined;
+                }
+            })
+                .withRetry({ maxRetries: 20, baseDelayMs: 5000, maxDelayMs: 3_600_000, backoffFactor: 2 }));
+        }
+        // ConfigManagers: optional, depends on SmartProxy
+        this.serviceManager.addService(new plugins.taskbuffer.Service('ConfigManagers')
+            .optional()
+            .dependsOn('SmartProxy')
+            .withStart(async () => {
+            this.routeConfigManager = new RouteConfigManager(this.storageManager, () => this.getConstructorRoutes(), () => this.smartProxy, () => this.options.http3, this.options.vpnConfig?.enabled
+                ? (tags) => {
+                    if (tags?.length && this.vpnManager) {
+                        return this.vpnManager.getClientIpsForServerDefinedTags(tags);
+                    }
+                    return [this.options.vpnConfig?.subnet || '10.8.0.0/24'];
+                }
+                : undefined);
+            this.apiTokenManager = new ApiTokenManager(this.storageManager);
+            await this.apiTokenManager.initialize();
+            await this.routeConfigManager.initialize();
+        })
+            .withStop(async () => {
+            this.routeConfigManager = undefined;
+            this.apiTokenManager = undefined;
+        })
+            .withRetry({ maxRetries: 2, baseDelayMs: 1000 }));
+        // Email Server: optional, depends on SmartProxy
+        if (this.options.emailConfig) {
+            this.serviceManager.addService(new plugins.taskbuffer.Service('EmailServer')
+                .optional()
+                .dependsOn('SmartProxy')
+                .withStart(async () => {
+                await this.setupUnifiedEmailHandling();
+            })
+                .withStop(async () => {
+                if (this.emailServer) {
+                    if (this.emailServer.deliverySystem) {
+                        this.emailServer.deliverySystem.removeAllListeners();
+                    }
+                    this.emailServer.removeAllListeners();
+                    await this.emailServer.stop();
+                    this.emailServer = undefined;
+                }
+            })
+                .withRetry({ maxRetries: 3, baseDelayMs: 2000, maxDelayMs: 30_000 }));
+        }
+        // DNS Server: optional, depends on SmartProxy
+        if (this.options.dnsNsDomains && this.options.dnsNsDomains.length > 0 && this.options.dnsScopes && this.options.dnsScopes.length > 0) {
+            this.serviceManager.addService(new plugins.taskbuffer.Service('DnsServer')
+                .optional()
+                .dependsOn('SmartProxy')
+                .withStart(async () => {
+                await this.setupDnsWithSocketHandler();
+            })
+                .withStop(async () => {
+                // Flush pending DNS batch log
+                if (this.dnsBatchTimer) {
+                    clearTimeout(this.dnsBatchTimer);
+                    if (this.dnsBatchCount > 0) {
+                        logger.log('info', `DNS: ${this.dnsBatchCount} queries processed (final flush)`, { zone: 'dns' });
+                    }
+                    this.dnsBatchTimer = null;
+                    this.dnsBatchCount = 0;
+                    this.dnsLogWindowSecond = 0;
+                    this.dnsLogWindowCount = 0;
+                }
+                if (this.dnsServer) {
+                    this.dnsServer.removeAllListeners();
+                    await this.dnsServer.stop();
+                    this.dnsServer = undefined;
+                }
+            })
+                .withRetry({ maxRetries: 3, baseDelayMs: 2000, maxDelayMs: 30_000 }));
+        }
+        // RADIUS Server: optional, no dependency on SmartProxy
+        if (this.options.radiusConfig) {
+            this.serviceManager.addService(new plugins.taskbuffer.Service('RadiusServer')
+                .optional()
+                .withStart(async () => {
+                await this.setupRadiusServer();
+            })
+                .withStop(async () => {
+                if (this.radiusServer) {
+                    await this.radiusServer.stop();
+                    this.radiusServer = undefined;
+                }
+            })
+                .withRetry({ maxRetries: 3, baseDelayMs: 2000, maxDelayMs: 30_000 }));
+        }
+        // Remote Ingress: optional, depends on SmartProxy
+        if (this.options.remoteIngressConfig?.enabled) {
+            this.serviceManager.addService(new plugins.taskbuffer.Service('RemoteIngress')
+                .optional()
+                .dependsOn('SmartProxy')
+                .withStart(async () => {
+                await this.setupRemoteIngress();
+            })
+                .withStop(async () => {
+                if (this.tunnelManager) {
+                    await this.tunnelManager.stop();
+                    this.tunnelManager = undefined;
+                }
+                this.remoteIngressManager = undefined;
+            })
+                .withRetry({ maxRetries: 3, baseDelayMs: 2000, maxDelayMs: 30_000 }));
+        }
+        // VPN Server: optional, depends on SmartProxy
+        if (this.options.vpnConfig?.enabled) {
+            this.serviceManager.addService(new plugins.taskbuffer.Service('VpnServer')
+                .optional()
+                .dependsOn('SmartProxy')
+                .withStart(async () => {
+                await this.setupVpnServer();
+            })
+                .withStop(async () => {
+                if (this.vpnManager) {
+                    await this.vpnManager.stop();
+                    this.vpnManager = undefined;
+                }
+            })
+                .withRetry({ maxRetries: 3, baseDelayMs: 2000, maxDelayMs: 30_000 }));
+        }
+        // Wire up aggregated events for logging
+        this.serviceSubjectSubscription = this.serviceManager.serviceSubject.subscribe((event) => {
+            const level = event.type === 'failed' ? 'error' : event.type === 'retrying' ? 'warn' : 'info';
+            logger.log(level, `Service '${event.serviceName}': ${event.type}`, {
+                state: event.state,
+                ...(event.error ? { error: event.error } : {}),
+                ...(event.attempt ? { attempt: event.attempt } : {}),
+            });
+        });
+    }
+    async start() {
+        await this.checkSystemLimits();
+        logger.log('info', 'Starting DcRouter Services');
+        await this.serviceManager.start();
+        this.logStartupSummary();
+    }
+    /**
+     * Detect OS-level resource limits and warn if they are too low for production use.
+     * This is detection only — no attempts to raise limits.
+     */
+    async checkSystemLimits() {
+        try {
+            const fs = new plugins.smartfs.SmartFs(new plugins.smartfs.SmartFsProviderNode());
+            const limitsContent = await fs.file('/proc/self/limits').encoding('utf8').read();
+            const nofileLine = limitsContent.split('\n').find((line) => line.startsWith('Max open files'));
+            if (nofileLine) {
+                const parts = nofileLine.split(/\s{2,}/);
+                const softLimit = parseInt(parts[1], 10);
+                const hardLimit = parseInt(parts[2], 10);
+                if (softLimit < 65536) {
+                    logger.log('warn', `File descriptor soft limit is ${softLimit} (hard: ${hardLimit}). ` +
+                        `For production use, set --ulimit nofile=65536:65536 on the container runtime.`);
+                }
+                else {
+                    logger.log('info', `File descriptor limits: soft=${softLimit}, hard=${hardLimit}`);
+                }
+            }
+        }
+        catch {
+            // Non-Linux or /proc not available — silently skip
+        }
+    }
+    /**
+     * Log comprehensive startup summary
+     */
+    logStartupSummary() {
+        logger.log('info', 'DcRouter Started Successfully');
+        // Metrics summary
+        if (this.metricsManager) {
+            logger.log('info', 'Metrics Service: SmartMetrics active, SmartProxy stats active, real-time tracking enabled');
+        }
+        // SmartProxy summary
+        if (this.smartProxy) {
+            const routeCount = this.options.smartProxyConfig?.routes?.length || 0;
+            const acmeEnabled = this.options.smartProxyConfig?.acme?.enabled || false;
+            const acmeMode = acmeEnabled
+                ? `email=${this.options.smartProxyConfig.acme.email || 'not set'}, mode=${this.options.smartProxyConfig.acme.useProduction ? 'production' : 'staging'}`
+                : 'disabled';
+            logger.log('info', `SmartProxy Service: ${routeCount} routes, ACME: ${acmeMode}`);
+        }
+        // Email service summary
+        if (this.emailServer && this.options.emailConfig) {
+            const ports = this.options.emailConfig.ports || [];
+            const domainCount = this.options.emailConfig.domains?.length || 0;
+            const domainNames = this.options.emailConfig.domains?.map(d => `${d.domain} (${d.dnsMode || 'default'})`).join(', ') || 'none';
+            logger.log('info', `Email Service: ports=[${ports.join(', ')}], hostname=${this.options.emailConfig.hostname || 'localhost'}, domains=${domainCount} [${domainNames}], DKIM initialized`);
+        }
+        // DNS service summary
+        if (this.dnsServer && this.options.dnsNsDomains && this.options.dnsScopes) {
+            logger.log('info', `DNS Service: nameservers=[${this.options.dnsNsDomains.join(', ')}], authoritative for ${this.options.dnsScopes.length} domains [${this.options.dnsScopes.join(', ')}], UDP:53, DoH enabled`);
+        }
+        // RADIUS service summary
+        if (this.radiusServer && this.options.radiusConfig) {
+            const vlanStats = this.radiusServer.getVlanManager().getStats();
+            logger.log('info', `RADIUS Service: auth=${this.options.radiusConfig.authPort || 1812}, acct=${this.options.radiusConfig.acctPort || 1813}, clients=${this.options.radiusConfig.clients?.length || 0}, VLANs=${vlanStats.totalMappings}, accounting=${this.options.radiusConfig.accounting?.enabled ? 'enabled' : 'disabled'}`);
+        }
+        // VPN summary
+        if (this.vpnManager && this.options.vpnConfig?.enabled) {
+            const subnet = this.vpnManager.getSubnet();
+            const wgPort = this.options.vpnConfig.wgListenPort ?? 51820;
+            const clientCount = this.vpnManager.listClients().length;
+            logger.log('info', `VPN Service: subnet=${subnet}, wg=:${wgPort}, clients=${clientCount}`);
+        }
+        // Remote Ingress summary
+        if (this.tunnelManager && this.options.remoteIngressConfig?.enabled) {
+            const edgeCount = this.remoteIngressManager?.getAllEdges().length || 0;
+            const connectedCount = this.tunnelManager.getConnectedCount();
+            logger.log('info', `Remote Ingress: tunnel port=${this.options.remoteIngressConfig.tunnelPort || 8443}, edges=${edgeCount} registered/${connectedCount} connected`);
+        }
+        // Storage summary
+        if (this.storageManager && this.options.storage) {
+            logger.log('info', `Storage: path=${this.options.storage.fsPath || 'default'}`);
+        }
+        // Cache database summary
+        if (this.cacheDb) {
+            logger.log('info', `Cache Database: storage=${this.cacheDb.getStoragePath()}, db=${this.cacheDb.getDbName()}, cleaner=${this.cacheCleaner?.isActive() ? 'active' : 'inactive'} (${(this.options.cacheConfig?.cleanupIntervalHours || 1)}h interval)`);
+        }
+        // Service status summary from ServiceManager
+        const health = this.serviceManager.getHealth();
+        const statuses = health.services;
+        const running = statuses.filter(s => s.state === 'running').length;
+        const failed = statuses.filter(s => s.state === 'failed').length;
+        const retrying = statuses.filter(s => s.state === 'starting' || s.state === 'degraded').length;
+        if (failed > 0) {
+            const failedNames = statuses.filter(s => s.state === 'failed').map(s => `${s.name}: ${s.lastError || 'unknown'}`);
+            logger.log('warn', `DcRouter started in degraded mode — ${running} running, ${failed} failed: ${failedNames.join('; ')}`);
+        }
+        else if (retrying > 0) {
+            logger.log('info', `DcRouter started — ${running} running, ${retrying} still initializing`);
+        }
+        else {
+            logger.log('info', `All ${running} services are running`);
+        }
+    }
+    /**
+     * Set up the cache database (smartdata + LocalTsmDb)
+     */
+    async setupCacheDb() {
+        logger.log('info', 'Setting up CacheDb...');
+        const cacheConfig = this.options.cacheConfig || {};
+        // Initialize CacheDb singleton
+        this.cacheDb = CacheDb.getInstance({
+            storagePath: cacheConfig.storagePath || this.resolvedPaths.defaultTsmDbPath,
+            dbName: cacheConfig.dbName || 'dcrouter',
+            debug: false,
+        });
+        await this.cacheDb.start();
+        // Start the cache cleaner
+        const cleanupIntervalMs = (cacheConfig.cleanupIntervalHours || 1) * 60 * 60 * 1000;
+        this.cacheCleaner = new CacheCleaner(this.cacheDb, {
+            intervalMs: cleanupIntervalMs,
+            verbose: false,
+        });
+        this.cacheCleaner.start();
+        logger.log('info', `CacheDb initialized at ${this.cacheDb.getStoragePath()}`);
+    }
+    /**
+     * Set up SmartProxy with direct configuration and automatic email routes
+     */
+    async setupSmartProxy() {
+        logger.log('info', 'Setting up SmartProxy...');
+        // Clean up any existing SmartProxy instance (e.g. from a retry)
+        if (this.smartProxy) {
+            this.smartProxy.removeAllListeners();
+            this.smartProxy = undefined;
+        }
+        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;
+            logger.log('info', `Found ${routes.length} routes in config, ACME config present: ${!!acmeConfig}`);
+        }
+        // If email config exists, automatically add email routes
+        if (this.options.emailConfig) {
+            const emailRoutes = this.generateEmailRoutes(this.options.emailConfig);
+            logger.log('debug', 'Email routes generated', { routes: JSON.stringify(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();
+            logger.log('debug', `DNS routes for nameservers ${this.options.dnsNsDomains.join(', ')}`, { routes: JSON.stringify(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) {
+            logger.log('info', '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);
+        }
+        // HTTP/3 augmentation (enabled by default unless explicitly disabled)
+        if (this.options.http3?.enabled !== false) {
+            const http3Config = { enabled: true, ...this.options.http3 };
+            routes = augmentRoutesWithHttp3(routes, http3Config);
+            logger.log('info', 'HTTP/3: Augmented qualifying HTTPS routes with QUIC/H3 configuration');
+        }
+        // VPN route security injection: restrict vpn.required routes to VPN subnet
+        if (this.options.vpnConfig?.enabled) {
+            routes = this.injectVpnSecurity(routes);
+        }
+        // Cache constructor routes for RouteConfigManager
+        this.constructorRoutes = [...routes];
+        // If we have routes or need a basic SmartProxy instance, create it
+        if (routes.length > 0 || this.options.smartProxyConfig) {
+            logger.log('info', 'Setting up SmartProxy with combined configuration');
+            // Track cert entries loaded from cert store so we can populate certificateStatusMap after start
+            const loadedCertEntries = [];
+            // Create SmartProxy configuration with sensible gateway defaults.
+            // User's smartProxyConfig overrides these defaults via spread.
+            const smartProxyConfig = {
+                // --- dcrouter gateway defaults ---
+                maxConnectionsPerIP: 100,
+                connectionRateLimitPerMinute: 600,
+                socketTimeout: 120_000,
+                inactivityTimeout: 120_000,
+                keepAlive: true,
+                noDelay: true,
+                gracefulShutdownTimeout: 30_000,
+                // --- user overrides ---
+                ...this.options.smartProxyConfig,
+                // --- deep-merge defaults.security so user can override maxConnections ---
+                defaults: {
+                    ...this.options.smartProxyConfig?.defaults,
+                    security: {
+                        maxConnections: 50_000,
+                        ...this.options.smartProxyConfig?.defaults?.security,
+                    },
+                },
+                // --- always set by dcrouter (after spread) ---
+                routes,
+                acme: acmeConfig,
+                certStore: {
+                    loadAll: async () => {
+                        const keys = await this.storageManager.list('/proxy-certs/');
+                        const certs = [];
+                        for (const key of keys) {
+                            const data = await this.storageManager.getJSON(key);
+                            if (data) {
+                                certs.push(data);
+                                loadedCertEntries.push({ domain: data.domain, publicKey: data.publicKey, validUntil: data.validUntil, validFrom: data.validFrom });
+                            }
+                        }
+                        return certs;
+                    },
+                    save: async (domain, publicKey, privateKey, ca) => {
+                        let validUntil;
+                        let validFrom;
+                        try {
+                            const x509 = new plugins.crypto.X509Certificate(publicKey);
+                            validUntil = new Date(x509.validTo).getTime();
+                            validFrom = new Date(x509.validFrom).getTime();
+                        }
+                        catch { /* PEM parsing failed */ }
+                        await this.storageManager.setJSON(`/proxy-certs/${domain}`, {
+                            domain, publicKey, privateKey, ca, validUntil, validFrom,
+                        });
+                    },
+                    remove: async (domain) => {
+                        await this.storageManager.delete(`/proxy-certs/${domain}`);
+                    },
+                },
+            };
+            // Initialize cert provision scheduler
+            this.certProvisionScheduler = new CertProvisionScheduler(this.storageManager);
+            // If we have DNS challenge handlers, create SmartAcme instance and wire certProvisionFunction
+            // Note: SmartAcme.start() is NOT called here — it runs as a separate optional service
+            // via the ServiceManager, with aggressive retry for rate-limit resilience.
+            if (challengeHandlers.length > 0) {
+                // Stop old SmartAcme if it exists (e.g., during updateSmartProxyConfig)
+                if (this.smartAcme) {
+                    this.smartAcmeReady = false;
+                    await this.smartAcme.stop().catch(err => logger.log('error', 'Error stopping old SmartAcme', { error: String(err) }));
+                }
+                this.smartAcme = new plugins.smartacme.SmartAcme({
+                    accountEmail: acmeConfig?.accountEmail || this.options.tls?.contactEmail || 'admin@example.com',
+                    certManager: new StorageBackedCertManager(this.storageManager),
+                    environment: 'production',
+                    challengeHandlers: challengeHandlers,
+                    challengePriority: ['dns-01'],
+                });
+                const scheduler = this.certProvisionScheduler;
+                smartProxyConfig.certProvisionFunction = async (domain, eventComms) => {
+                    // If SmartAcme is not yet ready (still starting or retrying), fall back to HTTP-01
+                    if (!this.smartAcmeReady) {
+                        eventComms.warn(`SmartAcme not yet initialized, falling back to http-01 for ${domain}`);
+                        return 'http01';
+                    }
+                    // Check backoff before attempting provision
+                    if (await scheduler.isInBackoff(domain)) {
+                        const info = await scheduler.getBackoffInfo(domain);
+                        const msg = `Domain ${domain} is in backoff (${info?.failures} failures), retry after ${info?.retryAfter}`;
+                        eventComms.warn(msg);
+                        throw new Error(msg);
+                    }
+                    try {
+                        // smartacme v9 handles concurrency, per-domain dedup, and rate limiting internally
+                        eventComms.log(`Attempting DNS-01 via SmartAcme for ${domain}`);
+                        eventComms.setSource('smartacme-dns-01');
+                        const isWildcardDomain = domain.startsWith('*.');
+                        const cert = await this.smartAcme.getCertificateForDomain(domain, {
+                            includeWildcard: !isWildcardDomain,
+                        });
+                        // Parse real X509 expiry from PEM (defense-in-depth over SmartAcme's estimate)
+                        let realValidUntil = cert.validUntil;
+                        if (cert.publicKey) {
+                            try {
+                                const x509 = new plugins.crypto.X509Certificate(cert.publicKey);
+                                realValidUntil = new Date(x509.validTo).getTime();
+                            }
+                            catch { /* fallback to SmartAcme's value */ }
+                        }
+                        if (realValidUntil) {
+                            eventComms.setExpiryDate(new Date(realValidUntil));
+                        }
+                        const result = {
+                            id: cert.id,
+                            domainName: cert.domainName,
+                            created: cert.created,
+                            validUntil: realValidUntil,
+                            privateKey: cert.privateKey,
+                            publicKey: cert.publicKey,
+                            csr: cert.csr,
+                        };
+                        // Success — clear any backoff
+                        await scheduler.clearBackoff(domain);
+                        return result;
+                    }
+                    catch (err) {
+                        // Record failure for backoff tracking
+                        await scheduler.recordFailure(domain, err.message);
+                        eventComms.warn(`SmartAcme DNS-01 failed for ${domain}: ${err.message}, falling back to http-01`);
+                        return 'http01';
+                    }
+                };
+            }
+            // When remoteIngress is enabled, the hub binary forwards tunneled connections
+            // to SmartProxy with PROXY protocol v1 headers to preserve client IPs.
+            if (this.options.remoteIngressConfig?.enabled) {
+                smartProxyConfig.acceptProxyProtocol = true;
+                smartProxyConfig.proxyIPs = ['127.0.0.1'];
+            }
+            // VPN uses socket mode with PP v2 — SmartProxy must accept proxy protocol from localhost
+            if (this.options.vpnConfig?.enabled) {
+                smartProxyConfig.acceptProxyProtocol = true;
+                if (!smartProxyConfig.proxyIPs) {
+                    smartProxyConfig.proxyIPs = [];
+                }
+                if (!smartProxyConfig.proxyIPs.includes('127.0.0.1')) {
+                    smartProxyConfig.proxyIPs.push('127.0.0.1');
+                }
+            }
+            // Create SmartProxy instance
+            logger.log('info', `Creating SmartProxy instance: routes=${smartProxyConfig.routes?.length}, acme=${smartProxyConfig.acme?.enabled}, certProvisionFunction=${!!smartProxyConfig.certProvisionFunction}`);
+            this.smartProxy = new plugins.smartproxy.SmartProxy(smartProxyConfig);
+            // Set up event listeners
+            this.smartProxy.on('error', (err) => {
+                logger.log('error', `SmartProxy error: ${err.message}`, { stack: err.stack });
+            });
+            // Always listen for certificate events — emitted by both ACME and certProvisionFunction paths
+            // Events are keyed by domain for domain-centric certificate tracking
+            this.smartProxy.on('certificate-issued', (event) => {
+                logger.log('info', `Certificate issued for ${event.domain} via ${event.source}, expires ${event.expiryDate}`);
+                const routeNames = this.findRouteNamesForDomain(event.domain);
+                this.certificateStatusMap.set(event.domain, {
+                    status: 'valid', routeNames,
+                    expiryDate: event.expiryDate, issuedAt: new Date().toISOString(),
+                    source: event.source,
+                });
+            });
+            this.smartProxy.on('certificate-renewed', (event) => {
+                logger.log('info', `Certificate renewed for ${event.domain} via ${event.source}, expires ${event.expiryDate}`);
+                const routeNames = this.findRouteNamesForDomain(event.domain);
+                this.certificateStatusMap.set(event.domain, {
+                    status: 'valid', routeNames,
+                    expiryDate: event.expiryDate, issuedAt: new Date().toISOString(),
+                    source: event.source,
+                });
+            });
+            this.smartProxy.on('certificate-failed', (event) => {
+                logger.log('error', `Certificate failed for ${event.domain} (${event.source}): ${event.error}`);
+                const routeNames = this.findRouteNamesForDomain(event.domain);
+                this.certificateStatusMap.set(event.domain, {
+                    status: 'failed', routeNames, error: event.error,
+                    source: event.source,
+                });
+            });
+            // Start SmartProxy
+            logger.log('info', 'Starting SmartProxy...');
+            await this.smartProxy.start();
+            logger.log('info', 'SmartProxy started successfully');
+            // Populate certificateStatusMap for certs loaded from store at startup
+            for (const entry of loadedCertEntries) {
+                if (!this.certificateStatusMap.has(entry.domain)) {
+                    const routeNames = this.findRouteNamesForDomain(entry.domain);
+                    let expiryDate;
+                    let issuedAt;
+                    // Use validUntil/validFrom from stored proxy-certs data if available
+                    if (entry.validUntil) {
+                        expiryDate = new Date(entry.validUntil).toISOString();
+                    }
+                    if (entry.validFrom) {
+                        issuedAt = new Date(entry.validFrom).toISOString();
+                    }
+                    // Try SmartAcme /certs/ metadata as secondary source
+                    if (!expiryDate) {
+                        try {
+                            const cleanDomain = entry.domain.replace(/^\*\.?/, '');
+                            const certMeta = await this.storageManager.getJSON(`/certs/${cleanDomain}`);
+                            if (certMeta?.validUntil) {
+                                expiryDate = new Date(certMeta.validUntil).toISOString();
+                            }
+                            if (certMeta?.created && !issuedAt) {
+                                issuedAt = new Date(certMeta.created).toISOString();
+                            }
+                        }
+                        catch { /* no metadata available */ }
+                    }
+                    // Fallback: parse X509 from PEM to get expiry
+                    if (!expiryDate && entry.publicKey) {
+                        try {
+                            const x509 = new plugins.crypto.X509Certificate(entry.publicKey);
+                            expiryDate = new Date(x509.validTo).toISOString();
+                            if (!issuedAt) {
+                                issuedAt = new Date(x509.validFrom).toISOString();
+                            }
+                        }
+                        catch { /* PEM parsing failed */ }
+                    }
+                    this.certificateStatusMap.set(entry.domain, {
+                        status: 'valid',
+                        routeNames,
+                        expiryDate,
+                        issuedAt,
+                        source: 'cert-store',
+                    });
+                }
+            }
+            if (loadedCertEntries.length > 0) {
+                logger.log('info', `Populated certificate status for ${loadedCertEntries.length} store-loaded domain(s)`);
+            }
+            logger.log('info', `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 forward action to route to internal email server ports
+            const defaultPortMapping = {
+                25: 10025, // SMTP
+                587: 10587, // Submission
+                465: 10465 // SMTPS
+            };
+            const portMapping = this.options.emailPortConfig?.portMapping || defaultPortMapping;
+            const internalPort = portMapping[port] || port + 10000;
+            let action = {
+                type: 'forward',
+                targets: [{
+                        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);
+        }
+        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) {
+        domain = domain.toLowerCase();
+        pattern = pattern.toLowerCase();
+        if (domain === pattern)
+            return true;
+        // Routing-glob: *example.com matches example.com, sub.example.com, *.example.com
+        if (pattern.startsWith('*') && !pattern.startsWith('*.')) {
+            const baseDomain = pattern.slice(1); // *nevermind.cloud → nevermind.cloud
+            if (domain === baseDomain || domain === `*.${baseDomain}`)
+                return true;
+            if (domain.endsWith(baseDomain) && domain.length > baseDomain.length)
+                return true;
+        }
+        // Standard wildcard: *.example.com matches sub.example.com and example.com
+        if (pattern.startsWith('*.')) {
+            const suffix = pattern.slice(2);
+            if (domain === suffix)
+                return true;
+            return domain.endsWith(suffix) && domain.length > suffix.length;
+        }
+        return false;
+    }
+    /**
+     * Find ALL route names that match a given domain
+     */
+    findRouteNamesForDomain(domain) {
+        if (!this.smartProxy)
+            return [];
+        const names = [];
+        for (const route of this.smartProxy.routeManager.getRoutes()) {
+            if (!route.match.domains || !route.name)
+                continue;
+            const routeDomains = Array.isArray(route.match.domains)
+                ? route.match.domains
+                : [route.match.domains];
+            for (const pattern of routeDomains) {
+                if (this.isDomainMatch(domain, pattern)) {
+                    names.push(route.name);
+                    break; // This route already matched, no need to check other patterns
+                }
+            }
+        }
+        return names;
+    }
+    /**
+     * Get the routes derived from constructor config (smartProxy + email + DNS).
+     * Used by RouteConfigManager as the "hardcoded" base.
+     */
+    getConstructorRoutes() {
+        return this.constructorRoutes;
+    }
+    async stop() {
+        logger.log('info', 'Stopping DcRouter services...');
+        // Unsubscribe from service events before stopping services
+        if (this.serviceSubjectSubscription) {
+            this.serviceSubjectSubscription.unsubscribe();
+            this.serviceSubjectSubscription = undefined;
+        }
+        // ServiceManager handles reverse-dependency-ordered shutdown
+        await this.serviceManager.stop();
+        // Clear backoff cache in cert scheduler
+        if (this.certProvisionScheduler) {
+            this.certProvisionScheduler.clear();
+            this.certProvisionScheduler = undefined;
+        }
+        this.certificateStatusMap.clear();
+        // Reset security singletons to allow GC
+        SecurityLogger.resetInstance();
+        ContentScanner.resetInstance();
+        IPReputationChecker.resetInstance();
+        logger.log('info', 'All DcRouter services stopped');
+    }
+    /**
+     * Update SmartProxy configuration
+     * @param config New SmartProxy configuration
+     */
+    async updateSmartProxyConfig(config) {
+        // Stop existing SmartProxy if running
+        if (this.smartProxy) {
+            this.smartProxy.removeAllListeners();
+            await this.smartProxy.stop();
+            this.smartProxy = undefined;
+        }
+        // Update configuration
+        this.options.smartProxyConfig = config;
+        // Update routes on RemoteIngressManager so derived ports stay in sync
+        if (this.remoteIngressManager && config.routes) {
+            this.remoteIngressManager.setRoutes(config.routes);
+        }
+        // Start new SmartProxy with updated configuration (will include email routes if configured)
+        await this.setupSmartProxy();
+        // Re-apply programmatic routes and overrides after SmartProxy restart
+        if (this.routeConfigManager) {
+            await this.routeConfigManager.initialize();
+        }
+        logger.log('info', '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
+        };
+        // Transform domains if they are provided as strings
+        let transformedDomains = this.options.emailConfig.domains;
+        if (transformedDomains && transformedDomains.length > 0) {
+            // Check if domains are strings (for backward compatibility)
+            if (typeof transformedDomains[0] === 'string') {
+                transformedDomains = transformedDomains.map((domain) => ({
+                    domain,
+                    dnsMode: 'external-dns',
+                    dkim: {
+                        selector: 'default',
+                        keySize: 2048,
+                        rotateKeys: false,
+                        rotationInterval: 90
+                    }
+                }));
+            }
+        }
+        // Create config with mapped ports
+        const emailConfig = {
+            ...this.options.emailConfig,
+            domains: transformedDomains,
+            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();
+        // Wire delivery events to MetricsManager and logger
+        if (this.metricsManager && this.emailServer.deliverySystem) {
+            this.emailServer.deliverySystem.on('deliveryStart', (item) => {
+                this.metricsManager.trackEmailReceived(item?.from);
+                logger.log('info', `Email delivery started: ${item?.from} → ${item?.to}`, { zone: 'email' });
+            });
+            this.emailServer.deliverySystem.on('deliverySuccess', (item) => {
+                this.metricsManager.trackEmailSent(item?.to);
+                logger.log('info', `Email delivered to ${item?.to}`, { zone: 'email' });
+            });
+            this.emailServer.deliverySystem.on('deliveryFailed', (item, error) => {
+                this.metricsManager.trackEmailFailed(item?.to, error?.message);
+                logger.log('warn', `Email delivery failed to ${item?.to}: ${error?.message}`, { zone: 'email' });
+            });
+        }
+        if (this.metricsManager && this.emailServer) {
+            this.emailServer.on('bounceProcessed', () => {
+                this.metricsManager.trackEmailBounced();
+                logger.log('warn', 'Email bounce processed', { zone: 'email' });
+            });
+        }
+        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();
+        logger.log('info', 'Unified email configuration updated');
+    }
+    /**
+     * Stop all unified email components
+     */
+    async stopUnifiedEmailComponents() {
+        try {
+            // Stop the unified email server which contains all components
+            if (this.emailServer) {
+                // Remove listeners before stopping to prevent leaks on config update cycles
+                if (this.emailServer.deliverySystem) {
+                    this.emailServer.deliverySystem.removeAllListeners();
+                }
+                this.emailServer.removeAllListeners();
+                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.updateEmailRoutes(routes);
+        }
+        logger.log('info', `Email routes updated with ${routes.length} routes`);
+    }
+    /**
+     * Get statistics from all components
+     */
+    getStats() {
+        const stats = {
+            emailServer: this.emailServer?.getStats()
+        };
+        return stats;
+    }
+    /**
+     * 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`);
+        // Wire DNS query events to MetricsManager and logger with adaptive rate limiting
+        if (this.metricsManager && this.dnsServer) {
+            const flushDnsBatch = () => {
+                if (this.dnsBatchCount > 0) {
+                    logger.log('info', `DNS: ${this.dnsBatchCount} queries processed (rate limited)`, { zone: 'dns' });
+                    this.dnsBatchCount = 0;
+                }
+                this.dnsBatchTimer = null;
+            };
+            this.dnsServer.on('query', (event) => {
+                // Metrics tracking
+                for (const question of event.questions) {
+                    this.metricsManager?.trackDnsQuery(question.type, question.name, false, event.responseTimeMs, event.answered);
+                }
+                // Adaptive logging: individual logs up to 2/sec, then batch
+                const nowSec = Math.floor(Date.now() / 1000);
+                if (nowSec !== this.dnsLogWindowSecond) {
+                    this.dnsLogWindowSecond = nowSec;
+                    this.dnsLogWindowCount = 0;
+                }
+                if (this.dnsLogWindowCount < 2) {
+                    this.dnsLogWindowCount++;
+                    const summary = event.questions.map(q => `${q.type} ${q.name}`).join(', ');
+                    logger.log('info', `DNS query: ${summary} (${event.responseTimeMs}ms, ${event.answered ? 'answered' : 'unanswered'})`, { zone: 'dns' });
+                }
+                else {
+                    this.dnsBatchCount++;
+                    if (!this.dnsBatchTimer) {
+                        this.dnsBatchTimer = setTimeout(flushDnsBatch, 5000);
+                    }
+                }
+            });
+        }
+        // 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;
+            }
+            // Prevent uncaught exception from socket 'error' events
+            socket.on('error', (err) => {
+                logger.log('error', `DNS socket error: ${err.message}`);
+                if (!socket.destroyed) {
+                    socket.destroy();
+                }
+            });
+            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}`);
+                if (!socket.destroyed) {
+                    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 = this.resolvedPaths.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 (public in smartmta)
+        const dkimCreator = this.emailServer.dkimCreator;
+        if (!dkimCreator) {
+            logger.log('warn', 'DKIMCreator not available, skipping DKIM initialization');
+            return;
+        }
+        // Ensure necessary directories exist
+        paths.ensureDataDirectories(this.resolvedPaths);
+        // 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;
+            this.detectedPublicIp = 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;
+                    this.detectedPublicIp = publicIp;
+                    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;
+        }
+    }
+    /**
+     * Set up Remote Ingress hub for edge tunnel connections
+     */
+    async setupRemoteIngress() {
+        if (!this.options.remoteIngressConfig?.enabled) {
+            return;
+        }
+        logger.log('info', 'Setting up Remote Ingress hub...');
+        // Initialize the edge registration manager
+        this.remoteIngressManager = new RemoteIngressManager(this.storageManager);
+        await this.remoteIngressManager.initialize();
+        // Pass current routes so the manager can derive edge ports from remoteIngress-tagged routes
+        const currentRoutes = this.constructorRoutes;
+        this.remoteIngressManager.setRoutes(currentRoutes);
+        // Resolve TLS certs for tunnel: explicit paths > ACME for hubDomain > self-signed (Rust default)
+        const riCfg = this.options.remoteIngressConfig;
+        let tlsConfig;
+        // Priority 1: Explicit cert/key file paths
+        if (riCfg.tls?.certPath && riCfg.tls?.keyPath) {
+            try {
+                const certPem = plugins.fs.readFileSync(riCfg.tls.certPath, 'utf8');
+                const keyPem = plugins.fs.readFileSync(riCfg.tls.keyPath, 'utf8');
+                tlsConfig = { certPem, keyPem };
+                logger.log('info', 'Using explicit TLS cert/key for RemoteIngress tunnel');
+            }
+            catch (err) {
+                logger.log('warn', `Failed to read RemoteIngress TLS cert/key files: ${err.message}`);
+            }
+        }
+        // Priority 2: Existing cert from SmartProxy cert store for hubDomain
+        if (!tlsConfig && riCfg.hubDomain) {
+            try {
+                const stored = await this.storageManager.getJSON(`/proxy-certs/${riCfg.hubDomain}`);
+                if (stored?.publicKey && stored?.privateKey) {
+                    tlsConfig = { certPem: stored.publicKey, keyPem: stored.privateKey };
+                    logger.log('info', `Using stored ACME cert for RemoteIngress tunnel TLS: ${riCfg.hubDomain}`);
+                }
+            }
+            catch { /* no stored cert, fall through */ }
+        }
+        if (!tlsConfig) {
+            logger.log('info', 'No TLS cert configured for RemoteIngress tunnel — using auto-generated self-signed');
+        }
+        // Create and start the tunnel manager
+        this.tunnelManager = new TunnelManager(this.remoteIngressManager, {
+            tunnelPort: riCfg.tunnelPort ?? 8443,
+            targetHost: '127.0.0.1',
+            tls: tlsConfig,
+        });
+        await this.tunnelManager.start();
+        const edgeCount = this.remoteIngressManager.getAllEdges().length;
+        logger.log('info', `Remote Ingress hub started on port ${this.options.remoteIngressConfig.tunnelPort || 8443} with ${edgeCount} registered edge(s)`);
+    }
+    /**
+     * Set up VPN server for VPN-based route access control.
+     */
+    async setupVpnServer() {
+        if (!this.options.vpnConfig?.enabled) {
+            return;
+        }
+        logger.log('info', 'Setting up VPN server...');
+        this.vpnManager = new VpnManager(this.storageManager, {
+            subnet: this.options.vpnConfig.subnet,
+            wgListenPort: this.options.vpnConfig.wgListenPort,
+            dns: this.options.vpnConfig.dns,
+            serverEndpoint: this.options.vpnConfig.serverEndpoint,
+            initialClients: this.options.vpnConfig.clients,
+            destinationPolicy: this.options.vpnConfig.destinationPolicy,
+            onClientChanged: () => {
+                // Re-apply routes so tag-based ipAllowLists get updated
+                this.routeConfigManager?.applyRoutes();
+            },
+        });
+        await this.vpnManager.start();
+    }
+    /**
+     * Inject VPN security into routes that have vpn.required === true.
+     * Adds the VPN subnet to security.ipAllowList so only VPN clients can access them.
+     */
+    injectVpnSecurity(routes) {
+        const vpnSubnet = this.options.vpnConfig?.subnet || '10.8.0.0/24';
+        let injectedCount = 0;
+        const result = routes.map((route) => {
+            const dcrouterRoute = route;
+            if (dcrouterRoute.vpn?.required) {
+                injectedCount++;
+                const existing = route.security?.ipAllowList || [];
+                let vpnAllowList;
+                if (dcrouterRoute.vpn.allowedServerDefinedClientTags?.length && this.vpnManager) {
+                    // Tag-based: only specific client IPs
+                    vpnAllowList = this.vpnManager.getClientIpsForServerDefinedTags(dcrouterRoute.vpn.allowedServerDefinedClientTags);
+                }
+                else {
+                    // No tags specified: entire VPN subnet
+                    vpnAllowList = [vpnSubnet];
+                }
+                return {
+                    ...route,
+                    security: {
+                        ...route.security,
+                        ipAllowList: [...existing, ...vpnAllowList],
+                    },
+                };
+            }
+            return route;
+        });
+        if (injectedCount > 0) {
+            logger.log('info', `VPN: Injected ipAllowList into ${injectedCount} VPN-protected route(s)`);
+        }
+        return result;
+    }
+    /**
+     * Set up RADIUS server for network authentication
+     */
+    async setupRadiusServer() {
+        if (!this.options.radiusConfig) {
+            return;
+        }
+        logger.log('info', 'Setting up RADIUS server...');
+        this.radiusServer = new RadiusServer(this.options.radiusConfig, this.storageManager);
+        await this.radiusServer.start();
+        logger.log('info', `RADIUS server started on ports ${this.options.radiusConfig.authPort || 1812} (auth) and ${this.options.radiusConfig.acctPort || 1813} (acct)`);
+    }
+    /**
+     * Update RADIUS configuration at runtime
+     */
+    async updateRadiusConfig(config) {
+        // Stop existing RADIUS server if running
+        if (this.radiusServer) {
+            await this.radiusServer.stop();
+            this.radiusServer = undefined;
+        }
+        // Update configuration
+        this.options.radiusConfig = config;
+        // Start with new configuration
+        await this.setupRadiusServer();
+        logger.log('info', 'RADIUS configuration updated');
+    }
+}
+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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"}