@bobfrankston/mailx 1.0.179 → 1.0.180

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

@@ -0,0 +1,340 @@
+/**
+ * Android bootstrap — wires WebMailxDB + WebMessageStore + GmailApiWebProvider + WebMailxService
+ * into the mailxapi bridge. This replaces Node.js backend for Android WebView.
+ *
+ * On Android, everything runs in the same JavaScript context:
+ * - wa-sqlite for metadata (via WebMailxDB)
+ * - IndexedDB for message bodies (via WebMessageStore)
+ * - Gmail/Outlook sync via REST APIs (plain fetch — no native bridge needed)
+ * - IMAP accounts use BridgeTransport (via MAUI TCP bridge) — not yet implemented
+ *
+ * The existing client UI (app.ts, components/) is completely unchanged —
+ * it calls window.mailxapi.* which this module provides.
+ */
+import { WebMailxDB } from "./db.js";
+import { WebMessageStore } from "./web-message-store.js";
+import { WebMailxService } from "./web-service.js";
+import { loadAccounts, clearSettings } from "./web-settings.js";
+import { GmailApiWebProvider } from "./gmail-api-web.js";
+// ── State ──
+let db;
+let bodyStore;
+let service;
+let syncManager;
+const eventHandlers = [];
+// ── Event emitter ──
+function emitEvent(event) {
+    for (const h of eventHandlers) {
+        try {
+            h(event);
+        }
+        catch { /* ignore */ }
+    }
+    if (typeof window._mailxapiEvent === "function") {
+        window._mailxapiEvent(event);
+    }
+}
+// ── Helpers ──
+function toEmailAddress(addr) {
+    return { name: addr?.name || "", address: addr?.address || "" };
+}
+// ── Sync Manager ──
+class AndroidSyncManager {
+    db;
+    bodyStore;
+    providers = new Map();
+    tokenProviders = new Map();
+    constructor(db, bodyStore) {
+        this.db = db;
+        this.bodyStore = bodyStore;
+    }
+    on(_event, _handler) { }
+    emit(event, ...args) { emitEvent({ type: event, ...args[0] }); }
+    async addAccount(account) {
+        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`);
+            }
+        }
+    }
+    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();
+        for (const account of accounts) {
+            try {
+                const folders = await this.syncFolders(account.id);
+                const sorted = [...folders].sort((a, b) => {
+                    if (a.specialUse === "inbox")
+                        return -1;
+                    if (b.specialUse === "inbox")
+                        return 1;
+                    return 0;
+                });
+                for (const folder of sorted.slice(0, 5)) {
+                    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());
+                emitEvent({ type: "syncComplete", accountId: account.id });
+            }
+            catch (e) {
+                console.error(`[sync] ${account.id}: ${e.message}`);
+                emitEvent({ type: "syncError", accountId: account.id, error: e.message });
+            }
+        }
+    }
+    async syncFolders(accountId) {
+        const provider = this.getProvider(accountId);
+        if (!provider)
+            return this.db.getFolders(accountId);
+        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);
+        }
+        emitEvent({ type: "syncProgress", accountId, phase: "folders", progress: 100 });
+        const dbFolders = this.db.getFolders(accountId);
+        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;
+        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);
+            emitEvent({ type: "folderCountsChanged", accountId, counts: {} });
+        }
+        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");
+                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 folders = this.db.getFolders(accountId);
+        const folder = folders.find(f => f.id === folderId);
+        if (!folder)
+            return null;
+        const msg = await provider.fetchOne(folder.path, uid, { source: true });
+        if (!msg?.source)
+            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 });
+        emitEvent({ type: "folderCountsChanged", accountId, counts: {} });
+    }
+    async trashMessage(accountId, folderId, uid) {
+        this.db.deleteMessage(accountId, uid);
+        this.db.queueSyncAction(accountId, "trash", uid, folderId);
+        emitEvent({ type: "messageDeleted", accountId, folderId, uid });
+        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 });
+        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);
+    }
+    queueOutgoingLocal(accountId, _rawMessage) {
+        console.log(`[send] Queued outgoing for ${accountId}`);
+    }
+    async saveDraft(_accountId, _raw, _prevUid, _draftId) {
+        return null;
+    }
+    async deleteDraft(_accountId, _draftUid) { }
+    async reauthenticate(_accountId) { return false; }
+    async searchOnServer() { return []; }
+    async syncAllContacts() { }
+}
+// ── Initialization ──
+export async function initAndroid() {
+    console.log("[android] Initializing mailx...");
+    db = new WebMailxDB("mailx");
+    await db.waitReady();
+    bodyStore = new WebMessageStore();
+    syncManager = new AndroidSyncManager(db, bodyStore);
+    service = new WebMailxService(db, bodyStore, syncManager);
+    const accounts = await loadAccounts();
+    console.log(`[android] ${accounts.length} account(s) found`);
+    for (const account of accounts) {
+        if (!account.enabled)
+            continue;
+        await syncManager.addAccount(account);
+    }
+    installBridge();
+    setTimeout(() => {
+        syncManager.syncAll().catch(e => console.error(`[android] Sync error: ${e.message}`));
+    }, 1000);
+    console.log("[android] Initialization complete");
+    emitEvent({ type: "connected" });
+}
+export async function resetStore() {
+    await service.resetStore();
+    await clearSettings();
+    console.log("[android] Store reset");
+}
+// ── mailxapi Bridge ──
+function installBridge() {
+    const api = {
+        isApp: true,
+        platform: "android",
+        getAccounts: () => service.getAccounts(),
+        getFolders: (accountId) => service.getFolders(accountId),
+        getMessages: (accountId, folderId, page, pageSize) => service.getMessages(accountId, folderId, page, pageSize),
+        getUnifiedInbox: (page, pageSize) => service.getUnifiedInbox(page, pageSize),
+        getMessage: (accountId, uid, allowRemote, folderId) => service.getMessage(accountId, uid, allowRemote, folderId),
+        updateFlags: async (accountId, uid, flags) => {
+            await service.updateFlags(accountId, uid, flags);
+            return { ok: true };
+        },
+        deleteMessage: async (accountId, uid) => {
+            await service.deleteMessage(accountId, uid);
+            return { ok: true };
+        },
+        deleteMessages: async (accountId, uids) => {
+            await service.deleteMessages(accountId, uids);
+            return { ok: true, count: uids.length };
+        },
+        undeleteMessage: async (accountId, uid, folderId) => {
+            await service.undeleteMessage(accountId, uid, folderId);
+            return { ok: true };
+        },
+        moveMessage: async (accountId, uid, targetFolderId, targetAccountId) => {
+            await service.moveMessage(accountId, uid, targetFolderId, targetAccountId);
+            return { ok: true };
+        },
+        moveMessages: async (accountId, uids, targetFolderId) => {
+            await service.moveMessages(accountId, uids, targetFolderId);
+            return { ok: true, count: uids.length };
+        },
+        sendMessage: async (msg) => { await service.send(msg); return { ok: true }; },
+        saveDraft: (p) => service.saveDraft(p.accountId, p.subject, p.bodyHtml, p.bodyText, p.to, p.cc, p.previousDraftUid, p.draftId),
+        deleteDraft: async (accountId, draftUid) => {
+            await service.deleteDraft(accountId, draftUid);
+            return { ok: true };
+        },
+        searchMessages: (query, page, pageSize) => service.search(query, page, pageSize),
+        searchContacts: (query) => service.searchContacts(query),
+        syncAll: async () => { await service.syncAll(); return { ok: true }; },
+        syncAccount: async (accountId) => { await service.syncAccount(accountId); return { ok: true }; },
+        getSyncPending: () => service.getSyncPending(),
+        reauthenticate: async (accountId) => ({ ok: await service.reauthenticate(accountId) }),
+        markFolderRead: (_accountId, folderId) => { service.markFolderRead(folderId); return { ok: true }; },
+        createFolder: async () => ({ ok: false, error: "Not supported on mobile" }),
+        renameFolder: async () => ({ ok: false, error: "Not supported on mobile" }),
+        deleteFolder: async () => ({ ok: false, error: "Not supported on mobile" }),
+        emptyFolder: async () => ({ ok: false, error: "Not supported on mobile" }),
+        allowRemoteContent: async (type, value) => {
+            await service.allowRemoteContent(type, value);
+            return { ok: true };
+        },
+        getSettings: () => service.getSettings(),
+        saveSettingsData: async (data) => { await service.saveSettingsData(data); return { ok: true }; },
+        getVersion: async () => {
+            const settings = await service.getSettings();
+            return { version: "1.0.0-android", theme: settings.ui?.theme || "system", storage: service.getStorageInfo(), platform: "android" };
+        },
+        getAutocompleteSettings: () => service.getAutocompleteSettings(),
+        saveAutocompleteSettings: async (settings) => { await service.saveAutocompleteSettings(settings); return { ok: true }; },
+        setupAccount: async () => ({ ok: false, error: "Use desktop for initial setup" }),
+        repairAccounts: async () => ({ ok: false, error: "Use desktop for repair" }),
+        resetStore: () => resetStore(),
+        restart: () => { location.reload(); },
+        onEvent: (handler) => { eventHandlers.push(handler); },
+    };
+    window.mailxapi = api;
+    window.dispatchEvent(new CustomEvent("mailxapiready"));
+    console.log("[android] mailxapi bridge installed");
+}
+//# sourceMappingURL=android-bootstrap.js.map

package/packages/mailx-store-web/db.d.ts

@@ -0,0 +1,112 @@
+/**
+ * WebAssembly SQLite metadata index for mailx (Android/browser).
+ * API-compatible with @bobfrankston/mailx-store's MailxDB.
+ * Uses sql.js (SQLite compiled to WebAssembly) for in-browser SQLite.
+ *
+ * Database is persisted to IndexedDB on every write operation.
+ * Bodies are stored in IndexedDB via WebMessageStore (not filesystem).
+ */
+import type { MessageEnvelope, Folder, EmailAddress, PagedResult, MessageQuery } from "@bobfrankston/mailx-types";
+export declare class WebMailxDB {
+    private db;
+    private ready;
+    private saveTimer;
+    constructor(dbName?: string);
+    private init;
+    /** Wait for DB initialization */
+    waitReady(): Promise<void>;
+    /** Persist DB to IndexedDB (debounced — batches rapid writes) */
+    private scheduleSave;
+    /** Force immediate persist */
+    flush(): Promise<void>;
+    close(): void;
+    private run;
+    private get;
+    private all;
+    private lastId;
+    upsertAccount(id: string, name: string, email: string, configJson: string): void;
+    getAccounts(): {
+        id: string;
+        name: string;
+        email: string;
+        lastSync: number;
+    }[];
+    getAccountConfigs(): {
+        id: string;
+        name: string;
+        email: string;
+        configJson: string;
+    }[];
+    updateLastSync(accountId: string, timestamp: number): void;
+    upsertFolder(accountId: string, folderPath: string, name: string, specialUse: string, delimiter: string): number;
+    getFolders(accountId: string): Folder[];
+    deleteFolder(folderId: number): void;
+    markFolderRead(folderId: number): void;
+    deleteAllMessages(accountId: string, folderId: number): void;
+    updateFolderCounts(folderId: number, total: number, unread: number): void;
+    updateFolderSync(folderId: number, uidvalidity: number, highestModseq: string): void;
+    getFolderSync(folderId: number): {
+        uidvalidity: number;
+        highestModseq: string;
+    };
+    upsertMessage(msg: {
+        accountId: string;
+        folderId: number;
+        uid: number;
+        messageId: string;
+        inReplyTo: string;
+        references: string[];
+        date: number;
+        subject: string;
+        from: EmailAddress;
+        to: EmailAddress[];
+        cc: EmailAddress[];
+        flags: string[];
+        size: number;
+        hasAttachments: boolean;
+        preview: string;
+        bodyPath: string;
+    }): number;
+    getMessages(query: MessageQuery): PagedResult<MessageEnvelope>;
+    getUnifiedInbox(page?: number, pageSize?: number): PagedResult<MessageEnvelope>;
+    getMessageByUid(accountId: string, uid: number, folderId?: number): MessageEnvelope;
+    getMessageBodyPath(accountId: string, uid: number): string;
+    updateMessageFlags(accountId: string, uid: number, flags: string[]): void;
+    updateBodyPath(accountId: string, uid: number, bodyPath: string): void;
+    getMessagesWithoutBody(accountId: string, limit?: number): {
+        uid: number;
+        folderId: number;
+    }[];
+    getHighestUid(accountId: string, folderId: number): number;
+    getOldestDate(accountId: string, folderId: number): number;
+    getMessageCount(accountId: string, folderId: number): number;
+    getUidsForFolder(accountId: string, folderId: number): number[];
+    deleteMessage(accountId: string, uid: number): void;
+    recalcFolderCounts(folderId: number): void;
+    beginTransaction(): void;
+    commitTransaction(): void;
+    rollbackTransaction(): void;
+    recordSentAddress(name: string, email: string): void;
+    seedContactsFromMessages(): number;
+    searchContacts(query: string, limit?: number): {
+        name: string;
+        email: string;
+        source: string;
+        useCount: number;
+    }[];
+    searchMessages(query: string, page?: number, pageSize?: number, accountId?: string, folderId?: number): PagedResult<MessageEnvelope>;
+    queueSyncAction(accountId: string, action: string, uid: number, folderId: number, extra?: {
+        targetFolderId?: number;
+        flags?: string[];
+        rawMessage?: string;
+    }): void;
+    getPendingSyncActions(accountId: string): any[];
+    completeSyncAction(id: number): void;
+    failSyncAction(id: number, error: string): void;
+    getPendingSyncCount(accountId: string): number;
+    getTotalPendingSyncCount(): number;
+    /** Reset the entire database */
+    resetStore(): Promise<void>;
+    private rowToEnvelope;
+}
+//# sourceMappingURL=db.d.ts.map