domma-cms 1.10.38 → 1.10.39

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [1.10.39] - 2026-10-27
+
+- Email rules can be sorted into named groups, each switched on or off as a whole; rules run in the order shown (ungrouped first, then each group). The message menu offers "Create a rule from this message…", which opens Rules with a new rule matching the sender (or the mailing list). Requires Email Pro 0.12.0 for the screens.
+
 ## [1.10.38] - 2026-10-27
 
 - Email gains Thunderbird's compose settings. Per mailbox: default read and delivery receipts (SMTP DSN), replies filed in the folder of the message they answer, and require secure delivery (REQUIRETLS - refused, with the reason, when the outgoing server cannot promise it). In this browser: default editor (rich or plain text), automatic draft saving (an automatic-only draft goes on Discard), spell checking, and registering Email as the mailto: link handler. Compose shows Read receipt, Delivery receipt, Sign and Encrypt ticks, and a reopened draft keeps them.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domma-cms",
-  "version": "1.10.38",
+  "version": "1.10.39",
   "description": "File-based CMS powered by Domma and Fastify. Run npx domma-cms my-site to create a new project.",
   "type": "module",
   "main": "server/server.js",

package/plugins/_lib/admin/mail/reader-view.js

@@ -50,6 +50,7 @@ const {fillMessageAction, loadMessageActions, messageFacts} = await import(versi
 const {isPlainKey, keyBelongsElsewhere, resolveKey, SHORTCUTS} = await import(versioned('keyboard.js'));
 const {menuPoint, quoteSelection, readBridgeMessage, selectionItems} = await import(versioned('body-menu.js'));
 const {describeWhen, quickTimes} = await import(versioned('scheduling.js'));
+const {ruleFromMessage} = await import(versioned('rules.js'));
 // Optional for the same reason as oauth-panel.js below.
 const {securityNote} = await import(versioned('security-note.js')).catch(() => ({securityNote: () => null}));
 // Sign in with Microsoft / Google (Email Pro). Optional: an older copy of this
@@ -194,6 +195,8 @@ function formatSize(bytes) {
  */
 export function createReaderView({pluginName, assetVersion = ASSET_VERSION, settingsSections = [], features = {},
     extensions = {}}) {
+    // Filing rules come with an edition's Rules tab (Email Pro).
+    const hasRules = settingsSections.some(section => section?.id === 'rules');
 const BASE = `/api/plugins/${pluginName}`;
 
 // Deliberately NOT keyed by plugin. The two editions never run together - the
@@ -910,13 +913,16 @@ return {
          *
          * @returns {void}
          */
-        function openSettings() {
+        function openSettings(target = null) {
             // One at a time: a second click, or a needs-password error while
             // it is open, must not stack a second panel on the first.
-            if (!settingsOnce.claim()) return;
+            if (!settingsOnce.claim()) {
+                if (target) E.toast('Mail Settings is already open. Close it first.', {type: 'info'});
+                return;
+            }
             let panel = null;
             try {
-                buildSettings((so) => { panel = so; });
+                buildSettings((so) => { panel = so; }, target);
             } catch (err) {
                 // Failed before it opened: let go of everything it took.
                 panel?.__mailAbandon?.();
@@ -926,7 +932,13 @@ return {
         }
 
         /** @returns {void} */
-        function buildSettings(made = () => {}) {
+        /**
+         * @param {Function} [made] - handed the slideover once it exists
+         * @param {{section: string, request?: object}|null} [target] - open on
+         *        this tab, and hand its section `ctx.request` (once) - e.g. the
+         *        rule a message's "Create a rule…" starts
+         */
+        function buildSettings(made = () => {}, target = null) {
             // Help popovers per drawn section, let go when the panel closes.
             const helpDisposers = [];
             // What sections registered through ctx.guard / ctx.onClose.
@@ -1007,8 +1019,11 @@ return {
              *
              * @returns {object}
              */
-            function context() {
+            function context(section = null) {
                 return {
+                    // What opened this section, when something did (a menu
+                    // item asking for a new rule). Only for that section.
+                    request: target && section?.id === target.section ? (target.request ?? null) : null,
                     account: mailboxes.find(b => b.id === currentAccountId) ?? mailboxes[0] ?? null,
                     mailboxes,
                     base: BASE,
@@ -1086,7 +1101,7 @@ return {
                     panel.appendChild(head);
                 }
                 try {
-                    await section.render(panel, context());
+                    await section.render(panel, context(section));
                 } catch (err) {
                     const message = document.createElement('p');
                     message.className = 'text-sm text-danger';
@@ -1135,8 +1150,15 @@ return {
                 host.appendChild(tabs);
                 slideover.element.appendChild(host);
                 E.tabs(tabs);
-                panels[0].drawn = true;
-                draw(panels[0].section, panels[0].panel);
+                // The tab asked for, through its own trigger so the tabs
+                // component switches as it would on a click; else the first.
+                const first = panels.findIndex(p => p.section.id === target?.section);
+                if (first > 0) {
+                    list.children[first].click();
+                } else {
+                    panels[0].drawn = true;
+                    draw(panels[0].section, panels[0].panel);
+                }
                 slideover.open();
                 return;
             }
@@ -3742,6 +3764,12 @@ return {
                     {type: 'divider'}
                 ] : []),
                 ...toolActionItems(message),
+                // An edition with filing rules: start one from this message.
+                ...(hasRules ? [{
+                    label: 'Create a rule from this message\u2026',
+                    icon: 'filter',
+                    action: () => openSettings({section: 'rules', request: {newRule: ruleFromMessage(message)}})
+                }] : []),
                 {type: 'divider'},
                 {
                     label: 'Mark as spam',

package/plugins/_lib/admin/mail/rules.js

@@ -32,6 +32,14 @@ export const MAX_RULES = 50;
 /** How many conditions or actions one rule may hold. */
 export const MAX_CLAUSES = 10;
 
+/** How many groups one mailbox's rules may be sorted into. */
+export const MAX_GROUPS = 20;
+
+/** A group name: one line, short, trimmed. */
+function groupName(value) {
+    return String(value ?? '').replace(/[\r\n\t]+/g, ' ').trim().slice(0, 60);
+}
+
 /**
  * The parts of a message a rule can look at.
  *
@@ -217,6 +225,9 @@ export function normaliseRule(input, index = 0) {
             : `rule-${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36).slice(-4)}`,
         name: String(source.name ?? '').replace(/[\r\n]+/g, ' ').trim() || `Rule ${index + 1}`,
         enabled: source.enabled !== false,
+        // The group it is filed under; '' for none. A group is a NAME, so a
+        // rule and the group list can never point at an id that went away.
+        group: groupName(source.group),
         match: source.match === 'any' ? 'any' : 'all',
         conditions,
         actions
@@ -244,6 +255,76 @@ export function normaliseRules(account) {
     return list;
 }
 
+/**
+ * A mailbox's rule groups, in the order they are shown and run: the stored
+ * list (`account.ruleGroups`, `[{name, enabled}]`), then any group a rule
+ * names that the list lacks - so a group cannot vanish from under its rules.
+ * Names compare without case; the first spelling wins.
+ *
+ * @param   {object|null|undefined} account - `{ruleGroups, rules}`
+ * @returns {{name: string, enabled: boolean}[]}
+ */
+export function normaliseRuleGroups(account) {
+    const source = account && typeof account === 'object' ? account : {};
+    const out = [];
+    const seen = new Set();
+    const add = (name, enabled) => {
+        const clean = groupName(name);
+        if (!clean || seen.has(clean.toLowerCase()) || out.length >= MAX_GROUPS) return;
+        seen.add(clean.toLowerCase());
+        out.push({name: clean, enabled: enabled !== false});
+    };
+    for (const group of Array.isArray(source.ruleGroups) ? source.ruleGroups : []) {
+        add(typeof group === 'string' ? group : group?.name, group?.enabled);
+    }
+    for (const rule of Array.isArray(source.rules) ? source.rules : []) add(rule?.group, true);
+    return out;
+}
+
+/**
+ * The rules that actually run: switched on, and not in a group that is
+ * switched off. Order is kept - it is the order they run in.
+ *
+ * @param   {object[]} rules
+ * @param   {{name: string, enabled: boolean}[]} [groups]
+ * @returns {object[]}
+ */
+export function rulesInEffect(rules, groups = []) {
+    const off = new Set((groups ?? []).filter(g => g.enabled === false).map(g => g.name.toLowerCase()));
+    return (rules ?? []).filter(rule => rule?.enabled !== false
+        && !(rule.group && off.has(String(rule.group).toLowerCase())));
+}
+
+/**
+ * A new rule started from a message - "Create a rule from this message".
+ *
+ * Mail from a mailing list is caught by its list; anything else by its
+ * sender's address, the narrowest thing that still catches the next one.
+ * The action is a move with the folder left to choose: the rule is not saved
+ * until someone has picked where the mail goes and pressed Save.
+ *
+ * @param   {object} message - a list row or opened message
+ * @returns {object}
+ */
+export function ruleFromMessage(message) {
+    const sender = (message?.from ?? [])[0] ?? {};
+    const address = String(sender.address ?? '').trim();
+    const list = String(message?.listId ?? '').trim();
+    const condition = list
+        ? {field: 'list', op: 'contains', value: list.replace(/^.*<|>.*$/g, '')}
+        : {field: 'from', op: 'contains', value: address};
+    const who = list ? `the ${list.replace(/^.*<|>.*$/g, '')} list` : (sender.name || address || 'this sender');
+    return {
+        id: '',
+        name: `Mail from ${who}`.slice(0, 120),
+        enabled: true,
+        match: 'all',
+        group: '',
+        conditions: condition.value ? [condition] : [{field: 'from', op: 'contains', value: ''}],
+        actions: [{type: 'move', folder: ''}]
+    };
+}
+
 /**
  * Does this rule apply to this message?
  *

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()
         };

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