@stage-labs/metro 0.1.0-beta.13 → 0.1.0-beta.130

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

@@ -0,0 +1,292 @@
+import { errMsg } from '@metro-labs/core/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-bot',
+    line: `metro://discord-bot/${s.accountId}/voice/${s.channelId}`,
+    line_name: 'voice',
+    from: `metro://discord-bot/${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-bot 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-bot[${accountId}] voice speaker failed: ${errMsg(err)}\n`,
+      );
+    });
+  };
+  receiver.speaking.on('start', s.onStart);
+  sessions.set(guildId, s);
+  process.stderr.write(
+    `discord-bot[${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-bot/src/voice.ts

@@ -0,0 +1,197 @@
+import { errMsg } from '@metro-labs/core/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/core/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/http/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@metro-labs/http",
+  "version": "0.1.0",
+  "private": true,
+  "description": "How a metro server authenticates and answers a request: CORS, the JSON helpers, ApiError, the signed-identity header and the identity registry. Shared by the daemon and api.metro.box, never by a station.",
+  "type": "module",
+  "exports": {
+    "./cors": "./src/cors.ts",
+    "./api-http": "./src/api-http.ts",
+    "./api-error": "./src/api-error.ts",
+    "./signed-identity": "./src/signed-identity.ts",
+    "./identity-key": "./src/identity-key.ts",
+    "./identity-registry": "./src/identity-registry.ts",
+    "./return-to": "./src/return-to.ts",
+    "./mode-api": "./src/mode-api.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && bun test test/"
+  },
+  "dependencies": {
+    "@metro-labs/core": "workspace:*",
+    "@noble/curves": "^1.9.7",
+    "viem": "2.52.2"
+  },
+  "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/http/src/api-error.ts

@@ -0,0 +1,8 @@
+export class ApiError extends Error {
+  constructor(
+    message: string,
+    readonly status: number,
+  ) {
+    super(message);
+  }
+}

package/runtime/node_modules/@metro-labs/http/src/api-http.ts

@@ -0,0 +1,95 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { ApiError } from './api-error.js';
+import { errMsg, log } from '@metro-labs/core/log';
+import { signedIdentity } from './signed-identity.js';
+import { identitySubject } from './identity-registry.js';
+
+const BODY_MAX = 4 * 1024;
+
+export interface ApiSession {
+  subject: string;
+}
+
+export function cors(req: IncomingMessage): Record<string, string> {
+  return {
+    'access-control-allow-origin': req.headers.origin ?? '*',
+    'access-control-allow-methods': 'GET, POST, PUT, DELETE, OPTIONS',
+    'access-control-allow-headers': 'Authorization, Content-Type',
+    'access-control-allow-private-network': 'true',
+    'access-control-max-age': '86400',
+    vary: 'Origin',
+  };
+}
+
+export function sendJson(
+  req: IncomingMessage,
+  res: ServerResponse,
+  status: number,
+  body: unknown,
+): void {
+  res.writeHead(status, {
+    'content-type': 'application/json',
+    'cache-control': 'no-store',
+    ...cors(req),
+  });
+  res.end(JSON.stringify(body));
+}
+
+export async function apiSession(req: IncomingMessage): Promise<ApiSession | null> {
+  const address = await signedIdentity(req);
+  const subject = address === null ? undefined : identitySubject(address);
+  return subject === undefined ? null : { subject };
+}
+
+export interface AgentIdentity {
+  subject: string;
+  agentId: string;
+}
+
+export function projectParam(req: IncomingMessage): string | null {
+  const raw = new URL(req.url ?? '/', 'http://localhost').searchParams.get(
+    'project',
+  );
+  return raw === null || raw === '' ? null : raw;
+}
+
+export async function readJsonBody(req: IncomingMessage, max = BODY_MAX): Promise<unknown> {
+  const chunks: Buffer[] = [];
+  let total = 0;
+  let over = false;
+  for await (const c of req) {
+    const buf = c as Buffer;
+    total += buf.length;
+    if (total > max) over = true;
+    if (!over) chunks.push(buf);
+    else if (total > 2 * max) break;
+  }
+  if (over) throw new ApiError('request body too large', 413);
+  const raw = Buffer.concat(chunks).toString('utf8').trim();
+  if (raw === '') return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new ApiError('body must be JSON', 400);
+  }
+}
+
+export function apiFailure(
+  req: IncomingMessage,
+  res: ServerResponse,
+  err: unknown,
+  label = 'agent-api',
+): void {
+  if (err instanceof ApiError) {
+    sendJson(req, res, err.status, { error: err.message });
+    return;
+  }
+  log.warn({ err: errMsg(err) }, `${label}: request failed`);
+  if (!res.headersSent) sendJson(req, res, 500, { error: `${label} failed` });
+}
+
+export function bodyField(body: unknown, key: string): unknown {
+  return typeof body === 'object' && body !== null && !Array.isArray(body)
+    ? (body as Record<string, unknown>)[key]
+    : undefined;
+}

package/runtime/node_modules/@metro-labs/http/src/cors.ts

@@ -0,0 +1,29 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+
+export function applyMcpCors(
+  req: IncomingMessage,
+  res: ServerResponse,
+): void {
+  const origin = req.headers.origin;
+  res.setHeader(
+    'Access-Control-Allow-Origin',
+    origin !== undefined && origin !== '' ? origin : '*',
+  );
+  res.setHeader('Vary', 'Origin');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  res.setHeader(
+    'Access-Control-Allow-Headers',
+    'Authorization, Content-Type, Accept, Mcp-Session-Id, Mcp-Protocol-Version, Last-Event-ID',
+  );
+  res.setHeader('Access-Control-Expose-Headers', 'Mcp-Session-Id');
+  res.setHeader('Access-Control-Max-Age', '86400');
+}
+
+export function handleMcpPreflight(
+  req: IncomingMessage,
+  res: ServerResponse,
+): boolean {
+  if (req.method !== 'OPTIONS') return false;
+  res.writeHead(204).end();
+  return true;
+}

package/runtime/node_modules/@metro-labs/http/src/identity-key.ts

@@ -0,0 +1,33 @@
+import { hkdfSync } from 'node:crypto';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { mapHashToField } from '@noble/curves/abstract/modular';
+import { privateKeyToAccount } from 'viem/accounts';
+
+export const ENCRYPTION_KEY_TYPED_DATA = {
+  domain: { name: 'metro', version: '1' },
+  types: {
+    EncryptionKey: [
+      { name: 'purpose', type: 'string' },
+      { name: 'keyVersion', type: 'uint256' },
+    ],
+  },
+  primaryType: 'EncryptionKey',
+  message: { purpose: 'encryption-key', keyVersion: 1n },
+} as const;
+
+const KEY_SALT = 'metro';
+const IDENTITY_INFO = 'vault-secp256k1';
+const KEY_HASH_BYTES = 48;
+
+const toHex = (bytes: Uint8Array): `0x${string}` =>
+  `0x${[...bytes].map((b) => b.toString(16).padStart(2, '0')).join('')}`;
+
+export function deriveIdentityKey(signature: `0x${string}`): `0x${string}` {
+  const ikm = Buffer.from(signature.slice(2), 'hex');
+  const hash = new Uint8Array(hkdfSync('sha256', ikm, KEY_SALT, IDENTITY_INFO, KEY_HASH_BYTES));
+  return toHex(mapHashToField(hash, secp256k1.CURVE.n));
+}
+
+export function deriveIdentityAddress(signature: `0x${string}`): string {
+  return privateKeyToAccount(deriveIdentityKey(signature)).address.toLowerCase();
+}