@bobfrankston/mailx 1.0.206 → 1.0.208

package/bin/mailx.js

@@ -31,14 +31,22 @@ const isDaemon = hasFlag("daemon"); // internal: re-spawned detached process
 // Auto-detach: re-spawn as background process so terminal returns immediately
 // Skip for: --verbose (want console), --daemon (already detached),
 // and any command flags (setup, kill, test, etc.)
-if (!verbose && !isDaemon && !process.argv.slice(2).some(a => /^-/.test(a) && !["--no-browser"].includes(a))) {
-    const { spawn } = await import("node:child_process");
-    const child = spawn(process.execPath, [...process.argv.slice(1), "--daemon"], {
-        detached: true,
-        stdio: "ignore",
-        windowsHide: true,
-    });
-    child.unref();
+if (!verbose && !isDaemon && !process.argv.slice(2).some(a => /^-/.test(a))) {
+    const { execSync, spawn } = await import("node:child_process");
+    if (process.platform === "win32") {
+        // Use wscript to launch without any visible console window
+        const args = [...process.argv.slice(1), "--daemon"].map(a => `"${a}"`).join(" ");
+        const vbs = `CreateObject("Wscript.Shell").Run """${process.execPath}"" ${args}", 0, False`;
+        const tmpVbs = path.join(os.tmpdir(), "mailx-launch.vbs");
+        fs.writeFileSync(tmpVbs, vbs);
+        execSync(`wscript "${tmpVbs}"`, { stdio: "ignore" });
+    }
+    else {
+        const child = spawn(process.execPath, [...process.argv.slice(1), "--daemon"], {
+            detached: true, stdio: "ignore",
+        });
+        child.unref();
+    }
     process.exit(0);
 }
 const setupMode = hasFlag("setup");
@@ -607,7 +615,7 @@ async function registerClient(settings) {
         }
     }
     catch { /* ignore */ }
-    // Read existing clients.jsonc from cloud
+    // Read existing clients.jsonc from cloud (may not exist yet — that's fine)
     let clients = {};
     try {
         const content = await cloudRead("clients.jsonc");

package/client/components/folder-tree.js

@@ -10,6 +10,7 @@ let selectedElement;
 let selectedAccountId = null;
 let selectedFolderId = null;
 let isFirstLoad = true; // only auto-select on first load
+let hasAutoSelected = false; // track whether we've ever managed to auto-select
 // Debounce timer for refreshFolderTree
 let refreshDebounceTimer = null;
 // Persist expand/collapse state in localStorage
@@ -670,7 +671,9 @@ async function loadFolderTree(container) {
                 }
             }
         }
-        if (!target && isFirstLoad) {
+        // Auto-select on first load OR until we successfully auto-selected at least once
+        // (handles Android where folders don't exist on first load — they arrive after sync)
+        if (!target && (isFirstLoad || !hasAutoSelected)) {
             // Auto-select only on first load — not on refresh (prevents jumping)
             const unified = container.querySelector('.ft-unified');
             if (unified) {
@@ -694,8 +697,10 @@ async function loadFolderTree(container) {
             }
             if (!target && allFolderEls.length > 0)
                 target = allFolderEls[0];
-            if (target)
+            if (target) {
                 target.click();
+                hasAutoSelected = true;
+            }
         }
         isFirstLoad = false;
         // Dismiss startup overlay once tree is loaded

package/client/styles/layout.css

@@ -87,8 +87,12 @@ body {
     #btn-menu { display: inline-flex !important; }
 }
 
-/* Responsive: narrow viewport — single panel navigation */
-@media (max-width: 768px) {
+/* 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; }
+}
+@media (max-width: 768px), (max-height: 600px) {
     body {
         grid-template-columns: 1fr;
         grid-template-rows: var(--toolbar-height) auto 1fr var(--statusbar-height);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.206",
+  "version": "1.0.208",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -24,7 +24,7 @@
     "@bobfrankston/iflow-node": "^0.1.2",
     "@bobfrankston/miscinfo": "^1.0.8",
     "@bobfrankston/oauthsupport": "^1.0.22",
-    "@bobfrankston/msger": "^0.1.267",
+    "@bobfrankston/msger": "^0.1.269",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",

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

@@ -64,6 +64,7 @@ export declare function getMessage(params: {
     size: number;
     hasAttachments: boolean;
     preview: string;
+    bodyPath?: string;
 }>;
 export declare function updateFlags(params: {
     accountId: string;

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

@@ -159,6 +159,9 @@ class AndroidSyncManager {
                     flags.push("\\Answered");
                 if (msg.draft)
                     flags.push("\\Draft");
+                // Store the Gmail providerId in bodyPath as "gmail:<id>" so we can
+                // fetch the body directly without re-listing 1000 messages from the folder
+                const bodyPath = msg.providerId ? `gmail:${msg.providerId}` : "";
                 this.db.upsertMessage({
                     accountId, folderId, uid: msg.uid,
                     messageId: msg.messageId || "", inReplyTo: "", references: [],
@@ -167,7 +170,7 @@ class AndroidSyncManager {
                     from: toEmailAddress(msg.from?.[0]),
                     to: msg.to.map(a => toEmailAddress(a)),
                     cc: msg.cc.map(a => toEmailAddress(a)),
-                    flags, size: msg.size || 0, hasAttachments: false, preview: "", bodyPath: "",
+                    flags, size: msg.size || 0, hasAttachments: false, preview: "", bodyPath,
                 });
             }
             this.db.commitTransaction();
@@ -182,15 +185,31 @@ class AndroidSyncManager {
             return this.bodyStore.getMessage(accountId, folderId, uid);
         }
         const provider = this.getProvider(accountId);
-        if (!provider)
-            return null;
-        const folders = this.db.getFolders(accountId);
-        const folder = folders.find(f => f.id === folderId);
-        if (!folder)
+        if (!provider) {
+            console.warn(`[fetchBody] No provider for ${accountId}`);
             return null;
-        const msg = await provider.fetchOne(folder.path, uid, { source: true });
-        if (!msg?.source)
+        }
+        // Look up the Gmail providerId stored in body_path during sync
+        const envelope = this.db.getMessageByUid(accountId, uid, folderId);
+        const bp = envelope?.bodyPath || "";
+        let msg = null;
+        if (bp.startsWith("gmail:") && provider.fetchById) {
+            const providerId = bp.substring(6);
+            msg = await provider.fetchById(providerId, { source: true });
+        }
+        else {
+            // Fallback: list-and-find by UID (slow, fragile)
+            const folders = this.db.getFolders(accountId);
+            const folder = folders.find(f => f.id === folderId);
+            if (!folder)
+                return null;
+            msg = await provider.fetchOne(folder.path, uid, { source: true });
+        }
+        if (!msg?.source) {
+            console.warn(`[fetchBody] No source returned for ${accountId}/${folderId}/${uid} (bp=${bp})`);
             return null;
+        }
+        // Encode the UTF-8 string back to bytes for storage
         const raw = new TextEncoder().encode(msg.source);
         await this.bodyStore.putMessage(accountId, folderId, uid, raw);
         this.db.updateBodyPath(accountId, uid, `idb:${accountId}/${folderId}/${uid}`);
@@ -247,7 +266,10 @@ const OAUTH_CLIENT = {
     // Reverse client ID scheme — auto-allowed for Google "installed" apps
     redirectUri: "com.googleusercontent.apps.884213380682-hcso64dcqmk4p98vsc7br2e6gvn7iv2u:/oauth2callback",
 };
-const OAUTH_SCOPES = "https://mail.google.com/ https://www.googleapis.com/auth/contacts.readonly https://www.googleapis.com/auth/drive.file";
+// Use full drive scope so we can read/write the desktop's accounts.jsonc + clients.jsonc.
+// drive.file is per-consent-grant: files created by desktop's grant aren't visible to Android's grant
+// even with the same client_id. drive (full) lets us see all files the user has access to.
+const OAUTH_SCOPES = "https://mail.google.com/ https://www.googleapis.com/auth/contacts.readonly https://www.googleapis.com/auth/drive";
 // ── Token cache (IndexedDB) ──
 async function getCachedToken(email) {
     const key = `oauth-token-${email.replace(/[@.]/g, "_")}`;
@@ -367,7 +389,18 @@ function createNativeTokenProvider(email) {
 async function registerDeviceInGDrive(tokenProvider, folderId, accountIds) {
     try {
         const token = await tokenProvider();
-        const deviceId = `android-${getDeviceId().substring(0, 8)}`;
+        // Use persistent Android device ID (survives factory reset & app data clear)
+        const bridge = window._nativeBridge;
+        let deviceId = "android-unknown";
+        if (bridge?.app?.getAndroidId) {
+            try {
+                const androidId = await bridge.app.getAndroidId();
+                deviceId = `android-${androidId.substring(0, 12)}`;
+            }
+            catch {
+                deviceId = `android-${getDeviceId().substring(0, 8)}`;
+            }
+        }
         // Read existing clients.jsonc
         const q = encodeURIComponent(`name='clients.jsonc' and '${folderId}' in parents and trashed=false`);
         const listRes = await fetch(`https://www.googleapis.com/drive/v3/files?q=${q}&fields=files(id)`, { headers: { "Authorization": `Bearer ${token}` } });
@@ -387,6 +420,12 @@ async function registerDeviceInGDrive(tokenProvider, folderId, accountIds) {
                 catch { /* */ }
             }
         }
+        // Remove stale android-* entries (from old random-UUID approach) — keep only this device
+        for (const key of Object.keys(clients)) {
+            if (key.startsWith("android-") && key !== deviceId) {
+                delete clients[key];
+            }
+        }
         clients[deviceId] = {
             hostname: deviceId,
             platform: "android",
@@ -483,6 +522,22 @@ export async function initAndroid() {
             else {
                 setGDriveFolderId(folderId);
                 console.log(`[android] GDrive mailx folder: ${folderId}`);
+                // DEBUG: list all files in the folder
+                try {
+                    const tk = await gmailTokenProvider();
+                    const lr = await fetch(`https://www.googleapis.com/drive/v3/files?q='${folderId}'+in+parents+and+trashed%3Dfalse&fields=files(id,name,mimeType,owners(emailAddress))`, { headers: { "Authorization": `Bearer ${tk}` } });
+                    if (lr.ok) {
+                        const ld = await lr.json();
+                        const names = (ld.files || []).map((f) => `${f.name}(${f.owners?.[0]?.emailAddress || "?"})`).join(",");
+                        console.log(`[android] Folder contents: ${ld.files?.length || 0} files [${names}]`);
+                    }
+                    else {
+                        console.warn(`[android] List folder failed: ${lr.status}`);
+                    }
+                }
+                catch (e) {
+                    console.warn(`[android] List debug: ${e.message}`);
+                }
                 // Read accounts directly from GDrive (bypass IndexedDB cache)
                 console.log("[android] Reading accounts.jsonc from GDrive...");
                 const gdriveAccounts = await loadAccountsFromCloud();

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

@@ -501,7 +501,8 @@ export class WebMailxDB {
             from: { name: r.from_name, address: r.from_address },
             to: JSON.parse(r.to_json), cc: JSON.parse(r.cc_json),
             flags: JSON.parse(r.flags_json), size: r.size,
-            hasAttachments: !!r.has_attachments, preview: r.preview
+            hasAttachments: !!r.has_attachments, preview: r.preview,
+            bodyPath: r.body_path || ""
         };
     }
 }

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

@@ -19,6 +19,8 @@ export declare class GmailApiWebProvider implements MailProvider {
     fetchSince(folder: string, sinceUid: number, options?: FetchOptions): Promise<ProviderMessage[]>;
     fetchByDate(folder: string, since: Date, before: Date, options?: FetchOptions, onChunk?: (msgs: ProviderMessage[]) => void): Promise<ProviderMessage[]>;
     fetchByUids(folder: string, uids: number[], options?: FetchOptions): Promise<ProviderMessage[]>;
+    /** Fetch a message directly by Gmail provider ID — fast path, no listing needed */
+    fetchById(providerId: string, options?: FetchOptions): Promise<ProviderMessage | null>;
     fetchOne(folder: string, uid: number, options?: FetchOptions): Promise<ProviderMessage | null>;
     getUids(folder: string): Promise<number[]>;
     close(): Promise<void>;

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

@@ -135,16 +135,14 @@ export class GmailApiWebProvider {
         const headers = msg.payload?.headers || [];
         let source = "";
         if (options.source && msg.raw) {
-            // URL-safe base64 → standard base64 → decoded string
+            // URL-safe base64 → standard base64 → UTF-8 string
+            // atob() returns a binary string (1 byte per char). Must decode bytes as UTF-8
+            // to handle multi-byte characters correctly (e.g. smart quotes).
             const base64 = msg.raw.replace(/-/g, "+").replace(/_/g, "/");
-            try {
-                source = atob(base64);
-            }
-            catch {
-                // Handle padding issues
-                const padded = base64 + "=".repeat((4 - (base64.length % 4)) % 4);
-                source = atob(padded);
-            }
+            const padded = base64 + "=".repeat((4 - (base64.length % 4)) % 4);
+            const binary = atob(padded);
+            const bytes = Uint8Array.from(binary, c => c.charCodeAt(0));
+            source = new TextDecoder("utf-8").decode(bytes);
         }
         const fromRaw = getHeader(headers, "From");
         const toRaw = getHeader(headers, "To");
@@ -189,6 +187,24 @@ export class GmailApiWebProvider {
         const matchingIds = ids.filter(id => uidSet.has(idToUid(id)));
         return this.batchFetch(matchingIds, options);
     }
+    /** Fetch a message directly by Gmail provider ID — fast path, no listing needed */
+    async fetchById(providerId, options = {}) {
+        const format = options.source ? "raw" : "metadata";
+        const params = new URLSearchParams({ format });
+        if (format === "metadata") {
+            for (const h of ["From", "To", "Cc", "Subject", "Message-ID", "Date"]) {
+                params.append("metadataHeaders", h);
+            }
+        }
+        try {
+            const msg = await this.apiFetch(`/messages/${providerId}?${params}`);
+            return this.parseMessage(msg, options);
+        }
+        catch (e) {
+            console.warn(`[gmail] fetchById ${providerId} failed: ${e.message}`);
+            return null;
+        }
+    }
     async fetchOne(folder, uid, options = {}) {
         const query = `in:${this.folderToLabel(folder)}`;
         const ids = await this.listMessageIds(query, 1000);

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

@@ -232,6 +232,56 @@ const DEFAULT_ALLOWLIST = {
     domains: [],
     recipients: [],
 };
+// ── JSONC parser (strips comments and trailing commas) ──
+function parseJsonc(text) {
+    // Strip /* block comments */ and // line comments, but preserve content inside strings
+    let stripped = "";
+    let i = 0;
+    let inString = false;
+    let stringChar = "";
+    while (i < text.length) {
+        const c = text[i];
+        const next = text[i + 1];
+        if (inString) {
+            stripped += c;
+            if (c === "\\" && i + 1 < text.length) {
+                stripped += text[i + 1];
+                i += 2;
+                continue;
+            }
+            if (c === stringChar)
+                inString = false;
+            i++;
+            continue;
+        }
+        if (c === '"' || c === "'") {
+            inString = true;
+            stringChar = c;
+            stripped += c;
+            i++;
+            continue;
+        }
+        if (c === "/" && next === "/") {
+            // Line comment — skip to end of line
+            while (i < text.length && text[i] !== "\n")
+                i++;
+            continue;
+        }
+        if (c === "/" && next === "*") {
+            // Block comment — skip to */
+            i += 2;
+            while (i < text.length - 1 && !(text[i] === "*" && text[i + 1] === "/"))
+                i++;
+            i += 2;
+            continue;
+        }
+        stripped += c;
+        i++;
+    }
+    // Strip trailing commas before } or ]
+    stripped = stripped.replace(/,(\s*[}\]])/g, "$1");
+    return JSON.parse(stripped);
+}
 // ── Public API ──
 /** Load accounts — first from IndexedDB cache, then GDrive */
 export async function loadAccounts() {
@@ -239,24 +289,28 @@ export async function loadAccounts() {
     const cached = await idbRead("accounts.jsonc");
     if (cached) {
         try {
-            const data = JSON.parse(cached);
+            const data = parseJsonc(cached);
             const raw = data.accounts || (Array.isArray(data) ? data : []);
             if (raw.length > 0) {
                 return raw.map((a) => normalizeAccount(a, data.name));
             }
         }
-        catch { /* parse error — fall through to GDrive */ }
+        catch (e) {
+            console.warn(`[settings] Cached accounts.jsonc parse failed: ${e.message}`);
+        }
     }
     // Try GDrive
     const content = await gDriveRead("accounts.jsonc");
     if (content) {
         await idbWrite("accounts.jsonc", content);
         try {
-            const data = JSON.parse(content);
+            const data = parseJsonc(content);
             const raw = data.accounts || (Array.isArray(data) ? data : []);
             return raw.map((a) => normalizeAccount(a, data.name));
         }
-        catch { /* parse error */ }
+        catch (e) {
+            console.warn(`[settings] GDrive accounts.jsonc parse failed: ${e.message}`);
+        }
     }
     return [];
 }
@@ -266,11 +320,13 @@ export async function loadAccountsFromCloud() {
     if (content) {
         await idbWrite("accounts.jsonc", content);
         try {
-            const data = JSON.parse(content);
+            const data = parseJsonc(content);
             const raw = data.accounts || (Array.isArray(data) ? data : []);
             return raw.map((a) => normalizeAccount(a, data.name));
         }
-        catch { /* parse error */ }
+        catch (e) {
+            console.warn(`[settings] loadAccountsFromCloud parse failed: ${e.message}`);
+        }
     }
     return [];
 }
@@ -285,7 +341,7 @@ export async function loadPreferences() {
     const cached = await idbRead("preferences.jsonc");
     if (cached) {
         try {
-            const data = JSON.parse(cached);
+            const data = parseJsonc(cached);
             return {
                 ui: { ...DEFAULT_PREFERENCES.ui, ...data.ui },
                 sync: { ...DEFAULT_PREFERENCES.sync, ...data.sync },
@@ -299,7 +355,7 @@ export async function loadPreferences() {
     if (content) {
         await idbWrite("preferences.jsonc", content);
         try {
-            const data = JSON.parse(content);
+            const data = parseJsonc(content);
             return {
                 ui: { ...DEFAULT_PREFERENCES.ui, ...data.ui },
                 sync: { ...DEFAULT_PREFERENCES.sync, ...data.sync },
@@ -341,7 +397,7 @@ export async function loadAllowlist() {
     const cached = await idbRead("allowlist.jsonc");
     if (cached) {
         try {
-            return JSON.parse(cached);
+            return parseJsonc(cached);
         }
         catch { /* */ }
     }
@@ -349,7 +405,7 @@ export async function loadAllowlist() {
     if (content) {
         await idbWrite("allowlist.jsonc", content);
         try {
-            return JSON.parse(content);
+            return parseJsonc(content);
         }
         catch { /* */ }
     }
@@ -418,7 +474,7 @@ export async function loadDeviceState() {
     const cached = await idbRead(filename);
     if (cached) {
         try {
-            return JSON.parse(cached);
+            return parseJsonc(cached);
         }
         catch { /* */ }
     }
@@ -426,7 +482,7 @@ export async function loadDeviceState() {
     if (content) {
         await idbWrite(filename, content);
         try {
-            return JSON.parse(content);
+            return parseJsonc(content);
         }
         catch { /* */ }
     }

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

@@ -72,6 +72,7 @@ export interface MessageEnvelope {
     size: number;
     hasAttachments: boolean;
     preview: string; /** First ~200 chars of body text */
+    bodyPath?: string; /** Local body location: "idb:..." or "gmail:<id>" */
 }
 /** Full message with body content */
 export interface Message extends MessageEnvelope {