@stage-labs/metro 0.1.0-beta.1 → 0.1.0-beta.3

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 };
-}

package/dist/tail.js

@@ -1,145 +0,0 @@
-// Standalone inbound stream. Polls Telegram + connects to Discord, prints
-// one JSON line per inbound message on stdout. Designed to be launched by
-// an agent and observed via Bash+Monitor (Claude Code) or unified_exec
-// polling (Codex).
-//
-// On every inbound: fires a 👀 reaction and starts a typing indicator that
-// refreshes until the agent replies (signaled by `metro reply` touching
-// .typing-stop/<key>) or the 60s safety cap is hit.
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import * as discord from './channels/discord.js';
-import * as telegram from './channels/telegram.js';
-import { tg } from './channels/telegram.js';
-import { configuredPlatforms, loadMetroEnv, STATE_DIR, requireConfiguredPlatform } from './paths.js';
-import { errMsg, log } from './log.js';
-loadMetroEnv();
-const platforms = configuredPlatforms();
-requireConfiguredPlatform(platforms);
-// Telegram allows only one getUpdates poller per bot token. If another
-// `metro` instance is already running, exit cleanly instead of fighting
-// (409 spam). Stale lockfiles (PID dead) are reclaimed.
-const LOCK_FILE = join(STATE_DIR, '.tail-lock');
-function processIsAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-if (existsSync(LOCK_FILE)) {
-    const pid = Number(readFileSync(LOCK_FILE, 'utf8').trim());
-    if (Number.isInteger(pid) && pid > 0 && processIsAlive(pid)) {
-        log.info({ pid }, 'another `metro` instance is already polling; exiting');
-        process.exit(0);
-    }
-    try {
-        unlinkSync(LOCK_FILE);
-    }
-    catch { }
-}
-writeFileSync(LOCK_FILE, String(process.pid));
-function releaseLock() {
-    try {
-        if (existsSync(LOCK_FILE) && readFileSync(LOCK_FILE, 'utf8').trim() === String(process.pid)) {
-            unlinkSync(LOCK_FILE);
-        }
-    }
-    catch { }
-}
-process.on('exit', releaseLock);
-const TYPING_DIR = join(STATE_DIR, '.typing-stop');
-const TYPING_REFRESH_MS = 4_000;
-const TYPING_MAX_MS = 60_000;
-mkdirSync(TYPING_DIR, { recursive: true });
-const emit = (line) => process.stdout.write(`${JSON.stringify(line)}\n`);
-const typingActive = new Map();
-const typingKey = (platform, chat) => `${platform}_${chat}`;
-function fireTyping(platform, chat) {
-    if (platform === 'telegram') {
-        void tg('sendChatAction', { chat_id: chat, action: 'typing' }).catch(err => log.warn({ err: errMsg(err) }, 'telegram typing failed'));
-    }
-    else {
-        void discord.sendTyping(chat).catch(err => log.warn({ err: errMsg(err) }, 'discord typing failed'));
-    }
-}
-function startTyping(platform, chat) {
-    const k = typingKey(platform, chat);
-    typingActive.set(k, { platform, chat, started: Date.now() });
-    // Clear any stale stop signal so the new typing actually fires.
-    const stopFile = join(TYPING_DIR, k);
-    if (existsSync(stopFile)) {
-        try {
-            unlinkSync(stopFile);
-        }
-        catch { }
-    }
-    fireTyping(platform, chat);
-}
-setInterval(() => {
-    const now = Date.now();
-    for (const [k, e] of typingActive) {
-        const stopFile = join(TYPING_DIR, k);
-        if (existsSync(stopFile)) {
-            try {
-                unlinkSync(stopFile);
-            }
-            catch { }
-            typingActive.delete(k);
-            continue;
-        }
-        if (now - e.started > TYPING_MAX_MS) {
-            typingActive.delete(k);
-            continue;
-        }
-        fireTyping(e.platform, e.chat);
-    }
-}, TYPING_REFRESH_MS);
-if (platforms.telegram) {
-    const me = await telegram.getMe();
-    log.info({ bot: `@${me.username}` }, 'telegram ready');
-    telegram.onInbound(m => {
-        void tg('setMessageReaction', {
-            chat_id: m.chat_id,
-            message_id: m.message_id,
-            reaction: [{ type: 'emoji', emoji: '👀' }],
-        }).catch(err => log.warn({ err: errMsg(err) }, 'telegram auto-react failed'));
-        const chat = String(m.chat_id);
-        startTyping('telegram', chat);
-        emit({ platform: 'telegram', to: `telegram:${chat}/${m.message_id}`, text: m.text });
-    });
-    void telegram.startPolling();
-}
-if (platforms.discord) {
-    await discord.startGateway();
-    const me = await discord.getMe();
-    log.info({ bot: me.username }, 'discord ready');
-    discord.onInbound(m => {
-        void discord
-            .setReaction(m.channel_id, m.message_id, '👀')
-            .catch(err => log.warn({ err: errMsg(err) }, 'discord auto-react failed'));
-        startTyping('discord', m.channel_id);
-        emit({ platform: 'discord', to: `discord:${m.channel_id}/${m.message_id}`, text: m.text });
-    });
-}
-// `process.on('exit', releaseLock)` above runs whenever process.exit is
-// called. We also `await discord.shutdownGateway()` here so the bot flips
-// offline immediately on SIGTERM / SIGINT instead of waiting ~45s for the
-// gateway's missed-heartbeat timeout. SIGKILL bypasses this (nothing we can
-// do); the lockfile auto-reclaims on the next start either way.
-let shuttingDown = false;
-async function shutdown() {
-    if (shuttingDown)
-        return;
-    shuttingDown = true;
-    if (platforms.discord) {
-        await discord.shutdownGateway().catch(err => log.warn({ err: errMsg(err) }, 'discord shutdown failed'));
-    }
-    process.exit(0);
-}
-process.stdin.on('end', shutdown);
-process.stdin.on('close', shutdown);
-process.on('SIGINT', shutdown);
-process.on('SIGTERM', shutdown);

package/skills/metro/SKILL.md

@@ -1,99 +0,0 @@
----
-name: metro
-description: Run the metro Telegram/Discord bridge in this session — launch `metro` in the background, watch its stdout for inbound JSON lines, and act on each. Use when the user asks to start/run/launch metro, when you see JSON lines on stdout shaped `{"platform":..., "to":..., "text":...}`, or when handling a chat reply/react/edit/send/download/fetch.
----
-
-# Metro — running the Telegram & Discord bridge
-
-Metro is a CLI bridge between this agent session and Telegram/Discord. You launch `metro` once when the user asks, then act on each inbound JSON line via `metro <subcommand>`.
-
-## Starting the bridge
-
-When the user asks to run/start/launch metro (or "start the bridge"):
-
-1. Launch `metro` as a backgrounded Bash command (Claude Code: `run_in_background: true`; Codex: equivalent background spawn). Don't block on it.
-2. Attach a stdout watcher: `Monitor` on Claude Code, `unified_exec` polling on Codex. Each stdout line is one inbound JSON. Stderr is logs — don't act on it.
-3. If `metro` exits immediately or no inbounds arrive within a minute of a known DM, run `metro doctor` to diagnose. Common causes: missing tokens (tell the user to run `metro setup telegram <token>` and/or `metro setup discord <token>` in their shell), Discord Message Content Intent not toggled, or a stale lockfile from a previous session.
-
-## Inbound shape
-
-Each `metro` line on stdout:
-
-```json
-{"platform":"telegram"|"discord","to":"<platform>:<chat>/<message_id>","text":"…"}
-```
-
-`text` may include placeholders for non-text content: `[image]`, `[voice]`, `[audio]`, `[file: <name>]`. Voice/audio are opaque markers — you can't download them.
-
-Discord guild messages preserve the user's raw mention markup, including the bot's own `<@bot_id>` (the gate that made the message visible). Treat the bot's own mention as metadata; other users' mentions (`<@some_other_id>`) can be addressee context. Reply normally — the message is addressed to you regardless of where the mention sits.
-
-## Required flow on every inbound
-
-1. **Echo to the visible reply.** Write `[<to>] <text>` on its own line in your visible output. Both Claude Code's Monitor and Codex dim/collapse tool output, so this echo is the only way the user sees what arrived without expanding cards.
-2. **Decide and act.** Pick the matching subcommand below.
-
-> 👀 is already on the message — `metro` auto-reacts server-side on every inbound and clears the reaction when you reply. Don't call `metro react --emoji=👀` yourself; you'd just flicker it on/off and waste a tool call.
-
-## Subcommands
-
-`reply` / `react` / `edit` / `download` take `--to=<platform>:<chat>/<message_id>` copied verbatim from the inbound `to` field. `send` and `fetch` take a channel-only `--to=<platform>:<chat>` (no message id). Append `--json` to any of them for a single JSON result line you can parse.
-
-| Action | Command |
-|---|---|
-| Quote-reply (threads under original; clears 👀) | `metro reply --to=<to> --text=<reply>` |
-| Quick ack reaction | `metro react --to=<to> --emoji=👍` |
-| Edit your previous bot message | `metro edit --to=<to> --text=<new text>` |
-| Send a proactive message (no reply context) | `metro send --to=<platform>:<chat_id> --text=<msg>` |
-| Download `[image]` attachments → file paths | `metro download --to=<to>` |
-| Fetch recent channel history (Discord only) | `metro fetch --to=discord:<channel_id> --limit=20` |
-
-`reply` / `edit` / `send` accept multi-line `--text` via stdin (heredoc).
-
-## When to use `send` vs `reply`
-
-- **`reply`** — responding to a specific inbound message. Threads under it. This is the default when handling a `metro` inbound line.
-- **`send`** — initiating without a triggering message: a long task you kicked off finished, a scheduled job fired, a follow-up the user asked you to deliver later. The chat/channel id you target must be one the bot can reach (existing DM, joined guild channel).
-
-## Address format
-
-- `telegram:<chat_id>/<message_id>` — copied straight from inbound `to`
-- `discord:<channel_id>/<message_id>` — same
-- `discord:<channel_id>` — channel-only, used for `metro fetch`
-
-## Image attachments
-
-When `text` contains `[image]`:
-
-1. Run `metro download --to=<to>` — writes images to disk and prints absolute paths (one per line).
-2. `Read` each path with the Read tool — the image enters your context as a vision input.
-3. Reply normally with `metro reply`.
-
-## Opaque attachment markers
-
-`[voice]`, `[audio: <name>]`, and `[file: <name>]` are opaque — `metro download` only handles images. Acknowledge in text (e.g., "got your voice note — could you type it out?") or, if your runtime accepts audio/file input directly, ask the user to resend as a regular file.
-
-## Exit codes
-
-- `0` success
-- `1` usage error (bad flags, unknown subcommand)
-- `2` configuration error (no tokens; tell the user to run `metro setup`)
-- `3` upstream error (rate limit, auth, network) — wait a few seconds and retry once before surfacing to the user
-
-If anything's misbehaving, run `metro doctor` to see which check fails.
-
-## --json output
-
-Every action command supports `--json` for stable, parseable output:
-
-```bash
-metro reply --to=… --text=… --json
-# {"ok":true,"platform":"discord","to":"discord:123/456","sent_message_id":"…"}
-
-metro fetch --to=discord:1234 --limit=10 --json
-# [{"message_id":"…","author":"…","text":"…","timestamp":"…"}, …]
-
-metro download --to=… --json
-# {"images":[{"path":"/abs/…png","mime":"image/png"}]}
-```
-
-Use `--json` when you need to chain calls or capture the new message_id for a later edit.