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

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

@@ -0,0 +1,171 @@
+import type {
+  ContentTypeId,
+  ContentCodec,
+  EncodedContent,
+} from '@xmtp/content-type-primitives';
+
+const enc = (o: unknown): Uint8Array =>
+  new TextEncoder().encode(JSON.stringify(o));
+const dec = (e: EncodedContent): unknown =>
+  JSON.parse(new TextDecoder().decode(e.content));
+
+const makeJsonCodec = <T>(
+  contentType: ContentTypeId,
+  fallbackFn: (c: T) => string,
+) =>
+  class {
+    get contentType() {
+      return contentType;
+    }
+    encode(c: T): EncodedContent {
+      return {
+        type: contentType,
+        parameters: {},
+        fallback: fallbackFn(c),
+        content: enc(c),
+      };
+    }
+    decode(e: EncodedContent): T {
+      return dec(e) as T;
+    }
+    fallback(c: T) {
+      return fallbackFn(c);
+    }
+    shouldPush() {
+      return true;
+    }
+  };
+
+export const ContentTypePoll: ContentTypeId = {
+  authorityId: 'metro.box',
+  typeId: 'poll',
+  versionMajor: 1,
+  versionMinor: 0,
+};
+export interface PollOption {
+  label: string;
+  description?: string;
+}
+export interface PollQuestion {
+  question: string;
+  header?: string;
+  multiSelect?: boolean;
+  open?: boolean;
+  options?: (PollOption | string)[];
+}
+export interface PollContent {
+  questions?: PollQuestion[];
+  question?: string;
+  header?: string;
+  multiSelect?: boolean;
+  pollId?: string;
+  options?: (PollOption | string)[];
+  [k: string]: unknown;
+}
+const pollTitle = (c: PollContent): string =>
+  c.questions?.[0]?.question ?? c.question ?? 'Poll';
+export const PollCodec = makeJsonCodec<PollContent>(
+  ContentTypePoll,
+  (c) => `📊 Poll: ${pollTitle(c)}`,
+);
+
+const normOpts = (o: (string | PollOption)[]): PollOption[] =>
+  o.map((x) =>
+    typeof x === 'string'
+      ? { label: x }
+      : { label: x.label, description: x.description },
+  );
+
+export function buildPollContent(
+  args: Record<string, unknown>,
+  pollId: string,
+): { poll: PollContent; title: string } {
+  const { question, options, header, multiSelect, questions } = args as {
+    question?: string;
+    options?: (string | PollOption)[];
+    header?: string;
+    multiSelect?: boolean;
+    questions?: PollQuestion[];
+  };
+  if (Array.isArray(questions) && questions.length > 0) {
+    const norm: PollQuestion[] = questions.map((q, i) => {
+      if (!q || typeof q.question !== 'string' || !q.question)
+        throw new Error(`ask questions[${i}] requires a question`);
+      const open = q.open === true;
+      const opts = Array.isArray(q.options) ? q.options : [];
+      if (!open && opts.length === 0)
+        throw new Error(
+          `ask questions[${i}] requires a non-empty options array (or open:true for free-text)`,
+        );
+      return {
+        question: q.question,
+        options: normOpts(opts),
+        multiSelect: !!q.multiSelect,
+        ...(open ? { open: true } : {}),
+        ...(q.header ? { header: q.header } : {}),
+      };
+    });
+    const first = norm[0];
+    if (!first) throw new Error('ask requires at least one question');
+    return { poll: { questions: norm, pollId }, title: first.question };
+  }
+  if (!question || typeof question !== 'string')
+    throw new Error('ask requires a question (or a questions[] array)');
+  if (!Array.isArray(options) || options.length === 0)
+    throw new Error('ask requires a non-empty options array');
+  return {
+    poll: {
+      question,
+      options: normOpts(options),
+      multiSelect: !!multiSelect,
+      pollId,
+      ...(header ? { header } : {}),
+    },
+    title: question,
+  };
+}
+
+export const ContentTypeSignatureRequest: ContentTypeId = {
+  authorityId: 'metro.box',
+  typeId: 'signatureRequest',
+  versionMajor: 1,
+  versionMinor: 0,
+};
+export interface SignatureRequestContent {
+  id?: string;
+  kind?: 'eip712' | 'personal';
+  eip712?: unknown;
+  message?: string;
+  description?: string;
+  [k: string]: unknown;
+}
+export const SignatureRequestCodec = makeJsonCodec<SignatureRequestContent>(
+  ContentTypeSignatureRequest,
+  (c) =>
+    c.description
+      ? `[Signature request] ${c.description}`
+      : '[Signature request]',
+);
+
+export const ContentTypeSignatureReference: ContentTypeId = {
+  authorityId: 'metro.box',
+  typeId: 'signatureReference',
+  versionMajor: 1,
+  versionMinor: 0,
+};
+export interface SignatureReferenceContent {
+  requestId?: string;
+  signature: string;
+  signer?: string;
+  [k: string]: unknown;
+}
+export const SignatureReferenceCodec =
+  makeJsonCodec<SignatureReferenceContent>(ContentTypeSignatureReference, (c) =>
+    c.signature ? `[Signature] ${c.signature}` : '[Signature]',
+  );
+
+export const CODECS = (): ContentCodec[] => [
+  new PollCodec(),
+  new SignatureRequestCodec(),
+  new SignatureReferenceCodec(),
+];

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