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

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

@@ -1,27 +1,31 @@
-import { ReactionAction, ReactionSchema } from '@xmtp/node-sdk';
+import {
+  GroupMessageKind,
+  ReactionAction,
+  ReactionSchema,
+  type Conversation,
+} from '@xmtp/node-sdk';
 import type { Reply } from '@xmtp/node-bindings';
 import {
   AttachmentCodec,
   type Attachment,
 } from '@xmtp/content-type-remote-attachment';
-import {
-  WalletSendCallsCodec,
-  type WalletSendCallsParams,
-} from '@xmtp/content-type-wallet-send-calls';
-import { toHex } from 'viem';
-import { convOf } from './accounts.js';
-import { resolveMsgId, respond } from './wire.js';
+import type { EncodedContent } from '@xmtp/content-type-primitives';
+import { convOf, type Account } from './accounts.js';
+import { resolveMsgId } from './wire.js';
 import { emitOutbound } from './emit.js';
-import {
-  PollCodec,
-  buildPollContent,
-  SignatureRequestCodec,
-  type SignatureRequestContent,
-} from './codecs.js';
+import { CallSignalCodec, FrameCodec, PollCodec, buildPollContent, encodeDeleteMessage } from './codecs.js';
+import { buildFrameContent } from './frames.js';
+import { buildWalletContent } from './wallet.js';
+import { network } from './network.js';
+import { callLeftovers } from './call-leftovers.js';
 import { convHandlers } from './actions-conv.js';
-import { normalizeXmtp } from '@metro-labs/mcp/stations/messaging-normalize';
-import { TrainError } from '@metro-labs/mcp/train-error';
-import { makeStation, type CallMsg } from '@metro-labs/mcp/stations/station-runtime';
+import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
+import { TrainError } from '@metro-labs/core/train-error';
+import { claimNameAction, nameAction, setProfile } from './profile.js';
+import { profileAction } from './sender.js';
+import { resolveSenderAction } from './resolve.js';
+import { listChannels } from './channels.js';
+import { makeStation, respond, type CallMsg } from '@metro-labs/core/stations/station-runtime';
 
 type Args = Record<string, unknown>;
 
@@ -30,78 +34,73 @@ const noConv = (line: string): TrainError =>
 const badArgs = (message: string): TrainError =>
   new TrainError('INVALID_ARGS', message);
 
+function framePart(raw: unknown): { encoded: EncodedContent; summary: string } {
+  const built = buildFrameContent(raw);
+  return { encoded: new FrameCodec().encode(built.frame), summary: `Frame: ${built.title}` };
+}
+
 async function send(id: string, args: Args): Promise<void> {
   const { line, text } = args as { line: string; text: string };
+  const parts = [
+    ...(args.frame === undefined ? [] : [framePart(args.frame)]),
+    ...(args.wallet === undefined ? [] : [buildWalletContent(args.wallet)]),
+  ];
   const { acct, conv } = await convOf(line);
   if (!conv) throw noConv(line);
-  const messageId = await conv.sendText(text);
-  emitOutbound(acct.cfg.id, line, messageId, text);
+  let messageId: string | undefined;
+  if (text || parts.length === 0) {
+    messageId = await conv.sendText(text);
+    emitOutbound(acct.cfg.id, line, messageId, text);
+  }
+  for (const part of parts) {
+    messageId = await conv.send(part.encoded);
+    emitOutbound(acct.cfg.id, line, messageId, part.summary);
+  }
   respond(id, { result: { messageId } });
 }
 
 async function ask(id: string, args: Args): Promise<void> {
-  const { line, pollId } = args as { line: string; pollId?: string };
+  const { line } = args as { line: string };
   const { acct, conv } = await convOf(line);
   if (!conv) throw noConv(line);
-  const fallbackId = `poll_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-  const mintedId =
-    pollId ??
-    (typeof crypto?.randomUUID === 'function'
-      ? crypto.randomUUID()
-      : fallbackId);
+  const mintedId = crypto.randomUUID();
   const { poll, title } = buildPollContent(args, mintedId);
   const sentId = await conv.send(new PollCodec().encode(poll));
   emitOutbound(acct.cfg.id, line, sentId, `📊 Poll: ${title}`);
   respond(id, { result: { messageId: sentId, pollId: mintedId } });
 }
 
+async function referenceInboxOf(conv: Conversation, xmtpMsgId: string): Promise<string> {
+  const recent = await conv.messages({ limit: 200, direction: 1 });
+  const inbox = recent.find((m) => m.id === xmtpMsgId)?.senderInboxId;
+  if (!inbox)
+    throw new TrainError('NOT_FOUND', `could not resolve referenceInboxId for ${xmtpMsgId}`);
+  return inbox;
+}
+
 async function react(id: string, args: Args): Promise<void> {
-  const {
-    line,
-    messageId,
-    emoji,
-    action: reactAction,
-    schema: reactSchema,
-  } = args as {
+  const { line, messageId, emoji, action: reactAction } = args as {
     line: string;
     messageId: string;
     emoji: string;
     action?: 'added' | 'removed';
-    schema?: string;
-    referenceInboxId?: string;
   };
   const { acct, conv } = await convOf(line);
   if (!conv) throw noConv(line);
   const xmtpMsgId = resolveMsgId(messageId);
-  let refInbox = (args as { referenceInboxId?: string }).referenceInboxId;
-  if (!refInbox) {
-    const recent = await conv.messages({ limit: 200, direction: 1 });
-    refInbox = recent.find((m) => m.id === xmtpMsgId)?.senderInboxId;
-    if (!refInbox)
-      throw new TrainError(
-        'NOT_FOUND',
-        `could not resolve referenceInboxId for ${xmtpMsgId}`,
-      );
-  }
-  const schemaEnum =
-    reactSchema === 'custom'
-      ? ReactionSchema.Custom
-      : reactSchema === 'shortcode'
-        ? ReactionSchema.Shortcode
-        : ReactionSchema.Unicode;
+  const removed = reactAction === 'removed';
   const sentId = await conv.sendReaction({
     reference: xmtpMsgId,
-    referenceInboxId: refInbox,
-    action:
-      reactAction === 'removed' ? ReactionAction.Removed : ReactionAction.Added,
+    referenceInboxId: await referenceInboxOf(conv, xmtpMsgId),
+    action: removed ? ReactionAction.Removed : ReactionAction.Added,
     content: emoji,
-    schema: schemaEnum,
+    schema: ReactionSchema.Unicode,
   });
   emitOutbound(
     acct.cfg.id,
     line,
     sentId,
-    `[react ${emoji}${reactAction === 'removed' ? ' (removed)' : ''}]`,
+    `[react ${emoji}${removed ? ' (removed)' : ''}]`,
     { type: 'react', emoji, targetId: xmtpMsgId },
   );
   respond(id, { result: { messageId: sentId } });
@@ -134,6 +133,37 @@ async function reply(id: string, args: Args): Promise<void> {
   respond(id, { result: { messageId: sentId } });
 }
 
+const UNDELETABLE = new Set(['deleteMessage', 'deletedMessage']);
+
+function assertDeletable(acct: Account, conv: Conversation, messageId: string): void {
+  const msg = acct.client.conversations.getMessageById(messageId);
+  if (msg?.conversationId !== conv.id)
+    throw new TrainError('NOT_FOUND', `message ${messageId} is not in this conversation`);
+  if (msg.senderInboxId !== acct.inboxId)
+    throw badArgs(`message ${messageId} was not sent by this account; only your own messages can be deleted`);
+  if (msg.kind !== GroupMessageKind.Application || UNDELETABLE.has(msg.contentType?.typeId ?? ''))
+    throw badArgs(`message ${messageId} cannot be deleted`);
+}
+
+async function remove(id: string, args: Args): Promise<void> {
+  const { line, messageId } = args as { line: string; messageId: string };
+  const { acct, conv } = await convOf(line);
+  if (!conv) throw noConv(line);
+  const target = resolveMsgId(messageId);
+  assertDeletable(acct, conv, target);
+  const sentId = await conv.send(encodeDeleteMessage(target), { shouldPush: false });
+  respond(id, { result: { messageId: sentId } });
+}
+
+async function callSignal(id: string, args: Args): Promise<void> {
+  const { line, signal } = args as { line: string; signal?: unknown };
+  if (typeof signal !== 'object' || signal === null) throw badArgs('callSignal requires a signal object');
+  const { conv } = await convOf(line);
+  if (!conv) throw noConv(line);
+  const messageId = await conv.send(new CallSignalCodec().encode(signal as Record<string, unknown>), { shouldPush: false });
+  respond(id, { result: { messageId } });
+}
+
 async function sendAttachment(id: string, args: Args): Promise<void> {
   const { line, name, mime, dataB64 } = args as {
     line: string;
@@ -159,175 +189,34 @@ const IMG_MIME_BY_EXT: Record<string, string> = {
   webp: 'image/webp',
 };
 
-async function loadImageBytes(
-  path: string | undefined,
-  dataB64: string | undefined,
-): Promise<Uint8Array> {
-  if (path) {
-    const { readFileSync } = await import('node:fs');
-    return new Uint8Array(readFileSync(path));
-  }
-  if (dataB64) return new Uint8Array(Buffer.from(dataB64, 'base64'));
-  throw badArgs('sendImage requires path or dataB64');
-}
-
-function imageMime(
-  mimeType: string | undefined,
-  filename: string | undefined,
-  path: string | undefined,
-): string {
-  if (mimeType) return mimeType;
-  const ext = (filename ?? path ?? '').toLowerCase().split('.').pop() ?? '';
+function imageMime(path: string): string {
+  const ext = path.toLowerCase().split('.').pop() ?? '';
   return IMG_MIME_BY_EXT[ext] ?? 'image/png';
 }
 
-function imageFilename(
-  filename: string | undefined,
-  path: string | undefined,
-): string {
-  if (filename) return filename;
-  const baseName = path ? path.split('/').pop() : undefined;
+function imageFilename(path: string): string {
+  const baseName = path.split('/').pop();
   return baseName != null && baseName !== '' ? baseName : 'image.png';
 }
 
 async function sendImage(id: string, args: Args): Promise<void> {
-  const { line, path, dataB64, filename, mimeType } = args as {
-    line: string;
-    path?: string;
-    dataB64?: string;
-    filename?: string;
-    mimeType?: string;
-  };
+  const { line, path } = args as { line: string; path?: string };
+  if (!path) throw badArgs('sendImage requires path');
   const { acct, conv } = await convOf(line);
   if (!conv) throw noConv(line);
-  const bytes = await loadImageBytes(path, dataB64);
-  const mime = imageMime(mimeType, filename, path);
-  const fname = imageFilename(filename, path);
+  const { readFileSync } = await import('node:fs');
+  const mime = imageMime(path);
+  const fname = imageFilename(path);
   const attachment: Attachment = {
     filename: fname,
     mimeType: mime,
-    data: bytes,
+    data: new Uint8Array(readFileSync(path)),
   };
   const sentId = await conv.send(new AttachmentCodec().encode(attachment));
   emitOutbound(acct.cfg.id, line, sentId, `[${mime.split('/')[0]}: ${fname}]`);
   respond(id, { result: { messageId: sentId } });
 }
 
-interface TxRequestArgs {
-  to: string;
-  amountEth?: number;
-  data?: string;
-  note?: string;
-  chainId?: number;
-}
-
-function validateTxAmount(amountEth: number | undefined, hasData: boolean): void {
-  if (!hasData && (typeof amountEth !== 'number' || !(amountEth > 0))) {
-    throw badArgs(
-      'sendTxRequest requires a positive `amountEth` (or `data` for a contract call)',
-    );
-  }
-  if (amountEth != null && (typeof amountEth !== 'number' || amountEth < 0)) {
-    throw badArgs('sendTxRequest `amountEth` must be a non-negative number');
-  }
-}
-
-function validateTxRequest(a: TxRequestArgs): boolean {
-  const { to, amountEth, data } = a;
-  if (!to || typeof to !== 'string' || !/^0x[0-9a-fA-F]{40}$/.test(to)) {
-    throw badArgs('sendTxRequest requires a valid 0x `to` address');
-  }
-  const hasData = data != null;
-  if (
-    hasData &&
-    (typeof data !== 'string' || !/^0x([0-9a-fA-F]{2})*$/.test(data))
-  ) {
-    throw badArgs('sendTxRequest `data` must be 0x-prefixed hex calldata');
-  }
-  validateTxAmount(amountEth, hasData);
-  return hasData;
-}
-
-function buildTxContent(
-  a: TxRequestArgs,
-  from: string,
-  hasData: boolean,
-): WalletSendCallsParams {
-  const { to, amountEth, data, note, chainId } = a;
-  const weiHex = amountEth
-    ? '0x' + BigInt(Math.round(amountEth * 1e18)).toString(16)
-    : '0x0';
-  return {
-    version: '1.0',
-    chainId: toHex(chainId ?? 1),
-    from: from as `0x${string}`,
-    calls: [
-      {
-        to: to as `0x${string}`,
-        value: weiHex as `0x${string}`,
-        ...(hasData ? { data: data as `0x${string}` } : {}),
-        metadata: {
-          description: note ?? (hasData ? 'Contract call' : 'Payment request'),
-          transactionType: 'transfer',
-        },
-      },
-    ],
-  };
-}
-
-function txRequestLabel(a: TxRequestArgs, hasData: boolean): string {
-  const { amountEth, note } = a;
-  return hasData
-    ? `📝 ${note ?? 'Contract call'}${amountEth ? ` (${amountEth} ETH)` : ''}`
-    : `💸 ${note ?? 'Payment request'} (${amountEth} ETH)`;
-}
-
-async function sendTxRequest(id: string, args: Args): Promise<void> {
-  const { line } = args as { line: string };
-  const txArgs = args as Args & TxRequestArgs;
-  const { acct, conv } = await convOf(line);
-  if (!conv) throw noConv(line);
-  const hasData = validateTxRequest(txArgs);
-  const content = buildTxContent(txArgs, acct.address, hasData);
-  const sentId = await conv.send(new WalletSendCallsCodec().encode(content));
-  emitOutbound(acct.cfg.id, line, sentId, txRequestLabel(txArgs, hasData));
-  respond(id, { result: { messageId: sentId } });
-}
-
-async function sendSignatureRequest(id: string, args: Args): Promise<void> {
-  const { line, kind, eip712, message, description } = args as {
-    line: string;
-    kind?: 'eip712' | 'personal';
-    eip712?: unknown;
-    message?: string;
-    description?: string;
-  };
-  const { acct, conv } = await convOf(line);
-  if (!conv) throw noConv(line);
-  const k: 'eip712' | 'personal' = kind === 'eip712' ? 'eip712' : 'personal';
-  if (k === 'eip712' && !eip712)
-    throw badArgs(
-      'sendSignatureRequest eip712 requires an `eip712` typed-data object',
-    );
-  if (k === 'personal' && (!message || typeof message !== 'string')) {
-    throw badArgs('sendSignatureRequest personal requires a `message` string');
-  }
-  const content: SignatureRequestContent = {
-    id: 'sig_' + Date.now().toString(36),
-    kind: k,
-    ...(k === 'eip712' ? { eip712 } : { message }),
-    description,
-  };
-  const sentId = await conv.send(new SignatureRequestCodec().encode(content));
-  emitOutbound(
-    acct.cfg.id,
-    line,
-    sentId,
-    `✍️ ${description ?? 'Signature request'}`,
-  );
-  respond(id, { result: { messageId: sentId } });
-}
-
 async function accountsAction(id: string): Promise<void> {
   const { accounts } = await import('./accounts.js');
   respond(id, {
@@ -335,41 +224,43 @@ async function accountsAction(id: string): Promise<void> {
       accounts: [...accounts.values()].map((a) => ({
         id: a.cfg.id,
         handle: a.address,
-        url: `https://etherscan.io/address/${a.address}`,
+        url: `https://stage.box/#/${a.address}`,
         address: a.address,
         inboxId: a.inboxId,
-        env: 'production',
-        owner: a.cfg.owner ?? null,
-        keySource: 'privateKey',
+        smart: a.smart !== null,
       })),
     },
   });
 }
 
-function unsupportedVerb(id: string, verb: string): Promise<void> {
-  respond(id, { error: `unsupported verb '${verb}' on xmtp` });
-  return Promise.resolve();
-}
-
 const handlers: Record<string, (id: string, args: Args) => Promise<void>> = {
   accounts: (id) => accountsAction(id),
+  listChannels,
+  set_profile: setProfile,
+  claim_name: claimNameAction,
+  name: nameAction,
+  profile: profileAction,
+  resolve_sender: resolveSenderAction,
   send,
   ask,
-  sendPoll: ask,
   react,
   reply,
+  delete: remove,
+  callSignal,
+  callLeftovers: (id) => callLeftovers(id),
   sendAttachment,
   sendImage,
-  sendTxRequest,
-  sendSignatureRequest,
-  edit: (id) => unsupportedVerb(id, 'edit'),
-  delete: (id) => unsupportedVerb(id, 'delete'),
   ...convHandlers,
 };
 
 export type { CallMsg };
 
 export const handleCall = makeStation({
-  handlers,
-  normalize: normalizeXmtp,
+  handlers: Object.fromEntries(Object.entries(handlers).map(([action, handler]) => [
+    action,
+    action === 'accounts' || action === 'callLeftovers' || action === 'listChannels'
+      ? handler
+      : (id: string, args: Args) => network.run(() => handler(id, args)),
+  ])),
+  normalize: messagingAliases({ action: 'removed' }),
 });

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

@@ -6,14 +6,28 @@ import {
 import {
   saveBufferToCache,
   assertAttachmentSize,
-} from '@metro-labs/mcp/stations/attachments';
-import type { SavedAttachment } from '@metro-labs/mcp/stations/attachments';
-import { errMsg } from '@metro-labs/mcp/log';
+} from '@metro-labs/core/stations/attachments';
+import type { SavedAttachment } from '@metro-labs/core/stations/attachments';
+import { errMsg } from '@metro-labs/core/log';
 
 export type { SavedAttachment };
 
-export const REMOTE_FETCH_ATTEMPTS = 3;
-const REMOTE_FETCH_BACKOFF_MS = 400;
+interface FetchSchedule {
+  delaysMs: readonly number[];
+  requestTimeoutMs: number;
+}
+
+const READ_SCHEDULE: FetchSchedule = { delaysMs: [400, 800], requestTimeoutMs: 18_000 };
+export const INBOUND_FETCH_SCHEDULE: FetchSchedule = {
+  delaysMs: [
+    2_000, 4_000, 8_000, 15_000, 30_000, 30_000,
+    60_000, 60_000, 60_000, 60_000, 60_000, 60_000,
+  ],
+  requestTimeoutMs: 120_000,
+};
+export const REMOTE_FETCH_ATTEMPTS = READ_SCHEDULE.delaysMs.length + 1;
+const SWARM_GATEWAY = 'https://download.gateway.ethswarm.org/bzz/';
+const SWARM_BZZ_URL = /^https:\/\/[^/]+\/bzz\/([0-9a-f]{64}(?:[0-9a-f]{64})?)\/?$/i;
 
 const sleep = (ms: number): Promise<void> =>
   new Promise((resolve) => setTimeout(resolve, ms));
@@ -74,22 +88,50 @@ interface DecodedAttachment {
   data: Uint8Array;
 }
 
-async function loadRemote(r: RemoteEntry): Promise<DecodedAttachment> {
+function remoteUrl(url: string): string {
+  const ref = SWARM_BZZ_URL.exec(url)?.[1];
+  return ref === undefined ? url : `${SWARM_GATEWAY}${ref.toLowerCase()}/`;
+}
+
+function withTimeout<T>(work: Promise<T>, ms: number, url: string): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const expired = new Promise<never>((_resolve, reject) => {
+    timer = setTimeout(() => {
+      reject(new Error(`no answer from ${url} within ${ms / 1000}s`));
+    }, ms);
+  });
+  return Promise.race([work, expired]).finally(() => {
+    clearTimeout(timer);
+  });
+}
+
+function loadFrom(r: RemoteEntry, url: string, timeoutMs: number): Promise<DecodedAttachment> {
+  return withTimeout(
+    RemoteAttachmentCodec.load<DecodedAttachment>(
+      { ...toRemoteDescriptor(r), url },
+      loadRegistry,
+    ),
+    timeoutMs,
+    url,
+  );
+}
+
+async function loadRemote(
+  r: RemoteEntry,
+  schedule: FetchSchedule,
+): Promise<DecodedAttachment> {
+  const url = remoteUrl(r.url);
   let last = '';
-  for (let attempt = 1; attempt <= REMOTE_FETCH_ATTEMPTS; attempt += 1) {
+  for (const delay of [0, ...schedule.delaysMs]) {
+    if (delay > 0) await sleep(delay);
     try {
-      return await RemoteAttachmentCodec.load<DecodedAttachment>(
-        toRemoteDescriptor(r),
-        loadRegistry,
-      );
+      return await loadFrom(r, url, schedule.requestTimeoutMs);
     } catch (err) {
       last = errMsg(err);
-      if (attempt < REMOTE_FETCH_ATTEMPTS)
-        await sleep(REMOTE_FETCH_BACKOFF_MS * attempt);
     }
   }
   throw new Error(
-    `xmtp remote attachment fetch failed after ${REMOTE_FETCH_ATTEMPTS} attempts: ${last}`,
+    `xmtp remote attachment fetch failed after ${schedule.delaysMs.length + 1} attempts: ${last}`,
   );
 }
 
@@ -97,9 +139,10 @@ export async function saveRemoteAttachment(
   r: RemoteEntry,
   messageId: string,
   index = 0,
+  schedule: FetchSchedule = READ_SCHEDULE,
 ): Promise<SavedAttachment> {
   if (r.contentLength) assertAttachmentSize(r.contentLength);
-  const decoded = await loadRemote(r);
+  const decoded = await loadRemote(r, schedule);
   return saveBufferToCache(decoded.data, messageId, index, {
     mime: decoded.mimeType,
     name: decoded.filename ?? r.filename,

package/runtime/node_modules/@metro-labs/xmtp/src/call-leftovers.ts

@@ -0,0 +1,48 @@
+import type { DecodedMessage } from '@xmtp/node-sdk';
+import { isRecord } from '@metro-labs/core/is-record';
+import { TrainError } from '@metro-labs/core/train-error';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { accounts, lineOf, type Account } from './accounts.js';
+import { isCallSignal } from './codecs.js';
+
+const RECENT_MS = 24 * 60 * 60_000;
+const STAGE_HISTORY = 100;
+
+interface Leftover {
+  line: string;
+  callId: string;
+  peer: string;
+}
+
+function ownSignal(acct: Account, m: DecodedMessage): Record<string, unknown> | null {
+  if (m.senderInboxId !== acct.inboxId || !isCallSignal(m)) return null;
+  return isRecord(m.content) ? m.content : null;
+}
+
+function openJoins(acct: Account, line: string, messages: DecodedMessage[]): Leftover[] {
+  const open = new Map<string, string>();
+  for (const m of messages) {
+    const signal = ownSignal(acct, m);
+    if (signal === null || typeof signal.from !== 'string' || typeof signal.callId !== 'string') continue;
+    if (signal.kind === 'join') open.set(signal.from, signal.callId);
+    else if (signal.kind === 'leave') open.delete(signal.from);
+  }
+  return [...open].map(([peer, callId]) => ({ line, callId, peer }));
+}
+
+async function leftoversOf(acct: Account, sinceNs: bigint): Promise<Leftover[]> {
+  const found: Leftover[] = [];
+  for (const conv of await acct.client.conversations.list()) {
+    const newestFirst = await conv.messages({ sentAfterNs: sinceNs, direction: 1, limit: STAGE_HISTORY });
+    found.push(...openJoins(acct, lineOf(acct.cfg.id, conv.id), newestFirst.reverse()));
+  }
+  return found;
+}
+
+export async function callLeftovers(id: string): Promise<void> {
+  if (accounts.size === 0) throw new TrainError('UNAVAILABLE', 'no XMTP account is ready yet');
+  const sinceNs = BigInt(Date.now() - RECENT_MS) * 1_000_000n;
+  const calls: Leftover[] = [];
+  for (const acct of accounts.values()) calls.push(...(await leftoversOf(acct, sinceNs)));
+  respond(id, { result: { calls } });
+}

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

@@ -0,0 +1,56 @@
+import {
+  ChannelDirectory,
+  DIRECTORY_LIMIT,
+  type ChannelSnapshot,
+} from '@metro-labs/core/stations/channel-directory';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { TrainError } from '@metro-labs/core/train-error';
+import { ListConversationsOrderBy, type ListConversationsOptions } from '@xmtp/node-sdk';
+import { accountForCall, lineOf, type Account } from './accounts.js';
+import { syncConversations } from './network.js';
+
+interface ConversationMetadata {
+  id: string;
+  name?: string;
+}
+
+interface ConversationSource {
+  sync: () => Promise<unknown>;
+  list: (options: ListConversationsOptions) => Promise<ConversationMetadata[]>;
+}
+
+const directories = new WeakMap<Account, ChannelDirectory>();
+
+export async function loadChannels(account: string, source: ConversationSource): Promise<ChannelSnapshot> {
+  await syncConversations(source);
+  const conversations = await source.list({
+    limit: DIRECTORY_LIMIT + 1,
+    includeDuplicateDms: false,
+    orderBy: ListConversationsOrderBy.CreatedAt,
+  });
+  return {
+    channels: conversations.slice(0, DIRECTORY_LIMIT + 1).map((conversation) => ({
+      id: conversation.id,
+      line: lineOf(account, conversation.id),
+      ...('name' in conversation && conversation.name ? { name: conversation.name } : {}),
+      kind: 'name' in conversation ? 'group' : 'direct',
+    })),
+    capability: {
+      supported: true,
+      complete: false,
+      source: 'mixed',
+      reason: 'Only conversations known to this XMTP installation are listed; other devices may know more. Group names use locally stored metadata.' +
+        (conversations.length > DIRECTORY_LIMIT ? ` Results are limited to ${DIRECTORY_LIMIT} conversations.` : ''),
+    },
+  };
+}
+
+export async function listChannels(id: string, args: Record<string, unknown>): Promise<void> {
+  if (typeof args.account !== 'string' || !args.account.trim())
+    throw new TrainError('INVALID_ARGS', 'listChannels requires an account');
+  const acct = accountForCall({ account: args.account });
+  const directory = directories.get(acct) ?? new ChannelDirectory();
+  directories.set(acct, directory);
+  const result = await directory.list(acct.cfg.id, args, () => loadChannels(acct.cfg.id, acct.client.conversations));
+  respond(id, { result });
+}