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

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.98",
   "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.98",
+  "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/agents/accounts-api.ts

@@ -74,6 +74,13 @@ export interface AccountApiDeps {
     allowlist: string[],
   ) => Promise<string[]>;
   recentSenders: (station: StationName, accountId: string) => RecentSender[];
+  setAccountEnabled: (
+    subject: string,
+    agentId: string,
+    station: StationName,
+    accountId: string,
+    enabled: boolean,
+  ) => Promise<boolean>;
 }
 
 export type AccountRoute =
@@ -82,7 +89,8 @@ export type AccountRoute =
   | { kind: 'step'; attachId: string }
   | { kind: 'account'; station: StationName; accountId: string }
   | { kind: 'allowlist'; station: StationName; accountId: string }
-  | { kind: 'senders'; station: StationName; accountId: string };
+  | { kind: 'senders'; station: StationName; accountId: string }
+  | { kind: 'enabled'; station: StationName; accountId: string };
 
 export const ATTACHABLE: string[] = [
   ...ATTACHABLE_STATIONS,
@@ -96,6 +104,7 @@ const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
   account: ['DELETE'],
   allowlist: ['PUT'],
   senders: ['GET'],
+  enabled: ['PUT'],
 };
 
 function twoSegmentRoute(head: string, tail: string): AccountRoute | null {
@@ -121,7 +130,7 @@ export function accountRoute(rest: string[]): AccountRoute | null {
 }
 
 function accountSubRoute(head: string, tail: string, sub: string | undefined): AccountRoute | null {
-  if (!isStationName(head) || (sub !== 'allowlist' && sub !== 'senders')) return null;
+  if (!isStationName(head) || (sub !== 'allowlist' && sub !== 'senders' && sub !== 'enabled')) return null;
   const accountId = parseAccountId(tail);
   return accountId === null ? null : { kind: sub, station: head, accountId };
 }
@@ -294,6 +303,27 @@ async function handleAllowlist(
   });
 }
 
+async function handleEnabled(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AccountApiDeps,
+  session: ApiSession,
+  agentId: string,
+  target: { station: StationName; accountId: string },
+): Promise<void> {
+  const wanted = bodyField(await readJsonBody(req), 'enabled');
+  if (typeof wanted !== 'boolean') throw new ApiError('enabled must be true or false', 400);
+  const enabled = await deps.setAccountEnabled(session.subject, agentId, target.station, target.accountId, wanted);
+  log.info({ agentId, station: target.station, account: target.accountId, enabled }, 'account-api: account enabled flag set');
+  sendJson(req, res, 200, {
+    agentId,
+    station: target.station,
+    accountId: target.accountId,
+    enabled,
+    activated: await activate(deps, target.station),
+  });
+}
+
 async function handleSession(
   req: IncomingMessage,
   res: ServerResponse,
@@ -345,6 +375,7 @@ async function dispatchRoute(
   if (route.kind === 'step')
     return handleStep(req, res, deps, ownerOf(session, agentId), route.attachId);
   if (route.kind === 'allowlist') return handleAllowlist(req, res, deps, session, agentId, route);
+  if (route.kind === 'enabled') return handleEnabled(req, res, deps, session, agentId, route);
   if (route.kind === 'senders') {
     sendJson(req, res, 200, { senders: deps.recentSenders(route.station, route.accountId) });
     return;

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

@@ -47,7 +47,7 @@ function stationOf(raw: unknown): LoadedAccount {
   const allowlist = Array.isArray(raw.allowlist)
     ? raw.allowlist.filter((s): s is string => typeof s === 'string')
     : null;
-  return { station: raw.station as LoadedAccount['station'], id: raw.id, allowlist, config: raw.config };
+  return { station: raw.station as LoadedAccount['station'], id: raw.id, allowlist, enabled: raw.enabled !== false, config: raw.config };
 }
 
 function connectorOf(raw: unknown): LoadedConnector {

package/runtime/node_modules/@metro-labs/daemon/src/agents/file-admin.ts

@@ -305,7 +305,7 @@ export async function localAttachAccount(
   if (typeof token === 'string') assertTokenFree(storedAgents(dir), station, token);
   const taken = new Set(stored.file.stations.map((a) => a.id));
   const accountId = freshId(taken);
-  stored.file.stations.push({ station, id: accountId, allowlist: ['*'], config });
+  stored.file.stations.push({ station, id: accountId, allowlist: ['*'], enabled: true, config });
   save(stored);
   return Promise.resolve({ agentId, station, accountId });
 }
@@ -326,6 +326,22 @@ export async function localSetAllowlist(
   return Promise.resolve(allowlist);
 }
 
+export async function localSetAccountEnabled(
+  subject: string,
+  agentId: string,
+  station: StationName,
+  accountId: string,
+  enabled: boolean,
+  dir = agentsDir(),
+): Promise<boolean> {
+  const stored = ownedOrThrow(subject, agentId, dir);
+  const account = stored.file.stations.find((a) => a.station === station && a.id === accountId);
+  if (account === undefined) throw new AgentAdminError('no such account on this agent', 404);
+  account.enabled = enabled;
+  save(stored);
+  return Promise.resolve(enabled);
+}
+
 export async function localDetachAccount(
   subject: string,
   agentId: string,

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

@@ -56,7 +56,7 @@ function stationOf(raw: unknown, path: string, index: number): LoadedAccount {
   if (typeof id !== 'string' || !ID_RE.test(id))
     fail(path, `${where}.id is not an 11-character id`);
   if (!isRecord(config)) fail(path, `${where}.config is not an object`);
-  return { station, id, allowlist: allowlistOf(raw.allowlist, path, where), config };
+  return { station, id, allowlist: allowlistOf(raw.allowlist, path, where), enabled: raw.enabled !== false, config };
 }
 
 function optionalMatch(

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

@@ -8,6 +8,7 @@ const mapKey = (station: string, accountId: string): string =>
 let agentMap: AgentMap = {};
 let agentNames: AgentNameMap = {};
 let allowlistMap: AllowlistMap = {};
+let disabledAccounts = new Set<string>();
 
 export function setAgentMap(map: AgentMap, names: AgentNameMap): void {
   agentMap = map;
@@ -18,6 +19,12 @@ export function setAllowlistMap(map: AllowlistMap): void {
   allowlistMap = map;
 }
 
+export function setDisabledAccounts(ids: Set<string>): void {
+  disabledAccounts = ids;
+}
+
+export const accountEnabled = (station: string, accountId: string): boolean => !disabledAccounts.has(mapKey(station, accountId));
+
 export function accountFromLine(
   line: string,
 ): { station: string; accountId: string } | undefined {

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/node_modules/@metro-labs/daemon/src/mcp/accounts.ts

@@ -5,7 +5,7 @@ import {
 } from '../stations/registry.js';
 import { listEndpoints } from '../net/tunnel.js';
 import { hookUrl } from '../stations/attach.js';
-import { agentIdForAccount, allowlistForAccount, knownAccounts, type KnownAccount } from '../agents/map.js';
+import { accountEnabled, agentIdForAccount, allowlistForAccount, knownAccounts, type KnownAccount } from '../agents/map.js';
 
 const accountId = (acc: unknown): string | undefined => {
   const id = (acc as { id?: unknown }).id;
@@ -25,7 +25,8 @@ function withAgentId(station: string, acc: unknown): unknown {
   const agentId = agentIdForAccount(station, id);
   if (agentId === undefined) return acc;
   const allowlist = allowlistForAccount(station, id);
-  return allowlist === undefined ? { ...rec, agentId } : { ...rec, agentId, allowlist };
+  const tagged = allowlist === undefined ? { ...rec, agentId } : { ...rec, agentId, allowlist };
+  return accountEnabled(station, id) ? tagged : { ...tagged, enabled: false };
 }
 
 export function attachAgentIds(

package/runtime/node_modules/@metro-labs/daemon/src/routes/local-mode.ts

@@ -36,6 +36,7 @@ import {
   localDeleteAgent,
   localDetachAccount,
   localSetAllowlist,
+  localSetAccountEnabled,
   localImportAgent,
   localListAgents,
   localOwnedAgentOrThrow,
@@ -103,6 +104,7 @@ function agentApi(deps: LocalModeDeps): AgentApiDeps {
     detachAccount: localDetachAccount,
     syncStations: deps.syncStations,
     setAllowlist: localSetAllowlist,
+    setAccountEnabled: localSetAccountEnabled,
     recentSenders,
     reloadAgents: deps.reloadAgents,
   };

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

@@ -13,6 +13,7 @@ import { trainsDir } from '../boot/paths.js';
 import {
   setAgentMap,
   setAllowlistMap,
+  setDisabledAccounts,
   type AgentMap,
   type AgentNameMap,
   type AllowlistMap,
@@ -30,6 +31,7 @@ export interface LoadedAccount {
   station: StationName;
   id: string;
   allowlist: string[] | null;
+  enabled?: boolean;
   config: Record<string, unknown>;
 }
 
@@ -126,6 +128,7 @@ function writeStations(list: LoadedAgent[]): WrittenStations {
   const map: AgentMap = {};
   const names: AgentNameMap = {};
   const allow: AllowlistMap = {};
+  const disabled = new Set<string>();
   for (const agent of list) {
     names[agent.id] = agent.name;
     for (const a of agent.accounts) {
@@ -138,6 +141,10 @@ function writeStations(list: LoadedAgent[]): WrittenStations {
       }
       map[`${a.station}/${a.id}`] = agent.id;
       if (a.allowlist) allow[`${a.station}/${a.id}`] = a.allowlist;
+      if (a.enabled === false) {
+        disabled.add(`${a.station}/${a.id}`);
+        continue;
+      }
       const cur = byStation.get(a.station);
       if (cur) cur.push(a);
       else byStation.set(a.station, [a]);
@@ -145,6 +152,7 @@ function writeStations(list: LoadedAgent[]): WrittenStations {
   }
   setAgentMap(map, names);
   setAllowlistMap(allow);
+  setDisabledAccounts(disabled);
 
   const active = new Map<StationName, number>();
   const changed: StationName[] = [];

package/runtime/runtime.json

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