@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.310

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 } : {}),
+    }));
+  }
+}

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

@@ -0,0 +1,48 @@
+import type { WASocket } from 'baileys';
+import { ChannelDirectory, DIRECTORY_LIMIT, type ChannelEntry, type ChannelList } from '@metro-labs/core/stations/channel-directory';
+import { lineOf } from './accounts.js';
+import { KnownChats, channelName } from './channel-chats.js';
+
+const REASON = `Participating groups come from WhatsApp. Direct chats are limited to at most ${DIRECTORY_LIMIT} chat metadata records observed or synced to this installation; WhatsApp has no all-direct-chats directory. Cleared chats are omitted, and WhatsApp channels are not enumerated.`;
+
+export class WhatsAppChannels {
+  private readonly chats: KnownChats;
+  private readonly directory = new ChannelDirectory();
+
+  constructor(private readonly accountId: string) {
+    this.chats = new KnownChats(accountId);
+  }
+
+  bind(sock: Pick<WASocket, 'ev'>, current: () => boolean): void {
+    sock.ev.on('chats.upsert', (chats) => {
+      if (current()) this.chats.note(chats, true);
+    });
+    sock.ev.on('chats.update', (chats) => {
+      if (current()) this.chats.note(chats, true);
+    });
+    sock.ev.on('messaging-history.set', ({ chats }) => {
+      if (current()) this.chats.note(chats);
+    });
+    sock.ev.on('chats.delete', (ids) => {
+      if (current()) this.chats.remove(ids);
+    });
+    sock.ev.on('chats.clear', ({ id }) => {
+      if (current()) this.chats.remove([id]);
+    });
+  }
+
+  list(ready: () => Promise<Pick<WASocket, 'groupFetchAllParticipating'>>, args: Record<string, unknown>): Promise<ChannelList> {
+    return this.directory.list(this.accountId, args, async () => {
+      const groups = await (await ready()).groupFetchAllParticipating();
+      const channels: ChannelEntry[] = [];
+      for (const group of Object.values(groups)) {
+        if (!/^\d+(?:-\d+)?@g\.us$/.test(group.id) || group.id.length > 128) continue;
+        const name = channelName(group.subject);
+        channels.push({ id: group.id, line: lineOf(this.accountId, group.id), kind: 'group', ...(name ? { name } : {}) });
+        if (channels.length > DIRECTORY_LIMIT) break;
+      }
+      channels.push(...this.chats.list());
+      return { channels, capability: { supported: true, complete: false, source: 'mixed', reason: REASON } };
+    });
+  }
+}

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

@@ -0,0 +1,31 @@
+import { log } from '@metro-labs/core/log';
+import { TrainError } from '@metro-labs/core/train-error';
+import { supportsHistoryDeletion } from './app-state.js';
+import { createHistory, type History } from './history.js';
+
+const UNAVAILABLE = 'WhatsApp local history is unavailable because this runtime lacks the deletion patch. Ask the owner to update and restart Metro to load the patched runtime. Prior history was invalidated to avoid stale deleted messages.';
+const ignore = (): void => undefined;
+
+export function createClientHistory(accountId: string, supported = supportsHistoryDeletion()): History {
+  const history = createHistory(accountId);
+  if (supported) return history;
+  try {
+    history.invalidate();
+  } finally {
+    history.close();
+  }
+  log.warn({ accountId }, UNAVAILABLE);
+  return {
+    read() { throw new TrainError('whatsapp_history_unavailable', UNAVAILABLE); },
+    ingest: ignore,
+    ingestSent: ignore,
+    alias: ignore,
+    clearRange: ignore,
+    invalidate: ignore,
+    update: ignore,
+    deleteMessages: ignore,
+    edit: ignore,
+    flush: ignore,
+    close: ignore,
+  };
+}

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

@@ -0,0 +1,48 @@
+import type makeWASocket from 'baileys';
+import type { fetchLatestWaWebVersion, WAMessage } from 'baileys';
+import type { MemberList } from '@metro-labs/core/stations/types';
+import type { ChannelList } from '@metro-labs/core/stations/channel-directory';
+import type { ProfileChange } from '@metro-labs/core/stations/profile';
+import type { SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import type { WhatsAppAccount } from './types.js';
+import type { InboundMessage, ReactionInput } from './format.js';
+import type { SenderFound } from './resolve.js';
+import type { HistoryOptions, HistoryPage } from './history.js';
+
+export interface InboundHandlers {
+  onMessage(m: InboundMessage, raw: WAMessage): void;
+  onReaction(r: ReactionInput): void;
+}
+
+export interface WAMedia {
+  kind: string;
+  path: string;
+  mime: string;
+  name: string;
+  caption?: string;
+}
+
+export interface WAClient {
+  account: WhatsAppAccount;
+  self(): string | null;
+  start(handlers: InboundHandlers): Promise<void>;
+  read(jid: string, options?: HistoryOptions): Promise<HistoryPage>;
+  listMembers(jid: string, limit?: number): Promise<MemberList>;
+  listChannels(args: Record<string, unknown>): Promise<ChannelList>;
+  sendText(jid: string, text: string, quotedId?: string): Promise<string>;
+  sendMedia(jid: string, media: WAMedia, quotedId?: string): Promise<string>;
+  sendReaction(jid: string, messageId: string, emoji: string): Promise<void>;
+  showTyping(jid: string): Promise<void>;
+  editMessage(jid: string, messageId: string, text: string): Promise<void>;
+  deleteMessage(jid: string, messageId: string): Promise<void>;
+  reuploadMedia(m: WAMessage): Promise<WAMessage>;
+  lookupSender(number: string): Promise<SenderFound>;
+  setProfile(change: ProfileChange): Promise<void>;
+  senderProfile(jid: string): Promise<SenderProfile | null>;
+  disconnect(): Promise<void>;
+}
+
+export interface ClientRuntime {
+  makeSocket: typeof makeWASocket;
+  fetchVersion: typeof fetchLatestWaWebVersion;
+}

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

@@ -1,4 +1,5 @@
 import makeWASocket, {
+  jidNormalizedUser,
   Browsers,
   DisconnectReason,
   fetchLatestWaWebVersion,
@@ -7,12 +8,21 @@ import makeWASocket, {
   type WAMessageKey,
   type WASocket,
 } from 'baileys';
-import { TrainError } from '@metro-labs/mcp/train-error';
-import { errMsg } from '@metro-labs/mcp/log';
+import { TrainError } from '@metro-labs/core/train-error';
+import { errMsg } from '@metro-labs/core/log';
 import type { WhatsAppAccount } from './types.js';
-import type { InboundMessage, ReactionInput } from './format.js';
-import { toInbound, toReaction, type ReactionEvent } from './parse.js';
+import type { InboundHandlers, WAClient, WAMedia, ClientRuntime } from './client-types.js';
+export type { InboundHandlers, WAClient, WAMedia } from './client-types.js';
+import { makeProfileCache, nonEmpty, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import type { SelfRef } from './parse.js';
+import type { History } from './history.js';
+import { createClientHistory } from './client-history.js';
+import { WhatsAppChannels } from './channels.js';
+import { bindMessages } from './messages.js';
+import { listMembers } from './members.js';
+import { SendExpiry } from './send-expiry.js';
 import { baileysLogger } from './logger.js';
+import { makeNameBook, nameFiles, phoneOf, type NameBook } from './names.js';
 import { useAccountAuthState } from './auth-state.js';
 import { knownKey, makeKeyCache, targetKey, type KeyCache } from './keys.js';
 import { makeOutbox, type Outbox } from './outbox.js';
@@ -25,69 +35,47 @@ import {
   type AckWatch,
 } from './ack.js';
 
-export interface InboundHandlers {
-  onMessage(m: InboundMessage, raw: WAMessage): void;
-  onReaction(r: ReactionInput): void;
-}
-
-export interface WAMedia {
-  kind: string;
-  path: string;
-  mime: string;
-  name: string;
-  caption?: string;
-}
-
-export interface WAClient {
-  account: WhatsAppAccount;
-  self(): string | null;
-  start(handlers: InboundHandlers): Promise<void>;
-  sendText(jid: string, text: string, quotedId?: string): Promise<string>;
-  sendMedia(jid: string, media: WAMedia, quotedId?: string): Promise<string>;
-  sendReaction(jid: string, messageId: string, emoji: string): Promise<void>;
-  editMessage(jid: string, messageId: string, text: string): Promise<void>;
-  deleteMessage(jid: string, messageId: string): Promise<void>;
-  reuploadMedia(m: WAMessage): Promise<WAMessage>;
-  disconnect(): Promise<void>;
-}
-
 interface State {
   account: WhatsAppAccount;
+  runtime: ClientRuntime;
+  history: History;
+  expiry: SendExpiry;
   handlers?: InboundHandlers;
   sock?: WASocket;
   closed: boolean;
+  closing?: Promise<void>;
   openResolve?: () => void;
   openPromise: Promise<void>;
   keys: KeyCache;
   outbox: Outbox;
   acks: AckWatch;
+  names: NameBook;
+  channels: WhatsAppChannels;
 }
-
 type SendOpts = Parameters<WASocket['sendMessage']>[2];
 type SendContent = Parameters<WASocket['sendMessage']>[1];
-
 function resetGate(st: State): void {
   st.openPromise = new Promise<void>((resolve) => {
     st.openResolve = resolve;
   });
 }
+function selfRef(st: State, sock: WASocket): SelfRef {
+  const jids = new Set<string>();
+  const me = sock.user;
+  if (me?.id) jids.add(jidNormalizedUser(me.id));
+  if (me?.lid) jids.add(jidNormalizedUser(me.lid));
+  return { jids, sentByMe: (jid, id) => st.keys.lookup(jid, id)?.fromMe === true };
+}
 
 function bindInbound(st: State, sock: WASocket): void {
-  sock.ev.on('messages.upsert', ({ messages, type }) => {
-    for (const m of messages) st.keys.remember(m.key);
-    if (type !== 'notify' || !st.handlers) return;
-    for (const m of messages) {
-      if (m.key.fromMe) continue;
-      const inbound = toInbound(st.account.id, m);
-      if (inbound) st.handlers.onMessage(inbound, m);
-    }
-  });
-  sock.ev.on('messages.reaction', (events: ReactionEvent[]) => {
-    if (!st.handlers) return;
-    for (const event of events) {
-      const reaction = toReaction(st.account.id, event);
-      if (reaction) st.handlers.onReaction(reaction);
-    }
+  bindMessages(sock, {
+    accountId: st.account.id,
+    keys: st.keys,
+    names: st.names,
+    history: st.history,
+    current: () => !st.closed && st.sock === sock,
+    handlers: () => st.handlers,
+    self: () => selfRef(st, sock),
   });
 }
 
@@ -168,19 +156,22 @@ async function connect(st: State): Promise<void> {
     st.account.credentials,
     st.account.id,
   );
-  const { version, error } = await fetchLatestWaWebVersion({});
+  if (st.closed) return;
+  const { version, error } = await st.runtime.fetchVersion({});
+  if (st.closed) return;
   if (error) {
     throw new TrainError(
       'whatsapp_connect',
       `failed to fetch WhatsApp web version: ${errMsg(error)}`,
     );
   }
-  const sock = makeWASocket({
+  const sock = st.runtime.makeSocket({
     version,
     auth: state,
     browser: Browsers.macOS('Safari'),
     markOnlineOnConnect: false,
     syncFullHistory: false,
+    emitOwnEvents: false,
     logger: baileysLogger(st.account.id),
     getMessage: (key) => Promise.resolve(servedFromOutbox(st, key)),
   });
@@ -188,15 +179,25 @@ async function connect(st: State): Promise<void> {
   sock.ev.on('creds.update', () => void saveCreds());
   bindConnection(st, sock);
   bindInbound(st, sock);
+  st.channels.bind(sock, () => !st.closed && st.sock === sock);
+  st.expiry.bind(sock, () => !st.closed && st.sock === sock);
   bindDelivery(st, sock);
 }
-
+async function lidFor(st: State, sock: WASocket, jid: string): Promise<string | null> {
+  try {
+    return await sock.signalRepository.lidMapping.getLIDForPN(jid);
+  } catch (e) {
+    process.stderr.write(
+      `whatsapp[${st.account.id}] no lid on file for ${jid}: ${errMsg(e)}\n`,
+    );
+    return null;
+  }
+}
 async function ready(st: State): Promise<WASocket> {
   await st.openPromise;
-  if (!st.sock) throw new TrainError('whatsapp_call', 'socket not connected');
+  if (st.closed || !st.sock) throw new TrainError('whatsapp_call', 'socket not connected');
   return st.sock;
 }
-
 async function send(
   st: State,
   jid: string,
@@ -204,10 +205,13 @@ async function send(
   opts?: SendOpts,
 ): Promise<string> {
   const sock = await ready(st);
-  const sent = await sock.sendMessage(jid, content, opts);
-  st.keys.remember(sent?.key);
-  st.outbox.remember(sent?.key, sent?.message);
-  const messageId = sent?.key.id;
+  const expiration = await st.expiry.forSend(sock, jid, content);
+  if (st.closed || st.sock !== sock) throw new TrainError('whatsapp_call', 'socket not connected');
+  const sent = await sock.sendMessage(jid, content, expiration === undefined ? opts : { ...opts, ephemeralExpiration: expiration });
+  const key = sent?.key;
+  st.keys.remember(key);
+  st.outbox.remember(key, sent?.message);
+  const messageId = key?.id;
   if (!messageId)
     throw new TrainError(
       'whatsapp_call',
@@ -216,9 +220,15 @@ async function send(
   const ack = await st.acks.wait(messageId, ACK_WAIT_MS);
   const refused = ack ? rejection(ack) : undefined;
   if (refused) throw refused;
+  recordSent(st, sock, sent, expiration);
   return messageId;
 }
 
+function recordSent(st: State, sock: WASocket, sent: WAMessage | undefined, expiration?: number): void {
+  if (!sent || st.closed) return;
+  st.history.ingestSent([sent], sock.user?.id ? jidNormalizedUser(sock.user.id) : undefined, expiration);
+}
+
 function quotedOpts(st: State, jid: string, quotedId: string): SendOpts {
   return {
     quoted: {
@@ -244,16 +254,60 @@ function mediaContent(m: WAMedia): SendContent {
   };
 }
 
-export function createClient(account: WhatsAppAccount): WAClient {
+async function readProfile(st: State, jid: string): Promise<SenderProfile> {
+  const sock = await ready(st);
+  const [statuses, avatar] = await Promise.all([sock.fetchStatus(jid).catch(() => undefined), sock.profilePictureUrl(jid, 'image').catch(() => undefined)]);
+  const about = nonEmpty((statuses?.[0]?.status as { status?: unknown } | undefined)?.status);
+  const picture = nonEmpty(avatar);
+  const phone = phoneOf(jid.endsWith('@lid') ? await sock.signalRepository.lidMapping.getPNForLID(jid).catch(() => null) : jid);
+  const name = st.names.get(jid);
+  return {
+    id: jid,
+    ...(name === undefined ? {} : { display_name: name }),
+    ...(phone === undefined ? {} : { name: phone, address: phone }),
+    ...(about === undefined ? {} : { about }),
+    ...(picture === undefined ? {} : { avatar: picture }),
+  };
+}
+
+async function disconnect(st: State): Promise<void> {
+  st.closed = true;
+  st.openResolve?.();
+  try {
+    st.history.close();
+  } finally {
+    const sock = st.sock;
+    st.sock = undefined;
+    await sock?.end(undefined);
+  }
+}
+
+function initialState(account: WhatsAppAccount, runtime: ClientRuntime): State {
   const st: State = {
     account,
+    runtime,
+    history: createClientHistory(account.id),
+    expiry: new SendExpiry(account.id),
     closed: false,
     openPromise: Promise.resolve(),
     keys: makeKeyCache(),
     outbox: makeOutbox(),
     acks: makeAckWatch(),
+    names: makeNameBook(nameFiles.path(account.id)),
+    channels: new WhatsAppChannels(account.id),
   };
   resetGate(st);
+  return st;
+}
+
+export function createClient(
+  account: WhatsAppAccount,
+  runtime: ClientRuntime = { makeSocket: makeWASocket, fetchVersion: fetchLatestWaWebVersion },
+): WAClient {
+  const st = initialState(account, runtime);
+  const senders = makeProfileCache<SenderProfile>((jid) => readProfile(st, jid), {
+    onError: (jid, err) => process.stderr.write(`whatsapp[${st.account.id}] could not read the profile of ${jid}: ${errMsg(err)}\n`),
+  });
   return {
     account,
     self() {
@@ -271,6 +325,18 @@ export function createClient(account: WhatsAppAccount): WAClient {
         );
       }
     },
+    read(jid, options) {
+      const page = st.history.read(jid, options);
+      for (const message of page.messages) st.keys.remember(message.key);
+      return Promise.resolve(page);
+    },
+    listMembers(jid, limit) {
+      return listMembers(jid, async (node): Promise<unknown> => await (await ready(st)).query(node), st.names, limit);
+    },
+    listChannels(args) {
+      if (st.closed) return Promise.reject(new TrainError('whatsapp_call', 'socket not connected'));
+      return st.channels.list(() => ready(st), args);
+    },
     sendText(jid, text, quotedId) {
       return send(
         st,
@@ -287,6 +353,10 @@ export function createClient(account: WhatsAppAccount): WAClient {
         quotedId ? quotedOpts(st, jid, quotedId) : undefined,
       );
     },
+    async showTyping(jid) {
+      const sock = await ready(st);
+      await sock.sendPresenceUpdate('composing', jid);
+    },
     async sendReaction(jid, messageId, emoji) {
       const target = targetKey(st.keys, jid, messageId, 'react to');
       await send(st, jid, { react: { text: emoji, key: target } });
@@ -301,18 +371,30 @@ export function createClient(account: WhatsAppAccount): WAClient {
       await send(st, jid, {
         delete: knownKey(st.keys, jid, messageId, true),
       });
+      if (!st.closed) st.history.deleteMessages({ keys: [{ remoteJid: jid, id: messageId }] });
     },
     async reuploadMedia(m) {
       const sock = await ready(st);
       return sock.updateMediaMessage(m);
     },
-    async disconnect() {
-      st.closed = true;
-      try {
-        await st.sock?.end(undefined);
-      } catch {
-        st.sock = undefined;
+    async lookupSender(number) {
+      const sock = await ready(st);
+      const found = (await sock.onWhatsApp(number))?.[0];
+      if (found?.exists !== true) return { exists: false, jid: null, lid: null };
+      const jid = jidNormalizedUser(found.jid);
+      return { exists: true, jid, lid: await lidFor(st, sock, jid) };
+    },
+    async setProfile(change) {
+      const sock = await ready(st);
+      if (change.name !== undefined) await sock.updateProfileName(change.name);
+      if (change.bio !== undefined) await sock.updateProfileStatus(change.bio);
+      if (change.avatar !== undefined) {
+        const me = sock.user?.id;
+        if (me === undefined) throw new TrainError('whatsapp_call', 'own jid unknown');
+        await sock.updateProfilePicture(me, { url: change.avatar.path });
       }
     },
+    senderProfile: (jid) => senders.get(jid),
+    disconnect: () => st.closing ??= disconnect(st),
   };
 }