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

package/dist/cli/config.js

@@ -1,129 +1,119 @@
-/** Setup / doctor / update — config-side commands consumed by cli.ts. */
-import { existsSync, readFileSync } from 'node:fs';
+/** `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 { join } from 'node:path';
+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 { 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 { 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';
-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))
+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 env = readDotenv(path);
-        if (value === null) {
-            if (!(key in env))
-                continue;
-            delete env[key];
+        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);
         }
-        else
-            env[key] = value;
-        writeDotenv(path, env);
-        out.push(path);
     }
-    return out;
+    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 });
 }
-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}`);
+/** 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, value] = p;
-    if (!sub)
-        return cmdSetupStatus(f);
+    const [sub] = p;
     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';
+    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 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) });
-        }
+    if (!existsSync(TRAINS_DIR)) {
+        checks.push({ name: 'trains', ok: null, detail: `${TRAINS_DIR} (not created — \`mkdir -p\` it and drop in train files)` });
     }
-    checks.unshift({
-        name: 'tokens', ok: cfg.telegram || cfg.discord,
-        detail: sources.length ? sources.join(', ') : 'no platform configured — run `metro setup telegram|discord <token>`',
-    });
+    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' });
@@ -138,18 +128,22 @@ export async function cmdDoctor(_, f) {
         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`)',
-    });
+    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');

package/dist/cli/index.js

@@ -1,83 +1,65 @@
-#!/usr/bin/env node
-/** Metro CLI entry: parses argv, dispatches to subcommands, owns action + info commands. */
+#!/usr/bin/env bun
+/** Metro CLI: parses argv, dispatches to subcommands. Bun runtime required (uses Bun.spawn for trains). */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
 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 { errMsg, log } from '../log.js';
+import { listLines, loadMetroEnv, STATE_DIR } 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 { cmdCall, cmdTrains, 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
+/** True if another live process owns the dispatcher lockfile. Mirrors paths.acquireLock'
+ *  s detection but as a peek — no claim, no exit. */
+function anotherDispatcherRunning() {
+    const lockFile = join(STATE_DIR, '.tail-lock');
+    if (!existsSync(lockFile))
+        return false;
+    const pid = Number(readFileSync(lockFile, 'utf8').trim());
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+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 [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 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 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=…]
+  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=…] [--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).
+                                              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 (run cloudflared tunnel login first).
+  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
 
-Lines: metro://<station>/<path>. See docs/uri-scheme.md.
-Multi-line --text: pipe on stdin in place of the positional arg.
+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 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()
@@ -112,7 +94,6 @@ async function cmdHistory(_, f) {
     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,
@@ -124,14 +105,14 @@ async function cmdHistory(_, f) {
         process.stdout.write('(no matching history entries)\n');
         return;
     }
-    process.stdout.write('time      id            kind          from                      → to                        body\n');
+    process.stdout.write('time      id            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 body = e.text ?? '';
         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`);
+        process.stdout.write(`${ts}  ${e.id.padEnd(12)}  ${from} → ${to}  ${text}\n`);
     }
 }
 /** Compact display: fromName if known; else `station:@<id>` (user) or `station:<id>`. */
@@ -149,9 +130,8 @@ function fmtActor(uri, name) {
 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,
+    setup: cmdSetup, doctor: cmdDoctor, lines: cmdLines,
+    call: cmdCall, trains: cmdTrains,
     webhook: cmdWebhook, tunnel: cmdTunnel,
     history: cmdHistory, tail: cmdTail,
     claim: cmdClaim, release: cmdRelease, claims: cmdClaims,
@@ -164,6 +144,13 @@ async function main() {
     if (cmd === '--help' || cmd === '-h')
         return void process.stdout.write(USAGE);
     if (!cmd) {
+        /** Multi-agent: another `metro` already owns the dispatcher → drop into tail mode so
+         *  a second agent (e.g. Codex while Claude is running) still gets the event stream. */
+        if (anotherDispatcherRunning()) {
+            log.info({}, 'dispatcher already running; subscribing as tail (--follow --json --since=tail)');
+            await cmdTail([], { follow: true, json: true, since: 'tail' });
+            return;
+        }
         await import('../dispatcher.js');
         return;
     }