wldx-cli 1.0.0 → 1.1.0

package/README.md

@@ -1,6 +1,6 @@
 # wldx-cli — `wx`, a command line for Wildix
 
-**Version 1.0.0** · unofficial · MIT
+**Version 1.1.0** · unofficial · MIT
 
 `wx` works with Wildix as **the logged-in user**: chats, calls and meetings on record, queue reports, what is going
 on now, and your phone. It is the command-line twin of the
@@ -15,7 +15,8 @@ wx chat list
 npx wldx-cli chat list     # without installing
 ```
 
-Requires Node.js 22 or newer. No dependencies.
+Requires Node.js 22 or newer. One dependency: [`wldx-core`](https://github.com/gorets/wildix-cli/tree/main/packages/core), the core it shares with `wx-admin`, from the
+same repository and of the same version.
 
 Unofficial: not made or supported by Wildix. It uses the same internal APIs as the Wildix apps, which may change.
 
@@ -317,27 +318,21 @@ another login · `3` nothing to show (no transcript yet) · `64` wrong usage.
 
 ## Development
 
+`wx` lives in the pnpm workspace of [gorets/wildix-cli](https://github.com/gorets/wildix-cli) next to `wx-admin` and
+their shared core (`packages/core`): see the [README](https://github.com/gorets/wildix-cli) and [AGENTS.md](https://github.com/gorets/wildix-cli/blob/main/AGENTS.md) there.
+
 ```sh
-npm test         # node:test, no network
-npm run check    # tests + the list of files that would be published
-npm link         # puts `wx` on your PATH from this folder
+pnpm install                       # at the root of the repository
+pnpm --filter wldx-cli test        # node:test, no network
+node packages/wx/bin/wx.mjs status # this checkout, without installing
 ```
 
-Layout: `bin/wx.mjs` (entry) → `src/cli.mjs` (router) → `src/commands/<group>.mjs`, with helpers per domain in
-`src/chat`, `src/history`, `src/live`, `src/phone`. Shared: `src/auth.mjs` (login, sessions, renewal),
-`src/services.mjs` (addresses), `src/http.mjs` (requests, safe paths), `src/format.mjs` (text output). See
-[AGENTS.md](AGENTS.md) for the rules. `node test/dev.mjs <module> <args>` runs a command module that is not listed
-yet; after changing commands, regenerate the reference: `node tools/readme-commands.mjs`.
+Layout: `bin/wx.mjs` (entry) → `src/cli.mjs` (the spec on the router of the core) → `src/commands/<group>.mjs`,
+with helpers per domain in `src/chat`, `src/history`, `src/live`, `src/phone`. Login, sessions, addresses, requests
+and text output come from `wldx-core`. See [AGENTS.md](https://github.com/gorets/wildix-cli/blob/main/packages/wx/AGENTS.md). `node test/dev.mjs <module> <args>` runs a command
+module that is not listed yet; after changing commands, regenerate the reference: `node tools/readme-commands.mjs`.
 
 ## Releasing
 
-1. Bump `version` in `package.json`, add a `CHANGELOG.md` entry, update the version at the top of this file.
-2. Commit, tag `vX.Y.Z`, push the tag: `.github/workflows/release.yml` checks the tag against `package.json`, runs
-   the tests and **stages** the version with provenance through npm trusted publishing (no npm token in the
-   repository).
-3. Approve it with 2FA, which makes it public: `npm stage list wldx-cli`, then `npm stage approve <stage-id>`
-   (`npm stage download <stage-id>` to look at the tarball first).
-
-The trusted publisher on npmjs.com (package settings → Trusted publishing): GitHub Actions, `gorets/wildix-cli`,
-workflow `release.yml`, permission "npm stage publish". Version 0.1.0 was published by hand, because a trusted
-publisher can be configured only for a package that exists.
+Together with `wx-admin` and the core, one version for the three: see Releasing in the
+[README of the repository](https://github.com/gorets/wildix-cli#releasing).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wldx-cli",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Unofficial command line for Wildix (x-bees chats and more), acting as the logged-in user",
   "keywords": [
     "wildix",
@@ -12,9 +12,10 @@
   "author": "Vladimir Gorobets",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/gorets/wildix-cli.git"
+    "url": "git+https://github.com/gorets/wildix-cli.git",
+    "directory": "packages/wx"
   },
-  "homepage": "https://github.com/gorets/wildix-cli#readme",
+  "homepage": "https://github.com/gorets/wildix-cli/tree/main/packages/wx#readme",
   "bugs": "https://github.com/gorets/wildix-cli/issues",
   "type": "module",
   "bin": {
@@ -27,8 +28,10 @@
   "engines": {
     "node": ">=22"
   },
+  "dependencies": {
+    "wldx-core": "1.1.0"
+  },
   "scripts": {
-    "test": "node --test test/*.test.mjs",
-    "check": "npm test && npm pack --dry-run"
+    "test": "node --test test/*.test.mjs"
   }
-}
+}

package/src/chat/format.mjs

@@ -1,10 +1,12 @@
 // Text output of the chat commands: one line per channel, message, member or person, local times, names of
 // people instead of their ids (looked up by the command, see withNames in lib.mjs).
-import {localTime, oneLine, paint, table} from '../format.mjs';
+import {localTime, oneLine, paint, table} from 'wldx-core/format';
 import {displayName, nameIn} from './lib.mjs';
 
 const reactions = (counts) => {
-  const parts = Object.entries(counts ?? {}).filter(([, n]) => n > 0).map(([t, n]) => `${t} ${n}`);
+  const parts = Object.entries(counts ?? {})
+    .filter(([, n]) => n > 0)
+    .map(([t, n]) => `${t} ${n}`);
   return parts.length ? `[${parts.join(', ')}]` : '';
 };
 
@@ -31,11 +33,20 @@ export function messageText(m, data, {max = 2000} = {}) {
 export function messageLines(messages, data, ctx) {
   const c = paint(ctx);
   const sorted = [...(messages ?? [])].sort((a, b) => (a.timelineSeq ?? 0) - (b.timelineSeq ?? 0));
-  return table(sorted.map((m) => [c.dim(localTime(m.createdAt)), c.bold(nameIn(data, m.userId) || '?'), `${messageText(m, data)}  ${c.dim(m.messageId)}`]));
+  return table(
+    sorted.map((m) => [
+      c.dim(localTime(m.createdAt)),
+      c.bold(nameIn(data, m.userId) || '?'),
+      `${messageText(m, data)}  ${c.dim(m.messageId)}`,
+    ]),
+  );
 }
 
 // The title of a channel: its subject, or for a 1:1 channel the name of the other person.
-export const channelTitle = (ch, data) => ch?.subject || (ch?.peerId ? nameIn(data, ch.peerId) : '') || (ch?.channelType === 'direct' ? '(direct)' : '(no subject)');
+export const channelTitle = (ch, data) =>
+  ch?.subject ||
+  (ch?.peerId ? nameIn(data, ch.peerId) : '') ||
+  (ch?.channelType === 'direct' ? '(direct)' : '(no subject)');
 
 // The people a channel line names: the other person of a 1:1 channel, the author of the last message.
 export const channelUserIds = (ch) => [ch?.peerId, ch?.lastMessage?.userId];
@@ -62,7 +73,15 @@ const preview = (ch, data) => {
 // Channels: last activity, id, inbox flags, title, the last message.
 export function channelLines(channels, data, ctx) {
   const c = paint(ctx);
-  return table((channels ?? []).map((ch) => [c.dim(localTime(ch.lastActivityAt)), ch.channelId, flags(ch, c), c.bold(oneLine(channelTitle(ch, data), 50)), c.dim(preview(ch, data))]));
+  return table(
+    (channels ?? []).map((ch) => [
+      c.dim(localTime(ch.lastActivityAt)),
+      ch.channelId,
+      flags(ch, c),
+      c.bold(oneLine(channelTitle(ch, data), 50)),
+      c.dim(preview(ch, data)),
+    ]),
+  );
 }
 
 export function channelDetails(ch, data, ctx) {
@@ -71,7 +90,10 @@ export function channelDetails(ch, data, ctx) {
   const rows = [
     ['Channel', ch.channelId],
     ['Title', c.bold(channelTitle(ch, data))],
-    ['Type', [ch.channelType, ch.access, ch.broadcast && 'broadcast', ch.external && 'external'].filter(Boolean).join(' · ')],
+    [
+      'Type',
+      [ch.channelType, ch.access, ch.broadcast && 'broadcast', ch.external && 'external'].filter(Boolean).join(' · '),
+    ],
   ];
   if (ch.description) rows.push(['Description', oneLine(ch.description, 300)]);
   if (ch.peerId) rows.push(['With', `${nameIn(data, ch.peerId)} (${ch.peerId})`]);
@@ -80,7 +102,10 @@ export function channelDetails(ch, data, ctx) {
   rows.push(['Last activity', localTime(ch.lastActivityAt)]);
   if (ch.pinnedMessageIds?.length) rows.push(['Pinned', ch.pinnedMessageIds.join(', ')]);
   if (ch.autoRecord !== undefined || ch.autoTranscribe !== undefined) {
-    rows.push(['Conferences', [ch.autoRecord && 'auto record', ch.autoTranscribe && 'auto transcribe'].filter(Boolean).join(', ') || 'manual']);
+    rows.push([
+      'Conferences',
+      [ch.autoRecord && 'auto record', ch.autoTranscribe && 'auto transcribe'].filter(Boolean).join(', ') || 'manual',
+    ]);
   }
   if (ch.inbox) rows.push(['Inbox', flags(ch, c) || 'read']);
   return table(rows);
@@ -88,7 +113,14 @@ export function channelDetails(ch, data, ctx) {
 
 // A person on one line: name, id, e-mail, extension, bot.
 export function userLine(u, c) {
-  return [c.bold(displayName(u) ?? ''), u.id, u.email ?? '', u.pbxExtension ? `ext ${u.pbxExtension}` : '', u.bot ? 'bot' : '', u.deactivatedAt ? c.dim('deactivated') : ''];
+  return [
+    c.bold(displayName(u) ?? ''),
+    u.id,
+    u.email ?? '',
+    u.pbxExtension ? `ext ${u.pbxExtension}` : '',
+    u.bot ? 'bot' : '',
+    u.deactivatedAt ? c.dim('deactivated') : '',
+  ];
 }
 
 export const nextPage = (cursor, c) => (cursor ? [c.dim(`More: --cursor ${cursor}`)] : []);

package/src/chat/lib.mjs

@@ -4,10 +4,10 @@
 import {randomUUID} from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import {jwtClaims} from '../auth.mjs';
-import {UsageError} from '../errors.mjs';
-import {readForUpload, refuseUnsafeWrite} from '../files.mjs';
-import {apiPath, request} from '../http.mjs';
+import {jwtClaims} from 'wldx-core/auth';
+import {UsageError} from 'wldx-core/errors';
+import {readForUpload, refuseUnsafeWrite} from 'wldx-core/files';
+import {apiPath, request} from 'wldx-core/http';
 import {streamClient} from '../stream.mjs';
 
 // The operations the service answers with HTTP 400 "Operation <Name> is not implemented." (checked 2026-11-05).
@@ -20,19 +20,22 @@ export const notImplemented = (operation) =>
 export function checkInt(name, value, min, max) {
   if (value === undefined) return undefined;
   const s = String(value);
-  if (!/^\d{1,12}$/.test(s) || Number(s) < min || Number(s) > max) throw new UsageError(`--${name} must be a whole number from ${min} to ${max}: ${value}`);
+  if (!/^\d{1,12}$/.test(s) || Number(s) < min || Number(s) > max)
+    throw new UsageError(`--${name} must be a whole number from ${min} to ${max}: ${value}`);
   return Number(s);
 }
 
 // An id that goes into a request path or a body: id characters only, never "/", "?", "#", ".." or nothing.
 export function checkId(what, value) {
   const v = String(value ?? '');
-  if (!/^[A-Za-z0-9_+][A-Za-z0-9_.:+-]*$/.test(v) || v.includes('..')) throw new UsageError(`${what} is not a valid id: ${value}`);
+  if (!/^[A-Za-z0-9_+][A-Za-z0-9_.:+-]*$/.test(v) || v.includes('..'))
+    throw new UsageError(`${what} is not a valid id: ${value}`);
   return v;
 }
 
 export function checkReaction(type) {
-  if (!/^[a-z0-9_+-]{1,64}$/.test(String(type))) throw new UsageError(`A reaction type must match [a-z0-9_+-] (up to 64): ${type}`);
+  if (!/^[a-z0-9_+-]{1,64}$/.test(String(type)))
+    throw new UsageError(`A reaction type must match [a-z0-9_+-] (up to 64): ${type}`);
   return type;
 }
 
@@ -90,7 +93,7 @@ export async function withNames(ctx, data, ids, client = api(ctx)) {
   Object.defineProperty(data, NAMES, {value: users, enumerable: false});
   return data;
 }
-export const nameIn = (data, id) => (id ? displayName(data?.[NAMES]?.get(id)) ?? id : '');
+export const nameIn = (data, id) => (id ? (displayName(data?.[NAMES]?.get(id)) ?? id) : '');
 
 // The ids of people a message names: its author, the author of its quote.
 export const messageUserIds = (m) => [m?.userId, m?.quote?.userId, m?.pinnedBy];
@@ -98,16 +101,42 @@ export const messageUserIds = (m) => [m?.userId, m?.quote?.userId, m?.pinnedBy];
 // ── files ───────────────────────────────────────────────────────────────────────────────────────────────────
 
 // The checks of files to attach and to save: src/files.mjs.
-export {refuseSecretPath} from '../files.mjs';
+export {refuseSecretPath} from 'wldx-core/files';
 
 const MIME = {
-  txt: 'text/plain', md: 'text/markdown', csv: 'text/csv', html: 'text/html', htm: 'text/html', css: 'text/css', js: 'text/javascript',
-  json: 'application/json', xml: 'application/xml', pdf: 'application/pdf', zip: 'application/zip', gz: 'application/gzip',
-  tar: 'application/x-tar', doc: 'application/msword', docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-  xls: 'application/vnd.ms-excel', xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-  ppt: 'application/vnd.ms-powerpoint', pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-  png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif', webp: 'image/webp', svg: 'image/svg+xml', heic: 'image/heic',
-  mp3: 'audio/mpeg', wav: 'audio/wav', ogg: 'audio/ogg', m4a: 'audio/mp4', mp4: 'video/mp4', mov: 'video/quicktime', webm: 'video/webm',
+  txt: 'text/plain',
+  md: 'text/markdown',
+  csv: 'text/csv',
+  html: 'text/html',
+  htm: 'text/html',
+  css: 'text/css',
+  js: 'text/javascript',
+  json: 'application/json',
+  xml: 'application/xml',
+  pdf: 'application/pdf',
+  zip: 'application/zip',
+  gz: 'application/gzip',
+  tar: 'application/x-tar',
+  doc: 'application/msword',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  xls: 'application/vnd.ms-excel',
+  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  ppt: 'application/vnd.ms-powerpoint',
+  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  png: 'image/png',
+  jpg: 'image/jpeg',
+  jpeg: 'image/jpeg',
+  gif: 'image/gif',
+  webp: 'image/webp',
+  svg: 'image/svg+xml',
+  heic: 'image/heic',
+  mp3: 'audio/mpeg',
+  wav: 'audio/wav',
+  ogg: 'audio/ogg',
+  m4a: 'audio/mp4',
+  mp4: 'video/mp4',
+  mov: 'video/quicktime',
+  webm: 'video/webm',
 };
 export const mimeOf = (file) => MIME[path.extname(file).slice(1).toLowerCase()] ?? 'application/octet-stream';
 
@@ -119,12 +148,14 @@ function presigned(url, env) {
   } catch {
     throw new Error('The service gave no valid storage link');
   }
-  if (u.protocol !== 'https:' && !(env.WILDIX_ALLOW_CUSTOM_URL === '1' && u.protocol === 'http:')) throw new Error(`The storage link is not https: ${u.protocol}`);
+  if (u.protocol !== 'https:' && !(env.WILDIX_ALLOW_CUSTOM_URL === '1' && u.protocol === 'http:'))
+    throw new Error(`The storage link is not https: ${u.protocol}`);
   return u.href;
 }
 
 const ATTACHMENT_FIELDS = ['fsId', 'name', 'size', 'mime', 'width', 'height', 'thumbnail'];
-export const attachmentOf = (f) => Object.fromEntries(ATTACHMENT_FIELDS.filter((k) => f?.[k] !== undefined && f?.[k] !== null).map((k) => [k, f[k]]));
+export const attachmentOf = (f) =>
+  Object.fromEntries(ATTACHMENT_FIELDS.filter((k) => f?.[k] !== undefined && f?.[k] !== null).map((k) => [k, f[k]]));
 
 // Uploads a file to a channel and returns the attachment object to put into a message (fsId, name, size, mime…).
 export async function uploadFile(ctx, channel, file, client = api(ctx)) {
@@ -133,7 +164,14 @@ export async function uploadFile(ctx, channel, file, client = api(ctx)) {
   const r = await client.call('POST', apiPath`/channels/${channel}/files`, {name});
   if (!r?.fsId || !r?.presignedUploadUrl) throw new Error('Unexpected answer of the upload: no fsId or link');
   const fsId = checkId('The file id of the answer', r.fsId);
-  await request(presigned(r.presignedUploadUrl, ctx.env), {method: 'PUT', raw: {data, contentType: mimeOf(file)}, responseType: 'text', fetchImpl: ctx.fetch, timeoutMs: 600_000, service: 'the storage'});
+  await request(presigned(r.presignedUploadUrl, ctx.env), {
+    method: 'PUT',
+    raw: {data, contentType: mimeOf(file)},
+    responseType: 'text',
+    fetchImpl: ctx.fetch,
+    timeoutMs: 600_000,
+    service: 'the storage',
+  });
   const info = await client.call('GET', apiPath`/channels/${channel}/files/${fsId}`);
   return attachmentOf(info?.file ?? {fsId, name, size: data.length});
 }
@@ -142,12 +180,22 @@ export async function uploadFile(ctx, channel, file, client = api(ctx)) {
 export async function downloadFile(ctx, channel, message, fsId, to, client = api(ctx)) {
   const out = path.resolve(ctx.cwd ?? process.cwd(), to);
   refuseUnsafeWrite(out, ctx.env);
-  if (fs.existsSync(out)) throw new UsageError(`${to} exists already: choose another path (nothing was overwritten or deleted)`);
+  if (fs.existsSync(out))
+    throw new UsageError(`${to} exists already: choose another path (nothing was overwritten or deleted)`);
   const dir = path.dirname(out);
-  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) throw new UsageError(`The folder of ${to} does not exist`);
-  const r = await client.call('GET', apiPath`/channels/${channel}/messages/${message}/files/${fsId}/download-url` + '?download=1');
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory())
+    throw new UsageError(`The folder of ${to} does not exist`);
+  const r = await client.call(
+    'GET',
+    apiPath`/channels/${channel}/messages/${message}/files/${fsId}/download-url` + '?download=1',
+  );
   if (!r?.presignedDownloadUrl) throw new Error('No download link in the answer');
-  const data = await request(presigned(r.presignedDownloadUrl, ctx.env), {responseType: 'buffer', fetchImpl: ctx.fetch, timeoutMs: 600_000, service: 'the storage'});
+  const data = await request(presigned(r.presignedDownloadUrl, ctx.env), {
+    responseType: 'buffer',
+    fetchImpl: ctx.fetch,
+    timeoutMs: 600_000,
+    service: 'the storage',
+  });
   const tmp = path.join(dir, `.download.${process.pid}.${randomUUID().slice(0, 8)}`);
   fs.writeFileSync(tmp, data, {flag: 'wx', mode: 0o600});
   try {

package/src/chat/watch.mjs

@@ -3,10 +3,10 @@
 // ctx.emit(); READY when subscribed, RECONNECTING / RECONNECTED while the connection is renewed (the service closes
 // one after two hours; the token, checked only when a connection opens, is renewed with ctx.freshToken()), END at
 // the end (ctx.signal, --count or --for).
-import {jwtClaims} from '../auth.mjs';
-import {AuthError} from '../errors.mjs';
-import {localTime, oneLine, paint} from '../format.mjs';
-import {streamWsUrl} from '../services.mjs';
+import {jwtClaims} from 'wldx-core/auth';
+import {AuthError} from 'wldx-core/errors';
+import {localTime, oneLine, paint} from 'wldx-core/format';
+import {streamWsUrl} from 'wldx-core/services';
 import {streamClient} from '../stream.mjs';
 import {displayName, meId} from './lib.mjs';
 
@@ -16,8 +16,17 @@ export const EVENT_GROUPS = {
   reads: ['read.cursor.updated', 'read.receipt.updated'],
   members: ['member.added', 'member.updated', 'member.removed'],
   channels: [
-    'channel.created', 'channel.updated', 'channel.truncated', 'channel.added', 'channel.removed', 'channel.hidden',
-    'channel.visible', 'channel.muted', 'channel.unmuted', 'channel.pinned', 'channel.unpinned',
+    'channel.created',
+    'channel.updated',
+    'channel.truncated',
+    'channel.added',
+    'channel.removed',
+    'channel.hidden',
+    'channel.visible',
+    'channel.muted',
+    'channel.unmuted',
+    'channel.pinned',
+    'channel.unpinned',
   ],
   typing: ['typing.start', 'typing.stop'],
 };
@@ -26,7 +35,8 @@ export const EVENT_CHOICES = [...Object.keys(EVENT_GROUPS), ...Object.values(EVE
 const KEEPALIVE_MS = 4 * 60 * 1000; // the gateway drops a connection that is quiet for 10 minutes
 const BACKOFF = [1, 2, 5, 10]; // seconds, then 30
 const drop = (o) => JSON.parse(JSON.stringify(o)); // removes the undefined fields
-const unreadOf = (counters) => (counters ? Object.values(counters).reduce((n, c) => n + (c?.unmutedUnreadMessageCount ?? 0), 0) : undefined);
+const unreadOf = (counters) =>
+  counters ? Object.values(counters).reduce((n, c) => n + (c?.unmutedUnreadMessageCount ?? 0), 0) : undefined;
 
 // Whether an event passes the filters. A reaction event does not say who reacted (its message is someone else's
 // work), so a reaction has no author: it is never taken for the user's own action, and --from leaves it out.
@@ -34,7 +44,7 @@ export function wanted(e, {channels, senders, types, mine, me}) {
   if (types.size && !types.has(e.eventType)) return false;
   if (channels.size && !channels.has(e.channelId)) return false;
   const isReaction = e.eventType.startsWith('reaction.');
-  const author = isReaction ? undefined : e.message?.userId ?? e.readerUserId ?? e.typingUserId;
+  const author = isReaction ? undefined : (e.message?.userId ?? e.readerUserId ?? e.typingUserId);
   if (isReaction && senders.size) return false;
   if (senders.size && !senders.has(author)) return false;
   if (!mine) {
@@ -74,7 +84,18 @@ export async function view(e, nameOf) {
 const tokenExp = (token) => (Number.isFinite(jwtClaims(token).exp) ? jwtClaims(token).exp * 1000 : 0);
 
 // Runs until ctx.signal, `count` events (0: no limit) or `seconds` (0: no limit). Resolves when it stops.
-export async function watch(ctx, {channels = new Set(), senders = new Set(), types = new Set(), mine = false, raw = false, count = 0, seconds = 0} = {}) {
+export async function watch(
+  ctx,
+  {
+    channels = new Set(),
+    senders = new Set(),
+    types = new Set(),
+    mine = false,
+    raw = false,
+    count = 0,
+    seconds = 0,
+  } = {},
+) {
   let token = ctx.token;
   let client = streamClient({token, env: ctx.env, fetchImpl: ctx.fetch});
   const me = await meId(ctx, client);
@@ -88,7 +109,9 @@ export async function watch(ctx, {channels = new Set(), senders = new Set(), typ
     if (!names.has(id)) {
       let name;
       try {
-        name = displayName((await client.call('POST', '/users/query', {query: {ids: [id]}}, {timeoutMs: 10_000}))?.users?.[0]);
+        name = displayName(
+          (await client.call('POST', '/users/query', {query: {ids: [id]}}, {timeoutMs: 10_000}))?.users?.[0],
+        );
       } catch {
         // a name is a nicety: the id is printed anyway
       }
@@ -203,11 +226,17 @@ export async function watch(ctx, {channels = new Set(), senders = new Set(), typ
         }
         attempts += 1;
         if (!opened && attempts >= 5) {
-          finish(new AuthError(`The chat service did not accept the connection (code ${ev?.code}): log in again (wx login) if this repeats`));
+          finish(
+            new AuthError(
+              `The chat service did not accept the connection (code ${ev?.code}): log in again (wx login) if this repeats`,
+            ),
+          );
           return;
         }
         const wait = BACKOFF[attempts - 1] ?? 30;
-        queue = queue.then(() => !stopping && ctx.emit({event: 'RECONNECTING', code: ev?.code, attempt: attempts, inSeconds: wait}));
+        queue = queue.then(
+          () => !stopping && ctx.emit({event: 'RECONNECTING', code: ev?.code, attempt: attempts, inSeconds: wait}),
+        );
         retry = setTimeout(again, wait * 1000);
       };
     };
@@ -219,8 +248,8 @@ export async function watch(ctx, {channels = new Set(), senders = new Set(), typ
 export function eventText(e, ctx) {
   const c = paint(ctx);
   const at = c.dim(localTime(ctx?.clock ? ctx.clock() : Date.now(), {seconds: true}));
-  const where = e.channel ? c.bold(oneLine(e.channel, 40)) : e.channelId ?? '';
-  const who = (p) => (p ? p.name ?? p.id : '?');
+  const where = e.channel ? c.bold(oneLine(e.channel, 40)) : (e.channelId ?? '');
+  const who = (p) => (p ? (p.name ?? p.id) : '?');
   switch (true) {
     case e.event === 'READY':
       return `${at}  ${c.green('watching the chats')}${e.types ? ` (${e.types.join(', ')})` : ''}${e.channels ? ` in ${e.channels.join(', ')}` : ''}${e.from ? ` from ${e.from.join(', ')}` : ''}. Ctrl-C stops.`;
@@ -236,7 +265,9 @@ export function eventText(e, ctx) {
       return `${at}  ${e.event.padEnd(15)}  ${where}  ${c.bold(who(e.from))}: ${text}`;
     }
     case e.event?.startsWith('reaction.'): {
-      const counts = Object.entries(e.reactions ?? {}).map(([t, n]) => `${t} ${n}`).join(', ');
+      const counts = Object.entries(e.reactions ?? {})
+        .map(([t, n]) => `${t} ${n}`)
+        .join(', ');
       return `${at}  ${e.event.padEnd(15)}  ${where}  on a message of ${who(e.messageAuthor)}: ${counts ? `[${counts}]` : '(none)'}`;
     }
     case e.event?.startsWith('read.'):