@wirecat/cli-core 0.472.0 → 0.474.0

package/dist/entities/message.d.ts

@@ -11,6 +11,7 @@ export declare const message: v.StrictObjectSchema<{
     readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     readonly sender_username: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly sender_is_chat: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly sender_is_me: v.BooleanSchema<undefined>;
     readonly mentions: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, undefined>;
     /** When it was sent. */
     readonly timestamp: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;

package/dist/entities/message.js

@@ -23,6 +23,7 @@ export const message = v.strictObject({
     sender_name: v.nullable(text),
     sender_username: v.optional(text),
     sender_is_chat: v.optional(v.boolean()),
+    sender_is_me: v.boolean(),
     mentions: v.optional(v.array(id)),
     /** When it was sent. */
     timestamp: time,

package/dist/entities/store-records.d.ts

@@ -35,6 +35,7 @@ export declare const storeExport: v.UnionSchema<[v.StrictObjectSchema<{
     readonly sender_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     readonly sender_username: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly sender_is_chat: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly sender_is_me: v.BooleanSchema<undefined>;
     readonly mentions: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, undefined>;
     readonly timestamp: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
     readonly edited_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;

package/dist/mail/source.d.ts

@@ -23,6 +23,13 @@ export interface Searched {
 }
 /** Everything the import asks of a mail client, so a transport can be replaced without touching the sync. */
 export interface MailSource {
+    /**
+     * How many messages one `list` call reads in about one request's time, parallel connections included; a budgeted
+     * sync lists that many at a time, so a request of the budget is one call. Absent: 200.
+     */
+    listBatch?: number;
+    /** The same for `fetchRaw`. Absent: 50. */
+    fetchBatch?: number;
     /**
      * Every message in `folder` received since `since`; all or nothing, since deletions are proved from it.
      * `headers` also reads From, To, Cc and the list fields, for the probe and the owner's rules.

package/dist/mail/sync.d.ts

@@ -1,3 +1,4 @@
+import type { BudgetStop, RunBudget } from "../background/budget.js";
 import type { LoadEngine } from "../readers/types.js";
 import type { AccountKey, MessageStore } from "../store/index.js";
 import { type TagOutcome } from "./rule-tags.js";
@@ -31,6 +32,14 @@ export interface MailSyncResult {
     deleted: number;
     /** False when `max` stopped the run before every new message was read; the next run continues. */
     complete: boolean;
+    /** `partial`: a budgeted run stopped before the whole window was read; the next run goes on. */
+    state?: "partial" | "complete";
+    /** Why a budgeted run stopped early: its request budget, its deadline, or a cancel. */
+    stopped?: BudgetStop;
+    /** Messages of the window this run did not get to read; a budgeted run only. */
+    remaining?: number;
+    /** Requests a budgeted run spent. */
+    requests?: number;
     /** Emails that could not be read or parsed; they are tried again next run. */
     unreadable?: {
         message: string;
@@ -85,7 +94,13 @@ export interface MailSyncOptions {
     index?: (store: MessageStore, key: AccountKey) => Promise<MailIndexed>;
     /** Stops between batches of emails, after saving the resume point. */
     signal?: AbortSignal;
+    /**
+     * Makes the run budgeted: it reads the window in rounds, one request of the budget per call to the source, saves
+     * after each, stops when the budget says so and answers `state: "partial"`. A message the source could not give
+     * is tried once more at the end of the run and, if it still fails, left for the next one. `max` defaults to no limit.
+     */
+    budget?: RunBudget;
 }
-export declare const syncMail: (source: MailSource, store: MessageStore, { account, since, max, maxBodyChars, maxAttachmentChars, now, ages, loadEngine, retryAttachments, rescan, resumeFrom, index, signal, }: MailSyncOptions) => Promise<MailSyncResult>;
+export declare const syncMail: (source: MailSource, store: MessageStore, options: MailSyncOptions) => Promise<MailSyncResult>;
 /** Failures a newer install mends: the reader was missing, not the file at fault, so reading again can succeed. */
 export declare const RETRYABLE_ATTACHMENTS: string[];

package/dist/mail/sync.js

@@ -53,7 +53,100 @@ const readAttachments = async (mail, messageId, { loadEngine, maxAttachmentChars
     }
     return files;
 };
-export const syncMail = async (source, store, { account, since, max = 200, maxBodyChars = MAX_BODY_CHARS, maxAttachmentChars = MAX_ATTACHMENT_CHARS, now = Date.now, ages, loadEngine = importEngine, retryAttachments = false, rescan = false, resumeFrom = RESUME_FROM, index, signal, }) => {
+const LIST_SLICE = 200;
+const FETCH_SLICE = 50;
+const keyOf = (folder, uid) => `${folder}\0${uid}`;
+export const syncMail = async (source, store, options) => {
+    const { budget, index } = options;
+    if (budget === undefined || options.retryAttachments || options.account.mode === "mbox")
+        return syncRound(source, store, options);
+    const plan = {
+        budget,
+        tried: new Set(),
+        failed: new Set(),
+        searches: new Map(),
+        modes: new Map(),
+        unreadable: new Map(),
+        unlisted: new Set(),
+        stopped: null,
+        remaining: 0,
+        asked: 0,
+    };
+    const rounds = [];
+    const goOn = async () => {
+        for (;;) {
+            plan.asked = 0;
+            plan.remaining = 0;
+            try {
+                rounds.push(await syncRound(source, store, { ...options, index: undefined, max: options.max ?? Number.POSITIVE_INFINITY }, plan));
+            }
+            catch (error) {
+                // A request cut at the deadline, or failed after the budget was spent, is the run's end, not its failure: what
+                // earlier rounds saved is kept and the next run goes on. While the budget has room the error is real.
+                const transient = error instanceof CliError && (error.code === "timeout" || error.code === "network_error");
+                const stop = transient && rounds.length > 0 ? budget.take() : null;
+                if (stop === null)
+                    throw error;
+                plan.stopped = stop;
+                plan.remaining = Math.max(plan.remaining, 1);
+                return;
+            }
+            if (plan.stopped !== null || plan.remaining === 0)
+                return;
+        }
+    };
+    await goOn();
+    const remaining = plan.remaining;
+    // A message the server failed on once is often fine a minute later; only one more try, then the next run.
+    if (plan.stopped === null && plan.failed.size > 0) {
+        plan.only = new Set(plan.failed);
+        plan.failed.clear();
+        plan.tried.clear();
+        await goOn();
+    }
+    const last = rounds.at(-1);
+    const sum = (pick) => rounds.reduce((total, round) => total + pick(round), 0);
+    const unreadable = [
+        ...[...plan.unreadable].map(([message, reason]) => ({ message, reason })),
+        ...[...plan.unlisted].map((key) => ({
+            message: `uid:${key.replace("\0", ":")}`,
+            reason: "the server did not return it",
+        })),
+    ];
+    const complete = last.complete && plan.stopped === null && unreadable.length === 0 && remaining === 0;
+    const account = { provider: "email", account: options.account.address.toLowerCase() };
+    const indexed = plan.stopped === null ? await index?.(store, account) : undefined;
+    const deletionsSkipped = rounds.map((round) => round.deletionsSkipped).findLast((text) => text !== undefined);
+    const { unreadable: _unreadable, ...rest } = last;
+    return {
+        ...rest,
+        listed: sum((round) => round.listed),
+        saved: sum((round) => round.saved),
+        alreadyStored: sum((round) => round.alreadyStored),
+        skipped: sum((round) => round.skipped),
+        envelopes: sum((round) => round.envelopes),
+        deleted: sum((round) => round.deleted),
+        complete,
+        state: complete ? "complete" : "partial",
+        remaining,
+        requests: budget.used,
+        ...(plan.stopped === null ? {} : { stopped: plan.stopped }),
+        ...(indexed === undefined ? {} : { indexed }),
+        ...(unreadable.length ? { unreadable } : {}),
+        ...(deletionsSkipped === undefined ? {} : { deletionsSkipped }),
+        ...(rounds.some((round) => round.pass === "resumed") ? { pass: "resumed" } : {}),
+        ...(rounds.some((round) => round.attachments)
+            ? { attachments: rounds.flatMap((round) => round.attachments ?? []) }
+            : {}),
+        ...(rounds.some((round) => round.tagsReused)
+            ? { tagsReused: rounds.flatMap((round) => round.tagsReused ?? []) }
+            : {}),
+        ...(rounds.some((round) => round.tagsSkipped)
+            ? { tagsSkipped: rounds.flatMap((round) => round.tagsSkipped ?? []) }
+            : {}),
+    };
+};
+const syncRound = async (source, store, { account, since, max = 200, maxBodyChars = MAX_BODY_CHARS, maxAttachmentChars = MAX_ATTACHMENT_CHARS, now = Date.now, ages, loadEngine = importEngine, retryAttachments = false, rescan = false, resumeFrom = RESUME_FROM, index, signal, }, plan) => {
     if (retryAttachments)
         return retryUnread({
             store,
@@ -94,10 +187,24 @@ export const syncMail = async (source, store, { account, since, max = 200, maxBo
         if (point?.complete && point.size === mboxStamp.size && point.mtimeMs === mboxStamp.mtimeMs)
             mboxPoint = point;
     }
+    let capped = false;
     for (const folder of folders) {
         if (mboxPoint !== undefined)
             break;
-        const searched = source.search === undefined || snapshot ? undefined : await source.search(since, folder);
+        let searched;
+        if (source.search !== undefined && !snapshot) {
+            searched = plan?.searches.get(folder);
+            if (searched === undefined) {
+                const stop = plan?.budget.take();
+                if (plan && stop) {
+                    plan.stopped = stop;
+                    capped = true;
+                    continue;
+                }
+                searched = await source.search(since, folder);
+                plan?.searches.set(folder, searched);
+            }
+        }
         let wanted = searched;
         if (searched !== undefined) {
             searches.set(folder, searched);
@@ -107,18 +214,59 @@ export const syncMail = async (source, store, { account, since, max = 200, maxBo
             const point = fresh ? undefined : kept;
             if (point !== undefined && point.validity === searched.validity && point.rules === ruleSet) {
                 earlier.set(folder, point);
-                if (searched.uids.length >= resumeFrom &&
-                    Date.parse(point.full.since) <= since.getTime() &&
-                    startedAt - Date.parse(point.full.at) < FULL_PASS_MS) {
+                const mode = plan?.modes.get(folder);
+                const usable = Date.parse(point.full.since) <= since.getTime() && startedAt - Date.parse(point.full.at) < FULL_PASS_MS;
+                // A budgeted run goes on with an unfinished pass however small its window is: listing it whole again would
+                // ask for the same newest messages every run.
+                const unfinished = plan !== undefined && searched.uids.some((uid) => !within(point.done, Number(uid)));
+                if (mode === "resumed" ||
+                    (mode === undefined && usable && (searched.uids.length >= resumeFrom || unfinished))) {
                     resumed.add(folder);
                     wanted = { ...searched, uids: searched.uids.filter((uid) => !within(point.done, Number(uid))) };
                 }
             }
+            if (plan !== undefined) {
+                plan.modes.set(folder, resumed.has(folder) ? "resumed" : "full");
+                const open = wanted.uids.filter((uid) => plan.only
+                    ? plan.only.has(keyOf(folder, uid)) && !plan.tried.has(keyOf(folder, uid))
+                    : !plan.tried.has(keyOf(folder, uid)));
+                const slice = [...open].sort((a, b) => Number(b) - Number(a)).slice(0, source.listBatch ?? LIST_SLICE);
+                plan.remaining += open.length - slice.length;
+                wanted = { ...searched, uids: slice };
+                if (open.length > slice.length)
+                    capped = true;
+            }
+        }
+        if (plan !== undefined && wanted !== undefined && wanted.uids.length === 0)
+            continue;
+        if (plan !== undefined) {
+            const stop = plan.budget.take();
+            if (stop) {
+                plan.stopped = stop;
+                capped = true;
+                plan.remaining += (wanted?.uids ?? []).length;
+                continue;
+            }
+            for (const uid of wanted?.uids ?? [])
+                plan.tried.add(keyOf(folder, uid));
+            plan.asked += (wanted?.uids ?? []).length;
         }
         const found = await source.list(since, folder, {
             headers: rules.length > 0,
             ...(wanted === undefined ? {} : { searched: wanted }),
         });
+        if (plan !== undefined && wanted !== undefined) {
+            const got = new Set(found.map(({ uid }) => uid));
+            for (const uid of wanted.uids) {
+                const key = keyOf(folder, uid);
+                if (got.has(uid))
+                    plan.unlisted.delete(key);
+                else {
+                    plan.failed.add(key);
+                    plan.unlisted.add(key);
+                }
+            }
+        }
         // Spreading a whole mailbox into push() overflows the stack past ~120,000 emails.
         for (const item of found)
             collected.push(item);
@@ -151,6 +299,8 @@ export const syncMail = async (source, store, { account, since, max = 200, maxBo
     let skipped;
     if (snapshot)
         skipped = "an mbox file is a snapshot; mail missing from it is not proven deleted";
+    else if (plan !== undefined && (capped || plan.tried.size > plan.asked || plan.only !== undefined))
+        skipped = "this run read the window in parts; a run that lists all of it at once checks deletions";
     else if (resumed.size > 0)
         skipped =
             "this run listed only mail not read before; a full listing, at least daily or with --rescan, checks deletions";
@@ -355,14 +505,33 @@ export const syncMail = async (source, store, { account, since, max = 200, maxBo
         await tagStored(item);
         await saveNow();
     }
-    for (let start = 0; start < pending.length; start += FETCH_CHUNK) {
+    const fetchChunk = plan === undefined ? FETCH_CHUNK : (source.fetchBatch ?? FETCH_SLICE);
+    for (let start = 0; start < pending.length; start += fetchChunk) {
         await stopIfAborted();
-        const chunk = pending.slice(start, start + FETCH_CHUNK);
-        const raws = await source.fetchRaw(chunk);
+        const chunk = pending.slice(start, start + fetchChunk);
+        if (plan !== undefined) {
+            const stop = plan.budget.take();
+            if (stop) {
+                plan.stopped = stop;
+                full = true;
+                break;
+            }
+        }
+        let raws;
+        try {
+            raws = await source.fetchRaw(chunk);
+        }
+        catch (error) {
+            // What this run saved stays saved: the next one goes on from it.
+            await saveNow(true);
+            throw error;
+        }
         await stopIfAborted();
         // Every email of a chunk failing is the connection or the login, not the mail: stop instead of trying the rest.
-        if (chunk.length > 1 && raws.every((raw) => raw instanceof Error))
+        if (chunk.length > 1 && raws.every((raw) => raw instanceof Error)) {
+            await saveNow(true);
             throw raws[0];
+        }
         for (const [index, item] of chunk.entries()) {
             let mail;
             try {
@@ -372,9 +541,15 @@ export const syncMail = async (source, store, { account, since, max = 200, maxBo
                 mail = await parseMail(raw, maxBodyChars);
             }
             catch (error) {
-                unreadable.push({ message: item.messageId, reason: error instanceof Error ? error.message : String(error) });
+                const reason = error instanceof Error ? error.message : String(error);
+                unreadable.push({ message: item.messageId, reason });
+                if (plan !== undefined) {
+                    plan.unreadable.set(item.messageId, reason);
+                    plan.failed.add(keyOf(item.folder ?? folders[0], item.uid));
+                }
                 continue;
             }
+            plan?.unreadable.delete(item.messageId);
             const header = mailHeadersOf(raws[index]);
             const files = await readAttachments(mail, item.messageId, { loadEngine, maxAttachmentChars, at: startedAt }, attachments);
             await store.mail.saveThread({
@@ -426,7 +601,8 @@ export const syncMail = async (source, store, { account, since, max = 200, maxBo
         await store.mail.setFlags(accountId, new Map([...labelsOf].flatMap(([id, { seen, flagged }]) => seen === undefined && flagged === undefined
             ? []
             : [[id, { ...(seen === undefined ? {} : { read: seen }), ...(flagged === undefined ? {} : { flagged }) }]])), startedAt);
-    const complete = !full && unreadable.length === 0;
+    const incomplete = plan !== undefined && (capped || plan.stopped !== null || plan.failed.size > 0);
+    const complete = !full && !incomplete && unreadable.length === 0 && (plan?.unreadable.size ?? 0) === 0;
     const bulk = new Map(listed.filter((item) => item.headers?.bulk).map((item) => [item.messageId, [bulkBox.externalId]]));
     if (bulk.size)
         await store.mail.setMailboxes(accountId, [bulkBox], bulk, startedAt);

package/dist/mail/testing/fake.d.ts

@@ -41,6 +41,17 @@ export interface FakeMailbox {
     moveFails?: boolean;
     /** UIDs whose raw bytes cannot be read: `fetchRaw` answers an Error for each of them, and only for them. */
     unreadable?: string[];
+    /** UIDs that fail once, as a server's backend error does: `list` leaves each out, `fetchRaw` answers an Error. */
+    failOnce?: string[];
+    /** Calls the source answered, by kind, so a test counts a budget's requests. */
+    calls?: {
+        search: number;
+        list: number;
+        fetchRaw: number;
+    };
+    /** What the source tells a budgeted sync about its batch sizes. */
+    listBatch?: number;
+    fetchBatch?: number;
     /** What the source was asked: the UIDs of each listing, and `msgid:<id>` for each `find`. */
     asked?: string[];
 }

package/dist/mail/testing/fake.js

@@ -64,9 +64,26 @@ export const fakeMailSource = (mailbox) => {
                 .map((m) => m.uid),
         };
     };
+    const failedOnce = new Set();
+    const failsNow = (uid) => {
+        if (!mailbox.failOnce?.includes(uid) || failedOnce.has(uid))
+            return false;
+        failedOnce.add(uid);
+        return true;
+    };
+    const count = (kind) => {
+        if (mailbox.calls)
+            mailbox.calls[kind] += 1;
+    };
     return {
-        search,
+        ...(mailbox.listBatch === undefined ? {} : { listBatch: mailbox.listBatch }),
+        ...(mailbox.fetchBatch === undefined ? {} : { fetchBatch: mailbox.fetchBatch }),
+        search: async (since, folder) => {
+            count("search");
+            return search(since, folder);
+        },
         list: async (since, folder, options) => {
+            count("list");
             const { uids } = options?.searched ?? (await search(since, folder));
             if (uids.length > 0)
                 mailbox.asked?.push(uids.join(","));
@@ -74,7 +91,7 @@ export const fakeMailSource = (mailbox) => {
                 throw failure("the header fetch was refused");
             const wanted = new Set(uids);
             return inFolder(folder)
-                .filter((m) => wanted.has(m.uid))
+                .filter((m) => wanted.has(m.uid) && !failsNow(m.uid))
                 .map((m) => listingOf(m, options?.headers ?? false, folder));
         },
         find: async (messageIds, folder, options) => {
@@ -112,12 +129,15 @@ export const fakeMailSource = (mailbox) => {
                 if (messageIds.includes(m.messageId))
                     m.labels = [...new Set([...(m.labels ?? []), ...labels])];
         },
-        fetchRaw: async (items) => items.map((item) => {
-            const m = mailbox.messages.find((each) => each.uid === item.uid);
-            if (m === undefined || mailbox.unreadable?.includes(item.uid))
-                return failure(`email ${item.uid} was not read`);
-            return rawOf(m);
-        }),
+        fetchRaw: async (items) => {
+            count("fetchRaw");
+            return items.map((item) => {
+                const m = mailbox.messages.find((each) => each.uid === item.uid);
+                if (m === undefined || mailbox.unreadable?.includes(item.uid) || failsNow(item.uid))
+                    return failure(`email ${item.uid} was not read`);
+                return rawOf(m);
+            });
+        },
     };
 };
 /**

package/dist/runs/error-detail.d.ts

@@ -7,6 +7,8 @@ export interface RunError {
     class: string;
     code?: string;
     reason?: string;
+    /** The transport's own code (`NoConnection`, `ETIMEDOUT`, `UNAVAILABLE`), kept so a failed run says what broke. */
+    cause_code?: string;
     message?: string;
     /** Ours, not the messenger's: `messages.send`. */
     operation?: string;

package/dist/runs/error-detail.js

@@ -10,6 +10,9 @@ export const errorDetailOf = (error, response) => {
     const thrown = error instanceof Error ? error : undefined;
     const code = isCliFailure(error) ? error.code : codeOf(error);
     const reason = typeof details.reason === "string" ? details.reason : undefined;
+    const causeCode = typeof details.cause_code === "string" && /^[A-Za-z0-9_.-]{1,40}$/.test(details.cause_code)
+        ? details.cause_code
+        : undefined;
     const message = thrown ? redactText(thrown.message) : undefined;
     const operation = stringOf(details.operation) ?? response?.operation;
     const status = numberOf(details.status) ?? response?.status;
@@ -30,6 +33,7 @@ export const errorDetailOf = (error, response) => {
         class: classOf(error),
         ...(code === undefined ? {} : { code }),
         ...(reason === undefined ? {} : { reason }),
+        ...(causeCode === undefined ? {} : { cause_code: causeCode }),
         ...(message ? { message } : {}),
         ...(operation === undefined ? {} : { operation }),
         ...(http ? { http } : {}),

package/dist/speech/hearing.d.ts

@@ -19,6 +19,8 @@ export interface Hearing {
     unheard: Voice[];
     /** Why some were not heard — the first reason; the messages are still worth showing. */
     problem?: string;
+    /** Set under `--offline`: the command (`<app> <profile>`) that hears a message online, which `--offline` never does. */
+    offline?: string;
 }
 export declare const keyOf: ({ chatId, messageId }: Voice) => string;
 /** Telegram says `voice`; MAX says `audio` with Ogg in it. */

package/dist/speech/hearing.js

@@ -119,6 +119,16 @@ export const hearingMissing = (hearing, transcribe) => {
         return [{ field: "transcript", why: `not transcribed: ${hearing.problem}`, step: "messages.transcribe" }];
     if (hearing.unheard.length === 0)
         return [];
+    if (hearing.offline !== undefined) {
+        const commands = hearing.unheard.map(({ chatId, messageId }) => `${hearing.offline} messages transcribe ${chatId} ${messageId}`);
+        return [
+            {
+                field: "transcript",
+                why: `--offline reads only transcripts already stored; ${hearing.unheard.length} voice message(s) have none: ${commands.join("; ")}`,
+                step: "messages.transcribe",
+            },
+        ];
+    }
     const ids = hearing.unheard.map((voice) => voice.messageId).join(", ");
     return [
         {

package/dist/store/knowledge-query.js

@@ -13,10 +13,12 @@ export const PROJECTS_QUERY = {
     entity: "project",
     backend: "sql",
     fields: queryFieldsOf(project, {
-        native: ["id", "key", "type", "organization_id", "scope", "created_at"],
+        native: ["id", "key", "name", "kind", "type", "organization_id", "scope", "created_at"],
         examples: {
             id: "id:1",
             key: "key:SMP",
+            name: "name:*tart*",
+            kind: "kind:inbox",
             type: "type:work",
             organization_id: "organization_id:1",
             scope: "scope:work",

package/dist/store/people.d.ts

@@ -45,6 +45,8 @@ export interface PeopleStore extends AccountPeople {
     /** The person a `person:<uid>` reference names. */
     personSeenInAccounts(uid: string, accountIds: readonly number[]): Promise<boolean>;
     personByUid(uid: string): Promise<PersonRecord | undefined>;
+    /** The person marked as the owner, with every identity linked to them; `undefined` when none is. */
+    owner(): Promise<PersonRecord | undefined>;
     /** Accepted facts, the owner's notes and open tasks about them; tasks of an account only if `accounts` holds it. */
     preparation(uid: string, options: {
         accounts: readonly AccountKey[];

package/dist/store/people.js

@@ -1,4 +1,6 @@
+import { CliError } from "@wirecat/cli-base";
 import { keysOver } from "./keys.js";
+import { ownerPerson } from "./sqlite/actors.js";
 import * as identities from "./sqlite/identities.js";
 import { linkToOwner } from "./sqlite/own-identities.js";
 import * as personLinks from "./sqlite/person-links.js";
@@ -59,6 +61,16 @@ export const peopleStoreOver = (context, keyed) => {
         personOf: async (identity) => personLinks.personOf(context, identity),
         personSeenInAccounts: async (uid, accountIds) => personSeenInAccounts(context, uid, accountIds),
         personByUid: async (uid) => personLinks.personByUid(context, uid),
+        owner: async () => {
+            try {
+                return personLinks.personByUid(context, String(ownerPerson(database).id));
+            }
+            catch (error) {
+                if (error instanceof CliError && error.code === "configuration_error")
+                    return undefined;
+                throw error;
+            }
+        },
         preparation: async (uid, options) => personPreparation(context, uid, options),
         linkIdentities: async (person, other, options) => {
             return write(database, () => personLinks.linkIdentities(context, person, other, options));

package/dist/store/sqlite/knowledge.d.ts

@@ -1,4 +1,4 @@
-import type { QueryAst } from "@wirecat/cli-base/query";
+import { type QueryAst } from "@wirecat/cli-base/query";
 import type { AccountKey } from "../types.js";
 import { RELATION_KINDS } from "./link-kinds.js";
 import { type MeetingProjectsStore } from "./meeting-projects.js";
@@ -78,6 +78,8 @@ export interface Project {
     ref: string;
     key: string;
     name: string;
+    /** `inbox`: the per-account project that holds an account's tasks; listed only when asked for. */
+    kind: "project" | "inbox";
     type: (typeof PROJECT_TYPES)[number];
     organizationId: string | null;
     scope: (typeof SCOPES)[number];

package/dist/store/sqlite/knowledge.js

@@ -1,4 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
+import { walkQuery } from "@wirecat/cli-base/query";
 import { parseLocator } from "../../domain/locator.js";
 import { formatReference, parseReference } from "../../domain/references.js";
 import { normalizeTag } from "../../domain/tags.js";
@@ -11,7 +12,7 @@ import { meetingProjectsStoreOver } from "./meeting-projects.js";
 import { insertLink, linkOf } from "./notes.js";
 import { queryFilter } from "./query-filter.js";
 import { addTags as addThingTags, canonicalTagNamed, createTag, labelsOf, liveTagging, removeTags as removeThingTags, setMainTopic, } from "./tags.js";
-import { TASK_KEY_PREFIXES } from "./task-keys.js";
+import { INBOX_KEY_LENGTH, TASK_KEY_PREFIXES } from "./task-keys.js";
 import { inboxKey, taskAccountOf, taskIdOf, taskRowOf } from "./tasks.js";
 import { referenceOfThing, stateOfThing, storedThing, thingOf } from "./things.js";
 import { write } from "./transaction.js";
@@ -199,6 +200,7 @@ export const knowledgeStoreOver = (context) => {
         ref: `project:${row.id}`,
         key: String(row.key),
         name: String(row.name),
+        kind: String(row.key).length === INBOX_KEY_LENGTH ? "inbox" : "project",
         type: row.type,
         organizationId: row.organization_id == null ? null : String(row.organization_id),
         scope: row.scope,
@@ -489,17 +491,20 @@ export const knowledgeStoreOver = (context) => {
             return projectOf(row);
         }),
         projects: async (query) => {
+            const asksKind = query !== undefined && walkQuery(query.root).some((node) => node.field === "kind");
             const where = query &&
                 queryFilter(query, {
                     id: { type: "kw", sql: "CAST(id AS TEXT)" },
                     key: { type: "kw", sql: "key" },
+                    name: { type: "kw", sql: "name" },
+                    kind: { type: "enum", sql: `CASE WHEN length(key) = ${INBOX_KEY_LENGTH} THEN 'inbox' ELSE 'project' END` },
                     type: { type: "enum", sql: "type" },
                     organization_id: { type: "kw", sql: "CAST(organization_id AS TEXT)" },
                     scope: { type: "enum", sql: "scope" },
                     created_at: { type: "time", sql: "created_at" },
                 });
             return database
-                .prepare(`SELECT * FROM projects WHERE deleted_at IS NULL${where ? ` AND (${where.sql})` : ""} ORDER BY name, id LIMIT 500`)
+                .prepare(`SELECT * FROM projects WHERE deleted_at IS NULL${asksKind ? "" : ` AND length(key) <> ${INBOX_KEY_LENGTH}`}${where ? ` AND (${where.sql})` : ""} ORDER BY name, id LIMIT 500`)
                 .all(...(where?.params ?? []))
                 .map(projectOf);
         },

package/dist/store/sqlite/task-keys.d.ts

@@ -8,6 +8,7 @@ export declare const TASK_KEY_PREFIXES: Readonly<Record<TaskKind, string>>;
  */
 export declare const typedKey: (database: CacheDatabase, kind: TaskKind) => string;
 /** One inbox project per task account (`telegram:100`): derived from the account text alone, no `-` in it. */
+export declare const INBOX_KEY_LENGTH = 10;
 export declare const inboxKey: (account: string) => string;
 /** An inbox made before its messenger saved the account learns it here, not only on its next task. */
 export declare const linkInbox: (database: CacheDatabase, account: string, accountId: number) => void;

package/dist/store/sqlite/task-keys.js

@@ -22,6 +22,7 @@ export const typedKey = (database, kind) => {
     }
 };
 /** One inbox project per task account (`telegram:100`): derived from the account text alone, no `-` in it. */
+export const INBOX_KEY_LENGTH = 10;
 export const inboxKey = (account) => `IN${createHash("sha256").update(account).digest("hex").slice(0, 8).toUpperCase()}`;
 /** An inbox made before its messenger saved the account learns it here, not only on its next task. */
 export const linkInbox = (database, account, accountId) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.472.0",
+  "version": "0.474.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",