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

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

@@ -0,0 +1,195 @@
+import { errMsg } from '@metro-labs/mcp/log';
+import { spawn } from 'node:child_process';
+import { unlink } from 'node:fs/promises';
+import {
+  createAudioPlayer,
+  createAudioResource,
+  getVoiceConnection,
+  entersState,
+  AudioPlayerStatus,
+  StreamType,
+  NoSubscriberBehavior,
+  type VoiceConnection,
+} from '@discordjs/voice';
+import type { Client } from 'discord.js';
+import { accountFor, accounts, routeOf } from './accounts.js';
+import { respond } from './wire.js';
+
+const TTS_VOICE = 'Samantha';
+
+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 run(cmd: string, args: string[]): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const p = spawn(cmd, args, { stdio: ['ignore', 'ignore', 'pipe'] });
+    let err = '';
+    p.stderr?.on('data', (d: Buffer) => {
+      err += d.toString();
+    });
+    p.on('error', reject);
+    p.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${cmd} exited ${code}: ${err.slice(-400)}`));
+    });
+  });
+}
+
+function channelName(ch: unknown, fallback: string): string {
+  return ch && typeof ch === 'object' && 'name' in ch
+    ? String((ch as { name?: string }).name)
+    : fallback;
+}
+
+function resolveChannelId(args: {
+  channelId?: string;
+  line?: string;
+  account?: string;
+}): string | undefined {
+  if (args.channelId) return args.channelId;
+  if (!args.line) return undefined;
+  try {
+    return routeOf(args.line, args.account).channelId;
+  } catch {
+    return undefined;
+  }
+}
+
+function connByChannel(
+  client: Client,
+  channelId: string | undefined,
+): { conn: VoiceConnection; channelName: string } | null {
+  if (!channelId) return null;
+  const ch = client.channels.cache.get(channelId);
+  const gid =
+    ch && 'guildId' in ch ? (ch as { guildId: string }).guildId : undefined;
+  if (!gid) return null;
+  const conn = getVoiceConnection(gid);
+  if (!conn) return null;
+  return { conn, channelName: channelName(ch, gid) };
+}
+
+function connByGuildScan(
+  client: Client,
+): { conn: VoiceConnection; channelName: string } | null {
+  for (const guild of client.guilds.cache.values()) {
+    const conn = getVoiceConnection(guild.id);
+    if (conn) {
+      const chId = (conn.joinConfig as { channelId?: string }).channelId;
+      const ch = chId ? client.channels.cache.get(chId) : undefined;
+      return { conn, channelName: channelName(ch, guild.name) };
+    }
+  }
+  return null;
+}
+
+function resolveConnection(
+  client: Client,
+  args: { channelId?: string; line?: string; account?: string },
+): { conn: VoiceConnection; channelName: string } | { error: string } {
+  const channelId = resolveChannelId(args);
+  return (
+    connByChannel(client, channelId) ??
+    connByGuildScan(client) ?? {
+      error: 'no active voice connection — run joinVoice first',
+    }
+  );
+}
+
+export async function speak(
+  id: string,
+  rawArgs: Record<string, unknown>,
+): Promise<void> {
+  const args = rawArgs as {
+    account?: string;
+    text?: string;
+    channelId?: string;
+    line?: string;
+    voice?: string;
+  };
+  const text = (args.text ?? '').trim();
+  if (!text) {
+    respond(id, { result: { ok: false, error: 'text is required' } });
+    return;
+  }
+
+  const { accountId, client } = clientFor(args.account);
+  if (!client.isReady()) {
+    respond(id, {
+      result: { ok: false, error: `gateway not ready for '${accountId}'` },
+    });
+    return;
+  }
+
+  const resolved = resolveConnection(client, args);
+  if ('error' in resolved) {
+    respond(id, { result: { ok: false, error: resolved.error } });
+    return;
+  }
+  const { conn, channelName } = resolved;
+
+  const ts = Date.now();
+  const aiff = `/tmp/metro-tts-${ts}.aiff`;
+  const ogg = `/tmp/metro-tts-${ts}.ogg`;
+  const cleanup = async () => {
+    await Promise.allSettled([unlink(aiff), unlink(ogg)]);
+  };
+
+  try {
+    await run('say', ['-v', args.voice ?? TTS_VOICE, '-o', aiff, text]);
+    await run('ffmpeg', [
+      '-hide_banner',
+      '-loglevel',
+      'error',
+      '-y',
+      '-i',
+      aiff,
+      '-ac',
+      '2',
+      '-ar',
+      '48000',
+      '-c:a',
+      'libopus',
+      '-b:a',
+      '64k',
+      '-f',
+      'ogg',
+      ogg,
+    ]);
+
+    const player = createAudioPlayer({
+      behaviors: { noSubscriber: NoSubscriberBehavior.Play },
+    });
+    const resource = createAudioResource(ogg, {
+      inputType: StreamType.OggOpus,
+    });
+    conn.subscribe(player);
+    try {
+      (conn as { rejoin: (c: object) => void }).rejoin({ selfMute: false });
+    } catch {
+    }
+    player.play(resource);
+
+    await entersState(player, AudioPlayerStatus.Playing, 10_000);
+    await entersState(player, AudioPlayerStatus.Idle, 120_000);
+    player.stop();
+    try {
+      (conn as { rejoin: (c: object) => void }).rejoin({ selfMute: true });
+    } catch {
+    }
+
+    respond(id, {
+      result: { ok: true, spoke: text, channelName, account: accountId },
+    });
+  } catch (err) {
+    respond(id, {
+      result: { ok: false, error: errMsg(err), account: accountId },
+    });
+  } finally {
+    await cleanup();
+  }
+}

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

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

@@ -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/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';