@push.rocks/smartmta 5.1.2 → 5.2.0

package/dist_ts/mail/routing/classes.dns.manager.js

@@ -0,0 +1,415 @@
+import * as plugins from '../../plugins.js';
+import { logger } from '../../logger.js';
+/**
+ * Manages DNS configuration for email domains
+ * Handles both validation and creation of DNS records
+ */
+export class DnsManager {
+    dcRouter;
+    storageManager;
+    constructor(dcRouter) {
+        this.dcRouter = dcRouter;
+        this.storageManager = dcRouter.storageManager;
+    }
+    /**
+     * Validate all domain configurations
+     */
+    async validateAllDomains(domainConfigs) {
+        const results = new Map();
+        for (const config of domainConfigs) {
+            const result = await this.validateDomain(config);
+            results.set(config.domain, result);
+        }
+        return results;
+    }
+    /**
+     * Validate a single domain configuration
+     */
+    async validateDomain(config) {
+        switch (config.dnsMode) {
+            case 'forward':
+                return this.validateForwardMode(config);
+            case 'internal-dns':
+                return this.validateInternalDnsMode(config);
+            case 'external-dns':
+                return this.validateExternalDnsMode(config);
+            default:
+                return {
+                    valid: false,
+                    errors: [`Unknown DNS mode: ${config.dnsMode}`],
+                    warnings: [],
+                    requiredChanges: []
+                };
+        }
+    }
+    /**
+     * Validate forward mode configuration
+     */
+    async validateForwardMode(config) {
+        const result = {
+            valid: true,
+            errors: [],
+            warnings: [],
+            requiredChanges: []
+        };
+        // Forward mode doesn't require DNS validation by default
+        if (!config.dns?.forward?.skipDnsValidation) {
+            logger.log('info', `DNS validation skipped for forward mode domain: ${config.domain}`);
+        }
+        // DKIM keys are still generated for consistency
+        result.warnings.push(`Domain "${config.domain}" uses forward mode. DKIM keys will be generated but signing only happens if email is processed.`);
+        return result;
+    }
+    /**
+     * Validate internal DNS mode configuration
+     */
+    async validateInternalDnsMode(config) {
+        const result = {
+            valid: true,
+            errors: [],
+            warnings: [],
+            requiredChanges: []
+        };
+        // Check if DNS configuration is set up
+        const dnsNsDomains = this.dcRouter.options?.dnsNsDomains;
+        const dnsScopes = this.dcRouter.options?.dnsScopes;
+        if (!dnsNsDomains || dnsNsDomains.length === 0) {
+            result.valid = false;
+            result.errors.push(`Domain "${config.domain}" is configured to use internal DNS, but dnsNsDomains is not set in DcRouter configuration.`);
+            console.error(`❌ ERROR: Domain "${config.domain}" is configured to use internal DNS,\n` +
+                '   but dnsNsDomains is not set in DcRouter configuration.\n' +
+                '   Please configure dnsNsDomains to enable the DNS server.\n' +
+                '   Example: dnsNsDomains: ["ns1.myservice.com", "ns2.myservice.com"]');
+            return result;
+        }
+        if (!dnsScopes || dnsScopes.length === 0) {
+            result.valid = false;
+            result.errors.push(`Domain "${config.domain}" is configured to use internal DNS, but dnsScopes is not set in DcRouter configuration.`);
+            console.error(`❌ ERROR: Domain "${config.domain}" is configured to use internal DNS,\n` +
+                '   but dnsScopes is not set in DcRouter configuration.\n' +
+                '   Please configure dnsScopes to define authoritative domains.\n' +
+                '   Example: dnsScopes: ["myservice.com", "mail.myservice.com"]');
+            return result;
+        }
+        // Check if the email domain is in dnsScopes
+        if (!dnsScopes.includes(config.domain)) {
+            result.valid = false;
+            result.errors.push(`Domain "${config.domain}" is configured to use internal DNS, but is not included in dnsScopes.`);
+            console.error(`❌ ERROR: Domain "${config.domain}" is configured to use internal DNS,\n` +
+                `   but is not included in dnsScopes: [${dnsScopes.join(', ')}].\n` +
+                '   Please add this domain to dnsScopes to enable internal DNS.\n' +
+                `   Example: dnsScopes: [..., "${config.domain}"]`);
+            return result;
+        }
+        const primaryNameserver = dnsNsDomains[0];
+        // Check NS delegation
+        try {
+            const nsRecords = await this.resolveNs(config.domain);
+            const delegatedNameservers = dnsNsDomains.filter(ns => nsRecords.includes(ns));
+            const isDelegated = delegatedNameservers.length > 0;
+            if (!isDelegated) {
+                result.warnings.push(`NS delegation not found for ${config.domain}. Please add NS records at your registrar.`);
+                dnsNsDomains.forEach(ns => {
+                    result.requiredChanges.push(`Add NS record: ${config.domain}. NS ${ns}.`);
+                });
+                console.log(`📋 DNS Delegation Required for ${config.domain}:\n` +
+                    '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n' +
+                    'Please add these NS records at your domain registrar:\n' +
+                    dnsNsDomains.map(ns => `  ${config.domain}. NS ${ns}.`).join('\n') + '\n' +
+                    '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n' +
+                    'This delegation is required for internal DNS mode to work.');
+            }
+            else {
+                console.log(`✅ NS delegation verified: ${config.domain} -> [${delegatedNameservers.join(', ')}]`);
+            }
+        }
+        catch (error) {
+            result.warnings.push(`Could not verify NS delegation for ${config.domain}: ${error.message}`);
+        }
+        return result;
+    }
+    /**
+     * Validate external DNS mode configuration
+     */
+    async validateExternalDnsMode(config) {
+        const result = {
+            valid: true,
+            errors: [],
+            warnings: [],
+            requiredChanges: []
+        };
+        try {
+            // Get current DNS records
+            const records = await this.checkDnsRecords(config);
+            const requiredRecords = config.dns?.external?.requiredRecords || ['MX', 'SPF', 'DKIM', 'DMARC'];
+            // Check MX record
+            if (requiredRecords.includes('MX') && !records.mx?.length) {
+                result.requiredChanges.push(`Add MX record: ${this.getBaseDomain(config.domain)} -> ${config.domain} (priority 10)`);
+            }
+            // Check SPF record
+            if (requiredRecords.includes('SPF') && !records.spf) {
+                result.requiredChanges.push(`Add TXT record: ${this.getBaseDomain(config.domain)} -> "v=spf1 a mx ~all"`);
+            }
+            // Check DKIM record
+            if (requiredRecords.includes('DKIM') && !records.dkim) {
+                const selector = config.dkim?.selector || 'default';
+                const dkimPublicKey = await this.storageManager.get(`/email/dkim/${config.domain}/public.key`);
+                if (dkimPublicKey) {
+                    const publicKeyBase64 = dkimPublicKey
+                        .replace(/-----BEGIN PUBLIC KEY-----/g, '')
+                        .replace(/-----END PUBLIC KEY-----/g, '')
+                        .replace(/\s/g, '');
+                    result.requiredChanges.push(`Add TXT record: ${selector}._domainkey.${config.domain} -> "v=DKIM1; k=rsa; p=${publicKeyBase64}"`);
+                }
+                else {
+                    result.warnings.push(`DKIM public key not found for ${config.domain}. It will be generated on first use.`);
+                }
+            }
+            // Check DMARC record
+            if (requiredRecords.includes('DMARC') && !records.dmarc) {
+                result.requiredChanges.push(`Add TXT record: _dmarc.${this.getBaseDomain(config.domain)} -> "v=DMARC1; p=none; rua=mailto:dmarc@${config.domain}"`);
+            }
+            // Show setup instructions if needed
+            if (result.requiredChanges.length > 0) {
+                console.log(`📋 DNS Configuration Required for ${config.domain}:\n` +
+                    '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n' +
+                    result.requiredChanges.map((change, i) => `${i + 1}. ${change}`).join('\n') +
+                    '\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            }
+        }
+        catch (error) {
+            result.errors.push(`DNS validation failed: ${error.message}`);
+            result.valid = false;
+        }
+        return result;
+    }
+    /**
+     * Check DNS records for a domain
+     */
+    async checkDnsRecords(config) {
+        const records = {};
+        const baseDomain = this.getBaseDomain(config.domain);
+        const selector = config.dkim?.selector || 'default';
+        // Use custom DNS servers if specified
+        const resolver = new plugins.dns.promises.Resolver();
+        if (config.dns?.external?.servers?.length) {
+            resolver.setServers(config.dns.external.servers);
+        }
+        // Check MX records
+        try {
+            const mxRecords = await resolver.resolveMx(baseDomain);
+            records.mx = mxRecords.map(mx => mx.exchange);
+        }
+        catch (error) {
+            logger.log('debug', `No MX records found for ${baseDomain}`);
+        }
+        // Check SPF record
+        try {
+            const txtRecords = await resolver.resolveTxt(baseDomain);
+            const spfRecord = txtRecords.find(records => records.some(record => record.startsWith('v=spf1')));
+            if (spfRecord) {
+                records.spf = spfRecord.join('');
+            }
+        }
+        catch (error) {
+            logger.log('debug', `No SPF record found for ${baseDomain}`);
+        }
+        // Check DKIM record
+        try {
+            const dkimRecords = await resolver.resolveTxt(`${selector}._domainkey.${config.domain}`);
+            const dkimRecord = dkimRecords.find(records => records.some(record => record.includes('v=DKIM1')));
+            if (dkimRecord) {
+                records.dkim = dkimRecord.join('');
+            }
+        }
+        catch (error) {
+            logger.log('debug', `No DKIM record found for ${selector}._domainkey.${config.domain}`);
+        }
+        // Check DMARC record
+        try {
+            const dmarcRecords = await resolver.resolveTxt(`_dmarc.${baseDomain}`);
+            const dmarcRecord = dmarcRecords.find(records => records.some(record => record.startsWith('v=DMARC1')));
+            if (dmarcRecord) {
+                records.dmarc = dmarcRecord.join('');
+            }
+        }
+        catch (error) {
+            logger.log('debug', `No DMARC record found for _dmarc.${baseDomain}`);
+        }
+        return records;
+    }
+    /**
+     * Resolve NS records for a domain
+     */
+    async resolveNs(domain) {
+        try {
+            const resolver = new plugins.dns.promises.Resolver();
+            const nsRecords = await resolver.resolveNs(domain);
+            return nsRecords;
+        }
+        catch (error) {
+            logger.log('warn', `Failed to resolve NS records for ${domain}: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * Get base domain from email domain (e.g., mail.example.com -> example.com)
+     */
+    getBaseDomain(domain) {
+        const parts = domain.split('.');
+        if (parts.length <= 2) {
+            return domain;
+        }
+        // For subdomains like mail.example.com, return example.com
+        // But preserve domain structure for longer TLDs like .co.uk
+        if (parts[parts.length - 2].length <= 3 && parts[parts.length - 1].length === 2) {
+            // Likely a country code TLD like .co.uk
+            return parts.slice(-3).join('.');
+        }
+        return parts.slice(-2).join('.');
+    }
+    /**
+     * Ensure all DNS records are created for configured domains
+     * This is the main entry point for DNS record management
+     */
+    async ensureDnsRecords(domainConfigs, dkimCreator) {
+        logger.log('info', `Ensuring DNS records for ${domainConfigs.length} domains`);
+        // First, validate all domains
+        const validationResults = await this.validateAllDomains(domainConfigs);
+        // Then create records for internal-dns domains
+        const internalDnsDomains = domainConfigs.filter(config => config.dnsMode === 'internal-dns');
+        if (internalDnsDomains.length > 0) {
+            await this.createInternalDnsRecords(internalDnsDomains);
+            // Create DKIM records if DKIMCreator is provided
+            if (dkimCreator) {
+                await this.createDkimRecords(domainConfigs, dkimCreator);
+            }
+        }
+        // Log validation results for external-dns domains
+        for (const [domain, result] of validationResults) {
+            const config = domainConfigs.find(c => c.domain === domain);
+            if (config?.dnsMode === 'external-dns' && result.requiredChanges.length > 0) {
+                logger.log('warn', `External DNS configuration required for ${domain}`);
+            }
+        }
+    }
+    /**
+     * Create DNS records for internal-dns mode domains
+     */
+    async createInternalDnsRecords(domainConfigs) {
+        // Check if DNS server is available
+        if (!this.dcRouter.dnsServer) {
+            logger.log('warn', 'DNS server not available, skipping internal DNS record creation');
+            return;
+        }
+        logger.log('info', `Creating DNS records for ${domainConfigs.length} internal-dns domains`);
+        for (const domainConfig of domainConfigs) {
+            const domain = domainConfig.domain;
+            const ttl = domainConfig.dns?.internal?.ttl || 3600;
+            const mxPriority = domainConfig.dns?.internal?.mxPriority || 10;
+            try {
+                // 1. Register MX record - points to the email domain itself
+                this.dcRouter.dnsServer.registerHandler(domain, ['MX'], () => ({
+                    name: domain,
+                    type: 'MX',
+                    class: 'IN',
+                    ttl: ttl,
+                    data: {
+                        priority: mxPriority,
+                        exchange: domain
+                    }
+                }));
+                logger.log('info', `MX record registered for ${domain} -> ${domain} (priority ${mxPriority})`);
+                // Store MX record in StorageManager
+                await this.storageManager.set(`/email/dns/${domain}/mx`, JSON.stringify({
+                    type: 'MX',
+                    priority: mxPriority,
+                    exchange: domain,
+                    ttl: ttl
+                }));
+                // 2. Register SPF record - allows the domain to send emails
+                const spfRecord = `v=spf1 a mx ~all`;
+                this.dcRouter.dnsServer.registerHandler(domain, ['TXT'], () => ({
+                    name: domain,
+                    type: 'TXT',
+                    class: 'IN',
+                    ttl: ttl,
+                    data: spfRecord
+                }));
+                logger.log('info', `SPF record registered for ${domain}: "${spfRecord}"`);
+                // Store SPF record in StorageManager
+                await this.storageManager.set(`/email/dns/${domain}/spf`, JSON.stringify({
+                    type: 'TXT',
+                    data: spfRecord,
+                    ttl: ttl
+                }));
+                // 3. Register DMARC record - policy for handling email authentication
+                const dmarcRecord = `v=DMARC1; p=none; rua=mailto:dmarc@${domain}`;
+                this.dcRouter.dnsServer.registerHandler(`_dmarc.${domain}`, ['TXT'], () => ({
+                    name: `_dmarc.${domain}`,
+                    type: 'TXT',
+                    class: 'IN',
+                    ttl: ttl,
+                    data: dmarcRecord
+                }));
+                logger.log('info', `DMARC record registered for _dmarc.${domain}: "${dmarcRecord}"`);
+                // Store DMARC record in StorageManager
+                await this.storageManager.set(`/email/dns/${domain}/dmarc`, JSON.stringify({
+                    type: 'TXT',
+                    name: `_dmarc.${domain}`,
+                    data: dmarcRecord,
+                    ttl: ttl
+                }));
+                // Log summary of DNS records created
+                logger.log('info', `✅ DNS records created for ${domain}:
+  - MX: ${domain} (priority ${mxPriority})
+  - SPF: ${spfRecord}
+  - DMARC: ${dmarcRecord}
+  - DKIM: Will be created when keys are generated`);
+            }
+            catch (error) {
+                logger.log('error', `Failed to create DNS records for ${domain}: ${error.message}`);
+            }
+        }
+    }
+    /**
+     * Create DKIM DNS records for all domains
+     */
+    async createDkimRecords(domainConfigs, dkimCreator) {
+        for (const domainConfig of domainConfigs) {
+            const domain = domainConfig.domain;
+            const selector = domainConfig.dkim?.selector || 'default';
+            try {
+                // Get DKIM DNS record from DKIMCreator
+                const dnsRecord = await dkimCreator.getDNSRecordForDomain(domain);
+                // For internal-dns domains, register the DNS handler
+                if (domainConfig.dnsMode === 'internal-dns' && this.dcRouter.dnsServer) {
+                    const ttl = domainConfig.dns?.internal?.ttl || 3600;
+                    this.dcRouter.dnsServer.registerHandler(`${selector}._domainkey.${domain}`, ['TXT'], () => ({
+                        name: `${selector}._domainkey.${domain}`,
+                        type: 'TXT',
+                        class: 'IN',
+                        ttl: ttl,
+                        data: dnsRecord.value
+                    }));
+                    logger.log('info', `DKIM DNS record registered for ${selector}._domainkey.${domain}`);
+                    // Store DKIM record in StorageManager
+                    await this.storageManager.set(`/email/dns/${domain}/dkim`, JSON.stringify({
+                        type: 'TXT',
+                        name: `${selector}._domainkey.${domain}`,
+                        data: dnsRecord.value,
+                        ttl: ttl
+                    }));
+                }
+                // For external-dns domains, just log what should be configured
+                if (domainConfig.dnsMode === 'external-dns') {
+                    logger.log('info', `DKIM record for external DNS: ${dnsRecord.name} -> "${dnsRecord.value}"`);
+                }
+            }
+            catch (error) {
+                logger.log('warn', `Could not create DKIM DNS record for ${domain}: ${error.message}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dns.manager.js","sourceRoot":"","sources":["../../../ts/mail/routing/classes.dns.manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/mail/routing/classes.domain.registry.d.ts

@@ -0,0 +1,54 @@
+import type { IEmailDomainConfig } from './interfaces.js';
+/**
+ * Registry for email domain configurations
+ * Provides fast lookups and validation for domains
+ */
+export declare class DomainRegistry {
+    private domains;
+    private defaults;
+    constructor(domainConfigs: IEmailDomainConfig[], defaults?: {
+        dnsMode?: 'forward' | 'internal-dns' | 'external-dns';
+        dkim?: IEmailDomainConfig['dkim'];
+        rateLimits?: IEmailDomainConfig['rateLimits'];
+    });
+    /**
+     * Get default DKIM configuration
+     */
+    private getDefaultDkimConfig;
+    /**
+     * Apply defaults to a domain configuration
+     */
+    private applyDefaults;
+    /**
+     * Check if a domain is registered
+     */
+    isDomainRegistered(domain: string): boolean;
+    /**
+     * Check if an email address belongs to a registered domain
+     */
+    isEmailRegistered(email: string): boolean;
+    /**
+     * Get domain configuration
+     */
+    getDomainConfig(domain: string): IEmailDomainConfig | undefined;
+    /**
+     * Get domain configuration for an email address
+     */
+    getEmailDomainConfig(email: string): IEmailDomainConfig | undefined;
+    /**
+     * Extract domain from email address
+     */
+    private extractDomain;
+    /**
+     * Get all registered domains
+     */
+    getAllDomains(): string[];
+    /**
+     * Get all domain configurations
+     */
+    getAllConfigs(): IEmailDomainConfig[];
+    /**
+     * Get domains by DNS mode
+     */
+    getDomainsByMode(mode: 'forward' | 'internal-dns' | 'external-dns'): IEmailDomainConfig[];
+}

package/dist_ts/mail/routing/classes.domain.registry.js

@@ -0,0 +1,119 @@
+import { logger } from '../../logger.js';
+/**
+ * Registry for email domain configurations
+ * Provides fast lookups and validation for domains
+ */
+export class DomainRegistry {
+    domains = new Map();
+    defaults;
+    constructor(domainConfigs, defaults) {
+        // Set defaults
+        this.defaults = {
+            dnsMode: defaults?.dnsMode || 'external-dns',
+            ...this.getDefaultDkimConfig(),
+            ...defaults?.dkim,
+            rateLimits: defaults?.rateLimits
+        };
+        // Process and store domain configurations
+        for (const config of domainConfigs) {
+            const processedConfig = this.applyDefaults(config);
+            this.domains.set(config.domain.toLowerCase(), processedConfig);
+            logger.log('info', `Registered domain: ${config.domain} with DNS mode: ${processedConfig.dnsMode}`);
+        }
+    }
+    /**
+     * Get default DKIM configuration
+     */
+    getDefaultDkimConfig() {
+        return {
+            selector: 'default',
+            keySize: 2048,
+            rotateKeys: false,
+            rotationInterval: 90
+        };
+    }
+    /**
+     * Apply defaults to a domain configuration
+     */
+    applyDefaults(config) {
+        return {
+            ...config,
+            dnsMode: config.dnsMode || this.defaults.dnsMode,
+            dkim: {
+                ...this.getDefaultDkimConfig(),
+                ...this.defaults,
+                ...config.dkim
+            },
+            rateLimits: {
+                ...this.defaults.rateLimits,
+                ...config.rateLimits,
+                outbound: {
+                    ...this.defaults.rateLimits?.outbound,
+                    ...config.rateLimits?.outbound
+                },
+                inbound: {
+                    ...this.defaults.rateLimits?.inbound,
+                    ...config.rateLimits?.inbound
+                }
+            }
+        };
+    }
+    /**
+     * Check if a domain is registered
+     */
+    isDomainRegistered(domain) {
+        return this.domains.has(domain.toLowerCase());
+    }
+    /**
+     * Check if an email address belongs to a registered domain
+     */
+    isEmailRegistered(email) {
+        const domain = this.extractDomain(email);
+        if (!domain)
+            return false;
+        return this.isDomainRegistered(domain);
+    }
+    /**
+     * Get domain configuration
+     */
+    getDomainConfig(domain) {
+        return this.domains.get(domain.toLowerCase());
+    }
+    /**
+     * Get domain configuration for an email address
+     */
+    getEmailDomainConfig(email) {
+        const domain = this.extractDomain(email);
+        if (!domain)
+            return undefined;
+        return this.getDomainConfig(domain);
+    }
+    /**
+     * Extract domain from email address
+     */
+    extractDomain(email) {
+        const parts = email.toLowerCase().split('@');
+        if (parts.length !== 2)
+            return null;
+        return parts[1];
+    }
+    /**
+     * Get all registered domains
+     */
+    getAllDomains() {
+        return Array.from(this.domains.keys());
+    }
+    /**
+     * Get all domain configurations
+     */
+    getAllConfigs() {
+        return Array.from(this.domains.values());
+    }
+    /**
+     * Get domains by DNS mode
+     */
+    getDomainsByMode(mode) {
+        return Array.from(this.domains.values()).filter(config => config.dnsMode === mode);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/mail/routing/classes.email.action.executor.d.ts

@@ -0,0 +1,33 @@
+import type { IEmailAction, IEmailContext } from './interfaces.js';
+import { Email } from '../core/classes.email.js';
+import { BounceManager } from '../core/classes.bouncemanager.js';
+import { UnifiedDeliveryQueue } from '../delivery/classes.delivery.queue.js';
+import type { ISmtpSendResult } from '../../security/classes.rustsecuritybridge.js';
+/**
+ * Dependencies injected from UnifiedEmailServer to avoid circular imports
+ */
+export interface IActionExecutorDeps {
+    sendOutboundEmail: (host: string, port: number, email: Email, options?: {
+        auth?: {
+            user: string;
+            pass: string;
+        };
+        dkimDomain?: string;
+        dkimSelector?: string;
+        tlsOpportunistic?: boolean;
+    }) => Promise<ISmtpSendResult>;
+    bounceManager: BounceManager;
+    deliveryQueue: UnifiedDeliveryQueue;
+}
+/**
+ * Executes email routing actions (forward, process, deliver, reject)
+ */
+export declare class EmailActionExecutor {
+    private deps;
+    constructor(deps: IActionExecutorDeps);
+    executeAction(action: IEmailAction, email: Email, context: IEmailContext): Promise<void>;
+    private handleForwardAction;
+    private handleProcessAction;
+    private handleDeliverAction;
+    private handleRejectAction;
+}