@stage-labs/metro 0.1.0-beta.30 → 0.1.0-beta.32

package/dist/api.js

@@ -1,4 +1,4 @@
-import { metroUrl, readToken } from './store.js';
+import { metroUrl, readRunTokens, readToken } from './store.js';
 export class NotSignedIn extends Error {
 }
 const TIMEOUT_MS = 20_000;
@@ -18,11 +18,15 @@ export function carriesSecretsSafely(base) {
 function tokenOrThrow() {
     if (!carriesSecretsSafely(metroUrl()))
         throw new Error(`refusing to send your session to ${metroUrl()} in the clear — use https, or a loopback address`);
-    const token = readToken();
+    const token = readToken() ?? soleRunToken();
     if (token === null)
-        throw new NotSignedIn('not signed in — run `metro login` first');
+        throw new NotSignedIn('not signed in — run `metro login`, or `metro start <agent-id>` on this machine');
     return token;
 }
+function soleRunToken() {
+    const tokens = readRunTokens();
+    return tokens.length === 1 ? (tokens[0] ?? null) : null;
+}
 async function get(path) {
     const auth = tokenOrThrow();
     let res;
@@ -36,7 +40,7 @@ async function get(path) {
         throw new Error(`could not reach ${metroUrl()}`);
     }
     if (res.status === 401)
-        throw new NotSignedIn('that sign-in has expired — run `metro login` again');
+        throw new NotSignedIn("metro refused this machine's sign-in — run `metro login` again");
     if (!res.ok)
         throw new Error(`metro answered ${String(res.status)}`);
     return res.json();
@@ -98,13 +102,9 @@ export async function claimCode(code) {
     if (!isRecord(body) ||
         typeof body.token !== 'string' ||
         typeof body.email !== 'string' ||
-        typeof body.collection !== 'string')
+        typeof body.agent !== 'string')
         throw new Error('metro returned an unexpected response');
-    return {
-        token: body.token,
-        email: body.email,
-        collection: body.collection,
-    };
+    return { token: body.token, email: body.email, agent: body.agent };
 }
 export async function claimRuntime(code, label) {
     const body = await post('/api/run/claim', { code, label });
@@ -125,7 +125,7 @@ export async function whoisAuthorized() {
     const body = await get('/api/cli/session');
     if (!isRecord(body) ||
         typeof body.email !== 'string' ||
-        typeof body.collection !== 'string')
+        typeof body.agent !== 'string')
         throw new Error('metro returned an unexpected response');
-    return { email: body.email, collection: body.collection };
+    return { email: body.email, agent: body.agent };
 }

package/dist/bedrock.js

@@ -25,9 +25,11 @@ export function settingsFiles(cwd = process.cwd(), env = process.env) {
     const explicit = env.CLAUDE_CONFIG_DIR?.trim() ?? '';
     const configDir = explicit === '' ? join(homedir(), '.claude') : explicit;
     return [
-        join(configDir, 'settings.json'),
-        join(cwd, '.claude', 'settings.json'),
-        join(cwd, '.claude', 'settings.local.json'),
+        ...new Set([
+            join(configDir, 'settings.json'),
+            join(cwd, '.claude', 'settings.json'),
+            join(cwd, '.claude', 'settings.local.json'),
+        ]),
     ];
 }
 function envBlock(file) {

package/dist/cli.js

@@ -10,11 +10,15 @@ 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>]
+                  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
   metro stop [agent-id]
                   stop every metro daemon on this machine, however it was started
   metro status <agent-id>
@@ -23,10 +27,11 @@ const USAGE = `metro — the command line for your MCP connectors
                   show the detached daemon's log
   metro tail <agent-id>
                   follow this machine's inbound events, one JSON line each
-  metro login     authorize a connector collection with a code from the web UI
+  metro login [code]
+                  authorize this machine for one agent with a code from its page
   metro logout    forget this machine's sign-in
-  metro whoami    print the account and collection this machine may read
-  metro mcp       print the mcpServers block for the authorized collection
+  metro whoami    print the account and agent this machine may read
+  metro mcp       print the mcpServers block of the authorized agent's connectors
   metro plugin    set up the Claude Code plugin (connector servers + /metro:login)
   metro claude [args...]
                   open Claude Code with the metro channel; every argument is passed through
@@ -42,7 +47,8 @@ Start Claude Code with all of them, without writing them to disk:
 
   METRO_URL          the metro to talk to (default https://mcp.metro.box)
   METRO_UI_URL       where the web UI lives (default https://metro.box)
-  METRO_TOKEN        use this connector sign-in instead of the stored one
+  METRO_TOKEN        use this agent sign-in instead of the stored one; with neither,
+                     a machine running metro start uses its run token
   METRO_RUN_TOKEN    use this runtime authorization instead of the stored one
   METRO_BEDROCK_MODEL
                      send every request to this Bedrock model id (default: derive from the
@@ -109,23 +115,28 @@ function logs(argv) {
     const agentId = assertAgentId(argv[0]);
     return tail(agentId, argv.includes('-f') || argv.includes('--follow'));
 }
-async function login() {
-    process.stderr.write(`Choose a connector collection at ${metroWebUrl()}/#/authorize\n`);
-    const { token, email, collection } = await claimCode(await askSecret('Paste the code here (input is hidden): '));
+async function pastedCode(given) {
+    if (given !== undefined && given.trim() !== '')
+        return given.trim();
+    process.stderr.write(`Get a pairing code from the agent's page, or pick the agent at ${metroWebUrl()}/#/authorize\n`);
+    return askSecret('Paste the code here (input is hidden): ');
+}
+async function login(given) {
+    const { token, email, agent } = await claimCode(await pastedCode(given));
     writeToken(token);
-    process.stderr.write(`Authorized '${collection}' for ${email}. Stored in ${credentialsPath()}\n`);
+    process.stderr.write(`Authorized '${agent}' for ${email}. Stored in ${credentialsPath()}\n`);
     if (syncPluginServers())
         process.stderr.write('Claude Code plugin refreshed — new sessions have the connectors; ' +
             'run /reload-plugins in any session already open.\n');
 }
 async function whoami() {
-    const { email, collection } = await whoisAuthorized();
-    process.stdout.write(`${email} · collection '${collection}' on ${metroUrl()}\n`);
+    const { email, agent } = await whoisAuthorized();
+    process.stdout.write(`${email} · agent '${agent}' on ${metroUrl()}\n`);
 }
 const HELP = new Set([undefined, 'help', '--help', '-h']);
 const COMMANDS = {
     login: async () => {
-        await login();
+        await login(process.argv[3]);
         return 0;
     },
     logout: async () => {
@@ -138,6 +149,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,57 @@
+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>]';
+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();
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i] ?? '';
+        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 };
+}
+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(),
+        },
+    };
+}
+export function serve(argv) {
+    const { port } = parseServeArgs(argv);
+    const plan = servePlan({ dir: runtimeDir(), port });
+    process.stderr.write(`Starting a metro daemon of your own on http://127.0.0.1:${String(port)}\n`);
+    return spawnPlan(plan);
+}

package/dist/store.js

@@ -1,4 +1,4 @@
-import { chmodSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { chmodSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 const DEFAULT_BASE = 'https://mcp.metro.box';
@@ -21,10 +21,10 @@ function configDir() {
 export function credentialsPath() {
     return join(configDir(), 'credentials.json');
 }
-function readStored() {
+function readStoredAt(path) {
     let raw;
     try {
-        raw = readFileSync(credentialsPath(), 'utf8');
+        raw = readFileSync(path, 'utf8');
     }
     catch {
         return null;
@@ -43,6 +43,29 @@ function readStored() {
         return null;
     return { token, url: typeof url === 'string' ? url : DEFAULT_BASE };
 }
+const readStored = () => readStoredAt(credentialsPath());
+const RUN_TOKEN_FILE = /^runtime-[A-Za-z0-9_-]{11}\.json$/;
+export function readRunTokens() {
+    const fromEnv = process.env.METRO_RUN_TOKEN?.trim();
+    if (fromEnv !== undefined && fromEnv !== '')
+        return [fromEnv];
+    let names;
+    try {
+        names = readdirSync(configDir());
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of names) {
+        if (!RUN_TOKEN_FILE.test(name))
+            continue;
+        const stored = readStoredAt(join(configDir(), name));
+        if (stored !== null && stored.url === metroUrl())
+            out.push(stored.token);
+    }
+    return out;
+}
 export function readToken() {
     const fromEnv = process.env.METRO_TOKEN?.trim();
     if (fromEnv !== undefined && fromEnv !== '')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.30",
+  "version": "0.1.0-beta.32",
   "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,13 +49,11 @@ export interface AgentApiDeps extends AccountApiDeps {
     unavailable: string[];
   }>;
   capabilities: () => Record<string, string[]>;
+  attachable?: string[];
   liveness: () => Map<string, { connected: boolean; lastSeenAt: number }>;
-  mintRuntimeCode: (
-    email: string,
-    agentId: string,
-  ) => Promise<{ code: string; expiresAt: 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[]>>;
 }
 
 type Routable =
@@ -134,12 +132,14 @@ function agentPayload(
   agent: AgentSummary,
   live: Map<string, { connected: boolean; lastSeenAt: number }>,
   runtimes: Map<string, string>,
+  connectors: Map<string, string[]>,
 ): Record<string, unknown> {
   return {
     id: agent.id,
     name: agent.name,
     owned: agent.owned,
     runtime: agent.owned ? (runtimes.get(agent.id) ?? null) : null,
+    connector_ids: connectors.get(agent.id) ?? [],
     ...livenessPayload(agent, live),
     ...keyPayload(agent),
   };
@@ -161,17 +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)),
+    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,14 +191,9 @@ async function handleRuntime(
   session: ApiSession,
   id: string,
 ): Promise<void> {
-  if (req.method === 'DELETE') {
-    await deps.releaseRuntime(session.email, id);
-    log.info({ agent: id }, 'agent-api: runtime released');
-    sendJson(req, res, 200, { agent: id, runtime: null });
-    return;
-  }
-  const minted = await deps.mintRuntimeCode(session.email, id);
-  sendJson(req, res, 201, minted);
+  await deps.releaseRuntime(session.subject, id);
+  log.info({ agent: id }, 'agent-api: runtime released');
+  sendJson(req, res, 200, { agent: id, runtime: null });
 }
 
 async function handleCreate(
@@ -213,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, {
@@ -232,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, {
@@ -252,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 });
@@ -286,7 +282,7 @@ const ALLOWED: Record<AgentTarget['kind'], string[]> = {
   collection: ['GET', 'POST'],
   agent: ['DELETE'],
   key: ['POST'],
-  runtime: ['POST', 'DELETE'],
+  runtime: ['DELETE'],
 };
 
 function methodAllowed(tgt: Routable, method: string | undefined): boolean {

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

@@ -0,0 +1,150 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from './log.js';
+import {
+  apiFailure,
+  apiSession,
+  bodyField,
+  cors,
+  readJsonBody,
+  sendJson,
+  type ApiSession,
+} from './api-http.js';
+import { parseId } from '../db/ids.js';
+import type { AgentConnectors } from '../db/agent-connectors.js';
+
+const PREFIX = '/api/agents';
+
+export interface AgentConnectorApiDeps {
+  agentConnectors: (subject: string, agentId: string) => Promise<AgentConnectors>;
+  addConnector: (
+    subject: string,
+    agentId: string,
+    connectorId: string,
+  ) => Promise<AgentConnectors>;
+  removeConnector: (
+    subject: string,
+    agentId: string,
+    connectorId: string,
+  ) => Promise<AgentConnectors>;
+  mintCode: (
+    subject: string,
+    agentId: string,
+  ) => Promise<{ code: string; expiresAt: number; agent: string }>;
+}
+
+type Routable =
+  | { kind: 'connectors'; id: string }
+  | { kind: 'connector'; id: string; connectorId: string }
+  | { kind: 'code'; id: string };
+
+type Target = Routable | { kind: 'unknown' } | null;
+
+const ALLOWED: Record<Routable['kind'], string[]> = {
+  connectors: ['GET', 'POST'],
+  connector: ['DELETE'],
+  code: ['POST'],
+};
+
+function connectorTarget(id: string, rest: string[]): Target {
+  if (rest.length === 1) return { kind: 'connectors', id };
+  if (rest.length > 2) return { kind: 'unknown' };
+  const connectorId = parseId(rest[1] ?? '');
+  return connectorId === null
+    ? { kind: 'unknown' }
+    : { kind: 'connector', id, connectorId };
+}
+
+export function target(path: string): Target {
+  if (!path.startsWith(`${PREFIX}/`)) return null;
+  const segments = path.slice(PREFIX.length + 1).split('/').filter(Boolean);
+  const id = parseId(segments[0] ?? '');
+  const head = segments[1];
+  if (id === null || head === undefined) return null;
+  if (head === 'connectors') return connectorTarget(id, segments.slice(1));
+  if (head === 'code' && segments.length === 2) return { kind: 'code', id };
+  return null;
+}
+
+async function handleConnectors(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AgentConnectorApiDeps,
+  session: ApiSession,
+  id: string,
+): Promise<void> {
+  if (req.method === 'GET') {
+    sendJson(req, res, 200, await deps.agentConnectors(session.subject, id));
+    return;
+  }
+  const connectorId = bodyField(await readJsonBody(req), 'connectorId');
+  if (typeof connectorId !== 'string' || parseId(connectorId) === null) {
+    sendJson(req, res, 400, { error: 'connectorId is required' });
+    return;
+  }
+  sendJson(req, res, 200, await deps.addConnector(session.subject, id, connectorId));
+}
+
+async function handleCode(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AgentConnectorApiDeps,
+  session: ApiSession,
+  id: string,
+): Promise<void> {
+  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);
+}
+
+async function route(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AgentConnectorApiDeps,
+  session: ApiSession,
+  tgt: Routable,
+): Promise<void> {
+  try {
+    if (tgt.kind === 'connectors') await handleConnectors(req, res, deps, session, tgt.id);
+    else if (tgt.kind === 'code') await handleCode(req, res, deps, session, tgt.id);
+    else
+      sendJson(
+        req,
+        res,
+        200,
+        await deps.removeConnector(session.subject, tgt.id, tgt.connectorId),
+      );
+  } catch (err) {
+    apiFailure(req, res, err, 'agent-api');
+  }
+}
+
+export function handleAgentConnectorRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AgentConnectorApiDeps,
+): boolean {
+  const tgt = target((req.url ?? '').split('?')[0] ?? '');
+  if (tgt === null) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (tgt.kind === 'unknown') {
+    sendJson(req, res, 404, { error: 'no such connector' });
+    return true;
+  }
+  if (!ALLOWED[tgt.kind].includes(req.method ?? '')) {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  const session = apiSession(req);
+  if (!session) {
+    sendJson(req, res, 401, { error: 'unauthorized' });
+    return true;
+  }
+  route(req, res, deps, session, tgt).catch((err: unknown) => {
+    log.warn({ err: errMsg(err) }, 'agent-api: unhandled error');
+    if (!res.headersSent) sendJson(req, res, 500, { error: 'agent api failed' });
+  });
+  return true;
+}

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

@@ -0,0 +1,20 @@
+import { makeCodeStore } from './pair-codes.js';
+
+export interface AgentCode {
+  subject: string;
+  agentId: string;
+}
+
+const store = makeCodeStore<AgentCode>('ma');
+
+export const AGENT_CODE_RE = store.pattern;
+
+export const mintAgentCode = (
+  entry: AgentCode,
+  now?: number,
+): { code: string; expiresAt: number } => store.mint(entry, now);
+
+export const takeAgentCode = (code: string, now?: number): AgentCode | undefined =>
+  store.take(code, now);
+
+export const agentCodeCount = (): number => store.count();