@bobfrankston/mailx 1.0.244 → 1.0.251

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

@@ -17,6 +17,8 @@ import { WebMailxService } from "./web-service.js";
 import { loadAccounts, loadAccountsFromCloud, saveAccounts, clearSettings, getDeviceId, setGDriveTokenProvider, setGDriveFolderId } from "./web-settings.js";
 import { GmailApiWebProvider } from "./gmail-api-web.js";
 import { ImapWebProvider } from "./imap-web-provider.js";
+import { SmtpClient } from "@bobfrankston/smtp-direct";
+import { BridgeTcpTransport } from "@bobfrankston/tcp-transport";
 // ── State ──
 let db;
 let bodyStore;
@@ -121,7 +123,12 @@ class AndroidSyncManager {
                         return 1;
                     return 0;
                 });
-                for (const folder of sorted.slice(0, 5)) {
+                // Sync every folder, not just the first five — the old slice(0, 5)
+                // meant subfolders past the cutoff (e.g. _spam, custom labels)
+                // never picked up moves made on other clients, and those moves
+                // also stayed visible in the source folder because reconcile
+                // (below in syncFolder) never ran for the target.
+                for (const folder of sorted) {
                     try {
                         await this.syncFolder(account.id, folder.id);
                     }
@@ -185,6 +192,48 @@ class AndroidSyncManager {
             this.db.recalcFolderCounts(folderId);
             emitEvent({ type: "folderCountsChanged", accountId, counts: {} });
         }
+        // Reconcile deletions — messages present locally but no longer on the
+        // server (moved away, deleted on another client). Without this, the
+        // Android client never drops removed rows: e.g., moves to _spam from
+        // another client showed up in _spam (next time it synced) but never
+        // disappeared from INBOX.
+        //
+        // Same safety guards as the desktop reconcile path:
+        //   - Skip if the server list is empty but local has messages (likely
+        //     a transient API failure that returned []).
+        //   - Refuse to delete more than 50% of local in one pass — better to
+        //     keep phantoms than to wipe a folder on a sync bug. Rebuild local
+        //     cache fixes a stuck state.
+        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} (${Math.round(toDelete.length / localUids.length * 100)}%)`);
+                }
+                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);
+                        emitEvent({ type: "folderCountsChanged", accountId, counts: {} });
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.error(`[sync] ${folder.path}: reconcile error: ${e.message}`);
+        }
+        emitEvent({ type: "folderSynced", accountId, entries: [{ folderId, syncedAt: Date.now() }] });
         emitEvent({ type: "syncProgress", accountId, phase: `sync:${folder.path}`, progress: 100 });
     }
     storeProviderMessages(accountId, folderId, messages) {
@@ -286,8 +335,122 @@ class AndroidSyncManager {
     async undeleteMessage(accountId, uid, folderId) {
         this.db.queueSyncAction(accountId, "undelete", uid, folderId);
     }
-    queueOutgoingLocal(accountId, _rawMessage) {
-        console.log(`[send] Queued outgoing for ${accountId}`);
+    queueOutgoingLocal(accountId, rawMessage) {
+        // Two paths, both real (no stubs that pretend success — see programming.md
+        // rule "Stubs MUST NOT appear successful"):
+        //   - Gmail accounts: POST to users.messages.send (Gmail handles SMTP +
+        //     auto-files into Sent label).
+        //   - Non-Gmail accounts: smtp-direct over BridgeTransport (mailxapi.tcp).
+        // Caller (web-service.send) is sync-returning; we kick off the network
+        // request and surface success/failure via events. Compose UI listens for
+        // sendError/sendComplete.
+        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})`);
+                emitEvent({ type: "sendComplete", accountId, messageId: result.id });
+            })
+                .catch((e) => {
+                console.error(`[send] ${accountId}: Gmail send failed: ${e.message}`);
+                emitEvent({ type: "sendError", accountId, error: e.message });
+            });
+            return;
+        }
+        // Non-Gmail: use smtp-direct + BridgeTransport. Pull SMTP config from the
+        // stored account JSON.
+        const accounts = db.getAccountConfigs();
+        const row = accounts.find(a => a.id === accountId);
+        if (!row) {
+            const e = "Unknown account";
+            console.error(`[send] ${accountId}: ${e}`);
+            emitEvent({ type: "sendError", accountId, error: e });
+            throw new Error(e);
+        }
+        let account;
+        try {
+            account = JSON.parse(row.configJson);
+        }
+        catch {
+            const e = "Account config malformed";
+            emitEvent({ type: "sendError", accountId, error: e });
+            throw new Error(e);
+        }
+        if (!account.smtp) {
+            const e = "No SMTP config for this account";
+            console.error(`[send] ${accountId}: ${e}`);
+            emitEvent({ type: "sendError", accountId, error: e });
+            throw new Error(e);
+        }
+        // Fire async — same pattern as Gmail path above.
+        this.sendViaSmtpDirect(accountId, account, rawMessage)
+            .then((result) => {
+            console.log(`[send] ${accountId}: sent via SMTP (${result.accepted.length} accepted, ${result.rejected.length} rejected)`);
+            emitEvent({ type: "sendComplete", accountId });
+        })
+            .catch((e) => {
+            console.error(`[send] ${accountId}: SMTP send failed: ${e.message}`);
+            emitEvent({ type: "sendError", accountId, error: e.message });
+        });
+    }
+    /** Build SMTP config from account, send via smtp-direct over BridgeTransport. */
+    async sendViaSmtpDirect(accountId, account, raw) {
+        const SMTP_PORT_STARTTLS = 587;
+        const SMTP_PORT_IMPLICIT_TLS = 465;
+        const smtp = account.smtp;
+        const smtpPort = smtp.port || SMTP_PORT_STARTTLS;
+        const smtpHost = smtp.host || account.imap?.host;
+        if (!smtpHost)
+            throw new Error("No SMTP host");
+        // Auth: password → PLAIN; oauth2 → XOAUTH2 (token from this account's provider)
+        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 };
+        }
+        // Recipients from headers
+        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 === SMTP_PORT_IMPLICIT_TLS,
+            auth,
+            localname: "mailx-android",
+        }, () => new BridgeTcpTransport());
+        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;
@@ -618,6 +781,13 @@ export async function initAndroid() {
     setTimeout(() => {
         syncManager.syncAll().catch(e => console.error(`[android] Sync error: ${e.message}`));
     }, 1000);
+    // Periodic re-sync every 2 minutes (no IDLE on Android, so poll)
+    const SYNC_INTERVAL_MS = 2 * 60 * 1000;
+    setInterval(() => {
+        console.log("[sync] periodic poll");
+        vlog("periodic sync poll");
+        syncManager.syncAll().catch(e => console.error(`[android] Periodic sync error: ${e.message}`));
+    }, SYNC_INTERVAL_MS);
     console.log("[android] Initialization complete");
     emitEvent({ type: "connected" });
 }

package/packages/mailx-store-web/gmail-api-web.d.ts

@@ -24,6 +24,13 @@ export declare class GmailApiWebProvider implements MailProvider {
     fetchOne(folder: string, uid: number, options?: FetchOptions): Promise<ProviderMessage | null>;
     getUids(folder: string): Promise<number[]>;
     close(): Promise<void>;
+    /** Send an RFC 2822 message via Gmail API users.messages.send. The server
+     *  handles SMTP — we just hand it the raw bytes base64url-encoded. Auto-files
+     *  a copy into the Sent label, so caller does NOT need to APPEND to Sent. */
+    sendRaw(rawRfc822: string): Promise<{
+        id: string;
+        threadId: string;
+    }>;
     private folderToLabel;
     private formatDate;
 }

package/packages/mailx-store-web/gmail-api-web.js

@@ -227,6 +227,18 @@ export class GmailApiWebProvider {
         return ids.map(idToUid);
     }
     async close() { }
+    /** Send an RFC 2822 message via Gmail API users.messages.send. The server
+     *  handles SMTP — we just hand it the raw bytes base64url-encoded. Auto-files
+     *  a copy into the Sent label, so caller does NOT need to APPEND to Sent. */
+    async sendRaw(rawRfc822) {
+        const b64 = btoa(unescape(encodeURIComponent(rawRfc822)))
+            .replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+        const data = await this.apiFetch("/messages/send", {
+            method: "POST",
+            body: JSON.stringify({ raw: b64 }),
+        });
+        return { id: data.id, threadId: data.threadId };
+    }
     folderToLabel(path) {
         const lower = path.toLowerCase();
         if (lower === "inbox")

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

@@ -5,14 +5,23 @@
  * The native shell (MAUI) exposes TCP via window._nativeBridge.tcp.*; we alias it
  * to window.msgapi in initAndroid() because iflow-direct's BridgeTransport expects
  * that global name.
+ *
+ * Includes automatic retry on broken pipe / connection errors: if an operation fails
+ * with a connection-related error, we create a fresh client and retry once.
  */
 import { type ImapClientConfig } from "@bobfrankston/iflow-direct";
 import type { MailProvider, ProviderFolder, ProviderMessage, FetchOptions } from "./provider-types.js";
 export declare class ImapWebProvider implements MailProvider {
     private client;
+    private config;
+    private transportFactory;
     private specialFolders;
     private folderListCache;
     constructor(config: ImapClientConfig);
+    /** Create a fresh client (after broken pipe / connection error) */
+    private reconnect;
+    /** Run an operation with one retry on connection error */
+    private withRetry;
     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[]>;

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

@@ -5,6 +5,9 @@
  * The native shell (MAUI) exposes TCP via window._nativeBridge.tcp.*; we alias it
  * to window.msgapi in initAndroid() because iflow-direct's BridgeTransport expects
  * that global name.
+ *
+ * Includes automatic retry on broken pipe / connection errors: if an operation fails
+ * with a connection-related error, we create a fresh client and retry once.
  */
 import { CompatImapClient, BridgeTransport } from "@bobfrankston/iflow-direct";
 /**
@@ -54,16 +57,50 @@ function toProviderMessage(m) {
         source: m.source || "",
     };
 }
+/** Check if an error is a connection/broken-pipe error worth retrying */
+function isConnectionError(e) {
+    const msg = (e?.message || "").toLowerCase();
+    return msg.includes("broken pipe") || msg.includes("not connected") ||
+        msg.includes("connection") || msg.includes("socket") ||
+        msg.includes("timeout") || msg.includes("econnreset") ||
+        msg.includes("epipe") || msg.includes("closed");
+}
 export class ImapWebProvider {
     client;
+    config;
+    transportFactory;
     specialFolders = {};
     folderListCache = null;
     constructor(config) {
-        const transportFactory = () => new BridgeTransport();
-        this.client = new CompatImapClient(config, transportFactory);
+        this.config = config;
+        this.transportFactory = () => new BridgeTransport();
+        this.client = new CompatImapClient(config, this.transportFactory);
+    }
+    /** Create a fresh client (after broken pipe / connection error) */
+    reconnect() {
+        console.log("[imap-web] reconnecting after connection error");
+        try {
+            this.client.logout();
+        }
+        catch { /* ignore */ }
+        this.client = new CompatImapClient(this.config, this.transportFactory);
+    }
+    /** Run an operation with one retry on connection error */
+    async withRetry(op, label) {
+        try {
+            return await op();
+        }
+        catch (e) {
+            if (isConnectionError(e)) {
+                console.warn(`[imap-web] ${label}: ${e.message} — reconnecting and retrying`);
+                this.reconnect();
+                return await op();
+            }
+            throw e;
+        }
     }
     async listFolders() {
-        const native = await this.client.getFolderList();
+        const native = await this.withRetry(() => this.client.getFolderList(), "listFolders");
         const special = this.client.getSpecialFolders(native);
         this.specialFolders = special;
         const result = native.map(f => toProviderFolder(f, this.specialFolders));
@@ -71,27 +108,27 @@ export class ImapWebProvider {
         return result;
     }
     async fetchSince(folder, sinceUid, options) {
-        const msgs = await this.client.fetchMessagesSinceUid(folder, sinceUid, { source: !!options?.source });
+        const msgs = await this.withRetry(() => this.client.fetchMessagesSinceUid(folder, sinceUid, { source: !!options?.source }), `fetchSince(${folder})`);
         return msgs.map(toProviderMessage);
     }
     async fetchByDate(folder, since, before, options, onChunk) {
         const wrappedChunk = onChunk ? (raw) => onChunk(raw.map(toProviderMessage)) : undefined;
-        const msgs = await this.client.fetchMessageByDate(folder, since, before, { source: !!options?.source }, wrappedChunk);
+        const msgs = await this.withRetry(() => this.client.fetchMessageByDate(folder, since, before, { source: !!options?.source }, wrappedChunk), `fetchByDate(${folder})`);
         return msgs.map(toProviderMessage);
     }
     async fetchByUids(folder, uids, options) {
         if (!uids.length)
             return [];
         const range = uids.join(",");
-        const msgs = await this.client.fetchMessages(folder, range, { source: !!options?.source });
+        const msgs = await this.withRetry(() => this.client.fetchMessages(folder, range, { source: !!options?.source }), `fetchByUids(${folder})`);
         return msgs.map(toProviderMessage);
     }
     async fetchOne(folder, uid, options) {
-        const msg = await this.client.fetchMessageByUid(folder, uid, { source: !!options?.source });
+        const msg = await this.withRetry(() => this.client.fetchMessageByUid(folder, uid, { source: !!options?.source }), `fetchOne(${folder}/${uid})`);
         return msg ? toProviderMessage(msg) : null;
     }
     async getUids(folder) {
-        return this.client.getUids(folder);
+        return this.withRetry(() => this.client.getUids(folder), `getUids(${folder})`);
     }
     async close() {
         try {

package/packages/mailx-store-web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-store-web",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -10,6 +10,9 @@
   "license": "ISC",
   "dependencies": {
     "@bobfrankston/mailx-types": "file:../mailx-types",
+    "@bobfrankston/iflow-direct": "file:../../../MailApps/iflow-direct",
+    "@bobfrankston/tcp-transport": "file:../../../MailApps/tcp-transport",
+    "@bobfrankston/smtp-direct": "file:../../../MailApps/smtp-direct",
     "sql.js": "^1.14.1"
   },
   "repository": {

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

@@ -159,6 +159,13 @@ export type WsEvent = {
         total: number;
         unread: number;
     }>;
+} | {
+    type: "folderSynced";
+    accountId: string;
+    entries: {
+        folderId: number;
+        syncedAt: number;
+    }[];
 } | {
     type: "syncProgress";
     accountId: string;

package/test-smtp-direct.mjs

@@ -0,0 +1,4 @@
+// Removed after one-shot smtp-direct test on 2026-04-13.
+// Original sent a test message to test1@bob.ma via iecc submission.
+// Result: 250 Accepted message qp 15437 (server queued for delivery).
+// File overwritten because it had a plaintext password; safe to delete.