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

package/dist/agents/claude.js

@@ -1,207 +0,0 @@
-/** Claude Code adapter: per-turn `claude -p` subprocess; --session-id then --resume (persisted across restarts). */
-import { spawn } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
-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 STARTED_FILE = join(STATE_DIR, 'claude-sessions.json');
-function loadStarted() {
-    if (!existsSync(STARTED_FILE))
-        return new Set();
-    try {
-        return new Set(JSON.parse(readFileSync(STARTED_FILE, 'utf8')));
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err), path: STARTED_FILE }, 'claude: started cache read failed');
-        return new Set();
-    }
-}
-export class ClaudeAgent {
-    started = loadStarted();
-    children = new Set();
-    persistStarted() {
-        try {
-            writeFileSync(STARTED_FILE, JSON.stringify([...this.started]));
-        }
-        catch (err) {
-            log.warn({ err: errMsg(err), path: STARTED_FILE }, 'claude: started cache write failed');
-        }
-    }
-    async start() {
-        await new Promise((resolve, reject) => {
-            const c = spawn('claude', ['--version'], { stdio: ['ignore', 'pipe', 'pipe'] });
-            let out = '';
-            c.stdout.on('data', d => { out += String(d); });
-            c.on('error', reject);
-            c.on('exit', code => {
-                if (code === 0) {
-                    log.info({ version: out.trim() }, 'claude agent: ready');
-                    resolve();
-                }
-                else
-                    reject(new Error(`claude --version exited with ${code}`));
-            });
-        });
-    }
-    async stop() {
-        for (const c of this.children) {
-            try {
-                c.kill('SIGTERM');
-            }
-            catch { /* ignore */ }
-        }
-        this.children.clear();
-    }
-    async createThread() {
-        const id = randomUUID();
-        log.info({ thread: id }, 'claude agent: thread allocated');
-        return id;
-    }
-    async sendTurn(threadId, text, callbacks) {
-        const args = ['-p', '--output-format', 'stream-json', '--include-partial-messages', '--verbose'];
-        args.push(this.started.has(threadId) ? '--resume' : '--session-id', threadId, text);
-        const child = spawn('claude', args, { stdio: ['ignore', 'pipe', 'pipe'] });
-        this.children.add(child);
-        log.debug({ thread: threadId }, 'claude agent: turn started');
-        const session = new TurnSession(callbacks);
-        let buffer = '';
-        child.stdout?.on('data', d => {
-            buffer += String(d);
-            let nl;
-            while ((nl = buffer.indexOf('\n')) !== -1) {
-                const line = buffer.slice(0, nl).trim();
-                buffer = buffer.slice(nl + 1);
-                if (!line)
-                    continue;
-                try {
-                    session.handle(JSON.parse(line));
-                }
-                catch (err) {
-                    log.warn({ err: errMsg(err) }, 'claude agent: malformed event');
-                }
-            }
-        });
-        child.stderr?.on('data', d => log.trace({ src: 'claude-stderr' }, String(d).trim()));
-        child.on('exit', code => {
-            this.children.delete(child);
-            if (!this.started.has(threadId)) {
-                this.started.add(threadId);
-                this.persistStarted();
-            }
-            if (!session.done) {
-                if (code === 0)
-                    session.fireComplete();
-                else
-                    session.fireError(new Error(`claude exited with code ${code}`));
-            }
-        });
-        child.on('error', err => { this.children.delete(child); if (!session.done)
-            session.fireError(err); });
-    }
-}
-class TurnSession {
-    cb;
-    done = false;
-    thinking = true;
-    /** tool_use_id → kind; survives until the matching tool_result lands. */
-    byUseId = new Map();
-    /** Pending tool_use blocks: input JSON streams in over multiple `input_json_delta` events before the input is complete. */
-    pendingTools = new Map();
-    constructor(cb) {
-        this.cb = cb;
-        cb.onToolStart({ id: 'thinking', kind: 'thinking', name: 'Thinking…', transient: true });
-    }
-    fireComplete() { if (this.done)
-        return; this.done = true; this.clearThinking(); this.cb.onComplete(); }
-    fireError(err) { if (this.done)
-        return; this.done = true; this.clearThinking(); this.cb.onError(err); }
-    clearThinking() { if (!this.thinking)
-        return; this.thinking = false; this.cb.onToolEnd('thinking'); }
-    handle(ev) {
-        if (ev.type === 'result') {
-            if (ev.is_error)
-                this.fireError(new Error(typeof ev.result === 'string' ? ev.result : 'claude error'));
-            else
-                this.fireComplete();
-            return;
-        }
-        if (ev.type === 'user') {
-            this.handleToolResults(ev);
-            return;
-        }
-        if (ev.type !== 'stream_event' || !ev.event)
-            return;
-        const e = ev.event;
-        if (e.type === 'content_block_start' && e.content_block?.type === 'tool_use') {
-            this.clearThinking();
-            const idx = e.index ?? -1;
-            const kind = e.content_block.name ?? 'tool';
-            const id = e.content_block.id ?? `${kind}:${idx}`;
-            this.byUseId.set(id, kind);
-            this.pendingTools.set(idx, { id, kind, toolName: e.content_block.name, inputJson: '' });
-        }
-        else if (e.type === 'content_block_delta' && e.delta?.type === 'input_json_delta') {
-            const tool = this.pendingTools.get(e.index ?? -1);
-            if (tool)
-                tool.inputJson += e.delta.partial_json ?? '';
-        }
-        else if (e.type === 'content_block_delta' && e.delta?.type === 'text_delta') {
-            this.clearThinking();
-            this.cb.onDelta(e.delta.text ?? '');
-        }
-        else if (e.type === 'content_block_stop') {
-            const tool = this.pendingTools.get(e.index ?? -1);
-            if (!tool)
-                return;
-            this.pendingTools.delete(e.index ?? -1);
-            let input;
-            try {
-                input = tool.inputJson ? JSON.parse(tool.inputJson) : undefined;
-            }
-            catch { /* malformed mid-stream — show name only */ }
-            const { name, detail } = summarizeTool(tool.toolName, input);
-            this.cb.onToolStart({ id: tool.id, kind: tool.kind, name, detail });
-        }
-    }
-    /** Claude emits `tool_result` blocks inside a follow-up `user` message after the tool runs. */
-    handleToolResults(ev) {
-        for (const block of ev.message?.content ?? []) {
-            if (block.type !== 'tool_result' || !block.tool_use_id)
-                continue;
-            if (!this.byUseId.has(block.tool_use_id))
-                continue;
-            this.byUseId.delete(block.tool_use_id);
-            this.cb.onToolEnd(block.tool_use_id, extractResultText(block.content));
-        }
-    }
-}
-function extractResultText(content) {
-    if (typeof content === 'string')
-        return content.trim() || undefined;
-    if (!Array.isArray(content))
-        return undefined;
-    const text = content.filter(b => b?.type === 'text').map(b => b.text ?? '').join('\n').trim();
-    return text || undefined;
-}
-function summarizeTool(name, input) {
-    const display = (name ?? 'Tool')[0].toUpperCase() + (name ?? 'Tool').slice(1);
-    if (!input)
-        return { name: display };
-    const path = (input.file_path ?? input.path);
-    const cmd = input.command;
-    const pattern = input.pattern;
-    switch (name) {
-        case 'Bash': return { name: 'Bash', detail: cmd };
-        case 'Edit':
-        case 'Write':
-        case 'NotebookEdit': return { name: display, detail: path };
-        case 'Read': return { name: 'Read', detail: path };
-        case 'Grep':
-        case 'Glob': return { name: display, detail: pattern };
-        case 'WebFetch': return { name: 'WebFetch', detail: input.url };
-        case 'WebSearch': return { name: 'WebSearch', detail: input.query };
-        case 'Task': return { name: 'Task', detail: (input.description ?? input.subagent_type) };
-        default: return { name: display };
-    }
-}

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