@bobfrankston/mailx 1.0.428 → 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

@@ -449,15 +449,30 @@ function applyInit(init) {
         }
     }
     // C42: append the account's signature (if configured) BEFORE rendering
-    // the body. For new mode: just signature. For reply/forward: appended
-    // after the quoted block. Drafts are skipped — the signature is already
-    // baked into the saved body. Editing existing draft also skipped.
+    // the body. Two sources, in priority order:
+    //   1. New `sig: { text, html? }` object — applied to NEW messages only.
+    //      `text` is HTML-escaped (newlines → <br>) unless `html: true` is set
+    //      (reserved for future use; currently `html` is ignored and text is
+    //      always escaped).
+    //   2. Legacy `signature: string` — HTML, applied to new + reply + forward.
+    //
+    // Drafts are skipped — the signature is already baked into the saved body.
+    // Editing an existing draft also skipped.
     let bodyToRender = init.bodyHtml || "";
     const acct = init.accounts.find(a => a.id === init.accountId);
-    const sig = acct?.signature || "";
-    if (sig && init.mode !== "draft" && !init.draftUid) {
-        const sigBlock = `<br><br>--<br>${sig}`;
-        bodyToRender = init.mode === "reply" || init.mode === "replyAll" || init.mode === "forward"
+    const isNew = init.mode !== "reply" && init.mode !== "replyAll"
+        && init.mode !== "forward" && init.mode !== "draft" && !init.draftUid;
+    const isReplyForward = init.mode === "reply" || init.mode === "replyAll"
+        || init.mode === "forward";
+    if (isNew && acct?.sig?.text) {
+        const sigText = acct.sig.html
+            ? acct.sig.text // future: trust as raw HTML
+            : escapeHtml(acct.sig.text).replace(/\n/g, "<br>");
+        bodyToRender = `${bodyToRender}<br><br>-- <br>${sigText}`;
+    }
+    else if (acct?.signature && init.mode !== "draft" && !init.draftUid) {
+        const sigBlock = `<br><br>--<br>${acct.signature}`;
+        bodyToRender = isReplyForward
             ? `<br>${sigBlock}<br>${bodyToRender}` // sig above the quote
             : `${bodyToRender}${sigBlock}`; // sig at the end for new
     }
@@ -959,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) {
@@ -1050,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.428",
+  "version": "1.0.432",
   "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.361",
+    "@bobfrankston/msger": "^0.1.362",
     "@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.361",
+      "@bobfrankston/msger": "^0.1.362",
       "@bobfrankston/mailx-host": "^0.1.8",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",

package/packages/mailx-settings/index.js

@@ -395,6 +395,8 @@ function normalizeAccount(acct, globalName) {
         // blocking the build. Once mailx-types has rebuilt once (post-field)
         // this cast can be removed.
         ...(acct.signature ? { signature: acct.signature } : {}),
+        ...(acct.sig && typeof acct.sig === "object" && typeof acct.sig.text === "string"
+            ? { sig: { text: acct.sig.text, html: !!acct.sig.html } } : {}),
     };
 }
 // ── Defaults ──

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

@@ -196,7 +196,18 @@ export declare class MailxDB {
     rollbackTransaction(): void;
     /** Record an address used in sent mail */
     recordSentAddress(name: string, email: string): void;
-    /** Seed contacts from all message senders in the DB */
+    /** 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,23 +1119,130 @@ 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 all message senders in the DB */
+    /** 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();
-        const rows = this.db.prepare(`SELECT from_name, from_address, COUNT(*) as cnt, MAX(date) as last
-             FROM messages
-             WHERE from_address != ''
-             GROUP BY from_address`).all();
+        // 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, 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++;
+                if (date > e.last)
+                    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, tag });
+            }
+        };
+        // 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;
+            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, "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;
-        for (const r of rows) {
-            // Skip invalid addresses so contact autocomplete never proposes non-emails
-            if (!r.from_address || !/^[^\s<>@]+@[^\s<>@]+\.[^\s<>@]+$/.test(r.from_address))
-                continue;
-            const existing = this.db.prepare("SELECT id FROM contacts WHERE email = ?").get(r.from_address);
+        let bumped = 0;
+        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) {
-                this.db.prepare("INSERT INTO contacts (source, name, email, last_used, use_count, updated_at) VALUES ('received', ?, ?, ?, ?, ?)").run(r.from_name || "", r.from_address, r.last, r.cnt, now);
+                insStmt.run(info.tag, info.name, email, info.last, info.cnt, now);
                 added++;
             }
+            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++;
+            }
+        }
+        if (added > 0 || upgraded > 0) {
+            console.log(`  [contacts] seed: ${added} new + ${bumped} refreshed (${upgraded} upgraded received→sent)`);
         }
         return added;
     }
@@ -1135,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 ?

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

@@ -39,7 +39,14 @@ export interface AccountConfig {
     deliveredToPrefix?: string[]; /** Prefixes to strip from Delivered-To to get clean alias (e.g., ["bobf-ma-", "bobf-"]) — order matters, longest first */
     identityDomains?: string[]; /** Domains where Delivered-To address should become the reply From (e.g., ["bob.ma", "bobf.frankston.com"]) */
     spam?: string; /** IMAP folder path for "Mark as spam" button (e.g., "_spam"). Button hidden when not set. */
-    signature?: string; /** HTML signature appended to outgoing messages from this account. Plain text or HTML allowed. */
+    signature?: string; /** Legacy: HTML signature appended to all outgoing messages (new + reply + forward). Plain text or HTML allowed. Superseded by `sig`. */
+    sig?: AccountSignature; /** Per-account signature object. Initially appended only to NEW messages; later options will cover replies/forwards. */
+}
+/** Signature configuration in accounts.jsonc. Initial shape carries `text`
+ *  only; `html: true` reserved for future support of raw HTML signatures. */
+export interface AccountSignature {
+    text: string; /** Plain-text signature body. Newlines preserved. Appended to NEW messages with the standard "-- " RFC 3676 separator. */
+    html?: boolean; /** Future flag: when true, `text` is treated as raw HTML rather than escaped plain text. Currently ignored. */
 }
 /** Standard IMAP special-use folder types */
 export type SpecialUse = "inbox" | "sent" | "drafts" | "trash" | "junk" | "archive" | "all";