@modelcontextprotocol/inspector 2.7.0 → 2.8.0

package/clients/web/build/index.js

@@ -109,6 +109,7 @@ var MODERN_LOG_LEVELS = [
 function isModernLogLevel(value) {
   return typeof value === "string" && MODERN_LOG_LEVELS.includes(value);
 }
+var MODERN_PROTOCOL_VERSION = "2026-07-28";
 
 // ../../core/mcp/skillsSchemas.ts
 import { z } from "zod/v4";
@@ -424,7 +425,7 @@ function cleanEndpointOverride(value, field) {
   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.skillCatalogMaxSkills !== void 0 || stored.skillCatalogMaxBytes !== 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;
+  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.suppressNotificationStream !== void 0 || stored.advertisedExtensions !== void 0 || stored.maxFetchRequests !== void 0 || stored.skillCatalogMaxSkills !== void 0 || stored.skillCatalogMaxBytes !== 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;
   const headersPairs = stored.headers ? Object.entries(stored.headers).map(([key, value]) => ({ key, value })) : [];
   const settings = {
@@ -456,6 +457,9 @@ function storedFieldsToInspectorSettings(stored) {
   if (isSkillCatalogLimit(stored.skillCatalogMaxBytes)) {
     settings.skillCatalogMaxBytes = stored.skillCatalogMaxBytes;
   }
+  if (stored.suppressNotificationStream === true) {
+    settings.suppressNotificationStream = true;
+  }
   if (isProtocolEra(stored.protocolEra)) {
     settings.protocolEra = stored.protocolEra;
   }
@@ -525,6 +529,9 @@ function inspectorSettingsToStoredFields(settings) {
   if (settings.paginatedLists) {
     out.paginatedLists = true;
   }
+  if (settings.suppressNotificationStream) {
+    out.suppressNotificationStream = true;
+  }
   if (settings.advertisedExtensions && Object.keys(settings.advertisedExtensions).length > 0) {
     out.advertisedExtensions = { ...settings.advertisedExtensions };
   }
@@ -591,6 +598,7 @@ var INSPECTOR_FIELD_KEY_MAP = {
   taskTtl: true,
   autoRefreshOnListChanged: true,
   paginatedLists: true,
+  suppressNotificationStream: true,
   advertisedExtensions: true,
   maxFetchRequests: true,
   skillCatalogMaxSkills: true,
@@ -954,7 +962,7 @@ function secretStorageCaveat(info) {
     return `The secrets file could not be read (${info.encryptionUnknown}). Saving a secret will fail rather than overwrite it.`;
   }
   if (info.plaintext) {
-    return info.pendingEncryption ? "Existing secrets in this file are still unencrypted (file mode 0600). They are re-encrypted the next time a secret is saved." : "Secrets are stored unencrypted (file mode 0600). Set MCP_INSPECTOR_SECRET_KEY to encrypt them.";
+    return info.pendingEncryption ? "Existing secrets in this file are still unencrypted (file mode 0600). They are re-encrypted the next time a secret is saved." : "Secrets are stored unencrypted (file mode 0600). Set MCP_INSPECTOR_SECRET_KEY or MCP_INSPECTOR_SECRET_KEY_FILE to encrypt them.";
   }
   return void 0;
 }
@@ -1058,14 +1066,14 @@ function isAllInterfacesHost(host) {
 
 // server/resolve-bind-host.ts
 var BIND_ALL_INTERFACES_ENV = "DANGEROUSLY_BIND_ALL_INTERFACES";
-function isEnabled(value) {
+function isEnvFlagEnabled(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])) {
+  if (isAllInterfacesHost(host) && !isEnvFlagEnabled(env[BIND_ALL_INTERFACES_ENV])) {
     const resolved2 = canonicalUrlHost(host);
     const shown = stripBrackets(resolved2) === stripBrackets(host.toLowerCase()) ? `HOST="${host}"` : `HOST="${host}" (resolves to ${resolved2})`;
     throw new Error(
@@ -1658,7 +1666,9 @@ function buildWebServerConfig(options = {}) {
     );
   }
   const hostname = resolveBindHostname();
-  const dangerouslyOmitAuth = !!process.env.DANGEROUSLY_OMIT_AUTH;
+  const dangerouslyOmitAuth = isEnvFlagEnabled(
+    process.env.DANGEROUSLY_OMIT_AUTH
+  );
   const authToken = dangerouslyOmitAuth ? "" : process.env[API_SERVER_ENV_VARS.AUTH_TOKEN] ?? process.env[LEGACY_AUTH_TOKEN_ENV] ?? "";
   const sandboxPort = resolveSandboxPort();
   const requestedAppOriginPort = resolveAppOriginPort();
@@ -1736,7 +1746,7 @@ import react from "@vitejs/plugin-react";
 
 // ../../core/mcp/remote/node/server.ts
 import { randomBytes as randomBytes3, timingSafeEqual } from "crypto";
-import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync6 } from "fs";
 import { stat as fsStat } from "fs/promises";
 import { homedir } from "os";
 import { Hono } from "hono";
@@ -2359,6 +2369,73 @@ function createProxyFetch() {
   };
 }
 
+// ../../core/mcp/node/notificationHeadersFetch.ts
+import { PROTOCOL_VERSION_META_KEY } from "@modelcontextprotocol/client";
+function createNotificationHeadersFetch(baseFetch) {
+  return (input, init) => {
+    const method = modernNotificationMethod(init);
+    if (method === void 0) return baseFetch(input, init);
+    const headers = new Headers(init?.headers);
+    headers.set("mcp-protocol-version", method.version);
+    headers.set("mcp-method", method.method);
+    return baseFetch(input, { ...init, headers });
+  };
+}
+function modernNotificationMethod(init) {
+  if (init?.method?.toUpperCase() !== "POST") return void 0;
+  if (typeof init.body !== "string") return void 0;
+  let message;
+  try {
+    message = JSON.parse(init.body);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(message) || "id" in message) return void 0;
+  if (typeof message.method !== "string") return void 0;
+  const meta = isRecord(message.params) ? message.params._meta : void 0;
+  const version = isRecord(meta) ? meta[PROTOCOL_VERSION_META_KEY] : void 0;
+  if (typeof version !== "string" || version < MODERN_PROTOCOL_VERSION) {
+    return void 0;
+  }
+  return { method: message.method, version };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../../core/mcp/node/suppressNotificationStreamFetch.ts
+function createSuppressNotificationStreamFetch(baseFetch, endpoint) {
+  return async (input, init) => {
+    if (isStandaloneStreamRequest(input, init, endpoint)) {
+      return new Response(null, {
+        status: 405,
+        statusText: "Method Not Allowed"
+      });
+    }
+    return baseFetch(input, init);
+  };
+}
+function requestUrl(input) {
+  const raw = input instanceof Request ? input.url : input instanceof URL ? input.href : input;
+  try {
+    return new URL(raw);
+  } catch {
+    return void 0;
+  }
+}
+function isStandaloneStreamRequest(input, init, endpoint) {
+  const request = input instanceof Request ? input : void 0;
+  const method = (init?.method ?? request?.method ?? "GET").toUpperCase();
+  if (method !== "GET") return false;
+  const url = requestUrl(input);
+  if (!url || url.origin !== endpoint.origin || url.pathname !== endpoint.pathname || url.search !== endpoint.search) {
+    return false;
+  }
+  const headers = new Headers(init?.headers ?? request?.headers);
+  const accept = headers.get("accept")?.toLowerCase() ?? "";
+  return accept.includes("text/event-stream") && !headers.has("last-event-id");
+}
+
 // ../../core/mcp/node/transport.ts
 function headersFromSettings(settings) {
   if (!settings || settings.headers.length === 0) return void 0;
@@ -2446,10 +2523,14 @@ function createTransportNode(config, options = {}) {
       ...httpConfig.requestInit,
       ...headers && { headers }
     };
+    const stampedFetch = createNotificationHeadersFetch(
+      fetchWithOptionalAuthIntercept
+    );
+    const httpFetch = settings?.suppressNotificationStream === true ? createSuppressNotificationStreamFetch(stampedFetch, url) : stampedFetch;
     const transport = new StreamableHTTPClientTransport(url, {
       authProvider,
       requestInit,
-      fetch: fetchWithOptionalAuthIntercept,
+      fetch: httpFetch,
       // SEP-2350: how the transport reacts to a `403 insufficient_scope`
       // challenge. Defaults to the SDK's `reauthorize` when unset.
       ...settings?.oauthOnInsufficientScope && {
@@ -3214,6 +3295,7 @@ import * as path4 from "path";
 
 // ../../core/auth/node/file-secret-store.ts
 import * as crypto2 from "crypto";
+import { readFileSync as readFileSync4, statSync as statSync2 } from "fs";
 import * as fs3 from "fs/promises";
 import * as path3 from "path";
 
@@ -3416,6 +3498,55 @@ var SCRYPT_N = 16384;
 var SCRYPT_R = 8;
 var SCRYPT_P = 1;
 var SECRET_KEY_ENV = "MCP_INSPECTOR_SECRET_KEY";
+var SECRET_KEY_FILE_ENV = "MCP_INSPECTOR_SECRET_KEY_FILE";
+function isSameFile(a, b) {
+  if (path3.resolve(a) === path3.resolve(b)) return true;
+  try {
+    const sa = statSync2(a);
+    const sb = statSync2(b);
+    return sa.dev === sb.dev && sa.ino === sb.ino;
+  } catch {
+    return false;
+  }
+}
+function resolveSecretPassphrase(env = process.env, secretFilePath) {
+  const direct = env[SECRET_KEY_ENV];
+  const hasDirect = direct !== void 0 && direct.trim() !== "";
+  const rawKeyFile = env[SECRET_KEY_FILE_ENV];
+  const wantsKeyFile = rawKeyFile !== void 0;
+  const keyFile = rawKeyFile?.trim();
+  if (hasDirect && wantsKeyFile) {
+    return {
+      problem: `both ${SECRET_KEY_ENV} and ${SECRET_KEY_FILE_ENV} are set; set only one`
+    };
+  }
+  if (hasDirect) return { passphrase: direct };
+  if (!wantsKeyFile) return {};
+  if (!keyFile) {
+    return { problem: `${SECRET_KEY_FILE_ENV} is set but empty` };
+  }
+  const resolved2 = path3.resolve(keyFile);
+  if (secretFilePath !== void 0 && isSameFile(resolved2, secretFilePath)) {
+    return {
+      problem: `${SECRET_KEY_FILE_ENV} (${resolved2}) is the secrets file itself; point it at a separate key file`
+    };
+  }
+  let contents;
+  try {
+    contents = readFileSync4(resolved2, "utf-8");
+  } catch (err) {
+    return {
+      // `String(err)` rather than `.message`: `readFileSync` only ever throws
+      // an `Error`, so an `instanceof` guard would be a branch no test can take.
+      problem: `${SECRET_KEY_FILE_ENV} (${resolved2}) could not be read: ${String(err)}`
+    };
+  }
+  const passphrase = contents.replace(/[\r\n]+$/, "");
+  if (passphrase.trim() === "") {
+    return { problem: `${SECRET_KEY_FILE_ENV} (${resolved2}) is empty` };
+  }
+  return { passphrase };
+}
 var buildAccount2 = (serverId, field) => `${serverId}:${field}`;
 function asSecretMap(value, filePath) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -3435,7 +3566,7 @@ function asSecretMap(value, filePath) {
 var SecretFileKeyMismatchError = class extends SecretStoreUnavailableError {
   constructor(filePath, hasKey) {
     super(
-      hasKey ? `The secrets file at ${filePath} could not be decrypted with the current ${SECRET_KEY_ENV}. Refusing to write, which would overwrite the existing secrets. Restore the original passphrase, or delete the file to start over.` : `The secrets file at ${filePath} is encrypted but ${SECRET_KEY_ENV} is not set. Refusing to write, which would overwrite the existing secrets. Set the passphrase this file was written with, or delete the file to start over.`
+      hasKey ? `The secrets file at ${filePath} could not be decrypted with the current ${SECRET_KEY_ENV} (or ${SECRET_KEY_FILE_ENV}). Refusing to write, which would overwrite the existing secrets. Restore the original passphrase, or delete the file to start over.` : `The secrets file at ${filePath} is encrypted but ${SECRET_KEY_ENV} is not set (nor ${SECRET_KEY_FILE_ENV}). Refusing to write, which would overwrite the existing secrets. Set the passphrase this file was written with, or delete the file to start over.`
     );
     this.name = "SecretFileKeyMismatchError";
   }
@@ -3493,10 +3624,17 @@ function encryptedEnvelopeProblem(parsed) {
 var FileSecretStore = class {
   filePath;
   passphrase;
+  /**
+   * Why a configured key could not be obtained. While set, every read throws
+   * and every write refuses — see {@link SecretPassphrase}.
+   */
+  keyProblem;
   constructor(options) {
     this.filePath = options.filePath;
-    const raw = options.passphrase ?? process.env[SECRET_KEY_ENV];
+    const resolved2 = options.passphrase !== void 0 ? { passphrase: options.passphrase } : resolveSecretPassphrase(process.env, this.filePath);
+    const raw = resolved2.passphrase;
     this.passphrase = raw && raw.trim() ? raw : void 0;
+    this.keyProblem = resolved2.problem;
   }
   /**
    * True when the *next write* will encrypt. This is the configured policy,
@@ -3511,7 +3649,8 @@ var FileSecretStore = class {
    * no file yet, or when it cannot be read or parsed.
    *
    * Separate from {@link encrypted} because the two genuinely disagree for a
-   * whole session: adding `MCP_INSPECTOR_SECRET_KEY` to an install that
+   * whole session: adding a passphrase (`MCP_INSPECTOR_SECRET_KEY` or
+   * `MCP_INSPECTOR_SECRET_KEY_FILE`) to an install that
    * already has a plaintext file flips `encrypted` to true immediately,
    * while the bytes stay readable until the next `set`. A descriptor built
    * from the policy would tell that user "File (encrypted)" while their
@@ -3535,6 +3674,9 @@ var FileSecretStore = class {
    * `set` is in fact about to refuse.
    */
   async readOnDiskEncryption() {
+    if (this.keyProblem !== void 0) {
+      return { state: "unreadable", detail: this.keyProblem };
+    }
     let raw;
     try {
       raw = await readStoreFile(this.filePath);
@@ -3572,7 +3714,7 @@ var FileSecretStore = class {
         } catch (err) {
           return {
             state: "unreadable",
-            detail: err instanceof SecretFileKeyMismatchError ? `it cannot be decrypted with the current ${SECRET_KEY_ENV}` : err instanceof Error ? err.message : String(err)
+            detail: err instanceof SecretFileKeyMismatchError ? `it cannot be decrypted with the current ${SECRET_KEY_ENV} (or ${SECRET_KEY_FILE_ENV})` : err instanceof Error ? err.message : String(err)
           };
         }
         return { state: "encrypted" };
@@ -3623,6 +3765,11 @@ var FileSecretStore = class {
     return this.serialize(() => this.readMap());
   }
   async readMap() {
+    if (this.keyProblem !== void 0) {
+      throw new SecretStoreUnavailableError(
+        `The secrets file at ${this.filePath} cannot be used: ${this.keyProblem}. Refusing to read or write it rather than store secrets unencrypted.`
+      );
+    }
     const raw = await readStoreFile(this.filePath);
     if (raw === null) return null;
     let parsed;
@@ -3978,6 +4125,7 @@ async function readSecretFilePermissions(filePath) {
 var SECRET_STORE_ENV = "MCP_INSPECTOR_SECRET_STORE";
 var SECRET_FILE_ENV = "MCP_INSPECTOR_SECRET_FILE";
 var STORAGE_DIR_ENV = "MCP_STORAGE_DIR";
+var SECRET_STORAGE_DOCS_URL = "https://github.com/modelcontextprotocol/inspector/blob/main/docs/secret-storage.md";
 var KINDS = ["keyring", "file", "memory"];
 function parseSecretStoreEnv(raw) {
   const value = raw?.trim().toLowerCase();
@@ -4120,6 +4268,11 @@ function warnAboutSecretStorage(info) {
   }
   const caveat = secretStorageCaveat(info);
   if (caveat) console.warn(`[mcp-inspector] ${caveat}`);
+  if (info.reason === "fallback" || caveat) {
+    console.warn(
+      `[mcp-inspector] How the secret store is chosen, and how to secure it: ${SECRET_STORAGE_DOCS_URL}`
+    );
+  }
 }
 var resolved;
 function resolveSecretStore() {
@@ -5584,6 +5737,12 @@ function createRemoteApp(options) {
         error: "settings.paginatedLists must be a boolean"
       };
     }
+    if (obj.suppressNotificationStream !== void 0 && typeof obj.suppressNotificationStream !== "boolean") {
+      return {
+        ok: false,
+        error: "settings.suppressNotificationStream must be a boolean"
+      };
+    }
     if (obj.maxFetchRequests !== void 0 && (typeof obj.maxFetchRequests !== "number" || obj.maxFetchRequests < 0)) {
       return {
         ok: false,
@@ -5686,6 +5845,10 @@ function createRemoteApp(options) {
       autoRefreshOnListChanged: obj.autoRefreshOnListChanged === true,
       // Absent → false, matching the read side (omit-on-false on the write side).
       paginatedLists: obj.paginatedLists === true,
+      // Absent → unset (off); only an explicit true is carried (#2317).
+      ...obj.suppressNotificationStream === true && {
+        suppressNotificationStream: true
+      },
       // Absent → product default, matching the read side. The default is the
       // omit-sentinel in inspectorSettingsToStoredFields, so a client that
       // didn't send one writes no spurious maxFetchRequests to disk.
@@ -5936,7 +6099,7 @@ function createRemoteApp(options) {
       type,
       process.platform,
       homedir(),
-      (path6) => existsSync3(path6) ? readFileSync5(path6, "utf-8") : null
+      (path6) => existsSync3(path6) ? readFileSync6(path6, "utf-8") : null
     );
     if (!result) {
       return c.json(
@@ -6745,7 +6908,7 @@ async function startViteDevServer(config) {
 }
 
 // server/server.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 import { join as join8, dirname as dirname8 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { randomBytes as randomBytes4 } from "crypto";
@@ -6799,7 +6962,7 @@ async function startHonoServer(config) {
   });
   const serveIndexHtml = (c) => {
     const indexPath = join8(rootPath, "index.html");
-    const html = readFileSync6(indexPath, "utf-8");
+    const html = readFileSync7(indexPath, "utf-8");
     c.header("Cache-Control", "no-store");
     return c.html(injectAuthToken(html, resolvedAuthToken));
   };