@stage-labs/metro 0.1.0-beta.20 → 0.1.0-beta.201

package/dist/serve.js

@@ -0,0 +1,158 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { agentsDir } from './local.js';
+import { currentVersion } from './version.js';
+import { serveLockedBy, serveStateDir } from './control.js';
+import { findBun, localPort, spawnPlan } from './runtime.js';
+import { prepareRuntime } from './runtime-install.js';
+import { ensureNodeName } from './node-name.js';
+import { holdUntilStart } from './hold.js';
+const SCRUBBED = new Set(['DATABASE_URL']);
+const PORT_FLAG = /^--port=(.*)$/;
+const OWNER_FLAG = /^--owner=(.*)$/;
+const ADDRESS = /^0x[0-9a-fA-F]{40}$/;
+const USAGE = 'usage: metro serve [--port <n>] [--owner <organization id>]';
+const TUNNEL_FLAG = /^--(no-)?tunnel(=.*)?$/;
+const TAILSCALE_APP = '/Applications/Tailscale.app/Contents/MacOS/Tailscale';
+function portOf(raw) {
+    const n = Number(raw);
+    if (raw === undefined || raw === '' || !Number.isInteger(n) || n < 1 || n > 65535)
+        throw new Error(`'${raw ?? ''}' is not a port — ${USAGE}`);
+    return n;
+}
+const ORGANIZATION = /^org_[A-Za-z0-9]{10,64}$/;
+function ownerOf(raw) {
+    if (raw !== undefined && ORGANIZATION.test(raw))
+        return { owner: raw };
+    if (raw !== undefined && ADDRESS.test(raw))
+        return { owner: null, ignoredOwner: raw };
+    throw new Error(`'${raw ?? ''}' is not an organization id (org_…) — ${USAGE}`);
+}
+export function parseServeArgs(argv) {
+    let port = localPort();
+    let owner = { owner: null };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i] ?? '';
+        if (TUNNEL_FLAG.test(arg))
+            throw new Error('--tunnel is gone: metro serve always publishes through Tailscale Funnel — ' + USAGE);
+        const inlineOwner = OWNER_FLAG.exec(arg);
+        if (inlineOwner) {
+            owner = ownerOf(inlineOwner[1]);
+            continue;
+        }
+        if (arg === '--owner') {
+            owner = ownerOf(argv[i + 1]);
+            i += 1;
+            continue;
+        }
+        const inline = PORT_FLAG.exec(arg);
+        if (inline) {
+            port = portOf(inline[1]);
+            continue;
+        }
+        if (arg === '--port' || arg === '-p') {
+            port = portOf(argv[i + 1]);
+            i += 1;
+            continue;
+        }
+        throw new Error(`unknown argument '${arg}' — ${USAGE}`);
+    }
+    return { port, ...owner };
+}
+export function requireOwner(args, dir = agentsDir()) {
+    if (args.ignoredOwner !== undefined) {
+        process.stderr.write(`--owner ${args.ignoredOwner} is a wallet address, which metro ignores: the organization id in ${join(dir, '.owner')} decides who signs in\n`);
+        return;
+    }
+    if (args.owner !== null || existsSync(join(dir, '.owner')))
+        return;
+    throw new Error('no owner is set for this machine, so nobody could sign in.\n' +
+        'Pass the organization that owns it once; it is remembered in ' +
+        join(dir, '.owner') +
+        ':\n  metro serve --owner <org_…>');
+}
+export function readOwner(dir = agentsDir()) {
+    try {
+        const raw = readFileSync(join(dir, '.owner'), 'utf8').trim();
+        return ORGANIZATION.test(raw) ? raw : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function holdInfo(port, owner, tailscaleBin) {
+    return {
+        port,
+        host: process.env.METRO_HTTP_HOST ?? '127.0.0.1',
+        owner: owner ?? readOwner(),
+        version: currentVersion(),
+        funnel: tailscaleBin,
+        lockFile: join(process.env.METRO_STATE_DIR ?? serveStateDir(), '.tail-lock'),
+    };
+}
+function tailscaleStatus(bin) {
+    const run = spawnSync(bin, ['status', '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    if (run.error !== undefined || run.status !== 0)
+        return { ok: false, state: 'not running' };
+    try {
+        const parsed = JSON.parse(run.stdout);
+        if (parsed.BackendState !== 'Running')
+            return { ok: false, state: String(parsed.BackendState) };
+        if (parsed.Self?.Online === false)
+            return { ok: false, state: 'Running, but not connected to the tailnet: the machine may have been removed from it' };
+        return { ok: true };
+    }
+    catch {
+        return { ok: false, state: 'unreadable' };
+    }
+}
+export function findTailscale(candidates = ['tailscale', TAILSCALE_APP]) {
+    const bin = candidates.find((c) => spawnSync(c, ['version'], { stdio: 'ignore' }).status === 0);
+    if (bin === undefined)
+        throw new Error('metro serve needs Tailscale on this machine: the daemon is published through Tailscale Funnel.\n' +
+            'macOS:  brew install --cask tailscale   (or the App Store app)\n' +
+            'Linux:  curl -fsSL https://tailscale.com/install.sh | sh\n' +
+            'Then sign the machine in:  tailscale up');
+    const status = tailscaleStatus(bin);
+    if (!status.ok)
+        throw new Error(`Tailscale is installed but this machine is not connected (${status.state}). Sign it in first:  tailscale up\n` +
+            'Funnel also has to be enabled once on your tailnet: https://tailscale.com/kb/1223/funnel');
+    return bin;
+}
+export function servePlan(opts) {
+    const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !SCRUBBED.has(key)));
+    return {
+        command: findBun(),
+        args: [opts.runtime.entry],
+        cwd: opts.runtime.dir,
+        env: {
+            ...env,
+            METRO_VERSION: currentVersion(),
+            METRO_CLI_BIN: process.argv[1] ?? '',
+            METRO_WEBHOOK_PORT: String(opts.port),
+            METRO_HTTP_HOST: process.env.METRO_HTTP_HOST ?? '127.0.0.1',
+            METRO_TRAINS_DIR: opts.runtime.trains,
+            ...(opts.runtime.manifest === null
+                ? {}
+                : { METRO_RUNTIME_STORE: opts.runtime.dir, METRO_RUNTIME_MANIFEST: opts.runtime.manifest }),
+            METRO_STATE_DIR: process.env.METRO_STATE_DIR ?? serveStateDir(),
+            METRO_TUNNEL: 'tailscale',
+            METRO_TAILSCALE_BIN: opts.tailscaleBin,
+            ...(opts.owner === null ? {} : { METRO_OWNER: opts.owner }),
+        },
+    };
+}
+export function serve(argv) {
+    const args = parseServeArgs(argv);
+    const { port, owner } = args;
+    const running = serveLockedBy();
+    if (running !== null)
+        throw new Error(`a metro serve daemon is already running on this machine (pid ${String(running)}). ` +
+            'Stop it first: metro stop');
+    requireOwner(args);
+    const tailscaleBin = findTailscale();
+    const node = ensureNodeName(tailscaleBin);
+    process.stderr.write(`Starting a metro daemon of your own on http://127.0.0.1:${String(port)}, published as ${node} on your tailnet\n`);
+    return spawnPlan(() => servePlan({ runtime: prepareRuntime(), port, owner, tailscaleBin }), () => holdUntilStart(holdInfo(port, owner, tailscaleBin)));
+}

package/dist/service.js

@@ -0,0 +1,243 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir, platform, userInfo } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { serveLockedBy } from './control.js';
+import { findBun } from './runtime.js';
+import { findTailscale, parseServeArgs, requireOwner } from './serve.js';
+const USAGE = 'usage: metro service install [--port <n>] [--owner <organization id>] | uninstall | status';
+const SERVICE = 'metro';
+const LABEL = 'box.metro.serve';
+const CARRIED = /^(METRO_.*|XDG_CACHE_HOME|PATH|HOME)$/;
+const PLAIN_WORD = /^[A-Za-z0-9_/.:=+@,-]+$/;
+const carriedEnv = (env) => Object.entries(env)
+    .filter((entry) => CARRIED.test(entry[0]) && typeof entry[1] === 'string' && entry[1] !== '')
+    .sort(([a], [b]) => a.localeCompare(b));
+const cacheDir = (host) => {
+    const xdg = host.env.XDG_CACHE_HOME?.trim();
+    return xdg === undefined || xdg === '' ? join(host.home, '.cache') : xdg;
+};
+function unitWord(arg) {
+    const escaped = arg.replaceAll('%', '%%');
+    if (PLAIN_WORD.test(arg))
+        return escaped;
+    return `"${escaped.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+}
+export function systemdUnit(host, exec, target) {
+    const env = carriedEnv(host.env).map(([key, value]) => `Environment=${unitWord(`${key}=${value}`)}`);
+    return [
+        '[Unit]',
+        'Description=Metro daemon (metro serve)',
+        'After=network-online.target tailscaled.service',
+        'Wants=network-online.target',
+        '',
+        '[Service]',
+        `ExecStart=${exec.map(unitWord).join(' ')}`,
+        'Restart=always',
+        'RestartSec=2',
+        'OOMPolicy=continue',
+        `WorkingDirectory=${unitWord(host.home)}`,
+        ...env,
+        '',
+        '[Install]',
+        `WantedBy=${target}`,
+        '',
+    ].join('\n');
+}
+const xml = (text) => text
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;');
+export function launchdPlist(host, exec, logFile) {
+    const env = carriedEnv(host.env).map(([key, value]) => `    <key>${xml(key)}</key><string>${xml(value)}</string>`);
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+        '<plist version="1.0">',
+        '<dict>',
+        `  <key>Label</key><string>${LABEL}</string>`,
+        '  <key>ProgramArguments</key>',
+        '  <array>',
+        ...exec.map((arg) => `    <string>${xml(arg)}</string>`),
+        '  </array>',
+        '  <key>EnvironmentVariables</key>',
+        '  <dict>',
+        ...env,
+        '  </dict>',
+        `  <key>WorkingDirectory</key><string>${xml(host.home)}</string>`,
+        '  <key>RunAtLoad</key><true/>',
+        '  <key>KeepAlive</key><true/>',
+        `  <key>StandardOutPath</key><string>${xml(logFile)}</string>`,
+        `  <key>StandardErrorPath</key><string>${xml(logFile)}</string>`,
+        '</dict>',
+        '</plist>',
+        '',
+    ].join('\n');
+}
+function systemdPlan(host, exec) {
+    const system = host.uid === 0;
+    const ctl = system ? ['systemctl'] : ['systemctl', '--user'];
+    const file = system
+        ? `/etc/systemd/system/${SERVICE}.service`
+        : join(host.home, '.config', 'systemd', 'user', `${SERVICE}.service`);
+    return {
+        kind: 'systemd',
+        file,
+        content: systemdUnit(host, exec, system ? 'multi-user.target' : 'default.target'),
+        dirs: [],
+        install: [{ args: [...ctl, 'daemon-reload'] }, { args: [...ctl, 'enable', '--now', SERVICE] }],
+        uninstall: [{ args: [...ctl, 'disable', '--now', SERVICE], mayFail: true }],
+        reload: [{ args: [...ctl, 'daemon-reload'], mayFail: true }],
+        status: { args: [...ctl, 'is-active', SERVICE], mayFail: true },
+        hints: [
+            `Logs:  journalctl ${system ? '' : '--user '}-u ${SERVICE} -f`,
+            ...(system
+                ? []
+                : [`A user service stops with your login session; keep it up without one:  loginctl enable-linger ${host.user}`]),
+        ],
+    };
+}
+function launchdPlan(host, exec) {
+    const file = join(host.home, 'Library', 'LaunchAgents', `${LABEL}.plist`);
+    const domain = `gui/${String(host.uid)}`;
+    const logFile = join(cacheDir(host), 'metro', 'serve', 'service.log');
+    return {
+        kind: 'launchd',
+        file,
+        content: launchdPlist(host, exec, logFile),
+        dirs: [dirname(logFile)],
+        install: [
+            { args: ['launchctl', 'bootout', `${domain}/${LABEL}`], mayFail: true },
+            { args: ['launchctl', 'bootstrap', domain, file] },
+        ],
+        uninstall: [{ args: ['launchctl', 'bootout', `${domain}/${LABEL}`], mayFail: true }],
+        reload: [],
+        status: { args: ['launchctl', 'print', `${domain}/${LABEL}`], mayFail: true },
+        hints: [`Logs:  tail -f ${logFile}`],
+    };
+}
+export function servicePlan(host, serveArgs) {
+    const exec = [host.node, host.cli, 'serve', ...serveArgs];
+    if (host.platform === 'linux')
+        return systemdPlan(host, exec);
+    if (host.platform === 'darwin')
+        return launchdPlan(host, exec);
+    throw new Error(`metro service supports Linux (systemd) and macOS (launchd), not ${host.platform}`);
+}
+function install(serveArgs, deps) {
+    const args = parseServeArgs(serveArgs);
+    const plan = servicePlan(deps.host, serveArgs);
+    if (deps.exists(plan.file)) {
+        deps.out(`metro is already installed as a ${plan.kind} service (${plan.file}) and restarts on its own; metro service status says whether it is running. To change its arguments: metro service uninstall, then install again`);
+        return 0;
+    }
+    deps.preflight(args);
+    const pid = deps.running();
+    if (pid !== null)
+        throw new Error(`a metro serve is running on this machine (pid ${String(pid)}). Stop it first (metro stop), then install: the service takes over from there`);
+    for (const dir of plan.dirs)
+        deps.mkdir(dir);
+    deps.write(plan.file, plan.content);
+    for (const command of plan.install)
+        deps.run(command);
+    deps.out(`Installed ${plan.file}: metro serve now starts at boot and after a crash, and the Server page on metro.box can stop, start and restart it.`);
+    for (const hint of plan.hints)
+        deps.out(hint);
+    return 0;
+}
+function uninstall(deps) {
+    const plan = servicePlan(deps.host, []);
+    if (!deps.exists(plan.file)) {
+        deps.out('metro is not installed as a service on this machine');
+        return 1;
+    }
+    for (const command of plan.uninstall)
+        deps.run(command);
+    deps.remove(plan.file);
+    for (const command of plan.reload)
+        deps.run(command);
+    deps.out(`Removed ${plan.file}; a running daemon was stopped, and metro serve no longer starts on its own`);
+    return 0;
+}
+function status(deps) {
+    const plan = servicePlan(deps.host, []);
+    if (!deps.exists(plan.file)) {
+        deps.out(`not installed (metro service install writes ${plan.file})`);
+        return 1;
+    }
+    const active = deps.run(plan.status).status === 0;
+    deps.out(active
+        ? `running as a ${plan.kind} service (${plan.file})`
+        : `installed as a ${plan.kind} service (${plan.file}), not running`);
+    return active ? 0 : 1;
+}
+function realHost() {
+    const who = userInfo();
+    return {
+        platform: platform(),
+        uid: who.uid,
+        user: who.username,
+        home: homedir(),
+        node: process.execPath,
+        cli: resolve(process.argv[1] ?? ''),
+        env: process.env,
+    };
+}
+export function serviceStopHint(host = realHost(), exists = existsSync) {
+    if (host.platform !== 'linux' && host.platform !== 'darwin')
+        return null;
+    const plan = servicePlan(host, []);
+    if (!exists(plan.file))
+        return null;
+    const keep = plan.kind === 'systemd'
+        ? `systemctl ${host.uid === 0 ? '' : '--user '}stop ${SERVICE}`
+        : `launchctl bootout gui/${String(host.uid)}/${LABEL}`;
+    return `metro runs as a ${plan.kind} service here (${plan.file}), so it starts again on its own in a moment. To keep it stopped:  ${keep}`;
+}
+function realDeps() {
+    return {
+        host: realHost(),
+        run: (command) => {
+            const [bin = '', ...args] = command.args;
+            const result = spawnSync(bin, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+            const code = result.status ?? 1;
+            if (code !== 0 && command.mayFail !== true) {
+                const said = [result.stderr, result.stdout, result.error?.message].find((t) => typeof t === 'string' && t.trim() !== '') ?? '';
+                throw new Error(`${command.args.join(' ')} failed (exit ${String(code)}): ${said.trim()}`);
+            }
+            return { status: code, output: `${result.stdout}${result.stderr}` };
+        },
+        running: serveLockedBy,
+        preflight: (args) => {
+            requireOwner(args);
+            findBun();
+            findTailscale();
+        },
+        mkdir: (dir) => {
+            mkdirSync(dir, { recursive: true });
+        },
+        write: (file, content) => {
+            mkdirSync(dirname(file), { recursive: true });
+            writeFileSync(file, content, { mode: 0o644 });
+        },
+        remove: (file) => {
+            rmSync(file, { force: true });
+        },
+        exists: existsSync,
+        out: (line) => {
+            process.stderr.write(`${line}\n`);
+        },
+    };
+}
+export function service(argv, deps = realDeps()) {
+    const [verb, ...rest] = argv;
+    if (verb === 'install')
+        return Promise.resolve(install(rest, deps));
+    if (verb === 'uninstall' && rest.length === 0)
+        return Promise.resolve(uninstall(deps));
+    if (verb === 'status' && rest.length === 0)
+        return Promise.resolve(status(deps));
+    throw new Error(USAGE);
+}

package/dist/tail.js

@@ -0,0 +1,119 @@
+import { localAgent } from './local.js';
+import { assertAgentId, localUrl } from './runtime.js';
+const BACKOFF_MS = [1_000, 2_000, 5_000];
+const STALL_MS = 90_000;
+export const backoffAt = (attempt) => BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)] ?? 5_000;
+export function sseDataLines(buffer, chunk) {
+    const lines = (buffer + chunk).split('\n');
+    const rest = lines.pop() ?? '';
+    const events = [];
+    for (const raw of lines) {
+        const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
+        if (!line.startsWith('data:'))
+            continue;
+        const value = line.slice(5);
+        events.push(value.startsWith(' ') ? value.slice(1) : value);
+    }
+    return { rest, events };
+}
+function keySource(agentId) {
+    const fromEnv = process.env.METRO_AGENT_KEY?.trim();
+    if (fromEnv !== undefined && fromEnv !== '')
+        return { resolve: () => Promise.resolve(fromEnv), fixed: true };
+    return {
+        resolve: () => {
+            const agent = localAgent();
+            if (agent === null || (agentId !== undefined && agent.id !== agentId))
+                throw new Error(`no agent ${agentId === undefined ? '' : `${agentId} `}on this machine — start metro serve, or set METRO_AGENT_KEY`);
+            return Promise.resolve(agent.key);
+        },
+        fixed: false,
+    };
+}
+const armStall = (control) => setTimeout(() => {
+    control.abort();
+}, STALL_MS);
+async function connect(key, signal) {
+    try {
+        return await fetch(`${localUrl()}/api/tail`, {
+            headers: { authorization: `Bearer ${key}` },
+            signal,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+async function pump(body, control, stall) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                return 'ended';
+            clearTimeout(stall.timer);
+            stall.timer = armStall(control);
+            const out = sseDataLines(buffer, decoder.decode(value, { stream: true }));
+            buffer = out.rest;
+            for (const event of out.events)
+                process.stdout.write(`${event}\n`);
+        }
+    }
+    catch {
+        return 'ended';
+    }
+}
+async function streamOnce(key) {
+    const control = new AbortController();
+    const stall = { timer: armStall(control) };
+    try {
+        const res = await connect(key, control.signal);
+        if (res === null)
+            return 'unreachable';
+        if (res.status === 401)
+            return 'unauthorized';
+        if (!res.ok || res.body === null)
+            return 'unreachable';
+        return await pump(res.body, control, stall);
+    }
+    finally {
+        clearTimeout(stall.timer);
+    }
+}
+function note(state, message) {
+    if (state.last === message)
+        return;
+    state.last = message;
+    process.stderr.write(`metro: ${message}\n`);
+}
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function settle(end, source, key, state) {
+    if (end === 'unauthorized') {
+        if (source.fixed)
+            throw new Error('the key in METRO_AGENT_KEY was refused by the local daemon');
+        note(state, 'key refused — fetching the current one');
+        return source.resolve();
+    }
+    if (end === 'unreachable')
+        note(state, `no metro daemon on ${localUrl()} — run 'metro serve'`);
+    else
+        note(state, 'stream ended — reconnecting');
+    return key;
+}
+export async function tailEvents(argv) {
+    const agentId = argv[0] === undefined ? undefined : assertAgentId(argv[0]);
+    const source = keySource(agentId);
+    let key = await source.resolve();
+    const state = { last: '' };
+    let attempt = 0;
+    for (;;) {
+        const end = await streamOnce(key);
+        if (end === 'ended')
+            attempt = 0;
+        key = await settle(end, source, key, state);
+        await delay(backoffAt(attempt));
+        attempt += 1;
+    }
+}

package/dist/update.js

@@ -9,7 +9,19 @@ export function installArgs(manager, version) {
         ? ['add', '--global', spec]
         : ['install', '--global', spec];
 }
-export async function update() {
+export const checkReport = (current, latest) => ({
+    current,
+    latest,
+    newer: latest !== '' && isNewer(latest, current),
+});
+export async function updateCheck() {
+    return checkReport(currentVersion(), await publishedVersion());
+}
+export async function update(argv = []) {
+    if (argv.includes('--check')) {
+        process.stdout.write(`${JSON.stringify(await updateCheck())}\n`);
+        return 0;
+    }
     const current = currentVersion();
     const newest = await publishedVersion();
     if (newest === '') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.20",
+  "version": "0.1.0-beta.201",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {
@@ -35,26 +35,5 @@
     "knip": "^6.15.0",
     "madge": "^8.0.0",
     "typescript": "^5"
-  },
-  "dependencies": {
-    "@discordjs/voice": "^0.19.2",
-    "@modelcontextprotocol/sdk": "^1.12.0",
-    "@mtcute/bun": "0.30.1",
-    "@xmtp/content-type-primitives": "^3.0.1",
-    "@xmtp/content-type-reaction": "^2.0.2",
-    "@xmtp/content-type-remote-attachment": "^2.0.4",
-    "@xmtp/content-type-reply": "^2.0.3",
-    "@xmtp/content-type-wallet-send-calls": "^2.0.0",
-    "@xmtp/node-bindings": "1.9.1",
-    "@xmtp/node-sdk": "^6.0.0",
-    "baileys": "7.0.0-rc14",
-    "discord.js": "^14.26.4",
-    "drizzle-orm": "^0.44.0",
-    "pino": "^9.5.0",
-    "pino-pretty": "^13.1.3",
-    "postgres": "^3.4.5",
-    "prism-media": "^1.3.5",
-    "viem": "^2.52.2",
-    "zod": "^3.23.8"
   }
 }

package/runtime/marketplace/.claude-plugin/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "metro",
+  "description": "Metro — connector relay and chat bridge for agents",
+  "owner": { "name": "Bonustrack", "url": "https://metro.box" },
+  "plugins": [
+    {
+      "name": "metro",
+      "source": "./plugin",
+      "description": "Every connector on this box as its own MCP server through metro's local relay, the orchestrator guard, and the standing rules loaded at session start."
+    }
+  ]
+}

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -0,0 +1,17 @@
+{
+  "name": "metro",
+  "version": "0.1.0-beta.201",
+  "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
+  "author": {
+    "name": "Bonustrack",
+    "url": "https://metro.box"
+  },
+  "repository": "https://github.com/bonustrack/metro",
+  "license": "MIT",
+  "keywords": [
+    "metro",
+    "mcp",
+    "connectors",
+    "relay"
+  ]
+}

package/runtime/marketplace/plugin/.mcp.json

@@ -0,0 +1 @@
+{}