@wirecat/cli-core 0.563.0 → 0.565.0

package/dist/calendar/cli/remind.d.ts

@@ -1,12 +1,3 @@
 import type { Command } from "commander";
-import type { CalendarWrites } from "../writes.js";
-import type { CalendarCommandDeps } from "./index.js";
-interface RemindHelpers {
-    deps: CalendarCommandDeps;
-    now: () => number;
-    zone: () => string;
-    print: (value: unknown, command: Command) => void;
-    example: (command: Command, ...lines: string[]) => Command;
-}
-export declare const addRemind: (events: Command, writes: CalendarWrites, { deps, now, zone, print, example }: RemindHelpers) => void;
-export {};
+import type { CommandHelpers } from "./index.js";
+export declare const addRemind: (events: Command, { within, now, zone, example }: CommandHelpers) => void;

package/dist/calendar/cli/remind.js

@@ -11,9 +11,10 @@ import { DEFAULT_PERMISSIONS, levelFor } from "../../sends/permissions.js";
 import { dueEvents, openReminders, reminderItem, remindersPath, runHook } from "../remind.js";
 import { syncCalendars } from "../sync.js";
 import { CALENDAR_WRITE_DEFAULTS, EVENTS_REMIND_HOOK_KEY } from "../writer.js";
+import { listBody } from "./bodies.js";
 const REMIND_MIN_MS = 60_000;
 const REMIND_MAX_MS = 86_400_000;
-export const addRemind = (events, writes, { deps, now, zone, print, example }) => {
+export const addRemind = (events, { within, now, zone, example }) => {
     const remind = example(destroysNothing(annotate(events.command("remind"), { effects: FETCH, mcp: false, literal_after_dashes: true }))
         .description("tell once about each event that starts within --due-within: print it, or run your program for it with the " +
         "event as JSON on its standard input; for cron or a timer every few minutes, syncing first unless --offline")
@@ -23,94 +24,93 @@ export const addRemind = (events, writes, { deps, now, zone, print, example }) =
         .option("--due-within <duration>", "the events that start within this long from now, 1m to 1d", "10m")
         .option("--dry-run", "say what it would remind; run nothing, sync nothing, remember nothing");
     remind.action(async (program, opts, command) => {
-        const within = parseDuration(opts.dueWithin, "--due-within");
-        if (within < REMIND_MIN_MS || within > REMIND_MAX_MS)
+        const dueWithin = parseDuration(opts.dueWithin, "--due-within");
+        if (dueWithin < REMIND_MIN_MS || dueWithin > REMIND_MAX_MS)
             throw new CliError("validation_error", "--due-within takes 1m to 1d", { reason: "remind.window" });
-        const settings = writes.settings();
-        const env = writes.env ?? process.env;
-        const hook = program.length > 0;
-        const defaults = { ...DEFAULT_PERMISSIONS, ...CALENDAR_WRITE_DEFAULTS, ...settings.permissionDefaults };
-        const { level, key: named } = levelFor(settings.permissions, EVENTS_REMIND_HOOK_KEY, defaults);
-        if (hook && !opts.dryRun) {
-            if (settings.readOnlyLock)
-                throw readOnlyRefusal(settings.readOnlyLock, "run a program for a reminder");
-            if (level === "deny" || level === "readonly")
-                throw levelRefusal({
-                    profile: settings.profile,
-                    command: writes.app.command,
-                    key: EVENTS_REMIND_HOOK_KEY,
-                    level,
-                    named,
-                    permissionSources: settings.permissionSources,
-                });
-        }
-        const at = now();
-        const issues = [];
-        const accountName = `${deps.account.provider}:${deps.account.account}`;
-        if (!opts.dryRun && deps.source && !command.optsWithGlobals().offline) {
-            // A reminder from what the store already holds beats none: a failed sync is said in meta and the run goes on.
-            try {
-                // Feeds wait for `sync`: a timer runs this every few minutes, and a feed's server is not Google.
-                const report = await syncCalendars(deps.source, deps.store, {
-                    accountId: deps.accountId,
-                    now: at,
-                    budget: runBudgetOf(command),
-                    ...(deps.expand ? { expand: deps.expand } : {}),
-                });
-                if (report.synced.some((one) => one.error !== undefined))
-                    issues.push({ code: "provider_error", reason: "sync.partial", source: accountName });
-            }
-            catch (error) {
-                issues.push({
-                    code: error instanceof CliError ? error.code : "provider_error",
-                    reason: "sync.failed",
-                    source: accountName,
-                });
+        await within(command, async (run) => {
+            if (!run.writes)
+                throw new CliError("configuration_error", "this profile cannot run reminders");
+            const writes = run.writes();
+            const settings = writes.settings();
+            const env = writes.env ?? process.env;
+            const hook = program.length > 0;
+            const defaults = { ...DEFAULT_PERMISSIONS, ...CALENDAR_WRITE_DEFAULTS, ...settings.permissionDefaults };
+            const { level, key: named } = levelFor(settings.permissions, EVENTS_REMIND_HOOK_KEY, defaults);
+            if (hook && !opts.dryRun) {
+                if (settings.readOnlyLock)
+                    throw readOnlyRefusal(settings.readOnlyLock, "run a program for a reminder");
+                if (level === "deny" || level === "readonly")
+                    throw levelRefusal({
+                        profile: settings.profile,
+                        command: writes.app.command,
+                        key: EVENTS_REMIND_HOOK_KEY,
+                        level,
+                        named,
+                        permissionSources: settings.permissionSources,
+                    });
             }
-        }
-        const window = { from: at, to: at + within };
-        const path = remindersPath(resolvePaths({ appName: writes.app.appName, prefix: writes.app.envPrefix, env }).state, settings.profile);
-        const reminders = opts.dryRun ? undefined : openReminders(path, at);
-        try {
-            const due = await dueEvents(deps.store, deps.accountId, window, reminders?.reminded ?? {});
-            if (hook && !opts.dryRun && due.length > 0 && level === "ask")
-                await terminalAsker(command)(EVENTS_REMIND_HOOK_KEY, { chatId: null, count: due.length });
-            const items = [];
-            const failed = [];
-            for (const details of due) {
-                const item = reminderItem(details);
-                if (hook && !opts.dryRun) {
-                    const exitCode = await runHook(program, `${JSON.stringify(item)}\n`, {
-                        ...env,
-                        [`${writes.app.envPrefix}_PROFILE`]: settings.profile,
-                        [`${writes.app.envPrefix}_EVENT`]: item.ref,
+            const at = now();
+            const issues = [];
+            const accountName = `${run.account.provider}:${run.account.account}`;
+            if (!opts.dryRun && !command.optsWithGlobals().offline) {
+                // A reminder from what the store already holds beats none: a failed sync is said in meta and the run goes on.
+                try {
+                    // Feeds wait for `sync`: a timer runs this every few minutes, and a feed's server is not Google.
+                    const report = await syncCalendars(run.source(), run.store, {
+                        accountId: run.accountId,
+                        now: at,
+                        budget: runBudgetOf(command),
+                        ...(run.expand ? { expand: run.expand } : {}),
+                    });
+                    if (report.synced.some((one) => one.error !== undefined))
+                        issues.push({ code: "provider_error", reason: "sync.partial", source: accountName });
+                }
+                catch (error) {
+                    issues.push({
+                        code: error instanceof CliError ? error.code : "provider_error",
+                        reason: "sync.failed",
+                        source: accountName,
                     });
-                    if (exitCode !== 0) {
-                        failed.push({ ref: item.ref, exit_code: exitCode });
-                        continue;
-                    }
                 }
-                reminders?.remember(details);
-                items.push(item);
             }
-            if (failed.length)
-                throw new CliError("configuration_error", `${program[0]} failed for ${failed.length} of ${due.length} events ` +
-                    `(${failed.map((one) => `${one.ref}: exit ${one.exit_code}`).join(", ")}); the next run tries them again`, { reason: "remind.hook-failed", reminded: items.map(({ ref }) => ref), failed, retryable: true });
-            print({
-                items,
-                page: 1,
-                limit: Math.max(1, items.length),
-                hasMore: false,
-                meta: {
+            const window = { from: at, to: at + dueWithin };
+            const path = remindersPath(resolvePaths({ appName: writes.app.appName, prefix: writes.app.envPrefix, env }).state, settings.profile);
+            const reminders = opts.dryRun ? undefined : openReminders(path, at);
+            try {
+                const due = await dueEvents(run.store, run.accountId, window, reminders?.reminded ?? {});
+                if (hook && !opts.dryRun && due.length > 0 && level === "ask")
+                    await terminalAsker(command)(EVENTS_REMIND_HOOK_KEY, { chatId: null, count: due.length });
+                const items = [];
+                const failed = [];
+                for (const details of due) {
+                    const item = reminderItem(details);
+                    if (hook && !opts.dryRun) {
+                        const exitCode = await runHook(program, `${JSON.stringify(item)}\n`, {
+                            ...env,
+                            [`${writes.app.envPrefix}_PROFILE`]: settings.profile,
+                            [`${writes.app.envPrefix}_EVENT`]: item.ref,
+                        });
+                        if (exitCode !== 0) {
+                            failed.push({ ref: item.ref, exit_code: exitCode });
+                            continue;
+                        }
+                    }
+                    reminders?.remember(details);
+                    items.push(item);
+                }
+                if (failed.length)
+                    throw new CliError("configuration_error", `${program[0]} failed for ${failed.length} of ${due.length} events ` +
+                        `(${failed.map((one) => `${one.ref}: exit ${one.exit_code}`).join(", ")}); the next run tries them again`, { reason: "remind.hook-failed", reminded: items.map(({ ref }) => ref), failed, retryable: true });
+                return listBody(command, { items, page: 1 }, {
                     complete: issues.length === 0,
                     ...(issues.length ? { issues } : {}),
                     window: { since: new Date(window.from).toISOString(), until: new Date(window.to).toISOString() },
                     ...clockMeta(at, zone()),
-                },
-            }, command);
-        }
-        finally {
-            reminders?.close();
-        }
+                });
+            }
+            finally {
+                reminders?.close();
+            }
+        });
     });
 };

package/dist/calendar/cli/search-all.d.ts

@@ -1,17 +1,12 @@
 import { Command } from "commander";
 import type { AppIdentity } from "../../ports/app.js";
-import type { CalendarCommandDeps } from "./index.js";
-interface SearchAllHelpers {
-    /** Read through, never copied: a CLI's deps may be getters that work only once a profile is open. */
-    deps: CalendarCommandDeps;
+import type { CommandHelpers } from "./index.js";
+interface SearchAllHelpers extends Pick<CommandHelpers, "within" | "zone" | "example"> {
     app: AppIdentity;
-    zone: () => string;
-    messages: (what: string) => NonNullable<CalendarCommandDeps["messages"]>;
-    example: (command: Command, ...lines: string[]) => Command;
 }
 /**
  * `search all` beside `search events`: the messenger's shared search over the store, without a messenger server.
  * Events are the calendar's own kind and always read; meeting transcripts only when `--source` names a meeting account.
  */
-export declare const addSearchAll: (searches: Command, { deps, app, zone, messages, example }: SearchAllHelpers) => void;
+export declare const addSearchAll: (searches: Command, { within, app, zone, example }: SearchAllHelpers) => void;
 export {};

package/dist/calendar/cli/search-all.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Command } from "commander";
+import { outputFor } from "../../cli/context.js";
 import { LOCAL_READ } from "../../cli/effects.js";
 import { historySkipsOf } from "../../cli/messenger/history-gaps.js";
 import { allAnswer, offsetOf, SOURCE_SEARCHED } from "../../cli/messenger/search-answers.js";
@@ -8,12 +9,13 @@ import { searchAllLine, searchAllOptions } from "../../cli/messenger/search-comm
 import { SAVE_HELP } from "../../meetings/index.js";
 import { meaningLane } from "../../services/messages-meaning.js";
 import { searchAllWithMeetings } from "../../services/search-all-meetings.js";
+import { messagesOf } from "./bodies.js";
 const DEFAULT_LIMIT = 20;
 /**
  * `search all` beside `search events`: the messenger's shared search over the store, without a messenger server.
  * Events are the calendar's own kind and always read; meeting transcripts only when `--source` names a meeting account.
  */
-export const addSearchAll = (searches, { deps, app, zone, messages, example }) => {
+export const addSearchAll = (searches, { within, app, zone, example }) => {
     const all = annotate(new Command("all"), { effects: LOCAL_READ, partial: true, output: { entity: "hit" } })
         .summary("search stored messages, notes, calendar events and selected meeting transcripts")
         .description("search calendar events, messages from the other WireCat tools and notes in the local store, and a meeting " +
@@ -27,46 +29,49 @@ export const addSearchAll = (searches, { deps, app, zone, messages, example }) =
     example(all, "search all roadmap", 'search all "quarterly review" --source telegram,gcal --json');
     all.action(async (words, _opts, leaf) => {
         const opts = leaf.opts();
-        if (deps.locked && opts.source !== undefined)
-            throw new CliError("permission_error", "this process is locked to one profile; search all reads its own calendar only, without --source", { reason: "profile.locked" });
-        const store = messages("search all");
-        const limit = opts.limit ?? DEFAULT_LIMIT;
-        const offset = offsetOf(opts.page, limit);
-        const env = deps.writes?.env ?? process.env;
-        const found = await searchAllWithMeetings(store, deps.account, {
-            text: words.join(" "),
-            limit,
-            ...(offset === undefined ? {} : { offset }),
-            ...(opts.exact ? { exact: true } : {}),
-            timezone: opts.timezone ?? zone(),
-            env,
-            only: opts.only ?? SOURCE_SEARCHED,
-            ...(opts.source === undefined ? {} : { source: opts.source }),
-            ...(opts.maxMeetings === undefined ? {} : { maxMeetings: opts.maxMeetings }),
-            ...(deps.locked ? { scope: { events: [deps.account] } } : {}),
-        }, { app }, undefined, meaningLane({ env, messenger: { app }, store: async () => store }));
-        const note = deps.note ?? (() => undefined);
-        const globals = leaf.optsWithGlobals();
-        const format = globals.json ? "json" : globals.jsonl ? "jsonl" : "text";
-        if (format === "text")
-            note(`searched: ${found.accounts.map(({ provider, account }) => `${provider}:${account}`).join(", ") || "nothing"}`);
-        for (const { resource, source, reason } of found.skipped)
-            note(`${resource ?? source} not searched: ${reason}`);
-        if (found.notes?.meaningSkipped)
-            note(`notes by words only: ${found.notes.meaningSkipped}`);
-        if (found.events?.meaningSkipped)
-            note(`events by words only: ${found.events.meaningSkipped}`);
-        const again = {
-            query: words.join(" "),
-            ...(opts.only === undefined ? {} : { only: opts.only.join(",") }),
-            ...(opts.source === undefined ? {} : { source: opts.source }),
-            ...(opts.maxMeetings === undefined ? {} : { max_meetings: opts.maxMeetings }),
-            ...(opts.exact ? { exact: true } : {}),
-            ...(opts.timezone === undefined ? {} : { timezone: opts.timezone }),
-        };
-        if (!found.items.length)
-            note("nothing found in what the local store holds");
-        const skips = await historySkipsOf(store, found.accounts).catch(() => []);
-        deps.write(allAnswer("search all", found, { limit, page: opts.page ?? 1, again }, opts.exact === true, skips), format, () => found.items.map(searchAllLine).join(""));
+        let lines = "";
+        await within(leaf, async (run) => {
+            if (run.locked && opts.source !== undefined)
+                throw new CliError("permission_error", "this process is locked to one profile; search all reads its own calendar only, without --source", { reason: "profile.locked" });
+            const store = messagesOf(run, "search all");
+            const limit = opts.limit ?? DEFAULT_LIMIT;
+            const offset = offsetOf(opts.page, limit);
+            const env = run.env ?? process.env;
+            const found = await searchAllWithMeetings(store, run.account, {
+                text: words.join(" "),
+                limit,
+                ...(offset === undefined ? {} : { offset }),
+                ...(opts.exact ? { exact: true } : {}),
+                timezone: opts.timezone ?? zone(),
+                env,
+                only: opts.only ?? SOURCE_SEARCHED,
+                ...(opts.source === undefined ? {} : { source: opts.source }),
+                ...(opts.maxMeetings === undefined ? {} : { maxMeetings: opts.maxMeetings }),
+                ...(run.locked ? { scope: { events: [run.account] } } : {}),
+            }, { app }, undefined, meaningLane({ env, messenger: { app }, store: async () => store }));
+            const note = (text) => outputFor(leaf).renderer.note(text);
+            const globals = leaf.optsWithGlobals();
+            if (!globals.json && !globals.jsonl)
+                note(`searched: ${found.accounts.map(({ provider, account }) => `${provider}:${account}`).join(", ") || "nothing"}`);
+            for (const { resource, source, reason } of found.skipped)
+                note(`${resource ?? source} not searched: ${reason}`);
+            if (found.notes?.meaningSkipped)
+                note(`notes by words only: ${found.notes.meaningSkipped}`);
+            if (found.events?.meaningSkipped)
+                note(`events by words only: ${found.events.meaningSkipped}`);
+            const again = {
+                query: words.join(" "),
+                ...(opts.only === undefined ? {} : { only: opts.only.join(",") }),
+                ...(opts.source === undefined ? {} : { source: opts.source }),
+                ...(opts.maxMeetings === undefined ? {} : { max_meetings: opts.maxMeetings }),
+                ...(opts.exact ? { exact: true } : {}),
+                ...(opts.timezone === undefined ? {} : { timezone: opts.timezone }),
+            };
+            if (!found.items.length)
+                note("nothing found in what the local store holds");
+            const skips = await historySkipsOf(store, found.accounts).catch(() => []);
+            lines = found.items.map(searchAllLine).join("");
+            return allAnswer("search all", found, { limit, page: opts.page ?? 1, again }, opts.exact === true, skips);
+        }, () => lines);
     });
 };

package/dist/calendar/mcp/index.d.ts

@@ -1479,7 +1479,7 @@ export declare const callCalendarTool: (store: EventStore, name: string, input:
     }[];
     structuredContent: {
         error: {
-            code: "authentication_error" | "cancelled" | "configuration_error" | "confirmation_required" | "internal_error" | "invalid_response" | "network_error" | "not_found" | "outcome_unknown" | "permission_error" | "provider_error" | "provider_unavailable" | "rate_limited" | "timeout" | "validation_error";
+            code: "authentication_error" | "cancelled" | "configuration_error" | "confirmation_required" | "conflict" | "internal_error" | "invalid_response" | "network_error" | "not_found" | "outcome_unknown" | "permission_error" | "provider_error" | "provider_unavailable" | "rate_limited" | "timeout" | "validation_error";
             reason: string;
             message: string;
             param?: string | undefined;

package/dist/calendar/prepare.d.ts

@@ -125,7 +125,7 @@ export declare const eventPreparation: (details: EventDetails, options: Preparat
         accounts?: string[] | undefined;
         complete: boolean;
         issues?: {
-            code: "authentication_error" | "cancelled" | "configuration_error" | "confirmation_required" | "invalid_response" | "network_error" | "not_found" | "outcome_unknown" | "permission_error" | "provider_error" | "provider_unavailable" | "rate_limited" | "timeout" | "validation_error";
+            code: "authentication_error" | "cancelled" | "configuration_error" | "confirmation_required" | "conflict" | "invalid_response" | "network_error" | "not_found" | "outcome_unknown" | "permission_error" | "provider_error" | "provider_unavailable" | "rate_limited" | "timeout" | "validation_error";
             reason?: string | undefined;
             source: string;
         }[] | undefined;

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

@@ -1,7 +1,29 @@
-import type { Command } from "commander";
+import { Command } from "commander";
+import type { AppIdentity } from "../../ports/app.js";
+import { type CalendarCommandOptions, type CalendarRun } from "../cli/index.js";
+/** Each item of a printed calendar answer, parsed against the command's declared entity. */
+export declare const checkCalendarAnswer: (root: Command, argv: readonly string[], envelope: unknown) => void;
+export declare const CALENDAR_TEST_APP: AppIdentity;
+/** A printed answer: an item's fields beside `meta` and `next`, or the list's `items` and `page`. */
+export type CalendarAnswer = Record<string, unknown> & {
+    items: Record<string, unknown>[];
+    meta: Record<string, unknown>;
+};
+export interface CalendarTestProgram {
+    root: Command;
+    /** Runs the words with `--json` and gives what was printed, its item spread at the top; checked by its entity. */
+    cli: (...args: string[]) => Promise<CalendarAnswer>;
+    /** Runs the words as a person at a terminal would, and gives the text printed. */
+    text: (...args: string[]) => Promise<string>;
+    /** Every line on stderr. */
+    stderr: string[];
+    /** How many times the profile was opened, and how. */
+    opened: {
+        readOnly: boolean;
+    }[];
+}
 /**
- * Parses what a shared calendar command handed its host against the command's entity, as a host prints it: keys in
- * snake_case, a list's items one by one, a search's hits each with the search's `untrusted`, and no `next`. A `meta`
- * goes into the host's envelope, never into the item.
+ * The shared calendar commands on a bare program over `run`, as an app mounts them, printing to captured streams. A
+ * test of the commands themselves; an app's own tests go through its `run()`.
  */
-export declare const checkCalendarAnswer: (root: Command, argv: readonly string[], value: unknown) => void;
+export declare const calendarTestProgram: (run: CalendarRun, options?: Partial<CalendarCommandOptions>) => CalendarTestProgram;

package/dist/calendar/testing/answers.js

@@ -1,6 +1,8 @@
+import { Command } from "commander";
 import * as v from "valibot";
 import { answerEntitySchema } from "../../cli/answer-entity.js";
-import { snakeKeys } from "../../cli/envelope.js";
+import { provide } from "../../cli/context.js";
+import { addCalendarCommands } from "../cli/index.js";
 const commandAt = (root, argv) => {
     let at = root;
     for (const word of argv) {
@@ -11,28 +13,97 @@ const commandAt = (root, argv) => {
     }
     return at;
 };
-/**
- * Parses what a shared calendar command handed its host against the command's entity, as a host prints it: keys in
- * snake_case, a list's items one by one, a search's hits each with the search's `untrusted`, and no `next`. A `meta`
- * goes into the host's envelope, never into the item.
- */
-export const checkCalendarAnswer = (root, argv, value) => {
+/** Each item of a printed calendar answer, parsed against the command's declared entity. */
+export const checkCalendarAnswer = (root, argv, envelope) => {
     const command = commandAt(root, argv);
     const schema = answerEntitySchema(command);
     if (!schema)
         throw new Error(`${argv.join(" ")} declares no answer entity`);
-    const { next: _next, meta: _meta, ...body } = snakeKeys(value);
-    const marker = body.untrusted
-        ?.filter((field) => field.startsWith("hits."))
-        .map((field) => field.slice("hits.".length));
-    const items = Array.isArray(body.items)
-        ? body.items
-        : Array.isArray(body.hits)
-            ? body.hits.map((hit) => ({ ...hit, untrusted: marker }))
-            : [body];
-    for (const item of items) {
+    const body = envelope;
+    for (const item of body.items ?? [body.item]) {
         const parsed = v.safeParse(schema, item);
         if (!parsed.success)
             throw new Error(`${argv.join(" ")}: ${parsed.issues.map((issue) => `${v.getDotPath(issue) ?? ""} ${issue.message}`).join("; ")}`);
     }
 };
+export const CALENDAR_TEST_APP = {
+    command: "gcal",
+    appName: "gcal-cli",
+    envPrefix: "GCAL",
+    description: "synthetic",
+    version: "1.0.0",
+};
+/**
+ * The shared calendar commands on a bare program over `run`, as an app mounts them, printing to captured streams. A
+ * test of the commands themselves; an app's own tests go through its `run()`.
+ */
+export const calendarTestProgram = (run, options = {}) => {
+    const stderr = [];
+    const opened = [];
+    let data = "";
+    const build = (tty = false) => {
+        const root = new Command("gcal")
+            .exitOverride()
+            .configureOutput({ writeErr: () => undefined, writeOut: () => undefined })
+            .option("--json")
+            .option("--jsonl")
+            .option("--offline")
+            .option("--full")
+            .option("--timeout <duration>")
+            .option("--yes")
+            .option("--dry-run");
+        addCalendarCommands(root, {
+            app: CALENDAR_TEST_APP,
+            open: async (_command, access) => {
+                opened.push(access);
+                return run;
+            },
+            now: () => Date.now(),
+            timezone: "UTC",
+            // A help example names a file; no test writes into the working folder.
+            readFile: async () => "",
+            writeFile: async () => undefined,
+            ...options,
+        });
+        provide(root, {
+            streams: {
+                data: (text) => {
+                    data += text;
+                },
+                diagnostic: (text) => {
+                    stderr.push(text);
+                },
+            },
+            tty,
+        });
+        return root;
+    };
+    const root = build();
+    const cli = async (...args) => {
+        const fresh = build();
+        data = "";
+        const dashes = args.indexOf("--");
+        const argv = args.includes("--json")
+            ? args
+            : dashes < 0
+                ? [...args, "--json"]
+                : [...args.slice(0, dashes), "--json", ...args.slice(dashes)];
+        await fresh.parseAsync(argv, { from: "user" });
+        if (!data.trim())
+            throw new Error(`${args.join(" ")} printed nothing`);
+        const envelope = JSON.parse(data);
+        // A --dry-run preview answers what would happen, not the command's entity.
+        if (!args.includes("--dry-run"))
+            checkCalendarAnswer(fresh, args, envelope);
+        // The run's own facts differ every run; a test compares the rest.
+        const { item, meta, ...rest } = envelope;
+        const { run_id: _run, duration_ms: _duration, ...facts } = meta;
+        return { ...(item ?? {}), ...rest, meta: facts };
+    };
+    const text = async (...args) => {
+        data = "";
+        await build(true).parseAsync(args, { from: "user" });
+        return data;
+    };
+    return { root, cli, text, stderr, opened };
+};

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

@@ -25,4 +25,5 @@ export interface FakeCalendarWriter extends CalendarWriter {
 }
 export declare const fakeCalendarWriter: (options?: {
     provider?: string;
+    now?: () => number;
 }) => FakeCalendarWriter;

package/dist/calendar/testing/writer.js

@@ -1,7 +1,9 @@
 import { CliError } from "@wirecat/cli-base";
 import { calendarConflict } from "../writer.js";
 export const fakeCalendarWriter = (options = {}) => {
+    const now = options.now ?? Date.now;
     const calendars = new Map();
+    const made = new Map();
     const calls = [];
     let version = 0;
     let lose = false;
@@ -89,8 +91,12 @@ export const fakeCalendarWriter = (options = {}) => {
                 participants: [],
             });
             of(calendar.externalId).set(id, entry);
+            made.set(id, now());
             return answer(entry);
         },
+        async quickAdded(calendar, since) {
+            return [...of(calendar.externalId).values()].filter((one) => (made.get(one.externalId) ?? -1) >= since);
+        },
         /** Keeps one event per UID on a calendar: a UID sent again replaces the event under the same id. */
         async importEvent(calendar, event) {
             const held = [...of(calendar.externalId).values()].find((one) => one.icalUid === event.uid);

package/dist/calendar/writer.d.ts

@@ -67,11 +67,16 @@ export interface CalendarWriter {
     }): Promise<EntryInput>;
     /**
      * Optional: the provider makes an event from one line of text, reading its date, time and place its own way. The
-     * provider picks the id, so a retry after `outcome_unknown` may make a second event.
+     * provider picks the id, so a retry after `outcome_unknown` first asks `quickAdded`.
      */
     quickAdd?(calendar: StoredCalendar, text: string, options: {
         notify: boolean;
     }): Promise<EntryInput>;
+    /**
+     * With `quickAdd`: the events this account made on `calendar` at or after `since` (epoch ms), so a retry of a quick
+     * add whose answer was lost finds the event instead of making a second one.
+     */
+    quickAdded?(calendar: StoredCalendar, since: number): Promise<EntryInput[]>;
     /**
      * Optional: adds a private copy of an event read from an iCalendar file, under its own UID, as Google's
      * `events.import`. The provider mails nobody. Sending the same UID again goes to the provider again; what it does

package/dist/calendar/writes.d.ts

@@ -86,10 +86,12 @@ export declare const createEvent: (context: WriteContext, calendarReference: str
 }>;
 /**
  * An event the provider makes from one line of text, as Google's quickAdd. Nobody is mailed unless `notify` says so:
- * the attendees are known only once the provider has read the text.
+ * the attendees are known only once the provider has read the text. The provider picks the event's id, so a retry
+ * with the `id` a lost attempt named first looks for the event that attempt made.
  */
 export declare const createEventFromText: (context: WriteContext, calendarReference: string, text: string, options?: {
     notify?: boolean;
+    id?: string;
 }) => Promise<{
     operation_id: string;
     event: string | null;