@wirecat/cli-core 0.390.0 → 0.392.0

package/dist/cli/messenger/download-command.js

@@ -17,7 +17,10 @@ import { nextStep } from "../steps.js";
 import { messengerContext, refuseLocalWrite } from "./context.js";
 import { stopOnSignal } from "./patience.js";
 /** `messages download`: every file of one message, or with `--all` of a whole chat, never over a file already there. */
-export const downloadSubcommand = (messages, messenger) => annotate(messages.command("download"), { effects: FETCH })
+export const downloadSubcommand = (messages, messenger) => annotate(messages.command("download"), {
+    examples: [`${messenger.app.command} personal messages download "Book club" 101 --output-dir ./downloads`],
+    effects: FETCH,
+})
     .description("save a message's photos, files, videos and voice notes to a folder — or a whole chat's with --all")
     .argument("<chat>", messenger.chatArgument)
     .argument("[message]", "the message id; left out with --all")

package/dist/cli/messenger/inbox.js

@@ -5,11 +5,11 @@ import { renderMessages } from "../../render/messages.js";
 import { CHAT_KINDS } from "../../services/chats.js";
 import { kindsOf } from "../../services/inbox.js";
 import { modelWith } from "../../speech/hearing.js";
-import { ownerOnlyOption, REMOTE_READ } from "../effects.js";
+import { REMOTE_READ } from "../effects.js";
 import { renderAnswer } from "../envelope.js";
 import { queryHelp } from "../list-query.js";
 import { positiveCount } from "../paging.js";
-import { MARK_READ_OPTION, markShown, marksRead, NO_MARK_READ_OPTION, pointsOf } from "./catch-up.js";
+import { pointsOf } from "./catch-up.js";
 import { catchUpQuery, INBOX_QUERY, inboxAnswer } from "./catch-up-answers.js";
 import { messengerContext } from "./context.js";
 import { hearForCommand, MODEL_OPTION, spokenItems, TRANSCRIBE_OPTION } from "./hearing-command.js";
@@ -42,10 +42,9 @@ export const inboxCommand = (messenger) => annotate(new Command("inbox"), {
     .option("--kind <kinds>", `only chats of these kinds, comma-separated: ${CHAT_KINDS.join(", ")}`)
     .option(...TRANSCRIBE_OPTION)
     .option(...MODEL_OPTION)
-    .addOption(ownerOnlyOption(...MARK_READ_OPTION))
-    .addOption(ownerOnlyOption(...NO_MARK_READ_OPTION))
+    .addHelpText("after", "To mark a chat read, use `chats mark-read <chat>`. The other side sees it.")
     .action(async function (query) {
-    const { new: fresh, all, kind, transcribe, model, markRead, } = this.opts();
+    const { new: fresh, all, kind, transcribe, model, } = this.opts();
     const hearWith = modelWith(transcribe, model);
     const context = messengerContext(this, messenger);
     const { app } = messenger;
@@ -64,8 +63,7 @@ export const inboxCommand = (messenger) => annotate(new Command("inbox"), {
         : undefined;
     const from = since ?? saved?.first;
     const points = saved?.chats;
-    const marking = marksRead(markRead, settings, this);
-    const { inbox, hearing, marked, reader } = await context.withServices(async (services, connect) => {
+    const { inbox, hearing, reader } = await context.withServices(async (services, connect) => {
         const inbox = await services.inbox.read({
             ...(from === undefined ? {} : { since: from }),
             ...(points === undefined ? {} : { points }),
@@ -76,11 +74,8 @@ export const inboxCommand = (messenger) => annotate(new Command("inbox"), {
         const reader = await services.messages.reader();
         const read = inbox.chats.flatMap((chat) => chat.messages.map((message) => ({ ...message, chatTitle: chat.title })));
         const hearing = await hearForCommand(context, messenger, read, transcribe === true, hearWith, connect);
-        const marked = marking ? await markShown(services, inbox.chats, renderer.warn) : undefined;
-        return { inbox, hearing, marked, reader };
+        return { inbox, hearing, reader };
     });
-    if (marked !== undefined)
-        renderer.note(`marked ${marked.length} chat(s) read up to the newest message shown`);
     if (inbox.partial && format === "pretty")
         renderer.warn(PARTIAL_NOTE);
     const answer = inboxAnswer(inbox, hearing, reader, transcribe === true, meta);

package/dist/cli/messenger/lacks.d.ts

@@ -7,6 +7,7 @@ type Need = readonly [method: keyof MessengerAdapter, what: string];
  */
 export declare const COMMAND_NEEDS: Readonly<Record<string, Need>>;
 interface Lacking {
+    channelComments?: boolean;
     lacks?: readonly (keyof MessengerAdapter)[];
     history?: "server" | "store";
 }

package/dist/cli/messenger/lacks.js

@@ -19,6 +19,7 @@ export const COMMAND_NEEDS = {
     "contacts remove": ["removeContact", "remove a contact"],
     "contacts rename": ["renameContact", "rename a contact"],
     "contacts import": ["importContacts", "import contacts"],
+    "messages comments": ["comments", "read comments on a channel post"],
     "messages pin": ["pin", "pin a message"],
     "messages unpin": ["unpin", "unpin a message"],
 };
@@ -27,7 +28,11 @@ const STORE_ANSWERS = new Set(["chats events"]);
 /** The one method this command needs and this messenger never has; none when it has it or the store answers. */
 export const lackedNeed = (messenger, path) => {
     const need = COMMAND_NEEDS[path];
-    if (!need || !messenger?.lacks?.includes(need[0]))
+    if (!need)
+        return undefined;
+    if (path === "messages comments" && messenger?.channelComments === false)
+        return need;
+    if (!messenger?.lacks?.includes(need[0]))
         return undefined;
     return messenger.history === "store" && STORE_ANSWERS.has(path) ? undefined : need;
 };

package/dist/cli/messenger/mcp-command.js

@@ -6,6 +6,7 @@ import { annotate } from "@wirecat/cli-base/commands";
 import { installerOf } from "@wirecat/cli-base/update";
 import { Command } from "commander";
 import { ATTACHMENT_LIMIT_ENV } from "../../attachments/limits.js";
+import { portOf, publicUrlOf } from "../../http/public-url.js";
 import { envName } from "../../ports/app.js";
 import { environmentOf } from "../context.js";
 import { grantsAuthority, LOCAL_READ, LOCAL_WRITE, REMOTE_WRITE } from "../effects.js";
@@ -17,32 +18,6 @@ import { messengerContext } from "./context.js";
 const DEFAULT_PORT = 8765;
 /** Where `mcp --http` keeps the hashes of the tokens it issued — per profile, in the state folder. */
 export const httpTokenFile = (app, profile, env) => join(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, "mcp-http", `${profile}.json`);
-const publicUrlOf = (app, given) => {
-    const example = `--public-url https://<name>.ts.net`;
-    if (!given)
-        throw new CliError("configuration_error", `--http needs the tunnel's address: ${example}`);
-    let url;
-    try {
-        url = new URL(given);
-    }
-    catch {
-        throw new CliError("validation_error", `--public-url is not an address: ${example}`);
-    }
-    const local = url.protocol === "http:" && ["localhost", "127.0.0.1"].includes(url.hostname);
-    if (url.protocol !== "https:" && !local)
-        throw new CliError("validation_error", `--public-url must be https — the browser apps reach ${app.command} through it`);
-    if (url.pathname !== "/" || url.search || url.hash)
-        throw new CliError("validation_error", `--public-url is the tunnel's address only, without a path: ${example}`);
-    return url;
-};
-const portOf = (given) => {
-    if (given === undefined)
-        return DEFAULT_PORT;
-    const port = Number(given);
-    if (!Number.isInteger(port) || port < 1 || port > 65535)
-        throw new CliError("validation_error", "--port takes 1–65535");
-    return port;
-};
 const withFlags = (command) => command.option("--permission <key=level>", "make a permission stricter for this server only, like messages.send=deny; it never loosens the profile; repeat for more keys", (value, previous = []) => [...previous, value]);
 export const mcpCommand = (messenger) => {
     const { app } = messenger;
@@ -61,11 +36,14 @@ export const mcpCommand = (messenger) => {
             return;
         }
         if (flags.http) {
-            const publicUrl = publicUrlOf(app, flags.publicUrl);
+            const publicUrl = publicUrlOf(flags.publicUrl, {
+                missing: "--http",
+                reaches: `the browser apps reach ${app.command}`,
+            });
             const { serveOverHttpUntilStopped } = await import("../../mcp/server.js");
             await serveOverHttpUntilStopped(this, context, messenger, {}, {
                 publicUrl,
-                port: portOf(flags.port),
+                port: portOf(flags.port, DEFAULT_PORT),
                 tokenFile: httpTokenFile(app, context.settings.profile, context.env),
             });
             return;

package/dist/cli/messenger/messages-command.js

@@ -7,7 +7,7 @@ import { renderMessages } from "../../render/messages.js";
 import { renderThreadLinks } from "../../render/thread-context.js";
 import { readMail } from "../../services/mail-search.js";
 import { modelWith, spoken } from "../../speech/hearing.js";
-import { ownerOnlyOption, REMOTE_READ } from "../effects.js";
+import { REMOTE_READ } from "../effects.js";
 import { itemOf, listOf, renderAnswer } from "../envelope.js";
 import { queryHelp } from "../list-query.js";
 import { positiveCount } from "../paging.js";
@@ -36,7 +36,10 @@ export const messagesCommand = (messenger) => {
     const messages = new Command("messages").description("read and send messages");
     messages.addCommand(evidenceCommand(messenger));
     const history = historyQuery(messenger);
-    const list = annotate(messages.command("list"), { effects: REMOTE_READ })
+    const list = annotate(messages.command("list"), {
+        examples: [`${messenger.app.command} personal messages list "Book club" --limit 20`],
+        effects: REMOTE_READ,
+    })
         .description("a chat's messages, oldest to newest")
         .addHelpText("after", SAVE_HELP)
         .addHelpText("after", queryHelp(history))
@@ -48,29 +51,19 @@ export const messagesCommand = (messenger) => {
         .option("--cursor <cursor>", "go on from where the last page stopped; page.next gives it")
         .option(...TRANSCRIBE_OPTION)
         .option(...MODEL_OPTION)
-        .addOption(ownerOnlyOption("--mark-read", "also mark the chat read up to the newest message shown; the other person sees it"))
+        .addHelpText("after", "To mark a chat read, use `chats mark-read <chat>`. The other side sees it.")
         .action(async function (chat, query) {
         const context = messengerContext(this, messenger);
-        const { cursor, transcribe, model, markRead } = this.opts();
+        const { cursor, transcribe, model } = this.opts();
         const window = historyWindow(query, cursor, "messages list", history);
         const hearWith = modelWith(transcribe, model);
-        if (markRead && window.threadId !== undefined) {
-            throw new CliError("validation_error", "--mark-read marks the whole chat; use `chats mark-read --topic` for one");
-        }
-        if (markRead && context.settings.offline) {
-            throw new CliError("validation_error", "--mark-read tells the messenger; not with --offline");
-        }
         const { limit } = context.settings;
-        const { page, hearing, marked, reader } = await context.withServices(async (services, connect) => {
+        const { page, hearing, reader } = await context.withServices(async (services, connect) => {
             const page = await services.messages.list(chat, { limit, ...window });
             const reader = await services.messages.reader();
-            const newest = page.items.at(-1);
-            const marked = markRead && newest ? await services.chats.markRead({ chat, until: newest.id }) : undefined;
             const hearing = await hearForCommand(context, messenger, page.items, transcribe === true, hearWith, connect);
-            return { page, hearing, marked, reader };
+            return { page, hearing, reader };
         });
-        if (marked)
-            context.renderer.note(`marked read up to ${marked.until} (operation ${marked.operationId})`);
         const next = page.hasMore
             ? cursorOf(window, { first: page.items[0]?.id, last: page.items.at(-1)?.id })
             : undefined;
@@ -115,7 +108,10 @@ export const messagesCommand = (messenger) => {
         }), view);
     };
     messages.addCommand(sendCommand(messenger));
-    annotate(messages.command("show"), { effects: REMOTE_READ })
+    annotate(messages.command("show"), {
+        examples: [`${messenger.app.command} personal messages show "Book club" 101`],
+        effects: REMOTE_READ,
+    })
         .description("one message, by its chat and id or by its msg: locator")
         .argument("<chat>", `${messenger.chatArgument}; or a msg: locator, with no message id after it`)
         .argument("[message]", "the message id")
@@ -124,7 +120,10 @@ export const messagesCommand = (messenger) => {
             return await readMailWindow(this, chat, { before: 0, after: 0 });
         await readWindow(this, chat, message, { before: 0, after: 0 });
     });
-    threadOptions(annotate(messages.command("context"), { effects: REMOTE_READ }))
+    threadOptions(annotate(messages.command("context"), {
+        examples: [`${messenger.app.command} personal messages context "Book club" 101 --before-n 3 --after-n 3`],
+        effects: REMOTE_READ,
+    }))
         .description("a message and what came either side of it, oldest first")
         .addHelpText("after", SAVE_HELP)
         .argument("<chat>", `${messenger.chatArgument}; or a msg: locator, with no message id after it`)

package/dist/cli/messenger/messages-comments-command.js

@@ -10,7 +10,10 @@ import { messengerContext } from "./context.js";
 import { COMMENTS_QUERY, cursorOf, historyWindow } from "./history-query.js";
 import { messageItems, viewOf } from "./message-items.js";
 export const commentsCommand = (messenger) => {
-    const command = annotate(new Command("comments"), { effects: REMOTE_READ })
+    const command = annotate(new Command("comments"), {
+        examples: [`${messenger.app.command} personal messages comments "News channel" 101 --limit 20`],
+        effects: REMOTE_READ,
+    })
         .description("the comments under a channel post, oldest to newest; they live in its discussion group")
         .addHelpText("after", queryHelp(COMMENTS_QUERY))
         .argument("<chat>", `the channel: ${messenger.chatArgument}`)

package/dist/cli/messenger/messages-delete-command.js

@@ -11,7 +11,10 @@ import { messengerContext } from "./context.js";
  * The guard asks first at the default level, `ask`; `--allow-dangerous` is the yes. For everyone only
  * with `--for-everyone` (max-cli `NEED-239`), and never for an agent (NEED-1423).
  */
-export const deleteCommand = (messenger) => annotate(new Command("delete"), { effects: REMOTE_WRITE })
+export const deleteCommand = (messenger) => annotate(new Command("delete"), {
+    examples: [`${messenger.app.command} personal messages delete "Book club" 101`],
+    effects: REMOTE_WRITE,
+})
     .description("delete messages for you only; with --for-everyone, for everyone in the chat")
     .argument("<chat>", messenger.chatArgument)
     .argument("<messages...>", `the message ids, by spaces or commas, at most ${DELETE_AT_ONCE}`)

package/dist/cli/messenger/messages-edit-command.js

@@ -8,7 +8,10 @@ import { afterWrite, writtenAnswer } from "./message-writes.js";
 import { HTML_HELP } from "./messages-send-command.js";
 import { readAll } from "./stdin.js";
 export const editCommand = (messenger) => {
-    const edit = annotate(new Command("edit"), { effects: REMOTE_WRITE })
+    const edit = annotate(new Command("edit"), {
+        examples: [`${messenger.app.command} personal messages edit "Book club" 101 "The meeting starts at 11."`],
+        effects: REMOTE_WRITE,
+    })
         .description("change the text of your own message; the other side may have read it already")
         .argument("<chat>", messenger.chatArgument)
         .argument("<message>", "the id of your own message")

package/dist/cli/messenger/messages-evidence-command.js

@@ -6,7 +6,10 @@ import { renderAnswer } from "../envelope.js";
 import { positiveCount } from "../paging.js";
 import { messengerContext } from "./context.js";
 import { evidenceAnswer } from "./message-answers.js";
-export const evidenceCommand = (messenger) => annotate(new Command("evidence"), { effects: LOCAL_READ })
+export const evidenceCommand = (messenger) => annotate(new Command("evidence"), {
+    examples: [`${messenger.app.command} personal messages evidence "Book club" --limit 10`],
+    effects: LOCAL_READ,
+})
     .description("a bounded evidence packet from stored messages, newest first")
     .argument("<chat>", messenger.chatArgument)
     .option("--limit <n>", "how many, 1–100", positiveCount("--limit"))

package/dist/cli/messenger/messages-forward-command.js

@@ -6,7 +6,10 @@ import { renderAnswer } from "../envelope.js";
 import { messengerContext } from "./context.js";
 import { afterWrite, writtenAnswer } from "./message-writes.js";
 export const forwardCommand = (messenger) => {
-    const forward = annotate(new Command("forward"), { effects: REMOTE_WRITE })
+    const forward = annotate(new Command("forward"), {
+        examples: [`${messenger.app.command} personal messages forward "Book club" 101 --to "Project room"`],
+        effects: REMOTE_WRITE,
+    })
         .description("forward one message to another chat")
         .argument("<chat>", `the chat the message is in: ${messenger.chatArgument}`)
         .argument("<message>", "the message id")

package/dist/cli/messenger/messages-link-command.js

@@ -4,7 +4,10 @@ import { REMOTE_READ } from "../effects.js";
 import { itemOf, renderAnswer } from "../envelope.js";
 import { messengerContext } from "./context.js";
 export const messageLinkCommand = (messenger) => {
-    const command = annotate(new Command("link"), { effects: REMOTE_READ })
+    const command = annotate(new Command("link"), {
+        examples: [`${messenger.app.command} personal messages link "Book club" 101`],
+        effects: REMOTE_READ,
+    })
         .description("a message permalink when supported, and its account-scoped locator")
         .argument("<chat>", `${messenger.chatArgument}; or a msg: locator, with no message id after it`)
         .argument("[message]", "the message id")

package/dist/cli/messenger/messages-scheduled-command.js

@@ -8,7 +8,10 @@ import { messengerContext } from "./context.js";
 import { messageItems, selfOf, viewOf } from "./message-items.js";
 /** Where to look after a scheduled send ended without an answer: repeating it would schedule a second one. */
 export const scheduledCommand = (messenger) => {
-    const command = annotate(new Command("scheduled"), { effects: REMOTE_READ })
+    const command = annotate(new Command("scheduled"), {
+        examples: [`${messenger.app.command} personal messages scheduled "Book club"`],
+        effects: REMOTE_READ,
+    })
         .description("messages waiting to be sent later in a chat, soonest first; cancel one in the app")
         .argument("<chat>", messenger.chatArgument)
         .action(async function (chat) {

package/dist/cli/messenger/messages-send-command.js

@@ -16,7 +16,10 @@ import { readAll } from "./stdin.js";
  */
 export const HTML_HELP = "the text is HTML: <b>, <i>, <a href>, <code>";
 export const sendCommand = (messenger) => {
-    const send = annotate(new Command("send"), { effects: REMOTE_WRITE })
+    const send = annotate(new Command("send"), {
+        examples: [`${messenger.app.command} personal messages send "Book club" "The meeting starts at 10."`],
+        effects: REMOTE_WRITE,
+    })
         .description("send a text message; without [text], the text is read from stdin")
         .argument("<chat>", messenger.chatArgument)
         .argument("[text]", "the message");

package/dist/cli/messenger/review.d.ts

@@ -5,7 +5,7 @@ export declare const unansweredHours: (value: unknown, flag?: string) => number;
 /**
  * **Everything said since a point, both sides, in every chat that changed** — the reading half of a
  * review of who owes what (max-cli's `review`). Sorting it is the reader's job, person or agent.
- * Nothing is marked read unless asked, and `inbox --new` keeps its point. The rules open and close
+ * Reading never marks a chat read, and `inbox --new` keeps its point. The rules open and close
  * tasks in the local store from what it read (`../../services/task-rules.ts`); nothing reaches the messenger.
  */
 export declare const reviewCommand: (messenger: Messenger) => Command;

package/dist/cli/messenger/review.js

@@ -6,10 +6,10 @@ import { renderMessages } from "../../render/messages.js";
 import { CHAT_KINDS } from "../../services/chats.js";
 import { kindsOf, REVIEW_DAYS, reviewStart, UNANSWERED_HOURS } from "../../services/inbox.js";
 import { modelWith } from "../../speech/hearing.js";
-import { ownerOnlyOption, REMOTE_READ } from "../effects.js";
+import { REMOTE_READ } from "../effects.js";
 import { renderAnswer } from "../envelope.js";
 import { queryHelp } from "../list-query.js";
-import { MARK_READ_OPTION, markShown, marksRead, NO_MARK_READ_OPTION, pointsOf } from "./catch-up.js";
+import { pointsOf } from "./catch-up.js";
 import { catchUpQuery, REVIEW_QUERY, reviewAnswer } from "./catch-up-answers.js";
 import { messengerContext } from "./context.js";
 import { heardItems, hearForCommand, MODEL_OPTION, spokenItems, TRANSCRIBE_OPTION } from "./hearing-command.js";
@@ -21,7 +21,7 @@ export const unansweredHours = (value, flag = "--unanswered") => value === true
 /**
  * **Everything said since a point, both sides, in every chat that changed** — the reading half of a
  * review of who owes what (max-cli's `review`). Sorting it is the reader's job, person or agent.
- * Nothing is marked read unless asked, and `inbox --new` keeps its point. The rules open and close
+ * Reading never marks a chat read, and `inbox --new` keeps its point. The rules open and close
  * tasks in the local store from what it read (`../../services/task-rules.ts`); nothing reaches the messenger.
  */
 export const reviewCommand = (messenger) => annotate(new Command("review"), {
@@ -38,8 +38,7 @@ export const reviewCommand = (messenger) => annotate(new Command("review"), {
     .option(...TRANSCRIBE_OPTION)
     .option(...MODEL_OPTION)
     .option("--new", "what changed since the last `review --new`, a point per chat — for scheduled runs")
-    .addOption(ownerOnlyOption(...MARK_READ_OPTION))
-    .addOption(ownerOnlyOption(...NO_MARK_READ_OPTION))
+    .addHelpText("after", "To mark a chat read, use `chats mark-read <chat>`. The other side sees it.")
     .action(async function (query) {
     const options = this.opts();
     const hearWith = modelWith(options.transcribe, options.model);
@@ -59,12 +58,11 @@ export const reviewCommand = (messenger) => annotate(new Command("review"), {
         })
         : undefined;
     const since = from ?? saved?.first ?? reviewStart();
-    const marking = marksRead(options.markRead, settings, this);
     const hours = options.unanswered === undefined ? undefined : unansweredHours(options.unanswered);
     const kinds = options.kind === undefined ? undefined : kindsOf(options.kind);
     let hearing;
     const transcribe = options.transcribe === true;
-    const { found, marked, reader } = await context.withServices(async (services, connect) => {
+    const { found, reader } = await context.withServices(async (services, connect) => {
         const found = await services.inbox.review({
             since,
             ...(saved === undefined ? {} : { points: saved.chats }),
@@ -84,13 +82,10 @@ export const reviewCommand = (messenger) => annotate(new Command("review"), {
         });
         return {
             found,
-            marked: marking ? await markShown(services, found.chats, context.renderer.warn) : undefined,
             reader: await services.messages.reader(),
         };
     });
     found.complete &&= (hearing?.unheard.length ?? 0) === 0;
-    if (marked !== undefined)
-        renderer.note(`marked ${marked.length} chat(s) read up to the newest message shown`);
     notes(found, format === "pretty", renderer);
     renderAnswer(this, context, reviewAnswer(found, hearing, reader, {
         transcribe,

package/dist/cli/messenger/tags-command.js

@@ -2,7 +2,7 @@ import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Command } from "commander";
 import { TAGGING_QUERY } from "../../services/tags.js";
-import { LOCAL_READ, LOCAL_WRITE } from "../effects.js";
+import { changesStore, FETCH, LOCAL_READ, LOCAL_WRITE } from "../effects.js";
 import { itemOf, renderAnswer, snakeKeys } from "../envelope.js";
 import { listQuery, pagedList, pageOf, typedQuery, withQuery } from "../list-query.js";
 import { positiveCount } from "../paging.js";
@@ -29,7 +29,7 @@ const sourceOf = (value) => {
 /** The owner's labels, in the local store only: `tag:` in a search finds what they label. */
 export const tagsCommand = (messenger) => {
     const tags = new Command("tags").description("your own labels on chats, people, messages and tasks, kept in the local store and never sent; tag: in a search finds them");
-    annotate(tags.command("auto"), { effects: LOCAL_WRITE })
+    changesStore(annotate(tags.command("auto"), { effects: FETCH }))
         .description("derive local group/channel tags from cached metadata using keyword rules")
         .option("--chat <chat>", "a stored group/channel; repeat to select several", (value, previous) => [...previous, value], [])
         .option("--limit <number>", "process at most 1–500 chats", positiveCount("--limit"), 50)

package/dist/cli/messenger/transcribe-command.js

@@ -8,7 +8,10 @@ import { messengerContext } from "./context.js";
 import { heardAnswer } from "./message-answers.js";
 import { keepRefreshedRefs } from "./refreshed-refs.js";
 /** `messages transcribe`: a voice message as text, by the messenger or by a model on this machine. */
-export const transcribeSubcommand = (messages, messenger) => annotate(messages.command("transcribe"), { effects: REMOTE_READ })
+export const transcribeSubcommand = (messages, messenger) => annotate(messages.command("transcribe"), {
+    examples: [`${messenger.app.command} personal messages transcribe "Book club" 101`],
+    effects: REMOTE_READ,
+})
     .description(`a voice message as text — by ${messenger.name ?? messenger.app.command} where it can, else by a model on this machine`)
     .argument("<chat>", messenger.chatArgument)
     .argument("<message>", "the id of a voice message")

package/dist/cli/settings.d.ts

@@ -78,8 +78,6 @@ export interface Settings extends AISettings {
     /** Unset means "decide from the terminal", which is `resolveOutput`'s job, not this one's. */
     color: boolean | undefined;
     senderColors: boolean;
-    /** `inbox` and `review` mark each chat they show read, as `--mark-read` does; the other side sees it. Off unless set. */
-    catchUpMarksRead: boolean;
     searchCatchUp?: boolean;
     /** Search and `images embed` read the pictures themselves, with a model on this machine. Off until set. */
     pictureSearch?: boolean;
@@ -297,7 +295,6 @@ export declare const settingsFor: <T extends object = Record<never, never>>(app:
             requests_per_minute: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 0, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
             transcribe_with: v.OptionalSchema<v.PicklistSchema<["auto", "messenger", "local"], (issue: v.BaseIssue<unknown>) => string>, undefined>;
             speech_model: v.OptionalSchema<v.StringSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
-            catch_up_marks_read: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             search_catch_up: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             picture_search: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             update_check: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
@@ -427,7 +424,6 @@ export declare const settingsFor: <T extends object = Record<never, never>>(app:
             requests_per_minute: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 0, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
             transcribe_with: v.OptionalSchema<v.PicklistSchema<["auto", "messenger", "local"], (issue: v.BaseIssue<unknown>) => string>, undefined>;
             speech_model: v.OptionalSchema<v.StringSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
-            catch_up_marks_read: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             search_catch_up: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             picture_search: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
         }, (issue: v.StrictObjectIssue) => string>, "has to be an object of profiles, by name">, {}>;

package/dist/cli/settings.js

@@ -48,7 +48,6 @@ const SHARED_PROFILE_ENTRIES = {
     requests_per_minute: v.optional(countOrZero),
     transcribe_with: v.optional(v.picklist(["auto", "messenger", "local"], plain("has to be auto, messenger or local"))),
     speech_model: v.optional(v.string(plain("has to be a model id from `models audio list`, in quotes"))),
-    catch_up_marks_read: v.optional(flag),
     search_catch_up: v.optional(flag),
     picture_search: v.optional(flag),
     ...AI_ENTRIES,
@@ -116,7 +115,10 @@ export const settingsFor = (app, extension = {}) => {
             return loadSnakeCaseConfig(path, extension.schema ?? schema, () => ({ profiles: {} }));
         }
         catch (error) {
-            throw new CliError("configuration_error", error instanceof Error ? error.message : String(error));
+            const message = error instanceof Error ? error.message : String(error);
+            throw new CliError("configuration_error", message.includes("catch_up_marks_read")
+                ? `${message}; remove catch_up_marks_read from the config file and use ${app.command} <profile> chats mark-read <chat>`
+                : message);
         }
     };
     /**
@@ -187,13 +189,15 @@ export const settingsFor = (app, extension = {}) => {
             [extension.sourcePaths ? "config file: defaults" : "config defaults", shared],
         ];
         const fromLayers = (key, fallback, only = layers) => first(only.map(([from, scope]) => [from, scope?.[key]]), fallback);
+        if (fromLayers("catch_up_marks_read", undefined).value !== undefined) {
+            throw new CliError("configuration_error", `remove catch_up_marks_read from the config file and use ${app.command} <profile> chats mark-read <chat>`);
+        }
         const kindLayers = layers.filter(([from]) => from.startsWith(`config file: ${kind}.`));
         const limit = flags.limit === undefined ? fromLayers("limit", DEFAULT_LIMIT) : { value: flags.limit, from: "flag" };
         const record = flags.record === undefined ? fromLayers("record", false) : { value: flags.record, from: "flag" };
         const timeoutMs = fromLayers("timeout_ms", undefined);
         const color = fromLayers("color", undefined);
         const senderColors = fromLayers("sender_colors", false);
-        const catchUpMarksRead = fromLayers("catch_up_marks_read", false);
         const searchCatchUp = fromLayers("search_catch_up", false);
         const pictureSearch = fromLayers("picture_search", false);
         const keepRunsForDays = fromLayers("keep_runs_for_days", DEFAULT_KEEP_RUNS_FOR_DAYS);
@@ -241,7 +245,6 @@ export const settingsFor = (app, extension = {}) => {
             offline: flags.offline === true,
             color: color.value,
             senderColors: senderColors.value,
-            catchUpMarksRead: catchUpMarksRead.value,
             searchCatchUp: searchCatchUp.value,
             pictureSearch: pictureSearch.value,
             limit: limit.value,
@@ -275,7 +278,6 @@ export const settingsFor = (app, extension = {}) => {
                 commandTimeoutMs: timeout.from,
                 color: color.from,
                 senderColors: senderColors.from,
-                catchUpMarksRead: catchUpMarksRead.from,
                 searchCatchUp: searchCatchUp.from,
                 pictureSearch: pictureSearch.from,
                 record: record.from,

package/dist/domain/providers.js

@@ -6,6 +6,8 @@ export const PROVIDERS = [
     { name: "telegram-bot", kind: "messages", aliases: ["tg-bot"] },
     { name: "max", kind: "messages", aliases: [] },
     { name: "max-bot", kind: "messages", aliases: [] },
+    { name: "whatsapp", kind: "messages", aliases: ["wa"] },
+    { name: "whatsapp-bot", kind: "messages", aliases: ["wa-bot"] },
     { name: "email", kind: "mail", aliases: [] },
     { name: "notes", kind: "notes", aliases: [] },
     { name: "zoom", kind: "meetings", aliases: [] },

package/dist/{mcp/http/node.d.ts → http/listen.d.ts}

@@ -4,13 +4,14 @@ export interface Listening {
     url: URL;
     close(): Promise<void>;
 }
-/** Larger bodies are refused unread: the port faces the internet, and MCP requests are small JSON. */
+/** Larger bodies are refused unread: the port faces the internet. MCP requests are small JSON. */
 export declare const MAX_BODY: number;
 /**
  * Binds `host` only — never every interface: the public address is the owner's tunnel.
  * `close` ends open streams too, so the process can exit.
  */
-export declare const listen: (handle: Handle, { host, port }: {
+export declare const listen: (handle: Handle, { host, port, maxBody }: {
     host: string;
     port: number;
+    maxBody?: number;
 }) => Promise<Listening>;

package/dist/{mcp/http/node.js → http/listen.js}

@@ -1,6 +1,6 @@
 import { createServer } from "node:http";
 import { Readable } from "node:stream";
-/** Larger bodies are refused unread: the port faces the internet, and MCP requests are small JSON. */
+/** Larger bodies are refused unread: the port faces the internet. MCP requests are small JSON. */
 export const MAX_BODY = 4 * 1024 * 1024;
 class TooLarge extends Error {
 }
@@ -21,7 +21,7 @@ const readBody = (incoming, limit) => new Promise((resolve, reject) => {
     incoming.once("end", () => resolve(Buffer.concat(chunks)));
     incoming.once("error", reject);
 });
-const toRequest = async (incoming, origin) => {
+const toRequest = async (incoming, origin, maxBody) => {
     const headers = new Headers();
     for (const [name, value] of Object.entries(incoming.headers)) {
         if (Array.isArray(value))
@@ -31,7 +31,7 @@ const toRequest = async (incoming, origin) => {
             headers.set(name, value);
     }
     const method = incoming.method ?? "GET";
-    const body = method === "GET" || method === "HEAD" ? undefined : await readBody(incoming, MAX_BODY);
+    const body = method === "GET" || method === "HEAD" ? undefined : await readBody(incoming, maxBody);
     if (body)
         headers.set("content-length", String(body.length));
     return new Request(new URL(incoming.url ?? "/", origin), { method, headers, ...(body ? { body } : {}) });
@@ -48,9 +48,9 @@ const send = async (response, outgoing) => {
  * Binds `host` only — never every interface: the public address is the owner's tunnel.
  * `close` ends open streams too, so the process can exit.
  */
-export const listen = (handle, { host, port }) => new Promise((resolve, reject) => {
+export const listen = (handle, { host, port, maxBody = MAX_BODY }) => new Promise((resolve, reject) => {
     const server = createServer((incoming, outgoing) => {
-        toRequest(incoming, `http://${host}`)
+        toRequest(incoming, `http://${host}`, maxBody)
             .then(handle)
             .then((response) => send(response, outgoing))
             .catch((error) => {

package/dist/http/public-url.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The tunnel's address a public listener is reached at, checked one way for every command that opens
+ * one. `missing` says what needs it; `reaches` who calls through it, for the https refusal.
+ */
+export declare const publicUrlOf: (given: string | undefined, { missing, reaches }: {
+    missing: string;
+    reaches: string;
+}) => URL;
+/** A local port from `--port`, or the command's own default. */
+export declare const portOf: (given: string | undefined, fallback: number) => number;