@stage-labs/metro 0.1.0-beta.26 → 0.1.0-beta.261

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

@@ -7,36 +7,25 @@ import { homedir } from 'node:os';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { CODECS } from './codecs.js';
-import { expandHome, signerFor, XMTP_ENV } from './identity.js';
+import { expandHome, identityFor, XMTP_ENV } from './identity.js';
+import type { SmartAccount } from './smart.js';
 import {
   makeAccountStore,
   resolveAccountId,
-} from '@metro-labs/mcp/stations/account-store';
-import { Line } from '@metro-labs/mcp/lines';
-
-const ACCOUNTS_FILE =
-  process.env.XMTP_ACCOUNTS_FILE ??
-  join(homedir(), '.metro', 'xmtp-accounts.json');
+} from '@metro-labs/core/stations/account-store';
+import { Line } from '@metro-labs/core/lines';
 
 export interface AccountConfig {
   id: string;
   privateKey?: string;
-  owner?: string;
   dbPath?: string;
+  smart?: boolean;
 }
 
 export const { loadAccounts } = makeAccountStore<AccountConfig>({
   prefix: 'xmtp',
-  file: ACCOUNTS_FILE,
-  allowlistEnv: ['XMTP_ONLY_ACCOUNTS', 'XMTP_ACCOUNTS'],
   validate(raw, die) {
-    const seen = new Set<string>();
-    for (const a of raw) {
-      if (!a.id) die('account missing id');
-      if (!a.privateKey) die(`account '${a.id}' needs a privateKey`);
-      if (seen.has(a.id)) die(`duplicate account id '${a.id}'`);
-      seen.add(a.id);
-    }
+    for (const a of raw) if (!a.privateKey) die(`account '${a.id}' needs a privateKey`);
   },
 });
 
@@ -51,25 +40,26 @@ export interface Account {
   client: Client<unknown>;
   inboxId: string;
   address: string;
+  smart: SmartAccount | null;
 }
 export const accounts = new Map<string, Account>();
 
 export async function bootAccount(cfg: AccountConfig): Promise<void> {
-  const { signer, address } = signerFor(resolvePrivateKey(cfg));
+  const { signer, address, smart } = await identityFor(resolvePrivateKey(cfg), cfg.smart === true);
   const dbPath = expandHome(
     cfg.dbPath ?? join(homedir(), '.metro', `xmtp-${XMTP_ENV}-${cfg.id}.db3`),
   );
   const fresh = !existsSync(dbPath);
   const options: ClientOptions = { env: XMTP_ENV, codecs: CODECS(), dbPath };
   const client: Client<unknown> = await Client.create(signer, options);
-  accounts.set(cfg.id, { cfg, client, inboxId: client.inboxId, address });
+  accounts.set(cfg.id, { cfg, client, inboxId: client.inboxId, address, smart });
   if (fresh)
     process.stderr.write(
       `xmtp[${cfg.id}] registered a NEW installation for this machine — ` +
         'an inbox allows 10, and each machine you run metro on spends one\n',
     );
   process.stderr.write(
-    `xmtp[${cfg.id}] ready — inbox ${client.inboxId} (${address}, owner=${cfg.owner ?? '(broadcast)'})\n`,
+    `xmtp[${cfg.id}] ready — inbox ${client.inboxId} (${address})\n`,
   );
 }
 

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

@@ -1,6 +1,6 @@
-import { errMsg } from '@metro-labs/mcp/log';
+import { errMsg } from '@metro-labs/core/log';
 import { accountForCall, convOf, lineOf, type Account } from './accounts.js';
-import { respond } from './wire.js';
+import { respond } from '@metro-labs/core/stations/station-runtime';
 import type { GroupLike } from './labels.js';
 
 type Args = Record<string, unknown>;

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

@@ -1,25 +1,11 @@
-import { IdentifierKind } from '@xmtp/node-sdk';
+import { IdentifierKind, type DecodedMessage } from '@xmtp/node-sdk';
+import { accountForCall, convOf, lineOf, parseLine } from './accounts.js';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { resolveMsgId } from './wire.js';
+import { TrainError } from '@metro-labs/core/train-error';
 import {
-  accounts,
-  accountForCall,
-  convOf,
-  lineOf,
-  parseLine,
-  type Account,
-} from './accounts.js';
-import { respond } from './wire.js';
-import { TrainError } from '@metro-labs/mcp/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 {
@@ -27,17 +13,13 @@ import {
   groupCreate,
   groupRemoveMembers,
 } from './group.js';
-import {
-  updateChannelMeta,
-  applyChannelMeta,
-  resolveLine,
-  setGithub,
-  setPreview,
-} from './actions-meta.js';
+import { updateChannelMeta } from './actions-meta.js';
+import { deletedByRequests, isDeleteRequest, superAdminCheck } from './delete-requests.js';
+import { isCallSignal } from './codecs.js';
+import { syncConversation } from './network.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 };
@@ -55,153 +37,49 @@ async function newDm(id: string, args: Args): Promise<void> {
   });
 }
 
-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,
-    },
-  });
+function upTo<T extends { id: string }>(all: T[], before: string | undefined): T[] {
+  if (!before) return all;
+  const target = resolveMsgId(before);
+  const at = all.findIndex((m) => m.id === target);
+  if (at < 0) throw new TrainError('NOT_FOUND', `message ${before} is not in this conversation`);
+  return all.slice(0, at);
 }
 
-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 ?? []),
-    },
-  });
+function textOf(m: DecodedMessage): string {
+  try {
+    const cc: unknown = m.content;
+    return typeof cc === 'string' ? cc : `[${m.contentType?.typeId ?? 'unknown'}]`;
+  } catch {
+    return `[${m.contentType?.typeId ?? 'unknown'}]`;
+  }
 }
 
-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,
-    },
-  });
-}
+const DELETED = { text: '[deletedMessage]', contentType: 'deletedMessage' };
 
-async function query(id: string, args: Args): Promise<void> {
-  const { line, limit } = args as { line: string; limit?: number };
-  const { conv } = await convOf(line);
+async function read(id: string, args: Args): Promise<void> {
+  const { line, limit, before } = args as { line: string; limit?: number; before?: string };
+  const { acct, 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);
+  await syncConversation(acct.client, conv);
   const all = await conv.messages();
-  const slice = all.slice(-lim);
+  const deleted = deletedByRequests(all, superAdminCheck(conv));
+  const slice = upTo(all.filter((m) => !isDeleteRequest(m) && !isCallSignal(m)), before).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',
-    };
-  });
+  const messages = slice.map((m) => ({
+    id: m.id,
+    ts: new Date(Number(m.sentAtNs / 1_000_000n)).toISOString(),
+    from: `metro://xmtp/${acctId}/user/${m.senderInboxId}`,
+    ...(m.senderInboxId === acct.inboxId ? { self: true } : {}),
+    ...(deleted.has(m.id) ? DELETED : { text: textOf(m), 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);
@@ -212,80 +90,19 @@ async function groupInfo(id: string, args: Args): Promise<void> {
 
 async function listMembers(id: string, args: Args): Promise<void> {
   const { line } = args as { line: string };
-  const { acct, conv } = await convOf(line);
+  const { 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) },
-  });
+  respond(id, { result: await buildMemberList(conv) });
 }
 
 export const convHandlers: Record<string, Handler> = {
   newDm,
-  newGroup,
-  createRequestGroup,
-  addMembers,
-  removeMembers,
-  setLabels,
-  setGithub,
-  setPreview,
   updateChannelMeta,
   closeGroup,
-  query,
+  read,
   groupInfo,
   listMembers,
-  listConvs,
   groupCreate: async (id, args) => {
     respond(id, { result: await groupCreate(args) });
   },
@@ -295,5 +112,4 @@ export const convHandlers: Record<string, Handler> = {
   groupRemoveMembers: async (id, args) => {
     respond(id, { result: await groupRemoveMembers(args) });
   },
-  ...pushHandlers,
 };

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

@@ -1,12 +1,13 @@
-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/mcp/train-error';
+import { accountForCall, convOf, lineOf, parseLine } from './accounts.js';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { ethIdentifiers, warmGroupName } from './conv-helpers.js';
+import { mergeAppData, normalizeAssigned, readAppDataObject, type GroupLike } from './labels.js';
+import { TrainError } from '@metro-labs/core/train-error';
+import { syncConversation } from './network.js';
 
 type Args = Record<string, unknown>;
 
-export function resolveLine(args: Args, verb: string): string {
+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;
@@ -50,10 +51,10 @@ async function applyMergedAppData(
     await group.updateAppData(res.blob);
     return res.merged;
   }
-  return readAppData(group.appData);
+  return readAppDataObject(group.appData);
 }
 
-export async function applyChannelMeta(
+async function applyChannelMeta(
   args: {
     line: string;
     name?: string;
@@ -73,7 +74,19 @@ export async function applyChannelMeta(
       `${verb} target is not a group (no updateAppData)`,
     );
   }
-  await group.sync?.().catch(() => undefined);
+  await syncConversation(acct.client, conv);
+  if (appData) mergeAppData(group.appData, appData);
+  else readAppDataObject(group.appData);
+  if (appData && Object.hasOwn(appData, 'assigned')) {
+    const assigned = normalizeAssigned(appData.assigned);
+    const inboxIds = await Promise.all(
+      ethIdentifiers(assigned).map((identifier) => acct.client.fetchInboxIdByIdentifier(identifier)),
+    );
+    const members = new Set((await conv.members()).map((member) => member.inboxId));
+    if (inboxIds.some((inboxId) => !inboxId || !members.has(inboxId))) {
+      throw new TrainError('INVALID_ARGS', 'Assignees must be current channel members');
+    }
+  }
 
   await applyNameAndDescription(group, name, description);
   const merged = await applyMergedAppData(
@@ -93,65 +106,46 @@ export async function applyChannelMeta(
 
 function metaFields(merged: Record<string, unknown>): {
   labels: string[];
+  category: string | undefined;
+  status: string | undefined;
+  priority: string | undefined;
   github: string | undefined;
   preview: string | undefined;
+  assigned: unknown;
 } {
   return {
     labels: Array.isArray(merged.labels) ? (merged.labels as string[]) : [],
+    category: typeof merged.category === 'string' ? merged.category : undefined,
+    status: typeof merged.status === 'string' ? merged.status : undefined,
+    priority: typeof merged.priority === 'string' ? merged.priority : undefined,
     github: typeof merged.github === 'string' ? merged.github : undefined,
     preview: typeof merged.preview === 'string' ? merged.preview : undefined,
+    assigned: Object.hasOwn(merged, 'assigned') ? merged.assigned : [],
   };
 }
 
+const metadataWrites = new Map<string, Promise<Record<string, unknown>>>();
+
 export async function updateChannelMeta(id: string, args: Args): Promise<void> {
   const line = resolveLine(args, 'updateChannelMeta');
+  const parsed = parseLine(line);
+  if (!parsed) throw new TrainError('INVALID_ARGS', `bad xmtp line: ${line}`);
+  const key = lineOf(parsed.accountId, parsed.convId);
   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,
-    },
-  });
+  if (name !== undefined && typeof name !== 'string') {
+    throw new TrainError('INVALID_ARGS', 'name must be a string');
+  }
+  const task = () => applyChannelMeta({ line, name, description, appData }, 'updateChannelMeta');
+  const previous = metadataWrites.get(key);
+  const pending = previous ? previous.then(task, task) : task();
+  metadataWrites.set(key, pending);
+  try {
+    respond(id, { result: await pending });
+  } finally {
+    if (metadataWrites.get(key) === pending) metadataWrites.delete(key);
+  }
 }