@bobfrankston/mailx 1.0.221 → 1.0.222

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.221",
+  "version": "1.0.222",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -24,7 +24,7 @@
     "@bobfrankston/iflow-node": "^0.1.2",
     "@bobfrankston/miscinfo": "^1.0.8",
     "@bobfrankston/oauthsupport": "^1.0.22",
-    "@bobfrankston/msger": "^0.1.283",
+    "@bobfrankston/msger": "^0.1.284",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",
@@ -78,7 +78,7 @@
       "@bobfrankston/iflow-node": "^0.1.2",
       "@bobfrankston/miscinfo": "^1.0.8",
       "@bobfrankston/oauthsupport": "^1.0.22",
-      "@bobfrankston/msger": "^0.1.283",
+      "@bobfrankston/msger": "^0.1.284",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",
       "@capacitor/core": "^8.3.0",

package/packages/mailx-imap/index.js

@@ -946,20 +946,40 @@ export class ImapManager extends EventEmitter {
             console.log(`  [api] ${accountId}/${folder.path}: ${messages.length} new messages`);
             this.storeApiMessages(accountId, folder.id, messages, highestUid);
         }
-        // Reconcile deletions
+        // Reconcile deletions — messages present locally but not on the server.
+        // SAFETY: this used to silently wipe entire folders when getUids()
+        // returned a partial list (e.g. paginated fetch hit a rate limit and
+        // bailed). Multiple guards now:
+        //   1. getUids() flags partial results via _truncated — refuse to delete
+        //   2. If server list is empty but local isn't, assume a transient error
+        //   3. If reconcile would delete more than RECONCILE_DELETE_THRESHOLD of
+        //      local messages, log and skip — safer to keep phantoms than to lose
+        //      real messages. User can fix with `mailx -rebuild` if needed.
         try {
-            const serverUids = new Set(await api.getUids(folder.path));
+            const serverUidsArr = await api.getUids(folder.path);
+            const serverUids = new Set(serverUidsArr);
             const localUids = this.db.getUidsForFolder(accountId, folder.id);
-            let deleted = 0;
-            for (const uid of localUids) {
-                if (!serverUids.has(uid)) {
-                    this.db.deleteMessage(accountId, uid);
-                    this.bodyStore.deleteMessage(accountId, folder.id, uid).catch(() => { });
-                    deleted++;
+            if (serverUidsArr._truncated) {
+                console.log(`  [api] ${accountId}/${folder.path}: reconcile skipped — server list truncated (${serverUidsArr.length} ids)`);
+            }
+            else if (serverUidsArr.length === 0 && localUids.length > 0) {
+                console.log(`  [api] ${accountId}/${folder.path}: reconcile skipped — server list empty but local has ${localUids.length}`);
+            }
+            else {
+                const toDelete = localUids.filter(uid => !serverUids.has(uid));
+                const RECONCILE_DELETE_THRESHOLD = 0.5; // refuse to delete >50% in one pass
+                if (localUids.length > 0 && toDelete.length / localUids.length > RECONCILE_DELETE_THRESHOLD) {
+                    console.log(`  [api] ${accountId}/${folder.path}: reconcile refused — would delete ${toDelete.length}/${localUids.length} (${Math.round(toDelete.length / localUids.length * 100)}%) — probably a sync bug, skipping`);
+                }
+                else {
+                    for (const uid of toDelete) {
+                        this.db.deleteMessage(accountId, uid);
+                        this.bodyStore.deleteMessage(accountId, folder.id, uid).catch(() => { });
+                    }
+                    if (toDelete.length > 0)
+                        console.log(`  [api] ${accountId}/${folder.path}: ${toDelete.length} deleted`);
                 }
             }
-            if (deleted > 0)
-                console.log(`  [api] ${accountId}/${folder.path}: ${deleted} deleted`);
         }
         catch (e) {
             console.error(`  [api] ${accountId}/${folder.path}: reconciliation error: ${e.message}`);
@@ -970,12 +990,15 @@ export class ImapManager extends EventEmitter {
     }
     /** Store API-fetched messages to DB */
     storeApiMessages(accountId, folderId, msgs, highestUid) {
+        // highestUid kept for signature compatibility but no longer used to
+        // filter — Gmail message IDs aren't monotonic, so `msg.uid <= highestUid`
+        // would drop brand-new messages whose hash happens to be smaller than
+        // the previous high. upsertMessage's primary-key dedup handles it.
+        void highestUid;
         let stored = 0;
         this.db.beginTransaction();
         try {
             for (const msg of msgs) {
-                if (msg.uid <= highestUid)
-                    continue;
                 const flags = [];
                 if (msg.seen)
                     flags.push("\\Seen");

package/packages/mailx-imap/providers/gmail-api.d.ts

@@ -8,7 +8,11 @@ export declare class GmailApiProvider implements MailProvider {
     constructor(tokenProvider: () => Promise<string>);
     private fetch;
     listFolders(): Promise<ProviderFolder[]>;
-    /** List message IDs matching a query, handling pagination */
+    /** List message IDs matching a query, handling pagination.
+     *  IMPORTANT: on any error we throw — do NOT return a partial list, because
+     *  callers use this for sync reconciliation and a short list would delete
+     *  real messages from the local DB. Returning [] silently caused the
+     *  "INBOX empty in mailx" bug when a rate-limit hit mid-pagination. */
     private listMessageIds;
     /** Batch-fetch message metadata or full content */
     private batchFetch;

package/packages/mailx-imap/providers/gmail-api.js

@@ -93,10 +93,15 @@ export class GmailApiProvider {
         }
         return folders;
     }
-    /** List message IDs matching a query, handling pagination */
+    /** List message IDs matching a query, handling pagination.
+     *  IMPORTANT: on any error we throw — do NOT return a partial list, because
+     *  callers use this for sync reconciliation and a short list would delete
+     *  real messages from the local DB. Returning [] silently caused the
+     *  "INBOX empty in mailx" bug when a rate-limit hit mid-pagination. */
     async listMessageIds(query, maxResults = 500) {
         const ids = [];
         let pageToken = "";
+        let truncated = false;
         while (true) {
             const params = new URLSearchParams({ q: query, maxResults: String(Math.min(maxResults - ids.length, 500)) });
             if (pageToken)
@@ -105,10 +110,17 @@ export class GmailApiProvider {
             for (const msg of data.messages || []) {
                 ids.push(msg.id);
             }
-            if (!data.nextPageToken || ids.length >= maxResults)
+            if (!data.nextPageToken)
                 break;
+            if (ids.length >= maxResults) {
+                // Hit the caller's cap but the server has more. Flag it so
+                // reconcile-style callers can refuse to treat this as complete.
+                truncated = true;
+                break;
+            }
             pageToken = data.nextPageToken;
         }
+        ids._truncated = truncated;
         return ids;
     }
     /** Batch-fetch message metadata or full content */
@@ -170,12 +182,15 @@ export class GmailApiProvider {
         };
     }
     async fetchSince(folder, sinceUid, options = {}) {
-        // Gmail doesn't have UIDs — use date-based query for incremental
-        // For now, fetch recent messages and let the caller filter by UID
+        // Gmail message IDs are hash-derived, NOT monotonic — filtering by
+        // `uid > sinceUid` silently drops new messages whose hash happens to
+        // fall below the high-water mark. Fetch the most recent page and let
+        // upsertMessage dedupe by (account, folder, uid). The sinceUid arg is
+        // kept for interface compatibility but no longer used for filtering.
+        void sinceUid;
         const query = `in:${this.folderToLabel(folder)}`;
         const ids = await this.listMessageIds(query, 200);
-        const messages = await this.batchFetch(ids, options);
-        return messages.filter(m => m.uid > sinceUid);
+        return this.batchFetch(ids, options);
     }
     async fetchByDate(folder, since, before, options = {}, onChunk) {
         const afterDate = this.formatDate(since);
@@ -213,7 +228,11 @@ export class GmailApiProvider {
     async getUids(folder) {
         const query = `in:${this.folderToLabel(folder)}`;
         const ids = await this.listMessageIds(query, 10000);
-        return ids.map(idToUid);
+        const result = ids.map(idToUid);
+        // Propagate the truncation flag so reconcile can refuse to delete.
+        if (ids._truncated)
+            result._truncated = true;
+        return result;
     }
     async close() {
         // No persistent connection to close