@bobfrankston/mailx 1.0.444 → 1.0.446

package/README.md

@@ -259,9 +259,6 @@ mailx -rebuild                Wipe local cache and re-download everything from I
 mailx -setup                  Interactive first-time setup (CLI)
 mailx -test                   Test IMAP/SMTP connectivity for all accounts
 mailx -reauth                 Clear cached OAuth tokens; next start re-consents
-mailx -lean-accounts          Strip defaulted fields from accounts.jsonc on
-                                Google Drive (port, tls, auth, enabled, ...).
-                                Add --dry-run to preview without writing.
 mailx -v                      Show version
 ```
 

package/bin/mailx.js

@@ -17,9 +17,6 @@
  *   mailx -repair            Re-sync metadata (fix corrupt subjects) keeping .eml files
  *   mailx -reauth            Clear cached OAuth tokens; next start re-consents
  *                             (use when new Google scopes have been added)
- *   mailx -lean-accounts     Strip defaulted fields from the GDrive copy of
- *                             accounts.jsonc (port, tls, auth, enabled, ...).
- *                             Add --dry-run to preview without writing.
  */
 import fs from "node:fs";
 import path from "node:path";
@@ -92,7 +89,7 @@ function pidAlive(pid) {
 // on an old UI with no indication that the install has been upgraded.
 // Skip this logic for command-only flags (kill, rebuild, setup, ...) and for
 // the internal --daemon respawn.
-const __commandFlags = ["kill", "v", "version", "setup", "add", "test", "rebuild", "repair", "import", "log", "reauth", "lean-accounts"];
+const __commandFlags = ["kill", "v", "version", "setup", "add", "test", "rebuild", "repair", "import", "log", "reauth"];
 const __isCommandInvocation = process.argv.slice(2).some(a => __commandFlags.includes(a.replace(/^--?/, "")));
 if (!isDaemon && !__isCommandInvocation) {
     const inst = readInstanceFile();
@@ -150,9 +147,8 @@ const testMode = hasFlag("test");
 const rebuildMode = hasFlag("rebuild");
 const repairMode = hasFlag("repair");
 const importMode = hasFlag("import");
-const leanAccountsMode = hasFlag("lean-accounts");
 // Validate arguments
-const knownFlags = ["verbose", "kill", "v", "version", "setup", "add", "test", "rebuild", "repair", "log", "import", "lean-accounts", "email", "mail", "daemon"];
+const knownFlags = ["verbose", "kill", "v", "version", "setup", "add", "test", "rebuild", "repair", "log", "import", "email", "mail", "daemon"];
 for (const arg of args) {
     const flag = arg.replace(/^--?/, "");
     if (arg.startsWith("-") && !knownFlags.includes(flag)) {
@@ -367,52 +363,6 @@ if (repairMode) {
     console.log("  Run 'mailx' to re-sync from IMAP with correct encoding.");
     process.exit(0);
 }
-// Strip default-valued fields from the GDrive copy of accounts.jsonc.
-// Operates on the cloud version directly — the local ~/.mailx/accounts.jsonc
-// is just a cache and gets updated on the next mailx run anyway.
-if (leanAccountsMode) {
-    const { parse: parseJsonc } = await import("jsonc-parser");
-    const { initCloudConfig, normalizeAccount, denormalizeAccount } = await import("@bobfrankston/mailx-settings");
-    const { cloudRead, cloudWrite } = await import("@bobfrankston/mailx-settings");
-    await initCloudConfig("gdrive");
-    const raw = await cloudRead("accounts.jsonc");
-    if (!raw) {
-        console.error("No accounts.jsonc found in GDrive.");
-        process.exit(1);
-    }
-    const errors = [];
-    const cfg = parseJsonc(raw, errors, { allowTrailingComma: true });
-    if (errors.length) {
-        console.error(`JSONC parse error: ${errors.map((e) => JSON.stringify(e)).join(", ")}`);
-        process.exit(1);
-    }
-    const accountsRaw = cfg?.accounts || (Array.isArray(cfg) ? cfg : []);
-    if (accountsRaw.length === 0) {
-        console.error("No accounts found in GDrive accounts.jsonc.");
-        process.exit(1);
-    }
-    const globalName = cfg?.name;
-    const normalized = accountsRaw.map(a => normalizeAccount(a, globalName));
-    const names = new Set(normalized.map((a) => a.name).filter(Boolean));
-    const sharedName = names.size === 1 ? [...names][0] : globalName;
-    const lean = normalized.map((a) => denormalizeAccount(a, sharedName));
-    const payload = sharedName ? { name: sharedName, accounts: lean } : { accounts: lean };
-    const output = JSON.stringify(payload, null, 2);
-    const before = raw.length;
-    const after = output.length;
-    console.log(`Read ${accountsRaw.length} account(s) from GDrive.`);
-    console.log(`Before: ${before} bytes`);
-    console.log(`After:  ${after} bytes (${Math.round(100 * (1 - after / before))}% smaller)`);
-    if (process.argv.includes("--dry-run") || process.argv.includes("-n")) {
-        console.log("--- Lean output (dry run, not written) ---");
-        console.log(output);
-    }
-    else {
-        await cloudWrite("accounts.jsonc", output);
-        console.log("Wrote lean accounts.jsonc back to GDrive.");
-    }
-    process.exit(0);
-}
 // Import accounts from a local file into GDrive
 if (importMode) {
     const importPath = args.find(a => !a.startsWith("-"));

package/client/app.js

@@ -2242,7 +2242,7 @@ document.getElementById("btn-open-log")?.addEventListener("click", async () => {
     }
 });
 async function openJsoncEditor(initialFile) {
-    const { readJsoncFile, writeJsoncFile, readConfigHelp, formatJsonc, leanAccountsJsonc } = await import("./lib/api-client.js");
+    const { readJsoncFile, writeJsoncFile, readConfigHelp, formatJsonc } = await import("./lib/api-client.js");
     const backdrop = document.createElement("div");
     backdrop.className = "mailx-modal-backdrop";
     const panel = document.createElement("div");
@@ -2278,7 +2278,6 @@ async function openJsoncEditor(initialFile) {
         <div class="mailx-modal-error" id="jsonc-error" hidden></div>
         <div class="mailx-modal-buttons">
             <button type="button" class="mailx-modal-btn" data-action="format" title="Reformat indentation while preserving comments and trailing commas">Format</button>
-            <button type="button" class="mailx-modal-btn" data-action="lean" title="accounts.jsonc only — strip default-valued fields (port, tls, auth, etc.) so the file stays compact. Comments are dropped (the lean output is regenerated from values, not the original text)">Lean</button>
             <span class="mailx-modal-spacer"></span>
             <button type="button" class="mailx-modal-btn" data-action="cancel">Cancel</button>
             <button type="button" class="mailx-modal-btn mailx-modal-btn-primary" data-action="save">Save</button>
@@ -2445,38 +2444,6 @@ async function openJsoncEditor(initialFile) {
                 }
                 return;
             }
-            if (action === "lean") {
-                // accounts.jsonc-only: strip defaulted fields and re-emit
-                // a compact form. User reviews it in the editor, then Save
-                // commits. Lean drops comments because the output is
-                // regenerated from canonical values, not the original text.
-                if (fileSelect.value !== "accounts.jsonc") {
-                    errorEl.textContent = "Lean is only available for accounts.jsonc.";
-                    errorEl.hidden = false;
-                    return;
-                }
-                btn.disabled = true;
-                const orig = btn.textContent;
-                btn.textContent = "Leaning…";
-                try {
-                    const r = await leanAccountsJsonc(textarea.value);
-                    if (r?.content !== undefined) {
-                        textarea.value = r.content;
-                        renderGutter();
-                        scheduleValidate();
-                        errorEl.hidden = true;
-                    }
-                }
-                catch (e) {
-                    errorEl.textContent = `Lean failed: ${e.message}`;
-                    errorEl.hidden = false;
-                }
-                finally {
-                    btn.disabled = false;
-                    btn.textContent = orig || "Lean";
-                }
-                return;
-            }
             if (action === "save") {
                 // Final sync-check; refuse to save if it doesn't parse
                 const err = validateJsonc(textarea.value);

package/client/components/message-list.js

@@ -140,10 +140,25 @@ if (!window.__mailxMultiSelectWired) {
         if (!body?.classList.contains("multi-select-on"))
             return;
         const target = e.target;
-        // A tap on a row is handled by the row's own click listener; only
-        // exit when the tap is on neutral ground (outside the list entirely).
-        if (!target.closest(".ml-row"))
-            exitMultiSelect();
+        // A tap on a row is handled by the row's own click listener.
+        // The toolbar must also be exempt: its trash / spam / etc.
+        // buttons operate ON the current multi-selection, so a tap on
+        // them should NOT clear selection before the button's click
+        // handler runs (otherwise getSelectedMessages returns empty
+        // and the action no-ops — Android-reported 2026-04-30: "press
+        // multiple circles, press trashcan, checks vanish, nothing
+        // deleted"). Same logic for the folder-tree (drop targets,
+        // future: bulk move). Exit only on a tap to genuine neutral
+        // ground.
+        // Exempt: rows (handled by their own listener), toolbar buttons
+        // (delete/spam/etc. operate ON the selection — clearing it here
+        // empties the selection before the click runs), folder-tree
+        // (drop targets / future bulk move), and the context menu
+        // (right-click → "mark read" / "move to" / etc. all need the
+        // selection intact when the menu item runs).
+        if (target.closest(".ml-row, .toolbar, .folder-tree, .ctx-menu, #btn-tb-delete, #btn-tb-spam"))
+            return;
+        exitMultiSelect();
     }, true);
 }
 function selectRange(from, to) {
@@ -549,6 +564,15 @@ function renderMessages(body, accountId, items) {
     body.replaceChildren(fragment);
 }
 function selectFirst(body) {
+    // Narrow viewports (Android, phone-sized): don't auto-select. The
+    // click handler in app.ts switches the layout to "narrow-active" on
+    // any list-row click, which on a phone means the message viewer takes
+    // over the screen and hides the list. Auto-selecting at startup
+    // therefore lands the user in the LAST letter they read instead of
+    // the inbox summary they wanted. Desktop unchanged — auto-select
+    // remains useful when the list and viewer are side-by-side.
+    if (window.innerWidth <= 768)
+        return;
     const firstRow = body.querySelector(".ml-row");
     if (firstRow)
         firstRow.click();

package/client/lib/api-client.js

@@ -351,9 +351,6 @@ export function readConfigHelp(name) {
 export function unsubscribeOneClick(url) {
     return ipc().unsubscribeOneClick?.(url);
 }
-export function leanAccountsJsonc(content) {
-    return ipc().leanAccountsJsonc?.(content) ?? Promise.resolve({ content });
-}
 export function openInWord(editId, html) {
     return ipc().openInWord?.(editId, html) ?? Promise.resolve({ ok: false, path: "", opener: "none" });
 }

package/client/lib/mailxapi.js

@@ -134,9 +134,6 @@
         formatJsonc: function(content) {
             return callNode("formatJsonc", { content: content });
         },
-        leanAccountsJsonc: function(content) {
-            return callNode("leanAccountsJsonc", { content: content });
-        },
         readConfigHelp: function(name) {
             return callNode("readConfigHelp", { name: name });
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.444",
+  "version": "1.0.446",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -36,7 +36,7 @@
     "@bobfrankston/iflow-node": "^0.1.8",
     "@bobfrankston/miscinfo": "^1.0.10",
     "@bobfrankston/oauthsupport": "^1.0.25",
-    "@bobfrankston/msger": "^0.1.366",
+    "@bobfrankston/msger": "^0.1.367",
     "@bobfrankston/mailx-host": "^0.1.8",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
@@ -100,7 +100,7 @@
       "@bobfrankston/iflow-node": "^0.1.8",
       "@bobfrankston/miscinfo": "^1.0.10",
       "@bobfrankston/oauthsupport": "^1.0.25",
-      "@bobfrankston/msger": "^0.1.366",
+      "@bobfrankston/msger": "^0.1.367",
       "@bobfrankston/mailx-host": "^0.1.8",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",

package/packages/mailx-service/index.d.ts

@@ -316,16 +316,6 @@ export declare class MailxService {
      *  `config.jsonc` is the local per-machine config (not cloud-synced). */
     readJsoncFile(name: string): Promise<string | null>;
     formatJsonc(content: string): Promise<string>;
-    /** Strip default-valued fields from accounts.jsonc and return the lean
-     *  form. Called from the JSONC editor's "Lean" button so the user can
-     *  see the tidy version before saving. Round-trips through normalize→
-     *  denormalize so the canonicalization rules stay in one place
-     *  (mailx-settings). Drops port: 993, tls: true, auth: "password",
-     *  enabled: true, sig.html: false, etc. when they match the defaults
-     *  for the email's provider. Promotes a shared `name` to the file
-     *  level when every account has the same name. Only handles
-     *  accounts.jsonc — other JSONC files have hand-curated shapes. */
-    leanAccountsJsonc(content: string): Promise<string>;
     /** Return the help section for a named config file, extracted from docs/config-help.md.
      *  Matches a level-2 heading whose text equals the filename. Returns markdown. */
     readConfigHelp(name: string): Promise<string>;

package/packages/mailx-service/index.js

@@ -9,7 +9,7 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 import * as gsync from "./google-sync.js";
-import { loadSettings, saveSettings, loadAccounts, loadAccountsAsync, saveAccounts, initCloudConfig, loadAllowlist, saveAllowlist, loadAutocomplete, saveAutocomplete, getStorageInfo, getConfigDir, normalizeAccount, denormalizeAccount } from "@bobfrankston/mailx-settings";
+import { loadSettings, saveSettings, loadAccounts, loadAccountsAsync, saveAccounts, initCloudConfig, loadAllowlist, saveAllowlist, loadAutocomplete, saveAutocomplete, getStorageInfo, getConfigDir } from "@bobfrankston/mailx-settings";
 import { sanitizeHtml, encodeQuotedPrintable, htmlToPlainText } from "@bobfrankston/mailx-types";
 import { simpleParser } from "mailparser";
 /** Parse `List-Unsubscribe` (RFC 2369) and `List-Unsubscribe-Post` (RFC 8058).
@@ -2053,30 +2053,6 @@ export class MailxService {
         });
         return applyEdits(content, edits);
     }
-    /** Strip default-valued fields from accounts.jsonc and return the lean
-     *  form. Called from the JSONC editor's "Lean" button so the user can
-     *  see the tidy version before saving. Round-trips through normalize→
-     *  denormalize so the canonicalization rules stay in one place
-     *  (mailx-settings). Drops port: 993, tls: true, auth: "password",
-     *  enabled: true, sig.html: false, etc. when they match the defaults
-     *  for the email's provider. Promotes a shared `name` to the file
-     *  level when every account has the same name. Only handles
-     *  accounts.jsonc — other JSONC files have hand-curated shapes. */
-    async leanAccountsJsonc(content) {
-        const { parse: parseJsonc } = await import("jsonc-parser");
-        const errors = [];
-        const cfg = parseJsonc(content, errors, { allowTrailingComma: true });
-        if (errors.length)
-            throw new Error(`JSONC parse error: ${errors.map((e) => e.error).join(", ")}`);
-        const raw = cfg?.accounts || (Array.isArray(cfg) ? cfg : []);
-        const globalName = cfg?.name;
-        const normalized = raw.map((a) => normalizeAccount(a, globalName));
-        const names = new Set(normalized.map((a) => a.name).filter(Boolean));
-        const sharedName = names.size === 1 ? [...names][0] : globalName;
-        const lean = normalized.map((a) => denormalizeAccount(a, sharedName));
-        const payload = sharedName ? { name: sharedName, accounts: lean } : { accounts: lean };
-        return JSON.stringify(payload, null, 2);
-    }
     /** Return the help section for a named config file, extracted from docs/config-help.md.
      *  Matches a level-2 heading whose text equals the filename. Returns markdown. */
     async readConfigHelp(name) {

package/packages/mailx-service/jsonrpc.js

@@ -177,8 +177,6 @@ async function dispatchAction(svc, action, p) {
             return await svc.unsubscribeOneClick(p.url);
         case "openInWord":
             return await svc.openInWord(p.editId, p.html);
-        case "leanAccountsJsonc":
-            return { content: await svc.leanAccountsJsonc(p.content) };
         case "closeWordEdit":
             return await svc.closeWordEdit(p.editId);
         // Client-side tracing — lets webview / iframe code ship events to the

package/packages/mailx-store-web/android-bootstrap.js

@@ -533,36 +533,64 @@ class AndroidSyncManager {
             }
         }
     }
-    queueOutgoingLocal(accountId, rawMessage) {
+    /** In-flight send tracker keyed by queueUid. Prevents
+     *  processSendQueue from re-firing the same row when it overlaps
+     *  with an in-progress attempt (e.g., the periodic tick fires while
+     *  the original attemptSend's promise is still pending). Without
+     *  this, a slow Gmail/SMTP send race-conditions into a double-send. */
+    sendInFlight = new Set();
+    async queueOutgoingLocal(accountId, rawMessage) {
         // Local-first: PERSIST to sync_actions before attempting the network
         // send, so a crash / offline / process kill between now and SMTP ACK
         // doesn't drop the message. Desktop parity — PC writes `.ltr` to disk
-        // before calling SMTP; Android writes a sync_actions row to sql.js +
-        // IndexedDB (which saveDbToIdb persists on scheduleSave). Unique neg
-        // uid = Date.now() to avoid colliding with real message UIDs and to
-        // give us a stable tracking key through the async send pipeline.
+        // synchronously; Android writes a sync_actions row and now FLUSHES
+        // sql.js → IndexedDB before returning. The previous version relied on
+        // the 1-second scheduleSave debounce, so a tab-close inside the debounce
+        // window erased the row before it was persisted — the "letter just
+        // disappeared" symptom user-reported 2026-04-30.
         //
-        // User-flagged 2026-04-23: "sending on android, like on the PC must
-        // be queued." Equivalent of PC's `~/.mailx/outbox/<acct>/*.ltr`.
+        // Equivalent of PC's `~/.mailx/outbox/<acct>/*.ltr` durable write.
         const queueUid = -Date.now();
         this.db.queueSyncAction(accountId, "send", queueUid, -1, { rawMessage });
+        await this.db.flush();
         this.attemptSend(accountId, queueUid, rawMessage);
     }
     /** Kick off a send for a message that's already in the queue. Called by
      *  queueOutgoingLocal on a fresh submit AND by processSendQueue on
-     *  startup / periodic tick for anything stranded from a prior run. */
+     *  startup / periodic tick for anything stranded from a prior run.
+     *  Guards against double-send via sendInFlight. */
     attemptSend(accountId, queueUid, rawMessage) {
+        if (this.sendInFlight.has(queueUid))
+            return;
+        this.sendInFlight.add(queueUid);
+        // Helper to mark complete + flush + clear in-flight — used on every
+        // success/failure exit. Flush ensures the row deletion or attempt
+        // counter actually reaches IndexedDB before the next process-kill,
+        // matching the "persist before network" rule for the post-network
+        // outcome too. Without flushing on completion, a successful send
+        // followed by a fast app-close left the row in the queue, which
+        // looked like a "stuck" message on next launch.
+        const finishSend = (success, error) => {
+            if (success) {
+                this.db.completeSyncActionByUid(accountId, "send", queueUid);
+            }
+            else {
+                this.db.failSyncActionByUid(accountId, "send", queueUid, error || "send failed");
+            }
+            this.db.flush().catch(() => { });
+            this.sendInFlight.delete(queueUid);
+        };
         const provider = this.getProvider(accountId);
         if (provider && typeof provider.sendRaw === "function") {
             provider.sendRaw(rawMessage)
                 .then((result) => {
                 console.log(`[send] ${accountId}: sent via Gmail API (id=${result.id})`);
-                this.db.completeSyncActionByUid(accountId, "send", queueUid);
+                finishSend(true);
                 emitEvent({ type: "sendComplete", accountId, messageId: result.id });
             })
                 .catch((e) => {
                 console.error(`[send] ${accountId}: Gmail send failed: ${e.message}`);
-                this.db.failSyncActionByUid(accountId, "send", queueUid, e.message || String(e));
+                finishSend(false, e.message || String(e));
                 emitEvent({ type: "sendError", accountId, error: e.message });
             });
             return;
@@ -574,7 +602,7 @@ class AndroidSyncManager {
         if (!row) {
             const e = "Unknown account";
             console.error(`[send] ${accountId}: ${e}`);
-            this.db.failSyncActionByUid(accountId, "send", queueUid, e);
+            finishSend(false, e);
             emitEvent({ type: "sendError", accountId, error: e });
             return;
         }
@@ -584,26 +612,26 @@ class AndroidSyncManager {
         }
         catch {
             const e = "Account config malformed";
-            this.db.failSyncActionByUid(accountId, "send", queueUid, e);
+            finishSend(false, e);
             emitEvent({ type: "sendError", accountId, error: e });
             return;
         }
         if (!account.smtp) {
             const e = "No SMTP config for this account";
             console.error(`[send] ${accountId}: ${e}`);
-            this.db.failSyncActionByUid(accountId, "send", queueUid, e);
+            finishSend(false, e);
             emitEvent({ type: "sendError", accountId, error: e });
             return;
         }
         this.sendViaSmtpDirect(accountId, account, rawMessage)
             .then((result) => {
             console.log(`[send] ${accountId}: sent via SMTP (${result.accepted.length} accepted, ${result.rejected.length} rejected)`);
-            this.db.completeSyncActionByUid(accountId, "send", queueUid);
+            finishSend(true);
             emitEvent({ type: "sendComplete", accountId });
         })
             .catch((e) => {
             console.error(`[send] ${accountId}: SMTP send failed: ${e.message}`);
-            this.db.failSyncActionByUid(accountId, "send", queueUid, e.message || String(e));
+            finishSend(false, e.message || String(e));
             emitEvent({ type: "sendError", accountId, error: e.message });
         });
     }
@@ -1039,11 +1067,17 @@ export async function initAndroid() {
         }
         syncManager.syncAll().catch(e => console.error(`[android] Periodic sync error: ${e.message}`));
     }, SYNC_INTERVAL_MS);
-    // Immediate sync when app comes back to foreground (e.g. user switches from
-    // another app). Without this, new messages wait up to 2 minutes after resume.
+    // Immediate sync + send-queue drain when app comes back to foreground
+    // (e.g. user switches from another app). Without the send-queue drain,
+    // a message queued while offline waits up to 2 minutes after resume
+    // before retrying — long enough for the user to think it's stuck.
     document.addEventListener("visibilitychange", () => {
         if (document.visibilityState === "visible") {
             console.log("[sync] resume poll");
+            for (const account of db.getAccounts()) {
+                syncManager.processSendQueue(account.id)
+                    .catch(e => console.error(`[android] resume send-drain ${account.id}: ${e.message}`));
+            }
             syncManager.syncAll().catch(e => console.error(`[android] Resume sync error: ${e.message}`));
         }
     });

package/packages/mailx-store-web/web-service.d.ts

@@ -30,7 +30,7 @@ export interface WebSyncManager {
     }[], targetFolderId: number): Promise<void>;
     moveMessageCrossAccount(accountId: string, uid: number, folderId: number, targetAccountId: string, targetFolderId: number): Promise<void>;
     undeleteMessage(accountId: string, uid: number, folderId: number): Promise<void>;
-    queueOutgoingLocal(accountId: string, rawMessage: string): void;
+    queueOutgoingLocal(accountId: string, rawMessage: string): void | Promise<void>;
     saveDraft(accountId: string, raw: string, previousDraftUid?: number, draftId?: string): Promise<number | null>;
     deleteDraft(accountId: string, draftUid: number): Promise<void>;
     reauthenticate(accountId: string): Promise<boolean>;

package/packages/mailx-store-web/web-service.js

@@ -394,7 +394,12 @@ export class WebMailxService {
             ].join("\r\n");
             rawMessage = `${headers}\r\n\r\n${textEncoded}`;
         }
-        this.syncManager.queueOutgoingLocal(account.id, rawMessage);
+        // queueOutgoingLocal on the Android bridge is async (it flushes
+        // sql.js → IndexedDB before returning so a tab-close in the
+        // debounce window can't lose the row). On the web-worker
+        // SyncManager it's synchronous and returns void; awaiting an
+        // undefined value is benign, so this works for both.
+        await this.syncManager.queueOutgoingLocal(account.id, rawMessage);
         for (const addr of msg.to)
             this.db.recordSentAddress(addr.name, addr.address);
         if (msg.cc)