@stage-labs/metro 0.1.0-beta.32 → 0.1.0-beta.321

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

@@ -0,0 +1,52 @@
+import { TrainError } from '@metro-labs/core/train-error';
+
+const INTERNATIONAL = /^[1-9]\d{5,17}$/;
+
+export interface SenderFound {
+  exists: boolean;
+  jid: string | null;
+  lid: string | null;
+}
+
+export interface SenderLookup extends SenderFound {
+  query: string;
+  number: string;
+  id: string | null;
+}
+
+function refuse(query: string, why: string): never {
+  throw new TrainError('bad_request', `'${query}' ${why}`);
+}
+
+function international(query: string, digits: string): string {
+  if (digits.startsWith('00')) return digits.slice(2);
+  if (digits.startsWith('0'))
+    refuse(
+      query,
+      'is a national number, so metro cannot tell which country it is in; write it in full international form, as in 41791234567 for a Swiss 079 123 45 67',
+    );
+  return digits;
+}
+
+export function phoneNumberOf(raw: string): string {
+  const query = raw.trim();
+  if (query.toLowerCase().endsWith('@lid'))
+    refuse(query, 'is already a sender id, so add it directly instead of looking it up');
+  const local = query.split('@')[0] ?? '';
+  const digits = local.replace(/\D/g, '');
+  const number = local.startsWith('+') ? digits : international(query, digits);
+  if (!INTERNATIONAL.test(number))
+    refuse(query, 'is not a phone number metro can look up; write it in full international form, as in 41791234567');
+  return number;
+}
+
+export function senderLookup(query: string, number: string, found: SenderFound): SenderLookup {
+  return {
+    query: query.trim(),
+    number,
+    exists: found.exists,
+    jid: found.jid,
+    lid: found.lid,
+    id: found.lid ?? found.jid,
+  };
+}

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

@@ -0,0 +1,65 @@
+import type { ChatUpdate, WASocket } from 'baileys';
+import { errMsg, log } from '@metro-labs/core/log';
+import { isGroupJid, isPrivateJid } from './parse.js';
+
+const MAX_CHATS = 2000;
+type Content = Parameters<WASocket['sendMessage']>[1];
+interface Setting { duration: number; at: number }
+
+function duration(value: number | undefined): number | undefined {
+  return value !== undefined && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+
+function setting(chat: ChatUpdate): Setting | undefined {
+  if (!Object.hasOwn(chat, 'ephemeralExpiration')) return undefined;
+  const seconds = duration(chat.ephemeralExpiration === null ? 0 : chat.ephemeralExpiration);
+  const timestamp = chat.ephemeralSettingTimestamp;
+  const at = typeof timestamp === 'number' ? timestamp : timestamp?.toNumber();
+  if (seconds === undefined || at === undefined || !Number.isSafeInteger(at) || at <= 0) return undefined;
+  return { duration: seconds, at };
+}
+
+export class SendExpiry {
+  private readonly chats = new Map<string, Setting>();
+
+  constructor(private readonly accountId: string) {}
+
+  private note(chat: ChatUpdate): void {
+    if (!chat.id || !isPrivateJid(chat.id)) return;
+    const next = setting(chat);
+    if (!next) return;
+    const known = this.chats.get(chat.id);
+    if (known && known.at > next.at) return;
+    this.chats.delete(chat.id);
+    this.chats.set(chat.id, next);
+    if (this.chats.size > MAX_CHATS) {
+      const oldest = this.chats.keys().next().value;
+      if (oldest !== undefined) this.chats.delete(oldest);
+    }
+  }
+
+  bind(sock: WASocket, current: () => boolean): void {
+    this.chats.clear();
+    const note = (chats: readonly ChatUpdate[]): void => {
+      if (current()) for (const chat of chats) this.note(chat);
+    };
+    sock.ev.on('chats.upsert', note);
+    sock.ev.on('chats.update', note);
+    sock.ev.on('messaging-history.set', ({ chats }) => { note(chats); });
+    sock.ev.on('chats.delete', (jids) => {
+      if (current()) for (const jid of jids) this.chats.delete(jid);
+    });
+  }
+
+  async forSend(sock: WASocket, jid: string, content: Content): Promise<number | undefined> {
+    if ('edit' in content || 'delete' in content || 'react' in content) return undefined;
+    if (!isGroupJid(jid)) return this.chats.get(jid)?.duration;
+    try {
+      const group = await sock.groupMetadata(jid);
+      return duration(group.ephemeralDuration ?? 0);
+    } catch (err) {
+      log.warn({ accountId: this.accountId, err: errMsg(err) }, 'whatsapp: send expiry unknown; local history may omit the message');
+      return undefined;
+    }
+  }
+}

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

@@ -1,17 +1,42 @@
-import type { Station, Verb } from '@metro-labs/mcp/stations/types';
+import type { Station, Verb } from '@metro-labs/core/stations/types';
+import { PROFILE_FIELDS, type ProfileField } from '@metro-labs/core/stations/profile';
+import { tokenFiles } from './token-store.js';
+import { nameFiles } from './names.js';
+import { historyFiles } from './history-files.js';
+import { channelFiles } from './channel-chats.js';
 
 export const whatsappStation: Station = {
   name: 'whatsapp',
   hasAccounts: true,
   hasTrain: true,
   messageVerbs: new Set<Verb>([
+    'read',
     'send',
     'reply',
     'react',
     'unreact',
     'edit',
     'delete',
+    'typing',
   ]),
   attachmentMode: 'canonical',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
+  resolvesSenders: true,
+  discoversChannels: true,
+  reportsStatus: true,
+  pairAgain: { identity: 'phone' },
+  forget: (accountId) => {
+    tokenFiles.forget(accountId);
+    nameFiles.forget(accountId);
+    historyFiles.forget(accountId);
+    channelFiles.forget(accountId);
+  },
+  forgetExcept: (kept) => {
+    tokenFiles.forgetExcept(kept);
+    nameFiles.forgetExcept(kept);
+    historyFiles.forgetExcept(kept);
+    channelFiles.forgetExcept(kept);
+  },
   tools: [],
 };

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

@@ -1,7 +1,6 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { readJson, writeSecure } from '@metro-labs/mcp/secure-fs';
-import { errMsg } from '@metro-labs/mcp/log';
+import { readJson, writeSecure } from '@metro-labs/core/secure-fs';
+import { accountFiles } from '@metro-labs/core/stations/account-files';
+import { errMsg } from '@metro-labs/core/log';
 
 export const PERSISTED_KEY_TYPES = ['tctoken', 'lid-mapping'] as const;
 
@@ -14,12 +13,9 @@ const WRITE_DEBOUNCE_MS = 1000;
 export const isPersistedKeyType = (type: string): boolean =>
   PERSISTED.has(type);
 
-const safeSegment = (s: string): string => s.replace(/[^A-Za-z0-9_-]/g, '_');
+export const tokenFiles = accountFiles('WHATSAPP_TOKEN_DIR', 'whatsapp-tokens-');
 
-export function tokenStorePath(accountId: string): string {
-  const dir = process.env.WHATSAPP_TOKEN_DIR ?? join(homedir(), '.metro');
-  return join(dir, `whatsapp-tokens-${safeSegment(accountId)}.json`);
-}
+export const tokenStorePath = (accountId: string): string => tokenFiles.path(accountId);
 
 export function persistedSubset(table: KeyTable): KeyTable {
   const out: KeyTable = {};

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

@@ -1,6 +1,5 @@
 export interface WhatsAppAccount {
   id: string;
   phone: string;
-  owner?: string;
   credentials?: unknown;
 }

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

@@ -13,18 +13,19 @@
     "test": "tsc --noEmit && DYLD_FALLBACK_LIBRARY_PATH=/usr/lib bun test test/"
   },
   "dependencies": {
-    "@metro-labs/mcp": "workspace:*",
+    "@metro-labs/core": "workspace:*",
     "@xmtp/content-type-primitives": "^3.0.1",
     "@xmtp/content-type-reaction": "^2.0.2",
     "@xmtp/content-type-remote-attachment": "^2.0.4",
     "@xmtp/content-type-reply": "^2.0.3",
-    "@xmtp/content-type-wallet-send-calls": "^2.0.0",
     "@xmtp/node-bindings": "1.9.1",
     "@xmtp/node-sdk": "^6.0.0",
+    "@zerodev/ecdsa-validator": "5.4.9",
+    "@zerodev/sdk": "5.5.10",
     "viem": "^2.52.2"
   },
   "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/xmtp/src/accounts.ts

@@ -7,36 +7,25 @@ import { homedir } from 'node:os';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { CODECS } from './codecs.js';
-import { expandHome, signerFor, XMTP_ENV } from './identity.js';
+import { expandHome, identityFor, XMTP_ENV } from './identity.js';
+import type { SmartAccount } from './smart.js';
 import {
   makeAccountStore,
   resolveAccountId,
-} from '@metro-labs/mcp/stations/account-store';
-import { Line } from '@metro-labs/mcp/lines';
-
-const ACCOUNTS_FILE =
-  process.env.XMTP_ACCOUNTS_FILE ??
-  join(homedir(), '.metro', 'xmtp-accounts.json');
+} from '@metro-labs/core/stations/account-store';
+import { Line } from '@metro-labs/core/lines';
 
 export interface AccountConfig {
   id: string;
   privateKey?: string;
-  owner?: string;
   dbPath?: string;
+  smart?: boolean;
 }
 
 export const { loadAccounts } = makeAccountStore<AccountConfig>({
   prefix: 'xmtp',
-  file: ACCOUNTS_FILE,
-  allowlistEnv: ['XMTP_ONLY_ACCOUNTS', 'XMTP_ACCOUNTS'],
   validate(raw, die) {
-    const seen = new Set<string>();
-    for (const a of raw) {
-      if (!a.id) die('account missing id');
-      if (!a.privateKey) die(`account '${a.id}' needs a privateKey`);
-      if (seen.has(a.id)) die(`duplicate account id '${a.id}'`);
-      seen.add(a.id);
-    }
+    for (const a of raw) if (!a.privateKey) die(`account '${a.id}' needs a privateKey`);
   },
 });
 
@@ -51,25 +40,26 @@ export interface Account {
   client: Client<unknown>;
   inboxId: string;
   address: string;
+  smart: SmartAccount | null;
 }
 export const accounts = new Map<string, Account>();
 
 export async function bootAccount(cfg: AccountConfig): Promise<void> {
-  const { signer, address } = signerFor(resolvePrivateKey(cfg));
+  const { signer, address, smart } = await identityFor(resolvePrivateKey(cfg), cfg.smart === true);
   const dbPath = expandHome(
     cfg.dbPath ?? join(homedir(), '.metro', `xmtp-${XMTP_ENV}-${cfg.id}.db3`),
   );
   const fresh = !existsSync(dbPath);
   const options: ClientOptions = { env: XMTP_ENV, codecs: CODECS(), dbPath };
   const client: Client<unknown> = await Client.create(signer, options);
-  accounts.set(cfg.id, { cfg, client, inboxId: client.inboxId, address });
+  accounts.set(cfg.id, { cfg, client, inboxId: client.inboxId, address, smart });
   if (fresh)
     process.stderr.write(
       `xmtp[${cfg.id}] registered a NEW installation for this machine — ` +
         'an inbox allows 10, and each machine you run metro on spends one\n',
     );
   process.stderr.write(
-    `xmtp[${cfg.id}] ready — inbox ${client.inboxId} (${address}, owner=${cfg.owner ?? '(broadcast)'})\n`,
+    `xmtp[${cfg.id}] ready — inbox ${client.inboxId} (${address})\n`,
   );
 }
 

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

@@ -1,6 +1,6 @@
-import { errMsg } from '@metro-labs/mcp/log';
+import { errMsg } from '@metro-labs/core/log';
 import { accountForCall, convOf, lineOf, type Account } from './accounts.js';
-import { respond } from './wire.js';
+import { respond } from '@metro-labs/core/stations/station-runtime';
 import type { GroupLike } from './labels.js';
 
 type Args = Record<string, unknown>;

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

@@ -1,25 +1,11 @@
-import { IdentifierKind } from '@xmtp/node-sdk';
+import { IdentifierKind, type DecodedMessage } from '@xmtp/node-sdk';
+import { accountForCall, convOf, lineOf, type Account } from './accounts.js';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { resolveMsgId } from './wire.js';
+import { serializeTrainError, TrainError } from '@metro-labs/core/train-error';
 import {
-  accounts,
-  accountForCall,
-  convOf,
-  lineOf,
-  parseLine,
-  type Account,
-} from './accounts.js';
-import { respond } from './wire.js';
-import { TrainError } from '@metro-labs/mcp/train-error';
-import { pushHandlers } from './actions-push.js';
-import { cleanLabels, labelsBlob } from './labels.js';
-import {
-  applyMemberOp,
   buildGroupInfo,
   buildMemberList,
-  createGroupWithMembers,
-  ethIdentifiers,
-  parseMemberArgs,
-  resolveMembers,
-  warmGroupName,
 } from './conv-helpers.js';
 import { closeGroup } from './actions-close.js';
 import {
@@ -27,17 +13,14 @@ import {
   groupCreate,
   groupRemoveMembers,
 } from './group.js';
-import {
-  updateChannelMeta,
-  applyChannelMeta,
-  resolveLine,
-  setGithub,
-  setPreview,
-} from './actions-meta.js';
+import { updateChannelMeta } from './actions-meta.js';
+import { deletedByRequests, isDeleteRequest, superAdminCheck } from './delete-requests.js';
+import { isCallSignal } from './codecs.js';
+import { syncConversation } from './network.js';
+import { readAttachments } from './read-attachments.js';
 
 type Args = Record<string, unknown>;
 type Handler = (id: string, args: Args) => Promise<void>;
-type Conv = Awaited<ReturnType<typeof convOf>>['conv'] & object;
 
 async function newDm(id: string, args: Args): Promise<void> {
   const { address } = args as { address: string };
@@ -55,153 +38,63 @@ async function newDm(id: string, args: Args): Promise<void> {
   });
 }
 
-async function newGroup(id: string, args: Args): Promise<void> {
-  const { addresses, name, permissions } = args as {
-    addresses: string[];
-    name?: string;
-    permissions?: 'admin-only' | 'default';
-  };
-  const acct = accountForCall(args);
-  const opts: { groupName?: string; permissions?: number } = {};
-  if (name) opts.groupName = name;
-  if (permissions === 'admin-only') opts.permissions = 1;
-  const group = await acct.client.conversations.createGroupWithIdentifiers(
-    ethIdentifiers(addresses),
-    opts,
-  );
-  warmGroupName(group.id, name);
-  respond(id, {
-    result: {
-      line: lineOf(acct.cfg.id, group.id),
-      id: group.id,
-      account: acct.cfg.id,
-    },
-  });
+function upTo<T extends { id: string }>(all: T[], before: string | undefined): T[] {
+  if (!before) return all;
+  const target = resolveMsgId(before);
+  const at = all.findIndex((m) => m.id === target);
+  if (at < 0) throw new TrainError('NOT_FOUND', `message ${before} is not in this conversation`);
+  return all.slice(0, at);
 }
 
-async function createRequestGroup(id: string, args: Args): Promise<void> {
-  const { name, description, labels } = args as {
-    name: string;
-    description?: string;
-    labels?: string[];
-  };
-  const acct = accountForCall(args);
-  if (!name || typeof name !== 'string')
-    throw new TrainError('INVALID_ARGS', 'createRequestGroup requires a `name`');
-  const { addrs, inboxes } = resolveMembers(args);
-  if (addrs.length === 0 && inboxes.length === 0)
-    throw new TrainError(
-      'INVALID_ARGS',
-      'createRequestGroup requires addresses[] or inboxIds[]',
-    );
-  const opts: {
-    groupName: string;
-    groupDescription?: string;
-    appData?: string;
-  } = { groupName: name };
-  if (description) opts.groupDescription = description;
-  if (Array.isArray(labels) && labels.length)
-    opts.appData = labelsBlob(undefined, labels);
-
-  const group = await createGroupWithMembers(acct, addrs, inboxes, opts);
-  warmGroupName(group.id, name);
-  respond(id, {
-    result: {
-      line: lineOf(acct.cfg.id, group.id),
-      id: group.id,
-      account: acct.cfg.id,
-      name,
-      description: description ?? '',
-      labels: cleanLabels(labels ?? []),
-    },
-  });
+function textOf(m: DecodedMessage): string {
+  try {
+    const cc: unknown = m.content;
+    return typeof cc === 'string' ? cc : `[${m.contentType?.typeId ?? 'unknown'}]`;
+  } catch {
+    return `[${m.contentType?.typeId ?? 'unknown'}]`;
+  }
 }
 
-async function setLabels(id: string, args: Args): Promise<void> {
-  const { labels, setName, setDescription, setGithub } = args as {
-    line?: string;
-    groupId?: string;
-    labels: string[];
-    setName?: string;
-    setDescription?: string;
-    setGithub?: string;
+const DELETED = { text: '[deletedMessage]', contentType: 'deletedMessage' };
+
+function messageOf(acct: Account, m: DecodedMessage, deleted: Set<string>): Record<string, unknown> {
+  return {
+    id: m.id,
+    ts: new Date(Number(m.sentAtNs / 1_000_000n)).toISOString(),
+    from: `metro://xmtp/${acct.cfg.id}/user/${m.senderInboxId}`,
+    ...(m.senderInboxId === acct.inboxId ? { self: true } : {}),
+    ...(deleted.has(m.id) ? DELETED : { text: textOf(m), contentType: m.contentType?.typeId ?? 'unknown' }),
   };
-  const resolvedLine = resolveLine(args, 'setLabels');
-  if (!Array.isArray(labels))
-    throw new TrainError('INVALID_ARGS', 'setLabels requires a `labels` array');
-  const appData: Record<string, unknown> = { labels };
-  if (typeof setGithub === 'string') appData.github = setGithub;
-  const result = await applyChannelMeta(
-    { line: resolvedLine, name: setName, description: setDescription, appData },
-    'setLabels',
-  );
-  respond(id, {
-    result: {
-      line: result.line,
-      id: result.id,
-      account: result.account,
-      labels: result.labels,
-    },
-  });
 }
 
-async function query(id: string, args: Args): Promise<void> {
-  const { line, limit } = args as { line: string; limit?: number };
-  const { conv } = await convOf(line);
+async function read(id: string, args: Args): Promise<void> {
+  const { line, limit, before, messageId } = args as { line: string; limit?: number; before?: string; messageId?: string };
+  const { acct, conv } = await convOf(line);
   if (!conv)
     throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
-  const lim = Math.min(Math.max(1, limit ?? 20), 200);
-  await conv.sync().catch(() => undefined);
+  await syncConversation(acct.client, conv);
   const all = await conv.messages();
-  const slice = all.slice(-lim);
-  const parsed = parseLine(line);
-  if (!parsed)
-    throw new TrainError('NOT_FOUND', `could not parse line ${line}`);
-  const acctId = parsed.accountId;
-  const messages = slice.map((m) => {
-    let text = '';
+  if (messageId) {
+    const target = resolveMsgId(messageId);
+    const message = acct.client.conversations.getMessageById(target);
+    if (message?.conversationId !== conv.id || isDeleteRequest(message) || isCallSignal(message))
+      throw new TrainError('NOT_FOUND', `message ${messageId} is not in this conversation`);
+    const deleted = deletedByRequests([...all, message], superAdminCheck(conv));
     try {
-      const cc: unknown = m.content;
-      text =
-        typeof cc === 'string' ? cc : `[${m.contentType?.typeId ?? 'unknown'}]`;
-    } catch {
-      text = `[${m.contentType?.typeId ?? 'unknown'}]`;
+      const attachments = deleted.has(message.id) ? [] : await readAttachments(message);
+      respond(id, { result: { line, account: acct.cfg.id, message: { ...messageOf(acct, message, deleted), attachments } } });
+    } catch (error) {
+      respond(id, serializeTrainError(error));
     }
-    return {
-      id: m.id,
-      ts: new Date(Number(m.sentAtNs / 1_000_000n)).toISOString(),
-      from: `metro://xmtp/${acctId}/user/${m.senderInboxId}`,
-      text,
-      contentType: m.contentType?.typeId ?? 'unknown',
-    };
-  });
+    return;
+  }
+  const lim = Math.min(Math.max(1, limit ?? 20), 200);
+  const deleted = deletedByRequests(all, superAdminCheck(conv));
+  const slice = upTo(all.filter((m) => !isDeleteRequest(m) && !isCallSignal(m)), before).slice(-lim);
+  const messages = slice.map((m) => messageOf(acct, m, deleted));
   respond(id, { result: { line, count: messages.length, messages } });
 }
 
-async function addMembers(id: string, args: Args): Promise<void> {
-  const { line, addrs, inboxes } = parseMemberArgs(args, 'addMembers');
-  const { acct, conv } = await convOf(line);
-  if (!conv)
-    throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
-  await applyMemberOp(conv, addrs, inboxes, 'add');
-  const info = await buildGroupInfo(line, acct, conv);
-  respond(id, {
-    result: { ...info, added: { addresses: addrs, inboxIds: inboxes } },
-  });
-}
-
-async function removeMembers(id: string, args: Args): Promise<void> {
-  const { line, addrs, inboxes } = parseMemberArgs(args, 'removeMembers');
-  const { acct, conv } = await convOf(line);
-  if (!conv)
-    throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
-  await applyMemberOp(conv, addrs, inboxes, 'remove');
-  const info = await buildGroupInfo(line, acct, conv);
-  respond(id, {
-    result: { ...info, removed: { addresses: addrs, inboxIds: inboxes } },
-  });
-}
-
 async function groupInfo(id: string, args: Args): Promise<void> {
   const { line } = args as { line: string };
   const { acct, conv } = await convOf(line);
@@ -212,80 +105,19 @@ async function groupInfo(id: string, args: Args): Promise<void> {
 
 async function listMembers(id: string, args: Args): Promise<void> {
   const { line } = args as { line: string };
-  const { acct, conv } = await convOf(line);
+  const { conv } = await convOf(line);
   if (!conv)
     throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
-  respond(id, { result: await buildMemberList(acct, conv) });
-}
-
-async function summarizeConv(acct: Account, c: Conv): Promise<unknown> {
-  const recent = await c.messages({ limit: 1, direction: 1 }).catch(() => []);
-  const last = recent[0];
-  let preview = '';
-  if (last) {
-    const cc: unknown = last.content;
-    preview =
-      typeof cc === 'string'
-        ? cc.slice(0, 80)
-        : `[${last.contentType?.typeId ?? 'unknown'}]`;
-  }
-  const isDm =
-    typeof (c as unknown as { peerInboxId?: unknown }).peerInboxId ===
-    'function';
-  const gn = (c as unknown as { name?: string | (() => Promise<string>) }).name;
-  const resolvedName =
-    typeof gn === 'function' ? await gn().catch(() => '') : (gn ?? '');
-  return {
-    line: lineOf(acct.cfg.id, c.id),
-    id: c.id,
-    account: acct.cfg.id,
-    version: isDm ? 'dm' : 'group',
-    name: resolvedName ?? '',
-    lastTs: last
-      ? new Date(Number(last.sentAtNs / 1_000_000n)).toISOString()
-      : null,
-    lastPreview: preview,
-  };
-}
-
-async function listConvs(id: string, args: Args): Promise<void> {
-  const { limit, account } = args as { limit?: number; account?: string };
-  const lim = Math.min(Math.max(1, limit ?? 50), 200);
-  const targets = account
-    ? [accounts.get(account)].filter((a): a is Account => a !== undefined)
-    : [...accounts.values()];
-  const summaries: unknown[] = [];
-  for (const acct of targets) {
-    await acct.client.conversations.syncAll();
-    const all = await acct.client.conversations.list();
-    for (const c of all.slice(0, lim))
-      summaries.push(await summarizeConv(acct, c));
-  }
-  summaries.sort((a, b) =>
-    ((b as { lastTs?: string }).lastTs ?? '').localeCompare(
-      (a as { lastTs?: string }).lastTs ?? '',
-    ),
-  );
-  respond(id, {
-    result: { count: summaries.length, conversations: summaries.slice(0, lim) },
-  });
+  respond(id, { result: await buildMemberList(conv) });
 }
 
 export const convHandlers: Record<string, Handler> = {
   newDm,
-  newGroup,
-  createRequestGroup,
-  addMembers,
-  removeMembers,
-  setLabels,
-  setGithub,
-  setPreview,
   updateChannelMeta,
   closeGroup,
-  query,
+  read,
   groupInfo,
   listMembers,
-  listConvs,
   groupCreate: async (id, args) => {
     respond(id, { result: await groupCreate(args) });
   },
@@ -295,5 +127,4 @@ export const convHandlers: Record<string, Handler> = {
   groupRemoveMembers: async (id, args) => {
     respond(id, { result: await groupRemoveMembers(args) });
   },
-  ...pushHandlers,
 };