@serve.zone/dcrouter 15.0.0 → 15.0.2

package/dist_ts/email/classes.accepted-email-spool.js

@@ -0,0 +1,345 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logger.js';
+import { CachedEmail } from '../db/index.js';
+export const DCROUTER_CACHE_ID_HEADER = 'X-Dcrouter-Cached-Email-Id';
+const ACCEPTED_EMAIL_SPOOL_INTERVAL_MS = 60_000;
+const ACCEPTED_EMAIL_RETRY_DELAY_MS = 5 * 60_000;
+const ACCEPTED_EMAIL_QUEUE_LEASE_MS = 30 * 60_000;
+const ACCEPTED_EMAIL_SPOOL_BATCH_SIZE = 25;
+const ACCEPTED_EMAIL_STOP_DRAIN_TIMEOUT_MS = 30_000;
+/**
+ * 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 class AcceptedEmailSpool {
+    dcRouterRef;
+    spoolTimer;
+    spoolRun;
+    processing = false;
+    stopping = false;
+    queueUpdatePromises = new Set();
+    constructor(dcRouterRef) {
+        this.dcRouterRef = dcRouterRef;
+    }
+    async acceptMessage(context, processAfterAccept = true) {
+        if (!this.dcRouterRef.dcRouterDb?.isReady()) {
+            throw new Error('DcRouterDb is not available for email acceptance');
+        }
+        this.throwIfMessageAcceptanceAborted(context.abortSignal);
+        const rawMessage = context.rawMessage;
+        const session = context.session;
+        const envelope = session.envelope;
+        const envelopeRecipients = Array.isArray(envelope.rcptTo)
+            ? envelope.rcptTo.map((recipient) => recipient.address).filter(Boolean)
+            : [];
+        const email = context.email;
+        const headers = email.headers;
+        const cachedEmail = CachedEmail.createNew();
+        this.removeHeader(email.headers, DCROUTER_CACHE_ID_HEADER);
+        email.headers[DCROUTER_CACHE_ID_HEADER] = cachedEmail.id;
+        cachedEmail.messageId = headers['Message-ID'] || headers['message-id'] || cachedEmail.id;
+        cachedEmail.from = envelope.mailFrom?.address || email.from || '';
+        cachedEmail.to = envelopeRecipients.length > 0
+            ? envelopeRecipients
+            : Array.isArray(email.to) ? email.to : [];
+        cachedEmail.cc = Array.isArray(email.cc) ? email.cc : [];
+        cachedEmail.bcc = Array.isArray(email.bcc) ? email.bcc : [];
+        cachedEmail.subject = email.subject || '';
+        cachedEmail.rawContent = this.setDcRouterCacheIdHeader(rawMessage.toString('utf8'), cachedEmail.id);
+        cachedEmail.status = 'pending';
+        cachedEmail.nextAttempt = new Date();
+        cachedEmail.routeData = JSON.stringify({
+            acceptedAt: new Date().toISOString(),
+            session: {
+                id: session.id,
+                remoteAddress: session.remoteAddress,
+                clientHostname: session.clientHostname,
+                secure: !!session.secure,
+                authenticated: !!session.authenticated,
+                user: session.user,
+                envelope,
+            },
+        });
+        cachedEmail.updateSenderDomain();
+        await cachedEmail.save();
+        if (context.abortSignal?.aborted) {
+            cachedEmail.markFailed('Message acceptance aborted before SMTP success');
+            await cachedEmail.save();
+            throw new Error('Message acceptance aborted before SMTP success');
+        }
+        if (processAfterAccept) {
+            this.run();
+        }
+        else {
+            cachedEmail.markDelivered();
+            await cachedEmail.save();
+        }
+        return {
+            accepted: true,
+            smtpCode: 250,
+            smtpMessage: '2.0.0 Message accepted for delivery',
+            continueProcessing: false,
+        };
+    }
+    /** Start the interval-driven spool processor and trigger an immediate run. */
+    start() {
+        this.clearSpoolTimer();
+        this.stopping = false;
+        const runProcessor = () => {
+            this.run();
+        };
+        this.spoolTimer = setInterval(runProcessor, ACCEPTED_EMAIL_SPOOL_INTERVAL_MS);
+        this.spoolTimer.unref?.();
+        runProcessor();
+    }
+    /** Mark the spool as stopping and clear the interval without awaiting in-flight work. */
+    beginStop() {
+        this.stopping = true;
+        this.clearSpoolTimer();
+    }
+    /** Stop the spool and wait (bounded) for an in-flight run to settle. */
+    async stop() {
+        this.beginStop();
+        const spoolRun = this.spoolRun;
+        if (spoolRun) {
+            const settled = await this.waitForPromiseToSettleWithTimeout(spoolRun, ACCEPTED_EMAIL_STOP_DRAIN_TIMEOUT_MS);
+            if (!settled) {
+                logger.log('warn', 'Timed out waiting for accepted email spool processing to stop');
+            }
+        }
+    }
+    /** Kick off a spool run unless one is already in flight. */
+    run() {
+        if (this.spoolRun) {
+            return;
+        }
+        const run = this.processSpool().catch((error) => {
+            logger.log('warn', `Accepted email spool processing failed: ${error.message}`);
+        });
+        this.spoolRun = run;
+        void run.finally(() => {
+            if (this.spoolRun === run) {
+                this.spoolRun = undefined;
+            }
+        });
+    }
+    trackQueueUpdate(item, status, failureMessage) {
+        const updatePromise = this.updateAcceptedEmailFromQueueItem(item, status).catch((error) => {
+            logger.log('warn', `${failureMessage}: ${error.message}`);
+        });
+        this.queueUpdatePromises.add(updatePromise);
+        void updatePromise.finally(() => {
+            this.queueUpdatePromises.delete(updatePromise);
+        });
+    }
+    async drainQueueUpdates() {
+        const queueUpdates = [...this.queueUpdatePromises];
+        if (queueUpdates.length === 0) {
+            return;
+        }
+        const settled = await this.waitForPromiseToSettleWithTimeout(Promise.allSettled(queueUpdates).then(() => undefined), ACCEPTED_EMAIL_STOP_DRAIN_TIMEOUT_MS);
+        if (!settled) {
+            for (const queueUpdate of queueUpdates) {
+                this.queueUpdatePromises.delete(queueUpdate);
+            }
+            logger.log('warn', `Timed out waiting for ${queueUpdates.length} accepted email queue update(s) to settle`);
+        }
+    }
+    /** Requeue emails left in 'queued' state by a previous process as pending. */
+    async recoverQueuedEmails() {
+        while (true) {
+            const queuedEmails = await CachedEmail.findQueuedForRecovery(ACCEPTED_EMAIL_SPOOL_BATCH_SIZE);
+            if (queuedEmails.length === 0) {
+                return;
+            }
+            for (const queuedEmail of queuedEmails) {
+                if (this.isCachedEmailTerminal(queuedEmail)) {
+                    continue;
+                }
+                queuedEmail.status = 'pending';
+                queuedEmail.nextAttempt = new Date();
+                await queuedEmail.save();
+            }
+            if (queuedEmails.length < ACCEPTED_EMAIL_SPOOL_BATCH_SIZE) {
+                return;
+            }
+        }
+    }
+    async processSpool() {
+        const emailServer = this.dcRouterRef.emailServer;
+        if (this.processing || !emailServer || !this.dcRouterRef.dcRouterDb?.isReady()) {
+            return;
+        }
+        this.processing = true;
+        try {
+            const cachedEmails = await CachedEmail.findPendingForDelivery(ACCEPTED_EMAIL_SPOOL_BATCH_SIZE);
+            for (const cachedEmail of cachedEmails) {
+                if (this.stopping || this.dcRouterRef.emailServer !== emailServer) {
+                    break;
+                }
+                const session = this.buildCachedEmailSession(cachedEmail);
+                const rawMessage = plugins.buffer.Buffer.from(cachedEmail.rawContent || '', 'utf8');
+                await this.processAcceptedCachedEmail(cachedEmail, rawMessage, session, emailServer);
+            }
+        }
+        finally {
+            this.processing = false;
+        }
+    }
+    async processAcceptedCachedEmail(cachedEmail, emailData, session, emailServer) {
+        cachedEmail.status = 'processing';
+        cachedEmail.nextAttempt = new Date(Date.now() + ACCEPTED_EMAIL_QUEUE_LEASE_MS);
+        await cachedEmail.save();
+        try {
+            await emailServer.processEmailByMode(emailData, session);
+            if (session.matchedRoute?.action.type === 'forward') {
+                cachedEmail.markDelivered();
+            }
+            else {
+                const currentCachedEmail = await CachedEmail.findById(cachedEmail.id) || cachedEmail;
+                if (this.isCachedEmailTerminal(currentCachedEmail)) {
+                    return;
+                }
+                currentCachedEmail.status = 'queued';
+                currentCachedEmail.nextAttempt = new Date(Date.now() + ACCEPTED_EMAIL_QUEUE_LEASE_MS);
+                await currentCachedEmail.save();
+                return;
+            }
+            await cachedEmail.save();
+        }
+        catch (error) {
+            cachedEmail.scheduleRetry(ACCEPTED_EMAIL_RETRY_DELAY_MS);
+            cachedEmail.lastError = error.message;
+            await cachedEmail.save();
+            logger.log('warn', `Accepted email ${cachedEmail.id} deferred after SmartMTA handoff failure: ${error.message}`);
+        }
+    }
+    buildCachedEmailSession(cachedEmail) {
+        const routeData = this.parseCachedEmailRouteData(cachedEmail);
+        const storedSession = routeData.session || {};
+        const storedEnvelope = storedSession.envelope || {};
+        const storedRcptTo = Array.isArray(storedEnvelope.rcptTo) && storedEnvelope.rcptTo.length > 0
+            ? storedEnvelope.rcptTo
+            : cachedEmail.to.map((address) => ({ address, args: {} }));
+        const rcptTo = storedRcptTo
+            .filter((recipient) => !!recipient.address)
+            .map((recipient) => ({ address: recipient.address, args: recipient.args || {} }));
+        const mailFrom = storedEnvelope.mailFrom
+            ? { address: storedEnvelope.mailFrom.address, args: storedEnvelope.mailFrom.args || {} }
+            : { address: cachedEmail.from || '', args: {} };
+        const session = {
+            id: `${storedSession.id || cachedEmail.id}-replay-${Date.now()}`,
+            state: 'DATA',
+            clientHostname: storedSession.clientHostname || '',
+            mailFrom: mailFrom.address,
+            rcptTo: rcptTo.map((recipient) => recipient.address),
+            emailData: cachedEmail.rawContent || '',
+            useTLS: !!storedSession.secure,
+            connectionEnded: false,
+            remoteAddress: storedSession.remoteAddress || '127.0.0.1',
+            secure: !!storedSession.secure,
+            authenticated: !!storedSession.authenticated,
+            envelope: {
+                mailFrom,
+                rcptTo,
+            },
+        };
+        if (storedSession.user) {
+            session.user = storedSession.user;
+        }
+        return session;
+    }
+    parseCachedEmailRouteData(cachedEmail) {
+        try {
+            return cachedEmail.routeData ? JSON.parse(cachedEmail.routeData) : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    async updateAcceptedEmailFromQueueItem(item, status) {
+        const cachedEmailId = this.getCachedEmailIdFromQueueItem(item);
+        if (!cachedEmailId || !this.dcRouterRef.dcRouterDb?.isReady()) {
+            return;
+        }
+        const cachedEmail = await CachedEmail.findById(cachedEmailId);
+        if (!cachedEmail) {
+            return;
+        }
+        if (this.isCachedEmailTerminal(cachedEmail) && status !== 'delivered') {
+            return;
+        }
+        cachedEmail.attempts = Math.max(cachedEmail.attempts || 0, item.attempts || 0);
+        if (status === 'delivered') {
+            cachedEmail.markDelivered();
+        }
+        else if (status === 'failed') {
+            cachedEmail.markFailed(item.lastError || 'SmartMTA delivery failed');
+        }
+        else {
+            cachedEmail.status = 'queued';
+            cachedEmail.nextAttempt = new Date(Date.now() + ACCEPTED_EMAIL_QUEUE_LEASE_MS);
+        }
+        await cachedEmail.save();
+    }
+    async waitForPromiseToSettleWithTimeout(promise, timeoutMs) {
+        let timeout;
+        return await new Promise((resolve) => {
+            let settled = false;
+            const settle = (didSettle) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                resolve(didSettle);
+            };
+            timeout = setTimeout(() => settle(false), timeoutMs);
+            timeout.unref?.();
+            promise.then(() => settle(true), () => settle(true));
+        });
+    }
+    clearSpoolTimer() {
+        if (this.spoolTimer) {
+            clearInterval(this.spoolTimer);
+            this.spoolTimer = undefined;
+        }
+    }
+    setDcRouterCacheIdHeader(rawContent, cachedEmailId) {
+        const headerRegex = new RegExp(`^${DCROUTER_CACHE_ID_HEADER}:.*(?:\r?\n[\t ].*)*\r?\n?`, 'gim');
+        const sanitizedContent = rawContent.replace(headerRegex, '');
+        return `${DCROUTER_CACHE_ID_HEADER}: ${cachedEmailId}\r\n${sanitizedContent}`;
+    }
+    isCachedEmailTerminal(cachedEmail) {
+        return cachedEmail.status === 'delivered' || cachedEmail.status === 'failed';
+    }
+    getCachedEmailIdFromQueueItem(item) {
+        return this.getHeaderValue(item.processingResult?.headers, DCROUTER_CACHE_ID_HEADER)
+            || this.getHeaderValue(item.processingResult?.email?.headers, DCROUTER_CACHE_ID_HEADER);
+    }
+    getHeaderValue(headers, headerName) {
+        if (!headers) {
+            return undefined;
+        }
+        const normalizedHeaderName = headerName.toLowerCase();
+        const matchingHeaderName = Object.keys(headers).find((key) => key.toLowerCase() === normalizedHeaderName);
+        return matchingHeaderName ? headers[matchingHeaderName] : undefined;
+    }
+    removeHeader(headers, headerName) {
+        const normalizedHeaderName = headerName.toLowerCase();
+        for (const key of Object.keys(headers)) {
+            if (key.toLowerCase() === normalizedHeaderName) {
+                delete headers[key];
+            }
+        }
+    }
+    throwIfMessageAcceptanceAborted(abortSignal) {
+        if (abortSignal?.aborted) {
+            throw new Error('Message acceptance aborted before SMTP success');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.accepted-email-spool.js","sourceRoot":"","sources":["../../../ts/email/classes.accepted-email-spool.ts"],"names":[],"mappings":"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"}

package/dist_ts/email/classes.email-route-builder.d.ts

@@ -0,0 +1,28 @@
+import * as plugins from '../plugins.js';
+import type { IUnifiedEmailServerOptions } from '@push.rocks/smartmta';
+import type { IRoute } from '../../dist_ts_interfaces/data/route-management.js';
+import type { IDcRouterRouteConfig } from '../../dist_ts_interfaces/data/remoteingress.js';
+import type { DcRouter } from '../classes.dcrouter.js';
+/**
+ * Generates SmartProxy routes for the email ports and hydrates persisted
+ * email routes into runtime routes: server-first SMTP ports get a raw
+ * socket-handler proxy that injects PROXY protocol toward the backend.
+ */
+export declare class EmailRouteBuilder {
+    private dcRouterRef;
+    constructor(dcRouterRef: DcRouter);
+    generateEmailRoutes(emailConfig: IUnifiedEmailServerOptions): IDcRouterRouteConfig[];
+    getRuntimeEmailRoutes(emailRoutes: IDcRouterRouteConfig[]): plugins.smartproxy.IRouteConfig[];
+    /**
+     * Hydrate a persisted route into its runtime form: generated email routes
+     * get the server-first socket-handler treatment, DoH routes get the DNS
+     * socket handler. Returns undefined when the stored route runs as-is.
+     */
+    hydrateStoredRouteForRuntime(storedRoute: IRoute): plugins.smartproxy.IRouteConfig | undefined;
+    private getCurrentGeneratedEmailRouteNames;
+    private shouldHydrateGeneratedEmailRoute;
+    private createServerFirstEmailRuntimeRoute;
+    private getRemoteIngressEmailInboundProxyPolicy;
+    private createEmailSocketProxyHandler;
+    private createProxyProtocolV1Header;
+}