@stage-labs/metro 0.1.0-beta.27 → 0.1.0-beta.271

package/dist/plugin.js

@@ -1,82 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { readToken } from './store.js';
-const MARKETPLACE_REPO = 'bonustrack/metro';
-const PLUGIN_SPEC = 'metro@metro';
-export function installPathFrom(raw) {
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-    if (typeof parsed !== 'object' || parsed === null)
-        return null;
-    const plugins = parsed.plugins;
-    if (typeof plugins !== 'object' || plugins === null)
-        return null;
-    const entries = plugins[PLUGIN_SPEC];
-    if (!Array.isArray(entries))
-        return null;
-    const first = entries[0];
-    return typeof first?.installPath === 'string' ? first.installPath : null;
-}
-export function pluginInstallPath() {
-    const registry = join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
-    let raw;
-    try {
-        raw = readFileSync(registry, 'utf8');
-    }
-    catch {
-        return null;
-    }
-    const path = installPathFrom(raw);
-    if (path === null)
-        return null;
-    return existsSync(join(path, 'bin', 'metro-plugin.mjs')) ? path : null;
-}
-function runClaude(args) {
-    const res = spawnSync('claude', args, { encoding: 'utf8' });
-    if (res.error !== undefined)
-        throw new Error('the `claude` command is not on PATH — install Claude Code first');
-    const output = `${res.stdout ?? ''}${res.stderr ?? ''}`;
-    return { ok: res.status === 0, output };
-}
-const tolerable = (output) => /already|exists|latest version/i.test(output);
-export function syncPluginServers() {
-    const path = pluginInstallPath();
-    if (path === null || readToken() === null)
-        return false;
-    const script = join(path, 'bin', 'metro-plugin.mjs');
-    const refreshed = spawnSync(process.execPath, [script, 'refresh'], {
-        stdio: ['ignore', 'inherit', 'inherit'],
-    });
-    if (refreshed.status !== 0)
-        return false;
-    runClaude(['plugin', 'update', PLUGIN_SPEC]);
-    return true;
-}
-export async function installPlugin() {
-    const added = runClaude(['plugin', 'marketplace', 'add', MARKETPLACE_REPO]);
-    if (!added.ok && !tolerable(added.output)) {
-        process.stderr.write(added.output);
-        return 1;
-    }
-    const installed = runClaude(['plugin', 'install', PLUGIN_SPEC]);
-    if (!installed.ok && !tolerable(installed.output)) {
-        process.stderr.write(installed.output);
-        return 1;
-    }
-    process.stderr.write('Claude Code plugin installed.\n');
-    if (syncPluginServers()) {
-        process.stderr.write('Connector servers loaded — new Claude sessions have them; ' +
-            'run /reload-plugins in any session already open.\n');
-        return 0;
-    }
-    process.stderr.write('Now sign in: metro login (get a code at https://metro.box/#/authorize), ' +
-        'or run /metro:login <code> inside Claude Code.\n');
-    return Promise.resolve(0);
-}

package/dist/prompt.js

@@ -1,61 +0,0 @@
-import { createInterface } from 'node:readline';
-const CTRL_C = '\u0003';
-const BACKSPACE = '\u007f';
-export function askLine(question) {
-    const rl = createInterface({ input: process.stdin, output: process.stderr });
-    return new Promise((resolve) => {
-        rl.question(question, (answer) => {
-            rl.close();
-            resolve(answer.trim());
-        });
-    });
-}
-export function feedSecret(value, chunk) {
-    let out = value;
-    for (const ch of chunk) {
-        if (ch === CTRL_C)
-            return { kind: 'cancelled' };
-        if (ch === '\r' || ch === '\n')
-            return { kind: 'done', value: out };
-        if (ch === BACKSPACE || ch === '\b') {
-            out = out.slice(0, -1);
-            continue;
-        }
-        if (ch >= ' ')
-            out += ch;
-    }
-    return { kind: 'more', value: out };
-}
-export function askSecret(question) {
-    const stdin = process.stdin;
-    if (!stdin.isTTY)
-        return askLine(question);
-    process.stderr.write(question);
-    stdin.setRawMode(true);
-    stdin.resume();
-    stdin.setEncoding('utf8');
-    return new Promise((resolve, reject) => {
-        let value = '';
-        const finish = () => {
-            stdin.setRawMode(false);
-            stdin.pause();
-            stdin.off('data', onData);
-            process.stderr.write('\n');
-        };
-        const onData = (chunk) => {
-            const step = feedSecret(value, chunk);
-            if (step.kind === 'cancelled') {
-                finish();
-                reject(new Error('cancelled'));
-                return;
-            }
-            if (step.kind === 'done') {
-                finish();
-                resolve(step.value.trim());
-                return;
-            }
-            value = step.value;
-        };
-        stdin.on('data', onData);
-    });
-}

package/dist/store.js

@@ -1,70 +0,0 @@
-import { chmodSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-const DEFAULT_BASE = 'https://mcp.metro.box';
-const DEFAULT_WEB = 'https://metro.box';
-function fromEnv(name, fallback) {
-    const raw = process.env[name]?.trim();
-    return raw === undefined || raw === '' ? fallback : raw.replace(/\/+$/, '');
-}
-export function metroUrl() {
-    return fromEnv('METRO_URL', DEFAULT_BASE);
-}
-export function metroWebUrl() {
-    return fromEnv('METRO_UI_URL', DEFAULT_WEB);
-}
-function configDir() {
-    const xdg = process.env.XDG_CONFIG_HOME?.trim();
-    const base = xdg === undefined || xdg === '' ? join(homedir(), '.config') : xdg;
-    return join(base, 'metro');
-}
-export function credentialsPath() {
-    return join(configDir(), 'credentials.json');
-}
-function readStored() {
-    let raw;
-    try {
-        raw = readFileSync(credentialsPath(), 'utf8');
-    }
-    catch {
-        return null;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-    if (typeof parsed !== 'object' || parsed === null)
-        return null;
-    const { token, url } = parsed;
-    if (typeof token !== 'string' || token === '')
-        return null;
-    return { token, url: typeof url === 'string' ? url : DEFAULT_BASE };
-}
-export function readToken() {
-    const fromEnv = process.env.METRO_TOKEN?.trim();
-    if (fromEnv !== undefined && fromEnv !== '')
-        return fromEnv;
-    const stored = readStored();
-    if (stored === null)
-        return null;
-    return stored.url === metroUrl() ? stored.token : null;
-}
-export function writeToken(token) {
-    const path = credentialsPath();
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    writeFileSync(path, `${JSON.stringify({ token, url: metroUrl() })}\n`, {
-        mode: 0o600,
-    });
-    chmodSync(path, 0o600);
-}
-export function clearToken() {
-    try {
-        rmSync(credentialsPath());
-    }
-    catch {
-        return;
-    }
-}

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

@@ -1,195 +0,0 @@
-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-bot/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-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);
-}