@stage-labs/metro 0.1.0-beta.286 → 0.1.0-beta.288

package/runtime/node_modules/@metro-labs/{daemon/src/connectors/oauth-discovery.ts → http/src/connector-discovery.ts}

@@ -1,6 +1,7 @@
-import { parseConnectorUrl, refused } from './verify.js';
-import { stringOf } from '@metro-labs/http/api-http';
 import { isRecord } from '@metro-labs/core/is-record';
+import type { FetchLike } from '@metro-labs/core/stations/oauth';
+import { stringOf } from './api-http.js';
+import { parseConnectorUrl, refused } from './connector-url.js';
 
 const DISCOVERY_TIMEOUT_MS = 10_000;
 
@@ -18,10 +19,10 @@ interface ResourceMetadata {
   scopes: string[];
 }
 
-async function getJson(url: URL): Promise<Record<string, unknown> | null> {
+async function getJson(url: URL, fetchImpl: FetchLike): Promise<Record<string, unknown> | null> {
   let res: Response;
   try {
-    res = await fetch(url, {
+    res = await fetchImpl(url.toString(), {
       redirect: 'manual',
       signal: AbortSignal.timeout(DISCOVERY_TIMEOUT_MS),
       headers: { accept: 'application/json' },
@@ -55,9 +56,9 @@ export function resourceMetadataUrls(resource: URL): URL[] {
   return urls;
 }
 
-export async function advertisesOAuth(resource: URL): Promise<boolean> {
+export async function advertisesOAuth(resource: URL, fetchImpl: FetchLike = fetch): Promise<boolean> {
   for (const candidate of resourceMetadataUrls(resource)) {
-    const body = await getJson(candidate);
+    const body = await getJson(candidate, fetchImpl);
     const servers: unknown = body?.authorization_servers;
     const first: unknown = Array.isArray(servers) ? servers[0] : undefined;
     if (typeof first === 'string' && first !== '') return true;
@@ -76,9 +77,9 @@ function scopesOf(body: Record<string, unknown> | null): string[] {
   return out;
 }
 
-async function resourceMetadata(resource: URL): Promise<ResourceMetadata> {
+async function resourceMetadata(resource: URL, fetchImpl: FetchLike): Promise<ResourceMetadata> {
   for (const candidate of resourceMetadataUrls(resource)) {
-    const body = await getJson(candidate);
+    const body = await getJson(candidate, fetchImpl);
     const servers: unknown = body?.authorization_servers;
     const first: unknown = Array.isArray(servers) ? servers[0] : undefined;
     if (typeof first === 'string' && first !== '')
@@ -87,19 +88,35 @@ async function resourceMetadata(resource: URL): Promise<ResourceMetadata> {
   return { issuer: parseConnectorUrl(resource.origin), scopes: [] };
 }
 
+const webAddress = (text: string): boolean => {
+  try {
+    parseConnectorUrl(text);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+function endpointOf(raw: unknown, issuer: URL): string {
+  const text = stringOf(raw);
+  if (text !== '' && !webAddress(text)) throw refused(`${issuer.hostname} advertises a sign-in address Metro will not open.`);
+  return text;
+}
+
 function toServer(
   body: Record<string, unknown>,
   issuer: URL,
   scopes: string[],
 ): OAuthServer {
-  const authorizationEndpoint = stringOf(body.authorization_endpoint);
-  const tokenEndpoint = stringOf(body.token_endpoint);
+  const authorizationEndpoint = endpointOf(body.authorization_endpoint, issuer);
+  const tokenEndpoint = endpointOf(body.token_endpoint, issuer);
   if (authorizationEndpoint === '' || tokenEndpoint === '')
     throw refused(
       `${issuer.hostname} advertises OAuth but not where to sign in.`,
     );
   const methods = body.code_challenge_methods_supported;
-  const registration = stringOf(body.registration_endpoint);
+  const offered = stringOf(body.registration_endpoint);
+  const registration = webAddress(offered) ? offered : '';
   return {
     issuer: stringOf(body.issuer) === '' ? issuer.origin : stringOf(body.issuer),
     authorizationEndpoint,
@@ -121,10 +138,10 @@ export function authServerMetadataUrls(issuer: URL): URL[] {
   return [...aware, new URL(`${path}/.well-known/openid-configuration`, issuer.origin), ...urls];
 }
 
-export async function discoverOAuth(resource: URL): Promise<OAuthServer> {
-  const { issuer, scopes } = await resourceMetadata(resource);
+export async function discoverOAuth(resource: URL, fetchImpl: FetchLike = fetch): Promise<OAuthServer> {
+  const { issuer, scopes } = await resourceMetadata(resource, fetchImpl);
   for (const candidate of authServerMetadataUrls(issuer)) {
-    const body = await getJson(candidate);
+    const body = await getJson(candidate, fetchImpl);
     if (body !== null) return toServer(body, issuer, scopes);
   }
   throw refused(

package/runtime/node_modules/@metro-labs/http/src/connector-input.ts

@@ -0,0 +1,73 @@
+import { ApiError } from './api-error.js';
+import { stringOf } from './api-http.js';
+import type { ConnectorAuth } from './connector-mcp.js';
+import type { OAuthClient } from './connector-oauth.js';
+
+const CONNECTOR_NAME_MAX = 64;
+const HEADER_NAME_RE = /^[A-Za-z0-9!#$%&'*+.^_`|~-]{1,64}$/;
+const HEADER_VALUE_RE = /^[\x20-\x7e]{1,4096}$/;
+const CLIENT_ID_RE = /^[\x21-\x7e]{1,256}$/;
+const CLIENT_SECRET_RE = /^[\x21-\x7e]{1,1024}$/;
+const DEFAULT_HEADER = 'Authorization';
+
+export class ConnectorError extends ApiError {}
+
+function hasControlChar(value: string): boolean {
+  for (const ch of value) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (code < 0x20 || code === 0x7f) return true;
+  }
+  return false;
+}
+
+export function connectorName(raw: unknown): string {
+  const name = typeof raw === 'string' ? raw.trim() : '';
+  if (name === '') throw new ConnectorError('a connector needs a name', 400);
+  if (name.length > CONNECTOR_NAME_MAX)
+    throw new ConnectorError(
+      `a connector name must be ${String(CONNECTOR_NAME_MAX)} characters or fewer`,
+      400,
+    );
+  if (hasControlChar(name))
+    throw new ConnectorError(
+      'a connector name must not contain control characters',
+      400,
+    );
+  return name;
+}
+
+export function connectorAuth(
+  rawHeader: unknown,
+  rawValue: unknown,
+): ConnectorAuth {
+  const header = stringOf(rawHeader).trim();
+  const value = stringOf(rawValue).trim();
+  if (header === '' && value === '') return { kind: 'none' };
+  if (value === '')
+    throw new ConnectorError(
+      'that header has no value. Give both a header name and its value, or neither.',
+      400,
+    );
+  const name = header === '' ? DEFAULT_HEADER : header;
+  if (!HEADER_NAME_RE.test(name))
+    throw new ConnectorError('that is not a valid HTTP header name', 400);
+  if (!HEADER_VALUE_RE.test(value))
+    throw new ConnectorError('that header value is not sendable', 400);
+  return { kind: 'header', name, value };
+}
+
+export function connectorClient(
+  rawId: unknown,
+  rawSecret: unknown,
+): OAuthClient | null {
+  const clientId = stringOf(rawId).trim();
+  const clientSecret = stringOf(rawSecret).trim();
+  if (clientId === '' && clientSecret === '') return null;
+  if (clientId === '')
+    throw new ConnectorError('a client secret needs the client ID it belongs to', 400);
+  if (!CLIENT_ID_RE.test(clientId))
+    throw new ConnectorError('that is not a client ID Metro can send', 400);
+  if (clientSecret !== '' && !CLIENT_SECRET_RE.test(clientSecret))
+    throw new ConnectorError('that client secret is not sendable', 400);
+  return { clientId, ...(clientSecret === '' ? {} : { clientSecret }) };
+}

package/runtime/node_modules/@metro-labs/{daemon/src/connectors/verify.ts → http/src/connector-mcp.ts}

@@ -1,14 +1,8 @@
 import { isRecord } from '@metro-labs/core/is-record';
-import { whyUnreachable } from './reach.js';
-import { ConnectorUnauthorized, refused } from './url.js';
-
-export {
-  ConnectorUnauthorized,
-  ConnectorVerifyError,
-  connectorUrlText,
-  parseConnectorUrl,
-  refused,
-} from './url.js';
+import type { FetchLike } from '@metro-labs/core/stations/oauth';
+import { ApiError } from './api-error.js';
+import { whyUnreachable } from './connector-reach.js';
+import { ConnectorUnauthorized, refused } from './connector-url.js';
 
 export interface OAuthTokens {
   accessToken: string;
@@ -63,10 +57,11 @@ export async function mcpPost(
   url: URL,
   auth: ConnectorAuth,
   body: unknown,
-  opts: { timeoutMs: number; headers?: Record<string, string> },
+  opts: { timeoutMs: number; headers?: Record<string, string>; fetch?: FetchLike },
 ): Promise<Response> {
+  const send = opts.fetch ?? fetch;
   try {
-    return await fetch(url, {
+    return await send(url.toString(), {
       method: 'POST',
       redirect: 'manual',
       signal: AbortSignal.timeout(opts.timeoutMs),
@@ -74,6 +69,7 @@ export async function mcpPost(
       body: JSON.stringify(body),
     });
   } catch (err) {
+    if (err instanceof ApiError) throw err;
     throw refused(`Metro could not reach ${url.hostname}: ${whyUnreachable(err)}`);
   }
 }
@@ -93,14 +89,18 @@ function serverNameOf(url: URL, text: string, contentType: string): string {
   return typeof info.name === 'string' ? info.name : url.hostname;
 }
 
-export async function verifyRemoteMcp(url: URL, auth: ConnectorAuth): Promise<VerifiedServer> {
-  const res = await mcpPost(url, auth, INITIALIZE, { timeoutMs: PROBE_TIMEOUT_MS });
-  const text = await res.text().catch(() => '');
-  if (res.status >= 300 && res.status < 400) throw refused('that url redirects — use the url it redirects to');
+function refuseStatus(res: Response, url: URL, auth: ConnectorAuth): void {
+  if (res.status >= 300 && res.status < 400) throw refused('that url redirects. Use the url it redirects to.');
   if (res.status === 401 || res.status === 403)
     throw new ConnectorUnauthorized(auth.kind === 'none' ? `${url.hostname} requires authorization.` : `${url.hostname} rejected that credential.`, 400);
   if (res.status === 404 || res.status === 405)
     throw refused(`${url.hostname} did not accept an MCP initialize over HTTP POST. If it is a legacy SSE server, Metro cannot verify it yet.`);
   if (!res.ok) throw refused(`${url.hostname} answered ${String(res.status)} instead of an MCP initialize.`);
+}
+
+export async function verifyRemoteMcp(url: URL, auth: ConnectorAuth, fetchImpl: FetchLike = fetch): Promise<VerifiedServer> {
+  const res = await mcpPost(url, auth, INITIALIZE, { timeoutMs: PROBE_TIMEOUT_MS, fetch: fetchImpl });
+  const text = await res.text().catch(() => '');
+  refuseStatus(res, url, auth);
   return { server: serverNameOf(url, text, res.headers.get('content-type') ?? '') };
 }

package/runtime/node_modules/@metro-labs/{daemon/src/connectors/oauth-client.ts → http/src/connector-oauth.ts}

@@ -1,12 +1,16 @@
 import { createHash, randomBytes } from 'node:crypto';
-import { whyUnreachable } from './reach.js';
-import { refused, type OAuthTokens } from './verify.js';
-import type { OAuthServer } from './oauth-discovery.js';
 import { isRecord } from '@metro-labs/core/is-record';
+import type { FetchLike } from '@metro-labs/core/stations/oauth';
+import { whyUnreachable } from './connector-reach.js';
+import { ConnectorVerifyError, refused } from './connector-url.js';
+import type { OAuthTokens } from './connector-mcp.js';
+import type { OAuthServer } from './connector-discovery.js';
 
 const TOKEN_TIMEOUT_MS = 15_000;
 const CLIENT_NAME = 'Metro';
 
+export class OAuthInvalidGrant extends ConnectorVerifyError {}
+
 export interface OAuthClient {
   clientId: string;
   clientSecret?: string;
@@ -23,6 +27,7 @@ export function challengeOf(verifier: string): string {
 export async function registerClient(
   server: OAuthServer,
   redirectUri: string,
+  fetchImpl: FetchLike = fetch,
 ): Promise<OAuthClient> {
   if (server.registrationEndpoint === null)
     throw refused(
@@ -32,7 +37,7 @@ export async function registerClient(
     );
   let res: Response;
   try {
-    res = await fetch(server.registrationEndpoint, {
+    res = await fetchImpl(server.registrationEndpoint, {
       method: 'POST',
       redirect: 'manual',
       signal: AbortSignal.timeout(TOKEN_TIMEOUT_MS),
@@ -81,18 +86,32 @@ export function authorizeUrl(input: AuthorizeInput): string {
   return url.toString();
 }
 
+function validateOptionalTokens(body: Record<string, unknown>): void {
+  const refresh = body.refresh_token;
+  if (Object.hasOwn(body, 'refresh_token') && (typeof refresh !== 'string' || !/^[\x21-\x7e]{1,16384}$/.test(refresh))) throw refused('That server returned an invalid refresh token.');
+  if (Object.hasOwn(body, 'token_type') && (typeof body.token_type !== 'string' || body.token_type.toLowerCase() !== 'bearer')) throw refused('That server returned an unsupported token type.');
+}
+
+function expiryFrom(body: Record<string, unknown>): number | undefined {
+  if (!Object.hasOwn(body, 'expires_in')) return undefined;
+  const expires = body.expires_in;
+  if (typeof expires !== 'number' || !Number.isFinite(expires) || expires <= 0) throw refused('That server returned an invalid token expiry.');
+  const at = Date.now() + expires * 1000;
+  if (!Number.isSafeInteger(at)) throw refused('That server returned an invalid token expiry.');
+  return at;
+}
+
 function tokensFrom(body: Record<string, unknown>): OAuthTokens {
   const access = body.access_token;
-  if (typeof access !== 'string' || access === '')
-    throw refused('That server did not return an access token.');
+  if (typeof access !== 'string' || !/^[\x21-\x7e]{1,16377}$/.test(access))
+    throw refused('That server did not return a sendable access token.');
+  validateOptionalTokens(body);
+  const expiresAt = expiryFrom(body);
   const refresh = body.refresh_token;
-  const expires = body.expires_in;
   return {
     accessToken: access,
     ...(typeof refresh === 'string' ? { refreshToken: refresh } : {}),
-    ...(typeof expires === 'number'
-      ? { expiresAt: Date.now() + expires * 1000 }
-      : {}),
+    ...(expiresAt === undefined ? {} : { expiresAt }),
   };
 }
 
@@ -100,6 +119,7 @@ async function postToken(
   server: OAuthServer,
   client: OAuthClient,
   form: Record<string, string>,
+  fetchImpl: FetchLike,
 ): Promise<OAuthTokens> {
   const params = new URLSearchParams({
     ...form,
@@ -110,7 +130,7 @@ async function postToken(
   });
   let res: Response;
   try {
-    res = await fetch(server.tokenEndpoint, {
+    res = await fetchImpl(server.tokenEndpoint, {
       method: 'POST',
       redirect: 'manual',
       signal: AbortSignal.timeout(TOKEN_TIMEOUT_MS),
@@ -124,6 +144,7 @@ async function postToken(
     throw refused(`Metro could not reach that server to finish signing in: ${whyUnreachable(err)}`);
   }
   const body: unknown = await res.json().catch(() => null);
+  if (form.grant_type === 'refresh_token' && res.status === 400 && isRecord(body) && body.error === 'invalid_grant') throw new OAuthInvalidGrant('That server requires a new sign-in.', 400);
   if (!res.ok || !isRecord(body))
     throw refused('That server refused to complete the sign-in.');
   return tokensFrom(body);
@@ -133,6 +154,7 @@ export function exchangeCode(
   server: OAuthServer,
   client: OAuthClient,
   input: { code: string; redirectUri: string; verifier: string; resource: string },
+  fetchImpl: FetchLike = fetch,
 ): Promise<OAuthTokens> {
   return postToken(server, client, {
     grant_type: 'authorization_code',
@@ -140,7 +162,7 @@ export function exchangeCode(
     redirect_uri: input.redirectUri,
     code_verifier: input.verifier,
     resource: input.resource,
-  });
+  }, fetchImpl);
 }
 
 export function refreshTokens(
@@ -149,11 +171,12 @@ export function refreshTokens(
   refreshToken: string,
   resource: string,
   scope?: string,
+  fetchImpl: FetchLike = fetch,
 ): Promise<OAuthTokens> {
   return postToken(server, client, {
     grant_type: 'refresh_token',
     refresh_token: refreshToken,
     resource,
     ...(scope === undefined ? {} : { scope }),
-  });
+  }, fetchImpl);
 }

package/runtime/node_modules/@metro-labs/http/src/connector-policy.ts

@@ -0,0 +1,53 @@
+import { isRecord } from '@metro-labs/core/is-record';
+
+export type ConnectorDecision = 'allow' | 'ask' | 'deny';
+
+export interface ConnectorPolicy {
+  read?: ConnectorDecision;
+  write?: ConnectorDecision;
+  tools?: Record<string, ConnectorDecision>;
+}
+
+const RANK: Record<ConnectorDecision, number> = { allow: 0, ask: 1, deny: 2 };
+const TOOL_RE = /^[A-Za-z0-9_.:/-]{1,256}$/;
+
+const decision = (value: unknown): value is ConnectorDecision => value === 'allow' || value === 'ask' || value === 'deny';
+
+export function connectorPolicyOf(value: unknown): ConnectorPolicy {
+  if (!isRecord(value) || Object.keys(value).some((key) => !['read', 'write', 'tools'].includes(key))) throw new Error('Invalid connector policy.');
+  const out: ConnectorPolicy = {};
+  for (const group of ['read', 'write'] as const) {
+    if (!Object.hasOwn(value, group)) continue;
+    const field = value[group];
+    if (!decision(field)) throw new Error('Invalid connector policy.');
+    out[group] = field;
+  }
+  if (Object.hasOwn(value, 'tools')) out.tools = toolPolicyOf(value.tools);
+  return out;
+}
+
+function toolPolicyOf(value: unknown): Record<string, ConnectorDecision> {
+  if (!isRecord(value) || Object.keys(value).length > 2000) throw new Error('Invalid connector policy.');
+  const out: Record<string, ConnectorDecision> = {};
+  for (const [name, rule] of Object.entries(value)) {
+    if (!TOOL_RE.test(name) || ['__proto__', 'constructor', 'prototype'].includes(name) || !decision(rule)) throw new Error('Invalid connector policy.');
+    out[name] = rule;
+  }
+  return out;
+}
+
+const strictest = (...values: (ConnectorDecision | undefined)[]): ConnectorDecision => values.reduce<ConnectorDecision>((held, next) => next !== undefined && RANK[next] > RANK[held] ? next : held, 'allow');
+
+export function combineConnectorPolicies(global: ConnectorPolicy, assignment: ConnectorPolicy): ConnectorPolicy {
+  const policies = [connectorPolicyOf(global), connectorPolicyOf(assignment)];
+  const out: ConnectorPolicy = {
+    read: strictest(...policies.map((policy) => policy.read)),
+    write: strictest(...policies.map((policy) => policy.write)),
+  };
+  const names = new Set(policies.flatMap((policy) => Object.keys(policy.tools ?? {})));
+  if (names.size > 0) {
+    out.tools = {};
+    for (const name of names) out.tools[name] = strictest(...policies.flatMap((policy) => [policy.read, policy.write, policy.tools?.[name]]));
+  }
+  return out;
+}

package/runtime/node_modules/@metro-labs/{daemon/src/connectors/url.ts → http/src/connector-url.ts}

@@ -1,4 +1,4 @@
-import { ApiError } from '@metro-labs/http/api-error';
+import { ApiError } from './api-error.js';
 
 export class ConnectorVerifyError extends ApiError {}
 

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

@@ -0,0 +1,56 @@
+const P = 2n ** 255n - 19n;
+
+interface Point {
+  x: bigint;
+  y: bigint;
+}
+
+const mod = (a: bigint): bigint => ((a % P) + P) % P;
+
+function pow(base: bigint, exp: bigint): bigint {
+  let result = 1n;
+  let b = mod(base);
+  for (let e = exp; e > 0n; e >>= 1n) {
+    if ((e & 1n) === 1n) result = (result * b) % P;
+    b = (b * b) % P;
+  }
+  return result;
+}
+
+const inv = (a: bigint): bigint => pow(a, P - 2n);
+const D = mod(-121665n * inv(121666n));
+const SQRT_M1 = pow(2n, (P - 1n) / 4n);
+
+function rootOf(u: bigint, v: bigint): bigint | null {
+  const x = mod(u * pow(v, 3n) * pow(mod(u * pow(v, 7n)), (P - 5n) / 8n));
+  const vx2 = mod(v * x * x);
+  if (vx2 === u) return x;
+  return vx2 === mod(-u) ? mod(x * SQRT_M1) : null;
+}
+
+function decode(bytes: Buffer): Point | null {
+  if (bytes.length !== 32) return null;
+  const last = bytes[31] ?? 0;
+  const sign = BigInt(last >> 7);
+  const copy = Buffer.from(bytes);
+  copy[31] = last & 0x7f;
+  const y = BigInt(`0x${copy.reverse().toString('hex')}`);
+  if (y >= P) return null;
+  const y2 = (y * y) % P;
+  const x = rootOf(mod(y2 - 1n), mod(D * y2 + 1n));
+  if (x === null || (x === 0n && sign === 1n)) return null;
+  return { x: (x & 1n) === sign ? x : mod(-x), y };
+}
+
+function add(a: Point, b: Point): Point {
+  const t = mod(D * a.x * b.x * a.y * b.y);
+  return { x: mod((a.x * b.y + a.y * b.x) * inv(mod(1n + t))), y: mod((a.y * b.y + a.x * b.x) * inv(mod(1n - t))) };
+}
+
+export function strongEd25519(raw: Buffer): boolean {
+  const point = decode(raw);
+  if (point === null) return false;
+  let eight = point;
+  for (let i = 0; i < 3; i += 1) eight = add(eight, eight);
+  return !(eight.x === 0n && eight.y === 1n);
+}

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.286"
+  "version": "0.1.0-beta.288"
 }

package/runtime/sdk-runner/runner.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0-beta.286",
+  "version": "0.1.0-beta.288",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.287",
     "@modelcontextprotocol/sdk": "^1.29.0",