@stage-labs/metro 0.1.0-beta.26 → 0.1.0-beta.261

package/runtime/sdk-runner/src/speech.ts

@@ -0,0 +1,79 @@
+import type { SDKMessage } from '@anthropic-ai/claude-agent-sdk';
+import { isRecord } from '@metro-labs/core/is-record';
+import type { InputKind } from './inbox.js';
+import { startedCommand, uuidsOf } from './session-watch.js';
+
+export interface SpeechSink {
+  say(text: string): void;
+  done(): void;
+  stalled?(): void;
+}
+
+
+function textDelta(event: unknown): string | null {
+  if (!isRecord(event) || event.type !== 'content_block_delta' || !isRecord(event.delta)) return null;
+  return event.delta.type === 'text_delta' && typeof event.delta.text === 'string' ? event.delta.text : null;
+}
+
+export class SpeechRouter {
+  private answering: string[] = [];
+  private speaking = false;
+  private live = false;
+
+  constructor(
+    private readonly kindOf: (uuid: string) => InputKind | undefined,
+    private readonly sink: SpeechSink,
+  ) {}
+
+  get callLive(): boolean {
+    return this.live;
+  }
+
+  get talking(): boolean {
+    return this.speaking;
+  }
+
+  setCallLive(on: boolean): void {
+    this.live = on;
+    if (!on) this.endTurn();
+  }
+
+  observe(message: SDKMessage): void {
+    const m: Record<string, unknown> = { ...message };
+    if (m.type === 'result') {
+      this.endTurn();
+      this.answering = [];
+      return;
+    }
+    if (m.type === 'system' && m.subtype === 'init') this.endTurn();
+    const started = startedCommand(m);
+    if (started !== null) this.answer([started]);
+    if (m.parent_tool_use_id === null) this.mainThread(m);
+  }
+
+  private answer(uuids: readonly string[]): void {
+    this.answering = [...new Set([...this.answering, ...uuids])];
+  }
+
+  private mainThread(m: Record<string, unknown>): void {
+    if (m.type !== 'stream_event' && m.type !== 'assistant') return;
+    const uuids = uuidsOf(m);
+    if (uuids !== null) this.answer(uuids);
+    const text = m.type === 'stream_event' ? textDelta(m.event) : null;
+    if (text === null || text === '' || !this.speaks()) return;
+    this.speaking = true;
+    this.sink.say(text);
+  }
+
+  private speaks(): boolean {
+    if (!this.live) return false;
+    if (this.answering.length === 0) return true;
+    return this.answering.some((uuid) => this.kindOf(uuid) === 'call');
+  }
+
+  private endTurn(): void {
+    if (!this.speaking) return;
+    this.speaking = false;
+    this.sink.done();
+  }
+}

package/runtime/sdk-runner/src/tool-proxy.ts

@@ -0,0 +1,40 @@
+import type { McpSdkServerConfigWithInstance } from '@anthropic-ai/claude-agent-sdk';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, type CallToolRequest, type CallToolResult, type ListToolsResult } from '@modelcontextprotocol/sdk/types.js';
+
+export const METRO_SERVER = 'metro';
+
+export interface ToolSource {
+  readonly instructions: string | undefined;
+  listTools(): Promise<ListToolsResult>;
+  callTool(params: CallToolRequest['params'], signal: AbortSignal): Promise<CallToolResult>;
+}
+
+export interface MetroTools {
+  config: McpSdkServerConfigWithInstance;
+  readOnly(tool: string): boolean;
+  changed(): void;
+}
+
+export function metroTools(source: ToolSource): MetroTools {
+  const instructions = source.instructions;
+  const reads = new Set<string>();
+  const server = new McpServer(
+    { name: METRO_SERVER, version: '0.1.0' },
+    { capabilities: { tools: { listChanged: true } }, ...(instructions === undefined ? {} : { instructions }) },
+  );
+  server.server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const listed = await source.listTools();
+    reads.clear();
+    for (const tool of listed.tools) if (tool.annotations?.readOnlyHint === true) reads.add(tool.name);
+    return listed;
+  });
+  server.server.setRequestHandler(CallToolRequestSchema, (request, extra) => source.callTool(request.params, extra.signal));
+  return {
+    config: { type: 'sdk', name: METRO_SERVER, instance: server },
+    readOnly: (tool) => reads.has(tool),
+    changed: () => {
+      server.sendToolListChanged();
+    },
+  };
+}

package/runtime/server.ts

@@ -0,0 +1 @@
+import './node_modules/@metro-labs/daemon/src/server.ts';

package/runtime/stations.json

@@ -0,0 +1,40 @@
+{
+  "core": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "opusscript": "^0.1.1",
+    "pino": "^9.5.0",
+    "pino-pretty": "^13.1.3",
+    "werift": "^0.24.4",
+    "ws": "^8.18.0",
+    "zod": "^3.23.8"
+  },
+  "stations": {
+    "xmtp": {
+      "@xmtp/content-type-primitives": "^3.0.1",
+      "@xmtp/content-type-reaction": "^2.0.2",
+      "@xmtp/content-type-remote-attachment": "^2.0.4",
+      "@xmtp/content-type-reply": "^2.0.3",
+      "@xmtp/node-bindings": "1.9.1",
+      "@xmtp/node-sdk": "^6.0.0",
+      "@zerodev/ecdsa-validator": "5.4.9",
+      "@zerodev/sdk": "5.5.10",
+      "viem": "^2.52.2"
+    },
+    "telegram-bot": {},
+    "telegram": {
+      "@mtcute/bun": "0.30.1"
+    },
+    "discord-bot": {
+      "discord.js": "^14.26.4"
+    },
+    "whatsapp": {
+      "baileys": "7.0.0-rc14"
+    },
+    "threema": {
+      "tweetnacl": "^1.0.3"
+    },
+    "outlook": {},
+    "gmail": {},
+    "webhook": {}
+  }
+}

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 = '\u0003';
-        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();
-  }
-}