@stage-labs/metro 0.1.0-beta.23 → 0.1.0-beta.231

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,72 @@
+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 async function sendSponsored(smart: SmartAccount, to: Hex, data: Hex): Promise<Hex> {
+  const client = smart.client();
+  const hash = await client.sendTransaction({ to, data, value: 0n } as Parameters<typeof client.sendTransaction>[0]);
+  const receipt = await smart.publicClient.waitForTransactionReceipt({ hash });
+  if (receipt.status !== 'success') throw new Error(`the Base transaction ${hash} reverted`);
+  return hash;
+}
+
+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,18 @@
-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']),
+  messageVerbs: new Set<Verb>(['send', 'reply', 'react', 'unreact', 'delete', 'read']),
   groupOps: new Set<GroupOp>(['create_group', 'add_members', 'remove_members']),
   attachmentMode: 'native',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
+  resolvesSenders: true,
+  claimsName: true,
   sendAttachments: xmtpSendAttachments,
   tools: XMTP_TOOLS,
 };

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)) {

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

@@ -1,7 +1,6 @@
-import type { StationTool } from '@metro-labs/mcp/stations/types';
+import type { StationTool } from '@metro-labs/core/stations/types';
 import {
   str,
-  createChannel,
   setChannelMetadata,
   xmtpSendAttachments,
 } from './tools-handlers.js';
@@ -15,43 +14,9 @@ const lineProp = {
 } as const;
 
 export const XMTP_TOOLS: StationTool[] = [
-  {
-    name: 'create_channel',
-    description:
-      'Create a new XMTP group conversation (channel). Args: addresses (required, array of ' +
-      'Ethereum 0x addresses to add as members), name (required, the group name), labels? ' +
-      '(optional string[] status labels applied after creation), account? ' +
-      '(defaults to your only XMTP account). Calls the daemon xmtp `newGroup`, then ' +
-      '`updateChannelMeta` if labels ' +
-      'are given. Returns the new metro:// line and convId. This is an xmtp-only operation. ' +
-      'NOTE: there is no add-members verb on the daemon, so members must be supplied at ' +
-      'creation time.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        addresses: {
-          type: 'array',
-          description: 'Ethereum 0x addresses to add as group members.',
-          items: { type: 'string' },
-        },
-        name: { type: 'string', description: 'The group/channel name.' },
-        labels: {
-          type: 'array',
-          description: 'Optional status labels to apply after creation.',
-          items: { type: 'string' },
-        },
-        account: {
-          type: 'string',
-          description:
-            'XMTP account to create under. Omit when you have only one.',
-        },
-      },
-      required: ['addresses', 'name'],
-    },
-    handle: (a, ctx) => createChannel(a, ctx),
-  },
   {
     name: 'ask',
+    group: 'write',
     description:
       'Ask a question as a poll in an XMTP conversation (mirrors Claude AskUserQuestion). ' +
       'Single-question form: question (required), options? (string[]), header?, multiSelect?, ' +
@@ -116,11 +81,12 @@ export const XMTP_TOOLS: StationTool[] = [
   },
   {
     name: 'dm',
+    group: 'write',
     description:
       'Open (or reuse) a 1:1 XMTP DM with an Ethereum address. Args: address (required, 0x...), ' +
       'account? (defaults to your only XMTP account). Returns the new metro:// line and ' +
       'convId. xmtp-only ' +
-      '(daemon `newDm`). Use this instead of create_channel when there is a single recipient.',
+      '(daemon `newDm`). For a group, use create_group.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -145,10 +111,13 @@ export const XMTP_TOOLS: StationTool[] = [
   },
   {
     name: 'group_info',
+    group: 'read',
     description:
       "Read an XMTP channel's current metadata + membership. Args: line (required). Returns " +
       '{line, id, account, version (dm|group), name, memberCount, labels, github, preview, ' +
-      'members:[{inboxId, address}]}. xmtp-only (daemon `groupInfo`). Use before ' +
+      'assigned, appData (stored JSON object), rawAppData (stored JSON string), ' +
+      'members:[{inboxId, address}]}. Syncs first and fails if metadata cannot be read. ' +
+      'xmtp-only (daemon `groupInfo`). Use before ' +
       'set_channel_metadata/add_members to see current state.',
     inputSchema: {
       type: 'object',
@@ -163,35 +132,73 @@ export const XMTP_TOOLS: StationTool[] = [
   },
   {
     name: 'close_channel',
+    group: 'write',
+    destructive: true,
     description:
-      'Archive/close an XMTP group (removes members). Args: line (required). xmtp-only ' +
-      '(daemon `closeGroup`). Irreversible-ish: members are removed from the group.',
+      'Remove members from an XMTP group, and optionally leave it. Args: line (required), ' +
+      'removeInboxIds? (inbox ids to remove; your own is ignored here), removeSelf? (true to ' +
+      'leave the group yourself). With neither, nothing changes. xmtp-only (daemon ' +
+      '`closeGroup`). Returns {removed, leftSelf}.',
     inputSchema: {
       type: 'object',
-      properties: { line: lineProp },
+      properties: {
+        line: lineProp,
+        removeInboxIds: {
+          type: 'array',
+          description: 'Inbox ids of the members to remove.',
+          items: { type: 'string' },
+        },
+        removeSelf: {
+          type: 'boolean',
+          description: 'Leave the group after removing the others.',
+        },
+      },
       required: ['line'],
     },
     async handle(a, ctx) {
       const line = str(a.line);
       if (!line) return ctx.err('close_channel requires `line`');
-      return ctx.okJson(await ctx.call('closeGroup', { line }));
+      const args: Record<string, unknown> = { line };
+      if (Array.isArray(a.removeInboxIds)) args.removeInboxIds = a.removeInboxIds.map(String);
+      if (a.removeSelf === true) args.removeSelf = true;
+      return ctx.okJson(await ctx.call('closeGroup', args));
     },
   },
   {
     name: 'set_channel_metadata',
+    group: 'write',
     description:
       "Update an existing channel's metadata. Args: line (required, the metro:// line), and " +
-      'any of labels? (string[]), github? (url), preview? (url), name? (string). All provided ' +
-      'fields are applied together in one atomic updateChannelMeta daemon call (a single ' +
-      'appData merge plus name update). xmtp-only ' +
-      '(channel metadata lives on xmtp groups). Returns the updated channel info.',
+      'any of metadata? (JSON object), github? (url), preview? (url), name? (string). ' +
+      'metadata is a shallow appData patch: omitted keys are preserved, supplied nested ' +
+      'values replace that key, and null deletes custom keys. v is reserved. Put labels ' +
+      'and assigned inside metadata. assigned replaces the array with normalized lowercase ' +
+      'Ethereum addresses of current members. Read group_info and union existing IDs to ' +
+      'add assignees. labels remains a legacy top-level alias. Duplicate top-level/metadata ' +
+      'label/link aliases are refused. All fields use one updateChannelMeta call. xmtp-only. ' +
+      'Returns updated metadata. Reread group_info to verify persistence.',
     inputSchema: {
       type: 'object',
       properties: {
         line: lineProp,
+        metadata: {
+          type: 'object',
+          description: 'Shallow JSON appData patch. Omitted keys stay unchanged. v is reserved.',
+          properties: {
+            labels: { type: 'array', items: { type: 'string' } },
+            assigned: {
+              type: 'array',
+              description: 'Replacement assignee list. Current member Ethereum addresses only. [] clears.',
+              items: { type: 'string', pattern: '^0x[0-9a-fA-F]{40}$' },
+            },
+            github: { type: 'string' },
+            preview: { type: 'string' },
+          },
+          additionalProperties: true,
+        },
         labels: {
           type: 'array',
-          description: 'Status labels to set.',
+          description: 'Legacy alias. Prefer metadata.labels.',
           items: { type: 'string' },
         },
         github: {

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

@@ -1,7 +1,6 @@
-import { errMsg } from '@metro-labs/mcp/log';
-import { mintId, SELF_URI } from './wire.js';
-
-type EmitInbound = (accountId: string, e: Record<string, unknown>) => void;
+import { errMsg } from '@metro-labs/core/log';
+import { emitInbound, selfUri } from '@metro-labs/core/stations/train-events';
+import { mintId } from '@metro-labs/core/stations/station-runtime';
 
 const WHISPER_BIN = process.env.METRO_WHISPER_BIN ?? 'whisper-cli';
 const WHISPER_MODEL =
@@ -14,7 +13,6 @@ export async function transcribeAndEmit(
   line: string,
   accountId: string,
   sourceMsgId: string,
-  emitInbound: EmitInbound,
 ): Promise<void> {
   const {
     existsSync: ex,
@@ -69,7 +67,7 @@ export async function transcribeAndEmit(
       ts: new Date().toISOString(),
       station: 'xmtp',
       line,
-      from: SELF_URI,
+      from: selfUri(),
       text: `🎙️ ${text}`,
       payload: {
         contentType: 'transcript',

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

@@ -1,7 +1,8 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { Client, type ClientOptions, type Signer } from '@xmtp/node-sdk';
-import { expandHome, signerFor, XMTP_ENV } from './identity.js';
+import { expandHome, identityFor, signerFor, XMTP_ENV } from './identity.js';
+import { ensureDeployed } from './smart.js';
 
 export class XmtpVerifyError extends Error {}
 
@@ -10,6 +11,7 @@ export interface XmtpVerified {
   address: string;
   installationId: string;
   dbPath: string;
+  smart: boolean;
 }
 
 interface RegisteredClient {
@@ -34,15 +36,25 @@ const reason = (err: unknown): string =>
 export async function verifyXmtpKey(
   privateKey: string,
   dbPath: string,
+  smart = false,
   create: CreateXmtpClient = openInbox,
 ): Promise<XmtpVerified> {
-  let signer: Signer;
-  let address: string;
+  let identity: Awaited<ReturnType<typeof identityFor>>;
   try {
-    ({ signer, address } = signerFor(privateKey));
+    signerFor(privateKey);
   } catch {
     throw new XmtpVerifyError('that is not a usable XMTP private key');
   }
+  try {
+    identity = await identityFor(privateKey, smart);
+  } catch (err) {
+    throw new XmtpVerifyError(`could not build the smart account on Base: ${reason(err)}`);
+  }
+  const { signer, address } = identity;
+  if (identity.smart !== null)
+    await ensureDeployed(identity.smart).catch((err: unknown) => {
+      throw new XmtpVerifyError(`could not deploy the smart account on Base (is the ZeroDev sponsorship still on?): ${reason(err)}`);
+    });
   const resolved = expandHome(dbPath);
   mkdirSync(dirname(resolved), { recursive: true });
   const client = await create(signer, resolved).catch((err: unknown) => {
@@ -59,6 +71,7 @@ export async function verifyXmtpKey(
     address,
     installationId: client.installationId,
     dbPath: resolved,
+    smart,
   };
 }
 
@@ -68,10 +81,11 @@ async function runCli(): Promise<void> {
     const input = JSON.parse(readFileSync(0, 'utf8')) as {
       privateKey?: unknown;
       dbPath?: unknown;
+      smart?: unknown;
     };
     if (typeof input.privateKey !== 'string' || typeof input.dbPath !== 'string')
       throw new XmtpVerifyError('xmtp verify needs a privateKey and a dbPath');
-    out = { ok: true, ...(await verifyXmtpKey(input.privateKey, input.dbPath)) };
+    out = { ok: true, ...(await verifyXmtpKey(input.privateKey, input.dbPath, input.smart === true)) };
   } catch (err) {
     out = { ok: false, error: reason(err) };
   }

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

@@ -1,7 +1,3 @@
-export { emit, respond, mintId } from '@metro-labs/mcp/stations/station-runtime';
-
-export const SELF_URI = process.env.METRO_SELF_URI ?? '';
-
 const UID_MAP_MAX = 5000;
 const uidToXmtp = new Map<string, string>();
 
@@ -37,3 +33,17 @@ export function resolveMsgId(rawId: string): string {
       '(not seen by this train; pass the raw xmtp message_id)',
   );
 }
+
+const SENT_MAX = 5000;
+const sentIds = new Set<string>();
+
+export function rememberSent(xmtpId: string | undefined): void {
+  if (!xmtpId) return;
+  sentIds.add(xmtpId);
+  if (sentIds.size > SENT_MAX) {
+    const oldest = sentIds.values().next().value;
+    if (oldest !== undefined) sentIds.delete(oldest);
+  }
+}
+
+export const sentByMe = (xmtpId: string): boolean => sentIds.has(xmtpId);

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.23"
+  "version": "0.1.0-beta.231"
 }

package/runtime/server.ts

@@ -0,0 +1 @@
+import './node_modules/@metro-labs/daemon/src/server.ts';