@stage-labs/metro 0.1.0-beta.21 → 0.1.0-beta.210

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

@@ -1,292 +0,0 @@
-import { errMsg } from '@metro-labs/mcp/log';
-import {
-  EndBehaviorType,
-  type VoiceConnection,
-  type VoiceReceiver,
-} from '@discordjs/voice';
-import type { Client } from 'discord.js';
-import { spawn, type ChildProcess } from 'node:child_process';
-import {
-  createWriteStream,
-  existsSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { pipeline } from 'node:stream/promises';
-import prism from 'prism-media';
-import { emitInbound } from './format.js';
-import { mintId } from './wire.js';
-
-const WHISPER_BIN = process.env.WHISPER_CLI ?? 'whisper-cli';
-const WHISPER_MODEL =
-  process.env.WHISPER_MODEL ??
-  join(process.env.HOME ?? '', '.whisper-models', 'ggml-base.en.bin');
-const FFMPEG_BIN = process.env.FFMPEG_BIN ?? 'ffmpeg';
-const MIN_PCM_BYTES = 0.5 * 48000 * 2 * 2;
-const TRANSCRIBE_TIMEOUT_MS = 120_000;
-
-function killAfter(p: ChildProcess, ms: number): () => void {
-  const t = setTimeout(() => {
-    p.kill('SIGKILL');
-  }, ms);
-  return () => {
-    clearTimeout(t);
-  };
-}
-
-interface Session {
-  receiver: VoiceReceiver;
-  accountId: string;
-  guildId: string;
-  channelId: string;
-  client: Client;
-  active: Set<string>;
-  tmp: string;
-  enabled: boolean;
-  onStart?: (userId: string) => void;
-}
-
-const sessions = new Map<string, Session>();
-
-function run(bin: string, args: string[]): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const p = spawn(bin, args, { stdio: ['ignore', 'ignore', 'ignore'] });
-    const cancel = killAfter(p, TRANSCRIBE_TIMEOUT_MS);
-    p.on('error', (e) => {
-      cancel();
-      reject(e);
-    });
-    p.on('close', (code) => {
-      cancel();
-      resolve(code ?? 0);
-    });
-  });
-}
-
-async function captureUtterance(
-  s: Session,
-  userId: string,
-  pcmPath: string,
-): Promise<number> {
-  const opus = s.receiver.subscribe(userId, {
-    end: { behavior: EndBehaviorType.AfterSilence, duration: 1000 },
-  });
-  const decoder = new prism.opus.Decoder({
-    rate: 48000,
-    channels: 2,
-    frameSize: 960,
-  });
-  let bytes = 0;
-  decoder.on('data', (c: Buffer) => {
-    bytes += c.length;
-  });
-  const out = createWriteStream(pcmPath);
-  await pipeline(opus, decoder, out);
-  return bytes;
-}
-
-async function pcmToWav(pcmPath: string, wavPath: string): Promise<void> {
-  await run(FFMPEG_BIN, [
-    '-hide_banner',
-    '-loglevel',
-    'error',
-    '-y',
-    '-f',
-    's16le',
-    '-ar',
-    '48000',
-    '-ac',
-    '2',
-    '-i',
-    pcmPath,
-    '-ar',
-    '16000',
-    '-ac',
-    '1',
-    wavPath,
-  ]);
-}
-
-function transcribe(wavPath: string): Promise<string> {
-  const ofBase = wavPath.replace(/\.wav$/, '');
-  return new Promise((resolve) => {
-    const p = spawn(
-      WHISPER_BIN,
-      [
-        '-m',
-        WHISPER_MODEL,
-        '-f',
-        wavPath,
-        '-otxt',
-        '-of',
-        ofBase,
-        '-np',
-        '-nt',
-      ],
-      { stdio: ['ignore', 'pipe', 'ignore'] },
-    );
-    const cancel = killAfter(p, TRANSCRIBE_TIMEOUT_MS);
-    let out = '';
-    p.stdout.on('data', (d: Buffer) => {
-      out += d.toString();
-    });
-    p.on('error', () => {
-      cancel();
-      resolve('');
-    });
-    p.on('close', () => {
-      cancel();
-      let text = out.trim();
-      if (!text && existsSync(`${ofBase}.txt`)) {
-        try {
-          text = readFileSync(`${ofBase}.txt`, 'utf8').trim();
-        } catch {
-        }
-      }
-      resolve(text);
-    });
-  });
-}
-
-const NOISE = new Set([
-  '',
-  '[blank_audio]',
-  '[silence]',
-  '[ Silence ]',
-  '(silence)',
-  'you',
-  'Thank you.',
-]);
-
-function speakerName(s: Session, userId: string): string {
-  const member = s.client.guilds.cache
-    .get(s.guildId)
-    ?.members.cache.get(userId);
-  return member?.displayName ?? member?.user.username ?? userId;
-}
-
-function emitTranscript(
-  s: Session,
-  userId: string,
-  stamp: string,
-  text: string,
-): void {
-  emitInbound(s.accountId, {
-    kind: 'inbound',
-    id: mintId(),
-    ts: new Date().toISOString(),
-    station: 'discord',
-    line: `metro://discord/${s.accountId}/voice/${s.channelId}`,
-    line_name: 'voice',
-    from: `metro://discord/${s.accountId}/user/${userId}`,
-    from_name: speakerName(s, userId),
-    message_id: stamp,
-    text,
-    is_private: false,
-    payload: {
-      kind: 'voice_transcript',
-      channel_id: s.channelId,
-      user_id: userId,
-    },
-  });
-}
-
-function cleanupFiles(pcmPath: string, wavPath: string): void {
-  for (const f of [pcmPath, wavPath, `${wavPath.replace(/\.wav$/, '')}.txt`]) {
-    try {
-      rmSync(f, { force: true });
-    } catch {
-    }
-  }
-}
-
-async function transcribeUtterance(
-  s: Session,
-  userId: string,
-  pcmPath: string,
-  wavPath: string,
-  stamp: string,
-): Promise<void> {
-  const bytes = await captureUtterance(s, userId, pcmPath);
-  if (bytes < MIN_PCM_BYTES) return;
-  await pcmToWav(pcmPath, wavPath);
-  const text = await transcribe(wavPath);
-  if (NOISE.has(text) || text.length < 2) return;
-  emitTranscript(s, userId, stamp, text);
-}
-
-async function handleSpeaker(s: Session, userId: string): Promise<void> {
-  if (!s.enabled || s.active.has(userId)) return;
-  s.active.add(userId);
-  const stamp = `${userId}_${Date.now()}`;
-  const pcmPath = join(s.tmp, `${stamp}.pcm`);
-  const wavPath = join(s.tmp, `${stamp}.wav`);
-  try {
-    await transcribeUtterance(s, userId, pcmPath, wavPath, stamp);
-  } catch (err) {
-    process.stderr.write(
-      `discord voice transcribe error (${userId}): ${errMsg(err)}\n`,
-    );
-  } finally {
-    s.active.delete(userId);
-    cleanupFiles(pcmPath, wavPath);
-  }
-}
-
-export function startTranscription(
-  guildId: string,
-  channelId: string,
-  accountId: string,
-  client: Client,
-  conn: VoiceConnection,
-): void {
-  stopTranscription(guildId);
-  const receiver = conn.receiver;
-  const s: Session = {
-    receiver,
-    accountId,
-    guildId,
-    channelId,
-    client,
-    active: new Set(),
-    tmp: mkdtempSync(join(tmpdir(), 'metro-voice-')),
-    enabled: true,
-  };
-  s.onStart = (userId: string) => {
-    handleSpeaker(s, userId).catch((err: unknown) => {
-      process.stderr.write(
-        `discord[${accountId}] voice speaker failed: ${errMsg(err)}\n`,
-      );
-    });
-  };
-  receiver.speaking.on('start', s.onStart);
-  sessions.set(guildId, s);
-  process.stderr.write(
-    `discord[${accountId}] voice transcription armed on ${channelId}\n`,
-  );
-}
-
-export function setTranscription(guildId: string, on: boolean): boolean {
-  const s = sessions.get(guildId);
-  if (!s) return false;
-  s.enabled = on;
-  return true;
-}
-
-export function stopTranscription(guildId: string): void {
-  const s = sessions.get(guildId);
-  if (!s) return;
-  try {
-    if (s.onStart) s.receiver.speaking.removeListener('start', s.onStart);
-  } catch {
-  }
-  s.enabled = false;
-  try {
-    rmSync(s.tmp, { recursive: true, force: true });
-  } catch {
-  }
-  sessions.delete(guildId);
-}

package/runtime/node_modules/@metro-labs/discord/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/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,66 +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": "workspace:*",
-    "@metro-labs/telegram": "workspace:*",
-    "@metro-labs/telegram-user": "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",
-    "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}`;