@wirecat/cli-core 0.487.0 → 0.489.0

package/dist/calendar/testing/writer-contract.js

@@ -3,7 +3,8 @@ import { mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { isCliError } from "@wirecat/cli-base";
-import { createEvent } from "../writes.js";
+import { ruleEnd } from "../recurrence.js";
+import { createEvent, deleteEvent, updateEvent } from "../writes.js";
 import { memoryEventStore } from "./memory.js";
 const reasonOf = (error) => (isCliError(error) ? error.details.reason : undefined);
 const rejectsWith = async (promise, check, message) => {
@@ -17,7 +18,10 @@ const rejectsWith = async (promise, check, message) => {
     assert.fail(`${message}, but it succeeded`);
 };
 const ID = "contract0sample0id0001";
+const NEW_ID = "contract0sample0id0002";
+const WEEK = 7 * 86_400_000;
 const WEEKLY = "RRULE:FREQ=WEEKLY;COUNT=3";
+const WEEKLY_OPEN = "RRULE:FREQ=WEEKLY";
 const DAILY = "RRULE:FREQ=DAILY;INTERVAL=2;COUNT=5";
 /**
  * What every calendar writer keeps (gcal-cli plan §9, W1): a stale `etag` is a conflict, never an overwrite; a create
@@ -25,6 +29,53 @@ const DAILY = "RRULE:FREQ=DAILY;INTERVAL=2;COUNT=5";
  * switches to all-day and back; `notify: false` mails nobody, and a profile that keeps `events.notify` at its
  * default never reaches the provider with a write that would.
  */
+const contextOver = async (f, permissions) => {
+    const store = memoryEventStore();
+    const [calendar] = await store.saveCalendars(1, [{ ...f.calendar, syncByDefault: true }], f.at);
+    const home = mkdtempSync(join(tmpdir(), "calendar-writer-contract-"));
+    return {
+        calendarId: calendar?.id,
+        store,
+        accountId: 1,
+        writes: {
+            writer: f.writer,
+            app: { command: "example", appName: "example-cli", envPrefix: "EXAMPLE", description: "", version: "0" },
+            settings: () => ({ profile: "work", permissions, permissionSources: {}, sendsPerHour: 30 }),
+            env: { HOME: home, XDG_DATA_HOME: home, EXAMPLE_STATE_DIR: home },
+        },
+        ask: async () => { },
+        now: f.at,
+        zone: "UTC",
+        names: {
+            notify: "notify",
+            id: "id",
+            calendar: "calendar",
+            series: "series",
+            following: "following",
+            repeat: "repeat",
+        },
+    };
+};
+/** A weekly series the writer made, stored with its second occurrence as a sync would store it. */
+const storedSeries = async (f, context) => {
+    const series = await f.writer.create(f.calendar, { title: "Example planning", startsAt: f.at, endsAt: f.at + 3_600_000, timezone: "UTC", recurrence: [WEEKLY_OPEN] }, { id: ID, notify: false });
+    const [, second] = await context.store.saveEntries(context.calendarId, [
+        series,
+        {
+            externalId: `${ID}_second`,
+            kind: "occurrence",
+            seriesExternalId: ID,
+            originalStartsAt: f.at + WEEK,
+            status: "confirmed",
+            title: "Example planning",
+            startsAt: f.at + WEEK,
+            endsAt: f.at + WEEK + 3_600_000,
+            timezone: "UTC",
+        },
+    ], f.at);
+    return `event:${second?.eventId}`;
+};
+const SPLIT = { "events.create": "allow", "events.update": "allow", "events.delete.series": "allow" };
 export const calendarWriterContract = (fixture) => {
     const draft = (at, extra = {}) => ({
         title: "Example planning",
@@ -139,35 +190,9 @@ export const calendarWriterContract = (fixture) => {
             name: "with events.notify at its default, a create that would mail attendees is refused before the provider",
             run: async () => {
                 const f = await fixture();
-                const store = memoryEventStore();
-                const [calendar] = await store.saveCalendars(1, [{ ...f.calendar, syncByDefault: true }], f.at);
-                const home = mkdtempSync(join(tmpdir(), "calendar-writer-contract-"));
+                const context = await contextOver(f, { events: "allow" });
                 const before = f.notified().length;
-                await rejectsWith(createEvent({
-                    store,
-                    accountId: 1,
-                    writes: {
-                        writer: f.writer,
-                        app: {
-                            command: "example",
-                            appName: "example-cli",
-                            envPrefix: "EXAMPLE",
-                            description: "",
-                            version: "0",
-                        },
-                        settings: () => ({
-                            profile: "work",
-                            permissions: { events: "allow" },
-                            permissionSources: {},
-                            sendsPerHour: 30,
-                        }),
-                        env: { HOME: home, XDG_DATA_HOME: home, EXAMPLE_STATE_DIR: home },
-                    },
-                    ask: async () => { },
-                    now: f.at,
-                    zone: "UTC",
-                    names: { notify: "notify", id: "id", calendar: "calendar", series: "series", repeat: "repeat" },
-                }, String(calendar?.id), {
+                await rejectsWith(createEvent(context, String(context.calendarId), {
                     title: "Example planning",
                     startTime: new Date(f.at).toISOString(),
                     endTime: new Date(f.at + 3_600_000).toISOString(),
@@ -176,6 +201,109 @@ export const calendarWriterContract = (fixture) => {
                 assert.equal(f.notified().length, before, "the provider was not called");
             },
         },
+        {
+            name: "following: the series ends before the occurrence, and a new one starts there with the change",
+            run: async () => {
+                const f = await fixture();
+                const context = await contextOver(f, SPLIT);
+                const occurrence = await storedSeries(f, context);
+                const answer = (await updateEvent(context, occurrence, { title: "Example planning (later)" }, {
+                    following: true,
+                    notify: false,
+                    id: NEW_ID,
+                }));
+                const old = await context.store.entry(context.calendarId, ID);
+                const ends = ruleEnd(old?.recurrence?.[0] ?? "", "UTC");
+                assert.ok(ends !== undefined && ends >= f.at && ends < f.at + WEEK, "the first occurrence stays, the second goes");
+                const made = await context.store.entry(context.calendarId, NEW_ID);
+                assert.equal(answer.entry?.external_id, NEW_ID);
+                assert.equal(made?.kind, "series");
+                assert.equal(made?.title, "Example planning (later)");
+                assert.equal(made?.startsAt, f.at + WEEK);
+                assert.deepEqual(made?.recurrence, [WEEKLY_OPEN]);
+            },
+        },
+        {
+            name: "following: a retry with the id after a lost answer finds the new series instead of making a second",
+            run: async () => {
+                const f = await fixture();
+                const context = await contextOver(f, SPLIT);
+                const occurrence = await storedSeries(f, context);
+                const change = { title: "Example planning (later)" };
+                f.loseNextAnswer();
+                let named;
+                await rejectsWith(updateEvent(context, occurrence, change, { following: true, notify: false }), (error) => {
+                    named = isCliError(error) ? error.details.operation_id : undefined;
+                    return isCliError(error) && error.code === "outcome_unknown" && typeof named === "string";
+                }, "a lost answer is outcome_unknown naming the new series' id");
+                const again = (await updateEvent(context, occurrence, change, {
+                    following: true,
+                    notify: false,
+                    id: named,
+                }));
+                assert.equal(again.entry?.external_id, named);
+                assert.ok(again.ended, "the old series is ended on the retry");
+                const ends = ruleEnd((await context.store.entry(context.calendarId, ID))?.recurrence?.[0] ?? "", "UTC");
+                assert.ok(ends !== undefined && ends < f.at + WEEK);
+            },
+        },
+        {
+            name: "following: a deletion ends the series before the occurrence and makes nothing",
+            run: async () => {
+                const f = await fixture();
+                const context = await contextOver(f, SPLIT);
+                const occurrence = await storedSeries(f, context);
+                await deleteEvent(context, occurrence, { following: true, notify: false });
+                const ends = ruleEnd((await context.store.entry(context.calendarId, ID))?.recurrence?.[0] ?? "", "UTC");
+                assert.ok(ends !== undefined && ends >= f.at && ends < f.at + WEEK);
+            },
+        },
+        ...moveCases(fixture),
     ];
     return cases;
 };
+const moveCases = (fixture) => {
+    const ready = async () => {
+        const f = await fixture();
+        return f.writer.move && f.target ? { ...f, move: f.writer.move.bind(f.writer), target: f.target } : undefined;
+    };
+    return [
+        {
+            name: "move: the event keeps its id on the other calendar, with a new etag",
+            run: async () => {
+                const f = await ready();
+                if (!f)
+                    return;
+                const moved = await f.move(f.calendar, f.existing.externalId, f.target, {
+                    etag: f.existing.etag,
+                    notify: false,
+                });
+                assert.equal(moved.externalId, f.existing.externalId);
+                assert.equal(typeof moved.etag, "string");
+            },
+        },
+        {
+            name: "move: an old etag is a conflict, and the event stays",
+            run: async () => {
+                const f = await ready();
+                if (!f)
+                    return;
+                await f.changeBehind();
+                await rejectsWith(f.move(f.calendar, f.existing.externalId, f.target, { etag: f.existing.etag, notify: false }), (error) => reasonOf(error) === "event.conflict", "a stale etag is a calendarConflict()");
+            },
+        },
+        {
+            name: "move: a retry after a lost answer finds the event on the other calendar",
+            run: async () => {
+                const f = await ready();
+                if (!f)
+                    return;
+                const options = { etag: f.existing.etag, notify: false };
+                f.loseNextAnswer();
+                await rejectsWith(f.move(f.calendar, f.existing.externalId, f.target, options), (error) => isCliError(error) && error.code === "outcome_unknown", "a lost answer is outcome_unknown");
+                const found = await f.move(f.calendar, f.existing.externalId, f.target, options);
+                assert.equal(found.externalId, f.existing.externalId);
+            },
+        },
+    ];
+};

package/dist/calendar/testing/writer.d.ts

@@ -1,11 +1,13 @@
 import type { EntryInput } from "../../meetings/index.js";
 import { type CalendarWriter } from "../writer.js";
 export interface FakeCalendarWriterCall {
-    write: "create" | "update" | "remove" | "respond";
+    write: "create" | "update" | "remove" | "respond" | "move";
     calendar: string;
     externalId: string;
     notify: boolean;
     scope?: "this" | "series";
+    /** A move's calendar. */
+    target?: string;
 }
 /**
  * A provider's calendars held in memory, as a writer sees them. Every entry carries an etag that each change moves

package/dist/calendar/testing/writer.js

@@ -97,5 +97,16 @@ export const fakeCalendarWriter = (options = {}) => {
             of(calendar.externalId).set(externalId, entry);
             return answer(entry);
         },
+        async move(calendar, externalId, target, { etag, notify }) {
+            calls.push({ write: "move", calendar: calendar.externalId, externalId, notify, target: target.externalId });
+            const arrived = of(target.externalId).get(externalId);
+            // A retry after a lost answer: the event left this calendar on the first try.
+            if (arrived && !of(calendar.externalId).has(externalId))
+                return arrived;
+            const entry = stamp(current(calendar, externalId, etag));
+            of(calendar.externalId).delete(externalId);
+            of(target.externalId).set(externalId, entry);
+            return answer(entry);
+        },
     };
 };

package/dist/calendar/writer.d.ts

@@ -26,8 +26,13 @@ export interface EventDraft {
  * `startDate` for a timed event, or `startsAt` for an all-day one, switches it: the adapter clears the other kind.
  */
 export type EventPatch = Partial<EventDraft>;
-/** `this`: the one entry named; `series`: the repeating event it belongs to, named by the series' own id. */
+/**
+ * `this`: the one entry named; `series`: the repeating event it belongs to, named by the series' own id. A writer
+ * receives only these two: cli-core makes `following` of a series change and a create (`FollowingScope`).
+ */
 export type WriteScope = "this" | "series";
+/** A write's scope as the owner chooses it: `following` is this occurrence and every later one. */
+export type FollowingScope = WriteScope | "following";
 export type EventResponse = Extract<ParticipantResponse, "accepted" | "tentative" | "declined">;
 /**
  * Writes to one provider's calendars. Each change carries the entry's `etag`, sent as the provider's precondition
@@ -59,15 +64,27 @@ export interface CalendarWriter {
         etag: string;
         notify: boolean;
     }): Promise<EntryInput>;
+    /**
+     * Optional: moves the event, keeping its id, to `target`, another calendar of the same account. `etag` is checked
+     * before the move; a provider whose move takes no precondition reads the event first. A retry after
+     * `outcome_unknown` that finds the event already on `target` returns it.
+     */
+    move?(calendar: StoredCalendar, externalId: string, target: StoredCalendar, options: {
+        etag: string;
+        notify: boolean;
+    }): Promise<EntryInput>;
 }
 /** Which write a command makes, for `CalendarWrites.extraKeys`. */
-export type CalendarWrite = "create" | "update" | "delete" | "respond";
+export type CalendarWrite = "create" | "update" | "delete" | "respond" | "move";
 /** Mailing the other attendees: an agent may write to the calendar and still not to people (WC-PERM-14's spirit). */
 export declare const EVENTS_NOTIFY_KEY: PermissionKey;
 export declare const EVENTS_DELETE_SERIES_KEY: PermissionKey;
 /** The keys the calendar writes check beyond their command paths, for a CLI's `commandPermissions({ extra })`. */
 export declare const CALENDAR_WRITE_KEYS: readonly PermissionKey[];
-/** Built in, and only ever tightening (WC-PERM-7): one change asks, a whole series is not deleted, nobody is mailed. */
+/**
+ * Built in, and only ever tightening (WC-PERM-7). A change that is easy to undo goes ahead, as tg's and drive's writes
+ * do; a deletion asks; a whole series is not deleted, and nobody is mailed.
+ */
 export declare const CALENDAR_WRITE_DEFAULTS: Readonly<Record<PermissionKey, Level>>;
 /** What an adapter throws when the provider refused a write because the entry's `etag` is old (HTTP 412). */
 export declare const calendarConflict: (message?: string) => CliError;

package/dist/calendar/writer.js

@@ -4,11 +4,15 @@ export const EVENTS_NOTIFY_KEY = "events.notify";
 export const EVENTS_DELETE_SERIES_KEY = "events.delete.series";
 /** The keys the calendar writes check beyond their command paths, for a CLI's `commandPermissions({ extra })`. */
 export const CALENDAR_WRITE_KEYS = [EVENTS_NOTIFY_KEY, EVENTS_DELETE_SERIES_KEY];
-/** Built in, and only ever tightening (WC-PERM-7): one change asks, a whole series is not deleted, nobody is mailed. */
+/**
+ * Built in, and only ever tightening (WC-PERM-7). A change that is easy to undo goes ahead, as tg's and drive's writes
+ * do; a deletion asks; a whole series is not deleted, and nobody is mailed.
+ */
 export const CALENDAR_WRITE_DEFAULTS = {
-    "events.create": "ask",
-    "events.update": "ask",
-    "events.respond": "ask",
+    "events.create": "allow",
+    "events.update": "allow",
+    "events.respond": "allow",
+    "events.move": "allow",
     "events.delete": "ask",
     [EVENTS_DELETE_SERIES_KEY]: "deny",
     [EVENTS_NOTIFY_KEY]: "deny",

package/dist/calendar/writes.d.ts

@@ -3,7 +3,7 @@ import type { AppIdentity } from "../ports/app.js";
 import type { Warn } from "../runs/events.js";
 import { type Asker, type GuardSettings } from "../sends/guard.js";
 import { type PermissionKey } from "../sends/permissions.js";
-import { type CalendarWrite, type CalendarWriter, type EventPatch, type EventResponse, type WriteScope } from "./writer.js";
+import { type CalendarWrite, type CalendarWriter, type EventPatch, type EventResponse } from "./writer.js";
 /** What a CLI or an MCP host hands the calendar writes for one profile. */
 export interface CalendarWrites {
     writer: CalendarWriter;
@@ -46,6 +46,7 @@ export interface WriteContext {
         id: string;
         calendar: string;
         series: string;
+        following: string;
         repeat: string;
     };
 }
@@ -82,9 +83,19 @@ export declare const createEvent: (context: WriteContext, calendarReference: str
     } | null;
     hint?: string | undefined;
 }>;
-export declare const updateEvent: (context: WriteContext, reference: string, fields: EventFields, options?: {
+interface ScopeChoice {
     calendar?: string;
     series?: boolean;
+    /** This occurrence and every later one of its series. */
+    following?: boolean;
+    notify?: boolean;
+}
+export declare const updateEvent: (context: WriteContext, reference: string, fields: EventFields, options?: ScopeChoice & {
+    id?: string;
+}) => Promise<object>;
+export declare const deleteEvent: (context: WriteContext, reference: string, options?: ScopeChoice) => Promise<object>;
+export declare const respondToEvent: (context: WriteContext, reference: string, response: EventResponse, options?: {
+    calendar?: string;
     notify?: boolean;
 }) => Promise<{
     operation_id: string;
@@ -106,19 +117,14 @@ export declare const updateEvent: (context: WriteContext, reference: string, fie
     } | null;
     hint?: string | undefined;
 }>;
-export declare const deleteEvent: (context: WriteContext, reference: string, options?: {
+/**
+ * The event, under the same id, to another calendar of the same account. A repeating event moves whole: an
+ * occurrence alone cannot change calendar at Google, and moving one copy of a series apart would split it.
+ */
+export declare const moveEvent: (context: WriteContext, reference: string, toCalendar: string, options?: {
     calendar?: string;
     series?: boolean;
     notify?: boolean;
-}) => Promise<{
-    operation_id: string;
-    event: string | null;
-    scope: WriteScope;
-    removed: number;
-}>;
-export declare const respondToEvent: (context: WriteContext, reference: string, response: EventResponse, options?: {
-    calendar?: string;
-    notify?: boolean;
 }) => Promise<{
     operation_id: string;
     event: string | null;
@@ -138,4 +144,7 @@ export declare const respondToEvent: (context: WriteContext, reference: string,
         deleted_at: string | null;
     } | null;
     hint?: string | undefined;
+    from_calendar: string;
+    calendar: string;
 }>;
+export {};