@stage-labs/metro 0.1.0-beta.14 → 0.1.0-beta.16

package/dist/broker/claims.js

@@ -1,144 +0,0 @@
-/** Claims map: per-line owner registry under an O_EXCL lockfile. */
-import { closeSync, existsSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from 'node:fs';
-import { join } from 'node:path';
-import { log } from '../log.js';
-import { STATE_DIR } from '../paths.js';
-import { Line } from '../lines.js';
-export const CLAIMS_FILE = join(STATE_DIR, 'claims.json');
-const CLAIMS_LOCK = join(STATE_DIR, 'claims.json.lock');
-export const HISTORY_FILE = join(STATE_DIR, 'history.jsonl');
-/** Read claims.json. Returns empty map if missing or malformed (retries once on race). */
-export function readClaims() {
-    if (!existsSync(CLAIMS_FILE))
-        return {};
-    for (let attempt = 0; attempt < 2; attempt++) {
-        try {
-            return JSON.parse(readFileSync(CLAIMS_FILE, 'utf8'));
-        }
-        catch { /* race with writer — retry once */ }
-    }
-    log.warn({ path: CLAIMS_FILE }, 'claims: malformed, treating as empty');
-    return {};
-}
-/** Mutate claims under an O_EXCL lockfile. Throws if another writer holds the lock past timeout. */
-function withClaimsLock(fn) {
-    const deadline = Date.now() + 2_000;
-    while (true) {
-        try {
-            closeSync(openSync(CLAIMS_LOCK, 'wx'));
-            break;
-        }
-        catch (err) {
-            if (err.code !== 'EEXIST')
-                throw err;
-            if (Date.now() > deadline)
-                throw new Error('claims.json: lock contention (held >2s)');
-        }
-    }
-    try {
-        const next = readClaims();
-        const result = fn(next);
-        /** atomic publish: tmpfile + rename so readers never see a half-written file */
-        const tmp = `${CLAIMS_FILE}.tmp.${process.pid}`;
-        writeFileSync(tmp, JSON.stringify(next, null, 2) + '\n');
-        renameSync(tmp, CLAIMS_FILE);
-        return result;
-    }
-    finally {
-        try {
-            unlinkSync(CLAIMS_LOCK);
-        }
-        catch { /* ignore */ }
-    }
-}
-export function claimLine(line, owner) {
-    return withClaimsLock(m => { m[line] = owner; return m; });
-}
-export function releaseLine(line) {
-    return withClaimsLock(m => {
-        const released = line in m;
-        delete m[line];
-        return { released, claims: m };
-    });
-}
-/** Classify a chat line as DM/group/unknown for the auto-claim group-skip rule. */
-/** TG: chatId<0⇒group. Discord: peek payload.guildId on most-recent inbound. Claude/Codex⇒dm. */
-export function classifyLine(line) {
-    const station = Line.station(line);
-    if (station === 'telegram') {
-        const parsed = Line.parseTelegram(line);
-        if (!parsed)
-            return 'unknown';
-        return parsed.chatId < 0 ? 'group' : 'dm';
-    }
-    if (station === 'claude' || station === 'codex')
-        return 'dm';
-    if (station === 'webhook')
-        return 'group';
-    if (station === 'discord') {
-        /** Lazy tail-scan of history.jsonl to avoid a static dep on the history filter helpers. */
-        const recent = readRecentInbound(line);
-        if (!recent)
-            return 'unknown';
-        const payload = recent.payload;
-        if (!payload || !('guildId' in payload)) {
-            /** Older entries may not have a guildId — fall back to the `to` field: DMs route to a user URI. */
-            if (recent.to && recent.to !== recent.line)
-                return 'dm';
-            return 'unknown';
-        }
-        return payload.guildId == null ? 'dm' : 'group';
-    }
-    return 'unknown';
-}
-/** Most-recent inbound on `line`. Walks `history.jsonl` from the tail; returns undefined if missing. */
-function readRecentInbound(line) {
-    if (!existsSync(HISTORY_FILE))
-        return undefined;
-    const lines = readFileSync(HISTORY_FILE, 'utf8').split('\n');
-    for (let i = lines.length - 1; i >= 0; i--) {
-        if (!lines[i].trim())
-            continue;
-        try {
-            const e = JSON.parse(lines[i]);
-            if (e.line === line && e.kind === 'inbound')
-                return e;
-        }
-        catch { /* skip */ }
-    }
-    return undefined;
-}
-/** Per-line decision: should auto-claim run on a successful outbound? */
-function shouldAutoClaim(line, kind) {
-    const station = Line.station(line);
-    /** Webhook lines are a broadcast stream — claiming one is a footgun. */
-    if (station === 'webhook')
-        return { ok: false, reason: 'webhook' };
-    /** Claude/Codex cross-user lines are 1:1 by construction — always safe. */
-    if (station === 'claude' || station === 'codex')
-        return { ok: true };
-    if (kind === 'group')
-        return { ok: false, reason: 'group' };
-    return { ok: true };
-}
-export function tryAutoClaim(line, owner, opts = {}) {
-    if (!opts.force) {
-        const decision = shouldAutoClaim(line, opts.lineKind ?? 'unknown');
-        if (!decision.ok)
-            return { status: decision.reason, line };
-    }
-    try {
-        return withClaimsLock(m => {
-            const existing = m[line];
-            if (existing && existing !== owner)
-                return { status: 'skipped', existing };
-            if (existing === owner)
-                return { status: 'kept', owner };
-            m[line] = owner;
-            return { status: 'claimed', owner };
-        });
-    }
-    catch (err) {
-        return { status: 'error', error: err.message };
-    }
-}

package/dist/broker/history-stream.js

@@ -1,147 +0,0 @@
-/** Per-user byte-offset cursors over history.jsonl + claim-aware mode filter. */
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, renameSync, watch, writeFileSync, } from 'node:fs';
-import { join } from 'node:path';
-import { errMsg, log } from '../log.js';
-import { STATE_DIR } from '../paths.js';
-import { HISTORY_FILE, readClaims } from './claims.js';
-const CURSORS_DIR = join(STATE_DIR, 'cursors');
-/** Filename-safe slug for a participant URI. `metro://claude/user/9bfc…` → `claude-user-9bfc…`. */
-export function userSlug(uri) {
-    return uri.replace(/^metro:\/+/, '').replace(/[^A-Za-z0-9_.-]/g, '-');
-}
-/** Cursor key for a tail invocation. Derived from the *effective mode*, NOT from `userSelf()`. */
-/** Keeps `--all` / `--unclaimed` from trampling a `--as=<id>` cursor in a CLAUDECODE shell. */
-/** Keys: `--as=<id>`→slug(id); `+--strict`→slug+`--strict`; `--unclaimed`→`_unclaimed`; `--all`→`_all`. */
-/** The `_` prefix can't collide with a userSlug (always has a station prefix like `claude-user-…`). */
-/** `--include-webhooks` adds `--with-webhooks` so toggling mid-stream doesn't re-emit/skip events. */
-export function cursorKey(mode, self, opts = {}) {
-    if (mode === 'all')
-        return '_all';
-    if (mode === 'unclaimed')
-        return '_unclaimed';
-    if (!self)
-        return null;
-    const base = userSlug(self);
-    const suffix = mode === 'mine-only' ? '--strict' : '';
-    const webhooks = opts.includeWebhooks ? '--with-webhooks' : '';
-    return `${base}${suffix}${webhooks}`;
-}
-const cursorPath = (key) => join(CURSORS_DIR, key);
-export function readCursor(key) {
-    const p = cursorPath(key);
-    if (!existsSync(p))
-        return 0;
-    const n = Number(readFileSync(p, 'utf8').trim());
-    return Number.isFinite(n) && n >= 0 ? n : 0;
-}
-export function writeCursor(key, offset) {
-    mkdirSync(CURSORS_DIR, { recursive: true });
-    const p = cursorPath(key);
-    const tmp = `${p}.tmp.${process.pid}`;
-    writeFileSync(tmp, String(offset));
-    renameSync(tmp, p);
-}
-/** Byte size of history.jsonl right now (for `--since=tail`). */
-export function historySize() {
-    if (!existsSync(HISTORY_FILE))
-        return 0;
-    try {
-        return readFileSync(HISTORY_FILE).length;
-    }
-    catch {
-        return 0;
-    }
-}
-/** Yield each complete JSONL line from `offset` to EOF; the returned offset is the position right after the `\n`. */
-export function* readEntriesFrom(offset) {
-    if (!existsSync(HISTORY_FILE))
-        return;
-    const fd = openSync(HISTORY_FILE, 'r');
-    try {
-        const chunk = Buffer.alloc(64 * 1024);
-        let pending = Buffer.alloc(0);
-        let pos = offset;
-        while (true) {
-            const n = readSync(fd, chunk, 0, chunk.length, pos);
-            if (n === 0)
-                break;
-            pending = Buffer.concat([pending, chunk.subarray(0, n)]);
-            pos += n;
-            let nl;
-            while ((nl = pending.indexOf(0x0a)) !== -1) {
-                const raw = pending.subarray(0, nl).toString('utf8').trim();
-                pending = pending.subarray(nl + 1);
-                if (!raw)
-                    continue;
-                try {
-                    const entry = JSON.parse(raw);
-                    /** offsetAfter = read-cursor in file - bytes still in pending buffer */
-                    yield { entry, offset: pos - pending.length };
-                }
-                catch (err) {
-                    log.warn({ err: errMsg(err) }, 'broker: skipped malformed history line');
-                }
-            }
-        }
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-/**
- * Claim-aware filter. Webhooks excluded from personal modes unless `includeWebhooks`.
- */
-export function passesMode(event, mode, self, claims, opts = {}) {
-    if (self && event.to === self)
-        return true;
-    if (mode === 'all')
-        return true;
-    const isWebhook = event.station === 'webhook';
-    if (mode === 'unclaimed')
-        return !claims[event.line];
-    /** webhooks are filtered out of personal modes unless opted in */
-    if (isWebhook && !opts.includeWebhooks)
-        return false;
-    const owner = claims[event.line];
-    if (mode === 'mine-only')
-        return owner === self;
-    return !owner || owner === self; /** mode === 'mine-or-unclaimed' */
-}
-/** Drain matching entries from `offset` to EOF, returning the new offset. */
-/** Caller `onEntry` may return `true` to stop draining early (e.g. tail --limit). */
-export function drainTail(offset, opts, onEntry) {
-    const claims = readClaims();
-    for (const { entry, offset: next } of readEntriesFrom(offset)) {
-        offset = next;
-        if (opts.chatFilter && entry.line !== opts.chatFilter)
-            continue;
-        if (opts.stationFilter && entry.station !== opts.stationFilter)
-            continue;
-        if (!passesMode(entry, opts.mode, opts.self, claims, { includeWebhooks: opts.includeWebhooks }))
-            continue;
-        if (onEntry(entry) === true)
-            return offset;
-    }
-    return offset;
-}
-/** Follow history.jsonl: drain on change + poll backstop (macOS fs.watch coalesces). */
-/** Caller invokes the returned `stop()` to clean up the watcher/timer. */
-export function followTail(startOffset, opts, onEntry, pollMs) {
-    let offset = startOffset;
-    const tick = () => { offset = drainTail(offset, opts, onEntry); };
-    let watcher = null;
-    try {
-        watcher = watch(HISTORY_FILE, () => tick());
-    }
-    catch { /* file may not exist yet */ }
-    const poll = setInterval(tick, pollMs);
-    return () => {
-        clearInterval(poll);
-        if (watcher) {
-            try {
-                watcher.close();
-            }
-            catch { /* ignore */ }
-        }
-    };
-}

package/dist/cli/config.js

@@ -1,179 +0,0 @@
-/** `metro setup` / `metro doctor` / `metro update` / `metro setup skill`. */
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync } from 'node:fs';
-import { spawn } from 'node:child_process';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import pkg from '../../package.json' with { type: 'json' };
-import { errMsg } from '../log.js';
-import { CONFIG_ENV_FILE, loadMetroEnv, STATE_DIR } from '../paths.js';
-import { TRAINS_DIR } from '../trains/supervisor.js';
-import { listEndpoints, loadTunnelConfig, webhookPort } from '../tunnel.js';
-import { emit, exitErr, isJson, writeJson } from './util.js';
-const RUNTIME_DIRS = {
-    'claude-code': join(homedir(), '.claude', 'skills', 'metro'),
-    codex: join(homedir(), '.codex', 'skills', 'metro'),
-};
-const skillDest = (r) => join(RUNTIME_DIRS[r], 'SKILL.md');
-/** dist/cli/config.js → <package-root>/skills/metro/SKILL.md */
-const bundledSkill = () => join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'skills', 'metro', 'SKILL.md');
-const skillStatus = () => ({
-    'claude-code': existsSync(skillDest('claude-code')), codex: existsSync(skillDest('codex')),
-});
-async function cmdSetupSkill(p, f) {
-    const sub = p[0];
-    if (sub === 'clear') {
-        const removed = [];
-        for (const r of Object.keys(RUNTIME_DIRS)) {
-            const path = skillDest(r);
-            if (existsSync(path)) {
-                try {
-                    unlinkSync(path);
-                    removed.push(path);
-                }
-                catch { /* ignore */ }
-            }
-        }
-        return emit(f, removed.length ? `removed metro skill from ${removed.join(', ')}` : 'no installed skill found', { ok: true, removed });
-    }
-    if (sub && sub !== 'install')
-        throw exitErr(`unknown skill subcommand '${sub}' (try: install, clear)`, 1);
-    const src = bundledSkill();
-    if (!existsSync(src))
-        throw exitErr(`bundled SKILL.md missing at ${src} (broken install?)`, 2);
-    const installed = [];
-    for (const r of Object.keys(RUNTIME_DIRS)) {
-        if (!existsSync(join(homedir(), r === 'claude-code' ? '.claude' : '.codex')))
-            continue;
-        const dest = skillDest(r);
-        try {
-            mkdirSync(RUNTIME_DIRS[r], { recursive: true });
-            copyFileSync(src, dest);
-            installed.push(dest);
-        }
-        catch (err) {
-            throw exitErr(`failed to install skill for ${r}: ${errMsg(err)}`, 2);
-        }
-    }
-    if (!installed.length)
-        throw exitErr('no user runtime detected (~/.claude or ~/.codex). Install one and rerun.', 2);
-    emit(f, `installed metro skill → ${installed.join(', ')}`, { ok: true, installed });
-}
-/** Scan ~/.metro/trains/*.{ts,js,mjs} for `process.env.<NAME>` refs; report set/unset status. */
-function envCheck() {
-    if (!existsSync(TRAINS_DIR))
-        return [];
-    const names = new Set();
-    for (const f of readdirSync(TRAINS_DIR).filter(n => /\.(ts|js|mjs)$/.test(n) && !/^[._]/.test(n))) {
-        try {
-            const src = readFileSync(join(TRAINS_DIR, f), 'utf8');
-            for (const m of src.matchAll(/process\.env\.([A-Z][A-Z0-9_]*)/g))
-                names.add(m[1]);
-        }
-        catch { /* ignore */ }
-    }
-    /** METRO_* are internal — don't surface them as "missing credentials". */
-    const interesting = [...names].filter(n => !n.startsWith('METRO_')).sort();
-    if (!interesting.length)
-        return [];
-    const set = interesting.filter(n => process.env[n]);
-    const missing = interesting.filter(n => !process.env[n]);
-    return [{ name: 'env-vars', ok: missing.length ? false : true,
-            detail: `set: ${set.join(', ') || '(none)'}${missing.length ? ` · missing: ${missing.join(', ')}` : ''}` }];
-}
-/* ──────────── setup / doctor / update ──────────── */
-export async function cmdSetup(p, f) {
-    const [sub] = p;
-    if (sub === 'skill')
-        return cmdSetupSkill(p.slice(1), f);
-    if (sub)
-        throw new Error(`unknown setup subcommand '${sub}' (try: skill)`);
-    loadMetroEnv();
-    const cfgExists = existsSync(CONFIG_ENV_FILE), trainsExists = existsSync(TRAINS_DIR);
-    if (isJson(f))
-        return writeJson({
-            version: pkg.version,
-            config_env_file: CONFIG_ENV_FILE, config_env_exists: cfgExists,
-            trains_dir: TRAINS_DIR, trains_dir_exists: trainsExists,
-        });
-    process.stdout.write(`metro ${pkg.version}\n\nconfig dir:  ${CONFIG_ENV_FILE}${cfgExists ? '' : ' (not yet written)'}\n`
-        + `trains dir:  ${TRAINS_DIR}${trainsExists ? '' : ' (will be created on first run)'}\n\n`
-        + 'Get started: see @stage-labs/metro/examples; drop train scripts in ~/.metro/trains/.\n');
-}
-export async function cmdDoctor(_, f) {
-    loadMetroEnv();
-    const checks = [];
-    if (!existsSync(TRAINS_DIR)) {
-        checks.push({ name: 'trains', ok: null, detail: `${TRAINS_DIR} (not created — \`mkdir -p\` it and drop in train files)` });
-    }
-    else {
-        const files = readdirSync(TRAINS_DIR).filter(n => /\.(ts|js|mjs)$/.test(n) && !/^[._]/.test(n));
-        checks.push({ name: 'trains', ok: files.length > 0,
-            detail: files.length ? `${files.length} train${files.length === 1 ? '' : 's'}: ${files.join(', ')}` : '(empty — no trains configured)' });
-    }
-    const metroPkg = join(homedir(), '.metro', 'package.json');
-    checks.push({ name: 'trains-pkg', ok: existsSync(metroPkg) ? true : null,
-        detail: existsSync(metroPkg) ? metroPkg : `${metroPkg} not found (run \`cd ~/.metro && bun init\` if any train needs deps)` });
-    const lockFile = join(STATE_DIR, '.tail-lock');
-    if (!existsSync(lockFile))
-        checks.push({ name: 'dispatcher', ok: null, detail: 'not running' });
-    else
-        try {
-            const pid = Number(readFileSync(lockFile, 'utf8').trim());
-            if (!Number.isInteger(pid) || pid <= 0)
-                throw new Error('invalid pid');
-            process.kill(pid, 0);
-            checks.push({ name: 'dispatcher', ok: true, detail: `running (pid ${pid})` });
-        }
-        catch {
-            checks.push({ name: 'dispatcher', ok: null, detail: 'stale lockfile (auto-reclaims)' });
-        }
-    checks.push({ name: 'codex-rc', ok: null,
-        detail: process.env.METRO_CODEX_RC ? `push enabled → ${process.env.METRO_CODEX_RC}`
-            : 'not configured (set METRO_CODEX_RC=ws://… to enable Codex push)' });
-    const tunnel = loadTunnelConfig();
-    checks.push({ name: 'tunnel', ok: tunnel ? true : null,
-        detail: tunnel ? `${tunnel.hostname} → 127.0.0.1:${webhookPort()}`
-            : 'not configured (run `metro tunnel setup <name> <hostname>`)' });
-    const eps = listEndpoints();
-    checks.push({ name: 'webhooks', ok: eps.length ? true : null,
-        detail: eps.length ? `${eps.length} endpoint${eps.length === 1 ? '' : 's'}: ${eps.map(e => e.label).join(', ')}`
-            : 'none (run `metro webhook add <label>`)' });
-    for (const c of envCheck())
-        checks.push(c);
-    const installed = Object.entries(skillStatus()).filter(([, ok]) => ok).map(([r]) => r);
-    checks.push({ name: 'skill', ok: installed.length ? true : null,
-        detail: installed.length ? `installed for ${installed.join(', ')}` : 'not installed (run `metro setup skill`)' });
-    if (isJson(f))
-        return writeJson({ checks });
-    process.stdout.write('metro doctor\n\n');
-    for (const c of checks) {
-        const mark = c.ok === true ? '✓' : c.ok === false ? '✗' : '–';
-        process.stdout.write(`  ${mark} ${c.name.padEnd(15)} ${c.detail}\n`);
-    }
-    process.stdout.write('\n');
-    if (checks.some(c => c.ok === false))
-        throw exitErr('one or more checks failed', 3);
-}
-export async function cmdUpdate(_, f) {
-    const tag = pkg.version.includes('-') ? 'beta' : 'latest';
-    const res = await fetch('https://registry.npmjs.org/@stage-labs/metro', { signal: AbortSignal.timeout(15_000) });
-    if (!res.ok)
-        throw new Error(`npm registry: ${res.status}`);
-    const latest = (await res.json())['dist-tags']?.[tag];
-    if (!latest)
-        throw new Error(`no '${tag}' dist-tag for @stage-labs/metro`);
-    if (latest === pkg.version) {
-        return emit(f, `already on ${pkg.version} (latest ${tag})`, { ok: true, current: pkg.version, latest, upgraded: false });
-    }
-    const argv1 = process.argv[1] ?? '', spec = `@stage-labs/metro@${tag}`;
-    const argv = argv1.includes('/.bun/') || argv1.includes('\\bun\\') ? ['bun', 'add', '-g', spec]
-        : argv1.includes('/pnpm/') || argv1.includes('\\pnpm\\') ? ['pnpm', 'add', '-g', spec]
-            : ['npm', 'install', '-g', spec];
-    emit(f, `metro ${pkg.version} → ${latest}\n$ ${argv.join(' ')}`, { ok: true, current: pkg.version, latest, command: argv.join(' ') });
-    await new Promise((resolve, reject) => {
-        const child = spawn(argv[0], argv.slice(1), { stdio: isJson(f) ? 'ignore' : 'inherit' });
-        child.on('exit', code => code === 0 ? resolve() : reject(new Error(`${argv[0]} exited ${code}`)));
-        child.on('error', reject);
-    });
-}

package/dist/cli/index.js

@@ -1,150 +0,0 @@
-#!/usr/bin/env bun
-/** Metro CLI: parses argv, dispatches to subcommands. Bun runtime required (uses Bun.spawn for trains). */
-import pkg from '../../package.json' with { type: 'json' };
-import { errMsg } from '../log.js';
-import { listLines, loadMetroEnv } from '../paths.js';
-import { readHistory } from '../history.js';
-import { cmdDoctor, cmdSetup, cmdUpdate } from './config.js';
-import { cmdClaim, cmdClaims, cmdRelease, cmdTail } from './tail.js';
-import { cmdCall, cmdTrains, cmdTunnel, cmdWebhook } from './webhook.js';
-import { flagOne, isJson, parseArgs, writeJson, } from './util.js';
-const USAGE = `metro — event-interception wire. Trains in ~/.metro/trains/ produce events;
-metro multiplexes them onto stdout. Outbound action calls flow back via \`metro call\`.
-
-Usage:
-  metro                                       Run the dispatcher (emits JSON events on stdout).
-  metro setup                                 Print config status (credentials are owned by trains).
-  metro setup skill [clear]                   Install/remove the metro skill into ~/.claude / ~/.codex.
-  metro doctor                                Health check.
-  metro lines                                 List recently-seen conversations.
-  metro trains [list]                         List supervised trains (running, pid, fail count).
-  metro trains restart <name>                 Kill + respawn a train (resets backoff).
-  metro trains new <name>                     Scaffold ~/.metro/trains/<name>.ts from the example.
-  metro call <train> <action> [args]          Forward an action call to a train via its stdin.
-                                              [args] is JSON, '@file', '-' (stdin), or a bare string.
-  metro history [--limit=N] [--line=…] [--station=…] [--kind=…] [--from=…] [--text=…] [--since=…]
-                                              Read the universal message log (newest first).
-  metro tail [--as=<user-uri>] [--follow] [--strict | --unclaimed | --all] [--include-webhooks]
-             [--chat=<line>] [--station=…] [--since=<offset|tail>] [--limit=N]
-                                              Subscribe to the event log; claim-aware by default.
-  metro claim <line> [--as=<user-uri>]        Take exclusive ownership of a line.
-  metro release <line>                        Release a line (it returns to broadcast).
-  metro claims                                Print the current claims map.
-  metro webhook add <label> [--secret=…]      Register an HTTP receive endpoint (GitHub, Intercom, …).
-  metro webhook list | remove <id>            List or remove webhook endpoints.
-  metro tunnel setup <name> <hostname>        Configure a Cloudflare named tunnel.
-  metro tunnel status                         Show current tunnel config.
-  metro update                                Upgrade in place.
-  metro --version | --help
-
-Trains: place \`<name>.ts\` files in ~/.metro/trains/. See \`@stage-labs/metro/examples\`.
-Lines: metro://<station>/<path>. Multi-line args: pipe on stdin where supported.
-Exit codes: 0 success · 1 usage · 2 config · 3 upstream
-`;
-async function cmdLines(_, f) {
-    loadMetroEnv();
-    const rows = listLines()
-        .map(({ line, entry }) => ({ line, name: entry.name ?? null, lastSeenAt: entry.lastSeenAt ?? null }))
-        .sort((a, b) => (b.lastSeenAt ?? '').localeCompare(a.lastSeenAt ?? ''));
-    if (isJson(f))
-        return writeJson({ lines: rows });
-    if (!rows.length)
-        return void process.stdout.write('metro lines\n\n  (none yet — start the dispatcher and send a message)\n\n');
-    const widest = Math.max(...rows.map(r => r.line.length));
-    process.stdout.write('metro lines\n\n');
-    for (const r of rows) {
-        const when = r.lastSeenAt ? humanAgo(r.lastSeenAt) : '—';
-        const tag = r.name ? `  ${r.name.slice(0, 40)}${r.name.length > 40 ? '…' : ''}` : '';
-        process.stdout.write(`  ${when.padEnd(10)} ${r.line.padEnd(widest)}${tag}\n`);
-    }
-    process.stdout.write('\n');
-}
-function humanAgo(iso) {
-    const sec = Math.max(0, Math.floor((Date.now() - new Date(iso).getTime()) / 1000));
-    if (sec < 60)
-        return `${sec}s ago`;
-    if (sec < 3600)
-        return `${Math.floor(sec / 60)}m ago`;
-    if (sec < 86400)
-        return `${Math.floor(sec / 3600)}h ago`;
-    return `${Math.floor(sec / 86400)}d ago`;
-}
-async function cmdHistory(_, f) {
-    loadMetroEnv();
-    const since = flagOne(f, 'since');
-    const entries = readHistory({
-        line: flagOne(f, 'line'),
-        station: flagOne(f, 'station'),
-        kind: flagOne(f, 'kind'),
-        from: flagOne(f, 'from'),
-        textContains: flagOne(f, 'text'),
-        since: since ? new Date(since) : undefined,
-        limit: Number(flagOne(f, 'limit')) || 50,
-    });
-    if (isJson(f))
-        return writeJson({ entries });
-    if (!entries.length) {
-        process.stdout.write('(no matching history entries)\n');
-        return;
-    }
-    process.stdout.write('time      id            kind          from                      → to                        body\n');
-    for (const e of entries.reverse()) {
-        const ts = e.ts.slice(11, 19);
-        const from = pad(fmtActor(e.from, e.fromName), 24);
-        const to = pad(fmtActor(e.to), 24);
-        const body = e.text ?? (e.emoji ? `[react ${e.emoji}]` : '');
-        const text = body.length > 60 ? body.slice(0, 59) + '…' : body;
-        process.stdout.write(`${ts}  ${e.id.padEnd(12)}  ${e.kind.padEnd(12)}  ${from} → ${to}  ${text}\n`);
-    }
-}
-/** Compact display: fromName if known; else `station:@<id>` (user) or `station:<id>`. */
-function fmtActor(uri, name) {
-    if (name)
-        return name;
-    const m = uri.match(/^metro:\/\/([^/]+)(?:\/(?:(user)\/)?(.*))?$/);
-    if (!m)
-        return uri;
-    const [, station, kind, rest] = m;
-    if (kind === 'user')
-        return `${station}:@${shortId(rest ?? '')}`;
-    return rest ? `${station}:${shortId(rest)}` : station;
-}
-const shortId = (s) => s.length <= 12 ? s : `${s.slice(0, 5)}…${s.slice(-4)}`;
-const pad = (s, n) => (s.length > n ? `${s.slice(0, n - 1)}…` : s.padEnd(n));
-const COMMANDS = {
-    setup: cmdSetup, doctor: cmdDoctor, lines: cmdLines,
-    call: cmdCall, trains: cmdTrains,
-    webhook: cmdWebhook, tunnel: cmdTunnel,
-    history: cmdHistory, tail: cmdTail,
-    claim: cmdClaim, release: cmdRelease, claims: cmdClaims,
-    update: cmdUpdate,
-};
-async function main() {
-    const cmd = process.argv[2];
-    if (cmd === '--version' || cmd === '-v')
-        return void process.stdout.write(`${pkg.version}\n`);
-    if (cmd === '--help' || cmd === '-h')
-        return void process.stdout.write(USAGE);
-    if (!cmd) {
-        await import('../dispatcher.js');
-        return;
-    }
-    const handler = COMMANDS[cmd];
-    if (!handler) {
-        process.stderr.write(`unknown command '${cmd}'\n\n${USAGE}`);
-        process.exit(1);
-    }
-    const { positional, flags } = parseArgs(process.argv.slice(3));
-    try {
-        await handler(positional, flags);
-    }
-    catch (err) {
-        const code = err.code;
-        if (isJson(flags))
-            writeJson({ ok: false, error: errMsg(err), code: code ?? 1 });
-        else
-            process.stderr.write(`error: ${errMsg(err)}\n`);
-        process.exit(typeof code === 'number' ? code : 1);
-    }
-}
-await main();