@stage-labs/metro 0.1.0-beta.2 → 0.1.0-beta.200

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 './wire.js';
+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;
+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

@@ -0,0 +1,17 @@
+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']),
+  groupOps: new Set<GroupOp>(['create_group', 'add_members', 'remove_members']),
+  attachmentMode: 'native',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
+  claimsName: true,
+  sendAttachments: xmtpSendAttachments,
+  tools: XMTP_TOOLS,
+};

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

@@ -0,0 +1,79 @@
+import type { CanonicalAttachment, ToolContext } from '@metro-labs/core/stations/types';
+import { TrainError } from '@metro-labs/core/train-error';
+import {
+  guessMime,
+  isImageMime,
+  isImageExt,
+  kindOf,
+} from '@metro-labs/core/stations/attachments';
+
+export const str = (v: unknown): string => (typeof v === 'string' ? v : '');
+
+export async function setChannelMetadata(
+  a: Record<string, unknown>,
+  ctx: ToolContext,
+) {
+  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;
+  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`',
+    );
+  const callArgs: Record<string, unknown> = { line, appData };
+  if (hasName) callArgs.name = metaName;
+  return ctx.okJson(await ctx.call('updateChannelMeta', callArgs));
+}
+
+const XMTP_ATTACH_MAX_BYTES = 190 * 1024;
+
+async function sendFileAttachment(
+  line: string,
+  a: CanonicalAttachment,
+  src: string,
+  ctx: ToolContext,
+): Promise<void> {
+  const buf = await ctx.readFile(src);
+  if (buf.byteLength > XMTP_ATTACH_MAX_BYTES) {
+    throw new TrainError(
+      'attachment_too_large',
+      `attachment '${src}' is ${(buf.byteLength / 1024).toFixed(0)} KiB; xmtp non-image files ` +
+        'over ~190 KiB (256 KiB once base64-encoded) cannot be sent via this MCP path. ' +
+        'Send it as an image, host it elsewhere, or use the metro CLI directly.',
+    );
+  }
+  await ctx.call('sendAttachment', {
+    line,
+    name: a.name ?? src.split('/').pop() ?? 'attachment',
+    mime: a.mime ?? guessMime(src),
+    dataB64: buf.toString('base64'),
+  });
+}
+
+export async function xmtpSendAttachments(
+  line: string,
+  atts: CanonicalAttachment[],
+  ctx: ToolContext,
+): Promise<string[]> {
+  const sent: string[] = [];
+  for (const a of atts) {
+    const src = a.path ?? a.url ?? '';
+    if (!src) continue;
+    const mime = a.mime ?? guessMime(src);
+    if (isImageMime(mime) || isImageExt(src)) {
+      await ctx.call('sendImage', { line, path: src });
+    } else {
+      await sendFileAttachment(line, a, src, ctx);
+    }
+    sent.push(kindOf(mime, src));
+  }
+  return sent;
+}

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

@@ -0,0 +1,198 @@
+import type { StationTool } from '@metro-labs/core/stations/types';
+import {
+  str,
+  setChannelMetadata,
+  xmtpSendAttachments,
+} from './tools-handlers.js';
+
+export { xmtpSendAttachments };
+
+const lineProp = {
+  type: 'string',
+  description:
+    'The metro:// line (from the inbound <channel> tag). The station is derived from it.',
+} as const;
+
+export const XMTP_TOOLS: StationTool[] = [
+  {
+    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?, ' +
+      'open? (true => free-text answer, options optional). Multi-question form: questions ' +
+      '(array of {question, options?, header?, multiSelect?, open?}). Args: line (required) + ' +
+      'the above. xmtp-only (the daemon `ask` action). Returns the poll messageId + pollId.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        line: lineProp,
+        question: {
+          type: 'string',
+          description: 'The question text (single-question form).',
+        },
+        options: {
+          type: 'array',
+          description: 'Answer options for a single question.',
+          items: { type: 'string' },
+        },
+        header: {
+          type: 'string',
+          description: 'Optional header/title for the poll.',
+        },
+        multiSelect: {
+          type: 'boolean',
+          description: 'Allow selecting multiple options.',
+        },
+        open: {
+          type: 'boolean',
+          description: 'Free-text answer (options optional).',
+        },
+        questions: {
+          type: 'array',
+          description:
+            'Multiple questions (multi-question form). Each is {question, options?, header?, multiSelect?, open?}.',
+          items: { type: 'object' },
+        },
+      },
+      required: ['line'],
+    },
+    async handle(a, ctx) {
+      const line = str(a.line);
+      if (!line) return ctx.err('ask requires `line`');
+      const args: Record<string, unknown> = { line };
+      for (const k of [
+        'question',
+        'options',
+        'header',
+        'multiSelect',
+        'open',
+        'questions',
+      ] as const) {
+        if (a[k] !== undefined) args[k] = a[k];
+      }
+      if (a.question === undefined && a.questions === undefined) {
+        return ctx.err(
+          'ask requires `question` (single) or `questions` (multi)',
+        );
+      }
+      return ctx.okJson(await ctx.call('ask', args));
+    },
+  },
+  {
+    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`). For a group, use create_group.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        address: {
+          type: 'string',
+          description: 'Recipient Ethereum 0x address.',
+        },
+        account: {
+          type: 'string',
+          description: 'XMTP account to DM from. Omit when you have only one.',
+        },
+      },
+      required: ['address'],
+    },
+    async handle(a, ctx) {
+      const address = str(a.address);
+      if (!address) return ctx.err('dm requires `address`');
+      const dmArgs: Record<string, unknown> = { address };
+      if (a.account) dmArgs.account = str(a.account);
+      return ctx.okJson(await ctx.call('newDm', dmArgs));
+    },
+  },
+  {
+    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 ' +
+      'set_channel_metadata/add_members to see current state.',
+    inputSchema: {
+      type: 'object',
+      properties: { line: lineProp },
+      required: ['line'],
+    },
+    async handle(a, ctx) {
+      const line = str(a.line);
+      if (!line) return ctx.err('group_info requires `line`');
+      return ctx.okJson(await ctx.call('groupInfo', { line }));
+    },
+  },
+  {
+    name: 'close_channel',
+    group: 'write',
+    destructive: true,
+    description:
+      '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,
+        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`');
+      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 go in one updateChannelMeta call: the name first, then the labels and links ' +
+      'merged into the group appData. xmtp-only ' +
+      '(channel metadata lives on xmtp groups). Returns the updated channel info.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        line: lineProp,
+        labels: {
+          type: 'array',
+          description: 'Status labels to set.',
+          items: { type: 'string' },
+        },
+        github: {
+          type: 'string',
+          description: 'Linked GitHub URL ("" to clear).',
+        },
+        preview: {
+          type: 'string',
+          description: 'Linked preview URL ("" to clear).',
+        },
+        name: { type: 'string', description: 'New channel name.' },
+      },
+      required: ['line'],
+    },
+    handle: (a, ctx) => setChannelMetadata(a, ctx),
+  },
+];
+

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

@@ -0,0 +1,88 @@
+import { errMsg } from '@metro-labs/core/log';
+import { emitInbound, selfUri } from '@metro-labs/core/stations/train-events';
+import { mintId } from './wire.js';
+
+const WHISPER_BIN = process.env.METRO_WHISPER_BIN ?? 'whisper-cli';
+const WHISPER_MODEL =
+  process.env.METRO_WHISPER_MODEL ??
+  `${process.env.HOME}/.cache/whisper-cpp/ggml-base.bin`;
+const FFMPEG_BIN = process.env.METRO_FFMPEG_BIN ?? 'ffmpeg';
+
+export async function transcribeAndEmit(
+  audio: Uint8Array,
+  line: string,
+  accountId: string,
+  sourceMsgId: string,
+): Promise<void> {
+  const {
+    existsSync: ex,
+    readFileSync: rf,
+    writeFileSync: wf,
+    unlinkSync,
+    mkdtempSync,
+  } = await import('node:fs');
+  const { tmpdir } = await import('node:os');
+  const path = await import('node:path');
+  const j = (...parts: string[]): string => path.join(...parts);
+  const { spawn } = await import('node:child_process');
+  if (!ex(WHISPER_MODEL)) return;
+  const dir = mkdtempSync(j(tmpdir(), 'xmtp-tx-'));
+  const inFile = j(dir, 'in.m4a');
+  const wav = j(dir, 'in.wav');
+  const out = j(dir, 'in');
+  const run = (bin: string, args: string[]): Promise<void> =>
+    new Promise((res, rej) => {
+      const p = spawn(bin, args, { stdio: 'ignore' });
+      p.on('error', rej);
+      p.on('exit', (c) => {
+        if (c === 0) res();
+        else rej(new Error(`${bin} ${String(c)}`));
+      });
+    });
+  try {
+    wf(inFile, audio);
+    await run(FFMPEG_BIN, [
+      '-y',
+      '-i',
+      inFile,
+      '-ar',
+      '16000',
+      '-ac',
+      '1',
+      wav,
+    ]);
+    await run(WHISPER_BIN, [
+      '-m',
+      WHISPER_MODEL,
+      '-f',
+      wav,
+      '--output-txt',
+      '-of',
+      out,
+    ]);
+    const text = rf(`${out}.txt`, 'utf8').trim();
+    if (!text) return;
+    emitInbound(accountId, {
+      id: mintId(),
+      ts: new Date().toISOString(),
+      station: 'xmtp',
+      line,
+      from: selfUri('xmtp', accountId),
+      text: `🎙️ ${text}`,
+      payload: {
+        contentType: 'transcript',
+        transcribeFor: sourceMsgId,
+        transcript: text,
+      },
+    });
+  } catch (err) {
+    process.stderr.write(`xmtp transcribe failed: ${errMsg(err)}\n`);
+  } finally {
+    for (const f of [inFile, wav, `${out}.txt`]) {
+      try {
+        unlinkSync(f);
+      } catch {
+      }
+    }
+  }
+}

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

@@ -0,0 +1,98 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { Client, type ClientOptions, type Signer } from '@xmtp/node-sdk';
+import { expandHome, identityFor, signerFor, XMTP_ENV } from './identity.js';
+import { ensureDeployed } from './smart.js';
+
+export class XmtpVerifyError extends Error {}
+
+export interface XmtpVerified {
+  inboxId: string;
+  address: string;
+  installationId: string;
+  dbPath: string;
+  smart: boolean;
+}
+
+interface RegisteredClient {
+  inboxId: string;
+  installationId: string;
+  isRegistered: boolean;
+}
+
+export type CreateXmtpClient = (
+  signer: Signer,
+  dbPath: string,
+) => Promise<RegisteredClient>;
+
+const openInbox: CreateXmtpClient = (signer, dbPath) => {
+  const options: ClientOptions = { env: XMTP_ENV, dbPath };
+  return Client.create(signer, options);
+};
+
+const reason = (err: unknown): string =>
+  err instanceof Error && err.message !== '' ? err.message : 'no reason given';
+
+export async function verifyXmtpKey(
+  privateKey: string,
+  dbPath: string,
+  smart = false,
+  create: CreateXmtpClient = openInbox,
+): Promise<XmtpVerified> {
+  let identity: Awaited<ReturnType<typeof identityFor>>;
+  try {
+    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) => {
+    throw new XmtpVerifyError(
+      `XMTP would not open an inbox for that key: ${reason(err)}`,
+    );
+  });
+  if (!client.isRegistered)
+    throw new XmtpVerifyError('XMTP did not register an inbox for that key');
+  if (client.inboxId === '')
+    throw new XmtpVerifyError('XMTP returned no inbox id for that key');
+  return {
+    inboxId: client.inboxId,
+    address,
+    installationId: client.installationId,
+    dbPath: resolved,
+    smart,
+  };
+}
+
+async function runCli(): Promise<void> {
+  let out: Record<string, unknown>;
+  try {
+    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, input.smart === true)) };
+  } catch (err) {
+    out = { ok: false, error: reason(err) };
+  }
+  writeFileSync(1, `${JSON.stringify(out)}\n`);
+}
+
+if (import.meta.main) {
+  await runCli();
+  process.exit(0);
+}