@bobfrankston/mailx 1.0.430 → 1.0.432

package/README.md

@@ -15,6 +15,8 @@ mailx
 
 Requires Node.js 22 or later.
 
+The package installs two equivalent commands: **`mailx`** and **`bobmail`**. They're the same binary — `bobmail` is provided as an alternative for environments where `mailx` collides with another tool (most commonly the BSD `mailx`/Heirloom mailx at `/usr/bin/mailx` on macOS and some Linux distributions). Use whichever name doesn't conflict on your system.
+
 On Windows, the native WebView2 app launches automatically via IPC (no HTTP server needed). Use `mailx --server` for browser mode at `http://127.0.0.1:9333`.
 
 ## First-Time Setup

package/client/app.js

@@ -492,16 +492,40 @@ document.getElementById("btn-restart-quick")?.addEventListener("click", async ()
     if (restartDropdown)
         restartDropdown.hidden = true;
     if (isApp) {
-        // Android: check for updates before reloading
+        // Android has no daemon — only the WebView. Reload-the-page is the
+        // right action there. Desktop IPC mode is a different story below.
         if (window.mailxapi?.platform === "android") {
             const f = document.createElement("iframe");
             f.style.display = "none";
             f.src = "mailxapi://checkUpdate";
             document.body.appendChild(f);
             setTimeout(() => f.remove(), 100);
+            location.reload();
+            return;
+        }
+        // Desktop IPC mode: there IS a daemon (the --daemon child of mailx)
+        // running mailx-service / mailx-imap / mailx-store. Just calling
+        // location.reload() reloads the WebView but the daemon keeps running
+        // the old code, so daemon-side changes (sync, store, IPC handlers)
+        // don't get picked up. Trigger restartDaemon — it spawns a fresh
+        // `mailx` process, hands off the instance.json slot, then gracefully
+        // shuts down the current daemon. The UI reloads after a short delay
+        // so the new daemon's WebView replaces this one.
+        const statusSync = document.getElementById("status-sync");
+        if (statusSync)
+            statusSync.textContent = "Restarting...";
+        const ipc = window.mailxapi;
+        if (ipc?.restartDaemon) {
+            try {
+                await ipc.restartDaemon();
+            }
+            catch { /* daemon shutting down */ }
+            setTimeout(() => location.reload(), 2000);
+        }
+        else {
+            // Older host with no restartDaemon IPC — fall back to UI reload.
+            location.reload();
         }
-        // IPC mode: reload the UI (no server to restart)
-        location.reload();
     }
     else {
         const statusSync = document.getElementById("status-sync");

package/client/compose/compose.js

@@ -974,7 +974,13 @@ function formatSize(n) {
         return `${(n / 1024).toFixed(1)} KB`;
     return `${(n / (1024 * 1024)).toFixed(1)} MB`;
 }
+/** Set when the user clicks Attach — the native file picker eats the Esc
+ *  press, but on Windows WebView2 the keydown can still spill to the page
+ *  and trip the document-level Esc-closes-compose handler. While this flag
+ *  is set, that handler short-circuits. Cleared shortly after click. */
+let attachJustClicked = 0;
 document.getElementById("btn-attach")?.addEventListener("click", () => {
+    attachJustClicked = Date.now();
     fileInput?.click();
 });
 async function ingestFiles(files) {
@@ -1065,6 +1071,12 @@ document.addEventListener("keydown", (e) => {
         document.getElementById("btn-send")?.click();
     }
     if (e.key === "Escape") {
+        // If the user just clicked Attach, the native file picker is up.
+        // The picker swallows the Esc that dismissed it, but the keydown can
+        // still bubble here on WebView2 — closing the whole compose. Suppress
+        // for a short window after the attach click.
+        if (Date.now() - attachJustClicked < 1500)
+            return;
         e.preventDefault();
         handleCloseRequest();
     }

package/client/index.html

@@ -70,7 +70,7 @@
                     <span class="tb-icon">⚡</span><span class="tb-label"> Restart ▾</span>
                 </button>
                 <div class="tb-menu-dropdown" id="restart-dropdown" hidden>
-                    <button class="tb-menu-item" id="btn-restart-quick" title="Reload the page">Reload</button>
+                    <button class="tb-menu-item" id="btn-restart-quick" title="Restart the mailx daemon and reload the UI — picks up new code after a build">Restart</button>
                     <button class="tb-menu-item" id="btn-update" title="Check for updates and install if available">Check for updates</button>
                     <button class="tb-menu-item" id="btn-rebuild" title="Wipe local DB and message cache, re-download everything. Accounts and settings are preserved. Safe and fast.">Rebuild local cache</button>
                     <hr class="tb-menu-sep">

package/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-client",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "private": true,
   "type": "module",
   "scripts": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.430",
+  "version": "1.0.432",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",

package/packages/mailx-store/db.d.ts

@@ -196,18 +196,18 @@ export declare class MailxDB {
     rollbackTransaction(): void;
     /** Record an address used in sent mail */
     recordSentAddress(name: string, email: string): void;
-    /** Seed contacts from every address that appears in any cached message —
-     *  From, To, Cc, Bcc — across all folders. The original implementation
-     *  only scanned `from_address`, so addresses you'd sent to (To/Cc on
-     *  outgoing mail) never made it into autocomplete unless they had also
-     *  written back to you. That left compose unable to suggest people you
-     *  email regularly but who never reply. This pass walks the JSON arrays
-     *  too. Dedup by lowercased email; per-address `use_count` is the total
-     *  occurrences across the corpus, `last_used` is the most recent message
-     *  date in any field. Existing rows have their counters bumped (instead of
-     *  the old skip-if-exists behavior) so periodic re-seeds keep recency
-     *  fresh — `received`-tagged rows get usage data from observed traffic;
-     *  `sent` and `google` rows are left alone (they're authoritative). */
+    /** Seed contacts from every address that appears in any cached message,
+     *  with two distinctions the prior version missed:
+     *    1. Sent-folder messages: harvest only To/Cc/Bcc (the user's *own*
+     *       From-address gets skipped — no point pre-filling our own
+     *       address into autocomplete). These are tagged `source='sent'`.
+     *    2. Other-folder messages: harvest From + To + Cc + Bcc, tagged
+     *       `source='received'`. Lower priority than 'sent' or 'google'
+     *       in searchContacts ranking.
+     *  Sent wins on insert conflict, so a person you've corresponded with
+     *  ends up tagged 'sent' (more authoritative). Junk addresses (noreply,
+     *  mailer-daemon, postmaster, *-bounces) are dropped at seed time so
+     *  they never even enter autocomplete. */
     seedContactsFromMessages(): number;
     /** Search contacts by name or email prefix */
     searchContacts(query: string, limit?: number): {

package/packages/mailx-store/db.js

@@ -7,6 +7,27 @@ import { DatabaseSync } from "node:sqlite";
 import { randomUUID } from "node:crypto";
 import * as path from "node:path";
 import * as fs from "node:fs";
+/** Addresses that have no business in autocomplete. Standard automated
+ *  sender patterns plus name-side hints ("MAILER-DAEMON" etc.). The exact
+ *  match list keeps surprise low; the regex catches the long tail of
+ *  *-bounces@, no-reply variants, and listserv-style addresses. */
+const JUNK_LOCAL_RE = /^(no-?reply|do-?not-?reply|noreply|mailer-daemon|postmaster|abuse|automated|bounce(s|d)?|list-?(server|admin|owner|manager)?|notification|notifications?|admin@.*automated|root|daemon|nobody|undisclosed)$/i;
+const JUNK_LOCAL_SUFFIX_RE = /(-bounces|\+bounces|-noreply|-no-reply|-notifications?|-mailer)$/i;
+function isJunkContact(email, name) {
+    const local = email.split("@")[0] || "";
+    if (JUNK_LOCAL_RE.test(local))
+        return true;
+    if (JUNK_LOCAL_SUFFIX_RE.test(local))
+        return true;
+    // Bare numeric / hex addresses (rotating IDs from automated systems)
+    // — three or fewer chars is too short to be useful regardless.
+    if (local.length < 2)
+        return true;
+    const lname = (name || "").trim().toLowerCase();
+    if (lname.includes("mailer-daemon") || lname.includes("postmaster"))
+        return true;
+    return false;
+}
 const SCHEMA = `
     CREATE TABLE IF NOT EXISTS accounts (
         id TEXT PRIMARY KEY,
@@ -1098,28 +1119,31 @@ export class MailxDB {
             this.db.prepare("INSERT INTO contacts (source, name, email, last_used, use_count, updated_at) VALUES ('sent', ?, ?, ?, 1, ?)").run(name, email, now, now);
         }
     }
-    /** Seed contacts from every address that appears in any cached message —
-     *  From, To, Cc, Bcc — across all folders. The original implementation
-     *  only scanned `from_address`, so addresses you'd sent to (To/Cc on
-     *  outgoing mail) never made it into autocomplete unless they had also
-     *  written back to you. That left compose unable to suggest people you
-     *  email regularly but who never reply. This pass walks the JSON arrays
-     *  too. Dedup by lowercased email; per-address `use_count` is the total
-     *  occurrences across the corpus, `last_used` is the most recent message
-     *  date in any field. Existing rows have their counters bumped (instead of
-     *  the old skip-if-exists behavior) so periodic re-seeds keep recency
-     *  fresh — `received`-tagged rows get usage data from observed traffic;
-     *  `sent` and `google` rows are left alone (they're authoritative). */
+    /** Seed contacts from every address that appears in any cached message,
+     *  with two distinctions the prior version missed:
+     *    1. Sent-folder messages: harvest only To/Cc/Bcc (the user's *own*
+     *       From-address gets skipped — no point pre-filling our own
+     *       address into autocomplete). These are tagged `source='sent'`.
+     *    2. Other-folder messages: harvest From + To + Cc + Bcc, tagged
+     *       `source='received'`. Lower priority than 'sent' or 'google'
+     *       in searchContacts ranking.
+     *  Sent wins on insert conflict, so a person you've corresponded with
+     *  ends up tagged 'sent' (more authoritative). Junk addresses (noreply,
+     *  mailer-daemon, postmaster, *-bounces) are dropped at seed time so
+     *  they never even enter autocomplete. */
     seedContactsFromMessages() {
         const VALID = /^[^\s<>@]+@[^\s<>@]+\.[^\s<>@]+$/;
         const now = Date.now();
-        // Per-email aggregator. `name` keeps the first non-empty display name
-        // we see so autocomplete shows "Alice <alice@…>" not just the address.
+        // Aggregator keyed by lowercased email. `tag` is 'sent' or 'received'
+        // — sent wins on conflict because it implies the user wrote to that
+        // address (more authoritative than passive observation).
         const agg = new Map();
-        const bump = (name, address, date) => {
+        const bump = (name, address, date, tag) => {
             const email = (address || "").trim().toLowerCase();
             if (!email || !VALID.test(email))
                 return;
+            if (isJunkContact(email, name))
+                return;
             const e = agg.get(email);
             if (e) {
                 e.cnt++;
@@ -1127,15 +1151,20 @@ export class MailxDB {
                     e.last = date;
                 if (!e.name && name)
                     e.name = name;
+                if (tag === "sent")
+                    e.tag = "sent"; // upgrade
             }
             else {
-                agg.set(email, { name: name || "", cnt: 1, last: date || 0 });
+                agg.set(email, { name: name || "", cnt: 1, last: date || 0, tag });
             }
         };
-        const rows = this.db.prepare("SELECT from_name, from_address, to_json, cc_json, bcc_json, date FROM messages").all();
-        for (const r of rows) {
+        // Sent folder rows: skip the From (it's us), harvest the recipients.
+        const sentRows = this.db.prepare(`SELECT m.to_json, m.cc_json, m.bcc_json, m.date
+             FROM messages m
+             JOIN folders f ON m.folder_id = f.id
+             WHERE f.special_use = 'sent'`).all();
+        for (const r of sentRows) {
             const date = r.date || 0;
-            bump(r.from_name, r.from_address, date);
             for (const field of [r.to_json, r.cc_json, r.bcc_json]) {
                 if (!field)
                     continue;
@@ -1151,30 +1180,70 @@ export class MailxDB {
                 for (const a of parsed) {
                     if (!a)
                         continue;
-                    bump(a.name || "", a.address || a.email || "", date);
+                    bump(a.name || "", a.address || a.email || "", date, "sent");
+                }
+            }
+        }
+        // Other folders: harvest everything.
+        const recvRows = this.db.prepare(`SELECT m.from_name, m.from_address, m.to_json, m.cc_json, m.bcc_json, m.date
+             FROM messages m
+             LEFT JOIN folders f ON m.folder_id = f.id
+             WHERE f.special_use IS NULL OR f.special_use != 'sent'`).all();
+        for (const r of recvRows) {
+            const date = r.date || 0;
+            bump(r.from_name, r.from_address, date, "received");
+            for (const field of [r.to_json, r.cc_json, r.bcc_json]) {
+                if (!field)
+                    continue;
+                let parsed;
+                try {
+                    parsed = JSON.parse(field);
+                }
+                catch {
+                    continue;
+                }
+                if (!Array.isArray(parsed))
+                    continue;
+                for (const a of parsed) {
+                    if (!a)
+                        continue;
+                    bump(a.name || "", a.address || a.email || "", date, "received");
                 }
             }
         }
         let added = 0;
         let bumped = 0;
-        const insStmt = this.db.prepare("INSERT INTO contacts (source, name, email, last_used, use_count, updated_at) VALUES ('received', ?, ?, ?, ?, ?)");
-        const updStmt = this.db.prepare("UPDATE contacts SET use_count = ?, last_used = max(last_used, ?), name = CASE WHEN name = '' AND ? != '' THEN ? ELSE name END, updated_at = ? WHERE email = ? AND source = 'received'");
+        let upgraded = 0;
+        const insStmt = this.db.prepare("INSERT INTO contacts (source, name, email, last_used, use_count, updated_at) VALUES (?, ?, ?, ?, ?, ?)");
+        // Refresh seed-derived rows ('sent' or 'received') with fresh counters.
+        // Allow upgrading a 'received' row to 'sent' if the seed now sees it
+        // in the Sent folder. 'google' rows stay untouched — they're owned
+        // by syncGoogleContacts and carry curated names/orgs.
+        const updStmt = this.db.prepare(`UPDATE contacts SET source = ?, use_count = ?,
+                                 last_used = max(last_used, ?),
+                                 name = CASE WHEN name = '' AND ? != '' THEN ? ELSE name END,
+                                 updated_at = ?
+             WHERE email = ? AND source IN ('sent', 'received')`);
         for (const [email, info] of agg) {
             const existing = this.db.prepare("SELECT id, source FROM contacts WHERE email = ?").get(email);
             if (!existing) {
-                insStmt.run(info.name, email, info.last, info.cnt, now);
+                insStmt.run(info.tag, info.name, email, info.last, info.cnt, now);
                 added++;
             }
-            else if (existing.source === "received") {
-                updStmt.run(info.cnt, info.last, info.name, info.name, now, email);
+            else if (existing.source === "google") {
+                // Don't overwrite curated address-book rows; recordSentAddress
+                // already bumps their use_count when actual sends happen.
+            }
+            else {
+                if (existing.source !== info.tag && info.tag === "sent")
+                    upgraded++;
+                updStmt.run(info.tag, info.cnt, info.last, info.name, info.name, now, email);
                 bumped++;
             }
-            // 'sent' and 'google' rows are authoritative — leave their
-            // use_count alone. recordSentAddress bumps 'sent' rows on actual
-            // sends, syncGoogleContacts owns 'google' rows.
         }
-        if (bumped > 0)
-            console.log(`  [contacts] seed: ${added} new + ${bumped} refreshed`);
+        if (added > 0 || upgraded > 0) {
+            console.log(`  [contacts] seed: ${added} new + ${bumped} refreshed (${upgraded} upgraded received→sent)`);
+        }
         return added;
     }
     /** Search contacts by name or email prefix */
@@ -1194,12 +1263,29 @@ export class MailxDB {
         let rows;
         try {
             const prefixQ = `${query}%`;
+            // match_rank combines two signals: how the query matches the
+            // contact (name prefix > local-part prefix > substring), and
+            // where the contact came from (curated Google address book >
+            // someone you've sent to > someone who emailed you). Without
+            // the source bonus, the seeded "received" rows — newsletters,
+            // mailing lists, no-reply senders — drown out the People API
+            // contacts because they have higher use_count from the corpus
+            // aggregation. The +30 / +20 / 0 spread is large enough that a
+            // google-source row with weak query match still beats a
+            // received-source row with the same query match, but small
+            // enough that within a tier the recency-weighted use_count
+            // (computed in JS below, magnitude ~10000×) still differentiates.
             rows = this.db.prepare(`SELECT name, email, source, use_count, last_used,
                         (CASE
                             WHEN lower(name) LIKE lower(?) THEN 3
                             WHEN substr(email, 1, instr(email, '@') - 1) LIKE lower(?) THEN 2
                             WHEN email LIKE ? OR name LIKE ? THEN 1
                             ELSE 0
+                         END) +
+                        (CASE source
+                            WHEN 'google' THEN 30
+                            WHEN 'sent' THEN 20
+                            ELSE 0
                          END) AS match_rank
                  FROM contacts
                  WHERE email LIKE ? OR name LIKE ?