@stage-labs/metro 0.1.0-beta.39 → 0.1.0-beta.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.39",
+  "version": "0.1.0-beta.40",
   "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/node_modules/@metro-labs/mcp/src/daemon/boot.ts

@@ -83,6 +83,7 @@ import {
   deleteConnectorForUser,
   disconnectConnectorForUser,
   connectorNamesByIds,
+  connectorSummariesByIds,
   getConnectorForUser,
   listConnectorsForUser,
   renameConnectorForUser,
@@ -276,6 +277,7 @@ const projectApi: ProjectApiDeps = {
 const connectorApi: ConnectorApiDeps = {
   listConnectors: listConnectorsForUser,
   connectorNamesByIds,
+  connectorSummariesByIds,
   agentConnectors: agentConnectorsForUser,
   fenceRuntime,
   renameConnector: renameConnectorForUser,

package/runtime/node_modules/@metro-labs/mcp/src/daemon/cli-pair-api.ts

@@ -20,11 +20,13 @@ import type { ConnectorApiDeps } from './connector-api.js';
 const CLAIM_PATH = '/api/cli/claim';
 const MCP_PATH = '/api/cli/mcp';
 const SESSION_PATH = '/api/cli/session';
+const CONNECTORS_PATH = '/api/cli/connectors';
 
 const ALLOWED: Record<string, string> = {
   [CLAIM_PATH]: 'POST',
   [MCP_PATH]: 'GET',
   [SESSION_PATH]: 'GET',
+  [CONNECTORS_PATH]: 'GET',
 };
 
 function secretOrNull(): string | null {
@@ -94,6 +96,13 @@ async function handleRead(
     });
     return;
   }
+  if (path === CONNECTORS_PATH) {
+    sendJson(req, res, 200, {
+      agent: agent.name,
+      connectors: await deps.connectorSummariesByIds(agent.connectorIds),
+    });
+    return;
+  }
   const entries = await deps.connectorNamesByIds(agent.connectorIds);
   const json = relayServersJson(
     entries,

package/runtime/node_modules/@metro-labs/mcp/src/daemon/connector-api.ts

@@ -1,3 +1,4 @@
+import type { ConnectorSummary } from '../db/connectors.js';
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { errMsg, log } from './log.js';
 import {
@@ -36,6 +37,7 @@ const asText = (value: unknown): string =>
 
 export interface ConnectorApiDeps extends OAuthRouteDeps {
   listConnectors: (subject: string, project: string) => Promise<Connector[]>;
+  connectorSummariesByIds: (ids: string[]) => Promise<ConnectorSummary[]>;
   connectorNamesByIds: (ids: string[]) => Promise<RelayServerEntry[]>;
   agentConnectors: (subject: string, agentId: string) => Promise<AgentConnectors>;
   fenceRuntime: Fence;

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

@@ -0,0 +1,91 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { errMsg, log } from './log.js';
+import { configDir } from './paths.js';
+import { metroBaseUrl } from './agent-import.js';
+
+const FETCH_TIMEOUT_MS = 15_000;
+const CACHE_MS = 60_000;
+
+export interface HostedConnector {
+  id: string;
+  name: string;
+  url: string;
+  transport: string;
+  signIn: 'connected' | 'disconnected' | null;
+}
+
+export interface HostedCredential {
+  token: string;
+  url: string;
+}
+
+function readJsonFile(path: string): Record<string, unknown> | null {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'));
+    return typeof parsed === 'object' && parsed !== null ? (parsed as Record<string, unknown>) : null;
+  } catch {
+    return null;
+  }
+}
+
+function agentOfToken(token: string): string | null {
+  const body = token.split('.')[1];
+  if (body === undefined) return null;
+  try {
+    const claims = JSON.parse(Buffer.from(body, 'base64url').toString('utf8')) as { agent?: unknown };
+    return typeof claims.agent === 'string' ? claims.agent : null;
+  } catch {
+    return null;
+  }
+}
+
+function credential(file: Record<string, unknown> | null): HostedCredential | null {
+  if (file === null || typeof file.token !== 'string' || file.token === '') return null;
+  return { token: file.token, url: typeof file.url === 'string' && file.url !== '' ? file.url : metroBaseUrl() };
+}
+
+export function hostedCredentialFor(agentId: string, dir = configDir()): HostedCredential | null {
+  const runtime = join(dir, `runtime-${agentId}.json`);
+  if (existsSync(runtime)) return credential(readJsonFile(runtime));
+  const login = credential(readJsonFile(join(dir, 'credentials.json')));
+  return login !== null && agentOfToken(login.token) === agentId ? login : null;
+}
+
+const isConnector = (v: unknown): v is HostedConnector =>
+  typeof v === 'object' &&
+  v !== null &&
+  typeof (v as { id?: unknown }).id === 'string' &&
+  typeof (v as { name?: unknown }).name === 'string';
+
+async function fetchHosted(cred: HostedCredential): Promise<HostedConnector[]> {
+  const res = await fetch(`${cred.url}/api/cli/connectors`, {
+    headers: { authorization: `Bearer ${cred.token}` },
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+    redirect: 'manual',
+  });
+  if (!res.ok) throw new Error(`metro answered ${String(res.status)} for the connectors`);
+  const body = (await res.json()) as { connectors?: unknown };
+  return Array.isArray(body.connectors) ? body.connectors.filter(isConnector) : [];
+}
+
+const cache = new Map<string, { at: number; list: HostedConnector[] }>();
+
+export async function hostedConnectorsFor(agentId: string, dir = configDir()): Promise<HostedConnector[]> {
+  const hit = cache.get(agentId);
+  if (hit !== undefined && Date.now() - hit.at < CACHE_MS) return hit.list;
+  const cred = hostedCredentialFor(agentId, dir);
+  if (cred === null) return [];
+  try {
+    const list = await fetchHosted(cred);
+    cache.set(agentId, { at: Date.now(), list });
+    return list;
+  } catch (err) {
+    log.warn({ agent: agentId, err: errMsg(err) }, 'hosted connectors: unavailable, listing none');
+    return [];
+  }
+}
+
+export function forgetHostedConnectors(): void {
+  cache.clear();
+}

package/runtime/node_modules/@metro-labs/mcp/src/daemon/local-connectors-api.ts

@@ -0,0 +1,56 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from './log.js';
+import { apiSession, cors, sendJson } from './api-http.js';
+import type { HostedConnector } from './hosted-connectors.js';
+
+const PATH = '/api/connectors';
+
+export interface LocalConnectorsDeps {
+  listConnectors: (subject: string) => Promise<HostedConnector[]>;
+}
+
+const payload = (c: HostedConnector): Record<string, unknown> => ({
+  id: c.id,
+  name: c.name,
+  url: c.url,
+  transport: c.transport,
+  auth: c.signIn === null ? 'none' : 'oauth',
+  header: null,
+  signIn: c.signIn,
+  verified: null,
+  managed: 'metro.box',
+});
+
+export function handleLocalConnectorsRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: LocalConnectorsDeps,
+): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (path !== PATH && !path.startsWith(`${PATH}/`)) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (path !== PATH || req.method !== 'GET') {
+    sendJson(req, res, path === PATH ? 405 : 404, {
+      error: 'connectors are managed on metro.box, not on a local daemon',
+    });
+    return true;
+  }
+  const session = apiSession(req);
+  if (!session) {
+    sendJson(req, res, 401, { error: 'unauthorized' });
+    return true;
+  }
+  deps
+    .listConnectors(session.subject)
+    .then((list) => {
+      sendJson(req, res, 200, { connectors: list.map(payload) });
+    })
+    .catch((err: unknown) => {
+      log.warn({ err: errMsg(err) }, 'local connectors: request failed');
+      if (!res.headersSent) sendJson(req, res, 500, { error: 'connectors failed' });
+    });
+  return true;
+}

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

@@ -10,6 +10,7 @@ import type { SessionApis } from './session-apis.js';
 import type { ModeInfo } from './mode-api.js';
 import type { ImportApiDeps } from './import-api.js';
 import { fetchAgentWithCode } from './agent-import.js';
+import { forgetHostedConnectors, hostedConnectorsFor, type HostedConnector } from './hosted-connectors.js';
 import {
   assertLocalOwner,
   claimLocalOwner,
@@ -93,7 +94,7 @@ function agentApi(deps: LocalModeDeps): AgentApiDeps {
     liveness: deps.liveness,
     releaseRuntime: () => notHere('runtime leases'),
     runtimes: () => Promise.resolve(new Map()),
-    connectorIds: () => Promise.resolve(new Map()),
+    connectorIds: connectorIdsOfLocalAgents,
     prepareAccount: deps.prepareAccount,
     attachAccount: localAttachAccount,
     detachAccount: localDetachAccount,
@@ -123,10 +124,25 @@ const projectApi: ProjectApiDeps = {
   removeMember: () => notHere('members'),
 };
 
+async function connectorIdsOfLocalAgents(ids: string[]): Promise<Map<string, string[]>> {
+  const pairs = await Promise.all(
+    ids.map(async (id) => [id, (await hostedConnectorsFor(id)).map((c) => c.id)] as const),
+  );
+  return new Map(pairs);
+}
+
+async function connectorsOfOwner(subject: string): Promise<HostedConnector[]> {
+  const agents = await localListAgents(subject, LOCAL_PROJECT_ID).catch(() => []);
+  const lists = await Promise.all(agents.map((a) => hostedConnectorsFor(a.id)));
+  const seen = new Map<string, HostedConnector>();
+  for (const c of lists.flat()) seen.set(c.id, c);
+  return [...seen.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
 const agentConnectorApi: AgentConnectorApiDeps = {
   agentConnectors: async (subject, id) => {
     const { agent } = await localOwnedAgentOrThrow(subject, id);
-    return { ...agent, connectorIds: [] };
+    return { ...agent, connectorIds: (await hostedConnectorsFor(id)).map((c) => c.id) };
   },
   addConnector: () => notHere('connectors'),
   removeConnector: () => notHere('connectors'),
@@ -141,6 +157,7 @@ function importApi(deps: LocalModeDeps): ImportApiDeps {
       assertLocalOwner(subject);
       const agent = await fetchAgent(code, hostname());
       const made = await localImportAgent(subject, agent);
+      forgetHostedConnectors();
       for (const station of new Set(agent.accounts.map((a) => a.station)))
         await deps.syncStations(station).catch((err: unknown) => {
           log.warn(
@@ -162,6 +179,7 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     agentApi: agentApi(deps),
     agentConnectorApi,
     importApi: importApi(deps),
+    localConnectors: { listConnectors: connectorsOfOwner },
     projectApi,
     siwe: { ensureUser: claimLocalOwner },
     mode: localModeInfo,

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

@@ -18,12 +18,17 @@ import {
 } from './agent-connector-api.js';
 import type { SiweRouteDeps } from './siwe-routes.js';
 import { handleImportRequest, type ImportApiDeps } from './import-api.js';
+import {
+  handleLocalConnectorsRequest,
+  type LocalConnectorsDeps,
+} from './local-connectors-api.js';
 import type { ModeInfo } from './mode-api.js';
 
 export interface SessionApis {
   agentApi?: AgentApiDeps;
   agentConnectorApi?: AgentConnectorApiDeps;
   importApi?: ImportApiDeps;
+  localConnectors?: LocalConnectorsDeps;
   connectorApi?: ConnectorApiDeps;
   projectApi?: ProjectApiDeps;
   runApi?: RunApiDeps;
@@ -38,6 +43,7 @@ export function handleSessionApis(
   apis: SessionApis,
 ): boolean {
   const { agentApi, agentConnectorApi, connectorApi, projectApi, runApi, importApi } = apis;
+  const { localConnectors } = apis;
   const routes: (() => boolean)[] = [() => handleSessionApiRequest(req, res)];
   if (runApi) routes.push(() => handleRunApiRequest(req, res, runApi));
   if (projectApi)
@@ -48,6 +54,8 @@ export function handleSessionApis(
       () => handleConnectorApiRequest(req, res, connectorApi),
     );
   if (importApi) routes.push(() => handleImportRequest(req, res, importApi));
+  if (localConnectors)
+    routes.push(() => handleLocalConnectorsRequest(req, res, localConnectors));
   if (agentConnectorApi)
     routes.push(() => handleAgentConnectorRequest(req, res, agentConnectorApi));
   if (agentApi) routes.push(() => handleAgentApiRequest(req, res, agentApi));

package/runtime/node_modules/@metro-labs/mcp/src/db/connectors.ts

@@ -139,6 +139,24 @@ async function rowsByIds(ids: string[]): Promise<ConnectorRow[]> {
     .orderBy(asc(connectors.id));
 }
 
+export interface ConnectorSummary {
+  id: string;
+  name: string;
+  url: string;
+  transport: string;
+  signIn: ConnectorSignIn;
+}
+
+export async function connectorSummariesByIds(ids: string[]): Promise<ConnectorSummary[]> {
+  return (await rowsByIds(ids)).map((row) => ({
+    id: row.id,
+    name: row.name,
+    url: row.url,
+    transport: row.transport,
+    signIn: signInState(readConfig(row.config)),
+  }));
+}
+
 export async function connectorNamesByIds(
   ids: string[],
 ): Promise<{ id: string; name: string }[]> {

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.39"
+  "version": "0.1.0-beta.40"
 }