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

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

@@ -0,0 +1,349 @@
+import { errMsg } from '@metro-labs/core/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/core/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/core/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/core/stations/types';
+import { TrainError } from '@metro-labs/core/train-error';
+import {
+  guessMime,
+  isImageMime,
+  isImageExt,
+  kindOf,
+} from '@metro-labs/core/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;
+}

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

@@ -0,0 +1,212 @@
+import type { StationTool } from '@metro-labs/core/stations/types';
+import {
+  str,
+  createChannel,
+  setChannelMetadata,
+  xmtpSendAttachments,
+} from './tools-handlers.js';
+
+export { xmtpSendAttachments };
+
+const lineProp = {
+  type: 'string',
+  description:
+    'The metro:// line (from the inbound <channel> tag). The station is derived from it.',
+} as const;
+
+export const XMTP_TOOLS: StationTool[] = [
+  {
+    name: 'create_channel',
+    description:
+      'Create a new XMTP group conversation (channel). Args: addresses (required, array of ' +
+      'Ethereum 0x addresses to add as members), name (required, the group name), labels? ' +
+      '(optional string[] status labels applied after creation), account? ' +
+      '(defaults to your only XMTP account). Calls the daemon xmtp `newGroup`, then ' +
+      '`updateChannelMeta` if labels ' +
+      'are given. Returns the new metro:// line and convId. This is an xmtp-only operation. ' +
+      'NOTE: there is no add-members verb on the daemon, so members must be supplied at ' +
+      'creation time.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        addresses: {
+          type: 'array',
+          description: 'Ethereum 0x addresses to add as group members.',
+          items: { type: 'string' },
+        },
+        name: { type: 'string', description: 'The group/channel name.' },
+        labels: {
+          type: 'array',
+          description: 'Optional status labels to apply after creation.',
+          items: { type: 'string' },
+        },
+        account: {
+          type: 'string',
+          description:
+            'XMTP account to create under. Omit when you have only one.',
+        },
+      },
+      required: ['addresses', 'name'],
+    },
+    handle: (a, ctx) => createChannel(a, ctx),
+  },
+  {
+    name: 'ask',
+    description:
+      'Ask a question as a poll in an XMTP conversation (mirrors Claude AskUserQuestion). ' +
+      'Single-question form: question (required), options? (string[]), header?, multiSelect?, ' +
+      'open? (true => free-text answer, options optional). Multi-question form: questions ' +
+      '(array of {question, options?, header?, multiSelect?, open?}). Args: line (required) + ' +
+      'the above. xmtp-only (the daemon `ask` action). Returns the poll messageId + pollId.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        line: lineProp,
+        question: {
+          type: 'string',
+          description: 'The question text (single-question form).',
+        },
+        options: {
+          type: 'array',
+          description: 'Answer options for a single question.',
+          items: { type: 'string' },
+        },
+        header: {
+          type: 'string',
+          description: 'Optional header/title for the poll.',
+        },
+        multiSelect: {
+          type: 'boolean',
+          description: 'Allow selecting multiple options.',
+        },
+        open: {
+          type: 'boolean',
+          description: 'Free-text answer (options optional).',
+        },
+        questions: {
+          type: 'array',
+          description:
+            'Multiple questions (multi-question form). Each is {question, options?, header?, multiSelect?, open?}.',
+          items: { type: 'object' },
+        },
+      },
+      required: ['line'],
+    },
+    async handle(a, ctx) {
+      const line = str(a.line);
+      if (!line) return ctx.err('ask requires `line`');
+      const args: Record<string, unknown> = { line };
+      for (const k of [
+        'question',
+        'options',
+        'header',
+        'multiSelect',
+        'open',
+        'questions',
+      ] as const) {
+        if (a[k] !== undefined) args[k] = a[k];
+      }
+      if (a.question === undefined && a.questions === undefined) {
+        return ctx.err(
+          'ask requires `question` (single) or `questions` (multi)',
+        );
+      }
+      return ctx.okJson(await ctx.call('ask', args));
+    },
+  },
+  {
+    name: 'dm',
+    description:
+      'Open (or reuse) a 1:1 XMTP DM with an Ethereum address. Args: address (required, 0x...), ' +
+      'account? (defaults to your only XMTP account). Returns the new metro:// line and ' +
+      'convId. xmtp-only ' +
+      '(daemon `newDm`). Use this instead of create_channel when there is a single recipient.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        address: {
+          type: 'string',
+          description: 'Recipient Ethereum 0x address.',
+        },
+        account: {
+          type: 'string',
+          description: 'XMTP account to DM from. Omit when you have only one.',
+        },
+      },
+      required: ['address'],
+    },
+    async handle(a, ctx) {
+      const address = str(a.address);
+      if (!address) return ctx.err('dm requires `address`');
+      const dmArgs: Record<string, unknown> = { address };
+      if (a.account) dmArgs.account = str(a.account);
+      return ctx.okJson(await ctx.call('newDm', dmArgs));
+    },
+  },
+  {
+    name: 'group_info',
+    description:
+      "Read an XMTP channel's current metadata + membership. Args: line (required). Returns " +
+      '{line, id, account, version (dm|group), name, memberCount, labels, github, preview, ' +
+      'members:[{inboxId, address}]}. xmtp-only (daemon `groupInfo`). Use before ' +
+      'set_channel_metadata/add_members to see current state.',
+    inputSchema: {
+      type: 'object',
+      properties: { line: lineProp },
+      required: ['line'],
+    },
+    async handle(a, ctx) {
+      const line = str(a.line);
+      if (!line) return ctx.err('group_info requires `line`');
+      return ctx.okJson(await ctx.call('groupInfo', { line }));
+    },
+  },
+  {
+    name: 'close_channel',
+    description:
+      'Archive/close an XMTP group (removes members). Args: line (required). xmtp-only ' +
+      '(daemon `closeGroup`). Irreversible-ish: members are removed from the group.',
+    inputSchema: {
+      type: 'object',
+      properties: { line: lineProp },
+      required: ['line'],
+    },
+    async handle(a, ctx) {
+      const line = str(a.line);
+      if (!line) return ctx.err('close_channel requires `line`');
+      return ctx.okJson(await ctx.call('closeGroup', { line }));
+    },
+  },
+  {
+    name: 'set_channel_metadata',
+    description:
+      "Update an existing channel's metadata. Args: line (required, the metro:// line), and " +
+      'any of labels? (string[]), github? (url), preview? (url), name? (string). All provided ' +
+      'fields are applied together in one atomic updateChannelMeta daemon call (a single ' +
+      'appData merge plus name update). xmtp-only ' +
+      '(channel metadata lives on xmtp groups). Returns the updated channel info.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        line: lineProp,
+        labels: {
+          type: 'array',
+          description: 'Status labels to set.',
+          items: { type: 'string' },
+        },
+        github: {
+          type: 'string',
+          description: 'Linked GitHub URL ("" to clear).',
+        },
+        preview: {
+          type: 'string',
+          description: 'Linked preview URL ("" to clear).',
+        },
+        name: { type: 'string', description: 'New channel name.' },
+      },
+      required: ['line'],
+    },
+    handle: (a, ctx) => setChannelMetadata(a, ctx),
+  },
+];
+