@bobfrankston/rmfmail 1.2.298 → 1.2.300

package/.commitmsg

@@ -1,33 +1,41 @@
-The signature in accounts.jsonc never reached compose
+The chip claimed every rule was a bulk-mail test without looking at them
 
-`sig` has been a documented field on AccountConfig for months and three of the
-four accounts carried one, yet no signature has ever appeared in a compose
-window. The reason is a projection: `MailxService.getAccounts()` builds the
-client's account list field by field — id/name/email from the DB row, then
-label, defaultSend, primary*, identityDomains from the config — and `sig` and
-`signature` were simply not on the list. `normalizeAccount()` resolved them
-correctly, `openCompose` forwarded `a.sig` faithfully, and compose.ts appended
-`acct.sig` exactly as designed; the value was undefined by the time any of that
-ran.
+Altis Hotels' welcome mail (Bob 2026-09-03: "marked as spam but is valid",
+`mailxstore/bobma/90/90fd2404….eml`). The banner on it is already right —
+`info`, no headline, "Your mail server scored this as spam, but altishotels.com
+proved it sent this", and the "Stop warning about marketing@altishotels.com"
+button underneath. What was wrong sat one element above: the score chip's
+tooltip read "Scored by bulk-mail or blocklist rules; the sending domain passed
+DMARC, so the sender is proved" — and then listed, on the next line of the same
+tooltip, `3.2 KAM_ACCOUNTPHISH (Spam that tries to get account information)`,
+which is 3.2 of the message's 8.3 and is neither a bulk-mail nor a blocklist
+rule. A reader who reads both lines has been told two different things about
+the same message by the same tooltip, and the app is the one that is wrong.
 
-Both fields are now carried, with a comment saying why the enumeration stays an
-enumeration rather than becoming `...cfg`: cfg holds the IMAP and SMTP
-passwords, which have no business crossing into the WebView. Anything new that
-the client needs has to be added in that spot deliberately.
+The claim was never checked. `benign = proved || kind === "bulk"` picked the
+neutral chip — correctly, that part is about the sender — and the tooltip then
+described the RULES from that same flag. `proved` is a fact about the headers
+and says nothing about any rule; `kind` is the WORST class present and says
+nothing about the rest. Neither one can support a sentence beginning "every
+rule that scored".
 
-The signature itself moved to the top level of accounts.jsonc — three
-byte-identical per-account copies replaced by the one the file format already
-supports, which every account without its own `sig` inherits. It is now
-`Bob Frankston<br>https://Frankston.com` with `html: true`; the previous text
-relied on bare newlines for its line break (HTML collapses those to a space)
-and pointed at a relative `href='Frankston.com'`, which resolves against
-whatever page the mail client happens to be rendering.
+`analyzeServerSpam` now computes `bulkOnly` — every rule that scored is `bulk`
+or `neutral` — and `spamScoreOf` carries it to the chip. The bulk-only sentence
+is said only when it is true. Otherwise the tooltip says what IS established
+and nothing more: the proof, by name, plus "not every rule that scored is a
+bulk-mail test — they are listed below", or for an unproved sender "no forgery
+rule scored", which `kind === "bulk"` does establish. The `info` banner for a
+bulk verdict loses its "— nothing that scored tests who sent it" clause on the
+same condition, since it was making the same unchecked claim.
 
-Two stale comments corrected while here. `AccountSignature.html` was documented
-in both mailx-types and compose.ts as "reserved for future use / currently
-ignored". It has never been ignored — compose has always branched on it — and
-now that a signature actually renders, the difference between escaped text and
-raw HTML is the thing an author needs to know.
+Measured over the 800 newest messages in the store: 138 raise the neutral chip,
+and 132 of those were being told the score was bulk-mail rules only. Most are
+unflagged mail scoring above half the threshold, which carries no
+X-Spam-Report at all — there the individual scores are unknown, which is
+precisely when a claim about all of them cannot be made.
 
-Compose only. Nothing in the send path or the daemon appends a signature; the
-body that leaves the editor is the body that goes out.
+Not changed, on purpose: KAM_ACCOUNTPHISH stays unclassified. Its description
+says it tests what the message asks for, not who sent it, but "other" is the
+honest answer for a rule this file has no basis to classify, and the cautious
+default is what "other" is for. The fix is to stop asserting past it, not to
+guess at it.

package/client/android-bootstrap.bundle.js

@@ -2226,6 +2226,13 @@ function bare(addr) {
   const m = (addr || "").match(/[^\s<>,;]+@[^\s<>,;]+/);
   return (m ? m[0] : addr || "").toLowerCase().replace(/[.,;]+$/, "");
 }
+function sameOrg(a, b) {
+  const x = (a || "").toLowerCase();
+  const y = (b || "").toLowerCase();
+  if (!x || !y)
+    return false;
+  return x === y || x.endsWith("." + y) || y.endsWith("." + x);
+}
 function classifyRule(name, dmarcFailed) {
   if (dmarcFailed && name === "DKIM_INVALID")
     return "forgery";
@@ -2311,6 +2318,7 @@ function analyzeServerSpam(input) {
   const unknown = rules.filter((r) => r.cls === "other" && scored(r));
   const unknownWeight = unknown.reduce((sum, r) => sum + r.score, 0);
   const unknownCouldFlagAlone = !unknown.length ? false : !Number.isFinite(unknownWeight) || !Number.isFinite(threshold) ? true : unknownWeight >= threshold;
+  const bulkOnly = rules.every((r) => !scored(r) || r.cls === "bulk" || r.cls === "neutral");
   const kind = dmarc.authFailures.length || present("forgery") ? "forgery" : present("association") ? "association" : unknownCouldFlagAlone ? "unclassified" : rules.length ? "bulk" : "unclassified";
   const has = (name) => rules.some((r) => r.name === name);
   const provedBy = dmarc.pass ? "dmarc" : has("DKIM_VALID_AU") ? "dkim" : has("ALL_TRUSTED") ? "trusted" : "";
@@ -2327,6 +2335,7 @@ function analyzeServerSpam(input) {
     kind,
     proved: !!provedBy,
     provedBy,
+    bulkOnly,
     provedDomain: dmarc.domain || fromDomain,
     provedPolicy: dmarc.policy,
     bayesHam: rules.some((r) => r.name === "BAYES_00" || r.name === "BAYES_01"),
@@ -2374,7 +2383,7 @@ function serverSpamVerdict(input) {
     return {
       id: "server-spam-verdict",
       severity: "info",
-      text: "Your mail server rates this bulk mail \u2014 nothing that scored tests who sent it.",
+      text: a.bulkOnly ? "Your mail server rates this bulk mail \u2014 nothing that scored tests who sent it." : "Your mail server rates this bulk mail.",
       detail: `${numbers}${why}${bayes}`
     };
   const proof = a.proved ? `${provedNote(a)} ` : "";
@@ -2455,7 +2464,17 @@ function hiddenLinkOverlay(bodyHtml) {
   }
   return null;
 }
-function redirectorLink(bodyHtml) {
+function provedSenderDomain(input) {
+  const fromDomain = (bare(input.fromAddress).split("@")[1] || "").toLowerCase();
+  if (!fromDomain)
+    return "";
+  if (dmarcProof(input).pass)
+    return fromDomain;
+  return analyzeServerSpam(input)?.proved ? fromDomain : "";
+}
+function redirectorLink(input) {
+  const bodyHtml = input.bodyHtml || "";
+  const senderDomain = provedSenderDomain(input);
   for (const m of bodyHtml.matchAll(/href\s*=\s*["']([^"']+)["']/gi)) {
     let url;
     try {
@@ -2465,6 +2484,8 @@ function redirectorLink(bodyHtml) {
     }
     if (!/^https?:$/.test(url.protocol))
       continue;
+    if (senderDomain && sameOrg(url.hostname, senderDomain))
+      continue;
     for (const [, value] of url.searchParams) {
       let target;
       try {
@@ -2474,7 +2495,7 @@ function redirectorLink(bodyHtml) {
       }
       if (!/^https?:$/.test(target.protocol))
         continue;
-      if (target.hostname === url.hostname)
+      if (sameOrg(target.hostname, url.hostname))
         continue;
       return {
         id: "redirector-link",
@@ -2493,7 +2514,7 @@ function assessMessageTrust(input) {
     relayAuthMismatch(input),
     zeroWidthObfuscation(input.bodyText || ""),
     hiddenLinkOverlay(input.bodyHtml || ""),
-    redirectorLink(input.bodyHtml || "")
+    redirectorLink(input)
   ].filter(Boolean);
   const rank = { danger: 0, caution: 1, info: 2 };
   return findings.sort((a, b) => rank[a.severity] - rank[b.severity]);
@@ -2506,9 +2527,7 @@ function relayAuthMismatch(input) {
   for (const name of RELAY_IDENTITY_HEADERS) {
     const stamped = bare(header(input.headerLines, name));
     const stampedDomain = stamped.split("@")[1] || "";
-    if (!stampedDomain || stampedDomain === fromDomain)
-      continue;
-    if (stampedDomain.endsWith("." + fromDomain) || fromDomain.endsWith("." + stampedDomain))
+    if (!stampedDomain || sameOrg(stampedDomain, fromDomain))
       continue;
     return {
       id: "relay-auth-mismatch",
@@ -2544,6 +2563,7 @@ function spamScoreOf(input) {
     kind: a.kind,
     proved: a.proved,
     provedBy: a.provedBy,
+    bulkOnly: a.bulkOnly,
     trusted: !!input.senderTrusted && a.proved && a.kind !== "forgery" && !a.authFailures.length,
     reasons: a.reasons
   };