@stage-labs/metro 0.1.0-beta.13 → 0.1.0-beta.131

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

@@ -0,0 +1,299 @@
+import { IdentifierKind } from '@xmtp/node-sdk';
+import {
+  accounts,
+  accountForCall,
+  convOf,
+  lineOf,
+  parseLine,
+  type Account,
+} from './accounts.js';
+import { respond } from './wire.js';
+import { TrainError } from '@metro-labs/core/train-error';
+import { pushHandlers } from './actions-push.js';
+import { cleanLabels, labelsBlob } from './labels.js';
+import {
+  applyMemberOp,
+  buildGroupInfo,
+  buildMemberList,
+  createGroupWithMembers,
+  ethIdentifiers,
+  parseMemberArgs,
+  resolveMembers,
+  warmGroupName,
+} from './conv-helpers.js';
+import { closeGroup } from './actions-close.js';
+import {
+  groupAddMembers,
+  groupCreate,
+  groupRemoveMembers,
+} from './group.js';
+import {
+  updateChannelMeta,
+  applyChannelMeta,
+  resolveLine,
+  setGithub,
+  setPreview,
+} from './actions-meta.js';
+
+type Args = Record<string, unknown>;
+type Handler = (id: string, args: Args) => Promise<void>;
+type Conv = Awaited<ReturnType<typeof convOf>>['conv'] & object;
+
+async function newDm(id: string, args: Args): Promise<void> {
+  const { address } = args as { address: string };
+  const acct = accountForCall(args);
+  const dm = await acct.client.conversations.createDmWithIdentifier({
+    identifier: address,
+    identifierKind: IdentifierKind.Ethereum,
+  });
+  respond(id, {
+    result: {
+      line: lineOf(acct.cfg.id, dm.id),
+      id: dm.id,
+      account: acct.cfg.id,
+    },
+  });
+}
+
+async function newGroup(id: string, args: Args): Promise<void> {
+  const { addresses, name, permissions } = args as {
+    addresses: string[];
+    name?: string;
+    permissions?: 'admin-only' | 'default';
+  };
+  const acct = accountForCall(args);
+  const opts: { groupName?: string; permissions?: number } = {};
+  if (name) opts.groupName = name;
+  if (permissions === 'admin-only') opts.permissions = 1;
+  const group = await acct.client.conversations.createGroupWithIdentifiers(
+    ethIdentifiers(addresses),
+    opts,
+  );
+  warmGroupName(group.id, name);
+  respond(id, {
+    result: {
+      line: lineOf(acct.cfg.id, group.id),
+      id: group.id,
+      account: acct.cfg.id,
+    },
+  });
+}
+
+async function createRequestGroup(id: string, args: Args): Promise<void> {
+  const { name, description, labels } = args as {
+    name: string;
+    description?: string;
+    labels?: string[];
+  };
+  const acct = accountForCall(args);
+  if (!name || typeof name !== 'string')
+    throw new TrainError('INVALID_ARGS', 'createRequestGroup requires a `name`');
+  const { addrs, inboxes } = resolveMembers(args);
+  if (addrs.length === 0 && inboxes.length === 0)
+    throw new TrainError(
+      'INVALID_ARGS',
+      'createRequestGroup requires addresses[] or inboxIds[]',
+    );
+  const opts: {
+    groupName: string;
+    groupDescription?: string;
+    appData?: string;
+  } = { groupName: name };
+  if (description) opts.groupDescription = description;
+  if (Array.isArray(labels) && labels.length)
+    opts.appData = labelsBlob(undefined, labels);
+
+  const group = await createGroupWithMembers(acct, addrs, inboxes, opts);
+  warmGroupName(group.id, name);
+  respond(id, {
+    result: {
+      line: lineOf(acct.cfg.id, group.id),
+      id: group.id,
+      account: acct.cfg.id,
+      name,
+      description: description ?? '',
+      labels: cleanLabels(labels ?? []),
+    },
+  });
+}
+
+async function setLabels(id: string, args: Args): Promise<void> {
+  const { labels, setName, setDescription, setGithub } = args as {
+    line?: string;
+    groupId?: string;
+    labels: string[];
+    setName?: string;
+    setDescription?: string;
+    setGithub?: string;
+  };
+  const resolvedLine = resolveLine(args, 'setLabels');
+  if (!Array.isArray(labels))
+    throw new TrainError('INVALID_ARGS', 'setLabels requires a `labels` array');
+  const appData: Record<string, unknown> = { labels };
+  if (typeof setGithub === 'string') appData.github = setGithub;
+  const result = await applyChannelMeta(
+    { line: resolvedLine, name: setName, description: setDescription, appData },
+    'setLabels',
+  );
+  respond(id, {
+    result: {
+      line: result.line,
+      id: result.id,
+      account: result.account,
+      labels: result.labels,
+    },
+  });
+}
+
+async function query(id: string, args: Args): Promise<void> {
+  const { line, limit } = args as { line: string; limit?: number };
+  const { conv } = await convOf(line);
+  if (!conv)
+    throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
+  const lim = Math.min(Math.max(1, limit ?? 20), 200);
+  await conv.sync().catch(() => undefined);
+  const all = await conv.messages();
+  const slice = all.slice(-lim);
+  const parsed = parseLine(line);
+  if (!parsed)
+    throw new TrainError('NOT_FOUND', `could not parse line ${line}`);
+  const acctId = parsed.accountId;
+  const messages = slice.map((m) => {
+    let text = '';
+    try {
+      const cc: unknown = m.content;
+      text =
+        typeof cc === 'string' ? cc : `[${m.contentType?.typeId ?? 'unknown'}]`;
+    } catch {
+      text = `[${m.contentType?.typeId ?? 'unknown'}]`;
+    }
+    return {
+      id: m.id,
+      ts: new Date(Number(m.sentAtNs / 1_000_000n)).toISOString(),
+      from: `metro://xmtp/${acctId}/user/${m.senderInboxId}`,
+      text,
+      contentType: m.contentType?.typeId ?? 'unknown',
+    };
+  });
+  respond(id, { result: { line, count: messages.length, messages } });
+}
+
+async function addMembers(id: string, args: Args): Promise<void> {
+  const { line, addrs, inboxes } = parseMemberArgs(args, 'addMembers');
+  const { acct, conv } = await convOf(line);
+  if (!conv)
+    throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
+  await applyMemberOp(conv, addrs, inboxes, 'add');
+  const info = await buildGroupInfo(line, acct, conv);
+  respond(id, {
+    result: { ...info, added: { addresses: addrs, inboxIds: inboxes } },
+  });
+}
+
+async function removeMembers(id: string, args: Args): Promise<void> {
+  const { line, addrs, inboxes } = parseMemberArgs(args, 'removeMembers');
+  const { acct, conv } = await convOf(line);
+  if (!conv)
+    throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
+  await applyMemberOp(conv, addrs, inboxes, 'remove');
+  const info = await buildGroupInfo(line, acct, conv);
+  respond(id, {
+    result: { ...info, removed: { addresses: addrs, inboxIds: inboxes } },
+  });
+}
+
+async function groupInfo(id: string, args: Args): Promise<void> {
+  const { line } = args as { line: string };
+  const { acct, conv } = await convOf(line);
+  if (!conv)
+    throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
+  respond(id, { result: await buildGroupInfo(line, acct, conv) });
+}
+
+async function listMembers(id: string, args: Args): Promise<void> {
+  const { line } = args as { line: string };
+  const { acct, conv } = await convOf(line);
+  if (!conv)
+    throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
+  respond(id, { result: await buildMemberList(acct, conv) });
+}
+
+async function summarizeConv(acct: Account, c: Conv): Promise<unknown> {
+  const recent = await c.messages({ limit: 1, direction: 1 }).catch(() => []);
+  const last = recent[0];
+  let preview = '';
+  if (last) {
+    const cc: unknown = last.content;
+    preview =
+      typeof cc === 'string'
+        ? cc.slice(0, 80)
+        : `[${last.contentType?.typeId ?? 'unknown'}]`;
+  }
+  const isDm =
+    typeof (c as unknown as { peerInboxId?: unknown }).peerInboxId ===
+    'function';
+  const gn = (c as unknown as { name?: string | (() => Promise<string>) }).name;
+  const resolvedName =
+    typeof gn === 'function' ? await gn().catch(() => '') : (gn ?? '');
+  return {
+    line: lineOf(acct.cfg.id, c.id),
+    id: c.id,
+    account: acct.cfg.id,
+    version: isDm ? 'dm' : 'group',
+    name: resolvedName ?? '',
+    lastTs: last
+      ? new Date(Number(last.sentAtNs / 1_000_000n)).toISOString()
+      : null,
+    lastPreview: preview,
+  };
+}
+
+async function listConvs(id: string, args: Args): Promise<void> {
+  const { limit, account } = args as { limit?: number; account?: string };
+  const lim = Math.min(Math.max(1, limit ?? 50), 200);
+  const targets = account
+    ? [accounts.get(account)].filter((a): a is Account => a !== undefined)
+    : [...accounts.values()];
+  const summaries: unknown[] = [];
+  for (const acct of targets) {
+    await acct.client.conversations.syncAll();
+    const all = await acct.client.conversations.list();
+    for (const c of all.slice(0, lim))
+      summaries.push(await summarizeConv(acct, c));
+  }
+  summaries.sort((a, b) =>
+    ((b as { lastTs?: string }).lastTs ?? '').localeCompare(
+      (a as { lastTs?: string }).lastTs ?? '',
+    ),
+  );
+  respond(id, {
+    result: { count: summaries.length, conversations: summaries.slice(0, lim) },
+  });
+}
+
+export const convHandlers: Record<string, Handler> = {
+  newDm,
+  newGroup,
+  createRequestGroup,
+  addMembers,
+  removeMembers,
+  setLabels,
+  setGithub,
+  setPreview,
+  updateChannelMeta,
+  closeGroup,
+  query,
+  groupInfo,
+  listMembers,
+  listConvs,
+  groupCreate: async (id, args) => {
+    respond(id, { result: await groupCreate(args) });
+  },
+  groupAddMembers: async (id, args) => {
+    respond(id, { result: await groupAddMembers(args) });
+  },
+  groupRemoveMembers: async (id, args) => {
+    respond(id, { result: await groupRemoveMembers(args) });
+  },
+  ...pushHandlers,
+};

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

@@ -0,0 +1,157 @@
+import { accountForCall, convOf, lineOf } from './accounts.js';
+import { respond } from './wire.js';
+import { warmGroupName } from './conv-helpers.js';
+import { mergeAppData, readAppData, type GroupLike } from './labels.js';
+import { TrainError } from '@metro-labs/core/train-error';
+
+type Args = Record<string, unknown>;
+
+export function resolveLine(args: Args, verb: string): string {
+  const line = (args as { line?: string }).line;
+  if (line) return line;
+  const groupId = (args as { groupId?: string }).groupId;
+  if (groupId) {
+    const acct = accountForCall(args);
+    return lineOf(acct.cfg.id, groupId);
+  }
+  throw new TrainError(
+    'INVALID_ARGS',
+    `${verb} requires \`line\` or \`groupId\``,
+  );
+}
+
+async function applyNameAndDescription(
+  group: GroupLike,
+  name: string | undefined,
+  description: string | undefined,
+): Promise<void> {
+  if (
+    typeof name === 'string' &&
+    name &&
+    typeof group.updateName === 'function'
+  ) {
+    await group.updateName(name);
+    warmGroupName(group.id, name);
+  }
+  if (
+    typeof description === 'string' &&
+    typeof group.updateDescription === 'function'
+  ) {
+    await group.updateDescription(description);
+  }
+}
+
+async function applyMergedAppData(
+  group: GroupLike & { updateAppData: (s: string) => Promise<void> },
+  appData: Record<string, unknown> | undefined,
+): Promise<Record<string, unknown>> {
+  if (appData && typeof appData === 'object' && !Array.isArray(appData)) {
+    const res = mergeAppData(group.appData, appData);
+    await group.updateAppData(res.blob);
+    return res.merged;
+  }
+  return readAppData(group.appData);
+}
+
+export async function applyChannelMeta(
+  args: {
+    line: string;
+    name?: string;
+    description?: string;
+    appData?: Record<string, unknown>;
+  },
+  verb: string,
+): Promise<Record<string, unknown>> {
+  const { line, name, description, appData } = args;
+  const { acct, conv } = await convOf(line);
+  if (!conv)
+    throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
+  const group = conv as unknown as GroupLike;
+  if (typeof group.updateAppData !== 'function') {
+    throw new TrainError(
+      'INVALID_ARGS',
+      `${verb} target is not a group (no updateAppData)`,
+    );
+  }
+  await group.sync?.().catch(() => undefined);
+
+  await applyNameAndDescription(group, name, description);
+  const merged = await applyMergedAppData(
+    group as GroupLike & { updateAppData: (s: string) => Promise<void> },
+    appData,
+  );
+
+  return {
+    line,
+    id: group.id,
+    account: acct.cfg.id,
+    ...(typeof name === 'string' && name ? { name } : {}),
+    ...metaFields(merged),
+    appData: merged,
+  };
+}
+
+function metaFields(merged: Record<string, unknown>): {
+  labels: string[];
+  github: string | undefined;
+  preview: string | undefined;
+} {
+  return {
+    labels: Array.isArray(merged.labels) ? (merged.labels as string[]) : [],
+    github: typeof merged.github === 'string' ? merged.github : undefined,
+    preview: typeof merged.preview === 'string' ? merged.preview : undefined,
+  };
+}
+
+export async function updateChannelMeta(id: string, args: Args): Promise<void> {
+  const line = resolveLine(args, 'updateChannelMeta');
+  const { name, description, appData } = args as {
+    name?: string;
+    description?: string;
+    appData?: Record<string, unknown>;
+  };
+  const result = await applyChannelMeta(
+    { line, name, description, appData },
+    'updateChannelMeta',
+  );
+  respond(id, { result });
+}
+
+export async function setGithub(id: string, args: Args): Promise<void> {
+  const line = resolveLine(args, 'setGithub');
+  const { url } = args as { url: string };
+  if (typeof url !== 'string')
+    throw new Error('setGithub requires a `url` string');
+  const result = await applyChannelMeta(
+    { line, appData: { github: url } },
+    'setGithub',
+  );
+  respond(id, {
+    result: {
+      line: result.line,
+      id: result.id,
+      account: result.account,
+      github: result.github,
+    },
+  });
+}
+
+export async function setPreview(id: string, args: Args): Promise<void> {
+  const line = resolveLine(args, 'setPreview');
+  const a = args as { preview?: unknown; url?: unknown };
+  const value = typeof a.preview === 'string' ? a.preview : a.url;
+  if (typeof value !== 'string')
+    throw new Error('setPreview requires a `preview` string');
+  const result = await applyChannelMeta(
+    { line, appData: { preview: value } },
+    'setPreview',
+  );
+  respond(id, {
+    result: {
+      line: result.line,
+      id: result.id,
+      account: result.account,
+      preview: result.preview,
+    },
+  });
+}

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

@@ -0,0 +1,87 @@
+import { accounts } from './accounts.js';
+import { respond } from './wire.js';
+import {
+  fcmPushToAll,
+  loadPushTokens,
+  removePushToken,
+  savePushTokens,
+  storePushToken,
+} from './push.js';
+
+type Args = Record<string, unknown>;
+type Handler = (id: string, args: Args) => Promise<void>;
+
+function registerPush(id: string, args: Args): Promise<void> {
+  const { token, account, platform, inboxId } = args as {
+    token?: string;
+    account?: string;
+    platform?: string;
+    inboxId?: string;
+  };
+  if (!token || typeof token !== 'string' || token.length < 20) {
+    throw new Error('register-push requires a non-empty FCM device token');
+  }
+  const total = storePushToken({ token, account, platform, inboxId });
+  respond(id, { result: { stored: true, total, account: account ?? null } });
+  return Promise.resolve();
+}
+
+function listPush(id: string): Promise<void> {
+  const tokens = loadPushTokens();
+  respond(id, {
+    result: {
+      count: tokens.length,
+      tokens: tokens.map((t) => ({
+        token: `${t.token.slice(0, 12)}…${t.token.slice(-6)}`,
+        registeredAt: t.registeredAt,
+        lastSeenAt: t.lastSeenAt ?? null,
+        account: t.account ?? null,
+        platform: t.platform ?? null,
+        inboxId: t.inboxId ?? null,
+      })),
+    },
+  });
+  return Promise.resolve();
+}
+
+async function testPush(id: string, args: Args): Promise<void> {
+  const { account } = args as { account?: string };
+  const acctId =
+    account ??
+    (accounts.size === 1 ? [...accounts.keys()][0] : 'default') ??
+    'default';
+  await fcmPushToAll(acctId, { channelId: 'xmtp', source: 'test-push' });
+  const sent = loadPushTokens().filter(
+    (t) => !t.account || t.account === acctId,
+  ).length;
+  respond(id, { result: { sent, account: acctId } });
+}
+
+function unregisterPush(id: string, args: Args): Promise<void> {
+  const { token } = args as { token: string };
+  savePushTokens(loadPushTokens().filter((t) => t.token !== token));
+  respond(id, { result: { removed: true } });
+  return Promise.resolve();
+}
+
+function disablePush(id: string, args: Args): Promise<void> {
+  const { token } = args as { token?: string };
+  if (!token || typeof token !== 'string')
+    throw new Error('disable-push requires a token');
+  const remaining = removePushToken(token);
+  respond(id, {
+    result: {
+      removed: remaining !== -1,
+      remaining: remaining === -1 ? null : remaining,
+    },
+  });
+  return Promise.resolve();
+}
+
+export const pushHandlers: Record<string, Handler> = {
+  'register-push': registerPush,
+  'list-push': (id) => listPush(id),
+  'test-push': testPush,
+  'unregister-push': unregisterPush,
+  'disable-push': disablePush,
+};