@bobfrankston/mailx 1.0.339 → 1.0.348

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

@@ -34,6 +34,15 @@ export declare class MailxService {
     getSyncPending(): {
         pending: number;
     };
+    /** Outbox queue depth + retry status for the UI status bar. Cheap to call. */
+    getOutboxStatus(): any;
+    /** List queued outgoing messages with parsed envelope headers so the UI
+     *  can render a pink-row "pending" view before IMAP APPEND succeeds. */
+    listQueuedOutgoing(): any[];
+    /** Manually drop a queued message (not yet sent). Removes the .ltr file. */
+    cancelQueuedOutgoing(filePath: string): {
+        ok: true;
+    };
     syncAll(): Promise<void>;
     syncAccount(accountId: string): Promise<void>;
     /** Force re-authentication for an account (deletes token, opens browser consent) */
@@ -73,6 +82,22 @@ export declare class MailxService {
      *  action on From/To/Cc addresses in the message viewer. Just calls the same
      *  validated upsert path as recordSentAddress. */
     addContact(name: string, email: string): boolean;
+    /** Address-book listing — paginated, filterable. */
+    listContacts(query: string, page?: number, pageSize?: number): any;
+    /** Upsert a contact from the address book UI (edit name). */
+    upsertContact(name: string, email: string): {
+        ok: true;
+    };
+    /** Delete a contact from the address book. */
+    deleteContact(email: string): {
+        ok: true;
+    };
+    /** Open a configured local path in the OS file explorer. Whitelisted to
+     *  avoid the UI poking at arbitrary paths. */
+    openLocalPath(which: "config" | "log"): Promise<{
+        ok: true;
+        path: string;
+    }>;
     /** Get all messages in a thread (across folders) for an account. */
     getThreadMessages(accountId: string, threadId: string): any;
     /** Read a JSONC config file from the shared cloud dir or local ~/.mailx.

package/packages/mailx-service/index.js

@@ -409,6 +409,87 @@ export class MailxService {
     getSyncPending() {
         return { pending: this.db.getTotalPendingSyncCount() };
     }
+    /** Outbox queue depth + retry status for the UI status bar. Cheap to call. */
+    getOutboxStatus() {
+        return this.imapManager.getOutboxStatus();
+    }
+    /** List queued outgoing messages with parsed envelope headers so the UI
+     *  can render a pink-row "pending" view before IMAP APPEND succeeds. */
+    listQueuedOutgoing() {
+        const configDir = getConfigDir();
+        const outboxRoot = path.join(configDir, "outbox");
+        const sendingRoot = path.join(configDir, "sending");
+        const out = [];
+        const parseEnv = (raw, file, dir, accountId) => {
+            const headerEnd = raw.search(/\r?\n\r?\n/);
+            const headers = headerEnd >= 0 ? raw.slice(0, headerEnd) : raw;
+            const get = (name) => {
+                const re = new RegExp(`^${name}:\\s*(.+(?:\\r?\\n\\s+.+)*)`, "mi");
+                const m = headers.match(re);
+                return m ? m[1].replace(/\r?\n\s+/g, " ").trim() : "";
+            };
+            const retries = (headers.match(/^X-Mailx-Retry:/gmi) || []).length;
+            const st = (() => { try {
+                return fs.statSync(path.join(dir, file));
+            }
+            catch {
+                return null;
+            } })();
+            return {
+                accountId,
+                file,
+                path: path.join(dir, file),
+                dir,
+                from: get("From"),
+                to: get("To"),
+                cc: get("Cc"),
+                bcc: get("Bcc"),
+                subject: get("Subject"),
+                date: get("Date"),
+                messageId: get("Message-ID"),
+                attempts: retries,
+                sizeBytes: st?.size || 0,
+                createdAt: st?.mtimeMs || 0,
+                claimed: /\.sending-[^-]+-\d+$/.test(file),
+            };
+        };
+        const scanDir = (accountId, dir) => {
+            if (!fs.existsSync(dir))
+                return;
+            for (const f of fs.readdirSync(dir)) {
+                if (!f.endsWith(".ltr") && !f.endsWith(".eml") && !/\.sending-/.test(f))
+                    continue;
+                try {
+                    const raw = fs.readFileSync(path.join(dir, f), "utf-8");
+                    out.push(parseEnv(raw, f, dir, accountId));
+                }
+                catch { /* unreadable — skip */ }
+            }
+        };
+        try {
+            if (fs.existsSync(outboxRoot)) {
+                for (const acct of fs.readdirSync(outboxRoot))
+                    scanDir(acct, path.join(outboxRoot, acct));
+            }
+            if (fs.existsSync(sendingRoot)) {
+                for (const acct of fs.readdirSync(sendingRoot))
+                    scanDir(acct, path.join(sendingRoot, acct, "queued"));
+            }
+        }
+        catch { /* */ }
+        out.sort((a, b) => b.createdAt - a.createdAt);
+        return out;
+    }
+    /** Manually drop a queued message (not yet sent). Removes the .ltr file. */
+    cancelQueuedOutgoing(filePath) {
+        // Safety: refuse anything outside the ~/.mailx tree.
+        const dir = getConfigDir();
+        if (!filePath.startsWith(dir))
+            throw new Error("path outside mailx data dir");
+        if (fs.existsSync(filePath))
+            fs.unlinkSync(filePath);
+        return { ok: true };
+    }
     async syncAll() {
         await this.imapManager.syncAll();
     }
@@ -440,6 +521,9 @@ export class MailxService {
         // locally. Everything else (contacts recording, IMAP APPEND,
         // SMTP) happens after the IPC ACK. Settings come from cache so
         // a stalled GDrive mount doesn't block the send.
+        const t0 = Date.now();
+        const lap = (label) => console.log(`  [send] +${Date.now() - t0}ms ${label}`);
+        console.log(`  [send] ENTRY from=${msg?.from} to=${JSON.stringify(msg?.to)} subject="${msg?.subject}" attachments=${msg?.attachments?.length || 0}`);
         const accounts = this.getCachedAccounts();
         let account = accounts.find(a => a.id === msg.from);
         if (!account) {
@@ -447,8 +531,12 @@ export class MailxService {
             this._accountsCache = null;
             account = this.getCachedAccounts().find(a => a.id === msg.from);
         }
-        if (!account)
+        if (!account) {
+            const ids = accounts.map(a => a.id).join(", ");
+            console.error(`  [send] FAIL: Unknown account "${msg.from}". Known accounts: [${ids}]`);
             throw new Error(`Unknown account: ${msg.from}`);
+        }
+        lap("account resolved");
         // Vet every recipient address — refuse to send if any field contains a
         // non-email (e.g. "Bob Frankston <Bob Frankston>" from a bad contact
         // autocomplete). This catches garbage BEFORE it hits SMTP, where the
@@ -531,7 +619,9 @@ export class MailxService {
             ].join("\r\n");
             rawMessage = `${headers}\r\n\r\n${bodyEncoded}`;
         }
+        lap(`MIME assembled (${rawMessage.length} bytes${hasAttachments ? `, ${msg.attachments.length} attachment(s)` : ""})`);
         this.imapManager.queueOutgoingLocal(account.id, rawMessage);
+        lap("queued to disk");
         console.log(`  Queued locally: ${msg.subject} via ${account.id} from ${fromHeader}`);
         // Contacts recording is off the critical path — deferred until after
         // the IPC ACK so a slow DB write can't stall the send.
@@ -604,8 +694,13 @@ export class MailxService {
     /** Move messages to the account's configured spam folder (accounts.jsonc "spam" path).
      *  Throws if the account has no spam folder configured or the folder doesn't exist locally. */
     async markAsSpamMessages(accountId, uids) {
-        const settings = loadSettings();
-        const account = settings.accounts.find(a => a.id === accountId);
+        // Cached accounts — same reason as send/saveDraft: a stalled GDrive
+        // mount could turn `Mark as spam` into a 120s IPC timeout.
+        let account = this.getCachedAccounts().find(a => a.id === accountId);
+        if (!account) {
+            this._accountsCache = null;
+            account = this.getCachedAccounts().find(a => a.id === accountId);
+        }
         if (!account)
             throw new Error(`Account ${accountId} not found`);
         const spamPath = account.spam;
@@ -760,8 +855,15 @@ export class MailxService {
         // a prerequisite. X-Mailx-Draft-ID is carried in the MIME headers
         // so the reconciler can de-duplicate on the server by header search
         // even without the previousDraftUid round-trip.
-        const settings = loadSettings();
-        const account = settings.accounts.find(a => a.id === accountId);
+        // Account lookup uses the cached list — `loadSettings()` reads
+        // accounts.jsonc from the GDrive mount and could itself stall for
+        // 120s, which was the actual `mailxapi timeout: saveDraft` source
+        // (the IMAP work was fire-and-forget, but loadSettings wasn't).
+        let account = this.getCachedAccounts().find(a => a.id === accountId);
+        if (!account) {
+            this._accountsCache = null;
+            account = this.getCachedAccounts().find(a => a.id === accountId);
+        }
         if (!account)
             throw new Error(`Unknown account: ${accountId}`);
         // Generate or reuse a stable draft ID for dedup
@@ -828,6 +930,41 @@ export class MailxService {
         this.db.recordSentAddress(name || "", email);
         return true;
     }
+    /** Address-book listing — paginated, filterable. */
+    listContacts(query, page = 1, pageSize = 100) {
+        return this.db.listContacts(query || "", page, pageSize);
+    }
+    /** Upsert a contact from the address book UI (edit name). */
+    upsertContact(name, email) {
+        this.db.upsertContact(name || "", email);
+        return { ok: true };
+    }
+    /** Delete a contact from the address book. */
+    deleteContact(email) {
+        this.db.deleteContact(email);
+        return { ok: true };
+    }
+    /** Open a configured local path in the OS file explorer. Whitelisted to
+     *  avoid the UI poking at arbitrary paths. */
+    async openLocalPath(which) {
+        const dir = getConfigDir();
+        let target = dir;
+        if (which === "log") {
+            const today = new Date();
+            const pad = (n) => String(n).padStart(2, "0");
+            const fname = `mailx-${today.getFullYear()}-${pad(today.getMonth() + 1)}-${pad(today.getDate())}.log`;
+            target = path.join(dir, "logs", fname);
+        }
+        const { spawn } = await import("child_process");
+        const cmd = process.platform === "win32" ? "explorer"
+            : process.platform === "darwin" ? "open"
+                : "xdg-open";
+        const args = process.platform === "win32" && which === "log"
+            ? ["/select,", target]
+            : [target];
+        spawn(cmd, args, { detached: true, stdio: "ignore", windowsHide: true }).unref();
+        return { ok: true, path: target };
+    }
     /** Get all messages in a thread (across folders) for an account. */
     getThreadMessages(accountId, threadId) {
         return this.db.getThreadMessages(accountId, threadId);

package/packages/mailx-service/jsonrpc.js

@@ -71,7 +71,12 @@ async function dispatchAction(svc, action, p) {
         case "emptyFolder":
             await svc.emptyFolder(p.accountId, p.folderId);
             return { ok: true };
-        // Compose
+        // Compose. sendMessage validates synchronously (fast — regex check on
+        // recipient strings), then writes to disk synchronously inside the
+        // service. Validation errors come back immediately to the user; once
+        // we've ACK'd, the message is durable on disk and the worker drains it.
+        // The whole call should be sub-100ms; if it ever isn't, the [send]
+        // timing log shows which step ate the budget.
         case "sendMessage":
             await svc.send(p);
             return { ok: true };
@@ -89,6 +94,12 @@ async function dispatchAction(svc, action, p) {
             return { ok: true };
         case "getSyncPending":
             return svc.getSyncPending();
+        case "getOutboxStatus":
+            return svc.getOutboxStatus();
+        case "listQueuedOutgoing":
+            return svc.listQueuedOutgoing();
+        case "cancelQueuedOutgoing":
+            return svc.cancelQueuedOutgoing(p.path);
         case "reauthenticate":
             return { ok: await svc.reauthenticate(p.accountId) };
         // Search & contacts
@@ -98,6 +109,14 @@ async function dispatchAction(svc, action, p) {
             return svc.searchContacts(p.query);
         case "addContact":
             return { ok: svc.addContact(p.name, p.email) };
+        case "listContacts":
+            return svc.listContacts(p.query || "", p.page || 1, p.pageSize || 100);
+        case "upsertContact":
+            return svc.upsertContact(p.name, p.email);
+        case "deleteContact":
+            return svc.deleteContact(p.email);
+        case "openLocalPath":
+            return await svc.openLocalPath(p.which);
         case "getThreadMessages":
             return svc.getThreadMessages(p.accountId, p.threadId);
         case "readJsoncFile":

package/packages/mailx-settings/index.js

@@ -349,13 +349,22 @@ const PROVIDERS = {
 /** Fill in provider defaults for an account based on email domain */
 function normalizeAccount(acct, globalName) {
     const email = acct.email || "";
+    const localPart = email.split("@")[0]?.toLowerCase() || "";
     const domain = email.split("@")[1]?.toLowerCase() || "";
     const provider = PROVIDERS[domain];
     const user = acct.imap?.user || acct.user || email;
+    // P14: auto-derive id and label so a known-provider account works with just
+    // { email, password? } in accounts.jsonc. id defaults to local-part (most
+    // accounts have a unique local-part); label defaults to provider name or id.
+    // Generic local-parts (info, admin, support, no-reply, ...) fall back to
+    // the domain stem to avoid collisions across accounts.
+    const GENERIC_LOCALS = new Set(["info", "admin", "support", "no-reply", "noreply", "contact", "hello", "mail", "office"]);
+    const domainStem = domain.split(".")[0] || "";
+    const autoId = (localPart && !GENERIC_LOCALS.has(localPart)) ? localPart : (domainStem || "account");
     return {
-        id: acct.id || domain.split(".")[0] || "account",
-        name: acct.name || globalName || email.split("@")[0],
-        label: acct.label || provider?.label,
+        id: acct.id || autoId,
+        name: acct.name || globalName || localPart,
+        label: acct.label || provider?.label || acct.id || autoId,
         email,
         imap: {
             host: acct.imap?.host || provider?.imap.host || `imap.${domain}`,
@@ -386,6 +395,12 @@ function normalizeAccount(acct, globalName) {
         // that had it configured. `acct.spam` first so a user-set value on
         // a recognized provider still overrides the default.
         spam: acct.spam !== undefined ? acct.spam : provider?.spam,
+        // `signature` is on AccountConfig in mailx-types but the workspace
+        // build order sometimes leaves a stale .d.ts for type-check; using
+        // `as any` is the minimum-blast-radius way to add the field without
+        // blocking the build. Once mailx-types has rebuilt once (post-field)
+        // this cast can be removed.
+        ...(acct.signature ? { signature: acct.signature } : {}),
     };
 }
 // ── Defaults ──

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

@@ -105,6 +105,23 @@ export declare class MailxDB {
         source: string;
         useCount: number;
     }[];
+    /** List all contacts (address-book view) with pagination + optional filter. */
+    listContacts(query: string, page?: number, pageSize?: number): {
+        items: {
+            name: string;
+            email: string;
+            source: string;
+            useCount: number;
+            lastUsed: number;
+        }[];
+        total: number;
+        page: number;
+        pageSize: number;
+    };
+    /** Update or insert a contact manually (from the address book UI). */
+    upsertContact(name: string, email: string): void;
+    /** Delete a contact by email (address book UI). */
+    deleteContact(email: string): void;
     /** Full-text search across all messages. Supports qualifiers: from:, to:, subject: */
     searchMessages(query: string, page?: number, pageSize?: number, accountId?: string, folderId?: number): PagedResult<MessageEnvelope>;
     /** Rebuild FTS index from existing messages */

package/packages/mailx-store/db.js

@@ -589,16 +589,87 @@ export class MailxDB {
              LIMIT ?`).all(q, q, limit);
         return rows.map(r => ({ name: r.name, email: r.email, source: r.source, useCount: r.use_count }));
     }
+    /** List all contacts (address-book view) with pagination + optional filter. */
+    listContacts(query, page = 1, pageSize = 100) {
+        const hasQuery = !!query.trim();
+        const q = `%${query}%`;
+        const whereClause = hasQuery ? "WHERE email LIKE ? OR name LIKE ?" : "";
+        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, use_count, last_used 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, useCount: r.use_count, lastUsed: r.last_used })),
+            total: totalRow?.c || 0,
+            page, pageSize,
+        };
+    }
+    /** Update or insert a contact manually (from the address book UI). */
+    upsertContact(name, email) {
+        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);
+        if (existing) {
+            this.db.prepare("UPDATE contacts SET name = ?, updated_at = ? WHERE email = ?").run(name, 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);
+        }
+    }
+    /** Delete a contact by email (address book UI). */
+    deleteContact(email) {
+        this.db.prepare("DELETE FROM contacts WHERE email = ?").run(email);
+    }
     // ── Search ──
     /** Full-text search across all messages. Supports qualifiers: from:, to:, subject: */
     searchMessages(query, page = 1, pageSize = 50, accountId, folderId) {
-        // Parse qualifiers
+        // Parse qualifiers (C45: extended set — date:, has:, is:, folder:).
         let ftsQuery = "";
         const parts = query.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
+        // Extra SQL where-clauses for qualifiers that don't map to FTS columns.
+        const extraWhere = [];
+        const extraParams = [];
+        // Parse a "1d", "1w", "2024-01-15", "yesterday", "today" etc. into ms epoch.
+        const parseRel = (s) => {
+            const lower = s.toLowerCase().trim();
+            if (lower === "today") {
+                const d = new Date();
+                d.setHours(0, 0, 0, 0);
+                return d.getTime();
+            }
+            if (lower === "yesterday") {
+                const d = new Date();
+                d.setHours(0, 0, 0, 0);
+                return d.getTime() - 86400_000;
+            }
+            const rel = lower.match(/^(\d+)([dwmy])$/);
+            if (rel) {
+                const n = parseInt(rel[1]);
+                const unit = rel[2];
+                const ms = unit === "d" ? n * 86400_000
+                    : unit === "w" ? n * 7 * 86400_000
+                        : unit === "m" ? n * 30 * 86400_000
+                            : n * 365 * 86400_000;
+                return Date.now() - ms;
+            }
+            const ts = Date.parse(s);
+            return isNaN(ts) ? null : ts;
+        };
         for (const part of parts) {
             const fromMatch = part.match(/^from:(.+)$/i);
             const toMatch = part.match(/^to:(.+)$/i);
             const subjectMatch = part.match(/^subject:(.+)$/i);
+            const dateMatch = part.match(/^date:([><]?=?)(.+)$/i);
+            const afterMatch = part.match(/^after:(.+)$/i);
+            const beforeMatch = part.match(/^before:(.+)$/i);
+            const hasMatch = part.match(/^has:(.+)$/i);
+            const isMatch = part.match(/^is:(.+)$/i);
+            const folderMatch = part.match(/^folder:(.+)$/i);
             if (fromMatch) {
                 const term = fromMatch[1].replace(/"/g, "");
                 ftsQuery += `(from_name:${term} OR from_address:${term}) `;
@@ -611,10 +682,51 @@ export class MailxDB {
                 const term = subjectMatch[1].replace(/"/g, "");
                 ftsQuery += `subject:${term} `;
             }
+            else if (dateMatch || afterMatch || beforeMatch) {
+                const op = dateMatch ? (dateMatch[1] || "=") : (afterMatch ? ">" : "<");
+                const valStr = dateMatch ? dateMatch[2] : (afterMatch ? afterMatch[1] : beforeMatch[1]);
+                const ts = parseRel(valStr.replace(/"/g, ""));
+                if (ts !== null) {
+                    if (op === ">" || op === ">=") {
+                        extraWhere.push("m.date >= ?");
+                        extraParams.push(ts);
+                    }
+                    else if (op === "<" || op === "<=") {
+                        extraWhere.push("m.date <= ?");
+                        extraParams.push(ts);
+                    }
+                    else {
+                        extraWhere.push("m.date >= ? AND m.date < ?");
+                        extraParams.push(ts, ts + 86400_000);
+                    }
+                }
+            }
+            else if (hasMatch) {
+                const v = hasMatch[1].toLowerCase().replace(/"/g, "");
+                if (v === "attachment" || v === "attachments") {
+                    extraWhere.push("m.has_attachments = 1");
+                }
+            }
+            else if (isMatch) {
+                const v = isMatch[1].toLowerCase().replace(/"/g, "");
+                if (v === "flagged" || v === "starred")
+                    extraWhere.push("m.flags_json LIKE '%\\\\Flagged%'");
+                else if (v === "unread")
+                    extraWhere.push("m.flags_json NOT LIKE '%\\\\Seen%'");
+                else if (v === "read" || v === "seen")
+                    extraWhere.push("m.flags_json LIKE '%\\\\Seen%'");
+                else if (v === "answered")
+                    extraWhere.push("m.flags_json LIKE '%\\\\Answered%'");
+                else if (v === "draft")
+                    extraWhere.push("m.flags_json LIKE '%\\\\Draft%'");
+            }
+            else if (folderMatch) {
+                const v = folderMatch[1].replace(/"/g, "");
+                extraWhere.push("LOWER(f.name) LIKE ?");
+                extraParams.push(`%${v.toLowerCase()}%`);
+            }
             else {
                 // Unqualified — search everything.
-                // Support "term1|term2" (regex OR) by converting to FTS5 OR.
-                // Strip surrounding /.../ if user typed regex delimiters.
                 let term = part.replace(/^\/|\/$/g, "");
                 if (term.includes("|")) {
                     const alts = term.split("|").filter(Boolean).map(t => `${t}*`).join(" OR ");
@@ -626,8 +738,10 @@ export class MailxDB {
             }
         }
         ftsQuery = ftsQuery.trim();
+        // If the user typed only qualifier-only terms (e.g. "is:flagged after:1w"),
+        // FTS query is empty — match-all surrogate.
         if (!ftsQuery)
-            return { items: [], total: 0, page, pageSize };
+            ftsQuery = "*";
         const offset = (page - 1) * pageSize;
         try {
             let scopeWhere = "";
@@ -640,6 +754,10 @@ export class MailxDB {
                 scopeWhere = " AND m.account_id = ?";
                 scopeParams.push(accountId);
             }
+            if (extraWhere.length > 0) {
+                scopeWhere += " AND " + extraWhere.join(" AND ");
+                scopeParams.push(...extraParams);
+            }
             const countRow = this.db.prepare(`SELECT COUNT(*) as cnt FROM messages m JOIN messages_fts fts ON m.id = fts.rowid WHERE messages_fts MATCH ?${scopeWhere}`).get(ftsQuery, ...scopeParams);
             const total = countRow?.cnt || 0;
             const rows = this.db.prepare(`SELECT m.*, f.name AS folder_name FROM messages m

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

@@ -35,6 +35,7 @@ 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. */
 }
 /** Standard IMAP special-use folder types */
 export type SpecialUse = "inbox" | "sent" | "drafts" | "trash" | "junk" | "archive" | "all";