@bobfrankston/mailx 1.0.297 → 1.0.299

package/bin/mailx.js

@@ -835,6 +835,17 @@ async function main() {
     const clientDir = path.join(import.meta.dirname, "..", "client");
     const mailxapiPath = path.join(clientDir, "lib", "mailxapi.js");
     const mailxapiScript = fs.readFileSync(mailxapiPath, "utf-8");
+    // Restore saved window geometry (position + size) from previous session
+    const windowJsonPath = path.join(getConfigDir(), "window.json");
+    let savedGeometry = null;
+    try {
+        const raw = JSON.parse(fs.readFileSync(windowJsonPath, "utf-8"));
+        if (typeof raw.width === "number" && raw.width > 200 &&
+            typeof raw.height === "number" && raw.height > 200) {
+            savedGeometry = raw;
+        }
+    }
+    catch { /* no saved geometry — use defaults */ }
     const rootPkgVersion = JSON.parse(fs.readFileSync(path.join(import.meta.dirname, "..", "package.json"), "utf-8")).version;
     const handle = showService({
         title: `mailx v${rootPkgVersion}`,
@@ -843,7 +854,12 @@ async function main() {
         initScript: mailxapiScript,
         icon: path.join(clientDir, "icon.png"),
         aumid: "com.frankston.mailx",
-        size: { width: 1400, height: 900 },
+        size: savedGeometry
+            ? { width: savedGeometry.width, height: savedGeometry.height }
+            : { width: 1400, height: 900 },
+        pos: savedGeometry
+            ? { x: savedGeometry.x, y: savedGeometry.y }
+            : undefined,
         escapeCloses: false,
     });
     // Register ourselves as the live instance so subsequent `mailx` invocations
@@ -868,6 +884,23 @@ async function main() {
             return;
         }
         console.log(`[ipc] ← ${req._action} (${req._cbid})`);
+        // Save window position+size for next launch (handled here, not in MailxService)
+        if (req._action === "saveWindowGeometry") {
+            try {
+                const geom = {
+                    x: Number(req.x) || 0,
+                    y: Number(req.y) || 0,
+                    width: Math.max(400, Number(req.width) || 1400),
+                    height: Math.max(300, Number(req.height) || 900),
+                };
+                fs.writeFileSync(windowJsonPath, JSON.stringify(geom, null, 2));
+            }
+            catch (e) {
+                console.error(`[window] Failed to save geometry: ${e.message}`);
+            }
+            handle.send({ _cbid: req._cbid, result: { ok: true } });
+            return;
+        }
         // Auto-update action: run npm install then restart
         if (req._action === "performUpdate") {
             handle.send({ _cbid: req._cbid, ok: true, status: "updating" });

package/client/app.js

@@ -691,6 +691,32 @@ document.addEventListener("mailx-moved", (e) => {
     undoTimeout = setTimeout(() => { lastMoved = null; }, 60000);
 });
 document.getElementById("btn-delete")?.addEventListener("click", deleteSelectedMessages);
+// ── Flag toggle ──
+document.getElementById("btn-flag")?.addEventListener("click", async () => {
+    const sel = messageState.getSelected();
+    if (!sel)
+        return;
+    const isFlagged = sel.flags.includes("\\Flagged");
+    const newFlags = isFlagged
+        ? sel.flags.filter((f) => f !== "\\Flagged")
+        : [...sel.flags, "\\Flagged"];
+    try {
+        await updateFlags(sel.accountId, sel.uid, newFlags);
+        sel.flags = newFlags;
+        messageState.updateMessageFlags(sel.accountId, sel.uid, newFlags);
+        // Update the message-list row's flag indicator
+        const row = document.querySelector(`.ml-row[data-uid="${sel.uid}"][data-account-id="${sel.accountId}"]`);
+        if (row) {
+            row.classList.toggle("flagged", newFlags.includes("\\Flagged"));
+            const flagEl = row.querySelector(".ml-flag");
+            if (flagEl)
+                flagEl.textContent = newFlags.includes("\\Flagged") ? "\u2605" : "\u2606";
+        }
+    }
+    catch (e) {
+        console.error(`Flag toggle failed: ${e.message}`);
+    }
+});
 async function spamSelectedMessages() {
     const selected = getSelectedMessages();
     if (selected.length === 0) {
@@ -1660,4 +1686,22 @@ versionPromise.then((d) => {
     else if (d.theme === "light")
         document.documentElement.classList.add("theme-light");
 }).catch(() => { });
+// ── Save window geometry on close (IPC mode only) ──
+// Sends window position and size so the next launch restores them.
+if (isApp) {
+    const ipcApi = window.mailxapi;
+    function sendGeometry() {
+        if (!ipcApi?.saveWindowGeometry)
+            return;
+        ipcApi.saveWindowGeometry({
+            x: window.screenX,
+            y: window.screenY,
+            width: window.outerWidth,
+            height: window.outerHeight,
+        }).catch(() => { });
+    }
+    // Save on unload (window close) and periodically as a safety net
+    window.addEventListener("beforeunload", sendGeometry);
+    setInterval(sendGeometry, 60_000);
+}
 //# sourceMappingURL=app.js.map

package/client/components/context-menu.js

@@ -3,12 +3,22 @@
  * Shows a menu at a given position with clickable items.
  */
 let activeMenu = null;
-/** Close any open context menu */
+let dismissListener = null;
+let escapeListener = null;
+/** Close any open context menu and remove dismiss listeners */
 export function closeContextMenu() {
     if (activeMenu) {
         activeMenu.remove();
         activeMenu = null;
     }
+    if (dismissListener) {
+        document.removeEventListener("pointerdown", dismissListener, true);
+        dismissListener = null;
+    }
+    if (escapeListener) {
+        document.removeEventListener("keydown", escapeListener, true);
+        escapeListener = null;
+    }
 }
 /** Show a context menu at the given position */
 export function showContextMenu(x, y, items) {
@@ -43,11 +53,28 @@ export function showContextMenu(x, y, items) {
     if (rect.bottom > window.innerHeight)
         menu.style.top = `${y - rect.height}px`;
     activeMenu = menu;
+    // Dismiss on click/tap outside the menu. Uses pointerdown in capture phase
+    // so it fires before any child handler and catches both left- and right-clicks.
+    // Deferred by one frame so the opening pointerdown doesn't immediately close it.
+    requestAnimationFrame(() => {
+        dismissListener = (e) => {
+            if (activeMenu && !activeMenu.contains(e.target)) {
+                closeContextMenu();
+            }
+        };
+        document.addEventListener("pointerdown", dismissListener, true);
+        escapeListener = (e) => {
+            if (e.key === "Escape") {
+                e.preventDefault();
+                e.stopPropagation();
+                closeContextMenu();
+            }
+        };
+        document.addEventListener("keydown", escapeListener, true);
+    });
 }
-// Close on any interaction outside the menu
-document.addEventListener("click", closeContextMenu);
-document.addEventListener("keydown", (e) => { if (e.key === "Escape")
-    closeContextMenu(); });
+// Scroll anywhere closes the menu (capture phase so nested scrollers trigger it)
 document.addEventListener("scroll", closeContextMenu, true);
+// A new right-click that opens a different menu goes through showContextMenu→closeContextMenu
 document.addEventListener("contextmenu", () => { });
 //# sourceMappingURL=context-menu.js.map

package/client/lib/mailxapi.js

@@ -172,6 +172,11 @@
         },
         repairAccounts: function() { return callNode("repairAccounts"); },
 
+        // Window geometry
+        saveWindowGeometry: function(geom) {
+            return callNode("saveWindowGeometry", geom);
+        },
+
         // Events
         onEvent: function(handler) { _eventHandlers.push(handler); },
     };

package/package.json

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

package/packages/mailx-imap/index.js

@@ -468,7 +468,7 @@ export class ImapManager extends EventEmitter {
                 // a hung OAuth server could block the entire sync thread indefinitely.
                 const TOKEN_FETCH_TIMEOUT_MS = 30000;
                 const authPromise = authenticateOAuth(credPath, {
-                    scope: "https://mail.google.com/ https://www.googleapis.com/auth/contacts.readonly https://www.googleapis.com/auth/calendar",
+                    scope: "https://mail.google.com/ https://www.googleapis.com/auth/contacts.readonly https://www.googleapis.com/auth/calendar https://www.googleapis.com/auth/drive",
                     tokenDirectory: tokenDir,
                     credentialsKey: "installed",
                     loginHint: account.imap.user,

package/packages/mailx-settings/cloud.js

@@ -59,30 +59,69 @@ const GDRIVE_SCOPES = "https://www.googleapis.com/auth/drive";
  *  is the auto-created default. First one that exists on GDrive wins. */
 const GDRIVE_PATH_SEARCH_ORDER = ["home/.mailx", "mailx"];
 // ── Token helpers ──
+/** Get a GDrive-capable token. Prefers the Gmail token (which now includes
+ *  drive scope) — avoids a second OAuth consent prompt. Falls back to the
+ *  dedicated GDrive token dir for non-Gmail setups or when Gmail token
+ *  doesn't have drive scope yet. */
 async function getGoogleDriveToken() {
+    // Strategy 1: reuse a Gmail token that already has drive scope.
+    // Scan the tokens/ dir for any account token with drive in its scope.
+    const tokensDir = path.join(SETTINGS_DIR, "tokens");
+    if (fs.existsSync(tokensDir)) {
+        try {
+            for (const entry of fs.readdirSync(tokensDir)) {
+                if (entry === "gdrive")
+                    continue;
+                const tokenPath = path.join(tokensDir, entry, "oauth-token.json");
+                if (!fs.existsSync(tokenPath))
+                    continue;
+                try {
+                    const tok = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
+                    if (tok.scope?.includes("drive") && tok.refresh_token) {
+                        console.log(`  [cloud] Reusing Gmail token from ${entry} (has drive scope)`);
+                        const creds = findGoogleCredentials();
+                        if (!creds)
+                            continue;
+                        const refreshed = await authenticateOAuth(creds, {
+                            scope: tok.scope,
+                            tokenDirectory: path.join(tokensDir, entry),
+                            tokenFileName: "oauth-token.json",
+                            credentialsKey: "installed",
+                            includeOfflineAccess: true,
+                        });
+                        if (refreshed?.access_token) {
+                            console.log(`  [cloud] GDrive auth: success (via Gmail token)`);
+                            return refreshed.access_token;
+                        }
+                    }
+                }
+                catch { /* skip this token */ }
+            }
+        }
+        catch { /* tokens dir unreadable */ }
+    }
+    // Strategy 2: dedicated GDrive token (legacy path or non-Gmail setups)
     const creds = findGoogleCredentials();
     if (!creds) {
         console.error("  [cloud] No Google credentials found (checked ~/.mailx/google-credentials.json and iflow package)");
         return null;
     }
     const tokenPath = path.join(GDRIVE_TOKEN_DIR, "token.json");
-    // Log token state so failures are diagnosable
     if (fs.existsSync(tokenPath)) {
         try {
             const existing = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
             const expired = existing.expires_at ? Date.now() >= existing.expires_at : true;
             const hasRefresh = !!existing.refresh_token;
-            console.log(`  [cloud] GDrive token: ${expired ? "expired" : "valid"}, refresh_token: ${hasRefresh ? "yes" : "NO"}, scope: ${existing.scope || "?"}`);
-            // Delete stale token if scope changed (drive → drive.file or vice versa)
+            console.log(`  [cloud] GDrive token (dedicated): ${expired ? "expired" : "valid"}, refresh_token: ${hasRefresh ? "yes" : "NO"}, scope: ${existing.scope || "?"}`);
             if (existing.scope && existing.scope !== GDRIVE_SCOPES) {
                 console.log(`  [cloud] Scope changed (${existing.scope} → ${GDRIVE_SCOPES}) — re-authenticating...`);
                 fs.unlinkSync(tokenPath);
             }
         }
-        catch { /* ignore parse errors */ }
+        catch { /* ignore */ }
     }
     else {
-        console.log(`  [cloud] GDrive token: not found at ${tokenPath}`);
+        console.log(`  [cloud] GDrive token: not found at ${tokenPath} (will auth)`);
     }
     try {
         const token = await authenticateOAuth(creds, {
@@ -93,10 +132,10 @@ async function getGoogleDriveToken() {
             includeOfflineAccess: true,
         });
         if (token?.access_token) {
-            console.log(`  [cloud] GDrive auth: success (token refreshed/valid)`);
+            console.log(`  [cloud] GDrive auth: success (dedicated token)`);
         }
         else {
-            console.error(`  [cloud] GDrive auth: returned null — OAuth callback likely timed out or was denied`);
+            console.error(`  [cloud] GDrive auth: returned null — OAuth likely timed out`);
         }
         return token?.access_token || null;
     }