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

package/dist/broker.js

@@ -1,202 +0,0 @@
-/** Broker primitives: claims map + per-user byte-offset cursors over history.jsonl. */
-import { closeSync, existsSync, openSync, readFileSync, readSync, renameSync, unlinkSync, writeFileSync, } from 'node:fs';
-import { mkdirSync } 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';
-export const CLAIMS_FILE = join(STATE_DIR, 'claims.json');
-const CLAIMS_LOCK = join(STATE_DIR, 'claims.json.lock');
-const CURSORS_DIR = join(STATE_DIR, 'cursors');
-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 };
-    });
-}
-/** 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 };
-    }
-}
-/** 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;
-    /** mode === 'mine-or-unclaimed' */
-    return !owner || owner === self;
-}

package/dist/cache.js

@@ -1,69 +0,0 @@
-/** Per-machine caches: seen lines (lines.json) + bot ids (bot-ids.json). */
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { errMsg, log } from './log.js';
-import { STATE_DIR } from './paths.js';
-const cacheFile = join(STATE_DIR, 'lines.json');
-const FLUSH_DELAY_MS = 5_000;
-let cache = null;
-let dirty = false;
-let flushTimer = null;
-function read() {
-    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 = read();
-    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(read()).map(([line, entry]) => ({ line: line, entry }));
-/** Bot identity cache: `{discord: "<userId>", telegram: "<userId>"}`. Daemon writes after getMe(). */
-const botIdsFile = join(STATE_DIR, 'bot-ids.json');
-export const readBotIds = () => {
-    try {
-        return existsSync(botIdsFile) ? JSON.parse(readFileSync(botIdsFile, 'utf8')) : {};
-    }
-    catch {
-        return {};
-    }
-};
-export function saveBotId(station, id) {
-    const cur = readBotIds();
-    if (cur[station] === id)
-        return;
-    cur[station] = id;
-    try {
-        writeFileSync(botIdsFile, JSON.stringify(cur, null, 2));
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err) }, 'bot-ids cache write failed');
-    }
-}

package/dist/cli/actions.js

@@ -1,206 +0,0 @@
-/** CLI action handlers: send/reply/edit/react/download/fetch + helpers. */
-import { mkdirSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { errMsg } from '../log.js';
-import { DiscordStation } from '../stations/discord.js';
-import { TelegramStation } from '../stations/telegram.js';
-import { ipcCall } from '../ipc.js';
-import { userSelf, appendHistory, lookupEntry, mintId, readHistory, resolvePlatformId, } from '../history.js';
-import { asLine, Line } from '../stations/index.js';
-import { loadMetroEnv } from '../paths.js';
-import { tryAutoClaim } from '../broker.js';
-import { emit, flagList, flagOne, isJson, need, resolveText, writeJson, } from './util.js';
-export function chatStationOf(line) {
-    const s = Line.station(line);
-    if (s === 'discord')
-        return new DiscordStation();
-    if (s === 'telegram')
-        return new TelegramStation();
-    throw new Error(`no chat station for line "${line}" (try metro://{discord|telegram}/...)`);
-}
-function parseButtons(f) {
-    const raw = flagOne(f, 'buttons');
-    if (raw === undefined)
-        return undefined;
-    try {
-        return JSON.parse(raw);
-    }
-    catch (err) {
-        throw new Error(`--buttons must be JSON like '[[{"text":"…","url":"…"}]]': ${errMsg(err)}`);
-    }
-}
-function richOpts(f) {
-    const opts = {};
-    const images = flagList(f, 'image');
-    if (images.length)
-        opts.images = images;
-    const documents = flagList(f, 'document');
-    if (documents.length)
-        opts.documents = documents;
-    const voice = flagOne(f, 'voice');
-    if (voice)
-        opts.voice = voice;
-    const buttons = parseButtons(f);
-    if (buttons)
-        opts.buttons = buttons;
-    return opts;
-}
-/** Mirror the original entry's destination: group → `line`; DM → the other-party user URI. */
-function destinationFor(orig, line) {
-    if (!orig || !orig.to || orig.to === orig.line)
-        return line;
-    return orig.from;
-}
-/** Classify a chat line as DM/group/unknown for the auto-claim group-skip rule. */
-/** Telegram: chat-id sign is authoritative (id < 0 ⇒ group). Discord: peek payload.guildId on */
-/** the most-recent inbound (null ⇒ DM, set ⇒ group, none seen ⇒ unknown). 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') {
-        /** Look at the most recent inbound on this line; the daemon stored the raw message in `payload`. */
-        const recent = readHistory({ line, kind: 'inbound', limit: 1 })[0];
-        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';
-}
-/** Append an outbound action to history.jsonl; `to` mirrors the destination per `destinationFor`. */
-function logOutbound(f, e) {
-    const id = mintId();
-    const fromOverride = flagOne(f, 'from');
-    const from = fromOverride ? asLine(fromOverride) : userSelf();
-    appendHistory({
-        id, ts: new Date().toISOString(), station: Line.station(e.line) ?? '?',
-        from, to: e.to ?? e.line, ...e,
-    });
-    maybeAutoClaim(f, e.line, from);
-    return id;
-}
-/** Auto-claim on outbound — skips when `--no-claim` / `METRO_NO_AUTO_CLAIM=1`, when the line is */
-/** a group/webhook, or when already owned by someone else. `--claim` forces a group-line claim. */
-function maybeAutoClaim(f, line, owner) {
-    if (f['no-claim'] === true)
-        return;
-    if (process.env.METRO_NO_AUTO_CLAIM === '1')
-        return;
-    const force = f['claim'] === true;
-    const lineKind = classifyLine(line);
-    const result = tryAutoClaim(line, owner, { lineKind, force });
-    if (result.status === 'skipped') {
-        process.stderr.write(`auto-claim skipped: line owned by ${result.existing}\n`);
-    }
-    else if (result.status === 'group') {
-        process.stderr.write(`auto-claim skipped: ${line} is a group/public line; pass --claim to take it explicitly\n`);
-    }
-    else if (result.status === 'webhook') {
-        process.stderr.write(`auto-claim skipped: ${line} is a webhook line (broadcast stream)\n`);
-    }
-    else if (result.status === 'error') {
-        process.stderr.write(`auto-claim failed: ${result.error}\n`);
-    }
-}
-export async function cmdSend(p, f) {
-    need(p, 1, 'metro send <line> <text> [--image=<path>]… [--document=<path>]… [--voice=<path>] [--buttons=<json>]');
-    loadMetroEnv();
-    const text = await resolveText(p, 1), line = asLine(p[0]);
-    if (Line.isLocal(line)) {
-        const fromFlag = flagOne(f, 'from');
-        const resp = await ipcCall({ op: 'notify', line, from: fromFlag, text });
-        if (!resp.ok)
-            throw new Error(resp.error);
-        /** cross-user notify still counts as the sender taking the line: auto-claim if unclaimed */
-        maybeAutoClaim(f, line, fromFlag ? asLine(fromFlag) : userSelf());
-        return emit(f, `notified ${line}`, { ok: true, line, id: null, messageId: null });
-    }
-    const messageId = await chatStationOf(line).send(line, text, richOpts(f));
-    /** Inherit destination from the most recent inbound on this line so DM sends address the user. */
-    const to = destinationFor(readHistory({ line, kind: 'inbound', limit: 1 })[0], line);
-    const id = logOutbound(f, { kind: 'outbound', line, text, messageId, to });
-    emit(f, `sent ${id} (${messageId}) to ${line}`, { ok: true, line, id, messageId });
-}
-export async function cmdReply(p, f) {
-    need(p, 2, 'metro reply <line> <message_id> <text> [--image=… --document=… --voice=… --buttons=…]');
-    loadMetroEnv();
-    const [to, replyToArg] = p, text = await resolveText(p, 2), line = asLine(to);
-    const replyTo = resolvePlatformId(replyToArg);
-    const messageId = await chatStationOf(line).send(line, text, { ...richOpts(f), replyTo });
-    const id = logOutbound(f, { kind: 'outbound', line, text, messageId, replyTo: replyToArg, to: destinationFor(lookupEntry(replyToArg), line) });
-    emit(f, `replied ${id} (${messageId}) to ${line}#${replyTo}`, { ok: true, line, id, replyTo: replyToArg, messageId });
-}
-export async function cmdEdit(p, f) {
-    need(p, 2, 'metro edit <line> <message_id> <text> [--buttons=<json>]');
-    loadMetroEnv();
-    const [to, msgArg] = p, text = await resolveText(p, 2), line = asLine(to);
-    const platformId = resolvePlatformId(msgArg);
-    const buttons = parseButtons(f);
-    await chatStationOf(line).edit(line, platformId, text, buttons ? { buttons } : undefined);
-    /** Carry forward the original recipient if we have a row for this message. */
-    const id = logOutbound(f, { kind: 'edit', line, text, messageId: platformId, replyTo: msgArg, to: lookupEntry(msgArg)?.to });
-    emit(f, `edited ${line}#${platformId} (${id})`, { ok: true, line, id, messageId: platformId });
-}
-export async function cmdReact(p, f) {
-    need(p, 2, 'metro react <line> <message_id> <emoji>   (empty emoji clears)');
-    loadMetroEnv();
-    const [to, msgArg, emoji = ''] = p, line = asLine(to);
-    const platformId = resolvePlatformId(msgArg);
-    await chatStationOf(line).react(line, platformId, emoji);
-    const id = logOutbound(f, { kind: 'react', line, messageId: platformId, emoji, to: destinationFor(lookupEntry(msgArg), line) });
-    const human = emoji ? `reacted ${emoji} on ${line}#${platformId}` : `cleared reaction on ${line}#${platformId}`;
-    emit(f, human, { ok: true, line, id, messageId: platformId, emoji });
-}
-export async function cmdDownload(p, f) {
-    need(p, 2, 'metro download <line> <message_id> [--out=<dir>]');
-    loadMetroEnv();
-    const [to, msgArg] = p, line = asLine(to);
-    const messageId = resolvePlatformId(msgArg);
-    const outDir = typeof f.out === 'string' ? f.out : join(tmpdir(), 'metro-downloads');
-    mkdirSync(outDir, { recursive: true });
-    /** Telegram has no get-message-by-id REST endpoint — daemon holds the in-memory snapshot. */
-    let files;
-    if (Line.station(line) === 'telegram') {
-        const resp = await ipcCall({ op: 'download', line, messageId, outDir });
-        if (!resp.ok)
-            throw new Error(resp.error);
-        files = 'files' in resp ? resp.files : [];
-    }
-    else {
-        files = await chatStationOf(line).download(line, messageId, outDir);
-    }
-    if (isJson(f))
-        return writeJson({ ok: true, line, files });
-    if (!files.length)
-        process.stdout.write(`(no image attachments on ${line}#${messageId})\n`);
-    for (const file of files)
-        process.stdout.write(file.path + '\n');
-}
-export async function cmdFetch(p, f) {
-    need(p, 1, 'metro fetch <line> [--limit=N]');
-    loadMetroEnv();
-    const line = asLine(p[0]);
-    const messages = await chatStationOf(line).fetch(line, Number(flagOne(f, 'limit')) || 20);
-    if (isJson(f))
-        return writeJson({ ok: true, line, messages });
-    if (!messages.length)
-        process.stdout.write(`(no messages on ${line})\n`);
-    for (const m of messages)
-        process.stdout.write(`${m.timestamp}  ${m.author}: ${m.text}\n`);
-}

package/dist/cli/config.js

@@ -1,185 +0,0 @@
-/** Setup / doctor / update — config-side commands consumed by cli.ts. */
-import { existsSync, readFileSync } from 'node:fs';
-import { spawn } from 'node:child_process';
-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 { errMsg } from '../log.js';
-import { CONFIG_ENV_FILE, configuredPlatforms, loadMetroEnv, readDotenv, STATE_DIR, writeDotenv, } from '../paths.js';
-import { emit, exitErr, isJson, writeJson } from './util.js';
-import { cmdSetupSkill, skillStatus } from './skill.js';
-const TOKEN_KEYS = { telegram: 'TELEGRAM_BOT_TOKEN', discord: 'DISCORD_BOT_TOKEN' };
-const stationFor = (p) => p === 'telegram' ? new TelegramStation() : new DiscordStation();
-const maskToken = (t) => !t ? '' : t.length <= 8 ? '••••' : `${t.slice(0, 6)}…${t.slice(-2)}`;
-/** Apply token across CONFIG_ENV_FILE (always set/cleared) AND cwd/.env (only if it exists). */
-function applyToken(key, value) {
-    const out = [];
-    for (const path of [CONFIG_ENV_FILE, join(process.cwd(), '.env')]) {
-        if (path !== CONFIG_ENV_FILE && !existsSync(path))
-            continue;
-        const env = readDotenv(path);
-        if (value === null) {
-            if (!(key in env))
-                continue;
-            delete env[key];
-        }
-        else
-            env[key] = value;
-        writeDotenv(path, env);
-        out.push(path);
-    }
-    return out;
-}
-async function cmdSetupStatus(f) {
-    loadMetroEnv();
-    const tg = process.env.TELEGRAM_BOT_TOKEN ?? '', dc = process.env.DISCORD_BOT_TOKEN ?? '';
-    if (isJson(f))
-        return writeJson({
-            version: pkg.version, config_env_file: CONFIG_ENV_FILE,
-            tokens: { telegram: { set: !!tg, masked: maskToken(tg) }, discord: { set: !!dc, masked: maskToken(dc) } },
-        });
-    const cfgState = existsSync(CONFIG_ENV_FILE) ? '' : ' (not yet written)';
-    const getStarted = !tg && !dc
-        ? 'Get started:\n  1. metro setup telegram <token>   # https://t.me/BotFather'
-            + '\n     metro setup discord <token>     # https://discord.com/developers/applications'
-            + '\n  2. metro doctor\n  3. metro\n'
-        : 'Run `metro` to start the dispatcher, or `metro doctor` to verify.\n';
-    process.stdout.write(`metro ${pkg.version}\n\nconfig:  ${CONFIG_ENV_FILE}${cfgState}\n\n`
-        + `  TELEGRAM_BOT_TOKEN  ${tg ? `set (${maskToken(tg)})` : 'not set'}\n`
-        + `  DISCORD_BOT_TOKEN   ${dc ? `set (${maskToken(dc)})` : 'not set'}\n\n${getStarted}`);
-}
-export async function cmdSetup(p, f) {
-    const [sub, value] = p;
-    if (!sub)
-        return cmdSetupStatus(f);
-    if (sub === 'skill')
-        return cmdSetupSkill(p.slice(1), f);
-    if (sub === 'telegram' || sub === 'discord') {
-        if (!value)
-            throw new Error(`metro setup ${sub} <token> — token is required`);
-        const trimmed = value.trim();
-        let identity;
-        if (!f['no-validate']) {
-            process.env[TOKEN_KEYS[sub]] = trimmed;
-            try {
-                const me = await stationFor(sub).getMe();
-                identity = sub === 'telegram' ? `@${me.username}` : me.username;
-            }
-            catch (err) {
-                delete process.env[TOKEN_KEYS[sub]];
-                throw exitErr(`token rejected by ${sub}: ${errMsg(err)} (use --no-validate to save anyway)`, 3);
-            }
-        }
-        const paths = applyToken(TOKEN_KEYS[sub], trimmed);
-        const verified = identity ? ` (verified as ${identity})` : '';
-        emit(f, `saved ${TOKEN_KEYS[sub]}${verified} to ${paths.join(', ')}\nrestart metro for the new token to take effect.`, { ok: true, saved: TOKEN_KEYS[sub], paths, verified_as: identity ?? null });
-        return;
-    }
-    if (sub === 'clear') {
-        const target = value ?? 'all';
-        if (target !== 'all' && target !== 'telegram' && target !== 'discord')
-            throw new Error(`metro setup clear <telegram|discord|all> — got '${target}'`);
-        const keys = target === 'all' ? Object.values(TOKEN_KEYS) : [TOKEN_KEYS[target]];
-        const paths = new Set();
-        for (const k of keys)
-            for (const path of applyToken(k, null))
-                paths.add(path);
-        const label = target === 'all' ? 'all metro tokens' : TOKEN_KEYS[target];
-        emit(f, `cleared ${label} from ${[...paths].join(', ') || '(no files had it)'}\nrestart metro for changes to take effect.`, { ok: true, cleared: target, paths: [...paths] });
-        return;
-    }
-    throw new Error(`unknown setup subcommand '${sub}' (try: telegram, discord, clear, skill)`);
-}
-function tokenSource(key) {
-    const val = process.env[key];
-    if (!val)
-        return '';
-    for (const path of [join(process.cwd(), '.env'), CONFIG_ENV_FILE]) {
-        if (existsSync(path) && readDotenv(path)[key] === val)
-            return path;
-    }
-    return 'process env';
-}
-export async function cmdDoctor(_, f) {
-    loadMetroEnv();
-    const cfg = configuredPlatforms();
-    const checks = [];
-    const sources = [];
-    for (const p of ['telegram', 'discord']) {
-        if (!cfg[p]) {
-            checks.push({ name: p, ok: null, detail: 'not configured' });
-            continue;
-        }
-        sources.push(`${p}←${tokenSource(TOKEN_KEYS[p])}`);
-        try {
-            const me = await stationFor(p).getMe();
-            checks.push({ name: p, ok: true, detail: `getMe → ${p === 'telegram' ? '@' : ''}${me.username}` });
-        }
-        catch (err) {
-            checks.push({ name: p, ok: false, detail: errMsg(err) });
-        }
-    }
-    checks.unshift({
-        name: 'tokens', ok: cfg.telegram || cfg.discord,
-        detail: sources.length ? sources.join(', ') : 'no platform configured — run `metro setup telegram|discord <token>`',
-    });
-    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 sk = skillStatus();
-    const installed = Object.entries(sk).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);
-    });
-}