@stage-labs/metro 0.1.0-beta.32 → 0.1.0-beta.321

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

@@ -1,12 +1,13 @@
-import { accountForCall, convOf, lineOf } from './accounts.js';
-import { respond } from './wire.js';
-import { warmGroupName } from './conv-helpers.js';
-import { mergeAppData, readAppData, type GroupLike } from './labels.js';
-import { TrainError } from '@metro-labs/mcp/train-error';
+import { accountForCall, convOf, lineOf, parseLine } from './accounts.js';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { ethIdentifiers, warmGroupName } from './conv-helpers.js';
+import { mergeAppData, normalizeAssigned, readAppDataObject, type GroupLike } from './labels.js';
+import { TrainError } from '@metro-labs/core/train-error';
+import { syncConversation } from './network.js';
 
 type Args = Record<string, unknown>;
 
-export function resolveLine(args: Args, verb: string): string {
+function resolveLine(args: Args, verb: string): string {
   const line = (args as { line?: string }).line;
   if (line) return line;
   const groupId = (args as { groupId?: string }).groupId;
@@ -24,7 +25,11 @@ async function applyNameAndDescription(
   group: GroupLike,
   name: string | undefined,
   description: string | undefined,
+  verb: string,
 ): Promise<void> {
+  if (description !== undefined && typeof group.updateDescription !== 'function') {
+    throw new TrainError('INVALID_ARGS', `${verb} target does not support native group descriptions`);
+  }
   if (
     typeof name === 'string' &&
     name &&
@@ -50,10 +55,10 @@ async function applyMergedAppData(
     await group.updateAppData(res.blob);
     return res.merged;
   }
-  return readAppData(group.appData);
+  return readAppDataObject(group.appData);
 }
 
-export async function applyChannelMeta(
+async function applyChannelMeta(
   args: {
     line: string;
     name?: string;
@@ -73,9 +78,21 @@ export async function applyChannelMeta(
       `${verb} target is not a group (no updateAppData)`,
     );
   }
-  await group.sync?.().catch(() => undefined);
+  await syncConversation(acct.client, conv);
+  if (appData) mergeAppData(group.appData, appData);
+  else readAppDataObject(group.appData);
+  if (appData && Object.hasOwn(appData, 'assigned')) {
+    const assigned = normalizeAssigned(appData.assigned);
+    const inboxIds = await Promise.all(
+      ethIdentifiers(assigned).map((identifier) => acct.client.fetchInboxIdByIdentifier(identifier)),
+    );
+    const members = new Set((await conv.members()).map((member) => member.inboxId));
+    if (inboxIds.some((inboxId) => !inboxId || !members.has(inboxId))) {
+      throw new TrainError('INVALID_ARGS', 'Assignees must be current channel members');
+    }
+  }
 
-  await applyNameAndDescription(group, name, description);
+  await applyNameAndDescription(group, name, description, verb);
   const merged = await applyMergedAppData(
     group as GroupLike & { updateAppData: (s: string) => Promise<void> },
     appData,
@@ -93,65 +110,49 @@ export async function applyChannelMeta(
 
 function metaFields(merged: Record<string, unknown>): {
   labels: string[];
+  category: string | undefined;
+  status: string | undefined;
+  priority: string | undefined;
   github: string | undefined;
   preview: string | undefined;
+  assigned: unknown;
 } {
   return {
     labels: Array.isArray(merged.labels) ? (merged.labels as string[]) : [],
+    category: typeof merged.category === 'string' ? merged.category : undefined,
+    status: typeof merged.status === 'string' ? merged.status : undefined,
+    priority: typeof merged.priority === 'string' ? merged.priority : undefined,
     github: typeof merged.github === 'string' ? merged.github : undefined,
     preview: typeof merged.preview === 'string' ? merged.preview : undefined,
+    assigned: Object.hasOwn(merged, 'assigned') ? merged.assigned : [],
   };
 }
 
+const metadataWrites = new Map<string, Promise<Record<string, unknown>>>();
+
 export async function updateChannelMeta(id: string, args: Args): Promise<void> {
   const line = resolveLine(args, 'updateChannelMeta');
+  const parsed = parseLine(line);
+  if (!parsed) throw new TrainError('INVALID_ARGS', `bad xmtp line: ${line}`);
+  const key = lineOf(parsed.accountId, parsed.convId);
   const { name, description, appData } = args as {
     name?: string;
     description?: string;
     appData?: Record<string, unknown>;
   };
-  const result = await applyChannelMeta(
-    { line, name, description, appData },
-    'updateChannelMeta',
-  );
-  respond(id, { result });
-}
-
-export async function setGithub(id: string, args: Args): Promise<void> {
-  const line = resolveLine(args, 'setGithub');
-  const { url } = args as { url: string };
-  if (typeof url !== 'string')
-    throw new Error('setGithub requires a `url` string');
-  const result = await applyChannelMeta(
-    { line, appData: { github: url } },
-    'setGithub',
-  );
-  respond(id, {
-    result: {
-      line: result.line,
-      id: result.id,
-      account: result.account,
-      github: result.github,
-    },
-  });
-}
-
-export async function setPreview(id: string, args: Args): Promise<void> {
-  const line = resolveLine(args, 'setPreview');
-  const a = args as { preview?: unknown; url?: unknown };
-  const value = typeof a.preview === 'string' ? a.preview : a.url;
-  if (typeof value !== 'string')
-    throw new Error('setPreview requires a `preview` string');
-  const result = await applyChannelMeta(
-    { line, appData: { preview: value } },
-    'setPreview',
-  );
-  respond(id, {
-    result: {
-      line: result.line,
-      id: result.id,
-      account: result.account,
-      preview: result.preview,
-    },
-  });
+  if (name !== undefined && typeof name !== 'string') {
+    throw new TrainError('INVALID_ARGS', 'name must be a string');
+  }
+  if (description !== undefined && typeof description !== 'string') {
+    throw new TrainError('INVALID_ARGS', 'description must be a string');
+  }
+  const task = () => applyChannelMeta({ line, name, description, appData }, 'updateChannelMeta');
+  const previous = metadataWrites.get(key);
+  const pending = previous ? previous.then(task, task) : task();
+  metadataWrites.set(key, pending);
+  try {
+    respond(id, { result: await pending });
+  } finally {
+    if (metadataWrites.get(key) === pending) metadataWrites.delete(key);
+  }
 }

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

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