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

package/dist/orchestrator.js

@@ -1,285 +1,132 @@
-// 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';
+/** 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 './lib/scope-cache.js';
-import { StreamingMessage, StreamScheduler } from './lib/streaming.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 { configuredPlatforms, loadMetroEnv, STATE_DIR, requireConfiguredPlatform } from './paths.js';
+import { acquireLock, 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).
+acquireLock(join(STATE_DIR, '.tail-lock'));
 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")),
+        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 === 0) {
-        log.fatal('no agents available — install codex or claude and authenticate');
+    if (!Object.keys(available).length) {
+        log.fatal('no agents available');
         process.exit(2);
     }
-    log.info({ agents: Object.keys(available) }, 'orchestrator: agents ready');
+    log.info({ agents: Object.keys(available) }, '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() };
+    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 };
 }
-// 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 };
-    }
+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, explicit: false };
+        return { kind: last };
     if (available.claude)
-        return { kind: 'claude', explicit: false };
+        return { kind: 'claude' };
     if (available.codex)
-        return { kind: 'codex', explicit: false };
+        return { kind: 'codex' };
     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;
+/** 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');
     }
-    // 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');
+    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 (bootstrapped.has(m.message_id))
+    if (!m.mentions_bot || 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);
+    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) {
-    // 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);
+    if (!m.is_private && !m.in_forum)
         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');
+    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 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);
+    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) {
-        log.debug({ chat: m.chat_id }, 'telegram: General msg ignored — no @-mention');
-        return;
-    }
-    if (bootstrapped.has(String(m.message_id)))
+    if (!m.mentions_bot || 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;
+    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 {
-        newTopicId = await telegram.createForumTopic(m.chat_id, topicName);
-        log.info({ chat: m.chat_id, topic: newTopicId, name: topicName }, 'telegram: created topic from @-mention');
+        topicId = await telegram.createForumTopic(m.chat_id, topicName);
     }
     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);
+        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 {
@@ -289,81 +136,13 @@ async function postTelegramError(chatId, threadId, message) {
         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.
+/** Strip mention syntax + normalize whitespace; cap at 100 chars (Discord limit). */
 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();
+    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) + '…';
 }
-/**
- * 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),
@@ -376,20 +155,50 @@ function telegramAdapter(chatId, topicId) {
         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().catch(err => log.warn({ err: errMsg(err) }, 'codex shutdown failed')),
-        available.claude?.stop().catch(err => log.warn({ err: errMsg(err) }, 'claude shutdown failed')),
-    ]);
+    await Promise.allSettled([available.codex?.stop(), available.claude?.stop()]);
     if (platforms.discord)
-        await discord.shutdownGateway().catch(err => log.warn({ err: errMsg(err) }, 'discord shutdown failed'));
+        await discord.shutdownGateway().catch(() => { });
     if (platforms.telegram)
-        await telegram.shutdownPolling().catch(err => log.warn({ err: errMsg(err) }, 'telegram shutdown failed'));
+        await telegram.shutdownPolling().catch(() => { });
     process.exit(0);
 }
 process.stdin.on('end', shutdown);

package/dist/paths.js

@@ -1,29 +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, 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
-// 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');
-// 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.
+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;
+}
+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)
@@ -31,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 */ } });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.3",
+  "version": "0.1.0-beta.4",
   "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": {

package/dist/lib/dotenv.js

@@ -1,31 +0,0 @@
-// Tiny .env reader/writer. Used by `metro setup` (read/write the global
-// config file) and by paths.ts (load env vars into process.env at startup).
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-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;
-}
-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);
-}
-// Load .env at `path` into process.env, but only for keys that aren't already
-// set — first definer wins, so callers control precedence by the order they
-// invoke this.
-export function loadDotenvIntoProcess(path) {
-    for (const [k, v] of Object.entries(readDotenv(path))) {
-        if (process.env[k] === undefined)
-            process.env[k] = v;
-    }
-}