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

package/dist/agents/codex.js

@@ -1,207 +0,0 @@
-/** Codex adapter: spawns `codex app-server` over UDS WebSocket; one thread/scope, streams turn events. */
-import { spawn } from 'node:child_process';
-import { existsSync, unlinkSync } from 'node:fs';
-import { createConnection } from 'node:net';
-import { join } from 'node:path';
-import { WebSocket } from 'ws';
-import { errMsg, log } from '../log.js';
-import { STATE_DIR } from '../paths.js';
-const SOCKET_PATH = join(STATE_DIR, 'codex-app-server.sock');
-const READY_TIMEOUT_MS = 15_000;
-const READY_POLL_MS = 100;
-export class CodexAgent {
-    clientVersion;
-    ws = null;
-    daemon = null;
-    nextId = 1;
-    pending = new Map();
-    turnCallbacks = new Map();
-    constructor(clientVersion) {
-        this.clientVersion = clientVersion;
-    }
-    async start() {
-        await this.checkCodexInstalled();
-        try {
-            unlinkSync(SOCKET_PATH);
-        }
-        catch { /* missing is fine */ }
-        log.info({ socket: SOCKET_PATH }, 'codex agent: starting app-server');
-        this.daemon = spawn('codex', ['app-server', '--listen', `unix://${SOCKET_PATH}`], { stdio: ['ignore', 'pipe', 'pipe'] });
-        let bootStderr = '';
-        let daemonExited = false;
-        let daemonExitCode = null;
-        this.daemon.stdout?.on('data', d => log.trace({ src: 'codex-stdout' }, String(d).trim()));
-        this.daemon.stderr?.on('data', (d) => { bootStderr += String(d); log.trace({ src: 'codex-stderr' }, String(d).trim()); });
-        this.daemon.on('exit', code => { daemonExited = true; daemonExitCode = code; log.warn({ code }, 'codex daemon exited'); });
-        try {
-            await this.waitForSocket(() => daemonExited, () => bootStderr.trim() || `exit code ${daemonExitCode}`);
-            await this.connect();
-        }
-        catch (err) {
-            const detail = bootStderr.trim() ? ` (codex stderr: ${bootStderr.trim().slice(0, 200)})` : '';
-            throw new Error(`${errMsg(err)}${detail}`);
-        }
-        log.info('codex agent: ready');
-    }
-    async checkCodexInstalled() {
-        await new Promise((resolve, reject) => {
-            const c = spawn('codex', ['--version'], { stdio: ['ignore', 'ignore', 'pipe'] });
-            let stderr = '';
-            c.stderr?.on('data', d => { stderr += String(d); });
-            c.on('error', err => reject(new Error(`codex CLI not found on PATH: ${errMsg(err)}`)));
-            c.on('exit', code => code === 0 ? resolve() : reject(new Error(`codex --version exited ${code}: ${stderr.trim()}`)));
-        });
-    }
-    async stop() {
-        this.ws?.close();
-        this.ws = null;
-        this.daemon?.kill('SIGTERM');
-        this.daemon = null;
-    }
-    async createThread() {
-        const result = await this.call('thread/start', {});
-        log.info({ thread: result.thread.id }, 'codex agent: thread created');
-        return result.thread.id;
-    }
-    async sendTurn(threadId, text, callbacks) {
-        this.turnCallbacks.set(threadId, callbacks);
-        try {
-            /** `text_elements` is snake_case per codex's generated bindings. */
-            await this.call('turn/start', { threadId, input: [{ type: 'text', text, text_elements: [] }] });
-        }
-        catch (err) {
-            this.turnCallbacks.delete(threadId);
-            callbacks.onError(err instanceof Error ? err : new Error(String(err)));
-        }
-    }
-    async waitForSocket(exited, exitReason) {
-        const deadline = Date.now() + READY_TIMEOUT_MS;
-        while (Date.now() < deadline) {
-            if (exited())
-                throw new Error(`codex app-server exited before listening: ${exitReason()}`);
-            if (existsSync(SOCKET_PATH))
-                return;
-            await new Promise(r => setTimeout(r, READY_POLL_MS));
-        }
-        throw new Error(`codex app-server didn't appear at ${SOCKET_PATH} within ${READY_TIMEOUT_MS}ms`);
-    }
-    /** perMessageDeflate disabled: codex 0.130 closes connections offering it. */
-    async connect() {
-        const ws = new WebSocket('ws://localhost/', {
-            perMessageDeflate: false,
-            createConnection: () => {
-                const sock = createConnection({ path: SOCKET_PATH });
-                sock.on('error', err => log.warn({ err: errMsg(err) }, 'codex agent: socket error'));
-                return sock;
-            },
-        });
-        this.ws = ws;
-        ws.on('error', err => log.warn({ err: errMsg(err) }, 'codex agent: websocket error'));
-        await new Promise((resolve, reject) => { ws.once('open', () => resolve()); ws.once('error', reject); });
-        ws.on('message', data => this.onMessage(data));
-        ws.on('close', () => { log.warn('codex agent: websocket closed'); this.ws = null; this.drainPending('codex websocket closed'); });
-        await this.call('initialize', { clientInfo: { name: 'metro', version: this.clientVersion, title: null } });
-    }
-    onMessage(raw) {
-        let msg;
-        try {
-            msg = JSON.parse(raw.toString());
-        }
-        catch (err) {
-            log.warn({ err: errMsg(err) }, 'codex agent: 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;
-        }
-        if (!msg.method)
-            return;
-        log.trace({ method: msg.method }, 'codex agent: notification');
-        const threadId = msg.params?.threadId;
-        if (!threadId)
-            return;
-        const cb = this.turnCallbacks.get(threadId);
-        if (!cb)
-            return;
-        if (msg.method === 'item/agentMessage/delta') {
-            cb.onDelta(msg.params.delta);
-        }
-        else if (msg.method === 'item/started') {
-            const a = summarizeItem(msg.params.item);
-            if (a)
-                cb.onToolStart(a);
-        }
-        else if (msg.method === 'item/completed') {
-            const item = msg.params.item;
-            if (item.type !== 'agentMessage' && item.type !== 'userMessage')
-                cb.onToolEnd(item.id, itemOutput(item));
-        }
-        else if (msg.method === 'thread/status/changed') {
-            /** codex 0.130: `thread/status=idle` is the dependable completion signal. */
-            const status = msg.params.status?.type;
-            if (status === 'idle') {
-                this.turnCallbacks.delete(threadId);
-                cb.onComplete();
-            }
-            else if (status === 'systemError') {
-                this.turnCallbacks.delete(threadId);
-                cb.onError(new Error('codex thread entered systemError'));
-            }
-        }
-        else if (msg.method === 'turn/completed') {
-            this.turnCallbacks.delete(threadId);
-            cb.onComplete();
-        }
-        else if (msg.method === 'error') {
-            this.turnCallbacks.delete(threadId);
-            cb.onError(new Error(msg.params.error?.message ?? 'codex error notification'));
-        }
-    }
-    call(method, params) {
-        if (!this.ws)
-            return Promise.reject(new Error('codex agent: 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 }));
-        });
-    }
-    drainPending(reason) {
-        const err = new Error(reason);
-        for (const cb of this.turnCallbacks.values()) {
-            try {
-                cb.onError(err);
-            }
-            catch (e) {
-                log.warn({ err: errMsg(e) }, 'codex agent: drain callback threw');
-            }
-        }
-        this.turnCallbacks.clear();
-        for (const p of this.pending.values())
-            p.reject(err);
-        this.pending.clear();
-    }
-}
-function summarizeItem(item) {
-    const id = item.id;
-    if (item.type === 'commandExecution' && 'command' in item) {
-        return { id, kind: 'commandExecution', name: 'Bash', detail: item.command || undefined };
-    }
-    if (item.type === 'fileChange' && 'changes' in item) {
-        const paths = (item.changes ?? []).map(c => c.path).filter((p) => !!p);
-        return { id, kind: 'fileChange', name: 'Edit', detail: paths.length === 1 ? paths[0] : paths.length ? `${paths.length} files` : undefined };
-    }
-    if (item.type === 'reasoning')
-        return { id, kind: 'reasoning', name: 'Thinking…', transient: true };
-    if (item.type === 'agentMessage' || item.type === 'userMessage')
-        return null;
-    return { id, kind: item.type, name: item.type };
-}
-const itemOutput = (item) => item.type === 'commandExecution' && 'output' in item ? item.output?.trim() || undefined : undefined;

package/dist/agents/types.js

@@ -1,2 +0,0 @@
-/** Shared interface across agent backends (Codex, Claude Code). */
-export {};

package/dist/channels/discord.js

@@ -1,104 +0,0 @@
-import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
-import { errMsg, log } from '../log.js';
-/** Receive: discord.js gateway. Send: raw REST so non-orchestrator callers stay one-shot. */
-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, retriesLeft = 2) {
-    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),
-    });
-    /** 429: honor `retry_after` (seconds) and retry, up to a few hops. */
-    if (res.status === 429 && retriesLeft > 0) {
-        const retryAfter = Number(res.headers.get('retry-after')) || 1;
-        log.debug({ path, retryAfter }, 'discord 429; backing off');
-        await new Promise(r => setTimeout(r, Math.max(retryAfter * 1000, 250)));
-        return rest(method, path, body, timeoutMs, retriesLeft - 1);
-    }
-    if (!res.ok) {
-        const text = await res.text().catch(() => '');
-        throw new Error(`discord ${method} ${path}: ${res.status} ${text}`);
-    }
-    if (res.status === 204)
-        return undefined;
-    return (await res.json());
-}
-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 const 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;
-        /** Forward every human message; orchestrator decides routing. @-mention stays in content. */
-        const tags = [...m.attachments.values()].map(a => a.contentType?.startsWith('image/') ? '[image]'
-            : a.contentType?.startsWith('audio/') ? `[audio: ${a.name}]`
-                : `[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,
-            in_guild: !!m.guildId,
-            mentions_bot: c.user ? m.mentions.has(c.user.id) : false,
-        });
-    });
-    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 };
-}
-/** SUPPRESS_EMBEDS (1 << 2) — strip link unfurls from every bot message. */
-const SUPPRESS_EMBEDS = 1 << 2;
-export async function sendMessage(channelId, text) {
-    const sent = await rest('POST', `/channels/${channelId}/messages`, { content: text, flags: SUPPRESS_EMBEDS });
-    return sent.id;
-}
-/** Public thread anchored on `messageId`. Returns the new thread channel id. */
-export async function createThreadFromMessage(channelId, messageId, name) {
-    const created = await rest('POST', `/channels/${channelId}/messages/${messageId}/threads`, { name, auto_archive_duration: 1440 });
-    return created.id;
-}
-export async function editMessage(channelId, messageId, text) {
-    const sent = await rest('PATCH', `/channels/${channelId}/messages/${messageId}`, { content: text, flags: SUPPRESS_EMBEDS });
-    return sent.id;
-}
-/** Catchup-on-restart: fetch messages newer than `afterMessageId` (cap 100). */
-export async function fetchMessagesSince(channelId, afterMessageId) {
-    const msgs = await rest('GET', `/channels/${channelId}/messages?after=${afterMessageId}&limit=100`);
-    /** Discord returns newest-first; flip to chronological for replay. */
-    return [...msgs].reverse().map(m => ({ message_id: m.id, text: m.content, author_id: m.author.id, author_is_bot: !!m.author.bot }));
-}

package/dist/channels/telegram.js

@@ -1,189 +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';
-import { mdToTelegramHtml } from '../helpers/telegram-format.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;
-}
-async function tg(method, body, opts = {}) {
-    const signals = [AbortSignal.timeout(opts.timeoutMs ?? 30_000)];
-    if (opts.signal)
-        signals.push(opts.signal);
-    const res = await fetch(`${API_BASE}/bot${token()}/${method}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-        signal: AbortSignal.any(signals),
-    });
-    const json = (await res.json());
-    if (!json.ok)
-        throw new Error(`telegram ${method}: ${json.description ?? 'unknown error'}`);
-    return json.result;
-}
-let botUsername = null;
-let botUserId = null;
-export async function getMe() {
-    const me = await tg('getMe', {});
-    botUsername = me.username;
-    botUserId = me.id;
-    return me;
-}
-let onInboundHandler = () => { };
-export const onInbound = (handler) => { onInboundHandler = handler; };
-const offsetFile = join(STATE_DIR, 'telegram-offset.json');
-let pollOffset = 0;
-let pollAbort = null;
-function loadOffset() {
-    try {
-        return existsSync(offsetFile) ? Number(readFileSync(offsetFile, 'utf8').trim()) || 0 : 0;
-    }
-    catch {
-        return 0;
-    }
-}
-function saveOffset(o) {
-    try {
-        writeFileSync(offsetFile, String(o));
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err) }, 'telegram offset save failed');
-    }
-}
-export async function startPolling() {
-    await tg('deleteWebhook', { drop_pending_updates: false }).catch(() => { });
-    const persisted = loadOffset();
-    if (persisted > 0) {
-        pollOffset = persisted;
-        log.info({ offset: pollOffset }, 'telegram polling: resuming from persisted offset');
-    }
-    else {
-        /** First run: anchor on latest update id (-1 returns most recent without consuming). */
-        const initial = await tg('getUpdates', { offset: -1, timeout: 0 });
-        pollOffset = initial.length ? initial[0].update_id + 1 : 0;
-        saveOffset(pollOffset);
-        log.info({ offset: pollOffset }, 'telegram polling: starting fresh');
-    }
-    pollAbort = new AbortController();
-    void pollLoop();
-}
-async function pollLoop() {
-    const abortSignal = pollAbort?.signal;
-    while (pollAbort && !pollAbort.signal.aborted) {
-        try {
-            const updates = await tg('getUpdates', { offset: pollOffset, timeout: 25 }, { timeoutMs: 60_000, signal: abortSignal });
-            for (const u of updates) {
-                pollOffset = u.update_id + 1;
-                await dispatchUpdate(u);
-            }
-            if (updates.length)
-                saveOffset(pollOffset);
-        }
-        catch (err) {
-            if (pollAbort?.signal.aborted)
-                break;
-            log.warn({ err: errMsg(err) }, 'telegram poll error; backing off');
-            await new Promise(r => setTimeout(r, 2000));
-        }
-    }
-    log.info('telegram polling stopped');
-}
-export async function shutdownPolling() { pollAbort?.abort(); pollAbort = null; }
-async function dispatchUpdate(u) {
-    const m = u.message;
-    if (!m?.chat?.id || typeof m.message_id !== 'number' || m.from?.is_bot)
-        return;
-    const text = messageToText(m);
-    if (!text)
-        return;
-    onInboundHandler({
-        chat_id: m.chat.id,
-        message_id: m.message_id,
-        message_thread_id: m.is_topic_message ? m.message_thread_id : undefined,
-        text,
-        is_private: m.chat.type === 'private',
-        is_forum_topic: !!m.is_topic_message,
-        in_forum: !!m.chat.is_forum,
-        mentions_bot: detectMentionsBot(m),
-    });
-}
-function detectMentionsBot(m) {
-    if (m.chat?.type === 'private')
-        return true;
-    const text = m.text ?? m.caption ?? '';
-    for (const e of m.entities ?? m.caption_entities ?? []) {
-        if (e.type === 'mention' && botUsername) {
-            if (text.substring(e.offset, e.offset + e.length).toLowerCase() === `@${botUsername.toLowerCase()}`)
-                return true;
-        }
-        else if (e.type === 'text_mention' && e.user?.id === botUserId)
-            return true;
-    }
-    return false;
-}
-function messageToText(m) {
-    if (m.text)
-        return m.text;
-    const caption = m.caption ?? '';
-    if (m.photo?.length || m.document?.mime_type?.startsWith('image/'))
-        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;
-}
-/** Create a forum topic; requires `can_manage_topics` admin permission. */
-export async function createForumTopic(chatId, name) {
-    const r = await tg('createForumTopic', { chat_id: chatId, name: name.slice(0, 128) || 'metro' });
-    return r.message_thread_id;
-}
-/** Deep link `t.me/c/<id>/<topic>`; strips supergroup's `-100` prefix from chat id. */
-export function topicLink(chatId, topicId) {
-    const id = String(Math.abs(chatId)).replace(/^100/, '');
-    return `https://t.me/c/${id}/${topicId}`;
-}
-const isParseError = (err) => errMsg(err).includes("can't parse entities");
-const NO_PREVIEW = { link_preview_options: { is_disabled: true } };
-/** Send agent-style markdown as Telegram HTML, falling back to plain text on parse errors. */
-export async function sendMessage(chatId, threadId, text, replyToMessageId) {
-    const base = { chat_id: chatId, ...NO_PREVIEW };
-    if (threadId !== undefined)
-        base.message_thread_id = threadId;
-    if (replyToMessageId !== undefined)
-        base.reply_parameters = { message_id: replyToMessageId };
-    try {
-        return (await tg('sendMessage', { ...base, text: mdToTelegramHtml(text), parse_mode: 'HTML' })).message_id;
-    }
-    catch (err) {
-        if (!isParseError(err))
-            throw err;
-        log.warn({ err: errMsg(err) }, 'telegram: HTML rejected, sending plain');
-        return (await tg('sendMessage', { ...base, text })).message_id;
-    }
-}
-export async function editMessageText(chatId, messageId, text) {
-    const base = { chat_id: chatId, message_id: messageId, ...NO_PREVIEW };
-    const swallow = (err) => { if (!errMsg(err).includes('message is not modified'))
-        throw err; };
-    try {
-        await tg('editMessageText', { ...base, text: mdToTelegramHtml(text), parse_mode: 'HTML' });
-    }
-    catch (err) {
-        if (errMsg(err).includes('message is not modified'))
-            return;
-        if (!isParseError(err))
-            throw err;
-        log.warn({ err: errMsg(err) }, 'telegram: HTML edit rejected, retrying plain');
-        try {
-            await tg('editMessageText', { ...base, text });
-        }
-        catch (e) {
-            swallow(e);
-        }
-    }
-}

package/dist/helpers/scope-cache.js

@@ -1,65 +0,0 @@
-/** Per-machine scope→{thread ids,last-used} cache. Keys: `discord:<id>` / `telegram:<chat>:<topic>`. */
-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 cacheFile = join(STATE_DIR, 'scopes.json');
-function read() {
-    if (!existsSync(cacheFile))
-        return {};
-    try {
-        return JSON.parse(readFileSync(cacheFile, 'utf8'));
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err), path: cacheFile }, 'scope cache read failed; treating as empty');
-        return {};
-    }
-}
-function write(cache) {
-    try {
-        writeFileSync(cacheFile, JSON.stringify(cache, null, 2));
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err), path: cacheFile }, 'scope cache write failed');
-    }
-}
-function ensure(cache, scopeKey) {
-    if (!cache[scopeKey])
-        cache[scopeKey] = { createdAt: new Date().toISOString(), agents: {} };
-    if (!cache[scopeKey].agents)
-        cache[scopeKey].agents = {};
-    return cache[scopeKey];
-}
-export function getAgentThread(scopeKey, kind) {
-    return read()[scopeKey]?.agents?.[kind];
-}
-export function setAgentThread(scopeKey, kind, threadId) {
-    const cache = read();
-    const entry = ensure(cache, scopeKey);
-    entry.agents[kind] = threadId;
-    entry.lastAgent = kind;
-    write(cache);
-}
-export function getLastAgent(scopeKey) {
-    return read()[scopeKey]?.lastAgent;
-}
-export function setLastAgent(scopeKey, kind) {
-    const cache = read();
-    if (!cache[scopeKey])
-        return;
-    cache[scopeKey].lastAgent = kind;
-    write(cache);
-}
-export function setLastSeen(scopeKey, messageId) {
-    const cache = read();
-    if (!cache[scopeKey])
-        return;
-    cache[scopeKey].lastSeenMessageId = messageId;
-    write(cache);
-}
-export function listScopes() {
-    return Object.entries(read()).map(([scopeKey, entry]) => ({ scopeKey, entry }));
-}
-export const discordScopeKey = (threadChannelId) => `discord:${threadChannelId}`;
-export const discordChannelFromScopeKey = (scopeKey) => scopeKey.startsWith('discord:') ? scopeKey.slice('discord:'.length) : null;
-export const telegramScopeKey = (chatId, topicId) => `telegram:${chatId}:${topicId ?? 'main'}`;