@mulmoclaude/core 0.24.0 → 0.25.0

package/dist/google/index.cjs

@@ -1,11 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("../rolldown-runtime-D6vf50IK.cjs");
+const require_discovery = require("../discovery-BZ2ms1tE.cjs");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
 let node_fs = require("node:fs");
 let node_fs_promises = require("node:fs/promises");
 let node_crypto = require("node:crypto");
 let node_os = require("node:os");
+let _receptron_task_scheduler = require("@receptron/task-scheduler");
 let node_http = require("node:http");
 node_http = require_rolldown_runtime.__toESM(node_http, 1);
 let google_auth_library = require("google-auth-library");
@@ -611,12 +613,21 @@ var ERROR_BODY_MAX_CHARS = 300;
 var HTTP_FORBIDDEN = 403;
 var DEFAULT_LIST_MAX_RESULTS = 10;
 var MAX_LIST_RESULTS = 50;
+/** Carries the HTTP status so callers can branch on it (e.g. an expired
+*  calendar syncToken answers 410) without parsing the message. */
+var GoogleApiError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.name = "GoogleApiError";
+		this.status = status;
+	}
+};
+var isGoogleApiError = (value) => value instanceof GoogleApiError;
 /** 403 usually means the API is not enabled for the user's Cloud project —
 *  name the API so the agent's recovery guidance can be specific. */
 var googleApiError = (apiLabel, status, body) => {
-	const hint = status === HTTP_FORBIDDEN ? ` (is the ${apiLabel} enabled for the Cloud project?)` : "";
-	const detail = body ? ` — ${truncate(body, ERROR_BODY_MAX_CHARS)}` : "";
-	return /* @__PURE__ */ new Error(`${apiLabel}: HTTP ${status}${hint}${detail}`);
+	return new GoogleApiError(status, `${apiLabel}: HTTP ${status}${status === HTTP_FORBIDDEN ? ` (is the ${apiLabel} enabled for the Cloud project?)` : ""}${body ? ` — ${truncate(body, ERROR_BODY_MAX_CHARS)}` : ""}`);
 };
 async function googleRequest(apiLabel, accessToken, url, init = {}) {
 	const { contentType = "application/json", expectText = false, ...rest } = init;
@@ -649,7 +660,16 @@ var CALENDAR_API_LABEL = "Google Calendar API";
 var DEFAULT_CALENDAR_ID = "primary";
 var CALENDAR_LIST_PAGE_SIZE = 250;
 var MAX_CALENDAR_LIST_PAGES = 40;
-var eventsUrl = (calendarId) => `${CALENDAR_BASE_URL}/calendars/${encodeURIComponent(calendarId || DEFAULT_CALENDAR_ID)}/events`;
+var EVENT_SYNC_PAGE_SIZE = 2500;
+var MAX_EVENT_SYNC_PAGES = 200;
+var HTTP_GONE = 410;
+/** Resolve a declared calendarId to the one the API and the sync-token store
+*  both address. `||` (not `??`) so an empty string also falls back instead of
+*  building a malformed `/calendars//events` URL. Single-sourced because an
+*  omitted id and an explicit "primary" MUST agree everywhere — grouping them
+*  apart while they share a sync token silently loses events (#2184). */
+var canonicalCalendarId = (calendarId) => calendarId || DEFAULT_CALENDAR_ID;
+var eventsUrl = (calendarId) => `${CALENDAR_BASE_URL}/calendars/${encodeURIComponent(canonicalCalendarId(calendarId))}/events`;
 var eventTime = (value) => {
 	if (!isRecord(value)) return "";
 	if (typeof value.dateTime === "string") return value.dateTime;
@@ -716,6 +736,54 @@ async function listCalendarEvents(accessToken, input = {}) {
 	});
 	return itemsOf(await googleRequest(CALENDAR_API_LABEL, accessToken, `${eventsUrl(input.calendarId)}?${params.toString()}`)).map(toEventSummary);
 }
+var GONE = Symbol("calendar-sync-gone");
+async function fetchSyncPage(accessToken, calendarId, params) {
+	try {
+		return await googleRequest(CALENDAR_API_LABEL, accessToken, `${eventsUrl(calendarId)}?${params.toString()}`);
+	} catch (err) {
+		if (isGoogleApiError(err) && err.status === HTTP_GONE) return GONE;
+		throw err;
+	}
+}
+/** Incremental sync over the events of one calendar (#2095).
+*
+*  Deliberately separate from `listCalendarEvents`: Google forbids combining
+*  `syncToken` with `timeMin` / `timeMax` / `updatedMin` / `orderBy` / `q`,
+*  and that function always sends `timeMin` + `orderBy`. So this one sends
+*  neither — a sync covers the WHOLE calendar and the caller sorts / windows
+*  client-side. `showDeleted` must stay true or deletions would be invisible.
+*
+*  `nextSyncToken` is only present on the LAST page, so every page must be
+*  walked before the token is worth storing. */
+async function syncCalendarEvents(accessToken, input = {}) {
+	const events = [];
+	let pageToken;
+	let nextSyncToken;
+	for (let page = 0; page < MAX_EVENT_SYNC_PAGES; page += 1) {
+		const params = new URLSearchParams({
+			singleEvents: "true",
+			showDeleted: "true",
+			maxResults: String(input.maxResults ?? EVENT_SYNC_PAGE_SIZE)
+		});
+		if (input.syncToken) params.set("syncToken", input.syncToken);
+		if (pageToken) params.set("pageToken", pageToken);
+		const payload = await fetchSyncPage(accessToken, input.calendarId, params);
+		if (payload === GONE) return {
+			events: [],
+			fullResyncRequired: true
+		};
+		const record = asRecord(payload);
+		events.push(...itemsOf(payload).map(toEventSummary));
+		nextSyncToken = stringField(record, "nextSyncToken") || void 0;
+		pageToken = stringField(record, "nextPageToken") || void 0;
+		if (!pageToken) break;
+	}
+	return {
+		events,
+		nextSyncToken,
+		fullResyncRequired: false
+	};
+}
 /** Pagination loop for CalendarList.list, extracted so it can be tested without
 *  network. Stops at the last page (no token) or the runaway page cap. */
 async function collectCalendarPages(fetchPage, maxPages = MAX_CALENDAR_LIST_PAGES) {
@@ -753,6 +821,214 @@ async function getCalendarColors(accessToken) {
 	};
 }
 //#endregion
+//#region src/google/calendarSyncStore.ts
+var SYNC_STATE_MODE = 384;
+/** `<workspace>/data/calendar/.sync-state.json` */
+function calendarSyncStatePath(workspaceRoot) {
+	return node_path.default.join(workspaceRoot ?? require_discovery.getWorkspaceRoot(), "data", "calendar", ".sync-state.json");
+}
+var calendarKey = canonicalCalendarId;
+async function readState(workspaceRoot) {
+	const stored = await readJsonOrNull(calendarSyncStatePath(workspaceRoot));
+	return stored?.tokens ? stored : { tokens: {} };
+}
+var writeQueue = { tail: Promise.resolve() };
+async function updateState(mutate, workspaceRoot) {
+	const run = writeQueue.tail.then(async () => {
+		const state = await readState(workspaceRoot);
+		await writeJsonAtomicWithMode(calendarSyncStatePath(workspaceRoot), { tokens: mutate(state.tokens) }, SYNC_STATE_MODE);
+	});
+	writeQueue.tail = run.catch(() => void 0);
+	return await run;
+}
+async function loadCalendarSyncToken(calendarId, workspaceRoot) {
+	return (await readState(workspaceRoot)).tokens[calendarKey(calendarId)] ?? null;
+}
+async function saveCalendarSyncToken(calendarId, syncToken, workspaceRoot) {
+	const stored = calendarKey(calendarId);
+	await updateState((tokens) => ({
+		...tokens,
+		[stored]: syncToken
+	}), workspaceRoot);
+}
+/** Drop one calendar's token — used when Google answers 410, so the next run
+*  starts a clean full sync. */
+async function clearCalendarSyncToken(calendarId, workspaceRoot) {
+	const dropped = calendarKey(calendarId);
+	await updateState((tokens) => Object.fromEntries(Object.entries(tokens).filter(([key]) => key !== dropped)), workspaceRoot);
+}
+//#endregion
+//#region src/google/collectionSync.ts
+var GOOGLE_CALENDAR_SYNC_TASK_ID = "system:google-calendar-sync";
+var DEFAULT_SYNC_INTERVAL_MS = 3600 * 1e3;
+var CANCELLED_STATUS = "cancelled";
+/** Project one Google event onto the collection's own field names. The
+*  primary field always takes the event id — upsert-by-id is what keeps the
+*  sync idempotent, so it is deliberately not remappable. */
+function toCollectionRecord(event, map, primaryKey) {
+	const mapped = Object.entries(map).map(([field, source]) => [field, event[source]]);
+	return {
+		...Object.fromEntries(mapped),
+		[primaryKey]: event.id
+	};
+}
+function classifyWrite(eventId, kind) {
+	if (kind === "ok") return { kind: "written" };
+	if (kind === "invalid-id") return {
+		kind: "unwritable",
+		message: `write ${eventId}: invalid-id`
+	};
+	return {
+		kind: "error",
+		message: `write ${eventId}: ${kind}`
+	};
+}
+function classifyDelete(eventId, kind) {
+	if (kind === "ok") return { kind: "removed" };
+	if (kind === "not-found") return { kind: "skipped" };
+	if (kind === "invalid-id") return {
+		kind: "unwritable",
+		message: `delete ${eventId}: invalid-id`
+	};
+	return {
+		kind: "error",
+		message: `delete ${eventId}: ${kind}`
+	};
+}
+async function applyEvent(collection, event, workspaceRoot) {
+	const { slug, dataDir, schema } = collection;
+	try {
+		if (event.status === CANCELLED_STATUS) {
+			const deleted = await require_discovery.deleteItem(dataDir, event.id, {
+				workspaceRoot,
+				slug
+			});
+			return classifyDelete(event.id, deleted.kind);
+		}
+		const record = toCollectionRecord(event, schema.googleCalendar?.map ?? {}, schema.primaryKey);
+		const written = await require_discovery.writeItem(dataDir, event.id, record, {
+			refuseOverwrite: false,
+			workspaceRoot,
+			slug
+		});
+		return classifyWrite(event.id, written.kind);
+	} catch (error) {
+		return {
+			kind: "error",
+			message: `apply ${event.id}: ${String(error)}`
+		};
+	}
+}
+async function restartFullSync(accessToken, calendarId, workspaceRoot) {
+	await clearCalendarSyncToken(calendarId, workspaceRoot);
+	return await syncCalendarEvents(accessToken, { calendarId });
+}
+/** Sync ONE calendar and fan its events out to every collection bound to it.
+*
+*  The fan-out is not an optimisation, it is correctness: the sync token is
+*  keyed by `calendarId`, so syncing collection-by-collection would let the
+*  first collection advance the shared token and leave every later collection
+*  on the same calendar reading an already-consumed window — silently missing
+*  those events forever. Fetch once, apply to all, then advance the token.
+*  (Codex + CodeRabbit review on #2184.) */
+async function syncCalendarGroup(calendarId, collections, workspaceRoot) {
+	const accessToken = await getGoogleAccessToken();
+	const first = await syncCalendarEvents(accessToken, {
+		calendarId,
+		syncToken: await loadCalendarSyncToken(calendarId, workspaceRoot) ?? void 0
+	});
+	const result = first.fullResyncRequired ? await restartFullSync(accessToken, calendarId, workspaceRoot) : first;
+	const results = [];
+	for (const collection of collections) results.push(await applyEventsToCollection(collection, result.events, workspaceRoot));
+	const unwritable = results.flatMap((entry) => entry.unwritable);
+	if (unwritable.length > 0) log.warn("google", "skipping calendar events that can never be stored", {
+		calendarId,
+		unwritable
+	});
+	const failed = results.flatMap((entry) => entry.errors);
+	if (result.nextSyncToken && failed.length === 0) await saveCalendarSyncToken(calendarId, result.nextSyncToken, workspaceRoot);
+	else if (failed.length > 0) log.warn("google", "holding back calendar sync token after failed writes", {
+		calendarId,
+		failed: failed.length
+	});
+	return results;
+}
+async function applyEventsToCollection(collection, events, workspaceRoot) {
+	const outcomes = [];
+	for (const event of events) outcomes.push(await applyEvent(collection, event, workspaceRoot));
+	return {
+		slug: collection.slug,
+		written: outcomes.filter((outcome) => outcome.kind === "written").length,
+		removed: outcomes.filter((outcome) => outcome.kind === "removed").length,
+		unwritable: outcomes.flatMap((outcome) => outcome.kind === "unwritable" ? [outcome.message] : []),
+		errors: outcomes.flatMap((outcome) => outcome.kind === "error" ? [outcome.message] : [])
+	};
+}
+/** A refresh token is what lets the scheduler run unattended; without one
+*  there is nothing to sync with. */
+async function isGoogleLinked() {
+	return Boolean((await loadGoogleTokens())?.refresh_token);
+}
+/** Group the declaring collections by the calendar they read, so each calendar
+*  is fetched exactly once.
+*
+*  Keyed by the CANONICAL id, not the declared one: an omitted `calendarId` and
+*  an explicit `"primary"` address the same calendar and therefore share one
+*  sync token, so grouping them apart would let one group advance the token out
+*  from under the other — the very loss this grouping exists to prevent
+*  (Codex review #2184). */
+function groupByCalendar(collections) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const collection of collections) {
+		const key = canonicalCalendarId(collection.schema.googleCalendar?.calendarId);
+		groups.set(key, [...groups.get(key) ?? [], collection]);
+	}
+	return groups;
+}
+/** Sync every collection that declares `googleCalendar`. Failures are isolated
+*  per calendar — one unreachable calendar (or a revoked grant) must not stop
+*  the others. */
+async function syncDueCalendarCollections(workspaceRoot) {
+	const declaring = (await require_discovery.discoverCollections({ workspaceRoot })).filter((collection) => collection.schema.googleCalendar);
+	if (declaring.length === 0) return [];
+	if (!await isGoogleLinked()) {
+		log.info("google", "skipping calendar sync — no Google account linked on this host", { collections: declaring.length });
+		return [];
+	}
+	const results = [];
+	for (const [calendarId, collections] of groupByCalendar(declaring)) try {
+		results.push(...await syncCalendarGroup(calendarId, collections, workspaceRoot));
+	} catch (error) {
+		log.warn("google", "calendar sync failed", {
+			calendarId,
+			error: String(error)
+		});
+		results.push(...collections.map((collection) => ({
+			slug: collection.slug,
+			written: 0,
+			removed: 0,
+			unwritable: [],
+			errors: [String(error)]
+		})));
+	}
+	return results;
+}
+/** Scheduler registration, shaped like `feedRefreshTaskDef` so hosts wire it
+*  with a single line. */
+function googleCalendarSyncTaskDef(opts) {
+	return {
+		id: GOOGLE_CALENDAR_SYNC_TASK_ID,
+		name: "Google Calendar sync",
+		description: "Pulls changed Google Calendar events into any collection declaring `googleCalendar`, without invoking the LLM.",
+		schedule: {
+			type: _receptron_task_scheduler.SCHEDULE_TYPES.interval,
+			intervalMs: opts?.intervalMs ?? DEFAULT_SYNC_INTERVAL_MS
+		},
+		missedRunPolicy: _receptron_task_scheduler.MISSED_RUN_POLICIES.runOnce,
+		run: () => syncDueCalendarCollections(opts?.workspaceRoot ?? require_discovery.getWorkspaceRoot()).then(() => {})
+	};
+}
+//#endregion
 //#region src/google/tasks.ts
 var TASKS_BASE_URL = "https://tasks.googleapis.com/tasks/v1";
 var TASKS_API_LABEL = "Google Tasks API";
@@ -905,9 +1181,11 @@ exports.DEFAULT_LIST_MAX_RESULTS = DEFAULT_LIST_MAX_RESULTS;
 exports.GOOGLE_AUTH_CANCELLED = GOOGLE_AUTH_CANCELLED;
 exports.GOOGLE_CALENDARLIST_SCOPE = GOOGLE_CALENDARLIST_SCOPE;
 exports.GOOGLE_CALENDAR_SCOPE = GOOGLE_CALENDAR_SCOPE;
+exports.GOOGLE_CALENDAR_SYNC_TASK_ID = GOOGLE_CALENDAR_SYNC_TASK_ID;
 exports.GOOGLE_DRIVE_FILE_SCOPE = GOOGLE_DRIVE_FILE_SCOPE;
 exports.GOOGLE_SCOPES = GOOGLE_SCOPES;
 exports.GOOGLE_TASKS_SCOPE = GOOGLE_TASKS_SCOPE;
+exports.GoogleApiError = GoogleApiError;
 exports.MAX_LIST_RESULTS = MAX_LIST_RESULTS;
 exports.assertSafeMimeType = assertSafeMimeType;
 exports.authorizeGoogle = authorizeGoogle;
@@ -917,6 +1195,11 @@ exports.brokerRefresh = brokerRefresh;
 exports.brokerStart = brokerStart;
 exports.buildMultipartBody = buildMultipartBody;
 exports.calendarApiError = calendarApiError;
+exports.calendarSyncStatePath = calendarSyncStatePath;
+exports.canonicalCalendarId = canonicalCalendarId;
+exports.classifyDelete = classifyDelete;
+exports.classifyWrite = classifyWrite;
+exports.clearCalendarSyncToken = clearCalendarSyncToken;
 exports.clientSecretPresence = clientSecretPresence;
 exports.collectCalendarPages = collectCalendarPages;
 exports.commitLinkedTokens = commitLinkedTokens;
@@ -934,9 +1217,12 @@ exports.getCalendarColors = getCalendarColors;
 exports.getGoogleAccessToken = getGoogleAccessToken;
 exports.googleApiError = googleApiError;
 exports.googleAuthFlow = googleAuthFlow;
+exports.googleCalendarSyncTaskDef = googleCalendarSyncTaskDef;
 exports.googleConfigDir = googleConfigDir;
 exports.googleSecretsDir = googleSecretsDir;
 exports.googleTokenPath = googleTokenPath;
+exports.groupByCalendar = groupByCalendar;
+exports.isGoogleApiError = isGoogleApiError;
 exports.isIsoDateTimeWithOffset = isIsoDateTimeWithOffset;
 exports.isTextMimeType = isTextMimeType;
 exports.legacyGoogleTokenPath = legacyGoogleTokenPath;
@@ -945,13 +1231,19 @@ exports.listCalendars = listCalendars;
 exports.listDriveFiles = listDriveFiles;
 exports.listTaskLists = listTaskLists;
 exports.listTasks = listTasks;
+exports.loadCalendarSyncToken = loadCalendarSyncToken;
 exports.loadClientSecret = loadClientSecret;
 exports.loadGoogleTokens = loadGoogleTokens;
 exports.mergeGoogleTokens = mergeGoogleTokens;
 exports.pickBoundary = pickBoundary;
 exports.readDriveFile = readDriveFile;
+exports.saveCalendarSyncToken = saveCalendarSyncToken;
 exports.saveGoogleTokens = saveGoogleTokens;
+exports.syncCalendarEvents = syncCalendarEvents;
+exports.syncCalendarGroup = syncCalendarGroup;
+exports.syncDueCalendarCollections = syncDueCalendarCollections;
 exports.toCalendarSummary = toCalendarSummary;
+exports.toCollectionRecord = toCollectionRecord;
 exports.toDriveFileSummary = toDriveFileSummary;
 exports.toEventSummary = toEventSummary;
 exports.toTaskListSummary = toTaskListSummary;