@mulmoclaude/core 1.3.0 → 1.5.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, anySyncedCollectionSurvives, groupByCalendar, orphanedCalendarId, releaseOrphanedCalendarToken, syncCalendarGroup, syncDueCalendarCollections, toCollectionRecord, GOOGLE_CALENDAR_SYNC_TASK_ID, type CalendarCollectionSyncResult, type CalendarDeclaring, } 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, uncompleteTask, 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,
@@ -1010,18 +1068,27 @@ async function releaseOrphanedCalendarToken(deleted, workspaceRoot) {
 		return null;
 	}
 }
-/** 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 [];
-	}
+/** 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", {
@@ -1038,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) {
@@ -1059,6 +1175,7 @@ var TASKS_BASE_URL = "https://tasks.googleapis.com/tasks/v1";
 var TASKS_API_LABEL = "Google Tasks API";
 var DEFAULT_TASK_LIST_ID = "@default";
 var TASK_STATUS_COMPLETED = "completed";
+var TASK_STATUS_NEEDS_ACTION = "needsAction";
 var MAX_TASK_LISTS = 50;
 var toTaskListSummary = (value) => {
 	const record = asRecord(value);
@@ -1077,7 +1194,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);
 }
@@ -1099,12 +1221,47 @@ 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` /
+*  `uncompleteTask` own 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",
 		body: JSON.stringify({ status: TASK_STATUS_COMPLETED })
 	}));
 }
+/** Send a completed task back to the to-do list.
+*
+*  Its own function rather than a flag on `completeTask`, and deliberately not
+*  a `status` field on `updateTask`: one kind per target state keeps the name
+*  honest and leaves exactly one code path setting each value.
+*
+*  The patch carries `status` alone — mirroring `completeTask`, which also
+*  sets only `status` and lets Google fill in the `completed` timestamp. Note
+*  that whether Google *clears* that timestamp on the way back is its
+*  behaviour, not ours, and is unverified here: `TaskSummary` doesn't carry
+*  `completed`, so nothing in this codebase would show a stale one. If a
+*  reopened task ever displays a completion date in Google's own UI, this is
+*  the place to add `completed: null` to the patch. */
+async function uncompleteTask(accessToken, input) {
+	return toTaskSummary(await googleRequest(TASKS_API_LABEL, accessToken, tasksUrl(input.taskListId, `/${encodeURIComponent(input.taskId)}`), {
+		method: "PATCH",
+		body: JSON.stringify({ status: TASK_STATUS_NEEDS_ACTION })
+	}));
+}
 async function deleteTask(accessToken, input) {
 	await googleRequest(TASKS_API_LABEL, accessToken, tasksUrl(input.taskListId, `/${encodeURIComponent(input.taskId)}`), { method: "DELETE" });
 }
@@ -1202,6 +1359,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, anySyncedCollectionSurvives, 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, orphanedCalendarId, pickBoundary, readDriveFile, releaseOrphanedCalendarToken, 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, uncompleteTask, unlinkGoogle, unsyncedGroups, updateCalendarEvent, updateTask, waitForAuthCode, withKeyedLock };
 
 //# sourceMappingURL=index.js.map