@bobfrankston/mailx-store 0.1.78 → 0.1.82

package/db.d.ts

@@ -19,12 +19,58 @@ export declare function cleanContactName(name: string): string;
 /** User-configured patterns from contacts.jsonc `denylistPatterns`. Compiled
  *  once on settings load; invalid regexes are skipped with a warning. */
 export declare function setContactsDenyPatterns(patterns: string[]): void;
+/** Contact-card columns beyond name/email. Kept as one list so the schema,
+ *  the SELECT, the upsert and the Google People mapping can't drift apart —
+ *  adding a field means touching this array and the People mapping, nothing
+ *  else. `organization` predates the rest (v2); the others arrived with v3. */
+export declare const CONTACT_FIELD_COLUMNS: readonly ["organization", "phone", "title", "address", "website", "notes", "birthday"];
+export type ContactFieldColumn = typeof CONTACT_FIELD_COLUMNS[number];
+export type ContactFields = Record<ContactFieldColumn, string>;
+/** A contact as the address book and autocomplete see it. */
+export interface ContactCard extends ContactFields {
+    name: string;
+    email: string;
+    source: string;
+    googleId: string | null;
+    useCount: number;
+    lastUsed: number;
+}
+/** Map a contacts row to a ContactCard, defaulting every optional field to
+ *  "" so callers never have to null-check a card field. */
+export declare function rowToContactCard(r: any): ContactCard;
 export declare class MailxDB {
     private db;
     /** True for the DB read-worker's connection. Read-only handles never run
      *  DDL / migrations / backfills (the main writer already did, before this
      *  handle opened) and reject any write at the SQLite level. */
     readonly readOnly: boolean;
+    /** Set when a WRITER connection came back read-only anyway — the OS refused
+     *  read-write access at open and SQLite silently downgraded the handle (see
+     *  openWritable). Every write for the life of the process will throw. The
+     *  daemon reads this right after construction and raises a sticky fatal
+     *  banner; nothing else should ever swallow it. */
+    writeDenied: boolean;
+    /** Open the database read-WRITE and VERIFY that we actually got write
+     *  access.
+     *
+     *  SQLite silently downgrades to a read-only handle when the OS refuses the
+     *  read-write open (a transient sharing/permission denial — AV or backup
+     *  scan, a previous instance still exiting, resume-from-sleep). Nothing
+     *  throws at open: reads all work, and then EVERY write for the life of the
+     *  process fails with "attempt to write a readonly database". On 2026-08-02
+     *  that ran an entire boot as a zombie session — is_replied backfill,
+     *  membership collapse, addAccount for all four accounts, flags (★), sync:
+     *  all dead, surfaced only as a per-account banner ("outlook: attempt to
+     *  write a readonly database") that read like an account problem.
+     *
+     *  So: probe with a real write inside a transaction we then ROLL BACK, and
+     *  reopen with backoff while the verdict is read-only. It has to be an
+     *  actual page write — under WAL, `BEGIN IMMEDIATE` alone takes its lock in
+     *  the -shm wal-index and SUCCEEDS on a read-only database (measured), so a
+     *  lock-only probe reports healthy on exactly the handle we're hunting.
+     *  SQLITE_BUSY is the opposite verdict — it PROVES the handle is
+     *  write-capable and merely contended, so keep it. */
+    private openWritable;
     constructor(dbDir: string, opts?: {
         readOnly?: boolean;
         skipMigrations?: boolean;
@@ -743,20 +789,21 @@ export declare class MailxDB {
     }[];
     /** List all contacts (address-book view) with pagination + optional filter. */
     listContacts(query: string, page?: number, pageSize?: number): {
-        items: {
-            name: string;
-            email: string;
-            source: string;
-            googleId: string | null;
-            useCount: number;
-            lastUsed: number;
-        }[];
+        items: ContactCard[];
         total: number;
         page: number;
         pageSize: number;
     };
-    /** Update or insert a contact manually (from the address book UI). */
-    upsertContact(name: string, email: string): void;
+    /** Update or insert a contact manually (from the address book UI, or
+     *  from an AI-extracted proposal the user accepted).
+     *
+     *  `fields` is OPTIONAL and PARTIAL by design: an undefined member
+     *  leaves the stored value alone rather than blanking it. The
+     *  address book edits one field at a time, and mail-derived proposals
+     *  only ever know a subset — neither should wipe what Google People
+     *  already knew about the person. Pass an explicit empty string to
+     *  clear a field. */
+    upsertContact(name: string, email: string, fields?: Partial<ContactFields>): void;
     /** Delete a contact by email (address book UI). */
     deleteContact(email: string): void;
     /** Delete contact rows by Google People resourceName. Used by the

package/db.js

@@ -202,6 +202,16 @@ const SCHEMA = `
         name TEXT DEFAULT '',
         email TEXT NOT NULL,
         organization TEXT DEFAULT '',
+        -- Full contact card (v3). Google People carries all of these; before
+        -- v3 we stored only name/email/organization and threw the rest away
+        -- on every sync, so a phone number in a signature had nowhere to land
+        -- (Bob 2026-08-07: "extend the contact support for all fields").
+        phone TEXT DEFAULT '',
+        title TEXT DEFAULT '',
+        address TEXT DEFAULT '',
+        website TEXT DEFAULT '',
+        notes TEXT DEFAULT '',
+        birthday TEXT DEFAULT '',
         last_used INTEGER DEFAULT 0,
         use_count INTEGER DEFAULT 0,
         updated_at INTEGER NOT NULL,
@@ -426,17 +436,119 @@ const SCHEMA = `
     CREATE INDEX IF NOT EXISTS idx_message_folders_msg ON message_folders(message_row_id);
     CREATE INDEX IF NOT EXISTS idx_message_folders_folder_uid ON message_folders(folder_id, uid);
 `;
+/** Park the thread for `ms` without spinning. The DB is opened in a
+ *  constructor (no async available) and the write-access probe below needs to
+ *  wait out a transient lock; Atomics.wait is the only true sync sleep. */
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+/** Contact-card columns beyond name/email. Kept as one list so the schema,
+ *  the SELECT, the upsert and the Google People mapping can't drift apart —
+ *  adding a field means touching this array and the People mapping, nothing
+ *  else. `organization` predates the rest (v2); the others arrived with v3. */
+export const CONTACT_FIELD_COLUMNS = [
+    "organization", "phone", "title", "address", "website", "notes", "birthday",
+];
+/** Map a contacts row to a ContactCard, defaulting every optional field to
+ *  "" so callers never have to null-check a card field. */
+export function rowToContactCard(r) {
+    const card = {
+        name: r.name || "",
+        email: r.email || "",
+        source: r.source || "",
+        googleId: r.google_id || null,
+        useCount: r.use_count || 0,
+        lastUsed: r.last_used || 0,
+    };
+    for (const col of CONTACT_FIELD_COLUMNS)
+        card[col] = r[col] || "";
+    return card;
+}
 export class MailxDB {
     db;
     /** True for the DB read-worker's connection. Read-only handles never run
      *  DDL / migrations / backfills (the main writer already did, before this
      *  handle opened) and reject any write at the SQLite level. */
     readOnly;
+    /** Set when a WRITER connection came back read-only anyway — the OS refused
+     *  read-write access at open and SQLite silently downgraded the handle (see
+     *  openWritable). Every write for the life of the process will throw. The
+     *  daemon reads this right after construction and raises a sticky fatal
+     *  banner; nothing else should ever swallow it. */
+    writeDenied = false;
+    /** Open the database read-WRITE and VERIFY that we actually got write
+     *  access.
+     *
+     *  SQLite silently downgrades to a read-only handle when the OS refuses the
+     *  read-write open (a transient sharing/permission denial — AV or backup
+     *  scan, a previous instance still exiting, resume-from-sleep). Nothing
+     *  throws at open: reads all work, and then EVERY write for the life of the
+     *  process fails with "attempt to write a readonly database". On 2026-08-02
+     *  that ran an entire boot as a zombie session — is_replied backfill,
+     *  membership collapse, addAccount for all four accounts, flags (★), sync:
+     *  all dead, surfaced only as a per-account banner ("outlook: attempt to
+     *  write a readonly database") that read like an account problem.
+     *
+     *  So: probe with a real write inside a transaction we then ROLL BACK, and
+     *  reopen with backoff while the verdict is read-only. It has to be an
+     *  actual page write — under WAL, `BEGIN IMMEDIATE` alone takes its lock in
+     *  the -shm wal-index and SUCCEEDS on a read-only database (measured), so a
+     *  lock-only probe reports healthy on exactly the handle we're hunting.
+     *  SQLITE_BUSY is the opposite verdict — it PROVES the handle is
+     *  write-capable and merely contended, so keep it. */
+    openWritable(dbPath) {
+        const backoffMs = [0, 100, 300, 1000, 2000];
+        let lastErr = "";
+        for (let attempt = 0; attempt < backoffMs.length; attempt++) {
+            if (backoffMs[attempt])
+                sleepSync(backoffMs[attempt]);
+            const db = new DatabaseSync(dbPath);
+            try {
+                db.exec("BEGIN IMMEDIATE");
+                db.exec("CREATE TABLE _mailx_write_probe(x)");
+                db.exec("ROLLBACK"); // probe table never reaches the file
+                if (attempt > 0)
+                    console.log(`  [db] write access acquired on attempt ${attempt + 1}`);
+                return db;
+            }
+            catch (e) {
+                lastErr = e?.message || String(e);
+                if (!/readonly/i.test(lastErr)) {
+                    // Busy/locked — another writer holds the lock this instant.
+                    // That is a write-capable handle; take it.
+                    try {
+                        db.exec("ROLLBACK");
+                    }
+                    catch { /* no txn was opened */ }
+                    return db;
+                }
+                console.error(`  [db] opened READ-ONLY (attempt ${attempt + 1}/${backoffMs.length}): ${lastErr}`);
+                db.close();
+            }
+        }
+        // Out of retries. Return a handle anyway — reading mail beats no app at
+        // all — but flag it so the daemon can say so, loudly and stickily.
+        console.error(`  [db] FATAL: ${dbPath} is READ-ONLY after ${backoffMs.length} attempts — no change will be saved (${lastErr})`);
+        this.writeDenied = true;
+        return new DatabaseSync(dbPath);
+    }
     constructor(dbDir, opts = {}) {
         fs.mkdirSync(dbDir, { recursive: true });
         const dbPath = path.join(dbDir, "mailx.db");
         this.readOnly = !!opts.readOnly;
-        this.db = new DatabaseSync(dbPath);
+        this.db = this.readOnly ? new DatabaseSync(dbPath) : this.openWritable(dbPath);
+        if (this.writeDenied) {
+            // Asked for a writer, got a read-only handle (openWritable already
+            // shouted about it). Everything below — journal_mode, the schema,
+            // every migration and backfill — is a write, so running it would
+            // throw or bury the real message under a dozen derived errors.
+            // Set up as a reader and let the daemon surface the banner: the
+            // user can still READ mail while the app says, once and plainly,
+            // that nothing is being saved.
+            this.db.exec("PRAGMA foreign_keys = ON");
+            this.db.exec("PRAGMA busy_timeout = 5000");
+            return;
+        }
         if (opts.skipMigrations && !opts.readOnly) {
             // Write-capable connection that does NOT run schema/migrations —
             // used by the sync worker, which opens its own writer AFTER the
@@ -827,6 +939,54 @@ export class MailxDB {
                 console.error(`  [db] contacts v2 reset failed: ${e.message}`);
             }
         }
+        // contacts v3: the full contact card. v2 kept only name / email /
+        // organization, so every phone number, job title, address, website,
+        // note and birthday Google People had was discarded on every sync,
+        // and a phone number read out of a signature block had nowhere to
+        // land (Bob 2026-08-07: "extend the contact support for all fields").
+        // Same recreate-the-table shape as v2 rather than an ALTER, but the
+        // EXISTING ROWS ARE CARRIED ACROSS. v2 dropped them outright, which is
+        // fine for google rows (one resync restores them) and wrong for the
+        // rest: sent/received/manual rows and their use_count ordering come
+        // from local mail and the user, and Google would never hand them back.
+        // The new columns simply arrive empty and fill in on the next sync.
+        const contactsV3Flag = this.getKv("schema", "contacts_v3");
+        if (!contactsV3Flag) {
+            try {
+                const carried = this.db.prepare("SELECT source, google_id, name, email, organization, last_used, use_count, updated_at FROM contacts").all();
+                this.db.exec("DROP TABLE IF EXISTS contacts");
+                this.db.exec(`
+                    CREATE TABLE contacts (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        source TEXT NOT NULL DEFAULT 'discovered',
+                        google_id TEXT,
+                        name TEXT DEFAULT '',
+                        email TEXT NOT NULL,
+                        organization TEXT DEFAULT '',
+                        phone TEXT DEFAULT '',
+                        title TEXT DEFAULT '',
+                        address TEXT DEFAULT '',
+                        website TEXT DEFAULT '',
+                        notes TEXT DEFAULT '',
+                        birthday TEXT DEFAULT '',
+                        last_used INTEGER DEFAULT 0,
+                        use_count INTEGER DEFAULT 0,
+                        updated_at INTEGER NOT NULL,
+                        UNIQUE(source, email, name)
+                    );
+                    CREATE INDEX IF NOT EXISTS idx_contacts_email ON contacts(email);
+                    CREATE INDEX IF NOT EXISTS idx_contacts_name ON contacts(name);
+                `);
+                const ins = this.db.prepare("INSERT OR IGNORE INTO contacts (source, google_id, name, email, organization, last_used, use_count, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
+                for (const m of carried)
+                    ins.run(m.source || "discovered", m.google_id || null, m.name || "", m.email, m.organization || "", m.last_used || 0, m.use_count || 0, m.updated_at || Date.now());
+                this.setKv("schema", "contacts_v3", String(Date.now()));
+                console.log(`  [db] contacts table reset to v3 schema (full contact card); carried ${carried.length} row(s)`);
+            }
+            catch (e) {
+                console.error(`  [db] contacts v3 reset failed: ${e.message}`);
+            }
+        }
         // Post-migration sanity check: verify the columns we actually read in
         // SELECTs exist. If any migration silently failed (stale driver, DB
         // file locked, permission error), later code would throw cryptic
@@ -3571,32 +3731,50 @@ export class MailxDB {
         const params = hasQuery ? [q, q] : [];
         const totalRow = this.db.prepare(`SELECT COUNT(*) as c FROM contacts ${whereClause}`).get(...params);
         const offset = (page - 1) * pageSize;
-        const rows = this.db.prepare(`SELECT name, email, source, google_id, use_count, last_used FROM contacts
+        const rows = this.db.prepare(`SELECT name, email, source, google_id, use_count, last_used,
+                    organization, phone, title, address, website, notes, birthday FROM contacts
              ${whereClause}
              ORDER BY use_count DESC, last_used DESC
              LIMIT ? OFFSET ?`).all(...params, pageSize, offset);
         return {
-            items: rows.map(r => ({
-                name: r.name, email: r.email, source: r.source,
-                googleId: r.google_id || null,
-                useCount: r.use_count, lastUsed: r.last_used,
-            })),
+            items: rows.map(r => rowToContactCard(r)),
             total: totalRow?.c || 0,
             page, pageSize,
         };
     }
-    /** Update or insert a contact manually (from the address book UI). */
-    upsertContact(name, email) {
+    /** Update or insert a contact manually (from the address book UI, or
+     *  from an AI-extracted proposal the user accepted).
+     *
+     *  `fields` is OPTIONAL and PARTIAL by design: an undefined member
+     *  leaves the stored value alone rather than blanking it. The
+     *  address book edits one field at a time, and mail-derived proposals
+     *  only ever know a subset — neither should wipe what Google People
+     *  already knew about the person. Pass an explicit empty string to
+     *  clear a field. */
+    upsertContact(name, email, fields) {
         if (!email || !/^[^\s<>@]+@[^\s<>@]+\.[^\s<>@]+$/.test(email)) {
             throw new Error(`Invalid email: ${email}`);
         }
         const now = Date.now();
         const existing = this.db.prepare("SELECT id FROM contacts WHERE email = ?").get(email);
+        // Only touch the columns the caller actually supplied.
+        const sets = [];
+        const vals = [];
+        for (const col of CONTACT_FIELD_COLUMNS) {
+            const v = fields?.[col];
+            if (v === undefined)
+                continue;
+            sets.push(`${col} = ?`);
+            vals.push(v);
+        }
         if (existing) {
-            this.db.prepare("UPDATE contacts SET name = ?, updated_at = ? WHERE email = ?").run(name, now, email);
+            this.db.prepare(`UPDATE contacts SET name = ?, ${sets.length ? sets.join(", ") + "," : ""} updated_at = ? WHERE email = ?`).run(name, ...vals, now, email);
         }
         else {
-            this.db.prepare("INSERT INTO contacts (source, name, email, last_used, use_count, updated_at) VALUES ('manual', ?, ?, ?, 0, ?)").run(name, email, now, now);
+            const cols = CONTACT_FIELD_COLUMNS.filter(c => fields?.[c] !== undefined);
+            const colSql = cols.length ? `, ${cols.join(", ")}` : "";
+            const phSql = cols.length ? `, ${cols.map(() => "?").join(", ")}` : "";
+            this.db.prepare(`INSERT INTO contacts (source, name, email, last_used, use_count, updated_at${colSql}) VALUES ('manual', ?, ?, ?, 0, ?${phSql})`).run(name, email, now, now, ...cols.map(c => fields[c]));
         }
     }
     /** Delete a contact by email (address book UI). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-store",
-  "version": "0.1.78",
+  "version": "0.1.82",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",