@serve.zone/dcrouter 15.0.1 → 15.0.3

package/dist_ts/dns/classes.dns-server-runtime.d.ts

@@ -0,0 +1,37 @@
+import * as plugins from '../plugins.js';
+import type { DcRouter } from '../classes.dcrouter.js';
+/**
+ * Sets up and feeds the embedded authoritative smartdns server: validates the
+ * DNS configuration, generates authoritative/email/DKIM records, applies
+ * proxy-IP replacement, registers record handlers, wires rate-limited query
+ * logging/metrics, and provides the DoH socket handler for SmartProxy routes.
+ */
+export declare class DnsServerRuntime {
+    private dcRouterRef;
+    private logWindowSecond;
+    private logWindowCount;
+    private batchCount;
+    private batchTimer;
+    constructor(dcRouterRef: DcRouter);
+    /**
+     * Create the DNS server, start it on UDP, wire metrics/logging, and
+     * register all generated records.
+     */
+    setup(): Promise<void>;
+    /**
+     * Create the DoH socket handler SmartProxy routes hand TLS sockets to.
+     */
+    createSocketHandler(): (socket: plugins.net.Socket) => Promise<void>;
+    /** Flush the pending rate-limited query-log batch and reset logging state. */
+    flushQueryLogBatch(): void;
+    private registerRecords;
+    private parseRecordData;
+    private validateConfiguration;
+    private generateEmailDnsRecords;
+    private loadDkimRecords;
+    private initializeDkimForEmailDomains;
+    private generateAuthoritativeRecords;
+    private extractDomain;
+    private applyProxyIpReplacement;
+    private detectServerPublicIp;
+}

package/dist_ts/dns/classes.dns-server-runtime.js

@@ -0,0 +1,449 @@
+import * as plugins from '../plugins.js';
+import * as paths from '../paths.js';
+import { logger } from '../logger.js';
+import { buildEmailDnsRecords } from '../email/index.js';
+/**
+ * Sets up and feeds the embedded authoritative smartdns server: validates the
+ * DNS configuration, generates authoritative/email/DKIM records, applies
+ * proxy-IP replacement, registers record handlers, wires rate-limited query
+ * logging/metrics, and provides the DoH socket handler for SmartProxy routes.
+ */
+export class DnsServerRuntime {
+    dcRouterRef;
+    // Adaptive query-log rate limiting state
+    logWindowSecond = 0; // epoch second of current window
+    logWindowCount = 0; // queries logged this second
+    batchCount = 0;
+    batchTimer = null;
+    constructor(dcRouterRef) {
+        this.dcRouterRef = dcRouterRef;
+    }
+    /**
+     * Create the DNS server, start it on UDP, wire metrics/logging, and
+     * register all generated records.
+     */
+    async setup() {
+        const options = this.dcRouterRef.options;
+        if (!options.dnsNsDomains || options.dnsNsDomains.length === 0) {
+            throw new Error('dnsNsDomains is required for DNS server setup');
+        }
+        if (!options.dnsScopes || options.dnsScopes.length === 0) {
+            throw new Error('dnsScopes is required for DNS server setup');
+        }
+        const primaryNameserver = 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 = options.dnsBindInterface || '0.0.0.0'; // Default to all interfaces
+        // Try to find the VM's internal IP address when no explicit bind address is configured.
+        if (!options.dnsBindInterface) {
+            interfaceLoop: 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 interfaceLoop;
+                        }
+                    }
+                }
+            }
+        }
+        // Create DNS server instance with manual HTTPS mode
+        const 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: ''
+        });
+        this.dcRouterRef.dnsServer = dnsServer;
+        // Start the DNS server (UDP only)
+        await 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.dcRouterRef.metricsManager) {
+            const flushDnsBatch = () => {
+                if (this.batchCount > 0) {
+                    logger.log('info', `DNS: ${this.batchCount} queries processed (rate limited)`, { zone: 'dns' });
+                    this.batchCount = 0;
+                }
+                this.batchTimer = null;
+            };
+            dnsServer.on('query', (event) => {
+                // Metrics tracking
+                for (const question of event.questions) {
+                    this.dcRouterRef.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.logWindowSecond) {
+                    this.logWindowSecond = nowSec;
+                    this.logWindowCount = 0;
+                }
+                if (this.logWindowCount < 2) {
+                    this.logWindowCount++;
+                    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.batchCount++;
+                    if (!this.batchTimer) {
+                        this.batchTimer = setTimeout(flushDnsBatch, 5000);
+                    }
+                }
+            });
+        }
+        // Validate DNS configuration
+        await this.validateConfiguration();
+        // Generate and register authoritative records
+        const authoritativeRecords = await this.generateAuthoritativeRecords();
+        // Generate email DNS records
+        const emailDnsRecords = await this.generateEmailDnsRecords();
+        // Ensure DKIM keys exist for internal-dns domains before generating records.
+        await this.initializeDkimForEmailDomains();
+        // Generate DKIM records directly from smartmta.
+        const dkimRecords = await this.loadDkimRecords();
+        // Combine all records: authoritative, email, DKIM, and user-defined
+        const allRecords = [...authoritativeRecords, ...emailDnsRecords, ...dkimRecords];
+        if (options.dnsRecords && options.dnsRecords.length > 0) {
+            allRecords.push(...options.dnsRecords);
+        }
+        // Apply proxy IP replacement if configured
+        await this.applyProxyIpReplacement(allRecords);
+        // Register all DNS records
+        if (allRecords.length > 0) {
+            this.registerRecords(allRecords);
+            logger.log('info', `Registered ${allRecords.length} DNS records (${authoritativeRecords.length} authoritative, ${emailDnsRecords.length} email, ${dkimRecords.length} DKIM, ${options.dnsRecords?.length || 0} user-defined)`);
+        }
+        // Hand the DnsServer to DnsManager so DB-backed local records on
+        // dcrouter-hosted domains get registered too.
+        if (this.dcRouterRef.dnsManager) {
+            await this.dcRouterRef.dnsManager.attachDnsServer(dnsServer);
+        }
+    }
+    /**
+     * Create the DoH socket handler SmartProxy routes hand TLS sockets to.
+     */
+    createSocketHandler() {
+        return async (socket) => {
+            if (!this.dcRouterRef.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.dcRouterRef.dnsServer.handleHttpsSocket(socket);
+            }
+            catch (error) {
+                logger.log('error', `DNS socket handler error: ${error.message}`);
+                if (!socket.destroyed) {
+                    socket.destroy();
+                }
+            }
+        };
+    }
+    /** Flush the pending rate-limited query-log batch and reset logging state. */
+    flushQueryLogBatch() {
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+            if (this.batchCount > 0) {
+                logger.log('info', `DNS: ${this.batchCount} queries processed (final flush)`, { zone: 'dns' });
+            }
+            this.batchTimer = null;
+            this.batchCount = 0;
+            this.logWindowSecond = 0;
+            this.logWindowCount = 0;
+        }
+    }
+    registerRecords(records) {
+        const dnsServer = this.dcRouterRef.dnsServer;
+        if (!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
+            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.parseRecordData(record.type, record.value)
+                    };
+                }
+                return null;
+            });
+        }
+        logger.log('info', `Registered ${records.length} DNS handlers (one per record)`);
+    }
+    parseRecordData(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;
+        }
+    }
+    async validateConfiguration() {
+        const options = this.dcRouterRef.options;
+        if (!options.dnsNsDomains || !options.dnsScopes) {
+            return;
+        }
+        logger.log('info', 'Validating DNS configuration...');
+        // Check if email domains with internal-dns are in dnsScopes
+        if (options.emailConfig?.domains) {
+            for (const domainConfig of options.emailConfig.domains) {
+                if (domainConfig.dnsMode === 'internal-dns' &&
+                    !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 (options.dnsRecords) {
+            for (const record of options.dnsRecords) {
+                const recordDomain = this.extractDomain(record.name);
+                const isInScope = options.dnsScopes.some(scope => recordDomain === scope || recordDomain.endsWith(`.${scope}`));
+                if (!isInScope) {
+                    logger.log('warn', `DNS record for '${record.name}' is outside defined scopes [${options.dnsScopes.join(', ')}]`);
+                }
+            }
+        }
+    }
+    async generateEmailDnsRecords() {
+        const options = this.dcRouterRef.options;
+        const records = [];
+        if (!options.emailConfig?.domains) {
+            return records;
+        }
+        // Filter domains with internal-dns mode
+        const internalDnsDomains = 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 requiredRecords = buildEmailDnsRecords({
+                domain,
+                hostname: options.emailConfig.hostname,
+                mxPriority: domainConfig.dns?.internal?.mxPriority,
+            }).filter((record) => !record.name.includes('._domainkey.'));
+            for (const record of requiredRecords) {
+                records.push({
+                    name: record.name,
+                    type: record.type,
+                    value: record.value,
+                    ttl,
+                });
+            }
+        }
+        logger.log('info', `Generated ${records.length} email DNS records for ${internalDnsDomains.length} internal-dns domains`);
+        return records;
+    }
+    async loadDkimRecords() {
+        const options = this.dcRouterRef.options;
+        const records = [];
+        if (!options.emailConfig?.domains || !this.dcRouterRef.emailServer?.dkimCreator) {
+            return records;
+        }
+        for (const domainConfig of options.emailConfig.domains) {
+            if (domainConfig.dnsMode !== 'internal-dns') {
+                continue;
+            }
+            const selector = domainConfig.dkim?.selector || 'default';
+            try {
+                const dkimRecord = await this.dcRouterRef.emailServer.dkimCreator.getDNSRecordForDomain(domainConfig.domain, selector);
+                records.push({
+                    name: dkimRecord.name,
+                    type: 'TXT',
+                    value: dkimRecord.value,
+                    ttl: domainConfig.dns?.internal?.ttl || 3600,
+                });
+            }
+            catch (error) {
+                logger.log('error', `Failed to generate DKIM record for ${domainConfig.domain}: ${error.message}`);
+            }
+        }
+        return records;
+    }
+    async initializeDkimForEmailDomains() {
+        const options = this.dcRouterRef.options;
+        if (!options.emailConfig?.domains || !this.dcRouterRef.emailServer) {
+            return;
+        }
+        logger.log('info', 'Initializing DKIM keys for email domains...');
+        // Get DKIMCreator instance from email server (public in smartmta)
+        const dkimCreator = this.dcRouterRef.emailServer.dkimCreator;
+        if (!dkimCreator) {
+            logger.log('warn', 'DKIMCreator not available, skipping DKIM initialization');
+            return;
+        }
+        // Ensure necessary directories exist
+        paths.ensureDataDirectories(this.dcRouterRef.resolvedPaths);
+        // Generate DKIM keys for each internal-dns email domain using the configured selector.
+        for (const domainConfig of options.emailConfig.domains) {
+            if (domainConfig.dnsMode !== 'internal-dns') {
+                continue;
+            }
+            try {
+                await dkimCreator.handleDKIMKeysForSelector(domainConfig.domain, domainConfig.dkim?.selector || 'default', domainConfig.dkim?.keySize || 2048);
+                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');
+    }
+    async generateAuthoritativeRecords() {
+        const options = this.dcRouterRef.options;
+        const records = [];
+        if (!options.dnsNsDomains || !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 (options.proxyIps && options.proxyIps.length > 0) {
+            publicIp = options.proxyIps[0]; // Use first proxy IP
+            logger.log('info', `Using proxy IP for nameserver A records: ${publicIp}`);
+        }
+        else if (options.publicIp) {
+            // Use explicitly configured public IP
+            publicIp = options.publicIp;
+            this.dcRouterRef.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.dcRouterRef.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 options.dnsNsDomains) {
+                records.push({
+                    name: nsDomain,
+                    type: 'A',
+                    value: publicIp,
+                    ttl: 3600
+                });
+            }
+            logger.log('info', `Generated A records for ${options.dnsNsDomains.length} nameservers`);
+        }
+        // Generate NS records for each domain in scopes
+        for (const domain of options.dnsScopes) {
+            // Add NS records for all nameservers
+            for (const nsDomain of 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 ${options.dnsScopes.length} domains`);
+        return records;
+    }
+    extractDomain(recordName) {
+        // Handle wildcards
+        if (recordName.startsWith('*.')) {
+            recordName = recordName.substring(2);
+        }
+        return recordName;
+    }
+    async applyProxyIpReplacement(records) {
+        const options = this.dcRouterRef.options;
+        if (!options.proxyIps || 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: ${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 = options.proxyIps[proxyIndex % options.proxyIps.length];
+                logger.log('info', `Replacing A record for ${record.name}: ${record.value} → ${proxyIp}`);
+                record.value = proxyIp;
+                proxyIndex++;
+            }
+        }
+    }
+    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;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dns-server-runtime.js","sourceRoot":"","sources":["../../../ts/dns/classes.dns-server-runtime.ts"],"names":[],"mappings":"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"}

package/dist_ts/dns/index.d.ts

@@ -1,2 +1,3 @@
 export * from './manager.dns.js';
 export * from './providers/index.js';
+export * from './classes.dns-server-runtime.js';

package/dist_ts/dns/index.js

@@ -1,3 +1,4 @@
 export * from './manager.dns.js';
 export * from './providers/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9kbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHNCQUFzQixDQUFDIn0=
+export * from './classes.dns-server-runtime.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9kbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsaUNBQWlDLENBQUMifQ==

package/dist_ts/email/classes.accepted-email-spool.d.ts

@@ -0,0 +1,55 @@
+import type { IMessageAcceptanceContext, IMessageAcceptanceDecision } from '@push.rocks/smartmta';
+import type { DcRouter } from '../classes.dcrouter.js';
+export declare const DCROUTER_CACHE_ID_HEADER = "X-Dcrouter-Cached-Email-Id";
+export type TSmartMtaQueueItemLike = {
+    processingResult?: {
+        headers?: Record<string, string>;
+        email?: {
+            headers?: Record<string, string>;
+        };
+    };
+    status?: 'pending' | 'processing' | 'queued' | 'delivered' | 'failed' | 'deferred';
+    attempts?: number;
+    nextAttempt?: Date;
+    lastError?: string;
+};
+/**
+ * Accept-then-spool pipeline for inbound SMTP messages: persists accepted
+ * messages as CachedEmail docs, replays them through SmartMTA on an interval,
+ * and mirrors SmartMTA delivery-queue outcomes back onto the cached docs.
+ */
+export declare class AcceptedEmailSpool {
+    private dcRouterRef;
+    private spoolTimer?;
+    private spoolRun?;
+    private processing;
+    private stopping;
+    private queueUpdatePromises;
+    constructor(dcRouterRef: DcRouter);
+    acceptMessage(context: IMessageAcceptanceContext, processAfterAccept?: boolean): Promise<IMessageAcceptanceDecision>;
+    /** Start the interval-driven spool processor and trigger an immediate run. */
+    start(): void;
+    /** Mark the spool as stopping and clear the interval without awaiting in-flight work. */
+    beginStop(): void;
+    /** Stop the spool and wait (bounded) for an in-flight run to settle. */
+    stop(): Promise<void>;
+    /** Kick off a spool run unless one is already in flight. */
+    run(): void;
+    trackQueueUpdate(item: TSmartMtaQueueItemLike, status: 'queued' | 'delivered' | 'failed', failureMessage: string): void;
+    drainQueueUpdates(): Promise<void>;
+    /** Requeue emails left in 'queued' state by a previous process as pending. */
+    recoverQueuedEmails(): Promise<void>;
+    private processSpool;
+    private processAcceptedCachedEmail;
+    private buildCachedEmailSession;
+    private parseCachedEmailRouteData;
+    private updateAcceptedEmailFromQueueItem;
+    private waitForPromiseToSettleWithTimeout;
+    private clearSpoolTimer;
+    private setDcRouterCacheIdHeader;
+    private isCachedEmailTerminal;
+    private getCachedEmailIdFromQueueItem;
+    private getHeaderValue;
+    private removeHeader;
+    private throwIfMessageAcceptanceAborted;
+}