@bobfrankston/mailx-imap 0.1.30 → 0.1.31

package/index.d.ts

@@ -224,7 +224,25 @@ export declare class ImapManager extends EventEmitter {
         path: string;
     }, uid: number, source: string, flags: string[]): Promise<void>;
     /** Sync messages for a specific folder */
+    /** Per-(accountId,folderId) sync lock. Multiple paths can call syncFolder
+     *  for the same folder concurrently — `syncOne` (full sync), `syncInbox`
+     *  (5-min fast poll), `quickInboxCheckAccount` (startup quick check),
+     *  `syncInboxNewOnly` (IDLE callback). Each path takes a different
+     *  connection, so withConnection can't serialize them. The DB layer
+     *  enforces "one transaction per connection" but doesn't notice the
+     *  concurrent UID set being mutated underneath. Symptom: two
+     *  `[sync-enter]` log lines for the same folder within ms (Bob 2026-05-08
+     *  21:47:52), `cannot start a transaction within a transaction` SQLite
+     *  errors, and prefetch SELECT/FETCH races when sync's SELECT runs
+     *  between prefetch's SELECT and FETCH.
+     *
+     *  This per-folder mutex means the second concurrent caller waits
+     *  rather than silently racing. The waiter still gets the lock when
+     *  the first caller finishes — important for outbox flushes that
+     *  expect their syncFolder for `Sent` to actually run. */
+    private syncFolderLocks;
     syncFolder(accountId: string, folderId: number, client?: any): Promise<number>;
+    private _syncFolderImpl;
     /** Sync all folders for all accounts */
     syncAll(): Promise<void>;
     private _syncAll;

package/index.js

@@ -972,7 +972,41 @@ export class ImapManager extends EventEmitter {
         console.log(`  [local-insert] ${folder.path} UID ${uid}: ${parsed.subject || "(no subject)"} (no IMAP roundtrip)`);
     }
     /** Sync messages for a specific folder */
+    /** Per-(accountId,folderId) sync lock. Multiple paths can call syncFolder
+     *  for the same folder concurrently — `syncOne` (full sync), `syncInbox`
+     *  (5-min fast poll), `quickInboxCheckAccount` (startup quick check),
+     *  `syncInboxNewOnly` (IDLE callback). Each path takes a different
+     *  connection, so withConnection can't serialize them. The DB layer
+     *  enforces "one transaction per connection" but doesn't notice the
+     *  concurrent UID set being mutated underneath. Symptom: two
+     *  `[sync-enter]` log lines for the same folder within ms (Bob 2026-05-08
+     *  21:47:52), `cannot start a transaction within a transaction` SQLite
+     *  errors, and prefetch SELECT/FETCH races when sync's SELECT runs
+     *  between prefetch's SELECT and FETCH.
+     *
+     *  This per-folder mutex means the second concurrent caller waits
+     *  rather than silently racing. The waiter still gets the lock when
+     *  the first caller finishes — important for outbox flushes that
+     *  expect their syncFolder for `Sent` to actually run. */
+    syncFolderLocks = new Map();
     async syncFolder(accountId, folderId, client) {
+        const lockKey = `${accountId}:${folderId}`;
+        const inflight = this.syncFolderLocks.get(lockKey);
+        if (inflight) {
+            // Coalesce: callers that fire while a sync is in flight get the
+            // result of the in-flight call rather than starting a duplicate.
+            // For "quick check that finds new mail and triggers sync" this
+            // means the quick check waits for the existing sync to complete
+            // — which is what the user wants anyway, no double work.
+            console.log(`  [sync-enter] ${accountId}/${folderId}: coalescing (sync already in flight)`);
+            return inflight;
+        }
+        const promise = this._syncFolderImpl(accountId, folderId, client)
+            .finally(() => { this.syncFolderLocks.delete(lockKey); });
+        this.syncFolderLocks.set(lockKey, promise);
+        return promise;
+    }
+    async _syncFolderImpl(accountId, folderId, client) {
         if (!client)
             client = await this.getOpsClient(accountId);
         const prefetch = getPrefetch();
@@ -2381,6 +2415,16 @@ export class ImapManager extends EventEmitter {
     async prefetchBodies(accountId) {
         if (this.prefetchingAccounts.has(accountId))
             return;
+        // Skip if the account isn't registered yet — the reconciler tick
+        // can fire 2 s after daemon start, and addAccount may still be
+        // running its OAuth flow. Without this guard we hit
+        // ERROR_BUDGET (20) failures with "No config for account X" and
+        // exit prefetch silently for the rest of the session — bodies
+        // never download. Symptom: log shows 20 lines of `[prefetch] X
+        // folder Y chunk 0: batch fetch failed: No config for account X`
+        // followed by `stopping after 20 errors`.
+        if (!this.configs.has(accountId))
+            return;
         this.prefetchingAccounts.add(accountId);
         try {
             await this._prefetchBodies(accountId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.30",
+  "version": "0.1.31",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",