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

package/dist/dispatcher.js

@@ -1,97 +0,0 @@
-/** 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 { Line } from './lines.js';
-import { CodexRC } from './codex-rc/client.js';
-import { startIpcServer, stopIpcServer } from './ipc.js';
-import { mintId, noteUserFromLine, selfLine, userSelf } from './history.js';
-import { errMsg, log } from './log.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();
-acquireLock(join(STATE_DIR, '.tail-lock'));
-const self = userSelf();
-log.info({ self, line: selfLine() }, 'user identity');
-const seedSelf = () => { const l = selfLine(); if (l)
-    noteUserFromLine(l); };
-seedSelf();
-/** 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');
-});
-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 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;
-const ipc = startIpcServer(async (req) => {
-    if (req.op === 'notify') {
-        const line = req.line;
-        emit({
-            id: mintId(), ts: new Date().toISOString(),
-            station: Line.station(line) ?? '?', line,
-            from: (req.from ?? userSelf()), to: line, text: req.text,
-        });
-        return { ok: true };
-    }
-    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) };
-        }
-    }
-    if (req.op === 'trains-list') {
-        return { ok: true, trains: supervisor.list() };
-    }
-    if (req.op === 'train-restart') {
-        try {
-            await supervisor.restart(req.name);
-            return { ok: true };
-        }
-        catch (err) {
-            return { ok: false, error: errMsg(err) };
-        }
-    }
-    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() {
-    if (shuttingDown)
-        return;
-    shuttingDown = true;
-    log.info('dispatcher shutting down');
-    codexRc?.stop();
-    tunnel?.stop();
-    await stopIpcServer(ipc).catch(() => { });
-    if (webhookServer)
-        await new Promise(r => webhookServer.close(() => r()));
-    await supervisor.stop();
-    process.exit(0);
-}
-process.stdin.on('end', shutdown).on('close', shutdown);
-for (const sig of ['SIGINT', 'SIGTERM'])
-    process.on(sig, shutdown);
-await main();

package/dist/history.js

@@ -1,143 +0,0 @@
-/** Append-only JSONL history of every message that flows through metro (inbound + outbound). */
-import { randomBytes } from 'node:crypto';
-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 './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 ?? '';
-    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 (Line.isLocal(e.from)) {
-        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. */
-export const mintId = () => `msg_${randomBytes(6).toString('base64url')}`;
-/** Append one entry as a JSON line. POSIX-atomic for sub-PIPE_BUF writes (we're well under). */
-export function appendHistory(entry) {
-    try {
-        appendFileSync(FILE, JSON.stringify(entry) + '\n');
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err), path: FILE }, 'history append failed');
-    }
-}
-/** Read JSONL, parse, filter (most-recent-first), apply `skip` then `limit`. Empty array if file is missing. */
-export function readHistory(filter = {}) {
-    if (!existsSync(FILE))
-        return [];
-    const lines = readFileSync(FILE, 'utf8').split('\n');
-    const out = [];
-    const skip = filter.skip ?? 0;
-    let skipped = 0;
-    /** Walk backwards so `limit` clamps without scanning the whole file body twice. */
-    for (let i = lines.length - 1; i >= 0; i--) {
-        const raw = lines[i].trim();
-        if (!raw)
-            continue;
-        let e;
-        try {
-            e = JSON.parse(raw);
-        }
-        catch {
-            continue;
-        }
-        if (!matches(e, filter))
-            continue;
-        if (skipped < skip) {
-            skipped++;
-            continue;
-        }
-        out.push(e);
-        if (filter.limit && out.length >= filter.limit)
-            break;
-    }
-    return out;
-}
-function matches(e, f) {
-    if (f.line && e.line !== f.line)
-        return false;
-    if (f.station && e.station !== f.station)
-        return false;
-    if (f.from && e.from !== f.from)
-        return false;
-    if (f.textContains && !(e.text ?? '').toLowerCase().includes(f.textContains.toLowerCase()))
-        return false;
-    if (f.since && new Date(e.ts) < f.since)
-        return false;
-    return true;
-}
-/** The current user's **participant** URI for `from`/`to`. Precedence: METRO_FROM > runtime env > generic. */
-export function userSelf() {
-    const explicit = process.env.METRO_FROM;
-    if (explicit)
-        return explicit;
-    if (process.env.CLAUDECODE)
-        return Line.user('claude', claudeUserId());
-    if (process.env.METRO_CODEX_RC || process.env.CODEX_HOME)
-        return Line.user('codex', codexUserId());
-    return 'metro://user';
-}
-/** The current user's **line** URI `<user-id>/<session>`. Null until session is known (rc thread pending). */
-export function selfLine() {
-    if (process.env.CLAUDECODE) {
-        const s = claudeSessionId();
-        return s ? Line.claude(claudeUserId(), s) : null;
-    }
-    if (process.env.METRO_CODEX_RC || process.env.CODEX_HOME) {
-        const s = codexSessionId();
-        return s ? Line.codex(codexUserId(), s) : null;
-    }
-    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,90 +0,0 @@
-/** 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';
-import { errMsg, log } from './log.js';
-import { STATE_DIR } from './paths.js';
-const SOCKET_PATH = join(STATE_DIR, 'metro.sock');
-export function startIpcServer(handler) {
-    if (existsSync(SOCKET_PATH)) {
-        try {
-            unlinkSync(SOCKET_PATH);
-        }
-        catch { /* ignore */ }
-    }
-    /** allowHalfOpen: any `await` in the handler races Node's auto-end-on-client-FIN, dropping the response. */
-    const server = createServer({ allowHalfOpen: true }, s => handleConnection(s, handler));
-    server.on('error', err => log.warn({ err: errMsg(err) }, 'ipc server error'));
-    server.listen(SOCKET_PATH, () => log.debug({ path: SOCKET_PATH }, 'ipc socket listening'));
-    return server;
-}
-export async function stopIpcServer(server) {
-    await new Promise(resolve => server.close(() => resolve()));
-    try {
-        if (existsSync(SOCKET_PATH))
-            unlinkSync(SOCKET_PATH);
-    }
-    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', 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(line);
-            resp = await handler(req);
-        }
-        catch (err) {
-            resp = { ok: false, error: errMsg(err) };
-        }
-        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 = 60_000) {
-    return new Promise((resolve, reject) => {
-        if (!existsSync(SOCKET_PATH)) {
-            reject(new Error('metro daemon is not running (start it with `metro`)'));
-            return;
-        }
-        const socket = createConnection({ path: SOCKET_PATH });
-        let buf = '';
-        const timer = setTimeout(() => {
-            socket.destroy();
-            reject(new Error(`ipc timeout after ${timeoutMs}ms`));
-        }, timeoutMs);
-        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(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

@@ -1,54 +0,0 @@
-/** 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

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

@@ -1,15 +0,0 @@
-/** Pino → stderr. TTY → pino-pretty (colorized, hostname/pid stripped); else JSON. */
-import pino from 'pino';
-import pinoPretty from 'pino-pretty';
-const stream = process.stderr.isTTY
-    ? pinoPretty({ colorize: true, translateTime: 'HH:MM:ss', ignore: 'pid,hostname,name', destination: 2 })
-    : pino.destination(2);
-/** `base: { name }` strips pino's default pid+hostname from JSON output too (not just from the TTY pretty stream). */
-export const log = pino({ base: { name: 'metro' }, level: process.env.METRO_LOG_LEVEL || 'info' }, stream);
-export const errMsg = (err) => {
-    if (err instanceof Error)
-        return err.message;
-    if (err && typeof err === 'object' && 'message' in err)
-        return String(err.message);
-    return String(err);
-};

package/dist/paths.js

@@ -1,114 +0,0 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-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) {
-    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/.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'), TRAINS_ENV_FILE, CONFIG_ENV_FILE]) {
-        for (const [k, v] of Object.entries(readDotenv(path))) {
-            if (process.env[k] === undefined)
-                process.env[k] = v;
-        }
-    }
-}
-/** 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 */ } });
-}
-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 {};
-    }
-};