@stage-labs/metro 0.1.0-beta.4 → 0.1.0-beta.41

package/runtime/node_modules/@metro-labs/mcp/src/db/runtimes.ts

@@ -0,0 +1,105 @@
+import { and, eq, isNull } from 'drizzle-orm';
+import { getDb } from './client.js';
+import { newId } from './ids.js';
+import { agents, runtimes } from './schema.js';
+import { ApiError } from '../daemon/api-error.js';
+
+export interface RuntimeLease {
+  runtimeId: string;
+  agentId: string;
+  label: string;
+}
+
+export interface RuntimeView {
+  id: string;
+  label: string;
+  lastSeenAt: string | null;
+}
+
+const nowIso = (): string => new Date().toISOString();
+
+const stale = (): ApiError =>
+  new ApiError('this runtime no longer holds the agent', 409);
+
+export async function claimRuntime(
+  agentId: string,
+  label: string,
+): Promise<RuntimeLease> {
+  const db = getDb();
+  const id = newId();
+  return db.transaction(async (tx) => {
+    await tx
+      .insert(runtimes)
+      .values({ id, agentId, label, createdAt: nowIso(), lastSeenAt: nowIso() });
+    const rows = await tx
+      .update(agents)
+      .set({ runtimeId: id })
+      .where(eq(agents.id, agentId))
+      .returning({ id: agents.id });
+    if (rows[0] === undefined) throw new ApiError('no such agent', 404);
+    return { runtimeId: id, agentId, label };
+  });
+}
+
+export async function fenceRuntime(
+  runtimeId: string,
+  agentId: string,
+): Promise<void> {
+  const rows = await getDb()
+    .select({ holder: agents.runtimeId })
+    .from(agents)
+    .innerJoin(runtimes, eq(runtimes.id, agents.runtimeId))
+    .where(
+      and(
+        eq(agents.id, agentId),
+        eq(agents.runtimeId, runtimeId),
+        isNull(runtimes.revokedAt),
+      ),
+    );
+  if (rows[0] === undefined) throw stale();
+}
+
+export async function touchRuntime(runtimeId: string): Promise<void> {
+  await getDb()
+    .update(runtimes)
+    .set({ lastSeenAt: nowIso() })
+    .where(eq(runtimes.id, runtimeId));
+}
+
+export async function releaseRuntime(agentId: string): Promise<void> {
+  const db = getDb();
+  await db.transaction(async (tx) => {
+    await tx
+      .update(runtimes)
+      .set({ revokedAt: nowIso() })
+      .where(and(eq(runtimes.agentId, agentId), isNull(runtimes.revokedAt)));
+    await tx
+      .update(agents)
+      .set({ runtimeId: null })
+      .where(eq(agents.id, agentId));
+  });
+}
+
+export async function runtimeLabels(
+  agentIds: string[],
+): Promise<Map<string, string>> {
+  const out = new Map<string, string>();
+  for (const id of agentIds) {
+    const found = await runtimeFor(id);
+    if (found !== null) out.set(id, found.label);
+  }
+  return out;
+}
+
+export async function runtimeFor(agentId: string): Promise<RuntimeView | null> {
+  const rows = await getDb()
+    .select({
+      id: runtimes.id,
+      label: runtimes.label,
+      lastSeenAt: runtimes.lastSeenAt,
+    })
+    .from(runtimes)
+    .innerJoin(agents, eq(agents.runtimeId, runtimes.id))
+    .where(and(eq(agents.id, agentId), isNull(runtimes.revokedAt)));
+  return rows[0] ?? null;
+}

package/runtime/node_modules/@metro-labs/mcp/src/db/schema.ts

@@ -0,0 +1,118 @@
+import {
+  boolean,
+  jsonb,
+  pgTable,
+  text,
+  unique,
+} from 'drizzle-orm/pg-core';
+
+export const STATIONS = [
+  'xmtp',
+  'telegram-bot',
+  'telegram',
+  'discord-bot',
+  'whatsapp',
+  'webhook',
+] as const;
+
+export type StationName = (typeof STATIONS)[number];
+
+export const users = pgTable('users', {
+  id: text('id').primaryKey(),
+  email: text('email').unique(),
+  address: text('address').unique(),
+});
+
+export const PROJECT_ROLES = ['admin', 'member'] as const;
+
+export type ProjectRole = (typeof PROJECT_ROLES)[number];
+
+export const projects = pgTable('projects', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  ownerId: text('owner_id')
+    .notNull()
+    .references(() => users.id, { onDelete: 'restrict' }),
+  isDefault: boolean('is_default').notNull().default(false),
+});
+
+export const projectMembers = pgTable(
+  'project_members',
+  {
+    id: text('id').primaryKey(),
+    projectId: text('project_id')
+      .notNull()
+      .references(() => projects.id, { onDelete: 'cascade' }),
+    userId: text('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'restrict' }),
+    role: text('role').$type<ProjectRole>().notNull(),
+  },
+  (t) => [unique('project_members_project_id_user_id_unique').on(t.projectId, t.userId)],
+);
+
+export const agents = pgTable('agents', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  projectId: text('project_id')
+    .notNull()
+    .references(() => projects.id, { onDelete: 'restrict' }),
+  key: text('key').unique(),
+  runtimeId: text('runtime_id'),
+});
+
+export const runtimes = pgTable('runtimes', {
+  id: text('id').primaryKey(),
+  agentId: text('agent_id')
+    .notNull()
+    .references(() => agents.id, { onDelete: 'cascade' }),
+  label: text('label').notNull(),
+  createdAt: text('created_at').notNull(),
+  lastSeenAt: text('last_seen_at'),
+  revokedAt: text('revoked_at'),
+});
+
+export const stations = pgTable('stations', {
+  id: text('id').primaryKey(),
+  agentId: text('agent_id').notNull(),
+  station: text('station').$type<StationName>().notNull(),
+  allowlist: text('allowlist').array().default(['*']),
+  config: jsonb('config').notNull(),
+});
+
+export const CONNECTOR_TRANSPORTS = ['http', 'sse'] as const;
+
+export type ConnectorTransport = (typeof CONNECTOR_TRANSPORTS)[number];
+
+export const connectors = pgTable(
+  'connectors',
+  {
+    id: text('id').primaryKey(),
+    projectId: text('project_id')
+      .notNull()
+      .references(() => projects.id, { onDelete: 'restrict' }),
+    name: text('name').notNull(),
+    url: text('url').notNull(),
+    transport: text('transport').$type<ConnectorTransport>().notNull(),
+    config: jsonb('config').notNull(),
+  },
+);
+
+export const agentConnectors = pgTable(
+  'agent_connectors',
+  {
+    id: text('id').primaryKey(),
+    agentId: text('agent_id')
+      .notNull()
+      .references(() => agents.id, { onDelete: 'cascade' }),
+    connectorId: text('connector_id')
+      .notNull()
+      .references(() => connectors.id, { onDelete: 'cascade' }),
+  },
+  (t) => [
+    unique('agent_connectors_agent_id_connector_id_unique').on(
+      t.agentId,
+      t.connectorId,
+    ),
+  ],
+);

package/runtime/node_modules/@metro-labs/mcp/src/db/token-carry.ts

@@ -0,0 +1,45 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { tokenStorePath } from '@metro-labs/whatsapp/tokens';
+import { errMsg, log } from '../daemon/log.js';
+import { writeSecure } from '../daemon/secure-fs.js';
+
+export const PREVIOUS_ACCOUNT_ID = 'previousAccountId';
+
+export interface CarriedStation {
+  station: string;
+  id: string;
+  config: Record<string, unknown>;
+}
+
+export function previousAccountId(
+  config: Record<string, unknown>,
+): string | undefined {
+  const raw = config[PREVIOUS_ACCOUNT_ID];
+  return typeof raw === 'string' && raw !== '' ? raw : undefined;
+}
+
+export function carryTokenStores(list: CarriedStation[]): number {
+  let carried = 0;
+  for (const s of list) {
+    if (s.station !== 'whatsapp') continue;
+    const previous = previousAccountId(s.config);
+    if (previous === undefined || previous === s.id) continue;
+    const from = tokenStorePath(previous);
+    const to = tokenStorePath(s.id);
+    if (!existsSync(from) || existsSync(to)) continue;
+    try {
+      writeSecure(to, readFileSync(from, 'utf8'));
+      carried += 1;
+      log.info(
+        { from: previous, to: s.id },
+        'db: carried the whatsapp token store to the station id',
+      );
+    } catch (err) {
+      log.error(
+        { from: previous, to: s.id, err: errMsg(err) },
+        'db: could not carry the whatsapp token store',
+      );
+    }
+  }
+  return carried;
+}

package/runtime/node_modules/@metro-labs/mcp/src/db/users.ts

@@ -0,0 +1,72 @@
+import { eq, type SQL } from 'drizzle-orm';
+import { ApiError } from '../daemon/api-error.js';
+import { getDb } from './client.js';
+import { newId } from './ids.js';
+import { users } from './schema.js';
+
+const UNIQUE_VIOLATION = '23505';
+const ADDRESS_RE = /^0x[0-9a-f]{40}$/;
+
+export class UserError extends ApiError {}
+
+const CAUSE_DEPTH = 5;
+
+export function isUniqueViolation(err: unknown): boolean {
+  let current: unknown = err;
+  for (let depth = 0; depth < CAUSE_DEPTH; depth += 1) {
+    if (typeof current !== 'object' || current === null) return false;
+    const { code, cause } = current as { code?: unknown; cause?: unknown };
+    if (code === UNIQUE_VIOLATION) return true;
+    current = cause;
+  }
+  return false;
+}
+
+export function normalizeEmail(raw: string): string {
+  return raw.trim().toLowerCase();
+}
+
+export function normalizeAddress(raw: string): string | null {
+  const address = raw.trim().toLowerCase();
+  return ADDRESS_RE.test(address) ? address : null;
+}
+
+async function userIdWhere(where: SQL): Promise<string | null> {
+  const rows = await getDb().select({ id: users.id }).from(users).where(where);
+  return rows[0]?.id ?? null;
+}
+
+export async function userIdForSubject(subject: string): Promise<string | null> {
+  const address = normalizeAddress(subject);
+  if (address !== null) return userIdWhere(eq(users.address, address));
+  return userIdWhere(eq(users.email, normalizeEmail(subject)));
+}
+
+export async function resolveUserId(
+  insert: () => Promise<string | undefined>,
+  lookup: () => Promise<string | null>,
+): Promise<string> {
+  const inserted = await insert();
+  if (inserted !== undefined) return inserted;
+  const existing = await lookup();
+  if (existing === null)
+    throw new UserError('user lookup returned no id', 500);
+  return existing;
+}
+
+export async function ensureUserByAddress(raw: string): Promise<string> {
+  const address = normalizeAddress(raw);
+  if (address === null)
+    throw new UserError('an Ethereum address is required', 400);
+  return resolveUserId(
+    async () => {
+      const rows = await getDb()
+        .insert(users)
+        .values({ id: newId(), address })
+        .onConflictDoNothing({ target: users.address })
+        .returning({ id: users.id });
+      return rows[0]?.id;
+    },
+    () => userIdWhere(eq(users.address, address)),
+  );
+}

package/runtime/node_modules/@metro-labs/mcp/src/db/whatsapp-login.ts

@@ -0,0 +1,18 @@
+import { and, eq, sql } from 'drizzle-orm';
+import { getDb } from './client.js';
+import { stations } from './schema.js';
+
+export async function writeWhatsappCredentials(
+  accountId: string,
+  credentials: unknown,
+): Promise<void> {
+  const db = getDb();
+  await db
+    .update(stations)
+    .set({
+      config: sql`${stations.config} || ${JSON.stringify({ credentials })}::jsonb`,
+    })
+    .where(
+      and(eq(stations.station, 'whatsapp'), eq(stations.id, accountId)),
+    );
+}

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

@@ -0,0 +1,141 @@
+import { forwardTrainCall } from '../daemon/train-call.js';
+import {
+  accountStationNames,
+  stationByName,
+} from '../stations/registry.js';
+import { listEndpoints } from '../daemon/tunnel.js';
+import { hookUrl } from '../stations/attach.js';
+import { agentIdForAccount, knownAccounts, type KnownAccount } from '../db/agent-map.js';
+import { stationRunsHere } from '../db/materialize.js';
+import { type StationName } from '../db/schema.js';
+
+const accountId = (acc: unknown): string | undefined => {
+  const id = (acc as { id?: unknown }).id;
+  return typeof id === 'string' ? id : undefined;
+};
+
+const asRecord = (acc: unknown): Record<string, unknown> | undefined =>
+  typeof acc === 'object' && acc !== null && !Array.isArray(acc)
+    ? (acc as Record<string, unknown>)
+    : undefined;
+
+function withAgentId(station: string, acc: unknown): unknown {
+  const rec = asRecord(acc);
+  if (rec === undefined) return acc;
+  const id = typeof rec.id === 'string' ? rec.id : undefined;
+  if (id === undefined) return acc;
+  const agentId = agentIdForAccount(station, id);
+  return agentId === undefined ? acc : { ...rec, agentId };
+}
+
+export function attachAgentIds(
+  byStation: Record<string, unknown[]>,
+): Record<string, unknown[]> {
+  const out: Record<string, unknown[]> = {};
+  for (const [station, list] of Object.entries(byStation))
+    out[station] = list.map((acc) => withAgentId(station, acc));
+  return out;
+}
+
+export function scopeAccountsByAgent(
+  byStation: Record<string, unknown[]>,
+  allowed: Set<string>,
+): Record<string, unknown[]> {
+  const out: Record<string, unknown[]> = {};
+  for (const [station, list] of Object.entries(byStation)) {
+    out[station] = list.filter((acc) => {
+      const id = accountId(acc);
+      if (id === undefined) return false;
+      const agentId = agentIdForAccount(station, id);
+      return agentId !== undefined && allowed.has(agentId);
+    });
+  }
+  return out;
+}
+
+const hasTrain = (station: string): boolean =>
+  stationByName(station)?.hasTrain !== false;
+
+function inCoreAccounts(station: string): unknown[] {
+  if (station !== 'webhook') return [];
+  return listEndpoints().flatMap((e) =>
+    e.secret === undefined || e.webhookId === undefined
+      ? []
+      : [
+          {
+            id: e.id,
+            handle: `/api/webhooks/${e.webhookId}`,
+            endpoint: hookUrl(e.webhookId, e.secret),
+          },
+        ],
+  );
+}
+
+export interface ScopedAccounts {
+  accounts: Record<string, unknown[]>;
+  unavailable: string[];
+}
+
+async function liveAccounts(
+  station: string,
+): Promise<{ rows: unknown[]; reachable: boolean }> {
+  if (!hasTrain(station))
+    return { rows: inCoreAccounts(station), reachable: true };
+  if (!stationRunsHere(station as StationName))
+    return { rows: [], reachable: true };
+  try {
+    const resp = await forwardTrainCall(station, 'accounts', {});
+    const list = (resp.result as { accounts?: unknown[] } | undefined)?.accounts;
+    return { rows: Array.isArray(list) ? list : [], reachable: true };
+  } catch {
+    return { rows: [], reachable: false };
+  }
+}
+
+function mergeKnown(
+  station: string,
+  live: unknown[],
+  known: KnownAccount[],
+): unknown[] {
+  const seen = new Set(
+    live.flatMap((row) => {
+      const id = accountId(row);
+      return id === undefined ? [] : [id];
+    }),
+  );
+  const missing = known
+    .filter((r) => r.station === station && !seen.has(r.id))
+    .map((r) => ({ id: r.id }));
+  return [...live, ...missing];
+}
+
+async function loadStations(): Promise<ScopedAccounts> {
+  const unavailable: string[] = [];
+  const accounts: Record<string, unknown[]> = {};
+  const known = knownAccounts();
+  await Promise.all(
+    accountStationNames().map(async (station) => {
+      const { rows, reachable } = await liveAccounts(station);
+      if (!reachable) unavailable.push(station);
+      accounts[station] = hasTrain(station) ? mergeKnown(station, rows, known) : rows;
+    }),
+  );
+  return { accounts, unavailable };
+}
+
+export async function gatherAccounts(
+  allowedAgents?: Set<string>,
+): Promise<Record<string, unknown[]>> {
+  const { accounts } = await loadStations();
+  return allowedAgents ? scopeAccountsByAgent(accounts, allowedAgents) : accounts;
+}
+
+export async function gatherAccountsForAgents(
+  allowed: Set<string>,
+): Promise<ScopedAccounts> {
+  const { accounts, unavailable } = await loadStations();
+  return {
+    accounts: attachAgentIds(scopeAccountsByAgent(accounts, allowed)),
+    unavailable,
+  };
+}

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

@@ -0,0 +1,203 @@
+import { stationForLine } from '../stations/registry.js';
+import { kindOf, toCanonical } from '../stations/attachments.js';
+import {
+  cleanupAttachments,
+  resolveAttachments,
+  type ResolvedAttachment,
+} from '../stations/attach-resolve.js';
+import type { CanonicalAttachment, ToolResult } from '../stations/types.js';
+import { errResult, makeCtx, ok, okJson, toErr } from './ctx.js';
+import { allowedAgents, currentIdentity } from './request-identity.js';
+import { str } from './str.js';
+
+type Station = NonNullable<ReturnType<typeof stationForLine>>;
+
+interface MessageArgs {
+  line: string;
+  a: Record<string, unknown>;
+  ctx: ReturnType<typeof makeCtx>;
+  station: Station;
+}
+
+const messageIdOf = (response: { result: unknown }): string | undefined => {
+  const id = (response.result as { messageId?: unknown } | null)?.messageId;
+  return typeof id === 'string' && id !== '' ? id : undefined;
+};
+
+const withId = (text: string, messageId: string | undefined): string =>
+  messageId === undefined ? text : `${text} — message_id: ${messageId}`;
+
+interface Sent {
+  labels: string[];
+  messageId?: string;
+}
+
+const deliveredLabels = (response: { result: unknown }): string[] => {
+  const list = (response.result as { attachments?: unknown } | null)
+    ?.attachments;
+  return Array.isArray(list)
+    ? list.filter((x): x is string => typeof x === 'string')
+    : [];
+};
+
+function assertDelivered(
+  station: Station,
+  delivered: string[],
+  atts: ResolvedAttachment[],
+): void {
+  if (delivered.length < atts.length)
+    throw new Error(
+      `${station.name} delivered ${delivered.length} of ${atts.length} attachment(s); ` +
+        'the message text may still have been sent',
+    );
+}
+
+async function sendNative(
+  m: MessageArgs,
+  text: string | undefined,
+  replyTo: string | undefined,
+  atts: ResolvedAttachment[],
+): Promise<Sent> {
+  const { line, ctx, station } = m;
+  const labels: string[] = [];
+  let messageId: string | undefined;
+  if (text) {
+    const response = await ctx.call(
+      'send',
+      replyTo ? { line, text, replyTo } : { line, text },
+    );
+    messageId = messageIdOf(response);
+    labels.push('text');
+  }
+  if (!atts.length) return { labels, messageId };
+  const delivered = station.sendAttachments
+    ? await station.sendAttachments(line, atts, ctx)
+    : [];
+  assertDelivered(station, delivered, atts);
+  labels.push(...delivered);
+  return { labels, messageId };
+}
+
+async function sendForwarded(
+  m: MessageArgs,
+  text: string | undefined,
+  replyTo: string | undefined,
+  atts: ResolvedAttachment[],
+): Promise<Sent> {
+  const { line, ctx, station } = m;
+  const args: Record<string, unknown> = { line };
+  if (text) args.text = text;
+  if (replyTo) args.replyTo = replyTo;
+  if (atts.length) args.attachments = atts.map(toCanonical);
+  const response = await ctx.call('send', args);
+  const messageId = messageIdOf(response);
+  const labels: string[] = [];
+  if (text) labels.push('text');
+  if (!atts.length) return { labels, messageId };
+  const delivered = deliveredLabels(response);
+  assertDelivered(station, delivered, atts);
+  labels.push(...delivered);
+  return { labels, messageId };
+}
+
+const unsupported = (station: Station, atts: CanonicalAttachment[]): string =>
+  `${station.name} cannot send attachments (${atts
+    .map((a) => kindOf(a.mime ?? '', a.path ?? a.url ?? a.name ?? ''))
+    .join(', ')}); send a link in \`text\` instead`;
+
+async function handleSend(m: MessageArgs): Promise<ToolResult> {
+  const text = m.a.text as string | undefined;
+  const replyTo = m.a.reply_to as string | undefined;
+  const requested = (m.a.attachments as CanonicalAttachment[] | undefined) ?? [];
+  if (!text && !requested.length)
+    return errResult('send requires `text` or `attachments`');
+  if (requested.length && m.station.attachmentMode === 'none')
+    return errResult(unsupported(m.station, requested));
+  const atts = await resolveAttachments(requested, {
+    allowed: allowedAgents(currentIdentity()),
+  });
+  try {
+    const native =
+      m.station.attachmentMode === 'native' &&
+      typeof m.station.sendAttachments === 'function';
+    const sent = native
+      ? await sendNative(m, text, replyTo, atts)
+      : await sendForwarded(m, text, replyTo, atts);
+    if (!sent.labels.length)
+      return errResult('send requires `text` or `attachments`');
+    return ok(withId(`sent: ${sent.labels.join(', ')}`, sent.messageId));
+  } finally {
+    await cleanupAttachments(atts);
+  }
+}
+
+async function handleRead({ line, a, ctx }: MessageArgs): Promise<ToolResult> {
+  const args: Record<string, unknown> = { line };
+  if (typeof a.limit === 'number') args.limit = a.limit;
+  if (a.before) args.before = str(a.before);
+  if (a.since) args.since = str(a.since);
+  return okJson(await ctx.call('read', args));
+}
+
+type MessageHandler = (m: MessageArgs) => Promise<ToolResult>;
+
+interface VerbSpec {
+  args: readonly (readonly [string, string])[];
+  success: string;
+}
+
+const MESSAGE_VERBS: Record<string, VerbSpec> = {
+  reply: { args: [['message_id', 'replyTo'], ['text', 'text']], success: 'replied' },
+  react: { args: [['message_id', 'messageId'], ['emoji', 'emoji']], success: 'reacted' },
+  unreact: {
+    args: [['message_id', 'messageId'], ['emoji', 'emoji']],
+    success: 'reaction removed',
+  },
+  edit: { args: [['message_id', 'messageId'], ['text', 'text']], success: 'edited' },
+  delete: { args: [['message_id', 'messageId']], success: 'deleted' },
+};
+
+function makeVerbHandler(verb: string, spec: VerbSpec): MessageHandler {
+  return async ({ line, a, ctx }) => {
+    const payload: Record<string, unknown> = { line };
+    for (const [snake, camel] of spec.args) {
+      const value = str(a[snake]);
+      if (!value) {
+        const fields = spec.args.map(([snakeName]) => `\`${snakeName}\``).join(' and ');
+        return errResult(`${verb} requires ${fields}`);
+      }
+      payload[camel] = value;
+    }
+    const response = await ctx.call(verb, payload);
+    return ok(withId(spec.success, messageIdOf(response)));
+  };
+}
+
+const MESSAGE_HANDLERS: Record<string, MessageHandler> = {
+  send: handleSend,
+  read: handleRead,
+  ...Object.fromEntries(
+    Object.entries(MESSAGE_VERBS).map(([verb, spec]) => [verb, makeVerbHandler(verb, spec)]),
+  ),
+};
+
+export async function dispatchMessageTool(
+  name: string,
+  a: Record<string, unknown>,
+): Promise<ToolResult> {
+  const line = str(a.line);
+  if (!line) return errResult(`${name} requires \`line\``);
+  const station = stationForLine(line);
+  if (!station || station.messageVerbs.size === 0) {
+    return errResult(
+      `${station?.name ?? 'these'} lines do not support outbound messaging (send/reply/react/unreact/edit/delete/read).`,
+    );
+  }
+  const handler = MESSAGE_HANDLERS[name];
+  if (!handler) return errResult(`unknown tool: ${name}`);
+  try {
+    return await handler({ line, a, ctx: makeCtx(station.name), station });
+  } catch (e) {
+    return toErr(name, e);
+  }
+}