@stage-labs/metro 0.1.0-beta.263 → 0.1.0-beta.264

package/dist/runtime-install.js

@@ -1,7 +1,7 @@
 import { spawnSync } from 'node:child_process';
 import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { localStations } from './local.js';
 import { STORE_ENTRY, daemonEntry, findBun, runtimeDir } from './runtime.js';
 const MANIFEST_FILE = 'stations.json';
@@ -24,6 +24,7 @@ export function readManifest(path) {
     return {
         core: ranges(raw.core),
         stations: Object.fromEntries(Object.entries(stations).map(([name, deps]) => [name, ranges(deps)])),
+        ...(raw.patchedDependencies === undefined ? {} : { patchedDependencies: ranges(raw.patchedDependencies) }),
     };
 }
 export function dependenciesFor(manifest, stations) {
@@ -32,7 +33,19 @@ export function dependenciesFor(manifest, stations) {
         Object.assign(out, manifest.stations[station] ?? {});
     return Object.fromEntries(Object.entries(out).sort(([a], [b]) => a.localeCompare(b)));
 }
-const packageText = (deps) => `${JSON.stringify({ name: 'metro-runtime', private: true, dependencies: deps }, null, 2)}\n`;
+function packageText(deps, patches) {
+    const patchedDependencies = Object.fromEntries(Object.entries(deps).flatMap(([name, version]) => {
+        const key = `${name}@${version}`;
+        const path = patches[key];
+        return path === undefined ? [] : [[key, path]];
+    }));
+    return `${JSON.stringify({
+        name: 'metro-runtime',
+        private: true,
+        dependencies: deps,
+        ...(Object.keys(patchedDependencies).length === 0 ? {} : { patchedDependencies }),
+    }, null, 2)}\n`;
+}
 export function readOrNull(path) {
     try {
         return readFileSync(path, 'utf8');
@@ -63,8 +76,8 @@ function syncSources(sources, store) {
         writeFileSync(join(store, 'runtime.json'), stamp);
     return true;
 }
-export function installDependencies(store, deps, bun, log) {
-    const wanted = packageText(deps);
+export function installDependencies(store, deps, bun, log, patches = {}) {
+    const wanted = packageText(deps, patches);
     const marker = join(store, 'node_modules', '.metro-installed');
     if (existsSync(marker) && readOrNull(join(store, 'package.json')) === wanted)
         return false;
@@ -92,6 +105,10 @@ export function prepareRuntime(opts = {}) {
         });
     mkdirSync(join(store, 'trains'), { recursive: true });
     syncSources(sources, store);
-    installDependencies(store, dependenciesFor(manifest, localStations(opts.agents)), opts.bun ?? findBun(), log);
+    for (const path of Object.values(manifest.patchedDependencies ?? {})) {
+        mkdirSync(dirname(join(store, path)), { recursive: true });
+        copyFileSync(join(sources, path), join(store, path));
+    }
+    installDependencies(store, dependenciesFor(manifest, localStations(opts.agents)), opts.bun ?? findBun(), log, manifest.patchedDependencies);
     return { dir: store, entry: daemonEntry(store), trains: join(store, 'trains'), manifest: manifestPath };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.263",
+  "version": "0.1.0-beta.264",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.263",
+  "version": "0.1.0-beta.264",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

package/runtime/marketplace/plugin/bin/policy.mjs

@@ -36,7 +36,7 @@ function targets(snap, name, input) {
   if (Array.isArray(snap.ungated) && snap.ungated.includes(name)) return [];
   const account = text(input.account);
   const line = text(input[LINE_FIELD[name] ?? 'line']);
-  if (line) return fromLine(line, name in LINE_FIELD ? '' : account);
+  if (line) return fromLine(line, name in LINE_FIELD || name === 'list_members' ? '' : account);
   const owners = isRecord(snap.owners) ? snap.owners : {};
   const station = (STATION_ARG.has(name) ? text(input.station) : text(owners[name])) || (account ? stationOfAccount(snap, account) : undefined);
   if (!station) return [];

package/runtime/node_modules/@metro-labs/core/src/stations/train-boot.ts

@@ -1,4 +1,4 @@
-import { errMsg } from '../log.js';
+import { errMsg, logFatalSync } from '../log.js';
 import { readCalls } from '../protocol.js';
 import { TrainError } from '../train-error.js';
 import type { CallMsg } from './station-runtime.js';
@@ -18,12 +18,33 @@ export interface ClientTrain<A extends { id: string }, C> {
   loadAccounts: () => A[];
   createClient: (account: A) => C;
   startInbound: (client: C) => Promise<void>;
+  disconnectClient?: (client: C) => Promise<void>;
   makeHandleCall: (clientFor: (accountId: string) => C) => (msg: CallMsg) => Promise<void>;
 }
 
 export function runClientTrain<A extends { id: string }, C>(train: ClientTrain<A, C>): void {
   const clients = new Map<string, C>();
+  let stopping = false;
+  if (train.disconnectClient) {
+    const disconnect = train.disconnectClient;
+    const shutdown = (): void => {
+      if (stopping) return;
+      stopping = true;
+      process.stdin.pause();
+      Promise.allSettled([...clients.values()].map(async (client) => { await disconnect(client); })).then((results) => {
+        const errors = results.flatMap((result) => result.status === 'rejected' ? [errMsg(result.reason)] : []);
+        if (errors.length) logFatalSync({ station: train.station, errors }, 'train: shutdown failed');
+        process.exit(errors.length ? 1 : 0);
+      }).catch((err: unknown) => {
+        logFatalSync({ station: train.station, err: errMsg(err) }, 'train: shutdown failed');
+        process.exit(1);
+      });
+    };
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+  }
   const clientFor = (accountId: string): C => {
+    if (stopping) throw new TrainError('train_stopping', `${train.station} is shutting down`);
     const known = clients.get(accountId);
     if (known !== undefined) return known;
     const account = train.accounts.get(accountId);

package/runtime/node_modules/@metro-labs/daemon/src/mcp/policy-gate.ts

@@ -13,9 +13,9 @@ type ChannelTarget = Extract<PolicyTarget, { kind: 'channel' }>;
 
 export const UNGATED = new Set<string>(['list_accounts', 'create_upload']);
 
-function fromLine(line: string, override: string | undefined): ChannelTarget[] {
+function fromLine(line: string, override = ''): ChannelTarget[] {
   const acct = accountFromLine(line);
-  return acct === undefined ? [] : [{ kind: 'channel', station: acct.station, account: override ?? acct.accountId }];
+  return acct === undefined ? [] : [{ kind: 'channel', station: acct.station, account: override || acct.accountId }];
 }
 
 function channelTargets(name: string, a: Record<string, unknown>): ChannelTarget[] {
@@ -26,7 +26,7 @@ function channelTargets(name: string, a: Record<string, unknown>): ChannelTarget
   }
   const account = str(a.account);
   const line = str(a.line);
-  if (line) return fromLine(line, account || undefined);
+  if (line) return fromLine(line, name === 'list_members' ? undefined : account);
   const station = stationForTool(name, a) ?? (account ? stationOfAccount(account) : undefined);
   if (station === undefined) return [];
   if (account) return [{ kind: 'channel', station, account }];

package/runtime/node_modules/@metro-labs/daemon/src/stations/runtime-deps.ts

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { log } from '@metro-labs/core/log';
 import { isRecord } from '@metro-labs/core/is-record';
@@ -11,6 +11,7 @@ const INSTALL_TIMEOUT_MS = 15 * 60_000;
 export interface RuntimeManifest {
   core: Record<string, string>;
   stations: Record<string, Record<string, string>>;
+  patchedDependencies?: Record<string, string>;
 }
 
 export interface RuntimeStore {
@@ -30,6 +31,7 @@ export function readManifest(path: string): RuntimeManifest {
   return {
     core: ranges(raw.core),
     stations: Object.fromEntries(Object.entries(stations).map(([name, deps]) => [name, ranges(deps)])),
+    ...(raw.patchedDependencies === undefined ? {} : { patchedDependencies: ranges(raw.patchedDependencies) }),
   };
 }
 
@@ -46,8 +48,21 @@ export function dependenciesFor(manifest: RuntimeManifest, stations: Iterable<st
   return Object.fromEntries(Object.entries(out).sort(([a], [b]) => a.localeCompare(b)));
 }
 
-const packageText = (deps: Record<string, string>): string =>
-  `${JSON.stringify({ name: 'metro-runtime', private: true, dependencies: deps }, null, 2)}\n`;
+function packageText(deps: Record<string, string>, patches: Record<string, string>): string {
+  const patchedDependencies = Object.fromEntries(
+    Object.entries(deps).flatMap(([name, version]) => {
+      const key = `${name}@${version}`;
+      const path = patches[key];
+      return path === undefined ? [] : [[key, path]];
+    }),
+  );
+  return `${JSON.stringify({
+    name: 'metro-runtime',
+    private: true,
+    dependencies: deps,
+    ...(Object.keys(patchedDependencies).length === 0 ? {} : { patchedDependencies }),
+  }, null, 2)}\n`;
+}
 
 function current(dir: string): string | null {
   try {
@@ -58,9 +73,10 @@ function current(dir: string): string | null {
 }
 
 export function installRuntime(store: RuntimeStore, stations: Iterable<string>): boolean {
-  const wanted = packageText(dependenciesFor(store.manifest, stations));
-  const installed = existsSync(join(store.dir, 'node_modules', '.metro-installed'));
-  if (installed && current(store.dir) === wanted) return false;
+  const wanted = packageText(dependenciesFor(store.manifest, stations), store.manifest.patchedDependencies ?? {});
+  const marker = join(store.dir, 'node_modules', '.metro-installed');
+  if (existsSync(marker) && current(store.dir) === wanted) return false;
+  rmSync(marker, { force: true });
   mkdirSync(store.dir, { recursive: true });
   writeFileSync(join(store.dir, 'package.json'), wanted);
   log.info({ dir: store.dir }, 'runtime: installing the channel SDKs this machine needs');
@@ -71,7 +87,7 @@ export function installRuntime(store: RuntimeStore, stations: Iterable<string>):
   });
   if (run.error !== undefined || run.status !== 0)
     throw new Error(`bun install failed in ${store.dir}: ${run.error?.message ?? `exit ${String(run.status)}`}`);
-  writeFileSync(join(store.dir, 'node_modules', '.metro-installed'), `${new Date().toISOString()}\n`);
+  writeFileSync(marker, `${new Date().toISOString()}\n`);
   return true;
 }
 

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

@@ -8,7 +8,7 @@ import {
   type StationHandler,
 } from '@metro-labs/core/stations/station-runtime';
 import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
-import { accountFor, accounts, targetOf } from './accounts.js';
+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';
@@ -117,6 +117,35 @@ 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 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);
@@ -208,6 +237,8 @@ export function makeHandleCall(
     handlers: {
       accounts: makeAccounts(clientFor),
       send: makeSend(clientFor),
+      read: makeRead(clientFor),
+      listMembers: makeListMembers(clientFor),
       react: makeReact(clientFor),
       typing: makeTyping(clientFor),
       edit: makeEdit(clientFor),

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/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. Restart the Metro service parent to install the patched runtime; a page Restart is not enough. 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,46 @@
+import type makeWASocket from 'baileys';
+import type { fetchLatestWaWebVersion, WAMessage } from 'baileys';
+import type { MemberList } from '@metro-labs/core/stations/types';
+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>;
+  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

@@ -11,13 +11,17 @@ import makeWASocket, {
 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 type { SenderFound } from './resolve.js';
-import type { ProfileChange } from '@metro-labs/core/stations/profile';
+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 { toInbound, toReaction, type ReactionEvent, type SelfRef } from './parse.js';
+import type { SelfRef } from './parse.js';
+import type { History } from './history.js';
+import { createClientHistory } from './client-history.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, noteContact, phoneOf, type NameBook } from './names.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';
@@ -30,41 +34,15 @@ 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>;
-  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>;
-}
-
 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;
@@ -91,32 +69,14 @@ function selfRef(st: State, sock: WASocket): SelfRef {
 }
 
 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, selfRef(st, sock));
-      if (inbound) st.names.note(inbound.senderJid, inbound.pushName);
-      if (inbound) st.handlers.onMessage(inbound, m);
-    }
-  });
-  sock.ev.on('contacts.upsert', (contacts) => {
-    for (const c of contacts) noteContact(st.names, c);
-  });
-  sock.ev.on('contacts.update', (contacts) => {
-    for (const c of contacts) noteContact(st.names, c);
-  });
-  sock.ev.on('messaging-history.set', ({ contacts, messages }) => {
-    for (const c of contacts) noteContact(st.names, c);
-    for (const m of messages) if (m.key.fromMe !== true) st.names.note(m.key.participant ?? m.key.remoteJid, m.pushName);
-  });
-  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),
   });
 }
 
@@ -197,19 +157,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)),
   });
@@ -217,6 +180,7 @@ async function connect(st: State): Promise<void> {
   sock.ev.on('creds.update', () => void saveCreds());
   bindConnection(st, sock);
   bindInbound(st, sock);
+  st.expiry.bind(sock, () => !st.closed && st.sock === sock);
   bindDelivery(st, sock);
 }
 
@@ -233,7 +197,7 @@ async function lidFor(st: State, sock: WASocket, jid: string): Promise<string |
 
 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;
 }
 
@@ -244,10 +208,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',
@@ -256,9 +223,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: {
@@ -300,9 +273,24 @@ async function readProfile(st: State, jid: string): Promise<SenderProfile> {
   };
 }
 
-export function createClient(account: WhatsAppAccount): WAClient {
+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(),
@@ -311,6 +299,14 @@ export function createClient(account: WhatsAppAccount): WAClient {
     names: makeNameBook(nameFiles.path(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`),
   });
@@ -331,6 +327,14 @@ 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);
+    },
     sendText(jid, text, quotedId) {
       return send(
         st,
@@ -365,6 +369,7 @@ 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);
@@ -388,13 +393,6 @@ export function createClient(account: WhatsAppAccount): WAClient {
       }
     },
     senderProfile: (jid) => senders.get(jid),
-    async disconnect() {
-      st.closed = true;
-      try {
-        await st.sock?.end(undefined);
-      } catch {
-        st.sock = undefined;
-      }
-    },
+    disconnect: () => st.closing ??= disconnect(st),
   };
 }