@bobfrankston/mailx-store 0.1.5 → 0.1.8

package/db.d.ts

@@ -4,12 +4,30 @@
  * Message bodies are NOT here -- they live in the MessageStore backend.
  */
 import type { MessageEnvelope, Folder, EmailAddress, PagedResult, MessageQuery } from "@bobfrankston/mailx-types";
+/** 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;
 export declare class MailxDB {
     private db;
     constructor(dbDir: string);
     /** Fail loud + early if expected columns are missing. Cheap (PRAGMA only
      *  runs at startup). The user-facing message names the recovery command. */
     private verifySchema;
+    /** One-shot: rewrite absolute body_path entries to relative-to-store
+     *  paths. Idempotent; flag stored in kv. Caller passes a FileMessageStore
+     *  whose `rewriteAbsoluteToRelative` does the actual mapping (mailx-store
+     *  doesn't depend on file-store directly to avoid a cycle). */
+    runOneShotBodyPathMigration(rewriteFn: (rows: Array<{
+        id: number;
+        body_path: string;
+    }>, update: (id: number, p: string) => void) => number): void;
+    /** One-shot purge: when the in-DB filter rules tighten (new prefix or
+     *  domain matchers), historical contacts harvested under the old rules
+     *  remain in the table and keep being written back to contacts.jsonc on
+     *  every cloud save. Bumping the version below re-runs the purge once
+     *  per device. The kv flag (`contacts:purge_v`) records the last version
+     *  that ran so we don't keep doing the work on every startup. */
+    private runOneShotJunkContactPurge;
     /** Fetch a string from the kv table. Returns null when not set. */
     getKv(scope: string, key: string): string | null;
     /** Upsert a kv row. Pass `null` to delete. */
@@ -201,6 +219,17 @@ export declare class MailxDB {
     private _denylist;
     isAddressDenylisted(emailLower: string): boolean;
     setContactsDenylist(emails: string[]): void;
+    /** Priority sender / domain index — populated from contacts.jsonc on reload.
+     *  Used by the client to flag list rows. Source of truth is the JSONC; this
+     *  is just a fast in-memory lookup. */
+    private _prioritySenders;
+    private _priorityDomains;
+    setPriorityIndex(senders: string[], domains: string[]): void;
+    getPriorityIndex(): {
+        senders: string[];
+        domains: string[];
+    };
+    isPrioritySender(addr: string): boolean;
     /** Callback fired when local-DB contacts mutations happen (sends adding
      *  to discovered, corpus seeder finding new addresses). The service
      *  registers a debounced cloud flush here so the GDrive copy stays in
@@ -237,8 +266,11 @@ export declare class MailxDB {
             source?: string;
             organization?: string;
             org?: string;
+            priority?: boolean;
         }[];
         denylist?: string[];
+        denylistPatterns?: string[];
+        priorityDomains?: string[];
         discovered?: {
             name?: string;
             email: string;

package/db.js

@@ -7,18 +7,33 @@ 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;
+import { CONTACT_RULES } from "@bobfrankston/mailx-types";
+/** Addresses that have no business in autocomplete. Patterns load from
+ *  contact-rules.jsonc in mailx-types — a single source of truth shipped
+ *  with every release. To change the rules edit the JSONC and rebuild. */
+const JUNK_LOCAL_RE = new RegExp(CONTACT_RULES.junk.localExact, "i");
+const JUNK_LOCAL_SUFFIX_RE = new RegExp(CONTACT_RULES.junk.localSuffix, "i");
+const JUNK_LOCAL_PREFIX_RE = new RegExp(CONTACT_RULES.junk.localPrefix, "i");
+const JUNK_DOMAIN_RE = new RegExp(CONTACT_RULES.junk.domain, "i");
+const JUNK_LOCAL_ONEOFF_RE = new RegExp(CONTACT_RULES.junk.localOneoff, "i");
+/** Optional user-configurable pattern list, refreshed when contacts.jsonc
+ *  reloads. Each entry is a regex compiled lazily in setContactsDenyPatterns. */
+let _denyPatterns = [];
 function isJunkContact(email, name) {
-    const local = email.split("@")[0] || "";
+    const lower = (email || "").toLowerCase();
+    const at = lower.indexOf("@");
+    const local = at >= 0 ? lower.slice(0, at) : lower;
+    const domain = at >= 0 ? lower.slice(at + 1) : "";
     if (JUNK_LOCAL_RE.test(local))
         return true;
     if (JUNK_LOCAL_SUFFIX_RE.test(local))
         return true;
+    if (JUNK_LOCAL_PREFIX_RE.test(local))
+        return true;
+    if (JUNK_LOCAL_ONEOFF_RE.test(local))
+        return true;
+    if (domain && JUNK_DOMAIN_RE.test(domain))
+        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)
@@ -26,8 +41,27 @@ function isJunkContact(email, name) {
     const lname = (name || "").trim().toLowerCase();
     if (lname.includes("mailer-daemon") || lname.includes("postmaster"))
         return true;
+    for (const re of _denyPatterns) {
+        if (re.test(lower))
+            return true;
+    }
     return false;
 }
+/** User-configured patterns from contacts.jsonc `denylistPatterns`. Compiled
+ *  once on settings load; invalid regexes are skipped with a warning. */
+export function setContactsDenyPatterns(patterns) {
+    _denyPatterns = [];
+    for (const p of patterns) {
+        if (!p)
+            continue;
+        try {
+            _denyPatterns.push(new RegExp(p, "i"));
+        }
+        catch (e) {
+            console.warn(`[contacts] invalid denylistPattern "${p}": ${e.message}`);
+        }
+    }
+}
 const SCHEMA = `
     CREATE TABLE IF NOT EXISTS accounts (
         id TEXT PRIMARY KEY,
@@ -364,6 +398,58 @@ export class MailxDB {
                 throw new Error(`[mailx-store] table "${table}" is missing columns [${missing.join(", ")}] — schema migration did not complete. Run 'mailx -rebuild' to rebuild the local store.`);
             }
         }
+        this.runOneShotJunkContactPurge();
+    }
+    /** One-shot: rewrite absolute body_path entries to relative-to-store
+     *  paths. Idempotent; flag stored in kv. Caller passes a FileMessageStore
+     *  whose `rewriteAbsoluteToRelative` does the actual mapping (mailx-store
+     *  doesn't depend on file-store directly to avoid a cycle). */
+    runOneShotBodyPathMigration(rewriteFn) {
+        const TARGET = "v1-relative";
+        const last = this.getKv("body_paths", "migrate_v");
+        if (last === TARGET)
+            return;
+        try {
+            const rows = this.db.prepare("SELECT id, body_path FROM messages WHERE body_path IS NOT NULL AND body_path != ''").all();
+            const upd = this.db.prepare("UPDATE messages SET body_path = ? WHERE id = ?");
+            const update = (id, newPath) => upd.run(newPath, id);
+            const n = rewriteFn(rows, update);
+            this.setKv("body_paths", "migrate_v", TARGET);
+            if (n > 0)
+                console.log(`  [body-paths] one-shot: rewrote ${n} of ${rows.length} body_path entries to relative`);
+        }
+        catch (e) {
+            console.warn(`[body-paths] one-shot migration failed: ${e.message}`);
+        }
+    }
+    /** One-shot purge: when the in-DB filter rules tighten (new prefix or
+     *  domain matchers), historical contacts harvested under the old rules
+     *  remain in the table and keep being written back to contacts.jsonc on
+     *  every cloud save. Bumping the version below re-runs the purge once
+     *  per device. The kv flag (`contacts:purge_v`) records the last version
+     *  that ran so we don't keep doing the work on every startup. */
+    runOneShotJunkContactPurge() {
+        const TARGET = CONTACT_RULES.rulesVersion; // bump in contact-rules.jsonc to re-run
+        const last = this.getKv("contacts", "purge_v");
+        if (last === TARGET)
+            return;
+        let dropped = 0;
+        try {
+            const rows = this.db.prepare("SELECT id, email, name FROM contacts WHERE source IN ('discovered','sent','received')").all();
+            const del = this.db.prepare("DELETE FROM contacts WHERE id = ?");
+            for (const r of rows) {
+                if (isJunkContact(r.email || "", r.name || "")) {
+                    del.run(r.id);
+                    dropped++;
+                }
+            }
+            this.setKv("contacts", "purge_v", TARGET);
+            if (dropped > 0)
+                console.log(`  [contacts] one-shot purge: dropped ${dropped} junk rows (${TARGET})`);
+        }
+        catch (e) {
+            console.warn(`[contacts] one-shot purge failed: ${e.message}`);
+        }
     }
     /** Fetch a string from the kv table. Returns null when not set. */
     getKv(scope, key) {
@@ -1150,6 +1236,8 @@ export class MailxDB {
         const lower = email.toLowerCase();
         if (this.isAddressDenylisted(lower))
             return;
+        if (isJunkContact(lower, name))
+            return;
         const now = Date.now();
         // discovered tier holds one row per email — bump if present, else
         // insert. Doesn't touch preferred or google rows for the same email;
@@ -1172,6 +1260,29 @@ export class MailxDB {
     setContactsDenylist(emails) {
         this._denylist = new Set(emails.map(e => (e || "").trim().toLowerCase()).filter(Boolean));
     }
+    /** Priority sender / domain index — populated from contacts.jsonc on reload.
+     *  Used by the client to flag list rows. Source of truth is the JSONC; this
+     *  is just a fast in-memory lookup. */
+    _prioritySenders = new Set();
+    _priorityDomains = new Set();
+    setPriorityIndex(senders, domains) {
+        this._prioritySenders = new Set((senders || []).map(s => (s || "").trim().toLowerCase()).filter(Boolean));
+        this._priorityDomains = new Set((domains || []).map(d => (d || "").trim().toLowerCase()).filter(Boolean));
+    }
+    getPriorityIndex() {
+        return {
+            senders: Array.from(this._prioritySenders).sort(),
+            domains: Array.from(this._priorityDomains).sort(),
+        };
+    }
+    isPrioritySender(addr) {
+        const lower = (addr || "").trim().toLowerCase();
+        if (this._prioritySenders.has(lower))
+            return true;
+        const at = lower.indexOf("@");
+        const domain = at >= 0 ? lower.slice(at + 1) : "";
+        return !!domain && this._priorityDomains.has(domain);
+    }
     /** Callback fired when local-DB contacts mutations happen (sends adding
      *  to discovered, corpus seeder finding new addresses). The service
      *  registers a debounced cloud flush here so the GDrive copy stays in
@@ -1312,8 +1423,18 @@ export class MailxDB {
     applyContactsConfig(cfg) {
         const preferred = Array.isArray(cfg.preferred) ? cfg.preferred : [];
         const denylist = Array.isArray(cfg.denylist) ? cfg.denylist : [];
+        const denylistPatterns = Array.isArray(cfg.denylistPatterns) ? cfg.denylistPatterns : [];
+        const priorityDomains = Array.isArray(cfg.priorityDomains) ? cfg.priorityDomains : [];
         const discovered = Array.isArray(cfg.discovered) ? cfg.discovered : [];
         this.setContactsDenylist(denylist);
+        setContactsDenyPatterns(denylistPatterns);
+        // Priority index — preferred[] entries with priority:true plus the
+        // top-level priorityDomains[]. Address book and visual highlight
+        // are independent: not every preferred contact is priority.
+        const prioritySenders = preferred
+            .filter(e => e && e.priority === true && e.email)
+            .map(e => e.email);
+        this.setPriorityIndex(prioritySenders, priorityDomains);
         // Wipe and rewrite preferred-tier rows owned by contacts.jsonc.
         // The address-book UI's legacy `upsertContact` still writes
         // source='manual' rows; those are owned by the address-book code

package/file-store.d.ts

@@ -14,20 +14,38 @@ import type { MessageStore } from "@bobfrankston/mailx-types";
 export declare class FileMessageStore implements MessageStore {
     private basePath;
     constructor(basePath: string);
-    /** Fresh opaque path per call. No inputs from the caller affect the name. */
-    private newMessagePath;
-    /** Verify a given path resolves inside this store's basePath — refuses
-     *  any value that doesn't (cheap directory-traversal guard). */
-    private inStore;
-    /** Write a new body. Always a fresh UUID path. Caller MUST persist the
-     *  returned path in the DB (`body_path`) and use it for all reads. The
-     *  (folderId, uid) args are kept for interface compatibility; they do
-     *  NOT affect the filename. */
+    /** Fresh opaque path per call, returned RELATIVE to `basePath`. The DB
+     *  stores this relative form so the body store can be relocated (or
+     *  the user folder renamed — e.g. `.mailx → .rmfmail`) without the
+     *  body_path entries breaking. */
+    private newRelativePath;
+    /** Resolve a stored path. Accepts either a relative path (post-2026-05
+     *  format) or an absolute path (legacy entries until next-launch
+     *  migration rewrites them). Either way, refuse anything outside the
+     *  store as a directory-traversal guard. */
+    private resolveStored;
+    /** Write a new body. Returns a path RELATIVE to basePath; caller stores
+     *  it in `body_path`. The (folderId, uid) args are kept for interface
+     *  compatibility; they do NOT affect the filename. */
     putMessage(accountId: string, _folderId: number, _uid: number, raw: Buffer): Promise<string>;
-    /** Read by absolute path (DB `body_path`). The primary read API. */
-    readByPath(fullPath: string): Promise<Buffer>;
-    hasByPath(fullPath: string): Promise<boolean>;
-    unlinkByPath(fullPath: string): Promise<void>;
+    /** Read by stored path (relative or absolute). */
+    readByPath(stored: string): Promise<Buffer>;
+    hasByPath(stored: string): Promise<boolean>;
+    unlinkByPath(stored: string): Promise<void>;
+    /** One-shot migration: rewrite absolute body_path values that point at
+     *  this store's basePath into relative form. Called once from db.ts on
+     *  startup (gated by a kv flag); silently skipped after first run.
+     *  Returns the count of rewritten paths.
+     *
+     *  Bodies whose absolute path is OUTSIDE basePath (the legacy
+     *  `~/.mailx/mailxstore/...` entries on a machine where basePath is
+     *  now `~/.rmfmail/mailxstore`) are left alone — the migration in
+     *  mailx-settings already moves the files; this rewrite is purely
+     *  about getting body_path to a relative shape. */
+    rewriteAbsoluteToRelative(rows: Array<{
+        id: number;
+        body_path: string;
+    }>, update: (id: number, newPath: string) => void): number;
     getMessagePath(_accountId: string, _folderId: number, _uid: number): string;
     getMessage(_accountId: string, _folderId: number, _uid: number): Promise<Buffer>;
     hasMessage(_accountId: string, _folderId: number, _uid: number): Promise<boolean>;

package/file-store.js

@@ -19,46 +19,90 @@ export class FileMessageStore {
         this.basePath = basePath;
         fs.mkdirSync(basePath, { recursive: true });
     }
-    /** Fresh opaque path per call. No inputs from the caller affect the name. */
-    newMessagePath(accountId) {
+    /** Fresh opaque path per call, returned RELATIVE to `basePath`. The DB
+     *  stores this relative form so the body store can be relocated (or
+     *  the user folder renamed — e.g. `.mailx → .rmfmail`) without the
+     *  body_path entries breaking. */
+    newRelativePath(accountId) {
         const uuid = randomUUID().replace(/-/g, "");
         const prefix = uuid.slice(0, 2);
-        return path.join(this.basePath, accountId, prefix, `${uuid}.eml`);
+        return path.join(accountId, prefix, `${uuid}.eml`);
     }
-    /** Verify a given path resolves inside this store's basePath — refuses
-     *  any value that doesn't (cheap directory-traversal guard). */
-    inStore(fullPath) {
-        if (!fullPath)
-            return false;
-        const rel = path.relative(path.resolve(this.basePath), path.resolve(fullPath));
-        return !rel.startsWith("..") && !path.isAbsolute(rel);
+    /** Resolve a stored path. Accepts either a relative path (post-2026-05
+     *  format) or an absolute path (legacy entries until next-launch
+     *  migration rewrites them). Either way, refuse anything outside the
+     *  store as a directory-traversal guard. */
+    resolveStored(p) {
+        if (!p)
+            return "";
+        const abs = path.isAbsolute(p) ? p : path.resolve(this.basePath, p);
+        const rel = path.relative(path.resolve(this.basePath), abs);
+        if (rel.startsWith("..") || path.isAbsolute(rel))
+            return "";
+        return abs;
     }
-    /** Write a new body. Always a fresh UUID path. Caller MUST persist the
-     *  returned path in the DB (`body_path`) and use it for all reads. The
-     *  (folderId, uid) args are kept for interface compatibility; they do
-     *  NOT affect the filename. */
+    /** Write a new body. Returns a path RELATIVE to basePath; caller stores
+     *  it in `body_path`. The (folderId, uid) args are kept for interface
+     *  compatibility; they do NOT affect the filename. */
     async putMessage(accountId, _folderId, _uid, raw) {
-        const filePath = this.newMessagePath(accountId);
-        fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        fs.writeFileSync(filePath, raw);
-        return filePath;
+        const rel = this.newRelativePath(accountId);
+        const abs = path.join(this.basePath, rel);
+        fs.mkdirSync(path.dirname(abs), { recursive: true });
+        fs.writeFileSync(abs, raw);
+        return rel;
     }
-    /** Read by absolute path (DB `body_path`). The primary read API. */
-    async readByPath(fullPath) {
-        if (!this.inStore(fullPath))
-            throw new Error(`refusing to read outside store: ${fullPath}`);
-        return fs.readFileSync(fullPath);
+    /** Read by stored path (relative or absolute). */
+    async readByPath(stored) {
+        const abs = this.resolveStored(stored);
+        if (!abs)
+            throw new Error(`refusing to read outside store: ${stored}`);
+        return fs.readFileSync(abs);
     }
-    async hasByPath(fullPath) {
-        if (!this.inStore(fullPath))
-            return false;
-        return fs.existsSync(fullPath);
+    async hasByPath(stored) {
+        const abs = this.resolveStored(stored);
+        return !!abs && fs.existsSync(abs);
     }
-    async unlinkByPath(fullPath) {
-        if (!this.inStore(fullPath))
+    async unlinkByPath(stored) {
+        const abs = this.resolveStored(stored);
+        if (!abs)
             return;
-        if (fs.existsSync(fullPath))
-            fs.unlinkSync(fullPath);
+        if (fs.existsSync(abs))
+            fs.unlinkSync(abs);
+    }
+    /** One-shot migration: rewrite absolute body_path values that point at
+     *  this store's basePath into relative form. Called once from db.ts on
+     *  startup (gated by a kv flag); silently skipped after first run.
+     *  Returns the count of rewritten paths.
+     *
+     *  Bodies whose absolute path is OUTSIDE basePath (the legacy
+     *  `~/.mailx/mailxstore/...` entries on a machine where basePath is
+     *  now `~/.rmfmail/mailxstore`) are left alone — the migration in
+     *  mailx-settings already moves the files; this rewrite is purely
+     *  about getting body_path to a relative shape. */
+    rewriteAbsoluteToRelative(rows, update) {
+        let n = 0;
+        const baseAbs = path.resolve(this.basePath);
+        for (const r of rows) {
+            if (!r.body_path || !path.isAbsolute(r.body_path))
+                continue;
+            const rel = path.relative(baseAbs, path.resolve(r.body_path));
+            if (rel.startsWith("..") || path.isAbsolute(rel)) {
+                // Outside this store — try mapping `.mailx → .rmfmail` if the
+                // legacy dir was the source. Then re-test.
+                const remapped = r.body_path.replace(/[\\/]\.mailx[\\/]mailxstore[\\/]/i, `${path.sep}.rmfmail${path.sep}mailxstore${path.sep}`);
+                if (remapped !== r.body_path) {
+                    const rel2 = path.relative(baseAbs, path.resolve(remapped));
+                    if (!rel2.startsWith("..") && !path.isAbsolute(rel2)) {
+                        update(r.id, rel2.replace(/\\/g, "/"));
+                        n++;
+                    }
+                }
+                continue;
+            }
+            update(r.id, rel.replace(/\\/g, "/"));
+            n++;
+        }
+        return n;
     }
     // MessageStore interface compatibility (unused once all callers migrate to
     // path-based reads). These used to compose {folderId}/{uid}.eml and they

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-store",
-  "version": "0.1.5",
+  "version": "0.1.8",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -9,21 +9,24 @@
   },
   "license": "ISC",
   "dependencies": {
-    "@bobfrankston/mailx-types": "^0.1.5",
-    "@bobfrankston/mailx-settings": "^0.1.6"
+    "@bobfrankston/mailx-types": "^0.1.7",
+    "@bobfrankston/mailx-settings": "^0.1.8"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/BobFrankston/mailx-store.git"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   ".dependencies": {
     "@bobfrankston/mailx-types": "file:../mailx-types",
     "@bobfrankston/mailx-settings": "file:../mailx-settings"
   },
   ".transformedSnapshot": {
     "dependencies": {
-      "@bobfrankston/mailx-types": "^0.1.5",
-      "@bobfrankston/mailx-settings": "^0.1.6"
+      "@bobfrankston/mailx-types": "^0.1.7",
+      "@bobfrankston/mailx-settings": "^0.1.8"
     }
   }
 }