@bobfrankston/mailx 1.0.394 → 1.0.399

package/client/styles/layout.css

@@ -153,10 +153,15 @@ body.calendar-sidebar-on {
             "status   status";
     }
 
-    /* Folder panel: overlay slide-in from left, sitting just to the right of the rail */
+    /* Folder panel: FULLY off-screen when closed — previously `calc(48px -
+       280px) = -232px` left a 48 px tail showing behind the rail, which on
+       Android (where the rail isn't always rendered) leaked a strip of
+       folder-row badges at the left edge of the viewport. Now the closed
+       panel is flush off-screen at `-280px` and the `.open` slide-in starts
+       at the rail's right edge. */
     .folder-panel {
         position: fixed;
-        left: calc(var(--rail-width, 48px) - 280px);
+        left: -280px;
         top: var(--toolbar-height);
         bottom: var(--statusbar-height);
         width: 280px;
@@ -168,14 +173,19 @@ body.calendar-sidebar-on {
     }
     .folder-panel.open { left: var(--rail-width, 48px); }
 
-    /* Show hamburger */
-    #btn-menu { display: inline-flex !important; }
+    /* Medium tier has the rail visible permanently — no hamburger needed.
+       Show the folder-toggle (📁) so the user can still reveal the folder
+       tree on demand. */
+    #btn-menu { display: none !important; }
+    #btn-folder-toggle { display: inline-flex !important; }
 }
 
 /* Responsive: narrow OR short viewport — single panel navigation */
 @media (max-width: 768px), (max-height: 600px) {
-    /* Hide preview snippet under message subject — save space */
-    .ml-preview { display: none; }
+    /* Preview snippets remain visible on narrow — user-controlled via the
+       View menu's "Preview snippets" checkbox. Previously this rule forced
+       them hidden on any narrow viewport, so Android users never saw the
+       checkbox take effect. */
     /* Column headers (From/Date/Subject) take space without being useful on narrow */
     .ml-header { display: none; }
     /* Current folder name shown above the list, Dovecot-style */
@@ -208,12 +218,25 @@ body.calendar-sidebar-on {
             "status";
     }
 
-    /* Rail hidden on narrow — its commands fold into the hamburger / toolbar.
-       Future work: a slide-in rail behind the hamburger so power-users on phone
-       can still reach calendar/contacts/etc. */
-    .icon-rail { display: none; }
+    /* Rail on narrow: slide-in drawer triggered by the hamburger (☰). The
+       rail is the entry point to Inbox / All-Inboxes / Contacts / Calendar /
+       Tasks / Settings — without this drawer, narrow-tier users couldn't
+       reach any of those. */
+    .icon-rail {
+        display: flex;
+        position: fixed;
+        left: -64px;
+        top: var(--toolbar-height);
+        bottom: var(--statusbar-height);
+        z-index: 60;
+        transition: left 0.2s ease;
+        box-shadow: 2px 0 8px rgba(0,0,0,0.3);
+    }
+    .icon-rail.open { left: 0; }
 
-    /* Folder panel: overlay slide-in from left */
+    /* Folder panel: slide-in drawer triggered by the folder icon (📁).
+       Kept separate from the rail drawer so the user can have folders open
+       while the rail is closed, or vice versa — matching the desktop flow. */
     .folder-panel {
         position: fixed;
         left: -280px;
@@ -246,8 +269,10 @@ body.calendar-sidebar-on {
     }
     .message-list.narrow-hidden { display: none; }
 
-    /* Show hamburger always on narrow */
+    /* Hamburger opens the rail drawer; folder-toggle opens the folder drawer.
+       Both always visible on narrow so the user can reach either. */
     #btn-menu { display: inline-flex !important; }
+    #btn-folder-toggle { display: inline-flex !important; }
     /* Back button: only show when viewer is active (message list hidden) */
     #btn-back { display: none !important; }
     .message-viewer.narrow-active ~ * #btn-back,
@@ -280,7 +305,8 @@ body.calendar-sidebar-on {
     }
 }
 
-/* Hide hamburger and back on wide screens (folder panel always visible) */
+/* Hide hamburger, folder-toggle, and back on wide screens (folder panel
+   permanent column, rail permanent column, no drawer toggles needed). */
 @media (min-width: 1101px) {
-    #btn-menu, #btn-back { display: none !important; }
+    #btn-menu, #btn-folder-toggle, #btn-back { display: none !important; }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.394",
+  "version": "1.0.399",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",

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

@@ -158,6 +158,10 @@ export declare class MailxService {
     }>;
     deleteDraft(accountId: string, draftUid: number, draftId?: string): Promise<void>;
     searchContacts(query: string): any[];
+    /** Q49: boolean hint for compose to auto-expand Cc when replying to this
+     *  address. True when at least one past sent message to the same recipient
+     *  had a non-empty Cc field. */
+    hasCcHistoryTo(email: string): boolean;
     syncGoogleContacts(): Promise<void>;
     seedContacts(): number;
     /** Explicit add to address book — used by the right-click "Add to contacts"

package/packages/mailx-service/index.js

@@ -1351,6 +1351,12 @@ export class MailxService {
             return [];
         return this.db.searchContacts(query);
     }
+    /** Q49: boolean hint for compose to auto-expand Cc when replying to this
+     *  address. True when at least one past sent message to the same recipient
+     *  had a non-empty Cc field. */
+    hasCcHistoryTo(email) {
+        return this.db.hasCcHistoryTo(email);
+    }
     async syncGoogleContacts() {
         await this.imapManager.syncAllContacts();
     }

package/packages/mailx-service/jsonrpc.js

@@ -140,6 +140,8 @@ async function dispatchAction(svc, action, p) {
             return svc.search(p.query, p.page, p.pageSize, p.scope, p.accountId, p.folderId);
         case "searchContacts":
             return svc.searchContacts(p.query);
+        case "hasCcHistoryTo":
+            return { hasCc: svc.hasCcHistoryTo(p.email) };
         case "addContact":
             return { ok: svc.addContact(p.name, p.email) };
         case "listContacts":

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

@@ -19,6 +19,14 @@ export declare class MailxDB {
     hasSentMessage(messageId: string): boolean;
     /** Record a successfully sent message so future attempts are skipped. */
     recordSent(messageId: string, accountId: string, subject: string, recipients: string[]): void;
+    /** Q49 heuristic: has the user ever sent a message to `recipientEmail`
+     *  that had a non-empty Cc field? Used by compose to auto-expand the Cc
+     *  input when replying to someone who customarily gets Cc'd with others.
+     *  Query scans only Sent folders (special_use='sent') and matches the
+     *  recipient's address inside `to_json` via LIKE. No special index — the
+     *  Sent folder's row count is typically a few thousand at most; acceptable
+     *  on the compose-open path. */
+    hasCcHistoryTo(recipientEmail: string): boolean;
     /** Mark a Message-ID as locally-deleted for an account. No-op if messageId
      *  is empty (e.g. provider stripped the header) — without a stable id we
      *  can't check against future sync results anyway. */

package/packages/mailx-store/db.js

@@ -338,6 +338,32 @@ export class MailxDB {
             console.error(`  [sent_log] failed to record ${messageId}: ${e.message}`);
         }
     }
+    /** Q49 heuristic: has the user ever sent a message to `recipientEmail`
+     *  that had a non-empty Cc field? Used by compose to auto-expand the Cc
+     *  input when replying to someone who customarily gets Cc'd with others.
+     *  Query scans only Sent folders (special_use='sent') and matches the
+     *  recipient's address inside `to_json` via LIKE. No special index — the
+     *  Sent folder's row count is typically a few thousand at most; acceptable
+     *  on the compose-open path. */
+    hasCcHistoryTo(recipientEmail) {
+        const email = (recipientEmail || "").trim().toLowerCase();
+        if (!email)
+            return false;
+        try {
+            const row = this.db.prepare(`
+                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
+            `).get(`%"${email}"%`);
+            return !!row;
+        }
+        catch {
+            return false;
+        }
+    }
     // ── Tombstones (local-delete record so server echo can't resurrect) ──
     /** Mark a Message-ID as locally-deleted for an account. No-op if messageId
      *  is empty (e.g. provider stripped the header) — without a stable id we

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