@bobfrankston/mailx 1.0.256 → 1.0.260

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

@@ -1,339 +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);
-    }
-    /** 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. */
-    async fetchBodiesBatch(folder, uids, onBody) {
-        if (uids.length === 0)
-            return;
-        const query = `in:${this.folderToLabel(folder)}`;
-        const ids = await this.listMessageIds(query, 10000);
-        const uidToId = new Map();
-        for (const id of ids)
-            uidToId.set(idToUid(id), id);
-        const wanted = [];
-        for (const uid of uids) {
-            const id = uidToId.get(uid);
-            if (id)
-                wanted.push({ uid, id });
-        }
-        if (wanted.length === 0)
-            return;
-        // Bounded concurrency — 10 in-flight is safe under Gmail's per-user rate
-        // limit (250 quota units/sec, messages.get = 5 units each = 50/sec cap).
-        const CONCURRENCY = 10;
-        let cursor = 0;
-        const worker = async () => {
-            while (cursor < wanted.length) {
-                const idx = cursor++;
-                const { uid, id } = wanted[idx];
-                try {
-                    const msg = await this.fetch(`/messages/${id}?format=raw`);
-                    if (!msg?.raw)
-                        continue;
-                    const base64 = msg.raw.replace(/-/g, "+").replace(/_/g, "/");
-                    const source = new TextDecoder().decode(Uint8Array.from(atob(base64), c => c.charCodeAt(0)));
-                    onBody(uid, source);
-                }
-                catch (e) {
-                    // Per-message failure is non-fatal; keep worker alive for the rest.
-                    console.error(`  [gmail batch] UID ${uid}: ${e.message}`);
-                }
-            }
-        };
-        await Promise.all(Array.from({ length: Math.min(CONCURRENCY, wanted.length) }, () => worker()));
-    }
-    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.js

@@ -96,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

@@ -694,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;
     }

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

@@ -1,41 +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>;
-    /** Bulk-fetch raw bodies for many UIDs in one Gmail label. Lists the label
-     *  once, builds UID→ID map, streams bodies via `onBody` with bounded
-     *  concurrency. Mirrors GmailApiProvider.fetchBodiesBatch on desktop. */
-    fetchBodiesBatch(folder: string, uids: number[], onBody: (uid: number, source: string) => void): 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