@bobfrankston/mailx-imap 0.1.58 → 0.1.60

package/index.d.ts

@@ -491,6 +491,41 @@ export declare class ImapManager extends EventEmitter {
     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

@@ -2597,6 +2597,14 @@ export class ImapManager extends EventEmitter {
      *  the user clicked, they're waiting, this jumps ahead of any background
      *  prefetch sitting in the slow lane. */
     async fetchMessageBody(accountId, folderId, uid) {
+        // Belt-and-braces against `UID FETCH 0`. The IMAP server rejects it as
+        // BAD "Invalid uidset" and the connection slot is consumed for the
+        // round-trip. The enqueue path now guards too — this catches direct
+        // callers that bypass the queue (Bob 2026-05-25).
+        if (!uid || !Number.isFinite(uid) || uid <= 0) {
+            console.error(`[imap] fetchMessageBody rejected invalid uid=${uid} for ${accountId}/folder${folderId}`);
+            return null;
+        }
         const envelope = this.db.getMessageByUid(accountId, uid, folderId);
         let storedPath = envelope?.bodyPath || "";
         if (!storedPath)
@@ -4371,6 +4379,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.58",
+  "version": "0.1.60",
   "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.36",
     "@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.36",
       "@bobfrankston/iflow-direct": "^0.1.50",
       "@bobfrankston/tcp-transport": "^0.1.6",
       "@bobfrankston/smtp-direct": "^0.1.8",