@stage-labs/metro 0.1.0-beta.13 → 0.1.0-beta.130

package/dist/codex-rc.js

@@ -1,245 +0,0 @@
-/**
- * JSON-RPC/WS client for codex app-server: each event → `turn/start` (Codex's Monitor equivalent).
- */
-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 in case `turn/completed` never arrives — unstick the single-flight gate. */
-const TURN_TIMEOUT_MS = 120_000;
-/** Accept ws://, wss://, unix:///abs/path, or /abs/path (shorthand for unix). */
-function parseUrl(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 abs path)`);
-}
-function openSocket(endpoint) {
-    if (endpoint.kind === 'tcp')
-        return new WebSocket(endpoint.url);
-    return new WebSocket('ws://localhost/', {
-        createConnection: () => createConnection({ path: endpoint.path }),
-    });
-}
-export class CodexRC {
-    url;
-    clientVersion;
-    ws = null;
-    nextId = 1;
-    pending = new Map();
-    threadId = null;
-    threadListener = null;
-    queue = [];
-    connected = false;
-    connecting = false;
-    turnInFlight = false;
-    turnTimeout = null;
-    closed = false;
-    endpoint;
-    constructor(url, clientVersion) {
-        this.url = url;
-        this.clientVersion = clientVersion;
-        this.endpoint = parseUrl(url);
-    }
-    start() { void this.connect(); }
-    getThreadId() { return this.threadId; }
-    onThread(listener) { this.threadListener = listener; }
-    setThreadId(id) {
-        if (this.threadId === id)
-            return;
-        this.threadId = id;
-        this.threadListener?.(id);
-    }
-    stop() {
-        this.closed = true;
-        this.clearTurnTimeout();
-        this.ws?.close();
-        this.ws = null;
-    }
-    push(line) {
-        if (this.queue.length >= MAX_QUEUE) {
-            log.warn({ url: this.url }, 'codex-rc queue full, dropping oldest');
-            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;
-            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());
-            const clientInfo = { name: 'metro', version: this.clientVersion, title: null };
-            await this.call('initialize', { clientInfo });
-            this.setThreadId(await this.pickOrCreateThread());
-            this.connected = true;
-            log.info({ url: this.url, thread: this.threadId ?? '(none yet)' }, 'codex-rc connected');
-            void this.drainQueue();
-        }
-        catch (err) {
-            log.warn({ err: errMsg(err), url: this.url }, '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;
-        }
-        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;
-        }
-        switch (msg.method) {
-            case 'thread/started': {
-                const id = msg.params?.thread?.id;
-                if (id) {
-                    this.setThreadId(id);
-                    log.info({ thread: id }, 'codex-rc thread started');
-                    void this.drainQueue();
-                }
-                break;
-            }
-            case 'thread/status/changed': {
-                /* Codex 0.130+: status `{active}` means in-flight; anything else is idle. */
-                const p = msg.params;
-                if (p?.threadId !== this.threadId)
-                    break;
-                const active = typeof p.status === 'object' && p.status !== null && 'active' in p.status;
-                if (active)
-                    this.turnInFlight = true;
-                else {
-                    this.clearTurnTimeout();
-                    this.turnInFlight = false;
-                    void this.drainQueue();
-                }
-                break;
-            }
-            case 'turn/completed':
-                this.clearTurnTimeout();
-                this.turnInFlight = false;
-                void this.drainQueue();
-                break;
-            case 'turn/started':
-                this.turnInFlight = true;
-                break;
-            case 'thread/closed':
-            case 'thread/archived':
-                log.warn({ method: msg.method }, 'codex-rc thread closed/archived');
-                this.setThreadId(null);
-                break;
-        }
-    }
-    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);
-    }
-    /** Prefer the most-recently-loaded thread (the TUI's if attached); else create our own. */
-    async pickOrCreateThread() {
-        try {
-            const loaded = await this.call('thread/loaded/list', {});
-            const existing = loaded.data?.[loaded.data.length - 1];
-            if (existing)
-                return existing;
-        }
-        catch (err) {
-            log.warn({ err: errMsg(err) }, 'codex-rc thread/loaded/list failed');
-        }
-        try {
-            const created = await this.call('thread/start', {});
-            return created.thread?.id ?? null;
-        }
-        catch (err) {
-            log.warn({ err: errMsg(err) }, 'codex-rc thread/start failed');
-            return null;
-        }
-    }
-    async drainQueue() {
-        if (!this.connected || this.turnInFlight || !this.queue.length)
-            return;
-        if (!this.threadId) {
-            this.setThreadId(await this.pickOrCreateThread());
-            if (!this.threadId)
-                return;
-        }
-        const line = this.queue[0];
-        this.turnInFlight = true;
-        this.armTurnTimeout();
-        try {
-            const input = [{ type: 'text', text: line, textElements: [] }];
-            await this.call('turn/start', { threadId: this.threadId, input });
-            this.queue.shift();
-        }
-        catch (err) {
-            const dead = errMsg(err).includes('thread not found');
-            log.warn({ err: errMsg(err) }, dead ? 'codex-rc thread gone; will create a new one' : 'codex-rc turn/start failed; will retry');
-            this.clearTurnTimeout();
-            this.turnInFlight = false;
-            if (dead)
-                this.setThreadId(null);
-            setTimeout(() => void this.drainQueue(), 1_000);
-        }
-    }
-    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 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/dispatcher.js

@@ -1,128 +0,0 @@
-/**
- * Daemon: chat inbound → JSON on stdout; optional codex-rc push; cross-user `notify` over Unix socket.
- */
-import { copyFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import pkg from '../package.json' with { type: 'json' };
-import { DiscordStation } from './stations/discord.js';
-import { TelegramStation } from './stations/telegram.js';
-import { WebhookStation } from './stations/webhook.js';
-import { asLine, Line } from './stations/index.js';
-import { CodexRC } from './codex-rc.js';
-import { startIpcServer, stopIpcServer } from './ipc.js';
-import { userSelf, appendHistory, formatDisplay, mintId, selfLine } from './history.js';
-import { noteSeen, saveBotId } from './cache.js';
-import { errMsg, log } from './log.js';
-import { acquireLock, configuredPlatforms, loadMetroEnv, STATE_DIR, requireConfiguredPlatform } from './paths.js';
-import { setCodexSessionId } from './stations/codex.js';
-import { noteUserFromLine } from './registry.js';
-import { listEndpoints, webhookPort } from './webhooks.js';
-import { loadTunnelConfig, Tunnel } from './tunnel.js';
-loadMetroEnv();
-const platforms = configuredPlatforms();
-const endpoints = listEndpoints();
-requireConfiguredPlatform(platforms, endpoints.length > 0);
-acquireLock(join(STATE_DIR, '.tail-lock'));
-// Fail fast if launched from Claude Code without a logged-in account.
-const self = userSelf();
-log.info({ self, line: selfLine() }, 'user identity');
-const seedSelf = () => { const l = selfLine(); if (l)
-    noteUserFromLine(l); };
-seedSelf();
-const USERS_MD = join(STATE_DIR, 'USERS.md');
-try {
-    copyFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'docs', 'users.md'), USERS_MD);
-}
-catch (err) {
-    log.warn({ err: errMsg(err), path: USERS_MD }, 'failed to install user skill');
-}
-/** Suppress EPIPE so the daemon survives the user (Monitor reader) restarting / dying. */
-process.stdout.on('error', err => {
-    if (err.code !== 'EPIPE')
-        log.warn({ err: errMsg(err) }, 'stdout error');
-});
-const codexRc = process.env.METRO_CODEX_RC ? new CodexRC(process.env.METRO_CODEX_RC, pkg.version) : null;
-codexRc?.onThread(id => { setCodexSessionId(id); seedSelf(); });
-codexRc?.start();
-const discord = new DiscordStation();
-const telegram = new TelegramStation();
-const webhook = new WebhookStation();
-const tunnelCfg = loadTunnelConfig();
-const tunnel = tunnelCfg ? new Tunnel(tunnelCfg, webhookPort()) : null;
-function emit(entry) {
-    /** `display` first so it survives Monitor's ~500-char body truncation — the user must see it to echo it. */
-    const enriched = { display: formatDisplay(entry), ...entry };
-    const json = JSON.stringify(enriched);
-    process.stdout.write(json + '\n');
-    codexRc?.push(json);
-    noteSeen(entry.line, entry.lineName);
-    for (const l of [entry.line, entry.from, entry.to])
-        if (l)
-            noteUserFromLine(l);
-    appendHistory(enriched);
-}
-const destinationFor = (m) => m.isPrivate ? userSelf() : m.line;
-const onInbound = (m) => emit({ ...m, kind: 'inbound', to: destinationFor(m) });
-const onReaction = (r) => emit({ ...r, kind: 'react', to: destinationFor(r) });
-const ipc = startIpcServer(async (req) => {
-    if (req.op === 'notify') {
-        const line = asLine(req.line);
-        emit({
-            id: mintId(), ts: new Date().toISOString(), kind: 'inbound',
-            station: Line.station(line) ?? '?', line,
-            from: req.from ? asLine(req.from) : userSelf(), to: line, text: req.text,
-        });
-        return { ok: true };
-    }
-    if (req.op === 'download') {
-        const line = asLine(req.line);
-        const station = req.line.startsWith('metro://telegram/') ? telegram : discord;
-        const files = await station.download(line, req.messageId, req.outDir);
-        return { ok: true, files };
-    }
-    return { ok: false, error: 'unknown op' };
-});
-async function main() {
-    if (platforms.discord) {
-        discord.onMessage(onInbound);
-        discord.onReaction(onReaction);
-        const [, me] = await Promise.all([discord.start(), discord.getMe()]);
-        saveBotId('discord', me.id);
-        log.info({ bot: me.username }, 'discord ready');
-    }
-    if (platforms.telegram) {
-        telegram.onMessage(onInbound);
-        telegram.onReaction(onReaction);
-        const [me] = await Promise.all([telegram.getMe(), telegram.start()]);
-        saveBotId('telegram', String(me.id));
-        log.info({ bot: `@${me.username}` }, 'telegram ready');
-    }
-    /** Start the HTTP receiver only when ≥1 endpoint is registered — no point binding a port nobody listens to. */
-    if (endpoints.length) {
-        webhook.onMessage(onInbound);
-        await webhook.start();
-        tunnel?.start();
-    }
-    log.info({ codexRc: !!codexRc, tunnel: !!tunnel }, 'dispatcher ready');
-}
-let shuttingDown = false;
-async function shutdown() {
-    if (shuttingDown)
-        return;
-    shuttingDown = true;
-    log.info('dispatcher shutting down');
-    codexRc?.stop();
-    tunnel?.stop();
-    await stopIpcServer(ipc).catch(() => { });
-    await webhook.stop().catch(() => { });
-    if (platforms.discord)
-        await discord.stop().catch(() => { });
-    if (platforms.telegram)
-        await telegram.stop().catch(() => { });
-    process.exit(0);
-}
-process.stdin.on('end', shutdown).on('close', shutdown);
-for (const sig of ['SIGINT', 'SIGTERM'])
-    process.on(sig, shutdown);
-await main();

package/dist/history.js

@@ -1,121 +0,0 @@
-/** Append-only JSONL history of every message that flows through metro (inbound + outbound). */
-import { randomBytes } from 'node:crypto';
-import { appendFileSync, existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { errMsg, log } from './log.js';
-import { STATE_DIR } from './paths.js';
-import { Line } from './stations/index.js';
-import { claudeUserId, claudeSessionId } from './stations/claude.js';
-import { codexUserId, codexSessionId } from './stations/codex.js';
-/** Pre-render a chat-bubble line — the user echoes `event.display` verbatim instead of composing markdown itself. */
-export function formatDisplay(e) {
-    const headerFor = (icon, parts) => `**${icon} ${parts.filter(Boolean).join(' · ')}**`;
-    const body = e.text ?? (e.emoji ? `[react ${e.emoji}]` : '');
-    if (e.kind === 'inbound' && e.station === 'webhook') {
-        const ev = e.payload
-            ?.headers?.['x-github-event'] ?? e.payload
-            ?.headers?.['x-intercom-topic'];
-        return `${headerFor('🪝', ['webhook', e.lineName, ev])}\n> ${body}`;
-    }
-    if (e.kind === 'inbound' || (e.kind === 'react' && !Line.isLocal(e.from))) {
-        const reactBody = e.kind === 'react' ? `reacted ${e.emoji ?? ''}`.trim() : body;
-        return `${headerFor('📩', [e.station, e.fromName ?? e.from, e.lineName])}\n> ${reactBody}`;
-    }
-    return `${headerFor('📤', [e.station, '→', e.fromName ?? e.to])}\n> ${body}`;
-}
-const FILE = join(STATE_DIR, 'history.jsonl');
-/** Mint a universal metro message ID. Short, prefixed, URL-safe. */
-export const mintId = () => `msg_${randomBytes(6).toString('base64url')}`;
-/** Append one entry as a JSON line. POSIX-atomic for sub-PIPE_BUF writes (we're well under). */
-export function appendHistory(entry) {
-    try {
-        appendFileSync(FILE, JSON.stringify(entry) + '\n');
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err), path: FILE }, 'history append failed');
-    }
-}
-/** Read JSONL, parse, filter (most-recent-first), apply `skip` then `limit`. Empty array if file is missing. */
-export function readHistory(filter = {}) {
-    if (!existsSync(FILE))
-        return [];
-    const lines = readFileSync(FILE, 'utf8').split('\n');
-    const out = [];
-    const skip = filter.skip ?? 0;
-    let skipped = 0;
-    /** Walk backwards so `limit` clamps without scanning the whole file body twice. */
-    for (let i = lines.length - 1; i >= 0; i--) {
-        const raw = lines[i].trim();
-        if (!raw)
-            continue;
-        let e;
-        try {
-            e = JSON.parse(raw);
-        }
-        catch {
-            continue;
-        }
-        if (!matches(e, filter))
-            continue;
-        if (skipped < skip) {
-            skipped++;
-            continue;
-        }
-        out.push(e);
-        if (filter.limit && out.length >= filter.limit)
-            break;
-    }
-    return out;
-}
-function matches(e, f) {
-    if (f.line && e.line !== f.line)
-        return false;
-    if (f.station && e.station !== f.station)
-        return false;
-    if (f.kind && e.kind !== f.kind)
-        return false;
-    if (f.from && e.from !== f.from)
-        return false;
-    if (f.textContains && !(e.text ?? '').toLowerCase().includes(f.textContains.toLowerCase()))
-        return false;
-    if (f.since && new Date(e.ts) < f.since)
-        return false;
-    return true;
-}
-/** Find an entry by universal id OR platform message id. */
-export function lookupEntry(id) {
-    const entries = readHistory({ limit: 5_000 });
-    return entries.find(e => e.id === id || e.messageId === id);
-}
-/** Look up the platform messageId for a universal `msg_*` id; returns the input unchanged otherwise. */
-export function resolvePlatformId(id) {
-    if (!id.startsWith('msg_'))
-        return id;
-    const hit = lookupEntry(id);
-    if (hit?.messageId)
-        return hit.messageId;
-    throw new Error(`unknown universal id: ${id} (run \`metro history --limit=50\` to see recent ids)`);
-}
-/** The current user's **participant** URI for `from`/`to`. Precedence: METRO_FROM > runtime env > generic. */
-export function userSelf() {
-    const explicit = process.env.METRO_FROM;
-    if (explicit)
-        return explicit;
-    if (process.env.CLAUDECODE)
-        return Line.user('claude', claudeUserId());
-    if (process.env.METRO_CODEX_RC || process.env.CODEX_HOME)
-        return Line.user('codex', codexUserId());
-    return 'metro://user';
-}
-/** The current user's **line** URI `<user-id>/<session>`. Null until session is known (rc thread pending). */
-export function selfLine() {
-    if (process.env.CLAUDECODE) {
-        const s = claudeSessionId();
-        return s ? Line.claude(claudeUserId(), s) : null;
-    }
-    if (process.env.METRO_CODEX_RC || process.env.CODEX_HOME) {
-        const s = codexSessionId();
-        return s ? Line.codex(codexUserId(), s) : null;
-    }
-    return null;
-}

package/dist/ipc.js

@@ -1,72 +0,0 @@
-/** Unix-socket IPC: `notify` re-emits on daemon stdout; `download` resolves Telegram attachments. */
-import { createConnection, createServer } from 'node:net';
-import { existsSync, unlinkSync } from 'node:fs';
-import { join } from 'node:path';
-import { errMsg, log } from './log.js';
-import { STATE_DIR } from './paths.js';
-const SOCKET_PATH = join(STATE_DIR, 'metro.sock');
-export function startIpcServer(handler) {
-    if (existsSync(SOCKET_PATH)) {
-        try {
-            unlinkSync(SOCKET_PATH);
-        }
-        catch { /* ignore */ }
-    }
-    /** allowHalfOpen: any `await` in the handler races Node's auto-end-on-client-FIN, dropping the response. */
-    const server = createServer({ allowHalfOpen: true }, s => handleConnection(s, handler));
-    server.on('error', err => log.warn({ err: errMsg(err) }, 'ipc server error'));
-    server.listen(SOCKET_PATH, () => log.debug({ path: SOCKET_PATH }, 'ipc socket listening'));
-    return server;
-}
-export async function stopIpcServer(server) {
-    await new Promise(resolve => server.close(() => resolve()));
-    try {
-        if (existsSync(SOCKET_PATH))
-            unlinkSync(SOCKET_PATH);
-    }
-    catch { /* ignore */ }
-}
-async function handleConnection(socket, handler) {
-    let buf = '';
-    socket.setEncoding('utf8');
-    socket.on('data', chunk => { buf += chunk; });
-    socket.on('end', async () => {
-        let resp;
-        try {
-            const req = JSON.parse(buf.trim());
-            resp = await handler(req);
-        }
-        catch (err) {
-            resp = { ok: false, error: errMsg(err) };
-        }
-        socket.end(JSON.stringify(resp) + '\n');
-    });
-    socket.on('error', err => log.debug({ err: errMsg(err) }, 'ipc connection error'));
-}
-/** CLI-side: send one request, get one response. Throws if the daemon isn't running. */
-export function ipcCall(req, timeoutMs = 30_000) {
-    return new Promise((resolve, reject) => {
-        if (!existsSync(SOCKET_PATH)) {
-            reject(new Error('metro daemon is not running (start it with `metro`)'));
-            return;
-        }
-        const socket = createConnection({ path: SOCKET_PATH });
-        let buf = '';
-        const timer = setTimeout(() => {
-            socket.destroy();
-            reject(new Error(`ipc timeout after ${timeoutMs}ms`));
-        }, timeoutMs);
-        socket.on('connect', () => { socket.end(JSON.stringify(req)); });
-        socket.on('data', chunk => { buf += chunk.toString('utf8'); });
-        socket.on('end', () => {
-            clearTimeout(timer);
-            try {
-                resolve(JSON.parse(buf.trim()));
-            }
-            catch (err) {
-                reject(new Error(`ipc bad response: ${errMsg(err)}`));
-            }
-        });
-        socket.on('error', err => { clearTimeout(timer); reject(err); });
-    });
-}

package/dist/log.js

@@ -1,15 +0,0 @@
-/** Pino → stderr. TTY → pino-pretty (colorized, hostname/pid stripped); else JSON. */
-import pino from 'pino';
-import pinoPretty from 'pino-pretty';
-const stream = process.stderr.isTTY
-    ? pinoPretty({ colorize: true, translateTime: 'HH:MM:ss', ignore: 'pid,hostname,name', destination: 2 })
-    : pino.destination(2);
-/** `base: { name }` strips pino's default pid+hostname from JSON output too (not just from the TTY pretty stream). */
-export const log = pino({ base: { name: 'metro' }, level: process.env.METRO_LOG_LEVEL || 'info' }, stream);
-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);
-};