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

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/mcp/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 };
+}

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

@@ -0,0 +1,349 @@
+import { errMsg } from '@metro-labs/mcp/log';
+import { type DecodedMessage } from '@xmtp/node-sdk';
+import { existsSync, readFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { readJson, writeJson } from '@metro-labs/mcp/secure-fs';
+import { parseLine } from './accounts.js';
+
+const FCM_SVC_PATH = `${process.env.HOME}/.config/metro/firebase-service-account.json`;
+const FCM_TOKENS_PATH = `${process.env.HOME}/.cache/metro/xmtp-push-tokens.json`;
+interface FcmServiceAccount {
+  client_email: string;
+  private_key: string;
+  project_id: string;
+  token_uri: string;
+}
+
+interface StoredPushToken {
+  token: string;
+  registeredAt: string;
+  account?: string;
+  inboxId?: string;
+  inboxIds?: string[];
+  platform?: string;
+  lastSeenAt?: string;
+}
+
+function loadFcmSvc(): FcmServiceAccount | null {
+  if (!existsSync(FCM_SVC_PATH)) return null;
+  try {
+    return JSON.parse(readFileSync(FCM_SVC_PATH, 'utf8')) as FcmServiceAccount;
+  } catch (err) {
+    process.stderr.write(
+      `fcm: bad service account: ${errMsg(err)}\n`,
+    );
+    return null;
+  }
+}
+export function loadPushTokens(): StoredPushToken[] {
+  return readJson<StoredPushToken[]>(FCM_TOKENS_PATH, []);
+}
+export function savePushTokens(tokens: StoredPushToken[]): void {
+  mkdirSync(dirname(FCM_TOKENS_PATH), { recursive: true });
+  writeJson(FCM_TOKENS_PATH, tokens);
+}
+
+function collectInboxIds(
+  existing: StoredPushToken | undefined,
+  entryInboxId: string | undefined,
+): Set<string> {
+  const inboxIds = new Set<string>(existing?.inboxIds ?? []);
+  if (existing?.inboxId) inboxIds.add(existing.inboxId);
+  if (entryInboxId) inboxIds.add(entryInboxId);
+  return inboxIds;
+}
+
+export function storePushToken(entry: {
+  token: string;
+  account?: string;
+  inboxId?: string;
+  platform?: string;
+}): number {
+  const now = new Date().toISOString();
+  const all = loadPushTokens();
+  const existing = all.find((t) => t.token === entry.token);
+  const remaining = all.filter((t) => t.token !== entry.token);
+  const inboxIds = collectInboxIds(existing, entry.inboxId);
+  const row: StoredPushToken = {
+    token: entry.token,
+    registeredAt: existing?.registeredAt ?? now,
+    lastSeenAt: now,
+  };
+  if (entry.account) row.account = entry.account;
+  if (entry.inboxId) row.inboxId = entry.inboxId;
+  if (inboxIds.size) row.inboxIds = [...inboxIds];
+  if (entry.platform) row.platform = entry.platform;
+  remaining.push(row);
+  savePushTokens(remaining);
+  return remaining.length;
+}
+
+let cachedAccessToken: { token: string; expiresAt: number } | null = null;
+async function fcmAccessToken(): Promise<string | null> {
+  const svc = loadFcmSvc();
+  if (!svc) return null;
+  if (cachedAccessToken && cachedAccessToken.expiresAt > Date.now() + 60_000)
+    return cachedAccessToken.token;
+  const { createSign } = await import('node:crypto');
+  const enc = (o: unknown): string =>
+    Buffer.from(JSON.stringify(o)).toString('base64url');
+  const now = Math.floor(Date.now() / 1000);
+  const header = { alg: 'RS256', typ: 'JWT' };
+  const payload = {
+    iss: svc.client_email,
+    scope: 'https://www.googleapis.com/auth/firebase.messaging',
+    aud: svc.token_uri,
+    iat: now,
+    exp: now + 3600,
+  };
+  const sigInput = `${enc(header)}.${enc(payload)}`;
+  const signer = createSign('RSA-SHA256');
+  signer.update(sigInput);
+  signer.end();
+  const sig = signer.sign(svc.private_key).toString('base64url');
+  const jwt = `${sigInput}.${sig}`;
+  const grant = encodeURIComponent(
+    'urn:ietf:params:oauth:grant-type:jwt-bearer',
+  );
+  const res = await fetch(svc.token_uri, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: `grant_type=${grant}&assertion=${jwt}`,
+    signal: AbortSignal.timeout(15_000),
+  });
+  if (!res.ok) {
+    process.stderr.write(
+      `fcm token exchange ${res.status}: ${await res.text()}\n`,
+    );
+    return null;
+  }
+  const json = (await res.json()) as {
+    access_token: string;
+    expires_in: number;
+  };
+  cachedAccessToken = {
+    token: json.access_token,
+    expiresAt: Date.now() + json.expires_in * 1000,
+  };
+  return cachedAccessToken.token;
+}
+
+async function fcmPushTo(
+  deviceToken: string,
+  data: Record<string, string> = {},
+): Promise<void> {
+  const svc = loadFcmSvc();
+  if (!svc) return;
+  const at = await fcmAccessToken();
+  if (!at) return;
+  const url = `https://fcm.googleapis.com/v1/projects/${svc.project_id}/messages:send`;
+  const payloadData: Record<string, string> = { channelId: 'xmtp', ...data };
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${at}`,
+    },
+    body: JSON.stringify({
+      message: {
+        token: deviceToken,
+        android: { priority: 'HIGH' },
+        data: payloadData,
+      },
+    }),
+    signal: AbortSignal.timeout(15_000),
+  });
+  if (!res.ok) {
+    const txt = await res.text().catch(() => '');
+    const dead =
+      res.status === 404 ||
+      txt.includes('UNREGISTERED') ||
+      txt.includes('NOT_FOUND') ||
+      txt.includes('registration-token-not-registered') ||
+      txt.includes('NotRegistered');
+    if (dead) {
+      removePushToken(deviceToken);
+      process.stderr.write(
+        `fcm: pruned stale token ${deviceToken.slice(0, 12)}…\n`,
+      );
+      return;
+    }
+    process.stderr.write(`fcm push ${res.status}: ${txt}\n`);
+  }
+}
+
+function freshestPerAccount(tokens: StoredPushToken[]): StoredPushToken[] {
+  const freshness = (t: StoredPushToken): number =>
+    new Date(t.lastSeenAt ?? t.registeredAt ?? 0).getTime();
+  const byAccount = new Map<string, StoredPushToken>();
+  const unscoped: StoredPushToken[] = [];
+  for (const t of tokens) {
+    if (!t.account) {
+      unscoped.push(t);
+      continue;
+    }
+    const cur = byAccount.get(t.account);
+    if (!cur || freshness(t) >= freshness(cur)) byAccount.set(t.account, t);
+  }
+  return [...byAccount.values(), ...unscoped];
+}
+
+export async function fcmPushToAll(
+  accountId: string,
+  data: Record<string, string> = {},
+  excludeInboxId?: string,
+): Promise<void> {
+  const tokens = loadPushTokens().filter((t) => {
+    if (t.account && t.account !== accountId) return false;
+    if (
+      excludeInboxId &&
+      (t.inboxId === excludeInboxId || t.inboxIds?.includes(excludeInboxId))
+    )
+      return false;
+    return true;
+  });
+  const deduped = freshestPerAccount(tokens);
+  if (deduped.length === 0) return;
+  await Promise.all(
+    deduped.map((t) =>
+      fcmPushTo(t.token, { ...data, account: accountId }).catch(
+        () => undefined,
+      ),
+    ),
+  );
+}
+
+const METRO_CTRL_PREFIX = 'METRO_CTRL:';
+const CTRL_REGISTER_PUSH = 'register-push';
+const CTRL_DISABLE_PUSH = 'disable-push';
+
+export function removePushToken(token: string): number {
+  const all = loadPushTokens();
+  const remaining = all.filter((t) => t.token !== token);
+  if (remaining.length === all.length) return -1;
+  savePushTokens(remaining);
+  return remaining.length;
+}
+
+function isMetroControlBody(text: unknown): text is string {
+  return typeof text === 'string' && text.startsWith(METRO_CTRL_PREFIX);
+}
+
+interface RegisterPushPayload {
+  v?: number;
+  token: string;
+  platform?: string;
+  address?: string;
+  inboxId?: string;
+}
+interface DisablePushPayload {
+  v?: number;
+  token: string;
+  address?: string;
+  inboxId?: string;
+}
+
+function isValidPushToken(token: unknown): token is string {
+  return typeof token === 'string' && token.length >= 20;
+}
+
+function handleRegisterPushCtrl(
+  accountId: string,
+  msg: DecodedMessage,
+  arg: string,
+): void {
+  const obj = JSON.parse(arg) as Partial<RegisterPushPayload>;
+  if (!obj || !isValidPushToken(obj.token)) {
+    process.stderr.write(
+      `xmtp[${accountId}]: register-push (ctrl-dm) ignored — bad/short token\n`,
+    );
+    return;
+  }
+  const total = storePushToken({
+    token: obj.token,
+    account: accountId,
+    inboxId: msg.senderInboxId,
+    platform: typeof obj.platform === 'string' ? obj.platform : undefined,
+  });
+  process.stderr.write(
+    `xmtp[${accountId}]: register-push (ctrl-dm) stored token ${obj.token.slice(0, 12)}… ` +
+      `from inbox ${msg.senderInboxId.slice(0, 10)}… (v=${obj.v ?? '?'}, ${total} total)\n`,
+  );
+}
+
+function handleDisablePushCtrl(accountId: string, arg: string): void {
+  const obj = JSON.parse(arg) as Partial<DisablePushPayload>;
+  if (!obj || !isValidPushToken(obj.token)) {
+    process.stderr.write(
+      `xmtp[${accountId}]: disable-push (ctrl-dm) ignored — bad/short token\n`,
+    );
+    return;
+  }
+  const remaining = removePushToken(obj.token);
+  process.stderr.write(
+    `xmtp[${accountId}]: disable-push (ctrl-dm) token ${obj.token.slice(0, 12)}… ` +
+      (remaining === -1
+        ? 'not found (already gone)\n'
+        : `removed (v=${obj.v ?? '?'}, ${remaining} remain)\n`),
+  );
+}
+
+export function handleControlDm(
+  accountId: string,
+  msg: DecodedMessage,
+): boolean {
+  const body = msg.content;
+  if (!isMetroControlBody(body)) return false;
+  const rest = body.slice(METRO_CTRL_PREFIX.length);
+  const sep = rest.indexOf(':');
+  const verb = sep === -1 ? rest : rest.slice(0, sep);
+  const arg = sep === -1 ? '' : rest.slice(sep + 1);
+  try {
+    if (verb === CTRL_REGISTER_PUSH) {
+      handleRegisterPushCtrl(accountId, msg, arg);
+    } else if (verb === CTRL_DISABLE_PUSH) {
+      handleDisablePushCtrl(accountId, arg);
+    } else {
+      process.stderr.write(
+        `xmtp[${accountId}]: unknown control verb '${verb}' — swallowed\n`,
+      );
+    }
+  } catch (err) {
+    process.stderr.write(
+      `xmtp[${accountId}]: control DM '${verb}' FAILED: ${errMsg(err)}\n`,
+    );
+  }
+  return true;
+}
+
+export function pushInbound(
+  accountId: string,
+  env: Record<string, unknown>,
+  msg: DecodedMessage,
+  conv?: unknown,
+): void {
+  const line = typeof env.line === 'string' ? env.line : '';
+  const messageId =
+    typeof env.message_id === 'string'
+      ? env.message_id
+      : typeof env.id === 'string'
+        ? env.id
+        : '';
+  void (async (): Promise<void> => {
+    const data: Record<string, string> = {
+      line,
+      messageId,
+      account: accountId,
+    };
+    {
+      const p = parseLine(line);
+      if (p) data.convId = p.convId.toLowerCase();
+    }
+    if (conv) {
+      const isDm =
+        typeof (conv as { peerInboxId?: unknown }).peerInboxId === 'function';
+      if (!isDm) data.isGroup = 'true';
+    }
+    await fcmPushToAll(accountId, data, msg.senderInboxId);
+  })().catch(() => undefined);
+}

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

@@ -0,0 +1,13 @@
+import type { GroupOp, Station, Verb } from '@metro-labs/mcp/stations/types';
+import { XMTP_TOOLS, xmtpSendAttachments } from './tools.js';
+
+export const xmtpStation: Station = {
+  name: 'xmtp',
+  hasAccounts: true,
+  hasTrain: true,
+  messageVerbs: new Set<Verb>(['send', 'reply', 'react', 'unreact', 'read']),
+  groupOps: new Set<GroupOp>(['create_group', 'add_members', 'remove_members']),
+  attachmentMode: 'native',
+  sendAttachments: xmtpSendAttachments,
+  tools: XMTP_TOOLS,
+};

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

@@ -0,0 +1,126 @@
+import type { CanonicalAttachment, ToolContext } from '@metro-labs/mcp/stations/types';
+import { TrainError } from '@metro-labs/mcp/train-error';
+import {
+  guessMime,
+  isImageMime,
+  isImageExt,
+  kindOf,
+} from '@metro-labs/mcp/stations/attachments';
+
+export const str = (v: unknown): string => (typeof v === 'string' ? v : '');
+
+function strList(value: unknown): string[] {
+  return (value as unknown[] | undefined)?.map(String).filter(Boolean) ?? [];
+}
+
+interface CreatedGroup {
+  line?: string;
+  id?: string;
+  account?: string;
+}
+
+async function applyCreateLabels(
+  line: string,
+  labels: string[],
+  ctx: ToolContext,
+): Promise<unknown> {
+  if (!labels.length) return undefined;
+  return ctx.call('updateChannelMeta', { line, appData: { labels } });
+}
+
+export async function createChannel(
+  a: Record<string, unknown>,
+  ctx: ToolContext,
+) {
+  const addresses = strList(a.addresses);
+  const channelName = str(a.name);
+  const labels = strList(a.labels);
+  const account = str(a.account) || undefined;
+  if (!addresses.length)
+    return ctx.err('create_channel requires a non-empty `addresses` array');
+  if (!channelName) return ctx.err('create_channel requires `name`');
+  const groupArgs: Record<string, unknown> = { addresses, name: channelName };
+  if (account) groupArgs.account = account;
+  const { result } = (await ctx.call('newGroup', groupArgs)) as {
+    result: CreatedGroup | null;
+  };
+  const newLine = result?.line ?? '';
+  const labelResult = newLine.length
+    ? await applyCreateLabels(newLine, labels, ctx)
+    : undefined;
+  return ctx.okJson({
+    line: newLine,
+    convId: result?.id,
+    account: result?.account,
+    labels: labelResult,
+  });
+}
+
+export async function setChannelMetadata(
+  a: Record<string, unknown>,
+  ctx: ToolContext,
+) {
+  const line = str(a.line);
+  if (!line) return ctx.err('set_channel_metadata requires `line`');
+  const labels = a.labels as unknown[] | undefined;
+  const github = a.github as string | undefined;
+  const preview = a.preview as string | undefined;
+  const metaName = a.name as string | undefined;
+  const appData: Record<string, unknown> = {};
+  if (Array.isArray(labels)) appData.labels = labels.map(String);
+  if (typeof github === 'string') appData.github = github;
+  if (typeof preview === 'string') appData.preview = preview;
+  const hasName = typeof metaName === 'string' && metaName.length > 0;
+  if (!hasName && Object.keys(appData).length === 0)
+    return ctx.err(
+      'set_channel_metadata requires at least one of `labels`, `github`, `preview`, `name`',
+    );
+  const callArgs: Record<string, unknown> = { line, appData };
+  if (hasName) callArgs.name = metaName;
+  return ctx.okJson(await ctx.call('updateChannelMeta', callArgs));
+}
+
+const XMTP_ATTACH_MAX_BYTES = 190 * 1024;
+
+async function sendFileAttachment(
+  line: string,
+  a: CanonicalAttachment,
+  src: string,
+  ctx: ToolContext,
+): Promise<void> {
+  const buf = await ctx.readFile(src);
+  if (buf.byteLength > XMTP_ATTACH_MAX_BYTES) {
+    throw new TrainError(
+      'attachment_too_large',
+      `attachment '${src}' is ${(buf.byteLength / 1024).toFixed(0)} KiB; xmtp non-image files ` +
+        'over ~190 KiB (256 KiB once base64-encoded) cannot be sent via this MCP path. ' +
+        'Send it as an image, host it elsewhere, or use the metro CLI directly.',
+    );
+  }
+  await ctx.call('sendAttachment', {
+    line,
+    name: a.name ?? src.split('/').pop() ?? 'attachment',
+    mime: a.mime ?? guessMime(src),
+    dataB64: buf.toString('base64'),
+  });
+}
+
+export async function xmtpSendAttachments(
+  line: string,
+  atts: CanonicalAttachment[],
+  ctx: ToolContext,
+): Promise<string[]> {
+  const sent: string[] = [];
+  for (const a of atts) {
+    const src = a.path ?? a.url ?? '';
+    if (!src) continue;
+    const mime = a.mime ?? guessMime(src);
+    if (isImageMime(mime) || isImageExt(src)) {
+      await ctx.call('sendImage', { line, path: src });
+    } else {
+      await sendFileAttachment(line, a, src, ctx);
+    }
+    sent.push(kindOf(mime, src));
+  }
+  return sent;
+}