@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.33

package/dist/cli.js

@@ -10,11 +10,17 @@ import { launchClaude } from './claude.js';
 import { bedrock } from './bedrock.js';
 import { installPlugin, syncPluginServers } from './plugin.js';
 import { update } from './update.js';
+import { serve } from './serve.js';
 import { currentVersion } from './version.js';
 const USAGE = `metro — the command line for your MCP connectors
 
   metro start <agent-id> [--detach]
                   run that agent's stations on this machine
+  metro serve [--port <n>] [--tunnel]
+                  run a daemon of your own: its agents and stations live in ~/.metro/agents
+                  here, and metro.box manages it through the link it prints; --tunnel adds
+                  a public https address through a Cloudflare quick tunnel (needs
+                  cloudflared, no account) so the link works from anywhere
   metro stop [agent-id]
                   stop every metro daemon on this machine, however it was started
   metro status <agent-id>
@@ -145,6 +151,7 @@ const COMMANDS = {
         return 0;
     },
     start: () => start(process.argv.slice(3)),
+    serve: () => serve(process.argv.slice(3)),
     stop: () => stopDaemon(process.argv.slice(3)),
     status: () => status(process.argv.slice(3)),
     logs: () => logs(process.argv.slice(3)),

package/dist/runtime.js

@@ -6,7 +6,7 @@ import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { metroUrl } from './store.js';
 const AGENT_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{10}$/;
-const SERVER_ENTRY = join('node_modules', '@metro-labs', 'mcp', 'src', 'server.ts');
+export const SERVER_ENTRY = join('node_modules', '@metro-labs', 'mcp', 'src', 'server.ts');
 export class MissingRuntime extends Error {
 }
 export function runtimeDir() {
@@ -76,6 +76,9 @@ export function daemonPlan(opts) {
 }
 export function runDaemon(agentId, plan) {
     process.stderr.write(`Starting metro for ${agentId}\n`);
+    return spawnPlan(plan);
+}
+export function spawnPlan(plan) {
     const child = spawn(plan.command, plan.args, {
         cwd: plan.cwd,
         env: plan.env,

package/dist/serve.js

@@ -0,0 +1,73 @@
+import { spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { findBun, localPort, runtimeDir, SERVER_ENTRY, spawnPlan, } from './runtime.js';
+const SCRUBBED = new Set(['METRO_RUN_TOKEN', 'METRO_AGENT', 'DATABASE_URL']);
+const PORT_FLAG = /^--port=(.*)$/;
+const USAGE = 'usage: metro serve [--port <n>] [--tunnel]';
+function portOf(raw) {
+    const n = Number(raw);
+    if (raw === undefined || raw === '' || !Number.isInteger(n) || n < 1 || n > 65535)
+        throw new Error(`'${raw ?? ''}' is not a port — ${USAGE}`);
+    return n;
+}
+export function parseServeArgs(argv) {
+    let port = localPort();
+    let tunnel = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i] ?? '';
+        if (arg === '--tunnel') {
+            tunnel = true;
+            continue;
+        }
+        const inline = PORT_FLAG.exec(arg);
+        if (inline) {
+            port = portOf(inline[1]);
+            continue;
+        }
+        if (arg === '--port' || arg === '-p') {
+            port = portOf(argv[i + 1]);
+            i += 1;
+            continue;
+        }
+        throw new Error(`unknown argument '${arg}' — ${USAGE}`);
+    }
+    return { port, tunnel };
+}
+export function findCloudflared() {
+    const found = spawnSync('cloudflared', ['--version'], { stdio: 'ignore' });
+    if (found.error !== undefined || found.status !== 0)
+        throw new Error('metro serve --tunnel needs cloudflared, which is not on PATH.\n' +
+            'Install it with:  brew install cloudflared  (macOS), or from\n' +
+            'https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/downloads/');
+}
+export function serveStateDir() {
+    const xdg = process.env.XDG_CACHE_HOME?.trim();
+    const base = xdg === undefined || xdg === '' ? join(homedir(), '.cache') : xdg;
+    return join(base, 'metro', 'serve');
+}
+export function servePlan(opts) {
+    const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !SCRUBBED.has(key)));
+    return {
+        command: findBun(),
+        args: [SERVER_ENTRY],
+        cwd: opts.dir,
+        env: {
+            ...env,
+            METRO_MODE: 'local',
+            METRO_WEBHOOK_PORT: String(opts.port),
+            METRO_HTTP_HOST: process.env.METRO_HTTP_HOST ?? '127.0.0.1',
+            METRO_TRAINS_DIR: join(opts.dir, 'trains'),
+            METRO_STATE_DIR: process.env.METRO_STATE_DIR ?? serveStateDir(),
+            ...(opts.tunnel ? { METRO_TUNNEL: 'quick' } : {}),
+        },
+    };
+}
+export function serve(argv) {
+    const { port, tunnel } = parseServeArgs(argv);
+    if (tunnel)
+        findCloudflared();
+    const plan = servePlan({ dir: runtimeDir(), port, tunnel });
+    process.stderr.write(`Starting a metro daemon of your own on http://127.0.0.1:${String(port)}\n`);
+    return spawnPlan(plan);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.31",
+  "version": "0.1.0-beta.33",
   "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/package.json

@@ -54,6 +54,7 @@
     "pino": "^9.5.0",
     "pino-pretty": "^13.1.3",
     "postgres": "^3.4.5",
+    "viem": "2.52.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {

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

@@ -51,13 +51,13 @@ export interface AccountApiDeps {
   attachSessions: AttachSessionApi;
   prepareAccount: (input: AttachInput) => Promise<PreparedAccount>;
   attachAccount: (
-    email: string,
+    subject: string,
     agentId: string,
     station: StationName,
     config: Record<string, unknown>,
   ) => Promise<AccountRef>;
   detachAccount: (
-    email: string,
+    subject: string,
     agentId: string,
     station: StationName,
     accountId: string,
@@ -146,7 +146,7 @@ async function storeAccount(
 ): Promise<AccountRef> {
   try {
     return await deps.attachAccount(
-      session.email,
+      session.subject,
       agentId,
       station,
       prepared.config,
@@ -158,7 +158,7 @@ async function storeAccount(
 }
 
 function ownerOf(session: ApiSession, agentId: string): AttachOwner {
-  return { email: session.email, agentId };
+  return { subject: session.subject, agentId };
 }
 
 function asInput(body: unknown): Record<string, unknown> {
@@ -224,7 +224,7 @@ async function handleDetach(
   target: { station: StationName; accountId: string },
 ): Promise<void> {
   const ref = await deps.detachAccount(
-    session.email,
+    session.subject,
     agentId,
     target.station,
     target.accountId,

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

@@ -30,18 +30,18 @@ const PREFIX = '/api/agents';
 const SERVER_NAME = 'metro';
 
 export interface AgentApiDeps extends AccountApiDeps {
-  listAgents: (email: string, project: string) => Promise<AgentSummary[]>;
+  listAgents: (subject: string, project: string) => Promise<AgentSummary[]>;
   createAgent: (
-    email: string,
+    subject: string,
     project: string,
     name: string,
   ) => Promise<CreatedAgent>;
   deleteAgent: (
-    email: string,
+    subject: string,
     id: string,
   ) => Promise<DeletedAgent>;
   resetKey: (
-    email: string,
+    subject: string,
     id: string,
   ) => Promise<ResetAgentKey>;
   gatherAccounts: (allowed: Set<string>) => Promise<{
@@ -49,8 +49,9 @@ export interface AgentApiDeps extends AccountApiDeps {
     unavailable: string[];
   }>;
   capabilities: () => Record<string, string[]>;
+  attachable?: string[];
   liveness: () => Map<string, { connected: boolean; lastSeenAt: number }>;
-  releaseRuntime: (email: string, agentId: string) => Promise<void>;
+  releaseRuntime: (subject: string, agentId: string) => Promise<void>;
   runtimes: (agentIds: string[]) => Promise<Map<string, string>>;
   connectorIds: (agentIds: string[]) => Promise<Map<string, string[]>>;
 }
@@ -160,18 +161,18 @@ async function handleList(
     sendJson(req, res, 400, { error: 'a project is required' });
     return;
   }
-  const list = await deps.listAgents(session.email, project);
+  const list = await deps.listAgents(session.subject, project);
   const live = deps.liveness();
   const held = await deps.runtimes(
     list.filter((a) => a.owned).map((a) => a.id),
   );
   const connectors = await deps.connectorIds(list.map((a) => a.id));
   const base = {
-    email: session.email,
+    subject: session.subject,
     endpoint: mcpEndpoint(),
     agents: list.map((a) => agentPayload(a, live, held, connectors)),
     capabilities: deps.capabilities(),
-    attachable: ATTACHABLE,
+    attachable: deps.attachable ?? ATTACHABLE,
   };
   if (!wantsAccounts(req)) {
     sendJson(req, res, 200, base);
@@ -190,7 +191,7 @@ async function handleRuntime(
   session: ApiSession,
   id: string,
 ): Promise<void> {
-  await deps.releaseRuntime(session.email, id);
+  await deps.releaseRuntime(session.subject, id);
   log.info({ agent: id }, 'agent-api: runtime released');
   sendJson(req, res, 200, { agent: id, runtime: null });
 }
@@ -208,9 +209,9 @@ async function handleCreate(
     sendJson(req, res, 400, { error: 'a project is required' });
     return;
   }
-  const created = await deps.createAgent(session.email, project, name as string);
+  const created = await deps.createAgent(session.subject, project, name as string);
   log.info(
-    { agent: created.name, id: created.id, owner: session.email },
+    { agent: created.name, id: created.id, owner: session.subject },
     'agent-api: created agent',
   );
   sendJson(req, res, 201, {
@@ -227,9 +228,9 @@ async function handleResetKey(
   session: ApiSession,
   id: string,
 ): Promise<void> {
-  const reset = await deps.resetKey(session.email, id);
+  const reset = await deps.resetKey(session.subject, id);
   log.info(
-    { agent: reset.name, id: reset.id, owner: session.email },
+    { agent: reset.name, id: reset.id, owner: session.subject },
     'agent-api: reset agent key',
   );
   sendJson(req, res, 200, {
@@ -247,9 +248,9 @@ async function handleDelete(
   session: ApiSession,
   id: string,
 ): Promise<void> {
-  const gone = await deps.deleteAgent(session.email, id);
+  const gone = await deps.deleteAgent(session.subject, id);
   log.info(
-    { agent: gone.name, id: gone.id, owner: session.email },
+    { agent: gone.name, id: gone.id, owner: session.subject },
     'agent-api: deleted agent',
   );
   sendJson(req, res, 200, { id: gone.id, name: gone.name, deleted: true });

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

@@ -15,19 +15,19 @@ import type { AgentConnectors } from '../db/agent-connectors.js';
 const PREFIX = '/api/agents';
 
 export interface AgentConnectorApiDeps {
-  agentConnectors: (email: string, agentId: string) => Promise<AgentConnectors>;
+  agentConnectors: (subject: string, agentId: string) => Promise<AgentConnectors>;
   addConnector: (
-    email: string,
+    subject: string,
     agentId: string,
     connectorId: string,
   ) => Promise<AgentConnectors>;
   removeConnector: (
-    email: string,
+    subject: string,
     agentId: string,
     connectorId: string,
   ) => Promise<AgentConnectors>;
   mintCode: (
-    email: string,
+    subject: string,
     agentId: string,
   ) => Promise<{ code: string; expiresAt: number; agent: string }>;
 }
@@ -73,7 +73,7 @@ async function handleConnectors(
   id: string,
 ): Promise<void> {
   if (req.method === 'GET') {
-    sendJson(req, res, 200, await deps.agentConnectors(session.email, id));
+    sendJson(req, res, 200, await deps.agentConnectors(session.subject, id));
     return;
   }
   const connectorId = bodyField(await readJsonBody(req), 'connectorId');
@@ -81,7 +81,7 @@ async function handleConnectors(
     sendJson(req, res, 400, { error: 'connectorId is required' });
     return;
   }
-  sendJson(req, res, 200, await deps.addConnector(session.email, id, connectorId));
+  sendJson(req, res, 200, await deps.addConnector(session.subject, id, connectorId));
 }
 
 async function handleCode(
@@ -91,8 +91,8 @@ async function handleCode(
   session: ApiSession,
   id: string,
 ): Promise<void> {
-  const minted = await deps.mintCode(session.email, id);
-  log.info({ agent: id, email: session.email }, 'agent-api: minted pairing code');
+  const minted = await deps.mintCode(session.subject, id);
+  log.info({ agent: id, subject: session.subject }, 'agent-api: minted pairing code');
   sendJson(req, res, 201, minted);
 }
 
@@ -111,7 +111,7 @@ async function route(
         req,
         res,
         200,
-        await deps.removeConnector(session.email, tgt.id, tgt.connectorId),
+        await deps.removeConnector(session.subject, tgt.id, tgt.connectorId),
       );
   } catch (err) {
     apiFailure(req, res, err, 'agent-api');

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

@@ -1,7 +1,7 @@
 import { makeCodeStore } from './pair-codes.js';
 
 export interface AgentCode {
-  email: string;
+  subject: string;
   agentId: string;
 }
 

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

@@ -14,7 +14,7 @@ const BODY_MAX = 4 * 1024;
 const DRAIN_MAX = 2 * BODY_MAX;
 
 export interface ApiSession {
-  email: string;
+  subject: string;
 }
 
 export function cors(req: IncomingMessage): Record<string, string> {
@@ -22,6 +22,7 @@ export function cors(req: IncomingMessage): Record<string, string> {
     'access-control-allow-origin': req.headers.origin ?? '*',
     'access-control-allow-methods': 'GET, POST, PUT, DELETE, OPTIONS',
     'access-control-allow-headers': 'Authorization, Content-Type',
+    'access-control-allow-private-network': 'true',
     'access-control-max-age': '86400',
     vary: 'Origin',
   };
@@ -47,8 +48,8 @@ export function apiSession(req: IncomingMessage): ApiSession | null {
   const token = extractToken(req) ?? '';
   if (token === '') return null;
   try {
-    const { email } = verifySession(token, secret);
-    return { email: email.toLowerCase() };
+    const { subject } = verifySession(token, secret);
+    return { subject: subject.toLowerCase() };
   } catch {
     return null;
   }
@@ -61,7 +62,7 @@ export function runIdentity(req: IncomingMessage): RunClaims | null {
   if (token === '') return null;
   try {
     const claims = verifyRunToken(token, secret);
-    return { ...claims, email: claims.email.toLowerCase() };
+    return { ...claims, subject: claims.subject.toLowerCase() };
   } catch {
     return null;
   }
@@ -77,12 +78,12 @@ export function agentIdentity(req: IncomingMessage): AgentIdentity | null {
   const token = extractToken(req) ?? '';
   if (token === '') return null;
   try {
-    const { email, agentId } = verifyAgentToken(token, secret);
-    return { email: email.toLowerCase(), agentId };
+    const { subject, agentId } = verifyAgentToken(token, secret);
+    return { subject: subject.toLowerCase(), agentId };
   } catch {
     const run = runIdentity(req);
     if (run === null) return null;
-    return { email: run.email, agentId: run.agentId, runtimeId: run.runtimeId };
+    return { subject: run.subject, agentId: run.agentId, runtimeId: run.runtimeId };
   }
 }
 

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

@@ -14,7 +14,8 @@ import {
 import { attachmentOwner, recordAttachmentOwner } from './attach-owner.js';
 import { grantAllows, issueAttachmentGrant } from './attach-grant.js';
 import { errMsg, log } from './log.js';
-import { loadTunnelConfig, webhookPort } from './tunnel.js';
+import { configuredTunnelHost, currentTunnelUrl, webhookPort } from './tunnel.js';
+import { isLocalMode } from './paths.js';
 
 function authorized(req: IncomingMessage, name: string): boolean {
   const owner = attachmentOwner(name);
@@ -30,14 +31,17 @@ const DEFAULT_PUBLIC_BASE = 'https://mcp.metro.box';
 export function publicBaseUrl(): string | null {
   const env = process.env.METRO_PUBLIC_URL?.trim();
   if (env) return env.replace(/\/+$/, '');
-  const host = loadTunnelConfig()?.hostname;
+  const live = currentTunnelUrl();
+  if (live !== null) return live;
+  const host = configuredTunnelHost();
   return host ? `https://${host}` : null;
 }
 
+const servesLocally = (): boolean =>
+  (process.env.METRO_RUN_TOKEN?.trim() ?? '') !== '' || isLocalMode();
+
 const localBase = (): string | null =>
-  (process.env.METRO_RUN_TOKEN?.trim() ?? '') === ''
-    ? null
-    : `http://127.0.0.1:${String(webhookPort())}`;
+  servesLocally() ? `http://127.0.0.1:${String(webhookPort())}` : null;
 
 export const publicBaseOrDefault = (): string =>
   publicBaseUrl() ?? localBase() ?? DEFAULT_PUBLIC_BASE;

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

@@ -28,7 +28,7 @@ const MAX_PER_AGENT = 2;
 const MAX_TOTAL = 40;
 
 export interface AttachOwner {
-  email: string;
+  subject: string;
   agentId: string;
 }
 
@@ -109,7 +109,7 @@ export class AttachSessions {
   private own(owner: AttachOwner, attachId: string): Session {
     const session = this.sessions.get(attachId);
     if (
-      session?.owner.email !== owner.email ||
+      session?.owner.subject !== owner.subject ||
       session.owner.agentId !== owner.agentId
     )
       throw missing();