@bobfrankston/mailx 1.0.256 → 1.0.260

package/packages/mailx-store-web/provider-types.d.ts

@@ -1,50 +1,7 @@
 /**
- * Mail provider interface for web (browser/Android).
- * Identical to @bobfrankston/mailx-imap/providers/types.ts.
- * Duplicated here to avoid importing from mailx-imap (which depends on Node.js).
+ * Back-compat re-export. Canonical types live in @bobfrankston/mailx-sync.
+ * Earlier this file was a hand-maintained copy of mailx-imap's types — that
+ * arrangement drifted. Now both sides import from one place.
  */
-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;
-    }[];
-    seen: boolean;
-    flagged: boolean;
-    answered: boolean;
-    draft: boolean;
-    size: number;
-    source: string;
-}
-export interface FetchOptions {
-    source?: boolean;
-}
-export interface MailProvider {
-    listFolders(): Promise<ProviderFolder[]>;
-    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[]>;
-    fetchOne(folder: string, uid: number, options?: FetchOptions): Promise<ProviderMessage | null>;
-    getUids(folder: string): Promise<number[]>;
-    close(): Promise<void>;
-}
+export type { MailProvider, ProviderFolder, ProviderMessage, FetchOptions } from "@bobfrankston/mailx-sync";
 //# sourceMappingURL=provider-types.d.ts.map

package/packages/mailx-store-web/provider-types.js

@@ -1,7 +1,7 @@
 /**
- * Mail provider interface for web (browser/Android).
- * Identical to @bobfrankston/mailx-imap/providers/types.ts.
- * Duplicated here to avoid importing from mailx-imap (which depends on Node.js).
+ * Back-compat re-export. Canonical types live in @bobfrankston/mailx-sync.
+ * Earlier this file was a hand-maintained copy of mailx-imap's types — that
+ * arrangement drifted. Now both sides import from one place.
  */
 export {};
 //# sourceMappingURL=provider-types.js.map

package/packages/mailx-store-web/sync-manager.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Sync manager — extracted from android-bootstrap.ts for use in both
+ * main-thread and Worker contexts.
+ *
+ * Platform-specific dependencies are injected:
+ *   - emitEvent: posts events to the UI
+ *   - vlog: verbose remote logging
+ *   - createTcpTransport: factory for TCP transport (BridgeTcpTransport or WorkerTcpTransport)
+ */
+import type { WebMailxDB } from "./db.js";
+import type { WebMessageStore } from "./web-message-store.js";
+import type { WebSyncManager } from "./web-service.js";
+import type { Folder, AccountConfig } from "@bobfrankston/mailx-types";
+export interface SyncManagerDeps {
+    emitEvent: (event: any) => void;
+    vlog: (msg: string) => void;
+    createTcpTransport: () => any;
+}
+export declare class SyncManager implements WebSyncManager {
+    private db;
+    private bodyStore;
+    private providers;
+    private tokenProviders;
+    private deps;
+    constructor(db: WebMailxDB, bodyStore: WebMessageStore, deps: SyncManagerDeps);
+    on(_event: string, _handler: (...args: any[]) => void): void;
+    emit(event: string, ...args: any[]): void;
+    addAccount(account: AccountConfig): Promise<void>;
+    setTokenProvider(accountId: string, provider: () => Promise<string>): void;
+    private isGmailAccount;
+    private getProvider;
+    syncAll(): Promise<void>;
+    syncAccount(accountId: string): Promise<void>;
+    syncFolders(accountId: string): Promise<Folder[]>;
+    syncFolder(accountId: string, folderId: number): Promise<void>;
+    private storeProviderMessages;
+    fetchMessageBody(accountId: string, folderId: number, uid: number): Promise<Uint8Array | null>;
+    updateFlagsLocal(accountId: string, uid: number, folderId: number, flags: string[]): Promise<void>;
+    trashMessage(accountId: string, folderId: number, uid: number): Promise<void>;
+    trashMessages(accountId: string, messages: {
+        uid: number;
+        folderId: number;
+    }[]): Promise<void>;
+    moveMessage(accountId: string, uid: number, folderId: number, targetFolderId: number): Promise<void>;
+    moveMessages(accountId: string, messages: {
+        uid: number;
+        folderId: number;
+    }[], targetFolderId: number): Promise<void>;
+    moveMessageCrossAccount(): Promise<void>;
+    undeleteMessage(accountId: string, uid: number, folderId: number): Promise<void>;
+    markFolderRead(folderId: number): Promise<void>;
+    emptyFolder(accountId: string, folderId: number): Promise<void>;
+    queueOutgoingLocal(accountId: string, rawMessage: string): void;
+    private sendViaSmtpDirect;
+    saveDraft(_accountId: string, _raw: string, _prevUid?: number, _draftId?: string): Promise<number | null>;
+    deleteDraft(_accountId: string, _uid: number): Promise<void>;
+    reauthenticate(_accountId: string): Promise<boolean>;
+    searchOnServer(_accountId: string, _query: string): Promise<any[]>;
+    syncAllContacts(): Promise<void>;
+}
+//# sourceMappingURL=sync-manager.d.ts.map

package/packages/mailx-store-web/sync-manager.js

@@ -0,0 +1,422 @@
+/**
+ * Sync manager — extracted from android-bootstrap.ts for use in both
+ * main-thread and Worker contexts.
+ *
+ * Platform-specific dependencies are injected:
+ *   - emitEvent: posts events to the UI
+ *   - vlog: verbose remote logging
+ *   - createTcpTransport: factory for TCP transport (BridgeTcpTransport or WorkerTcpTransport)
+ */
+import { GmailApiWebProvider } from "./gmail-api-web.js";
+import { ImapWebProvider } from "./imap-web-provider.js";
+import { SmtpClient } from "@bobfrankston/smtp-direct";
+function toEmailAddress(addr) {
+    return { name: addr?.name || "", address: addr?.address || "" };
+}
+export class SyncManager {
+    db;
+    bodyStore;
+    providers = new Map();
+    tokenProviders = new Map();
+    deps;
+    constructor(db, bodyStore, deps) {
+        this.db = db;
+        this.bodyStore = bodyStore;
+        this.deps = deps;
+    }
+    on(_event, _handler) { }
+    emit(event, ...args) { this.deps.emitEvent({ type: event, ...args[0] }); }
+    async addAccount(account) {
+        this.deps.vlog(`addAccount id=${account.id} email=${account.email} host=${account.imap?.host} auth=${account.imap?.auth}`);
+        this.db.upsertAccount(account.id, account.name, account.email, JSON.stringify(account));
+        if (this.isGmailAccount(account)) {
+            const tokenProvider = this.tokenProviders.get(account.id);
+            if (tokenProvider) {
+                this.providers.set(account.id, new GmailApiWebProvider(tokenProvider));
+                console.log(`[sync] ${account.id}: Gmail API provider registered`);
+            }
+            else {
+                console.warn(`[sync] ${account.id}: no token provider`);
+            }
+        }
+        else if (account.imap?.host && account.imap?.user) {
+            try {
+                const provider = new ImapWebProvider({
+                    server: account.imap.host,
+                    port: account.imap.port || 993,
+                    username: account.imap.user,
+                    password: account.imap.password,
+                    inactivityTimeout: 300000,
+                    fetchChunkSize: 10,
+                    fetchChunkSizeMax: 100,
+                }, this.deps.createTcpTransport);
+                this.providers.set(account.id, provider);
+                this.deps.vlog(`addAccount ${account.id}: IMAP provider registered (${account.imap.host}:${account.imap.port})`);
+                console.log(`[sync] ${account.id}: IMAP provider registered (${account.imap.host})`);
+            }
+            catch (e) {
+                this.deps.vlog(`addAccount ${account.id}: IMAP provider FAILED: ${e.message}`);
+                console.error(`[sync] ${account.id}: IMAP provider failed: ${e.message}`);
+            }
+        }
+        else {
+            this.deps.vlog(`addAccount ${account.id}: no imap config, skipping`);
+        }
+    }
+    setTokenProvider(accountId, provider) {
+        this.tokenProviders.set(accountId, provider);
+    }
+    isGmailAccount(account) {
+        return account.imap?.host?.includes("gmail") || account.email?.endsWith("@gmail.com") || false;
+    }
+    getProvider(accountId) {
+        return this.providers.get(accountId) || null;
+    }
+    async syncAll() {
+        const accounts = this.db.getAccounts();
+        this.deps.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) {
+            if (!this.providers.has(account.id))
+                continue;
+            try {
+                const folders = await this.syncFolders(account.id);
+                const inbox = folders.find((f) => f.specialUse === "inbox");
+                if (inbox) {
+                    await this.syncFolder(account.id, inbox.id);
+                    this.deps.emitEvent({ type: "syncComplete", accountId: account.id });
+                }
+            }
+            catch (e) {
+                console.error(`[sync] ${account.id} inbox: ${e.message}`);
+            }
+        }
+        // Phase 2: Remaining folders.
+        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);
+                    }
+                    catch (e) {
+                        console.error(`[sync] Skip ${folder.path}: ${e.message}`);
+                    }
+                }
+                this.db.updateLastSync(account.id, Date.now());
+                this.deps.emitEvent({ type: "syncComplete", accountId: account.id });
+            }
+            catch (e) {
+                console.error(`[sync] ${account.id}: ${e.message}`);
+                this.deps.vlog(`syncAll: ${account.id} ERROR: ${e.message}`);
+                this.deps.emitEvent({ type: "syncError", accountId: account.id, error: e.message });
+            }
+        }
+    }
+    async syncAccount(accountId) {
+        const folders = await this.syncFolders(accountId);
+        for (const folder of folders) {
+            try {
+                await this.syncFolder(accountId, folder.id);
+            }
+            catch (e) {
+                console.error(`[sync] Skip ${folder.path}: ${e.message}`);
+            }
+        }
+        this.db.updateLastSync(accountId, Date.now());
+        this.deps.emitEvent({ type: "syncComplete", accountId });
+    }
+    async syncFolders(accountId) {
+        const provider = this.getProvider(accountId);
+        if (!provider) {
+            const existing = this.db.getFolders(accountId);
+            this.deps.vlog(`syncFolders: ${accountId} no provider, returning ${existing.length} cached folders`);
+            return existing;
+        }
+        this.deps.emitEvent({ type: "syncProgress", accountId, phase: "folders", progress: 0 });
+        const providerFolders = await provider.listFolders();
+        for (const folder of providerFolders) {
+            const flags = folder.flags || [];
+            if (flags.some((f) => f.toLowerCase() === "\\noselect"))
+                continue;
+            this.db.upsertFolder(accountId, folder.path, folder.name, folder.specialUse, folder.delimiter);
+        }
+        this.deps.emitEvent({ type: "syncProgress", accountId, phase: "folders", progress: 100 });
+        const dbFolders = this.db.getFolders(accountId);
+        this.deps.emitEvent({ type: "folderCountsChanged", accountId, counts: {} });
+        return dbFolders;
+    }
+    async syncFolder(accountId, folderId) {
+        const provider = this.getProvider(accountId);
+        if (!provider)
+            return;
+        const folders = this.db.getFolders(accountId);
+        const folder = folders.find((f) => f.id === folderId);
+        if (!folder)
+            return;
+        this.deps.emitEvent({ type: "syncProgress", accountId, phase: `sync:${folder.path}`, progress: 0 });
+        const highestUid = this.db.getHighestUid(accountId, folderId);
+        const startDate = new Date(Date.now() - 30 * 86400000);
+        let messages;
+        if (highestUid > 0) {
+            messages = await provider.fetchSince(folder.path, highestUid, { source: false });
+            messages = messages.filter((m) => m.uid > highestUid);
+        }
+        else {
+            const tomorrow = new Date(Date.now() + 86400000);
+            messages = await provider.fetchByDate(folder.path, startDate, tomorrow, { source: false });
+        }
+        if (messages.length > 0) {
+            console.log(`[sync] ${folder.path}: ${messages.length} messages`);
+            this.storeProviderMessages(accountId, folderId, messages);
+            this.db.recalcFolderCounts(folderId);
+            this.deps.emitEvent({ type: "folderCountsChanged", accountId, counts: {} });
+        }
+        // Reconcile deletions
+        try {
+            const serverUidsArr = await provider.getUids(folder.path);
+            const serverUids = new Set(serverUidsArr);
+            const localUids = this.db.getUidsForFolder(accountId, folderId);
+            if (serverUidsArr.length === 0 && localUids.length > 0) {
+                console.log(`[sync] ${folder.path}: reconcile skipped — server returned empty but local has ${localUids.length}`);
+            }
+            else {
+                const toDelete = localUids.filter((uid) => !serverUids.has(uid));
+                const RECONCILE_DELETE_THRESHOLD = 0.5;
+                if (localUids.length > 0 && toDelete.length / localUids.length > RECONCILE_DELETE_THRESHOLD) {
+                    console.log(`[sync] ${folder.path}: reconcile refused — would delete ${toDelete.length}/${localUids.length}`);
+                }
+                else {
+                    for (const uid of toDelete) {
+                        this.db.deleteMessage(accountId, uid);
+                        this.bodyStore.deleteMessage(accountId, folderId, uid).catch(() => { });
+                    }
+                    if (toDelete.length > 0) {
+                        console.log(`[sync] ${folder.path}: reconciled ${toDelete.length} deletions`);
+                        this.db.recalcFolderCounts(folderId);
+                        this.deps.emitEvent({ type: "folderCountsChanged", accountId, counts: {} });
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.error(`[sync] ${folder.path}: reconcile error: ${e.message}`);
+        }
+        this.deps.emitEvent({ type: "folderSynced", accountId, entries: [{ folderId, syncedAt: Date.now() }] });
+        this.deps.emitEvent({ type: "syncProgress", accountId, phase: `sync:${folder.path}`, progress: 100 });
+    }
+    storeProviderMessages(accountId, folderId, messages) {
+        this.db.beginTransaction();
+        try {
+            for (const msg of messages) {
+                const flags = [];
+                if (msg.seen)
+                    flags.push("\\Seen");
+                if (msg.flagged)
+                    flags.push("\\Flagged");
+                if (msg.answered)
+                    flags.push("\\Answered");
+                if (msg.draft)
+                    flags.push("\\Draft");
+                const bodyPath = msg.providerId ? `gmail:${msg.providerId}` : "";
+                this.db.upsertMessage({
+                    accountId, folderId, uid: msg.uid,
+                    messageId: msg.messageId || "", inReplyTo: "", references: [],
+                    date: msg.date ? msg.date.getTime() : Date.now(),
+                    subject: msg.subject || "",
+                    from: toEmailAddress(msg.from?.[0]),
+                    to: msg.to.map((a) => toEmailAddress(a)),
+                    cc: msg.cc.map((a) => toEmailAddress(a)),
+                    flags, size: msg.size || 0, hasAttachments: false, preview: "", bodyPath,
+                });
+            }
+            this.db.commitTransaction();
+        }
+        catch (e) {
+            this.db.rollbackTransaction();
+            console.error(`[sync] storeMessages error: ${e.message}`);
+        }
+    }
+    async fetchMessageBody(accountId, folderId, uid) {
+        if (await this.bodyStore.hasMessage(accountId, folderId, uid)) {
+            return this.bodyStore.getMessage(accountId, folderId, uid);
+        }
+        const provider = this.getProvider(accountId);
+        if (!provider)
+            return null;
+        const envelope = this.db.getMessageByUid(accountId, uid, folderId);
+        const bp = envelope?.bodyPath || "";
+        let msg = null;
+        if (bp.startsWith("gmail:") && provider.fetchById) {
+            const providerId = bp.substring(6);
+            msg = await provider.fetchById(providerId, { source: true });
+        }
+        else {
+            const folders = this.db.getFolders(accountId);
+            const folder = folders.find((f) => f.id === folderId);
+            if (!folder)
+                return null;
+            msg = await provider.fetchOne(folder.path, uid, { source: true });
+        }
+        if (!msg?.source) {
+            console.warn(`[fetchBody] No source returned for ${accountId}/${folderId}/${uid} (bp=${bp})`);
+            return null;
+        }
+        const raw = new TextEncoder().encode(msg.source);
+        await this.bodyStore.putMessage(accountId, folderId, uid, raw);
+        this.db.updateBodyPath(accountId, uid, `idb:${accountId}/${folderId}/${uid}`);
+        return raw;
+    }
+    async updateFlagsLocal(accountId, uid, folderId, flags) {
+        this.db.updateMessageFlags(accountId, uid, flags);
+        this.db.recalcFolderCounts(folderId);
+        this.db.queueSyncAction(accountId, "flags", uid, folderId, { flags });
+        this.deps.emitEvent({ type: "folderCountsChanged", accountId, counts: {} });
+    }
+    async trashMessage(accountId, folderId, uid) {
+        this.db.deleteMessage(accountId, uid);
+        this.db.queueSyncAction(accountId, "trash", uid, folderId);
+        this.deps.emitEvent({ type: "messageDeleted", accountId, folderId, uid });
+        this.deps.emitEvent({ type: "folderCountsChanged", accountId, counts: {} });
+    }
+    async trashMessages(accountId, messages) {
+        for (const m of messages)
+            await this.trashMessage(accountId, m.folderId, m.uid);
+    }
+    async moveMessage(accountId, uid, folderId, targetFolderId) {
+        this.db.queueSyncAction(accountId, "move", uid, folderId, { targetFolderId });
+        this.deps.emitEvent({ type: "messageMoved", accountId, fromFolderId: folderId, toFolderId: targetFolderId, uid });
+    }
+    async moveMessages(accountId, messages, targetFolderId) {
+        for (const m of messages)
+            await this.moveMessage(accountId, m.uid, m.folderId, targetFolderId);
+    }
+    async moveMessageCrossAccount() {
+        throw new Error("Cross-account move not supported on mobile");
+    }
+    async undeleteMessage(accountId, uid, folderId) {
+        this.db.queueSyncAction(accountId, "undelete", uid, folderId);
+    }
+    async markFolderRead(folderId) {
+        this.db.markFolderRead(folderId);
+    }
+    async emptyFolder(accountId, folderId) {
+        const uids = this.db.getUidsForFolder(accountId, folderId);
+        for (const uid of uids) {
+            this.db.deleteMessage(accountId, uid);
+            this.bodyStore.deleteMessage(accountId, folderId, uid).catch(() => { });
+        }
+        this.db.recalcFolderCounts(folderId);
+        this.deps.emitEvent({ type: "folderCountsChanged", accountId, counts: {} });
+    }
+    queueOutgoingLocal(accountId, rawMessage) {
+        const provider = this.getProvider(accountId);
+        if (provider && typeof provider.sendRaw === "function") {
+            provider.sendRaw(rawMessage)
+                .then((result) => {
+                console.log(`[send] ${accountId}: sent via Gmail API (id=${result.id})`);
+                this.deps.emitEvent({ type: "sendComplete", accountId, messageId: result.id });
+            })
+                .catch((e) => {
+                console.error(`[send] ${accountId}: Gmail send failed: ${e.message}`);
+                this.deps.emitEvent({ type: "sendError", accountId, error: e.message });
+            });
+            return;
+        }
+        const accounts = this.db.getAccountConfigs();
+        const row = accounts.find((a) => a.id === accountId);
+        if (!row) {
+            const e = "Unknown account";
+            this.deps.emitEvent({ type: "sendError", accountId, error: e });
+            throw new Error(e);
+        }
+        let account;
+        try {
+            account = JSON.parse(row.configJson);
+        }
+        catch {
+            const e = "Account config malformed";
+            this.deps.emitEvent({ type: "sendError", accountId, error: e });
+            throw new Error(e);
+        }
+        if (!account.smtp) {
+            const e = "No SMTP config for this account";
+            this.deps.emitEvent({ type: "sendError", accountId, error: e });
+            throw new Error(e);
+        }
+        this.sendViaSmtpDirect(accountId, account, rawMessage)
+            .then((result) => {
+            console.log(`[send] ${accountId}: sent via SMTP (${result.accepted.length} accepted, ${result.rejected.length} rejected)`);
+            this.deps.emitEvent({ type: "sendComplete", accountId });
+        })
+            .catch((e) => {
+            console.error(`[send] ${accountId}: SMTP send failed: ${e.message}`);
+            this.deps.emitEvent({ type: "sendError", accountId, error: e.message });
+        });
+    }
+    async sendViaSmtpDirect(accountId, account, raw) {
+        const smtp = account.smtp;
+        const smtpPort = smtp.port || 587;
+        const smtpHost = smtp.host || account.imap?.host;
+        if (!smtpHost)
+            throw new Error("No SMTP host");
+        const smtpUser = smtp.user || account.imap?.user || account.email;
+        const authType = smtp.auth || (account.imap?.password ? "password" : undefined);
+        let auth;
+        if (authType === "password") {
+            const pass = smtp.password || account.imap?.password;
+            if (!pass)
+                throw new Error("SMTP password not configured");
+            auth = { method: "PLAIN", user: smtpUser, pass };
+        }
+        else if (authType === "oauth2") {
+            const tp = this.tokenProviders.get(accountId);
+            if (!tp)
+                throw new Error("OAuth token provider not registered");
+            const token = await tp();
+            auth = { method: "XOAUTH2", user: smtpUser, token };
+        }
+        const parseAddrs = (s) => s.match(/[\w.+-]+@[\w.-]+/g) || [];
+        const toMatch = raw.match(/^To:\s*(.+)$/mi);
+        const ccMatch = raw.match(/^Cc:\s*(.+)$/mi);
+        const bccMatch = raw.match(/^Bcc:\s*(.+)$/mi);
+        const fromMatch = raw.match(/^From:\s*(.+)$/mi);
+        const recipients = [
+            ...(toMatch ? parseAddrs(toMatch[1]) : []),
+            ...(ccMatch ? parseAddrs(ccMatch[1]) : []),
+            ...(bccMatch ? parseAddrs(bccMatch[1]) : []),
+        ];
+        const sender = fromMatch ? (parseAddrs(fromMatch[1])[0] || account.email) : account.email;
+        if (recipients.length === 0)
+            throw new Error("No recipients");
+        const rawToSend = raw.replace(/^Bcc:.*\r?\n/mi, "");
+        const client = new SmtpClient({
+            host: smtpHost,
+            port: smtpPort,
+            secure: smtpPort === 465,
+            auth,
+            localname: "mailx-android",
+        }, this.deps.createTcpTransport);
+        try {
+            await client.connect();
+            return await client.sendMail({ from: sender, to: recipients }, rawToSend);
+        }
+        finally {
+            try {
+                await client.quit();
+            }
+            catch { /* ignore */ }
+        }
+    }
+    async saveDraft(_accountId, _raw, _prevUid, _draftId) {
+        return null;
+    }
+    async deleteDraft(_accountId, _uid) { }
+    async reauthenticate(_accountId) { return false; }
+    async searchOnServer(_accountId, _query) { return []; }
+    async syncAllContacts() { }
+}
+//# sourceMappingURL=sync-manager.js.map

package/packages/mailx-store-web/worker-entry.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Worker entry point — runs the entire mailx service layer off the main thread.
+ *
+ * Hosts: wa-sqlite DB, sync manager, providers, service, settings.
+ * Main thread only handles UI rendering and proxies TCP/native bridge calls.
+ */
+export {};
+//# sourceMappingURL=worker-entry.d.ts.map