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

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

@@ -0,0 +1,197 @@
+import { errMsg } from '@metro-labs/mcp/log';
+import {
+  joinVoiceChannel,
+  getVoiceConnection,
+  VoiceConnectionStatus,
+  entersState,
+  type VoiceConnection,
+} from '@discordjs/voice';
+import type { Client, VoiceBasedChannel } from 'discord.js';
+import { accountFor, accounts } from './accounts.js';
+import { respond } from './wire.js';
+import {
+  startTranscription,
+  stopTranscription,
+  setTranscription,
+} from './voice-transcribe.js';
+
+const DEFAULT_USERNAME = 'bonustrack_';
+
+function clientFor(account?: string): { accountId: string; client: Client } {
+  const accountId = accountFor({ account });
+  const acct = accounts.get(accountId);
+  if (!acct) throw new Error(`unknown account '${accountId}'`);
+  return { accountId, client: acct.client };
+}
+
+function voiceStateMatches(
+  vs: { id: string; member?: { user: { username?: string } } | null },
+  opts: { userId?: string; username?: string },
+): boolean {
+  if (opts.userId && vs.id === opts.userId) return true;
+  return Boolean(
+    opts.username &&
+      vs.member?.user.username?.toLowerCase() === opts.username.toLowerCase(),
+  );
+}
+
+function findUserVoiceChannel(
+  client: Client,
+  opts: { userId?: string; username?: string },
+): VoiceBasedChannel | null {
+  for (const guild of client.guilds.cache.values()) {
+    for (const vs of guild.voiceStates.cache.values()) {
+      if (!vs.channelId) continue;
+      if (voiceStateMatches(vs, opts)) return vs.channel ?? null;
+    }
+  }
+  return null;
+}
+
+async function resolveTarget(
+  client: Client,
+  args: {
+    guildId?: string;
+    channelId?: string;
+    userId?: string;
+    username?: string;
+  },
+): Promise<VoiceBasedChannel> {
+  if (args.channelId) {
+    const ch = await client.channels.fetch(args.channelId);
+    if (!ch || !('guild' in ch) || !ch.isVoiceBased()) {
+      throw new Error(`channel ${args.channelId} is not a voice channel`);
+    }
+    return ch;
+  }
+  const ch = findUserVoiceChannel(client, {
+    userId: args.userId,
+    username: args.userId ? undefined : (args.username ?? DEFAULT_USERNAME),
+  });
+  if (!ch) {
+    const who = args.userId ?? args.username ?? DEFAULT_USERNAME;
+    throw new Error(
+      `could not find a voice channel for '${who}' — ` +
+        'is the user connected to voice in a guild the bot shares, and is the ' +
+        'GuildVoiceStates intent enabled? (full daemon restart needed after intent change)',
+    );
+  }
+  return ch;
+}
+
+export async function joinVoice(
+  id: string,
+  rawArgs: Record<string, unknown>,
+): Promise<void> {
+  const args = rawArgs as {
+    account?: string;
+    guildId?: string;
+    channelId?: string;
+    userId?: string;
+    username?: string;
+  };
+  const { accountId, client } = clientFor(args.account);
+  if (!client.isReady()) {
+    respond(id, { error: `gateway not ready for '${accountId}'` });
+    return;
+  }
+
+  const channel = await resolveTarget(client, args);
+  const guild = channel.guild;
+
+  const connection: VoiceConnection = joinVoiceChannel({
+    channelId: channel.id,
+    guildId: guild.id,
+    adapterCreator: guild.voiceAdapterCreator,
+    selfDeaf: false,
+    selfMute: true,
+  });
+
+  try {
+    await entersState(connection, VoiceConnectionStatus.Ready, 15_000);
+  } catch (err) {
+    connection.destroy();
+    throw new Error(
+      `voice connection failed to become Ready: ${errMsg(err)}`,
+    );
+  }
+
+  try {
+    startTranscription(guild.id, channel.id, accountId, client, connection);
+  } catch (err) {
+    process.stderr.write(
+      `voice transcription arm failed: ${errMsg(err)}\n`,
+    );
+  }
+
+  respond(id, {
+    result: {
+      ok: true,
+      account: accountId,
+      guildId: guild.id,
+      guildName: guild.name,
+      channelId: channel.id,
+      channelName: channel.name,
+      status: connection.state.status,
+      transcribing: true,
+    },
+  });
+}
+
+export function voiceDebug(id: string, rawArgs: Record<string, unknown>): void {
+  const args = rawArgs as { account?: string };
+  const { accountId, client } = clientFor(args.account);
+  const guilds = [...client.guilds.cache.values()].map((g) => {
+    const voiceChannels = [...g.channels.cache.values()]
+      .filter((c) => c.isVoiceBased())
+      .map((c) => ({ id: c.id, name: c.name }));
+    const occupants = [...g.voiceStates.cache.values()]
+      .filter((vs) => vs.channelId)
+      .map((vs) => ({
+        channelId: vs.channelId,
+        channelName: vs.channel?.name ?? null,
+        userId: vs.id,
+        username: vs.member?.user.username ?? null,
+      }));
+    return { id: g.id, name: g.name, voiceChannels, occupants };
+  });
+  respond(id, {
+    result: { ok: true, account: accountId, ready: client.isReady(), guilds },
+  });
+}
+
+export function leaveVoice(id: string, rawArgs: Record<string, unknown>): void {
+  const args = rawArgs as { account?: string; guildId?: string };
+  const { accountId, client } = clientFor(args.account);
+
+  const guildIds = args.guildId
+    ? [args.guildId]
+    : [...client.guilds.cache.keys()];
+  const left: string[] = [];
+  for (const gid of guildIds) {
+    const conn = getVoiceConnection(gid);
+    if (conn) {
+      stopTranscription(gid);
+      conn.destroy();
+      left.push(gid);
+    }
+  }
+  respond(id, { result: { ok: true, account: accountId, leftGuilds: left } });
+}
+
+export function voiceTranscribe(
+  id: string,
+  rawArgs: Record<string, unknown>,
+): void {
+  const args = rawArgs as { account?: string; guildId?: string; on?: boolean };
+  const { accountId, client } = clientFor(args.account);
+  const on = args.on !== false;
+  const guildIds = args.guildId
+    ? [args.guildId]
+    : [...client.guilds.cache.keys()];
+  const toggled: string[] = [];
+  for (const gid of guildIds) if (setTranscription(gid, on)) toggled.push(gid);
+  respond(id, {
+    result: { ok: true, account: accountId, on, toggledGuilds: toggled },
+  });
+}

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

@@ -0,0 +1,5 @@
+export { emit, respond, mintId } from '@metro-labs/mcp/stations/station-runtime';
+
+export const SELF_URI =
+  process.env.METRO_SELF_URI ??
+  'metro://claude/user/8a1857f3-4039-4da6-a4e1-611b432d2082';

package/runtime/node_modules/@metro-labs/mcp/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@metro-labs/mcp",
+  "version": "0.1.0-beta.15",
+  "private": true,
+  "description": "Event-interception wire. Supervises train subprocesses in ~/.metro/trains/, multiplexes their JSON event stream onto stdout, and routes outbound action calls back via stdin. Per-platform code is written by the agent (or user) as train scripts — metro core is pure transport.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bonustrack/metro.git"
+  },
+  "homepage": "https://github.com/bonustrack/metro#readme",
+  "bugs": "https://github.com/bonustrack/metro/issues",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "bin": {
+    "metro-daemon": "./dist/server.js"
+  },
+  "exports": {
+    ".": "./src/mcp/index.ts",
+    "./server": "./dist/server.js",
+    "./log": "./src/daemon/log.ts",
+    "./train-error": "./src/daemon/train-error.ts",
+    "./secure-fs": "./src/daemon/secure-fs.ts",
+    "./lines": "./src/stations/lines.ts",
+    "./events": "./src/daemon/events.ts",
+    "./endpoints": "./src/daemon/tunnel.ts",
+    "./trains/protocol": "./src/daemon/protocol.ts",
+    "./stations/types": "./src/stations/types.ts",
+    "./stations/station-runtime": "./src/stations/station-runtime.ts",
+    "./stations/account-store": "./src/stations/account-store.ts",
+    "./stations/attachments": "./src/stations/attachments.ts",
+    "./stations/messaging-normalize": "./src/stations/messaging-normalize.ts",
+    "./db/whatsapp-login": "./src/db/whatsapp-login.ts"
+  },
+  "scripts": {
+    "start": "bun src/server.ts",
+    "build": "tsc",
+    "db:generate": "drizzle-kit generate",
+    "db:migrate": "drizzle-kit migrate",
+    "test": "tsc --noEmit && DYLD_FALLBACK_LIBRARY_PATH=/usr/lib METRO_STATE_DIR=\"$(mktemp -d /tmp/metro-test.XXXXXX)\" bun test test/"
+  },
+  "dependencies": {
+    "@metro-labs/discord-bot": "workspace:*",
+    "@metro-labs/telegram": "workspace:*",
+    "@metro-labs/telegram-bot": "workspace:*",
+    "@metro-labs/webhook": "workspace:*",
+    "@metro-labs/whatsapp": "workspace:*",
+    "@metro-labs/xmtp": "workspace:*",
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "drizzle-kit": "^0.31.0",
+    "drizzle-orm": "^0.44.0",
+    "pino": "^9.5.0",
+    "pino-pretty": "^13.1.3",
+    "postgres": "^3.4.5",
+    "viem": "2.52.2",
+    "zod": "^3.23.8"
+  },
+  "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/mcp/src/channels/dedupe.ts

@@ -0,0 +1,24 @@
+import { accountFromLine, agentIdForAccount } from '../db/agent-map.js';
+
+const accountStrippedLine = (line: string): string => {
+  const parts = line.split('/');
+  if (parts.length < 5) return line;
+  return [parts[0], parts[1], parts[2], ...parts.slice(4)].join('/');
+};
+
+export const dedupeOwner = (line: string): string => {
+  const acct = accountFromLine(line);
+  if (!acct) return 'unowned';
+  const agentId = agentIdForAccount(acct.station, acct.accountId);
+  return agentId === undefined
+    ? `account:${acct.accountId}`
+    : `agent:${agentId}`;
+};
+
+export const dedupeKey = (
+  station: string,
+  line: string,
+  kind: string,
+  messageId: string,
+): string =>
+  `${dedupeOwner(line)} ${station} ${accountStrippedLine(line)} ${kind} ${messageId}`;

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

@@ -0,0 +1,367 @@
+import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { str } from '../mcp/str.js';
+import { dedupeKey } from './dedupe.js';
+import {
+  buildMediaFailureNote,
+  buildMediaNote,
+  type MediaNote,
+  type SavedMedia,
+} from './media-note.js';
+import { buildWebhookNote } from './webhook-note.js';
+import {
+  capSet,
+  displayNameMeta,
+  senderMeta,
+  tsMeta,
+  takeMediaCtx,
+  type MediaCtx,
+  type PendingAtt,
+  type PendingMsg,
+} from './pending.js';
+
+interface InboundDeps {
+  mcp: Server;
+  log: (...a: unknown[]) => void;
+  getStations: () => Set<string>;
+  senderAllowed: (from: string, line: string) => boolean;
+}
+
+const ATTACH_TIMEOUT_MS = 15_000;
+const DEDUPE_TTL_MS = 30_000;
+const DEDUPE_MAX = 2_000;
+const ALLOWED_LINES_MAX = 2_000;
+const PENDING_PERMISSIONS_MAX = 500;
+
+const PERMISSION_REPLY_RE = /^\s*(y|yes|n|no)\s+([a-km-z]{5})\s*$/i;
+
+const shortId = (id: string): string =>
+  id.length > 10 ? `${id.slice(0, 6)}…` : id;
+
+export class InboundRelay {
+  private readonly deps: InboundDeps;
+  private readonly pendingAttachments = new Map<string, PendingMsg>();
+  private readonly seenEvents = new Map<string, number>();
+  private readonly allowedLines = new Set<string>();
+  private readonly pendingPermissions = new Set<string>();
+  private lastLine: string | undefined;
+
+  constructor(deps: InboundDeps) {
+    this.deps = deps;
+  }
+
+  get knownLine(): string | undefined {
+    return this.lastLine;
+  }
+
+  registerPermission(requestId: string): void {
+    this.pendingPermissions.add(requestId);
+    capSet(this.pendingPermissions, PENDING_PERMISSIONS_MAX);
+  }
+
+  private notify(method: string, params: Record<string, unknown>): Promise<void> {
+    return this.deps.mcp.notification({ method, params });
+  }
+
+  private isDuplicate(
+    station: string,
+    line: string,
+    kind: string,
+    messageId: string,
+  ): boolean {
+    if (!messageId) return false;
+    const key = dedupeKey(station, line, kind, messageId);
+    const now = Date.now();
+    if (this.seenEvents.size >= DEDUPE_MAX) {
+      for (const [k, t] of this.seenEvents) {
+        if (now - t > DEDUPE_TTL_MS) this.seenEvents.delete(k);
+      }
+    }
+    const prev = this.seenEvents.get(key);
+    if (prev !== undefined && now - prev < DEDUPE_TTL_MS) return true;
+    this.seenEvents.set(key, now);
+    return false;
+  }
+
+  private surfaceNote(
+    ctx: MediaCtx,
+    p: SavedMedia,
+    note: MediaNote,
+    extra: Record<string, unknown>,
+  ): Promise<void> {
+    return this.notify('notifications/claude/channel', {
+      content: note.content,
+      meta: {
+        line: ctx.line,
+        from: ctx.from,
+        station: ctx.station,
+        ...senderMeta(ctx),
+        kind: note.kind,
+        mime: p.mime ?? '',
+        name: note.name,
+        ...extra,
+      },
+    });
+  }
+
+  private async surfaceMedia(ctx: MediaCtx, p: SavedMedia): Promise<void> {
+    const note = await buildMediaNote(p, ctx.text ?? '');
+    if (!note) return;
+    await this.surfaceNote(ctx, p, note, {
+      ...(p.url ? { url: p.url } : {}),
+      local_path: note.path,
+    });
+  }
+
+  private surfaceMediaFailure(ctx: MediaCtx, p: SavedMedia): Promise<void> {
+    return this.surfaceNote(ctx, p, buildMediaFailureNote(p, ctx.text ?? ''), {
+      attachment_error: p.reason ?? '',
+    });
+  }
+
+  private async flushPendingFallback(id: string): Promise<void> {
+    const e = this.pendingAttachments.get(id);
+    if (!e) return;
+    this.pendingAttachments.delete(id);
+    const missing = e.attachments.filter((_, i) => !e.saved.has(i));
+    if (!missing.length) return;
+    const names = missing
+      .map((a) => a.name ?? a.kind ?? 'attachment')
+      .join(', ');
+    await this.notify('notifications/claude/channel', {
+      content:
+        (e.text ? `${e.text}\n` : '') +
+        `[attachment(s) could not be fetched in time: ${names}]`,
+      meta: {
+        line: e.line,
+        from: e.from,
+        station: e.station,
+        ...tsMeta(e.ts),
+        message_id: e.messageId,
+        line_name: e.lineName,
+        from_name: e.fromName,
+        ...displayNameMeta(e.fromDisplayName),
+      },
+    });
+  }
+
+  private mediaCtxFor(
+    ev: Record<string, unknown>,
+    payload: SavedMedia,
+  ): MediaCtx | null {
+    const forId = str(payload.attachmentFor);
+    const buf = forId ? this.pendingAttachments.get(forId) : undefined;
+    if (buf) {
+      buf.saved.add(typeof payload.index === 'number' ? payload.index : 0);
+      const ctx = takeMediaCtx(buf);
+      if (buf.saved.size >= buf.attachments.length) {
+        clearTimeout(buf.timer);
+        this.pendingAttachments.delete(forId);
+      }
+      return ctx;
+    }
+    const line = str(ev.line);
+    if (!line || !this.allowedLines.has(line)) return null;
+    return {
+      line,
+      from: 'metro://attachment',
+      station: str(ev.station) || 'xmtp',
+      ts: str(ev.ts),
+    };
+  }
+
+  private async routeAttachment(ev: Record<string, unknown>): Promise<boolean> {
+    const p = ev.payload as SavedMedia | undefined;
+    if (!p) return false;
+    const type = p.contentType;
+    if (type !== 'attachmentSaved' && type !== 'attachmentFailed') return false;
+    const ctx = this.mediaCtxFor(ev, p);
+    if (!ctx) return true;
+    if (type === 'attachmentFailed') await this.surfaceMediaFailure(ctx, p);
+    else await this.surfaceMedia(ctx, p);
+    return true;
+  }
+
+  private bufferAttachments(
+    ev: Record<string, unknown>,
+    base: { line: string; from: string; station: string; text: string },
+    atts: PendingAtt[],
+  ): void {
+    const id = str(ev.id);
+    if (!id) return;
+    const existing = this.pendingAttachments.get(id);
+    if (existing) clearTimeout(existing.timer);
+    this.pendingAttachments.set(id, {
+      ...base,
+      ts: str(ev.ts),
+      messageId: str(ev.messageId),
+      lineName: str(ev.lineName),
+      fromName: str(ev.fromName),
+      fromDisplayName: str(ev.fromDisplayName),
+      attachments: atts.map((a) => ({ kind: a.kind, name: a.name })),
+      saved: new Set<number>(),
+      timer: setTimeout(() => {
+        this.flushPendingFallback(id).catch((err: unknown) => {
+          this.deps.log(
+            'inbound: attachment fallback not delivered',
+            'id',
+            id,
+            'line',
+            base.line,
+            err,
+          );
+        });
+      }, ATTACH_TIMEOUT_MS),
+    });
+  }
+
+  private async handleReact(
+    ev: Record<string, unknown>,
+    base: { line: string; from: string; station: string; text: string },
+  ): Promise<void> {
+    const re = ev.event as { emoji?: unknown; targetId?: string };
+    const emoji = reactionEmoji(re.emoji);
+    const target = re.targetId ?? str(ev.messageId);
+    const removed =
+      (ev.payload as { removed?: boolean } | undefined)?.removed === true ||
+      / \(removed\)\]?$/.test(base.text);
+    const verb = removed ? 'removed from' : 'reacted to';
+    const label = removed ? emoji || 'reaction' : emoji || 'reacted';
+    const content = `${label} ${verb} message ${shortId(target)}`.trim();
+    await this.notify('notifications/claude/channel', {
+      content,
+      meta: {
+        line: base.line,
+        from: base.from,
+        station: base.station,
+        ...tsMeta(ev.ts),
+        message_id: str(ev.messageId),
+        line_name: str(ev.lineName),
+        from_name: str(ev.fromName),
+        ...displayNameMeta(ev.fromDisplayName),
+        reaction: emoji,
+        target_id: target,
+      },
+    });
+  }
+
+  private async handlePermissionReply(text: string): Promise<boolean> {
+    const m = PERMISSION_REPLY_RE.exec(text);
+    if (m?.[1] === undefined || m[2] === undefined || !this.pendingPermissions.size)
+      return false;
+    const id = m[2].toLowerCase();
+    if (!this.pendingPermissions.has(id)) return false;
+    this.pendingPermissions.delete(id);
+    await this.notify('notifications/claude/channel/permission', {
+      request_id: id,
+      behavior: m[1].toLowerCase().startsWith('y') ? 'allow' : 'deny',
+    });
+    return true;
+  }
+
+  private droppedSender(from: string, line: string): boolean {
+    if (
+      from.startsWith('metro://claude') ||
+      from === 'metro://user' ||
+      !from.startsWith('metro://')
+    )
+      return true;
+    if (!this.deps.senderAllowed(from, line)) {
+      this.deps.log('drop: sender not allowed', from);
+      return true;
+    }
+    return false;
+  }
+
+  private routable(
+    ev: Record<string, unknown>,
+    replay: boolean,
+  ): EventBase | null {
+    const rawType = ev.event ? (ev.event as { type?: string }).type : 'msg';
+    const evType = rawType === 'reply' ? 'msg' : rawType;
+    if (evType !== 'msg' && evType !== 'react' && evType !== 'system')
+      return null;
+    const station = str(ev.station);
+    if (!this.deps.getStations().has(station)) return null;
+    const from = str(ev.from);
+    const line = str(ev.line);
+    if (this.droppedSender(from, line)) return null;
+    const text = str(ev.text);
+    if (!replay && this.isDuplicate(station, line, evType, str(ev.messageId))) {
+      this.deps.log(
+        'drop: duplicate (per-account) event',
+        evType,
+        station,
+        str(ev.messageId),
+      );
+      return null;
+    }
+    return { evType, station, from, line, text };
+  }
+
+  private async emitMessage(
+    ev: Record<string, unknown>,
+    base: EventBase,
+  ): Promise<void> {
+    if (base.evType === 'msg' && (await this.handlePermissionReply(base.text)))
+      return;
+    await this.notify('notifications/claude/channel', {
+      content:
+        base.evType === 'system'
+          ? buildWebhookNote(base.text, str(ev.lineName), ev.payload)
+          : base.text,
+      meta: {
+        line: base.line,
+        from: base.from,
+        station: base.station,
+        ...tsMeta(ev.ts),
+        message_id: str(ev.messageId),
+        line_name: str(ev.lineName),
+        from_name: str(ev.fromName),
+        ...displayNameMeta(ev.fromDisplayName),
+      },
+    });
+  }
+
+  async handleEvent(
+    ev: Record<string, unknown>,
+    replay = false,
+  ): Promise<void> {
+    if (await this.routeAttachment(ev)) return;
+
+    const base = this.routable(ev, replay);
+    if (!base) return;
+    if (base.evType !== 'system') this.lastLine = base.line;
+    if (base.line) {
+      this.allowedLines.add(base.line);
+      capSet(this.allowedLines, ALLOWED_LINES_MAX);
+    }
+
+    const atts = (ev.payload as { attachments?: PendingAtt[] } | undefined)
+      ?.attachments;
+    if (Array.isArray(atts) && atts.length) {
+      this.bufferAttachments(ev, base, atts);
+      return;
+    }
+
+    if (base.evType === 'react') {
+      await this.handleReact(ev, base);
+      return;
+    }
+
+    await this.emitMessage(ev, base);
+  }
+}
+
+interface EventBase {
+  evType: string;
+  station: string;
+  from: string;
+  line: string;
+  text: string;
+}
+
+function reactionEmoji(raw: unknown): string {
+  if (typeof raw === 'string') return raw;
+  const obj = raw as { name?: string; reaction?: string } | undefined;
+  return obj?.name ?? obj?.reaction ?? '';
+}