@serve.zone/coremail 1.1.0 → 1.3.0

package/dist_ts/classes.smtpsubmission.js

@@ -0,0 +1,379 @@
+import * as plugins from './plugins.js';
+import { stableStringify } from './classes.gateway.js';
+import { logCoreMailFailure } from './coremail.log.js';
+import { CoreMailQuotaExceededError } from './coremail.quota.js';
+/** Session grants live no longer than smartmta's own hook-grant window. */
+const sessionTtlMs = 60 * 60 * 1000;
+/** Hard cap mirroring smartmta's hook-grant table. */
+const sessionMaximum = 4_096;
+const reconcileIntervalMs = 1_000;
+/** First retry delay after a failed start. */
+const startBackoffBaseMs = 1_000;
+/** Ceiling for the consecutive-failure backoff. */
+const startBackoffMaximumMs = 60_000;
+const waitForAbortableDelay = async (delayMsArg, signalArg) => {
+    if (signalArg.aborted)
+        return;
+    await new Promise((resolveArg) => {
+        const timer = setTimeout(() => {
+            signalArg.removeEventListener('abort', onAbort);
+            resolveArg();
+        }, delayMsArg);
+        const onAbort = () => {
+            clearTimeout(timer);
+            resolveArg();
+        };
+        signalArg.addEventListener('abort', onAbort, { once: true });
+    });
+};
+/**
+ * CoreMail's SMTP submission listener (MSA).
+ *
+ * smartmta owns the transport only: it terminates TLS, runs SMTP AUTH over an
+ * encrypted channel, and hands every accepted message to `onMessageData` as
+ * the exact received bytes. Nothing is stored, queued or forwarded by it —
+ * `onMessageData` returns without `continueProcessing`, so the message ends at
+ * `CoreMailSubmissionService.submitRaw` and CoreMail's own durable outbound
+ * pipeline. The `MemoryStorageManager` handed to smartmta is therefore
+ * expected to stay empty for the life of the process; a test asserts that.
+ *
+ * The listener fails closed. It runs only when the desired state enables it
+ * and both PEM secrets resolve, because smartmta's Rust listener refuses AUTH
+ * on a cleartext session (538 5.7.11) and a listener without certificate
+ * material would advertise neither STARTTLS nor AUTH.
+ */
+export class CoreMailSmtpSubmissionServer {
+    config;
+    auth;
+    submissions;
+    getDesiredState;
+    now;
+    server = null;
+    storageManager = null;
+    serverSignature = '';
+    stopController = new AbortController();
+    reconcileTask = null;
+    sessions = new Map();
+    unavailableReason = 'CoreMail SMTP listener has not started.';
+    loggedUnavailableSignature = '';
+    /** Signature of the configuration the last start was attempted for. */
+    attemptedSignature = '';
+    startFailures = 0;
+    reportedUnavailable = 0;
+    nextStartAttemptAt = 0;
+    constructor(config, auth, submissions, getDesiredState, now = Date.now) {
+        this.config = config;
+        this.auth = auth;
+        this.submissions = submissions;
+        this.getDesiredState = getDesiredState;
+        this.now = now;
+    }
+    start() {
+        this.reconcileTask ??= this.runReconciliationLoop();
+    }
+    async stop() {
+        this.stopController.abort();
+        await this.reconcileTask?.catch(() => undefined);
+        this.reconcileTask = null;
+        await this.shutdownServer();
+        this.sessions.clear();
+        this.resetStartBackoff('');
+    }
+    /** Whether the listener is currently accepting submissions. */
+    isReady() {
+        return this.server !== null && this.unavailableReason === null;
+    }
+    /**
+     * Operator-facing view of the start-retry state. A listener that cannot bind
+     * (busy port, unusable key pair, missing mailer-bin) backs off instead of
+     * respawning the Rust bridge once per reconcile tick.
+     */
+    getListenerDiagnostics() {
+        return {
+            startFailures: this.startFailures,
+            reportedUnavailable: this.reportedUnavailable,
+            nextStartAttemptAt: this.nextStartAttemptAt,
+        };
+    }
+    /** In-memory storage handed to smartmta, for the emptiness assertion. */
+    getStorageManager() {
+        return this.storageManager;
+    }
+    async runReconciliationLoop() {
+        while (!this.stopController.signal.aborted) {
+            try {
+                await this.reconcile();
+            }
+            catch (error) {
+                await logCoreMailFailure('smtp', 'RECONCILIATION_FAILED', error)
+                    .catch(() => undefined);
+            }
+            await waitForAbortableDelay(reconcileIntervalMs, this.stopController.signal);
+        }
+    }
+    async reconcile() {
+        const desired = await this.getDesiredState();
+        const smtp = desired?.smtp;
+        if (!smtp || !smtp.enabled) {
+            await this.markUnavailable(smtp ? 'CoreMail SMTP listener is disabled.' : 'CoreMail SMTP listener is not configured.', stableStringify(smtp ?? null));
+            return;
+        }
+        const material = this.resolveTlsMaterial(smtp);
+        if (!material) {
+            await this.markUnavailable('CoreMail SMTP listener TLS material does not resolve.', stableStringify(smtp));
+            return;
+        }
+        const signature = stableStringify({ smtp, certPem: material.certPem });
+        if (this.server && signature === this.serverSignature)
+            return;
+        if (signature === this.attemptedSignature) {
+            // The same configuration failed already; wait out its backoff rather
+            // than spawning and tearing down the Rust bridge every tick.
+            if (this.now() < this.nextStartAttemptAt)
+                return;
+        }
+        else {
+            // A changed smtp section always restarts immediately.
+            this.resetStartBackoff(signature);
+        }
+        await this.shutdownServer();
+        if (this.stopController.signal.aborted)
+            return;
+        await this.startServer(smtp, material, signature);
+    }
+    resetStartBackoff(signatureArg) {
+        this.attemptedSignature = signatureArg;
+        this.startFailures = 0;
+        this.nextStartAttemptAt = 0;
+    }
+    /**
+     * Resolve both PEM secrets. A listener that cannot present a certificate
+     * must never come up: smartmta would then offer neither STARTTLS nor AUTH,
+     * and any client configured for submission would fail open into plaintext.
+     */
+    resolveTlsMaterial(smtpArg) {
+        try {
+            const certPem = this.config.resolveRuntimeSecret(smtpArg.tls.certificatePemSecretKey);
+            const keyPem = this.config.resolveRuntimeSecret(smtpArg.tls.privateKeyPemSecretKey);
+            if (typeof certPem !== 'string'
+                || !certPem.includes('BEGIN')
+                || typeof keyPem !== 'string'
+                || !keyPem.includes('BEGIN')) {
+                return null;
+            }
+            return { certPem, keyPem };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Record why the listener is not serving and log it once per distinct
+     * reason. Repeating the same reason every reconcile tick would drown the
+     * operator in noise without adding information.
+     */
+    async reportUnavailable(reasonArg, signatureArg, codeArg, errorArg) {
+        await this.shutdownServer();
+        this.unavailableReason = reasonArg;
+        const logSignature = `${codeArg}:${signatureArg}`;
+        if (this.loggedUnavailableSignature === logSignature)
+            return;
+        this.loggedUnavailableSignature = logSignature;
+        this.reportedUnavailable += 1;
+        await logCoreMailFailure('smtp', codeArg, errorArg, {
+            reason: reasonArg,
+        }).catch(() => undefined);
+    }
+    /**
+     * The configuration is not asking for a listener right now, so no start is
+     * pending and a later enable must take effect on its first tick.
+     */
+    async markUnavailable(reasonArg, signatureArg) {
+        this.resetStartBackoff('');
+        await this.reportUnavailable(reasonArg, signatureArg, 'LISTENER_UNAVAILABLE');
+    }
+    async startServer(smtpArg, materialArg, signatureArg) {
+        const storageManager = new plugins.smartmta.MemoryStorageManager();
+        const server = new plugins.smartmta.UnifiedEmailServer({ storageManager }, {
+            ports: [smtpArg.port],
+            hostname: smtpArg.hostname,
+            // CoreMail hosts no inbound domain of its own here: this listener only
+            // relays authenticated submissions to the durable outbound pipeline.
+            domains: [],
+            routes: [{
+                    name: 'submission',
+                    match: { authenticated: true },
+                    action: { type: 'process', allowRelay: true },
+                }],
+            persistRoutes: false,
+            dkimKeyProvisioning: 'caller-managed',
+            tls: { certPem: materialArg.certPem, keyPem: materialArg.keyPem },
+            auth: { required: true },
+            queue: { storageMode: 'memory' },
+            smtp: {
+                maxConcurrentMessages: 16,
+                recipientValidation: false,
+                authenticationTimeoutMs: 4_000,
+                messageAcceptanceTimeoutMs: 30_000,
+            },
+            maxMessageSize: plugins.serveZoneInterfaces.data.coreMailLimits.serializedMimeBytes,
+            hooks: {
+                onAuthenticate: (contextArg) => this.onAuthenticate(contextArg),
+                onMessageData: (contextArg) => this.onMessageData(contextArg),
+            },
+        });
+        try {
+            await server.start();
+        }
+        catch (error) {
+            await server.stop().catch(() => undefined);
+            this.startFailures += 1;
+            this.nextStartAttemptAt = this.now() + Math.min(startBackoffMaximumMs, startBackoffBaseMs * 2 ** (this.startFailures - 1));
+            await this.reportUnavailable('CoreMail SMTP listener failed to start.', signatureArg, 'LISTENER_START_FAILED', error);
+            return;
+        }
+        this.server = server;
+        this.storageManager = storageManager;
+        this.serverSignature = signatureArg;
+        this.unavailableReason = null;
+        this.loggedUnavailableSignature = '';
+        this.startFailures = 0;
+        this.nextStartAttemptAt = 0;
+    }
+    async shutdownServer() {
+        const server = this.server;
+        this.server = null;
+        this.serverSignature = '';
+        this.sessions.clear();
+        if (!server)
+            return;
+        await server.stop().catch(async (error) => {
+            await logCoreMailFailure('smtp', 'LISTENER_SHUTDOWN_FAILED', error)
+                .catch(() => undefined);
+        });
+    }
+    pruneSessions() {
+        const now = this.now();
+        for (const [sessionId, grant] of this.sessions) {
+            if (grant.expiresAt <= now)
+                this.sessions.delete(sessionId);
+        }
+        while (this.sessions.size > sessionMaximum) {
+            const oldest = this.sessions.keys().next();
+            if (oldest.done)
+                break;
+            this.sessions.delete(oldest.value);
+        }
+    }
+    async onAuthenticate(contextArg) {
+        // The SMTP username is the binding id; the password is any accepted
+        // credential secret of that binding.
+        const authenticated = await this.auth.authenticateSmtpSubmission(contextArg.username, contextArg.password);
+        if (!authenticated) {
+            return { accepted: false, message: 'CoreMail binding credential rejected.' };
+        }
+        const { binding } = authenticated;
+        const session = {
+            kind: 'workload',
+            peerId: `smtp:${contextArg.sessionId}`,
+            tenantId: binding.tenantId,
+            serviceId: binding.serviceId,
+            bindingId: binding.bindingId,
+            bindingRevision: binding.revision,
+            configEpoch: authenticated.configEpoch,
+            credentialId: authenticated.credentialId,
+            credentialVersion: authenticated.credentialVersion,
+            bindingState: binding.state === 'draining' ? 'draining' : 'active',
+            capabilities: [...binding.capabilities],
+            allowedOperations: [
+                ...plugins.serveZoneInterfaces.data.resolveCoreMailWorkloadOperations(binding.state, binding.capabilities),
+            ],
+            coreMailTransferOrigin: '-',
+            authenticatedAt: this.now(),
+        };
+        this.sessions.delete(contextArg.sessionId);
+        this.sessions.set(contextArg.sessionId, {
+            session,
+            binding,
+            expiresAt: this.now() + sessionTtlMs,
+        });
+        this.pruneSessions();
+        return {
+            accepted: true,
+            // smartmta enforces the same sender scope CoreMail enforces again in
+            // submitRaw, so an out-of-scope MAIL FROM is refused at RCPT time.
+            scope: { senders: [...binding.allowedSenders] },
+        };
+    }
+    async onMessageData(contextArg) {
+        const grant = this.sessions.get(contextArg.session.id);
+        if (!grant || grant.expiresAt <= this.now()) {
+            this.sessions.delete(contextArg.session.id);
+            return {
+                accepted: false,
+                smtpCode: 451,
+                smtpMessage: '4.7.1 Authentication scope unavailable; authenticate again',
+            };
+        }
+        try {
+            // smartmta strips the CRLF that preceded the DATA terminator; the
+            // durable raw queue requires canonical CRLF-terminated bytes.
+            const rawMime = new Uint8Array(contextArg.rawMessage.byteLength + 2);
+            rawMime.set(contextArg.rawMessage, 0);
+            rawMime.set([0x0d, 0x0a], contextArg.rawMessage.byteLength);
+            await this.submissions.submitRaw(grant.session, grant.binding, {
+                envelope: {
+                    from: contextArg.session.envelope.mailFrom.address,
+                    to: contextArg.session.envelope.rcptTo.map((recipientArg) => recipientArg.address),
+                },
+                rawMime,
+            });
+            // No continueProcessing: smartmta stores, queues and forwards nothing.
+            return { accepted: true };
+        }
+        catch (error) {
+            return this.refusalFor(error);
+        }
+    }
+    refusalFor(errorArg) {
+        if (errorArg instanceof CoreMailQuotaExceededError) {
+            return {
+                accepted: false,
+                smtpCode: 452,
+                smtpMessage: '4.2.1 Mail quota exceeded; try again later',
+            };
+        }
+        const message = errorArg instanceof Error ? errorArg.message : '';
+        if (message.includes('sender is not authorized')) {
+            return {
+                accepted: false,
+                smtpCode: 553,
+                smtpMessage: '5.7.1 Sender address not permitted',
+            };
+        }
+        if (message.includes('byte budget')) {
+            return {
+                accepted: false,
+                smtpCode: 552,
+                smtpMessage: '5.3.4 Message exceeds its size limit',
+            };
+        }
+        if (errorArg instanceof Error
+            && (errorArg.name === 'CoreMailCapabilityDeniedError'
+                || errorArg.name === 'CoreMailAuthorizationError')) {
+            return {
+                accepted: false,
+                smtpCode: 550,
+                smtpMessage: '5.7.1 Submission is not permitted by this authority',
+            };
+        }
+        void logCoreMailFailure('smtp', 'SUBMISSION_FAILED', errorArg)
+            .catch(() => undefined);
+        return {
+            accepted: false,
+            smtpCode: 451,
+            smtpMessage: '4.3.0 Submission temporarily unavailable',
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.smtpsubmission.js","sourceRoot":"","sources":["../ts/classes.smtpsubmission.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.storage.d.ts

@@ -24,6 +24,15 @@ export declare class CoreMailStorage {
         }>;
         cancel: (reasonArg?: unknown) => Promise<void>;
     }>;
+    /**
+     * Read at most `headBytesArg` leading bytes of a stored object.
+     *
+     * The object's integrity was already proven when its transfer grant was
+     * consumed, so a header scan does not need to re-hash the whole payload — it
+     * reads a bounded prefix and cancels. The verified full-object readers above
+     * remain the only way to obtain content that is acted on as a whole.
+     */
+    readObjectHeadBytes(objectKeyArg: string, lengthBytesArg: number, sha256Arg: TCoreMailSha256, maximumBytesArg: number, headBytesArg: number, signalArg?: AbortSignal): Promise<Uint8Array>;
     getVerifiedBytes(objectKeyArg: string, lengthBytesArg: number, sha256Arg: TCoreMailSha256, maximumBytesArg: number): Promise<Uint8Array>;
     verifyObject(objectKeyArg: string, lengthBytesArg: number, sha256Arg: TCoreMailSha256, maximumBytesArg: number, signalArg?: AbortSignal): Promise<void>;
 }

package/dist_ts/classes.storage.js

@@ -269,6 +269,49 @@ export class CoreMailStorage {
             signal: signalArg,
         }, 'webstream'), maximumBytesArg, lengthBytesArg, sha256Arg, signalArg, plugins.serveZoneInterfaces.data.coreMailLimits.transferIdleTimeoutMs);
     }
+    /**
+     * Read at most `headBytesArg` leading bytes of a stored object.
+     *
+     * The object's integrity was already proven when its transfer grant was
+     * consumed, so a header scan does not need to re-hash the whole payload — it
+     * reads a bounded prefix and cancels. The verified full-object readers above
+     * remain the only way to obtain content that is acted on as a whole.
+     */
+    async readObjectHeadBytes(objectKeyArg, lengthBytesArg, sha256Arg, maximumBytesArg, headBytesArg, signalArg) {
+        if (!Number.isSafeInteger(headBytesArg) || headBytesArg < 1) {
+            throw new Error('CoreMail object head read length is invalid.');
+        }
+        const verified = await this.getVerifiedStream(objectKeyArg, lengthBytesArg, sha256Arg, maximumBytesArg, signalArg);
+        const reader = verified.stream.getReader();
+        const chunks = [];
+        let total = 0;
+        try {
+            while (total < headBytesArg) {
+                const next = await reader.read();
+                if (next.done)
+                    break;
+                chunks.push(next.value);
+                total += next.value.byteLength;
+            }
+        }
+        finally {
+            await reader.cancel().catch(() => undefined);
+            reader.releaseLock();
+            await verified.cancel().catch(() => undefined);
+            // The digest is deliberately not awaited: only a prefix was consumed.
+            verified.completion.catch(() => undefined);
+        }
+        const head = new Uint8Array(Math.min(total, headBytesArg));
+        let offset = 0;
+        for (const chunk of chunks) {
+            if (offset >= head.byteLength)
+                break;
+            const slice = chunk.subarray(0, head.byteLength - offset);
+            head.set(slice, offset);
+            offset += slice.byteLength;
+        }
+        return head;
+    }
     async getVerifiedBytes(objectKeyArg, lengthBytesArg, sha256Arg, maximumBytesArg) {
         const verified = await this.getVerifiedStream(objectKeyArg, lengthBytesArg, sha256Arg, maximumBytesArg, AbortSignal.timeout(plugins.serveZoneInterfaces.data.coreMailLimits.transferOverallTimeoutMs));
         const reader = verified.stream.getReader();
@@ -314,4 +357,4 @@ export class CoreMailStorage {
 }
 export const createSha256 = (valueArg) => plugins.serveZoneInterfaces.data.normalizeCoreMailSha256(`sha256:${plugins.nodeCrypto.createHash('sha256').update(valueArg).digest('hex')}`);
 export const createOpaqueToken = () => plugins.nodeCrypto.randomBytes(32).toString('base64url');
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.storage.js","sourceRoot":"","sources":["../ts/classes.storage.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.storage.js","sourceRoot":"","sources":["../ts/classes.storage.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.submissions.d.ts

@@ -2,7 +2,7 @@ import * as plugins from './plugins.js';
 import { type ICoreMailModels } from './classes.models.js';
 import { CoreMailStorage } from './classes.storage.js';
 import { CoreMailTransferService } from './classes.transfer.js';
-import type { ICoreMailWorkloadSession } from './interfaces.js';
+import type { ICoreMailRawSubmissionInput, ICoreMailWorkloadSession } from './interfaces.js';
 type TBinding = plugins.serveZoneInterfaces.data.ICoreMailBindingDesiredState;
 type TSubmission = plugins.serveZoneInterfaces.data.ICoreMailSubmission;
 export declare class CoreMailSubmissionService {
@@ -16,6 +16,23 @@ export declare class CoreMailSubmissionService {
         submission: TSubmission;
         replayed: boolean;
     }>;
+    /**
+     * Accept an exact-byte SMTP submission from an authenticated MSA session.
+     *
+     * CoreMail never parses, rewrites, or re-encodes `rawMime`. The bytes become
+     * the submission's immutable MIME directly, so the existing outbound worker
+     * and gateway hand an SMTP submission off exactly as they hand off an API
+     * submission that `finalize()` has published.
+     *
+     * The write order mirrors `finalize()`: the record that owns the object key
+     * is committed first and only becomes worker-visible once the bytes are
+     * durably stored, so a failure between the two steps leaves a retirable
+     * record rather than an object no record refers to.
+     */
+    submitRaw(sessionArg: ICoreMailWorkloadSession, bindingArg: TBinding, inputArg: ICoreMailRawSubmissionInput): Promise<{
+        submissionId: string;
+        submissionDigest: plugins.serveZoneInterfaces.data.TCoreMailSha256;
+    }>;
     preparePartUpload(sessionArg: ICoreMailWorkloadSession, requestArg: plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailPrepareOutboundPartUpload['request']): Promise<{
         grant: plugins.serveZoneInterfaces.data.ICoreMailUploadGrant;
     }>;
@@ -25,6 +42,15 @@ export declare class CoreMailSubmissionService {
     finalize(sessionArg: ICoreMailWorkloadSession, requestArg: plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailFinalizeOutboundSubmission['request']): Promise<{
         submission: TSubmission;
     }>;
+    /**
+     * Publish an owned immutable MIME and hand the submission to the worker.
+     *
+     * The submitted counter is incremented in the same transaction as the
+     * transition that publishes, and only when `statsSubmittedCountedAt` is
+     * still absent. An interrupted publication that finalization later repeats
+     * therefore republishes without counting a second submission.
+     */
+    private publishSubmission;
     get(sessionArg: ICoreMailWorkloadSession, requestArg: plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailGetOutboundSubmission['request']): Promise<{
         submission: TSubmission;
     }>;