@stage-labs/metro 0.1.0-beta.247 → 0.1.0-beta.248

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.247",
+  "version": "0.1.0-beta.248",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.247",
+  "version": "0.1.0-beta.248",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

package/runtime/marketplace/plugin/STAGE.md

@@ -1,6 +1,6 @@
 ---
 name: stage
-description: How to use Stage channels (XMTP groups, https://stage.box) through metro. Create a channel, rename it, add or remove members, set labels and assignees, read its info, and send, reply, react, unreact, delete and read messages, and post frames (interactive ChatKit widget views). Works only when this agent has an XMTP account in metro.
+description: How to use Stage channels (XMTP groups, https://stage.box) through metro. Create a channel, rename it, add or remove members, set labels and assignees, read its info, and send, reply, react, unreact, delete and read messages, and post frames (interactive ChatKit widget views) and wallet cards (payment and signature requests, receipts). Works only when this agent has an XMTP account in metro.
 ---
 
 Stage (https://stage.box) is a messenger built on XMTP. A Stage channel is an XMTP group. You use it with the metro tools below (`mcp__metro__<name>`).
@@ -73,3 +73,17 @@ Move it from Backlog or To-do to In progress, then In review, then Done. Use Blo
     ]}}
   }}}
   ```
+
+**Wallet cards.** The payment and signature cards Stage's own Request payment and Request signature send. Sending one moves nothing and signs nothing: the person taps Pay or Sign and confirms in Stage. Send one only when you were asked to.
+- Send: `send {"line": "…", "wallet": {"type": "<type>", "content": {…}}}`. With `text` or a `frame` as well, the card goes last, and the `message_id` you get back is the card's.
+- Payment request, `walletSendCalls`, a card with a Pay button. Stage pays a request with one call; a Stage wallet pays on Base only.
+  ```json
+  {"type": "walletSendCalls", "content": {"version": "1.0", "chainId": "0x2105", "from": "0x<your address>", "calls": [
+    {"to": "0x<who gets paid>", "value": "0x38d7ea4c68000", "metadata": {"description": "Dinner", "transactionType": "transfer",
+      "currency": "ETH", "amount": 0.001, "decimals": 18, "toAddress": "0x<who gets paid>"}}
+  ]}}
+  ```
+  `chainId` is a hex string (`0x2105` is Base) and `value` is in wei, hex. For a token, `to` is the token contract, `data` its `transfer(address,uint256)` call data, `value` is left out, and `metadata` has `currency`, `amount` and `toAddress` (who gets paid).
+- Receipt, `transactionReference`: `{"networkId": 8453, "reference": "0x<tx hash>", "metadata": {"currency": "USDC", "amount": 5}}`. Stage shows "Payment sent · 5 USDC" (or "Transaction sent" without an amount) and a link to the explorer. Only post a real transaction hash.
+- Signature request, `signatureRequest`, a card with a Sign button: `{"id": "<any id>", "kind": "personal", "message": "The text to sign", "description": "Why"}`, or `"kind": "eip712"` with `"eip712": {"domain", "types", "primaryType", "message"}` instead of `message`.
+- Signature, `signatureReference`: `{"requestId": "<message_id of the request>", "signature": "0x…", "signer": "0x…"}`. Stage shows it as Signed.

package/runtime/node_modules/@metro-labs/daemon/src/claude/setup.ts

@@ -166,6 +166,7 @@ const PRIOR_STAGE: ReadonlySet<string> = new Set([
   'e3b8f9bbdb205311bc643aaf91d9d903a91204fd5b55ca949b85cdfa6fd00136',
   '08a30f5cd5cf8013ab70c1fa9e1109018c0337552296a8efe5c0cf543b284991',
   'f87e9494ea6151d140b742c1b88b4f435ae653559be641fddc2160cd24dd4e1b',
+  'cb4307b016855c1a09d48bc8b3924a3080bd78b205963df3d6f20401d0486df9',
 ]);
 const PRIOR_MEMORY: ReadonlySet<string> = new Set(['08795399635c8cdec2b50cb4e336f89ae880f3997ae52560ef647a9cdc8f1b08']);
 

package/runtime/node_modules/@metro-labs/daemon/src/mcp/call-tools.ts

@@ -60,16 +60,20 @@ function assertDelivered(
     );
 }
 
-const frameOf = (m: MessageArgs): Record<string, unknown> =>
-  m.a.frame === undefined ? {} : { frame: m.a.frame };
+const STAGE_PARTS = ['frame', 'wallet'] as const;
+
+const stagePartsIn = (m: MessageArgs): string[] => STAGE_PARTS.filter((key) => m.a[key] !== undefined);
+
+const stagePartArgs = (m: MessageArgs): Record<string, unknown> =>
+  Object.fromEntries(stagePartsIn(m).map((key) => [key, m.a[key]]));
 
 const sentLabels = (m: MessageArgs, text: string | undefined): string[] => [
   ...(text ? ['text'] : []),
-  ...(m.a.frame === undefined ? [] : ['frame']),
+  ...stagePartsIn(m),
 ];
 
 function nativeBody(m: MessageArgs, text: string | undefined, replyTo: string | undefined): Record<string, unknown> {
-  const body: Record<string, unknown> = { line: m.line, ...frameOf(m) };
+  const body: Record<string, unknown> = { line: m.line, ...stagePartArgs(m) };
   if (text) body.text = text;
   if (text && replyTo) body.replyTo = replyTo;
   return body;
@@ -101,7 +105,7 @@ async function sendForwarded(
   atts: ResolvedAttachment[],
 ): Promise<Sent> {
   const { line, ctx, station } = m;
-  const args: Record<string, unknown> = { line, ...frameOf(m) };
+  const args: Record<string, unknown> = { line, ...stagePartArgs(m) };
   if (text) args.text = text;
   if (typeof m.a.subject === 'string' && m.a.subject.trim() !== '') args.subject = m.a.subject;
   if (replyTo) args.replyTo = replyTo;
@@ -123,12 +127,13 @@ const unsupported = (station: Station, atts: CanonicalAttachment[]): string =>
     .map((a) => kindOf(a.mime ?? '', a.path ?? a.url ?? a.name ?? ''))
     .join(', ')}); send a link in \`text\` instead`;
 
-const NOTHING_TO_SEND = 'send requires `text`, `attachments` or `frame`';
+const NOTHING_TO_SEND = 'send requires `text`, `attachments`, `frame` or `wallet`';
 
 function refusal(m: MessageArgs, text: string | undefined, requested: CanonicalAttachment[]): string | undefined {
-  if (!text && !requested.length && m.a.frame === undefined) return NOTHING_TO_SEND;
-  if (m.a.frame !== undefined && m.station.sendsFrames !== true)
-    return `${m.station.name} cannot send a frame; frames are Stage (XMTP) only`;
+  const stageOnly = stagePartsIn(m);
+  if (!text && !requested.length && !stageOnly.length) return NOTHING_TO_SEND;
+  if (stageOnly.length && m.station.sendsFrames !== true)
+    return `${m.station.name} cannot send \`${stageOnly.join('` or `')}\`; that is Stage (XMTP) only`;
   if (requested.length && m.station.attachmentMode === 'none') return unsupported(m.station, requested);
   return undefined;
 }

package/runtime/node_modules/@metro-labs/daemon/src/mcp/permission-prompt.ts

@@ -45,7 +45,7 @@ function argText(value: unknown): string | undefined {
 
 function fieldText(key: string, value: unknown): string | undefined {
   if (key === 'attachments' && Array.isArray(value)) return `${String(value.length)} file(s)`;
-  return key === 'frame' ? argText(value) : valueText(value);
+  return key === 'frame' || key === 'wallet' ? argText(value) : valueText(value);
 }
 
 function metroLines(tool: string, input: Record<string, unknown>): string[] {

package/runtime/node_modules/@metro-labs/daemon/src/mcp/tool-schemas.ts

@@ -34,7 +34,7 @@ export const COMMON_TOOLS: ToolDef[] = [
     group: 'write',
     description:
       'Send a message (and/or media) to a Metro conversation. Args: line, text?, reply_to?, ' +
-      'subject?, attachments?, frame?. The station is derived from the line. Outlook and Gmail: send to ' +
+      'subject?, attachments?, frame?, wallet?. The station is derived from the line. Outlook and Gmail: send to ' +
       'metro://<outlook|gmail>/<account>/<email address> to start a new email (subject defaults to the ' +
       'first line of text); the result names the new thread line. Each attachment names EXACTLY ONE ' +
       'source, and the choice matters: `upload` (an `upload_id` from `create_upload`, the ' +
@@ -42,8 +42,8 @@ export const COMMON_TOOLS: ToolDef[] = [
       '`data` (base64 inline -- TINY FILES ONLY, a few KB, because the base64 has to be ' +
       'written out verbatim in the call and longer than that it corrupts); `url` (the daemon ' +
       'fetches it, so the file must already be public); `path` (resolved on the DAEMON host, ' +
-      'which is not your machine). Stage (XMTP) only: `frame` posts an interactive view. At least one ' +
-      'of text/attachments/frame is required. ' +
+      'which is not your machine). Stage (XMTP) only: `frame` posts an interactive view, `wallet` a payment ' +
+      'or signature card. At least one of text/attachments/frame/wallet is required. ' +
       'The success line names each attachment the station actually delivered; a station that ' +
       'cannot carry a file errors instead of reporting success.',
     inputSchema: {
@@ -99,6 +99,23 @@ export const COMMON_TOOLS: ToolDef[] = [
             description: { type: 'string', description: 'Card description in the chat (1000 characters at most).' },
           },
         },
+        wallet: {
+          type: 'object',
+          description:
+            'Stage (XMTP) only: a wallet card. `type` walletSendCalls is a payment request with a Pay button, ' +
+            'transactionReference a payment receipt with an explorer link, signatureRequest a Sign button, ' +
+            'signatureReference a signed proof. `content` is that type\'s JSON as Stage reads it; the stage skill ' +
+            'has an example of each. Sending it moves nothing: the person taps Pay or Sign and confirms in Stage. ' +
+            "It is sent after the text and any frame, and the message_id returned is the card's.",
+          properties: {
+            type: {
+              type: 'string',
+              enum: ['walletSendCalls', 'transactionReference', 'signatureRequest', 'signatureReference'],
+            },
+            content: { type: 'object', description: 'The JSON of that content type.', additionalProperties: true },
+          },
+          required: ['type', 'content'],
+        },
       },
       required: ['line'],
     },

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

@@ -9,11 +9,13 @@ import {
   AttachmentCodec,
   type Attachment,
 } from '@xmtp/content-type-remote-attachment';
+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 { CallSignalCodec, FrameCodec, PollCodec, buildPollContent, encodeDeleteMessage } from './codecs.js';
 import { buildFrameContent } from './frames.js';
+import { buildWalletContent } from './wallet.js';
 import { callLeftovers } from './call-leftovers.js';
 import { convHandlers } from './actions-conv.js';
 import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
@@ -30,19 +32,27 @@ 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 built = args.frame === undefined ? undefined : buildFrameContent(args.frame);
+  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);
   let messageId: string | undefined;
-  if (text || !built) {
+  if (text || parts.length === 0) {
     messageId = await conv.sendText(text);
     emitOutbound(acct.cfg.id, line, messageId, text);
   }
-  if (built) {
-    messageId = await conv.send(new FrameCodec().encode(built.frame));
-    emitOutbound(acct.cfg.id, line, messageId, `Frame: ${built.title}`);
+  for (const part of parts) {
+    messageId = await conv.send(part.encoded);
+    emitOutbound(acct.cfg.id, line, messageId, part.summary);
   }
   respond(id, { result: { messageId } });
 }

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

@@ -166,6 +166,24 @@ export const SignatureReferenceCodec =
     c.signature ? `[Signature] ${c.signature}` : '[Signature]',
   );
 
+const xmtpOrg = (typeId: string): ContentTypeId => ({
+  authorityId: 'xmtp.org',
+  typeId,
+  versionMajor: 1,
+  versionMinor: 0,
+});
+export const WalletSendCallsCodec = makeJsonCodec<{ calls?: { metadata?: { description?: string } }[] }>(
+  xmtpOrg('walletSendCalls'),
+  (c) => {
+    const desc = c.calls?.[0]?.metadata?.description;
+    return desc ? `[Transaction request] ${desc}` : '[Transaction request]';
+  },
+);
+export const TransactionReferenceCodec = makeJsonCodec<{ reference?: string }>(
+  xmtpOrg('transactionReference'),
+  (c) => (c.reference ? `[Transaction] ${c.reference}` : '[Transaction]'),
+);
+
 export const ContentTypeFrame: ContentTypeId = {
   authorityId: 'stage.box',
   typeId: 'frame',

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

@@ -12,10 +12,10 @@ const TEXT_TYPES = new Set(['Text', 'Caption', 'Markdown']);
 
 type Node = Record<string, unknown>;
 
-const isNode = (v: unknown): v is Node =>
+export const isNode = (v: unknown): v is Node =>
   typeof v === 'object' && v !== null && !Array.isArray(v);
 
-const bad = (message: string): TrainError => new TrainError('INVALID_ARGS', message);
+export const bad = (message: string): TrainError => new TrainError('INVALID_ARGS', message);
 
 function plain(value: unknown): string {
   if (typeof value !== 'string') return '';
@@ -56,7 +56,7 @@ function clip(value: unknown, max: number, name: string): string | undefined {
   return out === '' ? undefined : out;
 }
 
-function parseJson(raw: unknown, name: string): unknown {
+export function parseJson(raw: unknown, name: string): unknown {
   if (typeof raw !== 'string') return raw;
   try {
     return JSON.parse(raw);

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

@@ -0,0 +1,28 @@
+import type { EncodedContent } from '@xmtp/content-type-primitives';
+import {
+  SignatureReferenceCodec,
+  SignatureRequestCodec,
+  TransactionReferenceCodec,
+  WalletSendCallsCodec,
+} from './codecs.js';
+import { bad, isNode, parseJson } from './frames.js';
+
+const WALLET_TYPES: Record<string, { codec: { encode(c: Record<string, unknown>): EncodedContent }; needs: string[] }> = {
+  walletSendCalls: { codec: new WalletSendCallsCodec(), needs: ['version', 'chainId', 'from', 'calls'] },
+  transactionReference: { codec: new TransactionReferenceCodec(), needs: ['networkId', 'reference'] },
+  signatureRequest: { codec: new SignatureRequestCodec(), needs: ['id', 'kind'] },
+  signatureReference: { codec: new SignatureReferenceCodec(), needs: ['requestId', 'signature', 'signer'] },
+};
+
+export function buildWalletContent(raw: unknown): { encoded: EncodedContent; summary: string } {
+  const args = parseJson(raw, 'wallet');
+  const type = isNode(args) && typeof args.type === 'string' ? args.type : '';
+  const spec = Object.hasOwn(WALLET_TYPES, type) ? WALLET_TYPES[type] : undefined;
+  if (!isNode(args) || !spec) throw bad(`wallet type must be one of ${Object.keys(WALLET_TYPES).join(', ')}`);
+  const content = parseJson(args.content, 'wallet content');
+  if (!isNode(content)) throw bad(`wallet content must be the ${type} JSON object`);
+  const missing = spec.needs.filter((key) => content[key] === undefined);
+  if (missing.length > 0) throw bad(`${type} content needs ${missing.join(', ')}`);
+  const encoded = spec.codec.encode(content);
+  return { encoded, summary: encoded.fallback ?? type };
+}

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.247"
+  "version": "0.1.0-beta.248"
 }