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

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

@@ -0,0 +1,333 @@
+import type { Reaction } from '@xmtp/content-type-reaction';
+import type { Reply } from '@xmtp/content-type-reply';
+import { errMsg } from '@metro-labs/mcp/log';
+import { transcribeAndEmit } from './transcribe.js';
+import {
+  saveInlineAttachment,
+  saveRemoteAttachment,
+  type RemoteEntry,
+} from './attachments.js';
+import { emitInbound, emitAttachmentSaved } from './emit-core.js';
+
+export interface EnvelopeCtx {
+  accountId: string;
+  msgId: string;
+  line: string;
+  baseId: string;
+}
+
+interface RemoteAtt {
+  url: string;
+  filename?: string;
+  contentDigest?: string;
+  nonce?: Uint8Array;
+  salt?: Uint8Array;
+  secret?: Uint8Array;
+  scheme?: string;
+  contentLength?: number;
+}
+
+interface AttView {
+  kind: string;
+  url: string;
+  name?: string;
+  size?: number;
+  remote: {
+    contentDigest?: string;
+    nonce?: string;
+    salt?: string;
+    secret?: string;
+    scheme?: string;
+  };
+}
+
+const b64 = (u?: Uint8Array): string | undefined =>
+  u ? Buffer.from(u).toString('base64') : undefined;
+
+function remoteAtt(r: RemoteAtt, kind: string): AttView {
+  return {
+    kind,
+    url: r.url,
+    name: r.filename,
+    size: r.contentLength,
+    remote: {
+      contentDigest: r.contentDigest,
+      nonce: b64(r.nonce),
+      salt: b64(r.salt),
+      secret: b64(r.secret),
+      scheme: r.scheme,
+    },
+  };
+}
+
+const IMG_RE = /\.(png|jpg|jpeg|gif|webp|heic)(\?|$)/i;
+const VID_RE = /\.(mp4|mov|webm|m4v)(\?|$)/i;
+
+function attKindFor(r: RemoteAtt): string {
+  const isImg = IMG_RE.test(r.url) || IMG_RE.test(r.filename ?? '');
+  if (isImg) return 'image';
+  const isVid = VID_RE.test(r.url) || VID_RE.test(r.filename ?? '');
+  return isVid ? 'video' : 'file';
+}
+
+function singleAttText(one: AttView): string {
+  if (one.kind === 'video') return `🎥 ${one.name ?? 'video'}`;
+  return `[${one.kind}: ${one.name ?? one.url}]`;
+}
+
+function multiAttText(attachments: AttView[]): string {
+  const total = attachments.length;
+  const imgCount = attachments.filter((a) => a.kind === 'image').length;
+  const vidCount = attachments.filter((a) => a.kind === 'video').length;
+  if (imgCount === total && imgCount > 1) return `📷 ${imgCount} photos`;
+  if (vidCount === total && vidCount > 1) return `🎥 ${vidCount} videos`;
+  const one = attachments[0];
+  if (total === 1 && one) return singleAttText(one);
+  return `📎 ${total} attachments`;
+}
+
+function multiRemotePayload(
+  base: Record<string, unknown>,
+  typeId: string,
+  c: object,
+): Record<string, unknown> {
+  const m = c as { attachments?: RemoteAtt[] };
+  const list = Array.isArray(m.attachments) ? m.attachments : [];
+  const attachments = list.map((r) => remoteAtt(r, attKindFor(r)));
+  return {
+    ...base,
+    text: multiAttText(attachments),
+    payload: { contentType: typeId, attachments },
+  };
+}
+
+function reactionPayload(
+  base: Record<string, unknown>,
+  r: Reaction,
+): Record<string, unknown> {
+  const schemaStr = ((): string | undefined => {
+    const s = (r as { schema?: unknown }).schema;
+    if (typeof s === 'string') return s.toLowerCase();
+    if (s === 3) return 'custom';
+    if (s === 2) return 'shortcode';
+    if (s === 1) return 'unicode';
+    return undefined;
+  })();
+  const actionStr = ((): string | undefined => {
+    const a = (r as { action?: unknown }).action;
+    if (typeof a === 'string') return a.toLowerCase();
+    if (a === 2) return 'removed';
+    if (a === 1) return 'added';
+    return undefined;
+  })();
+  const removed = actionStr === 'removed';
+  return {
+    ...base,
+    text: `[react ${r.content ?? ''}${removed ? ' (removed)' : ''}]`,
+    event: { type: 'react', emoji: r.content, targetId: r.reference },
+    payload: {
+      contentType: 'reaction',
+      reactTo: r.reference,
+      emoji: r.content,
+      content: r.content,
+      schema: schemaStr,
+      action: actionStr,
+      removed,
+      optionIndex: schemaStr === 'custom' ? Number(r.content) : undefined,
+    },
+  };
+}
+
+function replyPayload(
+  base: Record<string, unknown>,
+  typeId: string,
+  c: Reply,
+): Record<string, unknown> {
+  return {
+    ...base,
+    text:
+      typeof c.content === 'string'
+        ? c.content
+        : `[reply with ${c.contentType?.typeId ?? 'unknown'}]`,
+    event: { type: 'reply', replyTo: c.reference },
+    payload: {
+      contentType: typeId,
+      replyTo: c.reference,
+      replyContentType: c.contentType?.typeId,
+    },
+  };
+}
+
+function attachmentKind(mime: string | undefined): string {
+  if (mime?.startsWith('image/')) return 'image';
+  if (mime?.startsWith('audio/')) return 'audio';
+  if (mime?.startsWith('video/')) return 'video';
+  return 'file';
+}
+
+function inlineAttachmentPayload(
+  base: Record<string, unknown>,
+  typeId: string,
+  c: { filename?: string; mimeType: string; content: Uint8Array },
+  ctx: EnvelopeCtx,
+): Record<string, unknown> {
+  const kind = attachmentKind(c.mimeType);
+  const dataB64 = Buffer.from(c.content).toString('base64');
+  const out = {
+    ...base,
+    text: `[${kind}: ${c.filename ?? 'attachment'}]`,
+    payload: {
+      contentType: typeId,
+      attachments: [{ kind, mime: c.mimeType, name: c.filename, dataB64 }],
+    },
+  };
+  if (kind === 'audio')
+    transcribeAndEmit(
+      c.content,
+      ctx.line,
+      ctx.accountId,
+      ctx.baseId,
+      emitInbound,
+    ).catch((err: unknown) => {
+      process.stderr.write(
+        `xmtp[${ctx.accountId}] voice transcription failed: ${errMsg(err)}\n`,
+      );
+    });
+  emitAttachmentSaved(
+    ctx.accountId,
+    ctx.line,
+    ctx.baseId,
+    0,
+    saveInlineAttachment(c, ctx.msgId, 0),
+  );
+  return out;
+}
+
+function remoteStaticPayload(
+  base: Record<string, unknown>,
+  typeId: string,
+  c: RemoteAtt,
+  ctx: EnvelopeCtx,
+): Record<string, unknown> {
+  const kind = IMG_RE.test(c.url) ? 'image' : 'file';
+  emitAttachmentSaved(
+    ctx.accountId,
+    ctx.line,
+    ctx.baseId,
+    0,
+    saveRemoteAttachment(c, ctx.msgId, 0),
+  );
+  return {
+    ...base,
+    text: `[${kind}: ${c.filename ?? c.url}]`,
+    payload: { contentType: typeId, attachments: [remoteAtt(c, kind)] },
+  };
+}
+
+function multiRemoteEnvelope(
+  base: Record<string, unknown>,
+  typeId: string,
+  c: object,
+  ctx: EnvelopeCtx,
+): Record<string, unknown> {
+  const m = c as { attachments?: RemoteEntry[] };
+  (Array.isArray(m.attachments) ? m.attachments : []).forEach((r, i) => {
+    emitAttachmentSaved(
+      ctx.accountId,
+      ctx.line,
+      ctx.baseId,
+      i,
+      saveRemoteAttachment(r, ctx.msgId, i),
+    );
+  });
+  return multiRemotePayload(base, typeId, c);
+}
+
+function pollPayload(
+  base: Record<string, unknown>,
+  typeId: string,
+  c: object,
+): Record<string, unknown> {
+  const p = c as { question?: string };
+  return {
+    ...base,
+    text: `Poll: ${p.question ?? ''}`,
+    payload: { contentType: typeId, poll: c },
+  };
+}
+
+function labeledPayload(
+  base: Record<string, unknown>,
+  typeId: string,
+  text: string,
+  key: string,
+  c: unknown,
+): Record<string, unknown> {
+  return { ...base, text, payload: { contentType: typeId, [key]: c } };
+}
+
+function attachmentEnvelope(
+  base: Record<string, unknown>,
+  typeId: string,
+  c: object,
+  ctx: EnvelopeCtx,
+): Record<string, unknown> | undefined {
+  if (typeId === 'attachment')
+    return inlineAttachmentPayload(
+      base,
+      typeId,
+      c as { filename?: string; mimeType: string; content: Uint8Array },
+      ctx,
+    );
+  if (typeId === 'remoteStaticAttachment')
+    return remoteStaticPayload(base, typeId, c as RemoteAtt, ctx);
+  if (
+    typeId === 'multiRemoteStaticAttachment' ||
+    typeId === 'multiRemoteAttachment'
+  )
+    return multiRemoteEnvelope(base, typeId, c, ctx);
+  return undefined;
+}
+
+function refEnvelope(
+  base: Record<string, unknown>,
+  typeId: string | undefined,
+  c: object,
+): Record<string, unknown> | undefined {
+  if (typeId === 'walletSendCalls')
+    return labeledPayload(
+      base,
+      typeId,
+      'Payment request',
+      'walletSendCalls',
+      c,
+    );
+  if (typeId === 'transactionReference')
+    return labeledPayload(
+      base,
+      typeId,
+      'Transaction',
+      'transactionReference',
+      c,
+    );
+  if (typeId === 'signatureRequest')
+    return labeledPayload(base, typeId, 'Signature request', 'signatureRequest', c);
+  if (typeId === 'signatureReference')
+    return labeledPayload(base, typeId, 'Signature', 'signatureReference', c);
+  return undefined;
+}
+
+export function typedEnvelope(
+  base: Record<string, unknown>,
+  typeId: string | undefined,
+  c: object,
+  ctx: EnvelopeCtx,
+): Record<string, unknown> | undefined {
+  if (typeId === 'reaction') return reactionPayload(base, c as Reaction);
+  if (typeId === 'reply') return replyPayload(base, typeId, c as Reply);
+  if (typeId === 'poll') return pollPayload(base, typeId, c);
+  return (
+    attachmentEnvelope(base, typeId ?? '', c, ctx) ??
+    refEnvelope(base, typeId, c)
+  );
+}

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

@@ -0,0 +1,78 @@
+import type { Conversation, DecodedMessage } from '@xmtp/node-sdk';
+import { lineOf, parseLine } from './accounts.js';
+import { emit, mintId, rememberUid, SELF_URI } from './wire.js';
+import { fcmPushToAll } from './push.js';
+import { emitInbound, emitAttachmentSaved } from './emit-core.js';
+import { typedEnvelope, type EnvelopeCtx } from './emit-payloads.js';
+import type { StructuredEvent } from '@metro-labs/mcp/events';
+
+export { emitInbound, emitAttachmentSaved };
+
+export function envelope(
+  accountId: string,
+  msg: DecodedMessage,
+  conv: Conversation,
+): Record<string, unknown> {
+  const typeId = msg.contentType?.typeId;
+  const c = msg.content;
+  const line = lineOf(accountId, conv.id);
+  const base = {
+    id: mintId(),
+    ts: msg.sentAt.toISOString(),
+    station: 'xmtp',
+    line,
+    from: `metro://xmtp/${accountId}/user/${msg.senderInboxId}`,
+    message_id: msg.id,
+  };
+  rememberUid(base.id, msg.id);
+  if (typeof c === 'string')
+    return { ...base, text: c, payload: { contentType: typeId } };
+  if (c && typeof c === 'object') {
+    const ctx: EnvelopeCtx = {
+      accountId,
+      msgId: msg.id,
+      line,
+      baseId: base.id,
+    };
+    const out = typedEnvelope(base, typeId, c, ctx);
+    if (out) return out;
+  }
+  return {
+    ...base,
+    text: `[${typeId ?? 'unknown'} payload]`,
+    payload: { contentType: typeId },
+  };
+}
+
+export function emitOutbound(
+  accountId: string,
+  line: string,
+  messageId: string,
+  text: string,
+  event?: StructuredEvent,
+): void {
+  const uid = mintId();
+  rememberUid(uid, messageId);
+  emit({
+    kind: 'outbound',
+    id: uid,
+    ts: new Date().toISOString(),
+    station: 'xmtp',
+    line,
+    from: SELF_URI,
+    to: line,
+    message_id: messageId,
+    text,
+    account: accountId,
+    ...(event ? { event } : {}),
+    payload: { account: accountId },
+  });
+  void (async (): Promise<void> => {
+    const data: Record<string, string> = { line, messageId };
+    {
+      const p = parseLine(line);
+      if (p) data.convId = p.convId.toLowerCase();
+    }
+    await fcmPushToAll(accountId, data);
+  })().catch(() => undefined);
+}

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

@@ -0,0 +1,34 @@
+import type {
+  MemberOutcome,
+  MemberOutcomeStatus,
+} from '@metro-labs/mcp/stations/types';
+
+type Args = Record<string, unknown>;
+
+const ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+
+function strList(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((v) => typeof v === 'string' && v.length > 0) as string[];
+}
+
+export function splitMembers(args: Args): {
+  addrs: string[];
+  inboxes: string[];
+} {
+  const addrs = new Set(strList(args.addresses));
+  const inboxes = new Set(strList(args.inboxIds));
+  for (const m of strList(args.members)) {
+    if (ADDRESS_RE.test(m)) addrs.add(m);
+    else inboxes.add(m);
+  }
+  return { addrs: [...addrs], inboxes: [...inboxes] };
+}
+
+export function memberOutcomes(
+  addrs: string[],
+  inboxes: string[],
+  status: MemberOutcomeStatus,
+): MemberOutcome[] {
+  return [...addrs, ...inboxes].map((id) => ({ id, status }));
+}

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

@@ -0,0 +1,56 @@
+import { TrainError } from '@metro-labs/mcp/train-error';
+import type { GroupResult } from '@metro-labs/mcp/stations/types';
+import { accountForCall, convOf, lineOf } from './accounts.js';
+import {
+  applyMemberOp,
+  createGroupWithMembers,
+  warmGroupName,
+} from './conv-helpers.js';
+import { memberOutcomes, splitMembers } from './group-members.js';
+
+type Args = Record<string, unknown>;
+
+export async function groupCreate(args: Args): Promise<GroupResult> {
+  const name = typeof args.name === 'string' ? args.name : '';
+  if (!name) throw new TrainError('INVALID_ARGS', 'groupCreate requires a `name`');
+  const acct = accountForCall(args);
+  const { addrs, inboxes } = splitMembers(args);
+  const group = await createGroupWithMembers(acct, addrs, inboxes, {
+    groupName: name,
+  });
+  warmGroupName(group.id, name);
+  return {
+    capability: { supported: true },
+    line: lineOf(acct.cfg.id, group.id),
+    id: group.id,
+    name,
+    members: memberOutcomes(addrs, inboxes, 'added'),
+  };
+}
+
+async function memberOp(
+  args: Args,
+  mode: 'add' | 'remove',
+  verb: string,
+): Promise<GroupResult> {
+  const line = typeof args.line === 'string' ? args.line : '';
+  if (!line) throw new TrainError('INVALID_ARGS', `${verb} requires a \`line\``);
+  const { addrs, inboxes } = splitMembers(args);
+  if (!addrs.length && !inboxes.length)
+    throw new TrainError('INVALID_ARGS', `${verb} requires members`);
+  const { conv } = await convOf(line);
+  if (!conv) throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
+  await applyMemberOp(conv, addrs, inboxes, mode);
+  return {
+    capability: { supported: true },
+    line,
+    id: conv.id,
+    members: memberOutcomes(addrs, inboxes, mode === 'add' ? 'added' : 'removed'),
+  };
+}
+
+export const groupAddMembers = (args: Args): Promise<GroupResult> =>
+  memberOp(args, 'add', 'groupAddMembers');
+
+export const groupRemoveMembers = (args: Args): Promise<GroupResult> =>
+  memberOp(args, 'remove', 'groupRemoveMembers');

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

@@ -0,0 +1,33 @@
+import { IdentifierKind, type Signer } from '@xmtp/node-sdk';
+import { privateKeyToAccount } from 'viem/accounts';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export const XMTP_ENV = 'production' as const;
+
+export const expandHome = (p: string): string =>
+  p.startsWith('~') ? join(homedir(), p.slice(1)) : p;
+
+export function signerFor(privateKey: string): {
+  signer: Signer;
+  address: string;
+} {
+  const acct = privateKeyToAccount(privateKey as `0x${string}`);
+  const signer: Signer = {
+    type: 'EOA',
+    getIdentifier: () =>
+      Promise.resolve({
+        identifier: acct.address,
+        identifierKind: IdentifierKind.Ethereum,
+      }),
+    signMessage: async (msg: string) => {
+      const sig = await acct.signMessage({ message: msg });
+      const hex = sig.slice(2);
+      const out = new Uint8Array(hex.length / 2);
+      for (let i = 0; i < out.length; i++)
+        out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+      return out;
+    },
+  };
+  return { signer, address: acct.address };
+}

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

@@ -0,0 +1,125 @@
+import { errMsg } from '@metro-labs/mcp/log';
+import { ConsentState, type DecodedMessage } from '@xmtp/node-sdk';
+import {
+  accounts,
+  bootAccount,
+  loadAccounts,
+  type Account,
+} from './accounts.js';
+import { emitInbound, envelope } from './emit.js';
+import { groupNameFor } from './conv-helpers.js';
+import { handleControlDm, pushInbound } from './push.js';
+import { readCalls } from '@metro-labs/mcp/trains/protocol';
+import { handleCall } from './actions.js';
+
+readCalls('xmtp', handleCall);
+
+const SYNC_MS = Number(process.env.XMTP_SYNC_MS ?? '60000');
+const SILENT_TYPES = new Set([
+  'readReceipt',
+  'transactionReference',
+  'walletSendCalls',
+  'groupUpdated',
+  'group_updated',
+]);
+
+async function bootSync(acct: Account): Promise<void> {
+  const { id } = acct.cfg;
+  try {
+    await acct.client.conversations.syncAll([
+      ConsentState.Allowed,
+      ConsentState.Unknown,
+    ]);
+    const initial = await acct.client.conversations.list();
+    process.stderr.write(
+      `xmtp[${id}]: synced ${initial.length} conversation(s) at boot\n`,
+    );
+  } catch (err) {
+    process.stderr.write(
+      `xmtp[${id}] boot sync error: ${errMsg(err)}\n`,
+    );
+  }
+}
+
+function startPeriodicSync(acct: Account): void {
+  const { id } = acct.cfg;
+  setInterval(() => {
+    acct.client.conversations
+      .syncAll([ConsentState.Allowed, ConsentState.Unknown])
+      .catch((err: unknown) => {
+        process.stderr.write(`xmtp[${id}] sync error: ${errMsg(err)}\n`);
+      });
+  }, SYNC_MS).unref();
+}
+
+async function handleStreamMessage(
+  acct: Account,
+  msg: DecodedMessage,
+): Promise<void> {
+  const { id } = acct.cfg;
+  if (msg.senderInboxId === acct.client.inboxId) return;
+  if (SILENT_TYPES.has(msg.contentType?.typeId ?? '')) return;
+  if (handleControlDm(id, msg)) return;
+  const conv = await acct.client.conversations.getConversationById(
+    msg.conversationId,
+  );
+  if (!conv) return;
+  const env = envelope(id, msg, conv);
+  const name = await groupNameFor(msg.conversationId, conv);
+  if (name) {
+    env.line_name = name;
+    env.lineName = name;
+    const p = (env.payload ?? {}) as Record<string, unknown>;
+    env.payload = { ...p, lineName: name };
+  }
+  emitInbound(id, env);
+  pushInbound(id, env, msg, conv);
+}
+
+async function runAccount(acct: Account): Promise<void> {
+  const { id } = acct.cfg;
+  await bootSync(acct);
+  startPeriodicSync(acct);
+
+  for (;;) {
+    try {
+      const stream = await acct.client.conversations.streamAllMessages({
+        consentStates: [ConsentState.Allowed, ConsentState.Unknown],
+      });
+      for await (const msg of stream) {
+        if (!msg) continue;
+        await handleStreamMessage(acct, msg);
+      }
+    } catch (err) {
+      process.stderr.write(
+        `xmtp[${id}] stream error (retry 5s): ${errMsg(err)}\n`,
+      );
+    }
+    await new Promise((r) => setTimeout(r, 5000));
+  }
+}
+
+const cfgs = loadAccounts();
+for (const cfg of cfgs) {
+  try {
+    await bootAccount(cfg);
+  } catch (err) {
+    process.stderr.write(
+      `xmtp[${cfg.id}] boot FAILED: ${errMsg(err)}\n`,
+    );
+  }
+}
+if (accounts.size === 0) {
+  process.stderr.write('xmtp: no accounts booted, exiting\n');
+  process.exit(2);
+}
+process.stderr.write(
+  `xmtp train ready — ${accounts.size} account(s): ${[...accounts.keys()].join(', ')}\n`,
+);
+
+for (const acct of accounts.values())
+  runAccount(acct).catch((err: unknown) => {
+    process.stderr.write(
+      `xmtp[${acct.cfg.id}] account loop failed: ${errMsg(err)}\n`,
+    );
+  });