@stage-labs/metro 0.1.0-beta.7 → 0.1.0-beta.70

package/dist/cli/actions.js

@@ -1,139 +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 { agentSelf, appendHistory, lookupEntry, mintId, resolvePlatformId, } from '../history.js';
-import { asLine, Line } from '../stations/index.js';
-import { loadMetroEnv } from '../paths.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;
-}
-/** Append an outbound action to history.jsonl; `to` = the original sender when replying/reacting. */
-function logOutbound(f, e) {
-    const id = mintId();
-    const fromOverride = flagOne(f, 'from');
-    appendHistory({
-        id, ts: new Date().toISOString(), station: Line.station(e.line) ?? '?',
-        from: fromOverride ? asLine(fromOverride) : agentSelf(), to: e.to ?? e.line, ...e,
-    });
-    return id;
-}
-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.isAgent(line)) {
-        const from = flagOne(f, 'from');
-        const resp = await ipcCall({ op: 'notify', line, from, text });
-        if (!resp.ok)
-            throw new Error(resp.error);
-        return emit(f, `notified ${line}`, { ok: true, line, id: null, messageId: null });
-    }
-    const messageId = await chatStationOf(line).send(line, text, richOpts(f));
-    const id = logOutbound(f, { kind: 'outbound', line, text, messageId });
-    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: lookupEntry(replyToArg)?.from });
-    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: lookupEntry(msgArg)?.from });
-    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);
-    });
-}

package/dist/cli/index.js

@@ -1,159 +0,0 @@
-#!/usr/bin/env node
-/** Metro CLI entry: parses argv, dispatches to subcommands, owns action + info commands. */
-import pkg from '../../package.json' with { type: 'json' };
-import { errMsg } from '../log.js';
-import { listLines } from '../cache.js';
-import { fmtCapabilities, listStations } from '../stations/index.js';
-import { loadMetroEnv } from '../paths.js';
-import { readHistory } from '../history.js';
-import { cmdDoctor, cmdSetup, cmdUpdate } from './config.js';
-import { cmdDownload, cmdEdit, cmdFetch, cmdReact, cmdReply, cmdSend, } from './actions.js';
-import { flagOne, isJson, parseArgs, writeJson, } from './util.js';
-const USAGE = `metro — Telegram + Discord stream for your Claude Code / Codex agent
-
-Usage:
-  metro                                       Run the dispatcher (emits JSON events on stdout).
-  metro setup [telegram|discord <token>]      Save token, or show status with no args.
-  metro setup clear [telegram|discord|all]    Remove tokens.
-  metro setup skill [clear]                   Install the metro skill into ~/.claude / ~/.codex.
-  metro doctor                                Health check.
-  metro stations                              List stations + capabilities.
-  metro lines                                 List recently-seen conversations.
-  metro send <line> <text> [--image=<path>]… [--document=<path>]… [--voice=<path>] [--buttons=<json>]
-                                              Post a fresh message; repeat --image/--document for multi-file albums.
-  metro reply <line> <message_id> <text> [--image=… --document=… --voice=… --buttons=…]
-                                              Threaded reply (same flags as send).
-  metro edit <line> <message_id> <text> [--buttons=<json>]
-                                              Edit a previously-sent message (text + buttons).
-  metro react <line> <message_id> <emoji>     Set or clear ('') a reaction.
-  metro download <line> <message_id> [--out=<dir>]
-                                              Download image attachments to disk.
-  metro fetch <line> [--limit=N]              Recent-message lookback (Discord only).
-  metro history [--limit=N] [--line=…] [--station=…] [--kind=…] [--from=…] [--text=…] [--since=…]
-                                              Read the universal message log (newest first).
-  metro update                                Upgrade in place.
-  metro --version | --help
-
-Lines: metro://<station>/<path>. See docs/uri-scheme.md.
-Multi-line --text: pipe on stdin in place of the positional arg.
-Exit codes: 0 success · 1 usage · 2 config · 3 upstream
-`;
-async function cmdStations(_, f) {
-    loadMetroEnv();
-    const rows = listStations();
-    if (isJson(f))
-        return writeJson({ stations: rows });
-    process.stdout.write('metro stations\n\n');
-    for (const s of rows) {
-        const mark = s.configured === true ? '✓' : s.configured === false ? '✗' : '·';
-        process.stdout.write(`  ${mark} ${s.name.padEnd(10)} ${s.kind.padEnd(6)} ${fmtCapabilities(s.capabilities)}\n        ${s.detail}\n`);
-    }
-    process.stdout.write('\n');
-}
-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), `station:bot`, or `station:<id>`. */
-function fmtActor(uri, name) {
-    if (name)
-        return name;
-    const m = uri.match(/^metro:\/\/([^/]+)(?:\/(?:(user|bot)\/)?(.*))?$/);
-    if (!m)
-        return uri;
-    const [, station, kind, rest] = m;
-    if (kind === 'bot')
-        return `${station}:bot`;
-    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, stations: cmdStations, lines: cmdLines,
-    send: cmdSend, reply: cmdReply, edit: cmdEdit, react: cmdReact,
-    download: cmdDownload, fetch: cmdFetch,
-    history: cmdHistory, 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();

package/dist/cli/skill.js

@@ -1,62 +0,0 @@
-/** `metro setup skill` — install the bundled SKILL.md into each detected agent runtime. */
-import { copyFileSync, existsSync, mkdirSync, unlinkSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { errMsg } from '../log.js';
-import { emit, exitErr } from './util.js';
-const RUNTIME_DIRS = {
-    'claude-code': join(homedir(), '.claude', 'skills', 'metro'),
-    codex: join(homedir(), '.codex', 'skills', 'metro'),
-};
-/** dist/cli/skill.js → <package-root>/skills/metro/SKILL.md */
-const bundledPath = () => join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'skills', 'metro', 'SKILL.md');
-const dest = (r) => join(RUNTIME_DIRS[r], 'SKILL.md');
-export const skillStatus = () => ({
-    'claude-code': existsSync(dest('claude-code')),
-    codex: existsSync(dest('codex')),
-});
-export async function cmdSetupSkill(p, f) {
-    const [sub] = p;
-    if (sub === 'clear')
-        return clear(f);
-    if (sub && sub !== 'install')
-        throw exitErr(`unknown skill subcommand '${sub}' (try: install, clear)`, 1);
-    return install(f);
-}
-function install(f) {
-    const src = bundledPath();
-    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;
-        try {
-            mkdirSync(RUNTIME_DIRS[r], { recursive: true });
-            copyFileSync(src, dest(r));
-            installed.push(dest(r));
-        }
-        catch (err) {
-            throw exitErr(`failed to install skill for ${r}: ${errMsg(err)}`, 2);
-        }
-    }
-    if (!installed.length) {
-        throw exitErr('no agent runtime detected (~/.claude or ~/.codex). Install one and rerun.', 2);
-    }
-    emit(f, `installed metro skill → ${installed.join(', ')}`, { ok: true, installed });
-}
-function clear(f) {
-    const removed = [];
-    for (const r of Object.keys(RUNTIME_DIRS)) {
-        const path = dest(r);
-        if (existsSync(path)) {
-            try {
-                unlinkSync(path);
-                removed.push(path);
-            }
-            catch { /* ignore */ }
-        }
-    }
-    emit(f, removed.length ? `removed metro skill from ${removed.join(', ')}` : 'no installed skill found', { ok: true, removed });
-}

package/dist/cli/util.js

@@ -1,72 +0,0 @@
-/** Shared CLI primitives consumed by index.ts + config.ts. */
-export const exitErr = (msg, code) => Object.assign(new Error(msg), { code });
-export const isJson = (f) => f.json === true;
-export const writeJson = (obj) => void process.stdout.write(JSON.stringify(obj) + '\n');
-export const emit = (f, human, structured) => isJson(f) ? writeJson(structured) : void process.stdout.write(human + '\n');
-export const need = (positional, min, usage) => {
-    if (positional.length < min)
-        throw exitErr(`usage: ${usage}`, 1);
-};
-/** Return the last string value for `key` (or undefined). */
-export function flagOne(f, key) {
-    const v = f[key];
-    if (typeof v === 'string')
-        return v;
-    if (Array.isArray(v) && v.length)
-        return v[v.length - 1];
-    return undefined;
-}
-/** Return all string values for `key`, also splitting comma-separated entries. */
-export function flagList(f, key) {
-    const v = f[key];
-    const raw = typeof v === 'string' ? [v] : Array.isArray(v) ? v : [];
-    return raw.flatMap(s => s.split(',').map(p => p.trim()).filter(Boolean));
-}
-export function parseArgs(argv) {
-    const positional = [], flags = {};
-    const add = (k, val) => {
-        const cur = flags[k];
-        if (cur === undefined) {
-            flags[k] = val;
-            return;
-        }
-        if (typeof val === 'boolean') {
-            flags[k] = val;
-            return;
-        }
-        flags[k] = Array.isArray(cur) ? [...cur, val] : [cur, val];
-    };
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i];
-        if (!a.startsWith('--')) {
-            positional.push(a);
-            continue;
-        }
-        const eq = a.indexOf('=');
-        if (eq !== -1) {
-            add(a.slice(2, eq), a.slice(eq + 1));
-            continue;
-        }
-        const next = argv[i + 1];
-        if (next !== undefined && !next.startsWith('--')) {
-            add(a.slice(2), next);
-            i++;
-        }
-        else
-            add(a.slice(2), true);
-    }
-    return { positional, flags };
-}
-export async function resolveText(positional, from) {
-    if (positional.length > from)
-        return positional.slice(from).join(' ');
-    if (process.stdin.isTTY)
-        throw exitErr('text is required (or pipe text on stdin)', 1);
-    const chunks = [];
-    for await (const c of process.stdin)
-        chunks.push(c);
-    const stdin = Buffer.concat(chunks).toString('utf8').replace(/\n$/, '');
-    if (!stdin)
-        throw exitErr('text is required (or pipe text on stdin)', 1);
-    return stdin;
-}