@stage-labs/metro 0.1.0-beta.50 → 0.1.0-beta.52

package/dist/api.js

@@ -1,148 +1,14 @@
-import { metroUrl, readRunTokens, readToken } from './store.js';
 import { localAgents, localDaemonUp, localMcpServers, pickLocalAgent } from './local.js';
 import { localUrl } from './runtime.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() ?? soleRunToken();
-    if (token === null)
-        throw new NotSignedIn('not signed in — run `metro login`, or `metro start <agent-id>` on this machine');
-    return token;
-}
-function soleRunToken() {
-    const tokens = readRunTokens();
-    return tokens.length === 1 ? (tokens[0] ?? null) : null;
-}
-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("metro refused this machine's sign-in — 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 class RuntimeRevoked extends Error {
-}
-export function keyOfRunConfig(body) {
-    const agent = isRecord(body) ? body.agent : undefined;
-    const key = isRecord(agent) ? agent.key : undefined;
-    if (typeof key !== 'string' || key === '')
-        throw new Error('this agent has no key — reset it on its page in the web UI');
-    return key;
-}
-export async function runConfigKey(token) {
-    if (!carriesSecretsSafely(metroUrl()))
-        throw new Error(`refusing to send this machine's authorization to ${metroUrl()} in the clear — use https, or a loopback address`);
-    let res;
-    try {
-        res = await fetch(`${metroUrl()}/api/run/config`, {
-            headers: { authorization: `Bearer ${token}` },
-            signal: AbortSignal.timeout(TIMEOUT_MS),
-        });
-    }
-    catch {
-        throw new Error(`could not reach ${metroUrl()}`);
-    }
-    if (res.status === 401 || res.status === 403 || res.status === 409)
-        throw new RuntimeRevoked('this machine no longer holds the agent — authorize it again from the agent page');
-    if (!res.ok)
-        throw new Error(`metro answered ${String(res.status)}`);
-    return keyOfRunConfig(await res.json());
-}
-export async function claimCode(code) {
-    const body = await post('/api/cli/claim', { code });
-    if (!isRecord(body) ||
-        typeof body.token !== 'string' ||
-        typeof body.subject !== 'string' ||
-        typeof body.agent !== 'string')
-        throw new Error('metro returned an unexpected response');
-    return { token: body.token, subject: body.subject, agent: body.agent };
-}
-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 };
-}
+const NO_DAEMON = `no metro daemon on ${localUrl()} — start one with: metro serve`;
 export async function mcpServers(wanted) {
-    if (await localDaemonUp()) {
-        const agents = localAgents();
-        if (agents.length > 0)
-            return localMcpServers(pickLocalAgent(agents, wanted));
-    }
-    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;
+    if (!(await localDaemonUp()))
+        throw new Error(NO_DAEMON);
+    return localMcpServers(pickLocalAgent(localAgents(), wanted));
 }
 export async function whoisAuthorized(wanted) {
-    if (await localDaemonUp()) {
-        const agents = localAgents();
-        if (agents.length > 0) {
-            const agent = pickLocalAgent(agents, wanted);
-            return { subject: 'this machine', agent: agent.name, where: `${localUrl()} (local)` };
-        }
-    }
-    return { ...(await hostedIdentity()), where: metroUrl() };
-}
-async function hostedIdentity() {
-    const body = await get('/api/cli/session');
-    if (!isRecord(body) ||
-        typeof body.subject !== 'string' ||
-        typeof body.agent !== 'string')
-        throw new Error('metro returned an unexpected response');
-    return { subject: body.subject, agent: body.agent };
+    if (!(await localDaemonUp()))
+        throw new Error(NO_DAEMON);
+    const agent = pickLocalAgent(localAgents(), wanted);
+    return { agent: agent.name, where: localUrl() };
 }

package/dist/cli.js

@@ -1,110 +1,53 @@
 #!/usr/bin/env node
-import { hostname } from 'node:os';
-import { claimCode, claimRuntime, mcpServers, NotSignedIn, whoisAuthorized, } from './api.js';
-import { askSecret } from './prompt.js';
-import { clearToken, credentialsPath, metroWebUrl, writeToken, } from './store.js';
-import { detach, lockedBy, probe, runningPid, stopAll, tail } from './control.js';
+import { mcpServers, whoisAuthorized } from './api.js';
+import { stopAll } 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 { installPlugin } 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
+const USAGE = `metro — run your agent on this machine
 
-  metro start <agent-id> [--detach]
-                  run that agent's stations on this machine
   metro serve [--port <n>] [--tunnel] [--owner <address>]
-                  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
+                  run the daemon: the agent, its channels and its connectors live in
+                  ~/.metro/agents here, and the page at metro.box manages it through the
+                  link it prints; --owner names the one wallet that may sign in (remembered
+                  after the first start); --tunnel adds a public https address through a
+                  Cloudflare quick tunnel (needs cloudflared, no account) so the link works
+                  from anywhere
+  metro stop      stop the metro daemon on this machine
   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 [agent]
-                  print the account and agent this machine may read
+                  print the agent this machine runs
   metro mcp [agent]
-                  print the mcpServers block of the agent's connectors; with a local daemon
-                  running, its agent's connectors (name one if several)
-  metro plugin    set up the Claude Code plugin (connector servers + /metro:login)
+                  print the mcpServers block of the agent's connectors, served through the
+                  daemon's own relay (name the agent if several live here)
+  metro plugin    set up the Claude Code plugin (connector servers + /metro:refresh)
   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 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:
+Start Claude Code with every connector, writing nothing 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_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_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
 `;
-function hostLabel() {
-    const name = hostname().trim();
-    return name === '' ? 'unnamed machine' : name;
-}
-async function authorizeRuntime(agentId) {
-    process.stderr.write(`Authorize this machine with a pairing code for agent ${agentId} from ${metroWebUrl()}\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 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 stopDaemon(argv) {
-    const agentId = argv[0] === undefined ? undefined : assertAgentId(argv[0]);
-    const stopped = await stopAll(agentId);
+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;
@@ -113,62 +56,15 @@ async function stopDaemon(argv) {
         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;
-    }
-    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 for the agent from ${metroWebUrl()}\n`);
-    return askSecret('Paste the code here (input is hidden): ');
-}
-async function login(given) {
-    const { token, subject, agent } = await claimCode(await pastedCode(given));
-    writeToken(token);
-    process.stderr.write(`Authorized '${agent}' for ${subject}. 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 whoami(wanted) {
-    const { subject, agent, where } = await whoisAuthorized(wanted);
-    process.stdout.write(`${subject} · agent '${agent}' on ${where}\n`);
-}
 const HELP = new Set([undefined, 'help', '--help', '-h']);
 const COMMANDS = {
-    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(process.argv[3]);
+        const { agent, where } = await whoisAuthorized(process.argv[3]);
+        process.stdout.write(`agent '${agent}' on ${where}\n`);
         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)),
+    stop: stopDaemon,
     tail: () => tailEvents(process.argv.slice(3)),
     mcp: async () => {
         process.stdout.write(`${await mcpServers(process.argv[3])}\n`);
@@ -177,7 +73,7 @@ const COMMANDS = {
     plugin: installPlugin,
     claude: () => launchClaude(process.argv.slice(3)),
     bedrock: () => bedrock(process.argv.slice(3)),
-    update,
+    update: () => update(process.argv.slice(3)),
     version: async () => {
         process.stdout.write(`${currentVersion()}\n`);
         return Promise.resolve(0);
@@ -193,6 +89,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,29 +1,13 @@
-import { execFileSync, spawn } from 'node:child_process';
-import { existsSync, mkdirSync, openSync, readdirSync, 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');
 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);
@@ -33,37 +17,6 @@ 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;
-}
 async function stopPid(pid, waitMs) {
     process.kill(pid, 'SIGTERM');
     const until = Date.now() + waitMs;
@@ -103,71 +56,19 @@ function holderOf(lockFile) {
 }
 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) {
+export async function stopAll(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);
+    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 && !seen.has(served)) {
+    if (served !== null && served !== holder) {
         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;
-    }
-}

package/dist/plugin.js

@@ -2,7 +2,6 @@ import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { readToken } from './store.js';
 const MARKETPLACE_REPO = 'bonustrack/metro';
 const PLUGIN_SPEC = 'metro@metro';
 export function installPathFrom(raw) {
@@ -48,7 +47,7 @@ function runClaude(args) {
 const tolerable = (output) => /already|exists|latest version/i.test(output);
 export function syncPluginServers() {
     const path = pluginInstallPath();
-    if (path === null || readToken() === null)
+    if (path === null)
         return false;
     const script = join(path, 'bin', 'metro-plugin.mjs');
     const refreshed = spawnSync(process.execPath, [script, 'refresh'], {
@@ -76,7 +75,6 @@ export async function installPlugin() {
             'run /reload-plugins in any session already open.\n');
         return 0;
     }
-    process.stderr.write('Now sign in: metro login (with a pairing code from https://metro.box), ' +
-        'or run /metro:login <code> inside Claude Code.\n');
+    process.stderr.write('Start the daemon on this machine (metro serve), then run /metro:refresh inside Claude Code.\n');
     return Promise.resolve(0);
 }

package/dist/runtime.js

@@ -1,10 +1,7 @@
 import { spawn, spawnSync } from 'node:child_process';
-import { mkdirSync, readFileSync, writeFileSync, chmodSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { existsSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { metroUrl } from './store.js';
 const AGENT_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{10}$/;
 export const SERVER_ENTRY = join('node_modules', '@metro-labs', 'mcp', 'src', 'server.ts');
 export class MissingRuntime extends Error {
@@ -28,77 +25,14 @@ export function assertAgentId(id) {
 export function findBun() {
     const found = spawnSync('bun', ['--version'], { stdio: 'ignore' });
     if (found.error !== undefined || found.status !== 0)
-        throw new MissingBun('metro start needs Bun, which is not on PATH.\n' +
+        throw new MissingBun('metro serve needs Bun, which is not on PATH.\n' +
             'Install it with:  curl -fsSL https://bun.sh/install | bash');
     return 'bun';
 }
-function tokenPath(agentId) {
-    const xdg = process.env.XDG_CONFIG_HOME?.trim();
-    const base = xdg === undefined || xdg === '' ? join(homedir(), '.config') : xdg;
-    return join(base, 'metro', `runtime-${agentId}.json`);
-}
-export function readRunToken(agentId) {
-    const fromEnv = process.env.METRO_RUN_TOKEN?.trim();
-    if (fromEnv !== undefined && fromEnv !== '')
-        return fromEnv;
-    try {
-        const parsed = JSON.parse(readFileSync(tokenPath(agentId), 'utf8'));
-        if (typeof parsed.token !== 'string' || parsed.token === '')
-            return null;
-        return parsed.url === metroUrl() ? parsed.token : null;
-    }
-    catch {
-        return null;
-    }
-}
-export function writeRunToken(agentId, token) {
-    const path = tokenPath(agentId);
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    writeFileSync(path, JSON.stringify({ token, url: metroUrl() }, null, 2));
-    chmodSync(path, 0o600);
-}
-const PROBE_TIMEOUT_MS = 15_000;
-export async function runTokenState(token) {
-    let res;
-    try {
-        res = await fetch(`${metroUrl()}/api/run/config`, {
-            headers: { authorization: `Bearer ${token}` },
-            signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
-            redirect: 'manual',
-        });
-    }
-    catch {
-        return 'unreachable';
-    }
-    await res.arrayBuffer().catch(() => undefined);
-    if (res.ok)
-        return 'ok';
-    return res.status === 401 || res.status === 403 || res.status === 409
-        ? 'stale'
-        : 'unreachable';
-}
 export const localPort = () => Number(process.env.METRO_WEBHOOK_PORT) || 8420;
 export const localUrl = () => `http://127.0.0.1:${String(localPort())}`;
-export function daemonPlan(opts) {
-    return {
-        command: findBun(),
-        args: [SERVER_ENTRY],
-        cwd: opts.dir,
-        env: {
-            ...process.env,
-            METRO_RUN_TOKEN: opts.token,
-            METRO_AGENT: opts.agentId,
-            METRO_URL: metroUrl(),
-            METRO_HTTP_HOST: process.env.METRO_HTTP_HOST ?? '127.0.0.1',
-            METRO_TRAINS_DIR: join(opts.dir, 'trains'),
-        },
-    };
-}
-export function runDaemon(agentId, plan) {
-    process.stderr.write(`Starting metro for ${agentId}\n`);
-    return spawnPlan(plan);
-}
-export function spawnPlan(plan) {
+export const RESTART_CODE = 75;
+function spawnOnce(plan) {
     const child = spawn(plan.command, plan.args, {
         cwd: plan.cwd,
         env: plan.env,
@@ -107,11 +41,23 @@ export function spawnPlan(plan) {
     const relay = (sig) => () => {
         child.kill(sig);
     };
-    process.on('SIGINT', relay('SIGINT'));
-    process.on('SIGTERM', relay('SIGTERM'));
+    const onInt = relay('SIGINT');
+    const onTerm = relay('SIGTERM');
+    process.on('SIGINT', onInt);
+    process.on('SIGTERM', onTerm);
     return new Promise((resolve) => {
         child.on('exit', (code) => {
+            process.off('SIGINT', onInt);
+            process.off('SIGTERM', onTerm);
             resolve(code ?? 0);
         });
     });
 }
+export async function spawnPlan(plan) {
+    for (;;) {
+        const code = await spawnOnce(plan());
+        if (code !== RESTART_CODE)
+            return code;
+        process.stderr.write('metro was updated; restarting the daemon on the new version\n');
+    }
+}

package/dist/serve.js

@@ -85,6 +85,7 @@ export function servePlan(opts) {
             ...env,
             METRO_MODE: 'local',
             METRO_VERSION: currentVersion(),
+            METRO_CLI_BIN: process.argv[1] ?? '',
             METRO_WEBHOOK_PORT: String(opts.port),
             METRO_HTTP_HOST: process.env.METRO_HTTP_HOST ?? '127.0.0.1',
             METRO_TRAINS_DIR: join(opts.dir, 'trains'),
@@ -103,7 +104,7 @@ export function serve(argv) {
     requireOwner(owner);
     if (tunnel)
         findCloudflared();
-    const plan = servePlan({ dir: runtimeDir(), port, tunnel, owner });
+    const dir = runtimeDir();
     process.stderr.write(`Starting a metro daemon of your own on http://127.0.0.1:${String(port)}\n`);
-    return spawnPlan(plan);
+    return spawnPlan(() => servePlan({ dir, port, tunnel, owner }));
 }