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

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,198 @@
+#!/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 { 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 { update } from './update.js';
+import { serve } from './serve.js';
+import { currentVersion } from './version.js';
+const USAGE = `metro — the command line for your MCP connectors
+
+  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
+  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
+  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)
+  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 version   print this CLI's version
+
+Start Claude Code with all of them, without writing them to disk:
+
+  claude --mcp-config <(metro mcp)
+
+  METRO_URL          the metro to talk to (default https://mcp.metro.box)
+  METRO_UI_URL       where the web UI lives (default https://metro.box)
+  METRO_TOKEN        use this 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_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);
+    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;
+}
+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]);
+        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)),
+    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,
+    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 err instanceof NotSignedIn ? 2 : 1;
+});
+process.exit(code);

package/dist/control.js

@@ -0,0 +1,173 @@
+import { execFileSync, spawn } from 'node:child_process';
+import { existsSync, mkdirSync, openSync, readdirSync, readFileSync, rmSync, writeFileSync, } 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);
+        return true;
+    }
+    catch {
+        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;
+    while (Date.now() < until) {
+        if (!isAlive(pid))
+            return;
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    process.kill(pid, 'SIGKILL');
+}
+const lockPath = () => process.env.METRO_STATE_DIR?.trim()
+    ? join(process.env.METRO_STATE_DIR.trim(), '.tail-lock')
+    : join(homedir(), '.cache', 'metro', '.tail-lock');
+function commandOf(pid) {
+    try {
+        return execFileSync('ps', ['-o', 'command=', '-p', String(pid)], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    }
+    catch {
+        return '';
+    }
+}
+const looksLikeMetro = (command) => command.includes('server.ts') || command.includes('metro');
+function holderOf(lockFile) {
+    let pid;
+    try {
+        pid = Number(readFileSync(lockFile, 'utf8').trim());
+    }
+    catch {
+        return null;
+    }
+    if (!Number.isInteger(pid) || pid <= 0 || !isAlive(pid))
+        return null;
+    return looksLikeMetro(commandOf(pid)) ? pid : null;
+}
+export const lockedBy = () => holderOf(lockPath());
+export const serveLockedBy = () => holderOf(serveLockPath());
+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) {
+    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);
+        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)) {
+        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/local.js

@@ -0,0 +1,67 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { localUrl } from './runtime.js';
+const PROBE_MS = 3_000;
+const READ_MS = 20_000;
+export function agentsDir() {
+    const explicit = process.env.METRO_AGENTS_DIR?.trim();
+    return explicit !== undefined && explicit !== '' ? explicit : join(homedir(), '.metro', 'agents');
+}
+export function localAgents(dir = agentsDir()) {
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const path = join(dir, entry.name, 'agent.json');
+        if (!existsSync(path))
+            continue;
+        try {
+            const file = JSON.parse(readFileSync(path, 'utf8'));
+            if (typeof file.id === 'string' && typeof file.name === 'string' && typeof file.key === 'string')
+                out.push({ id: file.id, name: file.name, key: file.key });
+        }
+        catch {
+            continue;
+        }
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+export function pickLocalAgent(agents, wanted) {
+    if (wanted !== undefined && wanted !== '') {
+        const found = agents.find((a) => a.name === wanted || a.id === wanted);
+        if (found === undefined)
+            throw new Error(`no local agent named '${wanted}'`);
+        return found;
+    }
+    const only = agents[0];
+    if (only !== undefined && agents.length === 1)
+        return only;
+    throw new Error(agents.length === 0
+        ? 'no agent on this machine yet'
+        : `several agents on this machine — name one: ${agents.map((a) => a.name).join(', ')}`);
+}
+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;
+    }
+}
+export async function localMcpServers(agent, base = localUrl()) {
+    const res = await fetch(`${base}/api/cli/mcp`, {
+        headers: { authorization: `Bearer ${agent.key}` },
+        signal: AbortSignal.timeout(READ_MS),
+    });
+    if (!res.ok)
+        throw new Error(`the local daemon answered ${String(res.status)} for the connectors`);
+    const body = (await res.json());
+    if (typeof body.json !== 'string')
+        throw new Error('the local daemon returned an unexpected response');
+    return body.json;
+}

package/dist/plugin.js

@@ -0,0 +1,82 @@
+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 (with a pairing code from https://metro.box), ' +
+        'or run /metro:login <code> inside Claude Code.\n');
+    return Promise.resolve(0);
+}