@bobfrankston/rmfmail 1.2.323 → 1.2.325

package/bin/mailx.ts

@@ -2025,7 +2025,7 @@ async function main(): Promise<void> {
         { ImapManager },
         { MailxService, spawnSyncWorker },
         { dispatch, setDebugEvalSink },
-        { loadSettings, loadAccountsAsync, loadAllowlistAsync, getConfigDir, getStorageInfo, getStorePath },
+        { loadSettings, loadAccounts, loadAccountsAsync, loadAllowlistAsync, getConfigDir, getStorageInfo, getStorePath },
         { NodeTcpTransport },
         { FileMessageStore },
     ] = await Promise.all([
@@ -2064,20 +2064,24 @@ async function main(): Promise<void> {
     //
     // The local accounts.jsonc cache (loaded synchronously above) has the
     // last-known state; that's what every account+folder+message UI read
-    // depends on. Cloud refresh's only job is "another device added an
-    // account" — fire-and-forget, log + warn if it diverges, the user can
-    // restart for it to take effect. Was a band-aid hidden in a sync
-    // path; per feedback_no_bandaids, fix the real cause.
-    void (async () => {
-        try {
-            const cloudAccounts = await loadAccountsAsync();
-            if (cloudAccounts.length > 0 && cloudAccounts.length !== settings.accounts.length) {
-                console.log(`  [cloud] accounts diverged: cache=${settings.accounts.length} cloud=${cloudAccounts.length} — restart to apply`);
-            }
-        } catch (e: any) {
-            console.error(`  [cloud] background account refresh failed: ${e?.message || e}`);
-        }
-    })();
+    // depends on. The cloud refresh runs in the background; its result is
+    // applied once the account machinery exists (see the continuation after
+    // watchConfigFiles() below).
+    //
+    // 2026-09-13 17:20 EDT — Claude Code (Fable 5.1), at Bob's direction.
+    // This used to log "accounts diverged — restart to apply" and stop. A
+    // kernel crash at 16:36 today zero-filled the local accounts.jsonc, the
+    // daemon booted with 0 accounts, and the cloud copy (4 accounts) sat
+    // unused behind a banner. Now the promise is kept and the divergence is
+    // reconciled in-process through the same configChanged path an on-disk
+    // edit takes (reconcileAccountsFromDisk) — one mechanism, two triggers.
+    // Typed off the loader: mailx-types is not a dependency of this package.
+    type AccountList = Awaited<ReturnType<typeof loadAccountsAsync>>;
+    const cloudAccountsRefresh = loadAccountsAsync().catch((e: any): AccountList => {
+        // The boot snapshot stays in force; the 3-minute cloud poll retries.
+        console.error(`  [cloud] background account refresh failed: ${e?.message || e}`);
+        return [];
+    });
 
     const db = new MailxDB(getConfigDir());
     _tick("DB opened");
@@ -2870,8 +2874,78 @@ RFC 5322 with CRLF line endings. Bodies are quoted-printable encoded (readable i
     imapManager.on("accountError", (accountId: string, error: string, hint: string, isOAuth: boolean) => {
         handle.send({ _event: "accountError", type: "accountError", accountId, error, hint, isOAuth });
     });
+    /** Bring the running daemon in line with accounts.jsonc as it is on disk.
+     *  New enabled accounts are added live (addAccount + inbox check + sync +
+     *  IDLE). Anything that can't be applied to a live account — one removed,
+     *  disabled, or with changed settings — is reported with restartNeeded so
+     *  the client shows the Restart banner only when a restart really is the
+     *  fix. Idempotent: addAccount ignores ids it already has, and the boot
+     *  snapshot (settings.accounts) is updated in place.
+     *
+     *  2026-09-13 17:20 EDT — Claude Code (Fable 5.1), at Bob's direction.
+     *  Before this every accounts.jsonc change, including the daemon's own
+     *  repair of a crash-zeroed cache from the cloud copy, produced only
+     *  "restart to apply". */
+    async function reconcileAccountsFromDisk(): Promise<{ restartNeeded: boolean; detail: string }> {
+        const onDisk = loadAccounts();
+        if (onDisk.length === 0) {
+            // A file that reads as empty is a broken file, not a request to
+            // drop every account (readJsonc has already logged the parse error).
+            return { restartNeeded: false, detail: "accounts.jsonc has no accounts — keeping the running set" };
+        }
+        const snapshot = new Map(settings.accounts.map(a => [a.id, a]));
+        const diskIds = new Set(onDisk.map(a => a.id));
+        const added = onDisk.filter(a => a.enabled && !snapshot.has(a.id));
+        const removed = settings.accounts.filter(a => !diskIds.has(a.id)).map(a => a.id);
+        const changed = onDisk
+            .filter(a => snapshot.has(a.id) && JSON.stringify(snapshot.get(a.id)) !== JSON.stringify(a))
+            .map(a => a.id);
+        if (added.length === 0 && removed.length === 0 && changed.length === 0) {
+            return { restartNeeded: false, detail: "accounts.jsonc updated — no account changes" };
+        }
+        const applied: string[] = [];
+        for (const account of added) {
+            try {
+                await imapManager.addAccount(account);
+                settings.accounts.push(account);
+                applied.push(account.label || account.name || account.id);
+                console.log(`  Account: ${account.label || account.name} (${account.id}) — added from accounts.jsonc`);
+                imapManager.quickInboxCheckAccount(account.id).catch(e =>
+                    console.error(`  [startup-check] ${account.id}: ${e?.message || e}`));
+            } catch (e: any) {
+                console.error(`  Failed: ${account.id}: ${e.message}`);
+            }
+        }
+        if (applied.length > 0) {
+            // syncAll is a no-op while a sync is already running; the periodic
+            // sweep picks the new account up then. startWatching is per-config
+            // and idempotent, so IDLE starts for the new account either way.
+            imapManager.syncAll()
+                .then(() => imapManager.startWatching())
+                .catch(e => console.error(`  Sync error: ${e.message}`));
+        }
+        const parts: string[] = [];
+        if (applied.length) parts.push(`added ${applied.join(", ")}`);
+        if (removed.length) parts.push(`removed ${removed.join(", ")}`);
+        if (changed.length) parts.push(`changed ${changed.join(", ")}`);
+        const restartNeeded = removed.length > 0 || changed.length > 0;
+        const detail = `accounts.jsonc: ${parts.join("; ")}${restartNeeded ? " — restart to apply" : ""}`;
+        console.log(`  [accounts] ${detail}`);
+        return { restartNeeded, detail };
+    }
     imapManager.on("configChanged", (filename: string) => {
-        handle.send({ _event: "configChanged", type: "configChanged", filename });
+        if (filename !== "accounts.jsonc") {
+            handle.send({ _event: "configChanged", type: "configChanged", filename });
+            return;
+        }
+        reconcileAccountsFromDisk()
+            .then(r => handle.send({ _event: "configChanged", type: "configChanged", filename, restartNeeded: r.restartNeeded, detail: r.detail }))
+            .catch((e: any) => {
+                // Reconcile failed: fall back to the old behaviour — the user can
+                // always restart — and say why in the log.
+                console.error(`  [accounts] reconcile failed: ${e?.message || e}`);
+                handle.send({ _event: "configChanged", type: "configChanged", filename, restartNeeded: true, detail: `accounts.jsonc changed — restart to apply (${e?.message || e})` });
+            });
     });
     imapManager.on("outboxStatus", (status: any) => {
         handle.send({ _event: "outboxStatus", type: "outboxStatus", ...status });
@@ -3231,6 +3305,21 @@ RFC 5322 with CRLF line endings. Bodies are quoted-printable encoded (readable i
     imapManager.startSentSweep();
     imapManager.watchConfigFiles();
 
+    // 2026-09-13 17:20 EDT — Claude Code (Fable 5.1), at Bob's direction.
+    // Apply the background cloud refresh started before the DB was even open.
+    // cloudRead has already written the cloud copy into the local cache; if
+    // it differs from the boot snapshot, run it through the same configChanged
+    // path an on-disk edit takes (MailxService drops its accounts cache, then
+    // reconcileAccountsFromDisk adds new accounts live and tells the client).
+    // Emitting here rather than relying on fs.watch closes the race where the
+    // cloud read lands before watchConfigFiles() registered the watcher.
+    void cloudAccountsRefresh.then((cloudAccounts) => {
+        if (cloudAccounts.length === 0) return;
+        if (JSON.stringify(cloudAccounts) === JSON.stringify(settings.accounts)) return;
+        console.log(`  [cloud] accounts.jsonc differs from the boot snapshot (cache=${settings.accounts.length} cloud=${cloudAccounts.length}) — reconciling`);
+        imapManager.emit("configChanged", "accounts.jsonc");
+    });
+
     // Deploy app-owned reference docs (.md per JSONC schema) to the cloud
     // folder so users see them next to the .jsonc they document. Versioned
     // by app version — only redeploys when the app updates. Fire-and-forget;

package/client/android-bootstrap.bundle.js

@@ -2589,6 +2589,8 @@ function provedSenderDomain(input) {
 function redirectorLink(input) {
   const bodyHtml = input.bodyHtml || "";
   const senderDomain = provedSenderDomain(input);
+  if (senderDomain && input.senderTrusted)
+    return null;
   const intermediary = provedIntermediary(input);
   const signers = dkimSigners(input);
   for (const m of bodyHtml.matchAll(/href\s*=\s*["']([^"']+)["']/gi)) {
@@ -2618,13 +2620,14 @@ function redirectorLink(input) {
       if (senderDomain && sameOrg(target.hostname, senderDomain))
         continue;
       const signer = signers.find((s) => sameOrg(s, url.hostname));
-      const how = signer ? ` ${signer} signed this message; "Trust ${signer} as an intermediary" stops this warning for links through ${signer} in mail it signs.` : ` Nobody signed this message for ${url.hostname}, so there is no intermediary to trust; only the sender could vouch for the link.`;
+      const how = signer ? ` ${signer} signed this message; "Trust ${signer} as an intermediary" stops this warning for links through ${signer} in mail it signs.` : senderDomain ? ` Nobody signed this message for ${url.hostname}, so there is no intermediary to trust; ${senderDomain} proved it sent this, and "Stop warning about *@${senderDomain}" lets it vouch for its own links.` : ` Nobody signed this message for ${url.hostname}, so there is no intermediary to trust; only the sender could vouch for the link, and nothing proves who the sender is.`;
       return {
         id: "redirector-link",
         severity: "caution",
         text: `A link hides where it goes: it passes through ${url.hostname} and ends at ${target.hostname}.`,
         detail: `${url.hostname} -> ${target.hostname}.${how}`,
-        ...signer ? { via: signer } : {}
+        ...signer ? { via: signer } : {},
+        ...senderDomain && !signer ? { sender: senderDomain } : {}
       };
     }
   }