@bobfrankston/mailx-imap 0.1.23 → 0.1.25

package/index.d.ts

@@ -5,7 +5,7 @@
  */
 import type { TransportFactory } from "@bobfrankston/tcp-transport";
 import { MailxDB, FileMessageStore } from "@bobfrankston/mailx-store";
-import type { AccountConfig, MessageEnvelope, EmailAddress, Folder } from "@bobfrankston/mailx-types";
+import type { AccountConfig, MessageEnvelope, Folder } from "@bobfrankston/mailx-types";
 import { EventEmitter } from "node:events";
 /** Events emitted by the IMAP manager */
 export interface ImapManagerEvents {
@@ -336,31 +336,6 @@ export declare class ImapManager extends EventEmitter {
     processSyncActions(accountId: string): Promise<void>;
     /** Find a folder by specialUse, case-insensitive */
     private findFolder;
-    /** Optimistic local-first Sent insert: write a row into the local DB's
-     *  Sent folder the moment the user hits Send, so the list reflects it
-     *  immediately instead of waiting for SMTP + IMAP-APPEND + syncFolder
-     *  (five server round-trips against a Dovecot that caps at 20 conns).
-     *
-     *  Uses a synthetic negative UID so it can't collide with a real APPENDUID
-     *  (which is always positive). When the real sync eventually picks the
-     *  message up in Sent with the server's UID, `db.upsertMessage` spots
-     *  the Message-ID match and rebinds the existing row's UID — no duplicate.
-     *  Negative UID also makes the row render pink (getMessages flags uid<0
-     *  as pending) so the user sees it's not-yet-reconciled.
-     *
-     *  Best-effort — any failure path (no Sent folder yet, parse error, store
-     *  write error) is logged and swallowed; the send itself is unaffected. */
-    insertOptimisticSentRow(accountId: string, envelope: {
-        messageId: string;
-        inReplyTo: string;
-        references: string[];
-        subject: string;
-        from: EmailAddress;
-        to: EmailAddress[];
-        cc: EmailAddress[];
-        bcc: EmailAddress[];
-        date: number;
-    }, rawMessage: string): Promise<void>;
     /** Copy sent message to the Sent folder via IMAP APPEND */
     copyToSent(accountId: string, rawMessage: string | Buffer): Promise<void>;
     /** Save a draft to the Drafts folder via IMAP APPEND.

package/index.js

@@ -874,7 +874,9 @@ export class ImapManager extends EventEmitter {
         if (!folder)
             throw new Error(`Folder ${folderId} not found`);
         this.emit("syncProgress", accountId, `sync:${folder.path}`, 0);
-        // Get the highest UID we already have for this folder
+        // Get the highest UID we already have for this folder. IMAP UIDs are
+        // monotonically increasing within a UIDVALIDITY (RFC 3501); a
+        // high-water mark is the right anchor for incremental fetch.
         const highestUid = this.db.getHighestUid(accountId, folderId);
         console.log(`  [sync] ${accountId}/${folder.path}: highestUid=${highestUid}, fetching...`);
         let messages;
@@ -1871,19 +1873,70 @@ export class ImapManager extends EventEmitter {
                 // is parked in IDLE, it's unusable for any other command, so
                 // it can't share the ops queue. Counts against the per-host
                 // semaphore (one slot for the IDLE socket).
-                const watchClient = await this.createClient(accountId, "idle");
-                const stop = await watchClient.watchMailbox("INBOX", (newCount) => {
-                    console.log(`  [idle] ${accountId}: ${newCount} new message(s)`);
-                    // Fetch only the new UIDs — the heavyweight gap/reconcile
-                    // path runs on the 5-minute STATUS poll, so EXISTS lands
-                    // in the UI in roughly one round-trip.
-                    this.syncInboxNewOnly(accountId).catch(e => console.error(`  [idle] sync error: ${e.message}`));
-                });
+                //
+                // We watch INBOX (incoming mail) and Sent + Drafts (outgoing
+                // changes from another client — Thunderbird, phone, web).
+                // Without IDLE on Sent, a message just sent from another
+                // device would only show in mailx after the next periodic
+                // full sync.
+                const stops = [];
+                const clients = [];
+                const watchOne = async (mailboxLabel, path) => {
+                    const client = await this.createClient(accountId, "idle");
+                    clients.push(client);
+                    const stop = await client.watchMailbox(path, (newCount) => {
+                        console.log(`  [idle] ${accountId} ${path}: ${newCount} new message(s)`);
+                        if (mailboxLabel === "inbox") {
+                            // Fast path: incremental fetch of NEW UIDs only.
+                            // Heavy reconcile runs on the 5-minute STATUS poll.
+                            this.syncInboxNewOnly(accountId).catch(e => console.error(`  [idle] inbox sync error: ${e.message}`));
+                        }
+                        else {
+                            // Sent / Drafts changed elsewhere. Use the
+                            // standard folder sync — picks up the new UID,
+                            // rebinds any optimistic local row by Message-ID.
+                            const folder = this.findFolder(accountId, mailboxLabel);
+                            if (folder) {
+                                this.syncFolder(accountId, folder.id).catch(e => console.error(`  [idle] ${path} sync error: ${e.message}`));
+                            }
+                        }
+                    });
+                    stops.push(stop);
+                };
+                await watchOne("inbox", "INBOX");
+                const sent = this.findFolder(accountId, "sent");
+                if (sent) {
+                    try {
+                        await watchOne("sent", sent.path);
+                    }
+                    catch (e) {
+                        console.error(`  [idle] Failed to watch ${sent.path}: ${e.message}`);
+                    }
+                }
+                const drafts = this.findFolder(accountId, "drafts");
+                if (drafts) {
+                    try {
+                        await watchOne("drafts", drafts.path);
+                    }
+                    catch (e) {
+                        console.error(`  [idle] Failed to watch ${drafts.path}: ${e.message}`);
+                    }
+                }
                 this.watchers.set(accountId, async () => {
-                    await stop();
-                    await watchClient.logout();
+                    for (const stop of stops) {
+                        try {
+                            await stop();
+                        }
+                        catch { /* ignore */ }
+                    }
+                    for (const c of clients) {
+                        try {
+                            await c.logout();
+                        }
+                        catch { /* ignore */ }
+                    }
                 });
-                console.log(`  [idle] Watching INBOX for ${accountId}`);
+                console.log(`  [idle] Watching INBOX${sent ? "+Sent" : ""}${drafts ? "+Drafts" : ""} for ${accountId}`);
             }
             catch (e) {
                 console.error(`  [idle] Failed to watch ${accountId}: ${e.message}`);
@@ -2565,64 +2618,10 @@ export class ImapManager extends EventEmitter {
         return folders.find(f => f.specialUse === specialUse ||
             f.path.toLowerCase() === specialUse.toLowerCase()) || null;
     }
-    /** Optimistic local-first Sent insert: write a row into the local DB's
-     *  Sent folder the moment the user hits Send, so the list reflects it
-     *  immediately instead of waiting for SMTP + IMAP-APPEND + syncFolder
-     *  (five server round-trips against a Dovecot that caps at 20 conns).
-     *
-     *  Uses a synthetic negative UID so it can't collide with a real APPENDUID
-     *  (which is always positive). When the real sync eventually picks the
-     *  message up in Sent with the server's UID, `db.upsertMessage` spots
-     *  the Message-ID match and rebinds the existing row's UID — no duplicate.
-     *  Negative UID also makes the row render pink (getMessages flags uid<0
-     *  as pending) so the user sees it's not-yet-reconciled.
-     *
-     *  Best-effort — any failure path (no Sent folder yet, parse error, store
-     *  write error) is logged and swallowed; the send itself is unaffected. */
-    async insertOptimisticSentRow(accountId, envelope, rawMessage) {
-        try {
-            const sent = this.findFolder(accountId, "sent");
-            if (!sent) {
-                console.log(`  [sent-local] no Sent folder for ${accountId}; skipping optimistic row`);
-                return;
-            }
-            // Synthetic UID — negative ms timestamp is monotonic + won't
-            // collide with server UIDs. When the real APPENDUID returns via
-            // sync, upsertMessage's Message-ID rebind swaps this for the
-            // real positive value.
-            const synthUid = -Date.now();
-            const bodyPath = await this.bodyStore.putMessage(accountId, sent.id, synthUid, Buffer.from(rawMessage, "utf-8"));
-            const parsed = await extractPreview(rawMessage);
-            this.db.upsertMessage({
-                accountId,
-                folderId: sent.id,
-                uid: synthUid,
-                messageId: envelope.messageId,
-                inReplyTo: envelope.inReplyTo,
-                references: envelope.references,
-                date: envelope.date,
-                subject: envelope.subject,
-                from: envelope.from,
-                to: envelope.to,
-                cc: envelope.cc,
-                flags: ["\\Seen"],
-                size: rawMessage.length,
-                hasAttachments: parsed.hasAttachments,
-                preview: parsed.preview,
-                bodyPath,
-            });
-            // Folder-tree badge refresh + message-list reload if the user
-            // is currently on Sent — same event the sync path emits.
-            this.db.recalcFolderCounts(sent.id);
-            this.emit("folderCountsChanged", { accountId, folderId: sent.id });
-            console.log(`  [sent-local] wrote optimistic row in Sent (uid=${synthUid}) for ${accountId}: ${envelope.subject}`);
-        }
-        catch (e) {
-            // Non-fatal — send continues, Sent folder just won't show the
-            // row until the real APPEND-then-sync cycle completes.
-            console.error(`  [sent-local] optimistic insert failed: ${e?.message || e}`);
-        }
-    }
+    // insertOptimisticSentRow removed — the synthetic-negative-UID hack
+    // wedged Sent's high-water-mark sync (a synthetic value polluted MAX(uid)
+    // and made every Sent fetch take a stale code path). Sent is now what
+    // the server has, period. Pending sends live in the Outbox view.
     /** Copy sent message to the Sent folder via IMAP APPEND */
     async copyToSent(accountId, rawMessage) {
         const sent = this.findFolder(accountId, "sent");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -10,8 +10,8 @@
   "license": "ISC",
   "dependencies": {
     "@bobfrankston/mailx-types": "^0.1.10",
-    "@bobfrankston/mailx-settings": "^0.1.11",
-    "@bobfrankston/mailx-store": "^0.1.9",
+    "@bobfrankston/mailx-settings": "^0.1.13",
+    "@bobfrankston/mailx-store": "^0.1.10",
     "@bobfrankston/iflow-direct": "^0.1.30",
     "@bobfrankston/tcp-transport": "^0.1.5",
     "@bobfrankston/smtp-direct": "^0.1.5",
@@ -38,8 +38,8 @@
   ".transformedSnapshot": {
     "dependencies": {
       "@bobfrankston/mailx-types": "^0.1.10",
-      "@bobfrankston/mailx-settings": "^0.1.11",
-      "@bobfrankston/mailx-store": "^0.1.9",
+      "@bobfrankston/mailx-settings": "^0.1.13",
+      "@bobfrankston/mailx-store": "^0.1.10",
       "@bobfrankston/iflow-direct": "^0.1.30",
       "@bobfrankston/tcp-transport": "^0.1.5",
       "@bobfrankston/smtp-direct": "^0.1.5",