@stage-labs/metro 0.1.0-beta.53 → 0.1.0-beta.54

package/package.json

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

@@ -44,6 +44,7 @@
     "@metro-labs/whatsapp": "workspace:*",
     "@metro-labs/xmtp": "workspace:*",
     "@modelcontextprotocol/sdk": "^1.12.0",
+    "@noble/curves": "^1.9.7",
     "drizzle-kit": "^0.31.0",
     "drizzle-orm": "^0.44.0",
     "pino": "^9.5.0",

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

@@ -259,20 +259,20 @@ function methodAllowed(tgt: Routable, method: string | undefined): boolean {
   return ALLOWED[tgt.kind].includes(method ?? '');
 }
 
-function dispatch(
+async function dispatch(
   req: IncomingMessage,
   res: ServerResponse,
   deps: AgentApiDeps,
   tgt: Routable,
 ): Promise<void> {
-  const session = apiSession(req);
+  const session = await apiSession(req);
   if (!session) {
     sendJson(req, res, 401, { error: 'unauthorized' });
-    return Promise.resolve();
+    return;
   }
   if (tgt.kind === 'accounts')
-    return handleAccountRoute(req, res, deps, session, tgt.id, tgt.route);
-  return routeAgent(req, res, deps, session, tgt);
+    await handleAccountRoute(req, res, deps, session, tgt.id, tgt.route);
+  else await routeAgent(req, res, deps, session, tgt);
 }
 
 export function handleAgentApiRequest(

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

@@ -122,12 +122,15 @@ export function handleAgentConnectorRequest(
     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) => {
+  apiSession(req)
+    .then((session) => {
+      if (!session) {
+        sendJson(req, res, 401, { error: 'unauthorized' });
+        return;
+      }
+      return 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' });
   });

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

@@ -1,8 +1,8 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { ApiError } from './api-error.js';
 import { errMsg, log } from './log.js';
-import { verifySession } from './session.js';
-import { extractToken } from '../mcp/request-identity.js';
+import { signedIdentity } from './signed-identity.js';
+import { identitySubject } from './identity-registry.js';
 
 const BODY_MAX = 4 * 1024;
 
@@ -35,17 +35,10 @@ export function sendJson(
   res.end(JSON.stringify(body));
 }
 
-export function apiSession(req: IncomingMessage): ApiSession | null {
-  const secret = process.env.METRO_SESSION_SECRET?.trim() ?? '';
-  if (secret === '') return null;
-  const token = extractToken(req) ?? '';
-  if (token === '') return null;
-  try {
-    const { subject } = verifySession(token, secret);
-    return { subject: subject.toLowerCase() };
-  } catch {
-    return null;
-  }
+export async function apiSession(req: IncomingMessage): Promise<ApiSession | null> {
+  const address = await signedIdentity(req);
+  const subject = address === null ? undefined : identitySubject(address);
+  return subject === undefined ? null : { subject };
 }
 
 export interface AgentIdentity {

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

@@ -7,7 +7,6 @@ import {
 } from '../stations/attachments.js';
 import {
   allowedAgents,
-  authConfigFromEnv,
   authenticate,
   extractToken,
 } from '../mcp/request-identity.js';
@@ -21,7 +20,7 @@ function authorized(req: IncomingMessage, name: string): boolean {
   const owner = attachmentOwner(name);
   if (owner === undefined) return false;
   if (grantAllows(name, owner, extractToken(req) ?? '')) return true;
-  return allowedAgents(authenticate(req, authConfigFromEnv()) ?? undefined).has(
+  return allowedAgents(authenticate(req) ?? undefined).has(
     owner,
   );
 }

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

@@ -20,7 +20,6 @@ import {
 } from './http.js';
 import { localAgentKey } from '../db/materialize.js';
 import { fileSource } from '../db/file-source.js';
-import { ensureLocalSessionSecret } from './local-secret.js';
 import { applyLocalOwner } from './local-owner.js';
 import { localOwner } from '../db/file-admin.js';
 import { ensureStationDeps } from './runtime-deps.js';
@@ -119,7 +118,6 @@ async function sessionApis(): Promise<SessionApis> {
       prepareAccount,
     });
   const vault = await import('../db/vault.js');
-  const users = await import('../db/users.js');
   return {
     vaultApi: {
       list: vault.listVaultForOwner,
@@ -127,14 +125,12 @@ async function sessionApis(): Promise<SessionApis> {
       get: vault.getVaultForOwner,
       remove: vault.deleteVaultForOwner,
     },
-    siwe: { ensureUser: users.ensureUserByAddress },
     mode: hostedMode,
   };
 }
 
 async function main(): Promise<void> {
   if (isLocalMode()) {
-    ensureLocalSessionSecret();
     applyLocalOwner();
     await materializeFrom(fileSource, { allowEmpty: true });
   }

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

@@ -92,12 +92,11 @@ export function handleBundleRequest(req: IncomingMessage, res: ServerResponse, d
     sendJson(req, res, 405, { error: 'method not allowed' });
     return true;
   }
-  const session = apiSession(req);
-  if (!session) {
-    sendJson(req, res, 401, { error: 'unauthorized' });
-    return true;
-  }
-  answer(req, deps, session.subject, path)
+  apiSession(req)
+    .then((session) => {
+      if (!session) throw new ApiError('unauthorized', 401);
+      return answer(req, deps, session.subject, path);
+    })
     .then((body) => {
       sendJson(req, res, isRestore ? 201 : 200, body);
     })

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

@@ -77,13 +77,9 @@ export function handleClaudeRequest(
     sendJson(req, res, 405, { error: 'method not allowed' });
     return true;
   }
-  const session = apiSession(req);
-  if (!session) {
-    sendJson(req, res, 401, { error: 'unauthorized' });
-    return true;
-  }
-  Promise.resolve()
-    .then(() => {
+  apiSession(req)
+    .then((session) => {
+      if (!session) throw new ApiError('unauthorized', 401);
       deps.authorize(session.subject);
       return answer(req.method ?? 'GET', path, new URLSearchParams(search), (deps.dir ?? claudeDir)());
     })

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

@@ -265,7 +265,7 @@ const ALLOWED: Record<Routable['kind'], string[]> = {
   rename: ['POST'],
 };
 
-function dispatch(
+async function dispatch(
   req: IncomingMessage,
   res: ServerResponse,
   deps: ConnectorApiDeps,
@@ -273,14 +273,14 @@ function dispatch(
 ): Promise<void> {
   if (tgt.kind === 'callback') {
     handleCallback(req, res, deps);
-    return Promise.resolve();
+    return;
   }
-  const session = apiSession(req);
+  const session = await apiSession(req);
   if (!session) {
     sendJson(req, res, 401, { error: 'unauthorized' });
-    return Promise.resolve();
+    return;
   }
-  return route(req, res, deps, session, tgt);
+  await route(req, res, deps, session, tgt);
 }
 
 export function handleConnectorApiRequest(

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

@@ -4,7 +4,7 @@ import {
   type OAuthAuth,
   type OAuthTokens,
 } from './connector-verify.js';
-import { validateReturnTo } from './session-config.js';
+import { validateReturnTo } from './return-to.js';
 import {
   authorizeUrl,
   exchangeCode,

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

@@ -27,7 +27,7 @@ import {
 } from './tunnel.js';
 import { attachmentEventUrl, handleAttachRequest } from './attach-serve.js';
 import { webhookEntry } from '@metro-labs/webhook';
-import { handleSiweAuthRequest } from './siwe-routes.js';
+import { handleIdentityRequest } from './identity-routes.js';
 import { handleModeRequest } from './mode-api.js';
 import { handleUploadRequest } from './upload-api.js';
 import {
@@ -328,7 +328,7 @@ function handleSignInRoutes(
   res: ServerResponse,
   apis: SessionApis,
 ): boolean {
-  if (apis.siwe !== undefined && handleSiweAuthRequest(req, res, apis.siwe)) return true;
+  if (apis.identity !== undefined && handleIdentityRequest(req, res, apis.identity)) return true;
   return apis.mode !== undefined && handleModeRequest(req, res, apis.mode);
 }
 

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

@@ -0,0 +1,33 @@
+import { hkdfSync } from 'node:crypto';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { mapHashToField } from '@noble/curves/abstract/modular';
+import { privateKeyToAccount } from 'viem/accounts';
+
+export const ENCRYPTION_KEY_TYPED_DATA = {
+  domain: { name: 'metro', version: '1' },
+  types: {
+    EncryptionKey: [
+      { name: 'purpose', type: 'string' },
+      { name: 'keyVersion', type: 'uint256' },
+    ],
+  },
+  primaryType: 'EncryptionKey',
+  message: { purpose: 'encryption-key', keyVersion: 1n },
+} as const;
+
+const KEY_SALT = 'metro';
+const IDENTITY_INFO = 'vault-secp256k1';
+const KEY_HASH_BYTES = 48;
+
+const toHex = (bytes: Uint8Array): `0x${string}` =>
+  `0x${[...bytes].map((b) => b.toString(16).padStart(2, '0')).join('')}`;
+
+export function deriveIdentityKey(signature: `0x${string}`): `0x${string}` {
+  const ikm = Buffer.from(signature.slice(2), 'hex');
+  const hash = new Uint8Array(hkdfSync('sha256', ikm, KEY_SALT, IDENTITY_INFO, KEY_HASH_BYTES));
+  return toHex(mapHashToField(hash, secp256k1.CURVE.n));
+}
+
+export function deriveIdentityAddress(signature: `0x${string}`): string {
+  return privateKeyToAccount(deriveIdentityKey(signature)).address.toLowerCase();
+}

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

@@ -0,0 +1,13 @@
+const subjects = new Map<string, string>();
+
+export function authorizeIdentity(address: string, subject: string): void {
+  subjects.set(address.toLowerCase(), subject.toLowerCase());
+}
+
+export function identitySubject(address: string): string | undefined {
+  return subjects.get(address.toLowerCase());
+}
+
+export function resetIdentities(): void {
+  subjects.clear();
+}

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

@@ -0,0 +1,54 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { verifyTypedData } from 'viem';
+import { log } from './log.js';
+import { ApiError } from './api-error.js';
+import { apiFailure, bodyField, cors, readJsonBody, sendJson } from './api-http.js';
+import { ENCRYPTION_KEY_TYPED_DATA, deriveIdentityAddress } from './identity-key.js';
+import { authorizeIdentity } from './identity-registry.js';
+
+const PATH = '/auth/identity';
+const SIGNATURE_RE = /^0x[0-9a-fA-F]{130}$/;
+
+export interface IdentityRouteDeps {
+  owner: () => string | null;
+}
+
+async function register(req: IncomingMessage, deps: IdentityRouteDeps): Promise<{ address: string; owner: string }> {
+  const signature = bodyField(await readJsonBody(req), 'signature');
+  if (typeof signature !== 'string' || !SIGNATURE_RE.test(signature))
+    throw new ApiError('signature is required: the EncryptionKey signature of the owner wallet', 400);
+  const owner = deps.owner();
+  if (owner === null)
+    throw new ApiError('this machine has no owner yet: start it with metro serve --owner <address>', 403);
+  const ok = await verifyTypedData({
+    ...ENCRYPTION_KEY_TYPED_DATA,
+    address: owner as `0x${string}`,
+    signature: signature as `0x${string}`,
+  }).catch(() => false);
+  if (!ok) throw new ApiError('this machine belongs to another wallet', 403);
+  const address = deriveIdentityAddress(signature as `0x${string}`);
+  authorizeIdentity(address, owner);
+  log.info({ owner, identity: address }, 'identity: owner signed in');
+  return { address, owner };
+}
+
+export function handleIdentityRequest(req: IncomingMessage, res: ServerResponse, deps: IdentityRouteDeps): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (path !== PATH) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  if (req.method !== 'POST') {
+    sendJson(req, res, 405, { error: 'method not allowed' });
+    return true;
+  }
+  register(req, deps)
+    .then((body) => {
+      sendJson(req, res, 200, body);
+    })
+    .catch((err: unknown) => {
+      apiFailure(req, res, err, 'identity');
+    });
+  return true;
+}

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

@@ -44,7 +44,6 @@ import {
   localOwnedAgentOrThrow,
   localOwner,
   localResetAgentKey,
-  ownerSignIn,
   readLocalAgentFile,
 } from '../db/file-admin.js';
 import { listAgentFiles, readAgentFile } from '../db/file-source.js';
@@ -191,7 +190,7 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     localCli,
     claudeApi: { authorize: (subject) => { assertLocalOwner(subject); } },
     updateApi: { authorize: (subject) => { assertLocalOwner(subject); }, restart: deps.restart },
-    siwe: { ensureUser: ownerSignIn },
+    identity: { owner: localOwner },
     mode: localModeInfo,
   };
 }

package/runtime/node_modules/@metro-labs/mcp/src/daemon/{session-config.ts → return-to.ts}

@@ -1,4 +1,3 @@
-export const SESSION_TTL_SEC = 30 * 24 * 3600;
 const PREVIEW = /^([a-z0-9-]+--)?metro-ui\.netlify\.app$/;
 
 export function allowedWebHost(host: string): boolean {

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

@@ -1,5 +1,5 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import { apiSession, cors, sendJson } from './api-http.js';
+import { apiFailure, apiSession, cors, sendJson } from './api-http.js';
 
 const PATH = '/api/session';
 
@@ -17,11 +17,13 @@ export function handleSessionApiRequest(
     sendJson(req, res, 405, { error: 'method not allowed' });
     return true;
   }
-  const session = apiSession(req);
-  if (!session) {
-    sendJson(req, res, 401, { error: 'unauthorized' });
-    return true;
-  }
-  sendJson(req, res, 200, { subject: session.subject });
+  apiSession(req)
+    .then((session) => {
+      if (!session) sendJson(req, res, 401, { error: 'unauthorized' });
+      else sendJson(req, res, 200, { subject: session.subject });
+    })
+    .catch((err: unknown) => {
+      apiFailure(req, res, err, 'session');
+    });
   return true;
 }

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

@@ -10,7 +10,7 @@ import {
   handleAgentConnectorRequest,
   type AgentConnectorApiDeps,
 } from './agent-connector-api.js';
-import type { SiweRouteDeps } from './siwe-routes.js';
+import type { IdentityRouteDeps } from './identity-routes.js';
 import { handleLocalCliRequest, type LocalCliDeps } from './local-cli-api.js';
 import { handleClaudeRequest, type ClaudeApiDeps } from './claude-api.js';
 import type { ModeInfo } from './mode-api.js';
@@ -28,7 +28,7 @@ export interface SessionApis {
   claudeApi?: ClaudeApiDeps;
   connectorApi?: ConnectorApiDeps;
   relayApi?: RelayApiDeps;
-  siwe?: SiweRouteDeps;
+  identity?: IdentityRouteDeps;
   mode?: () => ModeInfo;
 }
 

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

@@ -0,0 +1,36 @@
+import type { IncomingMessage } from 'node:http';
+import { verifyMessage } from 'viem';
+import { normalizeAddress } from '../db/address.js';
+
+export const AUTH_SCHEME = 'Metro';
+const SKEW_MS = 5 * 60_000;
+const SIGNATURE_RE = /^0x[0-9a-fA-F]{130}$/;
+
+export const identityChallenge = (method: string, path: string, at: number): string =>
+  `metro-auth\n${method} ${path}\n${String(at)}`;
+
+export interface SignedHeader {
+  address: string;
+  at: number;
+  signature: `0x${string}`;
+}
+
+export function parseIdentityHeader(header: string): SignedHeader | null {
+  const [scheme, rawAddress, rawAt, signature] = header.trim().split(/\s+/);
+  if (scheme !== AUTH_SCHEME || rawAddress === undefined || rawAt === undefined || signature === undefined) return null;
+  const address = normalizeAddress(rawAddress);
+  const at = Number(rawAt);
+  if (address === null || !Number.isFinite(at) || !SIGNATURE_RE.test(signature)) return null;
+  return { address, at, signature: signature as `0x${string}` };
+}
+
+export async function signedIdentity(req: IncomingMessage, now = Date.now()): Promise<string | null> {
+  const proof = parseIdentityHeader(req.headers.authorization ?? '');
+  if (proof === null || Math.abs(now - proof.at) > SKEW_MS) return null;
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  const message = identityChallenge(req.method ?? '', path, proof.at);
+  const ok = await verifyMessage({ address: proof.address as `0x${string}`, message, signature: proof.signature }).catch(
+    () => false,
+  );
+  return ok ? proof.address : null;
+}

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

@@ -93,13 +93,10 @@ export function handleUpdateRequest(req: IncomingMessage, res: ServerResponse, d
     sendJson(req, res, 405, { error: 'method not allowed' });
     return true;
   }
-  const session = apiSession(req);
-  if (!session) {
-    sendJson(req, res, 401, { error: 'unauthorized' });
-    return true;
-  }
   Promise.resolve()
     .then(async (): Promise<unknown> => {
+      const session = await apiSession(req);
+      if (!session) throw new ApiError('unauthorized', 401);
       deps.authorize(session.subject);
       const bin = binOrThrow(deps);
       if (req.method === 'GET') return { ...(await check(bin)), running: METRO_VERSION };

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

@@ -4,7 +4,6 @@ import { guessMime } from '../stations/attachments.js';
 import { safeFileName } from '../stations/attach-inline.js';
 import {
   allowedAgents,
-  authConfigFromEnv,
   authenticate,
   extractToken,
 } from '../mcp/request-identity.js';
@@ -69,7 +68,7 @@ const query = (req: IncomingMessage, key: string): string | undefined =>
   new URL(req.url ?? '/', 'http://localhost').searchParams.get(key) ?? undefined;
 
 const identityScope = (req: IncomingMessage): Set<string> =>
-  allowedAgents(authenticate(req, authConfigFromEnv()) ?? undefined);
+  allowedAgents(authenticate(req) ?? undefined);
 
 function ownerFromScope(req: IncomingMessage, allowed: Set<string>): string {
   const requested = query(req, 'agent');

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

@@ -1,42 +1,12 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { errMsg, log } from './log.js';
-import { verifyMessage } from 'viem';
 import { apiFailure, cors, readJsonBody, sendJson } from './api-http.js';
-import { normalizeAddress } from '../db/address.js';
 import { parseId } from '../db/ids.js';
 import { ENVELOPE_MAX, type VaultBundle, type VaultEntry } from './vault-types.js';
+import { signedIdentity } from './signed-identity.js';
 
 const PREFIX = '/api/vault';
 const BODY_MAX = ENVELOPE_MAX + 64 * 1024;
-const SKEW_MS = 5 * 60_000;
-const SIGNATURE_RE = /^0x[0-9a-fA-F]{130}$/;
-
-export const vaultChallenge = (method: string, path: string, at: number): string =>
-  `metro-vault\n${method} ${path}\n${String(at)}`;
-
-interface VaultProof {
-  address: string;
-  at: number;
-  signature: `0x${string}`;
-}
-
-function parseVaultHeader(header: string): VaultProof | null {
-  const [scheme, rawAddress, rawAt, signature] = header.trim().split(/\s+/);
-  if (scheme !== 'Vault' || rawAddress === undefined || rawAt === undefined || signature === undefined) return null;
-  const address = normalizeAddress(rawAddress);
-  const at = Number(rawAt);
-  if (address === null || !Number.isFinite(at) || !SIGNATURE_RE.test(signature)) return null;
-  return { address, at, signature: signature as `0x${string}` };
-}
-
-export async function vaultIdentity(req: IncomingMessage, now = Date.now()): Promise<string | null> {
-  const proof = parseVaultHeader(req.headers.authorization ?? '');
-  if (proof === null || Math.abs(now - proof.at) > SKEW_MS) return null;
-  const path = (req.url ?? '').split('?')[0] ?? '';
-  const message = vaultChallenge(req.method ?? '', path, proof.at);
-  const ok = await verifyMessage({ address: proof.address as `0x${string}`, message, signature: proof.signature }).catch(() => false);
-  return ok ? proof.address : null;
-}
 
 export interface VaultApiDeps {
   list: (subject: string) => Promise<VaultEntry[]>;
@@ -64,7 +34,7 @@ async function route(
   tgt: { kind: 'index' } | { kind: 'bundle'; id: string },
 ): Promise<void> {
   try {
-    const owner = await vaultIdentity(req);
+    const owner = await signedIdentity(req);
     if (owner === null) {
       sendJson(req, res, 401, { error: 'unauthorized' });
       return;

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

@@ -54,16 +54,6 @@ export function setLocalOwner(raw: string, dir = agentsDir()): string {
   return address;
 }
 
-export function ownerSignIn(raw: string, dir = agentsDir()): Promise<string> {
-  const owner = localOwner(dir);
-  if (owner === null)
-    return Promise.reject(
-      new ApiError('this machine has no owner yet: start it with metro serve --owner <address>', 403),
-    );
-  if (owner !== normalizeAddress(raw))
-    return Promise.reject(new ApiError('this machine belongs to another wallet', 403));
-  return Promise.resolve(owner);
-}
 
 function isOwner(subject: string, dir: string): boolean {
   const owner = localOwner(dir);

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

@@ -4,12 +4,6 @@ import { STATIONS, type ConnectorTransport, type StationName } from './stations.
 
 export { STATIONS, type ConnectorTransport, type StationName };
 
-export const users = pgTable('users', {
-  id: text('id').primaryKey(),
-  email: text('email').unique(),
-  address: text('address').unique(),
-});
-
 export type ProjectRole = 'admin' | 'member';
 
 

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

@@ -5,7 +5,6 @@ import {
 } from '../daemon/http.js';
 import {
   allowedAgents,
-  authConfigFromEnv,
   authenticate,
   runWithIdentity,
   type RequestIdentity,
@@ -156,7 +155,7 @@ export async function createMetroMcp(): Promise<{
     req: IncomingMessage,
     res: ServerResponse,
   ): Promise<void> => {
-    const identity = authenticate(req, authConfigFromEnv());
+    const identity = authenticate(req);
     if (!identity) {
       res.writeHead(401).end('unauthorized');
       return;

package/runtime/node_modules/@metro-labs/mcp/src/mcp/request-identity.ts

@@ -1,6 +1,5 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import type { IncomingMessage } from 'node:http';
-import { verifySession } from '../daemon/session.js';
 import { agentIdForKey } from '../db/key-map.js';
 
 export type RequestIdentity =
@@ -20,14 +19,6 @@ export function currentIdentity(): RequestIdentity | undefined {
   return storage.getStore();
 }
 
-export interface AuthConfig {
-  sessionSecret: string;
-}
-
-export function authConfigFromEnv(): AuthConfig {
-  return { sessionSecret: process.env.METRO_SESSION_SECRET?.trim() ?? '' };
-}
-
 export function extractToken(req: IncomingMessage): string | undefined {
   const header = req.headers.authorization;
   if (header?.startsWith('Bearer ')) {
@@ -40,28 +31,11 @@ export function extractToken(req: IncomingMessage): string | undefined {
   return qt ?? undefined;
 }
 
-const looksLikeJwt = (token: string): boolean =>
-  /^[\w-]+\.[\w-]+\.[\w-]+$/.test(token);
-
-export function authenticate(
-  req: IncomingMessage,
-  cfg: AuthConfig,
-): RequestIdentity | null {
+export function authenticate(req: IncomingMessage): RequestIdentity | null {
   const token = extractToken(req);
   if (!token) return null;
-
   const agentId = agentIdForKey(token);
-  if (agentId !== undefined) return { kind: 'agent', agentId };
-
-  if (cfg.sessionSecret !== '' && looksLikeJwt(token)) {
-    try {
-      const { subject, agentIds } = verifySession(token, cfg.sessionSecret);
-      return { kind: 'session', subject, agentIds };
-    } catch {
-      return null;
-    }
-  }
-  return null;
+  return agentId === undefined ? null : { kind: 'agent', agentId };
 }
 
 export function allowedAgents(

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

@@ -6,7 +6,6 @@ import { callTargetDenied, eventInScope } from '../db/agent-scope.js';
 import { hasAnyKey } from '../db/key-map.js';
 import {
   allowedAgents,
-  authConfigFromEnv,
   authenticate,
 } from '../mcp/request-identity.js';
 import { METRO_VERSION } from '../daemon/version.js';
@@ -20,9 +19,7 @@ export type MonitorCall = (
 const KEEPALIVE_MS = 25_000;
 const CALL_BODY_MAX = 256 * 1024;
 
-function monitorEnabled(): boolean {
-  return hasAnyKey() || authConfigFromEnv().sessionSecret !== '';
-}
+const monitorEnabled = (): boolean => hasAnyKey();
 
 function cors(req: IncomingMessage): Record<string, string> {
   return {
@@ -230,7 +227,7 @@ export function handleMonitorRequest(
   const path = (req.url ?? '').split('?', 2)[0] ?? '';
   if (!path.startsWith('/api/')) return false;
   if (preflight(req, res, path)) return true;
-  const identity = authenticate(req, authConfigFromEnv());
+  const identity = authenticate(req);
   if (!identity) {
     sendJson(res, req, 401, { error: 'unauthorized' });
     return true;

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.53"
+  "version": "0.1.0-beta.54"
 }

package/runtime/stations.json

@@ -1,6 +1,7 @@
 {
   "core": {
     "@modelcontextprotocol/sdk": "^1.12.0",
+    "@noble/curves": "^1.9.7",
     "pino": "^9.5.0",
     "pino-pretty": "^13.1.3",
     "viem": "2.52.2",

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

@@ -1,21 +0,0 @@
-import { randomBytes } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { agentsDir } from '../db/file-source.js';
-import { ensureSecureDir, writeSecure } from './secure-fs.js';
-
-const SECRET_FILE = '.session-secret';
-
-export function ensureLocalSessionSecret(dir = agentsDir()): string {
-  const configured = process.env.METRO_SESSION_SECRET?.trim() ?? '';
-  if (configured !== '') return configured;
-  const path = join(dir, SECRET_FILE);
-  let secret = existsSync(path) ? readFileSync(path, 'utf8').trim() : '';
-  if (secret === '') {
-    secret = randomBytes(32).toString('base64url');
-    ensureSecureDir(dir);
-    writeSecure(path, `${secret}\n`);
-  }
-  process.env.METRO_SESSION_SECRET = secret;
-  return secret;
-}

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

@@ -1,96 +0,0 @@
-import { createHmac, timingSafeEqual } from 'node:crypto';
-import { ID_RE } from '../db/ids.js';
-
-export class SessionError extends Error {}
-
-const b64url = (buf: Buffer): string =>
-  buf
-    .toString('base64')
-    .replace(/\+/g, '-')
-    .replace(/\//g, '_')
-    .replace(/=+$/, '');
-
-const b64urlJson = (v: unknown): string =>
-  b64url(Buffer.from(JSON.stringify(v)));
-
-const decodeJson = (seg: string): unknown =>
-  JSON.parse(
-    Buffer.from(seg.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString(
-      'utf8',
-    ),
-  );
-
-const HEADER = b64urlJson({ alg: 'HS256', typ: 'JWT' });
-
-function sign(payload: Record<string, unknown>, secret: string): string {
-  if (secret === '') throw new SessionError('missing signing secret');
-  const body = b64urlJson(payload);
-  const data = `${HEADER}.${body}`;
-  const sig = b64url(createHmac('sha256', secret).update(data).digest());
-  return `${data}.${sig}`;
-}
-
-function verify(token: string, secret: string): Record<string, unknown> {
-  if (secret === '') throw new SessionError('missing signing secret');
-  const parts = token.split('.');
-  if (parts.length !== 3) throw new SessionError('malformed token');
-  const data = `${parts[0]}.${parts[1]}`;
-  const expected = b64url(createHmac('sha256', secret).update(data).digest());
-  const a = Buffer.from(parts[2] ?? '');
-  const b = Buffer.from(expected);
-  if (a.length !== b.length || !timingSafeEqual(a, b))
-    throw new SessionError('bad signature');
-  let payload: unknown;
-  try {
-    payload = decodeJson(parts[1] ?? '');
-  } catch {
-    throw new SessionError('malformed payload');
-  }
-  if (typeof payload !== 'object' || payload === null)
-    throw new SessionError('malformed payload');
-  return payload as Record<string, unknown>;
-}
-
-const nowSec = (now?: number): number => Math.floor((now ?? Date.now()) / 1000);
-
-interface SessionClaims {
-  subject: string;
-  agentIds: string[];
-}
-
-export function signSession(
-  claims: SessionClaims,
-  secret: string,
-  opts: { ttlSec?: number; now?: number } = {},
-): string {
-  const iat = nowSec(opts.now);
-  return sign(
-    {
-      typ: 'session',
-      sub: claims.subject,
-      agent_ids: claims.agentIds,
-      iat,
-      exp: iat + (opts.ttlSec ?? 30 * 24 * 3600),
-    },
-    secret,
-  );
-}
-
-export function verifySession(
-  token: string,
-  secret: string,
-  now?: number,
-): SessionClaims {
-  const p = verify(token, secret);
-  if (p.typ !== 'session') throw new SessionError('wrong token type');
-  if (typeof p.exp !== 'number' || p.exp < nowSec(now))
-    throw new SessionError('session expired');
-  const ids = p.agent_ids;
-  if (
-    typeof p.sub !== 'string' ||
-    !Array.isArray(ids) ||
-    ids.some((a) => typeof a !== 'string' || !ID_RE.test(a))
-  )
-    throw new SessionError('malformed session');
-  return { subject: p.sub, agentIds: ids as string[] };
-}

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

@@ -1,73 +0,0 @@
-import { verifyMessage, type Hex } from 'viem';
-import { parseSiweMessage, validateSiweMessage } from 'viem/siwe';
-import { ApiError } from './api-error.js';
-import { allowedWebHost } from './session-config.js';
-
-export class SiweError extends ApiError {}
-
-export interface SiweLogin {
-  message: string;
-  signature: string;
-}
-
-export interface SiweDeps {
-  takeNonce: (nonce: string) => boolean;
-}
-
-const HEX_SIGNATURE = /^0x[0-9a-fA-F]{130}$/;
-
-export function allowedSiweDomain(domain: string): boolean {
-  return allowedWebHost(domain.replace(/:\d+$/, ''));
-}
-
-function hostOf(uri: string): string | null {
-  try {
-    return new URL(uri).host;
-  } catch {
-    return null;
-  }
-}
-
-function fieldsOrThrow(message: string): {
-  address: `0x${string}`;
-  domain: string;
-  nonce: string;
-  parsed: ReturnType<typeof parseSiweMessage>;
-} {
-  const parsed = parseSiweMessage(message);
-  const { address, domain, nonce, uri, version } = parsed;
-  if (
-    address === undefined ||
-    domain === undefined ||
-    nonce === undefined ||
-    uri === undefined ||
-    version !== '1'
-  )
-    throw new SiweError('that is not a sign-in message', 400);
-  if (!allowedSiweDomain(domain))
-    throw new SiweError(`sign-in messages for ${domain} are not accepted here`, 400);
-  if (hostOf(uri) !== domain)
-    throw new SiweError('the sign-in message names a different site', 400);
-  return { address, domain, nonce, parsed };
-}
-
-export async function verifySiweLogin(
-  input: SiweLogin,
-  deps: SiweDeps,
-): Promise<string> {
-  if (!HEX_SIGNATURE.test(input.signature))
-    throw new SiweError('that is not an Ethereum signature', 400);
-  const { address, domain, nonce, parsed } = fieldsOrThrow(input.message);
-  const time = new Date();
-  if (!validateSiweMessage({ message: parsed, domain, nonce, time }))
-    throw new SiweError('this sign-in message is expired or does not match', 400);
-  if (!deps.takeNonce(nonce))
-    throw new SiweError('that sign-in has expired or was already used', 400);
-  const signature = input.signature as Hex;
-  if (!(await verifyMessage({ address, message: input.message, signature })))
-    throw new SiweError(
-      'the signature does not match the address; smart-contract wallets are not supported yet',
-      401,
-    );
-  return address.toLowerCase();
-}

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

@@ -1,43 +0,0 @@
-import { generateSiweNonce } from 'viem/siwe';
-
-const TTL_MS = 10 * 60_000;
-const SWEEP_MS = 60_000;
-const MAX_LIVE = 500;
-
-const live = new Map<string, number>();
-let sweeper: ReturnType<typeof setInterval> | null = null;
-
-function sweep(now = Date.now()): void {
-  for (const [nonce, expiresAt] of live) if (expiresAt <= now) live.delete(nonce);
-}
-
-function ensureSweeper(): void {
-  if (sweeper !== null) return;
-  sweeper = setInterval(sweep, SWEEP_MS);
-  sweeper.unref?.();
-}
-
-export function mintNonce(now = Date.now()): string {
-  sweep(now);
-  while (live.size >= MAX_LIVE) {
-    const oldest = live.keys().next();
-    if (oldest.done) break;
-    live.delete(oldest.value);
-  }
-  const nonce = generateSiweNonce();
-  live.set(nonce, now + TTL_MS);
-  ensureSweeper();
-  return nonce;
-}
-
-export function takeNonce(nonce: string, now = Date.now()): boolean {
-  const expiresAt = live.get(nonce);
-  if (expiresAt === undefined) return false;
-  live.delete(nonce);
-  return expiresAt > now;
-}
-
-export function nonceCount(): number {
-  sweep();
-  return live.size;
-}

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

@@ -1,86 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { log } from './log.js';
-import {
-  apiFailure,
-  bodyField,
-  cors,
-  readJsonBody,
-  sendJson,
-} from './api-http.js';
-import { mintNonce, takeNonce } from './siwe-nonces.js';
-import { verifySiweLogin } from './siwe-auth.js';
-import { signSession } from './session.js';
-import { SESSION_TTL_SEC } from './session-config.js';
-
-const NONCE_PATH = '/auth/siwe/nonce';
-const VERIFY_PATH = '/auth/siwe/verify';
-
-export interface SiweRouteDeps {
-  ensureUser: (address: string) => Promise<string>;
-}
-
-async function handleVerify(
-  req: IncomingMessage,
-  res: ServerResponse,
-  secret: string,
-  deps: SiweRouteDeps,
-): Promise<void> {
-  const body = await readJsonBody(req);
-  const message = bodyField(body, 'message');
-  const signature = bodyField(body, 'signature');
-  if (typeof message !== 'string' || typeof signature !== 'string') {
-    sendJson(req, res, 400, { error: 'message and signature are required' });
-    return;
-  }
-  const address = await verifySiweLogin({ message, signature }, { takeNonce });
-  const userId = await deps.ensureUser(address);
-  log.info({ userId, address }, 'siwe: session issued');
-  const session = signSession({ subject: address, agentIds: [] }, secret, {
-    ttlSec: SESSION_TTL_SEC,
-  });
-  sendJson(req, res, 200, { session, address });
-}
-
-const ROUTES: Record<string, string> = {
-  [NONCE_PATH]: 'GET',
-  [VERIFY_PATH]: 'POST',
-};
-
-function refused(
-  req: IncomingMessage,
-  res: ServerResponse,
-  path: string,
-): boolean {
-  if (req.method === 'OPTIONS') {
-    res.writeHead(204, cors(req)).end();
-    return true;
-  }
-  if (req.method !== ROUTES[path]) {
-    sendJson(req, res, 405, { error: 'method not allowed' });
-    return true;
-  }
-  return false;
-}
-
-export function handleSiweAuthRequest(
-  req: IncomingMessage,
-  res: ServerResponse,
-  deps: SiweRouteDeps,
-): boolean {
-  const path = (req.url ?? '').split('?')[0] ?? '';
-  if (ROUTES[path] === undefined) return false;
-  if (refused(req, res, path)) return true;
-  const secret = process.env.METRO_SESSION_SECRET?.trim() ?? '';
-  if (secret === '') {
-    sendJson(req, res, 503, { error: 'sign-in is not configured' });
-    return true;
-  }
-  if (path === NONCE_PATH) {
-    sendJson(req, res, 200, { nonce: mintNonce() });
-    return true;
-  }
-  handleVerify(req, res, secret, deps).catch((err: unknown) => {
-    apiFailure(req, res, err, 'siwe');
-  });
-  return true;
-}

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

@@ -1,41 +0,0 @@
-import { eq } from 'drizzle-orm';
-import { ApiError } from '../daemon/api-error.js';
-import { getDb } from './client.js';
-import { newId } from './ids.js';
-import { users } from './schema.js';
-import { normalizeAddress } from './address.js';
-
-const UNIQUE_VIOLATION = '23505';
-
-export class UserError extends ApiError {}
-
-const CAUSE_DEPTH = 5;
-
-export function isUniqueViolation(err: unknown): boolean {
-  let current: unknown = err;
-  for (let depth = 0; depth < CAUSE_DEPTH; depth += 1) {
-    if (typeof current !== 'object' || current === null) return false;
-    const { code, cause } = current as { code?: unknown; cause?: unknown };
-    if (code === UNIQUE_VIOLATION) return true;
-    current = cause;
-  }
-  return false;
-}
-
-
-export async function ensureUserByAddress(raw: string): Promise<string> {
-  const address = normalizeAddress(raw);
-  if (address === null) throw new UserError('an Ethereum address is required', 400);
-  const db = getDb();
-  const inserted = await db
-    .insert(users)
-    .values({ id: newId(), address })
-    .onConflictDoNothing({ target: users.address })
-    .returning({ id: users.id });
-  const id = inserted[0]?.id;
-  if (id !== undefined) return id;
-  const rows = await db.select({ id: users.id }).from(users).where(eq(users.address, address));
-  const existing = rows[0]?.id;
-  if (existing === undefined) throw new UserError('user lookup returned no id', 500);
-  return existing;
-}