@stage-labs/metro 0.1.0-beta.3 → 0.1.0-beta.31

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

@@ -0,0 +1,239 @@
+import { IdentifierKind } from '@xmtp/node-sdk';
+import { convOf, type Account } from './accounts.js';
+import { inboxEthCache, cacheInboxEth } from './wire.js';
+import { TrainError } from '@metro-labs/mcp/train-error';
+import type { MemberList, MetroMember } from '@metro-labs/mcp/stations/types';
+import { readAppData, type GroupLike } from './labels.js';
+
+export { parseMemberArgs, resolveMembers } from './member-args.js';
+
+type Conv = Awaited<ReturnType<typeof convOf>>['conv'] & object;
+export interface EthId {
+  identifier: string;
+  identifierKind: IdentifierKind;
+}
+
+export function ethIdentifiers(addrs: string[]): EthId[] {
+  return addrs.map((a) => ({
+    identifier: a,
+    identifierKind: IdentifierKind.Ethereum,
+  }));
+}
+
+export async function createGroupWithMembers(
+  acct: Account,
+  addrs: string[],
+  inboxes: string[],
+  opts: { groupName: string; groupDescription?: string; appData?: string },
+): Promise<GroupLike> {
+  if (!addrs.length)
+    return acct.client.conversations.createGroup(inboxes, opts);
+  const created = await acct.client.conversations.createGroupWithIdentifiers(
+    ethIdentifiers(addrs),
+    opts,
+  );
+  if (inboxes.length)
+    await (
+      created as unknown as { addMembers: (ids: string[]) => Promise<unknown> }
+    ).addMembers(inboxes);
+  return created;
+}
+
+async function resolveAddresses(
+  acct: Account,
+  inboxIds: string[],
+): Promise<Record<string, string>> {
+  const addresses: Record<string, string> = {};
+  const missing = inboxIds.filter((iid) => {
+    const cached = inboxEthCache.get(iid);
+    if (cached) {
+      addresses[iid] = cached;
+      return false;
+    }
+    return true;
+  });
+  if (!missing.length) return addresses;
+  try {
+    const states = await acct.client.preferences.fetchInboxStates(missing);
+    for (let i = 0; i < missing.length; i++) {
+      const key = missing[i];
+      if (key === undefined) continue;
+      const eth = states[i]?.identifiers.find(
+        (it: { identifierKind: IdentifierKind }) =>
+          it.identifierKind === IdentifierKind.Ethereum,
+      );
+      if (eth?.identifier) {
+        addresses[key] = eth.identifier;
+        cacheInboxEth(key, eth.identifier);
+      }
+    }
+  } catch {
+    return addresses;
+  }
+  return addresses;
+}
+
+export async function buildGroupInfo(
+  line: string,
+  acct: Account,
+  conv: Conv,
+): Promise<Record<string, unknown>> {
+  const inboxIds = (await conv.members()).map((m) => m.inboxId);
+  const addresses = await resolveAddresses(acct, inboxIds);
+  const isDm =
+    typeof (conv as unknown as { peerInboxId?: unknown }).peerInboxId ===
+    'function';
+  const gn = (conv as unknown as { name?: string | (() => Promise<string>) })
+    .name;
+  const resolvedName = typeof gn === 'function' ? await gn() : (gn ?? '');
+  const { labels, github, preview } = readAppData(
+    (conv as unknown as GroupLike).appData,
+  );
+  return {
+    line,
+    id: conv.id,
+    account: acct.cfg.id,
+    version: isDm ? 'dm' : 'group',
+    name: resolvedName ?? '',
+    memberCount: inboxIds.length,
+    labels,
+    github,
+    preview,
+    members: inboxIds.map((iid) => ({
+      inboxId: iid,
+      address: addresses[iid] ?? null,
+    })),
+  };
+}
+
+interface RawMember {
+  inboxId: string;
+  permissionLevel?: number;
+}
+
+function toMetroMember(
+  m: RawMember,
+  addresses: Record<string, string>,
+): MetroMember {
+  const member: MetroMember = { id: m.inboxId };
+  const address = addresses[m.inboxId];
+  if (address) member.address = address;
+  if (typeof m.permissionLevel === 'number')
+    member.is_admin = m.permissionLevel >= 1;
+  return member;
+}
+
+export async function buildMemberList(
+  acct: Account,
+  conv: Conv,
+): Promise<MemberList> {
+  const raw = (await conv.members()) as RawMember[];
+  const addresses = await resolveAddresses(
+    acct,
+    raw.map((m) => m.inboxId),
+  );
+  return {
+    members: raw.map((m) => toMetroMember(m, addresses)),
+    capability: { supported: true, complete: true, total: raw.length },
+  };
+}
+
+interface MemberGroup {
+  sync?: () => Promise<unknown>;
+  addMembers?: (ids: string[]) => Promise<unknown>;
+  addMembersByIdentifiers?: (ids: EthId[]) => Promise<unknown>;
+  removeMembers?: (ids: string[]) => Promise<unknown>;
+  removeMembersByIdentifiers?: (ids: EthId[]) => Promise<unknown>;
+}
+
+async function applyByIdentifiers(
+  group: MemberGroup,
+  byIdent: ((ids: EthId[]) => Promise<unknown>) | undefined,
+  addrs: string[],
+  verb: string,
+): Promise<void> {
+  if (!addrs.length) return;
+  if (typeof byIdent !== 'function')
+    throw new TrainError(
+      'INVALID_ARGS',
+      `group does not support ${verb}ByIdentifiers; pass inboxIds instead`,
+    );
+  await byIdent.call(group, ethIdentifiers(addrs));
+}
+
+async function applyByInboxId(
+  group: MemberGroup,
+  byId: ((ids: string[]) => Promise<unknown>) | undefined,
+  inboxes: string[],
+  verb: string,
+): Promise<void> {
+  if (!inboxes.length) return;
+  if (typeof byId !== 'function')
+    throw new TrainError(
+      'INVALID_ARGS',
+      `group does not support ${verb} by inboxId`,
+    );
+  await byId.call(group, inboxes);
+}
+
+export async function applyMemberOp(
+  conv: Conv,
+  addrs: string[],
+  inboxes: string[],
+  mode: 'add' | 'remove',
+): Promise<void> {
+  const group = conv as unknown as MemberGroup;
+  const byId = mode === 'add' ? group.addMembers : group.removeMembers;
+  const byIdent =
+    mode === 'add'
+      ? group.addMembersByIdentifiers
+      : group.removeMembersByIdentifiers;
+  const verb = mode === 'add' ? 'addMembers' : 'removeMembers';
+  if (typeof byId !== 'function' && typeof byIdent !== 'function')
+    throw new TrainError(
+      'INVALID_ARGS',
+      `${verb} target is not a group (no ${verb})`,
+    );
+  await group.sync?.().catch(() => undefined);
+  await applyByIdentifiers(group, byIdent, addrs, verb);
+  await applyByInboxId(group, byId, inboxes, verb);
+}
+
+const NAME_CACHE_MAX = 5000;
+const convNameCache = new Map<string, string>();
+
+function remember(convId: string, name: string): void {
+  convNameCache.delete(convId);
+  convNameCache.set(convId, name);
+  if (convNameCache.size > NAME_CACHE_MAX) {
+    const oldest = convNameCache.keys().next().value;
+    if (oldest !== undefined) convNameCache.delete(oldest);
+  }
+}
+
+async function readName(conv: unknown): Promise<string> {
+  try {
+    if (typeof (conv as { peerInboxId?: unknown }).peerInboxId === 'function')
+      return '';
+    const n = (conv as { name?: string | (() => Promise<string>) }).name;
+    const resolved = typeof n === 'function' ? await n() : n;
+    return typeof resolved === 'string' ? resolved : '';
+  } catch {
+    return '';
+  }
+}
+
+export async function groupNameFor(
+  convId: string,
+  conv: unknown,
+): Promise<string> {
+  const cached = convNameCache.get(convId);
+  if (cached !== undefined) return cached;
+  const name = await readName(conv);
+  remember(convId, name);
+  return name;
+}
+
+export function warmGroupName(convId: string, name: string | undefined): void {
+  if (typeof name === 'string' && name) remember(convId, name);
+}

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

@@ -0,0 +1,55 @@
+import { accounts } from './accounts.js';
+import { emit, mintId, SELF_URI } from './wire.js';
+
+export function emitInbound(
+  accountId: string,
+  e: Record<string, unknown>,
+): void {
+  const acct = accounts.get(accountId);
+  const owner = acct?.cfg.owner;
+  const payload = {
+    ...(e.payload as Record<string, unknown> | undefined),
+    account: accountId,
+  };
+  emit({
+    kind: 'inbound',
+    ...e,
+    ...(owner ? { to: owner } : {}),
+    account: accountId,
+    payload,
+  });
+}
+
+export function emitAttachmentSaved(
+  accountId: string,
+  line: string,
+  sourceMsgId: string,
+  index: number,
+  save: Promise<{ path: string; mime?: string; name?: string }>,
+): void {
+  void save
+    .then((saved) => {
+      emitInbound(accountId, {
+        id: mintId(),
+        ts: new Date().toISOString(),
+        station: 'xmtp',
+        line,
+        from: SELF_URI,
+        text: `📎 saved: ${saved.path}`,
+        payload: {
+          contentType: 'attachmentSaved',
+          attachmentFor: sourceMsgId,
+          index,
+          attachmentPath: saved.path,
+          localPath: saved.path,
+          mime: saved.mime,
+          name: saved.name,
+        },
+      });
+    })
+    .catch((err: unknown) =>
+      process.stderr.write(
+        `xmtp attachment save failed: ${err instanceof Error ? err.message : String(err)}\n`,
+      ),
+    );
+}

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);
+}