@wirecat/cli-core 0.349.0 → 0.350.0

package/CHANGELOG.md

@@ -7,6 +7,26 @@ shape of this file.
 
 ## Unreleased
 
+## 0.350.0 — 19.10.2026
+
+### Added
+
+- **A messenger that pushes its history can be told the chats the store holds**: the optional
+  `PushedHistory.storedChats(ids)` gets every chat id of this account once as `feed` starts, in `serve` and `watch`.
+  whatsapp-cli uses it to re-key phone-form chats nothing names again, through `rekeys`. A reject is a
+  `stored_chats_failed` warning. The contract kit has a case for it, skipped without the method, and
+  `fakeAdapter(seed, { storedChats: true })`.
+- **`loginQr().show(link, scan)` says where to scan only once a code exists**: after the drawn code, or after
+  the `--qr-file` note. On a terminal too narrow to draw the code, only the hint to widen it or pass `--qr-file`
+  is shown. Before, the CLIs said "scan this code" first, so a narrow terminal asked to scan a code that was
+  never drawn. `scan` is optional and nothing changes without it: an adapter drops its own scan note before
+  `show()` and passes that text as `show(link, scan)` instead.
+
+### Fixed
+
+- **A `storedChats` hook that never finishes no longer says messages were not saved** at exit: after the 5 s wait
+  it is a `stored_chats_failed` warning that the hook was abandoned, since it only reads chat ids.
+
 ## 0.349.0 — 19.10.2026
 
 ### Added

package/dist/cli/messenger/context.js

@@ -193,6 +193,7 @@ export const connected = (connection, { app, provider, name, deletedWithoutChat,
     const pacer = new Pacer(pacePathFor(app, settings.profile, env), rate);
     const adapter = observed(flooded(connection, memory, { name: name ?? app.command, warn: renderer.warn, pacer }), events);
     const pending = new Set();
+    const announcing = new Set();
     const saving = self === null
         ? adapter
         : stored(adapter, {
@@ -202,6 +203,7 @@ export const connected = (connection, { app, provider, name, deletedWithoutChat,
             warn: renderer.warn,
             events,
             pending,
+            announcing,
             ...(deletedWithoutChat ? { deletedWithoutChat } : {}),
             rekeyed: (from, to) => rekeyRecipients(app, settings.profile, env, renderer.warn, from, to),
             ...(history === "store" ? { namesFromStore: savedChatId ? { savedChatId } : {} } : {}),
@@ -226,10 +228,15 @@ export const connected = (connection, { app, provider, name, deletedWithoutChat,
                         events({ event: "warning", code: "store_not_written", operation });
                         renderer.warn(`not saved to the local store: the messenger was still handing on ${what} at exit`);
                     });
-                    if (!(await settled(pending, SAVES_WAIT_MS))) {
+                    await settled(new Set([...pending, ...announcing]), SAVES_WAIT_MS);
+                    if (pending.size > 0) {
                         events({ event: "warning", code: "store_not_written", operation: "close" });
                         renderer.warn("not saved to the local store: the last messages were still being written at exit");
                     }
+                    if (announcing.size > 0) {
+                        events({ event: "warning", code: "stored_chats_failed", operation: "close" });
+                        renderer.warn("the messenger's stored-chats hook did not finish and was abandoned at exit; nothing is lost");
+                    }
                 }
                 finally {
                     await store.close();

package/dist/cli/messenger/flooded.js

@@ -3,7 +3,7 @@ import { isCliFailure } from "../../errors/failures.js";
 import { throughWrapper } from "../../ports/messenger.js";
 import { providerErrorKey } from "../../runs/events.js";
 import { holdEnd } from "../../sends/flood.js";
-const LONG_LIVED = new Set(["self", "newSendId", "close", "formatMarkdown", "formatHtml"]);
+const LONG_LIVED = new Set(["self", "newSendId", "close", "formatMarkdown", "formatHtml", "storedChats"]);
 /** Neither held nor paced, as they listen for as long as the run does; what ends them is still remembered. */
 const LISTENING = new Set(["watch", "feed", "listen", "listenHistory"]);
 const BLOCKING = new Set(["frozen", "limited", "banned"]);

package/dist/cli/messenger/serve-relay.js

@@ -10,6 +10,7 @@ import { environmentOf } from "../context.js";
 export const lentConnection = (connection, watchers) => throughWrapper(connection, {
     close: async () => { },
     feed: undefined,
+    storedChats: undefined,
     listen: undefined,
     listenHistory: undefined,
     ...(connection.watch && watchers

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

@@ -11,6 +11,8 @@ export interface Saving {
     events: EventSink;
     /** Saves still writing, for the closer to wait on: `watch` does not hold the next event for one. */
     pending?: Set<Promise<void>>;
+    /** `storedChats` calls still running, apart from `pending`: one abandoned at exit leaves nothing unsaved. */
+    announcing?: Set<Promise<void>>;
     deletedWithoutChat?: DeletionScope;
     /** The app command and profile running, recorded with the first save so another app can name this account. */
     profile?: {
@@ -33,4 +35,4 @@ export interface Saving {
  * would erase what `chats list` stored. Nor are `chat` and `contact`: a card's member list is not
  * known to be whole, and `saveMembers` replaces the list.
  */
-export declare const stored: (messenger: MessengerAdapter, { account, store, warn, events, pending, deletedWithoutChat, profile, rekeyed, namesFromStore }: Saving) => MessengerAdapter;
+export declare const stored: (messenger: MessengerAdapter, { account, store, warn, events, pending, announcing, deletedWithoutChat, profile, rekeyed, namesFromStore }: Saving) => MessengerAdapter;

package/dist/cli/messenger/stored.js

@@ -11,7 +11,7 @@ import { chatIdIn } from "../../services/message-resolution.js";
  * would erase what `chats list` stored. Nor are `chat` and `contact`: a card's member list is not
  * known to be whole, and `saveMembers` replaces the list.
  */
-export const stored = (messenger, { account, store, warn, events, pending, deletedWithoutChat, profile, rekeyed, namesFromStore }) => {
+export const stored = (messenger, { account, store, warn, events, pending, announcing, deletedWithoutChat, profile, rekeyed, namesFromStore }) => {
     let warned = false;
     let recorded = profile === undefined;
     const attempt = async (operation, write) => {
@@ -243,7 +243,14 @@ export const stored = (messenger, { account, store, warn, events, pending, delet
             : {}),
         ...(messenger.feed
             ? {
-                feed: (onBatch, signal) => messenger.feed?.(saveBatches("history.feed", onBatch), signal) ?? Promise.resolve(),
+                feed: (onBatch, signal) => {
+                    if (messenger.storedChats) {
+                        const announced = announceStoredChats(messenger, store, account, events, warn);
+                        announcing?.add(announced);
+                        void announced.finally(() => announcing?.delete(announced));
+                    }
+                    return messenger.feed?.(saveBatches("history.feed", onBatch), signal) ?? Promise.resolve();
+                },
             }
             : {}),
         ...(messenger.listenHistory
@@ -348,6 +355,19 @@ const personIn = (people, reference) => {
         throw error;
     }
 };
+const announceStoredChats = async (messenger, store, account, events, warn) => {
+    try {
+        const opened = await store();
+        if (!opened)
+            return;
+        const ids = (await opened.forAccount(account).chats.chats({})).items.map((chat) => chat.id);
+        await messenger.storedChats?.(ids);
+    }
+    catch (error) {
+        events({ event: "warning", code: "stored_chats_failed", operation: "history.stored_chats" });
+        warn(`the messenger was not told the stored chats: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
 /** Read once when `watch` starts: a store read per event would let a later event overtake an earlier one. */
 const rememberTitles = async (store, account, titles) => {
     try {

package/dist/kit/contract.d.ts

@@ -22,7 +22,7 @@ export interface ContractOptions {
     history?: "server" | "store";
 }
 /** Every method of the optional groups, which `capability` hands over or refuses. */
-export declare const OPTIONAL_METHODS: readonly ["fetchCounters", "chats", "history", "around", "contact", "historyAfter", "historyBefore", "topics", "inspect", "edit", "forward", "delete", "pin", "unpin", "star", "react", "markRead", "markTopicRead", "poll", "vote", "closePoll", "createPoll", "watch", "listen", "listenHistory", "feed", "download", "transcribe", "scheduled", "members", "admins", "chatEvents", "sessions", "lookup", "addressBook", "people", "createGroup", "join", "leave", "group", "updateGroup", "resetInviteLink", "addMembers", "removeMembers", "addAdmin", "removeAdmin", "folders", "createFolder", "updateFolder", "deleteFolder", "addContact", "removeContact", "block", "unblock", "renameContact", "importContacts", "updateProfile", "endOtherSessions"];
+export declare const OPTIONAL_METHODS: readonly ["fetchCounters", "chats", "history", "around", "contact", "historyAfter", "historyBefore", "topics", "inspect", "edit", "forward", "delete", "pin", "unpin", "star", "react", "markRead", "markTopicRead", "poll", "vote", "closePoll", "createPoll", "watch", "listen", "listenHistory", "feed", "storedChats", "download", "transcribe", "scheduled", "members", "admins", "chatEvents", "sessions", "lookup", "addressBook", "people", "createGroup", "join", "leave", "group", "updateGroup", "resetInviteLink", "addMembers", "removeMembers", "addAdmin", "removeAdmin", "folders", "createFolder", "updateFolder", "deleteFolder", "addContact", "removeContact", "block", "unblock", "renameContact", "importContacts", "updateProfile", "endOtherSessions"];
 /**
  * The port's promises as cases any test runner can run: each connects through `connect`, checks
  * with `node:assert/strict` and closes the adapter. None needs a live service.

package/dist/kit/contract.js

@@ -31,6 +31,7 @@ export const OPTIONAL_METHODS = [
     "listen",
     "listenHistory",
     "feed",
+    "storedChats",
     "download",
     "transcribe",
     "scheduled",
@@ -486,6 +487,17 @@ export const contractCases = ({ connect, ids = wordIds, orderBy = "id", waitMs =
                 },
                 "the fake pushes the seed's history once connected, as `fakeAdapter(seed, { feed: true })` does",
             ],
+            [
+                "storedChats takes no ids, and ids it does not know, without rejecting",
+                async (adapter, seed) => {
+                    const skipped = lacking(adapter, "storedChats");
+                    if (skipped)
+                        return skipped;
+                    await within(Promise.resolve(adapter.storedChats?.([])), "storedChats did not resolve for no ids", waitMs);
+                    const ids = [...seed.chats.map((chat) => chat.id), unknownChat];
+                    await within(Promise.resolve(adapter.storedChats?.(ids)), "storedChats did not resolve for the ids", waitMs);
+                },
+            ],
         ]),
         {
             name: "self() is null before a login",

package/dist/kit/fake.d.ts

@@ -6,4 +6,5 @@ export declare const fakeAdapter: (seed?: Seed, options?: {
     feed?: boolean;
     listen?: boolean;
     listenHistory?: boolean;
+    storedChats?: boolean;
 }) => FakeAdapter;

package/dist/kit/fake.js

@@ -29,7 +29,8 @@ const missing = (what) => new CliError("not_found", `the fake adapter has no ${w
  * With `{ feed: true }` it also pushes its history, as a messenger with `history: "store"` does:
  * the chats and people in one batch, then each chat's messages in a batch of their own.
  * With `{ listen: true }` it also has `listen`, which hands on what `watch` does, and with `{ listenHistory: true }`
- * `listenHistory`, which hands on what `feed` does.
+ * `listenHistory`, which hands on what `feed` does. With `{ storedChats: true }` it takes the stored chat ids and
+ * does nothing with them.
  */
 const withRules = (folder, { emoji, include, skip, exclude, pin }) => {
     if (emoji !== undefined)
@@ -337,6 +338,7 @@ export const fakeAdapter = (seed = contractSeed(), options = {}) => {
             : {}),
         ...(options.feed ? { feed: pushHistory } : {}),
         ...(options.listenHistory ? { listenHistory: pushHistory } : {}),
+        ...(options.storedChats ? { storedChats: async () => { } } : {}),
         download: async (reference, messageId) => {
             const message = messageOf(chatOf(reference).id, messageId);
             return {

package/dist/ports/messenger.d.ts

@@ -365,6 +365,11 @@ export interface HistoryBatch {
 export interface PushedHistory {
     /** Chats, people and past messages as the messenger pushes them, until `signal` aborts. */
     feed(onBatch: (batch: HistoryBatch) => void, signal: AbortSignal): Promise<void>;
+    /**
+     * Every chat id the store holds for this account, handed over once as `feed` starts, so a chat nothing names again
+     * can still be re-keyed through a later batch's `rekeys`. A reject is a warning; `feed` goes on.
+     */
+    storedChats?(ids: readonly Id[]): void | Promise<void>;
 }
 /** A message's files and its speech, fetched from the messenger. */
 export interface MessageMedia {

package/dist/terminal/login-qr.d.ts

@@ -19,8 +19,11 @@ export interface LoginQrOptions {
 }
 export interface LoginQr {
     readonly path: string | undefined;
-    /** Never throws for a code that does not fit: the messengers call it from inside their own event loops. */
-    show: (link: string) => void;
+    /**
+     * `scan` says where to scan; it follows the code, and is not said when the terminal is too narrow to draw one.
+     * Never throws for a code that does not fit: the messengers call it from inside their own event loops.
+     */
+    show: (link: string, scan?: string) => void;
     /** The image logs the account in while it is valid; call this in `finally`. */
     close: () => void;
 }

package/dist/terminal/login-qr.js

@@ -17,11 +17,13 @@ export const loginQr = ({ qrFile, diagnostic, note, indent: pad = 0, columns = (
     let written = false;
     return {
         path,
-        show: (link) => {
+        show: (link, scan) => {
             if (path) {
                 writeSecurely(path, qrPng(link), 0o600);
                 written = true;
                 note(`the QR code is in ${path} — it is replaced when the code renews`);
+                if (scan)
+                    note(scan);
                 return;
             }
             const drawn = terminalQr(link);
@@ -33,6 +35,8 @@ export const loginQr = ({ qrFile, diagnostic, note, indent: pad = 0, columns = (
                 return;
             }
             diagnostic(`\n${indent(drawn.text, pad + MARGIN)}`);
+            if (scan)
+                note(scan);
         },
         close: () => {
             if (!path || !written)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.349.0",
+  "version": "0.350.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",