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

package/dist/lib/streaming.js

@@ -0,0 +1,207 @@
+// Accumulates streaming response deltas + tool-call status lines from a
+// running agent turn and pushes them to a chat platform (Discord / Telegram)
+// via debounced message edits. Smooth visible progress without hammering
+// rate limits.
+//
+// The debounce is owned by a per-bot `StreamScheduler`, not by individual
+// streams. One tick (e.g. every 1500ms) flushes every dirty stream the bot
+// has accumulated, so two concurrent threads don't compound into 2× the
+// edit rate on the same bot token.
+//
+// When the agent's response grows past the platform's per-message content
+// cap, the body is split across multiple messages: the prior segment is
+// frozen at its final text, and a fresh message holds the continuation
+// (with the live status line, which always anchors to the latest segment).
+//
+// On agent turn completion, call finalize() to flush a final edit with the
+// status cleared.
+import { errMsg, log } from '../log.js';
+// Steady-state cadence: 1500ms keeps us comfortably under Discord's ~5/5s
+// per-channel edit cap even after the transport adds its own retry-on-429
+// jitter. After a quiet period, the next flush is leading-edge (LEADING_MS)
+// so short responses don't appear as one final dump.
+const DEFAULT_DEBOUNCE_MS = 1500;
+const LEADING_MS = 500;
+// Discord's bot content cap is 2000 by default (4000 for boosted/Nitro).
+// 1900 is universally safe and leaves headroom for the status suffix.
+const MAX_BODY_LEN = 1900;
+// Reserve for "\n\n_<status>_" + a continuation hint.
+const STATUS_RESERVE = 80;
+/**
+ * One scheduler per bot. Coalesces edits across every active stream the
+ * bot is serving — Discord's per-channel rate limit doesn't compound when
+ * we run multiple threads concurrently this way.
+ */
+export class StreamScheduler {
+    debounceMs;
+    leadingMs;
+    dirty = new Set();
+    timer = null;
+    lastFlushAt = 0;
+    constructor(debounceMs = DEFAULT_DEBOUNCE_MS, leadingMs = LEADING_MS) {
+        this.debounceMs = debounceMs;
+        this.leadingMs = leadingMs;
+    }
+    request(stream) {
+        this.dirty.add(stream);
+        if (this.timer)
+            return;
+        // Leading-edge: if we haven't flushed recently, fire fast so the first
+        // visible content lands within `leadingMs` of the agent's first delta.
+        // Otherwise stay at the steady-state cadence to respect rate limits.
+        const sinceLast = Date.now() - this.lastFlushAt;
+        const delay = sinceLast >= this.debounceMs ? this.leadingMs : this.debounceMs - sinceLast;
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            this.lastFlushAt = Date.now();
+            const batch = [...this.dirty];
+            this.dirty.clear();
+            // Fire all in parallel — distinct channels are in distinct rate-limit
+            // buckets, so they don't queue behind each other.
+            for (const s of batch)
+                void s._flushFromScheduler();
+        }, delay);
+    }
+    /** Drop a stream from the queue (called when it finalizes). */
+    forget(stream) {
+        this.dirty.delete(stream);
+    }
+}
+export class StreamingMessage {
+    adapter;
+    scheduler;
+    segments = [{ id: null, text: '', dirty: false }];
+    statusLine = null;
+    flushing = false;
+    flushAgain = false;
+    finalized = false;
+    constructor(adapter, scheduler) {
+        this.adapter = adapter;
+        this.scheduler = scheduler;
+    }
+    appendDelta(delta) {
+        if (this.finalized || !delta)
+            return;
+        this.appendToLast(delta);
+        this.scheduler.request(this);
+    }
+    setStatus(status) {
+        if (this.finalized)
+            return;
+        this.statusLine = status;
+        this.markLastDirty();
+        this.scheduler.request(this);
+    }
+    /**
+     * Append an error notice to the visible message. Renders as `⚠️ <msg>`
+     * either on its own (no prior text) or after a blank line (preserves
+     * whatever streamed before the failure). Clears any pending status
+     * line since 'Thinking…' is meaningless after an error.
+     */
+    appendError(message) {
+        if (this.finalized)
+            return;
+        const last = this.segments[this.segments.length - 1];
+        const sep = last.text ? '\n\n' : '';
+        this.statusLine = null;
+        this.appendToLast(`${sep}⚠️ ${message}`);
+        this.scheduler.request(this);
+    }
+    async finalize() {
+        if (this.finalized)
+            return;
+        this.finalized = true;
+        this.scheduler.forget(this);
+        this.statusLine = null;
+        this.markLastDirty();
+        await this.flush();
+    }
+    /** Internal — called by the scheduler tick. */
+    async _flushFromScheduler() {
+        await this.flush();
+    }
+    appendToLast(delta) {
+        const cap = MAX_BODY_LEN - STATUS_RESERVE;
+        let remaining = delta;
+        while (remaining) {
+            let last = this.segments[this.segments.length - 1];
+            const room = cap - last.text.length;
+            if (room <= 0) {
+                // Previous last loses status anchor — re-edit without it.
+                last.dirty = true;
+                last = { id: null, text: '', dirty: false };
+                this.segments.push(last);
+                continue;
+            }
+            const take = this.sliceAtBoundary(remaining, room);
+            last.text += take;
+            last.dirty = true;
+            remaining = remaining.slice(take.length);
+        }
+    }
+    // Prefer splitting at the last newline / space / sentence end within the
+    // allowed slice, so continuation messages don't cut words in half. Falls
+    // back to a hard slice if no boundary is in reach.
+    sliceAtBoundary(s, room) {
+        if (s.length <= room)
+            return s;
+        const candidate = s.slice(0, room);
+        const breakers = ['\n\n', '\n', '. ', ' '];
+        for (const b of breakers) {
+            const i = candidate.lastIndexOf(b);
+            if (i > room * 0.5)
+                return candidate.slice(0, i + b.length);
+        }
+        return candidate;
+    }
+    markLastDirty() {
+        this.segments[this.segments.length - 1].dirty = true;
+    }
+    async flush() {
+        if (this.flushing) {
+            this.flushAgain = true;
+            return;
+        }
+        this.flushing = true;
+        try {
+            do {
+                this.flushAgain = false;
+                for (let i = 0; i < this.segments.length; i++) {
+                    const s = this.segments[i];
+                    const isLast = i === this.segments.length - 1;
+                    const body = this.render(s, isLast);
+                    if (!body)
+                        continue;
+                    try {
+                        if (s.id === null) {
+                            s.id = await this.adapter.send(body);
+                            s.dirty = false;
+                        }
+                        else if (s.dirty) {
+                            await this.adapter.edit(s.id, body);
+                            s.dirty = false;
+                        }
+                    }
+                    catch (err) {
+                        log.warn({ err: errMsg(err) }, 'streaming edit failed');
+                        // Leave dirty=true so the next tick retries.
+                    }
+                }
+            } while (this.flushAgain);
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+    render(s, isLast) {
+        const body = s.text;
+        const showStatus = isLast && !!this.statusLine;
+        if (!body && !showStatus)
+            return ''; // nothing to show yet — skip the flush
+        if (!body)
+            return this.statusLine;
+        if (showStatus)
+            return `${body}\n\n${this.statusLine}`;
+        return body;
+    }
+}

package/dist/orchestrator.js

@@ -0,0 +1,399 @@
+// Metro orchestrator — long-running daemon. Owns the Discord gateway and
+// Telegram poller, runs both codex and claude as agent backends, streams
+// per-turn responses back to chat with tool-call status visible.
+//
+// Per-message agent routing: a message ending in "with claude" / "with
+// codex" (any casing) targets that agent. Otherwise, the scope's last-used
+// agent answers; for brand-new scopes, the default is Claude.
+//
+// Scopes:
+//   Discord — one per thread (auto-created from an @-mention).
+//   Telegram — one per DM, one per forum-topic (auto-created when a user
+//              @-mentions in General).
+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 { CodexAgent } from './agents/codex.js';
+import { ClaudeAgent } from './agents/claude.js';
+import { discordChannelFromScopeKey, discordScopeKey, getAgentThread, getLastAgent, listScopes, setAgentThread, setLastAgent, setLastSeen, telegramScopeKey, } from './lib/scope-cache.js';
+import { StreamingMessage, StreamScheduler } from './lib/streaming.js';
+import { errMsg, log } from './log.js';
+import { configuredPlatforms, loadMetroEnv, STATE_DIR, requireConfiguredPlatform } from './paths.js';
+loadMetroEnv();
+const platforms = configuredPlatforms();
+requireConfiguredPlatform(platforms);
+// Singleton lockfile. The orchestrator owns the Discord gateway / Telegram
+// poller, so only one instance can run per machine.
+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 running; exiting');
+        process.exit(0);
+    }
+    try {
+        unlinkSync(LOCK_FILE);
+    }
+    catch { /* ignore */ }
+}
+mkdirSync(STATE_DIR, { recursive: true });
+writeFileSync(LOCK_FILE, String(process.pid));
+process.on('exit', () => { try {
+    if (readFileSync(LOCK_FILE, 'utf8').trim() === String(process.pid))
+        unlinkSync(LOCK_FILE);
+}
+catch { /* ignore */ } });
+// Track which agent threads we're actively serving a turn in, so we don't
+// send overlapping turn/start requests on the same thread.
+const inFlight = new Set();
+const queued = new Map();
+// De-dupe the *same* gateway delivery (e.g. on reconnect replay).
+const bootstrapped = new Set();
+// Both agents are instantiated; either can fail start() and be left
+// unavailable. Routing falls back gracefully when an agent isn't usable.
+const codexAgent = new CodexAgent(pkg.version);
+const claudeAgent = new ClaudeAgent();
+const available = {};
+// One scheduler per bot — coalesces streamed edits across every active
+// thread so concurrent turns don't compound the bot's edit cadence.
+const discordScheduler = new StreamScheduler();
+const telegramScheduler = new StreamScheduler();
+async function startAgents() {
+    await Promise.allSettled([
+        codexAgent.start().then(() => { available.codex = codexAgent; })
+            .catch(err => log.warn({ err: errMsg(err) }, "codex unavailable — 'with codex' will fail")),
+        claudeAgent.start().then(() => { available.claude = claudeAgent; })
+            .catch(err => log.warn({ err: errMsg(err) }, "claude unavailable — 'with claude' will fail")),
+    ]);
+    if (Object.keys(available).length === 0) {
+        log.fatal('no agents available — install codex or claude and authenticate');
+        process.exit(2);
+    }
+    log.info({ agents: Object.keys(available) }, 'orchestrator: agents ready');
+}
+async function main() {
+    await startAgents();
+    if (platforms.discord) {
+        await discord.startGateway();
+        const me = await discord.getMe();
+        log.info({ bot: me.username }, 'discord ready');
+        discord.onInbound(m => void onDiscordInbound(m).catch(err => log.warn({ err: errMsg(err) }, 'discord inbound failed')));
+        void catchupDiscord().catch(err => log.warn({ err: errMsg(err) }, 'discord catchup failed'));
+    }
+    if (platforms.telegram) {
+        // Identity needed for @-mention detection in groups; populated as a
+        // side-effect on the channel module.
+        const me = await telegram.getMe();
+        log.info({ bot: `@${me.username}` }, 'telegram ready');
+        telegram.onInbound(m => void onTelegramInbound(m).catch(err => log.warn({ err: errMsg(err) }, 'telegram inbound failed')));
+        await telegram.startPolling();
+    }
+    log.info('orchestrator ready');
+}
+async function catchupDiscord() {
+    const scopes = listScopes();
+    for (const { scopeKey, entry } of scopes) {
+        const channelId = discordChannelFromScopeKey(scopeKey);
+        if (!channelId || !entry.lastSeenMessageId)
+            continue;
+        try {
+            const missed = await discord.fetchMessagesSince(channelId, entry.lastSeenMessageId);
+            const humanMissed = missed.filter(m => !m.author_is_bot && m.text);
+            if (humanMissed.length === 0)
+                continue;
+            log.info({ channel: channelId, count: humanMissed.length }, 'discord catchup: replaying missed messages');
+            for (const m of humanMissed) {
+                await onDiscordInbound({
+                    channel_id: channelId,
+                    message_id: m.message_id,
+                    text: m.text,
+                    in_guild: true,
+                    mentions_bot: false,
+                });
+            }
+        }
+        catch (err) {
+            log.warn({ err: errMsg(err), channel: channelId }, 'discord catchup: channel skipped');
+        }
+    }
+}
+// "with claude" / "with codex" suffix (any casing). Captures the kind and
+// returns the message without the suffix. If no suffix, returns null.
+const SUFFIX_RE = /(?:^|\s)with\s+(claude|codex)\s*$/i;
+function parseAgentSuffix(text) {
+    const trimmed = text.trimEnd();
+    const m = SUFFIX_RE.exec(trimmed);
+    if (!m)
+        return { kind: null, cleanText: text };
+    const kind = m[1].toLowerCase();
+    return { kind, cleanText: trimmed.slice(0, m.index).trimEnd() };
+}
+// Effective agent for this turn: explicit suffix beats lastAgent beats the
+// default (Claude). If the requested kind is unavailable, returns null so
+// the caller can surface an error to the user.
+function pickAgent(scopeKey, requestedKind) {
+    if (requestedKind) {
+        if (!available[requestedKind])
+            return { error: `${requestedKind} is not available on this metro instance` };
+        return { kind: requestedKind, explicit: true };
+    }
+    const last = scopeKey ? getLastAgent(scopeKey) : undefined;
+    if (last && available[last])
+        return { kind: last, explicit: false };
+    if (available.claude)
+        return { kind: 'claude', explicit: false };
+    if (available.codex)
+        return { kind: 'codex', explicit: false };
+    return { error: 'no agents available' };
+}
+async function onDiscordInbound(m) {
+    if (!m.in_guild) {
+        log.debug({ channel: m.channel_id }, 'discord DM ignored (not supported yet)');
+        return;
+    }
+    const cachedScope = discordScopeKey(m.channel_id);
+    const cachedHasAnyAgent = !!(getAgentThread(cachedScope, 'codex') ?? getAgentThread(cachedScope, 'claude'));
+    // Existing scope (in-thread message): route to the requested or last-used agent.
+    if (cachedHasAnyAgent) {
+        const parsed = parseAgentSuffix(m.text);
+        const choice = pickAgent(cachedScope, parsed.kind);
+        if ('error' in choice) {
+            await postErrorMessage(m.channel_id, choice.error);
+            return;
+        }
+        setLastSeen(cachedScope, m.message_id);
+        let agentThreadId = getAgentThread(cachedScope, choice.kind);
+        if (!agentThreadId) {
+            // First time using this agent in this scope — fresh session, no prior
+            // history shared with the other agent.
+            agentThreadId = await available[choice.kind].createThread();
+            setAgentThread(cachedScope, choice.kind, agentThreadId);
+            log.info({ scope: cachedScope, agent: choice.kind, thread: agentThreadId }, 'allocated new agent session for existing scope');
+        }
+        else {
+            setLastAgent(cachedScope, choice.kind);
+        }
+        await handleTurn(parsed.cleanText, choice.kind, agentThreadId, discordAdapter(m.channel_id), discordScheduler);
+        return;
+    }
+    // No scope yet — only @-mentions bootstrap a new thread.
+    if (!m.mentions_bot) {
+        log.debug({ channel: m.channel_id }, 'discord guild msg dropped: no scope, no @-mention');
+        return;
+    }
+    if (bootstrapped.has(m.message_id))
+        return;
+    bootstrapped.add(m.message_id);
+    const parsed = parseAgentSuffix(m.text);
+    const choice = pickAgent(null, parsed.kind);
+    if ('error' in choice) {
+        await postErrorMessage(m.channel_id, choice.error);
+        return;
+    }
+    const agentForBootstrap = available[choice.kind];
+    const agentThreadId = await agentForBootstrap.createThread();
+    const threadName = makeThreadName(parsed.cleanText, agentThreadId);
+    log.info({ parent: m.channel_id, agent: choice.kind, thread: agentThreadId, threadName }, 'discord: bootstrapping new scope from @-mention');
+    const threadId = await discord.createThreadFromMessage(m.channel_id, m.message_id, threadName);
+    setAgentThread(discordScopeKey(threadId), choice.kind, agentThreadId);
+    log.info({ discord: threadId, agent: choice.kind, thread: agentThreadId }, 'scope created');
+    await handleTurn(parsed.cleanText, choice.kind, agentThreadId, discordAdapter(threadId), discordScheduler);
+}
+async function onTelegramInbound(m) {
+    // Allow DMs and any chat in a forum supergroup (custom topics + General).
+    // Plain (non-forum) groups are skipped — no thread boundary.
+    if (!m.is_private && !m.in_forum) {
+        log.debug({ chat: m.chat_id }, 'telegram: dropped — non-private, non-forum chat');
+        return;
+    }
+    // General topic of a forum is a *launcher*, never a session. Every
+    // @-mention spawns a fresh topic + scope. Any stale scope previously
+    // bound to General is ignored deliberately.
+    if (m.in_forum && !m.is_forum_topic) {
+        await bootstrapForumTopic(m);
+        return;
+    }
+    // DM or custom topic: route via the existing scope, allocating fresh
+    // agent sessions per-kind on first use.
+    const scopeKey = telegramScopeKey(m.chat_id, m.message_thread_id);
+    const cachedHasAnyAgent = !!(getAgentThread(scopeKey, 'codex') ?? getAgentThread(scopeKey, 'claude'));
+    if (!cachedHasAnyAgent && !m.is_private && !m.mentions_bot) {
+        log.debug({ chat: m.chat_id, topic: m.message_thread_id }, 'telegram: dropped — no scope, no @-mention');
+        return;
+    }
+    const parsed = parseAgentSuffix(m.text);
+    const choice = pickAgent(cachedHasAnyAgent ? scopeKey : null, parsed.kind);
+    if ('error' in choice) {
+        await postTelegramError(m.chat_id, m.message_thread_id, choice.error);
+        return;
+    }
+    setLastSeen(scopeKey, String(m.message_id));
+    let agentThreadId = getAgentThread(scopeKey, choice.kind);
+    if (!agentThreadId) {
+        agentThreadId = await available[choice.kind].createThread();
+        setAgentThread(scopeKey, choice.kind, agentThreadId);
+        log.info({ scope: scopeKey, agent: choice.kind, thread: agentThreadId }, 'telegram: allocated agent session');
+    }
+    else {
+        setLastAgent(scopeKey, choice.kind);
+    }
+    await handleTurn(parsed.cleanText, choice.kind, agentThreadId, telegramAdapter(m.chat_id, m.message_thread_id), telegramScheduler);
+}
+async function bootstrapForumTopic(m) {
+    if (!m.mentions_bot) {
+        log.debug({ chat: m.chat_id }, 'telegram: General msg ignored — no @-mention');
+        return;
+    }
+    if (bootstrapped.has(String(m.message_id)))
+        return;
+    bootstrapped.add(String(m.message_id));
+    const parsed = parseAgentSuffix(m.text);
+    const choice = pickAgent(null, parsed.kind);
+    if ('error' in choice) {
+        await postTelegramError(m.chat_id, undefined, choice.error);
+        return;
+    }
+    const topicName = makeThreadName(parsed.cleanText, 'metro');
+    let newTopicId;
+    try {
+        newTopicId = await telegram.createForumTopic(m.chat_id, topicName);
+        log.info({ chat: m.chat_id, topic: newTopicId, name: topicName }, 'telegram: created topic from @-mention');
+    }
+    catch (err) {
+        await postTelegramError(m.chat_id, undefined, `couldn't create a new topic — make the bot a forum admin with "Manage Topics" permission. (${errMsg(err)})`);
+        return;
+    }
+    const agentThreadId = await available[choice.kind].createThread();
+    const newScopeKey = telegramScopeKey(m.chat_id, newTopicId);
+    setAgentThread(newScopeKey, choice.kind, agentThreadId);
+    setLastSeen(newScopeKey, String(m.message_id));
+    log.info({ scope: newScopeKey, agent: choice.kind, thread: agentThreadId }, 'telegram: scope created');
+    await handleTurn(parsed.cleanText, choice.kind, agentThreadId, telegramAdapter(m.chat_id, newTopicId), telegramScheduler);
+}
+async function postTelegramError(chatId, threadId, message) {
+    try {
+        await telegram.sendMessage(chatId, threadId, `⚠️ ${message}`);
+    }
+    catch (err) {
+        log.warn({ err: errMsg(err) }, 'failed to post telegram error');
+    }
+}
+async function postErrorMessage(channelId, message) {
+    try {
+        await discord.sendMessage(channelId, `⚠️ ${message}`);
+    }
+    catch (err) {
+        log.warn({ err: errMsg(err) }, 'failed to post error message');
+    }
+}
+// Thread/topic names. Strip platform mention syntax (discord <@id>, custom
+// emoji; telegram @username), normalize whitespace, fall back to the given
+// default if nothing usable is left. Telegram caps topic names at 128;
+// Discord at 100 — use 100 so the same value works for both.
+function makeThreadName(rawText, fallback) {
+    const cleaned = rawText
+        .replace(/<@!?\d+>/g, '')
+        .replace(/<@&\d+>/g, '')
+        .replace(/<#\d+>/g, '')
+        .replace(/<a?:[^:]+:\d+>/g, '')
+        .replace(/@\w+/g, '') // telegram @username
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!cleaned)
+        return fallback.slice(0, 100);
+    return cleaned.length <= 100 ? cleaned : cleaned.slice(0, 99) + '…';
+}
+/**
+ * Run one agent turn against a known agent thread, streaming the response
+ * through the provided platform adapter. If a turn is already in flight
+ * for this thread, append to the per-thread queue and let the current
+ * turn's drain pick it up.
+ */
+async function handleTurn(text, kind, agentThreadId, adapter, scheduler) {
+    const agent = available[kind];
+    if (!agent) {
+        // Shouldn't happen — the caller's pickAgent() already filters this —
+        // but log defensively so it's not silent.
+        log.warn({ kind, agent: agentThreadId }, 'handleTurn called for unavailable agent');
+        return;
+    }
+    const dispatch = (t) => handleTurn(t, kind, agentThreadId, adapter, scheduler);
+    if (inFlight.has(agentThreadId)) {
+        const q = queued.get(agentThreadId);
+        if (q)
+            q.texts.push(text);
+        else
+            queued.set(agentThreadId, { texts: [text], dispatch });
+        log.debug({ agent: agentThreadId, queueDepth: queued.get(agentThreadId).texts.length }, 'queued follow-up turn');
+        return;
+    }
+    inFlight.add(agentThreadId);
+    const stream = new StreamingMessage(adapter, scheduler);
+    const finishAndDrain = async () => {
+        await stream.finalize();
+        inFlight.delete(agentThreadId);
+        const q = queued.get(agentThreadId);
+        if (!q || q.texts.length === 0)
+            return;
+        queued.delete(agentThreadId);
+        const combined = q.texts.join('\n\n');
+        log.debug({ agent: agentThreadId, batched: q.texts.length }, 'draining queued follow-ups');
+        await q.dispatch(combined).catch(err => log.warn({ err: errMsg(err) }, 'queued turn failed'));
+    };
+    const callbacks = {
+        onDelta: d => stream.appendDelta(d),
+        onToolStart: (_kind, summary) => stream.setStatus(summary),
+        onToolEnd: () => stream.setStatus(null),
+        onComplete: () => { void finishAndDrain(); },
+        onError: err => {
+            log.warn({ err: errMsg(err) }, 'agent turn failed');
+            stream.appendError(errMsg(err) || 'agent turn failed');
+            void finishAndDrain();
+        },
+    };
+    await agent.sendTurn(agentThreadId, text, callbacks);
+}
+function discordAdapter(channelId) {
+    return {
+        send: t => discord.sendMessage(channelId, t),
+        edit: async (id, t) => { await discord.editMessage(channelId, id, t); },
+    };
+}
+function telegramAdapter(chatId, topicId) {
+    return {
+        send: async (t) => String(await telegram.sendMessage(chatId, topicId, t)),
+        edit: async (id, t) => { await telegram.editMessageText(chatId, Number(id), t); },
+    };
+}
+let shuttingDown = false;
+async function shutdown() {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    log.info('orchestrator shutting down');
+    await Promise.allSettled([
+        available.codex?.stop().catch(err => log.warn({ err: errMsg(err) }, 'codex shutdown failed')),
+        available.claude?.stop().catch(err => log.warn({ err: errMsg(err) }, 'claude shutdown failed')),
+    ]);
+    if (platforms.discord)
+        await discord.shutdownGateway().catch(err => log.warn({ err: errMsg(err) }, 'discord shutdown failed'));
+    if (platforms.telegram)
+        await telegram.shutdownPolling().catch(err => log.warn({ err: errMsg(err) }, 'telegram shutdown failed'));
+    process.exit(0);
+}
+process.stdin.on('end', shutdown);
+process.stdin.on('close', shutdown);
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+await main();

package/dist/paths.js

@@ -3,7 +3,8 @@ 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.
+// Lockfile, scope cache, codex app-server socket, telegram poll offset,
+// claude session set. 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
@@ -11,19 +12,6 @@ mkdirSync(STATE_DIR, { recursive: true });
 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.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.2",
-  "description": "Chat with your Claude Code or Codex agent over Telegram and Discord. Ultra-lightweight: ~1.2K lines of TypeScript, pure CLI, no hosted infra.",
+  "version": "0.1.0-beta.3",
+  "description": "Orchestrator daemon that bridges Codex / Claude Code agent sessions with Telegram and Discord. Each chat thread gets its own agent session, with streaming responses and tool-call visibility.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -18,7 +18,6 @@
   },
   "files": [
     "dist",
-    "skills",
     "README.md",
     "LICENSE"
   ],

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