@mulmoclaude/core 1.2.1 → 1.4.0

package/dist/google/index.d.ts

@@ -7,9 +7,9 @@ export { brokerBaseUrl, brokerExchange, brokerRefresh, brokerStart, type BrokerS
 export { authorizeGoogle, commitLinkedTokens, getGoogleAccessToken, unlinkGoogle, waitForAuthCode, GOOGLE_AUTH_CANCELLED, GOOGLE_CALENDAR_SCOPE, GOOGLE_CALENDARLIST_SCOPE, GOOGLE_TASKS_SCOPE, GOOGLE_DRIVE_FILE_SCOPE, GOOGLE_SCOPES, type AuthorizeGoogleOptions, type RevokeFetch, } from './auth.js';
 export { createGoogleAuthFlow, googleAuthFlow, type GoogleAuthFlow, type GoogleAuthFlowStatus } from './authFlow.js';
 export { googleApiError, isGoogleApiError, GoogleApiError, DEFAULT_LIST_MAX_RESULTS, MAX_LIST_RESULTS } from './apiClient.js';
-export { calendarApiError, collectCalendarPages, createCalendarEvent, getCalendarColors, canonicalCalendarId, listCalendarEvents, listCalendars, syncCalendarEvents, toCalendarSummary, toEventSummary, type CalendarColorEntry, type CalendarColors, type CalendarEventInput, type CalendarEventSummary, type CalendarListPage, type CalendarSummary, type CalendarSyncResult, type ListEventsInput, type SyncEventsInput, } from './calendar.js';
+export { buildEventPatch, calendarApiError, collectCalendarPages, createCalendarEvent, deleteCalendarEvent, getCalendarColors, canonicalCalendarId, listCalendarEvents, listCalendars, syncCalendarEvents, toCalendarSummary, toEventSummary, updateCalendarEvent, type CalendarColorEntry, type CalendarColors, type CalendarEventInput, type CalendarEventSummary, type CalendarListPage, type CalendarSummary, type CalendarSyncResult, type DeleteCalendarEventInput, type ListEventsInput, type SyncEventsInput, type UpdateCalendarEventInput, } from './calendar.js';
 export { calendarSyncStatePath, clearCalendarSyncToken, loadCalendarSyncToken, saveCalendarSyncToken } from './calendarSyncStore.js';
 export { toCollectionDateTime } from './collectionDateTime.js';
-export { googleCalendarSyncTaskDef, classifyDelete, classifyWrite, groupByCalendar, syncCalendarGroup, syncDueCalendarCollections, toCollectionRecord, GOOGLE_CALENDAR_SYNC_TASK_ID, type CalendarCollectionSyncResult, } from './collectionSync.js';
-export { completeTask, createTask, deleteTask, listTaskLists, listTasks, toTaskListSummary, toTaskSummary, type CompleteTaskInput, type CreateTaskInput, type ListTasksInput, type TaskListSummary, type TaskSummary, } from './tasks.js';
+export { googleCalendarSyncTaskDef, classifyDelete, classifyWrite, anySyncedCollectionSurvives, groupByCalendar, orphanedCalendarId, releaseOrphanedCalendarToken, syncCalendarForCollection, syncCalendarGroup, syncDueCalendarCollections, syncNewCalendarCollections, toCollectionRecord, unsyncedGroups, withKeyedLock, GOOGLE_CALENDAR_SYNC_TASK_ID, type CalendarCollectionSyncResult, type CalendarDeclaring, type ManualCalendarSyncDeps, type ManualCalendarSyncOutcome, } from './collectionSync.js';
+export { buildTaskPatch, canonicalTaskListId, completeTask, createTask, deleteTask, listTaskLists, listTasks, toTaskListSummary, toTaskSummary, updateTask, type CompleteTaskInput, type CreateTaskInput, type ListTasksInput, type TaskListSummary, type TaskSummary, type UpdateTaskInput, } from './tasks.js';
 export { assertSafeMimeType, buildMultipartBody, createDriveFile, deleteDriveFile, isTextMimeType, listDriveFiles, pickBoundary, readDriveFile, toDriveFileSummary, type CreateDriveFileInput, type DriveFileSummary, type ListDriveFilesInput, type ReadDriveFileInput, } from './driveFile.js';

package/dist/google/index.js

@@ -651,6 +651,34 @@ async function createCalendarEvent(accessToken, input) {
 		body: JSON.stringify(body)
 	}));
 }
+var eventUrl = (calendarId, eventId) => `${eventsUrl(calendarId)}/${encodeURIComponent(eventId)}`;
+/** PATCH body for an event edit — only the fields the caller actually supplied.
+*
+*  `undefined` means "leave as is" and `""` means "clear it", so the two cannot
+*  be collapsed: dropping `description: ""` would silently ignore a request to
+*  empty the body text. Pure so the distinction is testable without network. */
+var buildEventPatch = (input) => ({
+	...input.summary !== void 0 ? { summary: input.summary } : {},
+	...input.description !== void 0 ? { description: input.description } : {},
+	...input.startDateTime !== void 0 ? { start: { dateTime: input.startDateTime } } : {},
+	...input.endDateTime !== void 0 ? { end: { dateTime: input.endDateTime } } : {},
+	...input.colorId ? { colorId: input.colorId } : {}
+});
+/** Edit an existing event in place. PATCH, not PUT — a PUT would need the whole
+*  event and would drop every field the caller never read (attendees,
+*  reminders, recurrence). */
+async function updateCalendarEvent(accessToken, input) {
+	return toEventSummary(await googleRequest(CALENDAR_API_LABEL, accessToken, eventUrl(input.calendarId, input.eventId), {
+		method: "PATCH",
+		body: JSON.stringify(buildEventPatch(input))
+	}));
+}
+/** Remove an event. Google answers 204 with no body, so there is nothing to
+*  return; a second delete of the same id answers 410, which surfaces as a
+*  GoogleApiError rather than being swallowed. */
+async function deleteCalendarEvent(accessToken, input) {
+	await googleRequest(CALENDAR_API_LABEL, accessToken, eventUrl(input.calendarId, input.eventId), { method: "DELETE" });
+}
 async function listCalendarEvents(accessToken, input = {}) {
 	const params = new URLSearchParams({
 		timeMin: input.timeMin ?? (/* @__PURE__ */ new Date()).toISOString(),
@@ -879,6 +907,26 @@ async function restartFullSync(accessToken, calendarId, workspaceRoot) {
 	await clearCalendarSyncToken(calendarId, workspaceRoot);
 	return await syncCalendarEvents(accessToken, { calendarId });
 }
+/** Serialise `run` against whatever is already running for `key`.
+*
+*  `locks` is passed in so the queuing rule is testable without module state;
+*  the key is dropped once nothing is queued behind it, so the map cannot grow
+*  an entry per calendar forever. A failed predecessor still releases the
+*  queue — `then(run, run)`. */
+async function withKeyedLock(locks, key, run) {
+	const result = (locks.get(key) ?? Promise.resolve()).then(run, run);
+	const tail = result.then(() => void 0, () => void 0);
+	locks.set(key, tail);
+	try {
+		return await result;
+	} finally {
+		if (locks.get(key) === tail) locks.delete(key);
+	}
+}
+/** In-flight sync per canonical calendar id. Module state on purpose: the
+*  scheduler, the create trigger and the Refresh button are three doors into
+*  the same calendar (CodeRabbit review #2566). */
+var calendarLocks = /* @__PURE__ */ new Map();
 /** 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
@@ -886,8 +934,18 @@ async function restartFullSync(accessToken, calendarId, workspaceRoot) {
 *  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.) */
+*  (Codex + CodeRabbit review on #2184.)
+*
+*  Queued per calendar for the same reason the fan-out exists: two passes over
+*  one calendar (a Refresh click landing during the scheduled run) would each
+*  load the SAME stored token and walk the same window. That is idempotent —
+*  writes are upserts by event id — but it is a wasted full walk. Queued, the
+*  second pass resumes from the token the first just stored and fetches only
+*  what is genuinely new. */
 async function syncCalendarGroup(calendarId, collections, workspaceRoot) {
+	return await withKeyedLock(calendarLocks, canonicalCalendarId(calendarId), () => syncCalendarGroupNow(calendarId, collections, workspaceRoot));
+}
+async function syncCalendarGroupNow(calendarId, collections, workspaceRoot) {
 	const accessToken = await getGoogleAccessToken();
 	const first = await syncCalendarEvents(accessToken, {
 		calendarId,
@@ -902,13 +960,47 @@ async function syncCalendarGroup(calendarId, collections, workspaceRoot) {
 		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
-	});
+	if (failed.length > 0) {
+		log.warn("google", "holding back calendar sync token after failed writes", {
+			calendarId,
+			failed: failed.length
+		});
+		return results;
+	}
+	if (result.nextSyncToken) await advanceToken(calendarId, result.nextSyncToken, collections, workspaceRoot);
 	return results;
 }
+/** Save the window's token unless every collection that consumed it was deleted
+*  while the sync was in flight.
+*
+*  The sync opens with a `discoverCollections()` snapshot, so a delete landing
+*  mid-run has already cleared this calendar's token by the time we get here
+*  (`releaseOrphanedCalendarToken`). Saving anyway would resurrect exactly the
+*  orphan the delete removed, and the next collection on this calendar would
+*  resume from a token describing records it never received (#2428).
+*
+*  One survivor is enough: it still needs the incremental position. */
+async function advanceToken(calendarId, nextSyncToken, collections, workspaceRoot) {
+	if (!await anySyncedCollectionSurvives(collections)) {
+		log.info("google", "not advancing the sync token — every collection on this calendar was deleted mid-sync", { calendarId });
+		return;
+	}
+	await saveCalendarSyncToken(calendarId, nextSyncToken, workspaceRoot);
+}
+async function pathExists(absPath) {
+	try {
+		await stat(absPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Liveness of the collections a sync just wrote to, checked against the skill
+*  dir `deleteCollection` removes. `exists` is injected so the rule is testable
+*  without a filesystem. An empty group has no survivor by definition. */
+async function anySyncedCollectionSurvives(collections, exists = pathExists) {
+	return (await Promise.all(collections.map((collection) => exists(collection.skillDir)))).some(Boolean);
+}
 async function applyEventsToCollection(collection, events, workspaceRoot) {
 	const outcomes = [];
 	for (const event of events) outcomes.push(await applyEvent(collection, event, workspaceRoot));
@@ -941,18 +1033,62 @@ function groupByCalendar(collections) {
 	}
 	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 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 [];
+/** The canonical calendar whose sync token nothing needs any more, or null.
+*
+*  Sync tokens are keyed by calendar, NOT by collection, so a deleted
+*  collection's token outlives it. Recreating a collection on the same calendar
+*  then resumes from that token and receives only the delta — the new
+*  collection never gets the history (#2428).
+*
+*  Returns null while ANY remaining collection still reads that calendar:
+*  clearing a live calendar's token costs a full re-walk on the next sync. The
+*  comparison is on the CANONICAL id for the same reason `groupByCalendar` is —
+*  an omitted `calendarId` and an explicit `"primary"` are one calendar. */
+function orphanedCalendarId(deleted, remaining) {
+	if (!deleted.googleCalendar) return null;
+	const key = canonicalCalendarId(deleted.googleCalendar.calendarId);
+	return remaining.some((other) => other.googleCalendar && canonicalCalendarId(other.googleCalendar.calendarId) === key) ? null : key;
+}
+/** Drop the sync token of a just-deleted collection's calendar, unless another
+*  collection still reads it. Call AFTER the delete lands — the check reads the
+*  collections that survive it.
+*
+*  Returns the cleared calendar id, or null when nothing was cleared. Never
+*  throws: a failed cleanup must not fail the delete it follows. */
+async function releaseOrphanedCalendarToken(deleted, workspaceRoot) {
+	try {
+		if (!deleted.googleCalendar) return null;
+		const orphaned = orphanedCalendarId(deleted, (await discoverCollections({ workspaceRoot })).map((collection) => collection.schema));
+		if (orphaned === null) return null;
+		await clearCalendarSyncToken(orphaned, workspaceRoot);
+		log.info("google", "cleared the sync token of a calendar no collection reads any more", { calendarId: orphaned });
+		return orphaned;
+	} catch (error) {
+		log.warn("google", "could not release the deleted collection's calendar sync token", { error: String(error) });
+		return null;
 	}
+}
+/** Every declaring collection, grouped by the calendar it reads. */
+async function declaringGroups(workspaceRoot) {
+	return groupByCalendar((await discoverCollections({ workspaceRoot })).filter((collection) => collection.schema.googleCalendar));
+}
+/** Whether a background sync of these groups may run at all.
+*
+*  Authoring the collection before linking the account is an expected state,
+*  not a failure. Checking once here keeps it a quiet skip instead of an
+*  access-token throw per calendar, every hour, until the user links (#2188).
+*  A user-triggered sync answers differently — it says so out loud. */
+async function backgroundSyncAllowed(groups) {
+	if (groups.size === 0) return false;
+	if (await isGoogleLinked()) return true;
+	log.info("google", "skipping calendar sync — no Google account linked on this host", { calendars: groups.size });
+	return false;
+}
+/** Run each group, isolating failures per calendar — one unreachable calendar
+*  (or a revoked grant) must not stop the others. */
+async function runCalendarGroups(groups, workspaceRoot) {
 	const results = [];
-	for (const [calendarId, collections] of groupByCalendar(declaring)) try {
+	for (const [calendarId, collections] of groups) try {
 		results.push(...await syncCalendarGroup(calendarId, collections, workspaceRoot));
 	} catch (error) {
 		log.warn("google", "calendar sync failed", {
@@ -969,6 +1105,55 @@ async function syncDueCalendarCollections(workspaceRoot) {
 	}
 	return results;
 }
+/** Sync every collection that declares `googleCalendar`. */
+async function syncDueCalendarCollections(workspaceRoot) {
+	const groups = await declaringGroups(workspaceRoot);
+	return await backgroundSyncAllowed(groups) ? await runCalendarGroups(groups, workspaceRoot) : [];
+}
+/** The groups whose calendar has never synced. A missing token IS the "created
+*  since the last sync" signal — nothing else distinguishes a new collection
+*  from an edited one on the write path this feeds (#2427).
+*
+*  Self-silencing by construction: the first sync stores a token, so a calendar
+*  matches at most once. `loadToken` is injected so the rule is testable without
+*  a workspace on disk. */
+async function unsyncedGroups(groups, loadToken) {
+	const checked = await Promise.all([...groups].map(async (entry) => await loadToken(entry[0]) === null ? entry : null));
+	return new Map(checked.filter((entry) => entry !== null));
+}
+/** Sync only the calendars that have never synced — the first sync for a
+*  just-created collection, which otherwise stays empty until the hourly
+*  scheduler run (#2427). Cheap and safe to call on every config write. */
+async function syncNewCalendarCollections(workspaceRoot) {
+	const pending = await unsyncedGroups(await declaringGroups(workspaceRoot), (calendarId) => loadCalendarSyncToken(calendarId, workspaceRoot));
+	if (!await backgroundSyncAllowed(pending)) return [];
+	log.info("google", "running the first sync for newly declared calendars", { calendars: [...pending.keys()] });
+	return await runCalendarGroups(pending, workspaceRoot);
+}
+var liveManualSyncDeps = {
+	loadGroups: declaringGroups,
+	isLinked: isGoogleLinked,
+	runGroups: runCalendarGroups
+};
+/** Sync the calendar ONE collection reads, on demand (the Refresh button).
+*
+*  Deliberately syncs the whole group, not just `slug`: the sync token is keyed
+*  by calendar, so consuming a window for one collection would leave the others
+*  on that calendar reading an already-consumed one. Returns every result of the
+*  group so the caller can report the requested slug's own counts.
+*
+*  "Does this collection sync at all" is answered BEFORE "is Google linked":
+*  telling someone to link their account for a collection that never declared a
+*  calendar sends them fixing the wrong thing. */
+async function syncCalendarForCollection(slug, workspaceRoot, deps = liveManualSyncDeps) {
+	const owning = [...await deps.loadGroups(workspaceRoot)].filter(([, collections]) => collections.some((collection) => collection.slug === slug));
+	if (owning.length === 0) return { kind: "not-a-calendar" };
+	if (!await deps.isLinked()) return { kind: "not-linked" };
+	return {
+		kind: "synced",
+		results: await deps.runGroups(new Map(owning), workspaceRoot)
+	};
+}
 /** Scheduler registration, shaped like `feedRefreshTaskDef` so hosts wire it
 *  with a single line. */
 function googleCalendarSyncTaskDef(opts) {
@@ -1008,7 +1193,12 @@ var toTaskSummary = (value) => {
 		notes: stringField(record, "notes")
 	};
 };
-var tasksUrl = (taskListId, suffix = "") => `${TASKS_BASE_URL}/lists/${encodeURIComponent(taskListId ?? DEFAULT_TASK_LIST_ID)}/tasks${suffix}`;
+/** Resolve a declared taskListId to the one the API addresses. `||` (not `??`)
+*  so a blank string also falls back instead of building a malformed
+*  `/lists//tasks` URL — the same rule, and the same reason, as
+*  `canonicalCalendarId`. */
+var canonicalTaskListId = (taskListId) => taskListId?.trim() || DEFAULT_TASK_LIST_ID;
+var tasksUrl = (taskListId, suffix = "") => `${TASKS_BASE_URL}/lists/${encodeURIComponent(canonicalTaskListId(taskListId))}/tasks${suffix}`;
 async function listTaskLists(accessToken) {
 	return itemsOf(await googleRequest(TASKS_API_LABEL, accessToken, `${TASKS_BASE_URL}/users/@me/lists?maxResults=${MAX_TASK_LISTS}`)).map(toTaskListSummary);
 }
@@ -1030,6 +1220,21 @@ async function createTask(accessToken, input) {
 		body: JSON.stringify(body)
 	}));
 }
+/** PATCH body for a task edit — only the fields the caller supplied. As with
+*  events, `undefined` means "leave as is" and `""` means "clear it", so the
+*  two must stay distinct. `status` is deliberately absent: `completeTask`
+*  owns that transition, and two ways to set it would drift apart. */
+var buildTaskPatch = (input) => ({
+	...input.title !== void 0 ? { title: input.title } : {},
+	...input.notes !== void 0 ? { notes: input.notes } : {},
+	...input.due !== void 0 ? { due: input.due } : {}
+});
+async function updateTask(accessToken, input) {
+	return toTaskSummary(await googleRequest(TASKS_API_LABEL, accessToken, tasksUrl(input.taskListId, `/${encodeURIComponent(input.taskId)}`), {
+		method: "PATCH",
+		body: JSON.stringify(buildTaskPatch(input))
+	}));
+}
 async function completeTask(accessToken, input) {
 	return toTaskSummary(await googleRequest(TASKS_API_LABEL, accessToken, tasksUrl(input.taskListId, `/${encodeURIComponent(input.taskId)}`), {
 		method: "PATCH",
@@ -1133,6 +1338,6 @@ async function deleteDriveFile(accessToken, input) {
 	await googleRequest(DRIVE_API_LABEL, accessToken, `${DRIVE_FILES_URL}/${encodeURIComponent(input.fileId)}`, { method: "DELETE" });
 }
 //#endregion
-export { DEFAULT_LIST_MAX_RESULTS, GOOGLE_AUTH_CANCELLED, GOOGLE_CALENDARLIST_SCOPE, GOOGLE_CALENDAR_SCOPE, GOOGLE_CALENDAR_SYNC_TASK_ID, GOOGLE_DRIVE_FILE_SCOPE, GOOGLE_SCOPES, GOOGLE_TASKS_SCOPE, GoogleApiError, MAX_LIST_RESULTS, assertSafeMimeType, authorizeGoogle, brokerBaseUrl, brokerExchange, brokerRefresh, brokerStart, buildMultipartBody, calendarApiError, calendarSyncStatePath, canonicalCalendarId, classifyDelete, classifyWrite, clearCalendarSyncToken, clientSecretPresence, collectCalendarPages, commitLinkedTokens, completeTask, configureGoogleHost, createCalendarEvent, createDriveFile, createGoogleAuthFlow, createTask, deleteDriveFile, deleteGoogleTokens, deleteTask, findClientSecretPath, getCalendarColors, getGoogleAccessToken, googleApiError, googleAuthFlow, googleCalendarSyncTaskDef, googleConfigDir, googleSecretsDir, googleTokenPath, groupByCalendar, isGoogleApiError, isIsoDateTimeWithOffset, isTextMimeType, legacyGoogleTokenPath, listCalendarEvents, listCalendars, listDriveFiles, listTaskLists, listTasks, loadCalendarSyncToken, loadClientSecret, loadGoogleTokens, mergeGoogleTokens, pickBoundary, readDriveFile, saveCalendarSyncToken, saveGoogleTokens, syncCalendarEvents, syncCalendarGroup, syncDueCalendarCollections, toCalendarSummary, toCollectionDateTime, toCollectionRecord, toDriveFileSummary, toEventSummary, toTaskListSummary, toTaskSummary, unlinkGoogle, waitForAuthCode };
+export { DEFAULT_LIST_MAX_RESULTS, GOOGLE_AUTH_CANCELLED, GOOGLE_CALENDARLIST_SCOPE, GOOGLE_CALENDAR_SCOPE, GOOGLE_CALENDAR_SYNC_TASK_ID, GOOGLE_DRIVE_FILE_SCOPE, GOOGLE_SCOPES, GOOGLE_TASKS_SCOPE, GoogleApiError, MAX_LIST_RESULTS, anySyncedCollectionSurvives, assertSafeMimeType, authorizeGoogle, brokerBaseUrl, brokerExchange, brokerRefresh, brokerStart, buildEventPatch, buildMultipartBody, buildTaskPatch, calendarApiError, calendarSyncStatePath, canonicalCalendarId, canonicalTaskListId, classifyDelete, classifyWrite, clearCalendarSyncToken, clientSecretPresence, collectCalendarPages, commitLinkedTokens, completeTask, configureGoogleHost, createCalendarEvent, createDriveFile, createGoogleAuthFlow, createTask, deleteCalendarEvent, deleteDriveFile, deleteGoogleTokens, deleteTask, findClientSecretPath, getCalendarColors, getGoogleAccessToken, googleApiError, googleAuthFlow, googleCalendarSyncTaskDef, googleConfigDir, googleSecretsDir, googleTokenPath, groupByCalendar, isGoogleApiError, isIsoDateTimeWithOffset, isTextMimeType, legacyGoogleTokenPath, listCalendarEvents, listCalendars, listDriveFiles, listTaskLists, listTasks, loadCalendarSyncToken, loadClientSecret, loadGoogleTokens, mergeGoogleTokens, orphanedCalendarId, pickBoundary, readDriveFile, releaseOrphanedCalendarToken, saveCalendarSyncToken, saveGoogleTokens, syncCalendarEvents, syncCalendarForCollection, syncCalendarGroup, syncDueCalendarCollections, syncNewCalendarCollections, toCalendarSummary, toCollectionDateTime, toCollectionRecord, toDriveFileSummary, toEventSummary, toTaskListSummary, toTaskSummary, unlinkGoogle, unsyncedGroups, updateCalendarEvent, updateTask, waitForAuthCode, withKeyedLock };
 
 //# sourceMappingURL=index.js.map