@bobfrankston/mailx 1.0.377 → 1.0.379

package/packages/mailx-service/google-sync.js

@@ -0,0 +1,140 @@
+/**
+ * Google Calendar / Tasks / People (Contacts) two-way sync helpers.
+ *
+ * Used by MailxService to push local edits to Google and pull server
+ * changes into the local cache. All functions take a `getToken` function
+ * and a fetch implementation so they stay platform-agnostic (Node uses
+ * global `fetch` on Node 18+; browsers use window.fetch).
+ *
+ * Error handling: throws on network / HTTP errors. Caller catches and
+ * either retries via the store_sync drainer or surfaces to the UI.
+ */
+async function googleFetch(tokenProvider, url, init = {}) {
+    const token = await tokenProvider();
+    const headers = new Headers(init.headers || {});
+    headers.set("Authorization", `Bearer ${token}`);
+    if (init.body && !headers.has("Content-Type"))
+        headers.set("Content-Type", "application/json");
+    const res = await fetch(url, { ...init, headers });
+    if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`Google API ${res.status} ${res.statusText}: ${body.slice(0, 300)}`);
+    }
+    return res;
+}
+export async function listCalendarEvents(tokenProvider, fromMs, toMs, calendarId = "primary") {
+    const from = new Date(fromMs).toISOString();
+    const to = new Date(toMs).toISOString();
+    const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events`
+        + `?timeMin=${encodeURIComponent(from)}&timeMax=${encodeURIComponent(to)}`
+        + `&singleEvents=true&orderBy=startTime&maxResults=250`;
+    const all = [];
+    let pageToken;
+    do {
+        const pagedUrl = pageToken ? `${url}&pageToken=${encodeURIComponent(pageToken)}` : url;
+        const res = await googleFetch(tokenProvider, pagedUrl);
+        const data = await res.json();
+        for (const ev of (data.items || []))
+            all.push(ev);
+        pageToken = data.nextPageToken;
+    } while (pageToken);
+    return all;
+}
+export async function createCalendarEvent(tokenProvider, event, calendarId = "primary") {
+    const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events`;
+    const res = await googleFetch(tokenProvider, url, { method: "POST", body: JSON.stringify(event) });
+    return res.json();
+}
+export async function updateCalendarEvent(tokenProvider, eventId, event, calendarId = "primary") {
+    const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`;
+    const res = await googleFetch(tokenProvider, url, { method: "PATCH", body: JSON.stringify(event) });
+    return res.json();
+}
+export async function deleteCalendarEvent(tokenProvider, eventId, calendarId = "primary") {
+    const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`;
+    await googleFetch(tokenProvider, url, { method: "DELETE" });
+}
+export async function listTasks(tokenProvider, listId = "@default", showCompleted = false) {
+    const url = `https://tasks.googleapis.com/tasks/v1/lists/${encodeURIComponent(listId)}/tasks`
+        + `?showCompleted=${showCompleted}&maxResults=100`;
+    const res = await googleFetch(tokenProvider, url);
+    const data = await res.json();
+    return data.items || [];
+}
+export async function createTask(tokenProvider, task, listId = "@default") {
+    const url = `https://tasks.googleapis.com/tasks/v1/lists/${encodeURIComponent(listId)}/tasks`;
+    const res = await googleFetch(tokenProvider, url, { method: "POST", body: JSON.stringify(task) });
+    return res.json();
+}
+export async function updateTask(tokenProvider, taskId, task, listId = "@default") {
+    const url = `https://tasks.googleapis.com/tasks/v1/lists/${encodeURIComponent(listId)}/tasks/${encodeURIComponent(taskId)}`;
+    const res = await googleFetch(tokenProvider, url, { method: "PATCH", body: JSON.stringify(task) });
+    return res.json();
+}
+export async function deleteTask(tokenProvider, taskId, listId = "@default") {
+    const url = `https://tasks.googleapis.com/tasks/v1/lists/${encodeURIComponent(listId)}/tasks/${encodeURIComponent(taskId)}`;
+    await googleFetch(tokenProvider, url, { method: "DELETE" });
+}
+// ── Contacts (People API) ──
+export async function createContact(tokenProvider, person) {
+    const url = `https://people.googleapis.com/v1/people:createContact`;
+    const res = await googleFetch(tokenProvider, url, { method: "POST", body: JSON.stringify(person) });
+    return res.json();
+}
+export async function updateContact(tokenProvider, resourceName, updatePersonFields, person) {
+    const url = `https://people.googleapis.com/v1/${resourceName}:updateContact`
+        + `?updatePersonFields=${encodeURIComponent(updatePersonFields)}`;
+    const res = await googleFetch(tokenProvider, url, { method: "PATCH", body: JSON.stringify(person) });
+    return res.json();
+}
+export async function deleteContact(tokenProvider, resourceName) {
+    const url = `https://people.googleapis.com/v1/${resourceName}:deleteContact`;
+    await googleFetch(tokenProvider, url, { method: "DELETE" });
+}
+// ── Conversion helpers ──
+export function calendarEventToLocal(ev, accountId) {
+    const allDay = !!ev.start.date && !ev.start.dateTime;
+    const startMs = allDay
+        ? Date.parse(ev.start.date)
+        : Date.parse(ev.start.dateTime);
+    const endMs = allDay
+        ? Date.parse(ev.end.date)
+        : Date.parse(ev.end.dateTime);
+    return {
+        providerId: ev.id, accountId,
+        title: ev.summary || "(no title)",
+        startMs, endMs, allDay,
+        location: ev.location || "", notes: ev.description || "",
+        etag: ev.etag || "",
+    };
+}
+export function localToCalendarEvent(local) {
+    const toIso = (ms) => new Date(ms).toISOString();
+    const toDate = (ms) => new Date(ms).toISOString().slice(0, 10);
+    return {
+        summary: local.title,
+        start: local.allDay ? { date: toDate(local.startMs) } : { dateTime: toIso(local.startMs) },
+        end: local.allDay ? { date: toDate(local.endMs) } : { dateTime: toIso(local.endMs) },
+        location: local.location || undefined,
+        description: local.notes || undefined,
+    };
+}
+export function taskToLocal(t, accountId) {
+    return {
+        providerId: t.id, accountId, title: t.title || "",
+        notes: t.notes || "",
+        dueMs: t.due ? Date.parse(t.due) : undefined,
+        completedMs: t.completed ? Date.parse(t.completed) : undefined,
+        etag: t.etag || "",
+    };
+}
+export function localToTask(local) {
+    return {
+        title: local.title,
+        notes: local.notes || undefined,
+        due: local.dueMs ? new Date(local.dueMs).toISOString() : undefined,
+        completed: local.completedMs ? new Date(local.completedMs).toISOString() : undefined,
+        status: local.completedMs ? "completed" : "needsAction",
+    };
+}
+//# sourceMappingURL=google-sync.js.map

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

@@ -39,11 +39,54 @@ export declare class MailxService {
     /** Per-account health snapshot: inactivity-timeout count, conn-cap hits,
      *  last failed IMAP command. Drives the diagnostics ⚠ badge in the UI. */
     getDiagnostics(): any;
-    /** Return the account marked `primary: true` in accounts.jsonc, or the
-     *  first account if none. Used by Calendar / Tasks / Contacts to pick
-     *  which Google account's data to show. Single-flag for now;
-     *  per-feature flags + multi-calendar comingling deferred. */
-    getPrimaryAccount(): any;
+    /** Return the account that supplies `feature` data (calendar / tasks /
+     *  contacts). Resolution order:
+     *    1. Any account with `primary<Feature>: true`   (per-feature override)
+     *    2. Any account with `primary: true`            (catch-all default)
+     *    3. First account                               (fallback)
+     *  Called without `feature` it returns the catch-all primary — same
+     *  semantics as the original single-flag version for back-compat. */
+    getPrimaryAccount(feature?: string): any;
+    private primaryTokenProvider;
+    /** Return cal events visible in [fromMs..toMs), refreshing from Google
+     *  in the background if enough time has passed. Caller displays local
+     *  results immediately; events updated from Google emit an event. */
+    getCalendarEvents(fromMs: number, toMs: number): Promise<any[]>;
+    private refreshCalendarEvents;
+    createCalendarEventLocal(ev: {
+        title: string;
+        startMs: number;
+        endMs: number;
+        allDay?: boolean;
+        location?: string;
+        notes?: string;
+    }): Promise<string>;
+    updateCalendarEventLocal(uuid: string, patch: {
+        title?: string;
+        startMs?: number;
+        endMs?: number;
+        allDay?: boolean;
+        location?: string;
+        notes?: string;
+    }): Promise<void>;
+    deleteCalendarEventLocal(uuid: string): Promise<void>;
+    getTasks(includeCompleted?: boolean): Promise<any[]>;
+    private refreshTasks;
+    createTaskLocal(t: {
+        title: string;
+        notes?: string;
+        dueMs?: number;
+    }): Promise<string>;
+    updateTaskLocal(uuid: string, patch: {
+        title?: string;
+        notes?: string;
+        dueMs?: number;
+        completedMs?: number;
+    }): Promise<void>;
+    deleteTaskLocal(uuid: string): Promise<void>;
+    /** Drain the store_sync queue — calendar / tasks / contacts push-to-server.
+     *  Called on every local edit, and on a periodic tick from the outbox worker. */
+    drainStoreSync(): Promise<void>;
     /** List queued outgoing messages with parsed envelope headers so the UI
      *  can render a pink-row "pending" view before IMAP APPEND succeeds. */
     listQueuedOutgoing(): any[];
@@ -92,11 +135,13 @@ export declare class MailxService {
     addContact(name: string, email: string): boolean;
     /** Address-book listing — paginated, filterable. */
     listContacts(query: string, page?: number, pageSize?: number): any;
-    /** Upsert a contact from the address book UI (edit name). */
+    /** Upsert a contact from the address book UI (edit name). Two-way cache:
+     *  commits locally, queues a Google People push. */
     upsertContact(name: string, email: string): {
         ok: true;
     };
-    /** Delete a contact from the address book. */
+    /** Delete a contact from the address book. Also pushes the deletion to
+     *  Google People if the contact had a resourceName (i.e. was synced). */
     deleteContact(email: string): {
         ok: true;
     };

package/packages/mailx-service/index.js

@@ -8,6 +8,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+import * as gsync from "./google-sync.js";
 import { loadSettings, saveSettings, loadAccounts, loadAccountsAsync, saveAccounts, initCloudConfig, loadAllowlist, saveAllowlist, loadAutocomplete, saveAutocomplete, getStorageInfo, getConfigDir } from "@bobfrankston/mailx-settings";
 import { sanitizeHtml, encodeQuotedPrintable } from "@bobfrankston/mailx-types";
 import { simpleParser } from "mailparser";
@@ -102,7 +103,14 @@ export class MailxService {
         for (const cfg of cfgs) {
             const a = dbAccounts.find(d => d.id === cfg.id);
             if (a)
-                ordered.push({ ...a, label: cfg.label, defaultSend: cfg.defaultSend || false, primary: !!cfg.primary, identityDomains: cfg.identityDomains || [] });
+                ordered.push({
+                    ...a, label: cfg.label, defaultSend: cfg.defaultSend || false,
+                    primary: !!cfg.primary,
+                    primaryCalendar: !!cfg.primaryCalendar,
+                    primaryTasks: !!cfg.primaryTasks,
+                    primaryContacts: !!cfg.primaryContacts,
+                    identityDomains: cfg.identityDomains || [],
+                });
         }
         // Append any DB accounts not in settings
         for (const a of dbAccounts) {
@@ -421,14 +429,215 @@ export class MailxService {
     getDiagnostics() {
         return this.imapManager.getDiagnosticsSnapshot();
     }
-    /** Return the account marked `primary: true` in accounts.jsonc, or the
-     *  first account if none. Used by Calendar / Tasks / Contacts to pick
-     *  which Google account's data to show. Single-flag for now;
-     *  per-feature flags + multi-calendar comingling deferred. */
-    getPrimaryAccount() {
+    /** Return the account that supplies `feature` data (calendar / tasks /
+     *  contacts). Resolution order:
+     *    1. Any account with `primary<Feature>: true`   (per-feature override)
+     *    2. Any account with `primary: true`            (catch-all default)
+     *    3. First account                               (fallback)
+     *  Called without `feature` it returns the catch-all primary — same
+     *  semantics as the original single-flag version for back-compat. */
+    getPrimaryAccount(feature) {
         const all = this.getAccounts();
+        if (feature) {
+            const perFeatureKey = "primary" + feature.charAt(0).toUpperCase() + feature.slice(1);
+            const perFeature = all.find((a) => a[perFeatureKey]);
+            if (perFeature)
+                return perFeature;
+        }
         return all.find((a) => a.primary) || all[0] || null;
     }
+    // ── Calendar / Tasks / Contacts: two-way cache (2026-04-23) ──
+    async primaryTokenProvider(feature) {
+        const acct = this.getPrimaryAccount(feature);
+        if (!acct)
+            throw new Error(`No primary account for ${feature}`);
+        return async () => {
+            const tok = await this.imapManager.getOAuthToken(acct.id);
+            if (!tok)
+                throw new Error(`No OAuth token for ${acct.id}`);
+            return tok;
+        };
+    }
+    /** Return cal events visible in [fromMs..toMs), refreshing from Google
+     *  in the background if enough time has passed. Caller displays local
+     *  results immediately; events updated from Google emit an event. */
+    async getCalendarEvents(fromMs, toMs) {
+        const acct = this.getPrimaryAccount("calendar");
+        if (!acct)
+            return [];
+        // Fire-and-forget refresh; don't block the read on it.
+        this.refreshCalendarEvents(acct.id, fromMs, toMs).catch(e => console.error(`[calendar] refresh failed: ${e.message}`));
+        return this.db.getCalendarEvents(acct.id, fromMs, toMs);
+    }
+    async refreshCalendarEvents(accountId, fromMs, toMs) {
+        const tp = await this.primaryTokenProvider("calendar");
+        const events = await gsync.listCalendarEvents(tp, fromMs, toMs);
+        for (const ev of events) {
+            const local = gsync.calendarEventToLocal(ev, accountId);
+            // Use provider_id as the uuid basis — existing local row with matching
+            // providerId stays; if we invent a new uuid every time we'd create
+            // duplicates on every poll. Look up by provider_id first.
+            const existing = this.db.getCalendarEvents(accountId, fromMs, toMs).find(e => e.providerId === ev.id);
+            this.db.upsertCalendarEvent({
+                uuid: existing?.uuid,
+                ...local,
+            });
+        }
+    }
+    async createCalendarEventLocal(ev) {
+        const acct = this.getPrimaryAccount("calendar");
+        if (!acct)
+            throw new Error("No primary calendar account");
+        const uuid = this.db.upsertCalendarEvent({
+            accountId: acct.id, ...ev, dirty: true,
+        });
+        this.db.enqueueStoreSync("calendar", "create", acct.id, uuid, ev);
+        this.drainStoreSync().catch(() => { });
+        return uuid;
+    }
+    async updateCalendarEventLocal(uuid, patch) {
+        // Merge with existing row before writing so partial patches don't
+        // null-out unspecified fields in upsert.
+        const existing = this.db.getCalendarEvents("", 0, Number.MAX_SAFE_INTEGER).find(e => e.uuid === uuid);
+        if (!existing)
+            throw new Error(`No calendar event ${uuid}`);
+        this.db.upsertCalendarEvent({
+            uuid, accountId: existing.accountId, providerId: existing.providerId,
+            calendarId: existing.calendarId, dirty: true,
+            title: patch.title ?? existing.title,
+            startMs: patch.startMs ?? existing.startMs,
+            endMs: patch.endMs ?? existing.endMs,
+            allDay: patch.allDay ?? existing.allDay,
+            location: patch.location ?? existing.location,
+            notes: patch.notes ?? existing.notes,
+        });
+        this.db.enqueueStoreSync("calendar", "update", existing.accountId, uuid, { providerId: existing.providerId, patch });
+        this.drainStoreSync().catch(() => { });
+    }
+    async deleteCalendarEventLocal(uuid) {
+        const ev = this.db.getCalendarEvents("", 0, Number.MAX_SAFE_INTEGER).find(e => e.uuid === uuid);
+        if (!ev)
+            return;
+        this.db.deleteCalendarEventLocal(uuid);
+        if (ev.providerId) {
+            this.db.enqueueStoreSync("calendar", "delete", ev.accountId, uuid, { providerId: ev.providerId });
+            this.drainStoreSync().catch(() => { });
+        }
+        else {
+            // Never made it to the server; just purge locally.
+            this.db.purgeCalendarEvent(uuid);
+        }
+    }
+    async getTasks(includeCompleted = false) {
+        const acct = this.getPrimaryAccount("tasks");
+        if (!acct)
+            return [];
+        this.refreshTasks(acct.id, includeCompleted).catch(e => console.error(`[tasks] refresh failed: ${e.message}`));
+        return this.db.getTasks(acct.id, includeCompleted);
+    }
+    async refreshTasks(accountId, includeCompleted) {
+        const tp = await this.primaryTokenProvider("tasks");
+        const tasks = await gsync.listTasks(tp, "@default", includeCompleted);
+        const existing = this.db.getTasks(accountId, true);
+        for (const t of tasks) {
+            const local = gsync.taskToLocal(t, accountId);
+            const prior = existing.find(e => e.providerId === t.id);
+            this.db.upsertTask({ uuid: prior?.uuid, ...local });
+        }
+    }
+    async createTaskLocal(t) {
+        const acct = this.getPrimaryAccount("tasks");
+        if (!acct)
+            throw new Error("No primary tasks account");
+        const uuid = this.db.upsertTask({ accountId: acct.id, ...t, dirty: true });
+        this.db.enqueueStoreSync("tasks", "create", acct.id, uuid, t);
+        this.drainStoreSync().catch(() => { });
+        return uuid;
+    }
+    async updateTaskLocal(uuid, patch) {
+        const existing = this.db.getTasks("", true).find(t => t.uuid === uuid);
+        if (!existing)
+            throw new Error(`No task ${uuid}`);
+        this.db.upsertTask({
+            uuid, accountId: existing.accountId, providerId: existing.providerId,
+            listId: existing.listId, dirty: true,
+            title: patch.title ?? existing.title,
+            notes: patch.notes ?? existing.notes,
+            dueMs: patch.dueMs ?? existing.dueMs,
+            completedMs: patch.completedMs ?? existing.completedMs,
+        });
+        this.db.enqueueStoreSync("tasks", "update", existing.accountId, uuid, { providerId: existing.providerId, patch });
+        this.drainStoreSync().catch(() => { });
+    }
+    async deleteTaskLocal(uuid) {
+        const task = this.db.getTasks("", true).find(t => t.uuid === uuid);
+        if (!task)
+            return;
+        this.db.deleteTaskLocal(uuid);
+        if (task.providerId) {
+            this.db.enqueueStoreSync("tasks", "delete", task.accountId, uuid, { providerId: task.providerId });
+            this.drainStoreSync().catch(() => { });
+        }
+        else {
+            this.db.purgeTask(uuid);
+        }
+    }
+    /** Drain the store_sync queue — calendar / tasks / contacts push-to-server.
+     *  Called on every local edit, and on a periodic tick from the outbox worker. */
+    async drainStoreSync() {
+        const queue = this.db.getStoreSyncQueue();
+        for (const entry of queue) {
+            try {
+                if (entry.kind === "calendar") {
+                    const tp = await this.primaryTokenProvider("calendar");
+                    if (entry.op === "create") {
+                        const created = await gsync.createCalendarEvent(tp, gsync.localToCalendarEvent(entry.payload));
+                        this.db.markCalendarEventClean(entry.targetUuid, created.id, created.etag || "");
+                    }
+                    else if (entry.op === "update") {
+                        const updated = await gsync.updateCalendarEvent(tp, entry.payload.providerId, gsync.localToCalendarEvent(entry.payload.patch));
+                        this.db.markCalendarEventClean(entry.targetUuid, updated.id, updated.etag || "");
+                    }
+                    else if (entry.op === "delete") {
+                        await gsync.deleteCalendarEvent(tp, entry.payload.providerId);
+                        this.db.purgeCalendarEvent(entry.targetUuid);
+                    }
+                }
+                else if (entry.kind === "tasks") {
+                    const tp = await this.primaryTokenProvider("tasks");
+                    if (entry.op === "create") {
+                        const created = await gsync.createTask(tp, gsync.localToTask(entry.payload));
+                        this.db.markTaskClean(entry.targetUuid, created.id, created.etag || "");
+                    }
+                    else if (entry.op === "update") {
+                        const updated = await gsync.updateTask(tp, entry.payload.providerId, gsync.localToTask(entry.payload.patch));
+                        this.db.markTaskClean(entry.targetUuid, updated.id, updated.etag || "");
+                    }
+                    else if (entry.op === "delete") {
+                        await gsync.deleteTask(tp, entry.payload.providerId);
+                        this.db.purgeTask(entry.targetUuid);
+                    }
+                }
+                else if (entry.kind === "contacts") {
+                    const tp = await this.primaryTokenProvider("contacts");
+                    if (entry.op === "create") {
+                        await gsync.createContact(tp, entry.payload);
+                    }
+                    else if (entry.op === "update") {
+                        await gsync.updateContact(tp, entry.payload.resourceName, entry.payload.updatePersonFields || "names,emailAddresses", entry.payload.person);
+                    }
+                    else if (entry.op === "delete") {
+                        await gsync.deleteContact(tp, entry.payload.resourceName);
+                    }
+                }
+                this.db.completeStoreSync(entry.id);
+            }
+            catch (e) {
+                console.error(`[store_sync] ${entry.kind}/${entry.op}/${entry.targetUuid} failed: ${e.message}`);
+                this.db.failStoreSync(entry.id, e.message || String(e));
+            }
+        }
+    }
     /** List queued outgoing messages with parsed envelope headers so the UI
      *  can render a pink-row "pending" view before IMAP APPEND succeeds. */
     listQueuedOutgoing() {
@@ -969,14 +1178,36 @@ export class MailxService {
     listContacts(query, page = 1, pageSize = 100) {
         return this.db.listContacts(query || "", page, pageSize);
     }
-    /** Upsert a contact from the address book UI (edit name). */
+    /** Upsert a contact from the address book UI (edit name). Two-way cache:
+     *  commits locally, queues a Google People push. */
     upsertContact(name, email) {
         this.db.upsertContact(name || "", email);
+        const acct = this.getPrimaryAccount("contacts");
+        if (acct) {
+            // Google People `createContact` — resourceName is assigned by the
+            // server and stored back as google_id once the drainer gets an ACK.
+            this.db.enqueueStoreSync("contacts", "create", acct.id, email, {
+                names: [{ givenName: name || "" }],
+                emailAddresses: [{ value: email }],
+            });
+            this.drainStoreSync().catch(() => { });
+        }
         return { ok: true };
     }
-    /** Delete a contact from the address book. */
+    /** Delete a contact from the address book. Also pushes the deletion to
+     *  Google People if the contact had a resourceName (i.e. was synced). */
     deleteContact(email) {
-        this.db.deleteContact(email);
+        const acct = this.getPrimaryAccount("contacts");
+        // Look up the resourceName before deleting so we can push to Google.
+        const contacts = this.db.listContacts("", 1, 10_000);
+        const contact = (contacts.items || []).find((c) => c.email === email);
+        this.db.deleteContactLocal(email);
+        if (acct && contact?.googleId) {
+            this.db.enqueueStoreSync("contacts", "delete", acct.id, email, {
+                resourceName: contact.googleId,
+            });
+            this.drainStoreSync().catch(() => { });
+        }
         return { ok: true };
     }
     /** Open a configured local path in the OS file explorer. Whitelisted to

package/packages/mailx-service/jsonrpc.js

@@ -97,7 +97,32 @@ async function dispatchAction(svc, action, p) {
         case "getDiagnostics":
             return svc.getDiagnostics();
         case "getPrimaryAccount":
-            return svc.getPrimaryAccount();
+            return svc.getPrimaryAccount(p?.feature);
+        // Calendar / Tasks: two-way cache. Reads return local immediately
+        // and kick a background refresh that emits updates when done.
+        case "getCalendarEvents":
+            return await svc.getCalendarEvents(p.fromMs, p.toMs);
+        case "createCalendarEvent":
+            return { uuid: await svc.createCalendarEventLocal(p) };
+        case "updateCalendarEvent":
+            await svc.updateCalendarEventLocal(p.uuid, p.patch);
+            return { ok: true };
+        case "deleteCalendarEvent":
+            await svc.deleteCalendarEventLocal(p.uuid);
+            return { ok: true };
+        case "getTasks":
+            return await svc.getTasks(!!p.includeCompleted);
+        case "createTask":
+            return { uuid: await svc.createTaskLocal(p) };
+        case "updateTask":
+            await svc.updateTaskLocal(p.uuid, p.patch);
+            return { ok: true };
+        case "deleteTask":
+            await svc.deleteTaskLocal(p.uuid);
+            return { ok: true };
+        case "drainStoreSync":
+            await svc.drainStoreSync();
+            return { ok: true };
         case "getOutboxStatus":
             return svc.getOutboxStatus();
         case "listQueuedOutgoing":

package/packages/mailx-settings/index.js

@@ -377,6 +377,9 @@ function normalizeAccount(acct, globalName) {
         },
         enabled: acct.enabled ?? true,
         primary: acct.primary,
+        primaryCalendar: acct.primaryCalendar,
+        primaryTasks: acct.primaryTasks,
+        primaryContacts: acct.primaryContacts,
         defaultSend: acct.defaultSend,
         syncContacts: acct.syncContacts ?? (provider?.imap.auth === "oauth2"),
         relayDomains: acct.relayDomains,

package/packages/mailx-store/db.d.ts

@@ -7,6 +7,9 @@ import type { MessageEnvelope, Folder, EmailAddress, PagedResult, MessageQuery }
 export declare class MailxDB {
     private db;
     constructor(dbDir: string);
+    /** Fail loud + early if expected columns are missing. Cheap (PRAGMA only
+     *  runs at startup). The user-facing message names the recovery command. */
+    private verifySchema;
     /** One-time: assign UUIDs to every `messages` row that's missing one.
      *  Runs on every startup but the WHERE clause makes it a no-op after the
      *  first pass. */
@@ -30,6 +33,50 @@ export declare class MailxDB {
      *  growing unboundedly. Default retention is 30 days; caller passes the
      *  actual cutoff in ms since epoch. */
     pruneTombstones(olderThanMs: number): number;
+    upsertCalendarEvent(ev: {
+        uuid?: string;
+        accountId: string;
+        providerId?: string;
+        calendarId?: string;
+        title: string;
+        startMs: number;
+        endMs: number;
+        allDay?: boolean;
+        location?: string;
+        notes?: string;
+        etag?: string;
+        dirty?: boolean;
+    }): string;
+    getCalendarEvents(accountId: string, fromMs: number, toMs: number): any[];
+    getDirtyCalendarEvents(accountId: string): any[];
+    private calendarRowToObject;
+    markCalendarEventClean(uuid: string, providerId: string, etag: string): void;
+    deleteCalendarEventLocal(uuid: string): void;
+    purgeCalendarEvent(uuid: string): void;
+    upsertTask(t: {
+        uuid?: string;
+        accountId: string;
+        providerId?: string;
+        listId?: string;
+        title: string;
+        notes?: string;
+        dueMs?: number;
+        completedMs?: number;
+        etag?: string;
+        dirty?: boolean;
+    }): string;
+    getTasks(accountId: string, includeCompleted?: boolean): any[];
+    getDirtyTasks(accountId: string): any[];
+    private taskRowToObject;
+    markTaskClean(uuid: string, providerId: string, etag: string): void;
+    deleteTaskLocal(uuid: string): void;
+    purgeTask(uuid: string): void;
+    /** Local delete for the two-way cache drainer (symmetric with calendar/tasks). */
+    deleteContactLocal(email: string): void;
+    enqueueStoreSync(kind: string, op: string, accountId: string, targetUuid: string, payload: any): void;
+    getStoreSyncQueue(kind?: string, accountId?: string): any[];
+    completeStoreSync(id: number): void;
+    failStoreSync(id: number, error: string): void;
     /** Idempotently add a column to a table if it's missing. */
     private addColumnIfMissing;
     /** Compute a thread id for an incoming message. Strategy:
@@ -139,6 +186,7 @@ export declare class MailxDB {
             name: string;
             email: string;
             source: string;
+            googleId: string | null;
             useCount: number;
             lastUsed: number;
         }[];