@bobfrankston/mailx 1.0.395 → 1.0.399

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

@@ -447,6 +447,58 @@ class AndroidSyncManager {
     async undeleteMessage(accountId, uid, folderId) {
         this.db.queueSyncAction(accountId, "undelete", uid, folderId);
     }
+    /** Q112: drain queued move/flag/trash actions to the provider. Android is
+     *  standalone — it pushes state changes directly to Gmail (or other
+     *  provider) the same way desktop does. Called from the periodic 2-min
+     *  tick above. `send` actions drain separately via `processSendQueue`. */
+    async processSyncActions(accountId) {
+        const provider = this.providers.get(accountId);
+        if (!provider)
+            return;
+        const pending = this.db.getPendingSyncActions(accountId)
+            .filter((a) => a.action !== "send");
+        if (pending.length === 0)
+            return;
+        const folders = this.db.getFolders(accountId);
+        const folderPath = (id) => {
+            const f = folders.find((x) => x.id === id);
+            return f?.path || null;
+        };
+        for (const p of pending) {
+            const path = folderPath(p.folderId);
+            if (!path) {
+                this.db.failSyncActionByUid(accountId, p.action, p.uid, `unknown folder ${p.folderId}`);
+                continue;
+            }
+            try {
+                if (p.action === "flags" && typeof provider.setFlags === "function") {
+                    await provider.setFlags(path, p.uid, Array.isArray(p.flags) ? p.flags : (p.flags ? [p.flags] : []));
+                }
+                else if (p.action === "trash" && typeof provider.trashMessage === "function") {
+                    await provider.trashMessage(path, p.uid);
+                }
+                else if (p.action === "move" && typeof provider.moveMessage === "function") {
+                    const toId = p.targetFolderId;
+                    const toPath = folderPath(toId);
+                    if (!toPath) {
+                        this.db.failSyncActionByUid(accountId, p.action, p.uid, `unknown target folder ${toId}`);
+                        continue;
+                    }
+                    await provider.moveMessage(path, p.uid, toPath);
+                }
+                else {
+                    this.db.failSyncActionByUid(accountId, p.action, p.uid, `provider does not support ${p.action}`);
+                    continue;
+                }
+                this.db.completeSyncActionByUid(accountId, p.action, p.uid);
+            }
+            catch (e) {
+                const msg = e?.message || String(e);
+                console.error(`[sync-action] ${accountId} ${p.action} uid=${p.uid}: ${msg}`);
+                this.db.failSyncActionByUid(accountId, p.action, p.uid, msg);
+            }
+        }
+    }
     queueOutgoingLocal(accountId, rawMessage) {
         // Local-first: PERSIST to sync_actions before attempting the network
         // send, so a crash / offline / process kill between now and SMTP ACK
@@ -919,11 +971,16 @@ export async function initAndroid() {
     // Drain any stranded send-queue entries BEFORE first sync. A message
     // queued in a prior session (offline, crashed mid-send, process killed)
     // gets a retry as soon as we have accounts registered. Desktop parity.
+    // Q112 (2026-04-24): also drain move/flag/trash actions here — Android
+    // is standalone, not desktop-dependent, so it pushes state changes
+    // directly to the server the same way desktop does.
     for (const account of accounts) {
         if (!account.enabled)
             continue;
         syncManager.processSendQueue(account.id)
             .catch(e => console.error(`[android] processSendQueue ${account.id}: ${e.message}`));
+        syncManager.processSyncActions(account.id)
+            .catch(e => console.error(`[android] processSyncActions ${account.id}: ${e.message}`));
     }
     setTimeout(() => {
         syncManager.syncAll().catch(e => console.error(`[android] Sync error: ${e.message}`));
@@ -937,6 +994,8 @@ export async function initAndroid() {
         for (const account of db.getAccounts()) {
             syncManager.processSendQueue(account.id)
                 .catch(e => console.error(`[android] retry ${account.id}: ${e.message}`));
+            syncManager.processSyncActions(account.id)
+                .catch(e => console.error(`[android] processSyncActions ${account.id}: ${e.message}`));
         }
         syncManager.syncAll().catch(e => console.error(`[android] Periodic sync error: ${e.message}`));
     }, SYNC_INTERVAL_MS);
@@ -998,6 +1057,7 @@ function installBridge() {
         },
         searchMessages: (query, page, pageSize) => service.search(query, page, pageSize),
         searchContacts: (query) => service.searchContacts(query),
+        hasCcHistoryTo: (email) => ({ hasCc: service.hasCcHistoryTo?.(email) ?? false }),
         syncAll: async () => { await service.syncAll(); return { ok: true }; },
         syncAccount: async (accountId) => { await service.syncAccount(accountId); return { ok: true }; },
         getSyncPending: () => service.getSyncPending(),

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

@@ -94,6 +94,10 @@ export declare class WebMailxDB {
         source: string;
         useCount: number;
     }[];
+    /** Q49 heuristic: has the user ever sent to `recipientEmail` with a
+     *  non-empty Cc? Scans Sent folder(s). Used by compose to auto-expand
+     *  the Cc row on reply to a frequent-Cc'd recipient. */
+    hasCcHistoryTo(recipientEmail: string): boolean;
     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;

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

@@ -483,11 +483,36 @@ export class WebMailxDB {
         return added;
     }
     searchContacts(query, limit = 10) {
+        query = (query || "").trim();
+        if (!query)
+            return [];
         const q = `%${query}%`;
         return this.all(`SELECT name, email, source, use_count as useCount FROM contacts
              WHERE email LIKE ? OR name LIKE ?
              ORDER BY use_count DESC, last_used DESC LIMIT ?`, [q, q, limit]);
     }
+    /** Q49 heuristic: has the user ever sent to `recipientEmail` with a
+     *  non-empty Cc? Scans Sent folder(s). Used by compose to auto-expand
+     *  the Cc row on reply to a frequent-Cc'd recipient. */
+    hasCcHistoryTo(recipientEmail) {
+        const email = (recipientEmail || "").trim().toLowerCase();
+        if (!email)
+            return false;
+        try {
+            const row = this.get(`
+                SELECT 1 FROM messages m
+                JOIN folders f ON m.folder_id = f.id
+                WHERE f.special_use = 'sent'
+                  AND lower(m.to_json) LIKE ?
+                  AND m.cc_json IS NOT NULL AND m.cc_json != '[]' AND m.cc_json != ''
+                LIMIT 1
+            `, [`%"${email}"%`]);
+            return !!row;
+        }
+        catch {
+            return false;
+        }
+    }
     // ── Search ──
     searchMessages(query, page = 1, pageSize = 50, accountId, folderId) {
         const offset = (page - 1) * pageSize;

package/packages/mailx-store-web/sync-manager.d.ts

@@ -48,6 +48,13 @@ export declare class SyncManager implements WebSyncManager {
     }[], targetFolderId: number): Promise<void>;
     moveMessageCrossAccount(): Promise<void>;
     undeleteMessage(accountId: string, uid: number, folderId: number): Promise<void>;
+    /** Q112: drain queued move/flag/trash actions to the provider. Android is
+     *  standalone — it pushes state changes to Gmail (or other provider) the
+     *  same way desktop does, so local actions propagate without needing a
+     *  desktop to relay them. Called from android-bootstrap on startup and
+     *  every 2-min sync tick. `send` actions are drained separately by
+     *  processSendQueue. */
+    processSyncActions(accountId: string): Promise<void>;
     markFolderRead(folderId: number): Promise<void>;
     emptyFolder(accountId: string, folderId: number): Promise<void>;
     queueOutgoingLocal(accountId: string, rawMessage: string): void;

package/packages/mailx-store-web/sync-manager.js

@@ -329,6 +329,61 @@ export class SyncManager {
     async undeleteMessage(accountId, uid, folderId) {
         this.db.queueSyncAction(accountId, "undelete", uid, folderId);
     }
+    /** Q112: drain queued move/flag/trash actions to the provider. Android is
+     *  standalone — it pushes state changes to Gmail (or other provider) the
+     *  same way desktop does, so local actions propagate without needing a
+     *  desktop to relay them. Called from android-bootstrap on startup and
+     *  every 2-min sync tick. `send` actions are drained separately by
+     *  processSendQueue. */
+    async processSyncActions(accountId) {
+        const provider = this.getProvider(accountId);
+        if (!provider)
+            return;
+        const pending = this.db.getPendingSyncActions(accountId)
+            .filter((a) => a.action !== "send");
+        if (pending.length === 0)
+            return;
+        const folders = this.db.getFolders(accountId);
+        const folderPath = (id) => {
+            const f = folders.find((x) => x.id === id);
+            return f?.path || null;
+        };
+        for (const p of pending) {
+            const path = folderPath(p.folderId);
+            if (!path) {
+                this.db.failSyncActionByUid(accountId, p.action, p.uid, `unknown folder ${p.folderId}`);
+                continue;
+            }
+            try {
+                if (p.action === "flags" && typeof provider.setFlags === "function") {
+                    await provider.setFlags(path, p.uid, Array.isArray(p.flags) ? p.flags : (p.flags ? [p.flags] : []));
+                }
+                else if (p.action === "trash" && typeof provider.trashMessage === "function") {
+                    await provider.trashMessage(path, p.uid);
+                }
+                else if (p.action === "move" && typeof provider.moveMessage === "function") {
+                    const toId = p.targetFolderId;
+                    const toPath = folderPath(toId);
+                    if (!toPath) {
+                        this.db.failSyncActionByUid(accountId, p.action, p.uid, `unknown target folder ${toId}`);
+                        continue;
+                    }
+                    await provider.moveMessage(path, p.uid, toPath);
+                }
+                else {
+                    // Unsupported action for this provider — don't loop forever.
+                    this.db.failSyncActionByUid(accountId, p.action, p.uid, `provider does not support ${p.action}`);
+                    continue;
+                }
+                this.db.completeSyncActionByUid(accountId, p.action, p.uid);
+            }
+            catch (e) {
+                const msg = e?.message || String(e);
+                console.error(`[sync-action] ${accountId} ${p.action} uid=${p.uid}: ${msg}`);
+                this.db.failSyncActionByUid(accountId, p.action, p.uid, msg);
+            }
+        }
+    }
     async markFolderRead(folderId) {
         this.db.markFolderRead(folderId);
     }

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

@@ -71,6 +71,10 @@ export declare class WebMailxService {
     }>;
     deleteDraft(accountId: string, draftUid: number): Promise<void>;
     searchContacts(query: string): any[];
+    /** Q49 heuristic mirror: true if the user has ever sent a message to
+     *  `recipientEmail` that had a non-empty Cc field. Compose uses this to
+     *  decide whether to auto-expand the Cc row on reply. */
+    hasCcHistoryTo(recipientEmail: string): boolean;
     getSettings(): Promise<any>;
     saveSettingsData(settings: any): Promise<void>;
     getStorageInfo(): {

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

@@ -437,10 +437,17 @@ export class WebMailxService {
     }
     // ── Contacts ──
     searchContacts(query) {
+        query = (query || "").trim();
         if (query.length < 1)
             return [];
         return this.db.searchContacts(query);
     }
+    /** Q49 heuristic mirror: true if the user has ever sent a message to
+     *  `recipientEmail` that had a non-empty Cc field. Compose uses this to
+     *  decide whether to auto-expand the Cc row on reply. */
+    hasCcHistoryTo(recipientEmail) {
+        return this.db.hasCcHistoryTo?.(recipientEmail) ?? false;
+    }
     // ── Settings ──
     async getSettings() {
         return loadSettings();

package/tdview.cmd

@@ -0,0 +1 @@
+call mdview todo.md -pos 100,100,1 -size 900,1400