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

package/dist/helpers/scope-cache.js

@@ -0,0 +1,65 @@
+/** 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'}`;

package/dist/helpers/streaming.js

@@ -0,0 +1,209 @@
+/** Streams agent deltas + tool calls to chat via debounced edits; splits past MAX_BODY_LEN. */
+import { errMsg, log } from '../log.js';
+/** 1500ms keeps us under Discord's ~5/5s per-channel edit cap; leading-edge 500ms for first delta. */
+const DEFAULT_DEBOUNCE_MS = 1500;
+const LEADING_MS = 500;
+/** Discord cap is 2000; 1900 leaves headroom for status suffix. */
+const MAX_BODY_LEN = 1900;
+const STATUS_RESERVE = 80;
+/** Cap result so a 1000-line file dump doesn't blow the per-message char budget. */
+const MAX_RESULT_LINES = 50;
+const MAX_RESULT_CHARS = 1500;
+/** One per bot. Coalesces edits so concurrent threads don't compound rate limits. */
+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;
+        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();
+            for (const s of batch)
+                void s._flushFromScheduler();
+        }, delay);
+    }
+    forget(stream) { this.dirty.delete(stream); }
+}
+/** Break embedded triple backticks so they can't close our fenced block early. */
+const escapeFence = (s) => s.replace(/```/g, '`​`​`');
+/** Cap output by lines + chars; return `body` to embed and a `_(N more …)_` overflow note (or ''). */
+function truncateResult(s) {
+    const lines = s.split('\n');
+    let body = lines.slice(0, MAX_RESULT_LINES).join('\n');
+    const droppedLines = Math.max(0, lines.length - MAX_RESULT_LINES);
+    if (body.length > MAX_RESULT_CHARS)
+        body = body.slice(0, MAX_RESULT_CHARS) + '…';
+    if (droppedLines === 0 && body === s)
+        return { body: s, overflow: '' };
+    const noun = droppedLines > 0 ? `${droppedLines} more line${droppedLines === 1 ? '' : 's'}` : 'output truncated';
+    return { body, overflow: `_(${noun})_` };
+}
+export class StreamingMessage {
+    adapter;
+    scheduler;
+    blocks = [];
+    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;
+        const last = this.blocks.at(-1);
+        if (last?.kind === 'text')
+            last.text += delta;
+        else
+            this.blocks.push({ kind: 'text', text: delta });
+        this.scheduler.request(this);
+    }
+    setStatus(status) {
+        if (this.finalized)
+            return;
+        this.statusLine = status;
+        this.scheduler.request(this);
+    }
+    /** Add a tool block keyed by `id`; rendered immediately as a header, output filled in via appendToolResult. */
+    appendToolCall(id, name, detail) {
+        if (this.finalized)
+            return;
+        this.blocks.push({ kind: 'tool', id, name, detail });
+        this.scheduler.request(this);
+    }
+    /** Set the matching tool block's result; renders truncated output under the header. */
+    appendToolResult(id, result) {
+        if (this.finalized || !result)
+            return;
+        const tool = this.blocks.find((b) => b.kind === 'tool' && b.id === id);
+        if (tool)
+            tool.result = result;
+        this.scheduler.request(this);
+    }
+    appendError(message) {
+        if (this.finalized)
+            return;
+        this.statusLine = null;
+        this.blocks.push({ kind: 'text', text: `⚠️ ${message}` });
+        this.scheduler.request(this);
+    }
+    async finalize() {
+        if (this.finalized)
+            return;
+        this.finalized = true;
+        this.scheduler.forget(this);
+        this.statusLine = null;
+        await this.flush();
+    }
+    async _flushFromScheduler() { await this.flush(); }
+    /** Render the block list into a single markdown body. */
+    renderBody() {
+        return this.blocks.map(b => b.kind === 'text' ? b.text : this.renderToolBlock(b)).join('\n\n').trim();
+    }
+    /** Plain header + fenced input block + fenced output block. Each fence is fully visible (no collapse). */
+    renderToolBlock(b) {
+        const parts = [`🛠 **${b.name}**`];
+        if (b.detail)
+            parts.push('```\n' + escapeFence(b.detail) + '\n```');
+        if (b.result) {
+            const { body, overflow } = truncateResult(b.result);
+            parts.push('```\n' + escapeFence(body) + '\n```');
+            if (overflow)
+                parts.push(overflow);
+        }
+        return parts.join('\n');
+    }
+    /** Redistribute the rendered body across segments, keeping existing segment ids stable. */
+    redistribute() {
+        const fullBody = this.renderBody();
+        const chunks = this.chunkify(fullBody, MAX_BODY_LEN - STATUS_RESERVE);
+        if (!chunks.length)
+            chunks.push('');
+        for (let i = 0; i < chunks.length; i++) {
+            if (i >= this.segments.length) {
+                this.segments.push({ id: null, text: chunks[i], dirty: true });
+            }
+            else if (this.segments[i].text !== chunks[i]) {
+                this.segments[i].text = chunks[i];
+                this.segments[i].dirty = true;
+            }
+        }
+    }
+    chunkify(s, cap) {
+        if (s.length <= cap)
+            return [s];
+        const out = [];
+        for (let r = s; r.length > 0;) {
+            const take = r.length > cap ? this.sliceAtBoundary(r, cap) : r;
+            out.push(take);
+            r = r.slice(take.length);
+        }
+        return out;
+    }
+    /** Split at the last paragraph/line/sentence/word break in range; hard slice otherwise. */
+    sliceAtBoundary(s, room) {
+        if (s.length <= room)
+            return s;
+        const candidate = s.slice(0, room);
+        for (const b of ['\n\n', '\n', '. ', ' ']) {
+            const i = candidate.lastIndexOf(b);
+            if (i > room * 0.5)
+                return candidate.slice(0, i + b.length);
+        }
+        return candidate;
+    }
+    async flush() {
+        if (this.flushing) {
+            this.flushAgain = true;
+            return;
+        }
+        this.flushing = true;
+        try {
+            do {
+                this.flushAgain = false;
+                this.redistribute();
+                for (let i = 0; i < this.segments.length; i++) {
+                    const s = this.segments[i];
+                    const body = this.render(s, i === this.segments.length - 1);
+                    if (!body)
+                        continue;
+                    try {
+                        if (s.id === null)
+                            s.id = await this.adapter.send(body);
+                        else if (s.dirty)
+                            await this.adapter.edit(s.id, body);
+                        s.dirty = false;
+                    }
+                    catch (err) {
+                        log.warn({ err: errMsg(err) }, 'streaming edit failed');
+                    }
+                }
+            } while (this.flushAgain);
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+    render(s, isLast) {
+        const showStatus = isLast && !!this.statusLine;
+        if (!s.text)
+            return showStatus ? this.statusLine : '';
+        return showStatus ? `${s.text}\n\n${this.statusLine}` : s.text;
+    }
+}

package/dist/helpers/telegram-format.js

@@ -0,0 +1,39 @@
+/** Convert markdown → Telegram HTML. Stream-safe: unmatched markers fall through as literal text. */
+const ENTITY_MAP = { '&': '&amp;', '<': '&lt;', '>': '&gt;' };
+const esc = (s) => s.replace(/[&<>]/g, c => ENTITY_MAP[c]);
+/** SOH — invalid in Telegram text + never in agent output, so collisions are impossible. */
+const SENT = '\x01';
+export function mdToTelegramHtml(md) {
+    const slots = [];
+    const stash = (html) => {
+        slots.push(html);
+        return `${SENT}${slots.length - 1}${SENT}`;
+    };
+    /** Fenced code first so its contents aren't touched by other rules. */
+    let work = md.replace(/```([A-Za-z0-9_+\-.]*)\n?([\s\S]*?)```/g, (_m, lang, code) => {
+        const inner = lang
+            ? `<pre><code class="language-${esc(lang)}">${esc(code)}</code></pre>`
+            : `<pre>${esc(code)}</pre>`;
+        return stash(inner);
+    });
+    /** Inline code; skip multi-line spans (likely an unclosed mid-stream fence). */
+    work = work.replace(/`([^`\n]+)`/g, (_m, code) => stash(`<code>${esc(code)}</code>`));
+    /** Escape outside stashes before running tag-emitting rules. */
+    work = esc(work);
+    work = work.replace(/\[([^\]\n]+)\]\(([^)\s]+)\)/g, (_m, text, url) => stash(`<a href="${url.replace(/"/g, '%22')}">${text}</a>`));
+    /** Bold before italic so single-`*` rule doesn't eat half of `**bold**`. */
+    work = work.replace(/\*\*([^*\n]+?)\*\*/g, '<b>$1</b>').replace(/__([^_\n]+?)__/g, '<b>$1</b>');
+    /** Italic: \S guards prevent matching `2 * 3` arithmetic or `foo_bar` identifiers. */
+    work = work
+        .replace(/(^|[^*\w])\*(\S[^*\n]*?\S|\S)\*(?!\w)/g, '$1<i>$2</i>')
+        .replace(/(^|[^_\w])_(\S[^_\n]*?\S|\S)_(?!\w)/g, '$1<i>$2</i>');
+    work = work.replace(/~~([^~\n]+?)~~/g, '<s>$1</s>');
+    /** Headings → bold (Telegram has no heading element). */
+    work = work.replace(/^#{1,6}\s+(.+?)\s*$/gm, '<b>$1</b>');
+    /** Collapse consecutive `> ` lines into one <blockquote> for prose-level quotes. */
+    work = work.replace(/(^|\n)((?:&gt;\s?[^\n]*\n?)+)/g, (_m, lead, block) => {
+        const inner = block.replace(/^&gt;\s?/gm, '').replace(/\n+$/, '');
+        return `${lead}<blockquote>${inner}</blockquote>${block.endsWith('\n') ? '\n' : ''}`;
+    });
+    return work.replace(new RegExp(`${SENT}(\\d+)${SENT}`, 'g'), (_m, idx) => slots[Number(idx)]);
+}

package/dist/helpers/turn.js

@@ -0,0 +1,40 @@
+/** Run a turn; stream response via adapter. In-flight follow-ups queue and drain as one combined turn. */
+import { errMsg, log } from '../log.js';
+import { StreamingMessage } from './streaming.js';
+const inFlight = new Set();
+const queued = new Map();
+export async function runTurn(agent, threadId, text, adapter, scheduler) {
+    const dispatch = (t) => runTurn(agent, threadId, t, adapter, scheduler);
+    if (inFlight.has(threadId)) {
+        const q = queued.get(threadId);
+        if (q)
+            q.texts.push(text);
+        else
+            queued.set(threadId, { texts: [text], dispatch });
+        return;
+    }
+    inFlight.add(threadId);
+    const stream = new StreamingMessage(adapter, scheduler);
+    const finishAndDrain = async () => {
+        await stream.finalize();
+        inFlight.delete(threadId);
+        const q = queued.get(threadId);
+        if (!q?.texts.length)
+            return;
+        queued.delete(threadId);
+        await q.dispatch(q.texts.join('\n\n')).catch(err => log.warn({ err: errMsg(err) }, 'queued turn failed'));
+    };
+    const callbacks = {
+        onDelta: d => stream.appendDelta(d),
+        onToolStart: a => a.transient ? stream.setStatus(a.name) : stream.appendToolCall(a.id, a.name, a.detail),
+        onToolEnd: (id, result) => { if (result)
+            stream.appendToolResult(id, result); 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(threadId, text, callbacks);
+}

package/dist/log.js

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

package/dist/orchestrator.js

@@ -0,0 +1,208 @@
+/** Daemon: owns Discord gateway + Telegram poller; routes inbounds to codex/claude (suffix "with X" overrides scope default). */
+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 './helpers/scope-cache.js';
+import { StreamScheduler } from './helpers/streaming.js';
+import { runTurn } from './helpers/turn.js';
+import { errMsg, log } from './log.js';
+import { acquireLock, configuredPlatforms, loadMetroEnv, STATE_DIR, requireConfiguredPlatform } from './paths.js';
+loadMetroEnv();
+const platforms = configuredPlatforms();
+requireConfiguredPlatform(platforms);
+acquireLock(join(STATE_DIR, '.tail-lock'));
+const bootstrapped = new Set();
+const codexAgent = new CodexAgent(pkg.version);
+const claudeAgent = new ClaudeAgent();
+const available = {};
+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')),
+        claudeAgent.start().then(() => { available.claude = claudeAgent; }).catch(err => log.warn({ err: errMsg(err) }, 'claude unavailable')),
+    ]);
+    if (!Object.keys(available).length) {
+        log.fatal('no agents available');
+        process.exit(2);
+    }
+    log.info({ agents: Object.keys(available) }, 'agents ready');
+}
+const SUFFIX_RE = /(?:^|\s)with\s+(claude|codex)\s*$/i;
+function parseAgentSuffix(text) {
+    const t = text.trimEnd();
+    const m = SUFFIX_RE.exec(t);
+    return m ? { kind: m[1].toLowerCase(), cleanText: t.slice(0, m.index).trimEnd() } : { kind: null, cleanText: text };
+}
+function pickAgent(scopeKey, req) {
+    if (req)
+        return available[req] ? { kind: req } : { error: `${req} is not available on this metro instance` };
+    const last = scopeKey ? getLastAgent(scopeKey) : undefined;
+    if (last && available[last])
+        return { kind: last };
+    if (available.claude)
+        return { kind: 'claude' };
+    if (available.codex)
+        return { kind: 'codex' };
+    return { error: 'no agents available' };
+}
+/** Resolve agent session for `scopeKey`, allocating if new, then run the turn. */
+async function dispatch(scopeKey, text, kind, messageId, adapter, scheduler) {
+    setLastSeen(scopeKey, messageId);
+    let threadId = getAgentThread(scopeKey, kind);
+    if (!threadId) {
+        threadId = await available[kind].createThread();
+        setAgentThread(scopeKey, kind, threadId);
+        log.info({ scope: scopeKey, agent: kind, thread: threadId }, 'allocated agent session');
+    }
+    else
+        setLastAgent(scopeKey, kind);
+    await runTurn(available[kind], threadId, text, adapter, scheduler);
+}
+async function onDiscordInbound(m) {
+    if (!m.in_guild)
+        return;
+    const scope = discordScopeKey(m.channel_id);
+    const hasAgent = !!(getAgentThread(scope, 'codex') ?? getAgentThread(scope, 'claude'));
+    const { kind: req, cleanText } = parseAgentSuffix(m.text);
+    const postErr = (msg) => discord.sendMessage(m.channel_id, `⚠️ ${msg}`).then(() => { }).catch(err => log.warn({ err: errMsg(err) }, 'discord error post failed'));
+    if (hasAgent) {
+        const choice = pickAgent(scope, req);
+        if ('error' in choice)
+            return postErr(choice.error);
+        return dispatch(scope, cleanText, choice.kind, m.message_id, discordAdapter(m.channel_id), discordScheduler);
+    }
+    if (!m.mentions_bot || bootstrapped.has(m.message_id))
+        return;
+    bootstrapped.add(m.message_id);
+    const choice = pickAgent(null, req);
+    if ('error' in choice)
+        return postErr(choice.error);
+    const threadId = await available[choice.kind].createThread();
+    const ch = await discord.createThreadFromMessage(m.channel_id, m.message_id, makeThreadName(cleanText, threadId));
+    setAgentThread(discordScopeKey(ch), choice.kind, threadId);
+    log.info({ discord: ch, agent: choice.kind, thread: threadId }, 'scope created');
+    await runTurn(available[choice.kind], threadId, cleanText, discordAdapter(ch), discordScheduler);
+}
+async function onTelegramInbound(m) {
+    if (!m.is_private && !m.in_forum)
+        return;
+    if (m.in_forum && !m.is_forum_topic)
+        return bootstrapForumTopic(m);
+    const scope = telegramScopeKey(m.chat_id, m.message_thread_id);
+    const hasAgent = !!(getAgentThread(scope, 'codex') ?? getAgentThread(scope, 'claude'));
+    if (!hasAgent && !m.is_private && !m.mentions_bot)
+        return;
+    const { kind: req, cleanText } = parseAgentSuffix(m.text);
+    const choice = pickAgent(hasAgent ? scope : null, req);
+    if ('error' in choice)
+        return postTelegramError(m.chat_id, m.message_thread_id, choice.error);
+    await dispatch(scope, cleanText, choice.kind, String(m.message_id), telegramAdapter(m.chat_id, m.message_thread_id), telegramScheduler);
+}
+async function bootstrapForumTopic(m) {
+    if (!m.mentions_bot || bootstrapped.has(String(m.message_id)))
+        return;
+    bootstrapped.add(String(m.message_id));
+    const { kind: req, cleanText } = parseAgentSuffix(m.text);
+    const choice = pickAgent(null, req);
+    if ('error' in choice)
+        return postTelegramError(m.chat_id, undefined, choice.error);
+    let topicId;
+    const topicName = makeThreadName(cleanText, 'metro');
+    try {
+        topicId = await telegram.createForumTopic(m.chat_id, topicName);
+    }
+    catch (err) {
+        return postTelegramError(m.chat_id, undefined, `couldn't create topic — bot needs Manage Topics admin permission. (${errMsg(err)})`);
+    }
+    const threadId = await available[choice.kind].createThread();
+    const scope = telegramScopeKey(m.chat_id, topicId);
+    setAgentThread(scope, choice.kind, threadId);
+    setLastSeen(scope, String(m.message_id));
+    log.info({ scope, agent: choice.kind, thread: threadId }, 'telegram: scope created');
+    /** Post a deep link back in General as a reply to the @-mention so it threads visually. */
+    await telegram.sendMessage(m.chat_id, undefined, `→ [${topicName}](${telegram.topicLink(m.chat_id, topicId)})`, m.message_id)
+        .catch(err => log.warn({ err: errMsg(err) }, 'telegram: failed to post topic link in General'));
+    await runTurn(available[choice.kind], threadId, cleanText, telegramAdapter(m.chat_id, topicId), 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');
+    }
+}
+/** Strip mention syntax + normalize whitespace; cap at 100 chars (Discord limit). */
+function makeThreadName(rawText, fallback) {
+    const cleaned = rawText.replace(/<@!?\d+>|<@&\d+>|<#\d+>|<a?:[^:]+:\d+>|@\w+/g, '').replace(/\s+/g, ' ').trim();
+    if (!cleaned)
+        return fallback.slice(0, 100);
+    return cleaned.length <= 100 ? cleaned : cleaned.slice(0, 99) + '…';
+}
+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); },
+    };
+}
+async function catchupDiscord() {
+    for (const { scopeKey, entry } of listScopes()) {
+        const channelId = discordChannelFromScopeKey(scopeKey);
+        if (!channelId || !entry.lastSeenMessageId)
+            continue;
+        try {
+            const missed = (await discord.fetchMessagesSince(channelId, entry.lastSeenMessageId)).filter(m => !m.author_is_bot && m.text);
+            if (!missed.length)
+                continue;
+            log.info({ channel: channelId, count: missed.length }, 'discord catchup');
+            for (const m of missed)
+                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 skipped');
+        }
+    }
+}
+async function main() {
+    await startAgents();
+    if (platforms.discord) {
+        await discord.startGateway();
+        log.info({ bot: (await discord.getMe()).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) {
+        log.info({ bot: `@${(await telegram.getMe()).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');
+}
+let shuttingDown = false;
+async function shutdown() {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    log.info('orchestrator shutting down');
+    await Promise.allSettled([available.codex?.stop(), available.claude?.stop()]);
+    if (platforms.discord)
+        await discord.shutdownGateway().catch(() => { });
+    if (platforms.telegram)
+        await telegram.shutdownPolling().catch(() => { });
+    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

@@ -1,41 +1,40 @@
-import { mkdirSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { loadDotenvIntoProcess } from './lib/dotenv.js';
+import { dirname, join } from 'node:path';
 import { log } from './log.js';
-// Lockfile, typing-stop signals, attachment cache. Override with METRO_STATE_DIR.
 export const STATE_DIR = process.env.METRO_STATE_DIR ?? join(homedir(), '.cache', 'metro');
 mkdirSync(STATE_DIR, { recursive: true });
-// Where `metro setup` writes the global .env. Override with METRO_CONFIG_DIR
-// or the standard $XDG_CONFIG_HOME.
-const CONFIG_DIR = process.env.METRO_CONFIG_DIR ??
-    join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'metro');
+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');
+const LINE_RE = /^\s*([A-Za-z_]\w*)\s*=\s*(.*?)\s*$/;
+const QUOTED_RE = /^(['"])(.*)\1$/;
+export function readDotenv(path) {
+    if (!existsSync(path))
+        return {};
+    const out = {};
+    for (const line of readFileSync(path, 'utf8').split('\n')) {
+        const m = line.match(LINE_RE);
+        if (m)
+            out[m[1]] = m[2].replace(QUOTED_RE, '$2');
+    }
+    return out;
 }
-// Precedence: process.env (already set) > cwd/.env > <CONFIG_DIR>/.env.
-// loadDotenvIntoProcess only fills vars that aren't already populated, so the
-// first call that defines a key wins.
+export function writeDotenv(path, env) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, Object.entries(env).map(([k, v]) => `${k}=${v}`).join('\n') + '\n');
+    chmodSync(path, 0o600);
+}
+/** Precedence: process.env > cwd/.env > $METRO_CONFIG_DIR/.env. First-set wins. */
 export function loadMetroEnv() {
-    loadDotenvIntoProcess(join(process.cwd(), '.env'));
-    loadDotenvIntoProcess(CONFIG_ENV_FILE);
+    for (const path of [join(process.cwd(), '.env'), CONFIG_ENV_FILE]) {
+        for (const [k, v] of Object.entries(readDotenv(path))) {
+            if (process.env[k] === undefined)
+                process.env[k] = v;
+        }
+    }
 }
 export function configuredPlatforms() {
-    return {
-        telegram: !!process.env.TELEGRAM_BOT_TOKEN,
-        discord: !!process.env.DISCORD_BOT_TOKEN,
-    };
+    return { telegram: !!process.env.TELEGRAM_BOT_TOKEN, discord: !!process.env.DISCORD_BOT_TOKEN };
 }
 export function requireConfiguredPlatform(p) {
     if (p.telegram || p.discord)
@@ -43,3 +42,27 @@ export function requireConfiguredPlatform(p) {
     log.fatal('no platforms configured — run `metro setup telegram <token>` or `metro setup discord <token>`');
     process.exit(2);
 }
+/** Singleton pidfile. Exits if another instance owns it; reclaims stale locks. */
+export function acquireLock(lockFile) {
+    if (existsSync(lockFile)) {
+        const pid = Number(readFileSync(lockFile, 'utf8').trim());
+        try {
+            if (Number.isInteger(pid) && pid > 0) {
+                process.kill(pid, 0);
+                log.info({ pid }, 'another `metro` is running; exiting');
+                process.exit(0);
+            }
+        }
+        catch { /* stale */ }
+        try {
+            unlinkSync(lockFile);
+        }
+        catch { /* ignore */ }
+    }
+    writeFileSync(lockFile, String(process.pid));
+    process.on('exit', () => { try {
+        if (readFileSync(lockFile, 'utf8').trim() === String(process.pid))
+            unlinkSync(lockFile);
+    }
+    catch { /* ignore */ } });
+}