@stage-labs/metro 0.1.0-beta.8 → 0.1.0-beta.80

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

@@ -0,0 +1,34 @@
+import type {
+  MemberOutcome,
+  MemberOutcomeStatus,
+} from '@metro-labs/core/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/core/train-error';
+import type { GroupResult } from '@metro-labs/core/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/core/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/core/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`,
+    );
+  });

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

@@ -0,0 +1,157 @@
+export interface GroupLike {
+  id: string;
+  appData?: string;
+  updateAppData?: (s: string) => Promise<void>;
+  updateName?: (s: string) => Promise<void>;
+  updateDescription?: (s: string) => Promise<void>;
+  removeMembers?: (inboxIds: string[]) => Promise<void>;
+  sync?: () => Promise<unknown>;
+}
+
+const MAX_LABELS = 16;
+const MAX_LABEL_LEN = 24;
+
+export function cleanLabels(raw: unknown): string[] {
+  if (!Array.isArray(raw)) return [];
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const item of raw) {
+    if (typeof item !== 'string') continue;
+    const label = item.trim().replace(/\s+/g, ' ').slice(0, MAX_LABEL_LEN);
+    const key = label.toLowerCase();
+    if (!label || seen.has(key)) continue;
+    seen.add(key);
+    out.push(label);
+    if (out.length >= MAX_LABELS) break;
+  }
+  return out;
+}
+
+function parseAppDataObject(
+  existingAppData: string | undefined,
+): Record<string, unknown> {
+  if (!existingAppData?.trim()) return {};
+  try {
+    const p: unknown = JSON.parse(existingAppData);
+    if (p && typeof p === 'object' && !Array.isArray(p))
+      return p as Record<string, unknown>;
+  } catch {
+    return {};
+  }
+  return {};
+}
+
+export function labelsBlob(
+  existingAppData: string | undefined,
+  labels: string[],
+  github?: string,
+): string {
+  const existing = parseAppDataObject(existingAppData);
+  const blob: Record<string, unknown> = {
+    ...existing,
+    v: 1,
+    labels: cleanLabels(labels),
+  };
+  if (typeof github === 'string') {
+    if (github.trim()) blob.github = github.trim();
+    else delete blob.github;
+  }
+  return JSON.stringify(blob);
+}
+
+function trimmedString(v: unknown): string | undefined {
+  return typeof v === 'string' && v.trim() ? v.trim() : undefined;
+}
+
+export function readAppData(appData: string | undefined): {
+  labels: string[];
+  github?: string;
+  preview?: string;
+} {
+  if (!appData?.trim()) return { labels: [] };
+  try {
+    const p: unknown = JSON.parse(appData);
+    if (!p || typeof p !== 'object' || Array.isArray(p)) return { labels: [] };
+    const rec = p as Record<string, unknown>;
+    return {
+      labels: cleanLabels(rec.labels),
+      github: trimmedString(rec.github),
+      preview: trimmedString(rec.preview),
+    };
+  } catch {
+    return { labels: [] };
+  }
+}
+
+function applyMergeKey(
+  merged: Record<string, unknown>,
+  k: string,
+  v: unknown,
+): void {
+  if (k === 'labels') {
+    merged.labels = cleanLabels(v);
+    return;
+  }
+  if (k === 'github') {
+    const g = normalizeGithubUrl(v);
+    if (g) merged.github = g;
+    else delete merged.github;
+    return;
+  }
+  if (k === 'preview') {
+    const p = normalizePreviewUrl(v);
+    if (p) merged.preview = p;
+    else delete merged.preview;
+    return;
+  }
+  if (v === undefined || v === null) Reflect.deleteProperty(merged, k);
+  else merged[k] = v;
+}
+
+export function mergeAppData(
+  existingAppData: string | undefined,
+  patch: Record<string, unknown>,
+): { blob: string; merged: Record<string, unknown> } {
+  const merged: Record<string, unknown> = {
+    ...parseAppDataObject(existingAppData),
+    v: 1,
+  };
+  for (const [k, v] of Object.entries(patch)) applyMergeKey(merged, k, v);
+  return { blob: JSON.stringify(merged), merged };
+}
+
+export function normalizeGithubUrl(url: unknown): string {
+  if (typeof url !== 'string')
+    throw new Error('setGithub requires a `url` string');
+  const trimmed = url.trim();
+  if (!trimmed) return '';
+  let parsed: URL;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw new Error(`invalid url: ${trimmed}`);
+  }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    throw new Error(`github url must be http(s): ${trimmed}`);
+  }
+  if (
+    parsed.hostname !== 'github.com' &&
+    parsed.hostname !== 'www.github.com'
+  ) {
+    throw new Error(`url must be a github.com URL: ${trimmed}`);
+  }
+  return trimmed;
+}
+
+export function normalizePreviewUrl(url: unknown): string {
+  if (typeof url !== 'string')
+    throw new Error('setPreview requires a `preview` string');
+  const trimmed = url.trim();
+  if (!trimmed) return '';
+  try {
+    new URL(trimmed);
+  } catch {
+    throw new Error(`invalid preview url: ${trimmed}`);
+  }
+  return trimmed;
+}

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

@@ -0,0 +1,40 @@
+import { TrainError } from '@metro-labs/core/train-error';
+
+type Args = Record<string, unknown>;
+
+export function filterStrings(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((a) => typeof a === 'string' && a.length > 0) as string[];
+}
+
+export function resolveMembers(args: Args): {
+  addrs: string[];
+  inboxes: string[];
+} {
+  const { addresses, inboxIds, memberAddresses, memberInboxIds } = args as {
+    addresses?: string[];
+    inboxIds?: string[];
+    memberAddresses?: string[];
+    memberInboxIds?: string[];
+  };
+  return {
+    addrs: filterStrings(addresses ?? memberAddresses),
+    inboxes: filterStrings(inboxIds ?? memberInboxIds),
+  };
+}
+
+export function parseMemberArgs(
+  args: Args,
+  verb: string,
+): { line: string; addrs: string[]; inboxes: string[] } {
+  const { line } = args as { line: string };
+  if (!line || typeof line !== 'string')
+    throw new TrainError('INVALID_ARGS', `${verb} requires a \`line\``);
+  const { addrs, inboxes } = resolveMembers(args);
+  if (addrs.length === 0 && inboxes.length === 0)
+    throw new TrainError(
+      'INVALID_ARGS',
+      `${verb} requires addresses[] or inboxIds[]`,
+    );
+  return { line, addrs, inboxes };
+}