@bobfrankston/mailx 1.0.50 → 1.0.57

package/packages/mailx-service/index.js

@@ -0,0 +1,456 @@
+/**
+ * @bobfrankston/mailx-service
+ * Pure business logic — no HTTP, no Express.
+ * Both the Express API (mailx-api) and the Android bridge call these functions.
+ */
+import { loadSettings, saveSettings, loadAllowlist, saveAllowlist, getStorePath, getStorageInfo } from "@bobfrankston/mailx-settings";
+import { simpleParser } from "mailparser";
+// ── Sanitize ──
+export function sanitizeHtml(html) {
+    let hasRemoteContent = false;
+    let clean = html.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "");
+    clean = clean.replace(/\s+on\w+\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, "");
+    clean = clean.replace(/<img\b([^>]*)\bsrc\s*=\s*("[^"]*"|'[^']*')/gi, (match, before, src) => {
+        const url = src.slice(1, -1);
+        if (url.startsWith("data:") || url.startsWith("cid:"))
+            return match;
+        hasRemoteContent = true;
+        return `<img${before}src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='20' height='20'%3E%3Crect fill='%23888' width='20' height='20' rx='3'/%3E%3Ctext x='10' y='14' text-anchor='middle' fill='white' font-size='12'%3E⊘%3C/text%3E%3C/svg%3E" data-blocked-src=${src} title="Remote image blocked"`;
+    });
+    clean = clean.replace(/<link\b[^>]*rel\s*=\s*["']stylesheet["'][^>]*>/gi, (match) => {
+        hasRemoteContent = true;
+        return `<!-- blocked: ${match.replace(/--/g, "")} -->`;
+    });
+    clean = clean.replace(/url\s*\(\s*(['"]?)(https?:\/\/[^)]+)\1\s*\)/gi, (_match, _q, url) => {
+        hasRemoteContent = true;
+        return `url("") /* blocked: ${url} */`;
+    });
+    clean = clean.replace(/<\/?form\b[^>]*>/gi, "");
+    clean = clean.replace(/<iframe\b[^>]*>[\s\S]*?<\/iframe>/gi, "");
+    return { html: clean, hasRemoteContent };
+}
+// ── Service ──
+export class MailxService {
+    db;
+    imapManager;
+    constructor(db, imapManager) {
+        this.db = db;
+        this.imapManager = imapManager;
+    }
+    // ── Accounts ──
+    getAccounts() {
+        const accounts = this.db.getAccounts();
+        const settings = loadSettings();
+        return accounts.map(a => {
+            const cfg = settings.accounts.find(s => s.id === a.id);
+            return { ...a, label: cfg?.label, defaultSend: cfg?.defaultSend || false };
+        });
+    }
+    // ── 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.imapManager.fetchMessageBody(accountId, envelope.folderId, envelope.uid);
+        }
+        catch (fetchErr) {
+            return {
+                ...envelope, bodyHtml: "", bodyText: `[Message body unavailable: ${fetchErr.message || "IMAP connection failed"}]`,
+                hasRemoteContent: false, remoteAllowed: false, attachments: [], emlPath: "", deliveredTo: "", returnPath: "", listUnsubscribe: ""
+            };
+        }
+        if (raw) {
+            const parsed = await simpleParser(raw);
+            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 = 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;
+            }
+        }
+        // Extract headers
+        let deliveredTo = "";
+        let returnPath = "";
+        let listUnsubscribe = "";
+        if (raw) {
+            const parsed2 = await simpleParser(raw);
+            const hdr = (key) => {
+                let v = parsed2.headers.get(key);
+                if (!v)
+                    return "";
+                if (Array.isArray(v))
+                    v = v[0];
+                if (typeof v === "string")
+                    return v;
+                if (typeof v === "object" && v !== null) {
+                    if ("text" in v)
+                        return v.text || "";
+                    if ("value" in v)
+                        return String(v.value);
+                    if ("address" in v)
+                        return v.address || "";
+                }
+                return String(v);
+            };
+            const msgSettings = loadSettings();
+            const acctConfig = msgSettings.accounts.find((a) => a.id === accountId);
+            const relayDomains = acctConfig?.relayDomains || [];
+            const prefixes = acctConfig?.deliveredToPrefix || [];
+            const rawDelivered = parsed2.headers.get("delivered-to");
+            if (rawDelivered) {
+                const deliveredList = Array.isArray(rawDelivered) ? rawDelivered : [rawDelivered];
+                for (let i = deliveredList.length - 1; i >= 0; i--) {
+                    const d = deliveredList[i];
+                    const addr = typeof d === "string" ? d : d?.text || d?.address || String(d);
+                    if (!relayDomains.some(rd => addr.includes(`@${rd}`))) {
+                        deliveredTo = addr;
+                        break;
+                    }
+                }
+                if (!deliveredTo && deliveredList.length > 0) {
+                    const d = deliveredList[deliveredList.length - 1];
+                    deliveredTo = typeof d === "string" ? d : d?.text || d?.address || String(d);
+                }
+                if (deliveredTo && prefixes.length > 0) {
+                    const [local, domain] = deliveredTo.split("@");
+                    for (const prefix of prefixes) {
+                        if (local.startsWith(prefix)) {
+                            deliveredTo = `${local.slice(prefix.length)}@${domain}`;
+                            break;
+                        }
+                    }
+                }
+            }
+            returnPath = hdr("return-path").replace(/[<>]/g, "");
+            const listHeaders = parsed2.headers.get("list");
+            if (listHeaders?.unsubscribe) {
+                const unsub = listHeaders.unsubscribe;
+                listUnsubscribe = unsub.url || (unsub.mail ? `mailto:${unsub.mail}` : "");
+            }
+        }
+        const storePath = getStorePath();
+        const emlPath = `${storePath}/${accountId}/${envelope.folderId}/${envelope.uid}.eml`;
+        return {
+            ...envelope, bodyHtml, bodyText, hasRemoteContent, remoteAllowed: allowRemote,
+            attachments, emlPath, deliveredTo, returnPath, listUnsubscribe,
+        };
+    }
+    async updateFlags(accountId, uid, flags) {
+        const envelope = this.db.getMessageByUid(accountId, uid);
+        await this.imapManager.updateFlagsLocal(accountId, uid, envelope?.folderId || 0, flags);
+    }
+    // ── Remote content allow-list ──
+    allowRemoteContent(type, value) {
+        const list = 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);
+        }
+        saveAllowlist(list);
+        console.log(`  [allow] Added ${type}: ${value}`);
+    }
+    // ── Search ──
+    async search(q, page = 1, pageSize = 50, scope = "all", accountId, folderId) {
+        if (!q.trim())
+            return { items: [], total: 0, page, pageSize };
+        if (scope === "server" && accountId) {
+            const folders = this.db.getFolders(accountId);
+            const folder = folderId ? folders.find(f => f.id === folderId) : folders.find(f => f.specialUse === "inbox");
+            if (!folder)
+                return { items: [], total: 0, page, pageSize };
+            const criteria = {};
+            const fromMatch = q.match(/from:(\S+)/i);
+            const toMatch = q.match(/to:(\S+)/i);
+            const subjectMatch = q.match(/subject:(.+?)(?:\s+\w+:|$)/i);
+            const bodyText = q.replace(/(?:from|to|subject):\S+/gi, "").trim();
+            if (fromMatch)
+                criteria.from = fromMatch[1];
+            if (toMatch)
+                criteria.to = toMatch[1];
+            if (subjectMatch)
+                criteria.subject = subjectMatch[1].trim();
+            if (bodyText)
+                criteria.body = bodyText;
+            const uids = await this.imapManager.searchOnServer(accountId, folder.path, criteria);
+            const items = uids.slice((page - 1) * pageSize, page * pageSize)
+                .map(uid => this.db.getMessageByUid(accountId, uid, folderId))
+                .filter(Boolean);
+            return { items, total: uids.length, page, pageSize };
+        }
+        else if (scope === "current" && accountId && folderId) {
+            return this.db.searchMessages(q, page, pageSize, accountId, folderId);
+        }
+        else {
+            return this.db.searchMessages(q, page, pageSize);
+        }
+    }
+    rebuildSearchIndex() {
+        const count = this.db.rebuildSearchIndex();
+        console.log(`  Rebuilt search index: ${count} messages`);
+        return count;
+    }
+    // ── Sync ──
+    getSyncPending() {
+        return { pending: this.db.getTotalPendingSyncCount() };
+    }
+    async syncAll() {
+        await this.imapManager.syncAll();
+    }
+    async syncAccount(accountId) {
+        const folders = await this.imapManager.syncFolders(accountId);
+        folders.sort((a, b) => {
+            if (a.specialUse === "inbox")
+                return -1;
+            if (b.specialUse === "inbox")
+                return 1;
+            return 0;
+        });
+        for (const folder of folders) {
+            try {
+                await this.imapManager.syncFolder(accountId, folder.id);
+            }
+            catch (e) {
+                console.error(`  Skipping folder ${folder.path}: ${e.message}`);
+            }
+        }
+    }
+    // ── Send ──
+    async send(msg) {
+        const settings = 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 bodyBase64 = Buffer.from(body, "utf-8").toString("base64").replace(/(.{76})/g, "$1\r\n");
+        const headers = [
+            `From: ${fromHeader}`, `To: ${to}`,
+            cc ? `Cc: ${cc}` : null, bcc ? `Bcc: ${bcc}` : null,
+            `Subject: ${msg.subject}`, `Date: ${new Date().toUTCString()}`,
+            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: base64`,
+        ].filter(h => h !== null).join("\r\n");
+        const rawMessage = `${headers}\r\n\r\n${bodyBase64}`;
+        this.imapManager.queueOutgoingLocal(account.id, rawMessage);
+        console.log(`  Queued locally: ${msg.subject} via ${account.id} from ${fromHeader}`);
+        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 / Undelete ──
+    async deleteMessage(accountId, uid) {
+        const envelope = this.db.getMessageByUid(accountId, uid);
+        if (!envelope)
+            throw new Error("Message not found");
+        await this.imapManager.trashMessage(accountId, envelope.folderId, envelope.uid);
+    }
+    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.imapManager.moveMessageCrossAccount(accountId, envelope.uid, envelope.folderId, targetAccountId, targetFolderId);
+        }
+        else {
+            await this.imapManager.moveMessage(accountId, envelope.uid, envelope.folderId, targetFolderId);
+        }
+    }
+    async undeleteMessage(accountId, uid, folderId) {
+        await this.imapManager.undeleteMessage(accountId, uid, folderId);
+    }
+    async deleteOnServer(accountId, folderPath, uid) {
+        await this.imapManager.deleteOnServer(accountId, folderPath, uid);
+    }
+    // ── Folder management ──
+    async createFolder(accountId, parentPath, name) {
+        const fullPath = parentPath ? `${parentPath}.${name}` : name;
+        const client = this.imapManager.createPublicClient(accountId);
+        try {
+            await client.createmailbox(fullPath);
+            await this.imapManager.syncFolders(accountId, client);
+            await client.logout();
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* */ }
+        }
+    }
+    async renameFolder(accountId, folderId, newName) {
+        const folder = this.db.getFolders(accountId).find(f => f.id === folderId);
+        if (!folder)
+            throw new Error("Folder not found");
+        const parts = folder.path.split(folder.delimiter || ".");
+        parts[parts.length - 1] = newName;
+        const newPath = parts.join(folder.delimiter || ".");
+        const client = this.imapManager.createPublicClient(accountId);
+        try {
+            await client.withConnection(async () => {
+                await client.client.mailboxRename(folder.path, newPath);
+            });
+            await this.imapManager.syncFolders(accountId, client);
+            await client.logout();
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* */ }
+        }
+    }
+    async deleteFolder(accountId, folderId) {
+        const folder = this.db.getFolders(accountId).find(f => f.id === folderId);
+        if (!folder)
+            throw new Error("Folder not found");
+        const client = this.imapManager.createPublicClient(accountId);
+        try {
+            await client.withConnection(async () => {
+                await client.client.mailboxDelete(folder.path);
+            });
+            this.db.deleteFolder(folderId);
+            await client.logout();
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* */ }
+        }
+    }
+    markFolderRead(folderId) {
+        this.db.markFolderRead(folderId);
+    }
+    async emptyFolder(accountId, folderId) {
+        const folder = this.db.getFolders(accountId).find(f => f.id === folderId);
+        if (!folder)
+            throw new Error("Folder not found");
+        this.db.deleteAllMessages(accountId, folderId);
+        const client = this.imapManager.createPublicClient(accountId);
+        try {
+            const uids = await client.getUids(folder.path);
+            for (const uid of uids)
+                await client.deleteMessageByUid(folder.path, uid);
+            await client.logout();
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* */ }
+        }
+    }
+    // ── Attachments ──
+    async getAttachment(accountId, uid, attachmentId, folderId) {
+        const envelope = this.db.getMessageByUid(accountId, uid, folderId);
+        if (!envelope)
+            throw new Error("Message not found");
+        const raw = await this.imapManager.fetchMessageBody(accountId, envelope.folderId, envelope.uid);
+        if (!raw)
+            throw new Error("Message body not available");
+        const parsed = await simpleParser(raw);
+        const att = parsed.attachments?.[attachmentId];
+        if (!att)
+            throw new Error("Attachment not found");
+        return {
+            content: att.content,
+            contentType: att.contentType || "application/octet-stream",
+            filename: (att.filename || "attachment").replace(/"/g, ""),
+        };
+    }
+    // ── Drafts ──
+    async saveDraft(accountId, subject, bodyHtml, bodyText, to, cc, previousDraftUid) {
+        const settings = loadSettings();
+        const account = settings.accounts.find(a => a.id === accountId);
+        if (!account)
+            throw new Error(`Unknown account: ${accountId}`);
+        const headers = [
+            `From: ${account.name} <${account.email}>`,
+            to ? `To: ${to}` : null, cc ? `Cc: ${cc}` : null,
+            `Subject: ${subject || "(no subject)"}`, `Date: ${new Date().toUTCString()}`,
+            `MIME-Version: 1.0`, `Content-Type: text/html; charset=UTF-8`,
+        ].filter(h => h !== null).join("\r\n");
+        const raw = `${headers}\r\n\r\n${bodyHtml || bodyText || ""}`;
+        return this.imapManager.saveDraft(accountId, raw, previousDraftUid);
+    }
+    async deleteDraft(accountId, draftUid) {
+        await this.imapManager.deleteDraft(accountId, draftUid);
+    }
+    // ── Contacts ──
+    searchContacts(query) {
+        if (query.length < 1)
+            return [];
+        return this.db.searchContacts(query);
+    }
+    async syncGoogleContacts() {
+        await this.imapManager.syncAllContacts();
+    }
+    seedContacts() {
+        const added = this.db.seedContactsFromMessages();
+        console.log(`  Seeded ${added} contacts from message history`);
+        return added;
+    }
+    // ── Settings ──
+    getSettings() {
+        return loadSettings();
+    }
+    saveSettings(settings) {
+        saveSettings(settings);
+    }
+    getStorageInfo() {
+        return getStorageInfo();
+    }
+}
+//# sourceMappingURL=index.js.map

package/packages/mailx-service/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@bobfrankston/mailx-service",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "@bobfrankston/mailx-types": "file:../mailx-types",
+    "@bobfrankston/mailx-store": "file:../mailx-store",
+    "@bobfrankston/mailx-imap": "file:../mailx-imap",
+    "@bobfrankston/mailx-settings": "file:../mailx-settings",
+    "mailparser": "^3.7.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BobFrankston/mailx.git"
+  }
+}

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

@@ -32,6 +32,7 @@ export declare function getStorageInfo(): {
 declare const DEFAULT_PREFERENCES: {
     ui: {
         theme: "system" | "dark" | "light";
+        editor: "quill" | "tiptap";
         folderWidth: number;
         listViewerSplit: number;
         fontSize: number;

package/packages/mailx-settings/index.js

@@ -310,6 +310,7 @@ const DEFAULT_ACCOUNTS = [];
 const DEFAULT_PREFERENCES = {
     ui: {
         theme: "system",
+        editor: "quill",
         folderWidth: 220,
         listViewerSplit: 40,
         fontSize: 15,

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

@@ -177,6 +177,7 @@ export interface MailxSettings {
     accounts: AccountConfig[];
     ui: {
         theme: "system" | "dark" | "light";
+        editor: "quill" | "tiptap";
         folderWidth: number;
         listViewerSplit: number; /** Percentage for message list height */
         fontSize: number;