@stage-labs/metro 0.1.0-beta.169 → 0.1.0-beta.170

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.169",
+  "version": "0.1.0-beta.170",
   "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/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.169",
+  "version": "0.1.0-beta.170",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

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

@@ -1,4 +1,3 @@
-import { webhookPort } from '../net/tunnel.js';
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { parseId } from '@metro-labs/core/ids';
 import { log } from '@metro-labs/core/log';
@@ -63,20 +62,6 @@ export function target(path: string): Target {
   return id === null ? { kind: 'unknown' } : subTarget(id, segments.slice(1));
 }
 
-const localMcpEndpoint = (): string => `http://127.0.0.1:${String(webhookPort())}/mcp`;
-
-interface KeyPayload {
-  key: string | null;
-  endpoint: string | null;
-}
-
-const credentials = (key: string): KeyPayload => ({ key, endpoint: `${localMcpEndpoint()}?token=${key}` });
-
-function keyPayload(agent: AgentSummary): KeyPayload {
-  const value = agent.owned ? agent.key : null;
-  return value === null ? { key: null, endpoint: null } : credentials(value);
-}
-
 function livenessPayload(
   agent: AgentSummary,
   live: Map<string, { connected: boolean; lastSeenAt: number }>,
@@ -100,7 +85,6 @@ function agentPayload(
     owned: agent.owned,
     connector_ids: connectors.get(agent.id) ?? [],
     ...livenessPayload(agent, live),
-    ...keyPayload(agent),
   };
 }
 

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

@@ -1,6 +1,6 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { errMsg, log } from '@metro-labs/core/log';
-import { apiFailure, apiSession, cors, readJsonBody, sendJson } from '@metro-labs/http/api-http';
+import { apiFailure, apiSession, cors, readJsonBody, requireAdmin, sendJson } from '@metro-labs/http/api-http';
 import { ApiError } from '@metro-labs/http/api-error';
 import { isRecord } from '@metro-labs/core/is-record';
 import { parseId } from '@metro-labs/core/ids';
@@ -14,14 +14,14 @@ const STATION_NAMES = new Set<string>(STATIONS);
 
 export interface AgentBundle {
   version: 1;
-  agent: { id: string; name: string; key: string; stations: LoadedAccount[] };
+  agent: { id: string; name: string; stations: LoadedAccount[] };
   connectors: LoadedConnector[];
 }
 
 export const loadedAgentOf = (bundle: AgentBundle): LoadedAgent => ({
   id: bundle.agent.id,
   name: bundle.agent.name,
-  key: bundle.agent.key,
+  key: null,
   accounts: bundle.agent.stations,
   connectors: [],
 });
@@ -67,11 +67,10 @@ function connectorOf(raw: unknown): LoadedConnector {
 
 function agentOf(raw: unknown): AgentBundle['agent'] {
   if (!isRecord(raw)) throw bad('not a v1 agent bundle');
-  const { id, name, key, stations } = raw;
+  const { id, name, stations } = raw;
   if (typeof id !== 'string' || parseId(id) === null) throw bad('agent id is not an id');
-  if (typeof key !== 'string' || key === '') throw bad('agent has no key');
   if (!Array.isArray(stations)) throw bad('agent has no station list');
-  return { id, name: typeof name === 'string' ? name : '', key, stations: stations.map(stationOf) };
+  return { id, name: typeof name === 'string' ? name : '', stations: stations.map(stationOf) };
 }
 
 export function parseBundle(raw: unknown): AgentBundle {
@@ -106,6 +105,7 @@ export function handleBundleRequest(req: IncomingMessage, res: ServerResponse, d
   apiSession(req)
     .then((session) => {
       if (!session) throw new ApiError('unauthorized', 401);
+      requireAdmin(session);
       return answer(req, deps, session.subject, path);
     })
     .then((body) => {

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

@@ -174,15 +174,13 @@ export function assertLocalOwner(subject: string, dir = agentsDir()): void {
   if (!isOwner(subject, dir)) throw new AgentAdminError('no such project', 404);
 }
 
-function assertImportable(agent: LoadedAgent): asserts agent is LoadedAgent & { key: string } {
+function assertImportable(agent: LoadedAgent): void {
   const immovable = agent.accounts.find((a) => !MOVABLE_STATIONS.has(a.station));
   if (immovable !== undefined)
     throw new AgentAdminError(
       `a ${immovable.station} endpoint needs a public url and cannot live on a local daemon`,
       400,
     );
-  if (agent.key === null)
-    throw new AgentAdminError('that agent has no key; reset it on metro.box first', 400);
 }
 
 interface ImportTarget {
@@ -190,7 +188,7 @@ interface ImportTarget {
   previous: AgentFile | undefined;
 }
 
-function importTarget(dir: string, agent: LoadedAgent & { key: string }): ImportTarget {
+function importTarget(dir: string, agent: LoadedAgent): ImportTarget {
   const existing = storedAgents(dir);
   const same = existing.find((s) => s.file.id === agent.id);
   if (same === undefined && existing.length > 0)
@@ -210,15 +208,15 @@ export async function localImportAgent(
   assertLocalOwner(subject, dir);
   assertImportable(agent);
   const { path, previous } = importTarget(dir, agent);
-  const file = fileFor(agent, localOwner(dir), path, previous, mode);
+  const key = previous?.key ?? agent.key ?? newApiKey();
+  const file = fileFor({ ...agent, key }, localOwner(dir), path, previous, mode);
   ensureSecureDir(join(path, '..'));
   save({ path, file });
-  if (previous !== undefined && previous.key !== agent.key) unregisterAgentKey(agent.id);
-  registerKey(agent.key, agent.id);
+  registerKey(key, agent.id);
   return Promise.resolve({
     id: agent.id,
     name: agent.name,
-    key: agent.key,
+    key,
     stations: file.stations.length,
   });
 }

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

@@ -18,7 +18,6 @@ import {
   startWebhookServer,
   trainEventToMetroEvent,
 } from '../routes/http.js';
-import { localAgentKey } from '../stations/materialize.js';
 import { agentsDir, fileSource } from '../agents/files.js';
 import { syncPluginServers } from '../connectors/plugin-sync.js';
 import { readLocalConnectors } from '../connectors/store.js';
@@ -36,7 +35,6 @@ import {
   agentLiveness,
   createMetroMcp,
 } from '../mcp/index.js';
-import { metroCall } from '../mcp/ctx.js';
 import { gatherAccountsForAgents } from '../mcp/accounts.js';
 import {
   accountStationCapabilities,
@@ -80,15 +78,6 @@ function announceLocalEndpoint(): void {
   process.stderr.write(
     `\n${tunnel === null ? localConnectHint(webhookPort(), localOwner()) : tunnelPendingHint()}`,
   );
-  const key = localAgentKey();
-  if (key === null) {
-    log.info('no agent on this machine yet');
-    return;
-  }
-  const url = `http://127.0.0.1:${String(webhookPort())}/mcp?token=${key}`;
-  process.stderr.write(
-    `\nConnect an agent on this machine:\n\n  claude mcp add --transport http metro "${url}"\n\n`,
-  );
 }
 
 async function syncStations(station: StationName): Promise<void> {
@@ -135,7 +124,7 @@ installBearerSessions(agentsDir(), localOwner);
     emit,
     sessionApis(),
     metroMcp.httpHandler,
-    metroCall,
+    true,
   );
   metroMcp.startInbound();
   syncPluginServers(readLocalConnectors());

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

@@ -143,7 +143,7 @@ async function created(req: IncomingMessage, path: string, dir: string): Promise
   return createClaudeSkill(body.name, typeof body.text === 'string' ? body.text : undefined, dir);
 }
 
-const ADMIN_ONLY = /^\/(login|session|version|setup)(\/|$)/;
+const ADMIN_ONLY = /^\/api\/claude\/(login|session|version|setup)(\/|$)/;
 const LOGIN = 'login';
 const SESSION = 'session';
 const SETUP = 'setup';

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

@@ -1,30 +1,21 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import { stationByName } from '../stations/registry.js';
 import { errMsg, log } from '@metro-labs/core/log';
 import { subscribeEvents, type MetroEvent } from '@metro-labs/core/events';
-import { callTargetDenied, eventInScope } from '../agents/scope.js';
+import { eventInScope } from '../agents/scope.js';
 import { hasAnyKey } from '../agents/keys.js';
 import {
   allowedAgents,
   authenticate,
 } from '../mcp/request-identity.js';
-import { METRO_VERSION } from '@metro-labs/core/version';
-
-export type MonitorCall = (
-  train: string,
-  action: string,
-  args: Record<string, unknown>,
-) => Promise<{ result: unknown }>;
 
 const KEEPALIVE_MS = 25_000;
-const CALL_BODY_MAX = 256 * 1024;
 
 const monitorEnabled = (): boolean => hasAnyKey();
 
 function cors(req: IncomingMessage): Record<string, string> {
   return {
     'access-control-allow-origin': req.headers.origin ?? '*',
-    'access-control-allow-methods': 'GET, POST, OPTIONS',
+    'access-control-allow-methods': 'GET, OPTIONS',
     'access-control-allow-headers': 'Authorization, Content-Type',
     'access-control-max-age': '86400',
     vary: 'Origin',
@@ -41,33 +32,6 @@ function sendJson(
   res.end(JSON.stringify(body));
 }
 
-function parseCallArgs(raw: string): Record<string, unknown> {
-  if (!raw) return {};
-  const parsed = JSON.parse(raw) as { args?: unknown };
-  const value =
-    parsed && typeof parsed === 'object' && 'args' in parsed
-      ? parsed.args
-      : parsed;
-  if (!value || typeof value !== 'object' || Array.isArray(value))
-    throw new Error('call body must be a JSON object');
-  return value as Record<string, unknown>;
-}
-
-async function readCallArgs(
-  req: IncomingMessage,
-): Promise<Record<string, unknown>> {
-  const chunks: Buffer[] = [];
-  let total = 0;
-  for await (const chunk of req) {
-    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk as string);
-    total += buf.length;
-    if (total > CALL_BODY_MAX)
-      throw new Error(`request body exceeds ${CALL_BODY_MAX} bytes`);
-    chunks.push(buf);
-  }
-  return parseCallArgs(Buffer.concat(chunks).toString('utf8').trim());
-}
-
 function startTailStream(
   req: IncomingMessage,
   res: ServerResponse,
@@ -122,67 +86,12 @@ function startTailStream(
   req.on('error', cleanup);
 }
 
-async function handleCall(
-  req: IncomingMessage,
-  res: ServerResponse,
-  train: string,
-  action: string,
-  call: MonitorCall,
-  allowed: Set<string>,
-): Promise<void> {
-  let args: Record<string, unknown>;
-  try {
-    args = await readCallArgs(req);
-  } catch (err) {
-    sendJson(res, req, 400, { error: `bad JSON body: ${errMsg(err)}` });
-    return;
-  }
-  if (callTargetDenied(allowed, train, args)) {
-    sendJson(res, req, 403, {
-      error: 'metro: this account is outside your authorized scope',
-    });
-    return;
-  }
-  if (stationByName(train)?.hasTrain === false) {
-    sendJson(res, req, 400, {
-      error: `metro: station '${train}' runs in-core and takes no calls`,
-    });
-    return;
-  }
-  try {
-    const { result } = await call(train, action, args);
-    sendJson(res, req, 200, { result });
-  } catch (err) {
-    sendJson(res, req, 502, { error: errMsg(err) });
-  }
-}
-
 function routeApi(
   req: IncomingMessage,
   res: ServerResponse,
   path: string,
-  call: MonitorCall,
   allowed: Set<string>,
 ): void {
-  const callMatch = /^\/api\/call\/([^/]+)\/([^/]+)$/.exec(path);
-  if (callMatch) {
-    if (req.method !== 'POST') {
-      sendJson(res, req, 405, { error: 'method not allowed' });
-      return;
-    }
-    handleCall(
-      req,
-      res,
-      callMatch[1] ?? '',
-      callMatch[2] ?? '',
-      call,
-      allowed,
-    ).catch((err: unknown) => {
-      log.warn({ err: errMsg(err) }, 'monitor: call handler error');
-      if (!res.headersSent) sendJson(res, req, 500, { error: errMsg(err) });
-    });
-    return;
-  }
   if (path === '/api/tail') {
     if (req.method !== 'GET') {
       sendJson(res, req, 405, { error: 'method not allowed' });
@@ -194,11 +103,7 @@ function routeApi(
   sendJson(res, req, 404, { error: 'not found' });
 }
 
-function preflight(
-  req: IncomingMessage,
-  res: ServerResponse,
-  path: string,
-): boolean {
+function preflight(req: IncomingMessage, res: ServerResponse): boolean {
   if (!monitorEnabled()) {
     sendJson(res, req, 404, { error: 'not found' });
     return true;
@@ -207,31 +112,21 @@ function preflight(
     res.writeHead(204, cors(req)).end();
     return true;
   }
-  if (req.method === 'GET' && path === '/api/health') {
-    sendJson(res, req, 200, {
-      ok: true,
-      service: 'metro',
-      version: METRO_VERSION,
-      uptime_s: Math.round(process.uptime()),
-    });
-    return true;
-  }
   return false;
 }
 
 export function handleMonitorRequest(
   req: IncomingMessage,
   res: ServerResponse,
-  call: MonitorCall,
 ): boolean {
   const path = (req.url ?? '').split('?', 2)[0] ?? '';
   if (!path.startsWith('/api/')) return false;
-  if (preflight(req, res, path)) return true;
+  if (preflight(req, res)) return true;
   const identity = authenticate(req);
   if (!identity) {
     sendJson(res, req, 401, { error: 'unauthorized' });
     return true;
   }
-  routeApi(req, res, path, call, allowedAgents(identity));
+  routeApi(req, res, path, allowedAgents(identity));
   return true;
 }

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

@@ -38,7 +38,6 @@ import { handleModeRequest } from '@metro-labs/http/mode-api';
 import { handleUploadRequest } from '../files/upload-api.js';
 import {
   handleMonitorRequest,
-  type MonitorCall,
 } from '../monitor/api.js';
 import { applyMcpCors, handleMcpPreflight } from '@metro-labs/http/cors';
 import { METRO_VERSION } from '@metro-labs/core/version';
@@ -181,11 +180,11 @@ export async function startWebhookServer(
   emit: Emit,
   apis: SessionApis = {},
   mcp?: McpHandler,
-  monitorCall?: MonitorCall,
+  monitor = false,
 ): Promise<Server> {
   const port = webhookPort();
   const server = createServer((req, res) => {
-    handleRequest(req, res, emit, apis, mcp, monitorCall).catch(
+    handleRequest(req, res, emit, apis, mcp, monitor).catch(
       (err: unknown) => {
       log.warn({ err: errMsg(err) }, 'webhook handler error');
       if (!res.headersSent) res.writeHead(500).end();
@@ -340,7 +339,7 @@ async function handlePreMcpRoutes(
   res: ServerResponse,
   emit: Emit,
   apis: SessionApis,
-  monitorCall?: MonitorCall,
+  monitor = false,
 ): Promise<boolean> {
   if (handleEarlyRoutes(req, res, apis)) return true;
   if (handleUploadRequest(req, res)) return true;
@@ -348,7 +347,7 @@ async function handlePreMcpRoutes(
   if (apis.relayApi && handleRelayRequest(req, res, apis.relayApi)) return true;
   if (await handleWebhookRoute(req, res, emit)) return true;
   if (await handleThreemaCallback(req, res)) return true;
-  return Boolean(monitorCall && handleMonitorRequest(req, res, monitorCall));
+  return monitor && handleMonitorRequest(req, res);
 }
 
 async function handleRequest(
@@ -357,9 +356,9 @@ async function handleRequest(
   emit: Emit,
   apis: SessionApis = {},
   mcp?: McpHandler,
-  monitorCall?: MonitorCall,
+  monitor = false,
 ): Promise<void> {
-  if (await handlePreMcpRoutes(req, res, emit, apis, monitorCall)) return;
+  if (await handlePreMcpRoutes(req, res, emit, apis, monitor)) return;
   if (mcp && isMcpPath(req)) {
     applyMcpCors(req, res);
     if (handleMcpPreflight(req, res)) return;

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

@@ -143,14 +143,13 @@ const relayApi: RelayApiDeps = {
 function bundleApi(deps: LocalModeDeps): BundleApiDeps {
   return {
     bundle: async (subject, agentId) => {
-      const { agent } = await localOwnedAgentOrThrow(subject, agentId);
+      await localOwnedAgentOrThrow(subject, agentId);
       const file = readLocalAgentFile(agentId);
       const bundle: AgentBundle = {
         version: 1,
-        agent: { id: file.id, name: file.name ?? '', key: file.key ?? '', stations: file.stations },
+        agent: { id: file.id, name: file.name ?? '', stations: file.stations },
         connectors: readLocalConnectors().map((c) => ({ id: c.id, name: c.name, url: c.url, transport: c.transport, config: { ...c.config } })),
       };
-      if (bundle.agent.key === '') throw new ApiError(`agent ${agent.id} has no key to bundle`, 400);
       return bundle;
     },
     restore: async (subject, bundle, mode) => {

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

@@ -200,7 +200,6 @@ const stationLabels = (m: Map<StationName, number>): string[] =>
   [...m].map(([station, n]) => `${station}(${n})`);
 
 function applyKeyMap(list: LoadedAgent[]): void {
-  lastKey = list.find((a) => a.key !== null)?.key ?? null;
   setKeyMap(
     list.flatMap((agent) =>
       agent.key === null ? [] : [{ key: agent.key, agentId: agent.id }],
@@ -208,12 +207,6 @@ function applyKeyMap(list: LoadedAgent[]): void {
   );
 }
 
-let lastKey: string | null = null;
-
-export function localAgentKey(): string | null {
-  return lastKey;
-}
-
 async function loadAndWrite(
   source: StationSource,
 ): Promise<WrittenStations & { agents: number }> {

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.169"
+  "version": "0.1.0-beta.170"
 }