@wirecat/whatsapp-cli 0.4.0 → 0.7.0

package/README.md

@@ -45,6 +45,8 @@ You:    Yes.
 **Early.** `wa` is new, and some of what it does has not yet been checked against real WhatsApp. The
 [backlog](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/dev/BACKLOG.md) lists the checks still to run.
 
+More: [compared with other tools](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/compare.md) · [on wirecat.dev](https://wirecat.dev/en/docs/wa/compare)
+
 ## Quick start
 
 ```sh
@@ -117,11 +119,11 @@ Your agent. Your WhatsApp. Your rules.
   comes with ready prompts: `/catch-up`, `/review`, `/reply`, `/find` and more.
 
 ```sh
-wa personal mcp setup claude-code   # or: wa personal mcp setup codex
+wa personal mcp add claude-code   # or: wa personal mcp add codex
 wa personal mcp config              # the entry for Claude Desktop, Cursor and others
 ```
 
-The profile can send by default, so `mcp setup` stops first. Check the profile's permissions, then run it again with
+The profile can send by default, so `mcp add` stops first. Check the profile's permissions, then run it again with
 `--allow-writes`.
 
 More: [the MCP server](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/mcp.md) · [from the browser](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/remote.md)
@@ -130,6 +132,8 @@ More: [the MCP server](https://github.com/WireCatLabs/whatsapp-cli/blob/main/doc
 
 - **Your own account, as a linked device.** `wa` links the way WhatsApp Web does. It sees your chats, groups and
   contacts, and speaks as you, not as a business account or a bot.
+- **A business number too, when you have one.** `wa <profile> bot` speaks for a WhatsApp Business number on Meta's
+  Cloud API: send, templates, and messages received by webhook through your tunnel ([bot](docs/bot.md)).
 - **Local-first search.** Everything received is kept on your computer. Every read and search answers from there and
   never connects.
 - **Made for agents.** One operation per call, the same JSON shape every time with `--json`, a fixed exit code for
@@ -252,7 +256,7 @@ changing anything; at `ask` the server shows no form, so set up approval in your
 
 ```sh
 claude mcp add wa -- wa personal mcp  # Claude Code, by hand
-wa personal mcp doctor                # check the local MCP server
+wa personal mcp check                # check the local MCP server
 ```
 
 **From the browser.** ChatGPT or Claude in the browser reach `wa personal mcp --http --public-url` behind your tunnel,
@@ -357,6 +361,7 @@ Every page is in [`docs/`](https://github.com/WireCatLabs/whatsapp-cli/blob/main
 | [people](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/people.md) | One person: what the store holds about them, your own names and notes |
 | [mcp](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/mcp.md) | How do I connect Claude Desktop, Cursor or another client without a terminal? |
 | [remote](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/remote.md) | ChatGPT or Claude in the browser, through a login and a tunnel |
+| [bot](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/bot.md) | A WhatsApp Business number on Meta's Cloud API: setup, sending, templates, receiving by webhook |
 | [recipes](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/recipes.md) | What can an agent do for me every day, and how do I run it on a schedule? |
 | [commands](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/commands.md) | Every command, option and exit code — **generated** from the program |
 | [configuration](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/configuration.md) | How do I configure common behaviour? |
@@ -365,6 +370,7 @@ Every page is in [`docs/`](https://github.com/WireCatLabs/whatsapp-cli/blob/main
 | [configuration-reference](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/configuration-reference.md) | Every key, default, scope and variable |
 | [cli-contract](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/cli-contract.md) | Invocation, output, errors, headless runs, bounds and previews |
 | [limits](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/limits.md) | Limits, waits and the one connection per device |
+| [compare](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/compare.md) · [web](https://wirecat.dev/en/docs/wa/compare) | How does `wa` compare with wacli, whatsapp-mcp, mudslide and the Cloud API, and when does another tool fit better? |
 | [diagnostics](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/diagnostics.md) | What did a command do, and what is never recorded? |
 | [troubleshooting](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/troubleshooting.md) | Something does not work: what the screen says, and what to do |
 | [security](https://github.com/WireCatLabs/whatsapp-cli/blob/main/docs/security.md) | What does `wa` keep on my computer, and what can go wrong? |

package/dist/adapter/adapter.d.ts

@@ -2,12 +2,14 @@ import { type MarkdownFormatting } from "@wirecat/cli-core";
 import type { LiveUpdates, MessageEditing, MessageMedia, MessagePins, MessageReactions, MessageStars, MessengerCore, PassiveUpdates, PushedHistory, ReadState, ServerReads, StoredMessages } from "@wirecat/cli-core/cli";
 import { type WhatsAppEngine } from "../engine/contract.js";
 import type { Words } from "./checks.js";
+import { type CommentAdapter } from "./comments.js";
+import { type DiscoveryAdapter } from "./discovery.js";
 import { type GroupAdapter } from "./groups.js";
 import { type PollAdapter } from "./polls.js";
 import { type PrivacyAdapter } from "./privacy.js";
 import { type SettingsAdapter } from "./settings.js";
-export type WhatsAppAdapter = MessengerCore & LiveUpdates & PassiveUpdates & PushedHistory & Pick<MessageEditing, "edit" | "delete" | "forward"> & Pick<MessageMedia, "download"> & MessageReactions & MessageStars & ReadState & Pick<ServerReads, "history"> & MarkdownFormatting & PollAdapter & GroupAdapter & PrivacyAdapter & MessagePins & SettingsAdapter;
+export type WhatsAppAdapter = MessengerCore & LiveUpdates & PassiveUpdates & PushedHistory & Pick<MessageEditing, "edit" | "delete" | "forward"> & Pick<MessageMedia, "download"> & MessageReactions & MessageStars & ReadState & Pick<ServerReads, "history"> & MarkdownFormatting & PollAdapter & GroupAdapter & PrivacyAdapter & MessagePins & SettingsAdapter & DiscoveryAdapter & CommentAdapter;
 export declare const whatsAppAdapter: (engine: WhatsAppEngine, stored?: StoredMessages, words?: Words, 
 /** Where a skipped pushed event is said — a warning, so `--quiet` drops it. The diagnostic stream if not given. */
-warn?: (message: string) => void) => WhatsAppAdapter;
+warn?: (message: string) => void, now?: () => number) => WhatsAppAdapter;
 //# sourceMappingURL=adapter.d.ts.map

package/dist/adapter/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/adapter/adapter.ts"],"names":[],"mappings":"AAMA,OAAO,EAGL,KAAK,kBAAkB,EAMxB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EACd,YAAY,EACZ,WAAW,EACX,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,cAAc,EACd,aAAa,EACb,SAAS,EAGT,WAAW,EACX,cAAc,EACf,MAAM,uBAAuB,CAAA;AAE9B,OAAO,EASL,KAAK,cAAc,EACpB,MAAM,uBAAuB,CAAA;AAE9B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAGxC,OAAO,EAAE,KAAK,YAAY,EAAgB,MAAM,aAAa,CAAA;AAc7D,OAAO,EAAE,KAAK,WAAW,EAA2C,MAAM,YAAY,CAAA;AACtF,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,cAAc,CAAA;AAClE,OAAO,EAAuB,KAAK,eAAe,EAAkC,MAAM,eAAe,CAAA;AAEzG,MAAM,MAAM,eAAe,GAAG,aAAa,GACzC,WAAW,GACX,cAAc,GACd,aAAa,GACb,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC,GACnD,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,GAC9B,gBAAgB,GAChB,YAAY,GACZ,SAAS,GACT,IAAI,CAAC,WAAW,EAAE,SAAS,CAAC,GAC5B,kBAAkB,GAClB,WAAW,GACX,YAAY,GACZ,cAAc,GACd,WAAW,GACX,eAAe,CAAA;AAqMjB,eAAO,MAAM,eAAe,WAClB,cAAc,WACd,cAAc,UACf,KAAK;AACZ,mHAAmH;OAC7G,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,KAC9B,eAqeF,CAAA"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/adapter/adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,kBAAkB,EAIxB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EACd,YAAY,EACZ,WAAW,EACX,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,cAAc,EACd,aAAa,EACb,SAAS,EACT,WAAW,EACX,cAAc,EACf,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAsC,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAE/F,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACxC,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,eAAe,CAAA;AACnE,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,gBAAgB,CAAA;AAGxE,OAAO,EAAE,KAAK,YAAY,EAAgB,MAAM,aAAa,CAAA;AAI7D,OAAO,EAAE,KAAK,WAAW,EAAe,MAAM,YAAY,CAAA;AAC1D,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,cAAc,CAAA;AAElE,OAAO,EAAuB,KAAK,eAAe,EAAkC,MAAM,eAAe,CAAA;AAEzG,MAAM,MAAM,eAAe,GAAG,aAAa,GACzC,WAAW,GACX,cAAc,GACd,aAAa,GACb,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC,GACnD,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,GAC9B,gBAAgB,GAChB,YAAY,GACZ,SAAS,GACT,IAAI,CAAC,WAAW,EAAE,SAAS,CAAC,GAC5B,kBAAkB,GAClB,WAAW,GACX,YAAY,GACZ,cAAc,GACd,WAAW,GACX,eAAe,GACf,gBAAgB,GAChB,cAAc,CAAA;AAoChB,eAAO,MAAM,eAAe,WAClB,cAAc,WACd,cAAc,UACf,KAAK;AACZ,mHAAmH;OAC7G,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,QAC1B,MAAM,MAAM,KAChB,eA+KF,CAAA"}

package/dist/adapter/adapter.js

@@ -1,19 +1,19 @@
 import { randomBytes } from "node:crypto";
-import { createReadStream } from "node:fs";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { resolve as absolute, extname, join } from "node:path";
 import { CliError } from "@wirecat/cli-base";
 import { bareCheck, parseMarkdownSpans, pickChat, } from "@wirecat/cli-core";
-import { EngineError, OLDER_MAX, } from "../engine/contract.js";
-import { channelAdapter, channelHistory, channelWrites, isChannel, refuseChannelPost } from "./channels.js";
+import { EngineError, OLDER_MAX } from "../engine/contract.js";
+import { channelAdapter, channelHistory, channelWrites, isChannel } from "./channels.js";
+import { commentAdapter } from "./comments.js";
+import { discoveryAdapter } from "./discovery.js";
 import { fromEngine } from "./errors.js";
 import { toWhatsApp } from "./format-markdown.js";
 import { groupAdapter } from "./groups.js";
-import { isFile, sameFile, toAccount, toChat, toChatEvent, toChatUpdate, toMember, toMessage, toPersonReaction, toWaAttachment, } from "./map.js";
+import { listenAdapter } from "./listen.js";
+import { toAccount, toChat, toMember, toMessage } from "./map.js";
 import { pinAdapter } from "./pins.js";
-import { pollAdapter, toHistoryVote, toVoteEvent } from "./polls.js";
+import { pollAdapter } from "./polls.js";
 import { privacyAdapter } from "./privacy.js";
+import { onDisk, sendAdapter } from "./sends.js";
 import { AFTER_EVERY_MESSAGE, settingsAdapter, settingsWrite } from "./settings.js";
 // WhatsApp addresses a message by its sender and by whether it is the account's own, and the engine keeps no
 // messages, so an edit, a deletion, a reaction or a read receipt looks the message up in cli-core's store first.
@@ -26,8 +26,6 @@ const NOTHING_STORED = {
 };
 // whatsmeow's EditWindow: WhatsApp clients ignore an edit that comes later.
 const EDIT_WINDOW_MS = 20 * 60 * 1000;
-/** Options WhatsApp has no way to honour; `noPreview` is always true, since nothing here builds link previews. */
-const REFUSED = ["threadId", "markup", "sticker", "spoiler", "captionAbove"];
 const translated = async (work) => {
     try {
         return await work;
@@ -35,117 +33,14 @@ const translated = async (work) => {
     catch (error) {
         if (error instanceof EngineError)
             throw fromEngine(error);
-        throw error;
+        if (error instanceof CliError)
+            throw error;
+        const failure = new CliError("provider_error", "WhatsApp engine request failed");
+        Object.defineProperty(failure, "cause", { value: error });
+        throw failure;
     }
 };
-const hit = (message) => ({ ...message, chatTitle: null });
 const PHONE_CHAT = /^\d+@s\.whatsapp\.net$/;
-const ENDED = {
-    logged_out: (words) => fromEngine(new EngineError("authentication_error", `WhatsApp logged this device out — log in again with ${words("session.start")}`, "device.logged-out")),
-    replaced: () => fromEngine(new EngineError("provider_unavailable", "another process took over this WhatsApp login; only one may hold it", "device.replaced")),
-    banned: (_words, until) => fromEngine(new EngineError("permission_error", "WhatsApp has banned or restricted this account; see the phone", "account.banned", until)),
-    outdated: () => fromEngine(new EngineError("provider_unavailable", "WhatsApp no longer accepts this version of wa; update it", "client.outdated")),
-    stopped: () => fromEngine(new EngineError("provider_unavailable", "the WhatsApp engine stopped unexpectedly", "engine.stopped")),
-};
-const ENDING = new Set([
-    ...Object.values(ENDED).map((end) => end(bareCheck).details.reason),
-    "engine.stopped-mid-write",
-]);
-/** A failure that means the connection is gone, not that one event was odd: it ends the listening. */
-const ends = (error) => (error instanceof EngineError && ENDING.has(error.reason)) ||
-    (error instanceof CliError && ENDING.has(error.details.reason));
-/**
- * Hands each event on until `signal` aborts; a connection WhatsApp ended rejects with why, unless `expected` says this
- * process asked for that end. Events are handled one at a time in arrival order. One whose handling fails is skipped
- * and the next still runs: a stalled queue would keep every later push out of the store until a restart. The first skip
- * is said on `warn` at once, kind and code only, never its content; `drained` settles when the handling caught up and
- * then says how many were skipped if there were more.
- */
-const listening = (engine, kinds, signal, words, warn, handle, expected = () => false) => {
-    let stop = () => { };
-    let queue = Promise.resolve();
-    let skipped = 0;
-    let fail = () => { };
-    const run = (kind, work) => {
-        queue = queue.then(work).catch((error) => fail(kind, error));
-    };
-    const done = new Promise((resolve, reject) => {
-        fail = (kind, error) => {
-            if (ends(error))
-                return reject(error instanceof EngineError ? fromEngine(error) : error);
-            skipped += 1;
-            if (skipped > 1)
-                return;
-            const code = error instanceof CliError ? error.code : error instanceof Error ? error.name : "error";
-            warn(`a pushed ${kind} event could not be handled and was skipped (${code}); the ones after it go on, ` +
-                "and any more skips are counted when wa stops listening");
-        };
-        const unlisten = engine.listen(kinds, (event) => {
-            if (event.event === "connection" && expected(event.state))
-                return resolve();
-            const ended = event.event === "connection" ? ENDED[event.state]?.(words, event.until) : undefined;
-            if (ended)
-                reject(ended);
-            else
-                run(event.event, () => handle(event));
-        });
-        const aborted = () => resolve();
-        signal.addEventListener("abort", aborted, { once: true });
-        stop = () => {
-            unlisten();
-            signal.removeEventListener("abort", aborted);
-        };
-        if (signal.aborted)
-            resolve();
-    });
-    // The caller may still be awaiting the engine's readiness when an ended connection rejects `done`.
-    done.catch(() => { });
-    const drained = () => queue.then(() => {
-        if (skipped > 1)
-            warn(`${skipped} pushed events could not be handled and were skipped in all`);
-    });
-    return { done, stop, drained, run };
-};
-/** Re-keys that arrive this close together go to cli-core as one batch, up to this many. */
-const REKEY_WINDOW_MS = 100;
-const REKEY_BATCH = 500;
-const VIDEO = new Set([".mp4", ".m4v", ".mov"]);
-/** As tg sends them: a photo as a photo, a voice as a voice, a video as a video unless `--as-file`, the rest as files. */
-const uploadKind = ({ kind, name, asFile }) => kind === "photo" || kind === "voice" ? kind : !asFile && VIDEO.has(extname(name).toLowerCase()) ? "video" : "document";
-/** A folder only this user can read, gone when `work` ends: the engine writes a download into it, or reads bytes made in memory. */
-const inPrivateFolder = async (work) => {
-    const folder = await mkdtemp(join(tmpdir(), "wa-media-"));
-    try {
-        return await work(folder);
-    }
-    finally {
-        await rm(folder, { recursive: true, force: true });
-    }
-};
-const onDisk = async (source, work) => {
-    if (source.kind === "file")
-        return work(absolute(source.path));
-    return inPrivateFolder(async (folder) => {
-        const path = join(folder, "upload");
-        await writeFile(path, source.bytes, { mode: 0o600, flag: "wx" });
-        return work(path);
-    });
-};
-const allOnDisk = async (files, work, placed = []) => {
-    const [next, ...rest] = files;
-    if (!next)
-        return work(placed);
-    return onDisk(next.upload.source, (path) => allOnDisk(rest, work, [...placed, { ...next, path }]));
-};
-const quoted = (message) => ({
-    id: message.id,
-    senderId: message.senderId,
-    senderName: message.senderName,
-    timestamp: message.timestamp,
-    text: message.text,
-    attachments: message.attachments,
-    outgoing: message.outgoing ?? null,
-});
 const keyOf = (chatId, message) => ({
     chat: chatId,
     id: message.id,
@@ -154,7 +49,7 @@ const keyOf = (chatId, message) => ({
 });
 export const whatsAppAdapter = (engine, stored = NOTHING_STORED, words = bareCheck, 
 /** Where a skipped pushed event is said — a warning, so `--quiet` drops it. The diagnostic stream if not given. */
-warn = (line) => process.stderr.write(`${line}\n`)) => {
+warn = (line) => process.stderr.write(`${line}\n`), now = Date.now) => {
     // A guessed key would make WhatsApp drop the change without a word, so a message the store lacks is refused.
     const held = async (chatId, messageId) => {
         const message = await stored.message(chatId, messageId);
@@ -162,178 +57,13 @@ warn = (line) => process.stderr.write(`${line}\n`)) => {
             throw new CliError("not_found", `that message is not in the local store, and WhatsApp needs its sender to address it; ${words("serve")} keeps the store filled`);
         return message;
     };
-    // Set by `session end`: WhatsApp then ends the connection as logged out, which is the answer, not a failure.
-    let loggingOut = false;
-    // Held re-keys of a running `feed`: a live event may name the new id, and must not reach cli-core before them (§5).
-    const holding = new Set();
-    const handingOn = (onEvent, signal, expected) => {
-        const handed = async (event) => {
-            for (const handOn of holding)
-                handOn();
-            if (event.event === "message")
-                onEvent({ event: "message", message: hit(toMessage(event.message)) });
-            else if (event.event === "edit")
-                onEvent({ event: "edit", message: hit(toMessage(event.message)) });
-            else if (event.event === "delete")
-                onEvent({
-                    event: "delete",
-                    chatId: event.chat,
-                    chatTitle: null,
-                    messageId: event.id,
-                });
-            else if (event.event === "star")
-                onEvent({
-                    event: "star",
-                    chatId: event.chat,
-                    chatTitle: null,
-                    messageId: event.id,
-                    starred: event.starred,
-                });
-            else if (event.event === "reaction")
-                onEvent({
-                    event: "person_reaction",
-                    chatId: event.reaction.chat,
-                    chatTitle: null,
-                    messageId: event.reaction.message,
-                    reaction: toPersonReaction(event.reaction),
-                });
-            else if (event.event === "receipt")
-                onEvent({
-                    event: "delivery",
-                    chatId: event.receipt.chat,
-                    chatTitle: null,
-                    messageId: event.receipt.id,
-                    delivery: event.receipt.delivery,
-                    at: event.receipt.at,
-                });
-            else if (event.event === "vote") {
-                const vote = await toVoteEvent(event.vote, stored);
-                if (vote)
-                    onEvent(vote);
-            }
-            else if (event.event === "chat_event")
-                onEvent({
-                    event: "chat_event",
-                    chatId: event.change.chat,
-                    chatTitle: null,
-                    change: toChatEvent(event.change),
-                });
-        };
-        // In arrival order: a vote reads its poll from the store, and nothing after it may overtake it.
-        const live = listening(engine, ["message", "edit", "delete", "vote", "reaction", "star", "receipt", "chat_event", "connection"], signal, words, warn, handed, expected);
-        return {
-            done: live.done,
-            stop: async () => {
-                live.stop();
-                await live.drained();
-            },
-        };
-    };
-    // A push after a re-link carries the path the file had then, and the store may hold the one the phone uploaded
-    // again. cli-core keeps a stored ref only when the pushed file has none, so the pushed one is left off when it names
-    // the same file; another file keeps its own. Only a message with a ref costs a store read; one that fails hands the
-    // message on as pushed, never loses it.
-    const withoutKeptRefs = async (message) => {
-        if (!message.attachments.some((file) => file.providerRef))
-            return message;
-        const kept = await stored.message(message.chatId, message.id).catch(() => undefined);
-        if (!kept?.attachments.some((file) => file.providerRef))
-            return message;
-        return {
-            ...message,
-            attachments: message.attachments.map((file, position) => {
-                if (!sameFile(file.providerRef, kept.attachments[position]?.providerRef))
-                    return file;
-                const { providerRef: _pushed, ...rest } = file;
-                return rest;
-            }),
-        };
-    };
-    const pushing = async (onBatch, signal, expected) => {
-        // cli-core saves each batch's re-keys apart, so thousands at a serve's start must not come one batch each; a push
-        // hands on the held ones before its own, as they arrived.
-        let held = [];
-        let due;
-        const flush = () => {
-            clearTimeout(due);
-            due = undefined;
-            if (held.length === 0)
-                return;
-            const rekeys = held;
-            held = [];
-            onBatch({ rekeys });
-        };
-        // In arrival order: a push waits for its store reads, and a re-key after it must not overtake it.
-        const handed = async (event) => {
-            if (event.event === "rekey") {
-                held.push({ from: event.from, to: event.to });
-                if (held.length >= REKEY_BATCH)
-                    flush();
-                else
-                    due ??= setTimeout(() => pushes.run("rekey", flush), REKEY_WINDOW_MS);
-                return;
-            }
-            if (event.event !== "history")
-                return;
-            flush();
-            const { rekeys, chats, contacts, messages, votes, reactions, events } = event.history;
-            onBatch({
-                rekeys: rekeys ?? [],
-                chats: chats.map(toChatUpdate),
-                people: contacts.map(toMember),
-                messages: await Promise.all(messages.map((message) => withoutKeptRefs(toMessage(message)))),
-                votes: votes.flatMap((vote) => toHistoryVote(vote) ?? []),
-                reactions: (reactions ?? []).map((reaction) => ({
-                    chatId: reaction.chat,
-                    messageId: reaction.message,
-                    reaction: toPersonReaction(reaction),
-                })),
-                events: (events ?? []).map((change) => ({ chatId: change.chat, change: toChatEvent(change) })),
-            });
-        };
-        const pushes = listening(engine, ["history", "rekey", "connection"], signal, words, warn, handed, expected);
-        const handOn = () => {
-            try {
-                flush();
-            }
-            catch (error) {
-                pushes.run("rekey", () => Promise.reject(error));
-            }
-        };
-        holding.add(handOn);
-        try {
-            await pushes.done;
-        }
-        finally {
-            holding.delete(handOn);
-            pushes.stop();
-            pushes.run("rekey", flush);
-            await pushes.drained();
-        }
-    };
-    const ownLogout = (state) => state === "logged_out" && loggingOut;
     // A deletion for the account alone, a star and a chat marked read are changes to its synced settings, not messages.
     const synced = settingsWrite(translated, words);
-    // The phone's new upload replaces the whole stored ref on `file`, so cli-core saves it and a later download or a
-    // forward uses the live path; a second read of the same file in this run uses it too.
-    async function* fetched(file, attachment, key) {
-        const folder = await mkdtemp(join(tmpdir(), "wa-media-"));
-        try {
-            const path = join(folder, "file");
-            const renewed = await translated(engine.download(attachment, path, key));
-            if (renewed) {
-                // The old URL names the dead copy; without one, the engine builds it from the new path.
-                const { url: _dead, ...kept } = attachment.ref;
-                attachment.ref = { ...kept, ...renewed };
-                file.providerRef = attachment.ref;
-            }
-            yield* createReadStream(path);
-        }
-        finally {
-            await rm(folder, { recursive: true, force: true });
-        }
-    }
     const core = {
+        ...discoveryAdapter(engine, translated),
+        ...commentAdapter(engine, stored, translated),
+        ...sendAdapter({ engine, stored, held, keyOf, translated, resolve: (chat) => core.resolve(chat) }),
+        ...listenAdapter({ engine, stored, words, warn, translated }),
         formatMarkdown: async (text) => parseMarkdownSpans(text),
         self: () => engine.self(),
         newSendId: () => `3EB0${randomBytes(9).toString("hex").toUpperCase()}`,
@@ -370,99 +100,13 @@ warn = (line) => process.stderr.write(`${line}\n`)) => {
             const card = await translated(engine.chat(jid));
             return { ...toChat(card.chat), members: card.members?.map(toMember) ?? null };
         },
-        send: async (chatId, text, options) => {
-            const refused = REFUSED.filter((option) => options[option] !== undefined && options[option] !== false);
-            if (refused.length > 0)
-                throw new CliError("validation_error", `WhatsApp cannot send with ${refused.join(", ")}`);
-            const uploads = options.attachments ?? [];
-            const [upload] = uploads;
-            const files = uploads.map((one) => ({ upload: one, kind: uploadKind(one) }));
-            if (files.length > 1 && files.some(({ kind }) => kind !== "photo" && kind !== "video"))
-                throw new CliError("validation_error", "a WhatsApp album holds photos and videos only; send a document in a message of its own");
-            if (upload?.kind === "voice" && text.trim() !== "")
-                throw new CliError("validation_error", "WhatsApp sends a voice message alone, without text");
-            const { stickerFile } = options;
-            // Untried on a live channel, where a post carries a URL and no key.
-            if (stickerFile && isChannel(chatId))
-                throw new CliError("validation_error", "wa does not post stickers to a WhatsApp channel yet");
-            if (isChannel(chatId))
-                await refuseChannelPost(engine, translated, chatId, {
-                    files: files.length,
-                    reply: options.replyTo !== undefined,
-                });
-            // A reply to a message the store lacks still goes, with its id alone.
-            const answered = options.replyTo === undefined ? undefined : await stored.message(chatId, options.replyTo);
-            const request = {
-                chat: chatId,
-                text: options.formatting ? toWhatsApp(text, options.formatting) : text,
-                id: options.sendId,
-                ...(options.replyTo === undefined ? {} : { replyTo: options.replyTo }),
-                ...(answered
-                    ? { quoted: { fromMe: answered.outgoing === true, sender: answered.senderId, text: answered.text } }
-                    : {}),
-            };
-            const message = await translated(files.length > 1
-                ? allOnDisk(files, (placed) => engine.sendAlbum({
-                    ...request,
-                    files: placed.map(({ upload, kind, path }) => ({ kind, path, name: upload.name })),
-                }))
-                : upload
-                    ? onDisk(upload.source, (path) => engine.sendMedia({ ...request, file: { kind: uploadKind(upload), path, name: upload.name } }))
-                    : stickerFile
-                        ? onDisk(stickerFile.source, (path) => engine.sendMedia({ ...request, file: { kind: "sticker", path, name: stickerFile.name } }))
-                        : engine.send(request));
-            return { message: toMessage(message), sendId: options.sendId };
-        },
-        forward: async (fromChatId, messageId, toChatId, { sendId, threadId }) => {
-            if (threadId !== undefined)
-                throw new CliError("validation_error", "WhatsApp forwards without a topic");
-            const original = await held(fromChatId, messageId);
-            const attachments = original.attachments.map(toWaAttachment);
-            const [attachment] = attachments;
-            if (attachments.length > 1 || (attachments.length === 1 && !attachment?.ref))
-                throw new CliError("validation_error", "the local store does not hold this message's content whole, so it cannot be forwarded; forward it on the phone");
-            if (!attachment && original.text === "")
-                throw new CliError("validation_error", "that message has nothing to forward");
-            // A channel's files carry no key, and a chat's recipient cannot open a file without one.
-            if (isChannel(fromChatId) && attachment?.ref && "directPath" in attachment.ref)
-                throw new CliError("validation_error", "a WhatsApp channel's file is not encrypted, so a forward would arrive as a file that does not open; " +
-                    "save it on the phone and send it as a new file", { reason: "media.channel-file-forward" });
-            const copy = await translated(engine.forward({ chat: toChatId, id: sendId, text: original.text, attachment: attachment ?? null }));
-            return { ...toMessage(copy), forwardedFrom: quoted(original) };
-        },
-        // From the keys in the store: WhatsApp has no request for an old message. A file that is not one (a place, a
-        // contact card) or that the store has no keys for is named in `skipped`. The message's key goes along, so the
-        // engine can ask the phone for a file WhatsApp no longer keeps.
-        download: async (chat, messageId) => {
-            const { id: chatId } = await core.resolve(chat);
-            const message = await held(chatId, messageId);
-            const files = [];
-            const skipped = [];
-            message.attachments.forEach((stored, position) => {
-                const attachment = toWaAttachment(stored);
-                if (!isFile(attachment)) {
-                    skipped.push(stored.kind);
-                    return;
-                }
-                const file = {
-                    kind: attachment.kind,
-                    ...(attachment.name === undefined ? {} : { name: attachment.name }),
-                    ...(attachment.mime === undefined ? {} : { mime: attachment.mime }),
-                    ...(attachment.size === undefined ? {} : { size: attachment.size }),
-                    position,
-                    bytes: () => fetched(file, attachment, keyOf(chatId, message)),
-                };
-                files.push(file);
-            });
-            return { files, skipped };
-        },
         edit: async (chatId, messageId, text, { markup, formatting }) => {
             if (markup !== undefined)
                 throw new CliError("validation_error", "WhatsApp cannot edit with markup");
             const original = await held(chatId, messageId);
             if (!original.outgoing)
                 throw new CliError("validation_error", "only your own messages can be edited");
-            if (Date.now() - Date.parse(original.timestamp) > EDIT_WINDOW_MS)
+            if (now() - Date.parse(original.timestamp) > EDIT_WINDOW_MS)
                 throw new CliError("validation_error", "WhatsApp takes an edit only within 20 minutes of sending");
             const edited = await translated(engine.edit(keyOf(chatId, original), formatting ? toWhatsApp(text, formatting) : text));
             return { ...original, text: edited.text, editedAt: edited.editedAt };
@@ -524,37 +168,7 @@ warn = (line) => process.stderr.write(`${line}\n`)) => {
             const items = older.messages.map(toMessage).sort((one, other) => one.timestamp.localeCompare(other.timestamp));
             return { items, hasMore: older.more };
         },
-        logout: () => {
-            loggingOut = true;
-            return translated(engine.logout());
-        },
         close: () => engine.close(),
-        watch: async (onEvent, signal, onReady) => {
-            const live = handingOn(onEvent, signal);
-            try {
-                await translated(engine.ready(signal));
-                if (!signal.aborted)
-                    onReady?.();
-                await live.done;
-            }
-            finally {
-                await live.stop();
-            }
-        },
-        // What a one-shot connection receives: WhatsApp hands a queued message to a linked device once, so it is saved
-        // here or lost. Never connects; the command's own request does that.
-        listen: async (onEvent, signal) => {
-            const live = handingOn(onEvent, signal, ownLogout);
-            try {
-                await live.done;
-            }
-            finally {
-                await live.stop();
-            }
-        },
-        // The history a one-shot connection is pushed, which WhatsApp likewise sends once. Never connects.
-        listenHistory: (onBatch, signal) => pushing(onBatch, signal, ownLogout),
-        feed: (onBatch, signal) => pushing(onBatch, signal),
         // Only phone-form one-to-one chats can need a re-key, and in one request: cli-core waits at most 5 s for it.
         storedChats: async (ids, recipients = []) => {
             const phones = ids.filter((id) => PHONE_CHAT.test(id));
@@ -563,7 +177,7 @@ warn = (line) => process.stderr.write(`${line}\n`)) => {
                 await translated(engine.storedChats(phones, typed.length > 0 ? typed : undefined));
         },
     };
-    const polls = pollAdapter({ engine, stored, held, keyOf, translated });
+    const polls = pollAdapter({ engine, stored, held, keyOf, translated, now });
     const groups = groupAdapter({
         engine,
         resolve: core.resolve,