@stage-labs/metro 0.1.0-beta.290 → 0.1.0-beta.291

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.290",
+  "version": "0.1.0-beta.291",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.290",
+  "version": "0.1.0-beta.291",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

package/runtime/node_modules/@metro-labs/daemon/src/connectors/migration-api.ts

@@ -3,6 +3,7 @@ import { isRecord } from '@metro-labs/core/is-record';
 import { parseId } from '@metro-labs/core/ids';
 import { ApiError } from '@metro-labs/http/api-error';
 import { readJsonBody, sessionRoute } from '@metro-labs/http/api-http';
+import { publicOAuthResource } from '@metro-labs/http/connector-public-url';
 import type { ConnectorMigrations, MigrationAction } from './migration-control.js';
 
 const PATH = '/api/connectors/migrations';
@@ -15,6 +16,7 @@ interface MigrationInput {
   scope: string;
   operationId: string | null;
   uncertainty: string | null;
+  oauthResource?: string;
 }
 
 function operationOf(value: unknown): string | null {
@@ -34,13 +36,16 @@ function receiptOf(body: Record<string, unknown>, action: MigrationAction): stri
 }
 
 function inputOf(body: unknown): MigrationInput {
-  if (!isRecord(body) || Object.keys(body).some((key) => !['scope', 'sourceId', 'action', 'operationId', 'uncertainty'].includes(key)) || typeof body.scope !== 'string' || !/^[a-f0-9]{64}$/.test(body.scope)) {
+  if (!isRecord(body) || Object.keys(body).some((key) => !['scope', 'sourceId', 'action', 'operationId', 'uncertainty', 'oauthResource'].includes(key)) || typeof body.scope !== 'string' || !/^[a-f0-9]{64}$/.test(body.scope)) {
     throw new ApiError('A migration needs its connector, action and current enrollment scope.', 400);
   }
   const sourceId = parseId(body.sourceId);
   const action = actions.find((value) => value === body.action);
   if (sourceId === null || action === undefined) throw new ApiError('A migration needs a valid connector and action.', 400);
-  return { sourceId, action, scope: body.scope, operationId: operationOf(body.operationId), uncertainty: receiptOf(body, action) };
+  return {
+    sourceId, action, scope: body.scope, operationId: operationOf(body.operationId), uncertainty: receiptOf(body, action),
+    ...(body.oauthResource === undefined ? {} : { oauthResource: publicOAuthResource(body.oauthResource) }),
+  };
 }
 
 export function handleMigrationRequest(req: IncomingMessage, res: ServerResponse, deps: MigrationApiDeps): boolean {
@@ -49,7 +54,7 @@ export function handleMigrationRequest(req: IncomingMessage, res: ServerResponse
     const current = deps.status();
     if (current.owner === null || current.owner !== session.subject) throw new ApiError('This agent belongs to another organization.', 403);
     if (req.method !== 'POST') return current;
-    const { sourceId, action, scope, operationId, uncertainty } = inputOf(body);
-    return deps.run(sourceId, action, scope, operationId, uncertainty);
+    const { sourceId, action, scope, operationId, uncertainty, oauthResource } = inputOf(body);
+    return deps.run(sourceId, action, scope, operationId, uncertainty, oauthResource);
   });
 }

package/runtime/node_modules/@metro-labs/daemon/src/connectors/migration-control.ts

@@ -2,11 +2,12 @@ import { newId } from '@metro-labs/core/ids';
 import { log } from '@metro-labs/core/log';
 import type { ConnectorSyncStatus } from '@metro-labs/core/connector-sync';
 import { ApiError } from '@metro-labs/http/api-error';
+import { publicOAuthResource } from '@metro-labs/http/connector-public-url';
 import type { DeliverySnapshot } from '@metro-labs/http/connector-delivery';
 import { migrationResponseOf, sealConnectorMigration, type MigrationResponse, type MigrationView as RemoteMigration } from '@metro-labs/http/connector-migration';
 import { agentsDir } from '../agents/files.js';
 import { readAgentKey, type AgentKey } from './agent-key.js';
-import { agentCall, METRO_API, type MetroApi } from './metro-api.js';
+import { agentCall, METRO_API, MetroApiRefusal, type MetroApi } from './metro-api.js';
 import { migrationSource } from './migration-preview.js';
 import { migrationPayload } from './migration-source.js';
 import { localMigrationIdle } from './migration-guard.js';
@@ -48,6 +49,13 @@ const reasons: Record<RemoteMigration['readiness'], string | null> = { pending:
 const samePolicy = (a: MigrationRecord['policy'], b: MigrationRecord['policy']): boolean =>
   (a.read ?? 'allow') === (b.read ?? 'allow') && (a.write ?? 'allow') === (b.write ?? 'allow') && JSON.stringify(Object.entries(a.tools ?? {}).sort()) === JSON.stringify(Object.entries(b.tools ?? {}).sort());
 
+function callFailure(error: unknown, action: string): ApiError {
+  if (action === 'prepare' && error instanceof MetroApiRefusal && error.upstreamStatus === 400 && error.code === 'oauth_resource_required') {
+    return new ApiError("Enter the provider's public OAuth resource. Roll back this preparation, then prepare again with that public value; never enter credentials.", 400);
+  }
+  return uncertain();
+}
+
 function received(record: MigrationRecord, snapshot: DeliverySnapshot): boolean {
   const delivered = snapshot.connectors.find((row) => row.id === record.destinationId);
   return delivered?.state === 'ready' && delivered.name === record.name && samePolicy(delivered.policy, record.policy);
@@ -103,7 +111,7 @@ export class ConnectorMigrations {
   }
 
   private source(record: MigrationRecord): ReturnType<typeof migrationPayload> {
-    const payload = migrationPayload(migrationSource(record.sourceId, this.dir));
+    const payload = migrationPayload(migrationSource(record.sourceId, this.dir), record.oauthResource);
     if (payload.sourceStamp !== record.sourceStamp) throw conflict('The retained local connector changed. Restore its original settings before continuing; Metro will not overwrite it.');
     return payload;
   }
@@ -115,8 +123,8 @@ export class ConnectorMigrations {
       response = migrationResponseOf(await agentCall(this.api, context.key, '/api/agents/connector-migrations', {
         action, operationId: record.id, sourceId: record.sourceId, ...(sealed === undefined ? {} : { sealed }),
       }, { timeoutMs: 60_000 }));
-    } catch {
-      throw uncertain();
+    } catch (error) {
+      throw callFailure(error, action);
     }
     this.check(context, record);
     const remote = response.migration;
@@ -132,12 +140,13 @@ export class ConnectorMigrations {
     return this.save(context, { ...record, destinationId: remote.destinationId, reason: reasons[remote.readiness] });
   }
 
-  private create(context: Context, id: string): MigrationRecord {
-    const payload = migrationPayload(migrationSource(id, this.dir));
+  private create(context: Context, id: string, oauthResource?: string): MigrationRecord {
+    const payload = migrationPayload(migrationSource(id, this.dir), oauthResource);
     return this.save(context, {
       id: newId(), owner: context.owner, agentId: context.agentId, keyId: context.key.keyId,
       sourceId: id, name: payload.name, destinationId: null, phase: 'preparing', auth: payload.auth.kind,
       sourceStamp: payload.sourceStamp, policy: payload.policy, reason: null,
+      ...(payload.oauthResource === undefined ? {} : { oauthResource: payload.oauthResource }),
     });
   }
 
@@ -216,10 +225,10 @@ export class ConnectorMigrations {
     this.accept(context, record, migration);
   }
 
-  private obtain(context: Context, sourceId: string, action: MigrationAction): MigrationRecord | null {
+  private obtain(context: Context, sourceId: string, action: MigrationAction, oauthResource?: string): MigrationRecord | null {
     const record = migrationRecord(sourceId, this.dir);
     if (record !== null) this.check(context, record);
-    if (action === 'prepare' && (record === null || record.phase === 'rolled_back')) return this.create(context, sourceId);
+    if (action === 'prepare' && (record === null || record.phase === 'rolled_back')) return this.create(context, sourceId, oauthResource);
     if (record === null && action !== 'reconcile') throw conflict('Prepare this connector before moving it.');
     return record;
   }
@@ -238,18 +247,27 @@ export class ConnectorMigrations {
     this.save(context, { ...record, reason: record.phase === 'prepared' ? 'not_verified' : null });
   }
 
+  private validateResource(sourceId: string, action: MigrationAction, oauthResource: string | undefined): void {
+    if (oauthResource === undefined) return;
+    const resource = publicOAuthResource(oauthResource);
+    const record = migrationRecord(sourceId, this.dir);
+    if (action === 'prepare' && (record === null || record.phase === 'rolled_back')) return;
+    if (record?.oauthResource !== resource) throw conflict('The public OAuth resource is fixed for this preparation. Roll back, then prepare again to change it.');
+  }
+
   private validateIntent(sourceId: string, action: MigrationAction, operationId: string | null, receipt: string | null): void {
     if ((migrationRecord(sourceId, this.dir)?.id ?? null) !== operationId) throw conflict('This connector migration changed. Refresh before acting on its current operation.');
     if (action === 'resolve' && (receipt === null || receipt !== migrationUncertaintyReceipt(sourceId, this.dir))) throw conflict('The outstanding request receipt changed. Refresh before confirming that vendor requests have settled.');
   }
 
-  async run(sourceId: string, action: MigrationAction, scope: string, operationId: string | null, uncertainty: string | null = null): Promise<MigrationStatus> {
+  async run(sourceId: string, action: MigrationAction, scope: string, operationId: string | null, uncertainty: string | null = null, oauthResource?: string): Promise<MigrationStatus> {
     if (this.running) throw conflict('Another migration request is still running on this agent. Refresh after it finishes.');
     const context = this.context(scope, action === 'prepare' || action === 'cutover');
     this.validateIntent(sourceId, action, operationId, uncertainty);
+    this.validateResource(sourceId, action, oauthResource);
     this.running = true;
     try {
-      const record = this.obtain(context, sourceId, action);
+      const record = this.obtain(context, sourceId, action, oauthResource);
       if (record !== null) {
         if (action === 'resolve') this.resolve(context, record, uncertainty);
         else await this.perform(context, record, action);

package/runtime/node_modules/@metro-labs/daemon/src/connectors/migration-preview.ts

@@ -5,7 +5,6 @@ import { isRecord } from '@metro-labs/core/is-record';
 import { ApiError } from '@metro-labs/http/api-error';
 import { bodyField } from '@metro-labs/http/api-http';
 import { connectorAuth, connectorClient, connectorName } from '@metro-labs/http/connector-input';
-import { parseConnectorUrl } from '@metro-labs/http/connector-url';
 import { connectorPolicyOf } from '@metro-labs/http/connector-delivery';
 import { readConfig } from './config.js';
 import type { LocalConnectorRow } from './store.js';
@@ -15,7 +14,7 @@ import { connectorSyncScope, syncOptedIn, syncSetting } from './org-sync-setting
 import { readAgentKey } from './agent-key.js';
 import { migrationOrigin } from './migration-url.js';
 
-export type MigrationIssue = 'invalid_config' | 'unsupported_url' | 'custom_policy' | 'oauth_sign_in' | 'header_reentry' | 'unused_oauth_client' | 'oauth_private_resource';
+export type MigrationIssue = 'invalid_config' | 'unsupported_url' | 'custom_policy' | 'oauth_sign_in' | 'header_reentry' | 'unused_oauth_client';
 
 export interface MigrationConnector {
   id: string;
@@ -29,6 +28,7 @@ export interface MigrationConnector {
 
 export interface ConnectorMigrationPreview {
   migrationSupported: true;
+  oauthResourceSupported: true;
   enabled: boolean;
   enrolled: boolean;
   agentId: string | null;
@@ -53,19 +53,8 @@ function validClient(raw: unknown): boolean {
   return client !== null && client.clientId === raw.clientId && client.clientSecret === raw.clientSecret;
 }
 
-function oauthTokensValid(raw: Record<string, unknown>): boolean {
-  const token = (value: unknown): boolean => typeof value === 'string' && /^[\x21-\x7e]+$/.test(value);
-  return token(raw.accessToken) && (raw.refreshToken === undefined || token(raw.refreshToken));
-}
-
 function oauthAuth(raw: Record<string, unknown>): 'oauth' {
   if (!onlyKeys(raw, ['kind', 'accessToken', 'refreshToken', 'clientId', 'clientSecret', 'tokenEndpoint', 'issuer', 'scope', 'expiresAt'])) invalid();
-  if (!oauthTokensValid(raw) || ![raw.clientId, raw.tokenEndpoint, raw.issuer].every(nonempty)) invalid();
-  if (!optionalStrings(raw, ['refreshToken', 'clientSecret', 'scope'])) invalid();
-  if (raw.expiresAt !== undefined && (typeof raw.expiresAt !== 'number' || !Number.isFinite(raw.expiresAt) || raw.expiresAt < 0)) invalid();
-  connectorClient(raw.clientId, raw.clientSecret);
-  parseConnectorUrl(raw.tokenEndpoint);
-  parseConnectorUrl(raw.issuer);
   return 'oauth';
 }
 
@@ -156,14 +145,8 @@ function rowIdentity(row: Record<string, unknown>, index: number): { id: string;
   return { id: id ?? `invalid-${String(index + 1)}`, name: name ?? `Connector ${String(index + 1)}`, valid: id !== null && name !== null };
 }
 
-function authIssues(row: Record<string, unknown>, auth: MigrationConnector['auth'], origin: string | null): MigrationIssue[] {
-  if (auth === 'oauth') {
-    const issues: MigrationIssue[] = ['oauth_sign_in'];
-    if (origin === null) return issues;
-    const url = parseConnectorUrl(row.url);
-    if (![url.origin, `${url.origin}/`, `${url.origin}/mcp`].includes(String(row.url))) issues.push('oauth_private_resource');
-    return issues;
-  }
+function authIssues(row: Record<string, unknown>, auth: MigrationConnector['auth']): MigrationIssue[] {
+  if (auth === 'oauth') return ['oauth_sign_in'];
   const client = bodyField(row.config, 'client');
   return (auth === 'none' || auth === 'header') && client !== undefined && client !== null ? ['unused_oauth_client'] : [];
 }
@@ -178,7 +161,7 @@ function previewRow(raw: unknown, index: number): MigrationConnector {
   if (!identity.valid || auth === 'invalid' || !valid) issues.push('invalid_config');
   if (origin === null) issues.push('unsupported_url');
   if (valid && !policySupported) issues.push('custom_policy');
-  issues.push(...authIssues(row, auth, origin));
+  issues.push(...authIssues(row, auth));
   return { id: identity.id, name: identity.name, auth, origin, policy, policySupported, issues };
 }
 
@@ -223,14 +206,14 @@ export function migrationSource(id: string, dir = agentsDir()): LocalConnectorRo
   if (source.issues.some((issue) => issue !== 'oauth_sign_in')) throw new ApiError('This connector cannot be migrated without changing its settings or permissions. Resolve the preview blockers first.', 409);
   const raw = readRows(dir).find((row) => isRecord(row) && row.id === id);
   if (!isRecord(raw) || typeof raw.url !== 'string') throw unavailable();
-  return { id, name: source.name, url: raw.url, config: { ...readConfig(raw.config), policy: source.policy } };
+  return { id, name: source.name, url: raw.url, config: { ...readConfig(raw.config), oauth: source.auth === 'oauth', policy: source.policy } };
 }
 
 export function connectorMigrationPreview(owner: string | null, dir = agentsDir()): ConnectorMigrationPreview {
   const enabled = syncOptedIn(dir) && syncSetting(dir, connectorSyncScope(owner, readAgentKey(dir))).enabled;
   const liveEnabled = process.env.METRO_CONNECTORS_LIVE_ENABLED === 'true';
-  if (!enabled) return { migrationSupported: true, enabled, enrolled: false, agentId: null, owner, liveEnabled, connectors: [] };
+  if (!enabled) return { migrationSupported: true, oauthResourceSupported: true, enabled, enrolled: false, agentId: null, owner, liveEnabled, connectors: [] };
   const enrollment = owner === null ? null : readAgentKey(dir)?.enrollment;
   const agentId = enrollment?.organization === owner ? enrollment?.server ?? null : null;
-  return { migrationSupported: true, enabled, enrolled: agentId !== null, agentId, owner, liveEnabled, connectors: previewRows(dir) };
+  return { migrationSupported: true, oauthResourceSupported: true, enabled, enrolled: agentId !== null, agentId, owner, liveEnabled, connectors: previewRows(dir) };
 }

package/runtime/node_modules/@metro-labs/daemon/src/connectors/migration-source.ts

@@ -1,15 +1,18 @@
 import { createHash } from 'node:crypto';
 import type { MigrationPayload } from '@metro-labs/http/connector-migration';
 import { connectorPolicyOf } from '@metro-labs/http/connector-delivery';
+import { ApiError } from '@metro-labs/http/api-error';
+import { boundOAuthResource } from '@metro-labs/http/connector-public-url';
 import type { LocalConnectorRow } from './store.js';
 
-export function migrationPayload(row: LocalConnectorRow): MigrationPayload {
+export function migrationPayload(row: LocalConnectorRow, oauthResource?: string): MigrationPayload {
   const oauth = row.config.oauth || row.config.auth.kind === 'oauth';
   const auth = oauth ? { kind: 'oauth' as const } : row.config.auth;
-  if (auth.kind === 'oauth') {
-    return stamped({ name: row.name, url: row.url, auth: { kind: 'oauth' }, client: row.config.client, policy: connectorPolicyOf(row.config.policy ?? {}) });
-  }
-  return stamped({ name: row.name, url: row.url, auth, client: row.config.client, policy: connectorPolicyOf(row.config.policy ?? {}) });
+  if (!oauth && oauthResource !== undefined) throw new ApiError('Only an OAuth connector accepts a public OAuth resource.', 400);
+  return stamped({
+    name: row.name, url: row.url, auth, client: row.config.client, policy: connectorPolicyOf(row.config.policy ?? {}),
+    ...(oauthResource === undefined ? {} : { oauthResource: boundOAuthResource(row.url, oauthResource) }),
+  });
 }
 
 function stamped(value: Omit<MigrationPayload, 'sourceStamp'>): MigrationPayload {

package/runtime/node_modules/@metro-labs/daemon/src/connectors/migration-state.ts

@@ -6,6 +6,7 @@ import { parseId } from '@metro-labs/core/ids';
 import { ensureSecureDir } from '@metro-labs/core/secure-fs';
 import { ApiError } from '@metro-labs/http/api-error';
 import { connectorPolicyOf, type ConnectorPolicy } from '@metro-labs/http/connector-delivery';
+import { publicOAuthResource } from '@metro-labs/http/connector-public-url';
 import { agentsDir } from '../agents/files.js';
 import { captureMigrationOperations } from './migration-operations.js';
 
@@ -22,6 +23,7 @@ export interface MigrationRecord {
   destinationId: string | null;
   phase: MigrationPhase;
   auth: MigrationAuth;
+  oauthResource?: string;
   sourceStamp: string;
   policy: ConnectorPolicy;
   reason: string | null;
@@ -29,7 +31,7 @@ export interface MigrationRecord {
 
 const phases: readonly MigrationPhase[] = ['preparing', 'prepared', 'cutover', 'active', 'rollback', 'rolled_back'];
 const auths: readonly MigrationAuth[] = ['none', 'header', 'oauth'];
-const fields = ['id', 'owner', 'agentId', 'keyId', 'sourceId', 'name', 'destinationId', 'phase', 'auth', 'sourceStamp', 'policy', 'reason'];
+const fields = ['id', 'owner', 'agentId', 'keyId', 'sourceId', 'name', 'destinationId', 'phase', 'auth', 'oauthResource', 'sourceStamp', 'policy', 'reason'];
 const unavailable = (): ApiError => new ApiError('Protected connector migration records cannot be read. Restore their file or permissions before using connectors.', 503);
 const DIGEST = /^[A-Za-z0-9_-]{43}$/;
 const pathOf = (dir: string): string => join(dir, 'connector-migrations.json');
@@ -50,8 +52,9 @@ function recordOf(value: unknown): MigrationRecord {
   if (!isRecord(value) || Object.keys(value).some((key) => !fields.includes(key))) throw unavailable();
   const phase = phases.find((item) => item === value.phase);
   const auth = auths.find((item) => item === value.auth);
-  if (phase === undefined || auth === undefined) throw unavailable();
+  if (phase === undefined || auth === undefined || (value.oauthResource !== undefined && auth !== 'oauth')) throw unavailable();
   return {
+    ...(value.oauthResource === undefined ? {} : { oauthResource: publicOAuthResource(value.oauthResource) }),
     id: requiredId(value.id), sourceId: requiredId(value.sourceId), agentId: requiredId(value.agentId),
     owner: field(value.owner, /^org_[A-Za-z0-9]{1,128}$/), keyId: field(value.keyId, DIGEST), sourceStamp: field(value.sourceStamp, DIGEST),
     name: field(value.name, /^.{1,200}$/), destinationId: value.destinationId === null ? null : requiredId(value.destinationId),

package/runtime/node_modules/@metro-labs/daemon/src/connectors/migration-url.ts

@@ -1,31 +1,8 @@
-import { BlockList, isIP } from 'node:net';
-import { parseConnectorUrl } from '@metro-labs/http/connector-url';
-
-const blocked = new BlockList();
-for (const [address, prefix] of [
-  ['0.0.0.0', 8], ['10.0.0.0', 8], ['100.64.0.0', 10], ['127.0.0.0', 8], ['169.254.0.0', 16], ['172.16.0.0', 12],
-  ['192.0.0.0', 24], ['192.0.2.0', 24], ['192.88.99.0', 24], ['192.168.0.0', 16], ['198.18.0.0', 15],
-  ['198.51.100.0', 24], ['203.0.113.0', 24], ['224.0.0.0', 4], ['240.0.0.0', 4],
-] as const) blocked.addSubnet(address, prefix, 'ipv4');
-for (const [address, prefix] of [
-  ['2001::', 32], ['2001:10::', 28], ['2001:20::', 28], ['2001:db8::', 32], ['2002::', 16],
-] as const) blocked.addSubnet(address, prefix, 'ipv6');
-const globalV6 = new BlockList();
-globalV6.addSubnet('2000::', 3, 'ipv6');
-
-function publicHost(host: string): boolean {
-  if (isIP(host) === 4) return !blocked.check(host, 'ipv4');
-  if (isIP(host) === 6) return globalV6.check(host, 'ipv6') && !blocked.check(host, 'ipv6');
-  const name = host.replace(/\.$/, '');
-  if (/(^|\.)(localhost|local|internal|lan|home|invalid|test|onion)$/.test(name)) return false;
-  return name.includes('.') && name.split('.').every((label) => /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label));
-}
+import { parsePublicConnectorUrl } from '@metro-labs/http/connector-public-url';
 
 export function migrationOrigin(raw: unknown): string | null {
   try {
-    const url = parseConnectorUrl(raw);
-    if (url.protocol !== 'https:' || !publicHost(url.hostname.replace(/^\[|\]$/g, ''))) return null;
-    return url.origin;
+    return parsePublicConnectorUrl(raw).origin;
   } catch {
     return null;
   }

package/runtime/node_modules/@metro-labs/daemon/src/connectors/store.ts

@@ -388,7 +388,7 @@ export async function localRelayTarget(
 export function localRollbackMigrationSource(id: string, signOutOAuth: boolean, dir = agentsDir()): void {
   if (migrationSource(id, dir)?.phase !== 'rollback' || !localMigrationIdle(id, dir)) throw new ConnectorError('The connector migration is not ready to roll back.', 409);
   const row = rowOrThrow(id, dir);
-  if (signOutOAuth && row.config.auth.kind === 'oauth') replace(dir, signedOut(row), true);
+  if (signOutOAuth) replace(dir, signedOut(row), true);
   if (signOutOAuth) for (const path of [filePath(dir), dir]) {
     const fd = openSync(path, 'r');
     try { fsyncSync(fd); } finally { closeSync(fd); }

package/runtime/node_modules/@metro-labs/http/package.json

@@ -14,6 +14,8 @@
     "./sigv4": "./src/sigv4.ts",
     "./agent-signature": "./src/agent-signature.ts",
     "./connector-url": "./src/connector-url.ts",
+    "./connector-public-url": "./src/connector-public-url.ts",
+    "./connector-resource": "./src/connector-resource.ts",
     "./connector-reach": "./src/connector-reach.ts",
     "./connector-mcp": "./src/connector-mcp.ts",
     "./connector-discovery": "./src/connector-discovery.ts",

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

@@ -2,7 +2,7 @@ import { parseId } from '@metro-labs/core/ids';
 import { isRecord } from '@metro-labs/core/is-record';
 import { connectorName } from './connector-input.js';
 import { connectorPolicyOf, type ConnectorPolicy } from './connector-policy.js';
-import { parseConnectorUrl } from './connector-url.js';
+import { parsePublicConnectorUrl } from './connector-public-url.js';
 import { isOrganizationId } from './workos-token.js';
 
 export const CONNECTOR_DELIVERY_LEASE_MS = 90_000;
@@ -85,8 +85,8 @@ function stateOf(value: unknown, auth: DeliveredConnector['auth']): DeliveredCon
 }
 
 function urlOf(value: unknown): string {
-  const url = parseConnectorUrl(value);
-  if (url.protocol !== 'https:' || url.toString().length > 2048 || typeof value !== 'string') throw new Error('Invalid delivered connector URL.');
+  parsePublicConnectorUrl(value);
+  if (typeof value !== 'string') throw new Error('Invalid delivered connector URL.');
   return value;
 }
 

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

@@ -49,7 +49,7 @@ export function connectorAuth(
       400,
     );
   const name = header === '' ? DEFAULT_HEADER : header;
-  if (!HEADER_NAME_RE.test(name))
+  if (!HEADER_NAME_RE.test(name) || ['__proto__', 'constructor', 'prototype'].includes(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);

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

@@ -5,7 +5,7 @@ import { deliveryBytes, deliveryRecord } from './connector-delivery-validation.j
 import { connectorAuth, connectorClient, connectorName } from './connector-input.js';
 import type { OAuthClient } from './connector-oauth.js';
 import { connectorPolicyOf, type ConnectorPolicy } from './connector-policy.js';
-import { parseConnectorUrl } from './connector-url.js';
+import { boundOAuthResource, parsePublicConnectorUrl } from './connector-public-url.js';
 import { openTransfer, sealTransfer, type SealedTransfer } from './transfer-crypto.js';
 import { isOrganizationId } from './workos-token.js';
 
@@ -26,6 +26,7 @@ export interface MigrationPayload {
   url: string;
   auth: { kind: 'none' } | { kind: 'header'; name: string; value: string } | { kind: 'oauth' };
   client: OAuthClient | null;
+  oauthResource?: string;
   policy: ConnectorPolicy;
   sourceStamp: string;
 }
@@ -97,26 +98,20 @@ function clientOf(raw: unknown): OAuthClient | null {
   return client;
 }
 
-function canonicalResource(raw: unknown, url: URL): boolean {
-  return raw === `${url.origin}${url.pathname}` || (url.pathname === '/' && raw === url.origin);
-}
-
-function migrationClient(auth: MigrationPayload['auth'], url: URL, input: Record<string, unknown>): OAuthClient | null {
+function migrationClient(auth: MigrationPayload['auth'], input: Record<string, unknown>): OAuthClient | null {
   const client = clientOf(input.client);
-  if (auth.kind !== 'oauth' && client !== null) throw invalid();
-  if (auth.kind === 'oauth' && (url.search !== '' || !['/', '/mcp'].includes(url.pathname) || !canonicalResource(input.url, url))) throw invalid();
+  if (auth.kind !== 'oauth' && (client !== null || Object.hasOwn(input, 'oauthResource'))) throw invalid();
   return client;
 }
 
 export function migrationPayloadOf(raw: unknown): MigrationPayload {
-  const value = deliveryRecord(raw, ['name', 'url', 'auth', 'client', 'policy', 'sourceStamp']);
+  const value = deliveryRecord(raw, ['name', 'url', 'auth', 'client', 'oauthResource', 'policy', 'sourceStamp']);
   if (typeof value.name !== 'string' || connectorName(value.name) !== value.name || typeof value.url !== 'string' || typeof value.sourceStamp !== 'string') throw invalid();
-  const url = parseConnectorUrl(value.url);
-  if (url.protocol !== 'https:' || value.url.length > 2048) throw invalid();
+  parsePublicConnectorUrl(value.url);
   deliveryBytes(value.sourceStamp, 32);
   const auth = authOf(value.auth);
-  const client = migrationClient(auth, url, value);
-  const payload = { name: value.name, url: value.url, auth, client, policy: connectorPolicyOf(value.policy), sourceStamp: value.sourceStamp };
+  const client = migrationClient(auth, value);
+  const payload = { name: value.name, url: value.url, auth, client, ...(Object.hasOwn(value, 'oauthResource') ? { oauthResource: boundOAuthResource(value.url, value.oauthResource) } : {}), policy: connectorPolicyOf(value.policy), sourceStamp: value.sourceStamp };
   if (Buffer.byteLength(JSON.stringify(payload)) > PAYLOAD_MAX) throw invalid();
   return payload;
 }

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

@@ -0,0 +1,64 @@
+import { BlockList, isIP } from 'node:net';
+import { parseConnectorUrl, refused } from './connector-url.js';
+
+const blocked = new BlockList();
+for (const [address, prefix] of [
+  ['0.0.0.0', 8], ['10.0.0.0', 8], ['100.64.0.0', 10], ['127.0.0.0', 8], ['169.254.0.0', 16], ['172.16.0.0', 12],
+  ['192.0.0.0', 24], ['192.0.2.0', 24], ['192.88.99.0', 24], ['192.168.0.0', 16], ['198.18.0.0', 15],
+  ['198.51.100.0', 24], ['203.0.113.0', 24], ['224.0.0.0', 4], ['240.0.0.0', 4],
+] as const) blocked.addSubnet(address, prefix, 'ipv4');
+for (const [address, prefix] of [
+  ['2001::', 32], ['2001:10::', 28], ['2001:20::', 28], ['2001:db8::', 32], ['2002::', 16],
+] as const) blocked.addSubnet(address, prefix, 'ipv6');
+const globalV6 = new BlockList();
+globalV6.addSubnet('2000::', 3, 'ipv6');
+
+export function publicConnectorAddress(address: string, family: number): boolean {
+  if (family === 4) return isIP(address) === 4 && !blocked.check(address, 'ipv4');
+  return isIP(address) === 6 && globalV6.check(address, 'ipv6') && !blocked.check(address, 'ipv6');
+}
+
+function publicHost(host: string): boolean {
+  const family = isIP(host);
+  if (family !== 0) return publicConnectorAddress(host, family);
+  if (/(^|\.)(localhost|local|internal|lan|home|invalid|test|onion)$/.test(host)) return false;
+  return host.includes('.') && host.split('.').every((label) => /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label));
+}
+
+function invalidText(raw: string): boolean {
+  return raw.length > 2048 || /[\s\\#]/.test(raw) || /%(?![0-9a-f]{2})/i.test(raw);
+}
+
+export function parsePublicConnectorUrl(raw: unknown): URL {
+  const invalid = (): never => { throw refused('An organization endpoint must be a public HTTPS URL without user information or a fragment.'); };
+  if (typeof raw !== 'string' || invalidText(raw)) return invalid();
+  const authority = /^https:\/\/([^/ ?#]+)/i.exec(raw)?.[1];
+  if (authority === undefined || authority.includes('@')) return invalid();
+  let url: URL;
+  try { url = parseConnectorUrl(raw); } catch { return invalid(); }
+  if (url.toString().length > 2048 || !publicHost(url.hostname.replace(/^\[|\]$/g, ''))) return invalid();
+  return url;
+}
+
+export function publicOAuthResource(raw: unknown): string {
+  try {
+    const url = parsePublicConnectorUrl(raw);
+    if (typeof raw === 'string' && !raw.includes('?') && url.search === '') return raw;
+  } catch {
+    throw refused('The public OAuth resource must be a public HTTPS identifier without a query, user information or a fragment. Do not enter credentials.');
+  }
+  throw refused('The public OAuth resource must be a public HTTPS identifier without a query, user information or a fragment. Do not enter credentials.');
+}
+
+export function optionalOAuthResource(raw: unknown): string | undefined {
+  return raw === undefined || raw === '' ? undefined : publicOAuthResource(raw);
+}
+
+export function boundOAuthResource(target: string, raw: unknown): string {
+  const resource = publicOAuthResource(raw);
+  const transport = parsePublicConnectorUrl(target);
+  const url = new URL(resource);
+  const path = url.pathname.replace(/\/$/, '');
+  if (url.origin !== transport.origin || !(path === '' || transport.pathname === path || transport.pathname.startsWith(`${path}/`))) throw refused('The public OAuth resource does not identify this endpoint. Check the provider’s documented resource.');
+  return resource;
+}

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

@@ -0,0 +1,108 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import type { FetchLike } from '@metro-labs/core/stations/oauth';
+import { authServerMetadataUrls, resourceMetadataUrls, type OAuthServer } from './connector-discovery.js';
+import { boundOAuthResource, optionalOAuthResource, parsePublicConnectorUrl, publicOAuthResource } from './connector-public-url.js';
+import { refused, ConnectorVerifyError } from './connector-url.js';
+
+const METADATA_MAX = 1024 * 1024;
+const metadataError = (): Error => refused('The provider returned invalid or unavailable public OAuth metadata. Check its public OAuth resource and try again.');
+export class OAuthResourceRequired extends ConnectorVerifyError {
+  constructor() { super('Enter the provider’s public OAuth resource before continuing. It is shown in the sign-in page; never enter a private endpoint or credentials.', 400); }
+}
+
+async function metadataBody(res: Response): Promise<Record<string, unknown>> {
+  if (res.body === null) throw metadataError();
+  const reader = res.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.length;
+      if (size > METADATA_MAX) throw metadataError();
+      chunks.push(value);
+    }
+    const body: unknown = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    if (!isRecord(body)) throw metadataError();
+    return body;
+  } finally {
+    await reader.cancel().catch(() => undefined);
+  }
+}
+
+async function metadata(url: URL, send: FetchLike): Promise<Record<string, unknown> | null> {
+  try {
+    const res = await send(url.toString(), { redirect: 'manual', signal: AbortSignal.timeout(10_000), headers: { accept: 'application/json' } });
+    if (res.status === 404) {
+      await res.body?.cancel();
+      return null;
+    }
+    if (!res.ok) {
+      await res.body?.cancel();
+      throw metadataError();
+    }
+    return await metadataBody(res);
+  } catch {
+    throw metadataError();
+  }
+}
+
+function selectedResource(transport: URL, offered: string | undefined, body: Record<string, unknown> | null): string {
+  const advertised = body !== null && Object.hasOwn(body, 'resource') ? publicOAuthResource(body.resource) : undefined;
+  if (advertised !== undefined && offered !== undefined && advertised !== offered) throw metadataError();
+  const resource = advertised ?? offered;
+  if (resource === undefined) throw new OAuthResourceRequired();
+  return boundOAuthResource(transport.toString(), resource);
+}
+
+function issuerOf(body: Record<string, unknown> | null, transport: URL): string {
+  if (body === null || !Object.hasOwn(body, 'authorization_servers')) return transport.origin;
+  const servers = body.authorization_servers;
+  if (!Array.isArray(servers) || servers.length === 0 || servers.length > 20) throw metadataError();
+  const values = servers.map((value: unknown) => publicOAuthResource(value));
+  return values[0] ?? '';
+}
+
+function scopesOf(body: Record<string, unknown> | null): string[] {
+  if (body === null || !Object.hasOwn(body, 'scopes_supported')) return [];
+  const scopes = body.scopes_supported;
+  if (!Array.isArray(scopes) || scopes.length > 100 || scopes.some((scope: unknown) => typeof scope !== 'string' || !/^[\x21\x23-\x5b\x5d-\x7e]{1,128}$/.test(scope))) throw metadataError();
+  return [...new Set(scopes as string[])];
+}
+
+function serverOf(body: Record<string, unknown>, issuer: string, scopes: string[]): OAuthServer {
+  if (typeof body.issuer !== 'string' || publicOAuthResource(body.issuer) !== issuer) throw metadataError();
+  const endpoint = (raw: unknown): string => parsePublicConnectorUrl(raw).toString();
+  return {
+    issuer,
+    authorizationEndpoint: endpoint(body.authorization_endpoint),
+    tokenEndpoint: endpoint(body.token_endpoint),
+    registrationEndpoint: body.registration_endpoint === undefined ? null : endpoint(body.registration_endpoint),
+    supportsS256: Array.isArray(body.code_challenge_methods_supported) && body.code_challenge_methods_supported.includes('S256'),
+    scopes,
+  };
+}
+
+async function protectedMetadata(base: URL, send: FetchLike): Promise<Record<string, unknown> | null> {
+  for (const candidate of resourceMetadataUrls(base)) {
+    const body = await metadata(candidate, send);
+    if (body !== null) return body;
+  }
+  return null;
+}
+
+export async function discoverPublicOAuth(target: string, offered: unknown, send: FetchLike = fetch): Promise<{ server: OAuthServer; resource: string }> {
+  const transport = parsePublicConnectorUrl(target);
+  const explicit = optionalOAuthResource(offered);
+  if (explicit !== undefined) boundOAuthResource(target, explicit);
+  const body = await protectedMetadata(new URL(explicit ?? transport.origin), send);
+  const resource = selectedResource(transport, explicit, body);
+  const issuer = issuerOf(body, transport);
+  const scopes = scopesOf(body);
+  for (const candidate of authServerMetadataUrls(new URL(issuer))) {
+    const authorization = await metadata(candidate, send);
+    if (authorization !== null) return { server: serverOf(authorization, issuer, scopes), resource };
+  }
+  throw metadataError();
+}

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.290"
+  "version": "0.1.0-beta.291"
 }

package/runtime/sdk-runner/runner.json

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