@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.310

package/dist/bedrock.js

@@ -1,106 +0,0 @@
-import { spawn } from 'node:child_process';
-import { randomBytes } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { claudeArgs } from './claude.js';
-import { bedrockConfigFromEnv, startBedrockProxy } from './bedrock-proxy.js';
-export const PROVIDER_FLAGS = [
-    'CLAUDE_CODE_USE_BEDROCK',
-    'CLAUDE_CODE_USE_MANTLE',
-    'CLAUDE_CODE_USE_VERTEX',
-    'CLAUDE_CODE_USE_FOUNDRY',
-    'CLAUDE_CODE_USE_ANTHROPIC_AWS',
-    'CLAUDE_CODE_USE_ANTHROPIC_GOOGLE_CLOUD',
-    'CLAUDE_CODE_USE_GATEWAY',
-];
-const CONFLICTING = [
-    ...PROVIDER_FLAGS,
-    'ANTHROPIC_BASE_URL',
-    'ANTHROPIC_API_KEY',
-    'ANTHROPIC_AUTH_TOKEN',
-];
-const SCRUBBED = [...PROVIDER_FLAGS, 'ANTHROPIC_API_KEY', 'AWS_BEARER_TOKEN_BEDROCK'];
-export function settingsFiles(cwd = process.cwd(), env = process.env) {
-    const explicit = env.CLAUDE_CONFIG_DIR?.trim() ?? '';
-    const configDir = explicit === '' ? join(homedir(), '.claude') : explicit;
-    return [
-        ...new Set([
-            join(configDir, 'settings.json'),
-            join(cwd, '.claude', 'settings.json'),
-            join(cwd, '.claude', 'settings.local.json'),
-        ]),
-    ];
-}
-function envBlock(file) {
-    if (!existsSync(file))
-        return {};
-    try {
-        const parsed = JSON.parse(readFileSync(file, 'utf8'));
-        const block = parsed.env;
-        return typeof block === 'object' && block !== null
-            ? block
-            : {};
-    }
-    catch {
-        return {};
-    }
-}
-export function settingsConflicts(files) {
-    const out = [];
-    for (const file of files) {
-        const block = envBlock(file);
-        for (const key of CONFLICTING) {
-            const value = block[key];
-            if (typeof value === 'string' && value.trim() !== '')
-                out.push(`${file}: ${key}`);
-        }
-    }
-    return out;
-}
-export function firstPartyModelId(bedrockId) {
-    return bedrockId.replace(/^(?:[a-z-]+\.)?anthropic\./, '').replace(/-v\d+:\d+$/, '');
-}
-export function claudeEnv(base, port, token, pinned = null) {
-    const kept = Object.entries(base).filter(([key]) => !SCRUBBED.includes(key));
-    const model = (base.ANTHROPIC_MODEL ?? '').trim();
-    return {
-        ...Object.fromEntries(kept),
-        ...(pinned !== null && model === '' && { ANTHROPIC_MODEL: firstPartyModelId(pinned) }),
-        ANTHROPIC_BASE_URL: `http://127.0.0.1:${String(port)}`,
-        ANTHROPIC_AUTH_TOKEN: token,
-    };
-}
-function runClaude(args, env) {
-    return new Promise((resolve, reject) => {
-        const leaveToChild = () => undefined;
-        process.on('SIGINT', leaveToChild);
-        process.on('SIGTERM', leaveToChild);
-        const child = spawn('claude', args, { stdio: 'inherit', env });
-        child.on('error', (err) => {
-            reject(new Error(err.code === 'ENOENT'
-                ? 'the `claude` command is not on PATH — install Claude Code first'
-                : err.message));
-        });
-        child.on('exit', (code) => {
-            resolve(code ?? 1);
-        });
-    });
-}
-export async function bedrock(argv) {
-    const cfg = bedrockConfigFromEnv();
-    const conflicts = settingsConflicts(settingsFiles());
-    if (conflicts.length > 0)
-        throw new Error('metro bedrock: these settings would put Claude Code back on a third-party provider, or override the proxy. Remove them, or point CLAUDE_CONFIG_DIR at a separate profile:\n  ' +
-            conflicts.join('\n  '));
-    const token = `mb_${randomBytes(18).toString('base64url')}`;
-    const proxy = await startBedrockProxy(cfg, { token });
-    const pinned = cfg.model === null ? '' : ` (${cfg.model})`;
-    process.stderr.write(`metro bedrock: Claude Code → http://127.0.0.1:${String(proxy.port)} → Bedrock ${cfg.region}${pinned}\n`);
-    try {
-        return await runClaude(claudeArgs(argv), claudeEnv(process.env, proxy.port, token, cfg.model));
-    }
-    finally {
-        await proxy.close();
-    }
-}

package/dist/claude.js

@@ -1,15 +0,0 @@
-import { spawnSync } from 'node:child_process';
-const CHANNEL_FLAGS = ['--dangerously-load-development-channels', 'server:metro'];
-export const claudeArgs = (extra) => [
-    ...CHANNEL_FLAGS,
-    ...extra,
-];
-export function launchClaude(extra) {
-    const leaveToChild = () => undefined;
-    process.on('SIGINT', leaveToChild);
-    process.on('SIGTERM', leaveToChild);
-    const res = spawnSync('claude', claudeArgs(extra), { stdio: 'inherit' });
-    if (res.error !== undefined)
-        throw new Error('the `claude` command is not on PATH — install Claude Code first');
-    return Promise.resolve(res.status ?? 1);
-}

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,93 +0,0 @@
-import { chmodSync, mkdirSync, readdirSync, 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 readStoredAt(path) {
-    let raw;
-    try {
-        raw = readFileSync(path, '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 };
-}
-const readStored = () => readStoredAt(credentialsPath());
-const RUN_TOKEN_FILE = /^runtime-[A-Za-z0-9_-]{11}\.json$/;
-export function readRunTokens() {
-    const fromEnv = process.env.METRO_RUN_TOKEN?.trim();
-    if (fromEnv !== undefined && fromEnv !== '')
-        return [fromEnv];
-    let names;
-    try {
-        names = readdirSync(configDir());
-    }
-    catch {
-        return [];
-    }
-    const out = [];
-    for (const name of names) {
-        if (!RUN_TOKEN_FILE.test(name))
-            continue;
-        const stored = readStoredAt(join(configDir(), name));
-        if (stored !== null && stored.url === metroUrl())
-            out.push(stored.token);
-    }
-    return out;
-}
-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();
-  }
-}