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

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

package/dist/lib/codex-rc.js

@@ -1,274 +0,0 @@
-// JSON-RPC over WebSocket client for the Codex app-server. By default
-// connects over the Unix domain socket exposed by `codex remote-control`
-// (see paths.DEFAULT_CODEX_SOCKET). On every metro inbound it calls
-// `turn/start`, which lands the JSON line in the agent's history as a
-// user message and wakes the agent — the Codex equivalent of Claude
-// Code's `Monitor`.
-//
-// Wire format: standard JSON-RPC 2.0 over WebSocket. Methods we use:
-//   - initialize      → handshake, declares clientInfo.
-//   - thread/list     → discover existing threads on connect.
-//   - thread/started  → notification; track new threads as they appear.
-//   - turn/started    → notification; mark a turn in flight.
-//   - turn/completed  → notification; drain queued inbounds.
-//   - turn/start      → push a user message and wake the agent.
-//
-// If no thread exists yet, inbounds queue in memory; they fire as soon
-// as a thread is started or learned. If the connection drops, reconnect
-// with linear backoff and replay the queue. Connection failures don't
-// break metro — stdout emit always runs first, so Claude Code Monitor
-// users keep working regardless.
-import { createConnection } from 'node:net';
-import { WebSocket } from 'ws';
-import { errMsg, log } from '../log.js';
-const RECONNECT_DELAY_MS = 2_000;
-const MAX_QUEUE = 100;
-// Backstop: if `turn/completed` never arrives (the daemon doesn't broadcast
-// it to all clients, or we miss it for any reason), unstick after this long.
-// Generous enough that any normal turn finishes well within it.
-const TURN_TIMEOUT_MS = 120_000;
-/**
- * Accept any of these forms for METRO_CODEX_RC:
- *   ws://host:port/    TCP WebSocket.
- *   wss://host/        TCP WebSocket over TLS.
- *   unix:///abs/path   UDS WebSocket (the default for `codex remote-control`).
- *   /abs/path          shorthand for unix:///abs/path.
- */
-export function parseCodexUrl(input) {
-    if (input.startsWith('ws://') || input.startsWith('wss://')) {
-        return { kind: 'tcp', url: input };
-    }
-    if (input.startsWith('unix://')) {
-        return { kind: 'unix', path: input.replace(/^unix:\/+/, '/') };
-    }
-    if (input.startsWith('/')) {
-        return { kind: 'unix', path: input };
-    }
-    throw new Error(`unsupported METRO_CODEX_RC: ${input} (expected ws://…, wss://…, unix://…, or absolute path)`);
-}
-function openSocket(endpoint) {
-    if (endpoint.kind === 'tcp')
-        return new WebSocket(endpoint.url);
-    // UDS WebSocket: ws library upgrades any duplex stream, so we feed it a
-    // unix-socket Net connection via `createConnection`. The `ws://localhost/`
-    // URL is a placeholder — only the framing matters at this point; the
-    // bytes flow over the UDS we just opened.
-    return new WebSocket('ws://localhost/', {
-        createConnection: () => createConnection({ path: endpoint.path }),
-    });
-}
-export class CodexRC {
-    clientVersion;
-    ws = null;
-    nextId = 1;
-    pending = new Map();
-    threadId = null;
-    queue = [];
-    connected = false;
-    connecting = false;
-    turnInFlight = false;
-    turnTimeout = null;
-    closed = false;
-    endpoint;
-    displayUrl;
-    constructor(url, clientVersion) {
-        this.clientVersion = clientVersion;
-        this.endpoint = parseCodexUrl(url);
-        this.displayUrl = url;
-    }
-    start() {
-        void this.connect();
-    }
-    stop() {
-        this.closed = true;
-        this.ws?.close();
-        this.ws = null;
-    }
-    /**
-     * Push an inbound JSON line to the Codex agent. If not yet connected or
-     * no thread is active, queues until ready (FIFO, capped).
-     */
-    push(line) {
-        if (this.queue.length >= MAX_QUEUE) {
-            log.warn({ url: this.displayUrl }, 'codex-rc queue full, dropping oldest inbound');
-            this.queue.shift();
-        }
-        this.queue.push(line);
-        void this.drainQueue();
-    }
-    async connect() {
-        if (this.closed || this.connected || this.connecting)
-            return;
-        this.connecting = true;
-        try {
-            const ws = openSocket(this.endpoint);
-            this.ws = ws;
-            // Register the persistent error handler BEFORE awaiting open — without
-            // it, an error fired during the upgrade (UDS missing, daemon down,
-            // bad URL) is "unhandled" and crashes the process under Bun. The
-            // once('error') below covers the connect-time rejection; this on()
-            // covers later errors and the rare double-emit.
-            ws.on('error', err => log.warn({ err: errMsg(err) }, 'codex-rc websocket error'));
-            await new Promise((resolve, reject) => {
-                ws.once('open', resolve);
-                ws.once('error', err => reject(err));
-            });
-            ws.on('message', data => this.onMessage(data));
-            ws.on('close', () => this.onClose());
-            await this.call('initialize', {
-                clientInfo: { name: 'metro', version: this.clientVersion, title: null },
-            });
-            try {
-                const list = await this.call('thread/list', {});
-                const active = (list.data ?? []).find(t => t.status !== 'archived');
-                if (active)
-                    this.threadId = active.id;
-            }
-            catch (err) {
-                log.warn({ err: errMsg(err) }, 'codex-rc thread/list failed (non-fatal)');
-            }
-            this.connected = true;
-            log.info({ url: this.displayUrl, thread: this.threadId ?? '(none yet)' }, 'codex-rc connected');
-            void this.drainQueue();
-        }
-        catch (err) {
-            log.warn({ err: errMsg(err), url: this.displayUrl }, 'codex-rc connect failed; retrying');
-            this.scheduleReconnect();
-        }
-        finally {
-            this.connecting = false;
-        }
-    }
-    onMessage(raw) {
-        let msg;
-        try {
-            msg = JSON.parse(raw.toString());
-        }
-        catch (err) {
-            log.warn({ err: errMsg(err) }, 'codex-rc malformed message');
-            return;
-        }
-        log.debug({ id: msg.id, method: msg.method, hasError: !!msg.error }, 'codex-rc ← message');
-        if (msg.id !== undefined && this.pending.has(msg.id)) {
-            const p = this.pending.get(msg.id);
-            this.pending.delete(msg.id);
-            if (msg.error)
-                p.reject(new Error(msg.error.message ?? 'rpc error'));
-            else
-                p.resolve(msg.result);
-            return;
-        }
-        if (msg.method === 'thread/started') {
-            const params = msg.params;
-            if (params?.thread?.id) {
-                this.threadId = params.thread.id;
-                log.info({ thread: this.threadId }, 'codex-rc thread started');
-                void this.drainQueue();
-            }
-        }
-        else if (msg.method === 'thread/status/changed') {
-            // Codex 0.130 doesn't emit turn/started or turn/completed to a non-
-            // owner connection (the TUI gets them; metro doesn't). Instead the
-            // daemon broadcasts thread/status/changed transitions: status is
-            // either a string (`"idle"` / `"notLoaded"` / `"systemError"`) or an
-            // object (`{"active": {...}}`) per the v2 protocol enum. Treat
-            // anything other than `active` as ready-for-next-turn.
-            const params = msg.params;
-            if (params?.threadId === this.threadId) {
-                const isActive = typeof params.status === 'object' && params.status !== null && 'active' in params.status;
-                log.debug({ thread: this.threadId, isActive, status: params.status }, 'codex-rc thread status changed');
-                if (isActive) {
-                    this.turnInFlight = true;
-                }
-                else {
-                    this.clearTurnTimeout();
-                    this.turnInFlight = false;
-                    void this.drainQueue();
-                }
-            }
-        }
-        else if (msg.method === 'turn/completed') {
-            // Backstop in case some codex version does emit turn lifecycle
-            // notifications on the metro connection.
-            log.debug({ thread: this.threadId, queue: this.queue.length }, 'codex-rc turn/completed; draining');
-            this.clearTurnTimeout();
-            this.turnInFlight = false;
-            void this.drainQueue();
-        }
-        else if (msg.method === 'turn/started') {
-            log.debug({ thread: this.threadId }, 'codex-rc turn/started');
-            this.turnInFlight = true;
-        }
-        else if (msg.method === 'thread/closed' || msg.method === 'thread/archived') {
-            log.warn({ method: msg.method, params: msg.params }, 'codex-rc thread closed/archived; clearing thread reference');
-            this.threadId = null;
-        }
-    }
-    onClose() {
-        if (this.closed)
-            return;
-        this.connected = false;
-        this.ws = null;
-        for (const p of this.pending.values())
-            p.reject(new Error('websocket closed'));
-        this.pending.clear();
-        this.scheduleReconnect();
-    }
-    scheduleReconnect() {
-        if (this.closed)
-            return;
-        this.connected = false;
-        setTimeout(() => void this.connect(), RECONNECT_DELAY_MS);
-    }
-    async drainQueue() {
-        if (!this.connected || !this.threadId || this.turnInFlight)
-            return;
-        if (this.queue.length === 0)
-            return;
-        const line = this.queue[0];
-        this.turnInFlight = true;
-        this.armTurnTimeout();
-        log.debug({ thread: this.threadId, queue: this.queue.length }, 'codex-rc → turn/start');
-        try {
-            await this.call('turn/start', {
-                threadId: this.threadId,
-                input: [{ type: 'text', text: line, textElements: [] }],
-            });
-            this.queue.shift();
-        }
-        catch (err) {
-            log.warn({ err: errMsg(err) }, 'codex-rc turn/start failed; will retry');
-            this.clearTurnTimeout();
-            this.turnInFlight = false;
-            setTimeout(() => void this.drainQueue(), 1_000);
-        }
-    }
-    // If `turn/completed` never arrives (the daemon doesn't broadcast it to
-    // metro's connection, or we miss it for any reason), unstick after the
-    // backstop so subsequent inbounds don't queue forever.
-    armTurnTimeout() {
-        this.clearTurnTimeout();
-        this.turnTimeout = setTimeout(() => {
-            log.warn({ thread: this.threadId, queue: this.queue.length }, `codex-rc turn/completed not received within ${TURN_TIMEOUT_MS}ms; force-clearing single-flight gate`);
-            this.turnInFlight = false;
-            this.turnTimeout = null;
-            void this.drainQueue();
-        }, TURN_TIMEOUT_MS);
-    }
-    clearTurnTimeout() {
-        if (this.turnTimeout) {
-            clearTimeout(this.turnTimeout);
-            this.turnTimeout = null;
-        }
-    }
-    call(method, params) {
-        if (!this.ws)
-            return Promise.reject(new Error('not connected'));
-        const id = this.nextId++;
-        const ws = this.ws;
-        return new Promise((resolve, reject) => {
-            this.pending.set(id, { resolve: resolve, reject });
-            ws.send(JSON.stringify({ jsonrpc: '2.0', id, method, params }));
-        });
-    }
-}

package/dist/lib/dotenv.js

@@ -1,31 +0,0 @@
-// Tiny .env reader/writer. Used by `metro setup` (read/write the global
-// config file) and by paths.ts (load env vars into process.env at startup).
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-const LINE_RE = /^\s*([A-Za-z_]\w*)\s*=\s*(.*?)\s*$/;
-const QUOTED_RE = /^(['"])(.*)\1$/;
-export function readDotenv(path) {
-    if (!existsSync(path))
-        return {};
-    const out = {};
-    for (const line of readFileSync(path, 'utf8').split('\n')) {
-        const m = line.match(LINE_RE);
-        if (m)
-            out[m[1]] = m[2].replace(QUOTED_RE, '$2');
-    }
-    return out;
-}
-export function writeDotenv(path, env) {
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, Object.entries(env).map(([k, v]) => `${k}=${v}`).join('\n') + '\n');
-    chmodSync(path, 0o600);
-}
-// Load .env at `path` into process.env, but only for keys that aren't already
-// set — first definer wins, so callers control precedence by the order they
-// invoke this.
-export function loadDotenvIntoProcess(path) {
-    for (const [k, v] of Object.entries(readDotenv(path))) {
-        if (process.env[k] === undefined)
-            process.env[k] = v;
-    }
-}

package/dist/log.js

@@ -1,12 +0,0 @@
-// Pino → stderr. Stdout is reserved for command output (`metro`'s inbound
-// JSON lines, subcommand results, --json) — any stray write there breaks
-// parsing. Override level with METRO_LOG_LEVEL.
-import pino from 'pino';
-export const log = pino({ name: 'metro', level: process.env.METRO_LOG_LEVEL || 'info' }, pino.destination(2));
-export const errMsg = (err) => {
-    if (err instanceof Error)
-        return err.message;
-    if (err && typeof err === 'object' && 'message' in err)
-        return String(err.message);
-    return String(err);
-};

package/dist/paths.js

@@ -1,45 +0,0 @@
-import { mkdirSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { loadDotenvIntoProcess } from './lib/dotenv.js';
-import { log } from './log.js';
-// Lockfile, typing-stop signals, attachment cache. Override with METRO_STATE_DIR.
-export const STATE_DIR = process.env.METRO_STATE_DIR ?? join(homedir(), '.cache', 'metro');
-mkdirSync(STATE_DIR, { recursive: true });
-// Where `metro setup` writes the global .env. Override with METRO_CONFIG_DIR
-// or the standard $XDG_CONFIG_HOME.
-const CONFIG_DIR = process.env.METRO_CONFIG_DIR ??
-    join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'metro');
-export const CONFIG_ENV_FILE = join(CONFIG_DIR, '.env');
-// Default codex app-server WebSocket. The TUI's `--remote <ADDR>` flag
-// only accepts ws:// (no UDS), so this is the canonical URL we recommend
-// users align on across the daemon, the TUI, and metro:
-//   codex app-server --listen ws://127.0.0.1:8421
-//   codex --remote ws://127.0.0.1:8421
-//   METRO_CODEX_RC=ws://127.0.0.1:8421 metro
-// Override via METRO_CODEX_RC if a different port/host is needed.
-export const DEFAULT_CODEX_RC_URL = 'ws://127.0.0.1:8421';
-export function skillDir(runtime, scope) {
-    const base = scope === 'user' ? homedir() : process.cwd();
-    const root = runtime === 'claude-code' ? '.claude' : '.agents';
-    return join(base, root, 'skills', 'metro');
-}
-// Precedence: process.env (already set) > cwd/.env > <CONFIG_DIR>/.env.
-// loadDotenvIntoProcess only fills vars that aren't already populated, so the
-// first call that defines a key wins.
-export function loadMetroEnv() {
-    loadDotenvIntoProcess(join(process.cwd(), '.env'));
-    loadDotenvIntoProcess(CONFIG_ENV_FILE);
-}
-export function configuredPlatforms() {
-    return {
-        telegram: !!process.env.TELEGRAM_BOT_TOKEN,
-        discord: !!process.env.DISCORD_BOT_TOKEN,
-    };
-}
-export function requireConfiguredPlatform(p) {
-    if (p.telegram || p.discord)
-        return;
-    log.fatal('no platforms configured — run `metro setup telegram <token>` or `metro setup discord <token>`');
-    process.exit(2);
-}

package/dist/tail.js

@@ -1,161 +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 pkg from '../package.json' with { type: 'json' };
-import * as discord from './channels/discord.js';
-import * as telegram from './channels/telegram.js';
-import { tg } from './channels/telegram.js';
-import { CodexRC } from './lib/codex-rc.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 });
-// Codex push channel. Set METRO_CODEX_RC to the codex app-server URL
-// (typically `ws://127.0.0.1:8421` matching `codex app-server --listen
-// ws://127.0.0.1:8421`) to inject each inbound into the agent's history
-// via JSON-RPC `turn/start`. Codex's TUI `--remote` flag only accepts
-// ws://, so the daemon, the TUI, and metro must all share the same URL.
-// Unset → metro behaves exactly as before; stdout emit always runs first
-// so Claude Code Monitor users are unaffected.
-const codexRC = process.env.METRO_CODEX_RC ? new CodexRC(process.env.METRO_CODEX_RC, pkg.version) : null;
-codexRC?.start();
-const emit = (line) => {
-    const json = JSON.stringify(line);
-    process.stdout.write(`${json}\n`);
-    codexRC?.push(json);
-};
-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;
-    codexRC?.stop();
-    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);