@bobfrankston/mailx-imap 0.1.30 → 0.1.32

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);
@@ -3324,7 +3368,12 @@ export class ImapManager extends EventEmitter {
         //      this exact case: `.sending-rmf39-63196` sat in the queue
         //      for 7+ hours because PID 63196 was now an unrelated Node.
         //  (c) it's our PID — never sweep our own claim.
-        const STALE_CLAIM_MS = 3600_000;
+        // 5 minutes: SMTP transactions complete in seconds; 5m of
+        // claim with no progress means the worker is wedged or PID
+        // got recycled. Earlier 1h was a band-aid that left Bob's
+        // outbox stuck for hours when an SMTP wedge crashed the
+        // worker mid-flight.
+        const STALE_CLAIM_MS = 5 * 60_000;
         const myPid = process.pid;
         for (const dir of [outboxDir, queuedDir]) {
             if (!fs.existsSync(dir))
@@ -3426,11 +3475,23 @@ export class ImapManager extends EventEmitter {
                     // file is visible to the scan loop again.
                     const nextAt = new Date(nowMs + OUTBOX_RETRY_DELAY_MS).toISOString();
                     const withDelay = insertHeaderBeforeBody(raw, `X-Mailx-Retry-After: ${nextAt}`);
-                    fs.writeFileSync(claimedPath, withDelay, "utf-8");
+                    try {
+                        fs.writeFileSync(claimedPath, withDelay, "utf-8");
+                    }
+                    catch (we) {
+                        console.error(`  [outbox] FAIL writeBack ${claimedPath}: ${we?.message || we}`);
+                    }
                     try {
                         fs.renameSync(claimedPath, filePath);
                     }
-                    catch { /* file stays claimed; recovery sweeper will handle */ }
+                    catch (re) {
+                        // Loud — the file is now stuck in `.sending-` state
+                        // until the recovery sweeper's stale-claim timer
+                        // (5 min) reclaims it. User-visible as "stuck" in
+                        // the outbox view; cancelable via the new always-
+                        // allowed Cancel button.
+                        console.error(`  [outbox] FAIL renameBack ${claimedPath} → ${filePath}: ${re?.message || re} — claim will sit until stale-recovery (5 min)`);
+                    }
                     console.error(`  [outbox] Send failed for ${file} (attempt ${attempt}, retry after ${nextAt}): ${e.message}`);
                 }
             }

package/package.json

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