@stage-labs/metro 0.1.0-beta.2 → 0.1.0-beta.200

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

@@ -0,0 +1,51 @@
+export { emit, respond, mintId } from '@metro-labs/core/stations/station-runtime';
+
+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)',
+  );
+}
+
+const SENT_MAX = 5000;
+const sentIds = new Set<string>();
+
+export function rememberSent(xmtpId: string | undefined): void {
+  if (!xmtpId) return;
+  sentIds.add(xmtpId);
+  if (sentIds.size > SENT_MAX) {
+    const oldest = sentIds.values().next().value;
+    if (oldest !== undefined) sentIds.delete(oldest);
+  }
+}
+
+export const sentByMe = (xmtpId: string): boolean => sentIds.has(xmtpId);

package/runtime/runtime.json

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

package/runtime/server.ts

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

package/runtime/stations.json

@@ -0,0 +1,37 @@
+{
+  "core": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "pino": "^9.5.0",
+    "pino-pretty": "^13.1.3",
+    "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": {},
+    "webhook": {}
+  }
+}

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,78 +0,0 @@
-# Metro
-
-Chat with your Claude Code or Codex agent over Telegram and Discord.
-
-## Quickstart
-
-In your shell:
-
-```bash
-npm install -g @stage-labs/metro@beta    # or: bun add -g @stage-labs/metro@beta
-
-metro setup telegram <token>    # https://t.me/BotFather
-metro setup discord <token>     # https://discord.com/developers/applications
-
-metro setup skill                        # writes SKILL.md so Claude Code + Codex auto-onboard
-metro doctor                             # verify
-```
-
-> **Discord setup:** toggle **Message Content Intent** in Developer Portal → Bot → Privileged Gateway Intents.
-
-### Run with Claude Code
-
-```bash
-claude
-> Run metro in the background.
-```
-
-Then DM your bot. The bundled skill auto-triggers — the agent launches metro via Bash + Monitor, watches stdout, and replies.
-
-### Run with Codex
-
-Codex's `unified_exec` is poll-only ([#4751](https://github.com/openai/codex/issues/4751)) — there's no Monitor equivalent. Metro instead pushes each inbound into the agent's history via JSON-RPC. Two terminals plus a prompt — the TUI's `--remote` flag only accepts `ws://`, so daemon and TUI share one URL:
-
-```bash
-# Terminal 1 — daemon (must be running first)
-codex app-server --listen ws://127.0.0.1:8421
-
-# Terminal 2 — TUI attached to the daemon
-codex --remote ws://127.0.0.1:8421
-> Run metro in the background.
-```
-
-The agent launches `metro` (with `METRO_CODEX_RC=ws://127.0.0.1:8421` set) via its shell tool. Metro connects to the daemon and pushes each inbound as a `turn/start` on the active thread — the agent in terminal 2 reacts on its next turn. `codex remote-control` is stdio-only (no listener), so don't use it for this flow.
-
-Bare `codex` (no `--remote`) can't work with metro — the agent has no daemon to push to. The TUI must be attached to a running app-server.
-
-`METRO_CODEX_RC` accepts `ws://host:port` (required for use with the codex TUI) or `unix:///abs/path` (headless only — the daemon supports UDS but the TUI doesn't).
-
-## 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, attachment cache, default download dir. |
-| `METRO_LOG_LEVEL` | `info` | `trace` / `debug` / `info` / `warn` / `error` / `fatal`. |
-| `METRO_CODEX_RC` | — | Codex app-server URL (e.g. `ws://127.0.0.1:8421`). When set, metro pushes each inbound into the agent's history via JSON-RPC `turn/start` — the Codex equivalent of Claude Code's Monitor. Accepts `ws://host:port` (required for use with the codex TUI) or `unix:///abs/path` (headless only). See [Codex setup](#codex-setup). |
-
-Token precedence: process env → `./.env` → `$METRO_CONFIG_DIR/.env`. Logs to stderr.
-
-## Reference
-
-- `metro --help` — command surface
-- `metro doctor` — health check
-- [SKILL.md](skills/metro/SKILL.md) — agent-facing flow
-
-## Uninstall
-
-```bash
-metro setup clear; metro setup skill --clear
-rm -rf ~/.cache/metro/
-npm uninstall -g @stage-labs/metro
-```
-
-## Caveats
-
-- **No allowlist.** Anyone who can DM your bot or @-mention it can talk to your session. Run against bots you own.
-- **Latency.** Inbounds surface at the next agent decision boundary — sub-second on Claude Code, longer on Codex turns.

package/dist/channels/discord.js

@@ -1,148 +0,0 @@
-import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
-import { errMsg, log } from '../log.js';
-// Receive path: discord.js gateway, used by tail.ts only.
-// Send path: raw REST against discord.com/api — no gateway login required,
-// so cli.ts subcommands stay one-shot and fast.
-const API_BASE = 'https://discord.com/api/v10';
-function token() {
-    const t = process.env.DISCORD_BOT_TOKEN;
-    if (!t)
-        throw new Error('DISCORD_BOT_TOKEN is not set');
-    return t;
-}
-async function rest(method, path, body, timeoutMs = 30_000) {
-    const res = await fetch(`${API_BASE}${path}`, {
-        method,
-        headers: {
-            'Authorization': `Bot ${token()}`,
-            'User-Agent': 'metro (https://github.com/bonustrack/metro, dev)',
-            ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
-        },
-        body: body !== undefined ? JSON.stringify(body) : undefined,
-        signal: AbortSignal.timeout(timeoutMs),
-    });
-    if (!res.ok) {
-        const text = await res.text().catch(() => '');
-        throw new Error(`discord ${method} ${path}: ${res.status} ${text}`);
-    }
-    // 204 No Content for typing/reactions/clear.
-    if (res.status === 204)
-        return undefined;
-    return (await res.json());
-}
-// ---------- Receive path (gateway, discord.js) -----------------------------
-let client = null;
-function getClient() {
-    if (client)
-        return client;
-    client = new Client({
-        intents: [
-            GatewayIntentBits.DirectMessages,
-            GatewayIntentBits.Guilds,
-            GatewayIntentBits.GuildMessages,
-            GatewayIntentBits.MessageContent,
-        ],
-        // DM channels arrive partial; without this messageCreate never fires.
-        partials: [Partials.Channel],
-    });
-    return client;
-}
-let onInboundHandler = () => { };
-export function onInbound(handler) {
-    onInboundHandler = handler;
-}
-export async function shutdownGateway() {
-    if (!client)
-        return;
-    await client.destroy();
-    client = null;
-}
-export async function startGateway() {
-    const c = getClient();
-    c.on(Events.MessageCreate, m => {
-        if (m.author.bot)
-            return;
-        // Guild messages: only forward when the bot is mentioned. DMs always pass.
-        // The bot's own @-mention is preserved in `m.content` — stripping it would
-        // lose mid-sentence position ("Wdyt @Metro is this good?" → "Wdyt is this
-        // good?") and silently drop bare-mention pings. The agent recognizes
-        // `<@bot_id>` and acts on the request as a whole.
-        if (m.guildId && c.user && !m.mentions.has(c.user.id))
-            return;
-        const tags = [...m.attachments.values()]
-            .map(a => {
-            if (a.contentType?.startsWith('image/'))
-                return '[image]';
-            if (a.contentType?.startsWith('audio/'))
-                return `[audio: ${a.name}]`;
-            return `[file: ${a.name}]`;
-        })
-            .join(' ');
-        const text = [m.content, tags].filter(Boolean).join(' ').trim();
-        if (!text)
-            return;
-        onInboundHandler({ channel_id: m.channelId, message_id: m.id, text });
-    });
-    c.on(Events.Error, err => log.error({ err: errMsg(err) }, 'discord error'));
-    await c.login(process.env.DISCORD_BOT_TOKEN);
-    await new Promise(r => c.once(Events.ClientReady, () => r()));
-}
-export async function getMe() {
-    const me = await rest('GET', '/users/@me');
-    return { username: me.username };
-}
-export async function sendMessage(channelId, text) {
-    const sent = await rest('POST', `/channels/${channelId}/messages`, { content: text });
-    return sent.id;
-}
-export async function replyToMessage(channelId, messageId, text) {
-    const sent = await rest('POST', `/channels/${channelId}/messages`, {
-        content: text,
-        message_reference: { message_id: messageId, fail_if_not_exists: false },
-    });
-    return sent.id;
-}
-export async function editMessage(channelId, messageId, text) {
-    const sent = await rest('PATCH', `/channels/${channelId}/messages/${messageId}`, { content: text });
-    return sent.id;
-}
-export async function sendTyping(channelId) {
-    await rest('POST', `/channels/${channelId}/typing`);
-}
-export async function setReaction(channelId, messageId, emoji) {
-    if (emoji) {
-        await rest('PUT', `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}/@me`);
-        return;
-    }
-    // Clear only the bot's own reactions (matches Telegram's clear semantics).
-    const msg = await rest('GET', `/channels/${channelId}/messages/${messageId}`);
-    for (const r of msg.reactions ?? []) {
-        if (!r.me || !r.emoji.name)
-            continue;
-        await rest('DELETE', `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(r.emoji.name)}/@me`);
-    }
-}
-export async function fetchAttachments(channelId, messageId) {
-    const msg = await rest('GET', `/channels/${channelId}/messages/${messageId}`);
-    const out = [];
-    for (const a of msg.attachments) {
-        if (!a.content_type?.startsWith('image/'))
-            continue;
-        const res = await fetch(a.url, { signal: AbortSignal.timeout(30_000) });
-        if (!res.ok)
-            throw new Error(`discord: download ${a.url}: ${res.status}`);
-        out.push({ data: Buffer.from(await res.arrayBuffer()).toString('base64'), mime: a.content_type });
-    }
-    return out;
-}
-export async function fetchRecentMessages(channelId, limit) {
-    const n = Math.min(Math.max(limit, 1), 100);
-    const msgs = await rest('GET', `/channels/${channelId}/messages?limit=${n}`);
-    // Discord returns newest-first; reverse for chronological.
-    return [...msgs].reverse().map(m => ({
-        message_id: m.id,
-        author: m.author.username,
-        text: m.content,
-        timestamp: m.timestamp,
-    }));
-}

package/dist/channels/telegram.js

@@ -1,137 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { STATE_DIR } from '../paths.js';
-import { errMsg, log } from '../log.js';
-const API_BASE = 'https://api.telegram.org';
-function token() {
-    const t = process.env.TELEGRAM_BOT_TOKEN;
-    if (!t)
-        throw new Error('TELEGRAM_BOT_TOKEN is not set');
-    return t;
-}
-export async function tg(method, body, timeoutMs = 30_000) {
-    const res = await fetch(`${API_BASE}/bot${token()}/${method}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(timeoutMs),
-    });
-    const json = (await res.json());
-    if (!json.ok)
-        throw new Error(`telegram ${method}: ${json.description ?? 'unknown error'}`);
-    return json.result;
-}
-export function buildSendBody(chatId, text, opts) {
-    const body = { chat_id: chatId, text };
-    if (opts.parseMode)
-        body.parse_mode = opts.parseMode;
-    if (opts.disableLinkPreview)
-        body.link_preview_options = { is_disabled: true };
-    if (opts.buttons?.length)
-        body.reply_markup = { inline_keyboard: opts.buttons };
-    return body;
-}
-export async function getMe() {
-    return tg('getMe', {});
-}
-const CACHE_MAX = 200;
-const cacheFile = join(STATE_DIR, 'telegram-attachments.json');
-function readCache() {
-    try {
-        return existsSync(cacheFile) ? JSON.parse(readFileSync(cacheFile, 'utf8')) : {};
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err) }, 'telegram attachment cache read failed');
-        return {};
-    }
-}
-function cacheAttachment(chatId, messageId, att) {
-    try {
-        const data = readCache();
-        const key = `${chatId}:${messageId}`;
-        data[key] = [...(data[key] ?? []), att];
-        const keys = Object.keys(data);
-        for (const stale of keys.slice(0, Math.max(0, keys.length - CACHE_MAX)))
-            delete data[stale];
-        writeFileSync(cacheFile, JSON.stringify(data, null, 2));
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err) }, 'telegram attachment cache write failed');
-    }
-}
-export function getCachedAttachments(chatId, messageId) {
-    return readCache()[`${chatId}:${messageId}`] ?? [];
-}
-export async function downloadAttachment(fileId, mime) {
-    const file = await tg('getFile', { file_id: fileId });
-    const res = await fetch(`${API_BASE}/file/bot${token()}/${file.file_path}`, {
-        signal: AbortSignal.timeout(30_000),
-    });
-    if (!res.ok)
-        throw new Error(`download failed: ${res.status}`);
-    const buf = Buffer.from(await res.arrayBuffer());
-    // Trust the cached mime — it's the authoritative one from the message
-    // metadata (`image/jpeg` for photos, the document's mime_type for files).
-    // The Telegram CDN often returns `application/octet-stream` as Content-Type,
-    // which would otherwise wipe out our extension classification downstream.
-    return { data: buf.toString('base64'), mime };
-}
-async function messageToText(m, chatId) {
-    if (m.text)
-        return m.text;
-    const caption = m.caption ?? '';
-    if (m.photo?.length) {
-        const photo = m.photo[m.photo.length - 1];
-        cacheAttachment(chatId, m.message_id, { file_id: photo.file_id, mime: 'image/jpeg' });
-        return [caption, '[image]'].filter(Boolean).join(' ');
-    }
-    if (m.document?.mime_type?.startsWith('image/')) {
-        cacheAttachment(chatId, m.message_id, { file_id: m.document.file_id, mime: m.document.mime_type });
-        return [caption, '[image]'].filter(Boolean).join(' ');
-    }
-    if (m.voice)
-        return [caption, '[voice]'].filter(Boolean).join(' ');
-    if (m.audio)
-        return [caption, '[audio]'].filter(Boolean).join(' ');
-    return caption || null;
-}
-let onInboundHandler = () => { };
-export function onInbound(handler) {
-    onInboundHandler = handler;
-}
-export async function startPolling() {
-    // A registered webhook short-circuits getUpdates — clear it defensively.
-    await tg('deleteWebhook', { drop_pending_updates: false }).catch(() => { });
-    let offset = 0;
-    const initial = await tg('getUpdates', { timeout: 0 });
-    if (initial.length)
-        offset = initial[initial.length - 1].update_id + 1;
-    while (true) {
-        try {
-            const updates = await tg('getUpdates', { offset, timeout: 50 }, 60_000);
-            for (const u of updates) {
-                offset = u.update_id + 1;
-                void dispatchUpdate(u);
-            }
-        }
-        catch (err) {
-            log.error({ err: errMsg(err) }, 'telegram poll error');
-            await new Promise(r => setTimeout(r, 1000));
-        }
-    }
-}
-async function dispatchUpdate(u) {
-    const m = u.message;
-    if (!m?.chat?.id || typeof m.message_id !== 'number')
-        return;
-    const base = { chat_id: m.chat.id, message_id: m.message_id };
-    try {
-        const text = await messageToText(m, m.chat.id);
-        if (text === null)
-            return;
-        onInboundHandler({ ...base, text });
-    }
-    catch (err) {
-        onInboundHandler({ ...base, text: `[message processing failed: ${errMsg(err)}]` });
-    }
-}

package/dist/lib/address.js

@@ -1,21 +0,0 @@
-// `<platform>:<chat>[/<message_id>]` — the wire format of every metro
-// inbound `to` field, and the only address shape any subcommand accepts.
-export function parseAddress(to, requireMessage) {
-    const colon = to.indexOf(':');
-    if (colon === -1) {
-        throw new Error(`invalid --to (expected '<platform>:<chat>[/<message_id>]'): ${to}`);
-    }
-    const platform = to.slice(0, colon);
-    if (platform !== 'telegram' && platform !== 'discord') {
-        throw new Error(`unknown platform '${platform}' in --to (expected 'telegram' or 'discord')`);
-    }
-    const rest = to.slice(colon + 1);
-    const slash = rest.indexOf('/');
-    const chat = slash === -1 ? rest : rest.slice(0, slash);
-    const messageId = slash === -1 ? undefined : rest.slice(slash + 1);
-    if (!chat)
-        throw new Error(`empty chat/channel id in --to: ${to}`);
-    if (requireMessage && !messageId)
-        throw new Error(`--to must include /<message_id>: ${to}`);
-    return { platform, chat, messageId };
-}