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

package/dist/cli/index.js

@@ -1,188 +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 { listUsers } from '../registry.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 { cmdClaim, cmdClaims, cmdRelease, cmdTail } from './tail.js';
-import { cmdTunnel, cmdWebhook } from './webhook.js';
-import { flagOne, isJson, parseArgs, writeJson, } from './util.js';
-const USAGE = `metro — Telegram + Discord stream for your Claude Code / Codex user
-
-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>] [--no-claim] [--claim]
-                                              Post a fresh message; repeat --image/--document for multi-file albums.
-                                              First outbound on a DM auto-claims; --no-claim or METRO_NO_AUTO_CLAIM=1 opts out;
-                                              --claim forces auto-claim even on group/public lines.
-                                              Note: send/reply/edit/react read bot tokens from ~/.config/metro/.env and post
-                                              directly to the platform — METRO_STATE_DIR isolates claims/history but NOT creds.
-  metro reply <line> <message_id> <text> [--image=… --document=… --voice=… --buttons=…] [--no-claim] [--claim]
-                                              Threaded reply (same flags as send).
-  metro edit <line> <message_id> <text> [--buttons=<json>] [--no-claim] [--claim]
-                                              Edit a previously-sent message (text + buttons).
-  metro react <line> <message_id> <emoji> [--no-claim] [--claim]
-                                              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 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. See docs/broker.md.
-                                              Webhooks are hidden in personal modes unless --include-webhooks is set.
-  metro claim <line> [--as=<user-uri>]        Take exclusive ownership of a line (so only you receive its events).
-  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 (run cloudflared tunnel login first).
-  metro tunnel status                         Show current tunnel config.
-  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();
-    const usersByStation = {
-        claude: listUsers('claude'),
-        codex: listUsers('codex'),
-    };
-    if (isJson(f))
-        return writeJson({ stations: rows, users: usersByStation });
-    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)} ${fmtCapabilities(s.capabilities)}\n        ${s.detail}\n`);
-        const seen = usersByStation[s.name] ?? [];
-        for (const inst of seen) {
-            const sessionsTxt = inst.sessions.length ? ` · sessions: ${inst.sessions.length}` : '';
-            process.stdout.write(`          seen: ${inst.userId}${sessionsTxt}\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) 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, stations: cmdStations, lines: cmdLines,
-    send: cmdSend, reply: cmdReply, edit: cmdEdit, react: cmdReact,
-    download: cmdDownload, fetch: cmdFetch,
-    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();

package/dist/cli/skill.js

@@ -1,62 +0,0 @@
-/** `metro setup skill` — install the bundled SKILL.md into each detected user 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 user 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/tail.js

@@ -1,164 +0,0 @@
-/** CLI subcommands: `metro tail` (claim-aware log subscriber) + `metro claim|release|claims`. */
-import { existsSync, watch } from 'node:fs';
-import { CLAIMS_FILE, HISTORY_FILE, claimLine, cursorKey, historySize, passesMode, readClaims, readCursor, readEntriesFrom, releaseLine, writeCursor, } from '../broker.js';
-import { userSelf } from '../history.js';
-import { asLine } from '../stations/index.js';
-import { loadMetroEnv } from '../paths.js';
-import { emit, exitErr, flagOne, isJson, need, writeJson } from './util.js';
-function resolveMode(f, self) {
-    const strict = f.strict === true, unclaimed = f.unclaimed === true, all = f.all === true;
-    if ([strict, unclaimed, all].filter(Boolean).length > 1) {
-        throw exitErr('--strict, --unclaimed, --all are mutually exclusive', 1);
-    }
-    if (strict) {
-        if (!self)
-            throw exitErr('--strict requires --as <user-uri>', 1);
-        return 'mine-only';
-    }
-    if (unclaimed)
-        return 'unclaimed';
-    if (all || !self)
-        return 'all';
-    return 'mine-or-unclaimed';
-}
-/** Generic fallback returned by `userSelf()` when there's no Claude/Codex env — treat as "no identity". */
-const GENERIC_USER = 'metro://user';
-function resolveSelf(f) {
-    const raw = flagOne(f, 'as');
-    if (raw !== undefined)
-        return asLine(raw);
-    const auto = userSelf();
-    return auto === GENERIC_USER ? null : auto;
-}
-function resolveStartOffset(f, key) {
-    const since = flagOne(f, 'since');
-    if (since === 'tail')
-        return historySize();
-    if (since !== undefined) {
-        const n = Number(since);
-        if (!Number.isFinite(n) || n < 0)
-            throw exitErr(`--since must be a byte offset or 'tail' (got '${since}')`, 1);
-        return n;
-    }
-    return key ? readCursor(key) : 0;
-}
-export async function cmdTail(_, f) {
-    loadMetroEnv();
-    const self = resolveSelf(f);
-    const mode = resolveMode(f, self);
-    const follow = f.follow === true;
-    const chatFilter = flagOne(f, 'chat');
-    const stationFilter = flagOne(f, 'station');
-    const limit = Number(flagOne(f, 'limit')) || 0;
-    const json = isJson(f);
-    const includeWebhooks = f['include-webhooks'] === true;
-    /** Cursor key derives from the effective mode (not userSelf), so `--all` / `--unclaimed` */
-    /** don't trample the personal `--as=<me>` cursor in a CLAUDECODE shell. */
-    const key = cursorKey(mode, self, { includeWebhooks });
-    const startOffset = resolveStartOffset(f, key);
-    let emitted = 0;
-    let offset = startOffset;
-    const drain = () => {
-        /** read claims once per drain so a burst of events shares a snapshot */
-        const claims = readClaims();
-        for (const { entry, offset: next } of readEntriesFrom(offset)) {
-            offset = next;
-            if (chatFilter && entry.line !== chatFilter)
-                continue;
-            if (stationFilter && entry.station !== stationFilter)
-                continue;
-            if (!passesMode(entry, mode, self, claims, { includeWebhooks }))
-                continue;
-            if (json)
-                process.stdout.write(JSON.stringify(entry) + '\n');
-            else
-                process.stdout.write(fmtRow(entry) + '\n');
-            if (key)
-                writeCursor(key, offset);
-            emitted++;
-            if (limit && emitted >= limit)
-                return true;
-        }
-        return false;
-    };
-    if (drain() && !follow)
-        return;
-    if (!follow)
-        return;
-    /** fs.watch on macOS sometimes coalesces or drops events — poll every 500ms as a backstop. */
-    await new Promise(resolve => {
-        let watcher = null;
-        const trigger = () => { if (drain())
-            cleanup(); };
-        const cleanup = () => {
-            if (watcher) {
-                try {
-                    watcher.close();
-                }
-                catch { /* ignore */ }
-                watcher = null;
-            }
-            clearInterval(poll);
-            resolve();
-        };
-        const poll = setInterval(trigger, 500);
-        const startWatcher = () => {
-            if (!existsSync(HISTORY_FILE))
-                return;
-            try {
-                watcher = watch(HISTORY_FILE, () => trigger());
-            }
-            catch { /* ignore — poll will catch */ }
-        };
-        startWatcher();
-        process.on('SIGINT', cleanup);
-        process.on('SIGTERM', cleanup);
-        process.stdin.on('end', cleanup).on('close', cleanup);
-    });
-}
-function fmtRow(e) {
-    const ts = e.ts.slice(11, 19);
-    const body = e.text ?? (e.emoji ? `[react ${e.emoji}]` : '');
-    const text = body.length > 80 ? body.slice(0, 79) + '…' : body;
-    const who = (e.fromName ?? e.from).padEnd(28).slice(0, 28);
-    const where = e.line.padEnd(40).slice(0, 40);
-    return `${ts}  ${e.id.padEnd(12)}  ${e.kind.padEnd(8)}  ${who}  ${where}  ${text}`;
-}
-export async function cmdClaim(p, f) {
-    loadMetroEnv();
-    need(p, 1, 'metro claim <line> [--as <user-uri>]');
-    const line = asLine(p[0]);
-    const asRaw = flagOne(f, 'as');
-    const owner = asRaw ? asLine(asRaw) : userSelf();
-    const claims = claimLine(line, owner);
-    emit(f, `claimed ${line} → ${owner}`, { ok: true, line, owner, claims });
-}
-export async function cmdRelease(p, f) {
-    loadMetroEnv();
-    need(p, 1, 'metro release <line>');
-    const line = asLine(p[0]);
-    const { released, claims } = releaseLine(line);
-    if (!released) {
-        emit(f, `${line} was not claimed`, { ok: true, released: false, line, claims });
-        return;
-    }
-    emit(f, `released ${line}`, { ok: true, released: true, line, claims });
-}
-export async function cmdClaims(_, f) {
-    loadMetroEnv();
-    const claims = readClaims();
-    const entries = Object.entries(claims);
-    if (isJson(f))
-        return writeJson({ claims });
-    if (!entries.length) {
-        process.stdout.write('(no claims — every tail with matching filters receives every event)\n');
-        process.stdout.write(`file: ${CLAIMS_FILE}${existsSync(CLAIMS_FILE) ? '' : ' (not created yet)'}\n`);
-        return;
-    }
-    const widest = Math.max(...entries.map(([l]) => l.length));
-    process.stdout.write('metro claims\n\n');
-    for (const [line, owner] of entries) {
-        process.stdout.write(`  ${line.padEnd(widest)}  →  ${owner}\n`);
-    }
-    process.stdout.write(`\n${entries.length} claim${entries.length === 1 ? '' : 's'} · ${CLAIMS_FILE}\n`);
-}

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;
-}

package/dist/cli/webhook.js

@@ -1,81 +0,0 @@
-/** CLI subcommands: `metro webhook add|list|remove` + `metro tunnel setup`. */
-import { spawnSync } from 'node:child_process';
-import { addEndpoint, listEndpoints, removeEndpoint, webhookPort } from '../webhooks.js';
-import { loadTunnelConfig, saveTunnelConfig } from '../tunnel.js';
-import { emit, exitErr, flagOne, isJson, need, writeJson } from './util.js';
-function urlFor(endpointId) {
-    const t = loadTunnelConfig();
-    return t ? `https://${t.hostname}/wh/${endpointId}` : `http://127.0.0.1:${webhookPort()}/wh/${endpointId}`;
-}
-export async function cmdWebhook(p, f) {
-    const sub = p[0];
-    if (sub === 'add')
-        return cmdWebhookAdd(p.slice(1), f);
-    if (sub === 'list' || sub === undefined)
-        return cmdWebhookList(f);
-    if (sub === 'remove' || sub === 'rm')
-        return cmdWebhookRemove(p.slice(1), f);
-    throw exitErr('usage: metro webhook [add <label> [--secret=…] | list | remove <id>]', 1);
-}
-async function cmdWebhookAdd(p, f) {
-    need(p, 1, 'metro webhook add <label> [--secret=<shared-secret>]');
-    const ep = addEndpoint(p[0], flagOne(f, 'secret'));
-    const url = urlFor(ep.id);
-    emit(f, `webhook ${ep.id} (${ep.label}) → ${url}${ep.secret ? `\nshared secret: ${ep.secret}` : ''}`, { ok: true, endpoint: ep, url });
-}
-async function cmdWebhookList(f) {
-    const eps = listEndpoints().map(ep => ({ ...ep, url: urlFor(ep.id) }));
-    if (isJson(f))
-        return writeJson({ endpoints: eps });
-    if (!eps.length)
-        return void process.stdout.write('metro webhooks\n\n  (none — run `metro webhook add <label>`)\n\n');
-    process.stdout.write('metro webhooks\n\n');
-    for (const ep of eps) {
-        process.stdout.write(`  ${ep.id}  ${ep.label}${ep.secret ? '  (signed)' : ''}\n        ${ep.url}\n`);
-    }
-    process.stdout.write('\n');
-}
-async function cmdWebhookRemove(p, f) {
-    need(p, 1, 'metro webhook remove <id>');
-    const ok = removeEndpoint(p[0]);
-    if (!ok)
-        throw exitErr(`no webhook with id "${p[0]}"`, 1);
-    emit(f, `removed webhook ${p[0]}`, { ok: true, id: p[0] });
-}
-export async function cmdTunnel(p, f) {
-    const sub = p[0];
-    if (sub === 'setup')
-        return cmdTunnelSetup(p.slice(1), f);
-    if (sub === 'status' || sub === undefined)
-        return cmdTunnelStatus(f);
-    throw exitErr('usage: metro tunnel [setup <name> <hostname> | status]', 1);
-}
-async function cmdTunnelSetup(p, f) {
-    need(p, 2, 'metro tunnel setup <tunnel-name> <hostname>     (e.g. `metro tunnel setup metro webhook.example.com`)');
-    const [name, hostname] = p;
-    if (!hasCloudflared()) {
-        throw exitErr('cloudflared not on PATH — install with `brew install cloudflared` (or see https://developers.cloudflare.com/cloudflared/)', 2);
-    }
-    /** Idempotent: if tunnel exists, `tunnel create` errors with "already exists" — that's fine, continue. */
-    run('cloudflared', ['tunnel', 'create', name], { allowFail: true });
-    /** DNS route is also idempotent in newer cloudflared; older versions error if the CNAME exists. Same handling. */
-    run('cloudflared', ['tunnel', 'route', 'dns', name, hostname], { allowFail: true });
-    saveTunnelConfig({ name, hostname });
-    emit(f, `tunnel saved: ${name} → ${hostname}\n` +
-        'first run: `cloudflared tunnel login` if you haven\'t (browser OAuth).\n' +
-        'then start metro — the daemon will spawn `cloudflared tunnel run` for you.', { ok: true, name, hostname });
-}
-async function cmdTunnelStatus(f) {
-    const cfg = loadTunnelConfig();
-    if (isJson(f))
-        return writeJson({ configured: !!cfg, tunnel: cfg });
-    if (!cfg)
-        return void process.stdout.write('metro tunnel\n\n  (not configured — run `metro tunnel setup <name> <hostname>`)\n\n');
-    process.stdout.write(`metro tunnel\n\n  name:     ${cfg.name}\n  hostname: ${cfg.hostname}\n\n`);
-}
-const hasCloudflared = () => spawnSync('cloudflared', ['--version'], { stdio: 'ignore' }).status === 0;
-function run(cmd, args, opts = {}) {
-    const r = spawnSync(cmd, args, { stdio: 'inherit' });
-    if (r.status !== 0 && !opts.allowFail)
-        throw exitErr(`${cmd} ${args.join(' ')} exited ${r.status}`, 2);
-}