@stage-labs/metro 0.1.0-beta.32 → 0.1.0-beta.321

package/dist/bedrock-eventstream.js

@@ -1,120 +0,0 @@
-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

@@ -1,260 +0,0 @@
-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 {
-}
-export 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

@@ -1,72 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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/plugin.js

@@ -1,82 +0,0 @@
-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) {
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-    if (typeof parsed !== 'object' || parsed === null)
-        return null;
-    const plugins = parsed.plugins;
-    if (typeof plugins !== 'object' || plugins === null)
-        return null;
-    const entries = plugins[PLUGIN_SPEC];
-    if (!Array.isArray(entries))
-        return null;
-    const first = entries[0];
-    return typeof first?.installPath === 'string' ? first.installPath : null;
-}
-export function pluginInstallPath() {
-    const registry = join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
-    let raw;
-    try {
-        raw = readFileSync(registry, 'utf8');
-    }
-    catch {
-        return null;
-    }
-    const path = installPathFrom(raw);
-    if (path === null)
-        return null;
-    return existsSync(join(path, 'bin', 'metro-plugin.mjs')) ? path : null;
-}
-function runClaude(args) {
-    const res = spawnSync('claude', args, { encoding: 'utf8' });
-    if (res.error !== undefined)
-        throw new Error('the `claude` command is not on PATH — install Claude Code first');
-    const output = `${res.stdout ?? ''}${res.stderr ?? ''}`;
-    return { ok: res.status === 0, output };
-}
-const tolerable = (output) => /already|exists|latest version/i.test(output);
-export function syncPluginServers() {
-    const path = pluginInstallPath();
-    if (path === null || readToken() === null)
-        return false;
-    const script = join(path, 'bin', 'metro-plugin.mjs');
-    const refreshed = spawnSync(process.execPath, [script, 'refresh'], {
-        stdio: ['ignore', 'inherit', 'inherit'],
-    });
-    if (refreshed.status !== 0)
-        return false;
-    runClaude(['plugin', 'update', PLUGIN_SPEC]);
-    return true;
-}
-export async function installPlugin() {
-    const added = runClaude(['plugin', 'marketplace', 'add', MARKETPLACE_REPO]);
-    if (!added.ok && !tolerable(added.output)) {
-        process.stderr.write(added.output);
-        return 1;
-    }
-    const installed = runClaude(['plugin', 'install', PLUGIN_SPEC]);
-    if (!installed.ok && !tolerable(installed.output)) {
-        process.stderr.write(installed.output);
-        return 1;
-    }
-    process.stderr.write('Claude Code plugin installed.\n');
-    if (syncPluginServers()) {
-        process.stderr.write('Connector servers loaded — new Claude sessions have them; ' +
-            'run /reload-plugins in any session already open.\n');
-        return 0;
-    }
-    process.stderr.write('Now sign in: metro login (get a code at https://metro.box/#/authorize), ' +
-        'or run /metro:login <code> inside Claude Code.\n');
-    return Promise.resolve(0);
-}