@bobfrankston/mailx-imap 0.1.22 → 0.1.24

package/index.d.ts

@@ -239,6 +239,10 @@ export declare class ImapManager extends EventEmitter {
     quickInboxCheck(): Promise<void>;
     /** Start periodic sync */
     startPeriodicSync(intervalMinutes: number): void;
+    /** One-shot full sync + IDLE restart. Public so callers (Reconciler,
+     *  user-initiated "Sync now") can fire it on demand. The original body
+     *  that lived inline in startPeriodicSync was lifted verbatim. */
+    runFullSync(): Promise<void>;
     /** Stop periodic sync */
     stopPeriodicSync(): void;
     /** Check if an account is OAuth (Gmail/Outlook — generous connection limits) */
@@ -292,7 +296,11 @@ export declare class ImapManager extends EventEmitter {
     private shouldSkipFolder;
     private recordFolderError;
     private clearFolderErrors;
-    private prefetchBodies;
+    /** Background body-cache backfill. Public so the Reconciler can schedule
+     *  the periodic tick under its priority/back-pressure rules; existing
+     *  in-method post-sync nudges (sync, fetchSince, fetchOne) call this
+     *  too and the per-account `prefetchingAccounts` set deduplicates. */
+    prefetchBodies(accountId: string): Promise<void>;
     private _prefetchBodies;
     /** Get the body store for direct access */
     getBodyStore(): FileMessageStore;

package/index.js

@@ -1825,47 +1825,30 @@ export class ImapManager extends EventEmitter {
             }
         }, 30000);
         this.syncIntervals.set("actions", actionsInterval);
-        // Body prefetch as a first-class background task — independent of
-        // sync success. Prefetch was previously only triggered from inside
-        // sync, so any account with slow/failing IMAP had its "not downloaded"
-        // dots stuck forever even though body fetches use a separate
-        // connection that might succeed. Every 60s, for every account, fire
-        // prefetchBodies() (cheap when body_path is already populated — just a
-        // DB query that returns 0 rows; the prefetchingAccounts guard
-        // short-circuits concurrent triggers).
-        if (getPrefetch()) {
-            const kickPrefetch = () => {
-                for (const [accountId] of this.configs) {
-                    this.prefetchBodies(accountId).catch(e => console.error(`  [prefetch] ${accountId}: ${e?.message || e}`));
-                }
-            };
-            // Fire once now so the "not downloaded" dots start filling in
-            // immediately on app start, don't make the user wait a minute.
-            setTimeout(kickPrefetch, 2000);
-            const prefetchInterval = setInterval(kickPrefetch, 60000);
-            this.syncIntervals.set("prefetch", prefetchInterval);
-            console.log(`  [periodic] body prefetch every 60s (independent of sync)`);
-        }
-        // Tombstone prune: age out local-delete records older than 30 days.
-        // Runs hourly — cheap (one indexed DELETE).
-        const TOMBSTONE_RETENTION_DAYS = 30;
-        const pruneTombstones = () => {
-            const cutoff = Date.now() - TOMBSTONE_RETENTION_DAYS * 86400_000;
-            const n = this.db.pruneTombstones(cutoff);
-            if (n > 0)
-                console.log(`  [tombstones] pruned ${n} older than ${TOMBSTONE_RETENTION_DAYS} days`);
-        };
-        setTimeout(pruneTombstones, 30_000); // first run after startup settles
-        this.syncIntervals.set("tombstone-prune", setInterval(pruneTombstones, 3600_000));
-        // Full sync (all folders + IDLE restart) at configured interval
-        const fullInterval = setInterval(async () => {
-            console.log(`  [periodic] Full sync at ${new Date().toLocaleTimeString()}`);
-            await this.syncAll();
-            await this.stopWatching();
-            await this.startWatching();
+        // Body prefetch + tombstone prune moved to Reconciler.start —
+        // prefetch needs back-pressure from the body-fetch lane, and
+        // tombstone prune is pure DB bookkeeping with no IMAP coupling.
+        // Quick STATUS check (above) and actions/outbox drain (above)
+        // stay here because they're tightly tied to IMAP connection state
+        // and the `syncing` flag.
+        // Full sync (all folders + IDLE restart) at configured interval.
+        // Stays here because callers pass `intervalMinutes` directly —
+        // moving it would mean threading the value through MailxService
+        // → Reconciler with a separate setter, for no behavior gain.
+        const fullInterval = setInterval(() => {
+            this.runFullSync().catch(e => console.error(`  [periodic] full sync error: ${e?.message || e}`));
         }, intervalMinutes * 60000);
         this.syncIntervals.set("all", fullInterval);
     }
+    /** One-shot full sync + IDLE restart. Public so callers (Reconciler,
+     *  user-initiated "Sync now") can fire it on demand. The original body
+     *  that lived inline in startPeriodicSync was lifted verbatim. */
+    async runFullSync() {
+        console.log(`  [periodic] Full sync at ${new Date().toLocaleTimeString()}`);
+        await this.syncAll();
+        await this.stopWatching();
+        await this.startWatching();
+    }
     /** Stop periodic sync */
     stopPeriodicSync() {
         for (const [key, interval] of this.syncIntervals) {
@@ -1888,19 +1871,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}`);
@@ -2065,6 +2099,10 @@ export class ImapManager extends EventEmitter {
     clearFolderErrors(accountId, folderPath) {
         this.folderErrorCooldown.delete(`${accountId}:${folderPath}`);
     }
+    /** Background body-cache backfill. Public so the Reconciler can schedule
+     *  the periodic tick under its priority/back-pressure rules; existing
+     *  in-method post-sync nudges (sync, fetchSince, fetchOne) call this
+     *  too and the per-account `prefetchingAccounts` set deduplicates. */
     async prefetchBodies(accountId) {
         if (this.prefetchingAccounts.has(accountId))
             return;
@@ -2625,9 +2663,12 @@ export class ImapManager extends EventEmitter {
                 bodyPath,
             });
             // Folder-tree badge refresh + message-list reload if the user
-            // is currently on Sent — same event the sync path emits.
+            // is currently on Sent — same event shape the sync path emits.
+            // (Was sending {accountId,folderId} as a single arg, which the
+            // IPC forwarder + UI handler decoded as garbage — the optimistic
+            // row landed in the DB but never appeared in the list.)
             this.db.recalcFolderCounts(sent.id);
-            this.emit("folderCountsChanged", { accountId, folderId: sent.id });
+            this.emit("folderCountsChanged", accountId, {});
             console.log(`  [sent-local] wrote optimistic row in Sent (uid=${synthUid}) for ${accountId}: ${envelope.subject}`);
         }
         catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -9,9 +9,9 @@
   },
   "license": "ISC",
   "dependencies": {
-    "@bobfrankston/mailx-types": "^0.1.9",
-    "@bobfrankston/mailx-settings": "^0.1.10",
-    "@bobfrankston/mailx-store": "^0.1.8",
+    "@bobfrankston/mailx-types": "^0.1.10",
+    "@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",
@@ -37,9 +37,9 @@
   },
   ".transformedSnapshot": {
     "dependencies": {
-      "@bobfrankston/mailx-types": "^0.1.9",
-      "@bobfrankston/mailx-settings": "^0.1.10",
-      "@bobfrankston/mailx-store": "^0.1.8",
+      "@bobfrankston/mailx-types": "^0.1.10",
+      "@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",