@bobfrankston/rmfmail 1.1.45 → 1.1.49

package/packages/mailx-service/index.js

@@ -80,7 +80,8 @@ function calendarRowEquals(prior, fresh) {
         && (prior.notes || "") === (fresh.notes || "")
         && (prior.etag || "") === (fresh.etag || "")
         && (prior.recurringEventId || null) === (fresh.recurringEventId || null)
-        && (prior.htmlLink || null) === (fresh.htmlLink || null);
+        && (prior.htmlLink || null) === (fresh.htmlLink || null)
+        && (prior.calendarId || "") === (fresh.calendarId || "");
 }
 export class MailxService {
     store;
@@ -1249,6 +1250,29 @@ export class MailxService {
         console.log(`  [calendar] getCalendarEvents → ${rows.length} rows (${recurring} recurring, ${holidays} holiday) for window ${new Date(fromMs).toISOString().slice(0, 10)}..${new Date(toMs).toISOString().slice(0, 10)}`);
         return rows;
     }
+    /** List the user's *selected* Google calendars (id, display name, color,
+     *  primary flag) so the sidebar can render one checkbox + icon per
+     *  calendar. The user curates the set by selecting calendars in Google;
+     *  mailx only reflects it. Returns [] on quota cooldown / auth failure
+     *  — the sidebar then just shows no per-calendar controls. */
+    async getCalendars() {
+        const acct = this.getPrimaryAccount("calendar");
+        if (!acct)
+            return [];
+        if (this.inQuotaCooldown("calendar"))
+            return [];
+        try {
+            const tp = await this.primaryTokenProvider("calendar");
+            const all = await gsync.listCalendars(tp);
+            return all
+                .filter(c => c.selected)
+                .map(c => ({ id: c.id, name: c.summary, color: c.backgroundColor || "", primary: c.primary }));
+        }
+        catch (e) {
+            this.handleGoogleRefreshError("calendar", e);
+            return [];
+        }
+    }
     /** Returns true if the feature is currently in a quota-exceeded cooldown. */
     inQuotaCooldown(feature) {
         const until = this.quotaCooldown.get(feature);
@@ -1315,6 +1339,11 @@ export class MailxService {
         // calendarList; mailx now does too. Failing to list calendars
         // falls back to primary so single-calendar users still work.
         let calendarsToFetch = [{ id: "primary", label: "primary", defaultReminderMinutes: [] }];
+        // A failed enumeration / fetch returns fewer events than really
+        // exist; running the delete-reconciliation then purges live rows
+        // (the same data-loss shape as the Gmail partial-list bug). Track
+        // failures and skip the purge when any occurred.
+        let fetchFailed = false;
         try {
             const all = await gsync.listCalendars(tp);
             const selected = all.filter(c => c.selected);
@@ -1330,6 +1359,9 @@ export class MailxService {
             }
         }
         catch (e) {
+            // listCalendars failed — we'd fetch only `primary` and miss every
+            // secondary calendar's events. Treat as a failed pass.
+            fetchFailed = true;
             console.warn(`  [calendar] listCalendars failed (${e?.message || e}) — falling back to primary`);
         }
         const fetchResults = await Promise.all(calendarsToFetch.map(async (c) => {
@@ -1339,144 +1371,64 @@ export class MailxService {
                 return { events: ev, calendarId: c.id, defaultReminderMinutes: c.defaultReminderMinutes };
             }
             catch (e) {
+                fetchFailed = true;
                 console.warn(`  [calendar] fetch from "${c.label}" failed: ${e?.message || e}`);
                 return { events: [], calendarId: c.id, defaultReminderMinutes: c.defaultReminderMinutes };
             }
         }));
-        // Flatten with each event remembering its source calendar's default
-        // reminder list, so calendarEventToLocal can apply the right
-        // defaults when `reminders.useDefault === true`.
+        // Flatten with each event remembering its source calendar id + that
+        // calendar's default reminder list. The `calendarId` rides onto every
+        // row so the sidebar can show a per-calendar icon and the user can
+        // hide a calendar without touching Google.
         const eventsWithDefaults = [];
         for (const fr of fetchResults) {
             for (const ev of fr.events) {
-                eventsWithDefaults.push({ ev, defaultReminderMinutes: fr.defaultReminderMinutes });
-            }
-        }
-        const events = eventsWithDefaults.map(x => x.ev);
-        // Holiday calendars (Q131 + Bob 2026-05-11 second-toggle request).
-        // Each enabled toggle pulls a separate Google public calendar; rows
-        // are tagged with the source `calendar_id` so toggling one off only
-        // purges that source's rows, not the others. Future generalization
-        // to arbitrary user-supplied calendars is filed as Q140.
-        // Cached — refreshCalendarEvents runs on a poll AND on every
-        // getCalendarEvents call (envelope-first pattern). Synchronous
-        // GDrive read of accounts.jsonc here was a major contributor to
-        // the daemon-event-loop wedge that broke preview rendering.
-        const settings = this.getCachedSettings();
-        // `en.usa#holiday` is Google's "Holidays in United States" calendar
-        // which is *mixed*: federal (MLK, Memorial Day, July 4, Thanksgiving,
-        // …) PLUS Christian (Ascension Day, Pentecost, Catholic/Protestant
-        // /Orthodox/Armenian variants), Jewish observances, Ethiopian Jewish,
-        // etc. `en.usa.official#holiday` is the federal-secular-only variant.
-        // Per Bob 2026-05-11: "is there one for just secular holidays?" —
-        // yes, this is it.
-        const HOLIDAY_SOURCES = [
-            {
-                enabled: !!settings?.calendar?.showHolidays,
-                calId: "en.usa.official#holiday@group.v.calendar.google.com",
-                label: "US-official",
-            },
-            {
-                enabled: !!settings?.calendar?.showJewishHolidays,
-                // `en.judaism#holiday` is Google's Jewish-only feed.
-                // `en.jewish#holiday` (the obvious guess) is actually
-                // mis-curated and includes Christian observances
-                // (Ascension Eve / Day, Pentecost Eve / Day, Catholic /
-                // Protestant / Armenian / Orthodox variants) — Google
-                // packs cross-tradition events into the "regional"
-                // calendars. Bob 2026-05-11 confirmed `en.judaism` is
-                // the clean source via Google's embed URL.
-                calId: "en.judaism#holiday@group.v.calendar.google.com",
-                label: "Jewish",
-            },
-        ];
-        // Fan out enabled holiday-source fetches in parallel — Google's API
-        // handles each independently and the results merge by calId after.
-        // Earlier code awaited each in series, doubling latency when both
-        // US and Jewish sources were enabled (the common case for users who
-        // turn both on).
-        const enabledSources = HOLIDAY_SOURCES.filter(s => s.enabled);
-        const bundleResults = await Promise.all(enabledSources.map(async (src) => {
-            try {
-                const ev = await gsync.listCalendarEvents(tp, fromMs, toMs, src.calId);
-                console.log(`  [calendar] pulled ${ev.length} ${src.label} holiday events`);
-                return { calId: src.calId, events: ev };
+                eventsWithDefaults.push({ ev, calendarId: fr.calendarId, defaultReminderMinutes: fr.defaultReminderMinutes });
             }
-            catch (e) {
-                console.warn(`  [calendar] ${src.label} holiday pull failed: ${e?.message || e}`);
-                return null;
-            }
-        }));
-        const holidayBundles = bundleResults.filter((b) => b !== null);
-        const enabledHolidayCalIds = new Set(HOLIDAY_SOURCES.filter(s => s.enabled).map(s => s.calId));
+        }
+        // Holiday calendars are no longer hard-coded (the old HOLIDAY_SOURCES
+        // pull + `showHolidays`/`showJewishHolidays` toggles are retired). The
+        // user curates which calendars exist by selecting them in Google
+        // Calendar; mailx enumerates them above and tags every row with its
+        // source `calendarId`. The sidebar derives holiday/birthday/personal
+        // kind from that id and lets the user hide calendars per-mailx.
         let changed = false;
         // Upsert by provider_id — dedup globally, not just within the window,
         // so an event whose start moves outside the prior query range doesn't
-        // get a second row on the next pull.
+        // get a second row on the next pull. If the same event id arrives
+        // from two calendars, last-write-wins on `calendarId` (one row, one
+        // source icon — multi-source badges are a future refinement, Q143).
         const seenProviderIds = new Set();
-        for (const { ev, defaultReminderMinutes } of eventsWithDefaults) {
-            const local = gsync.calendarEventToLocal(ev, accountId, defaultReminderMinutes);
+        for (const { ev, calendarId, defaultReminderMinutes } of eventsWithDefaults) {
+            const local = { ...gsync.calendarEventToLocal(ev, accountId, defaultReminderMinutes), calendarId };
             seenProviderIds.add(ev.id);
             const existing = this.db.getCalendarEventByProviderId(accountId, ev.id);
-            if (existing && calendarRowEquals(existing, local) && !existing.isHoliday)
+            if (existing && calendarRowEquals(existing, local))
                 continue;
-            this.db.upsertCalendarEvent({ uuid: existing?.uuid, ...local, isHoliday: false });
+            this.db.upsertCalendarEvent({ uuid: existing?.uuid, ...local });
             changed = true;
         }
-        // First-wins guard. Google's holiday calendars overlap: a Christian
-        // observance can appear in both `en.usa#holiday` and `en.jewish#holiday`
-        // with the same event id. Without this guard the second bundle's
-        // upsert overwrites the first row's `calendarId`, and the sidebar's
-        // color classifier (us → green, jewish → blue) sees the wrong tag —
-        // Bob 2026-05-11 observed Catholic/Protestant entries colored blue
-        // (Jewish-source color) instead of green (US-source). Earlier
-        // bundles in HOLIDAY_SOURCES win; reorder the array to change
-        // precedence if needed.
-        const seenInHolidayPass = new Set();
-        for (const bundle of holidayBundles) {
-            for (const ev of bundle.events) {
-                if (seenInHolidayPass.has(ev.id))
-                    continue;
-                seenInHolidayPass.add(ev.id);
-                const baseLocal = gsync.calendarEventToLocal(ev, accountId);
-                // Override calendarId so reconcile (below) can tell which
-                // holiday source this row belongs to — toggling one source
-                // off must not purge rows from another active source.
-                const local = { ...baseLocal, calendarId: bundle.calId };
-                seenProviderIds.add(ev.id);
-                const existing = this.db.getCalendarEventByProviderId(accountId, ev.id);
-                if (existing && calendarRowEquals(existing, local) && existing.isHoliday)
+        // Server-side delete reconciliation: any local non-dirty row whose
+        // start falls in the queried window and whose provider_id wasn't
+        // returned was deleted on Google — or its calendar was deselected in
+        // Google (no longer enumerated, so its events stop arriving). Both
+        // mean the row should go. SKIPPED when any fetch failed this pass —
+        // a partial result would otherwise purge live events.
+        if (!fetchFailed) {
+            const localWindow = this.db.getCalendarEvents(accountId, fromMs, toMs);
+            for (const row of localWindow) {
+                if (!row.providerId)
+                    continue; // local-only, never pushed
+                if (row.dirty)
+                    continue; // locally edited, pending push
+                if (seenProviderIds.has(row.providerId))
                     continue;
-                this.db.upsertCalendarEvent({ uuid: existing?.uuid, ...local, isHoliday: true });
+                this.db.purgeCalendarEvent(row.uuid);
                 changed = true;
             }
         }
-        // Server-side delete reconciliation: any local non-dirty row whose
-        // start falls in the queried window and whose provider_id wasn't
-        // returned must have been deleted on Google. Holiday rows are
-        // partitioned by `calendarId`: only purge a holiday row when its
-        // source calendar is currently disabled. Sources that are enabled
-        // but returned nothing for this row keep the row (transient fail).
-        const localWindow = this.db.getCalendarEvents(accountId, fromMs, toMs);
-        for (const row of localWindow) {
-            if (!row.providerId)
-                continue; // local-only, never pushed
-            if (row.dirty)
-                continue; // locally edited, pending push
-            if (seenProviderIds.has(row.providerId))
-                continue;
-            if (row.isHoliday) {
-                const fromActiveSource = enabledHolidayCalIds.has(row.calendarId || "");
-                if (!fromActiveSource) {
-                    // Source toggled off — purge.
-                    this.db.purgeCalendarEvent(row.uuid);
-                    changed = true;
-                }
-                // Source enabled but row missing → transient; keep.
-                continue;
-            }
-            this.db.purgeCalendarEvent(row.uuid);
-            changed = true;
+        else {
+            console.warn(`  [calendar] fetch incomplete — skipping delete reconciliation to protect the local cache`);
         }
         return changed;
     }
@@ -1555,6 +1507,12 @@ export class MailxService {
         // a single `@default` query keeps single-list users working when
         // the listTaskLists call fails.
         let lists = [{ id: "@default", title: "@default" }];
+        // Track whether ANY fetch failed. A failed fetch returns an empty
+        // list indistinguishable from "all tasks deleted on the server" —
+        // running the delete-reconciliation then wipes the whole local task
+        // cache. `firstError` is surfaced so the quota cooldown gets armed.
+        let fetchFailed = false;
+        let firstError = null;
         try {
             const all = await gsync.listTaskLists(tp);
             if (all.length > 0) {
@@ -1563,6 +1521,8 @@ export class MailxService {
             }
         }
         catch (e) {
+            fetchFailed = true;
+            firstError = e;
             console.warn(`  [tasks] listTaskLists failed (${e?.message || e}) — falling back to @default`);
         }
         const fetchResults = await Promise.all(lists.map(async (l) => {
@@ -1572,6 +1532,8 @@ export class MailxService {
                 return t;
             }
             catch (e) {
+                fetchFailed = true;
+                firstError = firstError || e;
                 console.warn(`  [tasks] fetch from "${l.title}" failed: ${e?.message || e}`);
                 return [];
             }
@@ -1592,15 +1554,25 @@ export class MailxService {
             this.db.upsertTask({ uuid: prior?.uuid, ...local });
             changed = true;
         }
-        // Server-side delete reconciliation: any non-dirty local task whose
-        // provider_id wasn't returned has been deleted on Google. Purge.
-        for (const row of existing) {
-            if (!row.providerId || row.dirty)
-                continue;
-            if (seen.has(row.providerId))
-                continue;
-            this.db.purgeTask(row.uuid);
-            changed = true;
+        // Server-side delete reconciliation — ONLY when every list fetched
+        // cleanly. On a failed fetch (429, network) the server result is
+        // an empty list, which the purge below would read as "everything
+        // was deleted" and wipe the entire local task cache. Guard it.
+        if (!fetchFailed) {
+            for (const row of existing) {
+                if (!row.providerId || row.dirty)
+                    continue;
+                if (seen.has(row.providerId))
+                    continue;
+                this.db.purgeTask(row.uuid);
+                changed = true;
+            }
+        }
+        else {
+            console.warn(`  [tasks] fetch incomplete — skipping delete reconciliation to protect the local cache`);
+            // Arm the quota cooldown. Without this the 429 is swallowed here
+            // and the 30 s poll hammers Google's Tasks API forever.
+            this.handleGoogleRefreshError("tasks", firstError);
         }
         return changed;
     }