@wirecat/cli-core 0.457.0 → 0.458.0

package/dist/calendar/writer.d.ts

@@ -0,0 +1,68 @@
+import { CliError } from "@wirecat/cli-base";
+import type { EntryInput, ParticipantResponse, StoredCalendar } from "../meetings/index.js";
+import type { Level, PermissionKey } from "../sends/permissions.js";
+/**
+ * A new event in neutral words: a timed one has `startsAt` and `endsAt` (epoch ms, end exclusive) in `timezone`; an
+ * all-day one has `startDate` and `endDate` (`YYYY-MM-DD`, end exclusive). Never repeating.
+ */
+export interface EventDraft {
+    title: string;
+    startsAt?: number;
+    endsAt?: number;
+    startDate?: string;
+    endDate?: string;
+    timezone?: string | null;
+    location?: string | null;
+    description?: string | null;
+    attendees?: {
+        email: string;
+        optional?: boolean;
+    }[];
+}
+/** Only the fields to change; `null` clears one. `attendees` replaces the whole list. */
+export type EventPatch = Partial<EventDraft>;
+/** `this`: the one entry named; `series`: the repeating event it belongs to, named by the series' own id. */
+export type WriteScope = "this" | "series";
+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
+ * (Google and CalDAV `If-Match`); a mismatch throws `calendarConflict()`, never overwrites. `notify` says whether the
+ * provider mails the other attendees.
+ */
+export interface CalendarWriter {
+    readonly provider: string;
+    /**
+     * `id` is chosen here and journaled before the call: a create with an id the provider already holds returns that
+     * event instead of making a second one, so a retry after `outcome_unknown` is safe.
+     */
+    create(calendar: StoredCalendar, draft: EventDraft, options: {
+        id: string;
+        notify: boolean;
+    }): Promise<EntryInput>;
+    update(calendar: StoredCalendar, externalId: string, patch: EventPatch, options: {
+        scope: WriteScope;
+        etag: string;
+        notify: boolean;
+    }): Promise<EntryInput>;
+    /** Nothing comes back from a deletion; the store cancels the entry as a sync would. */
+    remove(calendar: StoredCalendar, externalId: string, options: {
+        scope: WriteScope;
+        etag: string;
+        notify: boolean;
+    }): Promise<void>;
+    respond(calendar: StoredCalendar, externalId: string, response: EventResponse, options: {
+        etag: string;
+        notify: boolean;
+    }): Promise<EntryInput>;
+}
+/** Which write a command makes, for `CalendarWrites.extraKeys`. */
+export type CalendarWrite = "create" | "update" | "delete" | "respond";
+/** 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. */
+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

@@ -0,0 +1,17 @@
+import { CliError } from "@wirecat/cli-base";
+/** Mailing the other attendees: an agent may write to the calendar and still not to people (WC-PERM-14's spirit). */
+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. */
+export const CALENDAR_WRITE_DEFAULTS = {
+    "events.create": "ask",
+    "events.update": "ask",
+    "events.respond": "ask",
+    "events.delete": "ask",
+    [EVENTS_DELETE_SERIES_KEY]: "deny",
+    [EVENTS_NOTIFY_KEY]: "deny",
+};
+/** What an adapter throws when the provider refused a write because the entry's `etag` is old (HTTP 412). */
+export const calendarConflict = (message = "the event changed at the provider since the last sync") => new CliError("validation_error", `${message}; sync and try again`, { reason: "event.conflict" });

package/dist/calendar/writes.d.ts

@@ -0,0 +1,128 @@
+import type { EventStore } from "../meetings/index.js";
+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";
+/** What a CLI or an MCP host hands the calendar writes for one profile. */
+export interface CalendarWrites {
+    writer: CalendarWriter;
+    app: AppIdentity;
+    /** The profile's levels, read on every write so a config change applies at once. */
+    settings: () => GuardSettings;
+    /**
+     * Keys a write must also pass beyond its command path, so denying them cannot be bypassed through the shared
+     * commands: gcal names its generated API's (`api.calendar.events.insert`).
+     */
+    extraKeys?: (write: CalendarWrite) => readonly PermissionKey[];
+    env?: NodeJS.ProcessEnv;
+    warn?: Warn;
+}
+export declare const EVENT_RESPONSES: readonly EventResponse[];
+/** An event's fields as typed: times in the caller's zone; an all-day event's dates, `endDate` its last day. */
+export interface EventFields {
+    title?: string;
+    startTime?: string;
+    endTime?: string;
+    startDate?: string;
+    endDate?: string;
+    location?: string;
+    description?: string;
+    attendees?: string[];
+}
+export interface WriteContext {
+    store: EventStore;
+    accountId: number;
+    writes: CalendarWrites;
+    /** A terminal's question, or an agent's go-ahead (WC-MCP-7). */
+    ask: Asker;
+    now: number;
+    zone: string;
+    /** How the caller spells an input in a hint: `--notify or --no-notify` on the command line, `notify` over MCP. */
+    names: {
+        notify: string;
+        id: string;
+        calendar: string;
+        series: string;
+    };
+}
+/** Typed fields into a draft, or into a patch with only what was given. */
+export declare const draftOf: (fields: EventFields, zone: string, { whole }: {
+    whole: boolean;
+}) => EventPatch;
+/** An id every provider takes as a client-chosen one: Google's base32hex `[a-v0-9]`, a CalDAV UID, a Graph id. */
+export declare const newEventId: () => string;
+export declare const createEvent: (context: WriteContext, calendarReference: string, fields: EventFields, options?: {
+    notify?: boolean;
+    id?: string;
+}) => Promise<{
+    operation_id: string;
+    event: string | null;
+    entry: {
+        id: string;
+        calendar_id: string;
+        external_id: string;
+        kind: import("../meetings/event-store.js").EntryKind;
+        status: import("../meetings/event-store.js").EntryStatus;
+        event_type: import("../meetings/event-store.js").EntryEventType | null;
+        own_response: import("../meetings/event-store.js").ParticipantResponse | null;
+        starts_at: string | null;
+        ends_at: string | null;
+        join_url: string | null;
+        url: string | null;
+        deleted_at: string | null;
+    } | null;
+}>;
+export declare const updateEvent: (context: WriteContext, reference: string, fields: EventFields, options?: {
+    calendar?: string;
+    series?: boolean;
+    notify?: boolean;
+}) => Promise<{
+    operation_id: string;
+    event: string | null;
+    entry: {
+        id: string;
+        calendar_id: string;
+        external_id: string;
+        kind: import("../meetings/event-store.js").EntryKind;
+        status: import("../meetings/event-store.js").EntryStatus;
+        event_type: import("../meetings/event-store.js").EntryEventType | null;
+        own_response: import("../meetings/event-store.js").ParticipantResponse | null;
+        starts_at: string | null;
+        ends_at: string | null;
+        join_url: string | null;
+        url: string | null;
+        deleted_at: string | null;
+    } | null;
+}>;
+export declare const deleteEvent: (context: WriteContext, reference: 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;
+    entry: {
+        id: string;
+        calendar_id: string;
+        external_id: string;
+        kind: import("../meetings/event-store.js").EntryKind;
+        status: import("../meetings/event-store.js").EntryStatus;
+        event_type: import("../meetings/event-store.js").EntryEventType | null;
+        own_response: import("../meetings/event-store.js").ParticipantResponse | null;
+        starts_at: string | null;
+        ends_at: string | null;
+        join_url: string | null;
+        url: string | null;
+        deleted_at: string | null;
+    } | null;
+}>;

package/dist/calendar/writes.js

@@ -0,0 +1,237 @@
+import { randomUUID } from "node:crypto";
+import { CliError, isCliError } from "@wirecat/cli-base";
+import { zonedMoment } from "@wirecat/cli-base/query";
+import { guardFor } from "../sends/guard.js";
+import { guardedWrite } from "../sends/guarded.js";
+import { DEFAULT_PERMISSIONS, levelFor } from "../sends/permissions.js";
+import { newOperationId } from "../sends/send-id.js";
+import { calendarIn, entryItem, eventIdOf, eventOf, plusDays } from "./reads.js";
+import { CALENDAR_WRITE_DEFAULTS, EVENTS_DELETE_SERIES_KEY, EVENTS_NOTIFY_KEY, } from "./writer.js";
+export const EVENT_RESPONSES = ["accepted", "tentative", "declined"];
+/** Each write is checked by its command's path, the key a declared CLI's `commandPermissions` already knows. */
+const COMMAND_KEY = {
+    create: "events.create",
+    update: "events.update",
+    delete: "events.delete",
+    respond: "events.respond",
+};
+const DATE = /^\d{4}-\d{2}-\d{2}$/u;
+const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/u;
+const dateOf = (text, what) => {
+    const [year, month, day] = text.split("-").map(Number);
+    if (!DATE.test(text) || new Date(Date.UTC(year, month - 1, day)).toISOString().slice(0, 10) !== text)
+        throw new CliError("validation_error", `${what} of an all-day event is a date, YYYY-MM-DD`);
+    return text;
+};
+const momentOf = (text, zone) => zonedMoment(text, zone, { start: 0, end: text.length });
+/** Typed fields into a draft, or into a patch with only what was given. */
+export const draftOf = (fields, zone, { whole }) => {
+    const patch = {};
+    if (fields.title !== undefined) {
+        if (!fields.title.trim())
+            throw new CliError("validation_error", "an event needs a title");
+        patch.title = fields.title.trim();
+    }
+    else if (whole)
+        throw new CliError("validation_error", "an event needs a title");
+    const timed = fields.startTime !== undefined || fields.endTime !== undefined;
+    const dated = fields.startDate !== undefined || fields.endDate !== undefined;
+    if (timed && dated)
+        throw new CliError("validation_error", "an event has start and end times, or dates, not both");
+    if (timed || dated || whole) {
+        const [start, end] = dated ? [fields.startDate, fields.endDate] : [fields.startTime, fields.endTime];
+        if (start === undefined || end === undefined)
+            throw new CliError("validation_error", "an event needs its start and its end");
+        if (dated) {
+            patch.startDate = dateOf(start, "the start");
+            patch.endDate = plusDays(dateOf(end, "the end"), 1);
+            if (patch.endDate <= patch.startDate)
+                throw new CliError("validation_error", "the event ends before it starts");
+        }
+        else {
+            patch.startsAt = momentOf(start, zone);
+            patch.endsAt = momentOf(end, zone);
+            if (patch.endsAt <= patch.startsAt)
+                throw new CliError("validation_error", "the event ends before it starts");
+        }
+        patch.timezone = zone;
+    }
+    if (fields.location !== undefined)
+        patch.location = fields.location.trim() || null;
+    if (fields.description !== undefined)
+        patch.description = fields.description.trim() || null;
+    if (fields.attendees !== undefined)
+        patch.attendees = [...new Set(fields.attendees.map((one) => one.trim().toLowerCase()))].map((email) => {
+            if (!EMAIL.test(email))
+                throw new CliError("validation_error", `${email} is not an email address`);
+            return { email };
+        });
+    if (!whole && Object.keys(patch).length === 0)
+        throw new CliError("validation_error", "nothing to change");
+    return patch;
+};
+/**
+ * Over the profile's guard, the write's other keys are checked too. A key that refuses is refused before anything is
+ * asked, so nobody answers yes to a write that a stricter key then stops, and one answer covers every key of a write.
+ */
+const writeGuard = (context, extra) => {
+    const settings = context.writes.settings();
+    const defaults = { ...DEFAULT_PERMISSIONS, ...CALENDAR_WRITE_DEFAULTS, ...settings.permissionDefaults };
+    let question;
+    let answered = false;
+    const guard = guardFor(context.writes.app, { ...settings, permissionDefaults: defaults }, context.writes.warn ?? (() => { }), context.writes.env, async (key, request) => {
+        if (answered)
+            return;
+        await context.ask(question ?? key, request);
+        answered = true;
+    });
+    const probes = new WeakMap();
+    // A probe is checked and never journaled or counted: the write itself holds the one journal line.
+    const all = (request) => {
+        let found = probes.get(request);
+        if (!found) {
+            found = extra.map((key) => ({ chatId: null, kind: "read", key }));
+            probes.set(request, found);
+        }
+        return [request, ...found];
+    };
+    return {
+        ask: async (request) => {
+            const levelOf = ({ key }) => levelFor(settings.permissions, key, defaults).level;
+            const refused = all(request).find((one) => ["deny", "readonly"].includes(levelOf(one)));
+            if (refused)
+                guard.check(refused, { reserve: false });
+            // The one question names every key that asks, so a yes to the write is never a silent yes to mailing people.
+            question = all(request)
+                .filter((one) => levelOf(one) === "ask")
+                .map(({ key }) => key)
+                .join(" and ");
+            for (const one of all(request))
+                await guard.ask?.(one);
+        },
+        check: (request, options) => {
+            for (const one of all(request).slice(1))
+                guard.check(one, { reserve: false });
+            guard.check(request, options);
+        },
+        ...(guard.reserve ? { reserve: guard.reserve } : {}),
+        record: (entry) => guard.record(entry),
+    };
+};
+const notifyOf = (context, choice, others) => {
+    if (choice !== undefined)
+        return choice;
+    if (others)
+        throw new CliError("validation_error", `the event has attendees other than you: say whether the provider mails them (${context.names.notify})`, { reason: "event.notify-required", param: context.names.notify });
+    return false;
+};
+const hasOthers = (participants) => participants.some((one) => !one.self && !one.resource);
+const keysFor = (context, write, notify) => [
+    ...(context.writes.extraKeys?.(write) ?? []),
+    ...(notify ? [EVENTS_NOTIFY_KEY] : []),
+];
+const answerOf = (operationId, saved) => ({
+    operation_id: operationId,
+    event: saved?.eventId == null ? null : `event:${saved.eventId}`,
+    entry: saved ? entryItem(saved) : null,
+});
+/** An id every provider takes as a client-chosen one: Google's base32hex `[a-v0-9]`, a CalDAV UID, a Graph id. */
+export const newEventId = () => randomUUID().replaceAll("-", "");
+const ID = /^[a-z0-9]{5,1024}$/u;
+export const createEvent = async (context, calendarReference, fields, options = {}) => {
+    const calendar = await calendarIn(context.store, context.accountId, calendarReference);
+    const draft = draftOf(fields, context.zone, { whole: true });
+    if (options.id !== undefined && !ID.test(options.id))
+        throw new CliError("validation_error", `${context.names.id} is the id a create's outcome_unknown named`, {
+            param: context.names.id,
+        });
+    const notify = notifyOf(context, options.notify, (draft.attendees?.length ?? 0) > 0);
+    const id = options.id ?? newEventId();
+    const guard = writeGuard(context, keysFor(context, "create", notify));
+    let entry;
+    try {
+        entry = await guardedWrite(guard, { chatId: null, kind: "edit", key: COMMAND_KEY.create, operationId: id, sendId: id, notify }, () => context.writes.writer.create(calendar, draft, { id, notify }));
+    }
+    catch (error) {
+        if (isCliError(error) && error.code === "outcome_unknown")
+            throw new CliError("outcome_unknown", `${error.message} — repeat the create with ${context.names.id} ${id}: the provider then finds the event ` +
+                "instead of making a second one", { ...error.details, operation_id: id });
+        throw error;
+    }
+    const [saved] = await context.store.saveEntries(calendar.id, [entry], context.now);
+    return answerOf(id, saved);
+};
+const targetOf = async (context, reference, { calendar, scope }) => {
+    const details = await eventOf(context.store, context.accountId, eventIdOf(reference));
+    const calendars = await context.store.calendars(context.accountId);
+    const only = calendar === undefined ? undefined : await calendarIn(context.store, context.accountId, calendar);
+    const live = details.entries.filter((one) => one.deletedAt === null && one.status !== "cancelled" && (!only || one.calendarId === only.id));
+    const [entry] = live;
+    if (!entry)
+        throw new CliError("not_found", `${reference} has no live copy${only ? ` on calendar ${only.id}` : ""}`);
+    if (live.length > 1)
+        throw new CliError("validation_error", `${reference} is on calendars ${live.map(({ calendarId }) => calendarId).join(", ")}; name one with ` +
+            `${context.names.calendar}`, { param: context.names.calendar });
+    let target = entry;
+    if (scope === "series") {
+        if (entry.kind !== "occurrence" || !entry.seriesExternalId)
+            throw new CliError("validation_error", `${reference} does not repeat; leave out ${context.names.series}`, {
+                param: context.names.series,
+            });
+        const series = await context.store.entry(entry.calendarId, entry.seriesExternalId);
+        if (!series)
+            throw new CliError("not_found", `the series of ${reference} is not stored; sync and try again`);
+        target = series;
+    }
+    if (!target.etag)
+        throw new CliError("validation_error", `no provider version is stored for ${reference}; sync and try again`, {
+            reason: "event.conflict",
+            sent: false,
+        });
+    return {
+        calendar: calendars.find(({ id }) => id === entry.calendarId),
+        entry,
+        target,
+        participants: details.participants.filter(({ entryId }) => entryId === entry.id),
+    };
+};
+export const updateEvent = async (context, reference, fields, options = {}) => {
+    const patch = draftOf(fields, context.zone, { whole: false });
+    const scope = options.series ? "series" : "this";
+    const { calendar, target, participants } = await targetOf(context, reference, { ...options, scope });
+    const notify = notifyOf(context, options.notify, hasOthers(participants) || (patch.attendees?.length ?? 0) > 0);
+    const operationId = newOperationId();
+    const entry = await guardedWrite(writeGuard(context, keysFor(context, "update", notify)), { chatId: null, kind: "edit", key: COMMAND_KEY.update, operationId, notify }, () => context.writes.writer.update(calendar, target.externalId, patch, { scope, etag: target.etag, notify }));
+    const [saved] = await context.store.saveEntries(calendar.id, [entry], context.now);
+    return answerOf(operationId, saved);
+};
+export const deleteEvent = async (context, reference, options = {}) => {
+    const scope = options.series ? "series" : "this";
+    const { calendar, entry, target, participants } = await targetOf(context, reference, { ...options, scope });
+    const notify = notifyOf(context, options.notify, hasOthers(participants));
+    const operationId = newOperationId();
+    await guardedWrite(writeGuard(context, keysFor(context, "delete", notify)), {
+        chatId: null,
+        kind: "edit",
+        key: scope === "series" ? EVENTS_DELETE_SERIES_KEY : COMMAND_KEY.delete,
+        operationId,
+        notify,
+    }, () => context.writes.writer.remove(calendar, target.externalId, { scope, etag: target.etag, notify }));
+    const removed = await context.store.removeEntries(calendar.id, [target.externalId], context.now);
+    return {
+        operation_id: operationId,
+        event: entry.eventId === null ? null : `event:${entry.eventId}`,
+        scope,
+        removed,
+    };
+};
+export const respondToEvent = async (context, reference, response, options = {}) => {
+    if (!EVENT_RESPONSES.includes(response))
+        throw new CliError("validation_error", `a response is one of ${EVENT_RESPONSES.join(", ")}`);
+    const { calendar, target, participants } = await targetOf(context, reference, { ...options, scope: "this" });
+    const notify = notifyOf(context, options.notify, hasOthers(participants));
+    const operationId = newOperationId();
+    const entry = await guardedWrite(writeGuard(context, keysFor(context, "respond", notify)), { chatId: null, kind: "edit", key: COMMAND_KEY.respond, operationId, notify }, () => context.writes.writer.respond(calendar, target.externalId, response, { etag: target.etag, notify }));
+    const [saved] = await context.store.saveEntries(calendar.id, [entry], context.now);
+    return answerOf(operationId, saved);
+};

package/dist/cli/messenger/store-maintenance-command.d.ts

@@ -3,9 +3,9 @@ import type { CacheDatabase } from "../../store/driver.js";
 import type { Messenger } from "./context.js";
 /** `doctor`'s short summary of the store. Must answer for a broken file, so an error is a field. */
 export declare const storeSummary: (env: NodeJS.ProcessEnv) => Promise<{
+    error?: undefined;
     path: string;
     exists: boolean;
-    error?: undefined;
 } | {
     path: string;
     exists: boolean;

package/dist/errors/reasons.js

@@ -54,6 +54,8 @@ const OTHERS = [
     validation("spreadsheet.unreadable", "the workbook could not be read"),
     ["state.invalid", "configuration_error", "the saved sync state is unreadable or invalid; it is kept, not reset"],
     ["sync.partial", "provider_error", "some calendars did not sync; the next sync retries them"],
+    validation("event.conflict", "the event changed at the provider since the last sync; sync and try again"),
+    validation("event.notify-required", "the event has other attendees; say whether to notify them"),
     validation("store.refused", "the local store refused the document text"),
     ["store.not-writable", "permission_error", "the message store cannot be written from this process"],
     [

package/dist/meetings/event-store.d.ts

@@ -140,6 +140,8 @@ export interface StoredEntry {
     joinKey: string | null;
     url: string | null;
     externalUpdatedAt: number | null;
+    /** The provider's version of the entry, sent back with a write so a change made since the last sync is refused. */
+    etag: string | null;
     seenAt: number | null;
     deletedAt: number | null;
 }
@@ -239,6 +241,8 @@ export interface EventStore {
     cursor(calendarId: number): Promise<string | null>;
     /** `null` forgets the cursor, so the next sync is a full list. */
     setCursor(calendarId: number, value: string | null, now: number): Promise<void>;
+    /** One entry by the provider's id; a series, which no event holds, is found only this way. */
+    entry(calendarId: number, externalId: string): Promise<StoredEntry | null>;
     events(filter?: EventFilter): Promise<Event[]>;
     event(id: number): Promise<EventDetails | null>;
     /** The owner's link of an entry to an event; no rule replaces it. */

package/dist/store/sqlite/calendar.js

@@ -48,6 +48,7 @@ const entryOf = (row) => ({
     joinKey: str(row.join_key),
     url: str(row.url),
     externalUpdatedAt: int(row.external_updated_at),
+    etag: str(row.etag),
     seenAt: int(row.seen_at),
     deletedAt: int(row.deleted_at),
 });
@@ -513,6 +514,12 @@ export const eventStoreOver = (context) => {
                     refreshEvent(eventId, now);
             return marked.length;
         }),
+        entry: async (calendarId, externalId) => read(database, () => {
+            const row = database
+                .prepare("SELECT * FROM calendar_entries WHERE calendar_id = ? AND external_id = ?")
+                .get(calendarId, externalId);
+            return row ? entryOf(row) : null;
+        }),
         cursor: async (calendarId) => read(database, () => {
             const { account_id } = calendarRow(calendarId);
             return str(database

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.457.0",
+  "version": "0.458.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",