@push.rocks/smartmta 11.1.0 → 12.0.0

package/dist_ts/plugins.d.ts

@@ -17,5 +17,3 @@ export { smartlog, smartmail, smartmailValidation, smartpath, smartrust };
 export type TLogLevel = 'error' | 'warn' | 'info' | 'success' | 'debug';
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass, };
-import mailparser from 'mailparser';
-export { mailparser, };

package/dist_ts/plugins.js

@@ -19,7 +19,4 @@ export { smartlog, smartmail, smartmailValidation, smartpath, smartrust };
 // tsclass scope
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass, };
-// third party
-import mailparser from 'mailparser';
-export { mailparser, };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBQzNCLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBQ2pDLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBQzNCLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBQzNCLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBQzNCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFDTCxHQUFHLEVBQ0gsTUFBTSxFQUNOLElBQUksRUFDSixHQUFHLEVBQ0gsRUFBRSxFQUNGLElBQUksRUFDSixHQUFHLEVBQ0gsR0FBRyxFQUNILElBQUksR0FDTCxDQUFBO0FBRUQsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssbUJBQW1CLE1BQU0sa0NBQWtDLENBQUM7QUFDeEUsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBRW5ELE9BQU8sRUFBRSxRQUFRLEVBQUUsU0FBUyxFQUFFLG1CQUFtQixFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQUUsQ0FBQztBQUsxRSxnQkFBZ0I7QUFDaEIsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQUU1QyxPQUFPLEVBQ0wsT0FBTyxHQUNSLENBQUE7QUFFRCxjQUFjO0FBQ2QsT0FBTyxVQUFVLE1BQU0sWUFBWSxDQUFDO0FBRXBDLE9BQU8sRUFDTCxVQUFVLEdBQ1gsQ0FBQSJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBQzNCLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBQ2pDLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBQzNCLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBQzNCLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBQzNCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFDTCxHQUFHLEVBQ0gsTUFBTSxFQUNOLElBQUksRUFDSixHQUFHLEVBQ0gsRUFBRSxFQUNGLElBQUksRUFDSixHQUFHLEVBQ0gsR0FBRyxFQUNILElBQUksR0FDTCxDQUFBO0FBRUQsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssbUJBQW1CLE1BQU0sa0NBQWtDLENBQUM7QUFDeEUsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBRW5ELE9BQU8sRUFBRSxRQUFRLEVBQUUsU0FBUyxFQUFFLG1CQUFtQixFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQUUsQ0FBQztBQUsxRSxnQkFBZ0I7QUFDaEIsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQUU1QyxPQUFPLEVBQ0wsT0FBTyxHQUNSLENBQUEifQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartmta",
-  "version": "11.1.0",
+  "version": "12.0.0",
   "description": "A high-performance, enterprise-grade Mail Transfer Agent (MTA) built from scratch in TypeScript with Rust acceleration.",
   "keywords": [
     "mta",
@@ -31,22 +31,20 @@
     ".": "./dist_ts/index.js"
   },
   "devDependencies": {
-    "@git.zone/cli": "^8.11.0",
+    "@git.zone/cli": "^9.0.1",
     "@git.zone/tsbuild": "^6.0.2",
-    "@git.zone/tsrust": "^4.5.1",
+    "@git.zone/tsrust": "^4.6.0",
     "@git.zone/tstest": "^8.0.0",
-    "@types/mailparser": "^3.4.6",
     "@types/node": "^26.6.4",
     "tsx": "^4.23.15"
   },
   "dependencies": {
     "@push.rocks/smartlog": "^4.0.4",
-    "@push.rocks/smartmail": "^3.0.1",
+    "@push.rocks/smartmail": "^3.1.0",
     "@push.rocks/smartpath": "^6.0.0",
     "@push.rocks/smartrust": "^2.6.0",
     "@tsclass/tsclass": "^9.5.0",
-    "lru-cache": "^11.5.2",
-    "mailparser": "^3.9.14"
+    "lru-cache": "^11.5.2"
   },
   "files": [
     "ts/**/*",

package/readme.md

@@ -430,7 +430,7 @@ server.updateOptions({ auth: { accounts } });
 Enforcement semantics:
 
 - **Credentials** — `PLAIN`/`LOGIN` passwords are verified against the stored verifier by deriving `StoredKey` from the presented password (PBKDF2-HMAC-SHA256 on the async crypto threadpool) and comparing in constant time. `SCRAM-SHA-256` clients are served the stored verifier fields directly, so the plaintext never needs to exist server-side. Accounts with `enabled: false` always fail authentication on both mechanisms. Verification is fully in-memory — no I/O inside the Rust auth callback window.
-- **Sender scope ("send AS who")** — enforced twice. At the first `RCPT TO`, an out-of-scope `MAIL FROM` is refused with `553` before any recipient is accepted (with `smtp.recipientValidation: false` this check still runs, but only at `DATA`). At `DATA`, the envelope sender (taken from session envelope truth, never the parsed message alone) is re-checked per recipient, and **every** parsed header `From` mailbox must independently be in scope — header-From spoofing behind an in-scope envelope, including multi-mailbox `From:` headers, is refused with `553`.
+- **Sender scope ("send AS who")** — enforced twice. At the first `RCPT TO`, an out-of-scope `MAIL FROM` is refused with `553` before any recipient is accepted (with `smtp.recipientValidation: false` this check still runs, but only at `DATA`). At `DATA`, the envelope sender (taken from session envelope truth, never the parsed message alone) is re-checked per recipient, and **every** header `From` mailbox must independently be in scope — header-From spoofing behind an in-scope envelope is refused with `553`, including multi-mailbox `From:` fields, group syntax (members are checked), repeated `From:` fields (all are checked) and `From:` fields that yield no mailbox. A message with no `From:` field at all is accepted, because its sender is the already-checked envelope `MAIL FROM`.
 - **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.

package/ts/00_commitinfo_data.ts

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

package/ts/mail/routing/classes.unified.email.server.ts

@@ -2475,22 +2475,37 @@ export class UnifiedEmailServer extends EventEmitter {
   }
 
   /**
-   * Extract every mailbox address from the parsed From header. The Email
-   * abstraction keeps only the first From mailbox, which is not sufficient
-   * for scope enforcement: `From: allowed@a.com, victim@b.com` must not
-   * pass. Parsing stops at the first CRLFCRLF header boundary when present
-   * (the Rust receiver normalizes line endings to CRLF); a bodyless message
-   * without one is parsed whole.
+   * The mailbox addresses of every From header field, one list per field in
+   * message order. Groups are flattened into their member mailboxes, and a
+   * repeated From field is kept rather than collapsed to one occurrence,
+   * because scope enforcement and Email.from must see every mailbox a
+   * recipient's client might display. A field that yields no mailbox, such
+   * as an empty group or an encoded word in place of an address, gives an
+   * empty list.
    */
-  private async parseHeaderFromMailboxes(rawMessage: Buffer): Promise<string[]> {
+  private parseFromHeaderFields(
+    headers: ReadonlyArray<{ key: string; value: string }>,
+  ): string[][] {
+    return headers
+      .filter((header) => header.key === 'from')
+      .map((header) =>
+        plugins.smartmail.parseAddressList(header.value).map((mailbox) => mailbox.email),
+      );
+  }
+
+  /**
+   * The From header fields of the header section of a raw message, see
+   * parseFromHeaderFields. Parsing stops at the first CRLFCRLF header
+   * boundary when present (the Rust receiver normalizes line endings to
+   * CRLF); a bodyless message without one is parsed whole.
+   */
+  private async parseHeaderFromFields(rawMessage: Buffer): Promise<string[][]> {
     const headerBoundary = rawMessage.indexOf('\r\n\r\n');
     const headerSection = headerBoundary === -1
       ? rawMessage
       : rawMessage.subarray(0, headerBoundary + 4);
-    const parsed = await plugins.mailparser.simpleParser(headerSection);
-    return ((parsed.from as any)?.value || [])
-      .map((mailbox: any) => mailbox?.address)
-      .filter(Boolean) as string[];
+    const parsed = await plugins.smartmail.parseMailMessage(headerSection);
+    return this.parseFromHeaderFields(parsed.headers);
   }
 
   /**
@@ -2516,28 +2531,36 @@ export class UnifiedEmailServer extends EventEmitter {
     if (resolved.kind === 'unrestricted') return null;
     if (resolved.kind === 'refused') return UnifiedEmailServer.authScopeUnavailableDecision();
     const scope = resolved.scope;
-    let fromMailboxes: string[];
+    const notPermitted: ISmtpDecision = {
+      accepted: false,
+      smtpCode: 553,
+      smtpMessage: `5.7.1 Header From address not permitted for authenticated user ${username}`,
+    };
+    let fromFields: string[][];
     try {
-      fromMailboxes = await this.parseHeaderFromMailboxes(rawMessage);
+      fromFields = await this.parseHeaderFromFields(rawMessage);
     } catch {
-      fromMailboxes = [];
+      // A header section that cannot be read cannot be shown to be in scope
+      return notPermitted;
     }
-    if (fromMailboxes.length === 0) {
-      // No parsable From header: Email.from falls back to the envelope
-      // MAIL FROM, which resolveRecipientPolicy has already scope-checked.
+    let fromMailboxes: string[];
+    if (fromFields.length === 0) {
+      // A message without a From field is accepted deliberately: Email.from
+      // falls back to the envelope MAIL FROM, which resolveRecipientPolicy has
+      // already scope-checked, and no other sender identity is displayed.
       fromMailboxes = [email.getFromAddress()];
+    } else if (fromFields.some((field) => field.length === 0)) {
+      // A From field without a mailbox, such as an empty group or an encoded
+      // word in place of the address, still displays an identity this check
+      // cannot verify.
+      return notPermitted;
+    } else {
+      fromMailboxes = fromFields.flat();
     }
     const outOfScope = fromMailboxes.find(
       (mailbox) => !this.matchesScopePatterns(mailbox, scope.senders),
     );
-    if (outOfScope === undefined) {
-      return null;
-    }
-    return {
-      accepted: false,
-      smtpCode: 553,
-      smtpMessage: `5.7.1 Header From address not permitted for authenticated user ${username}`,
-    };
+    return outOfScope === undefined ? null : notPermitted;
   }
 
   private getRecipientValidationTimeoutMs(): number {
@@ -3499,37 +3522,38 @@ export class UnifiedEmailServer extends EventEmitter {
 
   private async createEmailFromBuffer(emailData: Buffer, session: IExtendedSmtpSession): Promise<Email> {
     try {
-      const parsed = await plugins.mailparser.simpleParser(emailData);
+      // Forwarded messages stay attachments of their bytes, so a relay hands them on unchanged
+      const parsed = await plugins.smartmail.parseMailMessage(emailData, { rfc822Attachments: true });
+      const headerFromMailboxes = this.parseFromHeaderFields(parsed.headers).flat();
       const envelopeRecipients = session.envelope.rcptTo.map(recipient => recipient.address);
-      const parsedTo = ((parsed.to as any)?.value || [])
-        .map((recipient: any) => recipient.address)
-        .filter(Boolean) as string[];
-      const parsedCc = ((parsed.cc as any)?.value || [])
-        .map((recipient: any) => recipient.address)
-        .filter(Boolean) as string[];
-      const parsedHeaders: Record<string, string> = {};
-      for (const [headerName, headerValue] of parsed.headers.entries()) {
-        if (this.isStandardParsedHeader(headerName)) {
+      const parsedHeaders = new Map<string, string>();
+      for (const header of parsed.headers) {
+        if (this.isStandardParsedHeader(header.key)) {
           continue;
         }
-        parsedHeaders[headerName] = this.stringifyParsedHeaderValue(headerValue);
+        // Raw values as written; a repeated field joins its values with ', '
+        const previous = parsedHeaders.get(header.key);
+        parsedHeaders.set(header.key, previous === undefined ? header.value : `${previous}, ${header.value}`);
       }
       return new Email({
-        from: parsed.from?.value[0]?.address || session.envelope.mailFrom.address,
+        // The first mailbox of the From fields in message order, groups flattened
+        from: headerFromMailboxes[0] || session.envelope.mailFrom.address,
         to: envelopeRecipients.length > 0
           ? envelopeRecipients
-          : parsedTo,
-        cc: parsedCc,
+          : parsed.to.map(recipient => recipient.email),
+        cc: parsed.cc.map(recipient => recipient.email),
         bcc: [],
         subject: parsed.subject || '',
-        text: parsed.text || '',
+        // A message that carries only HTML is read and scanned through its text
+        text: parsed.text ?? (parsed.html ? plugins.smartmail.htmlToText(parsed.html) : ''),
         html: parsed.html || undefined,
-        headers: parsedHeaders,
-        attachments: parsed.attachments?.map(att => ({
-          filename: att.filename || '',
-          content: att.content,
-          contentType: att.contentType
-        })) || []
+        headers: Object.fromEntries(parsedHeaders),
+        attachments: parsed.attachments.map(attachment => ({
+          filename: attachment.filename || '',
+          content: Buffer.from(attachment.content),
+          contentType: attachment.contentType,
+          ...(attachment.contentId ? { contentId: attachment.contentId } : {}),
+        })),
       });
     } catch (error) {
       logger.log('error', `Error parsing email data: ${(error as Error).message}`);
@@ -3555,22 +3579,6 @@ export class UnifiedEmailServer extends EventEmitter {
     ]).has(headerName.toLowerCase());
   }
 
-  private stringifyParsedHeaderValue(headerValue: unknown): string {
-    if (Array.isArray(headerValue)) {
-      return headerValue.map(value => this.stringifyParsedHeaderValue(value)).join(', ');
-    }
-    if (headerValue instanceof Date) {
-      return headerValue.toUTCString();
-    }
-    if (typeof headerValue === 'string') {
-      return headerValue;
-    }
-    if (headerValue && typeof headerValue === 'object' && 'text' in headerValue) {
-      return String((headerValue as { text?: unknown }).text || '');
-    }
-    return headerValue === undefined || headerValue === null ? '' : String(headerValue);
-  }
-
   /**
    * Compute SCRAM-SHA-256 credential fields from a plaintext password with a
    * fresh random salt (used for legacy plaintext credentials only; verifier

package/ts/plugins.ts

@@ -39,10 +39,3 @@ import * as tsclass from '@tsclass/tsclass';
 export {
   tsclass,
 }
-
-// third party
-import mailparser from 'mailparser';
-
-export {
-  mailparser,
-}