@stage-labs/metro 0.1.0-beta.4 → 0.1.0-beta.41

package/dist/claude.js

@@ -0,0 +1,15 @@
+import { spawnSync } from 'node:child_process';
+const CHANNEL_FLAGS = ['--dangerously-load-development-channels', 'server:metro'];
+export const claudeArgs = (extra) => [
+    ...CHANNEL_FLAGS,
+    ...extra,
+];
+export function launchClaude(extra) {
+    const leaveToChild = () => undefined;
+    process.on('SIGINT', leaveToChild);
+    process.on('SIGTERM', leaveToChild);
+    const res = spawnSync('claude', claudeArgs(extra), { stdio: 'inherit' });
+    if (res.error !== undefined)
+        throw new Error('the `claude` command is not on PATH — install Claude Code first');
+    return Promise.resolve(res.status ?? 1);
+}

package/dist/cli.js

@@ -1,221 +1,195 @@
 #!/usr/bin/env node
-import { spawn } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import pkg from '../package.json' with { type: 'json' };
-import * as discord from './channels/discord.js';
-import * as telegram from './channels/telegram.js';
-import { errMsg } from './log.js';
-import { CONFIG_ENV_FILE, configuredPlatforms, loadMetroEnv, readDotenv, STATE_DIR, writeDotenv } from './paths.js';
-const USAGE = `metro — Telegram + Discord bridge for your Claude Code / Codex agent
+import { hostname } from 'node:os';
+import { claimCode, claimRuntime, mcpServers, NotSignedIn, whoisAuthorized, } from './api.js';
+import { askSecret } from './prompt.js';
+import { clearToken, credentialsPath, metroUrl, metroWebUrl, writeToken, } from './store.js';
+import { detach, lockedBy, probe, runningPid, stopAll, tail } from './control.js';
+import { tailEvents } from './tail.js';
+import { assertAgentId, daemonPlan, localUrl, readRunToken, runDaemon, runtimeDir, runTokenState, writeRunToken, } from './runtime.js';
+import { launchClaude } from './claude.js';
+import { bedrock } from './bedrock.js';
+import { installPlugin, syncPluginServers } from './plugin.js';
+import { update } from './update.js';
+import { serve } from './serve.js';
+import { currentVersion } from './version.js';
+const USAGE = `metro — the command line for your MCP connectors
 
-Usage:
-  metro                                       Run the orchestrator daemon.
-  metro setup [telegram|discord <token>]      Save token, or show status with no args.
-  metro setup clear [telegram|discord|all]    Remove tokens.
-  metro doctor                                Health check.
-  metro update                                Upgrade in place.
-  metro --version | --help
+  metro start <agent-id> [--detach]
+                  run that agent's stations on this machine
+  metro serve [--port <n>] [--tunnel]
+                  run a daemon of your own: its agents and stations live in ~/.metro/agents
+                  here, and metro.box manages it through the link it prints; --tunnel adds
+                  a public https address through a Cloudflare quick tunnel (needs
+                  cloudflared, no account) so the link works from anywhere
+  metro stop [agent-id]
+                  stop every metro daemon on this machine, however it was started
+  metro status <agent-id>
+                  is it running, and is it healthy
+  metro logs <agent-id> [-f]
+                  show the detached daemon's log
+  metro tail <agent-id>
+                  follow this machine's inbound events, one JSON line each
+  metro login [code]
+                  authorize this machine for one agent with a code from its page
+  metro logout    forget this machine's sign-in
+  metro whoami    print the account and agent this machine may read
+  metro mcp       print the mcpServers block of the authorized agent's connectors
+  metro plugin    set up the Claude Code plugin (connector servers + /metro:login)
+  metro claude [args...]
+                  open Claude Code with the metro channel; every argument is passed through
+  metro bedrock [args...]
+                  the same, with inference on Amazon Bedrock through a local proxy so the
+                  channel still works (needs AWS_BEARER_TOKEN_BEDROCK and AWS_REGION)
+  metro update    update to the newest published version
+  metro version   print this CLI's version
 
-Exit codes: 0 success · 1 usage · 2 config · 3 upstream
+Start Claude Code with all of them, without writing them to disk:
+
+  claude --mcp-config <(metro mcp)
+
+  METRO_URL          the metro to talk to (default https://mcp.metro.box)
+  METRO_UI_URL       where the web UI lives (default https://metro.box)
+  METRO_TOKEN        use this agent sign-in instead of the stored one; with neither,
+                     a machine running metro start uses its run token
+  METRO_RUN_TOKEN    use this runtime authorization instead of the stored one
+  METRO_BEDROCK_MODEL
+                     send every request to this Bedrock model id (default: derive from the
+                     model Claude Code asks for, e.g. eu.anthropic.claude-sonnet-4-6)
+  METRO_RUNTIME_DIR  run the daemon from this directory instead of the bundled one
 `;
-const exitErr = (msg, code) => Object.assign(new Error(msg), { code });
-const isJson = (f) => f.json === true;
-const emit = (f, human, structured) => {
-    process.stdout.write(isJson(f) ? JSON.stringify(structured) + '\n' : human + '\n');
-};
-const maskToken = (t) => !t ? '' : t.length <= 8 ? '••••' : `${t.slice(0, 6)}…${t.slice(-2)}`;
-const TOKEN_KEYS = { telegram: 'TELEGRAM_BOT_TOKEN', discord: 'DISCORD_BOT_TOKEN' };
-function parseArgs(argv) {
-    const positional = [];
-    const flags = {};
-    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) {
-            flags[a.slice(2, eq)] = a.slice(eq + 1);
-            continue;
-        }
-        const key = a.slice(2);
-        const next = argv[i + 1];
-        if (next !== undefined && !next.startsWith('--')) {
-            flags[key] = next;
-            i++;
-        }
-        else
-            flags[key] = true;
-    }
-    return { positional, flags };
+function hostLabel() {
+    const name = hostname().trim();
+    return name === '' ? 'unnamed machine' : name;
 }
-async function cmdSetup(positional, flags) {
-    const [sub, value] = positional;
-    if (!sub)
-        return cmdSetupStatus(flags);
-    if (sub === 'telegram' || sub === 'discord') {
-        if (!value)
-            throw new Error(`metro setup ${sub} <token> — token is required`);
-        const trimmed = value.trim();
-        let identity;
-        if (!flags['no-validate']) {
-            process.env[TOKEN_KEYS[sub]] = trimmed;
-            try {
-                identity = sub === 'telegram' ? `@${(await telegram.getMe()).username}` : (await discord.getMe()).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 env = readDotenv(CONFIG_ENV_FILE);
-        env[TOKEN_KEYS[sub]] = trimmed;
-        writeDotenv(CONFIG_ENV_FILE, env);
-        const human = `saved ${TOKEN_KEYS[sub]}${identity ? ` (verified as ${identity})` : ''} to ${CONFIG_ENV_FILE} (chmod 0600)`;
-        emit(flags, human, { ok: true, saved: TOKEN_KEYS[sub], verified_as: identity ?? null });
-        return;
-    }
-    if (sub === 'clear') {
-        const target = value ?? 'all';
-        const env = readDotenv(CONFIG_ENV_FILE);
-        if (target === 'all') {
-            delete env.TELEGRAM_BOT_TOKEN;
-            delete env.DISCORD_BOT_TOKEN;
-        }
-        else if (target === 'telegram' || target === 'discord')
-            delete env[TOKEN_KEYS[target]];
-        else
-            throw new Error(`metro setup clear <telegram|discord|all> — got '${target}'`);
-        writeDotenv(CONFIG_ENV_FILE, env);
-        emit(flags, `cleared ${target === 'all' ? 'all metro tokens' : TOKEN_KEYS[target]}`, { ok: true, cleared: target });
-        return;
-    }
-    throw new Error(`unknown setup subcommand '${sub}' (try: telegram, discord, clear)`);
+async function authorizeRuntime(agentId) {
+    process.stderr.write(`Authorize this machine at ${metroWebUrl()}/#/authorize/${agentId}\n`);
+    const code = (await askSecret('Paste the code (input is hidden): ')).trim();
+    if (code === '')
+        throw new Error('no code given');
+    const claimed = await claimRuntime(code, hostLabel());
+    writeRunToken(claimed.agent, claimed.token);
+    process.stderr.write(`Authorized as '${claimed.label}'.\n`);
+    return claimed.token;
 }
-async function cmdSetupStatus(flags) {
-    loadMetroEnv();
-    const tg = process.env.TELEGRAM_BOT_TOKEN ?? '';
-    const dc = process.env.DISCORD_BOT_TOKEN ?? '';
-    if (isJson(flags)) {
-        process.stdout.write(JSON.stringify({
-            version: pkg.version,
-            config_env_file: CONFIG_ENV_FILE,
-            tokens: { telegram: { set: !!tg, masked: maskToken(tg) }, discord: { set: !!dc, masked: maskToken(dc) } },
-        }) + '\n');
-        return;
-    }
-    const cfgState = existsSync(CONFIG_ENV_FILE) ? '' : ' (not yet written)';
-    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`);
-    process.stdout.write(!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 orchestrator, or `metro doctor` to verify.\n');
+async function usableRunToken(agentId) {
+    const stored = readRunToken(agentId);
+    if (stored === null)
+        return authorizeRuntime(agentId);
+    const state = await runTokenState(stored);
+    if (state !== 'stale')
+        return stored;
+    process.stderr.write(`metro no longer recognises this machine as the holder of ${agentId}: ` +
+        'it was taken back, or another machine claimed it since. Authorize it again.\n');
+    return authorizeRuntime(agentId);
+}
+async function start(argv) {
+    const agentId = assertAgentId(argv[0]);
+    if (runningPid(agentId) !== null || lockedBy() !== null)
+        throw new Error('a metro daemon is already running on this machine. ' +
+            'Stop it first: metro stop');
+    const dir = runtimeDir();
+    const token = await usableRunToken(agentId);
+    const detached = argv.includes('--detach');
+    const plan = daemonPlan({ agentId, token, dir });
+    if (!detached)
+        return runDaemon(agentId, plan);
+    const pid = detach({ agentId, ...plan });
+    process.stderr.write(`metro is running for ${agentId} (pid ${String(pid)})\n` +
+        `  logs:  metro logs ${agentId} -f\n` +
+        `  stop:  metro stop ${agentId}\n`);
+    return 0;
 }
-async function cmdDoctor(flags) {
-    loadMetroEnv();
-    const cfg = configuredPlatforms();
-    const checks = [{
-            name: 'tokens',
-            ok: cfg.telegram || cfg.discord,
-            detail: cfg.telegram || cfg.discord ? `loaded from ${existsSync(CONFIG_ENV_FILE) ? CONFIG_ENV_FILE : 'process env'}` : 'no platform configured — run `metro setup telegram|discord <token>`',
-        }];
-    for (const [p, getMe] of [['telegram', telegram.getMe], ['discord', discord.getMe]]) {
-        if (!cfg[p]) {
-            checks.push({ name: p, ok: null, detail: 'not configured' });
-            continue;
-        }
-        try {
-            const me = await getMe();
-            checks.push({ name: p, ok: true, detail: `getMe → ${p === 'telegram' ? '@' : ''}${me.username}` });
-        }
-        catch (err) {
-            checks.push({ name: p, ok: false, detail: errMsg(err) });
-        }
+async function stopDaemon(argv) {
+    const agentId = argv[0] === undefined ? undefined : assertAgentId(argv[0]);
+    const stopped = await stopAll(agentId);
+    if (stopped.length === 0) {
+        process.stderr.write('no metro daemon is running on this machine\n');
+        return 1;
     }
-    const lockFile = join(STATE_DIR, '.tail-lock');
-    if (!existsSync(lockFile))
-        checks.push({ name: 'orchestrator', 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: 'orchestrator', ok: true, detail: `running (pid ${pid})` });
-        }
-        catch {
-            checks.push({ name: 'orchestrator', ok: null, detail: 'stale lockfile (will auto-reclaim on next start)' });
-        }
-    if (isJson(flags))
-        process.stdout.write(JSON.stringify({ checks }) + '\n');
-    else {
-        process.stdout.write('metro doctor\n\n');
-        for (const c of checks)
-            process.stdout.write(`  ${c.ok === true ? '✓' : c.ok === false ? '✗' : '–'} ${c.name.padEnd(15)} ${c.detail}\n`);
-        process.stdout.write('\n');
+    for (const d of stopped)
+        process.stderr.write(`Stopped metro (pid ${String(d.pid)}, via ${d.via})\n`);
+    return 0;
+}
+async function status(argv) {
+    const agentId = assertAgentId(argv[0]);
+    const pid = runningPid(agentId);
+    if (pid === null) {
+        process.stdout.write(`${agentId}: not running\n`);
+        return 1;
     }
-    if (checks.some(c => c.ok === false))
-        throw exitErr('one or more checks failed', 3);
+    const health = await probe(localUrl());
+    process.stdout.write(`${agentId}: running (pid ${String(pid)}) · ` +
+        (health === null
+            ? `not answering on ${localUrl()}\n`
+            : `healthy, up ${String(health.uptime)}s\n`));
+    return health === null ? 1 : 0;
+}
+function logs(argv) {
+    const agentId = assertAgentId(argv[0]);
+    return tail(agentId, argv.includes('-f') || argv.includes('--follow'));
+}
+async function pastedCode(given) {
+    if (given !== undefined && given.trim() !== '')
+        return given.trim();
+    process.stderr.write(`Get a pairing code from the agent's page, or pick the agent at ${metroWebUrl()}/#/authorize\n`);
+    return askSecret('Paste the code here (input is hidden): ');
+}
+async function login(given) {
+    const { token, email, agent } = await claimCode(await pastedCode(given));
+    writeToken(token);
+    process.stderr.write(`Authorized '${agent}' for ${email}. Stored in ${credentialsPath()}\n`);
+    if (syncPluginServers())
+        process.stderr.write('Claude Code plugin refreshed — new sessions have the connectors; ' +
+            'run /reload-plugins in any session already open.\n');
 }
-async function cmdUpdate(flags) {
-    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(flags, `already on ${pkg.version} (latest ${tag})`, { ok: true, current: pkg.version, latest, upgraded: false });
-    const argv1 = process.argv[1] ?? '';
-    const 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];
-    if (isJson(flags))
-        process.stdout.write(JSON.stringify({ ok: true, current: pkg.version, latest, command: argv.join(' ') }) + '\n');
-    else
-        process.stdout.write(`metro ${pkg.version} → ${latest}\n$ ${argv.join(' ')}\n`);
-    await new Promise((resolve, reject) => {
-        const child = spawn(argv[0], argv.slice(1), { stdio: isJson(flags) ? 'ignore' : 'inherit' });
-        child.on('exit', code => code === 0 ? resolve() : reject(new Error(`${argv[0]} exited ${code}`)));
-        child.on('error', reject);
-    });
+async function whoami() {
+    const { email, agent } = await whoisAuthorized();
+    process.stdout.write(`${email} · agent '${agent}' on ${metroUrl()}\n`);
 }
+const HELP = new Set([undefined, 'help', '--help', '-h']);
 const COMMANDS = {
-    setup: cmdSetup,
-    doctor: (_, f) => cmdDoctor(f),
-    update: (_, f) => cmdUpdate(f),
+    login: async () => {
+        await login(process.argv[3]);
+        return 0;
+    },
+    logout: async () => {
+        clearToken();
+        process.stderr.write('Signed out.\n');
+        return Promise.resolve(0);
+    },
+    whoami: async () => {
+        await whoami();
+        return 0;
+    },
+    start: () => start(process.argv.slice(3)),
+    serve: () => serve(process.argv.slice(3)),
+    stop: () => stopDaemon(process.argv.slice(3)),
+    status: () => status(process.argv.slice(3)),
+    logs: () => logs(process.argv.slice(3)),
+    tail: () => tailEvents(process.argv.slice(3)),
+    mcp: async () => {
+        process.stdout.write(`${await mcpServers()}\n`);
+        return 0;
+    },
+    plugin: installPlugin,
+    claude: () => launchClaude(process.argv.slice(3)),
+    bedrock: () => bedrock(process.argv.slice(3)),
+    update,
+    version: async () => {
+        process.stdout.write(`${currentVersion()}\n`);
+        return Promise.resolve(0);
+    },
 };
-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('./orchestrator.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))
-            process.stdout.write(JSON.stringify({ ok: false, error: errMsg(err), code: code ?? 1 }) + '\n');
-        else
-            process.stderr.write(`error: ${errMsg(err)}\n`);
-        process.exit(typeof code === 'number' ? code : 1);
-    }
+async function run(command) {
+    const handler = command === undefined ? undefined : COMMANDS[command];
+    if (handler !== undefined)
+        return handler();
+    process.stderr.write(USAGE);
+    return Promise.resolve(HELP.has(command) ? 0 : 1);
 }
-await main();
+const code = await run(process.argv[2]).catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`metro: ${message}\n`);
+    return err instanceof NotSignedIn ? 2 : 1;
+});
+process.exit(code);

package/dist/control.js

@@ -0,0 +1,173 @@
+import { execFileSync, spawn } from 'node:child_process';
+import { existsSync, mkdirSync, openSync, readdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const STATE = () => join(homedir(), '.metro');
+export function serveStateDir() {
+    const xdg = process.env.XDG_CACHE_HOME?.trim();
+    const base = xdg === undefined || xdg === '' ? join(homedir(), '.cache') : xdg;
+    return join(base, 'metro', 'serve');
+}
+const serveLockPath = () => join(serveStateDir(), '.tail-lock');
+const pidPath = (agentId) => join(STATE(), `run-${agentId}.pid`);
+export const logPath = (agentId) => join(STATE(), 'logs', `${agentId}.log`);
+function ensureStateDirs() {
+    mkdirSync(STATE(), { recursive: true, mode: 0o700 });
+    mkdirSync(join(STATE(), 'logs'), { recursive: true, mode: 0o700 });
+}
+function readPid(agentId) {
+    try {
+        const pid = Number(readFileSync(pidPath(agentId), 'utf8').trim());
+        return Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function runningPid(agentId) {
+    const pid = readPid(agentId);
+    if (pid === null)
+        return null;
+    if (isAlive(pid))
+        return pid;
+    rmSync(pidPath(agentId), { force: true });
+    return null;
+}
+function writePid(agentId, pid) {
+    writeFileSync(pidPath(agentId), String(pid));
+}
+function clearPid(agentId) {
+    rmSync(pidPath(agentId), { force: true });
+}
+export function detach(opts) {
+    ensureStateDirs();
+    const out = openSync(logPath(opts.agentId), 'a');
+    const child = spawn(opts.command, opts.args, {
+        cwd: opts.cwd,
+        env: opts.env,
+        detached: true,
+        stdio: ['ignore', out, out],
+    });
+    child.unref();
+    const pid = child.pid ?? 0;
+    if (pid === 0)
+        throw new Error('could not start the metro daemon');
+    writePid(opts.agentId, pid);
+    return pid;
+}
+async function stopPid(pid, waitMs) {
+    process.kill(pid, 'SIGTERM');
+    const until = Date.now() + waitMs;
+    while (Date.now() < until) {
+        if (!isAlive(pid))
+            return;
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    process.kill(pid, 'SIGKILL');
+}
+const lockPath = () => process.env.METRO_STATE_DIR?.trim()
+    ? join(process.env.METRO_STATE_DIR.trim(), '.tail-lock')
+    : join(homedir(), '.cache', 'metro', '.tail-lock');
+function commandOf(pid) {
+    try {
+        return execFileSync('ps', ['-o', 'command=', '-p', String(pid)], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    }
+    catch {
+        return '';
+    }
+}
+const looksLikeMetro = (command) => command.includes('server.ts') || command.includes('metro');
+function holderOf(lockFile) {
+    let pid;
+    try {
+        pid = Number(readFileSync(lockFile, 'utf8').trim());
+    }
+    catch {
+        return null;
+    }
+    if (!Number.isInteger(pid) || pid <= 0 || !isAlive(pid))
+        return null;
+    return looksLikeMetro(commandOf(pid)) ? pid : null;
+}
+export const lockedBy = () => holderOf(lockPath());
+export const serveLockedBy = () => holderOf(serveLockPath());
+function trackedAgents(agentId) {
+    const tracked = new Set();
+    if (agentId !== undefined)
+        tracked.add(agentId);
+    try {
+        for (const name of readdirSync(STATE())) {
+            const found = /^run-(.+)\.pid$/.exec(name);
+            if (found?.[1] !== undefined)
+                tracked.add(found[1]);
+        }
+    }
+    catch {
+        return tracked;
+    }
+    return tracked;
+}
+export async function stopAll(agentId, waitMs = 10_000) {
+    const stopped = [];
+    const seen = new Set();
+    for (const id of trackedAgents(agentId)) {
+        const pid = runningPid(id);
+        if (pid === null || seen.has(pid))
+            continue;
+        seen.add(pid);
+        await stopPid(pid, waitMs);
+        clearPid(id);
+        stopped.push({ pid, via: id });
+    }
+    const holder = lockedBy();
+    if (holder !== null && !seen.has(holder)) {
+        seen.add(holder);
+        await stopPid(holder, waitMs);
+        rmSync(lockPath(), { force: true });
+        stopped.push({ pid: holder, via: 'the machine lock' });
+    }
+    const served = serveLockedBy();
+    if (served !== null && !seen.has(served)) {
+        await stopPid(served, waitMs);
+        rmSync(serveLockPath(), { force: true });
+        stopped.push({ pid: served, via: 'metro serve' });
+    }
+    return stopped;
+}
+export function tail(agentId, follow) {
+    const path = logPath(agentId);
+    if (!existsSync(path))
+        throw new Error(`no log for ${agentId} yet — it is only written when started with --detach`);
+    const args = follow ? ['-n', '200', '-f', path] : ['-n', '200', path];
+    const child = spawn('tail', args, { stdio: ['ignore', 'inherit', 'inherit'] });
+    return new Promise((resolve) => {
+        child.on('exit', (code) => {
+            resolve(code ?? 0);
+        });
+    });
+}
+export async function probe(url) {
+    try {
+        const res = await fetch(`${url}/health`, {
+            signal: AbortSignal.timeout(3_000),
+        });
+        if (!res.ok)
+            return null;
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+}