domma-cms 1.10.37 → 1.10.39

package/plugins/_lib/mail/accounts.js

@@ -30,7 +30,7 @@ import path from 'node:path';
 import {fileURLToPath} from 'node:url';
 
 import {normaliseIdentity, normaliseIdentityList, findIdentity} from '../admin/mail/identity.js';
-import {normaliseRules} from '../admin/mail/rules.js';
+import {normaliseRuleGroups, normaliseRules, rulesInEffect} from '../admin/mail/rules.js';
 import {normaliseUndoSeconds} from '../admin/mail/scheduling.js';
 import {normaliseVacation} from '../admin/mail/vacation.js';
 import {normaliseTemplates} from '../admin/mail/templates.js';
@@ -639,6 +639,26 @@ export function rulesToPublic(account) {
     return normaliseRules(account);
 }
 
+/**
+ * The groups this mailbox's rules are sorted into, in order.
+ *
+ * @param   {object|null} account
+ * @returns {{name: string, enabled: boolean}[]}
+ */
+export function ruleGroupsToPublic(account) {
+    return normaliseRuleGroups({ruleGroups: account?.ruleGroups, rules: normaliseRules(account)});
+}
+
+/**
+ * The rules a sync pass runs: switched on, and not in a switched-off group.
+ *
+ * @param   {object|null} account
+ * @returns {object[]}
+ */
+export function rulesToRun(account) {
+    return rulesInEffect(normaliseRules(account), ruleGroupsToPublic(account));
+}
+
 /**
  * Store the filing rules for a mailbox.
  *
@@ -653,15 +673,19 @@ export function rulesToPublic(account) {
  * @param   {object[]} rules
  * @returns {Promise<object|null>}
  */
-export async function setRules(userId, accountId, rules) {
+export async function setRules(userId, accountId, rules, groups = undefined) {
     return withStoreLock(async () => {
         const all = await readAll();
         const index = all.findIndex(a => a.id === accountId && a.userId === userId);
         if (index === -1) return null;
 
+        const saved = normaliseRules({rules});
         all[index] = {
             ...all[index],
-            rules: normaliseRules({rules}),
+            rules: saved,
+            // Only when given: a caller that knows nothing of groups (an older
+            // screen) keeps the stored ones.
+            ...(Array.isArray(groups) ? {ruleGroups: normaliseRuleGroups({ruleGroups: groups, rules: saved})} : {}),
             rulesFrom: all[index].rulesFrom ?? new Date().toISOString(),
             updatedAt: new Date().toISOString()
         };
@@ -725,6 +749,65 @@ export async function setSendingOptions(userId, accountId, options) {
     });
 }
 
+/**
+ * How a new message from this mailbox starts out, and two rules about where
+ * and how it leaves.
+ *
+ * All off by default, which is what every message sent before these existed
+ * did. The receipts, signing and encryption are only where the compose
+ * window's ticks START - each message can still change them. The other two
+ * are the mailbox's rules and apply to every message:
+ * `repliesInSourceFolder` files the copy of a reply beside the message it
+ * answers instead of in Sent, and `requireSecureDelivery` refuses to send
+ * unless the outgoing server promises TLS all the way (REQUIRETLS, RFC 8689).
+ */
+export const COMPOSE_DEFAULTS = Object.freeze({
+    readReceipt: false,
+    deliveryReceipt: false,
+    sign: false,
+    encrypt: false,
+    repliesInSourceFolder: false,
+    requireSecureDelivery: false
+});
+
+/**
+ * This mailbox's compose options, every key present.
+ *
+ * @param   {object|null} account
+ * @returns {typeof COMPOSE_DEFAULTS}
+ */
+export function composeOptions(account) {
+    const stored = account?.compose && typeof account.compose === 'object' ? account.compose : {};
+    return Object.fromEntries(Object.keys(COMPOSE_DEFAULTS)
+        .map(key => [key, stored[key] === true]));
+}
+
+/**
+ * Store the compose options. Only the known switches, only as booleans; a key
+ * left out keeps its stored value, so a screen that knows half of them cannot
+ * switch the other half off.
+ *
+ * @param   {string} userId
+ * @param   {string} accountId
+ * @param   {object} options
+ * @returns {Promise<object|null>}
+ */
+export async function setComposeOptions(userId, accountId, options) {
+    return withStoreLock(async () => {
+        const all = await readAll();
+        const index = all.findIndex(a => a.id === accountId && a.userId === userId);
+        if (index === -1) return null;
+
+        const next = composeOptions(all[index]);
+        for (const key of Object.keys(COMPOSE_DEFAULTS)) {
+            if (typeof options?.[key] === 'boolean') next[key] = options[key];
+        }
+        all[index] = {...all[index], compose: next, updatedAt: new Date().toISOString()};
+        await writeAll(all);
+        return all[index];
+    });
+}
+
 /**
  * Every address this mailbox sends as.
  *

package/plugins/_lib/mail/compose.js

@@ -10,7 +10,7 @@
  * @module _lib/mail/compose
  */
 import {readPriority} from './priority.js';
-import {normaliseMessageSource, readMessageSource} from './message-action.js';
+import {normaliseMessageSource, readComposeFlags, readMessageSource} from './message-action.js';
 
 /**
  * Addresses to reply to.
@@ -237,6 +237,10 @@ export function editableDraft(message, uid = null) {
         // Kept, or a draft marked urgent would quietly become ordinary the
         // moment it was reopened.
         priority: readPriority(message.headers),
+        // Both kept for the same reason: a draft that asked for a receipt, or
+        // to be signed or encrypted, must not quietly stop asking on reopen.
+        readReceipt: hasHeader(message.headers, 'disposition-notification-to'),
+        ...readComposeFlags(message.headers),
         attachments: (message.attachments ?? []).map(file => ({
             filename: file.filename ?? 'attachment',
             contentType: file.contentType ?? 'application/octet-stream',
@@ -248,6 +252,16 @@ export function editableDraft(message, uid = null) {
     };
 }
 
+/**
+ * @param   {Map|object|undefined} headers - mailparser's headers
+ * @param   {string} name - lower case
+ * @returns {boolean}
+ */
+function hasHeader(headers, name) {
+    const value = typeof headers?.get === 'function' ? headers.get(name) : headers?.[name];
+    return value !== undefined && value !== null && value !== '';
+}
+
 /**
  * References arrive as a string on one server and an array on the next.
  *

package/plugins/_lib/mail/message-action.js

@@ -22,6 +22,38 @@ export function readMessageSource(headers) {
     } catch { return null; }
 }
 
+/**
+ * The compose ticks a saved draft carries - delivery receipt, sign, encrypt -
+ * none of which leaves a trace a reopened draft could read back otherwise
+ * (the read receipt does: its own header). Private, like SOURCE_HEADER: only
+ * ever written into a draft, never onto a message that is sent.
+ */
+export const COMPOSE_HEADER = 'X-Domma-Compose';
+const COMPOSE_FLAGS = ['deliveryReceipt', 'sign', 'encrypt'];
+
+/**
+ * @param   {object} draft
+ * @returns {string|null} the header value, or null when nothing is ticked
+ */
+export function composeFlagsHeader(draft) {
+    const on = COMPOSE_FLAGS.filter(key => draft?.[key] === true);
+    return on.length ? Buffer.from(JSON.stringify(Object.fromEntries(on.map(k => [k, true])))).toString('base64url') : null;
+}
+
+/**
+ * @param   {Map|object} headers - mailparser's headers
+ * @returns {{deliveryReceipt: boolean, sign: boolean, encrypt: boolean}}
+ */
+export function readComposeFlags(headers) {
+    const value = typeof headers?.get === 'function'
+        ? headers.get(COMPOSE_HEADER.toLowerCase()) : headers?.[COMPOSE_HEADER.toLowerCase()];
+    let parsed = {};
+    if (typeof value === 'string' && value.length <= 512) {
+        try { parsed = JSON.parse(Buffer.from(value, 'base64url').toString('utf8')) ?? {}; } catch { parsed = {}; }
+    }
+    return Object.fromEntries(COMPOSE_FLAGS.map(key => [key, parsed[key] === true]));
+}
+
 /** Best effort: recording a delivered message must never turn it into a failed send. */
 export async function recordMessageAction({source, account, pool, poolKey, connection, store = null}) {
     source = normaliseMessageSource(source);

package/plugins/_lib/mail/messageSecurity.js

@@ -0,0 +1,111 @@
+/**
+ * Where signing and encryption plug into the mail core.
+ *
+ * The core builds, sends, files and reads raw messages; it does not know
+ * S/MIME. An edition that does (Email Pro) registers a provider here at boot,
+ * and every path that sends - the send route, the scheduler behind undo and
+ * send-later - or reads a message body goes through it. A registry rather
+ * than an option threaded through each caller, because the scheduler is core
+ * code started by the edition and would otherwise need the provider passed
+ * down three layers to reach the one call that uses it.
+ *
+ * The provider:
+ *   protect({raw, draft, account, userId}) -> Promise<Buffer>
+ *       the message as it should leave and be filed; called only when the
+ *       draft asks for `sign` or `encrypt`. Throws a plain Error to refuse.
+ *   protectDraft({raw, draft, account, userId}) -> Promise<Buffer>   (optional)
+ *       a draft of a message to be encrypted, encrypted to the sender alone.
+ *   unwrap({raw, account, userId}) -> Promise<{raw: Buffer, security: object|null}>
+ *       the message as it should be read; never throws for a bad message,
+ *       it says so in `security.problem` and hands the original back.
+ *
+ * @module _lib/mail/messageSecurity
+ */
+import {simpleParser} from 'mailparser';
+
+let provider = null;
+
+/**
+ * Register (or, with null, remove) the provider. One at a time: the editions
+ * never run together.
+ *
+ * @param   {{protect: Function, unwrap: Function}|null} next
+ * @returns {void}
+ */
+export function setMessageSecurity(next) {
+    provider = next && typeof next.protect === 'function' && typeof next.unwrap === 'function' ? next : null;
+}
+
+/** @returns {boolean} whether a message can be signed or encrypted here */
+export function canProtect() {
+    return provider !== null;
+}
+
+/**
+ * The message as it should leave. A draft that asks for neither comes back as
+ * it was; one that asks with no provider registered is refused, because
+ * sending it unprotected is the one outcome the sender ruled out.
+ *
+ * @param   {{raw: Buffer, draft: object, account?: object|null, userId?: string|null}} input
+ * @returns {Promise<Buffer>}
+ */
+export async function protectRaw(input) {
+    const wanted = input.draft?.sign === true || input.draft?.encrypt === true;
+    if (!wanted) return input.raw;
+    if (!provider) {
+        throw new Error('Signing and encryption need Email Pro with a certificate set up. The message was not sent.');
+    }
+    return provider.protect(input);
+}
+
+/**
+ * A draft as it should be stored: encrypted to the sender alone when the
+ * message is to be encrypted and the provider can (`protectDraft`), so the
+ * Drafts folder - which every client syncs - does not hold the plain text of
+ * a message meant to be secret. Otherwise, and on any failure, as it was: a
+ * draft that cannot be saved is worse, and the send itself still refuses to
+ * go out unencrypted.
+ *
+ * @param   {{raw: Buffer, draft: object, account?: object|null, userId?: string|null}} input
+ * @returns {Promise<Buffer>}
+ */
+export async function protectDraftRaw(input) {
+    if (input.draft?.encrypt !== true || typeof provider?.protectDraft !== 'function') return input.raw;
+    try {
+        return (await provider.protectDraft(input)) ?? input.raw;
+    } catch {
+        return input.raw;
+    }
+}
+
+/**
+ * The message as it should be read.
+ *
+ * @param   {{raw: Buffer, account?: object|null, userId?: string|null}} input
+ * @returns {Promise<{raw: Buffer, security: object|null}>}
+ */
+export async function unwrapRaw(input) {
+    if (!provider) return {raw: input.raw, security: null};
+    try {
+        const result = await provider.unwrap(input);
+        return result?.raw ? result : {raw: input.raw, security: null};
+    } catch {
+        // A provider fault must never cost the reader the message itself.
+        return {raw: input.raw, security: null};
+    }
+}
+
+/**
+ * Parse a message as it should be read: unwrapped first, then mailparser.
+ * Every route that shows, quotes or hands off a message's content goes
+ * through this, so an encrypted message reads the same in the pane, in a
+ * reply's quote and in its attachments.
+ *
+ * @param   {Buffer} raw
+ * @param   {{account?: object|null, userId?: string|null}} [context]
+ * @returns {Promise<{parsed: object, security: object|null}>}
+ */
+export async function parseReadable(raw, {account = null, userId = null} = {}) {
+    const {raw: readable, security} = await unwrapRaw({raw, account, userId});
+    return {parsed: await simpleParser(readable), security};
+}

package/plugins/_lib/mail/readRoutes.js

@@ -25,7 +25,6 @@
  *
  * @module _lib/mail/readRoutes
  */
-import {simpleParser} from 'mailparser';
 
 import {listUsers} from '../../../server/services/users.js';
 import {getConfig} from '../../../server/config.js';
@@ -41,6 +40,34 @@ import {listAttachments, MENU_BRIDGE_CSP, renderBody} from './render.js';
 import {readUnsubscribe} from './unsubscribe.js';
 import {MailKeyError} from './secretbox.js';
 import {unreadBadge} from './unreadBadge.js';
+import {parseReadable} from './messageSecurity.js';
+
+/**
+ * The security facts the reader shows - nothing else of the provider's
+ * answer (certificates, chains) goes to the browser.
+ *
+ * @param   {object|null} security
+ * @returns {object|null}
+ */
+export function publicSecurity(security) {
+    if (!security) return null;
+    const signer = security.signer ?? null;
+    return {
+        encrypted: security.encrypted === true,
+        decrypted: security.decrypted === true,
+        signed: security.signed === true,
+        verified: security.verified === true,
+        trusted: security.trusted === true,
+        fromMatches: security.fromMatches === true,
+        signer: signer ? {
+            emails: Array.isArray(signer.emails) ? signer.emails.map(String).slice(0, 10) : [],
+            subject: String(signer.subject ?? ''),
+            fingerprint: String(signer.fingerprint ?? ''),
+            notAfter: signer.notAfter ?? null
+        } : null,
+        problem: security.problem ? String(security.problem) : null
+    };
+}
 
 /**
  * Flatten an envelope address list into something the browser can render.
@@ -223,9 +250,9 @@ export function registerReadRoutes(fastify, {auth, hooks, config, pool, pluginNa
                 if (failed && Date.now() < failed.until) { boxes.push({label: account.label, unseen: null}); continue; }
                 try {
                     const status = await pool.withClient(`${uid}:${account.id}`, accounts.toConnection(account),
-                        client => client.status('INBOX', {unseen: true}));
+                        client => client.status('INBOX', {unseen: true, uidNext: true}));
                     failures.delete(key);
-                    boxes.push({label: account.label, unseen: status?.unseen ?? 0});
+                    boxes.push({id: account.id, label: account.label, unseen: status?.unseen ?? 0, uidNext: status?.uidNext ?? null});
                 } catch {
                     const wait = Math.min((failed?.wait || 150_000) * 2, 3_600_000);
                     failures.set(key, {wait, until: Date.now() + wait});
@@ -550,7 +577,7 @@ export function registerReadRoutes(fastify, {auth, hooks, config, pool, pluginNa
                 return null;
             }
 
-            const parsed = await simpleParser(fetched.source);
+            const {parsed, security} = await parseReadable(fetched.source, {account: ctx.account, userId: ctx.uid});
             const from = addresses(parsed.from?.value);
             const senderTrusted = accounts.sendersImagesTrusted(ctx.account, from);
             const allowRemoteImages = requestedNow || config.allowRemoteImages || senderTrusted;
@@ -606,6 +633,9 @@ export function registerReadRoutes(fastify, {auth, hooks, config, pool, pluginNa
                 // an unsubscribe link is reading; acting on it is a write and
                 // lives in the Pro edition.
                 unsubscribe: readUnsubscribe(parsed.headers),
+                // Signed and/or encrypted (S/MIME), and what came of checking -
+                // null for an ordinary message, or where no edition can tell.
+                security: publicSecurity(security),
                 attachments: listAttachments(parsed.attachments)
             };
         }));
@@ -660,7 +690,7 @@ export function registerReadRoutes(fastify, {auth, hooks, config, pool, pluginNa
                 if (!fetched || !fetched.source) return null;
                 if (fetched.source.length > config.maxMessageBytes) return null;
 
-                const parsed = await simpleParser(fetched.source);
+                const {parsed} = await parseReadable(fetched.source, {account, userId: grant.userId});
                 return renderBody(parsed, {
                     allowRemoteImages: grant.images,
                     inlineImageMaxBytes: config.inlineImageMaxBytes
@@ -790,7 +820,7 @@ export function registerReadRoutes(fastify, {auth, hooks, config, pool, pluginNa
                 return null;
             }
 
-            const parsed = await simpleParser(fetched.source);
+            const {parsed} = await parseReadable(fetched.source, {account: ctx.account, userId: ctx.uid});
             const attachment = parsed.attachments?.[index];
             if (!attachment) {
                 reply.code(404).send({error: 'That attachment is not on this message.'});

package/plugins/_lib/mail/send.js

@@ -16,7 +16,9 @@ import {bareAddress, formatFrom} from '../admin/mail/identity.js';
 import {describeError} from './imapPool.js';
 import {pinMailHost} from './hostGuard.js';
 import {normalisePriority, priorityHeaders} from './priority.js';
-import {normaliseMessageSource, recordMessageAction, SOURCE_HEADER} from './message-action.js';
+import {composeFlagsHeader, COMPOSE_HEADER, normaliseMessageSource, recordMessageAction, SOURCE_HEADER} from './message-action.js';
+import {composeOptions} from './accounts.js';
+import {protectDraftRaw, protectRaw} from './messageSecurity.js';
 
 // MailComposer is not on nodemailer's public export, but it is the piece that
 // turns a message object into the bytes that go on the wire - which is what a
@@ -195,10 +197,12 @@ export async function sendMessage({
     smtp, draft, pool, poolKey, connection, sentFolder = null, allowInsecureTLS = false,
     replaces = null, draftsFolder = null, headers = {}, fileCopy = true, account = null, store = null
 }) {
+    const options = composeOptions(account);
+
     // The header carries the display name; the envelope never can. They are
     // built from the same stored address so they cannot name two different
     // mailboxes, but they are not the same string.
-    const raw = await buildRaw(draft, formatFrom(smtp.from, smtp.fromName), {
+    const built = await buildRaw(draft, formatFrom(smtp.from, smtp.fromName), {
         replyTo: smtp.replyTo,
         // Asked for per message, addressed to wherever replies would go -
         // which is the Reply-To when there is one and the From otherwise.
@@ -210,6 +214,13 @@ export async function sendMessage({
         headers
     });
 
+    // Signed and/or encrypted when the message asks - after it is built and
+    // before it is sent, so what is sent and what is filed are one buffer, as
+    // ever. Encrypted, the copy in Sent is encrypted too (to the sender as
+    // well as the recipients), which is the point: a copy readable by anyone
+    // with the mailbox password would undo it.
+    const raw = await protectRaw({raw: built, draft, account, userId: account?.userId ?? null});
+
     // The same setting that governs incoming TLS governs outgoing: a site
     // running its own mail server with a self-signed certificate has the same
     // problem in both directions, and two switches for one decision is how
@@ -221,6 +232,8 @@ export async function sendMessage({
     try {
         transport = nodemailer.createTransport({
             ...await pinnedTransport(smtp.transport, pool?.mailHostOptions),
+            // Secure delivery starts with this hop: STARTTLS or nothing.
+            ...(options.requireSecureDelivery ? {requireTLS: true} : {}),
             tls: {rejectUnauthorized: !allowInsecureTLS}
         });
         info = await transport.sendMail({
@@ -232,10 +245,11 @@ export async function sendMessage({
                 to: [...addresses(draft.to), ...addresses(draft.cc), ...addresses(draft.bcc)]
                     .map(a => a.address)
             },
+            ...deliveryOptions(draft, options),
             raw
         });
     } catch (err) {
-        throw plainSendError(err, smtp.transport);
+        throw plainSendError(err, {...smtp.transport, requireTLS: options.requireSecureDelivery});
     } finally {
         transport?.close();
     }
@@ -252,7 +266,11 @@ export async function sendMessage({
         // is a Sent folder nobody can find anything in - the responder keeps
         // its own log instead.
         if (!fileCopy) throw new SkipFiling();
-        const destination = sentFolder ?? await findSentFolder(pool, poolKey, connection);
+        const destination = await filingFolder({
+            pool, poolKey, connection, sentFolder,
+            source: options.repliesInSourceFolder && account ? draft.sourceMessage : null,
+            accountId: account?.id ?? null
+        });
         if (destination) {
             await pool.withClient(poolKey, connection,
                 client => client.append(destination, raw, ['\\Seen']));
@@ -280,6 +298,66 @@ export async function sendMessage({
     };
 }
 
+/**
+ * The SMTP extras a message asks for: a delivery status notification (DSN,
+ * RFC 3461) when it wants a delivery receipt, and REQUIRETLS (RFC 8689) when
+ * the mailbox requires secure delivery.
+ *
+ * A delivery receipt is the outgoing server's to give: one that does not offer
+ * DSN sends the message without asking, which is the most a client can do.
+ * REQUIRETLS is the opposite - asked for, it must be honoured, and a server
+ * that cannot is refused before the message leaves (EREQUIRETLS).
+ *
+ * @param   {object} draft
+ * @param   {{requireSecureDelivery?: boolean}} options
+ * @returns {object}
+ */
+export function deliveryOptions(draft, options = {}) {
+    return {
+        // Headers, not the whole message, come back with the report: the
+        // sender has the message already, and a full copy doubles the mail.
+        ...(draft?.deliveryReceipt === true
+            ? {dsn: {ret: 'HDRS', notify: ['SUCCESS', 'FAILURE', 'DELAY']}}
+            : {}),
+        ...(options.requireSecureDelivery === true ? {requireTLSExtensionEnabled: true} : {})
+    };
+}
+
+/**
+ * Where the copy of a sent message is filed.
+ *
+ * Sent, normally. A reply goes beside the message it answers when the mailbox
+ * says so - the folder it was replied from, so a conversation filed under a
+ * project keeps both halves there. Never into Trash, Junk or Drafts (a reply
+ * written from the bin is not meant to live in it), nor into a folder that
+ * has gone, nor for another mailbox's message: those fall back to Sent.
+ *
+ * @param   {{folders: Array<{path: string, specialUse?: string}>, sentFolder?: string|null,
+ *            source?: object|null, accountId?: string|null}} input
+ * @returns {string|null}
+ */
+export function chooseFilingFolder({folders = [], sentFolder = null, source = null, accountId = null}) {
+    const sent = sentFolder ?? folders.find(box => box.specialUse === '\\Sent')?.path ?? null;
+    const from = normaliseMessageSource(source);
+    if (!from || from.action !== 'reply' || !accountId || from.accountId !== accountId) return sent;
+    const box = folders.find(entry => entry.path === from.folder);
+    if (!box || ['\\Trash', '\\Junk', '\\Drafts'].includes(box.specialUse)) return sent;
+    return box.path;
+}
+
+/**
+ * The folder list, then `chooseFilingFolder`. Skips the listing when there is
+ * nothing to choose: Sent is already known and this is not a reply to file
+ * elsewhere.
+ *
+ * @returns {Promise<string|null>}
+ */
+async function filingFolder({pool, poolKey, connection, sentFolder, source, accountId}) {
+    if (sentFolder && !source) return sentFolder;
+    const folders = await pool.withClient(poolKey, connection, client => client.list());
+    return chooseFilingFolder({folders, sentFolder, source, accountId});
+}
+
 /**
  * Take a superseded draft out of the Drafts folder.
  *
@@ -295,7 +373,7 @@ export async function sendMessage({
  *            draftsFolder?: string|null}} options
  * @returns {Promise<boolean>}
  */
-async function discardDraft({pool, poolKey, connection, uid, draftsFolder = null}) {
+export async function discardDraft({pool, poolKey, connection, uid, draftsFolder = null}) {
     try {
         const destination = draftsFolder
             ?? await findSpecialFolder(pool, poolKey, connection, '\\Drafts');
@@ -327,16 +405,20 @@ async function discardDraft({pool, poolKey, connection, uid, draftsFolder = null
  * @returns {Promise<{savedTo: string, uid: number|null, replaced: number|null}>}
  */
 export async function saveDraft({
-    draft, from, replyTo = '', pool, poolKey, connection, draftsFolder = null, replaces = null
+    draft, from, replyTo = '', pool, poolKey, connection, draftsFolder = null, replaces = null, account = null
 }) {
     // Written into the draft, not applied when it is eventually sent: a draft
     // opened on the phone should show the same headers it will go out with.
     const source = normaliseMessageSource(draft.sourceMessage);
+    const flags = composeFlagsHeader(draft);
     const raw = await buildRaw(draft, from, {
         replyTo,
         readReceiptTo: draft.readReceipt ? (replyTo || bareAddress(from)) : '',
         // Private draft metadata: it is omitted from SMTP and the Sent copy.
-        headers: source ? {[SOURCE_HEADER]: Buffer.from(JSON.stringify(source)).toString('base64url')} : {}
+        headers: {
+            ...(source ? {[SOURCE_HEADER]: Buffer.from(JSON.stringify(source)).toString('base64url')} : {}),
+            ...(flags ? {[COMPOSE_HEADER]: flags} : {})
+        }
     });
 
     const destination = draftsFolder ?? await findSpecialFolder(pool, poolKey, connection, '\\Drafts');
@@ -344,8 +426,12 @@ export async function saveDraft({
         throw new Error('This server has no Drafts folder to save into.');
     }
 
+    // A message that is to be encrypted is not left readable in Drafts: it
+    // is encrypted to the sender alone, and opened again when reopened.
+    const stored = await protectDraftRaw({raw, draft, account, userId: account?.userId ?? null});
+
     const appended = await pool.withClient(poolKey, connection,
-        client => client.append(destination, raw, ['\\Draft', '\\Seen']));
+        client => client.append(destination, stored, ['\\Draft', '\\Seen']));
 
     // Only now is the previous version expendable.
     let replaced = null;
@@ -378,21 +464,6 @@ async function findSpecialFolder(pool, poolKey, connection, use) {
     return boxes.find(box => box.specialUse === use)?.path ?? null;
 }
 
-/**
- * Where this server keeps sent mail.
- *
- * By SPECIAL-USE, never by name: it is localised on plenty of servers, and
- * guessing wrong means the copy lands in a folder nobody looks at.
- *
- * @param   {object} pool
- * @param   {string} poolKey
- * @param   {object} connection
- * @returns {Promise<string|null>}
- */
-async function findSentFolder(pool, poolKey, connection) {
-    return findSpecialFolder(pool, poolKey, connection, '\\Sent');
-}
-
 /**
  * A send failure as plain words. Our own errors (a refused host, a mailbox that
  * needs signing in again) pass as they are; anything from the server or the
@@ -405,6 +476,17 @@ async function findSentFolder(pool, poolKey, connection) {
  */
 export function plainSendError(err, transportConfig = {}) {
     if (!err || err.needsReconnect || err.mailHostRefused || err.name === 'MailKeyError') return err;
+    // Asked for, and the outgoing server could not promise it - said in words,
+    // because "not sent" is the right answer and the reason is the useful part.
+    // A certificate problem is NOT this - it keeps describeError's own words.
+    if (err.code === 'EREQUIRETLS'
+        || (err.code === 'ETLS' && transportConfig.requireTLS && /upgrading connection with STARTTLS/i.test(err.message ?? ''))) {
+        const plain = new Error('Not sent: this mailbox requires secure delivery, and its outgoing server '
+            + 'cannot promise it (it does not offer REQUIRETLS over an encrypted connection). '
+            + 'Switch "Require secure delivery" off in Settings > Composing to send it normally.');
+        plain.code = 'EREQUIRETLS';
+        return plain;
+    }
     const plain = new Error(describeError(err, transportConfig));
     if (err.code) plain.code = err.code;
     if (err.responseCode) plain.responseCode = err.responseCode;

package/plugins/_lib/mail/store.js

@@ -826,6 +826,28 @@ export function createStore(connection) {
             .toArray();
     }
 
+    /**
+     * The highest UID among a mailbox's unread messages in these folders -
+     * the "new mail arrived" mark for the sidebar's notifications. A UID only
+     * grows as mail arrives, so reading the newest message lowers this and
+     * a new arrival raises it past anything seen before.
+     *
+     * @param   {string} accountId
+     * @param   {string[]|null} [folders]
+     * @returns {Promise<number|null>}
+     */
+    async function newestUnreadUid(accountId, folders = null) {
+        const database = await connect();
+        const filter = {accountId, seen: false};
+        if (Array.isArray(folders) && folders.length) filter.folder = {$in: folders};
+        const row = await database.collection(MESSAGES)
+            .find(filter, {projection: {_id: 0, uid: 1}})
+            .sort({uid: -1})
+            .limit(1)
+            .next();
+        return Number.isFinite(row?.uid) ? row.uid : null;
+    }
+
     /**
      * The newest mirrored messages to or from any of these addresses, across
      * the given mailboxes - a contact's emails, for the card in Contacts.
@@ -1081,7 +1103,7 @@ export function createStore(connection) {
         connect,
         getFolder, saveFolder,
         putMessages, setFlags, setMessageAction, removeMessages, clearFolder,
-        storedUids, listMessages, listThreads, searchMessages, countUnread, listUnread, listByAddresses, forgetAccount,
+        storedUids, listMessages, listThreads, searchMessages, countUnread, listUnread, newestUnreadUid, listByAddresses, forgetAccount,
         queueSend, listQueuedSends, claimDueSends, finishSend, cancelSend, getQueuedSend,
         queueSnooze, listSnoozed, claimDueSnoozes, finishSnooze, wakeSnooze,
         lastAutoReply, noteAutoReply, listAutoReplies, clearAutoReplies,

package/plugins/_lib/mail/sync.js

@@ -218,7 +218,10 @@ export async function syncAccount({pool, store, account, config}) {
     const {paths, source} = resolveSyncFolders(account, folders);
     const results = {};
 
-    const rules = accounts.rulesToPublic(account).filter(rule => rule.enabled);
+    // Switched on, and not in a switched-off group.
+    const rules = accounts.rulesToRun
+        ? accounts.rulesToRun(account)
+        : accounts.rulesToPublic(account).filter(rule => rule.enabled);
     const ruleFolders = new Set(rules.length ? accounts.ruleFolders(account) : []);
 
     // The away message answers mail arriving in the same folders rules run