@bobfrankston/mailx 1.0.264 → 1.0.278

package/packages/mailx-settings/cloud.d.ts

@@ -22,8 +22,8 @@ export type CloudProvider = "gdrive" | "google" | "local";
 export interface CloudFile {
     /** Read a file. For gdrive, path is just the filename (folder ID is implicit). */
     read(filePath: string): Promise<string | null>;
-    /** Write a file. For gdrive, path is just the filename. */
-    write(filePath: string, content: string): Promise<boolean>;
+    /** Write a file. For gdrive, path is just the filename. Throws on failure with a descriptive error. */
+    write(filePath: string, content: string): Promise<void>;
     /** Check if a file exists. */
     exists(filePath: string): Promise<boolean>;
 }
@@ -32,4 +32,13 @@ export interface CloudFile {
  * Files are stored flat in the folder (no subdirectory navigation).
  */
 export declare function getCloudProvider(provider: string, folderId?: string): CloudFile | null;
+/** Fetch the authenticated Google user's profile (name + email) via the People API.
+ *  Caller must supply an OAuth access token whose scopes include `contacts.readonly`
+ *  or `userinfo.profile`. The Drive token (drive.file) does NOT have the right scope
+ *  on its own — use the Gmail/IMAP OAuth token instead (mailx-imap's
+ *  ImapManager.getOAuthToken). Returns null on failure. */
+export declare function getGoogleProfile(token: string): Promise<{
+    name?: string;
+    email?: string;
+} | null>;
 //# sourceMappingURL=cloud.d.ts.map

package/packages/mailx-settings/cloud.js

@@ -161,44 +161,49 @@ async function gDriveReadFromFolder(folderId, fileName) {
         return null;
     }
 }
-/** Write a file by name to a folder (by ID) — creates or updates */
+/** Write a file by name to a folder (by ID) — creates or updates.
+ *  Throws on failure with a descriptive error so callers can surface it to the UI. */
 async function gDriveWriteToFolder(folderId, fileName, content) {
     const token = await getGoogleDriveToken();
     if (!token)
-        return false;
-    try {
-        // Check if file exists in folder
-        const query = `name='${fileName}' and '${folderId}' in parents and trashed=false`;
-        const findRes = await fetch(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id)`, {
-            headers: { Authorization: `Bearer ${token}` },
+        throw new Error("Google Drive: no auth token (OAuth not granted or expired)");
+    // Check if file exists in folder
+    const query = `name='${fileName}' and '${folderId}' in parents and trashed=false`;
+    const findRes = await fetch(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id)`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!findRes.ok) {
+        const body = await findRes.text().catch(() => "");
+        throw new Error(`Google Drive: lookup '${fileName}' failed (${findRes.status} ${findRes.statusText}) ${body.slice(0, 200)}`);
+    }
+    const findData = await findRes.json();
+    const existingId = findData.files?.[0]?.id;
+    if (existingId) {
+        // Update existing file
+        const res = await fetch(`https://www.googleapis.com/upload/drive/v3/files/${existingId}?uploadType=media`, {
+            method: "PATCH",
+            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+            body: content,
         });
-        const findData = await findRes.json();
-        const existingId = findData.files?.[0]?.id;
-        if (existingId) {
-            // Update existing file
-            const res = await fetch(`https://www.googleapis.com/upload/drive/v3/files/${existingId}?uploadType=media`, {
-                method: "PATCH",
-                headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
-                body: content,
-            });
-            return res.ok;
-        }
-        else {
-            // Create new file in folder
-            const boundary = "mailx_boundary_" + Date.now();
-            const metadata = JSON.stringify({ name: fileName, parents: [folderId] });
-            const body = `--${boundary}\r\nContent-Type: application/json\r\n\r\n${metadata}\r\n--${boundary}\r\nContent-Type: application/json\r\n\r\n${content}\r\n--${boundary}--`;
-            const res = await fetch("https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart", {
-                method: "POST",
-                headers: { Authorization: `Bearer ${token}`, "Content-Type": `multipart/related; boundary=${boundary}` },
-                body,
-            });
-            return res.ok;
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new Error(`Google Drive: update '${fileName}' failed (${res.status} ${res.statusText}) ${body.slice(0, 200)}`);
         }
     }
-    catch (e) {
-        console.error(`  [cloud] gdrive write ${fileName}: ${e.message}`);
-        return false;
+    else {
+        // Create new file in folder
+        const boundary = "mailx_boundary_" + Date.now();
+        const metadata = JSON.stringify({ name: fileName, parents: [folderId] });
+        const body = `--${boundary}\r\nContent-Type: application/json\r\n\r\n${metadata}\r\n--${boundary}\r\nContent-Type: application/json\r\n\r\n${content}\r\n--${boundary}--`;
+        const res = await fetch("https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart", {
+            method: "POST",
+            headers: { Authorization: `Bearer ${token}`, "Content-Type": `multipart/related; boundary=${boundary}` },
+            body,
+        });
+        if (!res.ok) {
+            const errBody = await res.text().catch(() => "");
+            throw new Error(`Google Drive: create '${fileName}' failed (${res.status} ${res.statusText}) ${errBody.slice(0, 200)}`);
+        }
     }
 }
 /**
@@ -226,13 +231,7 @@ export function getCloudProvider(provider, folderId) {
                 catch {
                     return null;
                 } },
-                write: async (p, c) => { try {
-                    fs.writeFileSync(p, c);
-                    return true;
-                }
-                catch {
-                    return false;
-                } },
+                write: async (p, c) => { fs.writeFileSync(p, c); },
                 exists: async (p) => fs.existsSync(p),
             };
         default:
@@ -240,4 +239,32 @@ export function getCloudProvider(provider, folderId) {
             return null;
     }
 }
+/** Fetch the authenticated Google user's profile (name + email) via the People API.
+ *  Caller must supply an OAuth access token whose scopes include `contacts.readonly`
+ *  or `userinfo.profile`. The Drive token (drive.file) does NOT have the right scope
+ *  on its own — use the Gmail/IMAP OAuth token instead (mailx-imap's
+ *  ImapManager.getOAuthToken). Returns null on failure. */
+export async function getGoogleProfile(token) {
+    if (!token)
+        return null;
+    try {
+        const res = await fetch("https://people.googleapis.com/v1/people/me?personFields=names,emailAddresses", {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok) {
+            console.error(`  [cloud] People API: ${res.status} ${res.statusText}`);
+            return null;
+        }
+        const data = await res.json();
+        const name = data.names?.find((n) => n.displayName)?.displayName
+            || data.names?.[0]?.displayName;
+        const email = data.emailAddresses?.find((e) => e.metadata?.primary)?.value
+            || data.emailAddresses?.[0]?.value;
+        return { name, email };
+    }
+    catch (e) {
+        console.error(`  [cloud] getGoogleProfile: ${e.message}`);
+        return null;
+    }
+}
 //# sourceMappingURL=cloud.js.map

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

@@ -17,11 +17,20 @@
  */
 import type { MailxSettings, AccountConfig, AutocompleteSettings } from "@bobfrankston/mailx-types";
 declare const LOCAL_DIR: string;
+/** Subscribers notified whenever lastCloudError changes (push to UI immediately). */
+type CloudErrorListener = (error: string | null, context?: {
+    op: "read" | "write";
+    filename: string;
+}) => void;
+export declare function onCloudError(cb: CloudErrorListener): () => void;
+export declare function getLastCloudError(): string | null;
 declare function getSharedDir(): string;
 /** Read a file via cloud API (when filesystem mount not available) */
 export declare function cloudRead(filename: string): Promise<string | null>;
-/** Write a file via cloud API */
-export declare function cloudWrite(filename: string, content: string): Promise<boolean>;
+/** Write a file via cloud API. Throws on failure with a descriptive error,
+ *  and updates lastCloudError so UI banners pick it up via getStorageInfo()
+ *  and the onCloudError listener. */
+export declare function cloudWrite(filename: string, content: string): Promise<void>;
 /** Whether cloud API fallback is active */
 export declare function isCloudMode(): boolean;
 /** Get storage provider info for display */

package/packages/mailx-settings/index.js

@@ -62,6 +62,25 @@ function resolveProvider(cfg) {
 let pendingCloudConfig = null;
 /** Last cloud API error (for UI display) */
 let lastCloudError = null;
+const cloudErrorListeners = [];
+export function onCloudError(cb) {
+    cloudErrorListeners.push(cb);
+    return () => {
+        const i = cloudErrorListeners.indexOf(cb);
+        if (i >= 0)
+            cloudErrorListeners.splice(i, 1);
+    };
+}
+function setCloudError(error, context) {
+    lastCloudError = error;
+    for (const cb of cloudErrorListeners) {
+        try {
+            cb(error, context);
+        }
+        catch { /* listener faults shouldn't break writes */ }
+    }
+}
+export function getLastCloudError() { return lastCloudError; }
 function resolveSharedEntry(entry) {
     if (typeof entry === "string") {
         const p = resolvePath(entry);
@@ -97,16 +116,20 @@ export async function cloudRead(filename) {
         pendingCloudConfig.folderId = await gDriveFindOrCreateFolder() || undefined;
         if (pendingCloudConfig.folderId)
             saveFolderIdToConfig(pendingCloudConfig.folderId);
+        if (!pendingCloudConfig.folderId) {
+            setCloudError(`Cannot read ${filename}: Google Drive folder unavailable (OAuth not granted?)`, { op: "read", filename });
+            return null;
+        }
     }
     const provider = getCloudProvider(pendingCloudConfig.provider, pendingCloudConfig.folderId);
     if (!provider) {
-        lastCloudError = `No cloud provider for ${pendingCloudConfig.provider}`;
+        setCloudError(`No cloud provider for ${pendingCloudConfig.provider}`, { op: "read", filename });
         return null;
     }
     console.log(`  [cloud] Reading ${filename} via ${pendingCloudConfig.provider} API...`);
     const content = await provider.read(filename);
     if (content) {
-        lastCloudError = null;
+        setCloudError(null);
         // Cache locally
         try {
             fs.mkdirSync(LOCAL_DIR, { recursive: true });
@@ -117,20 +140,40 @@ export async function cloudRead(filename) {
     // Don't set error for missing files — they may not exist yet (e.g., clients.jsonc on first run)
     return content;
 }
-/** Write a file via cloud API */
+/** Write a file via cloud API. Throws on failure with a descriptive error,
+ *  and updates lastCloudError so UI banners pick it up via getStorageInfo()
+ *  and the onCloudError listener. */
 export async function cloudWrite(filename, content) {
-    if (!pendingCloudConfig)
-        return false;
+    if (!pendingCloudConfig) {
+        const err = `No cloud configured — cannot save ${filename} to cloud`;
+        setCloudError(err, { op: "write", filename });
+        throw new Error(err);
+    }
     // Ensure we have a folder ID
     if (!pendingCloudConfig.folderId) {
         pendingCloudConfig.folderId = await gDriveFindOrCreateFolder() || undefined;
         if (pendingCloudConfig.folderId)
             saveFolderIdToConfig(pendingCloudConfig.folderId);
+        if (!pendingCloudConfig.folderId) {
+            const err = `Cannot save ${filename}: Google Drive folder unavailable (OAuth not granted or token expired)`;
+            setCloudError(err, { op: "write", filename });
+            throw new Error(err);
+        }
     }
     const provider = getCloudProvider(pendingCloudConfig.provider, pendingCloudConfig.folderId);
-    if (!provider)
-        return false;
-    return provider.write(filename, content);
+    if (!provider) {
+        const err = `No cloud provider for ${pendingCloudConfig.provider}`;
+        setCloudError(err, { op: "write", filename });
+        throw new Error(err);
+    }
+    try {
+        await provider.write(filename, content);
+        setCloudError(null);
+    }
+    catch (e) {
+        setCloudError(e.message, { op: "write", filename });
+        throw e;
+    }
 }
 /** Persist the discovered folder ID back to config.jsonc so we don't search again */
 function saveFolderIdToConfig(folderId) {
@@ -231,7 +274,12 @@ function loadFile(filename, defaults) {
     }
     return { ...defaults, ...data };
 }
-/** Save a config file to the shared directory (and cloud API if active) */
+/** Save a config file to the shared directory (and cloud API if active).
+ *  Always writes the local copy first so the data is never lost.
+ *  If a cloud provider is configured, also writes there — failures set
+ *  lastCloudError and notify onCloudError listeners so the UI can show
+ *  a banner. The cloud write is fire-and-forget at this layer; callers
+ *  who need the result should use the typed save* helpers below. */
 function saveFile(filename, data) {
     const sharedDir = getSharedDir();
     atomicWrite(path.join(sharedDir, filename), data);
@@ -244,12 +292,13 @@ function saveFile(filename, data) {
     }
     // Write to cloud API if filesystem mount unavailable (creates app-owned file for drive.file scope)
     if (pendingCloudConfig) {
-        cloudWrite(filename, JSON.stringify(data, null, 2)).then(ok => {
-            if (ok)
-                console.log(`  [cloud] Saved ${filename} via ${pendingCloudConfig.provider} API`);
-            else
-                console.error(`  [cloud] Failed to save ${filename} via ${pendingCloudConfig.provider} API`);
-        }).catch(() => { });
+        cloudWrite(filename, JSON.stringify(data, null, 2))
+            .then(() => console.log(`  [cloud] Saved ${filename} via ${pendingCloudConfig.provider} API`))
+            .catch(e => console.error(`  [cloud] Failed to save ${filename}: ${e.message}`));
+        // Note: we don't await — saveFile is sync. cloudWrite() already calls
+        // setCloudError(), which fires onCloudError listeners synchronously
+        // when the promise rejects, so the UI gets the failure even though
+        // we don't propagate it back through the call chain here.
     }
 }
 const PROVIDERS = {

package/packages/mailx-store/db.js

@@ -345,6 +345,12 @@ export class MailxDB {
             const term = `%${query.search}%`;
             params.push(term, term, term);
         }
+        if (query.flaggedOnly) {
+            // flags_json is a JSON array like ["\\Seen","\\Flagged"]. A plain
+            // LIKE on the serialized form is sufficient to find rows with the
+            // \Flagged flag without decoding every row.
+            where += " AND flags_json LIKE '%\\\\Flagged%'";
+        }
         const total = this.db.prepare(`SELECT COUNT(*) as cnt FROM messages WHERE ${where}`).get(...params).cnt;
         const rows = this.db.prepare(`SELECT * FROM messages WHERE ${where} ORDER BY ${sortCol} ${sortDir} LIMIT ? OFFSET ?`).all(...params, pageSize, offset);
         const items = rows.map(r => ({

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

@@ -218,13 +218,24 @@ export class WebMailxService {
             raw = await this.syncManager.fetchMessageBody(accountId, envelope.folderId, envelope.uid);
         }
         catch (fetchErr) {
+            // Mirror the desktop service: surface as structured bodyError
+            // so the viewer shows its dedicated error banner instead of
+            // rendering the message text verbatim in the body area.
+            const rawErr = fetchErr.message || "fetch failed";
+            const isTransient = /connection|Too many|UNAVAILABLE|rate|429|5\d\d|timeout|ENOTFOUND|ECONNRESET|ETIMEDOUT/i.test(rawErr);
             return {
-                ...envelope, bodyHtml: "", bodyText: `[Message body unavailable: ${fetchErr.message || "fetch failed"}]`,
+                ...envelope, bodyHtml: "", bodyText: "",
+                bodyError: rawErr, bodyErrorTransient: isTransient,
                 hasRemoteContent: false, remoteAllowed: false, attachments: [], deliveredTo: "", returnPath: "", listUnsubscribe: ""
             };
         }
         if (!raw) {
-            bodyText = "[Message body not available. Try again or re-sync the folder.]";
+            return {
+                ...envelope, bodyHtml: "", bodyText: "",
+                bodyError: "Message body not cached locally and the server fetch returned nothing.",
+                bodyErrorTransient: true,
+                hasRemoteContent: false, remoteAllowed: false, attachments: [], deliveredTo: "", returnPath: "", listUnsubscribe: ""
+            };
         }
         else {
             const source = new TextDecoder().decode(raw);

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

@@ -106,6 +106,10 @@ export interface MessageQuery {
     sort?: "date" | "from" | "subject";
     sortDir?: "asc" | "desc";
     search?: string;
+    /** Restrict to messages with the \Flagged flag set (whole-folder, not
+     *  just the currently-rendered page — lets the "show flagged" filter
+     *  find stars on messages that haven't been paged in yet). */
+    flaggedOnly?: boolean;
 }
 /** Compose/send a message */
 export interface ComposeMessage {

package/tsconfig.base.json

@@ -6,6 +6,7 @@
     "allowSyntheticDefaultImports": true,
     "esModuleInterop": true,
     "allowJs": true,
+    "resolveJsonModule": true,
     "strict": true,
     "forceConsistentCasingInFileNames": true,
     "skipLibCheck": true,