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

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

@@ -0,0 +1,160 @@
+import { readFile } from 'node:fs/promises';
+import { encodeFunctionData, encodePacked, keccak256, namehash, stringToBytes, type Hex } from 'viem';
+import { normalize } from 'viem/ens';
+import { TrainError } from '@metro-labs/core/train-error';
+import {
+  assertImage,
+  fieldsOf,
+  parseProfileChange,
+  type ProfileApplied,
+  type ProfileAvatar,
+  type ProfileChange,
+} from '@metro-labs/core/stations/profile';
+import { accountForCall } from './accounts.js';
+import { STAGE_NAMES_PARENT, claimName, nameOf, parseLabel } from './names.js';
+import { sendSponsored, sendSponsoredCalls, type SmartAccount, type SponsoredCall } from './smart.js';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+
+export const BASENAME_REGISTRY = '0xB94704422c2a1E396835A571837Aa5AE53285a95' as const;
+export const BASENAME_L2_RESOLVER = '0xC6d566A56A1aFf6508b41f6c90ff131615583BCD' as const;
+export const BASENAME_REVERSE_REGISTRAR = '0x79EA96012eEa67A83431F1701B3dFf7e37F9E282' as const;
+export const PINEAPPLE_UPLOAD_URL = 'https://pineapple.fyi/upload';
+const STAMP_CLEAR_URL = 'https://stamp.fyi/clear/';
+const ZERO = '0x0000000000000000000000000000000000000000';
+const TEXT_KEYS = { name: 'name', bio: 'description', avatar: 'avatar' } as const;
+
+export const REGISTRY_ABI = [
+  { name: 'resolver', type: 'function', stateMutability: 'view', inputs: [{ name: 'node', type: 'bytes32' }], outputs: [{ name: '', type: 'address' }] },
+] as const;
+
+const RESOLVER_ABI = [
+  {
+    name: 'setText',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [{ name: 'node', type: 'bytes32' }, { name: 'key', type: 'string' }, { name: 'value', type: 'string' }],
+    outputs: [],
+  },
+  { name: 'multicall', type: 'function', stateMutability: 'nonpayable', inputs: [{ name: 'data', type: 'bytes[]' }], outputs: [{ name: 'results', type: 'bytes[]' }] },
+  { name: 'setAddr', type: 'function', stateMutability: 'nonpayable', inputs: [{ name: 'node', type: 'bytes32' }, { name: 'a', type: 'address' }], outputs: [] },
+] as const;
+
+const REVERSE_ABI = [
+  { name: 'setName', type: 'function', stateMutability: 'nonpayable', inputs: [{ name: 'name', type: 'string' }], outputs: [{ name: '', type: 'bytes32' }] },
+] as const;
+
+export const NAME_ABI = [
+  { name: 'name', type: 'function', stateMutability: 'view', inputs: [{ name: 'node', type: 'bytes32' }], outputs: [{ name: '', type: 'string' }] },
+] as const;
+
+const BASE_REVERSE_ROOT = namehash('80002105.reverse');
+
+type Args = Record<string, unknown>;
+
+const NO_NAME = 'this XMTP account has no name yet, so it has no profile: claim a <label>.stage.base.eth name on its channel page first';
+const NOT_SMART = 'this XMTP account was attached before names existed and cannot hold one; attach XMTP again to get an account that can';
+
+export async function pinAvatar(avatar: ProfileAvatar, fetchImpl: typeof fetch = fetch): Promise<string> {
+  assertImage(avatar);
+  const form = new FormData();
+  form.append('file', new Blob([await readFile(avatar.path)], { type: avatar.mime }), avatar.name);
+  const res = await fetchImpl(PINEAPPLE_UPLOAD_URL, { method: 'POST', body: form, signal: AbortSignal.timeout(60_000) });
+  const body = (await res.json().catch(() => ({}))) as { result?: { cid?: string }; error?: { message?: string } };
+  if (!res.ok) throw new TrainError('avatar_upload', `the image upload answered ${String(res.status)}`);
+  if (typeof body.error?.message === 'string') throw new TrainError('avatar_upload', body.error.message);
+  if (typeof body.result?.cid !== 'string' || body.result.cid === '') throw new TrainError('avatar_upload', 'the image upload returned no CID');
+  return `ipfs://${body.result.cid}`;
+}
+
+export const encodePrimaryName = (name: string): Hex => encodeFunctionData({ abi: REVERSE_ABI, functionName: 'setName', args: [name] });
+
+export const reverseNodeOf = (address: string): Hex =>
+  keccak256(encodePacked(['bytes32', 'bytes32'], [BASE_REVERSE_ROOT, keccak256(stringToBytes(address.slice(2).toLowerCase()))]));
+
+async function resolverOf(smart: SmartAccount, node: Hex, fallback: Hex = BASENAME_L2_RESOLVER): Promise<Hex> {
+  const found: Hex = await smart.publicClient.readContract({ address: BASENAME_REGISTRY, abi: REGISTRY_ABI, functionName: 'resolver', args: [node] });
+  return found === ZERO ? fallback : found;
+}
+
+export async function primaryNameOf(smart: SmartAccount): Promise<string | null> {
+  const node = reverseNodeOf(smart.address);
+  const found = await smart.publicClient.readContract({ address: await resolverOf(smart, node), abi: NAME_ABI, functionName: 'name', args: [node] }).catch(() => '');
+  return found === '' ? null : found;
+}
+
+export function nameSetupCalls(name: string, address: Hex, resolver: Hex): SponsoredCall[] {
+  const setAddr = encodeFunctionData({ abi: RESOLVER_ABI, functionName: 'setAddr', args: [namehash(normalize(name)), address] });
+  return [{ to: resolver, data: setAddr }, { to: BASENAME_REVERSE_REGISTRAR, data: encodePrimaryName(name) }];
+}
+
+export async function setUpName(smart: SmartAccount, name: string): Promise<boolean> {
+  try {
+    const resolver = await resolverOf(smart, namehash(normalize(name)), await resolverOf(smart, namehash(STAGE_NAMES_PARENT)));
+    await sendSponsoredCalls(smart, nameSetupCalls(name, smart.address, resolver));
+    return true;
+  } catch (err) {
+    process.stderr.write(`xmtp: the name ${name} is claimed but its address and primary name are not set for ${smart.address}: ${err instanceof Error ? err.message : String(err)}\n`);
+    return false;
+  }
+}
+
+export function encodeTextRecords(name: string, records: Record<string, string>): Hex {
+  const node = namehash(normalize(name));
+  const calls = Object.entries(records).map(([key, value]) => encodeFunctionData({ abi: RESOLVER_ABI, functionName: 'setText', args: [node, key, value] }));
+  return encodeFunctionData({ abi: RESOLVER_ABI, functionName: 'multicall', args: [calls] });
+}
+
+const resolverFor = (smart: SmartAccount, name: string): Promise<Hex> => resolverOf(smart, namehash(normalize(name)));
+
+async function recordsFor(change: ProfileChange, fetchImpl: typeof fetch): Promise<Record<string, string>> {
+  const records: Record<string, string> = {};
+  if (change.name !== undefined) records[TEXT_KEYS.name] = change.name;
+  if (change.bio !== undefined) records[TEXT_KEYS.bio] = change.bio;
+  if (change.avatar !== undefined) records[TEXT_KEYS.avatar] = await pinAvatar(change.avatar, fetchImpl);
+  return records;
+}
+
+export async function writeProfile(smart: SmartAccount, name: string, change: ProfileChange, fetchImpl: typeof fetch = fetch): Promise<Hex> {
+  const records = await recordsFor(change, fetchImpl);
+  const hash = await sendSponsored(smart, await resolverFor(smart, name), encodeTextRecords(name, records));
+  const id = smart.address.toLowerCase();
+  await Promise.all([fetchImpl(`${STAMP_CLEAR_URL}address/${id}`), fetchImpl(`${STAMP_CLEAR_URL}avatar/eth:${id}`)]).catch(() => undefined);
+  return hash;
+}
+
+const smartOf = (args: Args): { accountId: string; address: string; smart: SmartAccount } => {
+  const acct = accountForCall(args);
+  if (acct.smart === null) throw new TrainError('no_name', NOT_SMART);
+  return { accountId: acct.cfg.id, address: acct.address, smart: acct.smart };
+};
+
+export async function setProfile(id: string, args: Args): Promise<void> {
+  const { accountId, address, smart } = smartOf(args);
+  const change = parseProfileChange(args);
+  const name = await nameOf(address);
+  if (name === null) throw new TrainError('no_name', NO_NAME);
+  const tx = await writeProfile(smart, name, change);
+  const result: ProfileApplied & { name: string; tx: string } = { account: accountId, applied: fieldsOf(change), name, tx };
+  respond(id, { result });
+}
+
+export async function claimNameAction(id: string, args: Args): Promise<void> {
+  const { accountId, address, smart } = smartOf(args);
+  const held = await nameOf(address);
+  if (held !== null) throw new TrainError('name_held', `this account already holds ${held}`);
+  const name = await claimName(parseLabel(args.label), address, (message) => smart.signMessage(message));
+  const primary = await setUpName(smart, name);
+  respond(id, { result: { account: accountId, name, primary } });
+}
+
+export async function ensurePrimaryName(smart: SmartAccount, name: string): Promise<boolean> {
+  if ((await primaryNameOf(smart)) === name) return true;
+  return setUpName(smart, name);
+}
+
+export async function nameAction(id: string, args: Args): Promise<void> {
+  const acct = accountForCall(args);
+  const name = acct.smart === null ? null : await nameOf(acct.address);
+  const primary = acct.smart !== null && name !== null ? await ensurePrimaryName(acct.smart, name) : false;
+  respond(id, { result: { account: acct.cfg.id, name, primary, canClaim: acct.smart !== null && name === null } });
+}

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

@@ -0,0 +1,37 @@
+import type { DecodedMessage } from '@xmtp/node-sdk';
+import { kindOf } from '@metro-labs/core/stations/attachments';
+import { saveInlineAttachment, saveRemoteAttachment, type RemoteEntry, type SavedAttachment } from './attachments.js';
+
+interface ReadAttachment {
+  name?: string;
+  mime?: string;
+  kind: string;
+  size: number;
+  local_path: string;
+}
+
+function fileOf(saved: SavedAttachment): ReadAttachment {
+  return {
+    name: saved.name,
+    mime: saved.mime,
+    kind: kindOf(saved.mime ?? '', saved.path),
+    size: saved.bytes,
+    local_path: saved.path,
+  };
+}
+
+export async function readAttachments(message: DecodedMessage): Promise<ReadAttachment[]> {
+  const type = message.contentType?.typeId;
+  if (type === 'attachment') {
+    const content = message.content as { filename?: string; mimeType?: string; content: Uint8Array };
+    return [fileOf(await saveInlineAttachment(content, message.id))];
+  }
+  if (type === 'remoteStaticAttachment')
+    return [fileOf(await saveRemoteAttachment(message.content as RemoteEntry, message.id))];
+  if (type === 'multiRemoteStaticAttachment' || type === 'multiRemoteAttachment') {
+    const content = message.content as { attachments: RemoteEntry[] };
+    return Promise.all(content.attachments.map(async (entry, index) =>
+      fileOf(await saveRemoteAttachment(entry, message.id, index))));
+  }
+  return [];
+}

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

@@ -0,0 +1,44 @@
+import { IdentifierKind } from '@xmtp/node-sdk';
+import { namehash, type Hex } from 'viem';
+import { normalize } from 'viem/ens';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { TrainError } from '@metro-labs/core/train-error';
+import { accountForCall } from './accounts.js';
+import { BASENAME_L2_RESOLVER, BASENAME_REGISTRY, REGISTRY_ABI } from './profile.js';
+import { readerFor, type Reader } from './sender.js';
+
+const ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+const INBOX_RE = /^[0-9a-f]{64}$/;
+const NAME_RE = /^[a-z0-9-]+(\.[a-z0-9-]+)*\.eth$/i;
+const ZERO = '0x0000000000000000000000000000000000000000';
+const ADDR_ABI = [
+  { name: 'addr', type: 'function', stateMutability: 'view', inputs: [{ name: 'node', type: 'bytes32' }], outputs: [{ name: '', type: 'address' }] },
+] as const;
+
+function refuse(query: string, why: string): never {
+  throw new TrainError('bad_request', `'${query}' ${why}`, { retryable: false });
+}
+
+async function addressOfName(name: string, client: Reader): Promise<string> {
+  const node = namehash(normalize(name));
+  const found: Hex = await client.readContract({ address: BASENAME_REGISTRY, abi: REGISTRY_ABI, functionName: 'resolver', args: [node] });
+  const resolver = found === ZERO ? BASENAME_L2_RESOLVER : found;
+  const address = await client.readContract({ address: resolver, abi: ADDR_ABI, functionName: 'addr', args: [node] });
+  if (address === ZERO) refuse(name, 'points to no address');
+  return address;
+}
+
+export async function addressOf(query: string, client: Reader = readerFor()): Promise<string> {
+  if (INBOX_RE.test(query)) refuse(query, 'is already an inbox id, so add it directly instead of looking it up');
+  if (ADDRESS_RE.test(query)) return query.toLowerCase();
+  if (NAME_RE.test(query)) return (await addressOfName(query.toLowerCase(), client)).toLowerCase();
+  refuse(query, 'is not a wallet address (0x followed by 40 characters) or a name ending in .eth');
+}
+
+export async function resolveSenderAction(id: string, args: Record<string, unknown>): Promise<void> {
+  const query = typeof args.query === 'string' ? args.query.trim() : '';
+  const acct = accountForCall({ account: typeof args.account === 'string' ? args.account : undefined });
+  const address = await addressOf(query);
+  const inboxId = await acct.client.fetchInboxIdByIdentifier({ identifier: address, identifierKind: IdentifierKind.Ethereum });
+  respond(id, { result: { account: acct.cfg.id, query, address, exists: inboxId !== null, id: inboxId } });
+}

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

@@ -0,0 +1,112 @@
+import { createPublicClient, http, namehash, type Hex } from 'viem';
+import { base } from 'viem/chains';
+import { normalize } from 'viem/ens';
+import { makeProfileCache, type SenderProfile as Profile } from '@metro-labs/core/stations/sender-profile';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { TrainError } from '@metro-labs/core/train-error';
+import { accountForCall, accounts, type Account } from './accounts.js';
+import { resolveAddresses } from './conv-helpers.js';
+import { nameOf } from './names.js';
+import { BASENAME_L2_RESOLVER, BASENAME_REGISTRY, NAME_ABI, REGISTRY_ABI, reverseNodeOf } from './profile.js';
+
+export interface SenderProfile {
+  address: string;
+  name: string | null;
+  displayName: string | null;
+  about: string | null;
+  avatar: string | null;
+}
+
+const BASE_RPC = 'https://rpc.brovider.xyz/8453';
+const ZERO = '0x0000000000000000000000000000000000000000';
+const AVATAR_RE = /^(https?:\/\/|ipfs:\/\/|data:image\/)/i;
+
+const TEXT_ABI = [
+  { name: 'addr', type: 'function', stateMutability: 'view', inputs: [{ name: 'node', type: 'bytes32' }], outputs: [{ name: '', type: 'address' }] },
+  {
+    name: 'text',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [{ name: 'node', type: 'bytes32' }, { name: 'key', type: 'string' }],
+    outputs: [{ name: '', type: 'string' }],
+  },
+] as const;
+
+export const baseRpc = (): string => process.env.METRO_BASE_RPC ?? BASE_RPC;
+
+const makeReader = (rpc: string) => createPublicClient({ chain: base, transport: http(rpc), batch: { multicall: true } });
+
+export type Reader = ReturnType<typeof makeReader>;
+
+let reader: Reader | null = null;
+export const readerFor = (): Reader => (reader ??= makeReader(baseRpc()));
+
+const trimmed = (v: string): string | null => (v.trim() === '' ? null : v.trim());
+
+async function resolverOf(client: Reader, node: Hex): Promise<Hex> {
+  const found: Hex = await client.readContract({ address: BASENAME_REGISTRY, abi: REGISTRY_ABI, functionName: 'resolver', args: [node] });
+  return found === ZERO ? BASENAME_L2_RESOLVER : found;
+}
+
+async function primaryName(client: Reader, address: string): Promise<string | null> {
+  const node = reverseNodeOf(address);
+  const found = await client.readContract({ address: await resolverOf(client, node), abi: NAME_ABI, functionName: 'name', args: [node] });
+  return found === '' ? null : found;
+}
+
+async function recordsOf(client: Reader, name: string, address: string): Promise<SenderProfile | null> {
+  const node = namehash(normalize(name));
+  const resolver = { address: await resolverOf(client, node), abi: TEXT_ABI } as const;
+  const text = (key: string): Promise<string> => client.readContract({ ...resolver, functionName: 'text', args: [node, key] });
+  const [forward, displayName, about, avatar] = await Promise.all([
+    client.readContract({ ...resolver, functionName: 'addr', args: [node] }),
+    text('name'),
+    text('description'),
+    text('avatar'),
+  ]);
+  if (forward.toLowerCase() !== address.toLowerCase()) return null;
+  return { address, name, displayName: trimmed(displayName), about: trimmed(about), avatar: AVATAR_RE.test(avatar.trim()) ? avatar.trim() : null };
+}
+
+export async function profileOf(address: string, client: Reader = readerFor(), fetchImpl: typeof fetch = fetch): Promise<SenderProfile> {
+  const bare: SenderProfile = { address, name: null, displayName: null, about: null, avatar: null };
+  const name = (await primaryName(client, address)) ?? (await nameOf(address, fetchImpl));
+  if (name === null) return bare;
+  return (await recordsOf(client, name, address)) ?? bare;
+}
+
+const key = (acct: Account, inboxId: string): string => `${acct.cfg.id}:${inboxId}`;
+
+const senders = makeProfileCache<SenderProfile>(
+  async (k) => {
+    const [accountId, inboxId] = k.split(':', 2) as [string, string];
+    const acct = accounts.get(accountId);
+    if (acct === undefined) return null;
+    const address = (await resolveAddresses(acct, [inboxId]))[inboxId];
+    return address === undefined ? null : profileOf(address);
+  },
+  { onError: (k, err) => process.stderr.write(`xmtp: could not resolve the sender ${k}: ${err instanceof Error ? err.message : String(err)}\n`) },
+);
+
+export const senderFields = (p: SenderProfile | null): Record<string, string> =>
+  p === null ? {} : { from_name: p.name ?? p.address, ...(p.displayName === null ? {} : { from_display_name: p.displayName }) };
+
+export const senderFieldsNow = (acct: Account, inboxId: string): Record<string, string> => senderFields(senders.peek(key(acct, inboxId)));
+
+export const senderProfile = (acct: Account, inboxId: string): Promise<SenderProfile | null> => senders.get(key(acct, inboxId));
+
+export const profileView = (inboxId: string, p: SenderProfile | null): Profile => ({
+  id: inboxId,
+  ...(p === null ? {} : { address: p.address }),
+  ...(p?.name == null ? {} : { name: p.name }),
+  ...(p?.displayName == null ? {} : { display_name: p.displayName }),
+  ...(p?.about == null ? {} : { about: p.about }),
+  ...(p?.avatar == null ? {} : { avatar: p.avatar }),
+});
+
+export async function profileAction(id: string, args: Record<string, unknown>): Promise<void> {
+  const user = typeof args.user === 'string' ? args.user.trim() : '';
+  if (user === '') throw new TrainError('xmtp_user_required', 'profile needs the inbox id of the person', { retryable: false });
+  const acct = accountForCall({ account: typeof args.account === 'string' ? args.account : undefined });
+  respond(id, { result: profileView(user, await senderProfile(acct, user)) });
+}

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

@@ -0,0 +1,79 @@
+import { createPublicClient, http, type Hex } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { base } from 'viem/chains';
+import {
+  createKernelAccount,
+  createKernelAccountClient,
+  createZeroDevPaymasterClient,
+  getUserOperationGasPrice,
+  type KernelAccountClient,
+} from '@zerodev/sdk';
+import { getEntryPoint, KERNEL_V3_1 } from '@zerodev/sdk/constants';
+import { signerToEcdsaValidator } from '@zerodev/ecdsa-validator';
+
+export const SMART_CHAIN_ID = 8453;
+const STAGE_ZERODEV_PROJECT = 'c107f734-f7bb-48c1-a5d2-ceb3f70a42f6';
+const ENTRY_POINT = getEntryPoint('0.7');
+
+export const zerodevRpc = (): string =>
+  `https://rpc.zerodev.app/api/v3/${process.env.METRO_ZERODEV_PROJECT ?? STAGE_ZERODEV_PROJECT}/chain/${String(SMART_CHAIN_ID)}`;
+
+export const makePublicClient = (rpc: string) => createPublicClient({ chain: base, transport: http(rpc) });
+
+export type BaseClient = ReturnType<typeof makePublicClient>;
+
+export interface SmartAccount {
+  address: Hex;
+  publicClient: BaseClient;
+  client: () => KernelAccountClient;
+  signMessage: (message: string) => Promise<Hex>;
+  deployed: () => Promise<boolean>;
+}
+
+export async function smartAccountFor(privateKey: string, rpc = zerodevRpc()): Promise<SmartAccount> {
+  const owner = privateKeyToAccount(privateKey as Hex);
+  const publicClient = makePublicClient(rpc);
+  const validator = await signerToEcdsaValidator(publicClient, { signer: owner, entryPoint: ENTRY_POINT, kernelVersion: KERNEL_V3_1 });
+  const account = await createKernelAccount(publicClient, { plugins: { sudo: validator }, entryPoint: ENTRY_POINT, kernelVersion: KERNEL_V3_1, index: 0n });
+  const paymaster = createZeroDevPaymasterClient({ chain: base, transport: http(rpc) });
+  const client = (): KernelAccountClient =>
+    createKernelAccountClient({
+      account,
+      chain: base,
+      bundlerTransport: http(rpc),
+      client: publicClient,
+      paymaster: { getPaymasterData: (userOperation) => paymaster.sponsorUserOperation({ userOperation }) },
+      userOperation: { estimateFeesPerGas: ({ bundlerClient }) => getUserOperationGasPrice(bundlerClient) },
+    });
+  return {
+    address: account.address,
+    publicClient,
+    client,
+    signMessage: (message) => account.signMessage({ message }),
+    deployed: async () => {
+      const code = await publicClient.getCode({ address: account.address });
+      return code !== undefined && code !== '0x';
+    },
+  };
+}
+
+export interface SponsoredCall {
+  to: Hex;
+  data: Hex;
+}
+
+export async function sendSponsoredCalls(smart: SmartAccount, calls: SponsoredCall[]): Promise<Hex> {
+  const client = smart.client();
+  const hash = await client.sendTransaction({ calls: calls.map((call) => ({ ...call, value: 0n })) });
+  const receipt = await smart.publicClient.waitForTransactionReceipt({ hash });
+  if (receipt.status !== 'success') throw new Error(`the Base transaction ${hash} reverted`);
+  return hash;
+}
+
+export const sendSponsored = (smart: SmartAccount, to: Hex, data: Hex): Promise<Hex> => sendSponsoredCalls(smart, [{ to, data }]);
+
+export async function ensureDeployed(smart: SmartAccount): Promise<boolean> {
+  if (await smart.deployed()) return false;
+  await sendSponsored(smart, smart.address, '0x');
+  return true;
+}

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

@@ -1,13 +1,21 @@
-import type { GroupOp, Station, Verb } from '@metro-labs/mcp/stations/types';
+import type { GroupOp, Station, Verb } from '@metro-labs/core/stations/types';
+import { PROFILE_FIELDS, type ProfileField } from '@metro-labs/core/stations/profile';
 import { XMTP_TOOLS, xmtpSendAttachments } from './tools.js';
 
 export const xmtpStation: Station = {
   name: 'xmtp',
   hasAccounts: true,
   hasTrain: true,
-  messageVerbs: new Set<Verb>(['send', 'reply', 'react', 'unreact', 'read']),
+  discoversChannels: true,
+  messageVerbs: new Set<Verb>(['send', 'reply', 'react', 'unreact', 'delete', 'read']),
+  readFilters: new Set(['message_id']),
   groupOps: new Set<GroupOp>(['create_group', 'add_members', 'remove_members']),
   attachmentMode: 'native',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
+  resolvesSenders: true,
+  claimsName: true,
+  sendsFrames: true,
   sendAttachments: xmtpSendAttachments,
   tools: XMTP_TOOLS,
 };

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

@@ -0,0 +1,66 @@
+import { errMsg } from '@metro-labs/core/log';
+import { ConsentState } from '@xmtp/node-sdk';
+import { network, type NetworkBackoff } from './network.js';
+
+interface StreamOptions<T> {
+  consentStates: ConsentState[];
+  retryOnFail: false;
+  onError: (error: Error) => void;
+  onValue: (message: T) => void;
+}
+
+interface StreamSource<T> {
+  streamAllMessages: (options: StreamOptions<T>) => Promise<AsyncIterable<T>>;
+}
+
+interface StreamRuntime {
+  backoff: NetworkBackoff;
+  now: () => number;
+  wait: (ms: number) => Promise<void>;
+  report: (message: string) => void;
+}
+
+const defaultRuntime: StreamRuntime = {
+  backoff: network,
+  now: Date.now,
+  wait: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  report: (message) => { process.stderr.write(`xmtp: ${message}\n`); },
+};
+
+export async function streamMessages<T>(
+  source: StreamSource<T>,
+  handle: (message: T) => Promise<void>,
+  runtime: StreamRuntime = defaultRuntime,
+): Promise<never> {
+  let delay = 5000;
+  for (;;) {
+    const started = runtime.now();
+    let delivery = Promise.resolve();
+    try {
+      const stream = await runtime.backoff.run(() => source.streamAllMessages({
+        consentStates: [ConsentState.Allowed, ConsentState.Unknown],
+        retryOnFail: false,
+        onValue: (message) => {
+          delivery = delivery.then(() => handle(message)).catch((error: unknown) => {
+            runtime.report(`message handler failed: ${errMsg(error)}`);
+          });
+        },
+        onError: (error) => {
+          runtime.backoff.note(error);
+          runtime.report(`stream error: ${errMsg(error)}`);
+        },
+      }));
+      const iterator = stream[Symbol.asyncIterator]();
+      while (!(await iterator.next()).done) await delivery;
+    } catch (error) {
+      runtime.backoff.note(error);
+      runtime.report(`stream error: ${errMsg(error)}`);
+    }
+    await delivery;
+    if (runtime.now() - started >= 60_000) delay = 5000;
+    const wait = Math.max(delay, runtime.backoff.remaining());
+    runtime.report(`stream ended; retry in ${Math.ceil(wait / 1000)}s`);
+    await runtime.wait(wait);
+    delay = Math.min(delay * 2, 300_000);
+  }
+}

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

@@ -1,59 +1,26 @@
-import type { CanonicalAttachment, ToolContext } from '@metro-labs/mcp/stations/types';
-import { TrainError } from '@metro-labs/mcp/train-error';
+import type { CanonicalAttachment, ToolContext } from '@metro-labs/core/stations/types';
+import { TrainError } from '@metro-labs/core/train-error';
+import { metadataPatch, mergeAppData } from './labels.js';
 import {
   guessMime,
   isImageMime,
   isImageExt,
   kindOf,
-} from '@metro-labs/mcp/stations/attachments';
+} from '@metro-labs/core/stations/attachments';
 
 export const str = (v: unknown): string => (typeof v === 'string' ? v : '');
 
-function strList(value: unknown): string[] {
-  return (value as unknown[] | undefined)?.map(String).filter(Boolean) ?? [];
-}
-
-interface CreatedGroup {
-  line?: string;
-  id?: string;
-  account?: string;
-}
-
-async function applyCreateLabels(
-  line: string,
-  labels: string[],
-  ctx: ToolContext,
-): Promise<unknown> {
-  if (!labels.length) return undefined;
-  return ctx.call('updateChannelMeta', { line, appData: { labels } });
-}
-
-export async function createChannel(
-  a: Record<string, unknown>,
-  ctx: ToolContext,
-) {
-  const addresses = strList(a.addresses);
-  const channelName = str(a.name);
-  const labels = strList(a.labels);
-  const account = str(a.account) || undefined;
-  if (!addresses.length)
-    return ctx.err('create_channel requires a non-empty `addresses` array');
-  if (!channelName) return ctx.err('create_channel requires `name`');
-  const groupArgs: Record<string, unknown> = { addresses, name: channelName };
-  if (account) groupArgs.account = account;
-  const { result } = (await ctx.call('newGroup', groupArgs)) as {
-    result: CreatedGroup | null;
-  };
-  const newLine = result?.line ?? '';
-  const labelResult = newLine.length
-    ? await applyCreateLabels(newLine, labels, ctx)
-    : undefined;
-  return ctx.okJson({
-    line: newLine,
-    convId: result?.id,
-    account: result?.account,
-    labels: labelResult,
-  });
+function channelAppData(a: Record<string, unknown>): Record<string, unknown> {
+  const appData = a.metadata === undefined ? {} : { ...metadataPatch(a.metadata) };
+  for (const key of ['labels', 'github', 'preview']) {
+    if (!Object.hasOwn(a, key)) continue;
+    if (Object.hasOwn(appData, key)) {
+      throw new TrainError('INVALID_ARGS', `Specify ${key} only once, inside metadata or at the top level`);
+    }
+    appData[key] = a[key];
+  }
+  mergeAppData(undefined, appData);
+  return appData;
 }
 
 export async function setChannelMetadata(
@@ -62,18 +29,15 @@ export async function setChannelMetadata(
 ) {
   const line = str(a.line);
   if (!line) return ctx.err('set_channel_metadata requires `line`');
-  const labels = a.labels as unknown[] | undefined;
-  const github = a.github as string | undefined;
-  const preview = a.preview as string | undefined;
-  const metaName = a.name as string | undefined;
-  const appData: Record<string, unknown> = {};
-  if (Array.isArray(labels)) appData.labels = labels.map(String);
-  if (typeof github === 'string') appData.github = github;
-  if (typeof preview === 'string') appData.preview = preview;
+  if (Object.hasOwn(a, 'name') && typeof a.name !== 'string') {
+    return ctx.err('set_channel_metadata name must be a string');
+  }
+  const appData = channelAppData(a);
+  const metaName = a.name;
   const hasName = typeof metaName === 'string' && metaName.length > 0;
   if (!hasName && Object.keys(appData).length === 0)
     return ctx.err(
-      'set_channel_metadata requires at least one of `labels`, `github`, `preview`, `name`',
+      'set_channel_metadata requires at least one of `metadata`, `github`, `preview`, `name`, `labels`',
     );
   const callArgs: Record<string, unknown> = { line, appData };
   if (hasName) callArgs.name = metaName;
@@ -112,7 +76,7 @@ export async function xmtpSendAttachments(
 ): Promise<string[]> {
   const sent: string[] = [];
   for (const a of atts) {
-    const src = a.path ?? a.url ?? '';
+    const src = a.path ?? '';
     if (!src) continue;
     const mime = a.mime ?? guessMime(src);
     if (isImageMime(mime) || isImageExt(src)) {