@bobfrankston/mailx 1.0.256 → 1.0.260

package/bin/mailx.js

@@ -28,6 +28,92 @@ const args = process.argv.slice(2);
 function hasFlag(name) { return args.includes(`-${name}`) || args.includes(`--${name}`); }
 const verbose = hasFlag("verbose");
 const isDaemon = hasFlag("daemon"); // internal: re-spawned detached process
+// Read our own version once — used for the instance file + upgrade check below.
+const __selfRoot = path.join(import.meta.dirname, "..");
+const __selfVersion = (() => {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(__selfRoot, "package.json"), "utf-8")).version || "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+})();
+const __instanceFile = path.join(process.env.USERPROFILE || process.env.HOME || ".", ".mailx", "instance.json");
+function readInstanceFile() {
+    try {
+        const raw = fs.readFileSync(__instanceFile, "utf-8");
+        const inst = JSON.parse(raw);
+        if (typeof inst.pid === "number" && typeof inst.version === "string")
+            return inst;
+    }
+    catch { /* missing or unreadable — treated as no instance */ }
+    return null;
+}
+function writeInstanceFile(pid) {
+    try {
+        fs.mkdirSync(path.dirname(__instanceFile), { recursive: true });
+        fs.writeFileSync(__instanceFile, JSON.stringify({ pid, version: __selfVersion, startedAt: Date.now() }, null, 2));
+    }
+    catch { /* non-fatal */ }
+}
+function clearInstanceFile() {
+    try {
+        fs.unlinkSync(__instanceFile);
+    }
+    catch { /* ignore */ }
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Version-mismatch upgrade: if a daemon from an older version is running when
+// the user types `mailx`, kill it so the new one can take over. Without this,
+// a second invocation would silently no-op (daemon exists), leaving the user
+// on an old UI with no indication that the install has been upgraded.
+// Skip this logic for command-only flags (kill, rebuild, setup, ...) and for
+// the internal --daemon respawn.
+const __commandFlags = ["kill", "v", "version", "setup", "add", "test", "rebuild", "repair", "import", "log"];
+const __isCommandInvocation = process.argv.slice(2).some(a => __commandFlags.includes(a.replace(/^--?/, "")));
+if (!isDaemon && !__isCommandInvocation) {
+    const inst = readInstanceFile();
+    if (inst && pidAlive(inst.pid)) {
+        if (inst.version !== __selfVersion) {
+            console.log(`mailx: upgrading running daemon (PID ${inst.pid}) from v${inst.version} → v${__selfVersion}`);
+            try {
+                process.kill(inst.pid, "SIGTERM");
+            }
+            catch { /* already gone */ }
+            // Give it ~1.5s to exit gracefully, then verify
+            const deadline = Date.now() + 2000;
+            while (Date.now() < deadline && pidAlive(inst.pid)) {
+                const sab = new SharedArrayBuffer(4);
+                Atomics.wait(new Int32Array(sab), 0, 0, 100); // 100ms nap
+            }
+            if (pidAlive(inst.pid)) {
+                try {
+                    process.kill(inst.pid, "SIGKILL");
+                }
+                catch { /* */ }
+            }
+            clearInstanceFile();
+        }
+        else {
+            // Same version already running — nothing to do. Print so the user
+            // knows why `mailx` seems to have done nothing.
+            console.log(`mailx v${__selfVersion} is already running (PID ${inst.pid}). Use mailx -kill to stop it.`);
+            process.exit(0);
+        }
+    }
+    else if (inst) {
+        // Stale instance file — PID is dead. Clean up.
+        clearInstanceFile();
+    }
+}
 // Auto-detach: re-spawn as background process so terminal returns immediately
 // Skip for: --verbose (want console), --daemon (already detached),
 // and any command flags (setup, kill, test, etc.)
@@ -675,6 +761,24 @@ async function main() {
         const home = process.env.USERPROFILE || process.env.HOME || ".";
         const logDir = path.join(home, ".mailx", "logs");
         fs.mkdirSync(logDir, { recursive: true });
+        // Prune logs older than LOG_RETENTION_DAYS on startup. Keep it simple:
+        // scan the dir, stat, delete. Cheap even with years of history.
+        const LOG_RETENTION_DAYS = 7;
+        const cutoff = Date.now() - LOG_RETENTION_DAYS * 86400000;
+        try {
+            for (const name of fs.readdirSync(logDir)) {
+                if (!/^mailx-\d{4}-\d{2}-\d{2}\.log$/.test(name))
+                    continue;
+                const full = path.join(logDir, name);
+                try {
+                    const st = fs.statSync(full);
+                    if (st.mtimeMs < cutoff)
+                        fs.unlinkSync(full);
+                }
+                catch { /* ignore per-file error */ }
+            }
+        }
+        catch { /* ignore — log pruning is best-effort */ }
         const logDate = new Date().toISOString().slice(0, 10);
         const logPath = path.join(logDir, `mailx-${logDate}.log`);
         const logStream = fs.createWriteStream(logPath, { flags: "a" });
@@ -716,6 +820,14 @@ async function main() {
         size: { width: 1400, height: 900 },
         escapeCloses: false,
     });
+    // Register ourselves as the live instance so subsequent `mailx` invocations
+    // can detect version-mismatch and upgrade us (see top of file). Clear on
+    // any of: SIGINT, SIGTERM, normal exit.
+    writeInstanceFile(process.pid);
+    const __cleanupInstance = () => { clearInstanceFile(); };
+    process.once("exit", __cleanupInstance);
+    process.once("SIGINT", () => { __cleanupInstance(); process.exit(0); });
+    process.once("SIGTERM", () => { __cleanupInstance(); process.exit(0); });
     // Handle requests from WebView → dispatch to MailxService
     // Pass server version to dispatch so getVersion returns it
     const rootPkg = JSON.parse(fs.readFileSync(path.join(import.meta.dirname, "..", "package.json"), "utf-8"));

package/client/.msger-window.json

@@ -1 +1 @@
-{"height":1344,"width":2151,"x":616,"y":113}
+{"height":1344,"width":2151,"x":707,"y":89}

package/client/components/message-viewer.js

@@ -74,6 +74,7 @@ function installPreviewControls(iframe) {
             const target = e.target;
             if (target && (target.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(target.tagName)))
                 return;
+            // Zoom is iframe-local — handle here, don't forward.
             if (e.ctrlKey && (e.key === "=" || e.key === "+")) {
                 e.preventDefault();
                 setZoom(previewZoom + ZOOM_STEP, doc);
@@ -89,11 +90,23 @@ function installPreviewControls(iframe) {
                 setZoom(1, doc);
                 return;
             }
-            document.dispatchEvent(new KeyboardEvent("keydown", {
+            // Forward EVERY keydown to the parent — no duplicated hotkey list.
+            // If the parent's handler calls preventDefault (because it owns the
+            // shortcut), dispatchEvent returns false, and we preventDefault on
+            // the iframe side too so the browser doesn't ALSO act on it
+            // (Ctrl+N otherwise pops a new browser window in some hosts).
+            // Single source of truth = app.ts hotkey handlers. Plain typing in
+            // the email body — letters, etc. — propagates with no parent
+            // handler matching, so dispatchEvent returns true and the iframe
+            // event is left alone.
+            const synth = new KeyboardEvent("keydown", {
                 key: e.key, code: e.code,
                 ctrlKey: e.ctrlKey, shiftKey: e.shiftKey, altKey: e.altKey, metaKey: e.metaKey,
                 bubbles: true, cancelable: true,
-            }));
+            });
+            const allowDefault = document.dispatchEvent(synth);
+            if (!allowDefault)
+                e.preventDefault();
         });
         doc.addEventListener("wheel", (e) => {
             if (!e.ctrlKey)
@@ -412,6 +425,60 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
                 loadRemote();
             });
         }
+        // Body fetch error — show banner above (empty) body instead of polluting
+        // the main content area with the error text. Transient errors get a retry.
+        if (msg.bodyError) {
+            const err = String(msg.bodyError);
+            const isTransient = !!msg.bodyErrorTransient;
+            const errBanner = document.createElement("div");
+            errBanner.className = "mv-error-banner";
+            errBanner.style.cssText = "margin:1rem;padding:0.75rem 1rem;border:1px solid var(--color-border);border-left:3px solid #d33;background:var(--color-bg-surface);border-radius:4px;font-size:var(--font-size-sm)";
+            errBanner.innerHTML = `
+                <div style="font-weight:600;margin-bottom:0.25rem;color:#d33">Body unavailable</div>
+                <div style="color:var(--color-text-muted);white-space:pre-wrap;word-break:break-word">${err.replace(/[&<>"]/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[c] || c))}</div>
+                ${isTransient ? `<button id="btn-retry-body" style="margin-top:0.5rem;padding:0.25rem 0.75rem">Retry</button>` : ""}
+            `;
+            bodyEl.appendChild(errBanner);
+            if (isTransient) {
+                errBanner.querySelector("#btn-retry-body")?.addEventListener("click", async () => {
+                    errBanner.remove();
+                    bodyEl.innerHTML = `<div class="mv-empty">Fetching message body...</div>`;
+                    try {
+                        const retry = await getMessage(accountId, uid, false);
+                        if (retry.bodyError) {
+                            // Still failing — rebuild the error banner via recursive render.
+                            showMessage(accountId, uid, folderId, specialUse).catch(() => { });
+                            return;
+                        }
+                        bodyEl.innerHTML = "";
+                        if (retry.bodyHtml) {
+                            const iframe = document.createElement("iframe");
+                            iframe.sandbox.add("allow-same-origin");
+                            iframe.sandbox.add("allow-popups");
+                            iframe.sandbox.add("allow-popups-to-escape-sandbox");
+                            iframe.sandbox.add("allow-top-navigation-by-user-activation");
+                            iframe.sandbox.add("allow-scripts");
+                            iframe.srcdoc = wrapHtmlBody(retry.bodyHtml, retry.remoteAllowed);
+                            bodyEl.appendChild(iframe);
+                            installPreviewControls(iframe);
+                        }
+                        else if (retry.bodyText) {
+                            const pre = document.createElement("pre");
+                            pre.style.cssText = "padding: 1rem; white-space: pre-wrap; word-break: break-word;";
+                            pre.innerHTML = linkifyText(retry.bodyText);
+                            bodyEl.appendChild(pre);
+                        }
+                        else {
+                            bodyEl.innerHTML = `<div class="mv-empty">No content</div>`;
+                        }
+                    }
+                    catch (e) {
+                        bodyEl.innerHTML = `<div class="mv-empty">Retry failed: ${e.message}</div>`;
+                    }
+                });
+            }
+            return;
+        }
         // Body in sandboxed iframe
         if (msg.bodyHtml) {
             const iframe = document.createElement("iframe");
@@ -455,11 +522,19 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
                     e.preventDefault();
                     try {
                         const data = await getAttachment(accountId, uid, i, msg.folderId);
-                        // Create blob URL and open
-                        const bytes = Uint8Array.from(atob(data.content), c => c.charCodeAt(0));
-                        const blob = new Blob([bytes], { type: data.contentType });
-                        const url = URL.createObjectURL(blob);
-                        window.open(url, "_blank");
+                        const bridge = window._nativeBridge;
+                        if (bridge?.openAttachment) {
+                            // Android: blob URLs don't work in WebView. Pass base64
+                            // to native bridge which saves to Downloads and opens
+                            // with the system viewer.
+                            await bridge.openAttachment(att.filename, data.contentType, data.content);
+                        }
+                        else {
+                            const bytes = Uint8Array.from(atob(data.content), c => c.charCodeAt(0));
+                            const blob = new Blob([bytes], { type: data.contentType });
+                            const url = URL.createObjectURL(blob);
+                            window.open(url, "_blank");
+                        }
                     }
                     catch (err) {
                         console.error(`Attachment download failed: ${err.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.256",
+  "version": "1.0.260",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -20,11 +20,11 @@
     "postinstall": "node bin/postinstall.js"
   },
   "dependencies": {
-    "@bobfrankston/iflow-direct": "^0.1.16",
+    "@bobfrankston/iflow-direct": "^0.1.19",
     "@bobfrankston/iflow-node": "^0.1.5",
     "@bobfrankston/miscinfo": "^1.0.8",
     "@bobfrankston/oauthsupport": "^1.0.24",
-    "@bobfrankston/msger": "^0.1.315",
+    "@bobfrankston/msger": "^0.1.316",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",
@@ -37,7 +37,8 @@
     "sql.js": "^1.14.1",
     "@bobfrankston/tcp-transport": "^0.1.3",
     "@bobfrankston/node-tcp-transport": "^0.1.1",
-    "@bobfrankston/smtp-direct": "^0.1.2"
+    "@bobfrankston/smtp-direct": "^0.1.2",
+    "@bobfrankston/mailx-sync": "file:../../../MailApps/mailx-sync"
   },
   "devDependencies": {
     "@types/mailparser": "^3.4.6"
@@ -80,11 +81,11 @@
   },
   ".transformedSnapshot": {
     "dependencies": {
-      "@bobfrankston/iflow-direct": "^0.1.16",
+      "@bobfrankston/iflow-direct": "^0.1.19",
       "@bobfrankston/iflow-node": "^0.1.5",
       "@bobfrankston/miscinfo": "^1.0.8",
       "@bobfrankston/oauthsupport": "^1.0.24",
-      "@bobfrankston/msger": "^0.1.315",
+      "@bobfrankston/msger": "^0.1.316",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",
       "@capacitor/core": "^8.3.0",

package/packages/mailx-imap/index.d.ts

@@ -147,7 +147,13 @@ export declare class ImapManager extends EventEmitter {
      *  stale row locally and keep going. Only unrelated errors (network,
      *  auth, rate limits) count against the error budget, and the budget is
      *  generous so a few transient failures don't kill the whole run. */
+    /** Guard against concurrent prefetchBodies for the same account — mirror of
+     *  `sendingAccounts`. Without this, every periodic-sync tick spawns a new
+     *  prefetch session alongside any still in flight, blowing through Gmail's
+     *  per-minute quota and racing on disk writes. One prefetch per account. */
+    private prefetchingAccounts;
     private prefetchBodies;
+    private _prefetchBodies;
     /** Get the body store for direct access */
     getBodyStore(): FileMessageStore;
     /** Bulk trash messages — local-first, single IMAP connection for all */

package/packages/mailx-imap/index.js

@@ -1259,11 +1259,15 @@ export class ImapManager extends EventEmitter {
             // which gives instant push — the STATUS poll is just a fallback
             // in case IDLE silently dropped.
             const isGmail = this.isGmailAccount(accountId);
-            // Both Gmail API and IMAP accounts have IDLE running for instant
-            // push. The STATUS poll is just a safety net for silent IDLE drops.
-            // Keep it infrequent to avoid hammering — Gmail 429 rate limits
-            // and Dovecot connection limits are both real constraints.
-            const interval = isGmail ? 120000 : 300000; // Gmail: 2min; IMAP: 5min
+            // IMAP accounts: IDLE gives instant push; STATUS poll is just a
+            // safety net for silent IDLE drops — keep it infrequent.
+            // Gmail accounts: no IDLE (Gmail API doesn't expose it), so the
+            // quick poll IS the primary path to new-mail latency. Drop to 30s
+            // so Gmail mail appears in ~15s average. Gmail quota budget is
+            // huge (250 units/sec per user, 1.2B/day) — 120 polls/hour × 5
+            // units ≈ 600/hour, trivial. Dovecot accounts stay at 5min to
+            // respect connection limits (each poll = fresh connection).
+            const interval = isGmail ? 30000 : 300000; // Gmail: 30s; IMAP: 5min
             const timer = setInterval(() => {
                 this.quickInboxCheckAccount(accountId).catch(() => { });
             }, interval);
@@ -1422,8 +1426,18 @@ export class ImapManager extends EventEmitter {
                 // fetchOne returned null — message doesn't exist on the server anymore
                 throw makeNotFoundError(accountId, folderId, uid);
             }
-            if (!msg.source)
+            if (!msg.source) {
+                // Gmail returned a message object but no raw bytes. Seen when:
+                //  (a) the message exists but is larger than the format=raw cap (~10MB),
+                //  (b) UID→Gmail-ID resolution picked a collision and the target
+                //      exists only as a stub, or (c) the listMessageIds top-1000
+                //      didn't include our UID and fetchOne returned null above —
+                //      wait, that would hit the !msg branch. So (a)/(b) remain.
+                // Log enough to distinguish; surface the reason up via a non-null
+                // return so the UI stops showing a generic "fetch returned nothing".
+                console.error(`  [api] Body fetch empty source (${accountId}/${uid}): Gmail returned no raw body — likely too-large-for-format-raw or UID hash collision`);
                 return null;
+            }
             const raw = Buffer.from(msg.source, "utf-8");
             const bodyPath = await this.bodyStore.putMessage(accountId, folderId, uid, raw);
             this.db.updateBodyPath(accountId, uid, bodyPath);
@@ -1443,7 +1457,23 @@ export class ImapManager extends EventEmitter {
      *  stale row locally and keep going. Only unrelated errors (network,
      *  auth, rate limits) count against the error budget, and the budget is
      *  generous so a few transient failures don't kill the whole run. */
+    /** Guard against concurrent prefetchBodies for the same account — mirror of
+     *  `sendingAccounts`. Without this, every periodic-sync tick spawns a new
+     *  prefetch session alongside any still in flight, blowing through Gmail's
+     *  per-minute quota and racing on disk writes. One prefetch per account. */
+    prefetchingAccounts = new Set();
     async prefetchBodies(accountId) {
+        if (this.prefetchingAccounts.has(accountId))
+            return;
+        this.prefetchingAccounts.add(accountId);
+        try {
+            await this._prefetchBodies(accountId);
+        }
+        finally {
+            this.prefetchingAccounts.delete(accountId);
+        }
+    }
+    async _prefetchBodies(accountId) {
         const counters = { totalFetched: 0, deleted: 0, errors: 0 };
         const ERROR_BUDGET = 20;
         const RATE_LIMIT_PAUSE_MS = 30000;
@@ -1487,6 +1517,7 @@ export class ImapManager extends EventEmitter {
                             continue;
                         const received = new Set();
                         const pending = [];
+                        let batchSucceeded = false;
                         try {
                             await api.fetchBodiesBatch(folder.path, uidsInFolder, (uid, source) => {
                                 received.add(uid);
@@ -1503,6 +1534,7 @@ export class ImapManager extends EventEmitter {
                                     }
                                 })());
                             });
+                            batchSucceeded = true;
                         }
                         catch (e) {
                             const isRate = /429|rate|too many/i.test(String(e?.message || ""));
@@ -1516,20 +1548,24 @@ export class ImapManager extends EventEmitter {
                             }
                         }
                         await Promise.all(pending);
-                        // UIDs we asked for but didn't receive are either gone
-                        // server-side OR aren't in this label (can happen if the
-                        // folder DB row was mis-labeled). Drop them so the loop
-                        // moves forward instead of spinning.
-                        for (const uid of uidsInFolder) {
-                            if (received.has(uid))
-                                continue;
-                            try {
-                                this.db.deleteMessage(accountId, uid);
-                                this.bodyStore.deleteMessage(accountId, folderId, uid).catch(() => { });
-                                counters.deleted++;
-                                madeProgress = true;
+                        // CRITICAL: only prune as "server-deleted" when the batch
+                        // actually completed. If the batch threw (403, 429, network
+                        // error, etc.) NOTHING was received, and treating every
+                        // requested UID as deleted silently wipes 100 messages per
+                        // batch. That's a data-loss bug. Earlier version did this
+                        // and pruned 296 messages on a 403 auth error.
+                        if (batchSucceeded) {
+                            for (const uid of uidsInFolder) {
+                                if (received.has(uid))
+                                    continue;
+                                try {
+                                    this.db.deleteMessage(accountId, uid);
+                                    this.bodyStore.deleteMessage(accountId, folderId, uid).catch(() => { });
+                                    counters.deleted++;
+                                    madeProgress = true;
+                                }
+                                catch { /* ignore */ }
                             }
-                            catch { /* ignore */ }
                         }
                         if (counters.errors >= ERROR_BUDGET)
                             break;
@@ -1571,6 +1607,7 @@ export class ImapManager extends EventEmitter {
                         // batch command finishes. This keeps streaming throughput high while
                         // still giving us a single await point for progress accounting.
                         const pending = [];
+                        let batchSucceeded = false;
                         try {
                             await client.fetchBodiesBatch(folder.path, uids, (uid, source) => {
                                 received.add(uid);
@@ -1588,6 +1625,7 @@ export class ImapManager extends EventEmitter {
                                     }
                                 })());
                             });
+                            batchSucceeded = true;
                         }
                         catch (e) {
                             console.error(`  [prefetch] ${accountId} folder ${folder.path}: batch fetch failed: ${e.message}`);
@@ -1596,19 +1634,21 @@ export class ImapManager extends EventEmitter {
                                 break;
                         }
                         await Promise.all(pending);
-                        // UIDs we asked for but didn't receive were deleted server-side.
-                        // Drop their stale DB rows so they stop coming back next batch.
-                        for (const uid of uids) {
-                            if (received.has(uid))
-                                continue;
-                            try {
-                                this.db.deleteMessage(accountId, uid);
-                                this.bodyStore.deleteMessage(accountId, folderId, uid).catch(() => { });
-                                counters.deleted++;
-                                madeProgress = true;
+                        // CRITICAL: only prune when the batch actually completed.
+                        // A thrown batch means NOTHING was received and we must
+                        // not treat absence-from-received as server-deletion.
+                        if (batchSucceeded)
+                            for (const uid of uids) {
+                                if (received.has(uid))
+                                    continue;
+                                try {
+                                    this.db.deleteMessage(accountId, uid);
+                                    this.bodyStore.deleteMessage(accountId, folderId, uid).catch(() => { });
+                                    counters.deleted++;
+                                    madeProgress = true;
+                                }
+                                catch { /* ignore */ }
                             }
-                            catch { /* ignore */ }
-                        }
                     }
                 }
                 finally {
@@ -1901,8 +1941,35 @@ export class ImapManager extends EventEmitter {
                     console.error(`  [drafts] searchByHeader for ${draftId} failed: ${e.message}`);
                 }
             }
-            // Append new draft
-            const result = await client.appendMessage(drafts.path, rawMessage, ["\\Draft", "\\Seen"]);
+            // Append new draft. If the server returns [TRYCREATE] (RFC 3501 §7.1),
+            // the folder doesn't exist on the server even though mailx's DB has
+            // it — happens when the folder was never created, or when the local
+            // special-folder detection latched onto a path that doesn't match
+            // the server's actual name. Create it then retry. Logs the path so
+            // we can diagnose a mis-detected Drafts folder.
+            let result;
+            try {
+                result = await client.appendMessage(drafts.path, rawMessage, ["\\Draft", "\\Seen"]);
+            }
+            catch (e) {
+                const msg = String(e?.message || e);
+                if (/TRYCREATE/i.test(msg)) {
+                    console.log(`  [drafts] APPEND got TRYCREATE for "${drafts.path}" — creating folder and retrying`);
+                    try {
+                        await client.createmailbox(drafts.path);
+                    }
+                    catch (ce) {
+                        // "already exists" is benign; others we surface
+                        if (!/already exists/i.test(String(ce?.message || ""))) {
+                            console.error(`  [drafts] Folder create failed for "${drafts.path}": ${ce.message}`);
+                        }
+                    }
+                    result = await client.appendMessage(drafts.path, rawMessage, ["\\Draft", "\\Seen"]);
+                }
+                else {
+                    throw e;
+                }
+            }
             // APPENDUID returns the UID directly; imapflow returns { destination, uid }
             const uid = typeof result === "number" ? result : result?.uid || null;
             return uid;

package/packages/mailx-imap/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.7",
+  "version": "0.1.11",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -15,6 +15,7 @@
     "@bobfrankston/iflow-direct": "file:../../../MailApps/iflow-direct",
     "@bobfrankston/tcp-transport": "file:../../../MailApps/tcp-transport",
     "@bobfrankston/smtp-direct": "file:../../../MailApps/smtp-direct",
+    "@bobfrankston/mailx-sync": "file:../../../MailApps/mailx-sync",
     "@bobfrankston/oauthsupport": "file:../../../../projects/oauth/oauthsupport"
   },
   "repository": {

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

@@ -1,43 +1,8 @@
 /**
- * Gmail API provider — replaces IMAP for Gmail accounts.
- * Uses REST API for fast, reliable sync without connection limit issues.
+ * Back-compat re-export. The canonical Gmail provider lives in
+ * @bobfrankston/mailx-sync. mailx-imap re-exports it under its old name so
+ * call sites here keep compiling. Both desktop (this package) and Android
+ * (mailx-store-web) consume the same single implementation now.
  */
-import type { MailProvider, ProviderFolder, ProviderMessage, FetchOptions } from "./types.js";
-export declare class GmailApiProvider implements MailProvider {
-    private tokenProvider;
-    constructor(tokenProvider: () => Promise<string>);
-    private fetch;
-    listFolders(): Promise<ProviderFolder[]>;
-    /** 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;
-    /** Parse a Gmail API message response into ProviderMessage */
-    private parseMessage;
-    fetchSince(folder: string, sinceUid: number, options?: FetchOptions): Promise<ProviderMessage[]>;
-    fetchByDate(folder: string, since: Date, before: Date, options?: FetchOptions, onChunk?: (msgs: ProviderMessage[]) => void): Promise<ProviderMessage[]>;
-    fetchByUids(folder: string, uids: number[], options?: FetchOptions): Promise<ProviderMessage[]>;
-    /** Bulk-fetch raw bodies for many UIDs in one "folder" (Gmail label).
-     *  Lists the label once, builds UID→ID map, then streams bodies through
-     *  `onBody` with bounded concurrency (lets Gmail's HTTP/2 stream multiplex;
-     *  `fetch()`'s built-in 429/5xx retry handles backoff automatically).
-     *
-     *  NOTE: Gmail's model is labels, not folders — a single message can be in
-     *  many labels. Treating each label as a folder causes duplicate fetches
-     *  across labels. Proper fix tracked as separate TODO ("Gmail label-native
-     *  model"). For now we mirror the IMAP folder grouping, accepting duplicate
-     *  fetches of multi-labeled messages. */
-    fetchBodiesBatch(folder: string, uids: number[], onBody: (uid: number, source: string) => void): Promise<void>;
-    fetchOne(folder: string, uid: number, options?: FetchOptions): Promise<ProviderMessage | null>;
-    getUids(folder: string): Promise<number[]>;
-    close(): Promise<void>;
-    /** Map folder path to Gmail label query term */
-    private folderToLabel;
-    /** Format date for Gmail query (YYYY/MM/DD) */
-    private formatDate;
-}
+export { GmailApiProvider } from "@bobfrankston/mailx-sync";
 //# sourceMappingURL=gmail-api.d.ts.map