@wirecat/cli-core 0.396.0 → 0.398.0

package/dist/services/media-archive-locks.js

@@ -0,0 +1,71 @@
+import { mkdir, realpath } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { CliError } from "@wirecat/cli-base";
+import { acquireLock } from "../files/index.js";
+import { missingMediaFile, readMediaManifests } from "./media-archive-manifest.js";
+const archiveLocations = async (initial, signal) => {
+    const roots = new Set();
+    const queued = new Set(initial.map((directory) => resolve(directory)));
+    const pending = [...queued];
+    for (let at = 0; at < pending.length; at++) {
+        signal?.throwIfAborted();
+        let root;
+        try {
+            root = await realpath(pending[at]);
+        }
+        catch (error) {
+            if (missingMediaFile(error))
+                continue;
+            throw error;
+        }
+        if (roots.has(root))
+            continue;
+        if (roots.size >= 64)
+            throw new CliError("validation_error", "too many linked media archive directories");
+        roots.add(root);
+        for (const entry of await readMediaManifests(root, signal))
+            if (entry.relocatedTo) {
+                const location = resolve(entry.relocatedTo);
+                if (!queued.has(location)) {
+                    queued.add(location);
+                    pending.push(location);
+                }
+            }
+    }
+    return [...roots].sort();
+};
+/** Acquire in canonical path order, then recheck the graph before trusting relocation records. */
+export const withMediaArchiveLocks = async (directory, signal, run, options = {}) => {
+    signal?.throwIfAborted();
+    if (options.create)
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+    const root = await realpath(directory);
+    if (options.createAdditional)
+        for (const other of options.additional ?? [])
+            await mkdir(other, { recursive: true, mode: 0o700 });
+    const initial = [root, ...(options.additional ?? [])];
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const locations = await archiveLocations(initial, signal);
+        const leases = [];
+        try {
+            for (const location of locations)
+                leases.push(await acquireLock(join(location, ".media-writers"), { signal }));
+            const current = await archiveLocations(initial, signal);
+            if (current.some((location) => !locations.includes(location)))
+                continue;
+            const beforeWrite = async () => {
+                signal?.throwIfAborted();
+                for (const lease of leases)
+                    if (!(await lease.held()))
+                        throw new CliError("validation_error", "media archive writer lost its lock");
+            };
+            await beforeWrite();
+            return await run(root, beforeWrite);
+        }
+        finally {
+            for (const lease of leases.reverse())
+                await lease.release();
+        }
+    }
+    throw new CliError("validation_error", "archive locations changed during locking; run the command again");
+};

package/dist/services/media-archive-manifest.d.ts

@@ -0,0 +1,29 @@
+export interface MediaIdentity {
+    provider: string;
+    account: string;
+    chat: string;
+    message: string;
+    position: number;
+}
+export interface MediaArchiveEntry extends MediaIdentity {
+    version: 1;
+    kind: string;
+    path: string;
+    size: number;
+    sha256: string;
+    messageTime?: string;
+    mime?: string;
+    relocatedTo?: string;
+}
+export declare const mediaKey: (one: MediaIdentity) => string;
+export declare const mediaManifestName: (one: MediaIdentity) => string;
+export declare const missingMediaFile: (error: unknown) => boolean;
+export declare const parseMediaEntry: (value: unknown) => MediaArchiveEntry;
+export declare const mediaFingerprint: (path: string, signal?: AbortSignal) => Promise<{
+    size: number;
+    sha256: string;
+}>;
+export declare const readMediaManifests: (root: string, signal?: AbortSignal) => Promise<MediaArchiveEntry[]>;
+export declare const verifyMediaEntry: (root: string, one: MediaArchiveEntry, signal?: AbortSignal) => Promise<boolean>;
+export declare const sameMediaCopy: (a: MediaArchiveEntry, b: MediaArchiveEntry) => boolean;
+export declare const commitMediaEntry: (root: string, one: MediaArchiveEntry, beforePublish: () => Promise<void>) => Promise<void>;

package/dist/services/media-archive-manifest.js

@@ -0,0 +1,116 @@
+import { createHash } from "node:crypto";
+import { readdir } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+import { CliError } from "@wirecat/cli-base";
+import { openOrdinaryFile, readBoundedUtf8File, writeFileAtomic } from "../files/index.js";
+export const mediaKey = (one) => createHash("sha256")
+    .update(JSON.stringify([one.provider, one.account, one.chat, one.message, one.position]))
+    .digest("hex");
+export const mediaManifestName = (one) => `.media-archive-${mediaKey(one)}.json`;
+export const missingMediaFile = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+export const parseMediaEntry = (value) => {
+    const one = value;
+    if (!one ||
+        typeof one !== "object" ||
+        Array.isArray(one) ||
+        one.version !== 1 ||
+        Object.keys(one).some((key) => ![
+            "account",
+            "chat",
+            "kind",
+            "message",
+            "path",
+            "position",
+            "provider",
+            "sha256",
+            "size",
+            "version",
+            "messageTime",
+            "mime",
+            "relocatedTo",
+        ].includes(key)) ||
+        (one.messageTime !== undefined &&
+            (typeof one.messageTime !== "string" ||
+                !Number.isFinite(Date.parse(one.messageTime)) ||
+                new Date(one.messageTime).toISOString() !== one.messageTime)) ||
+        (one.mime !== undefined &&
+            (typeof one.mime !== "string" || one.mime.length > 127 || !/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/.test(one.mime))) ||
+        (one.relocatedTo !== undefined &&
+            (typeof one.relocatedTo !== "string" || !isAbsolute(one.relocatedTo) || /[\p{Cc}]/u.test(one.relocatedTo))) ||
+        [one.provider, one.account, one.chat, one.message, one.kind].some((text) => typeof text !== "string" || !text.trim() || text.length > 512 || /[\0\r\n]/.test(text)) ||
+        !Number.isSafeInteger(one.position) ||
+        one.position < 0 ||
+        !Number.isSafeInteger(one.size) ||
+        one.size < 0 ||
+        typeof one.sha256 !== "string" ||
+        !/^[a-f0-9]{64}$/.test(one.sha256) ||
+        one.path !== `${mediaKey(one)}.bin`)
+        throw new CliError("validation_error", "invalid media archive manifest");
+    return { ...one };
+};
+export const mediaFingerprint = async (path, signal) => {
+    signal?.throwIfAborted();
+    const file = await openOrdinaryFile(path);
+    try {
+        const hash = createHash("sha256");
+        let size = 0;
+        for await (const chunk of file.createReadStream({ autoClose: false, ...(signal ? { signal } : {}) })) {
+            signal?.throwIfAborted();
+            hash.update(chunk);
+            size += chunk.length;
+        }
+        return { size, sha256: hash.digest("hex") };
+    }
+    finally {
+        await file.close();
+    }
+};
+export const readMediaManifests = async (root, signal) => {
+    const entries = [];
+    for (const name of await readdir(root)) {
+        signal?.throwIfAborted();
+        if (!name.startsWith(".media-archive-") || !name.endsWith(".json"))
+            continue;
+        let one;
+        try {
+            one = parseMediaEntry(JSON.parse(await readBoundedUtf8File(join(root, name), { maxBytes: 16384 })));
+        }
+        catch {
+            throw new CliError("validation_error", "invalid media archive manifest");
+        }
+        if (name !== mediaManifestName(one))
+            throw new CliError("validation_error", "media manifest identity mismatch");
+        entries.push(one);
+    }
+    return entries;
+};
+export const verifyMediaEntry = async (root, one, signal) => {
+    let location = resolve(root);
+    let entry = one;
+    const visited = new Set();
+    while (entry.relocatedTo !== undefined) {
+        signal?.throwIfAborted();
+        if (visited.has(location) || visited.size >= 64)
+            throw new CliError("validation_error", "media archive relocation cycle or excessive depth");
+        visited.add(location);
+        location = resolve(entry.relocatedTo);
+        const target = parseMediaEntry(JSON.parse(await readBoundedUtf8File(join(location, mediaManifestName(one)), { maxBytes: 16384 })));
+        if (!sameMediaCopy(one, target))
+            return false;
+        entry = target;
+    }
+    if (visited.has(location))
+        return false;
+    const actual = await mediaFingerprint(join(location, one.path), signal);
+    return actual.size === one.size && actual.sha256 === one.sha256;
+};
+export const sameMediaCopy = (a, b) => mediaKey(a) === mediaKey(b) &&
+    a.size === b.size &&
+    a.sha256 === b.sha256 &&
+    a.kind === b.kind &&
+    a.messageTime === b.messageTime &&
+    a.mime === b.mime;
+export const commitMediaEntry = (root, one, beforePublish) => writeFileAtomic(join(root, mediaManifestName(one)), JSON.stringify(parseMediaEntry(one)), {
+    overwrite: false,
+    beforePublish,
+});

package/dist/services/media-archive-move.d.ts

@@ -0,0 +1,21 @@
+export interface MoveMediaArchiveOptions {
+    directory: string;
+    archiveDirectory: string;
+    beforeTime: string;
+    dryRun?: boolean;
+    signal?: AbortSignal;
+}
+/** The destination is durable before a source relocation record is published, then the verified local copy is removed. */
+export declare const moveMediaArchive: (options: MoveMediaArchiveOptions) => Promise<{
+    directory: string;
+    archiveDirectory: string;
+    beforeTime: string;
+    selected: number;
+    selectedBytes: number;
+    moved: number;
+    movedBytes: number;
+    alreadyArchived: number;
+    undated: number;
+    complete: boolean;
+    dryRun: boolean;
+}>;

package/dist/services/media-archive-move.js

@@ -0,0 +1,163 @@
+import { realpath, unlink } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { CliError } from "@wirecat/cli-base";
+import { openOrdinaryFile, sameOrdinaryFile, syncDirectory, writeFileAtomic } from "../files/index.js";
+import { validateMediaSince } from "./media-archive.js";
+import { archiveMediaFile } from "./media-archive-files.js";
+import { withMediaArchiveLocks } from "./media-archive-locks.js";
+import { mediaFingerprint, mediaKey, mediaManifestName, missingMediaFile, parseMediaEntry, readMediaManifests, sameMediaCopy, verifyMediaEntry, } from "./media-archive-manifest.js";
+const canonicalDestination = async (directory) => {
+    const path = resolve(directory);
+    try {
+        return await realpath(path);
+    }
+    catch (error) {
+        if (!missingMediaFile(error) || dirname(path) === path)
+            throw error;
+        return join(await canonicalDestination(dirname(path)), basename(path));
+    }
+};
+const image = (entry) => ["photo", "image"].includes(entry.kind) || entry.mime?.startsWith("image/");
+const removeLocalCopy = async (root, entry, beforeWrite, signal) => {
+    const path = join(root, entry.path);
+    let file;
+    try {
+        file = await openOrdinaryFile(path);
+    }
+    catch (error) {
+        if (missingMediaFile(error))
+            return;
+        throw error;
+    }
+    try {
+        const identity = await file.stat({ bigint: true });
+        const proof = await mediaFingerprint(path, signal);
+        if (proof.size !== entry.size || proof.sha256 !== entry.sha256 || !(await sameOrdinaryFile(path, identity)))
+            throw new CliError("validation_error", "local image changed during rotation; it was preserved");
+        if (!(await verifyMediaEntry(root, entry, signal)))
+            throw new CliError("validation_error", "rotated image checksum mismatch; the local copy was preserved");
+        await beforeWrite();
+        if (!(await sameOrdinaryFile(path, identity)))
+            throw new CliError("validation_error", "local image was replaced; it was preserved");
+        await unlink(path);
+        await syncDirectory(root);
+    }
+    finally {
+        await file.close();
+    }
+};
+/** The destination is durable before a source relocation record is published, then the verified local copy is removed. */
+export const moveMediaArchive = async (options) => {
+    const cutoff = validateMediaSince(options.beforeTime, "--before-time");
+    if (cutoff === undefined)
+        throw new CliError("validation_error", "--before-time is required");
+    const target = await canonicalDestination(options.archiveDirectory);
+    const source = await realpath(options.directory);
+    if (source === target)
+        throw new CliError("validation_error", "choose a different archive destination");
+    return withMediaArchiveLocks(source, options.signal, async (root, beforeWrite) => {
+        const entries = await readMediaManifests(root, options.signal);
+        if (!entries.length)
+            throw new CliError("not_found", "no media archive manifests in this directory");
+        const targetEntries = await readMediaManifests(target, options.signal).catch((error) => {
+            if (options.dryRun && missingMediaFile(error))
+                return [];
+            throw error;
+        });
+        for (const [folder, manifests] of [
+            [root, entries],
+            [target, targetEntries],
+        ])
+            for (const entry of manifests) {
+                let valid = false;
+                try {
+                    valid = await verifyMediaEntry(folder, entry, options.signal);
+                }
+                catch {
+                    options.signal?.throwIfAborted();
+                }
+                if (!valid)
+                    throw new CliError("validation_error", "archive checksum mismatch or missing file; no images were moved");
+            }
+        const known = new Map(targetEntries.map((entry) => [mediaKey(entry), entry]));
+        let selected = 0, moved = 0, movedBytes = 0, selectedBytes = 0, undated = 0, alreadyArchived = 0;
+        const candidates = [];
+        for (const entry of entries) {
+            if (!image(entry))
+                continue;
+            if (!entry.messageTime) {
+                undated++;
+                continue;
+            }
+            if (Date.parse(entry.messageTime) >= cutoff)
+                continue;
+            if (entry.relocatedTo) {
+                alreadyArchived++;
+                if (!options.dryRun)
+                    await removeLocalCopy(root, entry, beforeWrite, options.signal);
+                continue;
+            }
+            const existing = known.get(mediaKey(entry));
+            if (existing?.relocatedTo)
+                throw new CliError("validation_error", "destination image is already relocated; choose its current archive directory");
+            if (existing && !sameMediaCopy(entry, existing))
+                throw new CliError("validation_error", "destination has a different copy of this image; choose a new destination");
+            candidates.push(entry);
+            selected++;
+            selectedBytes += entry.size;
+        }
+        if (!options.dryRun)
+            for (const entry of candidates) {
+                await beforeWrite();
+                if (!known.has(mediaKey(entry))) {
+                    const file = await openOrdinaryFile(join(root, entry.path));
+                    try {
+                        const identity = {
+                            provider: entry.provider,
+                            account: entry.account,
+                            chat: entry.chat,
+                            message: entry.message,
+                            position: entry.position,
+                        };
+                        const copied = await archiveMediaFile(target, identity, entry.kind, async () => ({
+                            kind: entry.kind,
+                            size: entry.size,
+                            bytes: () => file.createReadStream({ autoClose: false, ...(options.signal ? { signal: options.signal } : {}) }),
+                        }), beforeWrite, options.signal, {
+                            messageTime: entry.messageTime,
+                            mime: entry.mime,
+                            expected: { size: entry.size, sha256: entry.sha256 },
+                        });
+                        known.set(mediaKey(entry), copied);
+                    }
+                    finally {
+                        await file.close();
+                    }
+                }
+                const receipt = parseMediaEntry({ ...entry, relocatedTo: target });
+                if (!(await verifyMediaEntry(root, receipt, options.signal)))
+                    throw new CliError("validation_error", "archive destination changed before rotation; the original was preserved");
+                await beforeWrite();
+                await writeFileAtomic(join(root, mediaManifestName(entry)), JSON.stringify(receipt), {
+                    beforePublish: beforeWrite,
+                    signal: options.signal,
+                });
+                await removeLocalCopy(root, receipt, beforeWrite, options.signal);
+                moved++;
+                movedBytes += entry.size;
+            }
+        return {
+            directory: root,
+            archiveDirectory: target,
+            beforeTime: new Date(cutoff).toISOString(),
+            selected,
+            selectedBytes,
+            moved,
+            movedBytes,
+            alreadyArchived,
+            undated,
+            complete: undated === 0,
+            dryRun: options.dryRun === true,
+        };
+    }, { additional: [target], createAdditional: !options.dryRun });
+};

package/dist/services/media-archive.d.ts

@@ -0,0 +1,34 @@
+import type { ChatsService } from "./chats.js";
+import { type MediaArchiveEntry } from "./media-archive-manifest.js";
+import type { MessagesService } from "./messages.js";
+export interface MediaArchivePorts {
+    chats: Pick<ChatsService, "list" | "account" | "show">;
+    messages: Pick<MessagesService, "list" | "download">;
+}
+export interface MediaArchiveOptions {
+    directory: string;
+    chats?: readonly string[];
+    sinceTime?: string;
+    orderByTime?: boolean;
+    pageSize?: number;
+    pauseMs?: number;
+    signal?: AbortSignal;
+    onSaved?: (entry: MediaArchiveEntry) => void;
+}
+export declare const validateMediaSince: (value?: string, flag?: string) => number | undefined;
+export declare const checkMediaArchive: (directory: string, signal?: AbortSignal) => Promise<{
+    valid: boolean;
+    checked: number;
+    files: {
+        path: string;
+        valid: boolean;
+        archiveDirectory?: string;
+    }[];
+}>;
+export declare const archiveMedia: (ports: MediaArchivePorts, options: MediaArchiveOptions) => Promise<{
+    directory: string;
+    chats: number;
+    saved: number;
+    existing: number;
+    complete: boolean;
+}>;

package/dist/services/media-archive.js

@@ -0,0 +1,165 @@
+import { setTimeout as sleep } from "node:timers/promises";
+import { CliError } from "@wirecat/cli-base";
+import { matchDownloads, NOT_FILES } from "../domain/attachments.js";
+import { archiveMediaFile } from "./media-archive-files.js";
+import { withMediaArchiveLocks } from "./media-archive-locks.js";
+import { mediaKey, readMediaManifests, verifyMediaEntry } from "./media-archive-manifest.js";
+export const validateMediaSince = (value, flag = "--since-time") => {
+    if (value === undefined)
+        return undefined;
+    if (!/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d{1,3})?(?:Z|[+-]\d\d:\d\d)$/.test(value) ||
+        !Number.isFinite(Date.parse(value)))
+        throw new CliError("validation_error", `${flag} needs an ISO timestamp with a time zone`);
+    const date = value.slice(0, 10);
+    if (new Date(`${date}T00:00:00Z`).toISOString().slice(0, 10) !== date)
+        throw new CliError("validation_error", `${flag} has an invalid calendar date`);
+    return Date.parse(value);
+};
+export const checkMediaArchive = (directory, signal) => withMediaArchiveLocks(directory, signal, async (root) => {
+    const entries = await readMediaManifests(root, signal);
+    if (!entries.length)
+        throw new CliError("not_found", "no media archive manifests in this directory");
+    const files = [];
+    for (const entry of entries) {
+        let valid = false;
+        try {
+            valid = await verifyMediaEntry(root, entry, signal);
+        }
+        catch {
+            signal?.throwIfAborted();
+        }
+        files.push({ path: entry.path, valid, ...(entry.relocatedTo ? { archiveDirectory: entry.relocatedTo } : {}) });
+    }
+    return { valid: files.every((one) => one.valid), checked: files.length, files };
+});
+const saveMessage = async (root, account, message, ports, known, beforeWrite, options) => {
+    let download;
+    let saved = 0;
+    let existing = 0;
+    for (const [position, attachment] of message.attachments.entries()) {
+        if (NOT_FILES.has(attachment.kind))
+            continue;
+        await beforeWrite();
+        const identity = { ...account, chat: message.chatId, message: message.id, position };
+        const key = mediaKey(identity);
+        if (known.has(key)) {
+            existing++;
+            continue;
+        }
+        const entry = await archiveMediaFile(root, identity, attachment.kind, async () => {
+            download ??= await ports.messages.download(message.chatId, message.id);
+            const positions = matchDownloads(message.attachments.map((one, index) => ({
+                position: index,
+                kind: one.kind,
+                name: one.name ?? null,
+            })), download.files);
+            const index = positions.indexOf(position);
+            const file = download.files[index];
+            if (!file)
+                throw new CliError("invalid_response", "the messenger did not return an identifiable attachment");
+            return file;
+        }, beforeWrite, options.signal, { messageTime: new Date(message.timestamp).toISOString(), ...(attachment.mime ? { mime: attachment.mime } : {}) });
+        known.set(key, entry);
+        saved++;
+        options.onSaved?.(entry);
+    }
+    return { saved, existing };
+};
+export const archiveMedia = async (ports, options) => {
+    const since = validateMediaSince(options.sinceTime);
+    const pageSize = options.pageSize ?? 100;
+    const pauseMs = options.pauseMs ?? 1000;
+    if (!Number.isSafeInteger(pageSize) ||
+        pageSize < 1 ||
+        pageSize > 1000 ||
+        !Number.isSafeInteger(pauseMs) ||
+        pauseMs < 0)
+        throw new CliError("validation_error", "invalid media archive page size or pause");
+    return withMediaArchiveLocks(options.directory, options.signal, async (root, beforeWrite) => {
+        const known = new Map();
+        for (const entry of await readMediaManifests(root, options.signal)) {
+            let valid = false;
+            try {
+                valid = await verifyMediaEntry(root, entry, options.signal);
+            }
+            catch {
+                options.signal?.throwIfAborted();
+            }
+            if (!valid)
+                throw new CliError("validation_error", "archive checksum mismatch or missing file; choose a new destination");
+            known.set(mediaKey(entry), entry);
+        }
+        const account = await ports.chats.account();
+        let saved = 0, existing = 0, chats = 0;
+        const walk = async (chat) => {
+            const seen = new Set();
+            let before;
+            for (;;) {
+                await beforeWrite();
+                const page = await ports.messages.list(chat, { limit: pageSize, ...(before ? { before } : {}) });
+                let fresh = 0;
+                let reachedSince = false;
+                let oldest;
+                for (const message of page.items) {
+                    const timestamp = Date.parse(message.timestamp);
+                    if (!Number.isFinite(timestamp))
+                        throw new CliError("invalid_response", "media history has an invalid timestamp");
+                    if (!oldest || timestamp < Date.parse(oldest.timestamp))
+                        oldest = message;
+                    if (since !== undefined && timestamp < since) {
+                        reachedSince = true;
+                        continue;
+                    }
+                    if (seen.has(message.id))
+                        continue;
+                    seen.add(message.id);
+                    fresh++;
+                    const one = await saveMessage(root, account, message, ports, known, beforeWrite, options);
+                    saved += one.saved;
+                    existing += one.existing;
+                }
+                if (!page.hasMore || reachedSince)
+                    break;
+                if (!oldest || !fresh)
+                    throw new CliError("invalid_response", "media history pagination did not advance; archive is incomplete");
+                before = options.orderByTime ? new Date(Date.parse(oldest.timestamp) + 1).toISOString() : page.items[0]?.id;
+                if (pauseMs)
+                    await sleep(pauseMs, undefined, { signal: options.signal });
+            }
+            chats++;
+        };
+        if (options.chats?.length) {
+            const ids = new Set();
+            for (const chat of options.chats) {
+                const found = await ports.chats.show(chat);
+                if (!ids.has(found.id)) {
+                    ids.add(found.id);
+                    await walk(found.id);
+                }
+            }
+        }
+        else {
+            const seen = new Set();
+            let offset = 0;
+            for (;;) {
+                await beforeWrite();
+                const page = await ports.chats.list({ offset, limit: 100 });
+                let fresh = 0;
+                for (const chat of page.items)
+                    if (!seen.has(chat.id)) {
+                        seen.add(chat.id);
+                        fresh++;
+                        await walk(chat.id);
+                    }
+                if (!page.hasMore)
+                    break;
+                if (!fresh)
+                    throw new CliError("invalid_response", "chat pagination did not advance; archive is incomplete");
+                offset += page.items.length;
+                if (pauseMs)
+                    await sleep(pauseMs, undefined, { signal: options.signal });
+            }
+        }
+        return { directory: root, chats, saved, existing, complete: true };
+    }, { create: true });
+};

package/dist/services/search-kind.js

@@ -50,7 +50,7 @@ export const accountsOfKind = (kind, chosen, held, explicit, command = undefined
         throw new CliError("validation_error", `search mail reads mail only — \`${command === undefined ? "" : `${command} `}search messages\` searches ${explicit}`);
     const mail = (listed ? chosen : held).filter(({ provider }) => kindOf(provider) === "mail");
     if (mail.length === 0)
-        throw new CliError("not_found", "no mail in the store yet — `memo sync --mail --since-time <time>` imports it", {
+        throw new CliError("not_found", "no mail in the store yet — `memo sync --only mail --since-time <time>` imports it", {
             reason: NO_MAIL,
         });
     const address = mailAccount?.trim().toLowerCase();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.396.0",
+  "version": "0.398.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",
@@ -165,7 +165,7 @@
     "@anthropic-ai/sdk": "0.131.0",
     "@bomb.sh/tab": "0.0.22",
     "@huggingface/tokenizers": "0.2.0",
-    "@modelcontextprotocol/server": "2.1.0",
+    "@modelcontextprotocol/server": "2.3.0",
     "@resvg/resvg-js": "2.6.2",
     "@valibot/to-json-schema": "1.8.0",
     "@wirecat/cli-core-onnx": "1.0.1",