@stage-labs/metro 0.1.0-beta.21 → 0.1.0-beta.211

package/dist/hold.js

@@ -0,0 +1,210 @@
+import { spawn } from 'node:child_process';
+import { readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+const FUNNEL_RETRY_MS = 2_000;
+const FUNNEL_EXIT_WAIT_MS = 5_000;
+const LISTEN_ATTEMPTS = 10;
+const LISTEN_RETRY_MS = 500;
+const STOPPED = 503;
+export const STOPPED_MESSAGE = 'metro is stopped on this machine. Start it from the Server page on metro.box, or run metro serve.';
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+function corsHeaders(req) {
+    return {
+        'access-control-allow-origin': req.headers.origin ?? '*',
+        'access-control-allow-methods': 'GET, POST, PUT, DELETE, OPTIONS',
+        'access-control-allow-headers': 'Authorization, Content-Type',
+        'access-control-allow-private-network': 'true',
+        'access-control-max-age': '86400',
+        vary: 'Origin',
+    };
+}
+function sendJson(req, res, status, body) {
+    res.writeHead(status, {
+        'content-type': 'application/json',
+        'cache-control': 'no-store',
+        ...corsHeaders(req),
+    });
+    res.end(JSON.stringify(body));
+}
+function holdRequest(req, res, info, onStart) {
+    const path = (req.url ?? '').split('?')[0] ?? '';
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204, corsHeaders(req)).end();
+        return;
+    }
+    if (path === '/api/mode' && req.method === 'GET') {
+        sendJson(req, res, 200, {
+            mode: 'local',
+            owner: info.owner,
+            version: info.version,
+            stopped: true,
+        });
+        return;
+    }
+    if (path === '/api/start') {
+        if (req.method !== 'POST') {
+            sendJson(req, res, 405, { error: 'method not allowed' });
+            return;
+        }
+        sendJson(req, res, 200, { starting: true });
+        onStart();
+        return;
+    }
+    if (path === '/health' || path === '/healthz') {
+        sendJson(req, res, STOPPED, { status: 'stopped', version: info.version });
+        return;
+    }
+    sendJson(req, res, STOPPED, { error: STOPPED_MESSAGE, stopped: true });
+}
+export const holdServer = (info, onStart) => createServer((req, res) => {
+    holdRequest(req, res, info, onStart);
+});
+const lastLine = (chunk) => String(chunk).trim().split('\n').at(-1) ?? '';
+class HeldFunnel {
+    bin;
+    port;
+    log;
+    child = null;
+    closed = false;
+    timer = null;
+    exits = 0;
+    constructor(bin, port, log) {
+        this.bin = bin;
+        this.port = port;
+        this.log = log;
+    }
+    start() {
+        if (this.closed)
+            return;
+        const child = spawn(this.bin, ['funnel', String(this.port)], { stdio: ['ignore', 'pipe', 'pipe'] });
+        this.child = child;
+        let last = '';
+        const read = (chunk) => {
+            const line = lastLine(chunk);
+            if (line !== '')
+                last = line;
+        };
+        child.stdout?.on('data', read);
+        child.stderr?.on('data', read);
+        child.on('error', (err) => {
+            this.child = null;
+            this.closed = true;
+            this.log(`funnel could not start (${err.message}); the loopback address is still held`);
+        });
+        child.on('exit', () => {
+            this.child = null;
+            if (this.closed)
+                return;
+            this.exits += 1;
+            if (this.exits > 1)
+                this.log(`funnel exited (${last}); retrying in ${String(FUNNEL_RETRY_MS / 1000)}s`);
+            this.timer = setTimeout(() => {
+                this.start();
+            }, FUNNEL_RETRY_MS);
+        });
+    }
+    async stop() {
+        this.closed = true;
+        if (this.timer !== null)
+            clearTimeout(this.timer);
+        const child = this.child;
+        this.child = null;
+        if (child === null)
+            return;
+        if (child.exitCode !== null || child.signalCode !== null)
+            return;
+        await new Promise((resolve) => {
+            const kill = setTimeout(() => {
+                child.kill('SIGKILL');
+            }, FUNNEL_EXIT_WAIT_MS);
+            child.once('exit', () => {
+                clearTimeout(kill);
+                resolve();
+            });
+            child.kill('SIGINT');
+        });
+    }
+}
+async function listen(server, info) {
+    for (let attempt = 1;; attempt += 1) {
+        try {
+            await new Promise((resolve, reject) => {
+                server.once('error', reject);
+                server.listen(info.port, info.host, () => {
+                    server.off('error', reject);
+                    resolve();
+                });
+            });
+            return;
+        }
+        catch (err) {
+            if (attempt >= LISTEN_ATTEMPTS)
+                throw err;
+            await wait(LISTEN_RETRY_MS);
+        }
+    }
+}
+const CLOSE_WAIT_MS = 2_000;
+const close = (server) => new Promise((resolve) => {
+    const timer = setTimeout(resolve, CLOSE_WAIT_MS);
+    server.close(() => {
+        clearTimeout(timer);
+        resolve();
+    });
+    server.closeAllConnections();
+});
+function releaseLock(lockFile) {
+    try {
+        if (readFileSync(lockFile, 'utf8').trim() === String(process.pid))
+            rmSync(lockFile, { force: true });
+    }
+    catch {
+        return;
+    }
+}
+function armFunnel(info, log, ending) {
+    if (info.funnel === null || ending !== null)
+        return null;
+    const funnel = new HeldFunnel(info.funnel, info.port, log);
+    funnel.start();
+    return funnel;
+}
+export const holdBanner = (info) => `metro is stopped. Holding http://${info.host}:${String(info.port)}${info.funnel === null ? '' : ' and the Funnel address'} ` +
+    'until Start on the Server page; Ctrl-C or metro stop ends metro serve';
+export async function holdUntilStart(info, deps = {}) {
+    const signals = deps.signals ?? process;
+    const log = deps.log ??
+        ((line) => {
+            process.stderr.write(`${line}\n`);
+        });
+    let finish = () => undefined;
+    let ending = null;
+    const ended = new Promise((resolve) => {
+        finish = (end) => {
+            ending ??= end;
+            resolve(end);
+        };
+    });
+    const server = holdServer(info, () => {
+        finish('start');
+    });
+    const onSignal = () => {
+        finish('exit');
+    };
+    signals.on('SIGINT', onSignal);
+    signals.on('SIGTERM', onSignal);
+    if (info.lockFile !== null)
+        writeFileSync(info.lockFile, String(process.pid));
+    await listen(server, info);
+    const funnel = armFunnel(info, log, ending);
+    if (ending === null)
+        log(holdBanner(info));
+    const end = await ended;
+    signals.off('SIGINT', onSignal);
+    signals.off('SIGTERM', onSignal);
+    await funnel?.stop();
+    await close(server);
+    if (info.lockFile !== null)
+        releaseLock(info.lockFile);
+    return end;
+}

package/dist/local.js

@@ -0,0 +1,43 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { localUrl } from './runtime.js';
+const PROBE_MS = 3_000;
+export function agentsDir() {
+    const explicit = process.env.METRO_AGENTS_DIR?.trim();
+    return explicit !== undefined && explicit !== '' ? explicit : join(homedir(), '.metro', 'agents');
+}
+function agentFile(dir) {
+    try {
+        return JSON.parse(readFileSync(join(dir, 'agent.json'), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function localAgent(dir = agentsDir()) {
+    const file = agentFile(dir);
+    return typeof file?.id === 'string' && typeof file.key === 'string' ? { id: file.id, key: file.key } : null;
+}
+export function localStations(dir = agentsDir()) {
+    const stations = agentFile(dir)?.stations;
+    if (!Array.isArray(stations))
+        return [];
+    const out = new Set();
+    for (const s of stations) {
+        const station = s.station;
+        if (typeof station === 'string')
+            out.add(station);
+    }
+    return [...out].sort();
+}
+export async function localDaemonUp(base = localUrl()) {
+    try {
+        const res = await fetch(`${base}/api/mode`, { signal: AbortSignal.timeout(PROBE_MS) });
+        const body = (await res.json());
+        return res.ok && body.mode === 'local';
+    }
+    catch {
+        return false;
+    }
+}

package/dist/mcp-config.js

@@ -0,0 +1,25 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+const METRO_SERVER = 'metro';
+export function metroMcpConfig(agentKey, port) {
+    const servers = {
+        [METRO_SERVER]: {
+            type: 'http',
+            url: `http://127.0.0.1:${String(port)}/mcp`,
+            headers: { Authorization: `Bearer ${agentKey}` },
+        },
+    };
+    return `${JSON.stringify({ mcpServers: servers }, null, 2)}\n`;
+}
+export function writeMcpConfig(agentKey, port, base = tmpdir()) {
+    const dir = mkdtempSync(join(base, 'metro-claude-'));
+    const path = join(dir, 'mcp.json');
+    writeFileSync(path, metroMcpConfig(agentKey, port), { mode: 0o600 });
+    return {
+        path,
+        cleanup: () => {
+            rmSync(dir, { recursive: true, force: true });
+        },
+    };
+}

package/dist/node-name.js

@@ -0,0 +1,71 @@
+import { spawnSync } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { agentsDir } from './local.js';
+const NODE_FILE = '.node';
+const ALPHABET = 'abcdefghjkmnpqrstuvwxyz23456789';
+const NAME_RE = /^metro-[a-z0-9](?:[a-z0-9-]{0,38}[a-z0-9])?$/;
+const RENAME_WAIT_MS = 30_000;
+const RENAME_POLL_MS = 500;
+const renameWaitMs = () => Number(process.env.METRO_NODE_RENAME_WAIT_MS) || RENAME_WAIT_MS;
+const pause = (ms) => {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+};
+const stderrLine = (line) => {
+    process.stderr.write(`${line}\n`);
+};
+export function newNodeName() {
+    const bytes = randomBytes(6);
+    return `metro-${[...bytes].map((b) => ALPHABET[b % ALPHABET.length] ?? 'x').join('')}`;
+}
+export function nodeName(dir = agentsDir()) {
+    const path = join(dir, NODE_FILE);
+    if (existsSync(path)) {
+        const held = readFileSync(path, 'utf8').trim();
+        if (NAME_RE.test(held))
+            return held;
+    }
+    const name = newNodeName();
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    writeFileSync(path, `${name}\n`, { mode: 0o600 });
+    return name;
+}
+export function currentNodeLabel(bin) {
+    const run = spawnSync(bin, ['status', '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    if (run.error !== undefined || run.status !== 0)
+        return null;
+    try {
+        const parsed = JSON.parse(run.stdout);
+        const dns = typeof parsed.Self?.DNSName === 'string' ? parsed.Self.DNSName : '';
+        const label = dns.split('.')[0] ?? '';
+        return label === '' ? null : label.toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
+function awaitRename(bin, wanted, warn) {
+    const wait = renameWaitMs();
+    const until = Date.now() + wait;
+    while (Date.now() < until) {
+        if (currentNodeLabel(bin) === wanted)
+            return;
+        pause(RENAME_POLL_MS);
+    }
+    warn(`tailscale still reports the old machine name after ${String(Math.round(wait / 1000))}s; the Funnel address may come up under it until the next restart`);
+}
+export function ensureNodeName(bin, dir = agentsDir(), warn = stderrLine) {
+    const wanted = nodeName(dir);
+    if (currentNodeLabel(bin) === wanted)
+        return wanted;
+    const run = spawnSync(bin, ['set', '--hostname', wanted], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    if (run.error !== undefined || run.status !== 0) {
+        const said = run.stderr.trim();
+        const reason = said === '' ? (run.error?.message ?? `exit ${String(run.status)}`) : said;
+        throw new Error(`could not name this machine ${wanted} on your tailnet (${reason}).\n` +
+            `Run it once yourself, then start again:  sudo tailscale set --hostname ${wanted}`);
+    }
+    awaitRename(bin, wanted, warn);
+    return wanted;
+}

package/dist/onboarding.js

@@ -0,0 +1,44 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const FILE = '.claude.json';
+const FLAG = 'hasCompletedOnboarding';
+const given = (value) => value !== undefined && value.trim() !== '' ? value.trim() : undefined;
+export function claudeConfigPath(env = process.env) {
+    return join(given(env.CLAUDE_CONFIG_DIR) ?? given(env.HOME) ?? homedir(), FILE);
+}
+function readConfig(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function markOnboardingDone(path = claudeConfigPath()) {
+    const config = readConfig(path);
+    if (config === null)
+        return 'unreadable';
+    if (config[FLAG] === true)
+        return 'already';
+    writeFileSync(path, `${JSON.stringify({ ...config, [FLAG]: true }, null, 2)}\n`, { mode: 0o600 });
+    return 'marked';
+}
+const FEATURES = 'cachedGrowthBookFeatures';
+const CHANNEL_FLAGS = ['tengu_harbor', 'tengu_harbor_permissions'];
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+export function seedChannels(path = claudeConfigPath()) {
+    const config = readConfig(path);
+    if (config === null)
+        return 'unreadable';
+    const features = isRecord(config[FEATURES]) ? config[FEATURES] : {};
+    if (CHANNEL_FLAGS.every((flag) => features[flag] === true))
+        return 'already';
+    const seeded = Object.fromEntries(CHANNEL_FLAGS.map((flag) => [flag, true]));
+    const next = { ...config, [FEATURES]: { ...features, ...seeded } };
+    writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+    return 'marked';
+}

package/dist/provider-flags.js

@@ -0,0 +1,9 @@
+export const PROVIDER_FLAGS = [
+    'CLAUDE_CODE_USE_BEDROCK',
+    'CLAUDE_CODE_USE_MANTLE',
+    'CLAUDE_CODE_USE_VERTEX',
+    'CLAUDE_CODE_USE_FOUNDRY',
+    'CLAUDE_CODE_USE_ANTHROPIC_AWS',
+    'CLAUDE_CODE_USE_ANTHROPIC_GOOGLE_CLOUD',
+    'CLAUDE_CODE_USE_GATEWAY',
+];

package/dist/route.js

@@ -0,0 +1,58 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { agentsDir } from './local.js';
+const PROVIDERS = new Set(['bedrock', 'openrouter', 'codex', 'gemini']);
+const text = (value) => (typeof value === 'string' ? value : '');
+function routeIn(cfg) {
+    if (typeof cfg !== 'object' || cfg === null)
+        return null;
+    const { route, connections } = cfg;
+    if (!Array.isArray(connections))
+        return null;
+    const conn = connections.find((c) => typeof c === 'object' && c !== null && c.id === route);
+    if (typeof conn !== 'object' || conn === null)
+        return null;
+    const provider = text(conn.provider);
+    const model = text(conn.model);
+    return PROVIDERS.has(provider) && model !== '' ? `${provider}:${model}` : null;
+}
+export function currentRoute(dir = agentsDir()) {
+    const path = join(dir, 'model.json');
+    if (!existsSync(path))
+        return null;
+    try {
+        return routeIn(JSON.parse(readFileSync(path, 'utf8')));
+    }
+    catch {
+        return null;
+    }
+}
+export function routeModelEnv(env, route) {
+    if (route === null || (env.ANTHROPIC_MODEL ?? '').trim() !== '')
+        return env;
+    return { ...env, ANTHROPIC_MODEL: route };
+}
+export function permissionMode(dir = agentsDir()) {
+    const path = join(dir, 'claude-setup.json');
+    if (!existsSync(path))
+        return 'auto';
+    try {
+        const state = JSON.parse(readFileSync(path, 'utf8'));
+        return state.permissionMode === 'bypass' ? 'bypass' : 'auto';
+    }
+    catch {
+        return 'auto';
+    }
+}
+export function systemPrompt(dir = agentsDir()) {
+    const path = join(dir, 'system-prompt.md');
+    if (!existsSync(path))
+        return null;
+    try {
+        const text = readFileSync(path, 'utf8').trim();
+        return text === '' ? null : text;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/runtime-install.js

@@ -0,0 +1,96 @@
+import { spawnSync } from 'node:child_process';
+import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { localStations } from './local.js';
+import { STORE_ENTRY, daemonEntry, findBun, runtimeDir } from './runtime.js';
+const MANIFEST_FILE = 'stations.json';
+const MARKETPLACE = 'marketplace';
+const METRO_SOURCES = join('node_modules', '@metro-labs');
+const INSTALL_TIMEOUT_MS = 15 * 60_000;
+export function runtimeStore() {
+    const env = process.env.METRO_RUNTIME_STORE?.trim() ?? '';
+    return env === '' ? join(homedir(), '.metro', 'runtime') : env;
+}
+const isRecord = (v) => typeof v === 'object' && v !== null;
+const ranges = (raw) => isRecord(raw)
+    ? Object.fromEntries(Object.entries(raw).filter((e) => typeof e[1] === 'string'))
+    : {};
+export function readManifest(path) {
+    const raw = JSON.parse(readFileSync(path, 'utf8'));
+    if (!isRecord(raw))
+        throw new Error(`${path} is not a runtime manifest`);
+    const stations = isRecord(raw.stations) ? raw.stations : {};
+    return {
+        core: ranges(raw.core),
+        stations: Object.fromEntries(Object.entries(stations).map(([name, deps]) => [name, ranges(deps)])),
+    };
+}
+export function dependenciesFor(manifest, stations) {
+    const out = { ...manifest.core };
+    for (const station of new Set(stations))
+        Object.assign(out, manifest.stations[station] ?? {});
+    return Object.fromEntries(Object.entries(out).sort(([a], [b]) => a.localeCompare(b)));
+}
+const packageText = (deps) => `${JSON.stringify({ name: 'metro-runtime', private: true, dependencies: deps }, null, 2)}\n`;
+function readOrNull(path) {
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+function copyMarketplace(sources, store) {
+    const staged = join(sources, MARKETPLACE);
+    if (!existsSync(staged))
+        return false;
+    cpSync(staged, join(store, MARKETPLACE), { recursive: true });
+    return true;
+}
+function syncSources(sources, store) {
+    const shim = join(sources, STORE_ENTRY);
+    if (existsSync(shim))
+        copyFileSync(shim, join(store, STORE_ENTRY));
+    const stamp = readOrNull(join(sources, 'runtime.json'));
+    if (stamp !== null && readOrNull(join(store, 'runtime.json')) === stamp)
+        return existsSync(join(store, MARKETPLACE)) ? false : copyMarketplace(sources, store);
+    rmSync(join(store, METRO_SOURCES), { recursive: true, force: true });
+    cpSync(join(sources, METRO_SOURCES), join(store, METRO_SOURCES), { recursive: true });
+    rmSync(join(store, MARKETPLACE), { recursive: true, force: true });
+    copyMarketplace(sources, store);
+    if (stamp !== null)
+        writeFileSync(join(store, 'runtime.json'), stamp);
+    return true;
+}
+export function installDependencies(store, deps, bun, log) {
+    const wanted = packageText(deps);
+    const marker = join(store, 'node_modules', '.metro-installed');
+    if (existsSync(marker) && readOrNull(join(store, 'package.json')) === wanted)
+        return false;
+    writeFileSync(join(store, 'package.json'), wanted);
+    log(`Installing the channel SDKs this machine needs into ${store}`);
+    const run = spawnSync(bun, ['install', '--no-summary', '--no-progress'], {
+        cwd: store,
+        stdio: ['ignore', 'inherit', 'inherit'],
+        timeout: INSTALL_TIMEOUT_MS,
+    });
+    if (run.error !== undefined || run.status !== 0)
+        throw new Error(`bun install failed in ${store}: ${run.error?.message ?? `exit ${String(run.status)}`}`);
+    writeFileSync(marker, `${new Date().toISOString()}\n`);
+    return true;
+}
+export function prepareRuntime(opts = {}) {
+    const sources = opts.sources ?? runtimeDir();
+    const manifestPath = join(sources, MANIFEST_FILE);
+    const manifest = readManifest(manifestPath);
+    const store = opts.store ?? runtimeStore();
+    const log = opts.log ??
+        ((line) => {
+            process.stderr.write(`${line}\n`);
+        });
+    mkdirSync(join(store, 'trains'), { recursive: true });
+    syncSources(sources, store);
+    installDependencies(store, dependenciesFor(manifest, localStations(opts.agents)), opts.bun ?? findBun(), log);
+    return { dir: store, entry: daemonEntry(store), trains: join(store, 'trains'), manifest: manifestPath };
+}

package/dist/runtime.js

@@ -1,12 +1,10 @@
 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}$/;
-const SERVER_ENTRY = join('node_modules', '@metro-labs', 'mcp', 'src', 'server.ts');
+export const STORE_ENTRY = 'server.ts';
+export const daemonEntry = (dir) => join(dir, STORE_ENTRY);
 export class MissingRuntime extends Error {
 }
 export function runtimeDir() {
@@ -14,11 +12,11 @@ export function runtimeDir() {
     const dir = explicit !== undefined && explicit !== ''
         ? explicit
         : join(dirname(dirname(fileURLToPath(import.meta.url))), 'runtime');
-    if (!existsSync(join(dir, SERVER_ENTRY)))
+    if (!existsSync(daemonEntry(dir)))
         throw new MissingRuntime(`no metro daemon at ${dir}. Reinstall with: npm i -g @stage-labs/metro@beta`);
     return dir;
 }
-export class MissingBun extends Error {
+class MissingBun extends Error {
 }
 export function assertAgentId(id) {
     if (id === undefined || !AGENT_RE.test(id))
@@ -28,54 +26,15 @@ 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);
-}
 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`);
+export const RESTART_CODE = 75;
+export const HOLD_CODE = 76;
+function spawnOnce(plan) {
     const child = spawn(plan.command, plan.args, {
         cwd: plan.cwd,
         env: plan.env,
@@ -84,11 +43,29 @@ export function runDaemon(agentId, 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, hold) {
+    for (;;) {
+        const code = await spawnOnce(plan());
+        if (code === RESTART_CODE) {
+            process.stderr.write('metro was updated; restarting the daemon on the new version\n');
+            continue;
+        }
+        if (code !== HOLD_CODE || hold === undefined)
+            return code;
+        if ((await hold()) === 'exit')
+            return 0;
+        process.stderr.write('starting the daemon again\n');
+    }
+}