@modelcontextprotocol/inspector 2.6.0 → 2.8.0

package/clients/web/build/index.js

@@ -91,6 +91,7 @@ async function deleteStoreFile(filePath) {
 
 // ../../core/mcp/types.ts
 var DEFAULT_TASK_TTL_MS = 6e4;
+var DEFAULT_CONNECTION_TIMEOUT_MS = 3e4;
 var DEFAULT_MAX_FETCH_REQUESTS = 1e3;
 var DEFAULT_PROTOCOL_ERA = "legacy";
 var DEFAULT_MODERN_LOG_LEVEL = "debug";
@@ -108,6 +109,140 @@ 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";
+import { ResourceSchema } from "@modelcontextprotocol/core";
+var DYNAMIC_RESOURCES = "dynamic";
+var SkillFrontmatterSchema = z.looseObject({
+  name: z.string().optional(),
+  description: z.string().optional()
+});
+var SkillResourceSchema = z.looseObject({
+  uri: z.string(),
+  digest: z.string().optional(),
+  size: z.number().optional()
+});
+var SkillEntrySchema = z.looseObject({
+  uri: z.string(),
+  frontmatter: SkillFrontmatterSchema,
+  resources: z.union([
+    z.literal(DYNAMIC_RESOURCES),
+    z.array(SkillResourceSchema)
+  ])
+});
+var ListSkillsResultSchema = z.looseObject({
+  skills: z.array(SkillEntrySchema),
+  nextCursor: z.string().optional()
+});
+var ModernListSkillsResultSchema = ListSkillsResultSchema.extend({
+  // A non-negative INTEGER, matching the codec: `ttlMs: -1` or `0.5` is an
+  // envelope violation, and accepting it here would hide exactly the kind of
+  // defect this schema exists to surface.
+  ttlMs: z.int().min(0),
+  cacheScope: z.enum(["public", "private"])
+});
+var GetSkillEnvelopeSchema = z.looseObject({
+  skill: SkillEntrySchema
+});
+var GetSkillResultSchema = GetSkillEnvelopeSchema.transform(
+  (result) => result.skill
+);
+var DirectoryChildSchema = ResourceSchema;
+var DirectoryReadResultSchema = z.looseObject({
+  resources: z.array(DirectoryChildSchema),
+  nextCursor: z.string().optional()
+});
+
+// ../../core/mcp/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var H0 = new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// ../../core/mcp/skillFile.ts
+import { parse as parseYaml } from "yaml";
+
+// ../../core/mcp/skills.ts
+var SKILL_MAX_TOTAL_BYTES = 16 * 1024 * 1024;
+var SKILL_MAX_CATALOG_SKILLS = 256;
+var SKILL_MAX_CATALOG_BYTES = 64 * 1024 * 1024;
+function isSkillCatalogLimit(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
 
 // ../../core/auth/secret-fields.ts
 var SECRET_FIELD_OAUTH_CLIENT_SECRET = "oauth-client-secret";
@@ -290,16 +425,19 @@ 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.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 = {
     headers: headersPairs,
     env: envRecordToPairs(stored.env),
     metadata: normalizeStoredMetadata(stored.metadata),
-    connectionTimeout: stored.connectionTimeout ?? 0,
+    // Concrete product default, like taskTtl below: an absent field reads back
+    // as 30 s so the form shows the bound that will actually apply. An explicit
+    // 0 is preserved as-is — it is the user's opt-out, not a sentinel (#2320).
+    connectionTimeout: stored.connectionTimeout ?? DEFAULT_CONNECTION_TIMEOUT_MS,
     requestTimeout: stored.requestTimeout ?? 0,
-    // Unlike the timeouts (0 = "SDK default"), task TTL has a concrete product
+    // Unlike requestTimeout (0 = "SDK default"), task TTL has a concrete product
     // default so the form shows it and "Run as task" has a value to send.
     taskTtl: stored.taskTtl ?? DEFAULT_TASK_TTL_MS,
     autoRefreshOnListChanged: stored.autoRefreshOnListChanged ?? false,
@@ -313,6 +451,15 @@ function storedFieldsToInspectorSettings(stored) {
     // `[]`, which `inspectorSettingsToStoredFields` then omits on write.
     roots: stored.roots ?? []
   };
+  if (isSkillCatalogLimit(stored.skillCatalogMaxSkills)) {
+    settings.skillCatalogMaxSkills = stored.skillCatalogMaxSkills;
+  }
+  if (isSkillCatalogLimit(stored.skillCatalogMaxBytes)) {
+    settings.skillCatalogMaxBytes = stored.skillCatalogMaxBytes;
+  }
+  if (stored.suppressNotificationStream === true) {
+    settings.suppressNotificationStream = true;
+  }
   if (isProtocolEra(stored.protocolEra)) {
     settings.protocolEra = stored.protocolEra;
   }
@@ -367,7 +514,7 @@ function inspectorSettingsToStoredFields(settings) {
   if (Object.keys(settings.metadata).length > 0) {
     out.metadata = settings.metadata;
   }
-  if (settings.connectionTimeout > 0) {
+  if (settings.connectionTimeout !== DEFAULT_CONNECTION_TIMEOUT_MS) {
     out.connectionTimeout = settings.connectionTimeout;
   }
   if (settings.requestTimeout > 0) {
@@ -382,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 };
   }
@@ -394,6 +544,12 @@ function inspectorSettingsToStoredFields(settings) {
   if (settings.maxFetchRequests !== DEFAULT_MAX_FETCH_REQUESTS) {
     out.maxFetchRequests = settings.maxFetchRequests;
   }
+  if (isSkillCatalogLimit(settings.skillCatalogMaxSkills) && settings.skillCatalogMaxSkills !== SKILL_MAX_CATALOG_SKILLS) {
+    out.skillCatalogMaxSkills = settings.skillCatalogMaxSkills;
+  }
+  if (isSkillCatalogLimit(settings.skillCatalogMaxBytes) && settings.skillCatalogMaxBytes !== SKILL_MAX_CATALOG_BYTES) {
+    out.skillCatalogMaxBytes = settings.skillCatalogMaxBytes;
+  }
   const oauthFields = {};
   if (settings.oauthClientId) oauthFields.clientId = settings.oauthClientId;
   if (settings.oauthClientSecret)
@@ -442,8 +598,11 @@ var INSPECTOR_FIELD_KEY_MAP = {
   taskTtl: true,
   autoRefreshOnListChanged: true,
   paginatedLists: true,
+  suppressNotificationStream: true,
   advertisedExtensions: true,
   maxFetchRequests: true,
+  skillCatalogMaxSkills: true,
+  skillCatalogMaxBytes: true,
   oauth: true,
   roots: true
 };
@@ -565,6 +724,14 @@ function parseHeaderPair(value, previous = {}) {
   }
   return { ...previous, [key]: val };
 }
+function parseProtocolEra(value) {
+  if (!isProtocolEra(value)) {
+    throw new Error(
+      `Invalid protocol era: ${value}. Valid eras are: legacy, auto, modern`
+    );
+  }
+  return value;
+}
 var EMPTY_CATALOG_CONTENT = `${JSON.stringify({ mcpServers: {} }, null, 2)}
 `;
 function seedEmptyCatalog(resolvedPath) {
@@ -795,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;
 }
@@ -899,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(
@@ -924,10 +1091,25 @@ function sandboxFrameAncestors(allowedOrigins) {
   return frameAncestorsDirective(allowedOrigins);
 }
 function frameAncestorsDirective(origins) {
-  const valid = (origins ?? []).filter((o) => CSP_HOST_SOURCE.test(o));
+  const valid = validHostSources(origins);
   const sources = valid.length > 0 ? valid : LOOPBACK_FRAME_ANCESTORS;
   return `frame-ancestors ${sources.join(" ")}`;
 }
+function validHostSources(origins) {
+  return (origins ?? []).filter((o) => CSP_HOST_SOURCE.test(o));
+}
+var EMBEDDER_ORIGINS_PLACEHOLDER = "/*INSPECTOR_EMBEDDER_ORIGINS*/ null";
+function embedderOriginsLiteral(origins) {
+  const valid = validHostSources(origins);
+  if (valid.length === 0) return "null";
+  return JSON.stringify(valid).replace(/</g, "\\u003c");
+}
+function renderSandboxProxyHtml(html, origins) {
+  return html.replace(
+    EMBEDDER_ORIGINS_PLACEHOLDER,
+    () => embedderOriginsLiteral(origins)
+  );
+}
 function parseListenPort(raw) {
   const v = raw?.trim();
   if (!v || !/^\d+$/.test(v)) return void 0;
@@ -945,22 +1127,25 @@ function resolveSandboxPort() {
   return fromSandbox ?? parseListenPort(process.env.SERVER_PORT) ?? DEFAULT_SANDBOX_PORT;
 }
 function createSandboxController(options) {
-  const { port, host = DEFAULT_BIND_HOST, allowedOrigins } = options;
+  const { port, host = DEFAULT_BIND_HOST, allowedOrigins, publicUrl } = options;
   let server = null;
   let sandboxUrl = null;
+  let boundPort = 0;
   const SANDBOX_PROXY_CSP = sandboxFrameAncestors(allowedOrigins);
   let sandboxHtml;
   try {
     const sandboxHtmlPath = join3(__dirname, "../static/sandbox_proxy.html");
-    sandboxHtml = readFileSync3(sandboxHtmlPath, "utf-8");
+    sandboxHtml = renderSandboxProxyHtml(
+      readFileSync3(sandboxHtmlPath, "utf-8"),
+      allowedOrigins
+    );
   } catch (e) {
     sandboxHtml = "<!DOCTYPE html><html><body>Sandbox not loaded: " + String(e.message) + "</body></html>";
   }
   return {
     async start() {
       if (server && sandboxUrl) {
-        const p = parseInt(new URL(sandboxUrl).port, 10);
-        return { port: p, url: sandboxUrl };
+        return { port: boundPort, url: sandboxUrl };
       }
       return new Promise((resolve9) => {
         let settled = false;
@@ -1014,7 +1199,15 @@ function createSandboxController(options) {
           );
           const canonicalHost = canonicalUrlHost(host);
           const urlHost = isAllInterfacesHost(canonicalHost) ? "localhost" : canonicalHost;
-          sandboxUrl = `http://${urlHost}:${actualPort}/sandbox`;
+          const derivedUrl = `http://${urlHost}:${actualPort}/sandbox`;
+          const onFixedPort = port !== 0 && !retriedDynamic;
+          if (publicUrl && !onFixedPort) {
+            console.warn(
+              `Sandbox: not advertising MCP_SANDBOX_FULL_ADDRESS, since the sandbox is not on a fixed port for it to route to; advertising ${derivedUrl} instead.`
+            );
+          }
+          sandboxUrl = publicUrl && onFixedPort ? publicUrl : derivedUrl;
+          boundPort = actualPort;
           settle({ port: actualPort, url: sandboxUrl });
         });
       });
@@ -1075,9 +1268,15 @@ function parseDocumentId(url) {
   return /^[0-9a-f]{32}$/.test(id ?? "") ? id ?? null : null;
 }
 function createAppOriginController(options) {
-  const { port, host = DEFAULT_BIND_HOST, embedderOrigins } = options;
+  const {
+    port,
+    host = DEFAULT_BIND_HOST,
+    embedderOrigins,
+    publicOrigin
+  } = options;
   let server = null;
   let origin = null;
+  let boundPort = 0;
   const documents = /* @__PURE__ */ new Map();
   let retainedChars = 0;
   function drop(id) {
@@ -1095,7 +1294,7 @@ function createAppOriginController(options) {
   return {
     async start() {
       if (server && origin) {
-        return { port: parseInt(new URL(origin).port, 10), url: origin };
+        return { port: boundPort, url: origin };
       }
       return new Promise((resolve9) => {
         let settled = false;
@@ -1129,6 +1328,22 @@ function createAppOriginController(options) {
           res.end(doc.html);
         });
         let retriedDynamic = false;
+        const adoptedOrigin = (derived) => {
+          if (!publicOrigin) return derived;
+          if (port === 0 || retriedDynamic) {
+            console.warn(
+              `App origin: not using MCP_APP_ORIGIN_FULL_ADDRESS, since the listener is not on a fixed port for it to route to; serving app documents from ${derived} instead.`
+            );
+            return derived;
+          }
+          if (embedderOrigins?.includes(publicOrigin)) {
+            console.warn(
+              `App origin: not using MCP_APP_ORIGIN_FULL_ADDRESS=${publicOrigin}: it is the sandbox's or the Inspector UI's origin, and a dedicated app origin must differ from both; serving app documents from ${derived} instead.`
+            );
+            return derived;
+          }
+          return publicOrigin;
+        };
         server.on("error", (err) => {
           if (err.code === "EADDRINUSE") {
             if (!retriedDynamic && port !== 0) {
@@ -1160,7 +1375,8 @@ function createAppOriginController(options) {
           const actualPort = addr.port;
           const canonicalHost = canonicalUrlHost(host);
           const urlHost = isAllInterfacesHost(canonicalHost) ? "localhost" : canonicalHost;
-          origin = `http://${urlHost}:${actualPort}`;
+          origin = adoptedOrigin(`http://${urlHost}:${actualPort}`);
+          boundPort = actualPort;
           settle({ port: actualPort, url: origin });
         });
       });
@@ -1198,6 +1414,107 @@ function createAppOriginController(options) {
   };
 }
 
+// server/public-address.ts
+var SANDBOX_FULL_ADDRESS_ENV = "MCP_SANDBOX_FULL_ADDRESS";
+var APP_ORIGIN_FULL_ADDRESS_ENV = "MCP_APP_ORIGIN_FULL_ADDRESS";
+var SANDBOX_PATH = "/sandbox";
+function parsePublicUrl(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return { reason: "it is not an absolute URL" };
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return { reason: "it needs an http:// or https:// scheme" };
+  }
+  if (url.username || url.password) {
+    return { reason: "it must not carry credentials" };
+  }
+  if (url.hostname.includes("*")) {
+    return { reason: "it must not contain a wildcard" };
+  }
+  if (url.hostname.startsWith("[")) {
+    return {
+      reason: "a bracketed IPv6 literal is not a valid CSP host-source \u2014 use a hostname or an IPv4 address"
+    };
+  }
+  if (url.search || url.hash) {
+    return { reason: "it must not carry a query string or fragment" };
+  }
+  return { url };
+}
+function describeForLog(raw) {
+  try {
+    const u = new URL(raw);
+    return `"${u.protocol}${u.host ? `//${u.host}` : ""}"`;
+  } catch {
+    return "(unparseable value, not echoed)";
+  }
+}
+function warnIgnored(env, raw, reason) {
+  console.warn(
+    `Ignoring ${env}=${describeForLog(raw)}: ${reason}. Advertising the bind-derived address instead.`
+  );
+}
+function warnMixedContent(env, url, allowedOrigins) {
+  if (url.protocol === "http:" && allowedOrigins.some((o) => o.startsWith("https:"))) {
+    console.warn(
+      `${env} is plain http (${url.origin}) but ALLOWED_ORIGINS includes an https origin: a browser on the https UI blocks it as mixed content and MCP Apps will not render there.`
+    );
+  }
+}
+function resolveSandboxPublicUrl(raw, allowedOrigins) {
+  const value = raw?.trim();
+  if (!value) return void 0;
+  const parsed = parsePublicUrl(value);
+  if ("reason" in parsed) {
+    warnIgnored(SANDBOX_FULL_ADDRESS_ENV, value, parsed.reason);
+    return void 0;
+  }
+  const { url } = parsed;
+  if (url.pathname === "/") url.pathname = SANDBOX_PATH;
+  if (allowedOrigins.includes(url.origin)) {
+    warnIgnored(
+      SANDBOX_FULL_ADDRESS_ENV,
+      value,
+      `its origin ${url.origin} is also an Inspector UI origin (ALLOWED_ORIGINS), and the MCP Apps sandbox must be on a different origin from its host \u2014 route it to its own hostname or port`
+    );
+    return void 0;
+  }
+  warnMixedContent(SANDBOX_FULL_ADDRESS_ENV, url, allowedOrigins);
+  return url.href;
+}
+function resolveAppOriginPublicOrigin(raw, allowedOrigins, sandboxUrl) {
+  const value = raw?.trim();
+  if (!value) return void 0;
+  const parsed = parsePublicUrl(value);
+  if ("reason" in parsed) {
+    warnIgnored(APP_ORIGIN_FULL_ADDRESS_ENV, value, parsed.reason);
+    return void 0;
+  }
+  const { url } = parsed;
+  if (url.pathname !== "/") {
+    warnIgnored(
+      APP_ORIGIN_FULL_ADDRESS_ENV,
+      value,
+      "it must be an origin only, with no path \u2014 app documents are served at <origin>/app-document/<id>"
+    );
+    return void 0;
+  }
+  const trusted = sandboxUrl ? [...allowedOrigins, new URL(sandboxUrl).origin] : allowedOrigins;
+  if (trusted.includes(url.origin)) {
+    warnIgnored(
+      APP_ORIGIN_FULL_ADDRESS_ENV,
+      value,
+      `its origin ${url.origin} is also the Inspector UI's or the sandbox's, and a dedicated app origin must differ from both \u2014 route it to its own hostname or port`
+    );
+    return void 0;
+  }
+  warnMixedContent(APP_ORIGIN_FULL_ADDRESS_ENV, url, allowedOrigins);
+  return url.origin;
+}
+
 // server/web-server-config.ts
 var inspectorVersion = readInspectorVersionSafe(import.meta.url);
 function defaultEnvironmentFromProcess(extra) {
@@ -1349,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();
@@ -1382,6 +1701,16 @@ function buildWebServerConfig(options = {}) {
       return null;
     }
   }).filter((o) => o !== null);
+  const allowedOrigins = configuredOrigins?.length ? configuredOrigins : defaultAllowedOrigins(hostname, port);
+  const sandboxPublicUrl = resolveSandboxPublicUrl(
+    process.env[SANDBOX_FULL_ADDRESS_ENV],
+    allowedOrigins
+  );
+  const appOriginPublicOrigin = resolveAppOriginPublicOrigin(
+    process.env[APP_ORIGIN_FULL_ADDRESS_ENV],
+    allowedOrigins,
+    sandboxPublicUrl
+  );
   return {
     port,
     hostname,
@@ -1392,10 +1721,12 @@ function buildWebServerConfig(options = {}) {
     writable,
     initialServers,
     storageDir: process.env.MCP_STORAGE_DIR,
-    allowedOrigins: configuredOrigins?.length ? configuredOrigins : defaultAllowedOrigins(hostname, port),
+    allowedOrigins,
     sandboxPort,
     sandboxHost: hostname,
     appOriginPort,
+    sandboxPublicUrl,
+    appOriginPublicOrigin,
     logger,
     autoOpen: resolveAutoOpen()
   };
@@ -1415,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";
@@ -1547,6 +1878,7 @@ function redactBody(body, contentType) {
   return body;
 }
 function findHeader(headers, name) {
+  if (!headers) return void 0;
   const target = name.toLowerCase();
   for (const [key, value] of Object.entries(headers)) {
     if (key.toLowerCase() === target) return value;
@@ -1554,9 +1886,146 @@ function findHeader(headers, name) {
   return void 0;
 }
 function isLongLivedStreamResponse(method, contentType) {
-  if (method !== "GET") return false;
+  if (method.toUpperCase() !== "GET") return false;
   if (!contentType) return false;
-  return contentType.includes("text/event-stream") || contentType.includes("application/x-ndjson");
+  const type = contentType.toLowerCase();
+  return type.includes("text/event-stream") || type.includes("application/x-ndjson");
+}
+var CHALLENGE_BODY_MAX_BYTES = 64 * 1024;
+var CHALLENGE_BODY_READ_MS = 2e3;
+var TRUNCATED_BODY_SUFFIX = "\n[truncated]";
+var WITHHELD_TRUNCATED_JSON_BODY = "[truncated JSON body withheld: an incomplete body cannot be redacted]";
+function recordableChallengeBody(read, contentType) {
+  if (!read.truncated) return redactBody(read.text, contentType);
+  const looksLikeJson = (contentType ?? "").toLowerCase().includes("json") || /^\s*[{[]/.test(read.text);
+  if (looksLikeJson) return WITHHELD_TRUNCATED_JSON_BODY;
+  return redactBody(read.text, contentType) + TRUNCATED_BODY_SUFFIX;
+}
+async function readChallengeBody(response) {
+  let reader;
+  try {
+    const body = response.clone().body;
+    if (!body) return void 0;
+    reader = body.getReader();
+  } catch {
+    return void 0;
+  }
+  const decoder = new TextDecoder();
+  let text = "";
+  let bytes = 0;
+  let timer;
+  const deadline = new Promise((resolve9) => {
+    timer = setTimeout(() => resolve9("timeout"), CHALLENGE_BODY_READ_MS);
+  });
+  try {
+    while (bytes < CHALLENGE_BODY_MAX_BYTES) {
+      const next = await Promise.race([reader.read(), deadline]);
+      if (next === "timeout") break;
+      if (next.done) return { text: text + decoder.decode(), truncated: false };
+      const chunk = next.value.subarray(0, CHALLENGE_BODY_MAX_BYTES - bytes);
+      bytes += chunk.byteLength;
+      text += decoder.decode(chunk, { stream: true });
+    }
+    reader.cancel().catch(() => {
+    });
+    return { text: text + decoder.decode(), truncated: true };
+  } catch {
+    return void 0;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var DEFAULT_STREAM_UPDATE_INTERVAL_MS = 250;
+function longLivedStreamFraming(contentType) {
+  return contentType?.toLowerCase().includes("application/x-ndjson") ? "ndjson" : "sse";
+}
+function watchLongLivedStream(response, id, framing, callbacks) {
+  const listener = callbacks.updateStream;
+  if (!listener) return;
+  const report = (state) => {
+    try {
+      listener(id, state);
+    } catch {
+    }
+  };
+  const intervalMs = callbacks.streamUpdateIntervalMs ?? DEFAULT_STREAM_UPDATE_INTERVAL_MS;
+  let body;
+  try {
+    body = response.clone().body;
+  } catch {
+    return;
+  }
+  if (!body) return;
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let eventCount = 0;
+  let pending = "";
+  let blockHasData = false;
+  let reportTimer = null;
+  const reportCount = () => {
+    if (intervalMs <= 0) {
+      report({ eventCount });
+      return;
+    }
+    if (reportTimer !== null) return;
+    reportTimer = setTimeout(() => {
+      reportTimer = null;
+      report({ eventCount });
+    }, intervalMs);
+  };
+  report({ eventCount });
+  const consumeLine = (line) => {
+    if (framing === "ndjson") {
+      if (line.trim() === "") return;
+      eventCount += 1;
+      reportCount();
+      return;
+    }
+    if (line === "") {
+      if (blockHasData) {
+        eventCount += 1;
+        blockHasData = false;
+        reportCount();
+      }
+      return;
+    }
+    if (line === "data" || line.startsWith("data:")) blockHasData = true;
+  };
+  const consumeCompleteLines = () => {
+    for (; ; ) {
+      const cr = pending.indexOf("\r");
+      const lf = pending.indexOf("\n");
+      const end = cr === -1 ? lf : lf === -1 ? cr : Math.min(cr, lf);
+      if (end === -1) return;
+      if (pending[end] === "\r") {
+        if (end === pending.length - 1) return;
+        const width = pending[end + 1] === "\n" ? 2 : 1;
+        consumeLine(pending.slice(0, end));
+        pending = pending.slice(end + width);
+      } else {
+        consumeLine(pending.slice(0, end));
+        pending = pending.slice(end + 1);
+      }
+    }
+  };
+  const pump = async () => {
+    try {
+      for (; ; ) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        pending += decoder.decode(value, { stream: true });
+        consumeCompleteLines();
+      }
+      if (pending.endsWith("\r")) consumeLine(pending.slice(0, -1));
+    } catch {
+    }
+    if (reportTimer !== null) {
+      clearTimeout(reportTimer);
+      reportTimer = null;
+    }
+    report({ eventCount, closedAt: /* @__PURE__ */ new Date() });
+  };
+  void pump();
 }
 function createFetchTracker(baseFetch, callbacks) {
   return async (input, init) => {
@@ -1564,7 +2033,7 @@ function createFetchTracker(baseFetch, callbacks) {
     const timestamp = /* @__PURE__ */ new Date();
     const id = `${timestamp.getTime()}-${Math.random().toString(36).slice(2, 11)}`;
     const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-    const method = init?.method || "GET";
+    const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
     const rawRequestHeaders = {};
     if (input instanceof Request) {
       input.headers.forEach((value, key) => {
@@ -1644,7 +2113,21 @@ function createFetchTracker(baseFetch, callbacks) {
       responseBody: void 0,
       duration
     };
+    if ((responseStatus === 401 || responseStatus === 403) && response.body && !response.bodyUsed) {
+      const read = await readChallengeBody(response);
+      entry.responseBody = read === void 0 ? void 0 : recordableChallengeBody(read, response.headers.get("content-type"));
+      callbacks.trackRequest?.(entry);
+      return response;
+    }
     callbacks.trackRequest?.(entry);
+    if (isLongLivedStream && response.body && !response.bodyUsed) {
+      watchLongLivedStream(
+        response,
+        id,
+        longLivedStreamFraming(response.headers.get("content-type")),
+        callbacks
+      );
+    }
     if (!isLongLivedStream && response.body && !response.bodyUsed) {
       const responseContentType = response.headers.get("content-type");
       try {
@@ -1756,7 +2239,7 @@ function createAuthChallengeInterceptFetch(baseFetch) {
     if (!challenge) {
       return response;
     }
-    await response.body?.cancel().catch(() => {
+    void response.body?.cancel().catch(() => {
     });
     throw new AuthChallengeError(
       challenge,
@@ -1886,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;
@@ -1904,14 +2454,24 @@ function createTransportNode(config, options = {}) {
     pipeStderr = false,
     onFetchRequest,
     onFetchResponseBody,
+    onFetchStreamUpdate,
     authProvider,
     settings,
     interceptAuthChallenges = false,
     onAuthChallengeObserved
   } = options;
+  const wantsFetchTracking = Boolean(
+    onFetchRequest || onFetchResponseBody || onFetchStreamUpdate
+  );
   const baseFetch = optionsFetchFn ?? createProxyFetch() ?? globalThis.fetch;
   const withChallengeObserver = (inner) => onAuthChallengeObserved ? createAuthChallengeObserverFetch(inner, onAuthChallengeObserved) : inner;
-  const fetchWithOptionalAuthIntercept = interceptAuthChallenges ? createAuthChallengeInterceptFetch(withChallengeObserver(baseFetch)) : withChallengeObserver(baseFetch);
+  const withTracking = (inner) => wantsFetchTracking ? createFetchTracker(inner, {
+    trackRequest: onFetchRequest,
+    updateResponseBody: onFetchResponseBody,
+    updateStream: onFetchStreamUpdate
+  }) : inner;
+  const trackedBase = withTracking(withChallengeObserver(baseFetch));
+  const fetchWithOptionalAuthIntercept = interceptAuthChallenges ? createAuthChallengeInterceptFetch(trackedBase) : trackedBase;
   if (serverType === "stdio") {
     const stdioConfig = config;
     const transport = new StdioClientTransport({
@@ -1937,11 +2497,7 @@ function createTransportNode(config, options = {}) {
     const sseConfig = config;
     const url = new URL(sseConfig.url);
     const configuredSseFetch = sseConfig.eventSourceInit?.fetch;
-    const sseFetch = configuredSseFetch ? withChallengeObserver(configuredSseFetch) : fetchWithOptionalAuthIntercept;
-    const trackedFetch = onFetchRequest ? createFetchTracker(sseFetch, {
-      trackRequest: onFetchRequest,
-      updateResponseBody: onFetchResponseBody
-    }) : sseFetch;
+    const trackedFetch = configuredSseFetch ? withTracking(withChallengeObserver(configuredSseFetch)) : fetchWithOptionalAuthIntercept;
     const headers = headersFromSettings(settings);
     const eventSourceInit = {
       ...sseConfig.eventSourceInit,
@@ -1952,15 +2508,11 @@ function createTransportNode(config, options = {}) {
       ...sseConfig.requestInit,
       ...headers && { headers }
     };
-    const postFetch = onFetchRequest ? createFetchTracker(fetchWithOptionalAuthIntercept, {
-      trackRequest: onFetchRequest,
-      updateResponseBody: onFetchResponseBody
-    }) : fetchWithOptionalAuthIntercept;
     const transport = new SSEClientTransport(url, {
       authProvider,
       eventSourceInit,
       requestInit,
-      fetch: postFetch
+      fetch: fetchWithOptionalAuthIntercept
     });
     return { transport };
   } else {
@@ -1971,14 +2523,14 @@ function createTransportNode(config, options = {}) {
       ...httpConfig.requestInit,
       ...headers && { headers }
     };
-    const transportFetch = onFetchRequest ? createFetchTracker(fetchWithOptionalAuthIntercept, {
-      trackRequest: onFetchRequest,
-      updateResponseBody: onFetchResponseBody
-    }) : fetchWithOptionalAuthIntercept;
+    const stampedFetch = createNotificationHeadersFetch(
+      fetchWithOptionalAuthIntercept
+    );
+    const httpFetch = settings?.suppressNotificationStream === true ? createSuppressNotificationStreamFetch(stampedFetch, url) : stampedFetch;
     const transport = new StreamableHTTPClientTransport(url, {
       authProvider,
       requestInit,
-      fetch: transportFetch,
+      fetch: httpFetch,
       // SEP-2350: how the transport reacts to a `403 insufficient_scope`
       // challenge. Defaults to the SDK's `reauthorize` when unset.
       ...settings?.oauthOnInsufficientScope && {
@@ -1989,6 +2541,9 @@ function createTransportNode(config, options = {}) {
   }
 }
 
+// ../../core/auth/requestTimeout.ts
+var OAUTH_TIMEOUT_WIRE_CODE = "oauth_request_timeout";
+
 // ../../core/json/xMcpHeader.ts
 var MCP_PARAM_HEADER_PREFIX = "Mcp-Param-";
 
@@ -2141,6 +2696,20 @@ function resolveImportSource(type, platform, homeDir, readFile2) {
   return { type, found: false, searched };
 }
 
+// ../../core/mcp/remote/progressToken.ts
+import { ProgressTokenSchema } from "@modelcontextprotocol/core";
+function progressTokenOf(message) {
+  if ("method" in message && message.method === "notifications/progress" && "params" in message && typeof message.params === "object" && message.params !== null) {
+    const parsed = ProgressTokenSchema.safeParse(
+      message.params.progressToken
+    );
+    if (parsed.success) {
+      return parsed.data;
+    }
+  }
+  return void 0;
+}
+
 // ../../core/mcp/remote/node/remote-session.ts
 var RemoteSession = class _RemoteSession {
   sessionId;
@@ -2260,30 +2829,54 @@ var RemoteSession = class _RemoteSession {
    */
   waitForRequestResponse(requestId, timeoutMs = 6e4) {
     return new Promise((resolve9, reject) => {
-      const timer = timeoutMs > 0 ? setTimeout(() => {
-        this.requestWaits.delete(requestId);
-        reject(
-          new Error(
-            `MCP request ${String(requestId)} timed out after ${timeoutMs}ms`
-          )
-        );
-      }, timeoutMs) : void 0;
+      let timer;
+      const arm = () => {
+        if (timeoutMs <= 0) return;
+        timer = setTimeout(() => {
+          this.requestWaits.delete(requestId);
+          reject(
+            new Error(
+              `MCP request ${String(requestId)} timed out after ${timeoutMs}ms`
+            )
+          );
+        }, timeoutMs);
+      };
+      const clear = () => {
+        if (timer !== void 0) {
+          clearTimeout(timer);
+          timer = void 0;
+        }
+      };
+      arm();
       this.requestWaits.set(requestId, {
         resolve: () => {
-          if (timer !== void 0) {
-            clearTimeout(timer);
-          }
+          clear();
           resolve9();
         },
         reject: (error) => {
-          if (timer !== void 0) {
-            clearTimeout(timer);
-          }
+          clear();
           reject(error);
+        },
+        // A progress notification for this request re-arms the full window, so
+        // a tool that keeps reporting progress never trips the relay's own
+        // deadline — the same guarantee the SDK client's `resetTimeoutOnProgress`
+        // gives on a direct transport (#2028).
+        resetTimeout: () => {
+          if (timer === void 0) return;
+          clear();
+          arm();
         }
       });
     });
   }
+  /**
+   * Re-arm a pending request's wait timeout. Invoked from {@link onMessage} when
+   * a `notifications/progress` carrying this request's `progressToken` arrives.
+   * A no-op when no wait is pending for the id.
+   */
+  noteRequestProgress(requestId) {
+    this.requestWaits.get(requestId)?.resetTimeout();
+  }
   cancelRequestWait(requestId) {
     const wait = this.requestWaits.get(requestId);
     if (!wait) {
@@ -2338,6 +2931,10 @@ var RemoteSession = class _RemoteSession {
     if ("id" in message && message.id !== null && message.id !== void 0 && ("result" in message || "error" in message)) {
       this.settleRequestWait(message.id);
     }
+    const progressToken = progressTokenOf(message);
+    if (progressToken !== void 0) {
+      this.noteRequestProgress(progressToken);
+    }
     this.pushEvent({ type: "message", data: message });
   }
   onFetchRequest(entry) {
@@ -2355,6 +2952,16 @@ var RemoteSession = class _RemoteSession {
       data: { id, responseBody }
     });
   }
+  onFetchStreamUpdate(id, stream) {
+    this.pushEvent({
+      type: "fetch_stream_update",
+      data: {
+        id,
+        eventCount: stream.eventCount,
+        ...stream.closedAt && { closedAt: stream.closedAt.toISOString() }
+      }
+    });
+  }
   onStderr(entry) {
     this.pushEvent({
       type: "stdio_log",
@@ -2688,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";
 
@@ -2890,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)) {
@@ -2909,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";
   }
@@ -2967,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,
@@ -2985,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
@@ -3009,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);
@@ -3046,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" };
@@ -3097,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;
@@ -3452,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();
@@ -3594,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() {
@@ -3821,7 +4500,7 @@ function defaultSecretStore() {
 }
 
 // ../../core/client/config-parse.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 function isAbsoluteHttpUrl(value) {
   let url;
   try {
@@ -3838,17 +4517,21 @@ function isRealHost(hostname) {
   const labels = hostname.split(".");
   return labels.length >= 2 && labels.every((label) => label !== "");
 }
-var HttpUrlStringSchema = z.string().min(1).superRefine((val, ctx) => {
+var HttpUrlStringSchema = z2.string().min(1).superRefine((val, ctx) => {
   const trimmed = val.trim();
   if (!isAbsoluteHttpUrl(trimmed)) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: z2.ZodIssueCode.custom,
       message: `Invalid URL: "${trimmed}" \u2014 must be an http(s) URL (e.g. https://idp.example.com)`
     });
   }
 });
 var CIMD_METADATA_URL_INVALID_ERROR = "Must be a valid URL, like https://example.com/oauth/client.json";
-var CIMD_METADATA_URL_HTTPS_ERROR = "CIMD client metadata URL must use HTTPS";
+var CIMD_METADATA_URL_HTTPS_ERROR = "CIMD client metadata URL must use HTTPS, except on localhost, 127.0.0.1 or [::1]";
+var CIMD_HTTP_EXEMPT_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+function isCimdHttpExemptHost(hostname) {
+  return CIMD_HTTP_EXEMPT_HOSTS.has(hostname);
+}
 var CIMD_METADATA_URL_PATH_ERROR = "Must include a path (not the site root), like https://example.com/oauth/client.json";
 function getCimdClientMetadataUrlError(value) {
   const trimmed = value.trim();
@@ -3858,7 +4541,7 @@ function getCimdClientMetadataUrlError(value) {
   }
   try {
     const url = new URL(trimmed);
-    if (url.protocol !== "https:") {
+    if (url.protocol !== "https:" && !isCimdHttpExemptHost(url.hostname)) {
       return CIMD_METADATA_URL_HTTPS_ERROR;
     }
     if (url.pathname === "/" || url.pathname === "") {
@@ -3874,7 +4557,7 @@ function refineCimdMetadataUrl(val, ctx, required) {
   if (trimmed === "") {
     if (required) {
       ctx.addIssue({
-        code: z.ZodIssueCode.custom,
+        code: z2.ZodIssueCode.custom,
         message: "CIMD client metadata URL is required when CIMD is enabled"
       });
     }
@@ -3883,25 +4566,25 @@ function refineCimdMetadataUrl(val, ctx, required) {
   const error = getCimdClientMetadataUrlError(trimmed);
   if (error) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: z2.ZodIssueCode.custom,
       message: error
     });
   }
 }
-var CimdConfigSchema = z.object({
-  enabled: z.boolean(),
-  clientMetadataUrl: z.string()
+var CimdConfigSchema = z2.object({
+  enabled: z2.boolean(),
+  clientMetadataUrl: z2.string()
 }).superRefine((data, ctx) => {
   refineCimdMetadataUrl(data.clientMetadataUrl, ctx, data.enabled === true);
 });
-var EnterpriseManagedAuthIdpConfigSchema = z.object({
+var EnterpriseManagedAuthIdpConfigSchema = z2.object({
   issuer: HttpUrlStringSchema,
-  clientId: z.string().min(1),
-  clientSecret: z.string().optional()
+  clientId: z2.string().min(1),
+  clientSecret: z2.string().optional()
 });
-var ClientConfigSchema = z.object({
-  enterpriseManagedAuth: z.object({
-    enabled: z.boolean().optional(),
+var ClientConfigSchema = z2.object({
+  enterpriseManagedAuth: z2.object({
+    enabled: z2.boolean().optional(),
     idp: EnterpriseManagedAuthIdpConfigSchema
   }).optional(),
   cimd: CimdConfigSchema.optional()
@@ -3910,7 +4593,7 @@ function parseClientConfig(raw) {
   return ClientConfigSchema.parse(raw);
 }
 function formatClientConfigLoadError(error) {
-  if (error instanceof z.ZodError) {
+  if (error instanceof z2.ZodError) {
     const issue = error.issues[0];
     if (issue) {
       const field = issue.path.length > 0 ? issue.path.map(String).join(".") : "config";
@@ -4395,6 +5078,7 @@ function createRemoteApp(options) {
         onStderr: (entry) => session.onStderr(entry),
         onFetchRequest: (entry) => session.onFetchRequest(entry),
         onFetchResponseBody: (id, body2) => session.onFetchResponseBody(id, body2),
+        onFetchStreamUpdate: (id, stream) => session.onFetchStreamUpdate(id, stream),
         authProvider: authHandle?.provider,
         settings: body.settings,
         // Always intercept 401/403 on the node MCP transport. Without this, the
@@ -4629,15 +5313,36 @@ function createRemoteApp(options) {
     } catch {
       return c.json({ error: "Invalid JSON body" }, 400);
     }
-    const { url, method = "GET", headers = {}, body: reqBody } = body;
+    const {
+      url,
+      method = "GET",
+      headers = {},
+      body: reqBody,
+      timeoutMs: requestedTimeoutMs
+    } = body;
     if (!url) {
       return c.json({ error: "Missing url" }, 400);
     }
+    const controller = new AbortController();
+    let deadlineFired = false;
+    const clientSignal = c.req.raw.signal;
+    const signal = clientSignal ? AbortSignal.any([controller.signal, clientSignal]) : controller.signal;
+    const deadlineMs = typeof requestedTimeoutMs === "number" && Number.isFinite(requestedTimeoutMs) ? Math.min(2147483647, Math.max(0, Math.round(requestedTimeoutMs))) : void 0;
+    const safeUrl = redactUrlQuery(url);
+    const timer = deadlineMs === void 0 ? void 0 : setTimeout(() => {
+      deadlineFired = true;
+      controller.abort(
+        new Error(
+          `proxied request to ${safeUrl} timed out after ${deadlineMs}ms`
+        )
+      );
+    }, deadlineMs);
     try {
       const res = await (createProxyFetch() ?? fetch)(url, {
         method,
         headers: new Headers(headers),
-        body: reqBody
+        body: reqBody,
+        signal
       });
       const resHeaders = {};
       res.headers.forEach((v, k) => {
@@ -4648,6 +5353,9 @@ function createRemoteApp(options) {
       let resBody;
       if (!isStream && res.body) {
         resBody = await res.text();
+      } else if (isStream) {
+        void res.body?.cancel().catch(() => {
+        });
       }
       return c.json({
         ok: res.ok,
@@ -4658,7 +5366,20 @@ function createRemoteApp(options) {
       });
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
+      if (deadlineFired) {
+        return c.json(
+          {
+            error: msg,
+            code: OAUTH_TIMEOUT_WIRE_CODE,
+            url: safeUrl,
+            timeoutMs: deadlineMs
+          },
+          504
+        );
+      }
       return c.json({ error: msg }, 500);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
     }
   });
   app.post("/api/log", async (c) => {
@@ -4854,6 +5575,18 @@ function createRemoteApp(options) {
         );
         delete valObj.maxFetchRequests;
       }
+      for (const key of [
+        "skillCatalogMaxSkills",
+        "skillCatalogMaxBytes"
+      ]) {
+        if (key in valObj && !isSkillCatalogLimit(valObj[key])) {
+          logWarn(
+            { route: "/api/servers", id, droppedKey: key },
+            `Dropping malformed \`${key}\` field \u2014 expected a positive integer.`
+          );
+          delete valObj[key];
+        }
+      }
       if ("oauth" in valObj && !isOauthObject(valObj.oauth)) {
         logWarn(
           { route: "/api/servers", id, droppedKey: "oauth" },
@@ -5004,12 +5737,29 @@ 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,
         error: "settings.maxFetchRequests must be a non-negative number"
       };
     }
+    for (const key of [
+      "skillCatalogMaxSkills",
+      "skillCatalogMaxBytes"
+    ]) {
+      if (obj[key] !== void 0 && !isSkillCatalogLimit(obj[key])) {
+        return {
+          ok: false,
+          error: `settings.${key} must be a positive integer`
+        };
+      }
+    }
     for (const optional of [
       "oauthClientId",
       "oauthClientSecret",
@@ -5095,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.
@@ -5105,6 +5859,12 @@ function createRemoteApp(options) {
       // writes no spurious `roots` field.
       roots: isRootArray(obj.roots) ? obj.roots : []
     };
+    if (isSkillCatalogLimit(obj.skillCatalogMaxSkills)) {
+      value.skillCatalogMaxSkills = obj.skillCatalogMaxSkills;
+    }
+    if (isSkillCatalogLimit(obj.skillCatalogMaxBytes)) {
+      value.skillCatalogMaxBytes = obj.skillCatalogMaxBytes;
+    }
     if (typeof obj.oauthClientId === "string" && obj.oauthClientId !== "") {
       value.oauthClientId = obj.oauthClientId;
     }
@@ -5339,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(
@@ -5667,12 +6427,14 @@ function honoMiddlewarePlugin(config) {
       const sandboxController = createSandboxController({
         port: config.sandboxPort,
         host: config.sandboxHost,
-        allowedOrigins: config.allowedOrigins
+        allowedOrigins: config.allowedOrigins,
+        publicUrl: config.sandboxPublicUrl
       });
       await sandboxController.start();
       const appOriginController = createAppOriginController({
         port: config.appOriginPort,
         host: config.sandboxHost,
+        publicOrigin: config.appOriginPublicOrigin,
         embedderOrigins: appDocumentEmbedders(
           sandboxController.getUrl(),
           config.allowedOrigins
@@ -5890,6 +6652,33 @@ function clearViteDepsCache(clientWebRoot) {
 // ../../vitest.shared.mts
 import path5 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
+var NO_RETRY_SETUP = path5.resolve(
+  path5.dirname(fileURLToPath3(import.meta.url)),
+  "vitest.setup.shared.mts"
+);
+var TIMEOUTS = Object.freeze({
+  /**
+   * 3x Vitest's default. Covers the measured load; past this a genuinely hung
+   * unit test costs the whole budget to discover. Both projects that had
+   * already answered this question by hand — `clients/cli` and web's
+   * `storybook` (#2292) — independently arrived at 15000, which is why it is
+   * the shared value rather than a new one.
+   */
+  testTimeout: 15e3,
+  /**
+   * Hooks do the setup and teardown a test's own budget never covers —
+   * spawning servers, provisioning temp dirs, unlinking filesystem-backed
+   * storage. They are also where the real-transitions auto-settle in
+   * `clients/web/src/test/renderWithMantine.tsx` awaits, so this is the one
+   * budget in the repo that actually governs a deliberate wait.
+   */
+  hookTimeout: 3e4,
+  teardownTimeout: 3e4
+});
+var INTEGRATION_TIMEOUTS = Object.freeze({
+  ...TIMEOUTS,
+  testTimeout: 3e4
+});
 function vitestSharedPaths(clientDir) {
   const dirname10 = path5.resolve(clientDir);
   const repoRoot = path5.resolve(dirname10, "../..");
@@ -6119,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";
@@ -6132,12 +6921,14 @@ async function startHonoServer(config) {
   const sandboxController = createSandboxController({
     port: config.sandboxPort,
     host: config.sandboxHost,
-    allowedOrigins: config.allowedOrigins
+    allowedOrigins: config.allowedOrigins,
+    publicUrl: config.sandboxPublicUrl
   });
   await sandboxController.start();
   const appOriginController = createAppOriginController({
     port: config.appOriginPort,
     host: config.sandboxHost,
+    publicOrigin: config.appOriginPublicOrigin,
     embedderOrigins: appDocumentEmbedders(
       sandboxController.getUrl(),
       config.allowedOrigins
@@ -6171,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));
   };
@@ -6310,6 +7101,10 @@ async function runWeb(argv) {
     'HTTP headers as "HeaderName: Value" pairs (for HTTP/SSE transports)',
     parseHeaderPair,
     {}
+  ).option(
+    "--protocol-era <era>",
+    "protocol era for the ad-hoc server: legacy, auto, or modern (default legacy)",
+    parseProtocolEra
   ).option("--dev", "run in development mode (Vite)").parse(preArgs);
   const opts = program.opts();
   const args = program.args;
@@ -6319,8 +7114,9 @@ async function runWeb(argv) {
   const hasCatalog = !!catalogPath;
   const hasConfig = !!opts.config;
   const hasHeaders = !!opts.header && Object.keys(opts.header).length > 0;
+  const hasProtocolEra = opts.protocolEra !== void 0;
   const hasAdHocServer = target.length > 0 || !!opts.serverUrl || !!opts.transport && opts.transport !== "stdio";
-  const conflict = hasCatalog && hasConfig ? "--catalog and --config are mutually exclusive. --catalog is the writable catalog; --config is a read-only session file." : hasCatalog && hasAdHocServer ? "--catalog cannot be combined with an ad-hoc server URL/command." : hasCatalog && hasHeaders ? "--header cannot be combined with --catalog. Set per-server headers in the catalog file." : hasConfig && hasAdHocServer ? "--config cannot be combined with an ad-hoc server URL/command. --config selects a read-only session file." : hasConfig && hasHeaders ? "--header cannot be combined with --config. Set per-server headers inside the config file instead." : null;
+  const conflict = hasCatalog && hasConfig ? "--catalog and --config are mutually exclusive. --catalog is the writable catalog; --config is a read-only session file." : hasCatalog && hasAdHocServer ? "--catalog cannot be combined with an ad-hoc server URL/command." : hasCatalog && hasHeaders ? "--header cannot be combined with --catalog. Set per-server headers in the catalog file." : hasCatalog && hasProtocolEra ? "--protocol-era cannot be combined with --catalog. Set protocolEra per server in the catalog file." : hasConfig && hasAdHocServer ? "--config cannot be combined with an ad-hoc server URL/command. --config selects a read-only session file." : hasConfig && hasHeaders ? "--header cannot be combined with --config. Set per-server headers inside the config file instead." : hasConfig && hasProtocolEra ? "--protocol-era cannot be combined with --config. Set protocolEra per server inside the config file instead." : null;
   if (conflict) {
     console.error(`Error: ${conflict}`);
     process.exit(1);
@@ -6385,6 +7181,9 @@ async function runWeb(argv) {
     }
     initialMcpConfig = config;
     const entry = hasHeaders && config.type !== "stdio" && config.type !== void 0 ? { ...config, headers: opts.header } : { ...config };
+    if (opts.protocolEra !== void 0) {
+      entry.protocolEra = opts.protocolEra;
+    }
     initialServers = {
       mcpServers: { [deriveSeedServerId(config)]: entry }
     };
@@ -6394,6 +7193,11 @@ async function runWeb(argv) {
       "Error: --header requires an ad-hoc --server-url or command target."
     );
     process.exit(1);
+  } else if (hasProtocolEra) {
+    console.error(
+      "Error: --protocol-era requires an ad-hoc --server-url or command target."
+    );
+    process.exit(1);
   }
   let webConfig;
   try {