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

package/dist/serve.js

@@ -10,13 +10,33 @@ const SCRUBBED = new Set(['METRO_RUN_TOKEN', 'METRO_AGENT', 'DATABASE_URL']);
 const PORT_FLAG = /^--port=(.*)$/;
 const OWNER_FLAG = /^--owner=(.*)$/;
 const ADDRESS = /^0x[0-9a-fA-F]{40}$/;
-const USAGE = 'usage: metro serve [--port <n>] [--tunnel] [--owner <address>]';
+const USAGE = 'usage: metro serve [--port <n>] [--tunnel [quick|tailscale]] [--owner <address>]';
+const TUNNEL_FLAG = /^--tunnel=(.*)$/;
+const TAILSCALE_APP = '/Applications/Tailscale.app/Contents/MacOS/Tailscale';
 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;
 }
+function tunnelOf(raw) {
+    if (raw === undefined || raw === '' || raw === 'quick')
+        return 'quick';
+    if (raw === 'tailscale')
+        return 'tailscale';
+    throw new Error(`'${raw}' is not a tunnel kind (quick or tailscale) — ${USAGE}`);
+}
+function tunnelFlag(argv, i) {
+    const arg = argv[i] ?? '';
+    const inline = TUNNEL_FLAG.exec(arg);
+    if (inline)
+        return { kind: tunnelOf(inline[1]), consumed: 0 };
+    if (arg !== '--tunnel')
+        return null;
+    const next = argv[i + 1];
+    const takesValue = next !== undefined && !next.startsWith('-');
+    return { kind: tunnelOf(takesValue ? next : undefined), consumed: takesValue ? 1 : 0 };
+}
 function ownerOf(raw) {
     if (raw === undefined || !ADDRESS.test(raw))
         throw new Error(`'${raw ?? ''}' is not an Ethereum address — ${USAGE}`);
@@ -24,12 +44,14 @@ function ownerOf(raw) {
 }
 export function parseServeArgs(argv) {
     let port = localPort();
-    let tunnel = false;
+    let tunnel = null;
     let owner = null;
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i] ?? '';
-        if (arg === '--tunnel') {
-            tunnel = true;
+        const tunnelArg = tunnelFlag(argv, i);
+        if (tunnelArg) {
+            tunnel = tunnelArg.kind;
+            i += tunnelArg.consumed;
             continue;
         }
         const inlineOwner = OWNER_FLAG.exec(arg);
@@ -64,6 +86,31 @@ export function requireOwner(owner, dir = agentsDir()) {
         join(dir, '.owner') +
         ':\n  metro serve --owner <address>');
 }
+function tailscaleStatus(bin) {
+    const run = spawnSync(bin, ['status', '--json'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    if (run.error !== undefined || run.status !== 0)
+        return { ok: false, state: 'not running' };
+    try {
+        const parsed = JSON.parse(run.stdout);
+        return parsed.BackendState === 'Running' ? { ok: true } : { ok: false, state: String(parsed.BackendState) };
+    }
+    catch {
+        return { ok: false, state: 'unreadable' };
+    }
+}
+export function findTailscale(candidates = ['tailscale', TAILSCALE_APP]) {
+    const bin = candidates.find((c) => spawnSync(c, ['version'], { stdio: 'ignore' }).status === 0);
+    if (bin === undefined)
+        throw new Error('metro serve --tunnel tailscale needs Tailscale on this machine.\n' +
+            'macOS:  brew install --cask tailscale   (or the App Store app)\n' +
+            'Linux:  curl -fsSL https://tailscale.com/install.sh | sh\n' +
+            'Then sign the machine in:  tailscale up');
+    const status = tailscaleStatus(bin);
+    if (!status.ok)
+        throw new Error(`Tailscale is installed but this machine is not connected (${status.state}). Sign it in first:  tailscale up\n` +
+            'Funnel also has to be enabled once on your tailnet: https://tailscale.com/kb/1223/funnel');
+    return bin;
+}
 function findCloudflared() {
     const found = spawnSync('cloudflared', ['--version'], { stdio: 'ignore' });
     if (found.error !== undefined || found.status !== 0)
@@ -94,7 +141,8 @@ export function servePlan(opts) {
                 ? {}
                 : { METRO_RUNTIME_STORE: opts.runtime.dir, METRO_RUNTIME_MANIFEST: opts.runtime.manifest }),
             METRO_STATE_DIR: process.env.METRO_STATE_DIR ?? serveStateDir(),
-            ...(opts.tunnel ? { METRO_TUNNEL: 'quick' } : {}),
+            ...(opts.tunnel === null ? {} : { METRO_TUNNEL: opts.tunnel }),
+            ...(opts.tailscaleBin === undefined ? {} : { METRO_TAILSCALE_BIN: opts.tailscaleBin }),
             ...(opts.owner === null ? {} : { METRO_OWNER: opts.owner }),
         },
     };
@@ -106,8 +154,9 @@ export function serve(argv) {
         throw new Error(`a metro serve daemon is already running on this machine (pid ${String(running)}). ` +
             'Stop it first: metro stop');
     requireOwner(owner);
-    if (tunnel)
+    if (tunnel === 'quick')
         findCloudflared();
+    const tailscaleBin = tunnel === 'tailscale' ? findTailscale() : undefined;
     process.stderr.write(`Starting a metro daemon of your own on http://127.0.0.1:${String(port)}\n`);
-    return spawnPlan(() => servePlan({ runtime: prepareRuntime(), port, tunnel, owner }));
+    return spawnPlan(() => servePlan({ runtime: prepareRuntime(), port, tunnel, owner, ...(tailscaleBin === undefined ? {} : { tailscaleBin }) }));
 }

package/package.json

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

@@ -6,7 +6,7 @@ import { errMsg, log, logFatalSync } from './log.js';
 import { acquireLock, isLocalMode, STATE_DIR, trainsDir } from './paths.js';
 import { installCrashGuard, markDaemonReady } from './crash-guard.js';
 import { METRO_VERSION } from './version.js';
-import { quickTunnelWanted, Tunnel, webhookPort } from './tunnel.js';
+import { driverFor, Tunnel, tunnelKind, webhookPort } from './tunnel.js';
 import {
   localConnectHint,
   publicConnectHint,
@@ -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';
@@ -62,7 +61,8 @@ supervisor.onTrainEvent((env, train) => {
 });
 
 let webhookServer: Server | null = null;
-const tunnel = quickTunnelWanted() ? new Tunnel(webhookPort(), announcePublic) : null;
+const tunnelWanted = tunnelKind();
+const tunnel = tunnelWanted === null ? null : new Tunnel(driverFor(tunnelWanted, webhookPort()), announcePublic);
 
 function announcePublic(url: string): void {
   process.stderr.write(`\n${publicConnectHint(url, localOwner())}`);
@@ -74,7 +74,7 @@ setTrainCallBackend((train, action, args) =>
 
 function announceLocalEndpoint(): void {
   process.stderr.write(
-    `\n${tunnel === null ? localConnectHint(webhookPort(), localOwner()) : tunnelPendingHint()}`,
+    `\n${tunnelWanted === null ? localConnectHint(webhookPort(), localOwner()) : tunnelPendingHint(tunnelWanted)}`,
   );
   const key = localAgentKey();
   if (key === null) {
@@ -119,7 +119,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 +126,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/connect-hint.ts

@@ -35,5 +35,7 @@ export function publicConnectHint(url: string, owner: string | null): string {
   ].join('\n');
 }
 
-export const tunnelPendingHint = (): string =>
-  'Bringing up a public address through a Cloudflare quick tunnel…\n';
+export const tunnelPendingHint = (kind: 'quick' | 'tailscale'): string =>
+  kind === 'quick'
+    ? 'Bringing up a public address through a Cloudflare quick tunnel…\n'
+    : 'Publishing this daemon through Tailscale Funnel…\n';

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;
+}