@bobfrankston/rmfmail 1.2.309 → 1.2.312

package/client/components/message-viewer.ts

@@ -1371,6 +1371,44 @@ export async function showMessage(accountId: string, uid: number, folderId?: num
                         if (dom) items.push({ label: `✓ Trust all senders at ${dom}`, action: () => void approve("domain", dom) });
                         items.push({ label: "", action: () => {}, separator: true });
                     }
+                    // "Trust the ‹list› mailing list" (Bob 2026-09-09: "how do I
+                    // say that this is a valid mailing list message"). A list
+                    // that keeps the poster's From — MIT's Mailman, for a Gmail
+                    // author — leaves nothing per-sender to trust: the author
+                    // is unproved on every post, by the list's own doing. The
+                    // LIST is proved (its host passed SPF for the bounce
+                    // address), so the list is what the reader vouches for.
+                    // Offered from the chip's own advice, which is the only
+                    // thing an unflagged list post shows; the banner has its
+                    // own button.
+                    const listSpam = (msg as any).spamScore as { listId?: string; listProved?: boolean; listTrusted?: boolean };
+                    if (listSpam?.listProved && listSpam.listId && !listSpam.listTrusted) {
+                        const listId = listSpam.listId;
+                        items.push({
+                            label: `✓ Trust the ${listId} mailing list`,
+                            action: async () => {
+                                const st = document.getElementById("status-sync");
+                                try {
+                                    // The action only ever ADDS, so anything but
+                                    // `trusted: true` means the write did not land.
+                                    const res = await trustSenderOrDomain("list", listId);
+                                    if (!res?.trusted) throw new Error("the list did not save");
+                                    listSpam.listTrusted = true;
+                                    document.querySelector(".mv-spamscore")?.remove();
+                                    document.querySelector(".mv-trust")?.remove();
+                                    if (st) st.textContent = `Trusting the ${listId} mailing list`;
+                                } catch (e: any) {
+                                    // The reader chose an action and must know whether it took.
+                                    if (st) {
+                                        st.textContent = `Couldn't trust the ${listId} list — ${e?.message || e}`;
+                                        st.style.color = "oklch(0.65 0.2 25)";
+                                    }
+                                    console.error("[allowlist] trust list failed:", e);
+                                }
+                            },
+                        });
+                        items.push({ label: "", action: () => {}, separator: true });
+                    }
                 }
                 if (omitted > 0) {
                     items.push({
@@ -1678,6 +1716,7 @@ export async function showMessage(accountId: string, uid: number, folderId?: num
             score: number; threshold: number; flagged: boolean;
             kind?: string; proved?: boolean; provedBy?: string; bulkOnly?: boolean;
             reasons?: string[]; trusted?: boolean;
+            listId?: string; listProved?: boolean; listTrusted?: boolean;
         };
         // A sender the reader has approved, whose identity is proved: the chip
         // goes with the banner. Repeating the score after the reader has said
@@ -1715,12 +1754,18 @@ export async function showMessage(accountId: string, uid: number, folderId?: num
                         : "No forgery rule scored. The rules that did are listed below.")
                 : level === "high"
                     ? "Your mail server scored this at or above its spam threshold and flagged it."
-                    : "Below your server's spam threshold, but more than halfway to it.") + why;
+                    : "Below your server's spam threshold, but more than halfway to it.") + why
+                // The list that provably delivered this, and where the action
+                // lives — the chip is the only thing an unflagged list post
+                // shows, so it has to say how to make it stop (2026-09-09).
+                + (spam.listProved && spam.listId && !spam.listTrusted
+                    ? `\n\nDelivered by the ${spam.listId} mailing list, which your server proved sent it. Right-click the From address to trust the list.`
+                    : "");
             chip.textContent = `spam score ${spam.score} of ${spam.threshold}`;
             bodyEl.appendChild(chip);
         }
 
-        const trust = ((msg as any).trust || []) as { id: string; severity: string; text: string; detail: string; via?: string }[];
+        const trust = ((msg as any).trust || []) as { id: string; severity: string; text: string; detail: string; via?: string; list?: string }[];
         if (trust.length) {
             // An `info` finding is not an accusation, so it gets neither the
             // headline nor the "do not open anything" footer — it renders as a
@@ -1796,6 +1841,38 @@ export async function showMessage(accountId: string, uid: number, folderId?: num
                 }
                 warn.appendChild(actions);
             }
+            // "Trust the ‹list› list" (Bob 2026-09-09: "how do I say that this
+            // is a valid mailing list message"). A finding carries `list` only
+            // when the receiving server proved the list's host sent the
+            // message and the list is not yet trusted; the entry it writes
+            // (`trustedLists`, keyed on List-Id) counts only on such mail.
+            // Not on a danger banner, for the same reason as every other
+            // button here.
+            const lists = worst === "danger" ? [] : Array.from(new Set(trust.map(f => f.list).filter(Boolean)));
+            if (lists.length) {
+                const actions = document.createElement("div");
+                actions.className = "mv-trust-actions";
+                for (const listId of lists) {
+                    const b = document.createElement("button");
+                    b.className = "mv-trust-action";
+                    b.textContent = `Trust the ${listId} list`;
+                    b.addEventListener("click", async () => {
+                        b.disabled = true;
+                        try {
+                            const res = await trustSenderOrDomain("list", listId);
+                            if (!res?.trusted) throw new Error("the list did not save");
+                            warn.remove();
+                            document.querySelector(".mv-spamscore")?.remove();
+                        } catch (e: any) {
+                            // The reader pressed a button and must know whether it took.
+                            b.disabled = false;
+                            b.textContent = `Could not save: ${e?.message || e}`;
+                        }
+                    });
+                    actions.appendChild(b);
+                }
+                warn.appendChild(actions);
+            }
             // "Trust ‹service› as an intermediary" (Bob 2026-09-08: "how do I
             // mark zoom and sites like that as trusted intermediaries?"). A
             // finding carries `via` only when a party PROVABLY handled the

package/client/compose/compose.bundle.js

@@ -1353,7 +1353,7 @@ function trustSenderOrDomain(type, value) {
   return ipc().trustSenderOrDomain?.(type, value) ?? Promise.resolve({ trusted: false });
 }
 function getAllowlist() {
-  return ipc().getAllowlist?.() ?? Promise.resolve({ senders: [], domains: [], recipients: [], flaggedSenders: [], flaggedDomains: [], trustedSenders: [], trustedDomains: [], trustedIntermediaries: [] });
+  return ipc().getAllowlist?.() ?? Promise.resolve({ senders: [], domains: [], recipients: [], flaggedSenders: [], flaggedDomains: [], trustedSenders: [], trustedDomains: [], trustedIntermediaries: [], trustedLists: [] });
 }
 function flagSenderOrDomain(type, value) {
   return ipc().flagSenderOrDomain?.(type, value) ?? Promise.resolve({ flagged: false });