@wirecat/whatsapp-cli 0.1.0 → 0.2.0

package/dist/adapter/adapter.js

@@ -4,14 +4,17 @@ 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 { parseMarkdownSpans, } from "@wirecat/cli-core";
+import { bareCheck, parseMarkdownSpans, } from "@wirecat/cli-core";
 import { EngineError, OLDER_MAX, } from "../engine/contract.js";
-import { bareCheck } from "./checks.js";
+import { channelAdapter, channelHistory, channelWrites, isChannel, refuseChannelPost } from "./channels.js";
 import { fromEngine } from "./errors.js";
 import { toWhatsApp } from "./format-markdown.js";
 import { groupAdapter } from "./groups.js";
-import { toChat, toMember, toMessage, toWaAttachment } from "./map.js";
+import { isFile, sameFile, toAccount, toChat, toChatEvent, toChatUpdate, toMember, toMessage, toWaAttachment, } from "./map.js";
+import { pinAdapter } from "./pins.js";
 import { pollAdapter, toHistoryVote, toVoteEvent } from "./polls.js";
+import { privacyAdapter } from "./privacy.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.
 const NOTHING_STORED = {
@@ -35,24 +38,56 @@ const translated = async (work) => {
         throw error;
     }
 };
-const hit = (chat, message) => ({ ...message, chatTitle: chat?.name ?? null });
+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: () => fromEngine(new EngineError("permission_error", "WhatsApp has banned or restricted this account; see the phone", "account.banned")),
+    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")),
 };
-/** Hands each event on until `signal` aborts; a connection WhatsApp ended rejects with why. */
-const listening = (engine, kinds, signal, words, onEvent) => {
+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) => {
-            const ended = event.event === "connection" ? ENDED[event.state]?.(words) : undefined;
+            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
-                onEvent(event);
+                run(event.event, () => handle(event));
         });
         const aborted = () => resolve();
         signal.addEventListener("abort", aborted, { once: true });
@@ -63,8 +98,17 @@ const listening = (engine, kinds, signal, words, onEvent) => {
         if (signal.aborted)
             resolve();
     });
-    return { done, stop };
+    // 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";
@@ -87,6 +131,12 @@ const onDisk = async (source, work) => {
         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,
@@ -102,7 +152,9 @@ const keyOf = (chatId, message) => ({
     fromMe: message.outgoing === true,
     sender: message.senderId,
 });
-export const whatsAppAdapter = (engine, stored = NOTHING_STORED, words = bareCheck) => {
+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`)) => {
     // 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);
@@ -110,41 +162,173 @@ export const whatsAppAdapter = (engine, stored = NOTHING_STORED, words = bareChe
             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;
     };
-    async function* fetched(attachment) {
+    // 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 === "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", "star", "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, 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) ?? []),
+                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");
-            await translated(engine.download(attachment, path));
+            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 titled = async () => new Map((await translated(engine.directory())).map((chat) => [chat.jid, chat]));
     const core = {
         formatMarkdown: async (text) => parseMarkdownSpans(text),
         self: () => engine.self(),
         newSendId: () => `3EB0${randomBytes(9).toString("hex").toUpperCase()}`,
-        me: async () => {
-            const account = await translated(engine.me());
-            return { id: account.jid, name: account.name, username: null };
-        },
+        me: async () => toAccount(await translated(engine.me())),
+        // A send to a phone-form chat lands under the LID the engine answers, so every later command must address that
+        // chat too, or a delete, a star or a vote by the typed number misses the stored message (§5).
         resolve: async (query) => {
-            const chats = await titled();
-            const byId = chats.get(query);
-            if (byId)
-                return toChat(byId);
             if (query.includes("@"))
                 return {
-                    id: query,
+                    id: PHONE_CHAT.test(query) ? await translated(engine.canonicalChat(query)) : query,
                     title: null,
                     kind: "unknown",
                     unreadCount: null,
                     lastMessageAt: null,
                     participantsCount: null,
                 };
-            const named = [...chats.values()].filter((chat) => chat.name === query);
+            const named = (await translated(engine.directory())).filter((chat) => chat.name === query);
             if (named.length === 1 && named[0])
                 return toChat(named[0]);
             if (named.length > 1)
@@ -159,11 +343,22 @@ export const whatsAppAdapter = (engine, stored = NOTHING_STORED, words = bareChe
             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 [upload, ...more] = options.attachments ?? [];
-            if (more.length > 0)
-                throw new CliError("validation_error", "WhatsApp sends one file per message here");
+            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 = {
@@ -175,9 +370,16 @@ export const whatsAppAdapter = (engine, stored = NOTHING_STORED, words = bareChe
                     ? { quoted: { fromMe: answered.outgoing === true, sender: answered.senderId, text: answered.text } }
                     : {}),
             };
-            const message = await translated(upload
-                ? onDisk(upload.source, (path) => engine.sendMedia({ ...request, file: { kind: uploadKind(upload), path, name: upload.name } }))
-                : engine.send(request));
+            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 }) => {
@@ -190,11 +392,16 @@ export const whatsAppAdapter = (engine, stored = NOTHING_STORED, words = bareChe
                 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`.
+        // 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);
@@ -202,18 +409,19 @@ export const whatsAppAdapter = (engine, stored = NOTHING_STORED, words = bareChe
             const skipped = [];
             message.attachments.forEach((stored, position) => {
                 const attachment = toWaAttachment(stored);
-                if (!attachment?.ref) {
+                if (!isFile(attachment)) {
                     skipped.push(stored.kind);
                     return;
                 }
-                files.push({
+                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(attachment),
-                });
+                    bytes: () => fetched(file, attachment, keyOf(chatId, message)),
+                };
+                files.push(file);
             });
             return { files, skipped };
         },
@@ -229,20 +437,44 @@ export const whatsAppAdapter = (engine, stored = NOTHING_STORED, words = bareChe
             return { ...original, text: edited.text, editedAt: edited.editedAt };
         },
         delete: async (chatId, messageIds, { forEveryone }) => {
-            if (!forEveryone)
-                throw new CliError("validation_error", "wa deletes only for everyone so far; add --for-everyone, or delete it for you on the phone");
             const messages = await Promise.all(messageIds.map((id) => held(chatId, id)));
-            for (const message of messages)
-                await translated(engine.revoke(keyOf(chatId, message)));
+            const done = [];
+            for (const message of messages) {
+                try {
+                    if (forEveryone)
+                        await translated(engine.revoke(keyOf(chatId, message)));
+                    else
+                        await synced(engine.deleteForMe({ ...keyOf(chatId, message), timestamp: message.timestamp }));
+                }
+                catch (error) {
+                    if (done.length === 0 || !(error instanceof CliError))
+                        throw error;
+                    // One request per message: the ones before this went, so the run as a whole is not unsent (WC-OUT-20).
+                    const { sent: _, ...details } = error.details;
+                    throw new CliError(error.code, `deleted ${done.join(", ")}; ${message.id} and any after it were not, or may not have been: ${error.message}`, details);
+                }
+                done.push(message.id);
+            }
         },
         react: async (chatId, messageId, emoji) => {
             const message = await held(chatId, messageId);
             await translated(engine.react(keyOf(chatId, message), emoji));
         },
-        // One receipt, for the newest message from someone else up to `until`: the account's own messages have none.
+        star: async (chatId, messageId, starred) => {
+            const message = await held(chatId, messageId);
+            await synced(engine.star(keyOf(chatId, message), starred));
+        },
+        // The read patch takes a mark-unread off the owner's devices, which a receipt does not; it is bounded by `until`
+        // or the newest stored message, either side's, so it names nothing newer than the receipt covers. It goes first,
+        // so a refusal for missing settings keys leaves nothing sent. Then one receipt, for the newest message from
+        // someone else up to `until`: the account's own messages have none. A chat the store holds nothing of has neither.
         markRead: async (chatId, until) => {
-            const anchor = until === undefined ? undefined : await held(chatId, until);
-            const target = anchor && !anchor.outgoing ? anchor : await stored.newestIncoming(chatId, until);
+            const anchor = until === undefined ? await stored.anchor(chatId, AFTER_EVERY_MESSAGE) : await held(chatId, until);
+            if (!anchor)
+                return;
+            if (!isChannel(chatId) && !chatId.endsWith("@broadcast"))
+                await synced(engine.markChatRead({ ...keyOf(chatId, anchor), timestamp: anchor.timestamp }));
+            const target = until !== undefined && !anchor.outgoing ? anchor : await stored.newestIncoming(chatId, until);
             if (target)
                 await translated(engine.markRead(keyOf(chatId, target)));
         },
@@ -251,6 +483,8 @@ export const whatsAppAdapter = (engine, stored = NOTHING_STORED, words = bareChe
         // page reached (`before` is a time, `fetching.orderBy: "time"`).
         history: async (chat, { limit, before }) => {
             const { id: chatId } = await core.resolve(chat);
+            if (isChannel(chatId))
+                return translated(channelHistory(engine, stored, chatId, { limit, ...(before === undefined ? {} : { before }) }));
             const anchor = await stored.anchor(chatId, before);
             if (!anchor)
                 throw new CliError("not_found", "nothing of this chat is in the local store to count back from — the phone sends messages older than one " +
@@ -259,33 +493,13 @@ export const whatsAppAdapter = (engine, stored = NOTHING_STORED, words = bareChe
             const items = older.messages.map(toMessage).sort((one, other) => one.timestamp.localeCompare(other.timestamp));
             return { items, hasMore: older.more };
         },
-        logout: () => translated(engine.logout()),
+        logout: () => {
+            loggingOut = true;
+            return translated(engine.logout());
+        },
         close: () => engine.close(),
         watch: async (onEvent, signal, onReady) => {
-            const chats = await titled();
-            const handed = async (event) => {
-                if (event.event === "message")
-                    onEvent({ event: "message", message: hit(chats.get(event.message.chat), toMessage(event.message)) });
-                else if (event.event === "edit")
-                    onEvent({ event: "edit", message: hit(chats.get(event.message.chat), toMessage(event.message)) });
-                else if (event.event === "delete")
-                    onEvent({
-                        event: "delete",
-                        chatId: event.chat,
-                        chatTitle: chats.get(event.chat)?.name ?? null,
-                        messageId: event.id,
-                    });
-                else if (event.event === "vote") {
-                    const vote = await toVoteEvent(event.vote, chats.get(event.vote.chat)?.name ?? null, stored);
-                    if (vote)
-                        onEvent(vote);
-                }
-            };
-            // In arrival order: a vote reads its poll from the store, and nothing after it may overtake it.
-            let queue = Promise.resolve();
-            const live = listening(engine, ["message", "edit", "delete", "vote", "connection"], signal, words, (event) => {
-                queue = queue.then(() => handed(event));
-            });
+            const live = handingOn(onEvent, signal);
             try {
                 await translated(engine.ready(signal));
                 if (!signal.aborted)
@@ -293,34 +507,48 @@ export const whatsAppAdapter = (engine, stored = NOTHING_STORED, words = bareChe
                 await live.done;
             }
             finally {
-                live.stop();
-                await queue;
+                await live.stop();
             }
         },
-        feed: async (onBatch, signal) => {
-            const pushes = listening(engine, ["history", "connection"], signal, words, (event) => {
-                if (event.event !== "history")
-                    return;
-                const { chats, contacts, messages, votes } = event.history;
-                onBatch({
-                    chats: chats.map(toChat),
-                    people: contacts.map(toMember),
-                    messages: messages.map(toMessage),
-                    votes: votes.flatMap((vote) => toHistoryVote(vote) ?? []),
-                });
-            });
+        // 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 pushes.done;
+                await live.done;
             }
             finally {
-                pushes.stop();
+                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));
+            const typed = recipients.filter((id) => PHONE_CHAT.test(id));
+            if (phones.length > 0 || typed.length > 0)
+                await translated(engine.storedChats(phones, typed.length > 0 ? typed : undefined));
+        },
     };
+    const polls = pollAdapter({ engine, stored, held, keyOf, translated });
+    const groups = groupAdapter({
+        engine,
+        resolve: core.resolve,
+        translated,
+        wroteTo: (person) => stored.wroteTo(person),
+        onDisk,
+    });
     return {
         ...core,
-        ...groupAdapter({ engine, resolve: core.resolve, translated, wroteTo: (person) => stored.wroteTo(person) }),
-        ...pollAdapter({ engine, stored, held, keyOf, translated }),
+        ...groups,
+        ...channelAdapter({ engine, resolve: core.resolve, translated, groups }),
+        ...polls,
+        ...channelWrites({ ...core, ...polls }),
+        ...privacyAdapter({ engine, translated }),
+        ...pinAdapter({ engine, held, keyOf, translated }),
+        ...settingsAdapter({ engine, translated, words, stored, keyOf, onDisk }),
     };
 };
 //# sourceMappingURL=adapter.js.map