@stage-labs/metro 0.1.0-beta.13 → 0.1.0-beta.15

package/dist/dispatcher.js

@@ -1,43 +1,26 @@
-/**
- * Daemon: chat inbound → JSON on stdout; optional codex-rc push; cross-user `notify` over Unix socket.
- */
-import { copyFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
+/** Daemon: supervises ~/.metro/trains/*, multiplexes their stdout to one JSON event stream, */
+/** routes outbound `forward-call` IPC back to trains' stdin. Two builtin event sources stay */
+/** in core: the HTTP webhook receiver + cross-user `notify` IPC. */
+import { join } from 'node:path';
 import pkg from '../package.json' with { type: 'json' };
-import { DiscordStation } from './stations/discord.js';
-import { TelegramStation } from './stations/telegram.js';
-import { WebhookStation } from './stations/webhook.js';
-import { asLine, Line } from './stations/index.js';
-import { CodexRC } from './codex-rc.js';
+import { Line } from './lines.js';
+import { CodexRC } from './codex-rc/client.js';
 import { startIpcServer, stopIpcServer } from './ipc.js';
-import { userSelf, appendHistory, formatDisplay, mintId, selfLine } from './history.js';
-import { noteSeen, saveBotId } from './cache.js';
+import { mintId, noteUserFromLine, selfLine, userSelf } from './history.js';
 import { errMsg, log } from './log.js';
-import { acquireLock, configuredPlatforms, loadMetroEnv, STATE_DIR, requireConfiguredPlatform } from './paths.js';
-import { setCodexSessionId } from './stations/codex.js';
-import { noteUserFromLine } from './registry.js';
-import { listEndpoints, webhookPort } from './webhooks.js';
-import { loadTunnelConfig, Tunnel } from './tunnel.js';
+import { acquireLock, loadMetroEnv, STATE_DIR } from './paths.js';
+import { setCodexSessionId } from './local-identity.js';
+import { loadTunnelConfig, Tunnel, webhookPort } from './tunnel.js';
+import { TrainSupervisor, TRAINS_DIR } from './trains/supervisor.js';
+import { makeEmit, startWebhookServer, trainEventToHistoryEntry } from './dispatcher/server.js';
 loadMetroEnv();
-const platforms = configuredPlatforms();
-const endpoints = listEndpoints();
-requireConfiguredPlatform(platforms, endpoints.length > 0);
 acquireLock(join(STATE_DIR, '.tail-lock'));
-// Fail fast if launched from Claude Code without a logged-in account.
 const self = userSelf();
 log.info({ self, line: selfLine() }, 'user identity');
 const seedSelf = () => { const l = selfLine(); if (l)
     noteUserFromLine(l); };
 seedSelf();
-const USERS_MD = join(STATE_DIR, 'USERS.md');
-try {
-    copyFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'docs', 'users.md'), USERS_MD);
-}
-catch (err) {
-    log.warn({ err: errMsg(err), path: USERS_MD }, 'failed to install user skill');
-}
-/** Suppress EPIPE so the daemon survives the user (Monitor reader) restarting / dying. */
+/** Suppress EPIPE so the daemon survives the reader (Monitor) restarting. */
 process.stdout.on('error', err => {
     if (err.code !== 'EPIPE')
         log.warn({ err: errMsg(err) }, 'stdout error');
@@ -45,66 +28,54 @@ process.stdout.on('error', err => {
 const codexRc = process.env.METRO_CODEX_RC ? new CodexRC(process.env.METRO_CODEX_RC, pkg.version) : null;
 codexRc?.onThread(id => { setCodexSessionId(id); seedSelf(); });
 codexRc?.start();
-const discord = new DiscordStation();
-const telegram = new TelegramStation();
-const webhook = new WebhookStation();
+const supervisor = new TrainSupervisor();
+const emit = makeEmit(codexRc);
+supervisor.onTrainEvent((env, train) => {
+    const entry = trainEventToHistoryEntry(env, train);
+    if (entry)
+        emit(entry);
+});
+let webhookServer = null;
 const tunnelCfg = loadTunnelConfig();
 const tunnel = tunnelCfg ? new Tunnel(tunnelCfg, webhookPort()) : null;
-function emit(entry) {
-    /** `display` first so it survives Monitor's ~500-char body truncation — the user must see it to echo it. */
-    const enriched = { display: formatDisplay(entry), ...entry };
-    const json = JSON.stringify(enriched);
-    process.stdout.write(json + '\n');
-    codexRc?.push(json);
-    noteSeen(entry.line, entry.lineName);
-    for (const l of [entry.line, entry.from, entry.to])
-        if (l)
-            noteUserFromLine(l);
-    appendHistory(enriched);
-}
-const destinationFor = (m) => m.isPrivate ? userSelf() : m.line;
-const onInbound = (m) => emit({ ...m, kind: 'inbound', to: destinationFor(m) });
-const onReaction = (r) => emit({ ...r, kind: 'react', to: destinationFor(r) });
 const ipc = startIpcServer(async (req) => {
     if (req.op === 'notify') {
-        const line = asLine(req.line);
+        const line = req.line;
         emit({
-            id: mintId(), ts: new Date().toISOString(), kind: 'inbound',
+            id: mintId(), ts: new Date().toISOString(),
             station: Line.station(line) ?? '?', line,
-            from: req.from ? asLine(req.from) : userSelf(), to: line, text: req.text,
+            from: (req.from ?? userSelf()), to: line, text: req.text,
         });
         return { ok: true };
     }
-    if (req.op === 'download') {
-        const line = asLine(req.line);
-        const station = req.line.startsWith('metro://telegram/') ? telegram : discord;
-        const files = await station.download(line, req.messageId, req.outDir);
-        return { ok: true, files };
+    if (req.op === 'forward-call') {
+        try {
+            const r = await supervisor.call(req.train, req.action, req.args);
+            return { ok: true, response: r };
+        }
+        catch (err) {
+            return { ok: false, error: errMsg(err) };
+        }
     }
-    return { ok: false, error: 'unknown op' };
-});
-async function main() {
-    if (platforms.discord) {
-        discord.onMessage(onInbound);
-        discord.onReaction(onReaction);
-        const [, me] = await Promise.all([discord.start(), discord.getMe()]);
-        saveBotId('discord', me.id);
-        log.info({ bot: me.username }, 'discord ready');
-    }
-    if (platforms.telegram) {
-        telegram.onMessage(onInbound);
-        telegram.onReaction(onReaction);
-        const [me] = await Promise.all([telegram.getMe(), telegram.start()]);
-        saveBotId('telegram', String(me.id));
-        log.info({ bot: `@${me.username}` }, 'telegram ready');
+    if (req.op === 'trains-list') {
+        return { ok: true, trains: supervisor.list() };
     }
-    /** Start the HTTP receiver only when ≥1 endpoint is registered — no point binding a port nobody listens to. */
-    if (endpoints.length) {
-        webhook.onMessage(onInbound);
-        await webhook.start();
-        tunnel?.start();
+    if (req.op === 'train-restart') {
+        try {
+            await supervisor.restart(req.name);
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: false, error: errMsg(err) };
+        }
     }
-    log.info({ codexRc: !!codexRc, tunnel: !!tunnel }, 'dispatcher ready');
+    return { ok: false, error: `unknown op: ${req.op ?? '(none)'}` };
+});
+async function main() {
+    supervisor.start();
+    webhookServer = await startWebhookServer(emit);
+    tunnel?.start();
+    log.info({ codexRc: !!codexRc, tunnel: !!tunnel, trainsDir: TRAINS_DIR }, 'dispatcher ready');
 }
 let shuttingDown = false;
 async function shutdown() {
@@ -115,11 +86,9 @@ async function shutdown() {
     codexRc?.stop();
     tunnel?.stop();
     await stopIpcServer(ipc).catch(() => { });
-    await webhook.stop().catch(() => { });
-    if (platforms.discord)
-        await discord.stop().catch(() => { });
-    if (platforms.telegram)
-        await telegram.stop().catch(() => { });
+    if (webhookServer)
+        await new Promise(r => webhookServer.close(() => r()));
+    await supervisor.stop();
     process.exit(0);
 }
 process.stdin.on('end', shutdown).on('close', shutdown);

package/dist/history.js

@@ -1,27 +1,25 @@
 /** Append-only JSONL history of every message that flows through metro (inbound + outbound). */
 import { randomBytes } from 'node:crypto';
-import { appendFileSync, existsSync, readFileSync } from 'node:fs';
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { errMsg, log } from './log.js';
 import { STATE_DIR } from './paths.js';
-import { Line } from './stations/index.js';
-import { claudeUserId, claudeSessionId } from './stations/claude.js';
-import { codexUserId, codexSessionId } from './stations/codex.js';
-/** Pre-render a chat-bubble line — the user echoes `event.display` verbatim instead of composing markdown itself. */
+import { Line } from './lines.js';
+import { claudeUserId, claudeSessionId, codexUserId, codexSessionId } from './local-identity.js';
+/** Pre-render a chat-bubble line. Direction is derived: from === local agent → outbound (📤), else inbound (📩). */
 export function formatDisplay(e) {
     const headerFor = (icon, parts) => `**${icon} ${parts.filter(Boolean).join(' · ')}**`;
-    const body = e.text ?? (e.emoji ? `[react ${e.emoji}]` : '');
-    if (e.kind === 'inbound' && e.station === 'webhook') {
+    const body = e.text ?? '';
+    if (e.station === 'webhook' && !Line.isLocal(e.from)) {
         const ev = e.payload
             ?.headers?.['x-github-event'] ?? e.payload
             ?.headers?.['x-intercom-topic'];
         return `${headerFor('🪝', ['webhook', e.lineName, ev])}\n> ${body}`;
     }
-    if (e.kind === 'inbound' || (e.kind === 'react' && !Line.isLocal(e.from))) {
-        const reactBody = e.kind === 'react' ? `reacted ${e.emoji ?? ''}`.trim() : body;
-        return `${headerFor('📩', [e.station, e.fromName ?? e.from, e.lineName])}\n> ${reactBody}`;
+    if (Line.isLocal(e.from)) {
+        return `${headerFor('📤', [e.station, '→', e.fromName ?? e.to])}\n> ${body}`;
     }
-    return `${headerFor('📤', [e.station, '→', e.fromName ?? e.to])}\n> ${body}`;
+    return `${headerFor('📩', [e.station, e.fromName ?? e.from, e.lineName])}\n> ${body}`;
 }
 const FILE = join(STATE_DIR, 'history.jsonl');
 /** Mint a universal metro message ID. Short, prefixed, URL-safe. */
@@ -72,8 +70,6 @@ function matches(e, f) {
         return false;
     if (f.station && e.station !== f.station)
         return false;
-    if (f.kind && e.kind !== f.kind)
-        return false;
     if (f.from && e.from !== f.from)
         return false;
     if (f.textContains && !(e.text ?? '').toLowerCase().includes(f.textContains.toLowerCase()))
@@ -82,20 +78,6 @@ function matches(e, f) {
         return false;
     return true;
 }
-/** Find an entry by universal id OR platform message id. */
-export function lookupEntry(id) {
-    const entries = readHistory({ limit: 5_000 });
-    return entries.find(e => e.id === id || e.messageId === id);
-}
-/** Look up the platform messageId for a universal `msg_*` id; returns the input unchanged otherwise. */
-export function resolvePlatformId(id) {
-    if (!id.startsWith('msg_'))
-        return id;
-    const hit = lookupEntry(id);
-    if (hit?.messageId)
-        return hit.messageId;
-    throw new Error(`unknown universal id: ${id} (run \`metro history --limit=50\` to see recent ids)`);
-}
 /** The current user's **participant** URI for `from`/`to`. Precedence: METRO_FROM > runtime env > generic. */
 export function userSelf() {
     const explicit = process.env.METRO_FROM;
@@ -119,3 +101,43 @@ export function selfLine() {
     }
     return null;
 }
+/* ──────────── user-registry: append-only (station, userId, sessions[]) tuples ──────────── */
+const REGISTRY_FILE = join(STATE_DIR, 'user-registry.json');
+function readRegistry() {
+    if (!existsSync(REGISTRY_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(REGISTRY_FILE, 'utf8'));
+    }
+    catch (err) {
+        log.warn({ err: errMsg(err) }, 'user-registry: malformed, resetting');
+        return {};
+    }
+}
+function record(station, userId, sessionId) {
+    const reg = readRegistry();
+    const rows = (reg[station] ??= []);
+    let row = rows.find(r => r.userId === userId);
+    if (!row) {
+        row = { userId, sessions: [], lastSeen: '' };
+        rows.push(row);
+    }
+    if (sessionId && !row.sessions.includes(sessionId))
+        row.sessions.push(sessionId);
+    row.lastSeen = new Date().toISOString();
+    try {
+        writeFileSync(REGISTRY_FILE, JSON.stringify(reg, null, 2));
+    }
+    catch (err) {
+        log.warn({ err: errMsg(err) }, 'user-registry: write failed');
+    }
+}
+/** Scan a line URI for `(station, userId, sessionId)` and record it. No-op on non-user or participant URIs. */
+export function noteUserFromLine(line) {
+    const station = Line.station(line);
+    if (station !== 'claude' && station !== 'codex')
+        return;
+    const p = station === 'claude' ? Line.parseClaude(line) : Line.parseCodex(line);
+    if (p)
+        record(station, p.userId, p.sessionId);
+}

package/dist/ipc.js

@@ -1,4 +1,5 @@
-/** Unix-socket IPC: `notify` re-emits on daemon stdout; `download` resolves Telegram attachments. */
+/** Unix-socket IPC: `notify` re-emits a cross-user message, `forward-call` reaches a train's */
+/** stdin and awaits its response, `trains-list` snapshots supervisor state. */
 import { createConnection, createServer } from 'node:net';
 import { existsSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
@@ -27,24 +28,31 @@ export async function stopIpcServer(server) {
     catch { /* ignore */ }
 }
 async function handleConnection(socket, handler) {
+    /** Newline-delimited request/response. Avoids races between `end()` writes and FIN under Bun. */
     let buf = '';
     socket.setEncoding('utf8');
-    socket.on('data', chunk => { buf += chunk; });
-    socket.on('end', async () => {
+    socket.on('data', async (chunk) => {
+        buf += chunk;
+        const nl = buf.indexOf('\n');
+        if (nl === -1)
+            return;
+        const line = buf.slice(0, nl).trim();
+        buf = buf.slice(nl + 1);
         let resp;
         try {
-            const req = JSON.parse(buf.trim());
+            const req = JSON.parse(line);
             resp = await handler(req);
         }
         catch (err) {
             resp = { ok: false, error: errMsg(err) };
         }
-        socket.end(JSON.stringify(resp) + '\n');
+        socket.write(JSON.stringify(resp) + '\n');
+        socket.end();
     });
     socket.on('error', err => log.debug({ err: errMsg(err) }, 'ipc connection error'));
 }
 /** CLI-side: send one request, get one response. Throws if the daemon isn't running. */
-export function ipcCall(req, timeoutMs = 30_000) {
+export function ipcCall(req, timeoutMs = 60_000) {
     return new Promise((resolve, reject) => {
         if (!existsSync(SOCKET_PATH)) {
             reject(new Error('metro daemon is not running (start it with `metro`)'));
@@ -56,17 +64,27 @@ export function ipcCall(req, timeoutMs = 30_000) {
             socket.destroy();
             reject(new Error(`ipc timeout after ${timeoutMs}ms`));
         }, timeoutMs);
-        socket.on('connect', () => { socket.end(JSON.stringify(req)); });
-        socket.on('data', chunk => { buf += chunk.toString('utf8'); });
-        socket.on('end', () => {
+        socket.on('connect', () => { socket.write(JSON.stringify(req) + '\n'); });
+        socket.on('data', chunk => {
+            buf += chunk.toString('utf8');
+            const nl = buf.indexOf('\n');
+            if (nl === -1)
+                return;
             clearTimeout(timer);
+            const line = buf.slice(0, nl).trim();
+            socket.end();
             try {
-                resolve(JSON.parse(buf.trim()));
+                resolve(JSON.parse(line));
             }
             catch (err) {
                 reject(new Error(`ipc bad response: ${errMsg(err)}`));
             }
         });
+        socket.on('end', () => {
+            clearTimeout(timer);
+            if (!buf)
+                reject(new Error('ipc connection closed without response'));
+        });
         socket.on('error', err => { clearTimeout(timer); reject(err); });
     });
 }

package/dist/lines.js

@@ -0,0 +1,54 @@
+/** Line URI helpers. The whole metro:// vocabulary. */
+export const asLine = (s) => s;
+const PREFIX = 'metro://';
+const build = (station, ...seg) => asLine(`${PREFIX}${station}/${seg.map(String).join('/')}`);
+/** Shared parser for `metro://{claude,codex}/<userId>/<sessionId>`. Skips the `/user/…` participant URI. */
+function parseLocalSession(line, station) {
+    const p = Line.parse(line);
+    if (p?.station !== station || p.path[0] === 'user' || p.path.length < 2)
+        return null;
+    return { userId: p.path[0], sessionId: p.path[1] };
+}
+/** URI helpers. Lives on a const that doubles as the `Line` type's value-side namespace. */
+export const Line = {
+    discord: (channelId) => build('discord', channelId),
+    telegram: (chatId, topicId) => topicId !== undefined ? build('telegram', chatId, topicId) : build('telegram', chatId),
+    claude: (orgId, sessionId) => build('claude', orgId, sessionId),
+    codex: (accountId, threadId) => build('codex', accountId, threadId),
+    webhook: (endpointId) => build('webhook', endpointId),
+    /** Participant URI — `metro://<station>/user/<id>`. */
+    user: (station, id) => build(station, 'user', id),
+    parse(line) {
+        if (!line.startsWith(PREFIX))
+            return null;
+        const rest = line.slice(PREFIX.length);
+        const slash = rest.indexOf('/');
+        if (slash <= 0)
+            return null;
+        const path = rest.slice(slash + 1).split('/').filter(Boolean);
+        return path.length ? { station: rest.slice(0, slash), path } : null;
+    },
+    station: (line) => Line.parse(line)?.station ?? null,
+    parseTelegram(line) {
+        const p = Line.parse(line);
+        if (p?.station !== 'telegram')
+            return null;
+        const chatId = Number(p.path[0]);
+        if (!Number.isFinite(chatId))
+            return null;
+        if (p.path.length === 1)
+            return { chatId };
+        const topicId = Number(p.path[1]);
+        return Number.isFinite(topicId) ? { chatId, topicId } : null;
+    },
+    parseClaude: (line) => parseLocalSession(line, 'claude'),
+    parseCodex: (line) => parseLocalSession(line, 'codex'),
+    parseWebhook(line) {
+        const p = Line.parse(line);
+        return p?.station === 'webhook' && p.path.length === 1 ? p.path[0] : null;
+    },
+    isLocal: (line) => {
+        const s = Line.station(line);
+        return s === 'claude' || s === 'codex';
+    },
+};

package/dist/local-identity.js

@@ -0,0 +1,80 @@
+/** Resolve the local user identity for Claude Code / Codex hosts — used to mint */
+/** `metro://claude/<orgId>/<sessionId>` and `metro://codex/<accountId>/<threadId>` URIs. */
+import { execFileSync } from 'node:child_process';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { STATE_DIR } from './paths.js';
+const TTL_MS = 5_000;
+/** Memoize an account-id resolver for TTL_MS to avoid hammering `claude auth` / re-reading auth.json. */
+function memo(loader) {
+    let cache = null;
+    return () => {
+        if (cache && Date.now() - cache.at < TTL_MS)
+            return cache.id;
+        const id = loader();
+        cache = { id, at: Date.now() };
+        return id;
+    };
+}
+const claudeAccountId = memo(() => {
+    let raw;
+    try {
+        raw = execFileSync('claude', ['auth', 'status', '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    }
+    catch (e) {
+        throw new Error(`metro: failed to run 'claude auth status --json' — is Claude Code installed? (${e.message})`);
+    }
+    let p;
+    try {
+        p = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`metro: 'claude auth status --json' returned non-JSON: ${raw.slice(0, 200)}`);
+    }
+    if (!p.loggedIn || !p.orgId)
+        throw new Error('metro: Claude Code is not logged in — run \'claude auth login\'');
+    return p.orgId;
+});
+const codexAccountId = memo(() => {
+    const path = join(process.env.CODEX_HOME || join(homedir(), '.codex'), 'auth.json');
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch (e) {
+        throw new Error(`metro: failed to read ${path} — is Codex logged in? (${e.message})`);
+    }
+    let p;
+    try {
+        p = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`metro: ${path} is not valid JSON`);
+    }
+    const id = p.tokens?.account_id;
+    if (!id)
+        throw new Error(`metro: no Codex account_id in ${path} (auth_mode=${p.auth_mode ?? 'unknown'}) — sign in with 'codex login' (ChatGPT mode required)`);
+    return id;
+});
+export const claudeUserId = () => process.env.METRO_USER_ID || claudeAccountId();
+export const codexUserId = () => process.env.METRO_USER_ID || codexAccountId();
+export const claudeSessionId = () => process.env.METRO_USER_SESSION_ID || process.env.CLAUDE_CODE_SESSION_ID || null;
+const CODEX_SESSION_FILE = join(STATE_DIR, 'codex-session-id');
+export function codexSessionId() {
+    if (process.env.METRO_USER_SESSION_ID)
+        return process.env.METRO_USER_SESSION_ID;
+    try {
+        return readFileSync(CODEX_SESSION_FILE, 'utf8').trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function setCodexSessionId(threadId) {
+    try {
+        mkdirSync(dirname(CODEX_SESSION_FILE), { recursive: true });
+        writeFileSync(CODEX_SESSION_FILE, threadId ?? '');
+    }
+    catch { /* CLI just won't have a session segment */ }
+}

package/dist/paths.js

@@ -1,11 +1,13 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { log } from './log.js';
+import { errMsg, log } from './log.js';
 export const STATE_DIR = process.env.METRO_STATE_DIR ?? join(homedir(), '.cache', 'metro');
 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');
+/** Train-owned env file. Trains read their tokens from here (passed through via process.env). */
+const TRAINS_ENV_FILE = join(homedir(), '.metro', '.env');
 const LINE_RE = /^\s*([A-Za-z_]\w*)\s*=\s*(.*?)\s*$/;
 const QUOTED_RE = /^(['"])(.*)\1$/;
 export function readDotenv(path) {
@@ -24,24 +26,16 @@ export function writeDotenv(path, env) {
     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. */
+/** Precedence: process.env > cwd/.env > ~/.metro/.env > $METRO_CONFIG_DIR/.env. First-set wins. */
+/** ~/.metro/.env is the canonical location for train credentials. */
 export function loadMetroEnv() {
-    for (const path of [join(process.cwd(), '.env'), CONFIG_ENV_FILE]) {
+    for (const path of [join(process.cwd(), '.env'), TRAINS_ENV_FILE, 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 };
-}
-export function requireConfiguredPlatform(p, hasWebhooks) {
-    if (p.telegram || p.discord || hasWebhooks)
-        return;
-    log.fatal('no inputs configured — run `metro setup telegram <token>`, `metro setup discord <token>`, or `metro webhook add <label>`');
-    process.exit(2);
-}
 /** Singleton pidfile. Exits if another instance owns it; reclaims stale locks. */
 export function acquireLock(lockFile) {
     if (existsSync(lockFile)) {
@@ -66,3 +60,55 @@ export function acquireLock(lockFile) {
     }
     catch { /* ignore */ } });
 }
+const cacheFile = join(STATE_DIR, 'lines.json');
+const FLUSH_DELAY_MS = 5_000;
+let cache = null;
+let dirty = false;
+let flushTimer = null;
+function readCache() {
+    if (cache)
+        return cache;
+    if (!existsSync(cacheFile))
+        return cache = {};
+    try {
+        cache = JSON.parse(readFileSync(cacheFile, 'utf8'));
+    }
+    catch (err) {
+        log.warn({ err: errMsg(err), path: cacheFile }, 'lines cache read failed; treating as empty');
+        cache = {};
+    }
+    return cache;
+}
+function flush() {
+    if (!dirty || !cache)
+        return;
+    try {
+        writeFileSync(cacheFile, JSON.stringify(cache, null, 2));
+        dirty = false;
+    }
+    catch (err) {
+        log.warn({ err: errMsg(err), path: cacheFile }, 'lines cache write failed');
+    }
+}
+process.on('exit', flush);
+export function noteSeen(line, name) {
+    const c = readCache();
+    const entry = c[line] ??= { createdAt: new Date().toISOString() };
+    entry.lastSeenAt = new Date().toISOString();
+    if (name && entry.name !== name)
+        entry.name = name;
+    dirty = true;
+    if (!flushTimer)
+        flushTimer = setTimeout(() => { flushTimer = null; flush(); }, FLUSH_DELAY_MS);
+}
+export const listLines = () => Object.entries(readCache()).map(([line, entry]) => ({ line: line, entry }));
+/** Bot identity cache: `{discord: "<userId>", telegram: "<userId>"}`. Trains may populate this. */
+const botIdsFile = join(STATE_DIR, 'bot-ids.json');
+export const readBotIds = () => {
+    try {
+        return existsSync(botIdsFile) ? JSON.parse(readFileSync(botIdsFile, 'utf8')) : {};
+    }
+    catch {
+        return {};
+    }
+};