@stage-labs/metro 0.1.0-beta.7 → 0.1.0-beta.70

package/dist/api.js

@@ -0,0 +1,14 @@
+import { localAgents, localDaemonUp, localMcpServers, pickLocalAgent } from './local.js';
+import { localUrl } from './runtime.js';
+const NO_DAEMON = `no metro daemon on ${localUrl()} — start one with: metro serve`;
+export async function mcpServers(wanted) {
+    if (!(await localDaemonUp()))
+        throw new Error(NO_DAEMON);
+    return localMcpServers(pickLocalAgent(localAgents(), wanted));
+}
+export async function whoisAuthorized(wanted) {
+    if (!(await localDaemonUp()))
+        throw new Error(NO_DAEMON);
+    const agent = pickLocalAgent(localAgents(), wanted);
+    return { agent: agent.name, where: localUrl() };
+}

package/dist/bedrock-eventstream.js

@@ -0,0 +1,120 @@
+const PRELUDE_BYTES = 12;
+const CRC_BYTES = 4;
+const HEADER_TRUE = 0;
+const HEADER_FALSE = 1;
+const HEADER_BYTE = 2;
+const HEADER_SHORT = 3;
+const HEADER_INT = 4;
+const HEADER_LONG = 5;
+const HEADER_BYTES = 6;
+const HEADER_STRING = 7;
+const HEADER_TIMESTAMP = 8;
+const HEADER_UUID = 9;
+const FIXED_WIDTH = {
+    [HEADER_TRUE]: 0,
+    [HEADER_FALSE]: 0,
+    [HEADER_BYTE]: 1,
+    [HEADER_SHORT]: 2,
+    [HEADER_INT]: 4,
+    [HEADER_LONG]: 8,
+    [HEADER_TIMESTAMP]: 8,
+    [HEADER_UUID]: 16,
+};
+function readHeaderValue(buf, at, type) {
+    if (type === HEADER_BYTES || type === HEADER_STRING) {
+        const len = buf.readUInt16BE(at);
+        const raw = buf.subarray(at + 2, at + 2 + len);
+        const value = type === HEADER_STRING ? raw.toString('utf8') : raw.toString('base64');
+        return { value, next: at + 2 + len };
+    }
+    const width = FIXED_WIDTH[type];
+    if (width === undefined)
+        throw new Error(`eventstream: unknown header type ${String(type)}`);
+    if (type === HEADER_TRUE)
+        return { value: 'true', next: at };
+    if (type === HEADER_FALSE)
+        return { value: 'false', next: at };
+    return { value: buf.subarray(at, at + width).toString('hex'), next: at + width };
+}
+function readHeaders(buf) {
+    const out = {};
+    let at = 0;
+    while (at < buf.length) {
+        const nameLen = buf.readUInt8(at);
+        const name = buf.subarray(at + 1, at + 1 + nameLen).toString('utf8');
+        const type = buf.readUInt8(at + 1 + nameLen);
+        const parsed = readHeaderValue(buf, at + 2 + nameLen, type);
+        out[name] = parsed.value;
+        at = parsed.next;
+    }
+    return out;
+}
+export function decodeFrame(buf, offset) {
+    if (buf.length - offset < PRELUDE_BYTES)
+        return null;
+    const total = buf.readUInt32BE(offset);
+    const headersLen = buf.readUInt32BE(offset + 4);
+    if (total < PRELUDE_BYTES + CRC_BYTES || headersLen > total)
+        throw new Error('eventstream: malformed frame prelude');
+    if (buf.length - offset < total)
+        return null;
+    const headersStart = offset + PRELUDE_BYTES;
+    const payloadStart = headersStart + headersLen;
+    const payloadEnd = offset + total - CRC_BYTES;
+    return {
+        message: {
+            headers: readHeaders(buf.subarray(headersStart, payloadStart)),
+            payload: Buffer.from(buf.subarray(payloadStart, payloadEnd)),
+        },
+        end: offset + total,
+    };
+}
+export class EventStreamDecoder {
+    pending = Buffer.alloc(0);
+    push(chunk) {
+        this.pending =
+            this.pending.length === 0 ? chunk : Buffer.concat([this.pending, chunk]);
+        const out = [];
+        let offset = 0;
+        for (;;) {
+            const frame = decodeFrame(this.pending, offset);
+            if (frame === null)
+                break;
+            out.push(frame.message);
+            offset = frame.end;
+        }
+        this.pending = this.pending.subarray(offset);
+        return out;
+    }
+    leftover() {
+        return this.pending.length;
+    }
+}
+function encodeHeader(name, value) {
+    const nameBuf = Buffer.from(name, 'utf8');
+    const valueBuf = Buffer.from(value, 'utf8');
+    const out = Buffer.alloc(1 + nameBuf.length + 1 + 2 + valueBuf.length);
+    let at = 0;
+    out.writeUInt8(nameBuf.length, at);
+    at += 1;
+    nameBuf.copy(out, at);
+    at += nameBuf.length;
+    out.writeUInt8(HEADER_STRING, at);
+    at += 1;
+    out.writeUInt16BE(valueBuf.length, at);
+    at += 2;
+    valueBuf.copy(out, at);
+    return out;
+}
+export function encodeFrame(headers, payload) {
+    const headerBuf = Buffer.concat(Object.entries(headers).map(([name, value]) => encodeHeader(name, value)));
+    const total = PRELUDE_BYTES + headerBuf.length + payload.length + CRC_BYTES;
+    const out = Buffer.alloc(total);
+    out.writeUInt32BE(total, 0);
+    out.writeUInt32BE(headerBuf.length, 4);
+    out.writeUInt32BE(0, 8);
+    headerBuf.copy(out, PRELUDE_BYTES);
+    payload.copy(out, PRELUDE_BYTES + headerBuf.length);
+    out.writeUInt32BE(0, total - CRC_BYTES);
+    return out;
+}

package/dist/bedrock-proxy.js

@@ -0,0 +1,260 @@
+import { createServer, } from 'node:http';
+import { EventStreamDecoder } from './bedrock-eventstream.js';
+import { callBedrock, freshAdaptations, invoke, invokeUrl, upstreamMessage, } from './bedrock-upstream.js';
+export class BedrockConfigError extends Error {
+}
+class ProxyError extends Error {
+    status;
+    kind;
+    constructor(status, kind, message) {
+        super(message);
+        this.status = status;
+        this.kind = kind;
+    }
+}
+const ANTHROPIC_VERSION = 'bedrock-2023-05-31';
+const BODY_MAX = 64 * 1024 * 1024;
+const MESSAGES_PATH = '/v1/messages';
+const COUNT_PATH = '/v1/messages/count_tokens';
+function firstEnv(env, names) {
+    for (const name of names) {
+        const value = env[name]?.trim() ?? '';
+        if (value !== '')
+            return value;
+    }
+    return '';
+}
+export function bedrockConfigFromEnv(env = process.env) {
+    const bearerToken = firstEnv(env, ['AWS_BEARER_TOKEN_BEDROCK']);
+    if (bearerToken === '')
+        throw new BedrockConfigError('AWS_BEARER_TOKEN_BEDROCK is not set. Create an Amazon Bedrock API key in the AWS console (Bedrock → API keys) and export it.');
+    const region = firstEnv(env, ['METRO_BEDROCK_REGION', 'AWS_REGION', 'AWS_DEFAULT_REGION']);
+    if (region === '')
+        throw new BedrockConfigError('no AWS region: set AWS_REGION (or METRO_BEDROCK_REGION) to the region your Bedrock API key belongs to');
+    const model = firstEnv(env, ['METRO_BEDROCK_MODEL']);
+    return { region, bearerToken, model: model === '' ? null : model };
+}
+const PREFIXES = [
+    [/^us-gov-/, 'us-gov'],
+    [/^us-/, 'us'],
+    [/^eu-/, 'eu'],
+    [/^ap-/, 'apac'],
+];
+export function regionPrefix(region) {
+    for (const [pattern, prefix] of PREFIXES)
+        if (pattern.test(region))
+            return prefix;
+    return 'global';
+}
+export function mapModel(requested, cfg) {
+    if (cfg.model !== null)
+        return cfg.model;
+    if (requested.includes('anthropic.'))
+        return requested;
+    return `${regionPrefix(cfg.region)}.anthropic.${requested}`;
+}
+export const upstreamBase = (cfg, override) => override ?? `https://bedrock-runtime.${cfg.region}.amazonaws.com`;
+function splitBetas(header) {
+    const raw = Array.isArray(header) ? header.join(',') : (header ?? '');
+    return raw
+        .split(',')
+        .map((b) => b.trim())
+        .filter((b) => b !== '');
+}
+export function rewriteBody(raw, betaHeader, cfg) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        throw new ProxyError(400, 'invalid_request_error', 'body must be a JSON object');
+    const { model, stream, ...rest } = raw;
+    if (typeof model !== 'string' || model === '')
+        throw new ProxyError(400, 'invalid_request_error', 'model is required');
+    const betas = splitBetas(betaHeader);
+    const body = { ...rest, anthropic_version: ANTHROPIC_VERSION };
+    if (betas.length > 0)
+        body.anthropic_beta = betas;
+    return { modelId: mapModel(model, cfg), stream: stream === true, body, betas };
+}
+export function errorKind(status, errorType) {
+    if (status === 429 || errorType === 'ThrottlingException')
+        return 'rate_limit_error';
+    if (status === 400)
+        return 'invalid_request_error';
+    if (status === 401)
+        return 'authentication_error';
+    if (status === 403)
+        return 'permission_error';
+    if (status === 404)
+        return 'not_found_error';
+    if (status === 503)
+        return 'overloaded_error';
+    return 'api_error';
+}
+function sendError(res, status, kind, message) {
+    res.writeHead(status, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ type: 'error', error: { type: kind, message } }));
+}
+async function readBody(req) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+        const buf = chunk;
+        total += buf.length;
+        if (total > BODY_MAX)
+            throw new ProxyError(413, 'invalid_request_error', 'request too large');
+        chunks.push(buf);
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        throw new ProxyError(400, 'invalid_request_error', 'body must be JSON');
+    }
+}
+async function relayError(upstream, res) {
+    const text = await upstream.text();
+    const kind = errorKind(upstream.status, upstream.headers.get('x-amzn-errortype'));
+    sendError(res, upstream.status, kind, upstreamMessage(text));
+}
+function eventTypeOf(event) {
+    try {
+        const parsed = JSON.parse(event);
+        return typeof parsed.type === 'string' ? parsed.type : 'message';
+    }
+    catch {
+        return 'message';
+    }
+}
+function writeEvent(res, message) {
+    if (message.headers[':message-type'] === 'event') {
+        const parsed = JSON.parse(message.payload.toString('utf8'));
+        if (typeof parsed.bytes !== 'string')
+            return;
+        const event = Buffer.from(parsed.bytes, 'base64').toString('utf8');
+        res.write(`event: ${eventTypeOf(event)}\ndata: ${event}\n\n`);
+        return;
+    }
+    const errorType = message.headers[':exception-type'] ?? message.headers[':error-code'] ?? null;
+    const body = {
+        type: 'error',
+        error: {
+            type: errorKind(500, errorType),
+            message: upstreamMessage(message.payload.toString('utf8')),
+        },
+    };
+    res.write(`event: error\ndata: ${JSON.stringify(body)}\n\n`);
+}
+async function relayStream(upstream, res) {
+    res.writeHead(200, {
+        'content-type': 'text/event-stream',
+        'cache-control': 'no-store',
+        connection: 'keep-alive',
+    });
+    const body = upstream.body;
+    if (body === null) {
+        res.end();
+        return;
+    }
+    const decoder = new EventStreamDecoder();
+    const reader = body.getReader();
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        for (const message of decoder.push(Buffer.from(value)))
+            writeEvent(res, message);
+    }
+    res.end();
+}
+async function relayJson(upstream, res) {
+    const text = await upstream.text();
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(text);
+}
+async function handleMessages(req, res, up) {
+    const rewritten = rewriteBody(await readBody(req), req.headers['anthropic-beta'], up.cfg);
+    const controller = new AbortController();
+    res.on('close', () => {
+        if (!res.writableEnded)
+            controller.abort();
+    });
+    const upstream = await invoke(up, rewritten, controller.signal);
+    if (!upstream.ok) {
+        await relayError(upstream, res);
+        return;
+    }
+    if (rewritten.stream)
+        await relayStream(upstream, res);
+    else
+        await relayJson(upstream, res);
+}
+function estimateTokens(body) {
+    return Math.ceil(JSON.stringify(body).length / 4);
+}
+async function handleCount(req, res, up) {
+    const rewritten = rewriteBody(await readBody(req), req.headers['anthropic-beta'], up.cfg);
+    const controller = new AbortController();
+    const upstream = await callBedrock(up, invokeUrl(up, rewritten.modelId, 'count-tokens'), { input: { invokeModel: { body: JSON.stringify(rewritten.body) } } }, 'application/json', controller.signal);
+    const text = await upstream.text();
+    let counted = null;
+    if (upstream.ok) {
+        const parsed = JSON.parse(text);
+        if (typeof parsed.inputTokens === 'number')
+            counted = parsed.inputTokens;
+    }
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ input_tokens: counted ?? estimateTokens(rewritten.body) }));
+}
+function presentedToken(req) {
+    const auth = req.headers.authorization ?? '';
+    if (auth.toLowerCase().startsWith('bearer '))
+        return auth.slice(7).trim();
+    const key = req.headers['x-api-key'];
+    return Array.isArray(key) ? (key[0] ?? '') : (key ?? '');
+}
+async function route(req, res, cfg, opts, learned) {
+    if (presentedToken(req) !== opts.token)
+        throw new ProxyError(401, 'authentication_error', 'unauthorized');
+    const path = (req.url ?? '').split('?')[0] ?? '';
+    const up = { cfg, base: upstreamBase(cfg, opts.upstream), learned };
+    if (req.method === 'POST' && path === MESSAGES_PATH)
+        return handleMessages(req, res, up);
+    if (req.method === 'POST' && path === COUNT_PATH)
+        return handleCount(req, res, up);
+    throw new ProxyError(404, 'not_found_error', 'not found');
+}
+function failed(res, err) {
+    if (res.headersSent) {
+        res.end();
+        return;
+    }
+    if (err instanceof ProxyError) {
+        sendError(res, err.status, err.kind, err.message);
+        return;
+    }
+    const message = err instanceof Error ? err.message : 'proxy failure';
+    sendError(res, 502, 'api_error', `metro bedrock proxy: ${message}`);
+}
+export function startBedrockProxy(cfg, opts) {
+    const learned = freshAdaptations();
+    const server = createServer((req, res) => {
+        route(req, res, cfg, opts, learned).catch((err) => {
+            failed(res, err);
+        });
+    });
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(opts.port ?? 0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address !== null ? address.port : 0;
+            resolve({
+                port,
+                server,
+                learned,
+                close: () => new Promise((done) => {
+                    server.close(() => {
+                        done();
+                    });
+                }),
+            });
+        });
+    });
+}

package/dist/bedrock-upstream.js

@@ -0,0 +1,72 @@
+export const freshAdaptations = () => ({
+    fields: new Set(),
+    dropBetas: false,
+});
+const EXTRA_INPUT_RE = /^([A-Za-z0-9_]+)(?:\.[^:]*)?: Extra inputs are not permitted/;
+const MAX_REPAIRS = 4;
+export function invokeUrl(up, modelId, action) {
+    return `${up.base}/model/${encodeURIComponent(modelId)}/${action}`;
+}
+export function callBedrock(up, url, body, accept, signal) {
+    return fetch(url, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${up.cfg.bearerToken}`,
+            'content-type': 'application/json',
+            accept,
+        },
+        body: JSON.stringify(body),
+        signal,
+    });
+}
+export function upstreamMessage(text) {
+    const fallback = text === '' ? 'Bedrock returned no body' : text;
+    try {
+        const parsed = JSON.parse(text);
+        const message = parsed.message ?? parsed.Message;
+        return typeof message === 'string' && message !== '' ? message : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+const without = (body, keys) => Object.fromEntries(Object.entries(body).filter(([key]) => !keys.has(key)));
+function applyLearned(req, learned) {
+    const dropped = new Set(learned.fields);
+    if (learned.dropBetas)
+        dropped.add('anthropic_beta');
+    return {
+        body: without(req.body, dropped),
+        betas: learned.dropBetas ? [] : req.betas,
+    };
+}
+function repair(attempt, learned, message) {
+    const named = EXTRA_INPUT_RE.exec(message)?.[1];
+    if (named !== undefined && named in attempt.body) {
+        learned.fields.add(named);
+        process.stderr.write(`metro bedrock: Bedrock refused "${named}" (extra input); dropping it from every request\n`);
+        return { body: without(attempt.body, new Set([named])), betas: attempt.betas };
+    }
+    if (attempt.betas.length > 0) {
+        learned.dropBetas = true;
+        process.stderr.write(`metro bedrock: retrying without anthropic_beta [${attempt.betas.join(', ')}]\n`);
+        return { body: without(attempt.body, new Set(['anthropic_beta'])), betas: [] };
+    }
+    return null;
+}
+export async function invoke(up, req, signal) {
+    const action = req.stream ? 'invoke-with-response-stream' : 'invoke';
+    const accept = req.stream ? 'application/vnd.amazon.eventstream' : 'application/json';
+    const url = invokeUrl(up, req.modelId, action);
+    let attempt = applyLearned(req, up.learned);
+    for (let repairs = 0;; repairs += 1) {
+        const res = await callBedrock(up, url, attempt.body, accept, signal);
+        if (res.status !== 400 || repairs >= MAX_REPAIRS)
+            return res;
+        const text = await res.text();
+        const next = repair(attempt, up.learned, upstreamMessage(text));
+        if (next === null)
+            return new Response(text, { status: 400, headers: res.headers });
+        attempt = next;
+    }
+}

package/dist/bedrock.js

@@ -0,0 +1,106 @@
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { claudeArgs } from './claude.js';
+import { bedrockConfigFromEnv, startBedrockProxy } from './bedrock-proxy.js';
+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',
+];
+const CONFLICTING = [
+    ...PROVIDER_FLAGS,
+    'ANTHROPIC_BASE_URL',
+    'ANTHROPIC_API_KEY',
+    'ANTHROPIC_AUTH_TOKEN',
+];
+const SCRUBBED = [...PROVIDER_FLAGS, 'ANTHROPIC_API_KEY', 'AWS_BEARER_TOKEN_BEDROCK'];
+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;
+}
+export function firstPartyModelId(bedrockId) {
+    return bedrockId.replace(/^(?:[a-z-]+\.)?anthropic\./, '').replace(/-v\d+:\d+$/, '');
+}
+export function claudeEnv(base, port, token, pinned = null) {
+    const kept = Object.entries(base).filter(([key]) => !SCRUBBED.includes(key));
+    const model = (base.ANTHROPIC_MODEL ?? '').trim();
+    return {
+        ...Object.fromEntries(kept),
+        ...(pinned !== null && model === '' && { ANTHROPIC_MODEL: firstPartyModelId(pinned) }),
+        ANTHROPIC_BASE_URL: `http://127.0.0.1:${String(port)}`,
+        ANTHROPIC_AUTH_TOKEN: token,
+    };
+}
+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);
+        });
+    });
+}
+export async function bedrock(argv) {
+    const cfg = bedrockConfigFromEnv();
+    const conflicts = settingsConflicts(settingsFiles());
+    if (conflicts.length > 0)
+        throw new Error('metro bedrock: these settings would put Claude Code back on a third-party provider, or override the proxy. Remove them, or point CLAUDE_CONFIG_DIR at a separate profile:\n  ' +
+            conflicts.join('\n  '));
+    const token = `mb_${randomBytes(18).toString('base64url')}`;
+    const proxy = await startBedrockProxy(cfg, { token });
+    const pinned = cfg.model === null ? '' : ` (${cfg.model})`;
+    process.stderr.write(`metro bedrock: Claude Code → http://127.0.0.1:${String(proxy.port)} → Bedrock ${cfg.region}${pinned}\n`);
+    try {
+        return await runClaude(claudeArgs(argv), claudeEnv(process.env, proxy.port, token, cfg.model));
+    }
+    finally {
+        await proxy.close();
+    }
+}

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

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import { mcpServers, whoisAuthorized } from './api.js';
+import { stopAll } from './control.js';
+import { tailEvents } from './tail.js';
+import { launchClaude } from './claude.js';
+import { bedrock } from './bedrock.js';
+import { installPlugin } from './plugin.js';
+import { update } from './update.js';
+import { serve } from './serve.js';
+import { service } from './service.js';
+import { currentVersion } from './version.js';
+const USAGE = `metro — run your agent on this machine
+
+  metro serve [--port <n>] [--owner <address>]
+                  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 one wallet that 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 <address>]
+                  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 [agent]
+                  print the agent this machine runs
+  metro mcp [agent]
+                  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 (--check only reports)
+  metro version   print this CLI's version
+
+Start Claude Code with every connector, writing nothing to disk:
+
+  claude --mcp-config <(metro mcp)
+
+  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
+`;
+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;
+    }
+    for (const d of stopped)
+        process.stderr.write(`Stopped metro (pid ${String(d.pid)}, via ${d.via})\n`);
+    return 0;
+}
+const HELP = new Set([undefined, 'help', '--help', '-h']);
+const COMMANDS = {
+    whoami: async () => {
+        const { agent, where } = await whoisAuthorized(process.argv[3]);
+        process.stdout.write(`agent '${agent}' on ${where}\n`);
+        return 0;
+    },
+    serve: () => serve(process.argv.slice(3)),
+    service: () => service(process.argv.slice(3)),
+    stop: stopDaemon,
+    tail: () => tailEvents(process.argv.slice(3)),
+    mcp: async () => {
+        process.stdout.write(`${await mcpServers(process.argv[3])}\n`);
+        return 0;
+    },
+    plugin: installPlugin,
+    claude: () => launchClaude(process.argv.slice(3)),
+    bedrock: () => bedrock(process.argv.slice(3)),
+    update: () => update(process.argv.slice(3)),
+    version: async () => {
+        process.stdout.write(`${currentVersion()}\n`);
+        return Promise.resolve(0);
+    },
+};
+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);
+}
+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 1;
+});
+process.exit(code);