@stage-labs/metro 0.1.0-beta.30 → 0.1.0-beta.301

package/runtime/node_modules/@metro-labs/threema/src/verify.ts

@@ -0,0 +1,117 @@
+import { createPrivateKey, createPublicKey } from 'node:crypto';
+import {
+  GATEWAY_API,
+  isGatewayId,
+  normalizeThreemaId,
+  parsePrivateKey,
+} from './ids.js';
+
+export { parsePrivateKey } from './ids.js';
+
+export class ThreemaGatewayError extends Error {}
+
+export interface ThreemaCredentials {
+  gatewayId: string;
+  secret: string;
+  privateKey: string;
+}
+
+export interface ThreemaGatewayIdentity {
+  gatewayId: string;
+  publicKey: string;
+  credits: number;
+}
+
+const PKCS8_X25519_PREFIX = Buffer.from(
+  '302e020100300506032b656e04220420',
+  'hex',
+);
+const TIMEOUT_MS = 10_000;
+const PUBLIC_KEY_RE = /^[0-9a-f]{64}$/;
+
+export function publicKeyOf(privateKeyHex: string): string {
+  const der = Buffer.concat([
+    PKCS8_X25519_PREFIX,
+    Buffer.from(privateKeyHex, 'hex'),
+  ]);
+  const key = createPrivateKey({ key: der, format: 'der', type: 'pkcs8' });
+  const jwk = createPublicKey(key).export({ format: 'jwk' });
+  return Buffer.from(String(jwk.x), 'base64url').toString('hex');
+}
+
+async function gatewayGet(
+  path: string,
+  gatewayId: string,
+  secret: string,
+): Promise<Response> {
+  const query = new URLSearchParams({ from: gatewayId, secret });
+  try {
+    return await fetch(`${GATEWAY_API}${path}?${query.toString()}`, {
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+  } catch {
+    throw new ThreemaGatewayError(
+      'could not reach the Threema Gateway to check those credentials',
+    );
+  }
+}
+
+function refused(res: Response, what: string): ThreemaGatewayError {
+  if (res.status === 401)
+    return new ThreemaGatewayError(
+      'Threema rejected that Gateway ID or API secret',
+    );
+  if (res.status === 404)
+    return new ThreemaGatewayError(`Threema does not know ${what}`);
+  return new ThreemaGatewayError(
+    `the Threema Gateway answered ${res.status} while checking ${what}`,
+  );
+}
+
+async function fetchCredits(gatewayId: string, secret: string): Promise<number> {
+  const res = await gatewayGet('/credits', gatewayId, secret);
+  if (!res.ok) throw refused(res, 'the credit balance');
+  const credits = Number((await res.text()).trim());
+  if (!Number.isInteger(credits))
+    throw new ThreemaGatewayError(
+      'the Threema Gateway gave an unexpected answer for the credit balance',
+    );
+  return credits;
+}
+
+async function fetchPublicKey(gatewayId: string, secret: string): Promise<string> {
+  const res = await gatewayGet(
+    `/pubkeys/${encodeURIComponent(gatewayId)}`,
+    gatewayId,
+    secret,
+  );
+  if (!res.ok) throw refused(res, `the public key of ${gatewayId}`);
+  const hex = (await res.text()).trim().toLowerCase();
+  if (!PUBLIC_KEY_RE.test(hex))
+    throw new ThreemaGatewayError(
+      'the Threema Gateway gave an unexpected answer for the public key',
+    );
+  return hex;
+}
+
+export async function verifyThreemaGateway(
+  input: ThreemaCredentials,
+): Promise<ThreemaGatewayIdentity> {
+  const gatewayId = normalizeThreemaId(input.gatewayId);
+  if (!isGatewayId(gatewayId))
+    throw new ThreemaGatewayError(
+      'a Threema Gateway ID is a * followed by 7 letters or digits, as in *ABCDEFG',
+    );
+  const privateKey = parsePrivateKey(input.privateKey);
+  if (privateKey === null)
+    throw new ThreemaGatewayError(
+      'the private key is the 64 hex characters from the key file Threema gave you, with or without its private: prefix',
+    );
+  const credits = await fetchCredits(gatewayId, input.secret);
+  const registered = await fetchPublicKey(gatewayId, input.secret);
+  if (registered !== publicKeyOf(privateKey))
+    throw new ThreemaGatewayError(
+      `that private key does not belong to ${gatewayId}: the Gateway holds a different public key for it`,
+    );
+  return { gatewayId, publicKey: registered, credits };
+}

package/runtime/node_modules/@metro-labs/webhook/package.json

@@ -11,10 +11,10 @@
     "test": "tsc --noEmit && bun test test/"
   },
   "dependencies": {
-    "@metro-labs/mcp": "workspace:*"
+    "@metro-labs/core": "workspace:*"
   },
   "devDependencies": {
-    "@stage-labs/config": "0.1.0-beta.2",
+    "@stage-labs/config": "0.1.0-beta.3",
     "eslint": "^10.3.0",
     "knip": "^6.15.0",
     "madge": "^8.0.0",

package/runtime/node_modules/@metro-labs/webhook/src/station.ts

@@ -1,11 +1,8 @@
 import { randomUUID } from 'node:crypto';
-import { Line, asLine } from '@metro-labs/mcp/lines';
-import { mintId, type MetroEvent } from '@metro-labs/mcp/events';
-import type { Endpoint } from '@metro-labs/mcp/endpoints';
-import type { Station, Verb } from '@metro-labs/mcp/stations/types';
-
-const sessionOwner = (sessionId: string): Line =>
-  asLine(`metro://session/${sessionId}`);
+import { Line } from '@metro-labs/core/lines';
+import { mintId, type MetroEvent } from '@metro-labs/core/events';
+import type { Endpoint } from '@metro-labs/core/endpoints';
+import type { Station, Verb } from '@metro-labs/core/stations/types';
 
 export const webhookStation: Station = {
   name: 'webhook',
@@ -31,7 +28,7 @@ export function webhookEntry(
     line,
     lineName: endpoint.label,
     from: line,
-    to: endpoint.session ? sessionOwner(endpoint.session) : line,
+    to: line,
     messageId:
       headers['x-github-delivery'] ?? headers['x-request-id'] ?? randomUUID(),
     text: `${headers['x-github-event'] ?? headers['x-intercom-topic'] ?? 'event'} ${method} ${url}`,

package/runtime/node_modules/@metro-labs/whatsapp/package.json

@@ -6,24 +6,21 @@
   "exports": {
     ".": "./src/station.ts",
     "./train": "./src/index.ts",
-    "./login": "./src/login.ts",
-    "./tokens": "./src/token-store.ts"
+    "./login": "./src/login.ts"
   },
   "scripts": {
     "build": "tsc",
     "test": "tsc --noEmit && bun test test/"
   },
   "dependencies": {
-    "@metro-labs/mcp": "workspace:*",
+    "@metro-labs/core": "workspace:*",
     "baileys": "7.0.0-rc14"
   },
   "devDependencies": {
-    "@stage-labs/config": "0.1.0-beta.2",
-    "@types/qrcode-terminal": "^0.12.2",
+    "@stage-labs/config": "0.1.0-beta.3",
     "eslint": "^10.3.0",
     "knip": "^6.15.0",
     "madge": "^8.0.0",
-    "qrcode-terminal": "^0.12.0",
     "typescript": "^5"
   }
 }

package/runtime/node_modules/@metro-labs/whatsapp/src/accounts.ts

@@ -1,37 +1,21 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
 import {
   makeAccountStore,
   resolveAccountId,
   type Die,
-} from '@metro-labs/mcp/stations/account-store';
+} from '@metro-labs/core/stations/account-store';
 import type { WhatsAppAccount } from './types.js';
 
-const ACCOUNTS_FILE =
-  process.env.WHATSAPP_ACCOUNTS_FILE ??
-  join(homedir(), '.metro', 'whatsapp-accounts.json');
-
 const isJid = (s: string): boolean => s.includes('@');
 
-function validateAccount(
-  a: WhatsAppAccount,
-  seen: Set<string>,
-  die: Die,
-): void {
-  if (!a.id) die('account missing id');
+function validateAccount(a: WhatsAppAccount, die: Die): void {
   if (!a.phone || typeof a.phone !== 'string')
     die(`account '${a.id}' missing phone`);
-  if (seen.has(a.id)) die(`duplicate account id '${a.id}'`);
-  seen.add(a.id);
 }
 
 export const { loadAccounts } = makeAccountStore<WhatsAppAccount>({
   prefix: 'whatsapp',
-  file: ACCOUNTS_FILE,
-  allowlistEnv: ['WHATSAPP_ONLY_ACCOUNTS', 'WHATSAPP_ACCOUNTS'],
   validate(raw, die) {
-    const seen = new Set<string>();
-    for (const a of raw) validateAccount(a, seen, die);
+    for (const a of raw) validateAccount(a, die);
   },
 });
 
@@ -50,18 +34,12 @@ interface Target {
   jid: string;
 }
 
-function splitScoped(path: string[]): { accountId: string; jid?: string } {
-  const first = path[0];
-  if (path.length >= 2 && first !== undefined && !isJid(first))
-    return { accountId: first, jid: path[1] };
-  return { accountId: 'default', jid: first };
-}
-
 export function targetOf(line: string): Target | undefined {
   const prefix = 'metro://whatsapp/';
   if (!line.startsWith(prefix)) return undefined;
   const path = line.slice(prefix.length).split('/').filter(Boolean);
-  const { accountId, jid } = splitScoped(path);
-  if (jid === undefined || !isJid(jid)) return undefined;
+  const [accountId, jid] = path;
+  if (path.length !== 2 || accountId === undefined || jid === undefined) return undefined;
+  if (!isJid(jid)) return undefined;
   return { accountId, jid };
 }

package/runtime/node_modules/@metro-labs/whatsapp/src/ack.ts

@@ -1,4 +1,4 @@
-import { TrainError } from '@metro-labs/mcp/train-error';
+import { TrainError } from '@metro-labs/core/train-error';
 import type { BinaryNode, WASocket } from 'baileys';
 
 const DEFAULT_ACK_WAIT_MS = 5000;

package/runtime/node_modules/@metro-labs/whatsapp/src/actions.ts

@@ -1,14 +1,16 @@
-import { TrainError } from '@metro-labs/mcp/train-error';
-import { errMsg } from '@metro-labs/mcp/log';
-import { kindOf } from '@metro-labs/mcp/stations/attachments';
+import { TrainError } from '@metro-labs/core/train-error';
+import { errMsg } from '@metro-labs/core/log';
+import { kindOf } from '@metro-labs/core/stations/attachments';
 import {
   makeStation,
   respond,
   type CallMsg,
   type StationHandler,
-} from '@metro-labs/mcp/stations/station-runtime';
-import { accountFor, accounts, targetOf } from './accounts.js';
-import { normalizeWhatsApp } from './normalize.js';
+} from '@metro-labs/core/stations/station-runtime';
+import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
+import { accountFor, accounts, lineOf, targetOf } from './accounts.js';
+import { phoneNumberOf, senderLookup } from './resolve.js';
+import { assertImage, fieldsOf, parseProfileChange, type ProfileApplied } from '@metro-labs/core/stations/profile';
 import type { WAClient } from './client.js';
 
 type Args = Record<string, unknown>;
@@ -48,8 +50,7 @@ async function guard<T>(run: () => Promise<T>): Promise<T> {
 
 interface WireAttachment {
   kind?: string;
-  path?: string;
-  url?: string;
+  path: string;
   mime?: string;
   name?: string;
 }
@@ -57,7 +58,7 @@ interface WireAttachment {
 function attachmentsOf(args: Args): WireAttachment[] {
   const raw = args.attachments;
   if (!Array.isArray(raw)) return [];
-  return (raw as WireAttachment[]).filter((a) => Boolean(a.path ?? a.url));
+  return (raw as Partial<WireAttachment>[]).filter((a): a is WireAttachment => Boolean(a.path));
 }
 
 async function sendMediaSet(
@@ -72,7 +73,7 @@ async function sendMediaSet(
   for (let i = 0; i < atts.length; i++) {
     const att = atts[i];
     if (!att) continue;
-    const path = att.path ?? att.url ?? '';
+    const path = att.path;
     const kind = att.kind ?? kindOf(att.mime ?? '', path);
     messageId = await guard(() =>
       client.sendMedia(
@@ -116,6 +117,45 @@ function makeSend(clientFor: ClientFor): StationHandler {
   };
 }
 
+function makeRead(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, jid } = resolve(args, clientFor);
+    const page = await guard(() => client.read(jid, {
+      limit: typeof args.limit === 'number' ? args.limit : undefined,
+      before: str(args.before),
+      since: str(args.since),
+    }));
+    const messages = page.messages.map((row) => ({
+      id: row.messageId,
+      ts: row.timestamp,
+      ...(row.senderJid ? { from: lineOf(accountId, `user/${row.senderJid}`) } : {}),
+      self: row.fromMe,
+      text: row.text,
+      ...(row.truncated ? { truncated: true } : {}),
+      ...(row.attachments ? { attachments: row.attachments } : {}),
+    }));
+    respond(id, { result: { ...page, line: lineOf(accountId, jid), account: accountId, messages } });
+  };
+}
+
+function makeListChannels(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const account = str(args.account);
+    if (!account) throw new TrainError('bad_request', 'listChannels requires an account');
+    const accountId = accountFor({ account });
+    const result = await guard(() => clientFor(accountId).listChannels(args));
+    respond(id, { result });
+  };
+}
+
+function makeListMembers(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { client, jid } = resolve({ line: args.line }, clientFor);
+    const result = await guard(() => client.listMembers(jid, typeof args.limit === 'number' ? args.limit : undefined));
+    respond(id, { result });
+  };
+}
+
 function makeReact(clientFor: ClientFor): StationHandler {
   return async (id, args) => {
     const { accountId, client, jid } = resolve(args, clientFor);
@@ -126,6 +166,14 @@ function makeReact(clientFor: ClientFor): StationHandler {
   };
 }
 
+function makeTyping(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const { accountId, client, jid } = resolve(args, clientFor);
+    await guard(() => client.showTyping(jid));
+    respond(id, { result: { ok: true, account: accountId } });
+  };
+}
+
 function makeEdit(clientFor: ClientFor): StationHandler {
   return async (id, args) => {
     const { accountId, client, jid } = resolve(args, clientFor);
@@ -154,7 +202,6 @@ function makeAccounts(clientFor: ClientFor): StationHandler {
         handle: phone === null ? null : `+${phone}`,
         url: phone === null ? null : `https://wa.me/${phone}`,
         connected: phone !== null,
-        owner: a.owner ?? null,
       };
     });
     respond(id, { result: { accounts: list } });
@@ -162,6 +209,37 @@ function makeAccounts(clientFor: ClientFor): StationHandler {
   };
 }
 
+function makeResolveSender(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const query = str(args.query) ?? '';
+    const number = phoneNumberOf(query);
+    const found = await guard(() => clientFor(accountId).lookupSender(number));
+    respond(id, { result: { account: accountId, ...senderLookup(query, number, found) } });
+  };
+}
+
+function makeSetProfile(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const change = parseProfileChange(args);
+    if (change.avatar !== undefined) assertImage(change.avatar);
+    await guard(() => clientFor(accountId).setProfile(change));
+    const result: ProfileApplied = { account: accountId, applied: fieldsOf(change) };
+    respond(id, { result });
+  };
+}
+
+function makeProfile(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const user = str(args.user) ?? '';
+    if (user === '') throw new TrainError('whatsapp_user_required', 'profile needs the jid of the person', { retryable: false });
+    const profile = await guard(() => clientFor(accountId).senderProfile(user));
+    respond(id, { result: profile ?? { id: user } });
+  };
+}
+
 export function makeHandleCall(
   clientFor: ClientFor,
 ): (msg: CallMsg) => Promise<void> {
@@ -169,10 +247,17 @@ export function makeHandleCall(
     handlers: {
       accounts: makeAccounts(clientFor),
       send: makeSend(clientFor),
+      read: makeRead(clientFor),
+      listMembers: makeListMembers(clientFor),
+      listChannels: makeListChannels(clientFor),
       react: makeReact(clientFor),
+      typing: makeTyping(clientFor),
       edit: makeEdit(clientFor),
       delete: makeDelete(clientFor),
+      resolve_sender: makeResolveSender(clientFor),
+      set_profile: makeSetProfile(clientFor),
+      profile: makeProfile(clientFor),
     },
-    normalize: normalizeWhatsApp,
+    normalize: messagingAliases(),
   });
 }

package/runtime/node_modules/@metro-labs/whatsapp/src/app-state.ts

@@ -0,0 +1,49 @@
+import { errMsg, log } from '@metro-labs/core/log';
+import { isPnUser, isLidUser, makeEventBuffer, processSyncAction, type BaileysEventEmitter, type Contact } from 'baileys';
+import type { History } from './history.js';
+import { baileysLogger } from './logger.js';
+
+interface AppStateHooks {
+  history: History;
+  current(): boolean;
+}
+
+export function supportsHistoryDeletion(processAction = processSyncAction): boolean {
+  const ev = makeEventBuffer(baileysLogger('history-support'));
+  const id = 'history-support@g.us';
+  const messageRange = { lastMessageTimestamp: 1 };
+  let received = 0;
+  ev.on('chats.clear', (event) => {
+    if (event.id === id && event.messageRange === messageRange) received++;
+  });
+  try {
+    for (const initial of [false, true]) {
+      for (const type of ['clearChat', 'deleteChat']) {
+        const value = type === 'clearChat' ? { clearChatAction: { messageRange } } : { deleteChatAction: { messageRange } };
+        const before = received;
+        processAction({ index: [type, id], syncAction: { value } }, ev, { id }, initial ? { accountSettings: { unarchiveChats: false } } : undefined);
+        if (received !== before + 1) return false;
+      }
+    }
+    return true;
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'whatsapp: local history deletion support check failed');
+    return false;
+  }
+}
+
+export function noteHistoryContact(history: History, contact: Partial<Contact>): void {
+  const pn = contact.phoneNumber ?? (isPnUser(contact.id) ? contact.id : undefined);
+  const lid = contact.lid ?? (isLidUser(contact.id) ? contact.id : undefined);
+  if (pn && lid) history.alias(pn, lid);
+}
+
+export function bindAppState(ev: BaileysEventEmitter, hooks: AppStateHooks): void {
+  ev.on('lid-mapping.update', ({ pn, lid }) => {
+    if (hooks.current()) hooks.history.alias(pn, lid);
+  });
+  ev.on('chats.clear', ({ id, messageRange }) => {
+    if (!hooks.current()) return;
+    hooks.history.clearRange(id, messageRange ?? {});
+  });
+}

package/runtime/node_modules/@metro-labs/whatsapp/src/attachments.ts

@@ -3,8 +3,8 @@ import {
   assertAttachmentSize,
   saveStreamToCache,
   type SavedAttachment,
-} from '@metro-labs/mcp/stations/attachments';
-import { TrainError } from '@metro-labs/mcp/train-error';
+} from '@metro-labs/core/stations/attachments';
+import { TrainError } from '@metro-labs/core/train-error';
 import { baileysLogger } from './logger.js';
 import type { WAMediaRef } from './media.js';
 

package/runtime/node_modules/@metro-labs/whatsapp/src/auth-state.ts

@@ -8,7 +8,7 @@ import {
   type SignalDataTypeMap,
   type SignalKeyStore,
 } from 'baileys';
-import { TrainError } from '@metro-labs/mcp/train-error';
+import { TrainError } from '@metro-labs/core/train-error';
 import {
   isPersistedKeyType,
   tokenStoreFor,

package/runtime/node_modules/@metro-labs/whatsapp/src/channel-chats.ts

@@ -0,0 +1,137 @@
+import { readFileSync, statSync } from 'node:fs';
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg, log } from '@metro-labs/core/log';
+import { writeSecure } from '@metro-labs/core/secure-fs';
+import { accountFiles } from '@metro-labs/core/stations/account-files';
+import { DIRECTORY_LIMIT, type ChannelEntry } from '@metro-labs/core/stations/channel-directory';
+import { lineOf } from './accounts.js';
+
+export const channelFiles = accountFiles('WHATSAPP_TOKEN_DIR', 'whatsapp-channels-');
+const FILE_BYTES = 16 * 1024 * 1024;
+const NAME_LIMIT = 256;
+
+interface ChatMetadata {
+  id?: string | null;
+  name?: string | null;
+  conversationTimestamp?: number | { toNumber(): number } | null;
+}
+
+interface StoredChat {
+  id: string;
+  name?: string;
+  deleted?: true;
+  deletedAt?: number;
+}
+
+function directId(value: unknown): string | undefined {
+  if (typeof value !== 'string' || value.length > 128 || !/^\d+(?::\d+)?@(s\.whatsapp\.net|lid)$/.test(value)) return undefined;
+  return value.replace(/:\d+@/, '@');
+}
+
+export function channelName(value: unknown): string | undefined {
+  return typeof value === 'string' ? value.trim().slice(0, NAME_LIMIT) || undefined : undefined;
+}
+
+function deletionTime(value: unknown): number {
+  return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 ? value : Date.now();
+}
+
+function newerActivity(chat: ChatMetadata, deletedAt: number): boolean {
+  const value = chat.conversationTimestamp;
+  const seconds = typeof value === 'number' ? value : value?.toNumber();
+  if (seconds === undefined || !Number.isSafeInteger(seconds)) return false;
+  const at = seconds * 1000;
+  return at > deletedAt && at <= Date.now();
+}
+
+function blocked(chat: ChatMetadata, prior: StoredChat | undefined, fresh: boolean): boolean {
+  return prior?.deleted === true && (!fresh || !newerActivity(chat, deletionTime(prior.deletedAt)));
+}
+
+function storedChat(row: unknown): StoredChat | undefined {
+  if (!isRecord(row)) return undefined;
+  const id = directId(row.id);
+  if (!id) return undefined;
+  return row.deleted === true
+    ? { id, deleted: true, deletedAt: deletionTime(row.deletedAt) }
+    : { id, name: channelName(row.name) };
+}
+
+export class KnownChats {
+  private readonly chats = new Map<string, StoredChat>();
+  private readonly file: string;
+
+  constructor(private readonly accountId: string) {
+    this.file = channelFiles.path(accountId);
+    this.load();
+  }
+
+  private load(): void {
+    try {
+      if (statSync(this.file).size > FILE_BYTES) throw new Error('channel metadata file is too large');
+      const raw: unknown = JSON.parse(readFileSync(this.file, 'utf8'));
+      if (!Array.isArray(raw)) throw new Error('invalid channel metadata');
+      for (const row of raw.slice(-DIRECTORY_LIMIT)) {
+        const chat = storedChat(row);
+        if (chat) this.put(chat);
+      }
+    } catch (err) {
+      if (isRecord(err) && err.code === 'ENOENT') return;
+      log.warn({ accountId: this.accountId, err: errMsg(err) }, 'whatsapp: could not load channel metadata');
+    }
+  }
+
+  private put(row: StoredChat): void {
+    this.chats.delete(row.id);
+    this.chats.set(row.id, row);
+    if (this.chats.size > DIRECTORY_LIMIT) {
+      const oldest = this.chats.keys().next().value;
+      if (oldest !== undefined) this.chats.delete(oldest);
+    }
+  }
+
+  private save(): void {
+    try {
+      writeSecure(this.file, JSON.stringify([...this.chats.values()]));
+    } catch (err) {
+      log.warn({ accountId: this.accountId, err: errMsg(err) }, 'whatsapp: could not save channel metadata');
+    }
+  }
+
+  private noteChat(chat: ChatMetadata, fresh: boolean): boolean {
+    const id = directId(chat.id);
+    if (!id) return false;
+    const prior = this.chats.get(id);
+    if (blocked(chat, prior, fresh)) return false;
+    const name = channelName(chat.name) ?? prior?.name;
+    if (prior && !prior.deleted && prior.name === name) return false;
+    this.put({ id, name });
+    return true;
+  }
+
+  note(chats: readonly ChatMetadata[], fresh = false): void {
+    let changed = false;
+    for (const chat of chats) {
+      if (this.noteChat(chat, fresh)) changed = true;
+    }
+    if (changed) this.save();
+  }
+
+  remove(ids: readonly string[]): void {
+    let changed = false;
+    for (const value of ids) {
+      const id = directId(value);
+      if (!id) continue;
+      const deletedAt = Math.max(Date.now(), this.chats.get(id)?.deletedAt ?? 0);
+      this.put({ id, deleted: true, deletedAt });
+      changed = true;
+    }
+    if (changed) this.save();
+  }
+
+  list(): ChannelEntry[] {
+    return [...this.chats.values()].filter((chat) => !chat.deleted).map(({ id, name }) => ({
+      id, line: lineOf(this.accountId, id), kind: 'direct', ...(name ? { name } : {}),
+    }));
+  }
+}