@modelcontextprotocol/inspector 2.1.0 → 2.3.0

package/clients/web/build/index.js

@@ -180,6 +180,38 @@ function envPairsToRecord(pairs) {
   }
   return out;
 }
+function cleanAuthorizationParams(params) {
+  if (params === void 0) return void 0;
+  if (typeof params !== "object" || params === null || Array.isArray(params)) {
+    console.warn(
+      "Ignoring `oauth.authorizationParams`: expected an object of string values, got",
+      Array.isArray(params) ? "array" : typeof params
+    );
+    return void 0;
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (typeof value !== "string") {
+      console.warn(
+        `Dropping \`oauth.authorizationParams.${key}\`: expected a string value, got ${typeof value}.`
+      );
+      continue;
+    }
+    if (key.trim() === "") continue;
+    out[key] = value;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function cleanEndpointOverride(value, field) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") {
+    console.warn(
+      `Ignoring \`oauth.${field}\`: expected a string, got ${typeof value}.`
+    );
+    return void 0;
+  }
+  return value.trim() || void 0;
+}
 function storedFieldsToInspectorSettings(stored) {
   const hasAny = stored.headers !== void 0 || stored.metadata !== void 0 || stored.connectionTimeout !== void 0 || stored.requestTimeout !== void 0 || stored.taskTtl !== void 0 || stored.autoRefreshOnListChanged !== void 0 || stored.paginatedLists !== void 0 || stored.advertisedExtensions !== void 0 || stored.maxFetchRequests !== void 0 || stored.oauth !== void 0 || stored.roots !== void 0 || stored.protocolEra !== void 0 || stored.modernLogLevel !== void 0 || stored.env !== void 0 || stored.cwd !== void 0;
   if (!hasAny) return void 0;
@@ -217,6 +249,19 @@ function storedFieldsToInspectorSettings(stored) {
   if (stored.oauth?.clientSecret)
     settings.oauthClientSecret = stored.oauth.clientSecret;
   if (stored.oauth?.scopes) settings.oauthScopes = stored.oauth.scopes;
+  const authorizationParams = cleanAuthorizationParams(
+    stored.oauth?.authorizationParams
+  );
+  if (authorizationParams) {
+    settings.oauthAuthorizationParams = envRecordToPairs(authorizationParams);
+  }
+  const authorizationUrl = cleanEndpointOverride(
+    stored.oauth?.authorizationUrl,
+    "authorizationUrl"
+  );
+  if (authorizationUrl) settings.oauthAuthorizationUrl = authorizationUrl;
+  const tokenUrl = cleanEndpointOverride(stored.oauth?.tokenUrl, "tokenUrl");
+  if (tokenUrl) settings.oauthTokenUrl = tokenUrl;
   if (stored.oauth?.onInsufficientScope) {
     settings.oauthOnInsufficientScope = stored.oauth.onInsufficientScope;
   }
@@ -272,6 +317,18 @@ function inspectorSettingsToStoredFields(settings) {
   if (settings.oauthClientSecret)
     oauthFields.clientSecret = settings.oauthClientSecret;
   if (settings.oauthScopes) oauthFields.scopes = settings.oauthScopes;
+  if (settings.oauthAuthorizationParams) {
+    const authParams = envPairsToRecord(settings.oauthAuthorizationParams);
+    if (Object.keys(authParams).length > 0) {
+      oauthFields.authorizationParams = authParams;
+    }
+  }
+  if (settings.oauthAuthorizationUrl?.trim()) {
+    oauthFields.authorizationUrl = settings.oauthAuthorizationUrl.trim();
+  }
+  if (settings.oauthTokenUrl?.trim()) {
+    oauthFields.tokenUrl = settings.oauthTokenUrl.trim();
+  }
   if (settings.oauthOnInsufficientScope) {
     oauthFields.onInsufficientScope = settings.oauthOnInsufficientScope;
   }
@@ -318,14 +375,7 @@ function extractSecretsFromStored(stored) {
   const stripped = { ...stored };
   if (stored.oauth?.clientSecret) {
     secrets[SECRET_FIELD_OAUTH_CLIENT_SECRET] = stored.oauth.clientSecret;
-    const restOauth = {};
-    if (stored.oauth.clientId !== void 0)
-      restOauth.clientId = stored.oauth.clientId;
-    if (stored.oauth.scopes !== void 0)
-      restOauth.scopes = stored.oauth.scopes;
-    if (stored.oauth.enterpriseManaged === true) {
-      restOauth.enterpriseManaged = true;
-    }
+    const { clientSecret: _clientSecret, ...restOauth } = stored.oauth;
     if (Object.keys(restOauth).length > 0) {
       stripped.oauth = restOauth;
     } else {
@@ -608,6 +658,7 @@ function resolveServerConfigs(options, mode) {
 }
 
 // server/web-server-config.ts
+import open from "open";
 import pino from "pino";
 
 // ../../core/mcp/remote/constants.ts
@@ -710,6 +761,25 @@ function isAllInterfacesHost(host) {
   return ALL_INTERFACES_LITERALS.has(normalized) || isAllZeroIpv4(normalized);
 }
 
+// server/resolve-bind-host.ts
+var BIND_ALL_INTERFACES_ENV = "DANGEROUSLY_BIND_ALL_INTERFACES";
+function isEnabled(value) {
+  const v = value?.trim().toLowerCase();
+  return v === "true" || v === "1";
+}
+var DEFAULT_BIND_HOST = "127.0.0.1";
+function resolveBindHostname(env = process.env) {
+  const host = (env.HOST ?? DEFAULT_BIND_HOST).trim();
+  if (isAllInterfacesHost(host) && !isEnabled(env[BIND_ALL_INTERFACES_ENV])) {
+    const resolved = canonicalUrlHost(host);
+    const shown = stripBrackets(resolved) === stripBrackets(host.toLowerCase()) ? `HOST="${host}"` : `HOST="${host}" (resolves to ${resolved})`;
+    throw new Error(
+      `Refusing to bind ${shown}: this exposes the MCP Inspector to your entire network, and its backend can spawn local processes and connect to MCP servers on your behalf \u2014 the exposure DNS-rebinding attacks target. Bind a loopback host (localhost / 127.0.0.1) instead. To override \u2014 only inside an isolated container or trusted network \u2014 set ${BIND_ALL_INTERFACES_ENV}=true.`
+    );
+  }
+  return stripBrackets(host);
+}
+
 // server/sandbox-controller.ts
 var __dirname = dirname4(fileURLToPath2(import.meta.url));
 var LOOPBACK_FRAME_ANCESTORS = ["http://127.0.0.1:*", "http://localhost:*"];
@@ -725,6 +795,7 @@ function parseListenPort(raw) {
   const n = parseInt(v, 10);
   return n <= 65535 ? n : void 0;
 }
+var DEFAULT_SANDBOX_PORT = 6275;
 function resolveSandboxPort() {
   const fromSandbox = parseListenPort(process.env.MCP_SANDBOX_PORT);
   if (fromSandbox === void 0 && process.env.MCP_SANDBOX_PORT?.trim()) {
@@ -732,10 +803,10 @@ function resolveSandboxPort() {
       `Ignoring invalid MCP_SANDBOX_PORT="${process.env.MCP_SANDBOX_PORT}" (need an integer 0\u201365535); falling back.`
     );
   }
-  return fromSandbox ?? parseListenPort(process.env.SERVER_PORT) ?? 0;
+  return fromSandbox ?? parseListenPort(process.env.SERVER_PORT) ?? DEFAULT_SANDBOX_PORT;
 }
 function createSandboxController(options) {
-  const { port, host = "localhost", allowedOrigins } = options;
+  const { port, host = DEFAULT_BIND_HOST, allowedOrigins } = options;
   let server = null;
   let sandboxUrl = null;
   const SANDBOX_PROXY_CSP = sandboxFrameAncestors(allowedOrigins);
@@ -773,8 +844,17 @@ function createSandboxController(options) {
           });
           res.end(sandboxHtml);
         });
+        let retriedDynamic = false;
         server.on("error", (err) => {
           if (err.code === "EADDRINUSE") {
+            if (!retriedDynamic && port !== 0) {
+              retriedDynamic = true;
+              console.warn(
+                `Sandbox: port ${port} in use; falling back to an OS-assigned port. The MCP Apps tab will work locally, but the sandbox is no longer on a predictable port \u2014 set MCP_SANDBOX_PORT to a free one if you need to forward it (container / SSH tunnel / reverse proxy).`
+              );
+              server.listen(0, host);
+              return;
+            }
             console.error(
               `Sandbox: port ${port || "dynamic"} in use. MCP Apps tab may not work.`
             );
@@ -816,24 +896,6 @@ function createSandboxController(options) {
   };
 }
 
-// server/resolve-bind-host.ts
-var BIND_ALL_INTERFACES_ENV = "DANGEROUSLY_BIND_ALL_INTERFACES";
-function isEnabled(value) {
-  const v = value?.trim().toLowerCase();
-  return v === "true" || v === "1";
-}
-function resolveBindHostname(env = process.env) {
-  const host = (env.HOST ?? "localhost").trim();
-  if (isAllInterfacesHost(host) && !isEnabled(env[BIND_ALL_INTERFACES_ENV])) {
-    const resolved = canonicalUrlHost(host);
-    const shown = stripBrackets(resolved) === stripBrackets(host.toLowerCase()) ? `HOST="${host}"` : `HOST="${host}" (resolves to ${resolved})`;
-    throw new Error(
-      `Refusing to bind ${shown}: this exposes the MCP Inspector to your entire network, and its backend can spawn local processes and connect to MCP servers on your behalf \u2014 the exposure DNS-rebinding attacks target. Bind a loopback host (localhost / 127.0.0.1) instead. To override \u2014 only inside an isolated container or trusted network \u2014 set ${BIND_ALL_INTERFACES_ENV}=true.`
-    );
-  }
-  return stripBrackets(host);
-}
-
 // server/web-server-config.ts
 var inspectorVersion = readInspectorVersionSafe(import.meta.url);
 function defaultEnvironmentFromProcess(extra) {
@@ -928,6 +990,11 @@ MCP Inspector Web is up and running at:
   }
   return url;
 }
+function openBrowser(url) {
+  open(url).catch((err) => {
+    console.warn("Could not open a browser automatically:", err);
+  });
+}
 var LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
 function httpOrigin(host, port) {
   return port === 80 ? `http://${host}` : `http://${host}:${port}`;
@@ -1023,9 +1090,6 @@ import { fileURLToPath as fileURLToPath4 } from "url";
 import { createServer as createServer2 } from "vite";
 import react from "@vitejs/plugin-react";
 
-// server/vite-hono-plugin.ts
-import open from "open";
-
 // ../../core/mcp/remote/node/server.ts
 import { randomBytes, timingSafeEqual } from "crypto";
 import { existsSync as existsSync2, readFileSync as readFileSync4 } from "fs";
@@ -1395,7 +1459,7 @@ function withProxyDispatcher(baseFetch) {
   if (readProxyEnv() === void 0) return baseFetch;
   let dispatcherPromise;
   const getDispatcher = () => {
-    dispatcherPromise ??= import("./undici-HXPKCIY3.js").then(
+    dispatcherPromise ??= import("./undici-KNXAVD2F.js").then(
       ({ EnvHttpProxyAgent }) => new EnvHttpProxyAgent(),
       (cause) => {
         throw new Error(
@@ -1680,6 +1744,9 @@ var RemoteSession = class _RemoteSession {
   static AUTH_HTTP_ECHO_SUPPRESS_MS = 3e4;
   requestWaits = /* @__PURE__ */ new Map();
   authProviderHandle = null;
+  appliedProtocolVersion;
+  /** A protocol version is a dated token (`2025-11-25`, `2026-07-28`, …). */
+  static PROTOCOL_VERSION_PATTERN = /^[A-Za-z0-9._-]{1,64}$/;
   constructor(sessionId) {
     this.sessionId = sessionId;
   }
@@ -1695,6 +1762,27 @@ var RemoteSession = class _RemoteSession {
   setTransport(transport) {
     this.transport = transport;
   }
+  /**
+   * Apply the client's negotiated protocol version to the upstream transport
+   * (#1935). The browser's SDK Client owns the `initialize` handshake, so the
+   * `setProtocolVersion` call it makes lands on the *remote* transport; without
+   * this the backend's real HTTP transport never learns the version and drops
+   * `Mcp-Protocol-Version` from every subsequent request.
+   *
+   * Ignores anything that isn't a plausible version token so a client can't
+   * push arbitrary bytes into an upstream header, and re-applies only on
+   * change (the value rides every `/api/mcp/send`). The value arrives from an
+   * unvalidated JSON body, so the type is checked rather than assumed —
+   * `RegExp.test` would otherwise coerce a `123` or `true` into a "matching"
+   * string and hand the wrong type to the transport.
+   */
+  applyProtocolVersion(version) {
+    if (typeof version !== "string" || version === this.appliedProtocolVersion || !_RemoteSession.PROTOCOL_VERSION_PATTERN.test(version)) {
+      return;
+    }
+    this.appliedProtocolVersion = version;
+    this.transport.setProtocolVersion?.(version);
+  }
   setEventConsumer(consumer) {
     this.eventConsumer = consumer;
     while (this.eventQueue.length > 0) {
@@ -1953,8 +2041,42 @@ function createRemoteAuthProvider(initialAuthState) {
 }
 
 // ../../core/auth/node/secret-store.ts
-import { AsyncEntry, findCredentialsAsync } from "@napi-rs/keyring";
 var SERVICE_NAME = "mcp-inspector";
+var keyringLoad;
+var KeyringModuleShapeError = class extends Error {
+  constructor(detail, options) {
+    super(`@napi-rs/keyring loaded but ${detail}`, options);
+    this.name = "KeyringModuleShapeError";
+  }
+};
+var checkKeyringShape = (mod) => {
+  try {
+    if (typeof mod.AsyncEntry === "function" && typeof mod.findCredentialsAsync === "function") {
+      return { ok: true, mod };
+    }
+    return {
+      ok: false,
+      err: new KeyringModuleShapeError(
+        "did not expose AsyncEntry / findCredentialsAsync"
+      )
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      err: new KeyringModuleShapeError(
+        `its exports could not be read: ${err instanceof Error ? err.message : String(err)}`,
+        { cause: err }
+      )
+    };
+  }
+};
+var loadKeyring = () => {
+  keyringLoad ??= import("@napi-rs/keyring").then(
+    checkKeyringShape,
+    (err) => ({ ok: false, err })
+  );
+  return keyringLoad;
+};
 function parseAccount(account) {
   const idx = account.indexOf(":");
   if (idx <= 0 || idx === account.length - 1) return null;
@@ -1966,16 +2088,31 @@ function parseAccount(account) {
 var buildAccount = (serverId, field) => `${serverId}:${field}`;
 var KeychainUnavailableError = class extends Error {
   constructor(cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
     super(
-      `OS keychain is not available. On Linux, install libsecret / gnome-keyring. Underlying error: ${cause instanceof Error ? cause.message : String(cause)}`
+      `OS keychain is not available. ${hintFor(cause, message)} Underlying error: ${message}`
     );
     this.name = "KeychainUnavailableError";
   }
 };
+var hintFor = (cause, message) => {
+  if (cause instanceof KeyringModuleShapeError) {
+    return `The @napi-rs/keyring package loaded but does not expose the API this build expects \u2014 most likely a version or packaging mismatch; reinstall the Inspector, and report this if it persists.`;
+  }
+  if (message.includes("Cannot find native binding")) {
+    return `The @napi-rs/keyring platform package for this OS is missing or unavailable \u2014 reinstall the Inspector (for npx, clear the npx cache under your npm cache directory first).`;
+  }
+  return `On Linux, install libsecret / gnome-keyring.`;
+};
 var KeyringSecretStore = class {
   async get(serverId, field) {
-    const entry = new AsyncEntry(SERVICE_NAME, buildAccount(serverId, field));
     try {
+      const keyring = await loadKeyring();
+      if (!keyring.ok) return null;
+      const entry = new keyring.mod.AsyncEntry(
+        SERVICE_NAME,
+        buildAccount(serverId, field)
+      );
       const v = await entry.getPassword();
       return v ?? null;
     } catch {
@@ -1983,16 +2120,27 @@ var KeyringSecretStore = class {
     }
   }
   async set(serverId, field, value) {
-    const entry = new AsyncEntry(SERVICE_NAME, buildAccount(serverId, field));
     try {
+      const keyring = await loadKeyring();
+      if (!keyring.ok) throw new KeychainUnavailableError(keyring.err);
+      const entry = new keyring.mod.AsyncEntry(
+        SERVICE_NAME,
+        buildAccount(serverId, field)
+      );
       await entry.setPassword(value);
     } catch (err) {
+      if (err instanceof KeychainUnavailableError) throw err;
       throw new KeychainUnavailableError(err);
     }
   }
   async delete(serverId, field) {
-    const entry = new AsyncEntry(SERVICE_NAME, buildAccount(serverId, field));
     try {
+      const keyring = await loadKeyring();
+      if (!keyring.ok) return;
+      const entry = new keyring.mod.AsyncEntry(
+        SERVICE_NAME,
+        buildAccount(serverId, field)
+      );
       await entry.deleteCredential();
     } catch {
     }
@@ -2000,7 +2148,9 @@ var KeyringSecretStore = class {
   async deleteAllForServer(serverId) {
     let creds;
     try {
-      creds = await findCredentialsAsync(SERVICE_NAME);
+      const keyring = await loadKeyring();
+      if (!keyring.ok) return;
+      creds = await keyring.mod.findCredentialsAsync(SERVICE_NAME);
     } catch {
       return;
     }
@@ -2232,6 +2382,25 @@ async function deleteClientConfigStore(filePath, secretStore) {
 
 // ../../core/mcp/remote/node/server.ts
 import { ZodError as ZodError2 } from "zod";
+var SSE_PRIMING_COMMENT = ":\n\n";
+function closeAbortedStream(stream) {
+  stream.close().catch(() => {
+  });
+}
+async function primeAndHoldSseStream(stream, cleanup) {
+  let done = false;
+  const aborted = new Promise((resolve6) => {
+    stream.onAbort(() => {
+      if (done) return;
+      done = true;
+      cleanup();
+      closeAbortedStream(stream);
+      resolve6();
+    });
+  });
+  await stream.write(SSE_PRIMING_COMMENT);
+  await aborted;
+}
 function createOriginMiddleware(allowedOrigins) {
   return async (c, next) => {
     if (!allowedOrigins || allowedOrigins.length === 0) {
@@ -2571,7 +2740,7 @@ function createRemoteApp(options) {
     } catch {
       return c.json({ error: "Invalid JSON body" }, 400);
     }
-    const { sessionId, message, relatedRequestId, headers } = body;
+    const { sessionId, message, relatedRequestId, headers, protocolVersion } = body;
     if (!sessionId || !message) {
       return c.json({ error: "Missing sessionId or message" }, 400);
     }
@@ -2583,6 +2752,7 @@ function createRemoteApp(options) {
       const errorMsg = session.getTransportError() || "Transport closed";
       return c.json({ ok: false, kind: "transport_error", error: errorMsg });
     }
+    session.applyProtocolVersion(protocolVersion);
     session.beginSend();
     const requestId = requestIdForSendWait(message);
     let responseWait;
@@ -2642,18 +2812,12 @@ function createRemoteApp(options) {
         sessions.delete(sessionId);
         return;
       }
-      stream.onAbort(() => {
+      await primeAndHoldSseStream(stream, () => {
         const shouldCleanup = session.clearEventConsumer();
-        stream.close();
         if (shouldCleanup || session.isTransportDead()) {
           sessions.delete(sessionId);
         }
       });
-      await new Promise((resolve6) => {
-        stream.onAbort(() => {
-          resolve6();
-        });
-      });
     });
   });
   app.post("/api/mcp/disconnect", async (c) => {
@@ -2841,9 +3005,21 @@ function createRemoteApp(options) {
   const isOauthObject = (v) => {
     if (v === null || typeof v !== "object" || Array.isArray(v)) return false;
     const o = v;
-    for (const k of ["clientId", "clientSecret", "scopes"]) {
+    for (const k of [
+      "clientId",
+      "clientSecret",
+      "scopes",
+      // #1906 — shape only; the values are validated as absolute http(s) URLs
+      // where they're applied (core/auth/endpointOverrides.ts), so a typo drops
+      // one field with a warning instead of dropping the whole `oauth` block.
+      "authorizationUrl",
+      "tokenUrl"
+    ]) {
       if (o[k] !== void 0 && typeof o[k] !== "string") return false;
     }
+    if (o.authorizationParams !== void 0 && !isStringRecord(o.authorizationParams)) {
+      return false;
+    }
     if (o.enterpriseManaged !== void 0 && typeof o.enterpriseManaged !== "boolean") {
       return false;
     }
@@ -2918,7 +3094,7 @@ function createRemoteApp(options) {
       if ("oauth" in valObj && !isOauthObject(valObj.oauth)) {
         logWarn(
           { route: "/api/servers", id, droppedKey: "oauth" },
-          "Dropping malformed `oauth` field \u2014 expected `{ clientId?, clientSecret?, scopes?, enterpriseManaged? }`."
+          "Dropping malformed `oauth` field \u2014 expected `{ clientId?, clientSecret?, scopes?, authorizationParams?, authorizationUrl?, tokenUrl?, enterpriseManaged?, onInsufficientScope? }`."
         );
         delete valObj.oauth;
       }
@@ -3075,12 +3251,22 @@ function createRemoteApp(options) {
     for (const optional of [
       "oauthClientId",
       "oauthClientSecret",
-      "oauthScopes"
+      "oauthScopes",
+      // #1906 — string-shaped on the wire; URL validity is checked where the
+      // override is applied, not here.
+      "oauthAuthorizationUrl",
+      "oauthTokenUrl"
     ]) {
       if (obj[optional] !== void 0 && typeof obj[optional] !== "string") {
         return { ok: false, error: `settings.${optional} must be a string` };
       }
     }
+    if (obj.oauthAuthorizationParams !== void 0 && !isKvArray2(obj.oauthAuthorizationParams)) {
+      return {
+        ok: false,
+        error: "settings.oauthAuthorizationParams must be an array of { key, value }"
+      };
+    }
     if (obj.enterpriseManaged !== void 0 && typeof obj.enterpriseManaged !== "boolean") {
       return {
         ok: false,
@@ -3154,6 +3340,15 @@ function createRemoteApp(options) {
     if (typeof obj.oauthScopes === "string" && obj.oauthScopes !== "") {
       value.oauthScopes = obj.oauthScopes;
     }
+    if (isKvArray2(obj.oauthAuthorizationParams)) {
+      value.oauthAuthorizationParams = obj.oauthAuthorizationParams;
+    }
+    if (typeof obj.oauthAuthorizationUrl === "string" && obj.oauthAuthorizationUrl !== "") {
+      value.oauthAuthorizationUrl = obj.oauthAuthorizationUrl;
+    }
+    if (typeof obj.oauthTokenUrl === "string" && obj.oauthTokenUrl !== "") {
+      value.oauthTokenUrl = obj.oauthTokenUrl;
+    }
     if (obj.enterpriseManaged === true) {
       value.enterpriseManaged = true;
     }
@@ -3612,13 +3807,9 @@ function createRemoteApp(options) {
         serverEventSubscribers.add(send);
         ensureWatcher();
       }
-      stream.onAbort(() => {
+      await primeAndHoldSseStream(stream, () => {
         serverEventSubscribers.delete(send);
         void maybeStopWatcher();
-        stream.close();
-      });
-      await new Promise((resolve6) => {
-        stream.onAbort(() => resolve6());
       });
     });
   });
@@ -3717,7 +3908,7 @@ function honoMiddlewarePlugin(config) {
           sandboxUrl ?? void 0
         );
         if (config.autoOpen) {
-          open(url);
+          openBrowser(url);
         }
       };
       server.httpServer.once("listening", () => {
@@ -3852,7 +4043,9 @@ var NODE_ONLY_OPTIMIZE_DEPS_EXCLUDE = [
   "which",
   // `@napi-rs/keyring` is loaded only inside
   // `core/auth/node/secret-store.ts` from the Hono `/api/servers`
-  // handlers. It's a native-binding package (no browser code path) so
+  // handlers — and lazily even there, via a cached dynamic import, so
+  // an unsupported platform degrades instead of crashing at startup
+  // (#1905). It's a native-binding package (no browser code path) so
   // excluding it keeps Vite's dep scanner from chasing into the
   // platform-specific binaries during dev startup.
   "@napi-rs/keyring"
@@ -3947,9 +4140,20 @@ function vitestSharedPaths(clientDir) {
       find: /^@napi-rs\/keyring$/,
       replacement: path2.resolve(dirname8, "node_modules/@napi-rs/keyring")
     },
+    // `express` and `yaml` resolve from the **repo root**, unlike every pin
+    // above. Both are reached only through `test-servers/src` — express by the
+    // http/oauth servers, yaml by `load-config.ts` — which is root-owned code
+    // with no manifest of its own, so the root is where they are declared and
+    // the only place a client's resolution chain is guaranteed to find them.
+    // Pointing these at `<client>/node_modules` is what broke when the MCP
+    // packages moved to the root (#1970): express was never declared by a client
+    // at all, it arrived in `clients/cli` as a peer of `express-rate-limit`
+    // under `@modelcontextprotocol/server-legacy`, so removing that manifest
+    // entry took express with it and every cli test that spawns a test server
+    // failed to resolve it.
     {
       find: /^express$/,
-      replacement: path2.resolve(dirname8, "node_modules/express")
+      replacement: path2.resolve(repoRoot, "node_modules/express")
     },
     {
       find: /^yaml$/,
@@ -4026,7 +4230,6 @@ import { readFileSync as readFileSync5 } from "fs";
 import { join as join7, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { randomBytes as randomBytes2 } from "crypto";
-import open2 from "open";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { Hono as Hono2 } from "hono";
@@ -4098,7 +4301,7 @@ async function startHonoServer(config) {
         sandboxUrl ?? void 0
       );
       if (config.autoOpen) {
-        open2(url);
+        openBrowser(url);
       }
     }
   );