@stage-labs/metro 0.1.0-beta.4 → 0.1.0-beta.41

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

@@ -0,0 +1,90 @@
+import { errMsg } from '@metro-labs/mcp/log';
+import { mintId, SELF_URI } from './wire.js';
+
+type EmitInbound = (accountId: string, e: Record<string, unknown>) => void;
+
+const WHISPER_BIN = process.env.METRO_WHISPER_BIN ?? 'whisper-cli';
+const WHISPER_MODEL =
+  process.env.METRO_WHISPER_MODEL ??
+  `${process.env.HOME}/.cache/whisper-cpp/ggml-base.bin`;
+const FFMPEG_BIN = process.env.METRO_FFMPEG_BIN ?? 'ffmpeg';
+
+export async function transcribeAndEmit(
+  audio: Uint8Array,
+  line: string,
+  accountId: string,
+  sourceMsgId: string,
+  emitInbound: EmitInbound,
+): Promise<void> {
+  const {
+    existsSync: ex,
+    readFileSync: rf,
+    writeFileSync: wf,
+    unlinkSync,
+    mkdtempSync,
+  } = await import('node:fs');
+  const { tmpdir } = await import('node:os');
+  const path = await import('node:path');
+  const j = (...parts: string[]): string => path.join(...parts);
+  const { spawn } = await import('node:child_process');
+  if (!ex(WHISPER_MODEL)) return;
+  const dir = mkdtempSync(j(tmpdir(), 'xmtp-tx-'));
+  const inFile = j(dir, 'in.m4a');
+  const wav = j(dir, 'in.wav');
+  const out = j(dir, 'in');
+  const run = (bin: string, args: string[]): Promise<void> =>
+    new Promise((res, rej) => {
+      const p = spawn(bin, args, { stdio: 'ignore' });
+      p.on('error', rej);
+      p.on('exit', (c) => {
+        if (c === 0) res();
+        else rej(new Error(`${bin} ${String(c)}`));
+      });
+    });
+  try {
+    wf(inFile, audio);
+    await run(FFMPEG_BIN, [
+      '-y',
+      '-i',
+      inFile,
+      '-ar',
+      '16000',
+      '-ac',
+      '1',
+      wav,
+    ]);
+    await run(WHISPER_BIN, [
+      '-m',
+      WHISPER_MODEL,
+      '-f',
+      wav,
+      '--output-txt',
+      '-of',
+      out,
+    ]);
+    const text = rf(`${out}.txt`, 'utf8').trim();
+    if (!text) return;
+    emitInbound(accountId, {
+      id: mintId(),
+      ts: new Date().toISOString(),
+      station: 'xmtp',
+      line,
+      from: SELF_URI,
+      text: `🎙️ ${text}`,
+      payload: {
+        contentType: 'transcript',
+        transcribeFor: sourceMsgId,
+        transcript: text,
+      },
+    });
+  } catch (err) {
+    process.stderr.write(`xmtp transcribe failed: ${errMsg(err)}\n`);
+  } finally {
+    for (const f of [inFile, wav, `${out}.txt`]) {
+      try {
+        unlinkSync(f);
+      } catch {
+      }
+    }
+  }
+}

package/runtime/node_modules/@metro-labs/xmtp/src/verify.ts

@@ -0,0 +1,84 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { Client, type ClientOptions, type Signer } from '@xmtp/node-sdk';
+import { expandHome, signerFor, XMTP_ENV } from './identity.js';
+
+export class XmtpVerifyError extends Error {}
+
+export interface XmtpVerified {
+  inboxId: string;
+  address: string;
+  installationId: string;
+  dbPath: string;
+}
+
+interface RegisteredClient {
+  inboxId: string;
+  installationId: string;
+  isRegistered: boolean;
+}
+
+export type CreateXmtpClient = (
+  signer: Signer,
+  dbPath: string,
+) => Promise<RegisteredClient>;
+
+const openInbox: CreateXmtpClient = (signer, dbPath) => {
+  const options: ClientOptions = { env: XMTP_ENV, dbPath };
+  return Client.create(signer, options);
+};
+
+const reason = (err: unknown): string =>
+  err instanceof Error && err.message !== '' ? err.message : 'no reason given';
+
+export async function verifyXmtpKey(
+  privateKey: string,
+  dbPath: string,
+  create: CreateXmtpClient = openInbox,
+): Promise<XmtpVerified> {
+  let signer: Signer;
+  let address: string;
+  try {
+    ({ signer, address } = signerFor(privateKey));
+  } catch {
+    throw new XmtpVerifyError('that is not a usable XMTP private key');
+  }
+  const resolved = expandHome(dbPath);
+  mkdirSync(dirname(resolved), { recursive: true });
+  const client = await create(signer, resolved).catch((err: unknown) => {
+    throw new XmtpVerifyError(
+      `XMTP would not open an inbox for that key: ${reason(err)}`,
+    );
+  });
+  if (!client.isRegistered)
+    throw new XmtpVerifyError('XMTP did not register an inbox for that key');
+  if (client.inboxId === '')
+    throw new XmtpVerifyError('XMTP returned no inbox id for that key');
+  return {
+    inboxId: client.inboxId,
+    address,
+    installationId: client.installationId,
+    dbPath: resolved,
+  };
+}
+
+async function runCli(): Promise<void> {
+  let out: Record<string, unknown>;
+  try {
+    const input = JSON.parse(readFileSync(0, 'utf8')) as {
+      privateKey?: unknown;
+      dbPath?: unknown;
+    };
+    if (typeof input.privateKey !== 'string' || typeof input.dbPath !== 'string')
+      throw new XmtpVerifyError('xmtp verify needs a privateKey and a dbPath');
+    out = { ok: true, ...(await verifyXmtpKey(input.privateKey, input.dbPath)) };
+  } catch (err) {
+    out = { ok: false, error: reason(err) };
+  }
+  writeFileSync(1, `${JSON.stringify(out)}\n`);
+}
+
+if (import.meta.main) {
+  await runCli();
+  process.exit(0);
+}

package/runtime/node_modules/@metro-labs/xmtp/src/wire.ts

@@ -0,0 +1,39 @@
+export { emit, respond, mintId } from '@metro-labs/mcp/stations/station-runtime';
+
+export const SELF_URI = process.env.METRO_SELF_URI ?? '';
+
+const UID_MAP_MAX = 5000;
+const uidToXmtp = new Map<string, string>();
+
+const INBOX_ETH_CACHE_MAX = 5000;
+export const inboxEthCache = new Map<string, string>();
+
+export function cacheInboxEth(inboxId: string, eth: string): void {
+  inboxEthCache.set(inboxId, eth);
+  if (inboxEthCache.size > INBOX_ETH_CACHE_MAX) {
+    const oldest = inboxEthCache.keys().next().value;
+    if (oldest !== undefined) inboxEthCache.delete(oldest);
+  }
+}
+
+export function rememberUid(
+  uid: string | undefined,
+  xmtpId: string | undefined,
+): void {
+  if (!uid || !xmtpId || !uid.startsWith('msg_')) return;
+  uidToXmtp.set(uid, xmtpId);
+  if (uidToXmtp.size > UID_MAP_MAX) {
+    const oldest = uidToXmtp.keys().next().value;
+    if (oldest !== undefined) uidToXmtp.delete(oldest);
+  }
+}
+
+export function resolveMsgId(rawId: string): string {
+  if (!rawId.startsWith('msg_')) return rawId;
+  const mapped = uidToXmtp.get(rawId);
+  if (mapped) return mapped;
+  throw new Error(
+    `could not resolve universal id ${rawId} to an xmtp message id ` +
+      '(not seen by this train; pass the raw xmtp message_id)',
+  );
+}

package/runtime/runtime.json

@@ -0,0 +1,3 @@
+{
+  "version": "0.1.0-beta.41"
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Stage Labs
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,117 +0,0 @@
-# Metro
-
-Run a long-lived daemon that bridges Discord and Telegram to your Codex + Claude Code agents. Each chat thread/topic gets its own agent session with streaming responses and inline, persistent tool-call traces. Both agents run side-by-side — pick per-message with a `with claude` / `with codex` suffix.
-
-## Prereqs
-
-- **Node ≥ 22** (or Bun ≥ 1.3).
-- **One or both agent CLIs** installed and authenticated:
-  - **Claude Code** — run `claude` once interactively to log in. Metro shells out per turn and inherits your auth, plugins, settings.
-  - **Codex** — run `codex` once interactively to log in. Metro spawns `codex app-server` and inherits your auth, MCPs, sandboxing.
-- **Discord bot** (optional) with **Message Content Intent** enabled (Developer Portal → Bot → Privileged Gateway Intents).
-- **Telegram bot** (optional). In supergroup forums, the bot also needs the **Manage Topics** admin permission so it can auto-create topics on @-mention.
-
-## Quickstart
-
-```bash
-npm install -g @stage-labs/metro@beta    # or: bun add -g @stage-labs/metro@beta
-
-metro setup discord <token>              # https://discord.com/developers/applications
-metro setup telegram <token>             # https://t.me/BotFather
-
-metro doctor                             # verify
-metro                                    # run the orchestrator
-```
-
-Metro starts both agents at boot and listens on whichever platforms are configured. Each scope defaults to **Claude** for the first turn; once you've used an agent there, follow-up messages stick with it. Switch per-message by suffixing `with claude` or `with codex` (any casing):
-
-```
-@Metro draft a release note
-   → uses Claude (default for a new scope)
-
-How would Codex have done this? with codex
-   → routes this turn to Codex; stays Codex on subsequent turns
-```
-
-### Discord
-
-@-mention the bot in any channel:
-1. Metro creates a thread anchored on your message (named after the message).
-2. Spins up an agent session for that thread.
-3. Streams the agent's reply with each tool call as its own block: plain header `🛠 **Read**` followed by two fenced code blocks — input (`src/foo.ts`) above, output (file contents) below. Outputs are capped at 50 lines / 1500 chars per tool with a `_(N more lines)_` note if truncated. `Thinking…` shows as a transient status that vanishes once real content arrives.
-
-Follow-ups in the thread route automatically — no @-mention needed.
-
-### Telegram
-
-- **DM the bot** — every message is implicitly addressed to it; one scope per chat.
-- **@-mention the bot in a forum supergroup's General topic** — metro auto-creates a new topic for the conversation (Discord-style "thread from message") and posts a deep link back in General so the new topic is one tap away. Subsequent messages in that topic route automatically.
-- **Inside an existing custom topic** — routes to that topic's scope on every message.
-
-Regular (non-forum) groups are not routed — they have no thread boundary.
-
-## How it works
-
-```
-Discord gateway ──┐                       ┌─▶ codex app-server   (long-lived subprocess, UDS JSON-RPC)
-                  ├─▶ metro orchestrator ─┤
-Telegram poller ──┘                       └─▶ claude -p ...      (per-turn subprocess, stream-json)
-                            │
-                            └──── scope map (scopes.json)
-```
-
-- **One metro = one daemon.** Lockfile at `$METRO_STATE_DIR/.tail-lock` keeps things singleton.
-- **Both agents side-by-side.** A scope can have up to one session per agent — independent histories. Routing is per-message: explicit `with claude` / `with codex` suffix, otherwise the scope's last-used agent, otherwise Claude.
-- **Streaming.** Replies edit one message every ~1500 ms while deltas stream in (leading-edge first flush for fast initial feedback). Long replies split past ~1900 chars onto a follow-up message.
-- **Tool-call visibility.** Each tool call is rendered as a plain `🛠 **<tool>**` header plus two fenced code blocks — input then output — paired by tool id so parallel calls don't collide. Both blocks are fully visible (no collapse). Outputs are capped at 50 lines / 1500 chars per tool.
-- **Telegram formatting.** Agent markdown (`**bold**`, `*italic*`, `` `code` ``, fenced blocks, `[link](url)`, blockquotes) is converted to Telegram's HTML parse mode on the way out, so it renders as formatted text instead of literal characters.
-- **No link previews.** Outgoing messages set `link_preview_options.is_disabled` on Telegram and the `SUPPRESS_EMBEDS` flag on Discord, so URLs in agent replies don't unfurl into giant auto-embeds.
-- **Queueing.** Messages that arrive while a turn is running are buffered per-scope and answered together in the next reply.
-- **Catchup-on-restart.** Discord uses a per-scope `lastSeenMessageId` watermark and REST-fetches anything newer when metro comes back up. Telegram leans on its own update-id queue (persisted offset in `telegram-offset.json`).
-
-## Config
-
-| Variable | Default | Description |
-|---|---|---|
-| `TELEGRAM_BOT_TOKEN`, `DISCORD_BOT_TOKEN` | — | Bot tokens. `metro setup` writes them here. |
-| `METRO_CONFIG_DIR` | `~/.config/metro` | Where the global `.env` lives. |
-| `METRO_STATE_DIR` | `~/.cache/metro` | Lockfile, scope cache, codex socket, telegram offset, claude session set. |
-| `METRO_LOG_LEVEL` | `info` | `trace` / `debug` / `info` / `warn` / `error` / `fatal`. |
-
-Token precedence: process env → `./.env` → `$METRO_CONFIG_DIR/.env`. Logs to stderr.
-
-## Develop locally
-
-```bash
-git clone https://github.com/bonustrack/metro && cd metro
-bun install && bun run build
-bun link                                 # makes `metro` resolve to this checkout
-METRO_LOG_LEVEL=debug metro
-```
-
-## Reference
-
-- `metro --help` — command surface
-- `metro doctor` — health check (tokens + gateway/poller reachability + orchestrator status)
-- State files (`$METRO_STATE_DIR`, defaults to `~/.cache/metro/`):
-  - `scopes.json` — Discord-thread / Telegram-topic ↔ agent-session map
-  - `.tail-lock` — orchestrator pid
-  - `codex-app-server.sock` — codex's UDS
-  - `telegram-offset.json` — last processed update id (used for catchup on restart)
-  - `claude-sessions.json` — set of started Claude session uuids (so restarts use `--resume` instead of `--session-id`)
-
-## Uninstall
-
-```bash
-metro setup clear
-rm -rf ~/.cache/metro/
-npm uninstall -g @stage-labs/metro
-```
-
-## Caveats
-
-- **No allowlist.** Anyone who can DM/@-mention your bot can spawn an agent session. Run against bots you own.
-- **Per-agent histories are separate.** Switching with `with codex` mid-scope spins up a fresh Codex session — it has no idea what you discussed with Claude in the same scope. Each agent only sees what was sent to it.
-- **One agent missing is OK.** If only `claude` or only `codex` is installed/authenticated, metro still starts; messages asking for the missing one surface an error in chat.
-- **Telegram non-forum groups are skipped.** Without a per-topic thread boundary the routing model breaks down. DMs and forum topics (incl. auto-created ones from General) work normally.
-- **Telegram bot privacy.** Default Telegram bot privacy is *enabled*, which can block group messages even with @-mentions. Disable in [@BotFather](https://t.me/BotFather) → Bot Settings → Group Privacy → Turn off, then kick + re-invite the bot.

package/dist/agents/claude.js

@@ -1,207 +0,0 @@
-/** Claude Code adapter: per-turn `claude -p` subprocess; --session-id then --resume (persisted across restarts). */
-import { spawn } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { errMsg, log } from '../log.js';
-import { STATE_DIR } from '../paths.js';
-const STARTED_FILE = join(STATE_DIR, 'claude-sessions.json');
-function loadStarted() {
-    if (!existsSync(STARTED_FILE))
-        return new Set();
-    try {
-        return new Set(JSON.parse(readFileSync(STARTED_FILE, 'utf8')));
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err), path: STARTED_FILE }, 'claude: started cache read failed');
-        return new Set();
-    }
-}
-export class ClaudeAgent {
-    started = loadStarted();
-    children = new Set();
-    persistStarted() {
-        try {
-            writeFileSync(STARTED_FILE, JSON.stringify([...this.started]));
-        }
-        catch (err) {
-            log.warn({ err: errMsg(err), path: STARTED_FILE }, 'claude: started cache write failed');
-        }
-    }
-    async start() {
-        await new Promise((resolve, reject) => {
-            const c = spawn('claude', ['--version'], { stdio: ['ignore', 'pipe', 'pipe'] });
-            let out = '';
-            c.stdout.on('data', d => { out += String(d); });
-            c.on('error', reject);
-            c.on('exit', code => {
-                if (code === 0) {
-                    log.info({ version: out.trim() }, 'claude agent: ready');
-                    resolve();
-                }
-                else
-                    reject(new Error(`claude --version exited with ${code}`));
-            });
-        });
-    }
-    async stop() {
-        for (const c of this.children) {
-            try {
-                c.kill('SIGTERM');
-            }
-            catch { /* ignore */ }
-        }
-        this.children.clear();
-    }
-    async createThread() {
-        const id = randomUUID();
-        log.info({ thread: id }, 'claude agent: thread allocated');
-        return id;
-    }
-    async sendTurn(threadId, text, callbacks) {
-        const args = ['-p', '--output-format', 'stream-json', '--include-partial-messages', '--verbose'];
-        args.push(this.started.has(threadId) ? '--resume' : '--session-id', threadId, text);
-        const child = spawn('claude', args, { stdio: ['ignore', 'pipe', 'pipe'] });
-        this.children.add(child);
-        log.debug({ thread: threadId }, 'claude agent: turn started');
-        const session = new TurnSession(callbacks);
-        let buffer = '';
-        child.stdout?.on('data', d => {
-            buffer += String(d);
-            let nl;
-            while ((nl = buffer.indexOf('\n')) !== -1) {
-                const line = buffer.slice(0, nl).trim();
-                buffer = buffer.slice(nl + 1);
-                if (!line)
-                    continue;
-                try {
-                    session.handle(JSON.parse(line));
-                }
-                catch (err) {
-                    log.warn({ err: errMsg(err) }, 'claude agent: malformed event');
-                }
-            }
-        });
-        child.stderr?.on('data', d => log.trace({ src: 'claude-stderr' }, String(d).trim()));
-        child.on('exit', code => {
-            this.children.delete(child);
-            if (!this.started.has(threadId)) {
-                this.started.add(threadId);
-                this.persistStarted();
-            }
-            if (!session.done) {
-                if (code === 0)
-                    session.fireComplete();
-                else
-                    session.fireError(new Error(`claude exited with code ${code}`));
-            }
-        });
-        child.on('error', err => { this.children.delete(child); if (!session.done)
-            session.fireError(err); });
-    }
-}
-class TurnSession {
-    cb;
-    done = false;
-    thinking = true;
-    /** tool_use_id → kind; survives until the matching tool_result lands. */
-    byUseId = new Map();
-    /** Pending tool_use blocks: input JSON streams in over multiple `input_json_delta` events before the input is complete. */
-    pendingTools = new Map();
-    constructor(cb) {
-        this.cb = cb;
-        cb.onToolStart({ id: 'thinking', kind: 'thinking', name: 'Thinking…', transient: true });
-    }
-    fireComplete() { if (this.done)
-        return; this.done = true; this.clearThinking(); this.cb.onComplete(); }
-    fireError(err) { if (this.done)
-        return; this.done = true; this.clearThinking(); this.cb.onError(err); }
-    clearThinking() { if (!this.thinking)
-        return; this.thinking = false; this.cb.onToolEnd('thinking'); }
-    handle(ev) {
-        if (ev.type === 'result') {
-            if (ev.is_error)
-                this.fireError(new Error(typeof ev.result === 'string' ? ev.result : 'claude error'));
-            else
-                this.fireComplete();
-            return;
-        }
-        if (ev.type === 'user') {
-            this.handleToolResults(ev);
-            return;
-        }
-        if (ev.type !== 'stream_event' || !ev.event)
-            return;
-        const e = ev.event;
-        if (e.type === 'content_block_start' && e.content_block?.type === 'tool_use') {
-            this.clearThinking();
-            const idx = e.index ?? -1;
-            const kind = e.content_block.name ?? 'tool';
-            const id = e.content_block.id ?? `${kind}:${idx}`;
-            this.byUseId.set(id, kind);
-            this.pendingTools.set(idx, { id, kind, toolName: e.content_block.name, inputJson: '' });
-        }
-        else if (e.type === 'content_block_delta' && e.delta?.type === 'input_json_delta') {
-            const tool = this.pendingTools.get(e.index ?? -1);
-            if (tool)
-                tool.inputJson += e.delta.partial_json ?? '';
-        }
-        else if (e.type === 'content_block_delta' && e.delta?.type === 'text_delta') {
-            this.clearThinking();
-            this.cb.onDelta(e.delta.text ?? '');
-        }
-        else if (e.type === 'content_block_stop') {
-            const tool = this.pendingTools.get(e.index ?? -1);
-            if (!tool)
-                return;
-            this.pendingTools.delete(e.index ?? -1);
-            let input;
-            try {
-                input = tool.inputJson ? JSON.parse(tool.inputJson) : undefined;
-            }
-            catch { /* malformed mid-stream — show name only */ }
-            const { name, detail } = summarizeTool(tool.toolName, input);
-            this.cb.onToolStart({ id: tool.id, kind: tool.kind, name, detail });
-        }
-    }
-    /** Claude emits `tool_result` blocks inside a follow-up `user` message after the tool runs. */
-    handleToolResults(ev) {
-        for (const block of ev.message?.content ?? []) {
-            if (block.type !== 'tool_result' || !block.tool_use_id)
-                continue;
-            if (!this.byUseId.has(block.tool_use_id))
-                continue;
-            this.byUseId.delete(block.tool_use_id);
-            this.cb.onToolEnd(block.tool_use_id, extractResultText(block.content));
-        }
-    }
-}
-function extractResultText(content) {
-    if (typeof content === 'string')
-        return content.trim() || undefined;
-    if (!Array.isArray(content))
-        return undefined;
-    const text = content.filter(b => b?.type === 'text').map(b => b.text ?? '').join('\n').trim();
-    return text || undefined;
-}
-function summarizeTool(name, input) {
-    const display = (name ?? 'Tool')[0].toUpperCase() + (name ?? 'Tool').slice(1);
-    if (!input)
-        return { name: display };
-    const path = (input.file_path ?? input.path);
-    const cmd = input.command;
-    const pattern = input.pattern;
-    switch (name) {
-        case 'Bash': return { name: 'Bash', detail: cmd };
-        case 'Edit':
-        case 'Write':
-        case 'NotebookEdit': return { name: display, detail: path };
-        case 'Read': return { name: 'Read', detail: path };
-        case 'Grep':
-        case 'Glob': return { name: display, detail: pattern };
-        case 'WebFetch': return { name: 'WebFetch', detail: input.url };
-        case 'WebSearch': return { name: 'WebSearch', detail: input.query };
-        case 'Task': return { name: 'Task', detail: (input.description ?? input.subagent_type) };
-        default: return { name: display };
-    }
-}