@bobfrankston/mailx 1.0.178 → 1.0.180

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

@@ -0,0 +1,481 @@
+/**
+ * Web-compatible MailxService for Android/browser.
+ * Replaces @bobfrankston/mailx-service which depends on Node.js (fs, dns, mailparser).
+ *
+ * Key differences from desktop:
+ * - Uses WebMailxDB (wa-sqlite) instead of MailxDB (node:sqlite)
+ * - Uses WebMessageStore (IndexedDB) instead of FileMessageStore (filesystem)
+ * - Uses postal-mime or manual header parsing instead of mailparser's simpleParser
+ * - Settings via IndexedDB + GDrive API instead of filesystem
+ * - No dns.resolveMx — provider detection is static (Gmail/Outlook/Yahoo/iCloud)
+ */
+import { loadSettings, saveSettings, loadAllowlist, saveAllowlist, loadAutocomplete, saveAutocomplete, getStorageInfo } from "./web-settings.js";
+// ── HTML sanitizer (same logic as desktop) ──
+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 };
+}
+/** Parse an RFC 2822 message from raw bytes. Handles basic MIME. */
+function parseEmailSource(raw) {
+    const headers = new Map();
+    const headerEnd = raw.indexOf("\r\n\r\n");
+    const headerSection = headerEnd >= 0 ? raw.substring(0, headerEnd) : raw;
+    const body = headerEnd >= 0 ? raw.substring(headerEnd + 4) : "";
+    // Parse headers (handle continuations)
+    const headerLines = headerSection.split("\r\n");
+    let lastKey = "";
+    for (const line of headerLines) {
+        if (line.startsWith(" ") || line.startsWith("\t")) {
+            // Continuation
+            if (lastKey) {
+                headers.set(lastKey, (headers.get(lastKey) || "") + " " + line.trim());
+            }
+        }
+        else {
+            const colon = line.indexOf(":");
+            if (colon > 0) {
+                lastKey = line.substring(0, colon).toLowerCase().trim();
+                headers.set(lastKey, line.substring(colon + 1).trim());
+            }
+        }
+    }
+    const contentType = headers.get("content-type") || "text/plain";
+    const transferEncoding = (headers.get("content-transfer-encoding") || "").toLowerCase();
+    const attachments = [];
+    // Check for multipart
+    const boundaryMatch = contentType.match(/boundary="?([^";\s]+)"?/i);
+    if (boundaryMatch) {
+        const boundary = boundaryMatch[1];
+        return parseMimeParts(body, boundary, headers);
+    }
+    // Single part
+    let decoded = decodeBody(body, transferEncoding);
+    const isHtml = contentType.includes("text/html");
+    return {
+        html: isHtml ? decoded : "",
+        text: isHtml ? "" : decoded,
+        headers,
+        attachments,
+    };
+}
+function parseMimeParts(body, boundary, topHeaders) {
+    const parts = body.split("--" + boundary);
+    let html = "";
+    let text = "";
+    const attachments = [];
+    for (let i = 1; i < parts.length; i++) {
+        const part = parts[i];
+        if (part.startsWith("--"))
+            break; // End marker
+        const partHeaderEnd = part.indexOf("\r\n\r\n");
+        if (partHeaderEnd < 0)
+            continue;
+        const partHeaderSection = part.substring(0, partHeaderEnd);
+        const partBody = part.substring(partHeaderEnd + 4).replace(/\r?\n$/, "");
+        // Parse part headers
+        const partHeaders = new Map();
+        const partHeaderLines = partHeaderSection.split("\r\n");
+        let lastKey = "";
+        for (const line of partHeaderLines) {
+            if (line.startsWith(" ") || line.startsWith("\t")) {
+                if (lastKey)
+                    partHeaders.set(lastKey, (partHeaders.get(lastKey) || "") + " " + line.trim());
+            }
+            else {
+                const colon = line.indexOf(":");
+                if (colon > 0) {
+                    lastKey = line.substring(0, colon).toLowerCase().trim();
+                    partHeaders.set(lastKey, line.substring(colon + 1).trim());
+                }
+            }
+        }
+        const partType = partHeaders.get("content-type") || "text/plain";
+        const partEncoding = (partHeaders.get("content-transfer-encoding") || "").toLowerCase();
+        const disposition = partHeaders.get("content-disposition") || "";
+        // Nested multipart
+        const nestedBoundary = partType.match(/boundary="?([^";\s]+)"?/i);
+        if (nestedBoundary) {
+            const nested = parseMimeParts(partBody, nestedBoundary[1], topHeaders);
+            if (!html && nested.html)
+                html = nested.html;
+            if (!text && nested.text)
+                text = nested.text;
+            attachments.push(...nested.attachments);
+            continue;
+        }
+        if (disposition.includes("attachment") || (partType.includes("application/") && !partType.includes("text/"))) {
+            const filenameMatch = disposition.match(/filename="?([^";\r\n]+)"?/i) || partType.match(/name="?([^";\r\n]+)"?/i);
+            const decoded = decodeBody(partBody, partEncoding);
+            attachments.push({
+                filename: filenameMatch?.[1]?.trim() || `attachment-${attachments.length}`,
+                contentType: partType.split(";")[0].trim(),
+                size: decoded.length,
+                contentId: (partHeaders.get("content-id") || "").replace(/[<>]/g, ""),
+                content: new TextEncoder().encode(decoded),
+            });
+        }
+        else if (partType.includes("text/html")) {
+            html = decodeBody(partBody, partEncoding);
+        }
+        else if (partType.includes("text/plain")) {
+            text = decodeBody(partBody, partEncoding);
+        }
+    }
+    return { html, text, headers: topHeaders, attachments };
+}
+function decodeBody(body, encoding) {
+    if (encoding === "base64") {
+        try {
+            return atob(body.replace(/\s/g, ""));
+        }
+        catch {
+            return body;
+        }
+    }
+    if (encoding === "quoted-printable") {
+        return body
+            .replace(/=\r?\n/g, "")
+            .replace(/=([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+    }
+    return body;
+}
+// ── Quoted-printable encoding (for compose/send) ──
+function encodeQuotedPrintable(text) {
+    const encoder = new TextEncoder();
+    const bytes = encoder.encode(text);
+    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) {
+            result += line + "\r\n";
+            line = "";
+            i++;
+            continue;
+        }
+        else if (b === 0x0A) {
+            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;
+}
+// ── Service ──
+export class WebMailxService {
+    db;
+    bodyStore;
+    syncManager;
+    constructor(db, bodyStore, syncManager) {
+        this.db = db;
+        this.bodyStore = bodyStore;
+        this.syncManager = syncManager;
+    }
+    // ── Accounts ──
+    async getAccounts() {
+        const dbAccounts = this.db.getAccounts();
+        const settings = await loadSettings();
+        const ordered = [];
+        for (const cfg of settings.accounts) {
+            const a = dbAccounts.find(d => d.id === cfg.id);
+            if (a)
+                ordered.push({ ...a, label: cfg.label, defaultSend: cfg.defaultSend || false });
+        }
+        for (const a of dbAccounts) {
+            if (!ordered.find((o) => o.id === a.id))
+                ordered.push(a);
+        }
+        return ordered;
+    }
+    // ── Folders ──
+    getFolders(accountId) {
+        return this.db.getFolders(accountId);
+    }
+    // ── Messages ──
+    getUnifiedInbox(page = 1, pageSize = 50) {
+        return this.db.getUnifiedInbox(page, pageSize);
+    }
+    getMessages(accountId, folderId, page = 1, pageSize = 50, sort = "date", sortDir = "desc", search) {
+        return this.db.getMessages({ accountId, folderId, page, pageSize, sort: sort, sortDir: sortDir, search });
+    }
+    async getMessage(accountId, uid, allowRemote = false, folderId) {
+        const envelope = this.db.getMessageByUid(accountId, uid, folderId);
+        if (!envelope)
+            throw new Error("Message not found");
+        let bodyHtml = "";
+        let bodyText = "";
+        let hasRemoteContent = false;
+        let attachments = [];
+        let raw = null;
+        try {
+            raw = await this.syncManager.fetchMessageBody(accountId, envelope.folderId, envelope.uid);
+        }
+        catch (fetchErr) {
+            return {
+                ...envelope, bodyHtml: "", bodyText: `[Message body unavailable: ${fetchErr.message || "fetch failed"}]`,
+                hasRemoteContent: false, remoteAllowed: false, attachments: [], deliveredTo: "", returnPath: "", listUnsubscribe: ""
+            };
+        }
+        if (!raw) {
+            bodyText = "[Message body not available. Try again or re-sync the folder.]";
+        }
+        else {
+            const source = new TextDecoder().decode(raw);
+            const parsed = parseEmailSource(source);
+            bodyHtml = parsed.html || "";
+            bodyText = parsed.text || "";
+            attachments = (parsed.attachments || []).map((a, i) => ({
+                id: i,
+                filename: a.filename || `attachment-${i}`,
+                mimeType: a.contentType || "application/octet-stream",
+                size: a.size || 0,
+                contentId: a.contentId || ""
+            }));
+        }
+        // Sanitize HTML
+        if (bodyHtml && !allowRemote) {
+            const allowList = await loadAllowlist();
+            const senderAddr = envelope.from?.address || "";
+            const senderDomain = senderAddr.split("@")[1] || "";
+            const toAddrs = (envelope.to || []).map((a) => a.address);
+            const isAllowed = allowList.senders.includes(senderAddr) ||
+                allowList.domains.includes(senderDomain) ||
+                toAddrs.some((a) => allowList.recipients?.includes(a));
+            if (isAllowed) {
+                allowRemote = true;
+            }
+            else {
+                const result = sanitizeHtml(bodyHtml);
+                bodyHtml = result.html;
+                hasRemoteContent = result.hasRemoteContent;
+            }
+        }
+        return {
+            ...envelope, bodyHtml, bodyText, hasRemoteContent, remoteAllowed: allowRemote,
+            attachments, deliveredTo: "", returnPath: "", listUnsubscribe: "",
+        };
+    }
+    async updateFlags(accountId, uid, flags) {
+        const envelope = this.db.getMessageByUid(accountId, uid);
+        await this.syncManager.updateFlagsLocal(accountId, uid, envelope?.folderId || 0, flags);
+    }
+    // ── Remote content allow-list ──
+    async allowRemoteContent(type, value) {
+        const list = await loadAllowlist();
+        if (type === "sender" && !list.senders.includes(value))
+            list.senders.push(value);
+        else if (type === "domain" && !list.domains.includes(value))
+            list.domains.push(value);
+        else if (type === "recipient") {
+            if (!list.recipients)
+                list.recipients = [];
+            if (!list.recipients.includes(value))
+                list.recipients.push(value);
+        }
+        await saveAllowlist(list);
+    }
+    // ── Search ──
+    async search(q, page = 1, pageSize = 50, scope = "all", accountId, folderId) {
+        if (!q.trim())
+            return { items: [], total: 0, page, pageSize };
+        // On mobile, always use local search (no server-side IMAP search)
+        if (scope === "current" && accountId && folderId) {
+            return this.db.searchMessages(q, page, pageSize, accountId, folderId);
+        }
+        return this.db.searchMessages(q, page, pageSize);
+    }
+    // ── Sync ──
+    getSyncPending() {
+        return { pending: this.db.getTotalPendingSyncCount() };
+    }
+    async syncAll() {
+        await this.syncManager.syncAll();
+    }
+    async syncAccount(accountId) {
+        const folders = await this.syncManager.syncFolders(accountId);
+        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) {
+            try {
+                await this.syncManager.syncFolder(accountId, folder.id);
+            }
+            catch (e) {
+                console.error(`  Skipping folder ${folder.path}: ${e.message}`);
+            }
+        }
+    }
+    async reauthenticate(accountId) {
+        return this.syncManager.reauthenticate(accountId);
+    }
+    // ── Send ──
+    async send(msg) {
+        const settings = await loadSettings();
+        const account = settings.accounts.find(a => a.id === msg.from);
+        if (!account)
+            throw new Error(`Unknown account: ${msg.from}`);
+        const fromHeader = msg.fromAddress || `${account.name} <${account.email}>`;
+        const to = msg.to.map((a) => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
+        const cc = msg.cc?.map((a) => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
+        const bcc = msg.bcc?.map((a) => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
+        const body = msg.bodyHtml || msg.bodyText || "";
+        const bodyEncoded = encodeQuotedPrintable(body);
+        const domain = account.email.split("@")[1] || "mailx.local";
+        const messageId = `<${Date.now()}.${Math.random().toString(36).slice(2)}@${domain}>`;
+        const headers = [
+            `From: ${fromHeader}`, `To: ${to}`,
+            cc ? `Cc: ${cc}` : null, bcc ? `Bcc: ${bcc}` : null,
+            `Subject: ${msg.subject}`, `Date: ${new Date().toUTCString()}`,
+            `Message-ID: ${messageId}`,
+            msg.inReplyTo ? `In-Reply-To: ${msg.inReplyTo}` : null,
+            msg.references?.length ? `References: ${msg.references.join(" ")}` : null,
+            `MIME-Version: 1.0`, `Content-Type: text/html; charset=UTF-8`, `Content-Transfer-Encoding: quoted-printable`,
+        ].filter(h => h !== null).join("\r\n");
+        const rawMessage = `${headers}\r\n\r\n${bodyEncoded}`;
+        this.syncManager.queueOutgoingLocal(account.id, rawMessage);
+        for (const addr of msg.to)
+            this.db.recordSentAddress(addr.name, addr.address);
+        if (msg.cc)
+            for (const addr of msg.cc)
+                this.db.recordSentAddress(addr.name, addr.address);
+        if (msg.bcc)
+            for (const addr of msg.bcc)
+                this.db.recordSentAddress(addr.name, addr.address);
+    }
+    // ── Delete / Move ──
+    async deleteMessage(accountId, uid) {
+        const envelope = this.db.getMessageByUid(accountId, uid);
+        if (!envelope)
+            throw new Error("Message not found");
+        await this.syncManager.trashMessage(accountId, envelope.folderId, envelope.uid);
+    }
+    async deleteMessages(accountId, uids) {
+        const messages = uids.map(uid => {
+            const env = this.db.getMessageByUid(accountId, uid);
+            if (!env)
+                return null;
+            return { uid: env.uid, folderId: env.folderId };
+        }).filter(m => m !== null);
+        await this.syncManager.trashMessages(accountId, messages);
+    }
+    async moveMessage(accountId, uid, targetFolderId, targetAccountId) {
+        const envelope = this.db.getMessageByUid(accountId, uid);
+        if (!envelope)
+            throw new Error("Message not found");
+        if (targetAccountId && targetAccountId !== accountId) {
+            await this.syncManager.moveMessageCrossAccount(accountId, envelope.uid, envelope.folderId, targetAccountId, targetFolderId);
+        }
+        else {
+            await this.syncManager.moveMessage(accountId, envelope.uid, envelope.folderId, targetFolderId);
+        }
+    }
+    async moveMessages(accountId, uids, targetFolderId) {
+        const messages = uids.map(uid => {
+            const env = this.db.getMessageByUid(accountId, uid);
+            if (!env)
+                return null;
+            return { uid: env.uid, folderId: env.folderId };
+        }).filter(m => m !== null);
+        await this.syncManager.moveMessages(accountId, messages, targetFolderId);
+    }
+    async undeleteMessage(accountId, uid, folderId) {
+        await this.syncManager.undeleteMessage(accountId, uid, folderId);
+    }
+    // ── Drafts ──
+    async saveDraft(accountId, subject, bodyHtml, bodyText, to, cc, previousDraftUid, draftId) {
+        const settings = await loadSettings();
+        const account = settings.accounts.find(a => a.id === accountId);
+        if (!account)
+            throw new Error(`Unknown account: ${accountId}`);
+        const id = draftId || `mailx-draft-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const body = bodyHtml || bodyText || "";
+        const bodyEncoded = encodeQuotedPrintable(body);
+        const headers = [
+            `From: ${account.name} <${account.email}>`,
+            to ? `To: ${to}` : null, cc ? `Cc: ${cc}` : null,
+            `Subject: ${subject || "(no subject)"}`, `Date: ${new Date().toUTCString()}`,
+            `X-Mailx-Draft-ID: ${id}`,
+            `MIME-Version: 1.0`, `Content-Type: text/html; charset=UTF-8`, `Content-Transfer-Encoding: quoted-printable`,
+        ].filter(h => h !== null).join("\r\n");
+        const raw = `${headers}\r\n\r\n${bodyEncoded}`;
+        const uid = await this.syncManager.saveDraft(accountId, raw, previousDraftUid, id);
+        return { uid, draftId: id };
+    }
+    async deleteDraft(accountId, draftUid) {
+        await this.syncManager.deleteDraft(accountId, draftUid);
+    }
+    // ── Contacts ──
+    searchContacts(query) {
+        if (query.length < 1)
+            return [];
+        return this.db.searchContacts(query);
+    }
+    // ── Settings ──
+    async getSettings() {
+        return loadSettings();
+    }
+    async saveSettingsData(settings) {
+        await saveSettings(settings);
+    }
+    getStorageInfo() {
+        return getStorageInfo();
+    }
+    // ── Folder management (limited on mobile — read-only) ──
+    markFolderRead(folderId) {
+        this.db.markFolderRead(folderId);
+    }
+    // ── Autocomplete ──
+    async getAutocompleteSettings() {
+        return loadAutocomplete();
+    }
+    async saveAutocompleteSettings(settings) {
+        await saveAutocomplete(settings);
+    }
+    async autocomplete(_req) {
+        // Autocomplete disabled on mobile by default
+        return { suggestion: "" };
+    }
+    // ── Reset ──
+    async resetStore() {
+        await this.db.resetStore();
+        await this.bodyStore.clear();
+        console.log("[service] Store reset complete");
+    }
+}
+//# sourceMappingURL=web-service.js.map

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

@@ -0,0 +1,81 @@
+/**
+ * Browser-compatible settings for Android/WebView.
+ * Replaces @bobfrankston/mailx-settings which depends on node:fs.
+ *
+ * Settings are stored in IndexedDB and synced to Google Drive
+ * via the GDrive API (same API as desktop cloud mode).
+ *
+ * On first run, settings are fetched from GDrive. Subsequent reads
+ * use the local IndexedDB cache. Writes go to both.
+ */
+import type { AccountConfig, MailxSettings, AutocompleteSettings } from "@bobfrankston/mailx-types";
+export declare function setGDriveTokenProvider(provider: () => Promise<string>): void;
+export declare function setGDriveFolderId(folderId: string): void;
+declare const DEFAULT_PREFERENCES: {
+    ui: {
+        theme: "system";
+        editor: "quill";
+        folderWidth: number;
+        listViewerSplit: number;
+        fontSize: number;
+    };
+    sync: {
+        intervalMinutes: number;
+        historyDays: number;
+        prefetch: boolean;
+    };
+    autocomplete: {
+        enabled: boolean;
+        provider: "off";
+        ollamaUrl: string;
+        ollamaModel: string;
+        cloudApiKey: string;
+        cloudModel: string;
+        debounceMs: number;
+        maxTokens: number;
+    };
+};
+declare const DEFAULT_ALLOWLIST: {
+    senders: string[];
+    domains: string[];
+    recipients: string[];
+};
+/** Load accounts — first from IndexedDB cache, then GDrive */
+export declare function loadAccounts(): Promise<AccountConfig[]>;
+/** Save accounts to IndexedDB and GDrive */
+export declare function saveAccounts(accounts: AccountConfig[]): Promise<void>;
+/** Load preferences */
+export declare function loadPreferences(): Promise<typeof DEFAULT_PREFERENCES>;
+/** Save preferences */
+export declare function savePreferences(prefs: any): Promise<void>;
+/** Load full settings (accounts + preferences combined) */
+export declare function loadSettings(): Promise<MailxSettings>;
+/** Save full settings */
+export declare function saveSettings(settings: MailxSettings): Promise<void>;
+/** Load allowlist */
+export declare function loadAllowlist(): Promise<typeof DEFAULT_ALLOWLIST>;
+/** Save allowlist */
+export declare function saveAllowlist(list: typeof DEFAULT_ALLOWLIST): Promise<void>;
+/** Load autocomplete settings */
+export declare function loadAutocomplete(): Promise<AutocompleteSettings>;
+/** Save autocomplete settings */
+export declare function saveAutocomplete(settings: AutocompleteSettings): Promise<void>;
+/** Get history days — read from preferences */
+export declare function getHistoryDays(): Promise<number>;
+/** Get prefetch setting */
+export declare function getPrefetch(): Promise<boolean>;
+/** Get storage info */
+export declare function getStorageInfo(): {
+    provider: string;
+    mode: string;
+};
+/** Clear all cached settings — used for "Reset Store" */
+export declare function clearSettings(): Promise<void>;
+/** Get or create a stable device ID (UUID stored in localStorage) */
+export declare function getDeviceId(): string;
+/** Save device-specific settings to GDrive (devices/<deviceId>/state.json) */
+export declare function saveDeviceState(state: any): Promise<void>;
+/** Load device-specific settings */
+export declare function loadDeviceState(): Promise<any>;
+export {};
+//# sourceMappingURL=web-settings.d.ts.map