@bobfrankston/mailx 1.0.253 → 1.0.260

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

@@ -1,289 +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.
  */
-const API = "https://gmail.googleapis.com/gmail/v1/users/me";
-/** Convert Gmail hex ID to integer UID (lower 48 bits — deterministic, stable) */
-function idToUid(id) {
-    const hex = id.length > 12 ? id.slice(-12) : id;
-    return parseInt(hex, 16);
-}
-/** Map Gmail label to IMAP-style specialUse */
-function labelSpecialUse(label) {
-    switch (label.id) {
-        case "INBOX": return "inbox";
-        case "SENT": return "sent";
-        case "DRAFT": return "drafts";
-        case "TRASH": return "trash";
-        case "SPAM": return "junk";
-        case "STARRED": return "";
-        case "IMPORTANT": return "";
-        default: return "";
-    }
-}
-/** Parse RFC 2822 headers from Gmail metadata payload */
-function getHeader(headers, name) {
-    return headers.find(h => h.name.toLowerCase() === name.toLowerCase())?.value || "";
-}
-/** Parse "Name <addr>" or "addr" into { name, address } */
-function parseAddress(raw) {
-    const match = raw.match(/^"?([^"<]*?)"?\s*<([^>]+)>/);
-    if (match)
-        return { name: match[1].trim(), address: match[2].trim() };
-    return { address: raw.trim() };
-}
-function parseAddressList(raw) {
-    if (!raw)
-        return [];
-    // Split on commas that aren't inside quotes
-    return raw.split(/,(?=(?:[^"]*"[^"]*")*[^"]*$)/).map(s => parseAddress(s.trim())).filter(a => a.address);
-}
-export class GmailApiProvider {
-    tokenProvider;
-    constructor(tokenProvider) {
-        this.tokenProvider = tokenProvider;
-    }
-    async fetch(path, options = {}) {
-        const token = await this.tokenProvider();
-        const maxAttempts = 6;
-        const baseDelayMs = 1000;
-        const maxDelayMs = 60_000;
-        let lastStatus = 0;
-        for (let attempt = 0; attempt < maxAttempts; attempt++) {
-            const res = await globalThis.fetch(`${API}${path}`, {
-                ...options,
-                headers: {
-                    "Authorization": `Bearer ${token}`,
-                    "Content-Type": "application/json",
-                    ...options.headers,
-                },
-            });
-            if (res.status === 429 || res.status >= 500) {
-                lastStatus = res.status;
-                // Honor Retry-After if present (seconds or HTTP-date)
-                const retryAfter = res.headers.get("Retry-After");
-                let delay = baseDelayMs * Math.pow(2, attempt);
-                if (retryAfter) {
-                    const asInt = parseInt(retryAfter, 10);
-                    if (!isNaN(asInt))
-                        delay = asInt * 1000;
-                    else {
-                        const when = Date.parse(retryAfter);
-                        if (!isNaN(when))
-                            delay = Math.max(0, when - Date.now());
-                    }
-                }
-                // Full jitter to avoid synchronized retries
-                delay = Math.min(maxDelayMs, delay);
-                delay = Math.floor(delay * (0.5 + Math.random() * 0.5));
-                console.log(`  [gmail] ${res.status} (attempt ${attempt + 1}/${maxAttempts}), waiting ${(delay / 1000).toFixed(1)}s${retryAfter ? ` (Retry-After: ${retryAfter})` : ""}...`);
-                await new Promise(r => setTimeout(r, delay));
-                continue;
-            }
-            if (!res.ok) {
-                const err = await res.text().catch(() => "");
-                throw new Error(`Gmail API ${res.status}: ${err.substring(0, 200)}`);
-            }
-            return res.json();
-        }
-        throw new Error(`Gmail API: failed after ${maxAttempts} retries (last status ${lastStatus})`);
-    }
-    async listFolders() {
-        const data = await this.fetch("/labels");
-        const labels = data.labels || [];
-        const folders = [];
-        for (const label of labels) {
-            // Skip system labels that aren't useful as folders
-            if (["UNREAD", "STARRED", "IMPORTANT", "CATEGORY_PERSONAL",
-                "CATEGORY_SOCIAL", "CATEGORY_PROMOTIONS", "CATEGORY_UPDATES",
-                "CATEGORY_FORUMS", "CHAT"].includes(label.id))
-                continue;
-            const specialUse = labelSpecialUse(label);
-            // Map Gmail path separators (/) to IMAP-style
-            const path = label.name || label.id;
-            const name = path.includes("/") ? path.split("/").pop() : path;
-            folders.push({
-                path,
-                name,
-                delimiter: "/",
-                specialUse,
-                flags: label.type === "system" ? ["\\Noselect"] : [],
-            });
-        }
-        return folders;
-    }
-    /** 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)
-                params.set("pageToken", pageToken);
-            const data = await this.fetch(`/messages?${params}`);
-            for (const msg of data.messages || []) {
-                ids.push(msg.id);
-            }
-            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 */
-    async batchFetch(ids, options = {}, onChunk) {
-        const all = [];
-        const chunkSize = options.source ? 10 : 50; // Smaller chunks for full bodies
-        const format = options.source ? "raw" : "metadata";
-        for (let i = 0; i < ids.length; i += chunkSize) {
-            const chunk = ids.slice(i, i + chunkSize);
-            // Sequential fetches to avoid Gmail 429 rate limits
-            const messages = [];
-            for (const id of chunk) {
-                const params = new URLSearchParams({ format });
-                if (format === "metadata") {
-                    for (const h of ["From", "To", "Cc", "Subject", "Message-ID", "Date", "In-Reply-To", "References"]) {
-                        params.append("metadataHeaders", h);
-                    }
-                }
-                messages.push(await this.fetch(`/messages/${id}?${params}`));
-            }
-            const parsed = messages.map(msg => this.parseMessage(msg, options));
-            all.push(...parsed);
-            if (onChunk)
-                onChunk(parsed);
-        }
-        return all;
-    }
-    /** Parse a Gmail API message response into ProviderMessage */
-    parseMessage(msg, options = {}) {
-        const labels = msg.labelIds || [];
-        const headers = msg.payload?.headers || [];
-        let source = "";
-        if (options.source && msg.raw) {
-            // Gmail returns URL-safe base64 — convert to standard base64 then decode
-            const base64 = msg.raw.replace(/-/g, "+").replace(/_/g, "/");
-            source = new TextDecoder().decode(Uint8Array.from(atob(base64), c => c.charCodeAt(0)));
-        }
-        const fromRaw = getHeader(headers, "From");
-        const toRaw = getHeader(headers, "To");
-        const ccRaw = getHeader(headers, "Cc");
-        const dateRaw = getHeader(headers, "Date") || "";
-        const subject = getHeader(headers, "Subject") || msg.snippet || "";
-        const messageId = getHeader(headers, "Message-ID") || "";
-        const inReplyTo = getHeader(headers, "In-Reply-To") || "";
-        const referencesRaw = getHeader(headers, "References") || "";
-        const references = referencesRaw.trim()
-            ? referencesRaw.split(/\s+/).filter(r => r.startsWith("<") && r.endsWith(">"))
-            : [];
-        return {
-            uid: idToUid(msg.id),
-            messageId,
-            providerId: msg.id,
-            date: dateRaw ? new Date(dateRaw) : (msg.internalDate ? new Date(Number(msg.internalDate)) : null),
-            subject,
-            from: parseAddressList(fromRaw),
-            to: parseAddressList(toRaw),
-            cc: parseAddressList(ccRaw),
-            inReplyTo,
-            references,
-            seen: !labels.includes("UNREAD"),
-            flagged: labels.includes("STARRED"),
-            answered: false, // Gmail API doesn't expose this directly
-            draft: labels.includes("DRAFT"),
-            size: msg.sizeEstimate || 0,
-            source,
-        };
-    }
-    async fetchSince(folder, sinceUid, options = {}) {
-        // 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);
-        return this.batchFetch(ids, options);
-    }
-    async fetchByDate(folder, since, before, options = {}, onChunk) {
-        const afterDate = this.formatDate(since);
-        const beforeDate = this.formatDate(before);
-        const query = `in:${this.folderToLabel(folder)} after:${afterDate} before:${beforeDate}`;
-        const ids = await this.listMessageIds(query);
-        return this.batchFetch(ids, options, onChunk);
-    }
-    async fetchByUids(folder, uids, options = {}) {
-        // UIDs are derived from Gmail IDs — we'd need a reverse lookup
-        // For now, fetch all messages in folder and filter
-        const query = `in:${this.folderToLabel(folder)}`;
-        const ids = await this.listMessageIds(query);
-        const uidSet = new Set(uids);
-        const matchingIds = ids.filter(id => uidSet.has(idToUid(id)));
-        return this.batchFetch(matchingIds, options);
-    }
-    async fetchOne(folder, uid, options = {}) {
-        // Need to find the Gmail ID from the UID — search all messages in folder
-        const query = `in:${this.folderToLabel(folder)}`;
-        const ids = await this.listMessageIds(query, 1000);
-        const id = ids.find(id => idToUid(id) === uid);
-        if (!id)
-            return null;
-        const format = options.source ? "raw" : "metadata";
-        const params = new URLSearchParams({ format });
-        if (format === "metadata") {
-            for (const h of ["From", "To", "Cc", "Subject", "Message-ID", "Date", "In-Reply-To", "References"]) {
-                params.append("metadataHeaders", h);
-            }
-        }
-        const msg = await this.fetch(`/messages/${id}?${params}`);
-        return this.parseMessage(msg, options);
-    }
-    async getUids(folder) {
-        const query = `in:${this.folderToLabel(folder)}`;
-        const ids = await this.listMessageIds(query, 10000);
-        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
-    }
-    /** Map folder path to Gmail label query term */
-    folderToLabel(path) {
-        const lower = path.toLowerCase();
-        if (lower === "inbox")
-            return "inbox";
-        if (lower === "sent" || lower === "[gmail]/sent mail")
-            return "sent";
-        if (lower === "drafts" || lower === "[gmail]/drafts")
-            return "drafts";
-        if (lower === "trash" || lower === "[gmail]/trash")
-            return "trash";
-        if (lower === "spam" || lower === "[gmail]/spam" || lower === "junk email")
-            return "spam";
-        if (lower === "archive" || lower === "[gmail]/all mail")
-            return "all";
-        // Custom label — use exact name
-        return `"${path}"`;
-    }
-    /** Format date for Gmail query (YYYY/MM/DD) */
-    formatDate(d) {
-        return `${d.getFullYear()}/${String(d.getMonth() + 1).padStart(2, "0")}/${String(d.getDate()).padStart(2, "0")}`;
-    }
-}
+export { GmailApiProvider } from "@bobfrankston/mailx-sync";
 //# sourceMappingURL=gmail-api.js.map

package/packages/mailx-imap/providers/types.d.ts

@@ -1,62 +1,9 @@
 /**
- * Mail provider interface — abstraction over IMAP, Gmail API, and Microsoft Graph.
- * Sync code uses this interface; never calls IMAP/REST directly.
+ * Back-compat re-export. The canonical mail provider types live in
+ * @bobfrankston/mailx-sync. New code should import from there directly.
+ *
+ * This shim keeps existing `import { ... } from "./types.js"` paths inside
+ * mailx-imap working without churn.
  */
-export interface ProviderFolder {
-    path: string;
-    name: string;
-    delimiter: string;
-    specialUse: string;
-    flags: string[];
-}
-export interface ProviderMessage {
-    uid: number;
-    messageId: string;
-    providerId: string;
-    date: Date | null;
-    subject: string;
-    from: {
-        name?: string;
-        address?: string;
-    }[];
-    to: {
-        name?: string;
-        address?: string;
-    }[];
-    cc: {
-        name?: string;
-        address?: string;
-    }[];
-    inReplyTo?: string;
-    references?: string[];
-    seen: boolean;
-    flagged: boolean;
-    answered: boolean;
-    draft: boolean;
-    size: number;
-    source: string;
-}
-export interface FetchOptions {
-    source?: boolean;
-}
-/**
- * A mail provider that can list folders, fetch messages, and perform actions.
- * Implementations: ImapProvider (existing iflow), GmailApiProvider, GraphApiProvider.
- */
-export interface MailProvider {
-    /** List all folders/labels */
-    listFolders(): Promise<ProviderFolder[]>;
-    /** Fetch messages newer than sinceUid (incremental sync) */
-    fetchSince(folder: string, sinceUid: number, options?: FetchOptions): Promise<ProviderMessage[]>;
-    /** Fetch messages by date range (first sync) */
-    fetchByDate(folder: string, since: Date, before: Date, options?: FetchOptions, onChunk?: (msgs: ProviderMessage[]) => void): Promise<ProviderMessage[]>;
-    /** Fetch specific messages by UID */
-    fetchByUids(folder: string, uids: number[], options?: FetchOptions): Promise<ProviderMessage[]>;
-    /** Fetch a single message by UID */
-    fetchOne(folder: string, uid: number, options?: FetchOptions): Promise<ProviderMessage | null>;
-    /** Get all UIDs in a folder (for reconciliation) */
-    getUids(folder: string): Promise<number[]>;
-    /** Close/cleanup */
-    close(): Promise<void>;
-}
+export type { MailProvider, ProviderFolder, ProviderMessage, FetchOptions } from "@bobfrankston/mailx-sync";
 //# sourceMappingURL=types.d.ts.map

package/packages/mailx-imap/providers/types.js

@@ -1,6 +1,9 @@
 /**
- * Mail provider interface — abstraction over IMAP, Gmail API, and Microsoft Graph.
- * Sync code uses this interface; never calls IMAP/REST directly.
+ * Back-compat re-export. The canonical mail provider types live in
+ * @bobfrankston/mailx-sync. New code should import from there directly.
+ *
+ * This shim keeps existing `import { ... } from "./types.js"` paths inside
+ * mailx-imap working without churn.
  */
 export {};
 //# sourceMappingURL=types.js.map

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

@@ -6,10 +6,6 @@
 import { MailxDB } from "@bobfrankston/mailx-store";
 import { ImapManager } from "@bobfrankston/mailx-imap";
 import type { Folder, AutocompleteRequest, AutocompleteResponse, AutocompleteSettings } from "@bobfrankston/mailx-types";
-export declare function sanitizeHtml(html: string): {
-    html: string;
-    hasRemoteContent: boolean;
-};
 export declare class MailxService {
     private db;
     private imapManager;

package/packages/mailx-service/index.js

@@ -7,43 +7,8 @@ import * as dns from "node:dns/promises";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { loadSettings, saveSettings, loadAccounts, loadAccountsAsync, saveAccounts, initCloudConfig, loadAllowlist, saveAllowlist, loadAutocomplete, saveAutocomplete, getStorePath, getStorageInfo, getConfigDir } from "@bobfrankston/mailx-settings";
+import { sanitizeHtml, encodeQuotedPrintable } from "@bobfrankston/mailx-types";
 import { simpleParser } from "mailparser";
-// ── Quoted-printable encoding (readable in debug .eml files) ──
-function encodeQuotedPrintable(text) {
-    const bytes = Buffer.from(text, "utf-8");
-    let line = "";
-    let result = "";
-    for (let i = 0; i < bytes.length; i++) {
-        const b = bytes[i];
-        let encoded;
-        if (b === 0x0D && bytes[i + 1] === 0x0A) {
-            // CRLF — output as-is
-            result += line + "\r\n";
-            line = "";
-            i++; // skip LF
-            continue;
-        }
-        else if (b === 0x0A) {
-            // Bare LF — normalize to CRLF
-            result += line + "\r\n";
-            line = "";
-            continue;
-        }
-        else if ((b >= 33 && b <= 126 && b !== 61) || b === 9 || b === 32) {
-            encoded = String.fromCharCode(b);
-        }
-        else {
-            encoded = "=" + b.toString(16).toUpperCase().padStart(2, "0");
-        }
-        if (line.length + encoded.length > 75) {
-            result += line + "=\r\n";
-            line = "";
-        }
-        line += encoded;
-    }
-    result += line;
-    return result;
-}
 // ── Email provider detection (MX-based) ──
 const GOOGLE_DOMAINS = ["gmail.com", "googlemail.com"];
 const MS_DOMAINS = ["outlook.com", "hotmail.com", "live.com"];
@@ -67,30 +32,7 @@ async function detectEmailProvider(domain) {
     catch { /* DNS lookup failed */ }
     return null;
 }
-// ── Sanitize ──
-export function sanitizeHtml(html) {
-    let hasRemoteContent = false;
-    let clean = html.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "");
-    clean = clean.replace(/\s+on\w+\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, "");
-    clean = clean.replace(/<img\b([^>]*)\bsrc\s*=\s*("[^"]*"|'[^']*')/gi, (match, before, src) => {
-        const url = src.slice(1, -1);
-        if (url.startsWith("data:") || url.startsWith("cid:"))
-            return match;
-        hasRemoteContent = true;
-        return `<img${before}src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='20' height='20'%3E%3Crect fill='%23888' width='20' height='20' rx='3'/%3E%3Ctext x='10' y='14' text-anchor='middle' fill='white' font-size='12'%3E⊘%3C/text%3E%3C/svg%3E" data-blocked-src=${src} title="Remote image blocked"`;
-    });
-    clean = clean.replace(/<link\b[^>]*rel\s*=\s*["']stylesheet["'][^>]*>/gi, (match) => {
-        hasRemoteContent = true;
-        return `<!-- blocked: ${match.replace(/--/g, "")} -->`;
-    });
-    clean = clean.replace(/url\s*\(\s*(['"]?)(https?:\/\/[^)]+)\1\s*\)/gi, (_match, _q, url) => {
-        hasRemoteContent = true;
-        return `url("") /* blocked: ${url} */`;
-    });
-    clean = clean.replace(/<\/?form\b[^>]*>/gi, "");
-    clean = clean.replace(/<iframe\b[^>]*>[\s\S]*?<\/iframe>/gi, "");
-    return { html: clean, hasRemoteContent };
-}
+// sanitizeHtml and encodeQuotedPrintable imported from @bobfrankston/mailx-types (shared with Android)
 // ── Service ──
 export class MailxService {
     db;
@@ -154,13 +96,27 @@ export class MailxService {
                 err.isNotFound = true;
                 throw err;
             }
+            // Don't stuff the error text into bodyText — it bleeds into the
+            // viewer's main content area. Surface as a structured error field
+            // so the UI can render a banner with retry UX above the (empty)
+            // body. The caller keeps the envelope so the header still shows.
+            const rawErr = fetchErr.message || "connection failed";
+            const isTransient = /connection|Too many|UNAVAILABLE|rate|429|5\d\d|timeout|ENOTFOUND|ECONNRESET|ETIMEDOUT/i.test(rawErr);
             return {
-                ...envelope, bodyHtml: "", bodyText: `[Message body unavailable: ${fetchErr.message || "connection failed"}]`,
+                ...envelope, bodyHtml: "", bodyText: "",
+                bodyError: rawErr,
+                bodyErrorTransient: isTransient,
                 hasRemoteContent: false, remoteAllowed: false, attachments: [], emlPath: "", deliveredTo: "", returnPath: "", listUnsubscribe: ""
             };
         }
         if (!raw) {
-            bodyText = "[Message body not cached locally and the server fetch returned nothing. Try re-syncing the folder.]";
+            // Same treatment as the thrown-error case: structured field, not body text.
+            return {
+                ...envelope, bodyHtml: "", bodyText: "",
+                bodyError: "Message body not cached locally and the server fetch returned nothing.",
+                bodyErrorTransient: true,
+                hasRemoteContent: false, remoteAllowed: false, attachments: [], emlPath: "", deliveredTo: "", returnPath: "", listUnsubscribe: ""
+            };
         }
         else {
             const parsed = await simpleParser(raw);

package/packages/mailx-store-web/android-bootstrap.js

@@ -110,25 +110,30 @@ class AndroidSyncManager {
     async syncAll() {
         const accounts = this.db.getAccounts();
         vlog(`syncAll: ${accounts.length} accounts in DB: ${accounts.map(a => a.id).join(",")}`);
+        // Phase 1: Sync INBOX for every account first — user sees new mail fast.
         for (const account of accounts) {
-            const hasProvider = this.providers.has(account.id);
-            vlog(`syncAll: ${account.id} hasProvider=${hasProvider}`);
+            if (!this.providers.has(account.id))
+                continue;
             try {
                 const folders = await this.syncFolders(account.id);
-                vlog(`syncAll: ${account.id} got ${folders.length} folders`);
-                const sorted = [...folders].sort((a, b) => {
-                    if (a.specialUse === "inbox")
-                        return -1;
-                    if (b.specialUse === "inbox")
-                        return 1;
-                    return 0;
-                });
-                // Sync every folder, not just the first five — the old slice(0, 5)
-                // meant subfolders past the cutoff (e.g. _spam, custom labels)
-                // never picked up moves made on other clients, and those moves
-                // also stayed visible in the source folder because reconcile
-                // (below in syncFolder) never ran for the target.
-                for (const folder of sorted) {
+                const inbox = folders.find(f => f.specialUse === "inbox");
+                if (inbox) {
+                    await this.syncFolder(account.id, inbox.id);
+                    emitEvent({ type: "syncComplete", accountId: account.id });
+                }
+            }
+            catch (e) {
+                console.error(`[sync] ${account.id} inbox: ${e.message}`);
+            }
+        }
+        // Phase 2: Remaining folders (sent, drafts, trash, then everything else).
+        for (const account of accounts) {
+            if (!this.providers.has(account.id))
+                continue;
+            try {
+                const folders = this.db.getFolders(account.id);
+                const remaining = folders.filter(f => f.specialUse !== "inbox");
+                for (const folder of remaining) {
                     try {
                         await this.syncFolder(account.id, folder.id);
                     }
@@ -689,13 +694,15 @@ async function waitForNativeBridge(timeoutMs = 5000) {
     });
 }
 export async function initAndroid() {
-    console.log("[android] Initializing mailx...");
-    // Wait for C# to inject the native bridge (TCP/FS/HTTP + OAuth)
+    console.log("[android] Initializing mailx (Worker mode)...");
+    // Use the Worker host — all service logic runs off the main thread.
+    const { createWorkerHost } = await import("./main-thread-host.js");
+    await createWorkerHost();
+    console.log("[android] Worker host initialized");
+    return;
+    // ── Legacy main-thread path (kept for reference, unreachable) ──
+    // eslint-disable-next-line no-unreachable
     await waitForNativeBridge();
-    console.log(`[android] Native bridge: ${window._nativeBridge ? "ready" : "timeout"}`);
-    // iflow-direct's BridgeTransport expects a global `msgapi` with a .tcp
-    // subobject. Our MAUI shell exposes the same API under `_nativeBridge`, so
-    // alias it. Must happen before any IMAP client is constructed.
     if (window._nativeBridge && !window.msgapi) {
         window.msgapi = window._nativeBridge;
     }
@@ -788,6 +795,14 @@ export async function initAndroid() {
         vlog("periodic sync poll");
         syncManager.syncAll().catch(e => console.error(`[android] Periodic sync error: ${e.message}`));
     }, SYNC_INTERVAL_MS);
+    // Immediate sync when app comes back to foreground (e.g. user switches from
+    // another app). Without this, new messages wait up to 2 minutes after resume.
+    document.addEventListener("visibilitychange", () => {
+        if (document.visibilityState === "visible") {
+            console.log("[sync] resume poll");
+            syncManager.syncAll().catch(e => console.error(`[android] Resume sync error: ${e.message}`));
+        }
+    });
     console.log("[android] Initialization complete");
     emitEvent({ type: "connected" });
 }

package/packages/mailx-store-web/db.js

@@ -7,6 +7,7 @@
  * Bodies are stored in IndexedDB via WebMessageStore (not filesystem).
  */
 import initSqlJs from "sql.js";
+import { parseSearchQuery } from "@bobfrankston/mailx-types";
 const SCHEMA = `
     CREATE TABLE IF NOT EXISTS accounts (
         id TEXT PRIMARY KEY,
@@ -433,20 +434,20 @@ export class WebMailxDB {
     // ── Search ──
     searchMessages(query, page = 1, pageSize = 50, accountId, folderId) {
         const offset = (page - 1) * pageSize;
-        const term = `%${query}%`;
-        let where = "(subject LIKE ? OR from_name LIKE ? OR from_address LIKE ? OR preview LIKE ?)";
-        const params = [term, term, term, term];
+        const parsed = parseSearchQuery(query);
+        const allParams = [...parsed.params];
+        let where = parsed.conditions.length > 0 ? parsed.conditions.join(" AND ") : "1=0";
         if (accountId && folderId) {
             where += " AND account_id = ? AND folder_id = ?";
-            params.push(accountId, folderId);
+            allParams.push(accountId, folderId);
         }
         else if (accountId) {
             where += " AND account_id = ?";
-            params.push(accountId);
+            allParams.push(accountId);
         }
-        const countRow = this.get(`SELECT COUNT(*) as cnt FROM messages WHERE ${where}`, params);
+        const countRow = this.get(`SELECT COUNT(*) as cnt FROM messages WHERE ${where}`, allParams);
         const total = countRow?.cnt || 0;
-        const rows = this.all(`SELECT * FROM messages WHERE ${where} ORDER BY date DESC LIMIT ? OFFSET ?`, [...params, pageSize, offset]);
+        const rows = this.all(`SELECT * FROM messages WHERE ${where} ORDER BY date DESC LIMIT ? OFFSET ?`, [...allParams, pageSize, offset]);
         return { items: rows.map(r => this.rowToEnvelope(r)), total, page, pageSize };
     }
     // ── Sync Actions ──

package/packages/mailx-store-web/gmail-api-web.d.ts

@@ -1,37 +1,11 @@
 /**
- * Web-compatible Gmail API provider.
- * Identical to packages/mailx-imap/providers/gmail-api.ts but uses
- * atob() instead of Buffer.from() for base64 decoding (no Node.js deps).
+ * Back-compat re-export. The Gmail provider is now a single implementation
+ * in @bobfrankston/mailx-sync, used by both desktop (mailx-imap) and
+ * Android (this package). Bug fixes (e.g. 403-quota retry, bounded
+ * concurrency) land in one place and apply to both platforms.
  *
- * This file is a standalone copy — not imported from mailx-imap — because
- * mailx-imap depends on Node.js modules (node:events, node:fs, mailparser, etc.)
- * that aren't available in a WebView.
+ * `GmailApiWebProvider` is kept as an alias for back-compat with existing
+ * Android wiring; it's the same class as `GmailApiProvider`.
  */
-import type { MailProvider, ProviderFolder, ProviderMessage, FetchOptions } from "./provider-types.js";
-export declare class GmailApiWebProvider implements MailProvider {
-    private tokenProvider;
-    constructor(tokenProvider: () => Promise<string>);
-    private apiFetch;
-    listFolders(): Promise<ProviderFolder[]>;
-    private listMessageIds;
-    private batchFetch;
-    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[]>;
-    /** Fetch a message directly by Gmail provider ID — fast path, no listing needed */
-    fetchById(providerId: string, options?: FetchOptions): Promise<ProviderMessage | null>;
-    fetchOne(folder: string, uid: number, options?: FetchOptions): Promise<ProviderMessage | null>;
-    getUids(folder: string): Promise<number[]>;
-    close(): Promise<void>;
-    /** Send an RFC 2822 message via Gmail API users.messages.send. The server
-     *  handles SMTP — we just hand it the raw bytes base64url-encoded. Auto-files
-     *  a copy into the Sent label, so caller does NOT need to APPEND to Sent. */
-    sendRaw(rawRfc822: string): Promise<{
-        id: string;
-        threadId: string;
-    }>;
-    private folderToLabel;
-    private formatDate;
-}
+export { GmailApiProvider as GmailApiWebProvider } from "@bobfrankston/mailx-sync";
 //# sourceMappingURL=gmail-api-web.d.ts.map