@wirecat/cli-core 0.20.0 → 0.263.0

package/dist/services/messages.js

@@ -0,0 +1,717 @@
+import { CliError, singleLine } from "@wirecat/cli-base";
+import { capability } from "../cli/messenger/port.js";
+import { threadIdOf } from "../cli/messenger/thread.js";
+import { validateFormattedText, visibleFormattedText } from "../domain/formatting.js";
+import { formatLocator, parseLocator } from "../domain/locator.js";
+import { messageLinkTarget, validatePermalink } from "../domain/message-link.js";
+import { isId, pickChat, pickPerson } from "../resolve.js";
+import { inSource, parseQuery, sourceOf } from "../search/query.js";
+import { search } from "../search/search.js";
+import { codeOf, guardedWrite } from "../sends/guarded.js";
+import { sendAsCheck } from "../sends/send-as.js";
+import { newOperationId, newSendId } from "../sends/send-id.js";
+import { crossAccount, fromStore, nothingStored, PUSHED } from "./deps.js";
+import { searchDiscovery } from "./messages-discovery.js";
+import { searchLucene, statsLucene, } from "./messages-search.js";
+import { searchAll } from "./search-all.js";
+import { searchAllWithMeetings, } from "./search-all-meetings.js";
+import { accountsOfKind, listedAccounts } from "./search-kind.js";
+import { refreshSearch, withRefresh } from "./search-refresh.js";
+import { searchRecordOf } from "./searches.js";
+import { searchServer, sourceKey, } from "./server-search.js";
+import { readThreadContext, threadBounds } from "./thread-context.js";
+/** max-cli's: many at once is what a ban for automation looks like. */
+export const DELETE_AT_ONCE = 10;
+/** How long a search may spend building the word index, then the stems, first (phase 2 plan S3: about 200 ms). */
+export const SEARCH_FILL_MS = 200;
+export const statsStore = async (store, account, request, messenger = {}) => {
+    const stop = Date.now() + SEARCH_FILL_MS;
+    await store.fillSearchIndex({ until: () => Date.now() >= stop });
+    await store.fillStems({ until: () => Date.now() >= stop });
+    return statsLucene(store, account, request, messenger);
+};
+export const messagesService = (deps) => {
+    const { guard } = deps;
+    const inStore = async (read) => read(await deps.store(), await deps.account());
+    const serverThenStore = async (store, account, query) => {
+        const server = await searchServer(deps, query);
+        const only = query.backend === "server" && server
+            ? [...server.sources.keys()].map((key) => {
+                const [chatId, id] = JSON.parse(key);
+                return { ...account, chatId, id };
+            })
+            : undefined;
+        const found = await searchStore(store, account, only ? { ...query, only } : query, deps.messenger);
+        return { found, server };
+    };
+    const unifiedMessages = (store, account) => async (query) => {
+        await topUp(store);
+        const { found, server } = await serverThenStore(store, account, query);
+        return withServer(found, account, server);
+    };
+    /**
+     * Only a run that answered is kept: a refused query is the caller's typo, not a search. The answer is
+     * already in hand, so a history write that fails — the store busy under `serve` — never fails the search.
+     */
+    const remember = async (store, command, query) => {
+        if (deps.history === false)
+            return;
+        await store
+            .recordSearch(searchRecordOf(command, paramsOf(command, query)), {
+            ...(query.saved === undefined ? {} : { saved: query.saved }),
+        })
+            .catch(() => undefined);
+    };
+    const pinning = async ({ chat, message }, pinned, notify) => {
+        const connection = await deps.connection();
+        const act = pinned
+            ? capability(connection, "pin", "pin a message")
+            : capability(connection, "unpin", "unpin a message");
+        const { id: chatId } = await connection.resolve(chat);
+        const operationId = newOperationId();
+        await guardedWrite(guard, { operationId, chatId, kind: "pin", key: pinned ? "messages.pin" : "messages.unpin", messageId: message, notify }, () => act(chatId, message, { notify }));
+        return { operationId, chatId, messageId: message, pinned };
+    };
+    const topicPage = async (chat, threadId, { limit, before, beforeTime, after }) => {
+        if (beforeTime !== undefined || after !== undefined)
+            throw new CliError("validation_error", "a topic is read back from its newest message, or from --before-id");
+        if (threadId === "1")
+            throw new CliError("validation_error", "the General topic's messages carry no topic id — read the whole chat without --topic");
+        const window = { limit, ...(before === undefined ? {} : { before }) };
+        if (fromStore(deps)) {
+            return inStore(async (store, account) => store.messages(account, await readChatId(deps, chat, store, account), { ...window, threadId }));
+        }
+        return capability(await deps.connection(), "topicHistory", "read one forum topic")(chat, threadId, window);
+    };
+    const listPage = async (chat, { limit, before, beforeTime, after, threadId: typedThread }) => {
+        const threadId = threadIdOf(typedThread);
+        if (threadId !== undefined)
+            return topicPage(chat, threadId, { limit, before, beforeTime, after });
+        if (beforeTime !== undefined) {
+            if (deps.offline)
+                throw new CliError("validation_error", "reading back from a time asks the messenger; not with --offline");
+            if (fromStore(deps))
+                throw new CliError("validation_error", `${PUSHED}, which pages back from a message only`);
+            const connection = await deps.connection();
+            return capability(connection, "historyBefore", "read back from a time")(chat, { limit, time: beforeTime });
+        }
+        if (after !== undefined) {
+            if (deps.offline)
+                throw new CliError("validation_error", "reading forward asks the messenger; the store pages only backwards");
+            if (fromStore(deps))
+                throw new CliError("validation_error", `${PUSHED}, which pages only backwards`);
+            const connection = await deps.connection();
+            return capability(connection, "historyAfter", "read forward from a message")(chat, { limit, after });
+        }
+        const window = { limit, ...(before === undefined ? {} : { before }) };
+        if (fromStore(deps)) {
+            return inStore(async (store, account) => store.messages(account, await readChatId(deps, chat, store, account), window));
+        }
+        return capability(await deps.connection(), "history", "read a chat's history")(chat, window);
+    };
+    return {
+        // A provider caps its pages (Telegram at 100), so a larger --limit reads on from the last page's edge.
+        // Only by id: where `before` is a send time (MAX), messages sharing the edge moment would be skipped.
+        list: async (chat, window) => {
+            const forward = window.after !== undefined;
+            let page = await listPage(chat, window);
+            let items = page.items;
+            const byId = (deps.messenger.fetching?.orderBy ?? "id") === "id";
+            while (byId && page.hasMore && items.length < window.limit) {
+                const edge = forward ? items.at(-1) : items[0];
+                if (!edge)
+                    break;
+                const { beforeTime: _first, ...rest } = window;
+                const next = forward
+                    ? { ...rest, limit: window.limit - items.length, after: { id: edge.id } }
+                    : { ...rest, limit: window.limit - items.length, before: edge.id };
+                page = await listPage(chat, next);
+                const seen = new Set(items.map((one) => one.id));
+                const fresh = page.items.filter((one) => !seen.has(one.id));
+                if (fresh.length === 0)
+                    break;
+                items = forward ? [...items, ...fresh] : [...fresh, ...items];
+            }
+            return { items, hasMore: page.hasMore };
+        },
+        around: async (reference, message, window) => {
+            const target = messageLinkTarget(reference, message, deps.messenger.provider);
+            if (target.account !== undefined) {
+                const account = await deps.account();
+                if (account.provider !== deps.messenger.provider || target.account !== account.account)
+                    throw new CliError("validation_error", "that locator belongs to another account; select its profile first");
+            }
+            if (fromStore(deps)) {
+                return inStore(async (store, account) => store.around(account, await readChatId(deps, target.chat, store, account), target.message, window));
+            }
+            return capability(await deps.connection(), "around", "read the messages around one")(target.chat, target.message, window);
+        },
+        thread: (reference, message, options) => inStore(async (store, account) => {
+            const target = messageLinkTarget(reference, message, deps.messenger.provider);
+            if (account.provider !== deps.messenger.provider ||
+                (target.account !== undefined && target.account !== account.account))
+                throw new CliError("validation_error", "that locator belongs to another account; select its profile first");
+            return readThreadContext(store, account, await storedChatId(deps.messenger, target.chat, store, account), target.message, options);
+        }),
+        comments: async (chat, typedPost, window) => {
+            const post = typedPost.trim();
+            if (post === "")
+                throw new CliError("validation_error", "which post? give its message id in the channel");
+            if (deps.offline)
+                throw new CliError("validation_error", "comments are read from the messenger; not with --offline");
+            const connection = await deps.connection();
+            const discussionOf = capability(connection, "discussionOf", "read comments on a channel post");
+            const comments = capability(connection, "comments", "read comments on a channel post");
+            const { id: channelId } = await connection.resolve(chat);
+            const discussion = await discussionOf(channelId, post);
+            return { discussion, ...(await comments(channelId, post, window)) };
+        },
+        link: async (reference, message) => {
+            const target = messageLinkTarget(reference, message, deps.messenger.provider);
+            const account = await deps.account();
+            if (account.provider !== deps.messenger.provider ||
+                (target.account !== undefined && target.account !== account.account))
+                throw new CliError("validation_error", "that locator belongs to another account; select its profile first");
+            if (fromStore(deps)) {
+                const store = await deps.store();
+                const chat = await readChatId(deps, target.chat, store, account);
+                const found = await store.around(account, chat, target.message, { before: 0, after: 0 });
+                if (!found.some((item) => item.id === target.message && item.chatId === chat))
+                    throw new CliError("not_found", "no such message in this account's stored chat");
+                return {
+                    locator: formatLocator({ ...account, chat, message: target.message }),
+                    url: null,
+                    access: "unavailable",
+                    reason: deps.offline ? "offline" : "unsupported_provider",
+                };
+            }
+            const connection = await deps.connection();
+            if (connection.self() !== account.account)
+                throw new CliError("authentication_error", "the connected account differs from the recorded profile; refresh the session before linking");
+            const { id: chat } = await connection.resolve(target.chat);
+            const locator = formatLocator({ ...account, chat, message: target.message });
+            if (connection.permalink)
+                return { locator, ...validatePermalink(await connection.permalink(chat, target.message)) };
+            const found = await capability(connection, "around", "read a message")(chat, target.message, {
+                before: 0,
+                after: 0,
+            });
+            if (!found.some((item) => item.id === target.message && item.chatId === chat))
+                throw new CliError("not_found", "no such message in this chat");
+            return { locator, url: null, access: "unavailable", reason: "unsupported_provider" };
+        },
+        download: async (chat, message) => capability(await deps.connection(), "download", "download attachments")(chat, message),
+        keepDownloaded: (chat, message, files) => inStore(async (store, account) => {
+            const chatId = (await storedChatId(deps.messenger, chat, store, account).catch(() => undefined)) ??
+                (await (await deps.connection()).resolve(chat)).id;
+            return store.keepDownloads(account, chatId, message, files);
+        }),
+        search: (request) => {
+            if (request.discover && request.backend === "server")
+                throw new CliError("validation_error", "discovery searches the local archive; use backend archive");
+            const query = {
+                ...request,
+                language: request.language ?? (request.pattern ? "legacy" : "lucene"),
+                // Mail is only ever in the local store, and a saved search replays as `search messages`.
+                ...(request.kind === "mail" || request.discover ? { backend: "archive" } : {}),
+            };
+            const opened = query.kind === "mail"
+                ? crossAccount(deps, "search mail reads every mail account unless --account names one")
+                : deps.store();
+            return opened.then(async (store) => {
+                const account = await deps.account();
+                if (query.thread)
+                    threadBounds(query.thread);
+                const refreshed = await refreshSearch(deps, query);
+                // The server step reads the indexes to translate the query, so they are topped up first.
+                if (query.backend !== undefined && query.backend !== "archive")
+                    await topUp(store);
+                const { found, server } = await serverThenStore(store, account, query);
+                if (query.kind !== "mail")
+                    await remember(store, "search", query);
+                return withServer(withRefresh(found, refreshed), account, server);
+            });
+        },
+        searchAll: (request) => inStore((store, account) => searchAll(store, account, request, deps.messenger, unifiedMessages(store, account))),
+        searchAllWithMeetings: (request) => inStore((store, account) => searchAllWithMeetings(store, account, request, deps.messenger, unifiedMessages(store, account))),
+        stats: (request) => {
+            const query = {
+                ...request,
+                language: request.language ?? (request.pattern ? "legacy" : "lucene"),
+            };
+            return inStore(async (store, account) => {
+                const refreshed = await refreshSearch(deps, query);
+                const stats = await statsStore(store, account, query, deps.messenger);
+                await remember(store, "stats", query);
+                return withRefresh(stats, refreshed);
+            });
+        },
+        send: async ({ chat, text: typed, sendId, replyTo: typedReplyTo, threadId: typedThread, silent, noPreview, markdown, html, at, attachments = [], key, origin, spoiler, captionAbove, sendAs, commentTo, sticker, }) => {
+            if (sticker !== undefined && (typed.trim() !== "" || attachments.length > 0 || markdown || html))
+                throw new CliError("validation_error", "a sticker goes alone — no text, no file, no photo");
+            if (commentTo !== undefined && (typedReplyTo !== undefined || typedThread !== undefined))
+                throw new CliError("validation_error", "a comment answers the post itself; not with --reply-to or --topic");
+            const media = { ...(spoiler ? { spoiler } : {}), ...(captionAbove ? { captionAbove } : {}) };
+            checkMediaOptions(deps.messenger, Object.keys(media), attachments.length);
+            const connection = await deps.connection();
+            if (at !== undefined && sendId !== undefined) {
+                throw new CliError("validation_error", "a scheduled send is never repeated: it would be scheduled twice — look in `messages scheduled` instead");
+            }
+            const prepared = await formatted(connection, typed, { markdown, html });
+            const { text, spans } = deps.agentText ? visibleFormattedText(prepared) : prepared;
+            if (text.trim() === "" && attachments.length === 0 && sticker === undefined) {
+                throw new CliError("validation_error", "nothing to send — the marks leave no text");
+            }
+            const threadId = threadIdOf(typedThread);
+            const validate = threadId === undefined ? undefined : capability(connection, "validateThread", "send to a forum topic");
+            const checkSendAs = sendAsCheck(connection, sendAs);
+            const discussionOf = commentTo === undefined ? undefined : capability(connection, "discussionOf", "comment on a channel post");
+            const { id: resolved } = await connection.resolve(chat);
+            const discussion = discussionOf && commentTo !== undefined ? await discussionOf(resolved, commentTo) : undefined;
+            const chatId = discussion?.chatId ?? resolved;
+            const replyTo = discussion?.messageId ?? typedReplyTo;
+            await checkSendAs(chatId);
+            const id = sendId ?? connection.newSendId?.() ?? newSendId();
+            const attempt = {
+                chatId,
+                kind: "message",
+                sendId: id,
+                operationId: id,
+                length: text.length,
+                ...(replyTo === undefined ? {} : { replyTo }),
+                ...(threadId === undefined ? {} : { threadId }),
+                ...(sendAs === undefined ? {} : { sendAs }),
+                ...(at === undefined ? {} : { scheduledFor: at }),
+                ...(key === undefined ? {} : { key }),
+                ...(origin === undefined ? {} : { origin }),
+                ...(attachments.length === 0
+                    ? {}
+                    : { attachments: attachments.map(({ kind, bytes }) => ({ kind, bytes: bytes.byteLength })) }),
+            };
+            try {
+                const done = await guardedWrite(guard, attempt, () => connection.send(chatId, text, {
+                    sendId: id,
+                    ...(replyTo === undefined ? {} : { replyTo }),
+                    ...(threadId === undefined ? {} : { threadId }),
+                    ...(silent ? { silent } : {}),
+                    ...(noPreview ? { noPreview } : {}),
+                    ...(spans.length > 0 ? { formatting: spans } : {}),
+                    ...(at === undefined ? {} : { at }),
+                    ...(attachments.length === 0 ? {} : { attachments }),
+                    ...(sticker === undefined ? {} : { sticker }),
+                    ...media,
+                    ...(sendAs === undefined ? {} : { sendAs }),
+                }), (sent) => ({ messageId: sent.message.id }), validate === undefined || threadId === undefined
+                    ? undefined
+                    : () => validate(chatId, threadId, { ...(replyTo === undefined ? {} : { replyTo }) }));
+                return { ...done, operationId: id };
+            }
+            catch (error) {
+                if (at !== undefined && codeOf(error) === "outcome_unknown") {
+                    throw new CliError("outcome_unknown", "no answer — the message may have been scheduled. Look in `messages scheduled` before anything else; " +
+                        "never send it again with --send-id", { scheduled_for: at });
+                }
+                throw error;
+            }
+        },
+        edit: async ({ chat, message, text: typed, markdown, html }) => {
+            const connection = await deps.connection();
+            const edit = capability(connection, "edit", "edit a message");
+            const prepared = await formatted(connection, typed, { markdown, html });
+            const { text, spans } = deps.agentText ? visibleFormattedText(prepared) : prepared;
+            if (text.trim() === "")
+                throw new CliError("validation_error", "no new text — the marks leave nothing");
+            const { id: chatId } = await connection.resolve(chat);
+            const operationId = newOperationId();
+            const edited = await guardedWrite(guard, { operationId, chatId, kind: "edit", messageId: message, length: text.length }, () => edit(chatId, message, text, spans.length > 0 ? { formatting: spans } : {}));
+            return { operationId, message: edited };
+        },
+        delete: async ({ chat, messages, forEveryone }) => {
+            const connection = await deps.connection();
+            if (messages.length > DELETE_AT_ONCE) {
+                throw new CliError("validation_error", `at most ${DELETE_AT_ONCE} messages at once, got ${messages.length}`);
+            }
+            const remove = capability(connection, "delete", "delete messages");
+            const { id: chatId } = await connection.resolve(chat);
+            const operationId = newOperationId();
+            await guardedWrite(guard, { operationId, chatId, kind: "delete", count: messages.length, forEveryone }, () => remove(chatId, messages, { forEveryone }));
+            return { operationId, chatId, deleted: messages, forEveryone };
+        },
+        forward: async ({ chat, message, to, silent, sendId, sendAs, threadId: typedThread }) => {
+            const connection = await deps.connection();
+            const forward = capability(connection, "forward", "forward a message");
+            const threadId = threadIdOf(typedThread);
+            if (threadId !== undefined && deps.messenger.forwardTopic !== true)
+                throw new CliError("validation_error", "this messenger cannot forward to a forum topic");
+            const validate = threadId === undefined ? undefined : capability(connection, "validateThread", "forward to a forum topic");
+            const checkSendAs = sendAsCheck(connection, sendAs);
+            const { id: fromChatId } = await connection.resolve(chat);
+            const { id: toChatId } = await connection.resolve(to);
+            await checkSendAs(toChatId);
+            const id = sendId ?? connection.newSendId?.() ?? newSendId();
+            const forwarded = await guardedWrite(guard, {
+                operationId: id,
+                sendId: id,
+                chatId: toChatId,
+                kind: "forward",
+                ...(threadId === undefined ? {} : { threadId }),
+                ...(sendAs === undefined ? {} : { sendAs }),
+            }, () => forward(fromChatId, message, toChatId, {
+                sendId: id,
+                ...(silent ? { silent } : {}),
+                ...(sendAs === undefined ? {} : { sendAs }),
+                ...(threadId === undefined ? {} : { threadId }),
+            }), (done) => ({ messageId: done.id }), validate === undefined || threadId === undefined ? undefined : () => validate(toChatId, threadId, {}));
+            return { operationId: id, sendId: id, message: forwarded };
+        },
+        pin: ({ notify, ...target }) => pinning(target, true, notify),
+        unpin: (target) => pinning(target, false, false),
+        react: async ({ chat, message, emoji }) => {
+            const connection = await deps.connection();
+            if (emoji === "")
+                throw new CliError("validation_error", "which emoji? give one, for example 👍");
+            const react = capability(connection, "react", "react to a message");
+            const { id: chatId } = await connection.resolve(chat);
+            const operationId = newOperationId();
+            await guardedWrite(guard, { operationId, chatId, kind: "reaction", messageId: message }, () => react(chatId, message, emoji));
+            return { operationId, chatId, messageId: message, reaction: emoji };
+        },
+    };
+};
+const withThreads = async (store, found, request) => {
+    if (!request.thread)
+        return found;
+    const items = [];
+    for (const hit of found.items)
+        items.push({
+            ...hit,
+            thread: await readThreadContext(store, accountOf(hit), hit.chatId, hit.id, {
+                before: request.context ?? 0,
+                after: request.context ?? 0,
+                ...request.thread,
+                signal: request.signal,
+            }),
+        });
+    return { ...found, items };
+};
+/** The server answers for the account it runs as only; another account's message with the same ids is the archive's. */
+const withServer = (found, account, server) => server
+    ? {
+        ...found,
+        server: server.report,
+        items: found.items.map((hit) => ({
+            ...hit,
+            source: (keyOf(accountOf(hit)) === keyOf(account) && server.sources.get(sourceKey(hit.chatId, hit.id))) ||
+                "archive",
+        })),
+    }
+    : found;
+export const validateSearchDialect = (request) => {
+    const { pattern } = request;
+    if (request.language !== undefined && !["lucene", "legacy"].includes(request.language))
+        throw new CliError("validation_error", "--language takes lucene or legacy");
+    if (pattern && (request.language === "lucene" || request.ast !== undefined || request.timezone !== undefined))
+        throw new CliError("validation_error", "--regex is legacy JavaScript mode; not with Lucene, AST or timezone");
+    if (request.language === "legacy" && (request.ast !== undefined || request.timezone !== undefined))
+        throw new CliError("validation_error", "AST and timezone require the Lucene language");
+    if (pattern && (request.source !== undefined || request.accounts !== undefined || request.senders !== undefined)) {
+        throw new CliError("validation_error", "--regex reads the account it runs as — not with --source, other accounts or senders");
+    }
+};
+/**
+ * `search messages` over a store, from the account given — or from `query.accounts`, which a caller such
+ * as a bot's search passes after checking it may read them.
+ */
+// A large file builds its word index a slice per search as well as in `store migrate` (NEED-453 A).
+const topUp = async (store) => {
+    const stop = Date.now() + SEARCH_FILL_MS;
+    await store.fillSearchIndex({ until: () => Date.now() >= stop });
+    await store.fillStems({ until: () => Date.now() >= stop });
+};
+/** How deep a search pages: each page reads every hit before it again. */
+export const MAX_SEARCH_OFFSET = 1000;
+/**
+ * Search the store, one page at a time: `offset` skips the hits a page before held, and `nextOffset` says where
+ * the next page starts. A page is the hits up to `offset + limit` read again and cut, so deep pages cost more.
+ */
+export const searchStore = async (store, account, request, messenger = {}) => {
+    const offset = request.offset ?? 0;
+    if (!Number.isInteger(offset) || offset < 0 || offset > MAX_SEARCH_OFFSET)
+        throw new CliError("validation_error", `offset takes a whole number from 0 to ${MAX_SEARCH_OFFSET}`);
+    const found = await searchPage(store, account, { ...request, limit: request.limit + offset }, messenger);
+    return {
+        ...found,
+        items: found.items.slice(offset),
+        ...(found.hasMore && offset + request.limit <= MAX_SEARCH_OFFSET ? { nextOffset: offset + request.limit } : {}),
+    };
+};
+const searchPage = async (store, account, request, messenger) => {
+    const { text, pattern, chat, source, accounts, senders, limit, newest = false, context = 0 } = request;
+    if (request.signal?.aborted)
+        throw new CliError("validation_error", "search was aborted", { reason: "query.aborted", complete: false });
+    validateSearchDialect(request);
+    if (request.thread)
+        threadBounds(request.thread);
+    if (request.discover !== undefined && typeof request.discover !== "boolean")
+        throw new CliError("validation_error", "discover takes a boolean");
+    if (request.discover && (pattern || request.language === "legacy"))
+        throw new CliError("validation_error", "discovery requires Lucene text, without legacy or regex");
+    if (request.discover && request.backend === "server")
+        throw new CliError("validation_error", "discovery searches the local archive; use backend archive");
+    await topUp(store);
+    if (request.discover)
+        return withThreads(store, await searchDiscovery(store, account, request, messenger), request);
+    if (!pattern && (request.language === "lucene" || request.ast !== undefined))
+        return withThreads(store, await searchLucene(store, account, request, messenger), request);
+    const found = pattern
+        ? {
+            ...(await store.find({
+                pattern,
+                signal: request.signal,
+                account,
+                limit,
+                ...(chat === undefined ? {} : { chatId: await storedChatId(messenger, chat, store, account) }),
+            })),
+            corrections: [],
+            wordsReady: (await store.searchIndexState())?.ready === true,
+        }
+        : await search(store, ...(await scopeOf(messenger, store, account, {
+            text: text ?? "",
+            chat,
+            source,
+            accounts,
+            senders,
+            kind: request.kind,
+        })), { limit, newest });
+    const items = await Promise.all(found.items.map(async (hit) => context > 0
+        ? {
+            ...hit,
+            context: await store.around(accountOf(hit), hit.chatId, hit.id, { before: context, after: context }),
+        }
+        : hit));
+    return withThreads(store, { ...found, items, completeness: await completenessOf(store, found.items) }, request);
+};
+/**
+ * The chat a store read is about. Offline, a chat with nothing kept answers empty, as it always has;
+ * in store mode the store is the only source, so an empty answer would pass for "nothing was said".
+ */
+export const readChatId = async (deps, reference, store, account) => {
+    if (deps.reads !== "store")
+        return storedChatId(deps.messenger, reference, store, account);
+    const chatId = await storedChatId(deps.messenger, reference, store, account).catch((error) => {
+        if (codeOf(error) === "not_found")
+            throw new CliError("not_found", nothingStored(deps.messenger));
+        throw error;
+    });
+    if ((await store.countMessages(account, chatId)) === 0) {
+        throw new CliError("not_found", nothingStored(deps.messenger), { chat: chatId });
+    }
+    return chatId;
+};
+/** A chat as typed, found among the stored chats the way an adapter finds it among its own. */
+export const storedChatId = async (messenger, reference, store, account) => chatIdAmong(messenger, reference, account, () => store.chats(account, {}));
+/** `storedChatId`, among the chats of the account the store is bound to. */
+export const chatIdIn = (messenger, reference, store) => chatIdAmong(messenger, reference, store.account, () => store.chats({}));
+const chatIdAmong = async (messenger, reference, account, held) => {
+    const trimmed = reference.trim();
+    if (messenger.savedChatId && ["me", "self", "saved"].includes(trimmed.toLowerCase())) {
+        return messenger.savedChatId(account);
+    }
+    if (/^-?\d+$/.test(trimmed))
+        return trimmed;
+    const chats = (await held()).items;
+    const exact = chats.find((one) => one.id === trimmed);
+    if (exact)
+        return exact.id;
+    if (trimmed.startsWith("@")) {
+        const username = trimmed.slice(1).toLowerCase();
+        const found = chats.find((one) => String(one.providerMetadata?.username ?? "").toLowerCase() === username);
+        if (!found)
+            throw new CliError("not_found", `no stored chat is ${trimmed}`);
+        return found.id;
+    }
+    return pickChat(trimmed, chats).id;
+};
+const accountOf = (hit) => {
+    const { provider, account } = parseLocator(hit.locator);
+    return { provider, account };
+};
+const keyOf = ({ provider, account }) => `${provider}/${account}`;
+/** Each chat's completeness from the account that holds it: a search may span several. */
+const completenessOf = async (store, hits) => {
+    const chats = new Map();
+    for (const hit of hits) {
+        const account = accountOf(hit);
+        const held = chats.get(keyOf(account)) ?? { account, chatIds: new Set() };
+        held.chatIds.add(hit.chatId);
+        chats.set(keyOf(account), held);
+    }
+    const found = await Promise.all([...chats.values()].map(async ({ account, chatIds }) => (await store.chatCompleteness(account, [...chatIds])).map((one) => ({ ...one, ...account }))));
+    return found.flat();
+};
+/** Several candidates in different accounts: which messenger each is in says which one was meant. */
+const ambiguousAcross = (reference, what, candidates) => {
+    const width = Math.max(...candidates.map(({ provider, id }) => `${provider}  ${id}`.length));
+    const lines = candidates.map(({ provider, id, label }) => `  ${`${provider}  ${id}`.padEnd(width)}  ${label}`);
+    return new CliError("validation_error", `"${singleLine(reference)}" matches ${candidates.length} ${what} in different accounts — ` +
+        `name one by its id, or narrow the search with in:<messenger>:\n${lines.join("\n")}`, { candidates: candidates.map(({ provider, id }) => ({ provider, id })) });
+};
+const missing = (error) => {
+    if (codeOf(error) === "not_found")
+        return undefined;
+    throw error;
+};
+/** A chat as `--chat` names it, in whichever of the accounts holds it — one of them, or it is an error. */
+export const chatAmong = async (messenger, store, accounts, reference) => {
+    const [only] = accounts;
+    if (accounts.length === 1 && only)
+        return { account: only, chatId: await storedChatId(messenger, reference, store, only) };
+    const found = (await Promise.all(accounts.map(async (account) => {
+        const held = (await store.chats(account, {})).items;
+        const chatId = await storedChatId(messenger, reference, store, account).catch(missing);
+        const chat = held.find((one) => one.id === chatId);
+        return chat ? [{ account, chat }] : [];
+    }))).flat();
+    const [one] = found;
+    if (found.length === 1 && one)
+        return { account: one.account, chatId: one.chat.id };
+    if (found.length === 0)
+        throw new CliError("not_found", `no stored chat matches "${singleLine(reference)}"`);
+    throw ambiguousAcross(reference, "chats", found.map(({ account, chat }) => ({
+        provider: account.provider,
+        id: chat.id,
+        label: singleLine(chat.title ?? ""),
+    })));
+};
+/** A sender, through the names each messenger's accounts have seen; `from:` names one person. */
+export const senderAmong = async (store, accounts, reference) => {
+    const providers = [...new Set(accounts.map(({ provider }) => provider))];
+    const [only] = accounts;
+    try {
+        if (accounts.length === 1 && only) {
+            const person = pickPerson(reference, await store.people(only.provider, { account: only.account }));
+            return { provider: only.provider, id: person.id };
+        }
+        const found = (await Promise.all(providers.map(async (provider) => {
+            const ids = accounts.filter((one) => one.provider === provider).map(({ account }) => account);
+            const person = await store
+                .people(provider, { accounts: ids })
+                .then((people) => pickPerson(reference, people))
+                .catch(missing);
+            return person ? [{ provider, person }] : [];
+        }))).flat();
+        const [one] = found;
+        if (found.length === 1 && one)
+            return { provider: one.provider, id: one.person.id };
+        if (found.length === 0) {
+            throw new CliError("not_found", isId(reference) ? `no person ${reference} in what these accounts have seen` : `nobody matches "${reference}"`);
+        }
+        throw ambiguousAcross(reference, "people", found.map(({ provider, person }) => ({ provider, id: person.id, label: singleLine(person.name ?? "") })));
+    }
+    catch (error) {
+        if (error instanceof CliError && error.code === "not_found") {
+            throw new CliError("not_found", `from:${reference} — ${error.message}`);
+        }
+        throw error;
+    }
+};
+/**
+ * The parsed query and the scope it names: the account the command runs as, or every account of the
+ * messenger `in:` or `--source` names. `chat:` resolves as `--chat` does, `from:` through the names
+ * `contacts search` uses, `from:me` as what the accounts sent — all inside the accounts chosen.
+ */
+export const scopeOf = async (messenger, store, account, { text, chat, source, accounts: given, senders, kind, }) => {
+    const held = await store.accounts();
+    const providers = [...new Set(held.map(({ provider }) => provider))];
+    const parsed = parseQuery(text, { providers });
+    if (chat !== undefined && parsed.chat !== undefined && parsed.chat !== chat) {
+        throw new CliError("validation_error", `--chat and chat: name different chats: "${chat}" and "${parsed.chat}"`);
+    }
+    const listed = await listedAccounts(store, account, source, messenger.app, kind);
+    if (listed && parsed.in !== undefined)
+        throw new CliError("validation_error", "--source names the accounts — leave in: out, or put it in the list");
+    const sourced = source === undefined || listed ? undefined : sourceOf("--source", source, providers);
+    if (sourced !== undefined && parsed.in !== undefined && sourced !== parsed.in) {
+        throw new CliError("validation_error", `--source and in: name different messengers: ${sourced} and ${parsed.in}`);
+    }
+    const wanted = parsed.in ?? sourced;
+    if (given !== undefined && (wanted !== undefined || listed)) {
+        throw new CliError("validation_error", "this search reads the accounts it was given — not with in: or --source");
+    }
+    if (given?.length === 0)
+        throw new CliError("validation_error", "a search names at least one account");
+    if (senders !== undefined && parsed.from !== undefined) {
+        throw new CliError("validation_error", "--from and from: together — name the people once");
+    }
+    const accounts = accountsOfKind(kind, given ??
+        listed?.accounts ??
+        (wanted === undefined || held.length === 0
+            ? [account]
+            : held.filter(({ provider }) => inSource(wanted, provider))), held, wanted, messenger.app?.command, undefined, listed !== undefined || given !== undefined);
+    const named = parsed.chat ?? chat;
+    const scope = { accounts };
+    if (named !== undefined)
+        scope.chat = await chatAmong(messenger, store, accounts, named);
+    if (senders !== undefined)
+        scope.senders = senders;
+    if (parsed.from?.toLowerCase() === "me")
+        scope.outgoing = true;
+    else if (parsed.from !== undefined)
+        scope.sender = await senderAmong(store, accounts, parsed.from);
+    if (parsed.after !== undefined)
+        scope.after = parsed.after;
+    if (parsed.before !== undefined)
+        scope.before = parsed.before;
+    if (parsed.has.length > 0) {
+        const held = await store.attachmentKinds();
+        const unknown = parsed.has.find((kind) => !["attachment", "link", ...held].includes(kind));
+        if (unknown !== undefined) {
+            throw new CliError("validation_error", `has:${unknown} — the store holds no ${unknown}; it holds ${["attachment", "link", ...held].join(", ")}`);
+        }
+        scope.has = parsed.has;
+    }
+    return [{ required: parsed.required, excluded: parsed.excluded }, scope];
+};
+/** What a run is kept as: the query and options it was given — a regular expression as its source. */
+const paramsOf = (command, query) => ({
+    ...(query.pattern
+        ? { text: query.pattern.source, regex: true }
+        : query.text === undefined
+            ? {}
+            : { text: query.text }),
+    ...(query.ast === undefined ? {} : { ast: query.ast }),
+    ...(query.discover === undefined ? {} : { discover: query.discover }),
+    ...(query.language === undefined ? {} : { language: query.language }),
+    ...(query.chat === undefined ? {} : { chat: query.chat }),
+    ...(query.source === undefined ? {} : { source: query.source }),
+    ...(query.timezone === undefined ? {} : { timezone: query.timezone }),
+    limit: query.limit,
+    ...(command === "search"
+        ? { newest: query.newest === true, ...(query.context === undefined ? {} : { context: query.context }) }
+        : { by: query.by }),
+});
+const formatted = async (connection, typed, { markdown, html }) => {
+    if (markdown && html)
+        throw new CliError("validation_error", "--md and --html mark up the text two ways; use one");
+    if (markdown)
+        return validateFormattedText(await capability(connection, "formatMarkdown", "format Markdown")(typed));
+    if (html)
+        return validateFormattedText(await capability(connection, "formatHtml", "format HTML")(typed));
+    return { text: typed, spans: [] };
+};
+const MEDIA_FLAGS = {
+    spoiler: "--spoiler",
+    captionAbove: "--caption-above",
+    fileName: "--filename",
+};
+const checkMediaOptions = (messenger, asked, attachments) => {
+    const [first] = asked;
+    if (first === undefined)
+        return;
+    const missing = asked.find((one) => !messenger.mediaOptions?.includes(one));
+    if (missing)
+        throw new CliError("validation_error", `this messenger has no ${MEDIA_FLAGS[missing]}`);
+    if (attachments === 0)
+        throw new CliError("validation_error", `${MEDIA_FLAGS[first]} needs a --photo or --file`);
+};
+//# sourceMappingURL=messages.js.map