@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/mail/delivery/classes.emailsendjob.d.ts

@@ -0,0 +1,84 @@
+import * as plugins from '../../plugins.js';
+import { Email } from '../core/classes.email.js';
+import type { UnifiedEmailServer } from '../routing/classes.unified.email.server.js';
+export interface IEmailSendOptions {
+    maxRetries?: number;
+    retryDelay?: number;
+    connectionTimeout?: number;
+    tlsOptions?: plugins.tls.ConnectionOptions;
+    debugMode?: boolean;
+}
+export declare enum DeliveryStatus {
+    PENDING = "pending",
+    SENDING = "sending",
+    DELIVERED = "delivered",
+    FAILED = "failed",
+    DEFERRED = "deferred"
+}
+export interface DeliveryInfo {
+    status: DeliveryStatus;
+    attempts: number;
+    error?: Error;
+    lastAttempt?: Date;
+    nextAttempt?: Date;
+    mxServer?: string;
+    deliveryTime?: Date;
+    logs: string[];
+}
+export declare class EmailSendJob {
+    emailServerRef: UnifiedEmailServer;
+    private email;
+    private mxServers;
+    private currentMxIndex;
+    private options;
+    deliveryInfo: DeliveryInfo;
+    constructor(emailServerRef: UnifiedEmailServer, emailArg: Email, options?: IEmailSendOptions);
+    /**
+     * Send the email to its recipients
+     */
+    send(): Promise<DeliveryStatus>;
+    /**
+     * Validate the email before sending
+     */
+    private validateEmail;
+    /**
+     * Resolve MX records for the recipient domain
+     */
+    private resolveMxRecords;
+    /**
+     * Attempt to deliver the email with retries
+     */
+    private attemptDelivery;
+    /**
+     * Connect to a specific MX server and send the email using SmtpClient
+     */
+    private connectAndSend;
+    /**
+     * Record delivery event for monitoring
+     */
+    private recordDeliveryEvent;
+    /**
+     * Check if an error represents a permanent failure
+     */
+    private isPermanentFailure;
+    /**
+     * Resolve MX records for a domain
+     */
+    private resolveMx;
+    /**
+     * Log a message with timestamp
+     */
+    private log;
+    /**
+     * Save successful email to storage
+     */
+    private saveSuccess;
+    /**
+     * Save failed email to storage
+     */
+    private saveFailed;
+    /**
+     * Delay for specified milliseconds
+     */
+    private delay;
+}

package/dist_ts/ts/mail/delivery/classes.emailsendjob.js

@@ -0,0 +1,362 @@
+import * as plugins from '../../plugins.js';
+import * as paths from '../../paths.js';
+import { Email } from '../core/classes.email.js';
+import { EmailSignJob } from './classes.emailsignjob.js';
+// Email delivery status
+export var DeliveryStatus;
+(function (DeliveryStatus) {
+    DeliveryStatus["PENDING"] = "pending";
+    DeliveryStatus["SENDING"] = "sending";
+    DeliveryStatus["DELIVERED"] = "delivered";
+    DeliveryStatus["FAILED"] = "failed";
+    DeliveryStatus["DEFERRED"] = "deferred"; // Temporary failure, will retry
+})(DeliveryStatus || (DeliveryStatus = {}));
+export class EmailSendJob {
+    constructor(emailServerRef, emailArg, options = {}) {
+        this.mxServers = [];
+        this.currentMxIndex = 0;
+        this.email = emailArg;
+        this.emailServerRef = emailServerRef;
+        // Set default options
+        this.options = {
+            maxRetries: options.maxRetries || 3,
+            retryDelay: options.retryDelay || 30000, // 30 seconds
+            connectionTimeout: options.connectionTimeout || 60000, // 60 seconds
+            tlsOptions: options.tlsOptions || {},
+            debugMode: options.debugMode || false
+        };
+        // Initialize delivery info
+        this.deliveryInfo = {
+            status: DeliveryStatus.PENDING,
+            attempts: 0,
+            logs: []
+        };
+    }
+    /**
+     * Send the email to its recipients
+     */
+    async send() {
+        try {
+            // Check if the email is valid before attempting to send
+            this.validateEmail();
+            // Resolve MX records for the recipient domain
+            await this.resolveMxRecords();
+            // Try to send the email
+            return await this.attemptDelivery();
+        }
+        catch (error) {
+            this.log(`Critical error in send process: ${error.message}`);
+            this.deliveryInfo.status = DeliveryStatus.FAILED;
+            this.deliveryInfo.error = error;
+            // Save failed email for potential future retry or analysis
+            await this.saveFailed();
+            return DeliveryStatus.FAILED;
+        }
+    }
+    /**
+     * Validate the email before sending
+     */
+    validateEmail() {
+        if (!this.email.to || this.email.to.length === 0) {
+            throw new Error('No recipients specified');
+        }
+        if (!this.email.from) {
+            throw new Error('No sender specified');
+        }
+        const fromDomain = this.email.getFromDomain();
+        if (!fromDomain) {
+            throw new Error('Invalid sender domain');
+        }
+    }
+    /**
+     * Resolve MX records for the recipient domain
+     */
+    async resolveMxRecords() {
+        const domain = this.email.getPrimaryRecipient()?.split('@')[1];
+        if (!domain) {
+            throw new Error('Invalid recipient domain');
+        }
+        this.log(`Resolving MX records for domain: ${domain}`);
+        try {
+            const addresses = await this.resolveMx(domain);
+            // Sort by priority (lowest number = highest priority)
+            addresses.sort((a, b) => a.priority - b.priority);
+            this.mxServers = addresses.map(mx => mx.exchange);
+            this.log(`Found ${this.mxServers.length} MX servers: ${this.mxServers.join(', ')}`);
+            if (this.mxServers.length === 0) {
+                throw new Error(`No MX records found for domain: ${domain}`);
+            }
+        }
+        catch (error) {
+            this.log(`Failed to resolve MX records: ${error.message}`);
+            throw new Error(`MX lookup failed for ${domain}: ${error.message}`);
+        }
+    }
+    /**
+     * Attempt to deliver the email with retries
+     */
+    async attemptDelivery() {
+        while (this.deliveryInfo.attempts < this.options.maxRetries) {
+            this.deliveryInfo.attempts++;
+            this.deliveryInfo.lastAttempt = new Date();
+            this.deliveryInfo.status = DeliveryStatus.SENDING;
+            try {
+                this.log(`Delivery attempt ${this.deliveryInfo.attempts} of ${this.options.maxRetries}`);
+                // Try each MX server in order of priority
+                while (this.currentMxIndex < this.mxServers.length) {
+                    const currentMx = this.mxServers[this.currentMxIndex];
+                    this.deliveryInfo.mxServer = currentMx;
+                    try {
+                        this.log(`Attempting delivery to MX server: ${currentMx}`);
+                        await this.connectAndSend(currentMx);
+                        // If we get here, email was sent successfully
+                        this.deliveryInfo.status = DeliveryStatus.DELIVERED;
+                        this.deliveryInfo.deliveryTime = new Date();
+                        this.log(`Email delivered successfully to ${currentMx}`);
+                        // Record delivery for sender reputation monitoring
+                        this.recordDeliveryEvent('delivered');
+                        // Save successful email record
+                        await this.saveSuccess();
+                        return DeliveryStatus.DELIVERED;
+                    }
+                    catch (error) {
+                        this.log(`Failed to deliver to ${currentMx}: ${error.message}`);
+                        this.currentMxIndex++;
+                        // If this MX server failed, try the next one
+                        if (this.currentMxIndex >= this.mxServers.length) {
+                            throw error; // No more MX servers to try
+                        }
+                    }
+                }
+                throw new Error('All MX servers failed');
+            }
+            catch (error) {
+                this.deliveryInfo.error = error;
+                // Check if this is a permanent failure
+                if (this.isPermanentFailure(error)) {
+                    this.log('Permanent failure detected, not retrying');
+                    this.deliveryInfo.status = DeliveryStatus.FAILED;
+                    // Record permanent failure for bounce management
+                    this.recordDeliveryEvent('bounced', true);
+                    await this.saveFailed();
+                    return DeliveryStatus.FAILED;
+                }
+                // This is a temporary failure
+                if (this.deliveryInfo.attempts < this.options.maxRetries) {
+                    this.log(`Temporary failure, will retry in ${this.options.retryDelay}ms`);
+                    this.deliveryInfo.status = DeliveryStatus.DEFERRED;
+                    this.deliveryInfo.nextAttempt = new Date(Date.now() + this.options.retryDelay);
+                    // Record temporary failure for monitoring
+                    this.recordDeliveryEvent('deferred');
+                    // Reset MX server index for next retry
+                    this.currentMxIndex = 0;
+                    // Wait before retrying
+                    await this.delay(this.options.retryDelay);
+                }
+            }
+        }
+        // If we get here, all retries failed
+        this.deliveryInfo.status = DeliveryStatus.FAILED;
+        await this.saveFailed();
+        return DeliveryStatus.FAILED;
+    }
+    /**
+     * Connect to a specific MX server and send the email using SmtpClient
+     */
+    async connectAndSend(mxServer) {
+        this.log(`Connecting to ${mxServer}:25`);
+        try {
+            // Check if IP warmup is enabled and get an IP to use
+            let localAddress = undefined;
+            try {
+                const fromDomain = this.email.getFromDomain();
+                const bestIP = this.emailServerRef.getBestIPForSending({
+                    from: this.email.from,
+                    to: this.email.getAllRecipients(),
+                    domain: fromDomain,
+                    isTransactional: this.email.priority === 'high'
+                });
+                if (bestIP) {
+                    this.log(`Using warmed-up IP ${bestIP} for sending`);
+                    localAddress = bestIP;
+                    // Record the send for warm-up tracking
+                    this.emailServerRef.recordIPSend(bestIP);
+                }
+            }
+            catch (error) {
+                this.log(`Error selecting IP address: ${error.message}`);
+            }
+            // Get SMTP client from UnifiedEmailServer
+            const smtpClient = this.emailServerRef.getSmtpClient(mxServer, 25);
+            // Sign the email with DKIM if available
+            let signedEmail = this.email;
+            try {
+                const fromDomain = this.email.getFromDomain();
+                if (fromDomain && this.emailServerRef.hasDkimKey(fromDomain)) {
+                    // Convert email to RFC822 format for signing
+                    const emailMessage = this.email.toRFC822String();
+                    // Create sign job with proper options
+                    const emailSignJob = new EmailSignJob(this.emailServerRef, {
+                        domain: fromDomain,
+                        selector: 'default', // Using default selector
+                        headers: {}, // Headers will be extracted from emailMessage
+                        body: emailMessage
+                    });
+                    // Get the DKIM signature header
+                    const signatureHeader = await emailSignJob.getSignatureHeader(emailMessage);
+                    // Add the signature to the email
+                    if (signatureHeader) {
+                        // For now, we'll use the email as-is since SmtpClient will handle DKIM
+                        this.log(`Email ready for DKIM signing for domain: ${fromDomain}`);
+                    }
+                }
+            }
+            catch (error) {
+                this.log(`Failed to prepare DKIM: ${error.message}`);
+            }
+            // Send the email using SmtpClient
+            const result = await smtpClient.sendMail(signedEmail);
+            if (result.success) {
+                this.log(`Email sent successfully: ${result.response}`);
+                // Record the send for reputation monitoring
+                this.recordDeliveryEvent('delivered');
+            }
+            else {
+                throw new Error(result.error?.message || 'Failed to send email');
+            }
+        }
+        catch (error) {
+            this.log(`Failed to send email via ${mxServer}: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Record delivery event for monitoring
+     */
+    recordDeliveryEvent(eventType, isHardBounce = false) {
+        try {
+            const domain = this.email.getFromDomain();
+            if (domain) {
+                if (eventType === 'delivered') {
+                    this.emailServerRef.recordDelivery(domain);
+                }
+                else if (eventType === 'bounced') {
+                    // Get the receiving domain for bounce recording
+                    let receivingDomain = null;
+                    const primaryRecipient = this.email.getPrimaryRecipient();
+                    if (primaryRecipient) {
+                        receivingDomain = primaryRecipient.split('@')[1];
+                    }
+                    if (receivingDomain) {
+                        this.emailServerRef.recordBounce(domain, receivingDomain, isHardBounce ? 'hard' : 'soft', this.deliveryInfo.error?.message || 'Unknown error');
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.log(`Failed to record delivery event: ${error.message}`);
+        }
+    }
+    /**
+     * Check if an error represents a permanent failure
+     */
+    isPermanentFailure(error) {
+        const permanentFailurePatterns = [
+            'User unknown',
+            'No such user',
+            'Mailbox not found',
+            'Invalid recipient',
+            'Account disabled',
+            'Account suspended',
+            'Domain not found',
+            'No such domain',
+            'Invalid domain',
+            'Relay access denied',
+            'Access denied',
+            'Blacklisted',
+            'Blocked',
+            '550', // Permanent failure SMTP code
+            '551',
+            '552',
+            '553',
+            '554'
+        ];
+        const errorMessage = error.message.toLowerCase();
+        return permanentFailurePatterns.some(pattern => errorMessage.includes(pattern.toLowerCase()));
+    }
+    /**
+     * Resolve MX records for a domain
+     */
+    resolveMx(domain) {
+        return new Promise((resolve, reject) => {
+            plugins.dns.resolveMx(domain, (err, addresses) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(addresses || []);
+                }
+            });
+        });
+    }
+    /**
+     * Log a message with timestamp
+     */
+    log(message) {
+        const timestamp = new Date().toISOString();
+        const logEntry = `[${timestamp}] ${message}`;
+        this.deliveryInfo.logs.push(logEntry);
+        if (this.options.debugMode) {
+            console.log(`[EmailSendJob] ${logEntry}`);
+        }
+    }
+    /**
+     * Save successful email to storage
+     */
+    async saveSuccess() {
+        try {
+            // Use the existing email storage path
+            const emailContent = this.email.toRFC822String();
+            const fileName = `${Date.now()}_${this.email.from}_to_${this.email.to[0]}_success.eml`;
+            const filePath = plugins.path.join(paths.sentEmailsDir, fileName);
+            await plugins.smartfile.fs.ensureDir(paths.sentEmailsDir);
+            await plugins.smartfile.memory.toFs(emailContent, filePath);
+            // Also save delivery info
+            const infoFileName = `${Date.now()}_${this.email.from}_to_${this.email.to[0]}_info.json`;
+            const infoPath = plugins.path.join(paths.sentEmailsDir, infoFileName);
+            await plugins.smartfile.memory.toFs(JSON.stringify(this.deliveryInfo, null, 2), infoPath);
+            this.log(`Email saved to ${fileName}`);
+        }
+        catch (error) {
+            this.log(`Failed to save email: ${error.message}`);
+        }
+    }
+    /**
+     * Save failed email to storage
+     */
+    async saveFailed() {
+        try {
+            // Use the existing email storage path
+            const emailContent = this.email.toRFC822String();
+            const fileName = `${Date.now()}_${this.email.from}_to_${this.email.to[0]}_failed.eml`;
+            const filePath = plugins.path.join(paths.failedEmailsDir, fileName);
+            await plugins.smartfile.fs.ensureDir(paths.failedEmailsDir);
+            await plugins.smartfile.memory.toFs(emailContent, filePath);
+            // Also save delivery info with error details
+            const infoFileName = `${Date.now()}_${this.email.from}_to_${this.email.to[0]}_error.json`;
+            const infoPath = plugins.path.join(paths.failedEmailsDir, infoFileName);
+            await plugins.smartfile.memory.toFs(JSON.stringify(this.deliveryInfo, null, 2), infoPath);
+            this.log(`Failed email saved to ${fileName}`);
+        }
+        catch (error) {
+            this.log(`Failed to save failed email: ${error.message}`);
+        }
+    }
+    /**
+     * Delay for specified milliseconds
+     */
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.emailsendjob.js","sourceRoot":"","sources":["../../../../ts/mail/delivery/classes.emailsendjob.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,KAAK,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAczD,wBAAwB;AACxB,MAAM,CAAN,IAAY,cAMX;AAND,WAAY,cAAc;IACxB,qCAAmB,CAAA;IACnB,qCAAmB,CAAA;IACnB,yCAAuB,CAAA;IACvB,mCAAiB,CAAA;IACjB,uCAAqB,CAAA,CAAC,gCAAgC;AACxD,CAAC,EANW,cAAc,KAAd,cAAc,QAMzB;AAcD,MAAM,OAAO,YAAY;IAQvB,YAAY,cAAkC,EAAE,QAAe,EAAE,UAA6B,EAAE;QALxF,cAAS,GAAa,EAAE,CAAC;QACzB,mBAAc,GAAG,CAAC,CAAC;QAKzB,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC;QACtB,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QAErC,sBAAsB;QACtB,IAAI,CAAC,OAAO,GAAG;YACb,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,CAAC;YACnC,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,KAAK,EAAE,aAAa;YACtD,iBAAiB,EAAE,OAAO,CAAC,iBAAiB,IAAI,KAAK,EAAE,aAAa;YACpE,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,EAAE;YACpC,SAAS,EAAE,OAAO,CAAC,SAAS,IAAI,KAAK;SACtC,CAAC;QAEF,2BAA2B;QAC3B,IAAI,CAAC,YAAY,GAAG;YAClB,MAAM,EAAE,cAAc,CAAC,OAAO;YAC9B,QAAQ,EAAE,CAAC;YACX,IAAI,EAAE,EAAE;SACT,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,IAAI;QACR,IAAI,CAAC;YACH,wDAAwD;YACxD,IAAI,CAAC,aAAa,EAAE,CAAC;YAErB,8CAA8C;YAC9C,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAE9B,wBAAwB;YACxB,OAAO,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QACtC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,GAAG,CAAC,mCAAmC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAC7D,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,cAAc,CAAC,MAAM,CAAC;YACjD,IAAI,CAAC,YAAY,CAAC,KAAK,GAAG,KAAK,CAAC;YAEhC,2DAA2D;YAC3D,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;YACxB,OAAO,cAAc,CAAC,MAAM,CAAC;QAC/B,CAAC;IACH,CAAC;IAED;;OAEG;IACK,aAAa;QACnB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,IAAI,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC7C,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACzC,CAAC;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;QAC9C,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,gBAAgB;QAC5B,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,mBAAmB,EAAE,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAC/D,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC9C,CAAC;QAED,IAAI,CAAC,GAAG,CAAC,oCAAoC,MAAM,EAAE,CAAC,CAAC;QACvD,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YAE/C,sDAAsD;YACtD,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC;YAElD,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;YAClD,IAAI,CAAC,GAAG,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,MAAM,gBAAgB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAEpF,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAChC,MAAM,IAAI,KAAK,CAAC,mCAAmC,MAAM,EAAE,CAAC,CAAC;YAC/D,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,GAAG,CAAC,iCAAiC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAC3D,MAAM,IAAI,KAAK,CAAC,wBAAwB,MAAM,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QACtE,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,eAAe;QAC3B,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;YAC5D,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;YAC7B,IAAI,CAAC,YAAY,CAAC,WAAW,GAAG,IAAI,IAAI,EAAE,CAAC;YAC3C,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,cAAc,CAAC,OAAO,CAAC;YAElD,IAAI,CAAC;gBACH,IAAI,CAAC,GAAG,CAAC,oBAAoB,IAAI,CAAC,YAAY,CAAC,QAAQ,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;gBAEzF,0CAA0C;gBAC1C,OAAO,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;oBACnD,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;oBACtD,IAAI,CAAC,YAAY,CAAC,QAAQ,GAAG,SAAS,CAAC;oBAEvC,IAAI,CAAC;wBACH,IAAI,CAAC,GAAG,CAAC,qCAAqC,SAAS,EAAE,CAAC,CAAC;wBAC3D,MAAM,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;wBAErC,8CAA8C;wBAC9C,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,cAAc,CAAC,SAAS,CAAC;wBACpD,IAAI,CAAC,YAAY,CAAC,YAAY,GAAG,IAAI,IAAI,EAAE,CAAC;wBAC5C,IAAI,CAAC,GAAG,CAAC,mCAAmC,SAAS,EAAE,CAAC,CAAC;wBAEzD,mDAAmD;wBACnD,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;wBAEtC,+BAA+B;wBAC/B,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;wBACzB,OAAO,cAAc,CAAC,SAAS,CAAC;oBAClC,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,IAAI,CAAC,GAAG,CAAC,wBAAwB,SAAS,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;wBAChE,IAAI,CAAC,cAAc,EAAE,CAAC;wBAEtB,6CAA6C;wBAC7C,IAAI,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;4BACjD,MAAM,KAAK,CAAC,CAAC,4BAA4B;wBAC3C,CAAC;oBACH,CAAC;gBACH,CAAC;gBAED,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;YAC3C,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,YAAY,CAAC,KAAK,GAAG,KAAK,CAAC;gBAEhC,uCAAuC;gBACvC,IAAI,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC;oBACnC,IAAI,CAAC,GAAG,CAAC,0CAA0C,CAAC,CAAC;oBACrD,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,cAAc,CAAC,MAAM,CAAC;oBAEjD,iDAAiD;oBACjD,IAAI,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;oBAE1C,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;oBACxB,OAAO,cAAc,CAAC,MAAM,CAAC;gBAC/B,CAAC;gBAED,8BAA8B;gBAC9B,IAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;oBACzD,IAAI,CAAC,GAAG,CAAC,oCAAoC,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,CAAC,CAAC;oBAC1E,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,cAAc,CAAC,QAAQ,CAAC;oBACnD,IAAI,CAAC,YAAY,CAAC,WAAW,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;oBAE/E,0CAA0C;oBAC1C,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC;oBAErC,uCAAuC;oBACvC,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC;oBAExB,uBAAuB;oBACvB,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;gBAC5C,CAAC;YACH,CAAC;QACH,CAAC;QAED,qCAAqC;QACrC,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,cAAc,CAAC,MAAM,CAAC;QACjD,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;QACxB,OAAO,cAAc,CAAC,MAAM,CAAC;IAC/B,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,cAAc,CAAC,QAAgB;QAC3C,IAAI,CAAC,GAAG,CAAC,iBAAiB,QAAQ,KAAK,CAAC,CAAC;QAEzC,IAAI,CAAC;YACH,qDAAqD;YACrD,IAAI,YAAY,GAAuB,SAAS,CAAC;YACjD,IAAI,CAAC;gBACH,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;gBAC9C,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,mBAAmB,CAAC;oBACrD,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;oBACrB,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,gBAAgB,EAAE;oBACjC,MAAM,EAAE,UAAU;oBAClB,eAAe,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,KAAK,MAAM;iBAChD,CAAC,CAAC;gBAEH,IAAI,MAAM,EAAE,CAAC;oBACX,IAAI,CAAC,GAAG,CAAC,sBAAsB,MAAM,cAAc,CAAC,CAAC;oBACrD,YAAY,GAAG,MAAM,CAAC;oBAEtB,uCAAuC;oBACvC,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;gBAC3C,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,GAAG,CAAC,+BAA+B,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAC3D,CAAC;YAED,0CAA0C;YAC1C,MAAM,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;YAEnE,wCAAwC;YACxC,IAAI,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC;YAC7B,IAAI,CAAC;gBACH,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;gBAC9C,IAAI,UAAU,IAAI,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;oBAC7D,6CAA6C;oBAC7C,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;oBAEjD,sCAAsC;oBACtC,MAAM,YAAY,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,cAAc,EAAE;wBACzD,MAAM,EAAE,UAAU;wBAClB,QAAQ,EAAE,SAAS,EAAE,yBAAyB;wBAC9C,OAAO,EAAE,EAAE,EAAE,8CAA8C;wBAC3D,IAAI,EAAE,YAAY;qBACnB,CAAC,CAAC;oBAEH,gCAAgC;oBAChC,MAAM,eAAe,GAAG,MAAM,YAAY,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAC;oBAE5E,iCAAiC;oBACjC,IAAI,eAAe,EAAE,CAAC;wBACpB,uEAAuE;wBACvE,IAAI,CAAC,GAAG,CAAC,4CAA4C,UAAU,EAAE,CAAC,CAAC;oBACrE,CAAC;gBACH,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,GAAG,CAAC,2BAA2B,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACvD,CAAC;YAED,kCAAkC;YAClC,MAAM,MAAM,GAAoB,MAAM,UAAU,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;YAEvE,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBACnB,IAAI,CAAC,GAAG,CAAC,4BAA4B,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAExD,4CAA4C;gBAC5C,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;YACxC,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,IAAI,sBAAsB,CAAC,CAAC;YACnE,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,GAAG,CAAC,4BAA4B,QAAQ,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACnE,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACK,mBAAmB,CACzB,SAA+C,EAC/C,eAAwB,KAAK;QAE7B,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;YAC1C,IAAI,MAAM,EAAE,CAAC;gBACX,IAAI,SAAS,KAAK,WAAW,EAAE,CAAC;oBAC9B,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;gBAC7C,CAAC;qBAAM,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;oBACnC,gDAAgD;oBAChD,IAAI,eAAe,GAAG,IAAI,CAAC;oBAC3B,MAAM,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,mBAAmB,EAAE,CAAC;oBAC1D,IAAI,gBAAgB,EAAE,CAAC;wBACrB,eAAe,GAAG,gBAAgB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;oBACnD,CAAC;oBAED,IAAI,eAAe,EAAE,CAAC;wBACpB,IAAI,CAAC,cAAc,CAAC,YAAY,CAC9B,MAAM,EACN,eAAe,EACf,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAC9B,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,OAAO,IAAI,eAAe,CACpD,CAAC;oBACJ,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,GAAG,CAAC,oCAAoC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QAChE,CAAC;IACH,CAAC;IAED;;OAEG;IACK,kBAAkB,CAAC,KAAY;QACrC,MAAM,wBAAwB,GAAG;YAC/B,cAAc;YACd,cAAc;YACd,mBAAmB;YACnB,mBAAmB;YACnB,kBAAkB;YAClB,mBAAmB;YACnB,kBAAkB;YAClB,gBAAgB;YAChB,gBAAgB;YAChB,qBAAqB;YACrB,eAAe;YACf,aAAa;YACb,SAAS;YACT,KAAK,EAAE,8BAA8B;YACrC,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;SACN,CAAC;QAEF,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;QACjD,OAAO,wBAAwB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAC7C,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,CAC7C,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,SAAS,CAAC,MAAc;QAC9B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,SAAS,EAAE,EAAE;gBAC/C,IAAI,GAAG,EAAE,CAAC;oBACR,MAAM,CAAC,GAAG,CAAC,CAAC;gBACd,CAAC;qBAAM,CAAC;oBACN,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC;gBAC3B,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,GAAG,CAAC,OAAe;QACzB,MAAM,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAC3C,MAAM,QAAQ,GAAG,IAAI,SAAS,KAAK,OAAO,EAAE,CAAC;QAC7C,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAEtC,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;YAC3B,OAAO,CAAC,GAAG,CAAC,kBAAkB,QAAQ,EAAE,CAAC,CAAC;QAC5C,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,WAAW;QACvB,IAAI,CAAC;YACH,sCAAsC;YACtC,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;YACjD,MAAM,QAAQ,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC;YACvF,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;YAElE,MAAM,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;YAC1D,MAAM,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;YAE5D,0BAA0B;YAC1B,MAAM,YAAY,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC;YACzF,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;YACtE,MAAM,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;YAE1F,IAAI,CAAC,GAAG,CAAC,kBAAkB,QAAQ,EAAE,CAAC,CAAC;QACzC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,GAAG,CAAC,yBAAyB,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QACrD,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,UAAU;QACtB,IAAI,CAAC;YACH,sCAAsC;YACtC,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;YACjD,MAAM,QAAQ,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC;YACtF,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAC;YAEpE,MAAM,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;YAC5D,MAAM,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;YAE5D,6CAA6C;YAC7C,MAAM,YAAY,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC;YAC1F,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,YAAY,CAAC,CAAC;YACxE,MAAM,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;YAE1F,IAAI,CAAC,GAAG,CAAC,yBAAyB,QAAQ,EAAE,CAAC,CAAC;QAChD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,GAAG,CAAC,gCAAgC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QAC5D,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,EAAU;QACtB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;IACzD,CAAC;CACF"}

package/dist_ts/ts/mail/delivery/classes.emailsignjob.d.ts

@@ -0,0 +1,18 @@
+import type { UnifiedEmailServer } from '../routing/classes.unified.email.server.js';
+interface Headers {
+    [key: string]: string;
+}
+interface IEmailSignJobOptions {
+    domain: string;
+    selector: string;
+    headers: Headers;
+    body: string;
+}
+export declare class EmailSignJob {
+    emailServerRef: UnifiedEmailServer;
+    jobOptions: IEmailSignJobOptions;
+    constructor(emailServerRef: UnifiedEmailServer, options: IEmailSignJobOptions);
+    loadPrivateKey(): Promise<string>;
+    getSignatureHeader(emailMessage: string): Promise<string>;
+}
+export {};

package/dist_ts/ts/mail/delivery/classes.emailsignjob.js

@@ -0,0 +1,44 @@
+import * as plugins from '../../plugins.js';
+export class EmailSignJob {
+    constructor(emailServerRef, options) {
+        this.emailServerRef = emailServerRef;
+        this.jobOptions = options;
+    }
+    async loadPrivateKey() {
+        const keyInfo = await this.emailServerRef.dkimCreator.readDKIMKeys(this.jobOptions.domain);
+        return keyInfo.privateKey;
+    }
+    async getSignatureHeader(emailMessage) {
+        const signResult = await plugins.dkimSign(emailMessage, {
+            // Optional, default canonicalization, default is "relaxed/relaxed"
+            canonicalization: 'relaxed/relaxed', // c=
+            // Optional, default signing and hashing algorithm
+            // Mostly useful when you want to use rsa-sha1, otherwise no need to set
+            algorithm: 'rsa-sha256',
+            // Optional, default is current time
+            signTime: new Date(), // t=
+            // Keys for one or more signatures
+            // Different signatures can use different algorithms (mostly useful when
+            // you want to sign a message both with RSA and Ed25519)
+            signatureData: [
+                {
+                    signingDomain: this.jobOptions.domain, // d=
+                    selector: this.jobOptions.selector, // s=
+                    // supported key types: RSA, Ed25519
+                    privateKey: await this.loadPrivateKey(), // k=
+                    // Optional algorithm, default is derived from the key.
+                    // Overrides whatever was set in parent object
+                    algorithm: 'rsa-sha256',
+                    // Optional signature specifc canonicalization, overrides whatever was set in parent object
+                    canonicalization: 'relaxed/relaxed', // c=
+                    // Maximum number of canonicalized body bytes to sign (eg. the "l=" tag).
+                    // Do not use though. This is available only for compatibility testing.
+                    // maxBodyLength: 12345
+                },
+            ],
+        });
+        const signature = signResult.signatures;
+        return signature;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5lbWFpbHNpZ25qb2IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9tYWlsL2RlbGl2ZXJ5L2NsYXNzZXMuZW1haWxzaWduam9iLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFjNUMsTUFBTSxPQUFPLFlBQVk7SUFJdkIsWUFBWSxjQUFrQyxFQUFFLE9BQTZCO1FBQzNFLElBQUksQ0FBQyxjQUFjLEdBQUcsY0FBYyxDQUFDO1FBQ3JDLElBQUksQ0FBQyxVQUFVLEdBQUcsT0FBTyxDQUFDO0lBQzVCLENBQUM7SUFFRCxLQUFLLENBQUMsY0FBYztRQUNsQixNQUFNLE9BQU8sR0FBRyxNQUFNLElBQUksQ0FBQyxjQUFjLENBQUMsV0FBVyxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQzNGLE9BQU8sT0FBTyxDQUFDLFVBQVUsQ0FBQztJQUM1QixDQUFDO0lBRU0sS0FBSyxDQUFDLGtCQUFrQixDQUFDLFlBQW9CO1FBQ2xELE1BQU0sVUFBVSxHQUFHLE1BQU0sT0FBTyxDQUFDLFFBQVEsQ0FBQyxZQUFZLEVBQUU7WUFDdEQsbUVBQW1FO1lBQ25FLGdCQUFnQixFQUFFLGlCQUFpQixFQUFFLEtBQUs7WUFFMUMsa0RBQWtEO1lBQ2xELHdFQUF3RTtZQUN4RSxTQUFTLEVBQUUsWUFBWTtZQUV2QixvQ0FBb0M7WUFDcEMsUUFBUSxFQUFFLElBQUksSUFBSSxFQUFFLEVBQUUsS0FBSztZQUUzQixrQ0FBa0M7WUFDbEMsd0VBQXdFO1lBQ3hFLHdEQUF3RDtZQUN4RCxhQUFhLEVBQUU7Z0JBQ2I7b0JBQ0UsYUFBYSxFQUFFLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLEtBQUs7b0JBQzVDLFFBQVEsRUFBRSxJQUFJLENBQUMsVUFBVSxDQUFDLFFBQVEsRUFBRSxLQUFLO29CQUN6QyxvQ0FBb0M7b0JBQ3BDLFVBQVUsRUFBRSxNQUFNLElBQUksQ0FBQyxjQUFjLEVBQUUsRUFBRSxLQUFLO29CQUU5Qyx1REFBdUQ7b0JBQ3ZELDhDQUE4QztvQkFDOUMsU0FBUyxFQUFFLFlBQVk7b0JBRXZCLDJGQUEyRjtvQkFDM0YsZ0JBQWdCLEVBQUUsaUJBQWlCLEVBQUUsS0FBSztvQkFFMUMseUVBQXlFO29CQUN6RSx1RUFBdUU7b0JBQ3ZFLHVCQUF1QjtpQkFDeEI7YUFDRjtTQUNGLENBQUMsQ0FBQztRQUNILE1BQU0sU0FBUyxHQUFHLFVBQVUsQ0FBQyxVQUFVLENBQUM7UUFDeEMsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztDQUNGIn0=

package/dist_ts/ts/mail/delivery/classes.mta.config.d.ts

@@ -0,0 +1,22 @@
+import type { UnifiedEmailServer } from '../routing/classes.unified.email.server.js';
+/**
+ * Configures email server storage settings
+ * @param emailServer Reference to the unified email server
+ * @param options Configuration options containing storage paths
+ */
+export declare function configureEmailStorage(emailServer: UnifiedEmailServer, options: any): void;
+/**
+ * Configure email server with port and storage settings
+ * @param emailServer Reference to the unified email server
+ * @param config Configuration settings for email server
+ */
+export declare function configureEmailServer(emailServer: UnifiedEmailServer, config: {
+    ports?: number[];
+    hostname?: string;
+    tls?: {
+        certPath?: string;
+        keyPath?: string;
+        caPath?: string;
+    };
+    storagePath?: string;
+}): boolean;

package/dist_ts/ts/mail/delivery/classes.mta.config.js

@@ -0,0 +1,51 @@
+import * as plugins from '../../plugins.js';
+import * as paths from '../../paths.js';
+/**
+ * Configures email server storage settings
+ * @param emailServer Reference to the unified email server
+ * @param options Configuration options containing storage paths
+ */
+export function configureEmailStorage(emailServer, options) {
+    // Extract the receivedEmailsPath if available
+    if (options?.emailPortConfig?.receivedEmailsPath) {
+        const receivedEmailsPath = options.emailPortConfig.receivedEmailsPath;
+        // Ensure the directory exists
+        plugins.smartfile.fs.ensureDirSync(receivedEmailsPath);
+        // Set path for received emails
+        if (emailServer) {
+            // Storage paths are now handled by the unified email server system
+            plugins.smartfile.fs.ensureDirSync(paths.receivedEmailsDir);
+            console.log(`Configured email server to store received emails to: ${receivedEmailsPath}`);
+        }
+    }
+}
+/**
+ * Configure email server with port and storage settings
+ * @param emailServer Reference to the unified email server
+ * @param config Configuration settings for email server
+ */
+export function configureEmailServer(emailServer, config) {
+    if (!emailServer) {
+        console.error('Email server not available');
+        return false;
+    }
+    // Configure the email server with updated options
+    const serverOptions = {
+        ports: config.ports || [25, 587, 465],
+        hostname: config.hostname || 'localhost',
+        tls: config.tls
+    };
+    // Update the email server options
+    emailServer.updateOptions(serverOptions);
+    console.log(`Configured email server on ports ${serverOptions.ports.join(', ')}`);
+    // Set up storage path if provided
+    if (config.storagePath) {
+        configureEmailStorage(emailServer, {
+            emailPortConfig: {
+                receivedEmailsPath: config.storagePath
+            }
+        });
+    }
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5tdGEuY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdHMvbWFpbC9kZWxpdmVyeS9jbGFzc2VzLm10YS5jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQUM1QyxPQUFPLEtBQUssS0FBSyxNQUFNLGdCQUFnQixDQUFDO0FBR3hDOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUscUJBQXFCLENBQUMsV0FBK0IsRUFBRSxPQUFZO0lBQ2pGLDhDQUE4QztJQUM5QyxJQUFJLE9BQU8sRUFBRSxlQUFlLEVBQUUsa0JBQWtCLEVBQUUsQ0FBQztRQUNqRCxNQUFNLGtCQUFrQixHQUFHLE9BQU8sQ0FBQyxlQUFlLENBQUMsa0JBQWtCLENBQUM7UUFFdEUsOEJBQThCO1FBQzlCLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO1FBRXZELCtCQUErQjtRQUMvQixJQUFJLFdBQVcsRUFBRSxDQUFDO1lBQ2hCLG1FQUFtRTtZQUNuRSxPQUFPLENBQUMsU0FBUyxDQUFDLEVBQUUsQ0FBQyxhQUFhLENBQUMsS0FBSyxDQUFDLGlCQUFpQixDQUFDLENBQUM7WUFFNUQsT0FBTyxDQUFDLEdBQUcsQ0FBQyx3REFBd0Qsa0JBQWtCLEVBQUUsQ0FBQyxDQUFDO1FBQzVGLENBQUM7SUFDSCxDQUFDO0FBQ0gsQ0FBQztBQUVEOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsb0JBQW9CLENBQ2xDLFdBQStCLEVBQy9CLE1BU0M7SUFFRCxJQUFJLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDakIsT0FBTyxDQUFDLEtBQUssQ0FBQyw0QkFBNEIsQ0FBQyxDQUFDO1FBQzVDLE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztJQUVELGtEQUFrRDtJQUNsRCxNQUFNLGFBQWEsR0FBRztRQUNwQixLQUFLLEVBQUUsTUFBTSxDQUFDLEtBQUssSUFBSSxDQUFDLEVBQUUsRUFBRSxHQUFHLEVBQUUsR0FBRyxDQUFDO1FBQ3JDLFFBQVEsRUFBRSxNQUFNLENBQUMsUUFBUSxJQUFJLFdBQVc7UUFDeEMsR0FBRyxFQUFFLE1BQU0sQ0FBQyxHQUFHO0tBQ2hCLENBQUM7SUFFRixrQ0FBa0M7SUFDbEMsV0FBVyxDQUFDLGFBQWEsQ0FBQyxhQUFhLENBQUMsQ0FBQztJQUV6QyxPQUFPLENBQUMsR0FBRyxDQUFDLG9DQUFvQyxhQUFhLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUM7SUFFbEYsa0NBQWtDO0lBQ2xDLElBQUksTUFBTSxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBQ3ZCLHFCQUFxQixDQUFDLFdBQVcsRUFBRTtZQUNqQyxlQUFlLEVBQUU7Z0JBQ2Ysa0JBQWtCLEVBQUUsTUFBTSxDQUFDLFdBQVc7YUFDdkM7U0FDRixDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDIn0=