@bobfrankston/rmfmail 1.2.324 → 1.2.326

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/app.bundle.js

@@ -12119,7 +12119,14 @@ onWsEvent((event) => {
         }, 8e3);
       }
       if (event.filename && /accounts\.jsonc/i.test(String(event.filename))) {
-        showRestartForConfigBanner();
+        if (event.restartNeeded) {
+          showRestartForConfigBanner();
+        } else if (event.detail && statusSync) {
+          statusSync.textContent = String(event.detail);
+          setTimeout(() => {
+            if (statusSync.textContent === String(event.detail)) statusSync.textContent = "";
+          }, 8e3);
+        }
       }
       break;
     case "cloudError":