@wrongstack/mcp 0.303.0 → 0.305.0

package/dist/authorization-manager.d.ts

@@ -49,6 +49,7 @@ export interface MCPAuthorizationStatus {
 export declare class MCPAuthorizationManager {
     private readonly options;
     private readonly pending;
+    private readonly starting;
     private readonly pendingTtlMs;
     private readonly discover;
     private readonly exchange;
@@ -59,6 +60,7 @@ export declare class MCPAuthorizationManager {
     status(serverName: string, resource: string): Promise<MCPAuthorizationStatus>;
     disconnect(serverName: string, resource: string): Promise<boolean>;
     private pruneExpired;
+    private activeAuthorizationCount;
     private emit;
 }
 export {};

package/dist/authorization.d.ts

@@ -28,6 +28,7 @@ export interface MCPAuthorizationServerMetadata {
     authorizationEndpoint: string;
     tokenEndpoint: string;
     registrationEndpoint?: string | undefined;
+    authorizationResponseIssuerParameterSupported?: boolean | undefined;
     scopesSupported: string[];
 }
 export interface MCPAuthorizationDiscoveryResult {
@@ -53,6 +54,8 @@ export interface MCPAuthorizationSession {
     redirectUri: string;
     clientId: string;
     resource: string;
+    issuer: string;
+    requireIssuerParameter: boolean;
 }
 export interface MCPTokenSet extends MCPAccessToken {
     refreshToken?: string | undefined;
@@ -121,7 +124,7 @@ export declare function validateMcpAuthorizationServerMetadata(value: unknown):
  */
 export declare function discoverMcpAuthorization(resource: string, options?: MCPAuthorizationDiscoveryOptions): Promise<MCPAuthorizationDiscoveryResult>;
 export declare function createMcpAuthorizationRequest(options: MCPAuthorizationRequestOptions): MCPAuthorizationSession;
-export declare function parseMcpAuthorizationCallback(callbackUrl: string, session: Pick<MCPAuthorizationSession, 'redirectUri' | 'state'>): string;
+export declare function parseMcpAuthorizationCallback(callbackUrl: string, session: Pick<MCPAuthorizationSession, 'redirectUri' | 'state' | 'issuer' | 'requireIssuerParameter'>): string;
 export declare function exchangeMcpAuthorizationCode(options: MCPTokenExchangeOptions): Promise<MCPTokenSet>;
 export declare function refreshMcpAccessToken(options: MCPTokenRefreshOptions): Promise<MCPTokenSet>;
 export {};

package/dist/client.d.ts

@@ -1,7 +1,7 @@
 import type { MCPAuthorizationProvider } from './authorization.js';
 import { type MCPGetPromptResult, type MCPListPromptsResult, type MCPListResourcesResult, type MCPListResourceTemplatesResult, type MCPReadResourceResult, type MCPServerMetadata } from './protocol.js';
-export { quoteWindowsArg } from './client-protocol-helpers.js';
 export { forceKillTree } from './client-process.js';
+export { quoteWindowsArg } from './client-protocol-helpers.js';
 export type Transport = 'stdio' | 'sse' | 'streamable-http';
 export interface MCPClientOptions {
     name: string;

package/dist/index.js

@@ -120,34 +120,59 @@ function parseAuthorizationServerMetadata(value, expectedIssuer) {
     throw new Error("MCP authorization server does not advertise required PKCE S256 support");
   }
   const registration = optionalString(metadata["registration_endpoint"], "registration_endpoint");
+  const authorizationEndpoint = secureOAuthUrl(
+    requiredString(metadata["authorization_endpoint"], "authorization_endpoint"),
+    "authorization endpoint"
+  ).toString();
+  const tokenEndpoint = secureOAuthUrl(
+    requiredString(metadata["token_endpoint"], "token_endpoint"),
+    "token endpoint"
+  ).toString();
+  const issuerParameterSupported = optionalBoolean(
+    metadata["authorization_response_iss_parameter_supported"],
+    "authorization_response_iss_parameter_supported"
+  );
+  if (issuerParameterSupported !== true && (new URL(authorizationEndpoint).origin !== new URL(issuer).origin || new URL(tokenEndpoint).origin !== new URL(issuer).origin)) {
+    throw new Error(
+      "MCP authorization server with cross-origin endpoints must support the authorization response issuer parameter"
+    );
+  }
   return {
     issuer,
-    authorizationEndpoint: secureOAuthUrl(
-      requiredString(metadata["authorization_endpoint"], "authorization_endpoint"),
-      "authorization endpoint"
-    ).toString(),
-    tokenEndpoint: secureOAuthUrl(
-      requiredString(metadata["token_endpoint"], "token_endpoint"),
-      "token endpoint"
-    ).toString(),
+    authorizationEndpoint,
+    tokenEndpoint,
     registrationEndpoint: registration ? secureOAuthUrl(registration, "registration endpoint").toString() : void 0,
+    authorizationResponseIssuerParameterSupported: issuerParameterSupported,
     scopesSupported: optionalStringArray(metadata["scopes_supported"], "scopes_supported", 128)
   };
 }
 function validateMcpAuthorizationServerMetadata(value) {
   const metadata = record(value, "stored authorization server metadata");
   const registration = optionalString(metadata["registrationEndpoint"], "registrationEndpoint");
+  const issuer = secureOAuthUrl(requiredString(metadata["issuer"], "issuer"), "issuer").toString();
+  const authorizationEndpoint = secureOAuthUrl(
+    requiredString(metadata["authorizationEndpoint"], "authorizationEndpoint"),
+    "authorization endpoint"
+  ).toString();
+  const tokenEndpoint = secureOAuthUrl(
+    requiredString(metadata["tokenEndpoint"], "tokenEndpoint"),
+    "token endpoint"
+  ).toString();
+  const issuerParameterSupported = optionalBoolean(
+    metadata["authorizationResponseIssuerParameterSupported"],
+    "authorizationResponseIssuerParameterSupported"
+  );
+  if (issuerParameterSupported !== true && (new URL(authorizationEndpoint).origin !== new URL(issuer).origin || new URL(tokenEndpoint).origin !== new URL(issuer).origin)) {
+    throw new Error(
+      "MCP authorization server with cross-origin endpoints must support the authorization response issuer parameter"
+    );
+  }
   return {
-    issuer: secureOAuthUrl(requiredString(metadata["issuer"], "issuer"), "issuer").toString(),
-    authorizationEndpoint: secureOAuthUrl(
-      requiredString(metadata["authorizationEndpoint"], "authorizationEndpoint"),
-      "authorization endpoint"
-    ).toString(),
-    tokenEndpoint: secureOAuthUrl(
-      requiredString(metadata["tokenEndpoint"], "tokenEndpoint"),
-      "token endpoint"
-    ).toString(),
+    issuer,
+    authorizationEndpoint,
+    tokenEndpoint,
     registrationEndpoint: registration ? secureOAuthUrl(registration, "registration endpoint").toString() : void 0,
+    authorizationResponseIssuerParameterSupported: issuerParameterSupported,
     scopesSupported: optionalStringArray(metadata["scopesSupported"], "scopesSupported", 128)
   };
 }
@@ -212,7 +237,9 @@ function createMcpAuthorizationRequest(options) {
     codeVerifier,
     redirectUri,
     clientId,
-    resource
+    resource,
+    issuer: options.authorizationServer.issuer,
+    requireIssuerParameter: options.authorizationServer.authorizationResponseIssuerParameterSupported === true
   };
 }
 function parseMcpAuthorizationCallback(callbackUrl, session) {
@@ -226,14 +253,33 @@ function parseMcpAuthorizationCallback(callbackUrl, session) {
   if (callback.protocol !== expected.protocol || callback.hostname !== expected.hostname || callback.port !== expected.port || callback.pathname !== expected.pathname) {
     throw new Error("MCP OAuth callback redirect URI does not match the authorization session");
   }
-  const returnedState = callback.searchParams.get("state") ?? "";
+  const returnedStates = callback.searchParams.getAll("state");
+  if (returnedStates.length !== 1) {
+    throw new Error("MCP OAuth callback must contain exactly one state parameter");
+  }
+  const returnedState = returnedStates[0];
   if (!constantTimeEqual(returnedState, session.state)) {
     throw new Error("MCP OAuth callback state mismatch");
   }
-  const oauthError = callback.searchParams.get("error");
-  if (oauthError)
-    throw new Error(`MCP OAuth authorization failed: ${boundedErrorCode(oauthError)}`);
-  return boundedCredential(callback.searchParams.get("code") ?? "", "authorization code");
+  const returnedIssuers = callback.searchParams.getAll("iss");
+  if (session.requireIssuerParameter && returnedIssuers.length !== 1) {
+    throw new Error("MCP OAuth callback must contain exactly one issuer parameter");
+  }
+  if (returnedIssuers.length > 0 && returnedIssuers.some((issuer) => issuer !== session.issuer)) {
+    throw new Error("MCP OAuth callback issuer mismatch");
+  }
+  const oauthErrors = callback.searchParams.getAll("error");
+  const codes = callback.searchParams.getAll("code");
+  if (oauthErrors.length > 1 || codes.length > 1 || oauthErrors.length === 1 && codes.length > 0) {
+    throw new Error("MCP OAuth callback contains ambiguous response parameters");
+  }
+  if (oauthErrors.length === 1) {
+    throw new Error(`MCP OAuth authorization failed: ${boundedErrorCode(oauthErrors[0])}`);
+  }
+  if (codes.length !== 1) {
+    throw new Error("MCP OAuth callback must contain exactly one authorization code");
+  }
+  return boundedCredential(codes[0], "authorization code");
 }
 async function exchangeMcpAuthorizationCode(options) {
   const resource = canonicalMcpResource(options.resource);
@@ -315,6 +361,13 @@ function requiredString(value, field) {
 function optionalString(value, field) {
   return value === void 0 ? void 0 : requiredString(value, field);
 }
+function optionalBoolean(value, field) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "boolean") {
+    throw new Error(`MCP authorization field "${field}" must be a boolean`);
+  }
+  return value;
+}
 function boundedStringArray(value, field, maxItems) {
   if (!Array.isArray(value) || value.length > maxItems) {
     throw new Error(`MCP authorization field "${field}" must be an array of at most ${maxItems}`);
@@ -595,6 +648,7 @@ var MCPAuthorizationManager = class {
   }
   options;
   pending = /* @__PURE__ */ new Map();
+  starting = /* @__PURE__ */ new Map();
   pendingTtlMs;
   discover;
   exchange;
@@ -603,33 +657,48 @@ var MCPAuthorizationManager = class {
     const resource = canonicalMcpResource(input.resource);
     const key = authorizationKey(input.serverName, resource);
     this.pruneExpired();
-    if (!this.pending.has(key) && this.pending.size >= MAX_PENDING_AUTHORIZATIONS) {
+    if (this.starting.has(key)) {
+      throw new Error("MCP authorization discovery is already in progress for this server");
+    }
+    if (!this.pending.has(key) && this.activeAuthorizationCount() >= MAX_PENDING_AUTHORIZATIONS) {
       throw new Error("Too many pending MCP authorization sessions");
     }
-    const discovery = await this.discover(resource, {
-      challengeHeader: input.challengeHeader,
-      signal: input.signal
-    });
-    const challengeScopes = parseMcpBearerChallenge(input.challengeHeader ?? null, resource).scopes;
-    const scopes = input.scopes ? [...input.scopes] : challengeScopes;
-    const session = createMcpAuthorizationRequest({
-      authorizationServer: discovery.authorizationServer,
-      clientId: input.clientId,
-      redirectUri: input.redirectUri,
-      resource,
-      scopes
-    });
-    const normalizedScopes = new URL(session.authorizationUrl).searchParams.get("scope")?.split(" ").filter(Boolean) ?? [];
-    const expiresAt = this.now() + this.pendingTtlMs;
-    this.pending.set(key, { session, discovery, scopes: normalizedScopes, expiresAt });
-    return {
-      serverName: boundedServerName(input.serverName),
-      resource,
-      authorizationUrl: session.authorizationUrl,
-      redirectUri: session.redirectUri,
-      scopes: [...normalizedScopes],
-      expiresAt
-    };
+    const attempt = Symbol(key);
+    this.starting.set(key, attempt);
+    try {
+      const discovery = await this.discover(resource, {
+        challengeHeader: input.challengeHeader,
+        signal: input.signal
+      });
+      if (this.starting.get(key) !== attempt) {
+        throw new Error("MCP authorization discovery was cancelled");
+      }
+      const challengeScopes = parseMcpBearerChallenge(
+        input.challengeHeader ?? null,
+        resource
+      ).scopes;
+      const scopes = input.scopes ? [...input.scopes] : challengeScopes;
+      const session = createMcpAuthorizationRequest({
+        authorizationServer: discovery.authorizationServer,
+        clientId: input.clientId,
+        redirectUri: input.redirectUri,
+        resource,
+        scopes
+      });
+      const normalizedScopes = new URL(session.authorizationUrl).searchParams.get("scope")?.split(" ").filter(Boolean) ?? [];
+      const expiresAt = this.now() + this.pendingTtlMs;
+      this.pending.set(key, { session, discovery, scopes: normalizedScopes, expiresAt });
+      return {
+        serverName: boundedServerName(input.serverName),
+        resource,
+        authorizationUrl: session.authorizationUrl,
+        redirectUri: session.redirectUri,
+        scopes: [...normalizedScopes],
+        expiresAt
+      };
+    } finally {
+      if (this.starting.get(key) === attempt) this.starting.delete(key);
+    }
   }
   async complete(input) {
     const serverName = boundedServerName(input.serverName);
@@ -690,7 +759,9 @@ var MCPAuthorizationManager = class {
   async disconnect(serverName, resource) {
     const normalizedName = boundedServerName(serverName);
     const normalizedResource = canonicalMcpResource(resource);
-    this.pending.delete(authorizationKey(normalizedName, normalizedResource));
+    const key = authorizationKey(normalizedName, normalizedResource);
+    this.starting.delete(key);
+    this.pending.delete(key);
     const removed = await this.options.store.remove(normalizedName, normalizedResource);
     if (removed) {
       this.options.onStateChange?.({
@@ -707,6 +778,13 @@ var MCPAuthorizationManager = class {
       if (value.expiresAt <= now) this.pending.delete(key);
     }
   }
+  activeAuthorizationCount() {
+    let count = this.pending.size;
+    for (const key of this.starting.keys()) {
+      if (!this.pending.has(key)) count++;
+    }
+    return count;
+  }
   emit(state, value) {
     this.options.onStateChange?.({
       serverName: value.serverName,
@@ -741,6 +819,57 @@ function boundedServerName(value) {
 import { spawn as spawn2 } from "node:child_process";
 import { buildChildEnv, buildWin32CmdShimInvocation, toErrorMessage } from "@wrongstack/core/utils";
 
+// src/client-process.ts
+import { spawn } from "node:child_process";
+function forceKillTree(child) {
+  if (child.pid === void 0) {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+    return;
+  }
+  if (process.platform === "win32") {
+    const killer = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    killer.once("error", () => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    });
+    killer.unref();
+    return;
+  }
+  try {
+    child.kill("SIGKILL");
+  } catch {
+  }
+}
+
+// src/client-protocol-helpers.ts
+var MAX_PROTOCOL_INPUT_CHARS = 8192;
+function validateProtocolString(value, label, allowEmpty = false) {
+  if (typeof value !== "string" || !allowEmpty && value.length === 0) {
+    throw new Error(`MCP ${label} must be ${allowEmpty ? "a string" : "a non-empty string"}`);
+  }
+  if (value.length > MAX_PROTOCOL_INPUT_CHARS) {
+    throw new Error(`MCP ${label} exceeds ${MAX_PROTOCOL_INPUT_CHARS} characters`);
+  }
+}
+function pageParams(cursor, label) {
+  if (cursor === void 0) return {};
+  validateProtocolString(cursor, label);
+  return { cursor };
+}
+function parseEmptyResult(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Malformed MCP empty result: expected object");
+  }
+}
+
 // src/constants.ts
 var MCP_CONSTANTS = Object.freeze({
   /** MCP protocol version advertised during handshake. */
@@ -2040,57 +2169,6 @@ var StreamableHTTPTransport = class extends BaseHTTPTransport {
   }
 };
 
-// src/client-protocol-helpers.ts
-var MAX_PROTOCOL_INPUT_CHARS = 8192;
-function validateProtocolString(value, label, allowEmpty = false) {
-  if (typeof value !== "string" || !allowEmpty && value.length === 0) {
-    throw new Error(`MCP ${label} must be ${allowEmpty ? "a string" : "a non-empty string"}`);
-  }
-  if (value.length > MAX_PROTOCOL_INPUT_CHARS) {
-    throw new Error(`MCP ${label} exceeds ${MAX_PROTOCOL_INPUT_CHARS} characters`);
-  }
-}
-function pageParams(cursor, label) {
-  if (cursor === void 0) return {};
-  validateProtocolString(cursor, label);
-  return { cursor };
-}
-function parseEmptyResult(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("Malformed MCP empty result: expected object");
-  }
-}
-
-// src/client-process.ts
-import { spawn } from "node:child_process";
-function forceKillTree(child) {
-  if (child.pid === void 0) {
-    try {
-      child.kill("SIGKILL");
-    } catch {
-    }
-    return;
-  }
-  if (process.platform === "win32") {
-    const killer = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
-      stdio: "ignore",
-      windowsHide: true
-    });
-    killer.once("error", () => {
-      try {
-        child.kill("SIGKILL");
-      } catch {
-      }
-    });
-    killer.unref();
-    return;
-  }
-  try {
-    child.kill("SIGKILL");
-  } catch {
-  }
-}
-
 // src/client.ts
 var MCPClient = class _MCPClient {
   constructor(opts) {
@@ -2477,7 +2555,11 @@ var MCPClient = class _MCPClient {
         if (child.exitCode !== null || child.signalCode !== null) resolve();
       });
       try {
-        child.kill();
+        if (process.platform === "win32" && child.stdin && !child.stdin.destroyed && child.stdin.writable) {
+          child.stdin.end();
+        } else {
+          child.kill();
+        }
       } catch {
       }
       const GRACEFUL_MS = 800;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/mcp",
-  "version": "0.303.0",
+  "version": "0.305.0",
   "license": "MIT",
   "description": "WrongStack Model Context Protocol client and registry: stdio, SSE, and streamable HTTP transports.",
   "repository": {
@@ -26,7 +26,7 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@wrongstack/core": "0.303.0"
+    "@wrongstack/core": "0.305.0"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",