@push.rocks/smartmta 9.4.1 → 9.6.0

package/dist_ts/mail/routing/interfaces.d.ts

@@ -195,6 +195,47 @@ export interface ISmtpAuthAccount {
     /** Absent scope = unrestricted (backwards compatible). */
     scope?: ISmtpAuthAccountScope;
 }
+/**
+ * Context handed to `hooks.onAuthenticate` for a PLAIN/LOGIN attempt whose
+ * username is not declared in `auth.accounts` or `auth.users`.
+ */
+export interface ISmtpAuthenticateContext {
+    /** Username exactly as supplied by the client. */
+    username: string;
+    /** Password exactly as supplied by the client. */
+    password: string;
+    /** SMTP session the attempt belongs to. */
+    sessionId: string;
+    /** Remote peer address of the SMTP connection. */
+    remoteAddress: string;
+    /** Aborted when the hook exceeds `smtp.authenticationTimeoutMs`. */
+    abortSignal?: AbortSignal;
+}
+/**
+ * Result of an `hooks.onAuthenticate` credential verification.
+ */
+export interface ISmtpAuthenticateDecision {
+    /** Whether the supplied credential is valid. */
+    accepted: boolean;
+    /**
+     * Reason for a rejection, recorded in the server log.
+     *
+     * It is deliberately NOT sent to the client: the SMTP listener answers every
+     * failed authentication with the same `535 5.7.8 Authentication credentials
+     * invalid`, so a caller cannot probe which usernames exist. Use this to make
+     * an operator's log say why a binding was refused.
+     */
+    message?: string;
+    /**
+     * Send-authorization scope for the resulting session, enforced identically
+     * to a configured account's scope for the lifetime of that session.
+     *
+     * Absent scope = unrestricted, matching `ISmtpAuthAccount.scope`. A hook
+     * that authenticates tenants MUST return a scope; without one the session
+     * may send as any sender to any recipient.
+     */
+    scope?: ISmtpAuthAccountScope;
+}
 /**
  * Context for route evaluation
  */

package/dist_ts/mail/routing/symbols.unified.email.server.d.ts

@@ -0,0 +1,2 @@
+export declare const kSendOutboundEmailInternal: unique symbol;
+export declare const kSendRawOutboundEmailInternal: unique symbol;

package/dist_ts/mail/routing/symbols.unified.email.server.js

@@ -0,0 +1,3 @@
+export const kSendOutboundEmailInternal = Symbol('smartmta.server.sendOutboundEmailInternal');
+export const kSendRawOutboundEmailInternal = Symbol('smartmta.server.sendRawOutboundEmailInternal');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3ltYm9scy51bmlmaWVkLmVtYWlsLnNlcnZlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL21haWwvcm91dGluZy9zeW1ib2xzLnVuaWZpZWQuZW1haWwuc2VydmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLDBCQUEwQixHQUFrQixNQUFNLENBQzdELDJDQUEyQyxDQUM1QyxDQUFDO0FBQ0YsTUFBTSxDQUFDLE1BQU0sNkJBQTZCLEdBQWtCLE1BQU0sQ0FDaEUsOENBQThDLENBQy9DLENBQUMifQ==

package/dist_ts/security/classes.rustsecuritybridge.d.ts

@@ -228,8 +228,19 @@ interface ISmtpSendRawOptions {
     envelopeFrom: string;
     envelopeTo: string[];
     rawMessageBase64: string;
+    dkim: {
+        domain: string;
+        selector: string;
+        privateKey: string;
+        keyType?: string;
+    };
+    connectionTimeoutSecs?: number;
+    socketTimeoutSecs?: number;
     poolKey?: string;
+    maxPoolConnections?: number;
+    tlsOpportunistic?: boolean;
     disablePooling?: boolean;
+    outboundAuthenticationCaptureId?: string;
 }
 interface ISmtpVerifyOptions {
     host: string;

package/dist_ts/security/classes.rustsecuritybridge.js

@@ -784,4 +784,4 @@ export class RustSecurityBridge extends EventEmitter {
         this.bridge.off('management:scramCredentialRequest', handler);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.rustsecuritybridge.js","sourceRoot":"","sources":["../../ts/security/classes.rustsecuritybridge.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.rustsecuritybridge.js","sourceRoot":"","sources":["../../ts/security/classes.rustsecuritybridge.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartmta",
-  "version": "9.4.1",
+  "version": "9.6.0",
   "description": "A high-performance, enterprise-grade Mail Transfer Agent (MTA) built from scratch in TypeScript with Rust acceleration.",
   "keywords": [
     "mta",
@@ -31,12 +31,12 @@
     ".": "./dist_ts/index.js"
   },
   "devDependencies": {
-    "@git.zone/cli": "^3.0.0",
-    "@git.zone/tsbuild": "4.4.2",
-    "@git.zone/tsrust": "^1.7.0",
-    "@git.zone/tstest": "^3.6.7",
+    "@git.zone/cli": "^6.13.2",
+    "@git.zone/tsbuild": "4.4.3",
+    "@git.zone/tsrust": "^1.13.0",
+    "@git.zone/tstest": "^6.0.0",
     "@types/mailparser": "^3.4.6",
-    "@types/node": "^26.1.1",
+    "@types/node": "26.5.0",
     "tsx": "^4.23.1"
   },
   "dependencies": {

package/readme.md

@@ -171,6 +171,11 @@ const emailServer = new UnifiedEmailServer(dcRouterRef, {
     securePort: 465,
     recipientValidationTimeoutMs: 5000,
 
+    // Timeout for hooks.onAuthenticate before failing the attempt closed.
+    // Defaults to 4000. The SMTP listener abandons the AUTH round trip after a
+    // fixed 5000 ms, so larger values are clamped to 4500 with a warning.
+    authenticationTimeoutMs: 4000,
+
     // Timeout for hooks.onMessageData and hooks.onAcceptEnvelope before
     // returning a temporary SMTP failure.
     messageAcceptanceTimeoutMs: 30000,
@@ -183,6 +188,20 @@ const emailServer = new UnifiedEmailServer(dcRouterRef, {
   },
 
   hooks: {
+    async onAuthenticate(context) {
+      // Only reached for usernames auth.accounts and auth.users do not declare.
+      // Verify the credential however the application stores it, and return the
+      // send scope the resulting session must be held to.
+      const binding = await credentialStore.verify(context.username, context.password);
+      if (!binding) {
+        // message is logged server-side; the client always sees a plain 535.
+        return { accepted: false, message: 'Unknown binding' };
+      }
+      return {
+        accepted: true,
+        scope: { senders: [`*@${binding.domain}`] },
+      };
+    },
     async onRcptTo(context) {
       if (context.abortSignal?.aborted) {
         return { accepted: false, smtpCode: 451, smtpMessage: 'Recipient policy timeout' };
@@ -281,10 +300,38 @@ Managed queues store complete queue items as SmartBucket blobs. Schema V2 adds p
 
 V1 queue blobs remain readable. They hydrate with an empty bounce outbox and are upgraded to V2 on their next mutation; SmartMTA never invents retroactive bounce work. V2 blobs are intentionally not readable by V7, so rolling back after a V2 write is unsupported.
 
-The managed-prefix ownership guard is process-local only. It coordinates queues only when they share the exact same `IBlobStorageManager` object instance and normalized storage prefix. Different storage-wrapper instances and different JavaScript processes are not coordinated; the embedder must enforce one delivery owner or provide an external distributed lease. This guard does not provide distributed ownership. Because queue writes are forward-only to schema V2, V7 rollback remains unsupported after the first V2 mutation.
+The managed-prefix ownership guard is process-local only. It coordinates queues only when they share the exact same `IBlobStorageManager` object instance and normalized storage prefix. Different storage-wrapper instances and different JavaScript processes are not coordinated; the embedder must enforce one delivery owner or provide an external distributed lease. This guard does not provide distributed ownership. Structured mutations remain forward-only to schema V2, while raw items use schema V3; older releases cannot read records from newer schemas.
 
 Bounce delivery is at-least-once. `BounceManager` uses the operation ID as a durable processed marker and deduplicates concurrent/restarted calls. Its in-process completed-operation LRU is only a hot-duplicate optimization, bounded to 10,000 entries with a 24-hour TTL; cache misses always re-read the durable marker. A process crash after an external side effect but before the queue completion checkpoint can cause the operation to be presented again. Custom `bounceHandler.processSmtpFailure` implementations receive `options.operationId` and must deduplicate it in their own durable store; SmartMTA does not claim exactly-once execution for custom handlers.
 
+### Durable Raw Outbound Queue
+
+`enqueueRawEmail()` is the narrow exact-byte path for already-constructed RFC822 messages that still need SmartMTA's durable MTA delivery. It always uses MTA mode, MX discovery, self-MX protection, per-recipient checkpoints, retries, and bounce handling. Callers cannot select a route, processing mode, transformation, or bypass.
+
+```typescript
+const queueId = await emailServer.enqueueRawEmail(
+  exactRfc822Buffer,
+  {
+    from: 'sender@example.com',
+    to: ['first@example.net', 'second@example.org'],
+  },
+  'stable-upstream-message-id',
+);
+```
+
+- The message must be a nonempty `Buffer` with canonical CRLF line endings and a final CRLF. SmartMTA rejects bare CR, bare LF, and missing final CRLF so SMTP DATA framing cannot change the signed message bytes. It stores the exact unsigned bytes without parsing the body or attachments. `queue.maxRawMessageBytes` defaults to 32 MiB.
+- The SMTP envelope is separate from RFC822 headers. Sender and recipients are canonicalized, recipients must be unique after canonicalization, and caller order is preserved. Header/envelope divergence is intentional; delivery recipients always come from the SMTP envelope.
+- The idempotency fingerprint is versioned and length-framed over the exact bytes, canonical sender, ordered canonical recipients, and fixed raw-MTA/mandatory-DKIM semantics. Reusing a key with different bytes, sender, recipients, or recipient order is a conflict.
+- Raw enqueue requires `queue.storageMode: 'managed'`, an `IBlobStorageManager`, and backend-bounded `listPage()`. Managed startup hydration uses bounded pages whenever the backend provides them. Raw records use schema V3 and keep metadata plus the exact `Buffer` in one atomic queue blob; V1/V2 structured records and their hydration remain unchanged.
+- Queue memory contains only a tiny metadata `Email` (sender, recipients, empty subject/text, no attachments), raw SHA-256/length, and a cloned SMTP envelope. Public queue getters, events, and server status getters never expose raw bytes or live queue records.
+- Delivery rereads and verifies one V3 blob only for the duration of a callback. `queue.rawInFlightByteBudget` defaults to 192 MiB and must be at least six times `maxRawMessageBytes`. Raw enqueue is charged at three times the message length; payload reread, persistence, direct raw send, base64, and IPC work is charged at six times the message length. Enqueue and direct-send admission fail immediately when the byte budget is occupied or the hard limit of 1,024 concurrent raw reservations is reached, rather than retaining unbounded caller buffers or promises. Shutdown closes reservation admission and drains accepted reservations before clearing queue state. This is a conservative concurrency budget for SmartMTA-owned transient representations, not a hard process-RSS limit. No payload cache or separate payload blobs exist.
+- DKIM is mandatory and fail-closed. At every delivery attempt SmartMTA resolves the sender domain's current selector from `DomainRegistry`, loads the matching current key, and asks Rust to prepend the signature directly to the decoded bytes. Missing keys, invalid keys, or signing failures send nothing. The unsigned queue bytes remain unchanged across MX attempts and retries.
+- `sendRawOutboundEmail()` is the corresponding low-level direct-target transport. It requires the caller to provide an exact `dkimSelector` for the envelope sender's `dkimDomain`; unlike queued delivery, it does not resolve a current selector from `DomainRegistry`. It uses the same connection proxy, source evidence, authentication capture, timeouts, TLS/opportunistic TLS, pooling, and cleanup path as `sendOutboundEmail()`.
+
+Schema V3 is a downgrade gate. SmartMTA 9.4 cannot read V3. Downgrade to 9.4 is safe only after every raw item has drained or been explicitly removed and a current `getQueueItems()` inventory proves there are zero items with `messageFormat === 'raw-rfc822'`. Do not infer this from enqueue traffic or stale metrics.
+
+The single-writer prerequisite is strict for raw and structured queue records alike. The process-local managed-prefix guard is not a distributed lease; deployments with multiple processes or storage-wrapper instances must provide an external lease so exactly one delivery owner mutates a queue prefix.
+
 
 ### 🛂 Inbound Recipient Policy And Relay Control
 
@@ -302,6 +349,8 @@ A submission route grants an authenticated client permission to relay. It does n
 
 Without this, an authenticated submission addressed to a domain this server hosts is accepted with `250`, relayed to that domain's MX, and destroyed by the self-MX loop guard. Everything else keeps today's behaviour: recipient-scoped `process` routes still win (consumers use them for local addresses handled by their own acceptance pipeline), `store`/`deliver`/`forward`/`reject` actions always win, and a domain registered for outbound identity only — no `inboundPolicy`, or the send-only `defaultAction: 'reject'` — keeps relaying because its real MX lives elsewhere. Encoding recipient intent in `match.headers` is not recognised for this purpose.
 
+`hooks.onAuthenticate` lets the embedding application own SMTP credentials that no static configuration can express — a per-tenant binding store, a remote authority, an opaque hash such as argon2id. See [Dynamic credentials](#dynamic-credentials-hooksonauthenticate).
+
 `hooks.onRcptTo`, `hooks.onMessageData`, and `hooks.onAcceptEnvelope` are awaited asynchronously. If a hook throws or times out, SmartMTA returns a temporary SMTP failure. The hook context includes `abortSignal`; long-running consumers should observe it and stop work promptly. A custom `onRcptTo` hook may accept local recipients using application-specific lookup, but external relay is still blocked unless a matched route explicitly sets `allowRelay: true`.
 
 `hooks.onMessageData` runs after `DATA` and before the final SMTP response — but only for envelopes with **no** resolved `store` or `deliver` action; terminal local deliveries go through `hooks.onAcceptEnvelope` instead and never invoke `onMessageData`. Return `{ accepted: true }` only after your application has accepted responsibility for the message, such as after durable persistence. Set `continueProcessing: false` when the consumer owns all downstream processing.
@@ -385,7 +434,7 @@ Enforcement semantics:
 - **Recipient scope ("send TO who")** — with `recipients.mode: 'patterns'`, every `RCPT TO` matching no pattern is refused with `550`. `mode: 'any'` or an absent `recipients` block leaves recipients unrestricted.
 - **Patterns** are exact addresses (`a@b.com`) or glob patterns (`*@b.com`), matched case-insensitively with identical semantics to route matching. A scoped account sending with an empty `MAIL FROM <>` (null sender) is refused unless a pattern explicitly matches — `senders: ['*']` is the documented escape hatch.
 - **Route binding** — a route with `match.authenticatedUser: 'newsletter-service'` (or an array of usernames) matches only sessions authenticated as that account (exact, case-sensitive username comparison), so dedicated processing or relay routes can be attached per account. Unauthenticated sessions never match such routes.
-- **Rejections** surface through `onRecipientRejected` with the reasons `sender-scope`, `recipient-scope`, and `account-disabled`.
+- **Rejections** surface through `onRecipientRejected` with the reasons `sender-scope`, `recipient-scope`, `account-disabled`, and `auth-scope-expired`.
 - **Live enablement** — when a configuration update transitions between zero and one-or-more accounts/users, `updateOptions` restarts only the Rust SMTP listener so the `AUTH` capability appears or disappears without a process restart. A failed listener restart logs loudly, emits `smtpListenerRestartFailed`, and leaves `isSmtpListenerActive()` false — surface that next to `getBridgeState()` in health endpoints.
 - An account without a `scope` is authenticated but unrestricted — identical to legacy `auth.users` behavior, which itself is unchanged.
 
@@ -395,6 +444,28 @@ Deriving verifiers: `deriveScramVerifier(password, iterations?)` is the canonica
 
 Compatibility probe: `smartMtaCapabilities.smtpAuthAccountsAndScopes`.
 
+### Dynamic credentials (`hooks.onAuthenticate`)
+
+`auth.accounts` is a static list. An embedding application that mints SMTP credentials at runtime — one per tenant, per service, per binding — cannot express them that way, and cannot store them as SCRAM verifiers if its credential store is an opaque hash such as argon2id. `hooks.onAuthenticate` hands those attempts to the application instead:
+
+```ts
+hooks: {
+  async onAuthenticate({ username, password, sessionId, remoteAddress, abortSignal }) {
+    const binding = await credentialStore.verify(username, password, { signal: abortSignal });
+    if (!binding) return { accepted: false, message: 'Unknown binding' };
+    return { accepted: true, scope: { senders: [`*@${binding.domain}`] } };
+  },
+}
+```
+
+- **Configuration always wins.** The hook is consulted only for usernames that neither `auth.accounts` nor `auth.users` declares. A hook can never override, weaken or second-guess a credential an operator configured — a configured username that fails its password fails, full stop. Ownership is matched **case-insensitively** while credential verification itself stays exact, so `Tenant-A` cannot slip past a configured (or deliberately `enabled: false`) `tenant-a` by changing case: it matches no exact credential, and it never reaches the hook either.
+- **A configured hook enables `AUTH` on its own.** `isAuthConfigured` counts it alongside `auth.required`, `auth.users` and `auth.accounts`, so a server whose credentials are entirely dynamic still advertises `AUTH` with an empty account list. The same listener-restart behaviour applies when the hook is added or removed through `updateOptions`.
+- **The returned `scope` is enforced identically to an account scope** — both the `RCPT TO` envelope check and the `DATA` header-`From` alignment check — for the lifetime of the session that authenticated. An absent `scope` is unrestricted, matching `ISmtpAuthAccount.scope`; **a hook that authenticates tenants must return one.**
+- **Grants are session-bound.** They are keyed by the SMTP session that authenticated, so one session cannot inherit another's scope, and they are bounded by a hard cap of 4096 (oldest-first eviction) and a one-hour TTL. Because the listener reports no session-close event, a session may outlive its grant: that case is refused with a temporary `451` and `onRecipientRejected` reason `auth-scope-expired`, never silently treated as unrestricted. Both enforcement points refuse independently, so neither relies on the other having run first. Note the capacity edge: above 4096 concurrent hook-authenticated sessions, eviction reaches live grants, and an affected client must reconnect and authenticate again rather than being able to recover in place.
+- **Failure is closed.** A throw, a `smtp.authenticationTimeoutMs` timeout, or a non-object return rejects the attempt. The client always receives the listener's standard `535 5.7.8 Authentication credentials invalid`; a `message` on the decision is recorded in the server log, never sent to the client, so a caller cannot use it to probe which usernames exist.
+- **`PLAIN`/`LOGIN` only.** SCRAM requires the server to hold the salt, iteration count, stored key and server key; a hook that verifies an opaque credential cannot produce them. SCRAM credential lookups for hook-owned usernames report not-found, which is why the hook receives the password directly. Offer SCRAM only for usernames configured as `auth.accounts` verifiers.
+- The hook sits on the SMTP auth path: keep it fast, and keep expensive derivation bounded. `abortSignal` fires on timeout — observe it.
+
 ### 📧 Sending Emails (Automatic MX Discovery)
 
 The recommended way to send email is `sendEmail()`. It defaults to **MTA mode**, which automatically resolves MX records for each recipient domain via DNS — you don't need to know the destination mail server:
@@ -491,6 +562,8 @@ The `sendOutboundEmail` method:
 - ⏱️ Configurable connection and socket timeouts via `outbound` options on the server
 - 🪪 Uses `outbound.hostname` as the SMTP identity when configured, otherwise falls back to `hostname`; a connection proxy's `ehloHostname` overrides both for that connection
 
+`sendRawOutboundEmail(host, port, rawMessage, envelope, { dkimDomain, dkimSelector })` provides the same transport behavior for exact bytes. It accepts only canonical CRLF-terminated message bytes and a canonical separate SMTP envelope, requires `dkimDomain` to equal the envelope sender domain, and loads the exact caller-supplied selector. It fails before SMTP if that selector/key cannot be loaded or Rust cannot sign the decoded bytes.
+
 When a connection proxy returns `sourceEvidence`, successful results and
 `SmtpDeliveryError` instances carry a non-enumerable
 `outboundAuthenticationHandle`. Its `pending` value is immediately safe to
@@ -498,7 +571,8 @@ persist; its `result` promise evaluates SPF, DKIM, and DMARC over the exact
 post-DKIM message bytes and the actual connected source address. Missing source
 evidence, capture limits, DNS failures, and timeouts become `indeterminate` and
 never change the SMTP delivery outcome. Captures are one-shot, memory-only,
-size-bounded, and expire after two minutes.
+size-bounded, and expire after two minutes. A capture remains charged against
+the global capture budget until its active verification finishes.
 
 For deployments that need outbound traffic to leave through a separate edge, configure `outbound.connectionProxyProvider`. SmartMTA keeps the logical `host`/`port` as the SMTP target for MX identity and TLS/SNI, but dials the returned `connectHost`/`connectPort` as the physical TCP endpoint. Proxied sends automatically disable Rust connection pooling and call `close()` in a `finally` block, which is suitable for one-shot local proxies. The provider context also includes `senderDomain` (lowercased domain of the sending address, `undefined` when unparsable) so providers can route by sender, and the returned proxy may set `ehloHostname` to override the EHLO/HELO identity for that connection — e.g. the selected egress edge's PTR hostname.
 
@@ -564,7 +638,7 @@ When `UnifiedEmailServer.start()` is called:
 - Signing is applied exactly once, by the Rust SMTP client at final outbound transmission.
 - When a route enables signing without explicit `dkimOptions`, the selector is resolved from the sending domain's registry configuration (`domains[].dkim.selector`); the hardcoded `'default'` selector is only the last fallback.
 
-Embedders can check `smartMtaCapabilities.selectorCorrectDkimSigning`, `callerManagedDkimKeys`, `structuredSmtpTransactions`, `typedDeliveryFailures`, `terminalLocalDeliverActions` (deliver routes are terminal local deliveries through the durable acceptance path), and `smtpAuthAccountsAndScopes` (authenticated accounts with hashed credentials and send scopes) as compatibility probes.
+Embedders can check `smartMtaCapabilities.selectorCorrectDkimSigning`, `callerManagedDkimKeys`, `structuredSmtpTransactions`, `typedDeliveryFailures`, `terminalLocalDeliverActions` (deliver routes are terminal local deliveries through the durable acceptance path), `smtpAuthAccountsAndScopes` (authenticated accounts with hashed credentials and send scopes), and `durableRawOutboundQueue` as compatibility probes.
 
 ### 🛡️ Email Authentication (SPF, DKIM, DMARC)
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartmta',
-  version: '9.4.1',
+  version: '9.6.0',
   description: 'A high-performance, enterprise-grade Mail Transfer Agent (MTA) built from scratch in TypeScript with Rust acceleration.'
 }

package/ts/index.ts

@@ -16,4 +16,6 @@ export const smartMtaCapabilities = Object.freeze({
   exactAcceptedEnvelopeDispatch: true,
   terminalLocalDeliverActions: true,
   smtpAuthAccountsAndScopes: true,
+  durableRawOutboundQueue: true,
+  dynamicSmtpAuthenticationHook: true,
 } as const);