@stage-labs/metro 0.1.0-beta.84 → 0.1.0-beta.85

package/package.json

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

@@ -19,7 +19,10 @@ import {
   trainEventToMetroEvent,
 } from '../routes/http.js';
 import { localAgentKey } from '../stations/materialize.js';
-import { fileSource } from '../agents/files.js';
+import { agentsDir, fileSource } from '../agents/files.js';
+import { ConnectorAggregate } from '../connectors/aggregate.js';
+import { setConnectorToolProvider } from '../mcp/connector-tools.js';
+import { invalidateToolSchema } from '../mcp/tool-dispatch.js';
 import { applyLocalOwner } from './local-owner.js';
 import { localOwner } from '../agents/file-admin.js';
 import { ensureStationDeps } from '../stations/runtime-deps.js';
@@ -29,6 +32,7 @@ import {
   agentLiveness,
   closeAgentSession,
   createMetroMcp,
+  announceToolSchemaToAll,
 } from '../mcp/index.js';
 import { metroCall } from '../mcp/ctx.js';
 import { gatherAccountsForAgents } from '../mcp/accounts.js';
@@ -114,6 +118,22 @@ function sessionApis(): SessionApis {
     });
 }
 
+let connectors: ConnectorAggregate | null = null;
+
+function startConnectors(): void {
+  const aggregate = new ConnectorAggregate(agentsDir(), () => {
+    invalidateToolSchema();
+    announceToolSchemaToAll();
+  });
+  connectors = aggregate;
+  setConnectorToolProvider({
+    list: () => aggregate.list(),
+    owns: (name) => aggregate.owns(name),
+    call: (name, args) => aggregate.call(name, args),
+  });
+  aggregate.start();
+}
+
 async function main(): Promise<void> {
   applyLocalOwner();
   await materializeFrom(fileSource, { allowEmpty: true });
@@ -126,6 +146,7 @@ async function main(): Promise<void> {
     metroCall,
   );
   metroMcp.startInbound();
+  startConnectors();
   startUploadReaper();
   announceLocalEndpoint();
   tunnel?.start();
@@ -145,6 +166,7 @@ async function shutdown(): Promise<void> {
   if (shuttingDown) return;
   shuttingDown = true;
   log.info('dispatcher shutting down');
+  connectors?.stop();
   tunnel?.stop();
   if (webhookServer) {
     const server = webhookServer;

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

@@ -0,0 +1,199 @@
+import { watch, type FSWatcher } from 'node:fs';
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg, log } from '@metro-labs/core/log';
+import type { ToolResult } from '@metro-labs/core/stations/types';
+import { signInState } from './config.js';
+import type { RelayTarget } from './relay-target.js';
+import { localRelayTarget, readLocalConnectors, type LocalConnectorRow } from './store.js';
+import { UpstreamClient, type UpstreamTool } from './upstream.js';
+
+const SEP = '__';
+const SLUG_MAX = 24;
+const NAME_MAX = 64;
+const WATCH_DEBOUNCE_MS = 300;
+const CONNECTORS_FILE = 'connectors.json';
+
+export interface ConnectorToolView {
+  name: string;
+  description: string;
+  inputSchema: unknown;
+  annotations?: unknown;
+}
+
+interface Entry {
+  row: LocalConnectorRow;
+  stamp: string;
+  slug: string;
+  client: UpstreamClient;
+  tools: UpstreamTool[];
+}
+
+type TargetOf = (connectorId: string, force: boolean, dir: string) => Promise<RelayTarget>;
+
+export function slugOf(name: string): string {
+  const slug = name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .slice(0, SLUG_MAX)
+    .replace(/_+$/, '');
+  return slug === '' ? 'connector' : slug;
+}
+
+const stampOf = (row: LocalConnectorRow): string =>
+  JSON.stringify([row.name, row.url, row.config.auth.kind, row.config.verified.at, row.config.oauth]);
+
+const toolName = (slug: string, tool: string): string => `${slug}${SEP}${tool}`.slice(0, NAME_MAX);
+
+const textBlock = (text: string): { type: 'text'; text: string } => ({ type: 'text', text });
+
+function blockOf(block: unknown): { type: 'text'; text: string } {
+  if (isRecord(block) && block.type === 'text' && typeof block.text === 'string') return textBlock(block.text);
+  const kind = isRecord(block) && typeof block.type === 'string' ? block.type : 'unknown';
+  return textBlock(`[${kind} block omitted by metro]`);
+}
+
+export function toToolResult(raw: unknown): ToolResult {
+  if (isRecord(raw) && Array.isArray(raw.content)) {
+    const content = raw.content.map(blockOf);
+    return raw.isError === true ? { content, isError: true } : { content };
+  }
+  return { content: [textBlock(JSON.stringify(raw ?? null))] };
+}
+
+function dedupeSlugs(entries: Map<string, Entry>): void {
+  const bySlug = new Map<string, Entry[]>();
+  for (const entry of entries.values()) bySlug.set(entry.slug, [...(bySlug.get(entry.slug) ?? []), entry]);
+  for (const group of bySlug.values()) {
+    if (group.length < 2) continue;
+    for (const entry of group) entry.slug = `${entry.slug}_${entry.row.id.toLowerCase().replace(/[^a-z0-9]/g, '').slice(0, 4)}`;
+  }
+}
+
+export class ConnectorAggregate {
+  private entries = new Map<string, Entry>();
+  private watcher: FSWatcher | null = null;
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private loading: Promise<void> | null = null;
+
+  constructor(
+    private readonly dir: string,
+    private readonly onChange: () => void,
+    private readonly targetOf: TargetOf = localRelayTarget,
+  ) {}
+
+  start(): void {
+    try {
+      this.watcher = watch(this.dir, (_event, file) => {
+        if (file === null || file === CONNECTORS_FILE) this.schedule();
+      });
+      this.watcher.on('error', (err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'connectors: watcher failed; tools refresh on the next daemon start');
+      });
+      this.watcher.unref();
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'connectors: could not watch the agents dir');
+    }
+    this.schedule(0);
+  }
+
+  stop(): void {
+    this.watcher?.close();
+    this.watcher = null;
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = null;
+  }
+
+  private schedule(ms = WATCH_DEBOUNCE_MS): void {
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.reload().catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'connectors: reload failed');
+      });
+    }, ms);
+    this.timer.unref();
+  }
+
+  reload(): Promise<void> {
+    this.loading ??= this.load().finally(() => {
+      this.loading = null;
+    });
+    return this.loading;
+  }
+
+  private async load(): Promise<void> {
+    const rows = readLocalConnectors(this.dir).filter((row) => signInState(row.config) !== 'disconnected');
+    const next = new Map<string, Entry>();
+    const jobs: Promise<void>[] = [];
+    for (const row of rows) {
+      const stamp = stampOf(row);
+      const kept = this.entries.get(row.id);
+      if (kept?.stamp === stamp && kept !== undefined) {
+        next.set(row.id, kept);
+        continue;
+      }
+      const entry: Entry = { row, stamp, slug: slugOf(row.name), client: new UpstreamClient((force) => this.targetOf(row.id, force, this.dir)), tools: [] };
+      next.set(row.id, entry);
+      jobs.push(this.fill(entry));
+    }
+    await Promise.all(jobs);
+    dedupeSlugs(next);
+    const before = this.signature();
+    this.entries = next;
+    if (this.signature() !== before) this.onChange();
+  }
+
+  private async fill(entry: Entry): Promise<void> {
+    try {
+      entry.tools = await entry.client.listTools();
+      log.info({ connector: entry.row.name, tools: entry.tools.length }, 'connectors: tools listed');
+    } catch (err) {
+      log.warn({ connector: entry.row.name, err: errMsg(err) }, 'connectors: tools not listed; the connector has no tools until it answers');
+    }
+  }
+
+  signature(): string {
+    return JSON.stringify([...this.entries.values()].map((e) => [e.row.id, e.slug, e.tools.map((t) => t.name)]).sort());
+  }
+
+  list(): ConnectorToolView[] {
+    const out: ConnectorToolView[] = [];
+    for (const entry of [...this.entries.values()].sort((a, b) => a.slug.localeCompare(b.slug)))
+      for (const tool of entry.tools)
+        out.push({
+          name: toolName(entry.slug, tool.name),
+          description: tool.description === '' ? `${entry.row.name}: ${tool.name}` : `${tool.description} (${entry.row.name})`,
+          inputSchema: tool.inputSchema,
+          ...(tool.annotations === undefined ? {} : { annotations: tool.annotations }),
+        });
+    return out;
+  }
+
+  private resolve(name: string): { entry: Entry; tool: UpstreamTool } | null {
+    const at = name.indexOf(SEP);
+    if (at <= 0) return null;
+    const slug = name.slice(0, at);
+    for (const entry of this.entries.values()) {
+      if (entry.slug !== slug) continue;
+      const tool = entry.tools.find((t) => toolName(slug, t.name) === name);
+      return tool === undefined ? null : { entry, tool };
+    }
+    return null;
+  }
+
+  owns(name: string): boolean {
+    return this.resolve(name) !== null;
+  }
+
+  async call(name: string, args: Record<string, unknown>): Promise<ToolResult> {
+    const found = this.resolve(name);
+    if (found === null) return { content: [textBlock(`metro: no connector serves ${name}`)], isError: true };
+    try {
+      return toToolResult(await found.entry.client.callTool(found.tool.name, args));
+    } catch (err) {
+      log.warn({ connector: found.entry.row.name, tool: found.tool.name, err: errMsg(err) }, 'connectors: tool call failed');
+      return { content: [textBlock(`metro: connector ${found.entry.row.name} ${errMsg(err)}`)], isError: true };
+    }
+  }
+}

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

@@ -0,0 +1,172 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg } from '@metro-labs/core/log';
+import type { RelayTarget } from './relay-target.js';
+
+const ACCEPT = 'application/json, text/event-stream';
+const PROTOCOL = '2025-11-25';
+const MAX_PAGES = 10;
+const LIST_MS = 15_000;
+const CALL_MS = 120_000;
+
+export interface UpstreamTool {
+  name: string;
+  description: string;
+  inputSchema: unknown;
+  annotations: unknown;
+}
+
+export type TargetOf = (force: boolean) => Promise<RelayTarget>;
+
+export class UpstreamRefused extends Error {}
+export class UpstreamFailed extends Error {}
+
+interface Live {
+  session: string | null;
+  protocol: string;
+}
+
+interface Answer {
+  status: number;
+  text: string;
+  contentType: string;
+  session: string | null;
+}
+
+function dataLines(text: string): string[] {
+  return text
+    .replace(/\r\n/g, '\n')
+    .split('\n')
+    .filter((line) => line.startsWith('data:'))
+    .map((line) => line.slice(5).trim());
+}
+
+function messageFor(answer: Answer, id: number): Record<string, unknown> | null {
+  const candidates = answer.contentType.includes('text/event-stream') ? dataLines(answer.text) : [answer.text];
+  for (const candidate of candidates) {
+    try {
+      const parsed: unknown = JSON.parse(candidate);
+      if (isRecord(parsed) && parsed.id === id) return parsed;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+function resultOf(answer: Answer, id: number): unknown {
+  const message = messageFor(answer, id);
+  if (message === null) throw new UpstreamFailed('answered without a result for the request');
+  if (isRecord(message.error)) {
+    const text = typeof message.error.message === 'string' ? message.error.message : JSON.stringify(message.error);
+    throw new UpstreamFailed(text);
+  }
+  return message.result;
+}
+
+const initializeBody = (id: number): unknown => ({
+  jsonrpc: '2.0',
+  id,
+  method: 'initialize',
+  params: { protocolVersion: PROTOCOL, capabilities: {}, clientInfo: { name: 'metro', version: '0.1.0' } },
+});
+
+function toolOf(raw: unknown): UpstreamTool | null {
+  if (!isRecord(raw) || typeof raw.name !== 'string' || raw.name === '') return null;
+  return {
+    name: raw.name,
+    description: typeof raw.description === 'string' ? raw.description : '',
+    inputSchema: isRecord(raw.inputSchema) ? raw.inputSchema : { type: 'object' },
+    annotations: isRecord(raw.annotations) ? raw.annotations : undefined,
+  };
+}
+
+export class UpstreamClient {
+  private live: Live | null = null;
+  private seq = 0;
+
+  constructor(private readonly target: TargetOf) {}
+
+  forget(): void {
+    this.live = null;
+  }
+
+  async listTools(): Promise<UpstreamTool[]> {
+    const tools: UpstreamTool[] = [];
+    let cursor = '';
+    for (let page = 0; page < MAX_PAGES; page += 1) {
+      const result = await this.rpc('tools/list', cursor === '' ? {} : { cursor }, LIST_MS);
+      if (!isRecord(result)) break;
+      if (Array.isArray(result.tools)) for (const raw of result.tools) {
+        const tool = toolOf(raw);
+        if (tool !== null) tools.push(tool);
+      }
+      const next = result.nextCursor;
+      if (typeof next !== 'string' || next === '' || next === cursor) break;
+      cursor = next;
+    }
+    return tools;
+  }
+
+  callTool(name: string, args: Record<string, unknown>): Promise<unknown> {
+    return this.rpc('tools/call', { name, arguments: args }, CALL_MS);
+  }
+
+  private async post(body: unknown, headers: Record<string, string>, force: boolean, ms: number): Promise<Answer> {
+    const target = await this.target(force);
+    if (target.kind === 'missing') throw new UpstreamRefused('this connector no longer exists on the daemon');
+    if (target.kind === 'signin') throw new UpstreamRefused('this connector needs signing in again on its page');
+    let res: Response;
+    try {
+      res = await fetch(target.url, {
+        method: 'POST',
+        redirect: 'manual',
+        signal: AbortSignal.timeout(ms),
+        headers: { 'content-type': 'application/json', accept: ACCEPT, ...target.headers, ...headers },
+        body: JSON.stringify(body),
+      });
+    } catch (err) {
+      throw new UpstreamFailed(`could not be reached (${errMsg(err)})`);
+    }
+    const text = await res.text().catch(() => '');
+    return { status: res.status, text, contentType: res.headers.get('content-type') ?? '', session: res.headers.get('mcp-session-id') };
+  }
+
+  private async withCredentialLadder(body: unknown, headers: Record<string, string>, ms: number): Promise<Answer> {
+    const first = await this.post(body, headers, false, ms);
+    if (first.status !== 401 && first.status !== 403) return first;
+    const again = await this.post(body, headers, true, ms);
+    if (again.status === 401 || again.status === 403) throw new UpstreamRefused('rejected the credential; sign in again on its page');
+    return again;
+  }
+
+  private async ensureSession(): Promise<Live> {
+    if (this.live !== null) return this.live;
+    const id = ++this.seq;
+    const answer = await this.withCredentialLadder(initializeBody(id), {}, LIST_MS);
+    if (answer.status >= 300) throw new UpstreamFailed(`answered ${String(answer.status)} to initialize`);
+    const result = resultOf(answer, id);
+    const protocol = isRecord(result) && typeof result.protocolVersion === 'string' ? result.protocolVersion : PROTOCOL;
+    this.live = { session: answer.session, protocol };
+    await this.post({ jsonrpc: '2.0', method: 'notifications/initialized' }, this.sessionHeaders(this.live), false, LIST_MS).catch(() => undefined);
+    return this.live;
+  }
+
+  private sessionHeaders(live: Live): Record<string, string> {
+    const headers: Record<string, string> = { 'mcp-protocol-version': live.protocol };
+    if (live.session !== null && live.session !== '') headers['mcp-session-id'] = live.session;
+    return headers;
+  }
+
+  private async rpc(method: string, params: unknown, ms: number): Promise<unknown> {
+    const live = await this.ensureSession();
+    const id = ++this.seq;
+    const body = { jsonrpc: '2.0', id, method, params };
+    let answer = await this.withCredentialLadder(body, this.sessionHeaders(live), ms);
+    if (answer.status === 404 && live.session !== null) {
+      this.live = null;
+      answer = await this.withCredentialLadder(body, this.sessionHeaders(await this.ensureSession()), ms);
+    }
+    if (answer.status >= 300) throw new UpstreamFailed(`answered ${String(answer.status)}${answer.text === '' ? '' : `: ${answer.text.slice(0, 200)}`}`);
+    return resultOf(answer, id);
+  }
+}

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

@@ -0,0 +1,31 @@
+import type { ToolResult } from '@metro-labs/core/stations/types';
+import { errResult } from './ctx.js';
+
+export interface ConnectorToolEntry {
+  name: string;
+  description: string;
+  inputSchema: unknown;
+  annotations?: unknown;
+}
+
+export interface ConnectorToolProvider {
+  list: () => ConnectorToolEntry[];
+  owns: (name: string) => boolean;
+  call: (name: string, args: Record<string, unknown>) => Promise<ToolResult>;
+}
+
+const NONE: ConnectorToolProvider = {
+  list: () => [],
+  owns: () => false,
+  call: (name) => Promise.resolve(errResult(`metro: no connector serves ${name}`)),
+};
+
+let provider: ConnectorToolProvider = NONE;
+
+export function setConnectorToolProvider(next: ConnectorToolProvider | null): void {
+  provider = next ?? NONE;
+}
+
+export const connectorToolList = (): ConnectorToolEntry[] => provider.list();
+export const isConnectorTool = (name: string): boolean => provider.owns(name);
+export const callConnectorTool = (name: string, args: Record<string, unknown>): Promise<ToolResult> => provider.call(name, args);

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

@@ -138,6 +138,10 @@ export function agentLiveness(): Map<string, AgentLiveness> {
   return activeRegistry?.liveness() ?? new Map<string, AgentLiveness>();
 }
 
+export function announceToolSchemaToAll(): void {
+  activeRegistry?.announceToolSchema();
+}
+
 export async function closeAgentSession(agentId: string): Promise<boolean> {
   const scopeKey = sessionScopeKey({ kind: 'agent', agentId });
   return (await activeRegistry?.closeScope(scopeKey)) ?? false;

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

@@ -61,6 +61,10 @@ export class SessionRegistry {
     return out;
   }
 
+  announceToolSchema(): void {
+    for (const session of this.byId.values()) session.announceToolSchema();
+  }
+
   forScope(scopeKey: string): McpSession | undefined {
     return this.byScope.get(scopeKey);
   }

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

@@ -165,7 +165,7 @@ export class McpSession {
     return this.issuedSchema !== toolSchemaSignature();
   }
 
-  private announceToolSchema(): void {
+  announceToolSchema(): void {
     if (!this.streamAttached) return;
     this.deliverSchemaNotice(
       () => this.server.sendToolListChanged(),

package/runtime/node_modules/@metro-labs/daemon/src/mcp/tool-dispatch.ts

@@ -31,6 +31,7 @@ import {
   type RequestIdentity,
 } from './request-identity.js';
 import { str } from '@metro-labs/core/str';
+import { callConnectorTool, connectorToolList, isConnectorTool } from './connector-tools.js';
 
 const STATION_TOOLS = new Map<
   string,
@@ -62,11 +63,16 @@ const toolList = (): { tools: unknown[] } => ({
       })),
     ),
     LIST_ACCOUNTS_TOOL,
+    ...connectorToolList(),
   ],
 });
 
 let schemaSignature: string | undefined;
 
+export function invalidateToolSchema(): void {
+  schemaSignature = undefined;
+}
+
 export const toolSchemaSignature = (): string => {
   schemaSignature ??= createHash('sha256')
     .update(JSON.stringify(toolList()))
@@ -149,6 +155,7 @@ async function runTool(
   const name = req.params.name;
   const a = req.params.arguments ?? {};
 
+  if (isConnectorTool(name)) return callConnectorTool(name, a);
   const identity = currentIdentity();
   if (name !== 'list_accounts' && scopeDenied(identity, name, a))
     return errResult('metro: this account is outside your authorized scope');

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.84"
+  "version": "0.1.0-beta.85"
 }