@bobfrankston/mailx 1.0.256 → 1.0.260

package/packages/mailx-store-web/worker-entry.js

@@ -0,0 +1,187 @@
+/**
+ * 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.
+ */
+import { initWorkerTcp, handleTcpMessage, WorkerTcpTransport } from "./worker-tcp-transport.js";
+import { WebMailxDB } from "./db.js";
+import { WebMessageStore } from "./web-message-store.js";
+import { WebMailxService } from "./web-service.js";
+import { SyncManager } from "./sync-manager.js";
+import { dispatch } from "./web-jsonrpc.js";
+import { loadAccounts, loadAccountsFromCloud, setGDriveTokenProvider, setGDriveFolderId } from "./web-settings.js";
+// ── Globals ──
+let db;
+let bodyStore;
+let syncManager;
+let service;
+const post = (msg) => self.postMessage(msg);
+// ── Event emission → main thread ──
+function emitEvent(event) {
+    post({ type: "event", event });
+}
+function vlog(msg) {
+    // Route through main thread for logit (fetch works in workers but keep consistent)
+    try {
+        fetch(`https://rmf39.aaz.lt/logit/${encodeURIComponent("V/" + msg.substring(0, 800))}?log=mailx-android&silent=true`).catch(() => { });
+    }
+    catch { /* ignore */ }
+}
+// ── Native bridge proxy ──
+let nativeReqCounter = 0;
+const pendingNative = new Map();
+function nativeRequest(op, args) {
+    const reqId = ++nativeReqCounter;
+    return new Promise((resolve, reject) => {
+        pendingNative.set(reqId, { resolve, reject });
+        post({ type: "native", reqId, op, args });
+        setTimeout(() => {
+            if (pendingNative.has(reqId)) {
+                pendingNative.delete(reqId);
+                reject(new Error(`Native ${op} timeout`));
+            }
+        }, 60000);
+    });
+}
+function handleNativeResponse(msg) {
+    const pending = pendingNative.get(msg.reqId);
+    if (pending) {
+        pendingNative.delete(msg.reqId);
+        if (msg.error)
+            pending.reject(new Error(msg.error));
+        else
+            pending.resolve(msg.result);
+    }
+}
+// ── Token provider (proxied through main thread → C# OAuth) ──
+function createTokenProvider(email) {
+    return async () => {
+        console.log(`[oauth] Refreshing token for ${email}`);
+        return nativeRequest("refreshToken", [email]);
+    };
+}
+// ── GDrive folder lookup ──
+async function findGDriveMailxFolder(tokenProvider) {
+    const token = await tokenProvider();
+    const r = await fetch(`https://www.googleapis.com/drive/v3/files?q=name='mailx' and mimeType='application/vnd.google-apps.folder' and trashed=false&fields=files(id,name)`, { headers: { "Authorization": `Bearer ${token}` } });
+    if (!r.ok)
+        return null;
+    const data = await r.json();
+    return data.files?.[0]?.id || null;
+}
+// ── Message handler ──
+self.onmessage = async (e) => {
+    const msg = e.data;
+    if (msg.type === "tcp-response" || msg.type === "tcp-data" ||
+        msg.type === "tcp-close" || msg.type === "tcp-error") {
+        handleTcpMessage(msg);
+        return;
+    }
+    if (msg.type === "native-response") {
+        handleNativeResponse(msg);
+        return;
+    }
+    if (msg.type === "rpc") {
+        try {
+            const result = await dispatch(service, {
+                _action: msg.action,
+                _cbid: String(msg.id),
+                ...msg.params
+            });
+            post({ type: "rpc-response", id: msg.id, result: result.result, error: result.error });
+        }
+        catch (e) {
+            post({ type: "rpc-response", id: msg.id, error: e.message });
+        }
+        return;
+    }
+    if (msg.type === "init") {
+        try {
+            await initialize();
+            post({ type: "init-complete" });
+        }
+        catch (e) {
+            console.error(`[worker] Init failed: ${e.message}\n${e.stack}`);
+            post({ type: "init-error", error: e.message });
+        }
+        return;
+    }
+};
+// ── Initialization ──
+async function initialize() {
+    console.log("[worker] Initializing service layer...");
+    // Wire up TCP proxy for IMAP/SMTP
+    initWorkerTcp(post);
+    // Initialize DB (wa-sqlite runs in this Worker thread — no main thread blocking)
+    db = new WebMailxDB("mailx");
+    await db.waitReady();
+    bodyStore = new WebMessageStore();
+    // Create sync manager with injected deps
+    syncManager = new SyncManager(db, bodyStore, {
+        emitEvent,
+        vlog,
+        createTcpTransport: () => new WorkerTcpTransport(),
+    });
+    service = new WebMailxService(db, bodyStore, syncManager);
+    // Load accounts
+    let accounts = await loadAccounts();
+    console.log(`[worker] ${accounts.length} account(s) found`);
+    let gmailTokenProvider = null;
+    for (const account of accounts) {
+        if (!account.enabled)
+            continue;
+        const domain = account.email?.split("@")[1]?.toLowerCase() || "";
+        if (domain === "gmail.com" || domain === "googlemail.com") {
+            const tp = createTokenProvider(account.email);
+            syncManager.setTokenProvider(account.id, tp);
+            if (!gmailTokenProvider)
+                gmailTokenProvider = tp;
+        }
+        await syncManager.addAccount(account);
+    }
+    // GDrive setup — read shared accounts from cloud
+    if (gmailTokenProvider) {
+        setGDriveTokenProvider(gmailTokenProvider);
+        try {
+            console.log("[worker] Looking up GDrive mailx folder...");
+            const folderId = await findGDriveMailxFolder(gmailTokenProvider);
+            if (folderId) {
+                setGDriveFolderId(folderId);
+                console.log(`[worker] GDrive mailx folder: ${folderId}`);
+                // Load accounts from cloud
+                const cloudAccounts = await loadAccountsFromCloud();
+                if (cloudAccounts && cloudAccounts.length > 0) {
+                    console.log(`[worker] GDrive returned ${cloudAccounts.length} accounts`);
+                    for (const account of cloudAccounts) {
+                        if (!account.enabled)
+                            continue;
+                        const domain = account.email?.split("@")[1]?.toLowerCase() || "";
+                        if (domain === "gmail.com" || domain === "googlemail.com") {
+                            const tp = createTokenProvider(account.email);
+                            syncManager.setTokenProvider(account.id, tp);
+                            if (!gmailTokenProvider)
+                                gmailTokenProvider = tp;
+                        }
+                        await syncManager.addAccount(account);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.error(`[worker] GDrive setup error: ${e.message}`);
+        }
+    }
+    // Periodic sync (runs in Worker — never blocks UI)
+    setInterval(() => {
+        console.log("[sync] periodic poll");
+        syncManager.syncAll().catch((e) => console.error(`[worker] Periodic sync error: ${e.message}`));
+    }, 2 * 60 * 1000);
+    // Initial sync after 1 second
+    setTimeout(() => {
+        syncManager.syncAll().catch((e) => console.error(`[worker] Initial sync error: ${e.message}`));
+    }, 1000);
+    console.log("[worker] Service layer ready");
+    emitEvent({ type: "connected" });
+}
+//# sourceMappingURL=worker-entry.js.map

package/packages/mailx-store-web/worker-tcp-transport.d.ts

@@ -0,0 +1,28 @@
+/**
+ * WorkerTcpTransport — TcpTransport implementation for Web Workers.
+ * Proxies TCP operations to the main thread via postMessage, where the
+ * main thread relays them to msgapi.tcp (the C# native bridge).
+ *
+ * Same interface as BridgeTcpTransport, but works in a Worker context
+ * where window/msgapi aren't available.
+ */
+/** Call once from worker-entry to wire up the postMessage channel. */
+export declare function initWorkerTcp(post: (msg: any) => void): void;
+/** Route incoming TCP messages from the main thread to the right transport instance. */
+export declare function handleTcpMessage(msg: any): void;
+export declare class WorkerTcpTransport {
+    streamId: number | null;
+    dataHandler: ((data: string) => void) | null;
+    closeHandler: ((hadError: boolean) => void) | null;
+    errorHandler: ((err: Error) => void) | null;
+    _connected: boolean;
+    get connected(): boolean;
+    connect(host: string, port: number, tls: boolean, _servername?: string): Promise<void>;
+    upgradeTLS(servername?: string): Promise<void>;
+    write(data: string | Uint8Array): Promise<void>;
+    onData(handler: (data: string) => void): void;
+    onClose(handler: (hadError: boolean) => void): void;
+    onError(handler: (err: Error) => void): void;
+    close(): void;
+}
+//# sourceMappingURL=worker-tcp-transport.d.ts.map

package/packages/mailx-store-web/worker-tcp-transport.js

@@ -0,0 +1,98 @@
+/**
+ * WorkerTcpTransport — TcpTransport implementation for Web Workers.
+ * Proxies TCP operations to the main thread via postMessage, where the
+ * main thread relays them to msgapi.tcp (the C# native bridge).
+ *
+ * Same interface as BridgeTcpTransport, but works in a Worker context
+ * where window/msgapi aren't available.
+ */
+/** Function to send messages to the main thread. Set during worker init. */
+let postToMain = () => { throw new Error("Worker TCP transport not initialized"); };
+let reqCounter = 0;
+const pendingRequests = new Map();
+const instances = new Map();
+/** Call once from worker-entry to wire up the postMessage channel. */
+export function initWorkerTcp(post) {
+    postToMain = post;
+}
+/** Route incoming TCP messages from the main thread to the right transport instance. */
+export function handleTcpMessage(msg) {
+    if (msg.type === "tcp-response") {
+        const pending = pendingRequests.get(msg.reqId);
+        if (pending) {
+            pendingRequests.delete(msg.reqId);
+            if (msg.error)
+                pending.reject(new Error(msg.error));
+            else
+                pending.resolve(msg.result);
+        }
+    }
+    else if (msg.type === "tcp-data") {
+        instances.get(msg.streamId)?.dataHandler?.(msg.data);
+    }
+    else if (msg.type === "tcp-close") {
+        const t = instances.get(msg.streamId);
+        if (t) {
+            t._connected = false;
+            instances.delete(msg.streamId);
+            t.closeHandler?.(msg.hadError);
+        }
+    }
+    else if (msg.type === "tcp-error") {
+        const t = instances.get(msg.streamId);
+        if (t) {
+            t.errorHandler?.(new Error(msg.message));
+        }
+    }
+}
+function tcpRequest(op, params) {
+    const reqId = ++reqCounter;
+    return new Promise((resolve, reject) => {
+        pendingRequests.set(reqId, { resolve, reject });
+        postToMain({ type: "tcp", op, reqId, ...params });
+        // 30s timeout
+        setTimeout(() => {
+            if (pendingRequests.has(reqId)) {
+                pendingRequests.delete(reqId);
+                reject(new Error(`TCP ${op} timeout`));
+            }
+        }, 30000);
+    });
+}
+export class WorkerTcpTransport {
+    streamId = null;
+    dataHandler = null;
+    closeHandler = null;
+    errorHandler = null;
+    _connected = false;
+    get connected() { return this._connected; }
+    async connect(host, port, tls, _servername) {
+        const streamId = await tcpRequest("connect", { host, port, tls });
+        this.streamId = Number(streamId);
+        this._connected = true;
+        instances.set(this.streamId, this);
+    }
+    async upgradeTLS(servername) {
+        if (this.streamId == null)
+            throw new Error("Not connected");
+        await tcpRequest("upgradeTLS", { streamId: this.streamId, servername: servername || "" });
+    }
+    async write(data) {
+        if (this.streamId == null)
+            throw new Error("Not connected");
+        const s = typeof data === "string" ? data : new TextDecoder().decode(data);
+        await tcpRequest("write", { streamId: this.streamId, data: s });
+    }
+    onData(handler) { this.dataHandler = handler; }
+    onClose(handler) { this.closeHandler = handler; }
+    onError(handler) { this.errorHandler = handler; }
+    close() {
+        if (this.streamId != null) {
+            postToMain({ type: "tcp", op: "close", streamId: this.streamId });
+            instances.delete(this.streamId);
+            this.streamId = null;
+            this._connected = false;
+        }
+    }
+}
+//# sourceMappingURL=worker-tcp-transport.js.map