@stage-labs/metro 0.1.0-beta.140 → 0.1.0-beta.142

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

@@ -1,12 +1,6 @@
-import { errMsg, log } from '@metro-labs/core/log';
+import { isRecord } from '@metro-labs/core/is-record';
 import { whyUnreachable } from './reach.js';
-import {
-  ConnectorNotMcp,
-  ConnectorUnauthorized,
-  refused,
-  safeIconSrc,
-} from './url.js';
-import { toToolList, type ToolInfo } from './tools.js';
+import { ConnectorUnauthorized, refused } from './url.js';
 
 export {
   ConnectorUnauthorized,
@@ -14,7 +8,6 @@ export {
   connectorUrlText,
   parseConnectorUrl,
 } from './url.js';
-import { isRecord } from '@metro-labs/core/is-record';
 
 export interface OAuthTokens {
   accessToken: string;
@@ -38,295 +31,71 @@ export type ConnectorAuth =
 
 export interface VerifiedServer {
   server: string;
-  version: string;
-  protocol: string;
-  icon: string;
-  tools: number;
-  catalog: ToolInfo[];
 }
 
 export interface VerifiedRecord extends VerifiedServer {
   at: string;
 }
 
-const PROTOCOL_VERSIONS = ['2025-11-25', '2025-06-18'] as const;
-const MAX_TOOL_PAGES = 10;
-
-function notMcp(url: URL): ConnectorNotMcp {
-  return new ConnectorNotMcp(
-    `${url.hostname} answered, but it does not speak MCP.`,
-    400,
-  );
-}
+const PROTOCOL_VERSION = '2025-11-25';
 const PROBE_TIMEOUT_MS = 10_000;
-const ACCEPT = 'application/json, text/event-stream';
 
-async function discard(res: Response): Promise<void> {
-  await res.body?.cancel().catch((err: unknown) => {
-    log.debug(
-      { err: errMsg(err) },
-      'connector-verify: could not discard a response body',
-    );
-  });
-}
+const INITIALIZE = {
+  jsonrpc: '2.0',
+  id: 1,
+  method: 'initialize',
+  params: { protocolVersion: PROTOCOL_VERSION, capabilities: {}, clientInfo: { name: 'metro', version: '0.1.0' } },
+};
 
-function authHeaders(auth: ConnectorAuth): Record<string, string> {
+export function authHeaders(auth: ConnectorAuth): Record<string, string> {
   if (auth.kind === 'header') return { [auth.name]: auth.value };
-  if (auth.kind === 'oauth')
-    return { authorization: `Bearer ${auth.accessToken}` };
+  if (auth.kind === 'oauth') return { authorization: `Bearer ${auth.accessToken}` };
   return {};
 }
 
-async function frame(
-  url: URL,
-  auth: ConnectorAuth,
-  extra: Record<string, string>,
-  body: unknown,
-  signal: AbortSignal,
-): Promise<Response> {
-  let res: Response;
-  try {
-    res = await fetch(url, {
-      method: 'POST',
-      redirect: 'manual',
-      signal,
-      headers: {
-        'content-type': 'application/json',
-        accept: ACCEPT,
-        ...authHeaders(auth),
-        ...extra,
-      },
-      body: JSON.stringify(body),
-    });
-  } catch (err) {
-    throw refused(`Metro could not reach ${url.hostname}: ${whyUnreachable(err)}`);
-  }
-  if (res.status >= 300 && res.status < 400) {
-    await discard(res);
-    throw refused('that url redirects — use the url it redirects to');
-  }
-  return res;
-}
-
-function sseData(body: string): string {
-  for (const line of body.replace(/\r\n/g, '\n').split('\n'))
-    if (line.startsWith('data:')) return line.slice(5).trim();
+function payloadOf(text: string, contentType: string): string {
+  if (!contentType.includes('text/event-stream')) return text;
+  for (const line of text.replace(/\r\n/g, '\n').split('\n')) if (line.startsWith('data:')) return line.slice(5).trim();
   return '';
 }
 
-async function payloadOf(res: Response): Promise<string> {
-  const contentType = res.headers.get('content-type') ?? '';
-  const text = await res.text().catch(() => '');
-  return contentType.includes('text/event-stream') ? sseData(text) : text;
-}
-
-async function resultOrNull(
-  res: Response,
-): Promise<Record<string, unknown> | null> {
-  const payload = await payloadOf(res);
+function serverNameOf(url: URL, text: string, contentType: string): string {
   let parsed: unknown;
   try {
-    parsed = JSON.parse(payload);
+    parsed = JSON.parse(payloadOf(text, contentType));
   } catch {
-    return null;
+    throw refused(`${url.hostname} answered, but it does not speak MCP.`);
   }
-  if (!isRecord(parsed) || !isRecord(parsed.result)) return null;
-  return parsed.result;
-}
-
-function initializeBody(version: string): unknown {
-  return {
-    jsonrpc: '2.0',
-    id: 1,
-    method: 'initialize',
-    params: {
-      protocolVersion: version,
-      capabilities: {},
-      clientInfo: { name: 'metro', version: '0.1.0' },
-    },
-  };
-}
-
-function iconOf(info: Record<string, unknown>): string {
-  const icons = info.icons;
-  if (!Array.isArray(icons)) return '';
-  for (const entry of icons) {
-    if (!isRecord(entry)) continue;
-    const src = safeIconSrc(entry.src);
-    if (src !== '') return src;
-  }
-  return '';
-}
-
-function serverFrom(url: URL, result: Record<string, unknown>): VerifiedServer {
-  const protocol = result.protocolVersion;
-  if (typeof protocol !== 'string') throw notMcp(url);
+  const result = isRecord(parsed) && isRecord(parsed.result) ? parsed.result : null;
+  if (result === null || typeof result.protocolVersion !== 'string') throw refused(`${url.hostname} answered, but it does not speak MCP.`);
   const info = isRecord(result.serverInfo) ? result.serverInfo : {};
   const title = typeof info.title === 'string' ? info.title : '';
-  return {
-    server:
-      title !== ''
-        ? title
-        : typeof info.name === 'string'
-          ? info.name
-          : url.hostname,
-    version: typeof info.version === 'string' ? info.version : '',
-    protocol,
-    icon: iconOf(info),
-    tools: 0,
-    catalog: [],
-  };
-}
-
-async function initialize(
-  url: URL,
-  auth: ConnectorAuth,
-  signal: AbortSignal,
-  version: string,
-): Promise<{ session: string | null; server: VerifiedServer }> {
-  const res = await frame(url, auth, {}, initializeBody(version), signal);
-  if (res.status === 401 || res.status === 403) {
-    await discard(res);
-    throw new ConnectorUnauthorized(
-      auth.kind === 'none'
-        ? `${url.hostname} requires authorization.`
-        : `${url.hostname} rejected that credential.`,
-      400,
-    );
-  }
-  if (res.status === 404 || res.status === 405) {
-    await discard(res);
-    throw refused(
-      `${url.hostname} did not accept an MCP initialize over HTTP POST. ` +
-        'If it is a legacy SSE server, Metro cannot verify it yet.',
-    );
-  }
-  if (!res.ok) {
-    await discard(res);
-    throw notMcp(url);
-  }
-  const result = await resultOrNull(res);
-  if (result === null) throw notMcp(url);
-  return {
-    session: res.headers.get('mcp-session-id'),
-    server: serverFrom(url, result),
-  };
-}
-
-function sessionHeaders(
-  session: string | null,
-  version: string,
-): Record<string, string> {
-  const headers: Record<string, string> = {
-    'mcp-protocol-version': version,
-  };
-  if (session !== null && session !== '') headers['mcp-session-id'] = session;
-  return headers;
-}
-
-async function announce(
-  url: URL,
-  auth: ConnectorAuth,
-  headers: Record<string, string>,
-  signal: AbortSignal,
-): Promise<void> {
-  const res = await frame(
-    url,
-    auth,
-    headers,
-    { jsonrpc: '2.0', method: 'notifications/initialized' },
-    signal,
-  );
-  await discard(res);
-}
-
-async function toolPage(
-  url: URL,
-  auth: ConnectorAuth,
-  headers: Record<string, string>,
-  signal: AbortSignal,
-  cursor: string,
-): Promise<Record<string, unknown> | null> {
-  const params = cursor === '' ? {} : { cursor };
-  const res = await frame(
-    url,
-    auth,
-    headers,
-    { jsonrpc: '2.0', id: 2, method: 'tools/list', params },
-    signal,
-  );
-  if (!res.ok) {
-    await discard(res);
-    return null;
-  }
-  return resultOrNull(res);
+  if (title !== '') return title;
+  return typeof info.name === 'string' ? info.name : url.hostname;
 }
 
-async function listTools(
-  url: URL,
-  auth: ConnectorAuth,
-  headers: Record<string, string>,
-  signal: AbortSignal,
-): Promise<ToolInfo[]> {
-  const tools: ToolInfo[] = [];
-  let cursor = '';
-  for (let page = 0; page < MAX_TOOL_PAGES; page += 1) {
-    const result = await toolPage(url, auth, headers, signal, cursor);
-    if (result === null) break;
-    tools.push(...toToolList(result.tools));
-    const next = result.nextCursor;
-    if (typeof next !== 'string' || next === '' || next === cursor) break;
-    cursor = next;
+async function post(url: URL, auth: ConnectorAuth): Promise<Response> {
+  try {
+    return await fetch(url, {
+      method: 'POST',
+      redirect: 'manual',
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+      headers: { 'content-type': 'application/json', accept: 'application/json, text/event-stream', ...authHeaders(auth) },
+      body: JSON.stringify(INITIALIZE),
+    });
+  } catch (err) {
+    throw refused(`Metro could not reach ${url.hostname}: ${whyUnreachable(err)}`);
   }
-  return tools;
 }
 
-async function terminate(
-  url: URL,
-  auth: ConnectorAuth,
-  headers: Record<string, string>,
-  signal: AbortSignal,
-): Promise<void> {
-  const res = await fetch(url, {
-    method: 'DELETE',
-    redirect: 'manual',
-    signal,
-    headers: { ...authHeaders(auth), ...headers },
-  });
-  await discard(res);
-}
-
-async function probeWith(
-  url: URL,
-  auth: ConnectorAuth,
-  version: string,
-): Promise<VerifiedServer> {
-  const signal = AbortSignal.timeout(PROBE_TIMEOUT_MS);
-  const { session, server } = await initialize(url, auth, signal, version);
-  const headers = sessionHeaders(session, server.protocol);
-  await announce(url, auth, headers, signal);
-  const catalog = await listTools(url, auth, headers, signal);
-  await terminate(url, auth, headers, signal).catch((err: unknown) => {
-    log.debug(
-      { host: url.hostname, err: errMsg(err) },
-      'connector-verify: the remote declined to end the session',
-    );
-  });
-  return { ...server, tools: catalog.length, catalog };
-}
-
-export async function verifyRemoteMcp(
-  url: URL,
-  auth: ConnectorAuth,
-): Promise<VerifiedServer> {
-  let last: unknown;
-  for (const version of PROTOCOL_VERSIONS) {
-    try {
-      return await probeWith(url, auth, version);
-    } catch (err) {
-      if (!(err instanceof ConnectorNotMcp)) throw err;
-      last = err;
-    }
-  }
-  throw last;
+export async function verifyRemoteMcp(url: URL, auth: ConnectorAuth): Promise<VerifiedServer> {
+  const res = await post(url, auth);
+  const text = await res.text().catch(() => '');
+  if (res.status >= 300 && res.status < 400) throw refused('that url redirects — use the url it redirects to');
+  if (res.status === 401 || res.status === 403)
+    throw new ConnectorUnauthorized(auth.kind === 'none' ? `${url.hostname} requires authorization.` : `${url.hostname} rejected that credential.`, 400);
+  if (res.status === 404 || res.status === 405)
+    throw refused(`${url.hostname} did not accept an MCP initialize over HTTP POST. If it is a legacy SSE server, Metro cannot verify it yet.`);
+  if (!res.ok) throw refused(`${url.hostname} answered ${String(res.status)} instead of an MCP initialize.`);
+  return { server: serverNameOf(url, text, res.headers.get('content-type') ?? '') };
 }

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

@@ -12,12 +12,11 @@ import { loadedAgentOf, type AgentBundle, type BundleApiDeps } from '../agents/b
 import { METRO_VERSION } from '@metro-labs/core/version';
 import type { ConnectorApiDeps } from '../connectors/api.js';
 import { allowLocalConnectors } from '../connectors/url.js';
-import { keyIdentity, type LocalCliDeps } from '../connectors/cli-api.js';
+import { authenticate } from '../mcp/request-identity.js';
 import type { RelayApiDeps } from '../connectors/relay.js';
 import {
   readLocalConnectors,
   localImportConnectors,
-  localConnectorNamesByIds,
   localCreateConnector,
   localCreatePendingConnector,
   localDeleteConnector,
@@ -45,7 +44,6 @@ import {
   localResetAgentKey,
   readLocalAgentFile,
 } from '../agents/file-admin.js';
-import { listAgentFiles, readAgentFile } from '../agents/files.js';
 import { readModelConfig } from '../gateway/model-config.js';
 import type { StationName } from '@metro-labs/core/station-names';
 
@@ -123,7 +121,7 @@ function connectorIdsOfLocalAgents(ids: string[]): Promise<Map<string, string[]>
 const connectorApi: ConnectorApiDeps = {
   listConnectors: async (subject, project) => {
     const rows = await localListConnectors(subject, project);
-    syncPluginServers();
+    syncPluginServers(readLocalConnectors());
     return rows;
   },
   createConnector: localCreateConnector,
@@ -138,19 +136,12 @@ const connectorApi: ConnectorApiDeps = {
 
 const relayApi: RelayApiDeps = {
   target: (connectorId, force) => localRelayTarget(connectorId, force),
-  identify: keyIdentity,
+  identify: (req) => {
+    const who = authenticate(req);
+    return who?.kind === 'agent' ? { subject: 'agent-key', agentId: who.agentId } : null;
+  },
 };
 
-function agentNameOf(agentId: string): string | null {
-  return listAgentFiles()
-    .map((path) => readAgentFile(path))
-    .find((file) => file.id === agentId)?.name ?? null;
-}
-
-const localCli: LocalCliDeps = {
-  agentName: agentNameOf,
-  connectorEntries: () => localConnectorNamesByIds(allConnectorIds()),
-};
 
 function bundleApi(deps: LocalModeDeps): BundleApiDeps {
   return {
@@ -210,7 +201,6 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     bundleApi: bundleApi(deps),
     connectorApi,
     relayApi,
-    localCli,
     claudeApi: { authorize: (subject) => { assertLocalOwner(subject); } },
     updateApi: { authorize: (subject) => { assertLocalOwner(subject); }, restart: deps.restart },
     controlApi: { authorize: (subject) => { assertLocalOwner(subject); }, restart: deps.restart, stop: deps.stop },

package/runtime/node_modules/@metro-labs/daemon/src/routes/session-apis.ts

@@ -6,7 +6,6 @@ import {
   type ConnectorApiDeps,
 } from '../connectors/api.js';
 import type { RelayApiDeps } from '../connectors/relay.js';
-import { handleLocalCliRequest, type LocalCliDeps } from '../connectors/cli-api.js';
 import { handleClaudeRequest, type ClaudeApiDeps } from '../claude/api.js';
 import type { ModeInfo } from '@metro-labs/http/mode-api';
 import { handleBundleRequest, type BundleApiDeps } from '../agents/bundle.js';
@@ -28,7 +27,6 @@ export interface SessionApis {
   modelApi?: ModelApiDeps;
   gateway?: GatewayDeps;
   terminalApi?: TerminalApiDeps;
-  localCli?: LocalCliDeps;
   claudeApi?: ClaudeApiDeps;
   connectorApi?: ConnectorApiDeps;
   relayApi?: RelayApiDeps;
@@ -45,7 +43,6 @@ export function handleSessionApis(
 ): boolean {
   const routes: (() => boolean)[] = [
     () => handleSessionApiRequest(req, res),
-    ...when(apis.localCli, (d) => handleLocalCliRequest(req, res, d)),
     ...when(apis.connectorApi, (d) => handleConnectorApiRequest(req, res, d)),
     ...when(apis.bundleApi, (d) => handleBundleRequest(req, res, d)),
     ...when(apis.updateApi, (d) => handleUpdateRequest(req, res, d)),

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

@@ -1,5 +1,7 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import { hostname } from 'node:os';
+import { hostname, homedir } from 'node:os';
+import { statfs } from 'node:fs/promises';
+import { errMsg, log } from '@metro-labs/core/log';
 import { ApiError } from '@metro-labs/http/api-error';
 import { apiFailure, apiSession, cors, sendJson } from '@metro-labs/http/api-http';
 import { publicBaseUrl } from '../files/attach-serve.js';
@@ -18,9 +20,26 @@ export interface MachineApiDeps {
 
 const bootedAt = new Date(Date.now() - process.uptime() * 1000).toISOString();
 
-export function machineInfo(startedAt = bootedAt): Record<string, unknown> {
+export interface Disk {
+  path: string;
+  totalBytes: number;
+  freeBytes: number;
+}
+
+export async function diskInfo(path = homedir()): Promise<Disk | null> {
+  try {
+    const s = await statfs(path);
+    return { path, totalBytes: s.bsize * s.blocks, freeBytes: s.bsize * s.bavail };
+  } catch (err) {
+    log.warn({ err: errMsg(err), path }, 'machine: could not read the disk');
+    return null;
+  }
+}
+
+export async function machineInfo(startedAt = bootedAt): Promise<Record<string, unknown>> {
   const store = process.env.METRO_RUNTIME_STORE?.trim() ?? '';
   return {
+    disk: await diskInfo(),
     version: METRO_VERSION,
     owner: localOwner(),
     hostname: hostname(),
@@ -49,10 +68,10 @@ export function handleMachineRequest(req: IncomingMessage, res: ServerResponse,
     return true;
   }
   apiSession(req)
-    .then((session) => {
+    .then(async (session) => {
       if (!session) throw new ApiError('unauthorized', 401);
       deps.authorize(session.subject);
-      sendJson(req, res, 200, machineInfo(deps.startedAt));
+      sendJson(req, res, 200, await machineInfo(deps.startedAt));
     })
     .catch((err: unknown) => {
       apiFailure(req, res, err, 'machine-api');

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.140"
+  "version": "0.1.0-beta.142"
 }

package/dist/plugin.js

@@ -1,120 +0,0 @@
-import { spawnSync } from 'node:child_process';
-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 {
-        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)
-        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;
-}
-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 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, '-y', '--scope', 'user']);
-    if (!installed.ok && !tolerable(installed.output)) {
-        process.stderr.write(installed.output);
-        return 1;
-    }
-    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 --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');
-    return Promise.resolve(0);
-}

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

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