@bobfrankston/mailx-imap 0.1.57 → 0.1.59

package/index.d.ts

@@ -473,9 +473,59 @@ export declare class ImapManager extends EventEmitter {
     /** Start background Outbox worker — runs immediately then every 10 seconds */
     private outboxBackoff;
     private outboxBackoffDelay;
+    /** Route a file dropped into the general `~/.rmfmail/outbox/` (no acct
+     *  subdir) to one of the configured accounts. Match order:
+     *   1. `From:` address matches an `account.email` exactly (case-insensitive).
+     *   2. `From:` domain matches a known-provider domain → first account whose
+     *      domain matches (gmail.com / googlemail.com → first Gmail account;
+     *      outlook.com / hotmail.com / live.com → first Outlook account).
+     *   3. Default = first account with an explicit IMAP override host (i.e.,
+     *      not one of the known providers). Bob's bobma is the prototype.
+     *  Returns the routed accountId or null if no candidate exists. */
+    private routeGeneralOutboxFile;
+    /** Scan the general outbox (`~/.rmfmail/outbox/*.ltr|*.eml` — no acct
+     *  subdir) and route each file into the appropriate per-account dir. Runs
+     *  once per outboxLoop tick before the per-account sweep, so a file
+     *  manually dropped at the root gets handed off the same tick. */
+    private routeGeneralOutbox;
     startOutboxWorker(): void;
     /** Stop Outbox worker */
     stopOutboxWorker(): void;
+    /** Periodic Sent sweep — reconciles optimistic local-inserts against
+     *  the server's actual Sent folder for every IMAP-path account.
+     *
+     *  Why: when a message is sent on an IMAP account, the local DB row is
+     *  inserted with a PREDICTED UID (the Sent folder's UIDNEXT at submit
+     *  time). The submission server's drain-Outbox sieve appends the real
+     *  Sent copy at whatever UID it chooses, which may differ if anything
+     *  else raced — another client, a sieve append from a different rule,
+     *  or just the sieve picking its own UID. Without reconciliation:
+     *    - On the next set-diff sync the local row's UID doesn't match
+     *      any server UID → set-diff deletes it → "Sent copy missing".
+     *    - Or the server's actual Sent copy gets reconciled as a NEW row
+     *      → duplicate in the user's Sent view.
+     *
+     *  What this sweep does:
+     *    For each IMAP-path account, walk local Sent rows newer than
+     *    SENT_SWEEP_WINDOW_MS, query the server's Sent folder by
+     *    Message-ID, and:
+     *      - if found at the local-known UID → no-op
+     *      - if found at a different UID → rebind the local row to the
+     *        real UID
+     *      - if not found and the .eml is on disk → IMAP APPEND it
+     *        from disk (no SMTP)
+     *      - if not found and no .eml → leave it (set-diff will GC; the
+     *        user has bigger problems than the Sent reconcile)
+     *
+     *  Gmail-path accounts: skipped. Gmail's Sent is API-driven, the
+     *  optimistic-insert path doesn't apply (gmail-api writes the row
+     *  directly post-send with the real Gmail message ID, no UID race). */
+    private sentSweepInterval;
+    private readonly SENT_SWEEP_WINDOW_MS;
+    private readonly SENT_SWEEP_INTERVAL_MS;
+    startSentSweep(): void;
+    stopSentSweep(): void;
+    private sweepSentOnce;
     private configWatchers;
     private cloudPollTimers;
     /** Watch the local config files for external changes. On change, emit

package/index.js

@@ -4213,11 +4213,113 @@ export class ImapManager extends EventEmitter {
     /** Start background Outbox worker — runs immediately then every 10 seconds */
     outboxBackoff = new Map(); // accountId → next retry timestamp
     outboxBackoffDelay = new Map(); // accountId → current delay ms
+    /** Route a file dropped into the general `~/.rmfmail/outbox/` (no acct
+     *  subdir) to one of the configured accounts. Match order:
+     *   1. `From:` address matches an `account.email` exactly (case-insensitive).
+     *   2. `From:` domain matches a known-provider domain → first account whose
+     *      domain matches (gmail.com / googlemail.com → first Gmail account;
+     *      outlook.com / hotmail.com / live.com → first Outlook account).
+     *   3. Default = first account with an explicit IMAP override host (i.e.,
+     *      not one of the known providers). Bob's bobma is the prototype.
+     *  Returns the routed accountId or null if no candidate exists. */
+    routeGeneralOutboxFile(filePath) {
+        let raw = "";
+        try {
+            raw = fs.readFileSync(filePath, "utf-8");
+        }
+        catch {
+            return null;
+        }
+        const fromMatch = raw.match(/^From:\s*(?:[^<\n]*<\s*)?([^\s<>@]+@[^\s<>]+)/mi);
+        const fromAddr = (fromMatch?.[1] || "").toLowerCase().replace(/[>\s].*$/, "");
+        const fromDomain = fromAddr.split("@")[1] || "";
+        const settings = loadSettings();
+        const accounts = settings.accounts || [];
+        // 1. exact email match
+        if (fromAddr) {
+            const m = accounts.find(a => (a.email || "").toLowerCase() === fromAddr);
+            if (m)
+                return m.id;
+        }
+        // 2. known-provider domain match
+        const GMAIL_DOMAINS = new Set(["gmail.com", "googlemail.com"]);
+        const OUTLOOK_DOMAINS = new Set(["outlook.com", "hotmail.com", "live.com", "msn.com"]);
+        if (fromDomain) {
+            if (GMAIL_DOMAINS.has(fromDomain)) {
+                const m = accounts.find(a => GMAIL_DOMAINS.has((a.email || "").split("@")[1]?.toLowerCase() || ""));
+                if (m)
+                    return m.id;
+            }
+            if (OUTLOOK_DOMAINS.has(fromDomain)) {
+                const m = accounts.find(a => OUTLOOK_DOMAINS.has((a.email || "").split("@")[1]?.toLowerCase() || ""));
+                if (m)
+                    return m.id;
+            }
+        }
+        // 3. default: first account on a non-known-provider domain (i.e. one
+        // whose IMAP host was explicitly configured rather than auto-detected).
+        const KNOWN_PROVIDER_DOMAINS = new Set([
+            ...GMAIL_DOMAINS, ...OUTLOOK_DOMAINS,
+            "yahoo.com", "aol.com", "icloud.com", "me.com", "mac.com",
+        ]);
+        const override = accounts.find(a => {
+            const d = (a.email || "").split("@")[1]?.toLowerCase() || "";
+            return d && !KNOWN_PROVIDER_DOMAINS.has(d);
+        });
+        if (override)
+            return override.id;
+        // Last resort — any account at all
+        return accounts[0]?.id || null;
+    }
+    /** Scan the general outbox (`~/.rmfmail/outbox/*.ltr|*.eml` — no acct
+     *  subdir) and route each file into the appropriate per-account dir. Runs
+     *  once per outboxLoop tick before the per-account sweep, so a file
+     *  manually dropped at the root gets handed off the same tick. */
+    routeGeneralOutbox() {
+        const root = path.join(getConfigDir(), "outbox");
+        if (!fs.existsSync(root))
+            return;
+        let entries = [];
+        try {
+            entries = fs.readdirSync(root, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            if (!ent.isFile())
+                continue;
+            if (!/\.(ltr|eml)$/i.test(ent.name))
+                continue;
+            const filePath = path.join(root, ent.name);
+            const accountId = this.routeGeneralOutboxFile(filePath);
+            if (!accountId) {
+                console.error(`  [outbox] No account candidate for ${ent.name} — leaving in general outbox`);
+                continue;
+            }
+            const acctDir = path.join(root, accountId);
+            try {
+                fs.mkdirSync(acctDir, { recursive: true });
+            }
+            catch { /* */ }
+            try {
+                fs.renameSync(filePath, path.join(acctDir, ent.name));
+                console.log(`  [outbox] Routed ${ent.name} → ${accountId}/`);
+            }
+            catch (e) {
+                console.error(`  [outbox] Failed to route ${ent.name}: ${e.message}`);
+            }
+        }
+    }
     startOutboxWorker() {
         if (this.outboxInterval)
             return;
         const processAll = async () => {
             const now = Date.now();
+            // Auto-route any files dropped into the general (acct-agnostic)
+            // outbox — they move into `outbox/<accountId>/` before the
+            // per-account sweep picks them up below.
+            this.routeGeneralOutbox();
             for (const [accountId] of this.configs) {
                 // Skip accounts in backoff
                 const retryAfter = this.outboxBackoff.get(accountId) || 0;
@@ -4269,6 +4371,126 @@ export class ImapManager extends EventEmitter {
             this.outboxInterval = null;
         }
     }
+    /** Periodic Sent sweep — reconciles optimistic local-inserts against
+     *  the server's actual Sent folder for every IMAP-path account.
+     *
+     *  Why: when a message is sent on an IMAP account, the local DB row is
+     *  inserted with a PREDICTED UID (the Sent folder's UIDNEXT at submit
+     *  time). The submission server's drain-Outbox sieve appends the real
+     *  Sent copy at whatever UID it chooses, which may differ if anything
+     *  else raced — another client, a sieve append from a different rule,
+     *  or just the sieve picking its own UID. Without reconciliation:
+     *    - On the next set-diff sync the local row's UID doesn't match
+     *      any server UID → set-diff deletes it → "Sent copy missing".
+     *    - Or the server's actual Sent copy gets reconciled as a NEW row
+     *      → duplicate in the user's Sent view.
+     *
+     *  What this sweep does:
+     *    For each IMAP-path account, walk local Sent rows newer than
+     *    SENT_SWEEP_WINDOW_MS, query the server's Sent folder by
+     *    Message-ID, and:
+     *      - if found at the local-known UID → no-op
+     *      - if found at a different UID → rebind the local row to the
+     *        real UID
+     *      - if not found and the .eml is on disk → IMAP APPEND it
+     *        from disk (no SMTP)
+     *      - if not found and no .eml → leave it (set-diff will GC; the
+     *        user has bigger problems than the Sent reconcile)
+     *
+     *  Gmail-path accounts: skipped. Gmail's Sent is API-driven, the
+     *  optimistic-insert path doesn't apply (gmail-api writes the row
+     *  directly post-send with the real Gmail message ID, no UID race). */
+    sentSweepInterval = null;
+    SENT_SWEEP_WINDOW_MS = 60 * 60 * 1000; // 1 hour
+    SENT_SWEEP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+    startSentSweep() {
+        if (this.sentSweepInterval)
+            return;
+        const tick = async () => {
+            for (const [accountId] of this.configs) {
+                if (this.isGmailAccount(accountId))
+                    continue;
+                try {
+                    await this.sweepSentOnce(accountId);
+                }
+                catch (e) {
+                    console.error(`  [sent-sweep] ${accountId}: ${e?.message || e}`);
+                }
+            }
+        };
+        // First tick deferred 30 s so it doesn't race the daemon's
+        // boot-time sync. Subsequent ticks every SENT_SWEEP_INTERVAL_MS.
+        setTimeout(() => { tick().catch(() => { }); }, 30_000);
+        this.sentSweepInterval = setInterval(() => { tick().catch(() => { }); }, this.SENT_SWEEP_INTERVAL_MS);
+    }
+    stopSentSweep() {
+        if (this.sentSweepInterval) {
+            clearInterval(this.sentSweepInterval);
+            this.sentSweepInterval = null;
+        }
+    }
+    async sweepSentOnce(accountId) {
+        const sent = this.findFolder(accountId, "sent");
+        if (!sent)
+            return;
+        // Pull recent local rows. Restrict to (a) account+folder, (b) cached
+        // in the last hour, (c) have a message_id (no MID = can't reconcile).
+        const cutoff = Date.now() - this.SENT_SWEEP_WINDOW_MS;
+        const rows = this.db.getRecentMessagesByCachedAt(accountId, sent.id, cutoff);
+        if (rows.length === 0)
+            return;
+        let reconciled = 0;
+        let appended = 0;
+        await this.withConnection(accountId, async (client) => {
+            for (const row of rows) {
+                const msgId = row.message_id;
+                if (!msgId)
+                    continue;
+                let serverUids = [];
+                try {
+                    serverUids = await client.searchByHeader(sent.path, "Message-ID", msgId);
+                }
+                catch (e) {
+                    console.error(`  [sent-sweep] searchByHeader ${msgId}: ${e?.message || e}`);
+                    continue;
+                }
+                if (serverUids.length === 0) {
+                    // Not on server. Re-APPEND from .eml if we have one.
+                    if (!row.body_path)
+                        continue;
+                    try {
+                        const buf = await this.bodyStore.readByPath(row.body_path);
+                        if (!buf)
+                            continue;
+                        await client.appendMessage(sent.path, buf, ["\\Seen"]);
+                        appended++;
+                        console.log(`  [sent-sweep] ${accountId}: re-APPENDed ${msgId} (was missing on server)`);
+                    }
+                    catch (e) {
+                        console.error(`  [sent-sweep] APPEND ${msgId}: ${e?.message || e}`);
+                    }
+                }
+                else if (!serverUids.includes(row.uid)) {
+                    // Server has it under a different UID — rebind local row by
+                    // patching the messages.uid in place. Cheap, no upsert
+                    // shuffle, no audit-trail noise.
+                    const realUid = serverUids[serverUids.length - 1];
+                    try {
+                        this.db.updateMessageUid?.(accountId, sent.id, row.uid, realUid);
+                        reconciled++;
+                        console.log(`  [sent-sweep] ${accountId}: rebound ${msgId} ${row.uid} → ${realUid}`);
+                    }
+                    catch (e) {
+                        console.error(`  [sent-sweep] rebind ${msgId}: ${e?.message || e}`);
+                    }
+                }
+            }
+        }, { slow: true, timeoutMs: 120_000 });
+        if (reconciled + appended > 0) {
+            this.emit("folderCountsChanged", accountId, {});
+            console.log(`  [sent-sweep] ${accountId}: ${reconciled} rebound, ${appended} re-appended`);
+        }
+    }
     // ── Config file watcher ──
     configWatchers = [];
     cloudPollTimers = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.57",
+  "version": "0.1.59",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -11,7 +11,7 @@
   "dependencies": {
     "@bobfrankston/mailx-types": "^0.1.18",
     "@bobfrankston/mailx-settings": "^0.1.22",
-    "@bobfrankston/mailx-store": "^0.1.34",
+    "@bobfrankston/mailx-store": "^0.1.35",
     "@bobfrankston/iflow-direct": "^0.1.50",
     "@bobfrankston/tcp-transport": "^0.1.6",
     "@bobfrankston/smtp-direct": "^0.1.8",
@@ -39,7 +39,7 @@
     "dependencies": {
       "@bobfrankston/mailx-types": "^0.1.18",
       "@bobfrankston/mailx-settings": "^0.1.22",
-      "@bobfrankston/mailx-store": "^0.1.34",
+      "@bobfrankston/mailx-store": "^0.1.35",
       "@bobfrankston/iflow-direct": "^0.1.50",
       "@bobfrankston/tcp-transport": "^0.1.6",
       "@bobfrankston/smtp-direct": "^0.1.8",