@stage-labs/metro 0.1.0-beta.20 → 0.1.0-beta.200

package/dist/api.js

@@ -1,103 +1,11 @@
-import { metroUrl, readToken } from './store.js';
-export class NotSignedIn extends Error {
-}
-const TIMEOUT_MS = 20_000;
-const LOOPBACK = new Set(['localhost', '127.0.0.1', '::1', '[::1]']);
-export function carriesSecretsSafely(base) {
-    let url;
-    try {
-        url = new URL(base);
-    }
-    catch {
-        return false;
-    }
-    if (url.protocol === 'https:')
-        return true;
-    return url.protocol === 'http:' && LOOPBACK.has(url.hostname);
-}
-function tokenOrThrow() {
-    if (!carriesSecretsSafely(metroUrl()))
-        throw new Error(`refusing to send your session to ${metroUrl()} in the clear — use https, or a loopback address`);
-    const token = readToken();
-    if (token === null)
-        throw new NotSignedIn('not signed in — run `metro login` first');
-    return token;
-}
-async function get(path) {
-    const auth = tokenOrThrow();
-    let res;
-    try {
-        res = await fetch(`${metroUrl()}${path}`, {
-            headers: { authorization: `Bearer ${auth}` },
-            signal: AbortSignal.timeout(TIMEOUT_MS),
-        });
-    }
-    catch {
-        throw new Error(`could not reach ${metroUrl()}`);
-    }
-    if (res.status === 401)
-        throw new NotSignedIn('that sign-in has expired — run `metro login` again');
-    if (!res.ok)
-        throw new Error(`metro answered ${String(res.status)}`);
-    return res.json();
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-async function post(path, body) {
-    if (!carriesSecretsSafely(metroUrl()))
-        throw new Error(`refusing to send your code to ${metroUrl()} in the clear — use https, or a loopback address`);
-    let res;
-    try {
-        res = await fetch(`${metroUrl()}${path}`, {
-            method: 'POST',
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify(body),
-            signal: AbortSignal.timeout(TIMEOUT_MS),
-        });
-    }
-    catch {
-        throw new Error(`could not reach ${metroUrl()}`);
-    }
-    const parsed = await res.json().catch(() => null);
-    if (res.ok)
-        return parsed;
-    const detail = isRecord(parsed) ? parsed.error : undefined;
-    throw new Error(typeof detail === 'string' ? detail : `metro answered ${String(res.status)}`);
-}
-export async function claimCode(code) {
-    const body = await post('/api/cli/claim', { code });
-    if (!isRecord(body) ||
-        typeof body.token !== 'string' ||
-        typeof body.email !== 'string' ||
-        typeof body.collection !== 'string')
-        throw new Error('metro returned an unexpected response');
-    return {
-        token: body.token,
-        email: body.email,
-        collection: body.collection,
-    };
-}
-export async function claimRuntime(code, label) {
-    const body = await post('/api/run/claim', { code, label });
-    if (!isRecord(body) ||
-        typeof body.token !== 'string' ||
-        typeof body.agent !== 'string' ||
-        typeof body.label !== 'string')
-        throw new Error('metro returned an unexpected response');
-    return { token: body.token, agent: body.agent, label: body.label };
-}
-export async function mcpServers() {
-    const body = await get('/api/cli/mcp');
-    if (!isRecord(body) || typeof body.json !== 'string')
-        throw new Error('metro returned an unexpected response');
-    return body.json;
-}
+import { localAgent, localDaemonUp } from './local.js';
+import { localUrl } from './runtime.js';
+const NO_DAEMON = `no metro daemon on ${localUrl()} — start one with: metro serve`;
 export async function whoisAuthorized() {
-    const body = await get('/api/cli/session');
-    if (!isRecord(body) ||
-        typeof body.email !== 'string' ||
-        typeof body.collection !== 'string')
-        throw new Error('metro returned an unexpected response');
-    return { email: body.email, collection: body.collection };
+    if (!(await localDaemonUp()))
+        throw new Error(NO_DAEMON);
+    const agent = localAgent();
+    if (agent === null)
+        throw new Error('no agent on this machine yet');
+    return { agent: agent.id, where: localUrl() };
 }

package/dist/claude-settings.js

@@ -0,0 +1,40 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { PROVIDER_FLAGS } from './provider-flags.js';
+const CONFLICTING = [...PROVIDER_FLAGS, 'ANTHROPIC_BASE_URL', 'ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'];
+export function settingsFiles(cwd = process.cwd(), env = process.env) {
+    const explicit = env.CLAUDE_CONFIG_DIR?.trim() ?? '';
+    const configDir = explicit === '' ? join(homedir(), '.claude') : explicit;
+    return [
+        ...new Set([
+            join(configDir, 'settings.json'),
+            join(cwd, '.claude', 'settings.json'),
+            join(cwd, '.claude', 'settings.local.json'),
+        ]),
+    ];
+}
+function envBlock(file) {
+    if (!existsSync(file))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        const block = parsed.env;
+        return typeof block === 'object' && block !== null ? block : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function settingsConflicts(files) {
+    const out = [];
+    for (const file of files) {
+        const block = envBlock(file);
+        for (const key of CONFLICTING) {
+            const value = block[key];
+            if (typeof value === 'string' && value.trim() !== '')
+                out.push(`${file}: ${key}`);
+        }
+    }
+    return out;
+}

package/dist/claude.js

@@ -0,0 +1,163 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { markOnboardingDone, seedChannels } from './onboarding.js';
+import { writeMcpConfig } from './mcp-config.js';
+import { currentRoute, permissionMode, routeModelEnv, systemPrompt } from './route.js';
+import { settingsConflicts, settingsFiles } from './claude-settings.js';
+import { localAgent } from './local.js';
+import { PROVIDER_FLAGS } from './provider-flags.js';
+import { localPort, localUrl } from './runtime.js';
+const CHANNEL_FLAGS = ['--dangerously-load-development-channels', 'server:metro'];
+const FRESH_PROMPT_FLAGS = ['--system-prompt-snapshot', 'off'];
+const PERMISSION_MODE_FLAG = { auto: 'auto', bypass: 'bypassPermissions' };
+const KEY_HEADER = 'x-metro-key';
+const PROBE_MS = 3_000;
+export const claudeArgs = (extra, mcpConfig, mode = 'auto', prompt = null) => [
+    ...CHANNEL_FLAGS,
+    '--permission-mode',
+    PERMISSION_MODE_FLAG[mode],
+    ...FRESH_PROMPT_FLAGS,
+    ...(mcpConfig === undefined ? [] : ['--mcp-config', mcpConfig]),
+    ...(prompt === null ? [] : ['--append-system-prompt', prompt]),
+    ...extra,
+];
+const set = (env, name) => (env[name] ?? '').trim() !== '';
+export function bypassSandboxEnv(env, mode, uid) {
+    if (mode !== 'bypass' || uid !== 0 || env.IS_SANDBOX !== undefined)
+        return env;
+    return { ...env, IS_SANDBOX: '1' };
+}
+export function pinnedBy(env) {
+    if (set(env, 'ANTHROPIC_BASE_URL'))
+        return 'ANTHROPIC_BASE_URL';
+    return PROVIDER_FLAGS.find((flag) => set(env, flag)) ?? null;
+}
+export function gatewayEnv(base, agentKey, port) {
+    if (agentKey === null || pinnedBy(base) !== null)
+        return base;
+    const own = (base.ANTHROPIC_CUSTOM_HEADERS ?? '').trim();
+    const mine = `${KEY_HEADER}: ${agentKey}`;
+    return {
+        ...base,
+        ANTHROPIC_BASE_URL: `http://127.0.0.1:${String(port)}/gateway`,
+        ANTHROPIC_CUSTOM_HEADERS: own === '' ? mine : `${own}\n${mine}`,
+        CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: '1',
+    };
+}
+const OWN_CREDENTIALS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'];
+export function credentialEnv(env, agentKey, signedIn) {
+    if (signedIn || OWN_CREDENTIALS.some((name) => set(env, name)))
+        return env;
+    return { ...env, ANTHROPIC_AUTH_TOKEN: agentKey };
+}
+export function claudeSignedIn() {
+    const run = spawnSync('claude', ['auth', 'status', '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    if (run.error !== undefined || typeof run.stdout !== 'string')
+        return false;
+    try {
+        const parsed = JSON.parse(run.stdout);
+        return parsed.authenticated === true || parsed.loggedIn === true || typeof parsed.email === 'string' || typeof parsed.organization === 'string';
+    }
+    catch {
+        return false;
+    }
+}
+export function servingDaemon(body) {
+    if (typeof body !== 'object' || body === null)
+        return false;
+    const mode = body;
+    return mode.mode === 'local' && mode.stopped !== true;
+}
+async function daemonServing(base = localUrl()) {
+    try {
+        const res = await fetch(`${base}/api/mode`, { signal: AbortSignal.timeout(PROBE_MS) });
+        return res.ok && servingDaemon(await res.json());
+    }
+    catch {
+        return false;
+    }
+}
+export function agentKey(agent) {
+    return agent === null ? { skip: 'no agent lives on this machine yet, so Claude Code talks to Anthropic directly' } : { key: agent.key };
+}
+async function verdict() {
+    const pinned = pinnedBy(process.env);
+    if (pinned !== null)
+        return { skip: `${pinned} is set, so Claude Code keeps talking to it` };
+    const conflicts = settingsConflicts(settingsFiles());
+    if (conflicts.length > 0)
+        return { skip: `a settings file pins the provider (${conflicts.join(', ')}), so Claude Code keeps it` };
+    const picked = agentKey(localAgent());
+    if ('skip' in picked)
+        return picked;
+    if (await daemonServing())
+        return picked;
+    return { skip: 'the daemon is not serving here (stopped, or not running), so Claude Code talks to Anthropic directly' };
+}
+export function runClaude(args, env) {
+    return new Promise((resolve, reject) => {
+        const leaveToChild = () => undefined;
+        process.on('SIGINT', leaveToChild);
+        process.on('SIGTERM', leaveToChild);
+        const child = spawn('claude', args, { stdio: 'inherit', env });
+        child.on('error', (err) => {
+            reject(new Error(err.code === 'ENOENT'
+                ? 'the `claude` command is not on PATH — install Claude Code first'
+                : err.message));
+        });
+        child.on('exit', (code) => {
+            resolve(code ?? 1);
+        });
+    });
+}
+async function servedKey(decision) {
+    if ('key' in decision)
+        return decision.key;
+    const picked = agentKey(localAgent());
+    if ('skip' in picked)
+        return null;
+    return (await daemonServing()) ? picked.key : null;
+}
+function mcpConfigFor(key, port) {
+    if (key === null)
+        return null;
+    const file = writeMcpConfig(key, port);
+    process.stderr.write(`metro claude: the metro MCP server is loaded for this session from the daemon at http://127.0.0.1:${String(port)}/mcp, nothing to add by hand\n`);
+    return file;
+}
+function gatewayLaunchEnv(key, port) {
+    process.stderr.write(`metro claude: inference goes through the daemon at http://127.0.0.1:${String(port)}/gateway (the Model page decides where)\n`);
+    const routed = routeModelEnv(gatewayEnv(process.env, key, port), currentRoute());
+    const env = credentialEnv(routed, key, claudeSignedIn());
+    if (env !== routed)
+        process.stderr.write("metro claude: Claude Code has no login of its own here, so metro's key stands in as its credential; the Model page must route to Bedrock, OpenRouter or Codex\n");
+    if (seedChannels() === 'marked')
+        process.stderr.write('metro claude: marked Channels as available in Claude Code cached flags, since a box that sends no telemetry never fetches them\n');
+    if (markOnboardingDone() === 'marked')
+        process.stderr.write("metro claude: skipped Claude Code's first-run setup, since it already has a credential here\n");
+    return env;
+}
+export async function launchClaude(extra) {
+    const decision = await verdict();
+    const port = localPort();
+    const mcp = mcpConfigFor(await servedKey(decision), port);
+    const mode = permissionMode();
+    const prompt = systemPrompt();
+    if (prompt !== null)
+        process.stderr.write('metro claude: the system prompt from the Harness page is appended to this session\n');
+    const sandbox = (env) => {
+        const out = bypassSandboxEnv(env, mode, process.getuid?.());
+        if (out !== env)
+            process.stderr.write('metro claude: bypass permission mode under root, so IS_SANDBOX=1 is set for Claude Code (it refuses to skip permissions as root otherwise); this box is a dedicated single-tenant machine\n');
+        return out;
+    };
+    try {
+        if ('skip' in decision) {
+            process.stderr.write(`metro claude: ${decision.skip}\n`);
+            return await runClaude(claudeArgs(extra, mcp?.path, mode, prompt), sandbox(process.env));
+        }
+        return await runClaude(claudeArgs(extra, mcp?.path, mode, prompt), sandbox(gatewayLaunchEnv(decision.key, port)));
+    }
+    finally {
+        mcp?.cleanup();
+    }
+}

package/dist/cli.js

@@ -1,127 +1,68 @@
 #!/usr/bin/env node
-import { hostname } from 'node:os';
-import { claimCode, claimRuntime, mcpServers, NotSignedIn, whoisAuthorized, } from './api.js';
-import { askLine } from './prompt.js';
-import { clearToken, credentialsPath, metroUrl, metroWebUrl, writeToken, } from './store.js';
-import { detach, probe, runningPid, stop, tail } from './control.js';
-import { assertAgentId, daemonPlan, localUrl, readRunToken, runDaemon, runtimeDir, writeRunToken, } from './runtime.js';
+import { whoisAuthorized } from './api.js';
+import { stopAll } from './control.js';
+import { tailEvents } from './tail.js';
+import { launchClaude } from './claude.js';
 import { update } from './update.js';
+import { serve } from './serve.js';
+import { service, serviceStopHint } from './service.js';
 import { currentVersion } from './version.js';
-const USAGE = `metro — the command line for your MCP connectors
+const USAGE = `metro — run your agent on this machine
 
-  metro start <agent-id> [--detach]
-                  run that agent's stations on this machine
-  metro stop <agent-id>
-                  stop the daemon started with --detach
-  metro status <agent-id>
-                  is it running, and is it healthy
-  metro logs <agent-id> [-f]
-                  show the detached daemon's log
-  metro login     authorize a connector collection with a code from the web UI
-  metro logout    forget this machine's sign-in
-  metro whoami    print the account and collection this machine may read
-  metro mcp       print the mcpServers block for the authorized collection
-  metro update    update to the newest published version
+  metro serve [--port <n>] [--owner <organization id>]
+                  run the daemon: the agent, its channels and its connectors live in
+                  ~/.metro/agents here, and it is published through Tailscale Funnel at a
+                  permanent https://<machine>.<tailnet>.ts.net (Tailscale installed and
+                  signed in on this machine); the page at metro.box manages it through the
+                  link it prints; --owner names the organization whose members may sign
+                  in, needed on the first start only; Stop on the page parks the daemon and keeps the
+                  address, so Start works from the page too
+  metro service install [--port <n>] [--owner <organization id>]
+                  run metro serve as a service (systemd on Linux, launchd on macOS): it
+                  starts at boot and after a crash, so the page can stop, start and
+                  restart it with no shell; metro service uninstall and status as well
+  metro stop      stop metro on this machine, metro serve included
+  metro tail [agent-id]
+                  follow this machine's inbound events, one JSON line each
+  metro whoami    print the agent this machine runs
+  metro claude [args...]
+                  open Claude Code with the metro channel and the metro MCP server, its
+                  inference routed through the daemon's model gateway (the Model page);
+                  every argument is passed through the same
+  metro update    update to the newest published version (--check only reports)
   metro version   print this CLI's version
 
-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 connector sign-in instead of the stored one
-  METRO_RUN_TOKEN    use this runtime authorization instead of the stored one
+  METRO_WEBHOOK_PORT the daemon's port (default 8420)
+  METRO_AGENTS_DIR   where the agents live (default ~/.metro/agents)
+  METRO_AGENT_KEY    the key metro tail presents, instead of the agent file's
   METRO_RUNTIME_DIR  run the daemon from this directory instead of the bundled one
 `;
-function hostLabel() {
-    const name = hostname().trim();
-    return name === '' ? 'unnamed machine' : name;
-}
-async function authorizeRuntime(agentId) {
-    process.stderr.write(`Authorize this machine at ${metroWebUrl()}/#/agent/${agentId}\n`);
-    const code = (await askLine('Paste the code: ')).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 start(argv) {
-    const agentId = assertAgentId(argv[0]);
-    if (runningPid(agentId) !== null)
-        throw new Error(`metro is already running for ${agentId} — stop it first`);
-    const dir = runtimeDir();
-    const token = readRunToken(agentId) ?? (await authorizeRuntime(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 stopDaemon(argv) {
-    const agentId = assertAgentId(argv[0]);
-    const stopped = await stop(agentId);
-    process.stderr.write(stopped ? `Stopped metro for ${agentId}\n` : `metro is not running for ${agentId}\n`);
-    return stopped ? 0 : 1;
-}
-async function status(argv) {
-    const agentId = assertAgentId(argv[0]);
-    const pid = runningPid(agentId);
-    if (pid === null) {
-        process.stdout.write(`${agentId}: not running\n`);
+async function stopDaemon() {
+    const stopped = await stopAll();
+    if (stopped.length === 0) {
+        process.stderr.write('no metro daemon is running on this machine\n');
         return 1;
     }
-    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 login() {
-    process.stderr.write(`Choose a connector collection at ${metroWebUrl()}/#/authorize\n`);
-    const { token, email, collection } = await claimCode(await askLine('Paste the code here: '));
-    writeToken(token);
-    process.stderr.write(`Authorized '${collection}' for ${email}. Stored in ${credentialsPath()}\n`);
-}
-async function whoami() {
-    const { email, collection } = await whoisAuthorized();
-    process.stdout.write(`${email} · collection '${collection}' on ${metroUrl()}\n`);
+    for (const d of stopped)
+        process.stderr.write(`Stopped metro (pid ${String(d.pid)}, via ${d.via})\n`);
+    const hint = serviceStopHint();
+    if (hint !== null)
+        process.stderr.write(`${hint}\n`);
+    return 0;
 }
 const HELP = new Set([undefined, 'help', '--help', '-h']);
 const COMMANDS = {
-    login: async () => {
-        await login();
-        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)),
-    stop: () => stopDaemon(process.argv.slice(3)),
-    status: () => status(process.argv.slice(3)),
-    logs: () => logs(process.argv.slice(3)),
-    mcp: async () => {
-        process.stdout.write(`${await mcpServers()}\n`);
+        const { agent, where } = await whoisAuthorized();
+        process.stdout.write(`agent ${agent} on ${where}\n`);
         return 0;
     },
-    update,
+    serve: () => serve(process.argv.slice(3)),
+    service: () => service(process.argv.slice(3)),
+    stop: stopDaemon,
+    tail: () => tailEvents(process.argv.slice(3)),
+    claude: () => launchClaude(process.argv.slice(3)),
+    update: () => update(process.argv.slice(3)),
     version: async () => {
         process.stdout.write(`${currentVersion()}\n`);
         return Promise.resolve(0);
@@ -137,6 +78,6 @@ async function run(command) {
 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;
+    return 1;
 });
 process.exit(code);

package/dist/control.js

@@ -1,23 +1,13 @@
-import { spawn } from 'node:child_process';
-import { existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { readFileSync, rmSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-const STATE = () => join(homedir(), '.metro');
-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;
-    }
+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');
 function isAlive(pid) {
     try {
         process.kill(pid, 0);
@@ -27,76 +17,58 @@ function isAlive(pid) {
         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;
-}
-export async function stop(agentId, waitMs = 10_000) {
-    const pid = runningPid(agentId);
-    if (pid === null)
-        return false;
+async function stopPid(pid, waitMs) {
     process.kill(pid, 'SIGTERM');
     const until = Date.now() + waitMs;
     while (Date.now() < until) {
-        if (!isAlive(pid)) {
-            clearPid(agentId);
-            return true;
-        }
+        if (!isAlive(pid))
+            return;
         await new Promise((r) => setTimeout(r, 100));
     }
     process.kill(pid, 'SIGKILL');
-    clearPid(agentId);
-    return true;
 }
-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);
+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 '';
+    }
 }
-export async function probe(url) {
+const looksLikeMetro = (command) => command.includes('server.ts') || command.includes('metro');
+function holderOf(lockFile) {
+    let pid;
     try {
-        const res = await fetch(`${url}/health`, {
-            signal: AbortSignal.timeout(3_000),
-        });
-        if (!res.ok)
-            return null;
-        return (await res.json());
+        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());
+export async function stopAll(waitMs = 10_000) {
+    const stopped = [];
+    const holder = lockedBy();
+    if (holder !== null) {
+        await stopPid(holder, waitMs);
+        rmSync(lockPath(), { force: true });
+        stopped.push({ pid: holder, via: 'the machine lock' });
+    }
+    const served = serveLockedBy();
+    if (served !== null && served !== holder) {
+        await stopPid(served, waitMs);
+        rmSync(serveLockPath(), { force: true });
+        stopped.push({ pid: served, via: 'metro serve' });
+    }
+    return stopped;
 }