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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.4",
-  "description": "Orchestrator daemon that bridges Codex / Claude Code agent sessions with Telegram and Discord. Each chat thread gets its own agent session, with streaming responses and tool-call visibility.",
+  "version": "0.1.0-beta.41",
+  "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -14,34 +14,47 @@
     "node": ">=22"
   },
   "bin": {
-    "metro": "./dist/cli.js"
+    "metro": "dist/cli.js"
   },
   "files": [
     "dist",
-    "README.md",
-    "LICENSE"
+    "runtime"
   ],
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "tag": "beta"
   },
   "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "tsc",
-    "lint": "eslint src/",
-    "lint:fix": "eslint src/ --fix",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "discord.js": "^14.14.0",
-    "pino": "^9.5.0",
-    "ws": "^8.20.0"
+    "build": "tsc && node scripts/stage-runtime.mjs",
+    "prepublishOnly": "tsc && node scripts/stage-runtime.mjs",
+    "test": "tsc --noEmit && node scripts/stage-runtime.mjs && bun test test/"
   },
   "devDependencies": {
-    "@types/node": "^22.10.0",
-    "@types/ws": "^8.18.1",
+    "@stage-labs/config": "0.1.0-beta.2",
     "eslint": "^10.3.0",
-    "typescript": "^5",
-    "typescript-eslint": "^8.59.2"
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
   },
-  "packageManager": "bun@1.3.9"
+  "dependencies": {
+    "@discordjs/voice": "^0.19.2",
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@mtcute/bun": "0.30.1",
+    "@xmtp/content-type-primitives": "^3.0.1",
+    "@xmtp/content-type-reaction": "^2.0.2",
+    "@xmtp/content-type-remote-attachment": "^2.0.4",
+    "@xmtp/content-type-reply": "^2.0.3",
+    "@xmtp/content-type-wallet-send-calls": "^2.0.0",
+    "@xmtp/node-bindings": "1.9.1",
+    "@xmtp/node-sdk": "^6.0.0",
+    "baileys": "7.0.0-rc14",
+    "discord.js": "^14.26.4",
+    "drizzle-orm": "^0.44.0",
+    "pino": "^9.5.0",
+    "pino-pretty": "^13.1.3",
+    "postgres": "^3.4.5",
+    "prism-media": "^1.3.5",
+    "viem": "^2.52.2",
+    "zod": "^3.23.8"
+  }
 }

package/runtime/node_modules/@metro-labs/discord-bot/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@metro-labs/discord-bot",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/station.ts",
+    "./train": "./src/index.ts",
+    "./verify": "./src/verify.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && bun test test/"
+  },
+  "dependencies": {
+    "@metro-labs/mcp": "workspace:*",
+    "@discordjs/voice": "^0.19.2",
+    "discord.js": "^14.26.4",
+    "prism-media": "^1.3.5"
+  },
+  "devDependencies": {
+    "@stage-labs/config": "0.1.0-beta.2",
+    "eslint": "^10.3.0",
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
+}

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

@@ -0,0 +1,119 @@
+import { Client } from 'discord.js';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import {
+  makeAccountStore,
+  resolveAccountId,
+} from '@metro-labs/mcp/stations/account-store';
+import { Line } from '@metro-labs/mcp/lines';
+import { emit } from './wire.js';
+import { API } from './api-base.js';
+
+const ACCOUNTS_FILE =
+  process.env.DISCORD_BOT_ACCOUNTS_FILE ??
+  join(homedir(), '.metro', 'discord-bot-accounts.json');
+
+export interface AccountConfig {
+  id: string;
+  token: string;
+  owner?: string;
+}
+
+export const { loadAccounts } = makeAccountStore<AccountConfig>({
+  prefix: 'discord-bot',
+  file: ACCOUNTS_FILE,
+  allowlistEnv: ['DISCORD_BOT_ONLY_ACCOUNTS', 'DISCORD_BOT_ACCOUNTS'],
+  validate(raw, die) {
+    const seen = new Set<string>();
+    for (const a of raw) {
+      if (!a.id) die('account missing id');
+      if (!a.token || typeof a.token !== 'string')
+        die(`account '${a.id}' missing token`);
+      if (seen.has(a.id)) die(`duplicate account id '${a.id}'`);
+      seen.add(a.id);
+    }
+  },
+});
+
+export interface Account {
+  cfg: AccountConfig;
+  client: Client;
+}
+export const accounts = new Map<string, Account>();
+
+function restBody(
+  body: unknown,
+  isForm: boolean,
+): RequestInit['body'] | undefined {
+  if (body === undefined) return undefined;
+  return isForm ? (body as RequestInit['body']) : JSON.stringify(body);
+}
+
+async function restResult<T>(res: Response): Promise<T> {
+  if (res.status === 204) return undefined as T;
+  const ctype = res.headers.get('content-type') ?? '';
+  if (ctype.includes('application/json')) return res.json() as Promise<T>;
+  return res.arrayBuffer().then((b) => Buffer.from(b) as unknown as T);
+}
+
+export async function rest<T = unknown>(
+  accountId: string,
+  method: string,
+  path: string,
+  body?: unknown,
+  isForm = false,
+): Promise<T> {
+  const acct = accounts.get(accountId);
+  if (!acct) throw new Error(`unknown account '${accountId}'`);
+  const headers: Record<string, string> = {
+    Authorization: `Bot ${acct.cfg.token}`,
+    'User-Agent': 'metro-discord-bot-train (https://github.com/bonustrack/stage)',
+  };
+  if (body !== undefined && !isForm)
+    headers['Content-Type'] = 'application/json';
+  emit({ op: 'log', text: `discord-bot[${accountId}] api ${method} ${path}` });
+  const res = await fetch(`${API}${path}`, {
+    method,
+    headers,
+    body: restBody(body, isForm),
+    signal: AbortSignal.timeout(30_000),
+  });
+  emit({
+    op: 'log',
+    text: `discord-bot[${accountId}] api ${method} ${path} -> ${res.status}`,
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`discord-bot ${method} ${path}: ${res.status} ${text}`);
+  }
+  return restResult<T>(res);
+}
+
+export function lineOf(accountId: string, channelId: string): string {
+  return `metro://discord-bot/${accountId}/${channelId}`;
+}
+
+export function parseLine(
+  line: string,
+): { accountId: string; channelId: string } | null {
+  const p = Line.parseDiscord(line);
+  return p ? { accountId: p.accountId, channelId: p.resource } : null;
+}
+
+export function accountFor(args: { account?: string; line?: string }): string {
+  return resolveAccountId(accounts, args, (line) => parseLine(line)?.accountId);
+}
+
+export function routeOf(
+  line: string,
+  account?: string,
+): { accountId: string; channelId: string } {
+  const parsed = parseLine(line);
+  if (!parsed) throw new Error(`bad discord-bot line: ${line}`);
+  const accountId = account ?? parsed.accountId;
+  if (!accounts.has(accountId))
+    throw new Error(`unknown account '${accountId}' in line ${line}`);
+  return { accountId, channelId: parsed.channelId };
+}
+
+export const encodeEmoji = (e: string): string => encodeURIComponent(e);

package/runtime/node_modules/@metro-labs/discord-bot/src/actions.ts

@@ -0,0 +1,388 @@
+import {
+  ActivityType,
+  type Message,
+  type PresenceStatusData,
+} from 'discord.js';
+import {
+  accountFor,
+  accounts,
+  encodeEmoji,
+  lineOf,
+  rest,
+  routeOf,
+} from './accounts.js';
+import { emitOutbound, emitOutboundEdit, emitOutboundReact } from './format.js';
+import { respond } from './wire.js';
+import { normalizeDiscord } from '@metro-labs/mcp/stations/messaging-normalize';
+import { assertContentLength } from '@metro-labs/mcp/stations/attachments';
+import {
+  appendFiles,
+  outgoingFiles,
+  type OutgoingFile,
+} from './send-files.js';
+import {
+  makeStation,
+  type CallMsg,
+  type StationHandler,
+} from '@metro-labs/mcp/stations/station-runtime';
+import { joinVoice, leaveVoice, voiceDebug, voiceTranscribe } from './voice.js';
+import { speak } from './voice-speak.js';
+import { discordMembers } from './members.js';
+import {
+  groupAddHandler,
+  groupCreateHandler,
+  groupRemoveHandler,
+} from './group-actions.js';
+
+async function sendMessage(
+  accountId: string,
+  channel: string,
+  body: Record<string, unknown>,
+  files: OutgoingFile[],
+): Promise<{ id: string; delivered: string[] }> {
+  if (files.length === 0) {
+    const plain = await rest<{ id: string }>(
+      accountId,
+      'POST',
+      `/channels/${channel}/messages`,
+      body,
+    );
+    return { id: plain.id, delivered: [] };
+  }
+  const form = new FormData();
+  form.append('payload_json', JSON.stringify(body));
+  const delivered = await appendFiles(form, files);
+  const res = await rest<{ id: string }>(
+    accountId,
+    'POST',
+    `/channels/${channel}/messages`,
+    form,
+    true,
+  );
+  return { id: res.id, delivered };
+}
+
+export type { CallMsg };
+
+async function send(id: string, args: Record<string, unknown>): Promise<void> {
+  const {
+    line,
+    text,
+    replyTo,
+    embeds,
+    stickerIds,
+    images,
+    files,
+    account,
+    attachmentKinds,
+    attachmentNames,
+  } = args as {
+    line: string;
+    text?: string;
+    replyTo?: string;
+    embeds?: unknown[];
+    stickerIds?: string[];
+    images?: string[];
+    files?: string[];
+    account?: string;
+    attachmentKinds?: string[];
+    attachmentNames?: string[];
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  const body: Record<string, unknown> = { flags: 4 };
+  if (text !== undefined) body.content = text;
+  if (replyTo) body.message_reference = { message_id: replyTo };
+  if (embeds) body.embeds = embeds;
+  if (stickerIds) body.sticker_ids = stickerIds;
+  const outgoing = outgoingFiles(
+    [...(images ?? []), ...(files ?? [])],
+    attachmentNames,
+    attachmentKinds,
+  );
+  const res = await sendMessage(accountId, channelId, body, outgoing);
+  emitOutbound(accountId, line, res.id, text ?? '', replyTo);
+  respond(id, {
+    result: {
+      messageId: res.id,
+      account: accountId,
+      ...(res.delivered.length ? { attachments: res.delivered } : {}),
+    },
+  });
+}
+
+function presence(id: string, args: Record<string, unknown>): void {
+  const {
+    text,
+    status = 'online',
+    account,
+  } = args as {
+    text?: string;
+    status?: PresenceStatusData;
+    account?: string;
+  };
+  const accountId = accountFor({ account });
+  const acct = accounts.get(accountId);
+  if (!acct) {
+    respond(id, { error: `unknown account '${accountId}'` });
+    return;
+  }
+  const client = acct.client;
+  if (!client.user) {
+    respond(id, { error: `gateway not ready for account '${accountId}'` });
+    return;
+  }
+  client.user.setPresence({
+    status,
+    activities: text
+      ? [{ name: 'Custom Status', type: ActivityType.Custom, state: text }]
+      : [],
+  });
+  respond(id, {
+    result: { ok: true, text: text ?? null, status, account: accountId },
+  });
+}
+
+const profileUrl = (userId?: string): string | null =>
+  userId === undefined ? null : `https://discord.com/users/${userId}`;
+
+function listAccounts(id: string): void {
+  respond(id, {
+    result: {
+      accounts: [...accounts.values()].map((a) => ({
+        id: a.cfg.id,
+        handle: a.client.user?.username ?? null,
+        url: profileUrl(a.client.user?.id),
+        userId: a.client.user?.id ?? null,
+        username: a.client.user?.username ?? null,
+        owner: a.cfg.owner ?? null,
+        ready: a.client.isReady(),
+      })),
+    },
+  });
+}
+
+async function react(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, messageId, emoji, account } = args as {
+    line: string;
+    messageId: string;
+    emoji: string;
+    account?: string;
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  if (emoji) {
+    const e = encodeEmoji(emoji);
+    await rest(
+      accountId,
+      'PUT',
+      `/channels/${channelId}/messages/${messageId}/reactions/${e}/@me`,
+    );
+    emitOutboundReact(accountId, line, messageId, emoji);
+  } else {
+    await rest(
+      accountId,
+      'DELETE',
+      `/channels/${channelId}/messages/${messageId}/reactions/@me`,
+    );
+  }
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+async function edit(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, messageId, text, account } = args as {
+    line: string;
+    messageId: string;
+    text: string;
+    account?: string;
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  await rest(accountId, 'PATCH', `/channels/${channelId}/messages/${messageId}`, {
+    content: text,
+  });
+  emitOutboundEdit(accountId, line, messageId, text);
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+async function remove(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const { line, messageId, account } = args as {
+    line: string;
+    messageId: string;
+    account?: string;
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  await rest(accountId, 'DELETE', `/channels/${channelId}/messages/${messageId}`);
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+async function fetchMessages(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const {
+    line,
+    limit = 20,
+    before,
+    account,
+  } = args as {
+    line: string;
+    limit?: number;
+    before?: string;
+    account?: string;
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  const qs = new URLSearchParams({
+    limit: String(limit),
+    ...(before ? { before } : {}),
+  });
+  const msgs = await rest<Message[]>(
+    accountId,
+    'GET',
+    `/channels/${channelId}/messages?${qs}`,
+  );
+  respond(id, { result: { messages: msgs, account: accountId } });
+}
+
+async function download(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const {
+    line,
+    messageId,
+    outDir = '/tmp',
+    account,
+  } = args as {
+    line: string;
+    messageId: string;
+    outDir?: string;
+    account?: string;
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  const msg = await rest<{
+    attachments: { url: string; content_type?: string; filename: string }[];
+  }>(accountId, 'GET', `/channels/${channelId}/messages/${messageId}`);
+  const files: { path: string; mediaType: string }[] = [];
+  for (const att of msg.attachments) {
+    const res = await fetch(att.url, { signal: AbortSignal.timeout(60_000) });
+    if (!res.ok)
+      throw new Error(`discord-bot download ${res.status} for ${att.url}`);
+    assertContentLength(res.headers.get('content-length'));
+    const buf = await res.arrayBuffer();
+    const path = `${outDir}/${messageId}-${att.filename}`;
+    await Bun.write(path, buf);
+    files.push({
+      path,
+      mediaType: att.content_type ?? 'application/octet-stream',
+    });
+  }
+  respond(id, { result: { files, account: accountId } });
+}
+
+async function threadCreate(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const {
+    line,
+    messageId,
+    name,
+    autoArchiveDuration = 1440,
+    account,
+  } = args as {
+    line: string;
+    messageId?: string;
+    name: string;
+    autoArchiveDuration?: number;
+    account?: string;
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  const path = messageId
+    ? `/channels/${channelId}/messages/${messageId}/threads`
+    : `/channels/${channelId}/threads`;
+  const res = await rest<{ id: string }>(accountId, 'POST', path, {
+    name,
+    auto_archive_duration: autoArchiveDuration,
+  });
+  respond(id, {
+    result: {
+      threadId: res.id,
+      line: lineOf(accountId, res.id),
+      account: accountId,
+    },
+  });
+}
+
+async function pin(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, messageId, account } = args as {
+    line: string;
+    messageId: string;
+    account?: string;
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  await rest(accountId, 'PUT', `/channels/${channelId}/pins/${messageId}`);
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+async function typing(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, account } = args as { line: string; account?: string };
+  const { accountId, channelId } = routeOf(line, account);
+  await rest(accountId, 'POST', `/channels/${channelId}/typing`);
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+async function channel(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const { line, account } = args as { line: string; account?: string };
+  const { accountId, channelId } = routeOf(line, account);
+  const res = await rest(accountId, 'GET', `/channels/${channelId}`);
+  respond(id, { result: res });
+}
+
+async function listMembers(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const { line, limit, account } = args as {
+    line: string;
+    limit?: number;
+    account?: string;
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  const result = await discordMembers(accountId, channelId, limit);
+  respond(id, { result });
+}
+
+const HANDLERS: Record<string, StationHandler> = {
+  accounts: (id) => {
+    listAccounts(id);
+  },
+  groupCreate: groupCreateHandler,
+  groupAddMembers: groupAddHandler,
+  groupRemoveMembers: groupRemoveHandler,
+  send,
+  react,
+  edit,
+  delete: remove,
+  fetch: fetchMessages,
+  download,
+  thread_create: threadCreate,
+  pin,
+  typing,
+  channel,
+  listMembers,
+  set_presence: presence,
+  joinVoice,
+  leaveVoice,
+  speak,
+  voiceDebug,
+  voiceTranscribe,
+};
+
+export const handleCall = makeStation({
+  handlers: HANDLERS,
+  normalize: normalizeDiscord,
+});

package/runtime/node_modules/@metro-labs/discord-bot/src/api-base.ts

@@ -0,0 +1 @@
+export const API = 'https://discord.com/api/v10';

package/runtime/node_modules/@metro-labs/discord-bot/src/attachments.ts

@@ -0,0 +1,29 @@
+import {
+  saveBufferToCache,
+  assertContentLength,
+} from '@metro-labs/mcp/stations/attachments';
+import type { SavedAttachment } from '@metro-labs/mcp/stations/attachments';
+
+export type { SavedAttachment };
+
+export interface DiscordAttachmentRef {
+  url: string;
+  name?: string | null;
+  contentType?: string | null;
+}
+
+export async function saveDiscordAttachment(
+  a: DiscordAttachmentRef,
+  messageId: string,
+  index = 0,
+): Promise<SavedAttachment> {
+  const res = await fetch(a.url, { signal: AbortSignal.timeout(60_000) });
+  if (!res.ok)
+    throw new Error(`discord-bot attachment fetch ${res.status} for ${a.url}`);
+  assertContentLength(res.headers.get('content-length'));
+  const data = new Uint8Array(await res.arrayBuffer());
+  return saveBufferToCache(data, messageId, index, {
+    mime: a.contentType ?? undefined,
+    name: a.name ?? undefined,
+  });
+}