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

package/dist/helpers/turn.js

@@ -1,40 +0,0 @@
-/** 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/orchestrator.js

@@ -1,208 +0,0 @@
-/** 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();