npm - @bobfrankston/mailx - Versions diffs - 1.0.449 → 1.0.451 - Mend

@bobfrankston/mailx 1.0.449 → 1.0.451

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/client/app.js +13 -1
package/client/components/message-viewer.js +120 -0
package/client/index.html +1 -0
package/client/styles/layout.css +20 -0
package/package.json +1 -1
package/packages/mailx-imap/index.d.ts +1 -0
package/packages/mailx-imap/index.js +34 -2
package/packages/mailx-service/index.d.ts +16 -1
package/packages/mailx-service/index.js +87 -8
package/packages/mailx-store-web/android-bootstrap.js +4 -0
package/packages/mailx-store-web/db.d.ts +10 -0
package/packages/mailx-store-web/db.js +40 -0
package/packages/mailx-store-web/main-thread-host.js +4 -0
package/packages/mailx-store-web/web-jsonrpc.js +8 -0
package/packages/mailx-store-web/web-service.d.ts +19 -0
package/packages/mailx-store-web/web-service.js +23 -0

package/client/app.js CHANGED Viewed

@@ -4,7 +4,7 @@
  */
 import { initFolderTree, refreshFolderTree, updateFolderCounts, setFolderSynced, getFolderSynced, setOutboxTotal } from "./components/folder-tree.js";
 import { initMessageList, loadMessages, loadUnifiedInbox, loadSearchResults, reloadCurrentFolder, clearSearchMode, getSelectedMessages, markBodiesCached } from "./components/message-list.js";
-import { showMessage, getCurrentMessage, initViewer } from "./components/message-viewer.js";
+import { showMessage, getCurrentMessage, initViewer, popOutCurrentMessage } from "./components/message-viewer.js";
 import { connectWebSocket, onWsEvent, triggerSync, syncAccount, reauthenticate, getAccounts, getFolders, deleteMessages, undeleteMessage, restartServer, getSyncPending, getVersion, getSettings, saveSettings, getAutocompleteSettings, saveAutocompleteSettings, repairAccounts, updateFlags, markAsSpamMessages, logClientEvent, sendMessage as apiSendMessage } from "./lib/api-client.js";
 import * as messageState from "./lib/message-state.js";
 // ── New message badge (favicon + title) ──
@@ -409,6 +409,14 @@ document.getElementById("btn-folder-toggle")?.addEventListener("click", () => {
 const backToList = (e) => {
     e.preventDefault();
     e.stopPropagation();
+    // If user is in full-screen-viewer mode, the first back tap should exit
+    // full-screen and return to the normal narrow split (list + active
+    // viewer). It shouldn't also deselect — that would yank the user out two
+    // levels in one tap.
+    if (document.body.classList.contains("viewer-fullscreen")) {
+        document.body.classList.remove("viewer-fullscreen");
+        return;
+    }
     document.getElementById("message-viewer")?.classList.remove("narrow-active");
     document.getElementById("message-list")?.classList.remove("narrow-hidden");
     // Deselect the message so the viewer component clears. Without this, a
@@ -420,6 +428,10 @@ document.getElementById("btn-back")?.addEventListener("click", backToList);
 // Android WebView sometimes drops synthetic clicks after a touchend inside a
 // header bar layered above the iframe — handle touchend explicitly too.
 document.getElementById("btn-back")?.addEventListener("touchend", backToList);
+// Pop-out viewer button — desktop spawns a floating overlay (multiple at
+// once), mobile toggles `body.viewer-fullscreen` for full-screen reading.
+// Threshold and behavior live in popOutCurrentMessage.
+document.getElementById("mv-popout")?.addEventListener("click", () => popOutCurrentMessage());
 // Close folder panel when a folder is selected (narrow mode)
 // Also reset narrow navigation: show message list, hide viewer
 document.getElementById("folder-tree")?.addEventListener("click", (e) => {

package/client/components/message-viewer.js CHANGED Viewed

@@ -1168,4 +1168,124 @@ ${csp}
 </script>
 </head><body>${html}</body></html>`;
 }
+/** Open the current message in a separate view: floating draggable overlay
+ *  on desktop (multiple at once, like compose), full-screen mode on mobile.
+ *  Threshold matches the layout.css responsive breakpoint so the experience
+ *  is consistent with other narrow-mode behavior. Snapshot in time — the
+ *  pop-out doesn't auto-update if the user clicks another message. */
+export function popOutCurrentMessage() {
+    if (!currentMessage)
+        return;
+    const isNarrow = window.innerWidth <= 768;
+    if (isNarrow) {
+        document.body.classList.toggle("viewer-fullscreen");
+        return;
+    }
+    spawnDesktopPopout(currentMessage, currentAccountId);
+}
+/** Build a floating overlay carrying a snapshot of the message: header
+ *  (subject, from, to, date) + sandboxed body iframe + attachment chips.
+ *  Reuses the compose-overlay drag/resize/close pattern. Independent of the
+ *  main viewer — opening pop-out for message A then switching the main pane
+ *  to message B leaves A visible in its overlay. */
+function spawnDesktopPopout(msg, accountId) {
+    const wrapper = document.createElement("div");
+    wrapper.className = "compose-overlay viewer-popout";
+    wrapper.style.cssText = "position:fixed;top:60px;right:20px;width:min(720px,55vw);height:min(800px,80vh);z-index:1000;border:1px solid var(--color-border, #ccc);border-radius:8px;box-shadow:0 8px 32px rgba(0,0,0,0.3);display:flex;flex-direction:column;background:var(--color-bg, #fff);resize:both;overflow:hidden;";
+    const titleBar = document.createElement("div");
+    titleBar.style.cssText = "display:flex;align-items:center;justify-content:space-between;padding:6px 10px;background:var(--color-bg-alt, #e8ecf0);color:var(--color-text, #000);border-radius:8px 8px 0 0;cursor:move;user-select:none;flex-shrink:0;font-size:13px;";
+    const titleText = document.createElement("span");
+    titleText.style.cssText = "overflow:hidden;text-overflow:ellipsis;white-space:nowrap;flex:1;font-weight:600;";
+    titleText.textContent = msg.subject || "(no subject)";
+    titleBar.appendChild(titleText);
+    const closeBtn = document.createElement("button");
+    closeBtn.textContent = "✕";
+    closeBtn.title = "Close pop-out";
+    closeBtn.style.cssText = "background:none;border:none;font-size:16px;cursor:pointer;color:#666;padding:2px 8px;border-radius:4px;flex-shrink:0;";
+    closeBtn.addEventListener("mouseenter", () => closeBtn.style.color = "#c00");
+    closeBtn.addEventListener("mouseleave", () => closeBtn.style.color = "#666");
+    closeBtn.addEventListener("click", () => wrapper.remove());
+    titleBar.appendChild(closeBtn);
+    const headerInfo = document.createElement("div");
+    headerInfo.style.cssText = "padding:8px 12px;border-bottom:1px solid var(--color-border, #ddd);font-size:13px;line-height:1.4;flex-shrink:0;";
+    const formatAddrLocal = (a) => a.name ? `${a.name} <${a.address}>` : a.address;
+    const fromStr = formatAddrLocal(msg.from || { address: "" });
+    const toStr = (msg.to || []).map(formatAddrLocal).join(", ");
+    const ccStr = msg.cc?.length ? ` Cc: ${msg.cc.map(formatAddrLocal).join(", ")}` : "";
+    const dateStr = msg.date ? new Date(msg.date).toLocaleString() : "";
+    headerInfo.innerHTML =
+        `<div><strong>${escapeHtmlLocal(fromStr)}</strong></div>` +
+            `<div style="color:var(--color-text-muted, #666)">To: ${escapeHtmlLocal(toStr)}${escapeHtmlLocal(ccStr)}</div>` +
+            `<div style="color:var(--color-text-muted, #666);font-size:12px">${escapeHtmlLocal(dateStr)}</div>`;
+    const bodyContainer = document.createElement("div");
+    bodyContainer.style.cssText = "flex:1;overflow:hidden;display:flex;";
+    if (msg.bodyHtml) {
+        const iframe = document.createElement("iframe");
+        iframe.sandbox.add("allow-same-origin");
+        iframe.sandbox.add("allow-popups");
+        iframe.sandbox.add("allow-popups-to-escape-sandbox");
+        iframe.sandbox.add("allow-top-navigation-by-user-activation");
+        iframe.sandbox.add("allow-scripts");
+        iframe.srcdoc = wrapHtmlBody(msg.bodyHtml, msg.remoteAllowed);
+        iframe.style.cssText = "flex:1;border:none;width:100%;background:#fff;";
+        bodyContainer.appendChild(iframe);
+    }
+    else {
+        const pre = document.createElement("pre");
+        pre.style.cssText = "padding:12px;white-space:pre-wrap;word-break:break-word;margin:0;flex:1;overflow:auto;";
+        pre.textContent = msg.bodyText || "(no content)";
+        bodyContainer.appendChild(pre);
+    }
+    // Drag — same pattern as compose-overlay: pointer-events:none on the
+    // iframe so cursor crossing into it doesn't lose drag events.
+    let dragX = 0, dragY = 0;
+    titleBar.addEventListener("mousedown", (e) => {
+        if (e.target === closeBtn)
+            return;
+        e.preventDefault();
+        const rect = wrapper.getBoundingClientRect();
+        dragX = e.clientX - rect.left;
+        dragY = e.clientY - rect.top;
+        const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+        bodyContainer.style.pointerEvents = "none";
+        document.body.style.userSelect = "none";
+        const onMove = (ev) => {
+            ev.preventDefault();
+            const left = clamp(ev.clientX - dragX, 0, window.innerWidth - 40);
+            const top = clamp(ev.clientY - dragY, 0, window.innerHeight - 40);
+            wrapper.style.left = `${left}px`;
+            wrapper.style.top = `${top}px`;
+            wrapper.style.right = "auto";
+            wrapper.style.bottom = "auto";
+        };
+        const onUp = () => {
+            bodyContainer.style.pointerEvents = "";
+            document.body.style.userSelect = "";
+            document.removeEventListener("mousemove", onMove);
+            document.removeEventListener("mouseup", onUp);
+        };
+        document.addEventListener("mousemove", onMove);
+        document.addEventListener("mouseup", onUp);
+    });
+    // Bring to front on click — shared with compose-overlay so they all
+    // restack uniformly.
+    wrapper.addEventListener("mousedown", () => {
+        document.querySelectorAll(".compose-overlay").forEach(el => el.style.zIndex = "1000");
+        wrapper.style.zIndex = "1001";
+    });
+    // Cascade pop-outs so they don't all stack at the same coords.
+    const existing = document.querySelectorAll(".viewer-popout").length;
+    if (existing > 0) {
+        wrapper.style.top = `${60 + existing * 28}px`;
+        wrapper.style.right = `${20 + existing * 28}px`;
+    }
+    void accountId; // accountId reserved for future per-account actions on the popout
+    wrapper.appendChild(titleBar);
+    wrapper.appendChild(headerInfo);
+    wrapper.appendChild(bodyContainer);
+    document.body.appendChild(wrapper);
+}
+function escapeHtmlLocal(s) {
+    return (s || "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
 //# sourceMappingURL=message-viewer.js.map

package/client/index.html CHANGED Viewed

@@ -161,6 +161,7 @@
                     <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>
                     <button class="mv-action" id="mv-view-source" title="View source (.eml)" hidden>Source</button>
+                    <button class="mv-action" id="mv-popout" title="Pop out (desktop) / Full-screen (mobile)">⤢</button>
                     <button class="mv-action" id="mv-toggle-details" title="Show/hide extra headers">Details</button>
                 </div>
                 <div class="mv-header-info">

package/client/styles/layout.css CHANGED Viewed

@@ -127,6 +127,26 @@ body.calendar-sidebar-on {
 .main-area.no-preview .message-viewer { display: none; }
 .main-area.no-preview .message-list { border-right: none; }
+/* Full-screen viewer mode (mobile/Android) — viewer takes the whole app
+   surface; folder rail, folder tree, message list and statusbar are hidden.
+   Toggle via `body.viewer-fullscreen` from the pop-out / full-screen button.
+   On desktop the same button instead spawns a floating overlay (handled in
+   message-viewer.ts) and never sets this class. */
+body.viewer-fullscreen .folder-rail,
+body.viewer-fullscreen .folder-tree,
+body.viewer-fullscreen .message-list,
+body.viewer-fullscreen .splitter,
+body.viewer-fullscreen .toolbar,
+body.viewer-fullscreen .statusbar { display: none !important; }
+body.viewer-fullscreen .main-area {
+    grid-template-columns: 1fr !important;
+    grid-template-rows: 1fr !important;
+}
+body.viewer-fullscreen .message-viewer {
+    display: flex !important;
+    grid-column: 1 / -1 !important;
+}
 /* Splitter */
 .splitter {
     background: var(--color-border);

package/package.json CHANGED Viewed

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

package/packages/mailx-imap/index.d.ts CHANGED Viewed

@@ -141,6 +141,7 @@ export declare class ImapManager extends EventEmitter {
      *  preempt a command mid-flight. */
     withConnection<T>(accountId: string, fn: (client: any) => Promise<T>, opts?: {
         slow?: boolean;
+        timeoutMs?: number;
     }): Promise<T>;
     /** Run the next queued task. Fast lane drains before slow.
      *  Idempotent — safe to call after each task completes; the running

package/packages/mailx-imap/index.js CHANGED Viewed

@@ -383,15 +383,32 @@ export class ImapManager extends EventEmitter {
             queue = { fast: [], slow: [], running: false };
             this.opsQueues.set(accountId, queue);
         }
+        // Per-task wall-clock cap. Without one, a wedged IMAP command (TCP
+        // half-open, server stalled mid-FETCH) keeps the queue's running flag
+        // set forever and every subsequent fast-lane task — including the
+        // retry button the user just hit — waits behind it. Default is
+        // generous; callers driving user-visible reads pass a tighter value.
+        const timeoutMs = opts.timeoutMs ?? 90_000;
         return new Promise((resolve, reject) => {
             const task = async () => {
+                let timer;
                 try {
                     const client = await this.getOpsClient(accountId);
-                    resolve(await fn(client));
+                    const result = await Promise.race([
+                        fn(client),
+                        new Promise((_, rej) => {
+                            timer = setTimeout(() => rej(new Error(`ops timeout after ${Math.round(timeoutMs / 1000)}s — discarding client`)), timeoutMs);
+                        }),
+                    ]);
+                    clearTimeout(timer);
+                    resolve(result);
                 }
                 catch (e) {
+                    clearTimeout(timer);
                     // Discard client on any error — keeping a half-broken
-                    // socket poisoned every subsequent request.
+                    // socket poisoned every subsequent request. Destroy
+                    // synchronously kills the in-flight command's socket so
+                    // the underlying promise rejects and stops holding state.
                     const stale = this.opsClients.get(accountId);
                     this.opsClients.delete(accountId);
                     if (stale) {
@@ -975,6 +992,14 @@ export class ImapManager extends EventEmitter {
                         this.db.updateMessageFlags(accountId, msg.uid, flags);
                         continue;
                     }
+                    // Tombstone check — same reason as the streamy onChunk path
+                    // at storeMessages: a locally-deleted message that the server
+                    // hasn't EXPUNGEd yet would otherwise reappear on next sync.
+                    // User-visible symptom: "I deleted it but it came back."
+                    if (msg.messageId && this.db.hasTombstone(accountId, msg.messageId)) {
+                        console.log(`  [tombstone] ${accountId}: skipping ${msg.messageId} in syncFolder (locally deleted)`);
+                        continue;
+                    }
                     // Store body
                     const source = msg.source || "";
                     let bodyPath = "";
@@ -1462,6 +1487,13 @@ export class ImapManager extends EventEmitter {
         // standalone — bad rows are logged and skipped.
         for (const msg of msgs) {
             try {
+                // Tombstone check — Gmail API sync was missing this so a
+                // locally-trashed Gmail message would reappear on the next
+                // listMessages tick if Gmail's eventual-consistency hadn't
+                // promoted the trash yet. Symmetric with the IMAP paths.
+                if (msg.messageId && this.db.hasTombstone(accountId, msg.messageId)) {
+                    continue;
+                }
                 const flags = [];
                 if (msg.seen)
                     flags.push("\\Seen");

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

@@ -320,8 +320,23 @@ export declare class MailxService {
      *  Matches a level-2 heading whose text equals the filename. Returns markdown. */
     readConfigHelp(name: string): Promise<string>;
     /** Write a JSONC config file. Validates that the content parses as JSONC
-     *  (loosely — strips comments/trailing commas) before writing. */
+     *  (loosely — strips comments/trailing commas) before writing.
+     *  Saves the prior content to a dated backup file first — manual edits
+     *  occasionally have typos that survive validation (semantically wrong
+     *  but syntactically OK), and a one-key undo isn't enough; the user
+     *  asked to be able to recover yesterday's accounts.jsonc. Automatic
+     *  saveAccounts/saveAllowlist paths skip backups (they're driven by
+     *  trusted code, not the JSONC editor). */
     writeJsoncFile(name: string, content: string): Promise<void>;
+    /** Read the current content of a config file (cloud or local) so it can
+     *  be saved as a backup before being overwritten. Returns null if the
+     *  file doesn't exist yet (first save — nothing to back up). */
+    private readJsoncForBackup;
+    /** Write the prior content to `<configDir>/backup/<name>.<ts>.bak` and
+     *  prune so at most 10 backups per file remain AND none are older than 7
+     *  days. Skipped when previous content is null (first write) or
+     *  identical to the new content (no-op save). */
+    private backupJsoncIfChanged;
     getSettings(): any;
     saveSettings(settings: any): void;
     getStorageInfo(): {

package/packages/mailx-service/index.js CHANGED Viewed

@@ -314,17 +314,16 @@ export class MailxService {
         let bodyText = "";
         let hasRemoteContent = false;
         let attachments = [];
-        // Wall-clock cap on the server-side body fetch. Without this, a Gmail
-        // rate-limit cooldown (shared across providers via module-level state)
-        // can park the request indefinitely — the user sees an infinite
-        // "Fetching message body..." spinner with no way to recover. The cap
-        // surfaces a transient error so the viewer can show a retry banner.
-        const BODY_FETCH_TIMEOUT_MS = 45_000;
+        // The per-account ops queue inside ImapManager has its own per-task
+        // timeout that destroys a wedged client and unblocks the queue. This
+        // outer race is a safety net only — the underlying timeout in
+        // withConnection should trigger first.
+        const BODY_FETCH_TIMEOUT_MS = 60_000;
         let raw = null;
         try {
             raw = await Promise.race([
                 this.imapManager.fetchMessageBody(accountId, envelope.folderId, envelope.uid),
-                new Promise((_, reject) => setTimeout(() => reject(new Error("body fetch timeout (45s) — server is slow or rate-limited")), BODY_FETCH_TIMEOUT_MS)),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("body fetch timed out — try again")), BODY_FETCH_TIMEOUT_MS)),
             ]);
         }
         catch (fetchErr) {
@@ -2093,7 +2092,13 @@ export class MailxService {
         return out.join("\n").trim();
     }
     /** Write a JSONC config file. Validates that the content parses as JSONC
-     *  (loosely — strips comments/trailing commas) before writing. */
+     *  (loosely — strips comments/trailing commas) before writing.
+     *  Saves the prior content to a dated backup file first — manual edits
+     *  occasionally have typos that survive validation (semantically wrong
+     *  but syntactically OK), and a one-key undo isn't enough; the user
+     *  asked to be able to recover yesterday's accounts.jsonc. Automatic
+     *  saveAccounts/saveAllowlist paths skip backups (they're driven by
+     *  trusted code, not the JSONC editor). */
     async writeJsoncFile(name, content) {
         const WHITELIST = ["accounts.jsonc", "allowlist.jsonc", "clients.jsonc", "config.jsonc", "contacts.jsonc"];
         if (!WHITELIST.includes(name))
@@ -2105,6 +2110,8 @@ export class MailxService {
         if (errors.length) {
             throw new Error(`JSONC parse error: ${errors.map(e => e.error).join(", ")}`);
         }
+        const previous = await this.readJsoncForBackup(name);
+        await this.backupJsoncIfChanged(name, previous, content);
         if (name === "config.jsonc") {
             const configPath = path.join(getConfigDir(), "config.jsonc");
             fs.writeFileSync(configPath, content);
@@ -2113,6 +2120,78 @@ export class MailxService {
         const { cloudWrite } = await import("@bobfrankston/mailx-settings");
         await cloudWrite(name, content); // throws on failure with descriptive error
     }
+    /** Read the current content of a config file (cloud or local) so it can
+     *  be saved as a backup before being overwritten. Returns null if the
+     *  file doesn't exist yet (first save — nothing to back up). */
+    async readJsoncForBackup(name) {
+        if (name === "config.jsonc") {
+            const configPath = path.join(getConfigDir(), "config.jsonc");
+            try {
+                return fs.readFileSync(configPath, "utf-8");
+            }
+            catch {
+                return null;
+            }
+        }
+        try {
+            const { cloudRead } = await import("@bobfrankston/mailx-settings");
+            return await cloudRead(name);
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Write the prior content to `<configDir>/backup/<name>.<ts>.bak` and
+     *  prune so at most 10 backups per file remain AND none are older than 7
+     *  days. Skipped when previous content is null (first write) or
+     *  identical to the new content (no-op save). */
+    async backupJsoncIfChanged(name, previous, next) {
+        if (previous == null || previous === next)
+            return;
+        const backupDir = path.join(getConfigDir(), "backup");
+        try {
+            fs.mkdirSync(backupDir, { recursive: true });
+        }
+        catch { /* */ }
+        // Filename-safe ISO timestamp (colons become hyphens on Windows).
+        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const backupPath = path.join(backupDir, `${name}.${stamp}.bak`);
+        try {
+            fs.writeFileSync(backupPath, previous);
+        }
+        catch (e) {
+            console.error(`[backup] failed to write ${backupPath}: ${e.message}`);
+            return; // don't block the save just because backup failed
+        }
+        // Prune: keep at most 10 most-recent for this filename, drop anything
+        // older than 7 days. Whichever cuts more wins.
+        const MAX_KEEP = 10;
+        const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+        const now = Date.now();
+        let entries;
+        try {
+            entries = fs.readdirSync(backupDir)
+                .filter(f => f.startsWith(`${name}.`) && f.endsWith(".bak"))
+                .map(f => {
+                const p = path.join(backupDir, f);
+                return { path: p, mtime: fs.statSync(p).mtimeMs };
+            })
+                .sort((a, b) => b.mtime - a.mtime); // newest first
+        }
+        catch {
+            return;
+        }
+        for (let i = 0; i < entries.length; i++) {
+            const tooOld = now - entries[i].mtime > MAX_AGE_MS;
+            const tooMany = i >= MAX_KEEP;
+            if (tooOld || tooMany) {
+                try {
+                    fs.unlinkSync(entries[i].path);
+                }
+                catch { /* */ }
+            }
+        }
+    }
     // ── Settings ──
     getSettings() {
         return loadSettings();

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

@@ -1131,6 +1131,10 @@ function installBridge() {
         },
         searchMessages: (query, page, pageSize) => service.search(query, page, pageSize),
         searchContacts: (query) => service.searchContacts(query),
+        listContacts: (query, page = 1, pageSize = 100) => service.listContacts(query || "", page, pageSize),
+        upsertContact: (name, email) => service.upsertContact(name || "", email),
+        deleteContact: (email) => service.deleteContact(email),
+        addContact: (name, email) => service.addContact(name || "", email),
         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 }; },

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

@@ -94,6 +94,16 @@ export declare class WebMailxDB {
         source: string;
         useCount: number;
     }[];
+    /** Address-book listing. Same shape as mailx-store/db.ts:listContacts so
+     *  the address-book modal renders identically on desktop and Android. */
+    listContacts(query: string, page?: number, pageSize?: number): {
+        items: any[];
+        total: number;
+        page: number;
+        pageSize: number;
+    };
+    upsertContact(name: string, email: string): void;
+    deleteContactLocal(email: string): void;
     /** 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. */

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

@@ -491,6 +491,46 @@ export class WebMailxDB {
              WHERE email LIKE ? OR name LIKE ?
              ORDER BY use_count DESC, last_used DESC LIMIT ?`, [q, q, limit]);
     }
+    /** Address-book listing. Same shape as mailx-store/db.ts:listContacts so
+     *  the address-book modal renders identically on desktop and Android. */
+    listContacts(query, page = 1, pageSize = 100) {
+        query = (query || "").trim();
+        const hasQuery = !!query;
+        const q = `%${query}%`;
+        const whereClause = hasQuery ? "WHERE email LIKE ? OR name LIKE ?" : "";
+        const params = hasQuery ? [q, q] : [];
+        const totalRow = this.get(`SELECT COUNT(*) as c FROM contacts ${whereClause}`, params);
+        const offset = (page - 1) * pageSize;
+        const rows = this.all(`SELECT name, email, source, google_id, use_count, last_used FROM contacts
+             ${whereClause}
+             ORDER BY use_count DESC, last_used DESC
+             LIMIT ? OFFSET ?`, [...params, pageSize, offset]);
+        return {
+            items: rows.map((r) => ({
+                name: r.name, email: r.email, source: r.source,
+                googleId: r.google_id || null,
+                useCount: r.use_count, lastUsed: r.last_used,
+            })),
+            total: totalRow?.c || 0,
+            page, pageSize,
+        };
+    }
+    upsertContact(name, email) {
+        if (!email || !/^[^\s<>@]+@[^\s<>@]+\.[^\s<>@]+$/.test(email)) {
+            throw new Error(`Invalid email: ${email}`);
+        }
+        const now = Date.now();
+        const existing = this.get("SELECT id FROM contacts WHERE email = ?", [email]);
+        if (existing) {
+            this.run("UPDATE contacts SET name = ?, updated_at = ? WHERE email = ?", [name || "", now, email]);
+        }
+        else {
+            this.run("INSERT INTO contacts (source, name, email, last_used, use_count, updated_at) VALUES ('manual', ?, ?, 0, 0, ?)", [name || "", email, now]);
+        }
+    }
+    deleteContactLocal(email) {
+        this.run("DELETE FROM contacts WHERE email = ?", [email]);
+    }
     /** 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. */

package/packages/mailx-store-web/main-thread-host.js CHANGED Viewed

@@ -234,6 +234,10 @@ function installBridge() {
         reauthenticate: (accountId) => sendRpc("reauthenticate", { accountId }),
         searchMessages: (query, page, pageSize) => sendRpc("searchMessages", { query, page, pageSize }),
         searchContacts: (query) => sendRpc("searchContacts", { query }),
+        listContacts: (query, page = 1, pageSize = 100) => sendRpc("listContacts", { query, page, pageSize }),
+        upsertContact: (name, email) => sendRpc("upsertContact", { name, email }),
+        deleteContact: (email) => sendRpc("deleteContact", { email }),
+        addContact: (name, email) => sendRpc("addContact", { name, email }),
         getSettings: () => sendRpc("getSettings"),
         saveSettings: (data) => sendRpc("saveSettingsData", data),
         allowRemoteContent: (type, value) => sendRpc("allowRemoteContent", { type, value }),

package/packages/mailx-store-web/web-jsonrpc.js CHANGED Viewed

@@ -69,6 +69,14 @@ 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 "listContacts":
+            return svc.listContacts(p.query || "", p.page || 1, p.pageSize || 100);
+        case "upsertContact":
+            return svc.upsertContact(p.name || "", p.email);
+        case "deleteContact":
+            return svc.deleteContact(p.email);
+        case "addContact":
+            return svc.addContact(p.name || "", p.email);
         case "getSettings":
             return svc.getSettings();
         case "saveSettingsData":

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

@@ -71,6 +71,25 @@ export declare class WebMailxService {
     }>;
     deleteDraft(accountId: string, draftUid: number): Promise<void>;
     searchContacts(query: string): any[];
+    /** Address-book listing — paginated, filterable. Mirrors mailx-service's
+     *  signature so the same client-side address-book modal works on Android
+     *  without an "ipc(...).listContacts is not a function" crash. */
+    listContacts(query: string, page?: number, pageSize?: number): {
+        items: any[];
+        total: number;
+        page: number;
+        pageSize: number;
+    };
+    /** Manual upsert from the address-book UI. The desktop path queues a
+     *  Google People sync; Android relies on the desktop pushing changes
+     *  back, so this is local-only for now. */
+    upsertContact(name: string, email: string): {
+        ok: true;
+    };
+    deleteContact(email: string): {
+        ok: true;
+    };
+    addContact(name: string, email: string): boolean;
     /** 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. */

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

@@ -478,6 +478,29 @@ export class WebMailxService {
             return [];
         return this.db.searchContacts(query);
     }
+    /** Address-book listing — paginated, filterable. Mirrors mailx-service's
+     *  signature so the same client-side address-book modal works on Android
+     *  without an "ipc(...).listContacts is not a function" crash. */
+    listContacts(query, page = 1, pageSize = 100) {
+        return this.db.listContacts(query || "", page, pageSize);
+    }
+    /** Manual upsert from the address-book UI. The desktop path queues a
+     *  Google People sync; Android relies on the desktop pushing changes
+     *  back, so this is local-only for now. */
+    upsertContact(name, email) {
+        this.db.upsertContact(name || "", email);
+        return { ok: true };
+    }
+    deleteContact(email) {
+        this.db.deleteContactLocal(email);
+        return { ok: true };
+    }
+    addContact(name, email) {
+        if (!email || !/^[^\s<>@]+@[^\s<>@]+\.[^\s<>@]+$/.test(email))
+            return false;
+        this.db.recordSentAddress(name || "", email);
+        return true;
+    }
     /** 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. */