@stage-labs/metro 0.1.0-beta.96 → 0.1.0-beta.97

package/dist/plugin.js

@@ -1,9 +1,39 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { MARKETPLACE, runtimeStore } from './runtime-install.js';
 const MARKETPLACE_REPO = 'bonustrack/metro';
+const MARKETPLACE_NAME = 'metro';
 const PLUGIN_SPEC = 'metro@metro';
+export function marketplaceSource(store = runtimeStore()) {
+    const bundled = join(store, MARKETPLACE);
+    return existsSync(join(bundled, '.claude-plugin', 'marketplace.json')) ? bundled : MARKETPLACE_REPO;
+}
+const realish = (path) => {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return path;
+    }
+};
+export function registeredMarketplacePath(listJson) {
+    let parsed;
+    try {
+        parsed = JSON.parse(listJson);
+    }
+    catch {
+        return undefined;
+    }
+    if (!Array.isArray(parsed))
+        return undefined;
+    const mine = parsed.find((m) => typeof m === 'object' && m !== null && m.name === MARKETPLACE_NAME);
+    if (mine === undefined)
+        return undefined;
+    const at = mine.installLocation ?? mine.path;
+    return typeof at === 'string' ? at : null;
+}
 export function installPathFrom(raw) {
     let parsed;
     try {
@@ -58,21 +88,31 @@ export function syncPluginServers() {
     runClaude(['plugin', 'update', PLUGIN_SPEC]);
     return true;
 }
+function ensureMarketplace(source) {
+    const listed = runClaude(['plugin', 'marketplace', 'list', '--json']);
+    const at = registeredMarketplacePath(listed.output);
+    if (at !== undefined && at !== null && (at === source || realish(at) === realish(source)))
+        return { ok: true, output: '' };
+    if (at !== undefined)
+        runClaude(['plugin', 'marketplace', 'remove', MARKETPLACE_NAME]);
+    return runClaude(['plugin', 'marketplace', 'add', source]);
+}
 export async function installPlugin() {
-    const added = runClaude(['plugin', 'marketplace', 'add', MARKETPLACE_REPO]);
+    const source = marketplaceSource();
+    const added = ensureMarketplace(source);
     if (!added.ok && !tolerable(added.output)) {
         process.stderr.write(added.output);
         return 1;
     }
-    const installed = runClaude(['plugin', 'install', PLUGIN_SPEC]);
+    const installed = runClaude(['plugin', 'install', PLUGIN_SPEC, '-y', '--scope', 'user']);
     if (!installed.ok && !tolerable(installed.output)) {
         process.stderr.write(installed.output);
         return 1;
     }
-    process.stderr.write('Claude Code plugin installed.\n');
+    process.stderr.write(`Claude Code plugin installed from ${source}.\n`);
     if (syncPluginServers()) {
         process.stderr.write('Connector servers loaded — new Claude sessions have them; ' +
-            'run /reload-plugins in any session already open.\n');
+            'run /reload-plugins --force in any session already open.\n');
         return 0;
     }
     process.stderr.write('Start the daemon on this machine (metro serve), then run /metro:refresh inside Claude Code.\n');

package/dist/runtime-install.js

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import { localStations } from './local.js';
 import { STORE_ENTRY, daemonEntry, findBun, runtimeDir } from './runtime.js';
 export const MANIFEST_FILE = 'stations.json';
+export const MARKETPLACE = 'marketplace';
 const METRO_SOURCES = join('node_modules', '@metro-labs');
 const INSTALL_TIMEOUT_MS = 15 * 60_000;
 export function runtimeStore() {
@@ -49,6 +50,9 @@ function syncSources(sources, store) {
         return false;
     rmSync(join(store, METRO_SOURCES), { recursive: true, force: true });
     cpSync(join(sources, METRO_SOURCES), join(store, METRO_SOURCES), { recursive: true });
+    rmSync(join(store, MARKETPLACE), { recursive: true, force: true });
+    if (existsSync(join(sources, MARKETPLACE)))
+        cpSync(join(sources, MARKETPLACE), join(store, MARKETPLACE), { recursive: true });
     if (stamp !== null)
         writeFileSync(join(store, 'runtime.json'), stamp);
     return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.96",
+  "version": "0.1.0-beta.97",
   "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": {

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": "Sign in as one metro agent and use the connectors it holds as MCP servers through metro's relay, credentials injected server-side."
+    }
+  ]
+}

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

@@ -0,0 +1,18 @@
+{
+  "name": "metro",
+  "version": "0.1.0-beta.97",
+  "description": "Metro connectors for Claude Code. Runs beside the metro daemon on this machine: each connector the agent holds is one MCP server relayed through the daemon, the daemon keeps that list current on its own, and /reload-plugins picks up a new one without leaving your session. 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"
+  ],
+  "skills": "./skills/"
+}

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

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

package/runtime/marketplace/plugin/bin/metro-plugin.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const mcpPath = join(pluginRoot, '.mcp.json');
+const NAME_PREFIX = 'metro.box ';
+
+const localUrl = () => `http://127.0.0.1:${Number(process.env.METRO_WEBHOOK_PORT) || 8420}`;
+
+function agentsDir() {
+  const explicit = process.env.METRO_AGENTS_DIR?.trim();
+  return explicit ? explicit : join(homedir(), '.metro', 'agents');
+}
+
+function localAgents() {
+  const 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));
+}
+
+function pickAgent() {
+  const agents = localAgents();
+  const wanted = process.env.METRO_AGENT?.trim();
+  if (wanted) {
+    const found = agents.find((a) => a.name === wanted || a.id === wanted);
+    if (!found) throw new Error(`no local agent named '${wanted}' in ${agentsDir()}`);
+    return found;
+  }
+  if (agents.length === 1) return agents[0];
+  throw new Error(
+    agents.length === 0
+      ? 'no agent on this machine yet — start metro serve and create or restore one in the web UI'
+      : `several agents on this machine — set METRO_AGENT to one of: ${agents.map((a) => a.name).join(', ')}`,
+  );
+}
+
+async function api(path, key) {
+  let res;
+  try {
+    res = await fetch(`${localUrl()}${path}`, { headers: { authorization: `Bearer ${key}` } });
+  } catch {
+    throw new Error(`no metro daemon on ${localUrl()} — start one with: metro serve`);
+  }
+  const body = await res.json().catch(() => null);
+  if (!res.ok) {
+    const detail = typeof body?.error === 'string' ? body.error : `the daemon answered ${res.status}`;
+    const err = new Error(detail);
+    err.status = res.status;
+    throw err;
+  }
+  return body;
+}
+
+function serverEntries(rawJson) {
+  const servers = JSON.parse(rawJson)?.mcpServers;
+  if (typeof servers !== 'object' || servers === null)
+    throw new Error('the daemon returned an unexpected mcpServers shape');
+  const out = {};
+  for (const [key, value] of Object.entries(servers)) {
+    const name = key.startsWith(NAME_PREFIX) ? key.slice(NAME_PREFIX.length) : key;
+    out[name] = {
+      type: value.type ?? 'http',
+      url: value.url,
+      headersHelper: 'node "${CLAUDE_PLUGIN_ROOT}/bin/metro-plugin.mjs" headers',
+    };
+  }
+  return out;
+}
+
+async function refresh() {
+  const agent = pickAgent();
+  const body = await api('/api/cli/mcp', agent.key);
+  const servers = serverEntries(body.json);
+  writeFileSync(mcpPath, `${JSON.stringify(servers, null, 2)}\n`);
+  const names = Object.keys(servers);
+  process.stdout.write(
+    `agent '${agent.name}': ${names.length} server(s) written to the plugin\n` +
+      (names.length ? `  ${names.join('\n  ')}\n` : '') +
+      'Run /reload-plugins to apply in this session.\n',
+  );
+}
+
+function headers() {
+  let agent;
+  try {
+    agent = pickAgent();
+  } catch (err) {
+    process.stderr.write(`metro: ${err.message}\n`);
+    process.stdout.write('{}\n');
+    return;
+  }
+  process.stdout.write(`${JSON.stringify({ Authorization: `Bearer ${agent.key}` })}\n`);
+}
+
+const command = process.argv[2];
+const run = { refresh, headers: () => Promise.resolve(headers()) }[command];
+
+if (run === undefined) {
+  process.stderr.write('usage: metro-plugin.mjs <refresh|headers>\n');
+  process.exit(1);
+}
+
+run().catch((err) => {
+  process.stderr.write(`metro: ${err.message}\n`);
+  process.exit(err.status === 401 ? 2 : 1);
+});

package/runtime/marketplace/plugin/skills/refresh/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: refresh
+description: Rewrite the plugin's MCP servers from the metro daemon's connector list by hand, for when the daemon could not keep the list current itself.
+---
+
+The metro daemon writes this plugin's MCP server list itself whenever a connector is added, renamed or removed, so this is the fallback for when it could not: the daemon was not running at the time, or a plugin update reset the file.
+
+1. Run with Bash:
+
+```
+node "${CLAUDE_PLUGIN_ROOT}/bin/metro-plugin.mjs" refresh
+```
+
+2. On success, relay the script's output verbatim and tell the user to run `/reload-plugins --force`, which re-reads the plugin from disk; a plain `/reload-plugins` reuses a cached manifest and keeps the old list. You cannot run that command for them.
+3. If the script says there is no daemon, tell the user to start one with `metro serve` and stop. If it says there is no agent yet, tell them to create or restore one in the web UI the daemon links to.

package/runtime/node_modules/@metro-labs/daemon/src/boot/boot.ts

@@ -22,6 +22,7 @@ import { localAgentKey } from '../stations/materialize.js';
 import { agentsDir, fileSource } from '../agents/files.js';
 import { ConnectorWatch } from '../connectors/watch.js';
 import { syncPluginServers } from '../connectors/plugin-sync.js';
+import { ensureMetroPlugin } from '../claude/plugin-install.js';
 import { applyLocalOwner } from './local-owner.js';
 import { localOwner } from '../agents/file-admin.js';
 import { ensureStationDeps } from '../stations/runtime-deps.js';
@@ -150,6 +151,14 @@ async function main(): Promise<void> {
     'dispatcher ready',
   );
   markDaemonReady();
+  ensureMetroPlugin()
+    .then((outcome) => {
+      log.info({ outcome }, 'plugin: metro plugin for Claude Code');
+      if (outcome !== 'skipped') syncPluginServers();
+    })
+    .catch((err: unknown) => {
+      log.warn({ err: errMsg(err) }, 'plugin: could not ensure the Claude Code plugin');
+    });
 }
 
 const SHUTDOWN_TIMEOUT_MS = 3_000;

package/runtime/node_modules/@metro-labs/daemon/src/claude/plugin-install.ts

@@ -0,0 +1,128 @@
+import { execFile } from 'node:child_process';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
+
+const MARKETPLACE = 'metro';
+const PLUGIN = 'metro@metro';
+const STEP_MS = 120_000;
+const SAID_MAX = 300;
+
+export interface Answer {
+  status: number;
+  stdout: string;
+  stderr: string;
+}
+
+export type Run = (args: string[]) => Promise<Answer>;
+
+export interface PluginInstallDeps {
+  run: Run | null;
+  marketplaceDir: string | null;
+}
+
+export type PluginOutcome = 'skipped' | 'unchanged' | 'installed' | 'updated' | 'failed';
+
+export function stagedMarketplaceDir(env: NodeJS.ProcessEnv = process.env): string | null {
+  const store = env.METRO_RUNTIME_STORE?.trim() ?? '';
+  if (store === '') return null;
+  const dir = join(store, 'marketplace');
+  return existsSync(join(dir, '.claude-plugin', 'marketplace.json')) ? dir : null;
+}
+
+export function stagedPluginVersion(dir: string): string | null {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(join(dir, 'plugin', '.claude-plugin', 'plugin.json'), 'utf8'));
+    return isRecord(parsed) && typeof parsed.version === 'string' ? parsed.version : null;
+  } catch {
+    return null;
+  }
+}
+
+const runner =
+  (bin: string): Run =>
+  (args) =>
+    new Promise((resolve) => {
+      execFile(bin, args, { encoding: 'utf8', timeout: STEP_MS, maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
+        const status = err === null ? 0 : typeof (err as { code?: unknown }).code === 'number' ? (err as { code: number }).code : 1;
+        resolve({ status, stdout, stderr });
+      });
+    });
+
+export async function findClaude(candidates = ['claude', join(homedir(), '.local', 'bin', 'claude')]): Promise<Run | null> {
+  for (const bin of candidates) {
+    const run = runner(bin);
+    if ((await run(['--version'])).status === 0) return run;
+  }
+  return null;
+}
+
+function listOf(stdout: string): Record<string, unknown>[] {
+  try {
+    const parsed: unknown = JSON.parse(stdout);
+    return Array.isArray(parsed) ? parsed.filter(isRecord) : [];
+  } catch {
+    return [];
+  }
+}
+
+const realish = (path: string): string => {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+};
+
+const samePath = (a: string | null, b: string): boolean => a !== null && realish(a) === realish(b);
+
+async function step(run: Run, args: string[]): Promise<boolean> {
+  const answer = await run(args);
+  if (answer.status === 0) {
+    log.info({ args }, 'plugin: claude');
+    return true;
+  }
+  log.warn({ args, said: `${answer.stderr}${answer.stdout}`.trim().slice(0, SAID_MAX) }, 'plugin: claude refused');
+  return false;
+}
+
+async function marketplacePath(run: Run): Promise<string | null | undefined> {
+  const mine = listOf((await run(['plugin', 'marketplace', 'list', '--json'])).stdout).find((m) => m.name === MARKETPLACE);
+  if (mine === undefined) return undefined;
+  const at = mine.installLocation ?? mine.path;
+  return typeof at === 'string' ? at : null;
+}
+
+async function ensureMarketplace(run: Run, dir: string): Promise<boolean> {
+  const at = await marketplacePath(run);
+  if (at !== undefined && samePath(at, dir)) return true;
+  if (at !== undefined) await step(run, ['plugin', 'marketplace', 'remove', MARKETPLACE]);
+  return step(run, ['plugin', 'marketplace', 'add', dir]);
+}
+
+async function installedVersion(run: Run): Promise<string | null> {
+  const mine = listOf((await run(['plugin', 'list', '--json'])).stdout).find((p) => p.id === PLUGIN);
+  return mine !== undefined && typeof mine.version === 'string' ? mine.version : null;
+}
+
+async function ensureInstalled(run: Run, wanted: string | null): Promise<PluginOutcome> {
+  const have = await installedVersion(run);
+  if (have === null) return (await step(run, ['plugin', 'install', PLUGIN, '-y', '--scope', 'user'])) ? 'installed' : 'failed';
+  if (wanted === null || have === wanted) return 'unchanged';
+  await step(run, ['plugin', 'marketplace', 'update', MARKETPLACE]);
+  return (await step(run, ['plugin', 'update', PLUGIN, '-y'])) ? 'updated' : 'failed';
+}
+
+export async function ensureMetroPlugin(deps?: Partial<PluginInstallDeps>): Promise<PluginOutcome> {
+  const dir = deps?.marketplaceDir === undefined ? stagedMarketplaceDir() : deps.marketplaceDir;
+  if (dir === null) return 'skipped';
+  const run = deps?.run === undefined ? await findClaude() : deps.run;
+  if (run === null) {
+    log.info('plugin: claude is not on this machine, so metro leaves its Claude Code plugin alone');
+    return 'skipped';
+  }
+  if (!(await ensureMarketplace(run, dir))) return 'failed';
+  return ensureInstalled(run, stagedPluginVersion(dir));
+}

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.96"
+  "version": "0.1.0-beta.97"
 }