@bobfrankston/mailx 1.0.340 → 1.0.349

package/packages/mailx-service/index.js

@@ -413,6 +413,83 @@ export class MailxService {
     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();
     }
@@ -617,22 +694,19 @@ 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) {
-        // 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;
-        if (!spamPath)
-            throw new Error(`Account ${accountId} has no "spam" folder configured`);
+        // The spam folder is whatever the provider's getSpecialFolders() said
+        // it is. iflow-direct's compat client fills this in from RFC 6154
+        // \Junk / \Spam flags (with sensible defaults if the server doesn't
+        // advertise them); Gmail has SPAM built in. mailx stores the result
+        // as `specialUse: "junk"` on the matching folder row.
+        //
+        // Earlier versions required an explicit `spam:` field in accounts.jsonc
+        // and the button erroring out when that was absent. That's obsolete —
+        // the provider knows where spam goes. Just look up the flagged folder.
         const folders = this.db.getFolders(accountId);
-        const target = folders.find(f => f.path.toLowerCase() === spamPath.toLowerCase());
+        const target = folders.find(f => f.specialUse === "junk");
         if (!target)
-            throw new Error(`Spam folder "${spamPath}" not found in ${accountId}`);
+            throw new Error(`No \\Junk/\\Spam folder found for ${accountId}`);
         await this.moveMessages(accountId, uids, target.id);
         return { targetFolderId: target.id, moved: uids.length };
     }
@@ -853,6 +927,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 };
@@ -91,6 +96,10 @@ async function dispatchAction(svc, action, p) {
             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
@@ -100,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";