@bobfrankston/mailx 1.0.377 → 1.0.378

package/client/components/calendar-sidebar.js

@@ -58,7 +58,7 @@ async function fetchUpcoming(from) {
     const local = loadLocalEvents();
     let google = [];
     try {
-        const primary = await getPrimaryAccount();
+        const primary = await getPrimaryAccount("calendar");
         if (primary?.email) {
             // The OAuth token is held by the service-side OAuthTokenManager;
             // calendar fetch goes through a server-side proxy method (not

package/client/components/message-list.js

@@ -370,7 +370,7 @@ function restoreSelection(body, savedUid) {
 /** Show a floating list of all messages in a thread when the pill is clicked.
  *  Each entry in the popup selects that message in the viewer when clicked.
  *  This is simpler than inline expansion and avoids duplicating the row builder. */
-async function showThreadPopup(pillEl, headMsg) {
+export async function showThreadPopup(pillEl, headMsg) {
     // Remove any existing popup
     document.querySelectorAll(".ml-thread-popup").forEach(el => el.remove());
     let thread = [];
@@ -464,6 +464,11 @@ function appendMessages(body, accountId, items) {
         // action (move/flag/delete) hasn't been ACK'd by the server yet.
         if (msg.pending)
             row.classList.add("pending-reconcile");
+        // Reply-row marker: messages with In-Reply-To are replies. Shows a
+        // subtle left-border accent so the eye can pick out threaded replies
+        // without enabling full thread grouping.
+        if (msg.inReplyTo)
+            row.classList.add("is-reply");
         row.dataset.uid = String(msg.uid);
         row.dataset.accountId = msgAccountId;
         row.dataset.folderId = String(msg.folderId);
@@ -600,6 +605,37 @@ function appendMessages(body, accountId, items) {
             }
         });
         row.addEventListener("dragend", () => row.classList.remove("dragging"));
+        // ── Q66: long-press on touch → context menu ──
+        // Mirrors right-click on the phone where right-click isn't a thing.
+        // Cancelled by any touchmove or touchend before the threshold.
+        let longPressTimer = null;
+        const LONG_PRESS_MS = 550;
+        row.addEventListener("touchstart", (e) => {
+            const t = e.touches[0];
+            if (!t)
+                return;
+            const cx = t.clientX, cy = t.clientY;
+            if (longPressTimer)
+                clearTimeout(longPressTimer);
+            longPressTimer = setTimeout(() => {
+                longPressTimer = null;
+                // Synthesize a contextmenu event so the existing handler below
+                // owns all the menu logic — no per-event duplication.
+                const ev = new MouseEvent("contextmenu", {
+                    clientX: cx, clientY: cy, bubbles: true, cancelable: true,
+                });
+                row.dispatchEvent(ev);
+            }, LONG_PRESS_MS);
+        }, { passive: true });
+        const cancelLongPress = () => {
+            if (longPressTimer) {
+                clearTimeout(longPressTimer);
+                longPressTimer = null;
+            }
+        };
+        row.addEventListener("touchmove", cancelLongPress, { passive: true });
+        row.addEventListener("touchend", cancelLongPress, { passive: true });
+        row.addEventListener("touchcancel", cancelLongPress, { passive: true });
         // ── Right-click context menu ──
         row.addEventListener("contextmenu", (e) => {
             e.preventDefault();

package/client/components/message-viewer.js

@@ -395,6 +395,23 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
                 unsubBtn.hidden = true;
             }
         }
+        // View Thread button — opens the thread popup from the message list
+        // so the user can see all messages in the conversation. Works from
+        // the viewer even when thread-grouping is off.
+        const threadBtn = document.getElementById("mv-view-thread");
+        if (threadBtn) {
+            const tid = msg.threadId || "";
+            if (tid) {
+                threadBtn.hidden = false;
+                threadBtn.onclick = async () => {
+                    const { showThreadPopup } = await import("./message-list.js");
+                    await showThreadPopup(threadBtn, { accountId, threadId: tid });
+                };
+            }
+            else {
+                threadBtn.hidden = true;
+            }
+        }
         // View Source button — shows .eml file path
         const srcBtn = document.getElementById("mv-view-source");
         if (srcBtn) {

package/client/index.html

@@ -134,6 +134,7 @@
                     <button class="tb-btn" id="btn-spam" title="Mark as spam — move to configured spam folder" hidden>⚠</button>
                     <button class="tb-btn" id="btn-flag" title="Flag">⚑</button>
                     <button class="tb-btn" id="btn-mark-unread" title="Mark unread (R)">◉</button>
+                    <button class="tb-btn" id="mv-view-thread" title="View thread (conversation)" hidden>💬</button>
                     <span style="flex:1"></span>
                     <button class="mv-action mv-action-primary" id="mv-edit-draft" hidden>Edit & Send</button>
                     <a class="mv-unsubscribe" id="mv-unsubscribe" hidden>Unsubscribe</a>

package/client/lib/api-client.js

@@ -134,10 +134,12 @@ export function getSyncPending() {
 export function getDiagnostics() {
     return ipc().getDiagnostics?.() ?? Promise.resolve([]);
 }
-/** Account marked `primary: true` in accounts.jsonc — used by Calendar /
- *  Tasks / Contacts to pick which Google account's data to show. */
-export function getPrimaryAccount() {
-    return ipc().getPrimaryAccount?.() ?? Promise.resolve(null);
+/** Account that supplies `feature` data (calendar / tasks / contacts).
+ *  Resolution: per-feature primary flag → catch-all `primary` → first account.
+ *  Pass e.g. "calendar" to honor `primaryCalendar:true` overrides; omit for
+ *  back-compat single-flag behavior. */
+export function getPrimaryAccount(feature) {
+    return ipc().getPrimaryAccount?.(feature) ?? Promise.resolve(null);
 }
 export function getOutboxStatus() {
     return ipc().getOutboxStatus();

package/client/lib/mailxapi.js

@@ -160,7 +160,7 @@
         getSyncPending: function() { return callNode("getSyncPending"); },
         getOutboxStatus: function() { return callNode("getOutboxStatus"); },
         getDiagnostics: function() { return callNode("getDiagnostics"); },
-        getPrimaryAccount: function() { return callNode("getPrimaryAccount"); },
+        getPrimaryAccount: function(feature) { return callNode("getPrimaryAccount", { feature: feature }); },
         listQueuedOutgoing: function() { return callNode("listQueuedOutgoing"); },
         cancelQueuedOutgoing: function(p) { return callNode("cancelQueuedOutgoing", { path: p }); },
         reauthenticate: function(accountId) { return callNode("reauthenticate", { accountId: accountId }); },

package/client/styles/components.css

@@ -788,6 +788,24 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
     opacity: 0.5;
 }
 
+/* Reply marker — messages whose In-Reply-To points at another message get a
+   subtle left-edge accent so threaded replies visibly distinguish from top-
+   level posts without needing thread-grouping mode on. Works regardless of
+   whether thread-grouping is enabled. */
+.ml-row.is-reply::before {
+    content: "";
+    position: absolute;
+    left: 0;
+    top: 2px;
+    bottom: 2px;
+    width: 2px;
+    background: oklch(0.70 0.12 250);  /* muted blue */
+    border-radius: 0 1px 1px 0;
+    pointer-events: none;
+    opacity: 0.5;
+}
+.ml-row { position: relative; }
+
 /* S1 slice C — local action (move/flag/delete) queued but server hasn't
    ACK'd. Reuses the same date-column dot as the download indicator so
    "still on client, not yet on server" sits in the same visual slot as

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.377",
+  "version": "1.0.378",
   "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

@@ -39,11 +39,14 @@ export declare class MailxService {
     /** Per-account health snapshot: inactivity-timeout count, conn-cap hits,
      *  last failed IMAP command. Drives the diagnostics ⚠ badge in the UI. */
     getDiagnostics(): any;
-    /** Return the account marked `primary: true` in accounts.jsonc, or the
-     *  first account if none. Used by Calendar / Tasks / Contacts to pick
-     *  which Google account's data to show. Single-flag for now;
-     *  per-feature flags + multi-calendar comingling deferred. */
-    getPrimaryAccount(): any;
+    /** Return the account that supplies `feature` data (calendar / tasks /
+     *  contacts). Resolution order:
+     *    1. Any account with `primary<Feature>: true`   (per-feature override)
+     *    2. Any account with `primary: true`            (catch-all default)
+     *    3. First account                               (fallback)
+     *  Called without `feature` it returns the catch-all primary — same
+     *  semantics as the original single-flag version for back-compat. */
+    getPrimaryAccount(feature?: string): any;
     /** List queued outgoing messages with parsed envelope headers so the UI
      *  can render a pink-row "pending" view before IMAP APPEND succeeds. */
     listQueuedOutgoing(): any[];

package/packages/mailx-service/index.js

@@ -102,7 +102,14 @@ export class MailxService {
         for (const cfg of cfgs) {
             const a = dbAccounts.find(d => d.id === cfg.id);
             if (a)
-                ordered.push({ ...a, label: cfg.label, defaultSend: cfg.defaultSend || false, primary: !!cfg.primary, identityDomains: cfg.identityDomains || [] });
+                ordered.push({
+                    ...a, label: cfg.label, defaultSend: cfg.defaultSend || false,
+                    primary: !!cfg.primary,
+                    primaryCalendar: !!cfg.primaryCalendar,
+                    primaryTasks: !!cfg.primaryTasks,
+                    primaryContacts: !!cfg.primaryContacts,
+                    identityDomains: cfg.identityDomains || [],
+                });
         }
         // Append any DB accounts not in settings
         for (const a of dbAccounts) {
@@ -421,12 +428,21 @@ export class MailxService {
     getDiagnostics() {
         return this.imapManager.getDiagnosticsSnapshot();
     }
-    /** Return the account marked `primary: true` in accounts.jsonc, or the
-     *  first account if none. Used by Calendar / Tasks / Contacts to pick
-     *  which Google account's data to show. Single-flag for now;
-     *  per-feature flags + multi-calendar comingling deferred. */
-    getPrimaryAccount() {
+    /** Return the account that supplies `feature` data (calendar / tasks /
+     *  contacts). Resolution order:
+     *    1. Any account with `primary<Feature>: true`   (per-feature override)
+     *    2. Any account with `primary: true`            (catch-all default)
+     *    3. First account                               (fallback)
+     *  Called without `feature` it returns the catch-all primary — same
+     *  semantics as the original single-flag version for back-compat. */
+    getPrimaryAccount(feature) {
         const all = this.getAccounts();
+        if (feature) {
+            const perFeatureKey = "primary" + feature.charAt(0).toUpperCase() + feature.slice(1);
+            const perFeature = all.find((a) => a[perFeatureKey]);
+            if (perFeature)
+                return perFeature;
+        }
         return all.find((a) => a.primary) || all[0] || null;
     }
     /** List queued outgoing messages with parsed envelope headers so the UI

package/packages/mailx-service/jsonrpc.js

@@ -97,7 +97,7 @@ async function dispatchAction(svc, action, p) {
         case "getDiagnostics":
             return svc.getDiagnostics();
         case "getPrimaryAccount":
-            return svc.getPrimaryAccount();
+            return svc.getPrimaryAccount(p?.feature);
         case "getOutboxStatus":
             return svc.getOutboxStatus();
         case "listQueuedOutgoing":

package/packages/mailx-settings/index.js

@@ -377,6 +377,9 @@ function normalizeAccount(acct, globalName) {
         },
         enabled: acct.enabled ?? true,
         primary: acct.primary,
+        primaryCalendar: acct.primaryCalendar,
+        primaryTasks: acct.primaryTasks,
+        primaryContacts: acct.primaryContacts,
         defaultSend: acct.defaultSend,
         syncContacts: acct.syncContacts ?? (provider?.imap.auth === "oauth2"),
         relayDomains: acct.relayDomains,

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

@@ -7,6 +7,9 @@ import type { MessageEnvelope, Folder, EmailAddress, PagedResult, MessageQuery }
 export declare class MailxDB {
     private db;
     constructor(dbDir: string);
+    /** Fail loud + early if expected columns are missing. Cheap (PRAGMA only
+     *  runs at startup). The user-facing message names the recovery command. */
+    private verifySchema;
     /** One-time: assign UUIDs to every `messages` row that's missing one.
      *  Runs on every startup but the WHERE clause makes it a no-op after the
      *  first pass. */

package/packages/mailx-store/db.js

@@ -182,6 +182,34 @@ export class MailxDB {
         // this column landed. One UPDATE + an id roundtrip per row — cheap
         // at our row counts, runs once per DB upgrade.
         this.backfillUuids();
+        // Post-migration sanity check: verify the columns we actually read in
+        // SELECTs exist. If any migration silently failed (stale driver, DB
+        // file locked, permission error), later code would throw cryptic
+        // "no such column" errors buried deep in a sync run. Fail loud here
+        // with a clear "run mailx -rebuild" message. C32 on Linux was exactly
+        // this — old mailx-store that predated thread_id/uuid migrations.
+        this.verifySchema();
+    }
+    /** Fail loud + early if expected columns are missing. Cheap (PRAGMA only
+     *  runs at startup). The user-facing message names the recovery command. */
+    verifySchema() {
+        const required = {
+            messages: ["thread_id", "provider_id", "uuid"],
+        };
+        for (const [table, cols] of Object.entries(required)) {
+            let actual;
+            try {
+                actual = this.db.prepare(`PRAGMA table_info(${table})`).all();
+            }
+            catch (e) {
+                throw new Error(`[mailx-store] schema check failed for "${table}": ${e.message}. Run 'mailx -rebuild' to rebuild the local store.`);
+            }
+            const names = new Set(actual.map(r => r.name));
+            const missing = cols.filter(c => !names.has(c));
+            if (missing.length > 0) {
+                throw new Error(`[mailx-store] table "${table}" is missing columns [${missing.join(", ")}] — schema migration did not complete. Run 'mailx -rebuild' to rebuild the local store.`);
+            }
+        }
     }
     /** One-time: assign UUIDs to every `messages` row that's missing one.
      *  Runs on every startup but the WHERE clause makes it a no-op after the

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

@@ -983,6 +983,25 @@ function installBridge() {
         syncAll: async () => { await service.syncAll(); return { ok: true }; },
         syncAccount: async (accountId) => { await service.syncAccount(accountId); return { ok: true }; },
         getSyncPending: () => service.getSyncPending(),
+        getPrimaryAccount: (feature) => {
+            // Resolve primary account for a feature (calendar/tasks/contacts):
+            // per-feature flag → catch-all `primary` → first account.
+            const all = db.getAccountConfigs().map(r => {
+                try {
+                    return { id: r.id, name: r.name, email: r.email, ...JSON.parse(r.configJson) };
+                }
+                catch {
+                    return { id: r.id, name: r.name, email: r.email };
+                }
+            });
+            if (feature) {
+                const key = "primary" + feature.charAt(0).toUpperCase() + feature.slice(1);
+                const perFeature = all.find((a) => a[key]);
+                if (perFeature)
+                    return perFeature;
+            }
+            return all.find((a) => a.primary) || all[0] || null;
+        },
         reauthenticate: async (accountId) => ({ ok: await service.reauthenticate(accountId) }),
         markFolderRead: (_accountId, folderId) => { service.markFolderRead(folderId); return { ok: true }; },
         createFolder: async () => ({ ok: false, error: "Not supported on mobile" }),

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

@@ -29,7 +29,10 @@ export interface AccountConfig {
         password?: string;
     };
     enabled: boolean;
-    primary?: boolean; /** Designates the account that supplies Calendar / Tasks / Contacts data. At most one per user; first one wins if multiple set. */
+    primary?: boolean; /** Catch-all "this is my main account" — default source for Calendar / Tasks / Contacts when no per-feature override set. */
+    primaryCalendar?: boolean; /** Per-feature override: use this account's Google Calendar. Falls back to `primary` if unset. */
+    primaryTasks?: boolean; /** Per-feature override: use this account's Google Tasks. Falls back to `primary` if unset. */
+    primaryContacts?: boolean; /** Per-feature override: use this account's Google Contacts. Falls back to `primary` if unset. */
     defaultSend?: boolean; /** Use this account's SMTP when From doesn't match any account */
     syncContacts?: boolean; /** Sync contacts even when account is disabled (contacts-only Gmail) */
     relayDomains?: string[]; /** Domains to skip in Delivered-To chain (e.g., ["m.connectivity.xyz"]) */