@stage-labs/metro 0.1.0-beta.32 → 0.1.0-beta.320

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

@@ -1,197 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,67 +0,0 @@
-{
-  "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

@@ -1,24 +0,0 @@
-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/daemon/account-api.ts

@@ -1,311 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { errMsg, log } from './log.js';
-import { ApiError } from './api-error.js';
-import {
-  apiFailure,
-  bodyField,
-  readJsonBody,
-  sendJson,
-  type ApiSession,
-} from './api-http.js';
-import {
-  isStationName,
-  parseAccountId,
-  type AccountRef,
-} from '../db/account-attach.js';
-import type { StationName } from '../db/schema.js';
-import {
-  ATTACHABLE_STATIONS,
-  isAttachStation,
-  type AttachInput,
-  type OneTimeSecret,
-  type PreparedAccount,
-} from '../stations/attach.js';
-import {
-  INTERACTIVE_STATIONS,
-  isInteractiveStation,
-  type InteractiveStation,
-} from '../stations/attach-interactive.js';
-import {
-  ATTACH_ID_RE,
-  type AttachOwner,
-  type AttachView,
-} from './attach-session.js';
-
-export interface AttachSessionApi {
-  start: (
-    owner: AttachOwner,
-    station: InteractiveStation,
-    input: Record<string, unknown>,
-  ) => Promise<AttachView>;
-  view: (owner: AttachOwner, attachId: string) => AttachView;
-  submit: (
-    owner: AttachOwner,
-    attachId: string,
-    input: { code?: unknown; password?: unknown },
-  ) => Promise<AttachView>;
-  cancel: (owner: AttachOwner, attachId: string) => Promise<void>;
-}
-
-export interface AccountApiDeps {
-  attachSessions: AttachSessionApi;
-  prepareAccount: (input: AttachInput) => Promise<PreparedAccount>;
-  attachAccount: (
-    subject: string,
-    agentId: string,
-    station: StationName,
-    config: Record<string, unknown>,
-  ) => Promise<AccountRef>;
-  detachAccount: (
-    subject: string,
-    agentId: string,
-    station: StationName,
-    accountId: string,
-  ) => Promise<AccountRef>;
-  syncStations: (station: StationName) => Promise<void>;
-}
-
-export type AccountRoute =
-  | { kind: 'start' }
-  | { kind: 'session'; attachId: string }
-  | { kind: 'step'; attachId: string }
-  | { kind: 'account'; station: StationName; accountId: string };
-
-export const ATTACHABLE: string[] = [
-  ...ATTACHABLE_STATIONS,
-  ...INTERACTIVE_STATIONS,
-];
-
-const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
-  start: ['POST'],
-  session: ['GET', 'DELETE'],
-  step: ['POST'],
-  account: ['DELETE'],
-};
-
-function twoSegmentRoute(head: string, tail: string): AccountRoute | null {
-  if (ATTACH_ID_RE.test(head))
-    return tail === 'step' ? { kind: 'step', attachId: head } : null;
-  if (!isStationName(head)) return null;
-  const accountId = parseAccountId(tail);
-  return accountId === null ? null : { kind: 'account', station: head, accountId };
-}
-
-export function accountRoute(rest: string[]): AccountRoute | null {
-  const [head, tail] = rest;
-  if (head === undefined) return null;
-  if (rest.length === 1)
-    return head === 'start'
-      ? { kind: 'start' }
-      : ATTACH_ID_RE.test(head)
-        ? { kind: 'session', attachId: head }
-        : null;
-  if (rest.length !== 2 || tail === undefined) return null;
-  return twoSegmentRoute(head, tail);
-}
-
-export function accountRouteAllows(
-  route: AccountRoute,
-  method: string | undefined,
-): boolean {
-  return ROUTE_METHODS[route.kind].includes(method ?? '');
-}
-
-async function activate(
-  deps: AccountApiDeps,
-  station: StationName,
-): Promise<boolean> {
-  try {
-    await deps.syncStations(station);
-    return true;
-  } catch (err) {
-    log.warn(
-      { station, err: errMsg(err) },
-      'account-api: station reload failed, the change lands at the next boot',
-    );
-    return false;
-  }
-}
-
-interface AttachPayload {
-  status: 'done';
-  agentId: string;
-  station: string;
-  accountId: string;
-  identity: Record<string, string>;
-  activated: boolean;
-  secret?: OneTimeSecret;
-}
-
-async function storeAccount(
-  deps: AccountApiDeps,
-  session: ApiSession,
-  agentId: string,
-  station: StationName,
-  prepared: PreparedAccount,
-): Promise<AccountRef> {
-  try {
-    return await deps.attachAccount(
-      session.subject,
-      agentId,
-      station,
-      prepared.config,
-    );
-  } catch (err) {
-    prepared.discard?.();
-    throw err;
-  }
-}
-
-function ownerOf(session: ApiSession, agentId: string): AttachOwner {
-  return { subject: session.subject, agentId };
-}
-
-function asInput(body: unknown): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
-  for (const key of ['apiId', 'apiHash', 'phone'])
-    out[key] = bodyField(body, key);
-  return out;
-}
-
-async function handleStart(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AccountApiDeps,
-  session: ApiSession,
-  agentId: string,
-): Promise<void> {
-  const body = await readJsonBody(req);
-  const station = bodyField(body, 'station');
-  if (isInteractiveStation(station)) {
-    const view = await deps.attachSessions.start(
-      ownerOf(session, agentId),
-      station,
-      asInput(body),
-    );
-    sendJson(req, res, 201, view);
-    return;
-  }
-  if (!isAttachStation(station))
-    throw new ApiError(`station must be one of ${ATTACHABLE.join(', ')}`, 400);
-  const prepared = await deps.prepareAccount({
-    station,
-    token: bodyField(body, 'token'),
-  });
-  const ref = await storeAccount(deps, session, agentId, station, prepared);
-  log.info(
-    { agentId: ref.agentId, station, account: ref.accountId },
-    'account-api: attached a station account',
-  );
-  const payload: AttachPayload = {
-    status: 'done',
-    agentId: ref.agentId,
-    station,
-    accountId: ref.accountId,
-    identity: prepared.identity,
-    activated: await activate(deps, station),
-  };
-  sendJson(
-    req,
-    res,
-    201,
-    prepared.secret === undefined
-      ? payload
-      : { ...payload, secret: prepared.secret },
-  );
-}
-
-async function handleDetach(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AccountApiDeps,
-  session: ApiSession,
-  agentId: string,
-  target: { station: StationName; accountId: string },
-): Promise<void> {
-  const ref = await deps.detachAccount(
-    session.subject,
-    agentId,
-    target.station,
-    target.accountId,
-  );
-  log.info(
-    { agentId: ref.agentId, station: ref.station, account: ref.accountId },
-    'account-api: detached a station account',
-  );
-  sendJson(req, res, 200, {
-    agentId: ref.agentId,
-    station: ref.station,
-    accountId: ref.accountId,
-    detached: true,
-    activated: await activate(deps, ref.station),
-  });
-}
-
-async function handleSession(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AccountApiDeps,
-  owner: AttachOwner,
-  attachId: string,
-): Promise<void> {
-  if (req.method === 'DELETE') {
-    await deps.attachSessions.cancel(owner, attachId);
-    sendJson(req, res, 200, { attachId, cancelled: true });
-    return;
-  }
-  sendJson(req, res, 200, deps.attachSessions.view(owner, attachId));
-}
-
-async function handleStep(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AccountApiDeps,
-  owner: AttachOwner,
-  attachId: string,
-): Promise<void> {
-  const body = await readJsonBody(req);
-  const view = await deps.attachSessions.submit(owner, attachId, {
-    code: bodyField(body, 'code'),
-    password: bodyField(body, 'password'),
-  });
-  sendJson(req, res, 200, view);
-}
-
-async function dispatchRoute(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AccountApiDeps,
-  session: ApiSession,
-  agentId: string,
-  route: AccountRoute,
-): Promise<void> {
-  if (route.kind === 'start')
-    return handleStart(req, res, deps, session, agentId);
-  if (route.kind === 'session')
-    return handleSession(
-      req,
-      res,
-      deps,
-      ownerOf(session, agentId),
-      route.attachId,
-    );
-  if (route.kind === 'step')
-    return handleStep(req, res, deps, ownerOf(session, agentId), route.attachId);
-  return handleDetach(req, res, deps, session, agentId, route);
-}
-
-export async function handleAccountRoute(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: AccountApiDeps,
-  session: ApiSession,
-  agentId: string,
-  route: AccountRoute,
-): Promise<void> {
-  try {
-    await dispatchRoute(req, res, deps, session, agentId, route);
-  } catch (err) {
-    apiFailure(req, res, err);
-  }
-}