@modelcontextprotocol/inspector 2.7.0 → 2.9.0

package/clients/cli/build/index.js

@@ -90,6 +90,19 @@ var SECRET_FIELD_OAUTH_CLIENT_SECRET = "oauth-client-secret";
 var SECRET_FIELD_IDP_CLIENT_SECRET = "idp-client-secret";
 var envSecretField = (envKey) => `env:${envKey}`;
 
+// ../../core/storage/own-entry.ts
+function setOwnEntry(map, key, value) {
+  Object.defineProperty(map, key, {
+    value,
+    enumerable: true,
+    writable: true,
+    configurable: true
+  });
+}
+function getOwnEntry(map, key) {
+  return map !== void 0 && Object.hasOwn(map, key) ? map[key] : void 0;
+}
+
 // ../../core/auth/node/secret-store.ts
 var SERVICE_NAME = "mcp-inspector";
 var keyringLoad;
@@ -142,6 +155,12 @@ var SecretStoreUnavailableError = class extends Error {
     this.name = "SecretStoreUnavailableError";
   }
 };
+var SecretFileLockHeldError = class extends SecretStoreUnavailableError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SecretFileLockHeldError";
+  }
+};
 var KeychainUnavailableError = class extends SecretStoreUnavailableError {
   constructor(cause) {
     const message = cause instanceof Error ? cause.message : String(cause);
@@ -172,6 +191,7 @@ async function probeKeyringAvailable() {
   try {
     const entry = new keyring.mod.AsyncEntry(SERVICE_NAME, PROBE_ACCOUNT);
     await entry.getPassword();
+    await keyring.mod.findCredentialsAsync(SERVICE_NAME);
     return { available: true };
   } catch (err) {
     return {
@@ -181,6 +201,7 @@ async function probeKeyringAvailable() {
   }
 }
 var PROBE_ACCOUNT = "__inspector:probe";
+var isNoEntryError = (err) => err instanceof Error && /no (matching )?entry/i.test(err.message);
 var KeyringSecretStore = class {
   /**
    * The intolerant read. Same lookup as {@link get}, minus the catch — a
@@ -232,23 +253,27 @@ var KeyringSecretStore = class {
   async delete(serverId, field) {
     try {
       const keyring = await loadKeyring();
-      if (!keyring.ok) return;
+      if (!keyring.ok) throw new KeychainUnavailableError(keyring.err);
       const entry = new keyring.mod.AsyncEntry(
         SERVICE_NAME,
         buildAccount(serverId, field)
       );
       await entry.deleteCredential();
-    } catch {
+    } catch (err) {
+      if (isNoEntryError(err)) return;
+      if (err instanceof KeychainUnavailableError) throw err;
+      throw new KeychainUnavailableError(err);
     }
   }
   async deleteAllForServer(serverId) {
     let creds;
     try {
       const keyring = await loadKeyring();
-      if (!keyring.ok) return;
+      if (!keyring.ok) throw new KeychainUnavailableError(keyring.err);
       creds = await keyring.mod.findCredentialsAsync(SERVICE_NAME);
-    } catch {
-      return;
+    } catch (err) {
+      if (err instanceof KeychainUnavailableError) throw err;
+      throw new KeychainUnavailableError(err);
     }
     const prefix = `${serverId}:`;
     for (const c of creds) {
@@ -262,6 +287,25 @@ var KeyringSecretStore = class {
 async function secretStoreGetStrict(store, serverId, field) {
   return store.getStrict ? store.getStrict(serverId, field) : store.get(serverId, field);
 }
+async function snapshotSecretFields(store, serverId, fields) {
+  return Promise.all(
+    fields.map(async (field) => ({
+      serverId,
+      field,
+      value: await secretStoreGetStrict(store, serverId, field)
+    }))
+  );
+}
+async function restoreSecretFields(store, snapshot, onRestoreFailure) {
+  for (const { serverId, field, value } of snapshot) {
+    try {
+      if (value === null) await store.delete(serverId, field);
+      else await store.set(serverId, field, value);
+    } catch (error) {
+      onRestoreFailure(error);
+    }
+  }
+}
 async function secretStoreGetMany(store, requests) {
   if (store.getMany) return store.getMany(requests);
   const out = {};
@@ -274,16 +318,44 @@ async function secretStoreGetMany(store, requests) {
       );
       const found = {};
       for (const [field, value] of entries) {
-        if (value !== null) found[field] = value;
+        if (value !== null) setOwnEntry(found, field, value);
       }
-      out[serverId] = found;
+      setOwnEntry(out, serverId, found);
     })
   );
   return out;
 }
+async function secretStoreGetManyStrict(store, requests) {
+  if (store.getManyStrict) return store.getManyStrict(requests);
+  const out = {};
+  await Promise.all(
+    requests.map(async ({ serverId, fields }) => {
+      const entries = await Promise.all(
+        fields.map(
+          async (field) => [
+            field,
+            await secretStoreGetStrict(store, serverId, field)
+          ]
+        )
+      );
+      const found = {};
+      for (const [field, value] of entries) {
+        if (value !== null) setOwnEntry(found, field, value);
+      }
+      setOwnEntry(out, serverId, found);
+    })
+  );
+  return out;
+}
+async function settleStoreMutations(mutations) {
+  const results = await Promise.allSettled(mutations);
+  for (const result of results) {
+    if (result.status === "rejected") throw result.reason;
+  }
+}
 async function secretStoreSetMany(store, serverId, values) {
   if (store.setMany) return store.setMany(serverId, values);
-  await Promise.all(
+  await settleStoreMutations(
     Object.entries(values).map(
       ([field, value]) => store.set(serverId, field, value)
     )
@@ -430,6 +502,10 @@ var ModernListSkillsResultSchema = ListSkillsResultSchema.extend({
 var GetSkillEnvelopeSchema = z.looseObject({
   skill: SkillEntrySchema
 });
+var ModernGetSkillEnvelopeSchema = GetSkillEnvelopeSchema.extend({
+  ttlMs: z.int().min(0),
+  cacheScope: z.enum(["public", "private"])
+});
 var GetSkillResultSchema = GetSkillEnvelopeSchema.transform(
   (result) => result.skill
 );
@@ -1041,6 +1117,176 @@ function checkSkillNameCollisions(entries) {
   return issues;
 }
 
+// ../../core/json/localRefs.ts
+var SUBSCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
+  "items",
+  "contains",
+  "not",
+  "propertyNames",
+  "if",
+  "then",
+  "else",
+  "additionalProperties",
+  "unevaluatedProperties",
+  "additionalItems",
+  "unevaluatedItems",
+  "contentSchema"
+]);
+var SUBSCHEMA_ARRAY_KEYWORDS = /* @__PURE__ */ new Set([
+  "allOf",
+  "anyOf",
+  "oneOf",
+  "prefixItems"
+]);
+var SUBSCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set([
+  "properties",
+  "patternProperties",
+  "dependentSchemas",
+  // Pre-2019 spelling of `dependentSchemas`; its array values are property
+  // name lists, which are not schemas and pass through untouched.
+  "dependencies",
+  "$defs",
+  "definitions"
+]);
+var NON_CONSTRAINT_SIBLINGS = /* @__PURE__ */ new Set([
+  "title",
+  "description",
+  "default",
+  "examples",
+  "deprecated",
+  "readOnly",
+  "writeOnly",
+  // Non-standard labels for `enum` values, read by both form builders.
+  "enumNames",
+  "$comment",
+  "$schema",
+  "$id",
+  "$defs",
+  "definitions"
+]);
+var EXPANSION_BUDGET = 1e4;
+var MAX_DEPTH = 64;
+var Bail = class extends Error {
+};
+function spend(traversal) {
+  traversal.remaining -= 1;
+  if (traversal.remaining < 0) throw new Bail();
+}
+function mapSubschemas(node, visit) {
+  const result = {};
+  for (const [key, value] of Object.entries(node)) {
+    let next = value;
+    if (SUBSCHEMA_KEYWORDS.has(key)) {
+      next = Array.isArray(value) ? value.map(visit) : visit(value);
+    } else if (SUBSCHEMA_ARRAY_KEYWORDS.has(key) && Array.isArray(value)) {
+      next = value.map(visit);
+    } else if (SUBSCHEMA_MAP_KEYWORDS.has(key) && isRecord(value)) {
+      next = mapNames(value, visit);
+    }
+    define(result, key, next);
+  }
+  return result;
+}
+function mapNames(map, visit) {
+  const result = {};
+  for (const [name, value] of Object.entries(map)) {
+    define(result, name, Array.isArray(value) ? value : visit(value));
+  }
+  return result;
+}
+function define(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolvePointer(root, ref) {
+  if (!ref.startsWith("#")) return void 0;
+  let pointer;
+  try {
+    pointer = decodeURIComponent(ref.slice(1));
+  } catch {
+    return void 0;
+  }
+  if (pointer === "") return root;
+  if (!pointer.startsWith("/")) return void 0;
+  let current = root;
+  for (const token of pointer.slice(1).split("/")) {
+    if (/~(?![01])/.test(token)) return void 0;
+    const segment = token.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (Array.isArray(current)) {
+      const index = Number(segment);
+      if (!/^(0|[1-9]\d*)$/.test(segment) || index >= current.length) {
+        return void 0;
+      }
+      current = current[index];
+    } else if (isRecord(current) && Object.hasOwn(current, segment)) {
+      current = current[segment];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function containsRef(node, depth) {
+  if (depth > MAX_DEPTH) throw new Bail();
+  if (!isRecord(node)) return false;
+  if (typeof node.$ref === "string") return true;
+  let found = false;
+  mapSubschemas(node, (child) => {
+    found ||= containsRef(child, depth + 1);
+    return child;
+  });
+  return found;
+}
+function inline(node, traversal, depth) {
+  if (depth > MAX_DEPTH) throw new Bail();
+  if (!isRecord(node)) return node;
+  if (node !== traversal.root && typeof node.$id === "string") return node;
+  spend(traversal);
+  const visit = (child) => inline(child, traversal, depth + 1);
+  const ref = node.$ref;
+  const siblingsConstrain = Object.keys(node).some(
+    (key) => key !== "$ref" && !NON_CONSTRAINT_SIBLINGS.has(key)
+  );
+  if (typeof ref === "string" && !siblingsConstrain && !traversal.active.has(ref)) {
+    const target = resolvePointer(traversal.root, ref);
+    if (isRecord(target)) {
+      traversal.active.add(ref);
+      const resolved2 = visit(target);
+      traversal.active.delete(ref);
+      const siblings = { ...node };
+      delete siblings.$ref;
+      return { ...resolved2, ...mapSubschemas(siblings, visit) };
+    }
+  }
+  return mapSubschemas(node, visit);
+}
+var cache = /* @__PURE__ */ new WeakMap();
+function inlineLocalRefs(schema) {
+  if (!isRecord(schema)) return schema;
+  const cached = cache.get(schema);
+  if (cached !== void 0) return cached;
+  let resolved2;
+  try {
+    resolved2 = containsRef(schema, 0) ? inline(
+      schema,
+      { root: schema, active: /* @__PURE__ */ new Set(), remaining: EXPANSION_BUDGET },
+      0
+    ) : schema;
+  } catch (error) {
+    if (!(error instanceof Bail)) throw error;
+    resolved2 = schema;
+  }
+  cache.set(schema, resolved2);
+  return resolved2;
+}
+
 // ../../core/json/nullableUnion.ts
 var RENDERABLE_TYPES = [
   "string",
@@ -1639,7 +1885,7 @@ function convertToolParameters(tool, params) {
 function convertParametersForSchema(inputSchema, params) {
   const result = {};
   const { base, branches } = resolveRootUnion(
-    inputSchema ?? {}
+    inlineLocalRefs(inputSchema ?? {})
   );
   const properties = coercionProperties(base, branches, params);
   for (const [key, value] of Object.entries(params)) {
@@ -1831,7 +2077,7 @@ function oauthEndpointOverridesFromSettings(settings) {
   };
 }
 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 = {
@@ -1863,6 +2109,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;
   }
@@ -1914,6 +2163,7 @@ var INSPECTOR_FIELD_KEY_MAP = {
   taskTtl: true,
   autoRefreshOnListChanged: true,
   paginatedLists: true,
+  suppressNotificationStream: true,
   advertisedExtensions: true,
   maxFetchRequests: true,
   skillCatalogMaxSkills: true,
@@ -2268,7 +2518,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;
 }
@@ -2283,6 +2533,7 @@ function secretStorageSummary(info) {
 
 // ../../core/auth/node/file-secret-store.ts
 import * as crypto2 from "crypto";
+import { readFileSync as readFileSync2, statSync as statSync2 } from "fs";
 import * as fs3 from "fs/promises";
 import * as path3 from "path";
 
@@ -2426,7 +2677,7 @@ async function openSecretFileLock(filePath) {
     });
   } catch (err) {
     if (isStuckOrHeld(err, lockPathOf(target))) {
-      throw new SecretStoreUnavailableError(
+      throw new SecretFileLockHeldError(
         `Could not save to the secrets file at ${target}: its lock (${lockPathOf(target)}) was still held after the ${Math.round(RETRY_BUDGET_MS / 1e3)} seconds this save waited. Its secrets are intact; the value you just entered was not saved. If no other Inspector is running, remove that lock and try again.`
       );
     }
@@ -2485,7 +2736,63 @@ 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 = readFileSync2(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 assertSecretString(field, value) {
+  if (typeof value !== "string") {
+    throw new TypeError(
+      `Refusing to store a non-string secret value (${typeof value}) for "${field}": the secrets file holds only strings, and writing this would make the whole file unreadable.`
+    );
+  }
+}
 function asSecretMap(value, filePath) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new SecretStoreUnavailableError(
@@ -2504,7 +2811,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";
   }
@@ -2562,10 +2869,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,
@@ -2580,7 +2894,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
@@ -2604,6 +2919,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);
@@ -2641,7 +2959,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" };
@@ -2692,6 +3010,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;
@@ -2728,7 +3051,9 @@ var FileSecretStore = class {
     let plain;
     try {
       const key = await this.deriveKey(parsed.kdf);
-      const decipher = crypto2.createDecipheriv(CIPHER, key, parts.iv);
+      const decipher = crypto2.createDecipheriv(CIPHER, key, parts.iv, {
+        authTagLength: GCM_TAG_BYTES
+      });
       decipher.setAuthTag(parts.tag);
       plain = Buffer.concat([
         decipher.update(parts.body),
@@ -2762,7 +3087,9 @@ var FileSecretStore = class {
       };
       const key = await this.deriveKey(kdf);
       const iv = crypto2.randomBytes(IV_BYTES);
-      const cipher = crypto2.createCipheriv(CIPHER, key, iv);
+      const cipher = crypto2.createCipheriv(CIPHER, key, iv, {
+        authTagLength: GCM_TAG_BYTES
+      });
       const body = Buffer.concat([
         cipher.update(JSON.stringify(map), "utf-8"),
         cipher.final()
@@ -2927,9 +3254,36 @@ var FileSecretStore = class {
       const found = {};
       for (const field of fields) {
         const value = map?.[buildAccount2(serverId, field)];
-        if (value !== void 0) found[field] = value;
+        if (value !== void 0) setOwnEntry(found, field, value);
+      }
+      setOwnEntry(out, serverId, found);
+    }
+    return out;
+  }
+  /**
+   * Bulk twin of {@link getStrict}: the same single-pass read as
+   * {@link getMany}, but an unreadable store throws (with the typed advice
+   * {@link getStrict} attaches) instead of yielding no fields — required by
+   * OAuth read hydration, whose result later drives store deletions.
+   */
+  async getManyStrict(requests) {
+    let map;
+    try {
+      map = await this.serialize(() => this.readMap());
+    } catch (err) {
+      if (err instanceof SecretStoreUnavailableError) throw err;
+      throw new SecretStoreUnavailableError(
+        `Could not read the secrets file at ${this.filePath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    const out = {};
+    for (const { serverId, fields } of requests) {
+      const found = {};
+      for (const field of fields) {
+        const value = map?.[buildAccount2(serverId, field)];
+        if (value !== void 0) setOwnEntry(found, field, value);
       }
-      out[serverId] = found;
+      setOwnEntry(out, serverId, found);
     }
     return out;
   }
@@ -2973,6 +3327,9 @@ var FileSecretStore = class {
    */
   async setMany(serverId, values) {
     if (Object.keys(values).length === 0) return;
+    for (const [field, value] of Object.entries(values)) {
+      assertSecretString(field, value);
+    }
     await this.serialize(
       () => this.mutate((map) => {
         const next = { ...map };
@@ -2984,6 +3341,7 @@ var FileSecretStore = class {
     );
   }
   async set(serverId, field, value) {
+    assertSecretString(field, value);
     await this.serialize(
       () => this.mutate((map) => ({
         ...map,
@@ -2999,9 +3357,11 @@ var FileSecretStore = class {
     await this.deleteWhere((key) => key.startsWith(prefix));
   }
   /**
-   * Shared delete body. Silent on every failure, matching the keyring store:
-   * every reason a delete can fail collapses to "the entry isn't there
-   * anymore", and `set` is the operation that reports a broken store.
+   * Shared delete body. Same confirmed-delete contract as the keyring
+   * store: a deletion that cannot be confirmed (unreadable file, failed
+   * decrypt, failed write) must escape, because reporting success would
+   * let a caller commit state that assumes the entry is gone — once the
+   * file becomes readable again, a later read would resurrect it.
    */
   async deleteWhere(match) {
     try {
@@ -3014,7 +3374,12 @@ var FileSecretStore = class {
           return next;
         })
       );
-    } catch {
+    } catch (err) {
+      if (err instanceof SecretStoreUnavailableError) throw err;
+      throw new SecretStoreUnavailableError(
+        `Could not delete from the secrets file: ${err instanceof Error ? err.message : String(err)}`,
+        { cause: err }
+      );
     }
   }
 };
@@ -3047,6 +3412,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();
@@ -3189,6 +3555,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() {
@@ -3384,6 +3755,9 @@ var DeferredSecretStore = class {
   async getMany(requests) {
     return secretStoreGetMany(await this.target(), requests);
   }
+  async getManyStrict(requests) {
+    return secretStoreGetManyStrict(await this.target(), requests);
+  }
   async get(serverId, field) {
     return (await this.target()).get(serverId, field);
   }
@@ -3622,12 +3996,31 @@ function redactJsonValue(value) {
   }
   return value;
 }
+function joinSensitiveContinuations(body) {
+  const out = [];
+  let sensitiveAt = -1;
+  for (const pair of body.split("&")) {
+    const eq = pair.indexOf("=");
+    if (eq === -1) {
+      if (sensitiveAt !== -1 && pair.length > 0) {
+        out[sensitiveAt] += `%26${pair}`;
+      } else {
+        out.push(pair);
+      }
+      continue;
+    }
+    const [key] = new URLSearchParams(pair).keys();
+    sensitiveAt = isSensitiveField(key) && eq < pair.length - 1 ? out.length : -1;
+    out.push(pair);
+  }
+  return out.join("&");
+}
 function redactBody(body, contentType) {
   if (!body) return body;
   const type = (contentType ?? "").toLowerCase();
   if (type.includes("application/x-www-form-urlencoded")) {
     try {
-      const params = new URLSearchParams(body);
+      const params = new URLSearchParams(joinSensitiveContinuations(body));
       let changed = false;
       for (const key of new Set(params.keys())) {
         if (isSensitiveField(key)) {
@@ -4351,6 +4744,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 (!isRecord2(message) || "id" in message) return void 0;
+  if (typeof message.method !== "string") return void 0;
+  const meta = isRecord2(message.params) ? message.params._meta : void 0;
+  const version = isRecord2(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 isRecord2(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;
@@ -4438,10 +4898,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 && {
@@ -4587,42 +5051,57 @@ import {
 function withIssuer(value, issuer) {
   return issuer === void 0 ? value : { ...value, issuer };
 }
-var OAuthStorageBase = class {
+var OAuthStorageCoordination = class {
   loaded = false;
   loadPromise;
   /** Serializes persist writes so concurrent mutators cannot reorder POSTs. */
   persistQueue = Promise.resolve();
+};
+var OAuthStorageBase = class {
+  coordination;
   memory;
   backend;
-  constructor(memory, backend) {
+  constructor(memory, backend, coordination = new OAuthStorageCoordination()) {
     this.memory = memory;
     this.backend = backend;
+    this.coordination = coordination;
   }
   load() {
-    if (!this.loadPromise) {
-      this.loadPromise = this.doLoad();
+    const coordination = this.coordination;
+    if (!coordination.loadPromise) {
+      coordination.loadPromise = this.doLoad().catch((error) => {
+        coordination.loadPromise = void 0;
+        throw error;
+      });
     }
-    return this.loadPromise;
+    return coordination.loadPromise;
   }
   async doLoad() {
-    if (this.loaded) {
+    if (this.coordination.loaded) {
       return;
     }
     const snapshot = await this.backend.read();
     if (snapshot) {
       this.memory.replace(snapshot);
     }
-    this.loaded = true;
+    this.coordination.loaded = true;
   }
   async ensureLoaded() {
     await this.load();
   }
-  async persist() {
-    const snapshot = this.memory.snapshot();
-    const prior = this.persistQueue;
+  /**
+   * Flush memory to the backend, naming the sections the calling mutation
+   * touched so shared-store backends can merge just those entries over a
+   * fresh read (the clobber fix — see {@link OAuthPersistSections}). The
+   * snapshot is taken *inside* the queued closure, so a write that waited in
+   * the queue carries the state as of when it actually runs, coalescing with
+   * any mutations that landed in memory while it waited.
+   */
+  async persist(sections) {
+    const prior = this.coordination.persistQueue;
     const tracked = prior.catch(() => {
-    }).then(() => this.backend.write(snapshot));
-    this.persistQueue = tracked;
+    }).then(() => this.backend.write(this.memory.snapshot(), sections));
+    this.coordination.persistQueue = tracked;
     await tracked;
   }
   /**
@@ -4636,7 +5115,7 @@ var OAuthStorageBase = class {
   /** Read the issuer-bound slot for a read, if one exists. */
   issuerSlot(state, issuer) {
     const key = this.resolveReadIssuer(state, issuer);
-    return key ? state.byIssuer?.[key] : void 0;
+    return key ? getOwnEntry(state.byIssuer, key) : void 0;
   }
   /**
    * Read-modify-write the `byIssuer[issuer]` slot, set `activeIssuer`, and clear
@@ -4647,7 +5126,9 @@ var OAuthStorageBase = class {
     const state = this.memory.getState().getServerState(serverUrl);
     const byIssuer = {
       ...state.byIssuer,
-      [issuer]: { ...state.byIssuer?.[issuer], ...updates }
+      // The computed key defines an own property; the merge-base read needs
+      // the own guard so an absent `__proto__` slot reads as undefined.
+      [issuer]: { ...getOwnEntry(state.byIssuer, issuer), ...updates }
     };
     this.memory.getState().setServerState(serverUrl, {
       byIssuer,
@@ -4659,7 +5140,7 @@ var OAuthStorageBase = class {
   mapIssuerSlots(state, fn) {
     const byIssuer = {};
     for (const [key, slot] of Object.entries(state.byIssuer ?? {})) {
-      byIssuer[key] = { ...slot, ...fn(slot) };
+      setOwnEntry(byIssuer, key, { ...slot, ...fn(slot) });
     }
     return byIssuer;
   }
@@ -4705,7 +5186,7 @@ var OAuthStorageBase = class {
         clientRegistrationKind: options.registrationKind
       });
     }
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
   }
   async savePreregisteredClientInformation(serverUrl, clientInformation) {
     await this.ensureLoaded();
@@ -4713,7 +5194,7 @@ var OAuthStorageBase = class {
       preregisteredClientInformation: clientInformation,
       clientRegistrationKind: "static"
     });
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
   }
   async clearClientInformation(serverUrl, isPreregistered, issuer) {
     await this.ensureLoaded();
@@ -4721,7 +5202,7 @@ var OAuthStorageBase = class {
       this.memory.getState().setServerState(serverUrl, {
         preregisteredClientInformation: void 0
       });
-      await this.persist();
+      await this.persist({ servers: [serverUrl] });
       return;
     }
     if (issuer !== void 0) {
@@ -4744,7 +5225,7 @@ var OAuthStorageBase = class {
         clientRegistrationKind: void 0
       });
     }
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
   }
   async getTokens(serverUrl, issuer) {
     await this.ensureLoaded();
@@ -4755,9 +5236,12 @@ var OAuthStorageBase = class {
     if (!tokens) {
       return void 0;
     }
-    const parsed = await OAuthTokensSchema.parseAsync(tokens);
+    const result = await OAuthTokensSchema.safeParseAsync(tokens);
+    if (!result.success) {
+      return void 0;
+    }
     return withIssuer(
-      parsed,
+      result.data,
       fromSlot ? this.resolveReadIssuer(state, issuer) : void 0
     );
   }
@@ -4781,7 +5265,7 @@ var OAuthStorageBase = class {
         ...options?.enterpriseManaged === true && { enterpriseManaged: true }
       });
     }
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
   }
   async clearTokens(serverUrl, issuer) {
     await this.ensureLoaded();
@@ -4800,7 +5284,7 @@ var OAuthStorageBase = class {
       }));
       this.memory.getState().setServerState(serverUrl, { byIssuer, tokens: void 0 });
     }
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
   }
   async getCodeVerifier(serverUrl) {
     await this.ensureLoaded();
@@ -4810,12 +5294,12 @@ var OAuthStorageBase = class {
   async saveCodeVerifier(serverUrl, codeVerifier) {
     await this.ensureLoaded();
     this.memory.getState().setServerState(serverUrl, { codeVerifier });
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
   }
   async clearCodeVerifier(serverUrl) {
     await this.ensureLoaded();
     this.memory.getState().setServerState(serverUrl, { codeVerifier: void 0 });
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
   }
   async getScope(serverUrl) {
     await this.ensureLoaded();
@@ -4825,12 +5309,12 @@ var OAuthStorageBase = class {
   async saveScope(serverUrl, scope) {
     await this.ensureLoaded();
     this.memory.getState().setServerState(serverUrl, { scope });
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
   }
   async clearScope(serverUrl) {
     await this.ensureLoaded();
     this.memory.getState().setServerState(serverUrl, { scope: void 0 });
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
   }
   async getServerMetadata(serverUrl) {
     await this.ensureLoaded();
@@ -4840,12 +5324,12 @@ var OAuthStorageBase = class {
   async saveServerMetadata(serverUrl, metadata) {
     await this.ensureLoaded();
     this.memory.getState().setServerState(serverUrl, { serverMetadata: metadata });
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
   }
   async clearServerMetadata(serverUrl) {
     await this.ensureLoaded();
     this.memory.getState().setServerState(serverUrl, { serverMetadata: void 0 });
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
   }
   async getDiscoveryState(serverUrl) {
     await this.ensureLoaded();
@@ -4854,12 +5338,12 @@ var OAuthStorageBase = class {
   async saveDiscoveryState(serverUrl, state) {
     await this.ensureLoaded();
     this.memory.getState().setServerState(serverUrl, { discoveryState: state });
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
   }
   async clearDiscoveryState(serverUrl) {
     await this.ensureLoaded();
     this.memory.getState().setServerState(serverUrl, { discoveryState: void 0 });
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
   }
   async takeRevocationSnapshot(serverUrl) {
     await this.ensureLoaded();
@@ -4877,13 +5361,13 @@ var OAuthStorageBase = class {
       serverMetadata: state.serverMetadata
     };
     this.memory.getState().clearServerState(serverUrl);
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
     return snapshot;
   }
   async clear(serverUrl) {
     await this.ensureLoaded();
     this.memory.getState().clearServerState(serverUrl);
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
   }
   async getIdpSession(issuer) {
     await this.ensureLoaded();
@@ -4896,17 +5380,18 @@ var OAuthStorageBase = class {
   async saveIdpSession(issuer, session) {
     await this.ensureLoaded();
     this.memory.getState().setIdpSession(issuer, session);
-    await this.persist();
+    await this.persist({ idpSessions: [issuer] });
   }
   async clearIdpSession(issuer) {
     await this.ensureLoaded();
     this.memory.getState().clearIdpSession(issuer);
-    await this.persist();
+    await this.persist({ idpSessions: [issuer] });
   }
   async clearEnterpriseManagedResourceServers() {
     await this.ensureLoaded();
+    const servers = Object.entries(this.memory.getState().servers).filter(([, state]) => state.enterpriseManaged === true).map(([url]) => url);
     this.memory.getState().clearEnterpriseManagedResourceServers();
-    await this.persist();
+    await this.persist({ servers });
   }
 };
 
@@ -4924,13 +5409,15 @@ var OAuthMemoryStore = class {
       servers: this.servers,
       idpSessions: this.idpSessions,
       getServerState: (serverUrl) => {
-        return this.servers[serverUrl] || {};
+        return getOwnEntry(this.servers, serverUrl) || {};
       },
       setServerState: (serverUrl, updates) => {
         this.servers = {
           ...this.servers,
+          // Computed keys define own properties, so this write is safe for
+          // `__proto__`; only the merge-base read needs the own guard.
           [serverUrl]: {
-            ...this.servers[serverUrl],
+            ...getOwnEntry(this.servers, serverUrl),
             ...updates
           }
         };
@@ -4941,13 +5428,13 @@ var OAuthMemoryStore = class {
         this.servers = rest;
       },
       getIdpSession: (issuer) => {
-        return this.idpSessions[issuer] || {};
+        return getOwnEntry(this.idpSessions, issuer) || {};
       },
       setIdpSession: (issuer, updates) => {
         this.idpSessions = {
           ...this.idpSessions,
           [issuer]: {
-            ...this.idpSessions[issuer],
+            ...getOwnEntry(this.idpSessions, issuer),
             ...updates
           }
         };
@@ -4981,24 +5468,81 @@ var OAuthMemoryStore = class {
 };
 
 // ../../core/auth/oauth-persist.ts
-function isRecord(value) {
+import { OAuthTokensSchema as OAuthTokensSchema2 } from "@modelcontextprotocol/core";
+function mergeOAuthSections(disk, snapshot, sections) {
+  const merged = {
+    servers: { ...disk?.servers },
+    idpSessions: { ...disk?.idpSessions }
+  };
+  for (const url of sections.servers ?? []) {
+    const value = getOwnEntry(snapshot.servers, url);
+    if (value === void 0) {
+      delete merged.servers[url];
+    } else {
+      setOwnEntry(merged.servers, url, value);
+    }
+  }
+  for (const issuer of sections.idpSessions ?? []) {
+    const value = getOwnEntry(snapshot.idpSessions, issuer);
+    if (value === void 0) {
+      delete merged.idpSessions[issuer];
+    } else {
+      setOwnEntry(merged.idpSessions, issuer, value);
+    }
+  }
+  return merged;
+}
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function snapshotFromPayload(payload) {
-  return {
-    servers: payload.servers ?? {},
-    idpSessions: payload.idpSessions ?? {}
-  };
+function isEntryMap(value) {
+  return isRecord3(value) && Object.values(value).every(isRecord3);
+}
+var VERBATIM_SECRET_KEYS = [
+  "client_secret",
+  "registration_access_token"
+];
+function isValidClientInformation(value) {
+  if (value === void 0) return true;
+  if (!isRecord3(value)) return false;
+  return VERBATIM_SECRET_KEYS.every(
+    (key) => !Object.hasOwn(value, key) || typeof value[key] === "string"
+  );
+}
+var PartialTokensSchema = OAuthTokensSchema2.partial();
+function isValidServerEntry(entry) {
+  if (!isRecord3(entry)) return false;
+  if (!isValidClientInformation(entry.clientInformation)) return false;
+  if (!isValidClientInformation(entry.preregisteredClientInformation))
+    return false;
+  if (entry.byIssuer !== void 0) {
+    if (!isRecord3(entry.byIssuer)) return false;
+    for (const slot of Object.values(entry.byIssuer)) {
+      if (!isRecord3(slot)) return false;
+      if (!isValidClientInformation(slot.clientInformation)) return false;
+    }
+  }
+  return true;
+}
+function snapshotFromPayload(payload) {
+  const servers = payload.servers ?? {};
+  const idpSessions = payload.idpSessions ?? {};
+  if (!isEntryMap(servers) || !isEntryMap(idpSessions)) return null;
+  if (!Object.values(servers).every(isValidServerEntry)) return null;
+  return {
+    servers,
+    idpSessions
+  };
 }
 function parseOAuthPersistBlob(raw) {
   if (raw === null || raw === void 0) {
     return null;
   }
   const parsed = typeof raw === "string" ? raw ? parseStore(raw) : null : raw;
-  if (!isRecord(parsed)) {
+  if (!isRecord3(parsed)) {
     return null;
   }
-  if (isRecord(parsed.state) && "version" in parsed) {
+  if (isRecord3(parsed.state) && "version" in parsed) {
     return snapshotFromPayload(parsed.state);
   }
   if ("servers" in parsed || "idpSessions" in parsed) {
@@ -5010,21 +5554,774 @@ function serializeOAuthPersistBlob(snapshot) {
   return serializeStore(snapshot);
 }
 
+// ../../core/auth/node/oauth-secrets.ts
+import { OAuthTokensSchema as OAuthTokensSchema3 } from "@modelcontextprotocol/core";
+var PERSIST_TOKENS_ENV = "MCP_INSPECTOR_PERSIST_TOKENS";
+var warnedPolicyValues = /* @__PURE__ */ new Set();
+function getPersistTokensPolicy(env = process.env) {
+  const raw = env[PERSIST_TOKENS_ENV];
+  if (raw === void 0 || raw === "") return "all";
+  if (raw === "all" || raw === "access" || raw === "none") return raw;
+  if (!warnedPolicyValues.has(raw)) {
+    warnedPolicyValues.add(raw);
+    console.warn(
+      `[mcp-inspector] Ignoring invalid ${PERSIST_TOKENS_ENV}=${JSON.stringify(raw)} (expected "all", "access", or "none"); persisting all tokens.`
+    );
+  }
+  return "all";
+}
+var oauthSecretServerId = (serverUrl) => `oauth+${encodeURIComponent(serverUrl)}`;
+var oauthIdpSecretServerId = (issuer) => `oauth-idp+${encodeURIComponent(issuer)}`;
+var issuerTokensField = (issuer) => `tokens:${issuer}`;
+var issuerClientSecretField = (issuer) => `client-secret:${issuer}`;
+var issuerRegistrationTokenField = (issuer) => `registration-token:${issuer}`;
+var LEGACY_TOKENS_FIELD = "tokens";
+var LEGACY_CLIENT_SECRET_FIELD = "client-secret";
+var LEGACY_REGISTRATION_TOKEN_FIELD = "registration-token";
+var PREREG_CLIENT_SECRET_FIELD = "prereg-client-secret";
+var PREREG_REGISTRATION_TOKEN_FIELD = "prereg-registration-token";
+var IDP_SESSION_FIELD = "idp-session";
+function applyTokensPolicy(tokens, policy) {
+  if (policy === "none") return void 0;
+  if (policy === "access" && tokens.refresh_token !== void 0) {
+    const { refresh_token: _stripped, ...rest } = tokens;
+    return rest;
+  }
+  return tokens;
+}
+var StorableTokensSchema = OAuthTokensSchema3.partial();
+function hasSecretBearingTokenField(tokens) {
+  return tokens.access_token !== void 0 || tokens.refresh_token !== void 0 || tokens.id_token !== void 0;
+}
+function splitTokens(tokens, policy) {
+  const kept = applyTokensPolicy(tokens, policy);
+  if (!kept) return {};
+  if (!StorableTokensSchema.safeParse(kept).success) {
+    return { plaintext: kept };
+  }
+  if (!hasSecretBearingTokenField(kept)) {
+    return {};
+  }
+  return { secret: JSON.stringify(kept) };
+}
+function splitClientInformation(info, fields, secrets) {
+  const { client_secret, registration_access_token, ...publicInfo } = info;
+  if (client_secret === void 0 && registration_access_token === void 0) {
+    return info;
+  }
+  if (client_secret !== void 0) {
+    secrets[fields.clientSecret] = client_secret;
+  }
+  if (registration_access_token !== void 0) {
+    secrets[fields.registrationToken] = registration_access_token;
+  }
+  return publicInfo;
+}
+function joinClientInformation(info, fields, secrets) {
+  const clientSecret = secrets[fields.clientSecret];
+  const registrationToken = secrets[fields.registrationToken];
+  if (clientSecret === void 0 && registrationToken === void 0) {
+    return info;
+  }
+  return {
+    ...info,
+    ...clientSecret !== void 0 && { client_secret: clientSecret },
+    ...registrationToken !== void 0 && {
+      registration_access_token: registrationToken
+    }
+  };
+}
+var issuerClientInfoFields = (issuer) => ({
+  clientSecret: issuerClientSecretField(issuer),
+  registrationToken: issuerRegistrationTokenField(issuer)
+});
+var LEGACY_CLIENT_INFO_FIELDS = {
+  clientSecret: LEGACY_CLIENT_SECRET_FIELD,
+  registrationToken: LEGACY_REGISTRATION_TOKEN_FIELD
+};
+var PREREG_CLIENT_INFO_FIELDS = {
+  clientSecret: PREREG_CLIENT_SECRET_FIELD,
+  registrationToken: PREREG_REGISTRATION_TOKEN_FIELD
+};
+function splitServerOAuthState(state, policy) {
+  const secrets = {};
+  const residue = { ...state };
+  if (state.byIssuer) {
+    const byIssuer = {};
+    for (const [issuer, slot] of Object.entries(state.byIssuer)) {
+      const slotResidue = { ...slot };
+      if (slot.tokens) {
+        delete slotResidue.tokens;
+        const tokenSplit = splitTokens(slot.tokens, policy);
+        if (tokenSplit.secret !== void 0) {
+          secrets[issuerTokensField(issuer)] = tokenSplit.secret;
+        }
+        if (tokenSplit.plaintext) slotResidue.tokens = tokenSplit.plaintext;
+      }
+      if (slot.clientInformation) {
+        slotResidue.clientInformation = splitClientInformation(
+          slot.clientInformation,
+          issuerClientInfoFields(issuer),
+          secrets
+        );
+      }
+      setOwnEntry(byIssuer, issuer, slotResidue);
+    }
+    residue.byIssuer = byIssuer;
+  }
+  if (state.tokens) {
+    delete residue.tokens;
+    const tokenSplit = splitTokens(state.tokens, policy);
+    if (tokenSplit.secret !== void 0) {
+      secrets[LEGACY_TOKENS_FIELD] = tokenSplit.secret;
+    }
+    if (tokenSplit.plaintext) residue.tokens = tokenSplit.plaintext;
+  }
+  if (state.clientInformation) {
+    residue.clientInformation = splitClientInformation(
+      state.clientInformation,
+      LEGACY_CLIENT_INFO_FIELDS,
+      secrets
+    );
+  }
+  if (state.preregisteredClientInformation) {
+    residue.preregisteredClientInformation = splitClientInformation(
+      state.preregisteredClientInformation,
+      PREREG_CLIENT_INFO_FIELDS,
+      secrets
+    );
+  }
+  return { residue, secrets };
+}
+function parseStoredTokens(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (StorableTokensSchema.safeParse(parsed).success && hasSecretBearingTokenField(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function parseStoredIdpSession(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null) {
+      const { idToken, refreshToken } = parsed;
+      const usable = {
+        ...typeof idToken === "string" && { idToken },
+        ...typeof refreshToken === "string" && { refreshToken }
+      };
+      if (Object.keys(usable).length > 0) return usable;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function isUsableStoredSecret(field, raw) {
+  if (field === LEGACY_TOKENS_FIELD || field.startsWith("tokens:")) {
+    return parseStoredTokens(raw) !== void 0;
+  }
+  if (field === IDP_SESSION_FIELD) {
+    return parseStoredIdpSession(raw) !== void 0;
+  }
+  return true;
+}
+function joinServerOAuthState(residue, secrets) {
+  const joined = { ...residue };
+  if (residue.byIssuer) {
+    const byIssuer = {};
+    for (const [issuer, slot] of Object.entries(residue.byIssuer)) {
+      const joinedSlot = { ...slot };
+      const tokensRaw = secrets[issuerTokensField(issuer)];
+      if (tokensRaw !== void 0) {
+        const tokens = parseStoredTokens(tokensRaw);
+        if (tokens) joinedSlot.tokens = tokens;
+      }
+      if (joinedSlot.clientInformation) {
+        joinedSlot.clientInformation = joinClientInformation(
+          joinedSlot.clientInformation,
+          issuerClientInfoFields(issuer),
+          secrets
+        );
+      }
+      setOwnEntry(byIssuer, issuer, joinedSlot);
+    }
+    joined.byIssuer = byIssuer;
+  }
+  const legacyTokensRaw = secrets[LEGACY_TOKENS_FIELD];
+  if (legacyTokensRaw !== void 0) {
+    const tokens = parseStoredTokens(legacyTokensRaw);
+    if (tokens) joined.tokens = tokens;
+  }
+  if (joined.clientInformation) {
+    joined.clientInformation = joinClientInformation(
+      joined.clientInformation,
+      LEGACY_CLIENT_INFO_FIELDS,
+      secrets
+    );
+  }
+  if (joined.preregisteredClientInformation) {
+    joined.preregisteredClientInformation = joinClientInformation(
+      joined.preregisteredClientInformation,
+      PREREG_CLIENT_INFO_FIELDS,
+      secrets
+    );
+  }
+  return joined;
+}
+function splitIdpSession(session, policy) {
+  const { idToken, refreshToken, ...residue } = session;
+  const secrets = {};
+  if (policy !== "none" && (idToken !== void 0 || refreshToken !== void 0)) {
+    const kept = {
+      ...typeof idToken === "string" && { idToken },
+      ...policy === "all" && typeof refreshToken === "string" && { refreshToken }
+    };
+    if (Object.keys(kept).length > 0) {
+      secrets[IDP_SESSION_FIELD] = JSON.stringify(kept);
+    }
+  }
+  return { residue, secrets };
+}
+function joinIdpSession(residue, secrets) {
+  const raw = secrets[IDP_SESSION_FIELD];
+  if (raw === void 0) return { ...residue };
+  const stored = parseStoredIdpSession(raw);
+  return stored ? { ...residue, ...stored } : { ...residue };
+}
+function serverSecretFields(state) {
+  const fields = /* @__PURE__ */ new Set([
+    LEGACY_TOKENS_FIELD,
+    LEGACY_CLIENT_SECRET_FIELD,
+    LEGACY_REGISTRATION_TOKEN_FIELD,
+    PREREG_CLIENT_SECRET_FIELD,
+    PREREG_REGISTRATION_TOKEN_FIELD
+  ]);
+  for (const issuer of Object.keys(state?.byIssuer ?? {})) {
+    fields.add(issuerTokensField(issuer));
+    fields.add(issuerClientSecretField(issuer));
+    fields.add(issuerRegistrationTokenField(issuer));
+  }
+  return [...fields];
+}
+function clientInfoHasPlaintext(info) {
+  return info !== void 0 && (info.client_secret !== void 0 || info.registration_access_token !== void 0);
+}
+function snapshotHasPlaintextSecrets(snapshot) {
+  for (const state of Object.values(snapshot.servers)) {
+    if (state.tokens) return true;
+    if (clientInfoHasPlaintext(state.clientInformation)) return true;
+    if (clientInfoHasPlaintext(state.preregisteredClientInformation)) {
+      return true;
+    }
+    for (const slot of Object.values(state.byIssuer ?? {})) {
+      if (slot.tokens) return true;
+      if (clientInfoHasPlaintext(slot.clientInformation)) return true;
+    }
+  }
+  for (const session of Object.values(snapshot.idpSessions)) {
+    if (session.idToken !== void 0 || session.refreshToken !== void 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
 // ../../core/auth/node/oauth-persist-file.ts
+var warnedStoreFailures = /* @__PURE__ */ new Set();
+function warnStoreWriteFailure(error) {
+  const reason = error instanceof Error ? error.message : String(error);
+  if (warnedStoreFailures.has(reason)) return;
+  warnedStoreFailures.add(reason);
+  console.warn(
+    `[mcp-inspector] Could not write OAuth tokens to the secret store (${reason}). Tokens will be kept in memory for this session only and will NOT be persisted; expect to re-authorize after a restart.`
+  );
+}
+function warnRestoreFailure(error) {
+  const reason = error instanceof Error ? error.message : String(error);
+  const key = `restore:${reason}`;
+  if (warnedStoreFailures.has(key)) return;
+  warnedStoreFailures.add(key);
+  console.warn(
+    `[mcp-inspector] Could not restore secret-store entries after a failed OAuth state write (${reason}). The secret store may be inconsistent with oauth.json; if a server's stored credentials stop working, re-authorize it.`
+  );
+}
+function warnUnconfirmedFile(error) {
+  const reason = error instanceof Error ? error.message : String(error);
+  const key = `unconfirmed:${reason}`;
+  if (warnedStoreFailures.has(key)) return;
+  warnedStoreFailures.add(key);
+  console.warn(
+    `[mcp-inspector] Could not re-read oauth.json after a failed OAuth state save (${reason}). The file may still contain the interrupted save while the secret store was restored to the previous values; if a server's stored credentials stop working, re-authorize it.`
+  );
+}
+function warnMigrationFailure(error) {
+  const reason = error instanceof Error ? error.message : String(error);
+  const key = `migration:${reason}`;
+  if (warnedStoreFailures.has(key)) return;
+  warnedStoreFailures.add(key);
+  console.warn(
+    `[mcp-inspector] Could not migrate plaintext OAuth secrets into the secret store (${reason}). The plaintext copy in oauth.json was kept and keeps working; migration will be retried on the next read.`
+  );
+}
+function rethrowLockError(filePath, error, action = "save") {
+  if (error instanceof SecretFileLockHeldError) {
+    throw new SecretFileLockHeldError(
+      `Could not ${action} OAuth state: the state file at ${filePath} is locked by another Inspector process and did not become available.`,
+      { cause: error }
+    );
+  }
+  throw error;
+}
+async function withOAuthStateLock(filePath, action, body) {
+  let entered = false;
+  try {
+    return await withSecretFileLock(filePath, async () => {
+      entered = true;
+      return body();
+    });
+  } catch (error) {
+    if (!entered) rethrowLockError(filePath, error, action);
+    throw error;
+  }
+}
+var OAuthStateFileUnrecognizedError = class extends Error {
+  constructor(filePath, action) {
+    super(
+      `Refusing to ${action} OAuth state: ${filePath} exists but is not a recognized OAuth state file (it may be corrupt, truncated, or written by something else). Its entries are the only index of credentials in the OS keychain / secret store, so overwriting it would strand them. Restore the file from a backup or fix its JSON; deleting it starts fresh but abandons any credentials it indexed.`
+    );
+    this.name = "OAuthStateFileUnrecognizedError";
+  }
+};
+async function readDiskForMutation(filePath, action) {
+  const raw = await readStoreFile(filePath);
+  const parsed = parseOAuthPersistBlob(raw);
+  if (raw !== null && parsed === null) {
+    throw new OAuthStateFileUnrecognizedError(filePath, action);
+  }
+  return parsed;
+}
+async function persistEntrySecrets(store, serverId, candidates, secrets, prior, allowDegrade) {
+  const priorValue = new Map(prior.map(({ field, value }) => [field, value]));
+  const changed = {};
+  for (const [field, value] of Object.entries(secrets)) {
+    if (priorValue.get(field) !== value) changed[field] = value;
+  }
+  try {
+    if (Object.keys(changed).length > 0) {
+      await secretStoreSetMany(store, serverId, changed);
+    }
+  } catch (error) {
+    if (!allowDegrade) throw error;
+    warnStoreWriteFailure(error);
+    const touched = prior.filter(({ field }) => changed[field] !== void 0);
+    let restoreFailure;
+    await restoreSecretFields(store, touched, (err) => {
+      restoreFailure = err;
+    });
+    if (restoreFailure !== void 0) throw restoreFailure;
+    return false;
+  }
+  await settleStoreMutations(
+    candidates.filter(
+      (field) => secrets[field] === void 0 && priorValue.get(field) !== null
+    ).map((field) => store.delete(serverId, field))
+  );
+  return true;
+}
+function revertEntryToDisk(merged, disk, key) {
+  const diskEntry = getOwnEntry(disk, key);
+  if (diskEntry === void 0) {
+    if (Object.hasOwn(merged, key)) delete merged[key];
+  } else {
+    setOwnEntry(merged, key, diskEntry);
+  }
+}
+function preserveNonDurableSecrets(diskSecrets, secrets) {
+  const keep = {};
+  for (const [field, value] of Object.entries(secrets)) {
+    if (diskSecrets[field] === value) keep[field] = value;
+  }
+  return keep;
+}
+async function writeOAuthSections(filePath, snapshot, sections, secretStore = defaultSecretStore()) {
+  const policy = getPersistTokensPolicy();
+  const durable = await secretStoreIsDurable(secretStore);
+  await withOAuthStateLock(filePath, "save", async () => {
+    const restoreBaseline = /* @__PURE__ */ new Map();
+    const ourWrites = /* @__PURE__ */ new Map();
+    const priorKey = (p) => `${p.serverId}\0${p.field}`;
+    const foldPriors = (priors) => {
+      for (const prior of priors) {
+        const key = priorKey(prior);
+        if (restoreBaseline.has(key) && ourWrites.get(key) !== void 0 && prior.value === ourWrites.get(key)) {
+          continue;
+        }
+        restoreBaseline.set(key, prior);
+      }
+    };
+    const restoreToBaseline = () => restoreSecretFields(
+      secretStore,
+      [...restoreBaseline.values()],
+      warnRestoreFailure
+    );
+    let unconfirmed = null;
+    const reconcileFailure = async () => {
+      if (unconfirmed !== null) {
+        const committed = unconfirmed;
+        let observed = null;
+        let readable = true;
+        try {
+          observed = await readStoreFile(filePath);
+        } catch (error) {
+          readable = false;
+          warnUnconfirmedFile(error);
+        }
+        if (readable && observed === committed.written) {
+          const target = new Map(
+            [...restoreBaseline].map(([key, { serverId, field, value }]) => [
+              key,
+              { serverId, field, value }
+            ])
+          );
+          for (const [key, write] of committed.writes) target.set(key, write);
+          try {
+            await settleStoreMutations(
+              [...target.values()].map(
+                ({ serverId, field, value }) => value === null ? secretStore.delete(serverId, field) : secretStore.set(serverId, field, value)
+              )
+            );
+            return true;
+          } catch (error) {
+            warnRestoreFailure(error);
+            return false;
+          }
+        }
+      }
+      await restoreToBaseline();
+      return false;
+    };
+    for (let attempt = 0; attempt < MAX_WRITE_ATTEMPTS; attempt++) {
+      const priorSecrets = [];
+      const attemptWrites = /* @__PURE__ */ new Map();
+      let written;
+      try {
+        const disk = await readDiskForMutation(filePath, "save");
+        const effective = sections ? {
+          servers: sections.servers && [...new Set(sections.servers)],
+          idpSessions: sections.idpSessions && [
+            ...new Set(sections.idpSessions)
+          ]
+        } : {
+          servers: [
+            .../* @__PURE__ */ new Set([
+              ...Object.keys(disk?.servers ?? {}),
+              ...Object.keys(snapshot.servers)
+            ])
+          ],
+          idpSessions: [
+            .../* @__PURE__ */ new Set([
+              ...Object.keys(disk?.idpSessions ?? {}),
+              ...Object.keys(snapshot.idpSessions)
+            ])
+          ]
+        };
+        const merged = mergeOAuthSections(disk, snapshot, effective);
+        for (const url of effective.servers ?? []) {
+          const serverId = oauthSecretServerId(url);
+          const next = getOwnEntry(snapshot.servers, url);
+          const candidates = [
+            .../* @__PURE__ */ new Set([
+              ...serverSecretFields(getOwnEntry(disk?.servers, url)),
+              ...serverSecretFields(next)
+            ])
+          ];
+          const entryPrior = await snapshotSecretFields(
+            secretStore,
+            serverId,
+            candidates
+          );
+          priorSecrets.push(...entryPrior);
+          if (next === void 0) {
+            for (const field of candidates) {
+              ourWrites.set(priorKey({ serverId, field }), null);
+            }
+            await secretStore.deleteAllForServer(serverId);
+            for (const field of candidates) {
+              attemptWrites.set(priorKey({ serverId, field }), {
+                serverId,
+                field,
+                value: null
+              });
+            }
+            continue;
+          }
+          const { residue, secrets } = splitServerOAuthState(next, policy);
+          for (const field of candidates) {
+            ourWrites.set(
+              priorKey({ serverId, field }),
+              secrets[field] ?? null
+            );
+          }
+          setOwnEntry(merged.servers, url, residue);
+          if (!durable) {
+            const diskEntry = getOwnEntry(disk?.servers, url);
+            const keep = preserveNonDurableSecrets(
+              diskEntry ? splitServerOAuthState(diskEntry, policy).secrets : {},
+              secrets
+            );
+            if (Object.keys(keep).length > 0) {
+              setOwnEntry(
+                merged.servers,
+                url,
+                joinServerOAuthState(residue, keep)
+              );
+            }
+          }
+          const persisted = await persistEntrySecrets(
+            secretStore,
+            serverId,
+            candidates,
+            secrets,
+            entryPrior,
+            // Degrading is only sound when the disk entry is the pre-call
+            // state this attempt's priors pair with; on a retry it may be an
+            // earlier attempt's committed residue, so escalate into the
+            // reconciling exit instead.
+            attempt === 0
+          );
+          if (!persisted) {
+            revertEntryToDisk(merged.servers, disk?.servers, url);
+            continue;
+          }
+          for (const field of candidates) {
+            attemptWrites.set(priorKey({ serverId, field }), {
+              serverId,
+              field,
+              value: secrets[field] ?? null
+            });
+          }
+        }
+        for (const issuer of effective.idpSessions ?? []) {
+          const serverId = oauthIdpSecretServerId(issuer);
+          const next = getOwnEntry(snapshot.idpSessions, issuer);
+          const entryPrior = await snapshotSecretFields(secretStore, serverId, [
+            IDP_SESSION_FIELD
+          ]);
+          priorSecrets.push(...entryPrior);
+          if (next === void 0) {
+            ourWrites.set(
+              priorKey({ serverId, field: IDP_SESSION_FIELD }),
+              null
+            );
+            await secretStore.deleteAllForServer(serverId);
+            attemptWrites.set(
+              priorKey({ serverId, field: IDP_SESSION_FIELD }),
+              {
+                serverId,
+                field: IDP_SESSION_FIELD,
+                value: null
+              }
+            );
+            continue;
+          }
+          const { residue, secrets } = splitIdpSession(next, policy);
+          ourWrites.set(
+            priorKey({ serverId, field: IDP_SESSION_FIELD }),
+            secrets[IDP_SESSION_FIELD] ?? null
+          );
+          setOwnEntry(merged.idpSessions, issuer, residue);
+          if (!durable) {
+            const diskSession = getOwnEntry(disk?.idpSessions, issuer);
+            const keep = preserveNonDurableSecrets(
+              diskSession ? splitIdpSession(diskSession, policy).secrets : {},
+              secrets
+            );
+            if (Object.keys(keep).length > 0) {
+              setOwnEntry(
+                merged.idpSessions,
+                issuer,
+                joinIdpSession(residue, keep)
+              );
+            }
+          }
+          const persisted = await persistEntrySecrets(
+            secretStore,
+            serverId,
+            [IDP_SESSION_FIELD],
+            secrets,
+            entryPrior,
+            // Same as the server loop: degrade on the first attempt only.
+            attempt === 0
+          );
+          if (!persisted) {
+            revertEntryToDisk(merged.idpSessions, disk?.idpSessions, issuer);
+            continue;
+          }
+          attemptWrites.set(priorKey({ serverId, field: IDP_SESSION_FIELD }), {
+            serverId,
+            field: IDP_SESSION_FIELD,
+            value: secrets[IDP_SESSION_FIELD] ?? null
+          });
+        }
+        written = serializeOAuthPersistBlob(merged);
+        await writeStoreFile(filePath, written);
+        unconfirmed = { written, writes: attemptWrites };
+      } catch (error) {
+        foldPriors(priorSecrets);
+        if (await reconcileFailure()) return;
+        throw error;
+      }
+      foldPriors(priorSecrets);
+      let observed;
+      try {
+        observed = await readStoreFile(filePath);
+      } catch {
+        continue;
+      }
+      if (observed === written) return;
+      unconfirmed = null;
+    }
+    if (await reconcileFailure()) return;
+    throw new SecretStoreUnavailableError(
+      `Could not save OAuth state: another process kept overwriting ${filePath} (gave up after ${MAX_WRITE_ATTEMPTS} attempts). Re-run the action to retry.`
+    );
+  });
+}
+function secretRequestsFor(snapshot) {
+  const requests = [];
+  for (const [url, state] of Object.entries(snapshot.servers)) {
+    requests.push({
+      serverId: oauthSecretServerId(url),
+      fields: serverSecretFields(state)
+    });
+  }
+  for (const issuer of Object.keys(snapshot.idpSessions)) {
+    requests.push({
+      serverId: oauthIdpSecretServerId(issuer),
+      fields: [IDP_SESSION_FIELD]
+    });
+  }
+  return requests;
+}
+async function joinSnapshot(snapshot, secretStore) {
+  const requests = secretRequestsFor(snapshot);
+  const values = requests.length > 0 ? await secretStoreGetManyStrict(secretStore, requests) : {};
+  return {
+    servers: Object.fromEntries(
+      Object.entries(snapshot.servers).map(([url, state]) => [
+        url,
+        joinServerOAuthState(state, values[oauthSecretServerId(url)] ?? {})
+      ])
+    ),
+    idpSessions: Object.fromEntries(
+      Object.entries(snapshot.idpSessions).map(([issuer, session]) => [
+        issuer,
+        joinIdpSession(session, values[oauthIdpSecretServerId(issuer)] ?? {})
+      ])
+    )
+  };
+}
+async function migratePlaintextSecrets(filePath, secretStore) {
+  const raw = await readStoreFile(filePath);
+  const fresh = parseOAuthPersistBlob(raw);
+  if (!fresh || !snapshotHasPlaintextSecrets(fresh)) return;
+  const migrateEntrySecrets = async (serverId, secrets) => {
+    const absent = {};
+    for (const [field, value] of Object.entries(secrets)) {
+      const existing = await secretStoreGetStrict(secretStore, serverId, field);
+      if (existing === null || !isUsableStoredSecret(field, existing)) {
+        absent[field] = value;
+      }
+    }
+    if (Object.keys(absent).length > 0) {
+      await secretStoreSetMany(secretStore, serverId, absent);
+    }
+  };
+  const residue = { servers: {}, idpSessions: {} };
+  for (const [url, state] of Object.entries(fresh.servers)) {
+    const split = splitServerOAuthState(state, "all");
+    setOwnEntry(residue.servers, url, split.residue);
+    await migrateEntrySecrets(oauthSecretServerId(url), split.secrets);
+  }
+  for (const [issuer, session] of Object.entries(fresh.idpSessions)) {
+    const split = splitIdpSession(session, "all");
+    setOwnEntry(residue.idpSessions, issuer, split.residue);
+    await migrateEntrySecrets(oauthIdpSecretServerId(issuer), split.secrets);
+  }
+  const stripped = serializeOAuthPersistBlob(residue);
+  if (stripped !== raw) {
+    await writeStoreFile(filePath, stripped);
+  }
+}
+async function readOAuthStore(filePath, secretStore = defaultSecretStore()) {
+  return withOAuthStateLock(filePath, "read", async () => {
+    let snapshot = parseOAuthPersistBlob(await readStoreFile(filePath));
+    if (snapshot === null) return null;
+    if (snapshotHasPlaintextSecrets(snapshot) && await secretStoreIsDurable(secretStore)) {
+      try {
+        await migratePlaintextSecrets(filePath, secretStore);
+        snapshot = parseOAuthPersistBlob(await readStoreFile(filePath)) ?? snapshot;
+      } catch (error) {
+        warnMigrationFailure(error);
+      }
+    }
+    return joinSnapshot(snapshot, secretStore);
+  });
+}
+async function removeOAuthStore(filePath, secretStore = defaultSecretStore()) {
+  await withOAuthStateLock(filePath, "remove", async () => {
+    const snapshot = await readDiskForMutation(filePath, "remove");
+    if (snapshot) {
+      const targets = [
+        ...Object.entries(snapshot.servers).map(([url, state]) => ({
+          id: oauthSecretServerId(url),
+          fields: serverSecretFields(state)
+        })),
+        ...Object.keys(snapshot.idpSessions).map((issuer) => ({
+          id: oauthIdpSecretServerId(issuer),
+          fields: [IDP_SESSION_FIELD]
+        }))
+      ];
+      const priorSecrets = [];
+      try {
+        for (const { id, fields } of targets) {
+          priorSecrets.push(
+            ...await snapshotSecretFields(secretStore, id, fields)
+          );
+          await secretStore.deleteAllForServer(id);
+        }
+        await deleteStoreFile(filePath);
+      } catch (error) {
+        await restoreSecretFields(
+          secretStore,
+          priorSecrets,
+          warnRestoreFailure
+        );
+        throw error;
+      }
+    } else {
+      await deleteStoreFile(filePath);
+    }
+  });
+}
 function createFileOAuthPersistBackend(options) {
+  const secretStore = options.secretStore ?? defaultSecretStore();
   return {
     async read() {
-      const raw = await readStoreFile(options.filePath);
-      return parseOAuthPersistBlob(raw);
+      return readOAuthStore(options.filePath, secretStore);
     },
-    async write(snapshot) {
-      await writeStoreFile(
+    async write(snapshot, sections) {
+      await writeOAuthSections(
         options.filePath,
-        serializeOAuthPersistBlob(snapshot)
+        snapshot,
+        sections,
+        secretStore
       );
     },
     async remove() {
-      await deleteStoreFile(options.filePath);
+      await removeOAuthStore(options.filePath, secretStore);
     }
   };
 }
@@ -5041,31 +6338,39 @@ function getStateFilePath(customPath) {
   }
   return DEFAULT_STATE_PATH;
 }
-var memoryCache = /* @__PURE__ */ new Map();
+var sharedStateCache = /* @__PURE__ */ new Map();
 var storageCache = /* @__PURE__ */ new Map();
-function getSharedMemory(stateFilePath) {
+function getSharedState(stateFilePath) {
   const key = getStateFilePath(stateFilePath);
-  let memory = memoryCache.get(key);
-  if (!memory) {
-    memory = new OAuthMemoryStore();
-    memoryCache.set(key, memory);
+  let shared = sharedStateCache.get(key);
+  if (!shared) {
+    shared = {
+      memory: new OAuthMemoryStore(),
+      coordination: new OAuthStorageCoordination()
+    };
+    sharedStateCache.set(key, shared);
   }
-  return memory;
+  return shared;
 }
 function resetNodeOAuthStorageCache(stateFilePath) {
   const key = getStateFilePath(stateFilePath);
-  memoryCache.delete(key);
+  sharedStateCache.delete(key);
   storageCache.delete(key);
 }
 var NodeOAuthStorage = class extends OAuthStorageBase {
   /**
    * @param storagePath - Optional path to state file. Default: ~/.mcp-inspector/storage/oauth.json
+   * @param secretStore - Optional secret store for tokens/client secrets.
+   *   Default: the process-wide selected store. Tests inject an in-memory
+   *   double here so they never touch the OS keychain.
    */
-  constructor(storagePath) {
+  constructor(storagePath, secretStore) {
     const filePath = getStateFilePath(storagePath);
+    const shared = getSharedState(storagePath);
     super(
-      getSharedMemory(storagePath),
-      createFileOAuthPersistBackend({ filePath })
+      shared.memory,
+      createFileOAuthPersistBackend({ filePath, secretStore }),
+      shared.coordination
     );
   }
 };
@@ -5074,7 +6379,7 @@ var NodeOAuthStorage = class extends OAuthStorageBase {
 import { selectClientAuthMethod } from "@modelcontextprotocol/client";
 import {
   OAuthClientInformationSchema as OAuthClientInformationSchema2,
-  OAuthTokensSchema as OAuthTokensSchema2
+  OAuthTokensSchema as OAuthTokensSchema4
 } from "@modelcontextprotocol/core";
 var DEFAULT_REVOCATION_TIMEOUT_MS = 5e3;
 var MIN_REVOCATION_REQUEST_BUDGET_MS = 5;
@@ -5302,7 +6607,7 @@ async function collectGrants(snapshot) {
   return { grants, failures };
 }
 async function parseTokens(raw) {
-  return raw === void 0 || raw === null ? void 0 : await OAuthTokensSchema2.parseAsync(raw);
+  return raw === void 0 || raw === null ? void 0 : await OAuthTokensSchema4.partial().parseAsync(raw);
 }
 async function parseClient(raw) {
   return raw === void 0 || raw === null ? void 0 : await OAuthClientInformationSchema2.parseAsync(raw);
@@ -5462,14 +6767,14 @@ var OBJECT_VALUED_SUBSCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
 function pathName(path5) {
   return path5.length === 0 ? "<root>" : path5.join(".");
 }
-function isRecord2(node) {
+function isRecord4(node) {
   return node !== null && typeof node === "object";
 }
 function scanXMcpHeaderDeclarations(inputSchema) {
   const declarations = [];
   const seenLower = /* @__PURE__ */ new Map();
   const visit = (node, path5, reachable) => {
-    if (!isRecord2(node)) return void 0;
+    if (!isRecord4(node)) return void 0;
     const schema = node;
     if (X_MCP_HEADER_KEY in schema) {
       if (!reachable || path5.length === 0) {
@@ -5495,7 +6800,7 @@ function scanXMcpHeaderDeclarations(inputSchema) {
       declarations.push({ path: path5, headerName: raw, type });
     }
     const properties = schema.properties;
-    if (isRecord2(properties)) {
+    if (isRecord4(properties)) {
       for (const [key, child] of Object.entries(properties)) {
         const fault2 = visit(child, [...path5, key], reachable);
         if (fault2 !== void 0) return fault2;
@@ -5504,7 +6809,7 @@ function scanXMcpHeaderDeclarations(inputSchema) {
     for (const k of NON_REACHABLE_SUBSCHEMA_KEYWORDS) {
       const sub = schema[k];
       if (sub === void 0) continue;
-      const branches = Array.isArray(sub) ? sub : isRecord2(sub) && OBJECT_VALUED_SUBSCHEMA_KEYWORDS.has(k) ? Object.values(sub) : [sub];
+      const branches = Array.isArray(sub) ? sub : isRecord4(sub) && OBJECT_VALUED_SUBSCHEMA_KEYWORDS.has(k) ? Object.values(sub) : [sub];
       for (const branch of branches) {
         const fault2 = visit(branch, [...path5, `<${k}>`], false);
         if (fault2 !== void 0) return fault2;
@@ -5736,7 +7041,7 @@ import {
   LOG_LEVEL_META_KEY,
   CLIENT_CAPABILITIES_META_KEY,
   CLIENT_INFO_META_KEY,
-  PROTOCOL_VERSION_META_KEY,
+  PROTOCOL_VERSION_META_KEY as PROTOCOL_VERSION_META_KEY2,
   RELATED_TASK_META_KEY as RELATED_TASK_META_KEY3
 } from "@modelcontextprotocol/client";
 
@@ -5805,10 +7110,13 @@ var ADVERTISABLE_EXTENSIONS = [
   {
     key: UI_EXTENSION_KEY,
     label: "MCP Apps UI (io.modelcontextprotocol/ui)",
-    // The MCP Apps UI extension. The Inspector always renders App tools, so it
-    // advertises this by default with the App resource MIME type it supports —
-    // a conforming server checks the `mimeTypes` before serving a UI resource.
+    // The MCP Apps UI extension, advertised with the App resource MIME type the
+    // Inspector renders — a conforming server checks the `mimeTypes` before
+    // serving a UI resource. Default-on only where Apps can actually be
+    // rendered (the web client); the CLI and TUI cannot, so they leave it off
+    // unless explicitly overridden (#2403).
     defaultAdvertised: true,
+    requiresAppRenderer: true,
     advertisement: { mimeTypes: [MCP_APP_MIME_TYPE] }
   },
   {
@@ -5824,10 +7132,13 @@ var ADVERTISABLE_EXTENSIONS = [
     defaultAdvertised: true
   }
 ];
+function isAdvertisedByDefault(ext, rendersApps) {
+  return ext.defaultAdvertised && (!ext.requiresAppRenderer || rendersApps);
+}
 function buildClientExtensions(input) {
   const map = {};
   for (const ext of ADVERTISABLE_EXTENSIONS) {
-    const advertised = input.advertised?.[ext.key] ?? ext.defaultAdvertised;
+    const advertised = input.advertised?.[ext.key] ?? isAdvertisedByDefault(ext, input.rendersApps === true);
     if (advertised) {
       map[ext.key] = ext.advertisement ? structuredClone(ext.advertisement) : {};
     }
@@ -6772,6 +8083,14 @@ function exemptMcpEndpoint(getServerUrl, negotiatesEndpoint) {
   };
 }
 var REQUEST_DEADLINES = /* @__PURE__ */ new WeakMap();
+function stampRequestDeadline(init, budget) {
+  if (REQUEST_DEADLINES.has(init)) {
+    throw new Error(
+      "stampRequestDeadline: this RequestInit already carries a deadline \u2014 withOAuthRequestTimeout must build a fresh init per call (#2418)"
+    );
+  }
+  REQUEST_DEADLINES.set(init, budget);
+}
 function requestHeadersOf(input, init) {
   if (init?.headers) return new Headers(init.headers);
   if (typeof input !== "string" && !(input instanceof URL)) {
@@ -6829,7 +8148,7 @@ function withOAuthRequestTimeout(fetchFn, timeoutMs = DEFAULT_OAUTH_REQUEST_TIME
       }
     });
     const nextInit = { ...init, signal };
-    REQUEST_DEADLINES.set(nextInit, budget);
+    stampRequestDeadline(nextInit, budget);
     let settled;
     let drainReader;
     try {
@@ -6942,7 +8261,7 @@ function withRfc8414OidcCompat(fetchFn) {
         return response;
       }
       if (!probe.ok) {
-        await releaseBody(probe);
+        releaseBodyDetached(probe);
         if (callerSignal?.aborted) {
           releaseBodyDetached(response);
           throw callerSignal.reason;
@@ -6966,7 +8285,7 @@ function withRfc8414OidcCompat(fetchFn) {
         return response;
       }
       const source = probe.url || candidate;
-      await releaseBody(response);
+      releaseBodyDetached(response);
       console.warn(
         `[oauth] ${source} returned RFC 8414 OAuth 2.0 authorization server metadata, not an OpenID provider document. The MCP TypeScript SDK validates that path as OpenID Connect Discovery and would reject it (modelcontextprotocol/typescript-sdk#2733), so the Inspector is handing it to discovery as the RFC 8414 document it is.`
       );
@@ -7926,7 +9245,7 @@ async function discoverResourceAsMetadata(resourceAsUrl, fetchFn) {
 
 // ../../core/auth/ema/wire.ts
 import { discoverAndRequestJwtAuthGrant } from "@modelcontextprotocol/client";
-import { OAuthTokensSchema as OAuthTokensSchema3 } from "@modelcontextprotocol/core";
+import { OAuthTokensSchema as OAuthTokensSchema5 } from "@modelcontextprotocol/core";
 async function exchangeIdJag(params) {
   const issuer = normalizeIdpIssuer(params.idp.issuer);
   const resource = params.resource.trim();
@@ -8005,7 +9324,7 @@ async function redeemIdJagForAccessToken(params) {
       "EMA leg 3 (resource AS JWT bearer grant)"
     );
   }
-  return OAuthTokensSchema3.parse(await response.json());
+  return OAuthTokensSchema5.parse(await response.json());
 }
 
 // ../../core/auth/ema/emaFlow.ts
@@ -9230,6 +10549,14 @@ function progressTokenOf(message) {
   }
   return void 0;
 }
+function waitForProgressToken(waits, token) {
+  const exact = waits.get(token);
+  if (exact !== void 0 || typeof token === "number") {
+    return exact;
+  }
+  const numeric = Number(token);
+  return Number.isSafeInteger(numeric) ? waits.get(numeric) : void 0;
+}
 
 // ../../core/mcp/remote/remoteClientTransport.ts
 var DEFAULT_SSE_RESPONSE_TIMEOUT_MS = 6e4;
@@ -9706,8 +11033,8 @@ var RemoteClientTransport = class {
     });
   }
   /** Re-arm a pending request's SSE wait timeout on a matching progress note. */
-  resetSseResponseWait(requestId) {
-    this.sseResponseWaits.get(requestId)?.resetTimeout();
+  resetSseResponseWait(progressToken) {
+    waitForProgressToken(this.sseResponseWaits, progressToken)?.resetTimeout();
   }
   async postSend(message, options, retryCount) {
     const requestId = requestIdForMessage(message);
@@ -9912,6 +11239,11 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
   requestTimeout;
   defaultMetadata;
   serverSettings;
+  // The settings the current transport was built from. `serverSettings` is
+  // replaced live on every settings save (#1444), but transport-level inputs
+  // such as custom headers are fixed when the transport is created, so this
+  // is what the open connection actually sends (#2460).
+  transportSettings;
   versionNegotiation;
   status = "disconnected";
   // True only while an explicit disconnect() owns the teardown. close() can
@@ -10266,6 +11598,10 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     const advertisedExtensions = buildClientExtensions({
       enterpriseManaged: options.oauth?.enterpriseManaged ?? false,
       advertised: this.advertisedExtensions,
+      // Only a client that can render Apps claims the UI extension by default
+      // (#2403). An app-elicitation renderer is itself a claim to host an App,
+      // so supplying one implies it.
+      rendersApps: options.rendersApps === true || this.appElicitationRenderer !== void 0,
       // Read off the built `capabilities.elicitation.form` rather than
       // re-deriving from `options.elicit`: the nested MCP Apps `elicitation`
       // setting must never be advertised without the core form capability it
@@ -10691,6 +12027,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     }
     this.baseTransport = null;
     this.transport = null;
+    this.transportSettings = void 0;
     this.transportHasAuthProvider = false;
   }
   /**
@@ -11164,6 +12501,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
         transportOptions
       );
       this.baseTransport = baseTransport;
+      this.transportSettings = transportOptions.settings;
       if (this.directAuthRecovery) {
         this.directAuthRecoveryActive = !(baseTransport instanceof RemoteClientTransport);
       }
@@ -11365,6 +12703,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     }
     this.baseTransport = null;
     this.transport = null;
+    this.transportSettings = void 0;
     this.transportHasAuthProvider = false;
     this.clearPendingPeerRequests();
     if (this.status !== "disconnected") {
@@ -11521,7 +12860,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       ...params,
       _meta: {
         ...existingMeta,
-        [PROTOCOL_VERSION_META_KEY]: protocolVersion,
+        [PROTOCOL_VERSION_META_KEY2]: protocolVersion,
         [CLIENT_INFO_META_KEY]: this.clientInfo,
         [CLIENT_CAPABILITIES_META_KEY]: clientCapabilities
       }
@@ -12097,6 +13436,13 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
   getClientCapabilities() {
     return this.clientCapabilities;
   }
+  /**
+   * Get the client identity (name, version) this client reports to servers —
+   * the caller's `clientIdentity`, or core's neutral fallback without one.
+   */
+  getClientInfo() {
+    return this.clientInfo;
+  }
   /**
    * Get server info (name, version)
    */
@@ -12148,6 +13494,16 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
   getServerSettings() {
     return this.serverSettings;
   }
+  /**
+   * The settings the current transport was built from, or `undefined` when no
+   * transport exists. Unlike {@link getServerSettings}, a live settings edit
+   * does not change this: transport-level inputs (custom headers) apply only
+   * when the next transport is created, so comparing the two tells a caller
+   * whether an edit is still waiting on a reconnect (#2460).
+   */
+  getTransportSettings() {
+    return this.transportSettings;
+  }
   /**
    * Replace the in-memory per-server settings on a live client. Lets a settings
    * edit (e.g. toggling auto-refresh-on-list-changed) take effect on the
@@ -13669,10 +15025,9 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
    * removes it before the result gets here (#2373).
    *
    * Separate from {@link getSkill} because the callers differ: the UIs want the
-   * entry, while the CLI prints the result and must not reshape it. SEP-2640
-   * explicitly leaves open whether this result carries `ttlMs` / `cacheScope`,
-   * so a server may send them — and unwrapping to the entry discards exactly
-   * those (Copilot).
+   * entry, while the CLI prints the result and must not reshape it. A modern
+   * result carries `ttlMs` / `cacheScope` (#2404), and unwrapping to the entry
+   * discards exactly those (Copilot).
    */
   async getSkillResult(uri, metadata) {
     if (!this.client) {
@@ -13683,11 +15038,12 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       uri,
       ...effectiveMeta ? { _meta: effectiveMeta } : {}
     };
+    const resultSchema = this.isModernEra() ? ModernGetSkillEnvelopeSchema : GetSkillEnvelopeSchema;
     try {
       return await this.invokeMcpClient(
         () => this.client.request(
           { method: SKILLS_GET_METHOD, params },
-          GetSkillEnvelopeSchema,
+          resultSchema,
           this.getRequestOptions(this.progressTokenOf(metadata))
         ),
         { method: SKILLS_GET_METHOD }
@@ -14838,9 +16194,74 @@ function isLoopbackHost(host) {
   return h === "localhost" || h === "[::1]" || /^127(\.(25[0-5]|2[0-4]\d|1?\d?\d)){3}$/.test(h);
 }
 
-// src/error-handler.ts
-var EXIT_CODES = {
-  OK: 0,
+// ../../core/auth/issuerBinding.ts
+import { AuthorizationServerMismatchError } from "@modelcontextprotocol/client";
+var MISSING_DISCOVERY_STATE_PHRASE = "discoveryState was not available";
+function isAuthorizationServerMismatchShape(err) {
+  if (err === null || typeof err !== "object") {
+    return false;
+  }
+  const candidate = err;
+  if (typeof candidate.recordedIssuer !== "string" || typeof candidate.currentIssuer !== "string") {
+    return false;
+  }
+  return AuthorizationServerMismatchError.isInstance(err) || candidate.name === "AuthorizationServerMismatchError";
+}
+function isMissingDiscoveryStatePlaceholder(recordedIssuer) {
+  if (recordedIssuer.includes(MISSING_DISCOVERY_STATE_PHRASE)) {
+    return true;
+  }
+  try {
+    const url = new URL(recordedIssuer);
+    return url.protocol !== "http:" && url.protocol !== "https:";
+  } catch {
+    return true;
+  }
+}
+function findIssuerBindingFailure(err) {
+  return findIssuerBindingFailureDeep(err, /* @__PURE__ */ new Set());
+}
+function findIssuerBindingFailureDeep(err, seen) {
+  if (err === null || typeof err !== "object" || seen.has(err)) {
+    return void 0;
+  }
+  seen.add(err);
+  if (isAuthorizationServerMismatchShape(err)) {
+    return classifyAuthorizationServerMismatch(err);
+  }
+  const nested = findIssuerBindingFailureDeep(
+    err.cause,
+    seen
+  );
+  if (nested) {
+    return nested;
+  }
+  const data = err.data;
+  if (data !== null && typeof data === "object") {
+    return findIssuerBindingFailureDeep(
+      data.cause,
+      seen
+    );
+  }
+  return void 0;
+}
+function classifyAuthorizationServerMismatch(err) {
+  if (isMissingDiscoveryStatePlaceholder(err.recordedIssuer)) {
+    return {
+      kind: "lost_authorization_state",
+      currentIssuer: err.currentIssuer
+    };
+  }
+  return {
+    kind: "issuer_mismatch",
+    recordedIssuer: err.recordedIssuer,
+    currentIssuer: err.currentIssuer
+  };
+}
+
+// src/error-handler.ts
+var EXIT_CODES = {
+  OK: 0,
   USAGE: 1,
   NO_APP: 2,
   AUTH_REQUIRED: 3,
@@ -14869,7 +16290,20 @@ var EXIT_CODES = {
    * job that wants to tolerate oversized catalogs can allow 8 and still fail
    * on 7.
    */
-  SKILL_INCOMPLETE: 8
+  SKILL_INCOMPLETE: 8,
+  /**
+   * `--verify --require-digests` found a skill whose `resources` is
+   * `"dynamic"`, so no digest was advertised and nothing was hashed (#2405).
+   *
+   * Only ever produced under `--require-digests`: `"dynamic"` is a conforming
+   * wire form, and SEP-2640 leaves declining such skills to the host ("Hosts
+   * MAY decline to load such skills"). The flag is how a CI job standing in for
+   * a host that declines them says so; without it the run exits 0 and reports
+   * `outcome: "unverifiable"`. Its own code, like 8, so a job can tell "no
+   * digests to check" apart from "a digest was wrong" and "the walk was cut
+   * short".
+   */
+  SKILL_UNVERIFIABLE: 9
 };
 var CliExitCodeError = class extends Error {
   constructor(exitCode, message, envelope) {
@@ -14904,7 +16338,44 @@ function statusOf(error) {
   return void 0;
 }
 var UNREACHABLE_PATTERN = /ENOTFOUND|ECONNREFUSED|ECONNRESET|EAI_AGAIN|ETIMEDOUT|fetch failed|getaddrinfo|connect(?:ion)? timed out|aborted/i;
+var EMBEDDED_URL_PATTERN = /\bhttps?:\/\/(?:(?!https?:\/\/)[^\s"<>])+/gi;
+var TRAILING_PUNCTUATION = /* @__PURE__ */ new Set([
+  ".",
+  ",",
+  ";",
+  ":",
+  "!",
+  "?",
+  ")",
+  "]",
+  "'"
+]);
+function trailingPunctuationStart(match) {
+  let end = match.length;
+  while (end > 0 && TRAILING_PUNCTUATION.has(match.charAt(end - 1))) end--;
+  return end;
+}
+function redactUrlsInText(text) {
+  return text.replace(EMBEDDED_URL_PATTERN, (match) => {
+    const end = trailingPunctuationStart(match);
+    return redactUrlQuery(match.slice(0, end)) + match.slice(end);
+  });
+}
+function redactEnvelope(envelope) {
+  return {
+    ...envelope,
+    message: redactUrlsInText(envelope.message),
+    ...envelope.cause !== void 0 && {
+      cause: redactUrlsInText(envelope.cause)
+    },
+    ...envelope.url !== void 0 && { url: redactUrlQuery(envelope.url) }
+  };
+}
 function classifyError(error, context) {
+  const { exitCode, envelope } = classifyUnredacted(error, context);
+  return { exitCode, envelope: redactEnvelope(envelope) };
+}
+function classifyUnredacted(error, context) {
   const message = error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error";
   const cause = causeOf(error);
   const status = statusOf(error);
@@ -14925,9 +16396,29 @@ function classifyError(error, context) {
       }
     };
   }
-  if (status === 401 || status === 403 || /WWW-Authenticate|Unauthorized|invalid_token|OAuth/i.test(
-    message + " " + (cause ?? "")
-  )) {
+  if (error instanceof SecretStoreUnavailableError) {
+    return {
+      exitCode: EXIT_CODES.USAGE,
+      envelope: {
+        code: "store_unavailable",
+        message,
+        ...cause !== void 0 && { cause },
+        ...url !== void 0 && { url }
+      }
+    };
+  }
+  if (error instanceof OAuthStateFileUnrecognizedError) {
+    return {
+      exitCode: EXIT_CODES.USAGE,
+      envelope: {
+        code: "oauth_state_unrecognized",
+        message,
+        ...cause !== void 0 && { cause },
+        ...url !== void 0 && { url }
+      }
+    };
+  }
+  if (status === 401 || status === 403 || isUnauthorizedError(error)) {
     return {
       exitCode: EXIT_CODES.AUTH_REQUIRED,
       envelope: {
@@ -14998,7 +16489,7 @@ var BOOLEAN_VALUED_KEYWORDS = /* @__PURE__ */ new Set([
   "additionalItems",
   "unevaluatedItems"
 ]);
-var SUBSCHEMA_KEYWORDS = [
+var SUBSCHEMA_KEYWORDS2 = [
   "items",
   "contains",
   "not",
@@ -15015,13 +16506,13 @@ var SUBSCHEMA_KEYWORDS = [
   // real finding.
   "contentSchema"
 ];
-var SUBSCHEMA_ARRAY_KEYWORDS = [
+var SUBSCHEMA_ARRAY_KEYWORDS2 = [
   "allOf",
   "anyOf",
   "oneOf",
   "prefixItems"
 ];
-var SUBSCHEMA_MAP_KEYWORDS = [
+var SUBSCHEMA_MAP_KEYWORDS2 = [
   "properties",
   "patternProperties",
   "dependentSchemas",
@@ -15103,8 +16594,8 @@ function isPortableTypeUnion(type) {
   }
   return new Set(type).size === type.length;
 }
-var MAX_DEPTH = 64;
-function isRecord3(value) {
+var MAX_DEPTH2 = 64;
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function childPath(parent, key) {
@@ -15120,7 +16611,7 @@ function describeSchemaPath(schema, path5) {
   return path5 === "" ? schema : `${schema}.${path5}`;
 }
 function declaresAnyId(node, depth = 0) {
-  if (depth > MAX_DEPTH || !isRecord3(node)) return false;
+  if (depth > MAX_DEPTH2 || !isRecord5(node)) return false;
   if (typeof node.$id === "string" && node.$id !== "") return true;
   let found = false;
   forEachSubschema(node, "", (child) => {
@@ -15139,21 +16630,21 @@ function add(ctx, rule, severity, path5, issue, suggestion) {
   });
 }
 function forEachSubschema(node, path5, visit) {
-  for (const key of SUBSCHEMA_MAP_KEYWORDS) {
+  for (const key of SUBSCHEMA_MAP_KEYWORDS2) {
     const map = node[key];
-    if (!isRecord3(map)) continue;
+    if (!isRecord5(map)) continue;
     for (const [name, sub] of Object.entries(map)) {
       visit(sub, childPath(childPath(path5, key), name), key);
     }
   }
-  for (const key of SUBSCHEMA_ARRAY_KEYWORDS) {
+  for (const key of SUBSCHEMA_ARRAY_KEYWORDS2) {
     const arr = node[key];
     if (!Array.isArray(arr)) continue;
     arr.forEach((sub, i) => {
       visit(sub, indexPath(childPath(path5, key), i), key);
     });
   }
-  for (const key of SUBSCHEMA_KEYWORDS) {
+  for (const key of SUBSCHEMA_KEYWORDS2) {
     if (!(key in node)) continue;
     const value = node[key];
     if (key === "items" && Array.isArray(value)) {
@@ -15172,7 +16663,7 @@ function booleanTrueSuggestion(keyword) {
   return 'Declare what the value actually is \u2014 e.g. `{"type": "object", "additionalProperties": true}` for a free-form object. That is a deliberate change of contract, not an equivalent rewrite: `true` accepts any JSON value at all.';
 }
 function walk(node, path5, keyword, depth, ctx) {
-  if (depth > MAX_DEPTH) return;
+  if (depth > MAX_DEPTH2) return;
   if (typeof node === "boolean") {
     if (keyword !== void 0 && BOOLEAN_VALUED_KEYWORDS.has(keyword)) return;
     add(
@@ -15191,12 +16682,13 @@ function walk(node, path5, keyword, depth, ctx) {
     );
     return;
   }
-  if (!isRecord3(node)) return;
+  if (!isRecord5(node)) return;
   lintNode(node, path5, keyword, ctx);
   forEachSubschema(node, path5, (child, childPathValue, childKeyword) => {
     walk(child, childPathValue, childKeyword, depth + 1, ctx);
   });
 }
+var NULL_BRANCH_CAVEAT = " A dialect with no `null` type, such as OpenAPI 3.0, still cannot express the `null` branch directly; there nullability is written `nullable: true`, which is not JSON Schema, so no single spelling is portable to both.";
 function lintNode(node, path5, keyword, ctx) {
   const type = node.type;
   if (Array.isArray(type) && isPortableTypeUnion(type)) {
@@ -15205,10 +16697,10 @@ function lintNode(node, path5, keyword, ctx) {
       "type-union",
       "warning",
       path5,
-      `\`type\` is an array (${JSON.stringify(type)}). The array form is legal JSON Schema, but several MCP clients read \`type\` as a single string and either reject the tool or drop the constraint.`,
+      `\`type\` is an array (${JSON.stringify(type)}). This is legal JSON Schema, and some model providers recommend it for nullable fields, but it is less portable: a client that maps tool schemas onto a single-\`type\` dialect (such as the OpenAPI subset used for Gemini function declarations) may reject the tool or drop the constraint.`,
       `Split it into \`anyOf\` branches, each with a single \`type\` \u2014 \`{"anyOf": [${type.map((t) => `{"type": "${t}"}`).join(
         ", "
-      )}]}\`. (Making the property optional instead is a different contract: absent is not the same as \`null\`.)`
+      )}]}\`. (Making the property optional instead is a different contract: absent is not the same as \`null\`.)${type.includes("null") ? NULL_BRANCH_CAVEAT : ""}`
     );
   }
   const ref = node.$ref;
@@ -15368,6 +16860,9 @@ async function emitResult(result, appInfo, args) {
 }
 
 // src/handlers/consume-outcome.ts
+function isBrokenPipe(err) {
+  return err instanceof Error && err.code === "EPIPE";
+}
 async function consumeMethodOutcome(outcome, args) {
   if (outcome.kind === "result") {
     await emitResult(outcome.result, outcome.appInfo, args);
@@ -15383,23 +16878,37 @@ async function consumeMethodOutcome(outcome, args) {
       throw new CliExitCodeError(outcome.exitCode, outcome.summary ?? "", {
         // The envelope's `code` follows the exit code, so a caller reading one
         // never has to reconcile it against the other.
-        code: outcome.exitCode === EXIT_CODES.SKILL_INCOMPLETE ? "skills_incomplete" : "skills_nonconformant"
+        code: outcome.exitCode === EXIT_CODES.SKILL_INCOMPLETE ? "skills_incomplete" : outcome.exitCode === EXIT_CODES.SKILL_UNVERIFIABLE ? "skills_unverifiable" : "skills_nonconformant"
       });
     }
     return;
   }
-  await new Promise((resolve7) => {
-    const stop = outcome.start((obj) => {
-      void awaitableLog(JSON.stringify(obj) + "\n");
-    });
-    const onSignal = () => {
-      stop();
+  await new Promise((resolve7, reject) => {
+    let stop;
+    const detach = () => {
       process.off("SIGINT", onSignal);
       process.off("SIGTERM", onSignal);
-      resolve7();
+      process.stdout.off("error", onStdoutError);
+    };
+    const finish = (err) => {
+      detach();
+      stop?.();
+      if (err === void 0) resolve7();
+      else reject(err);
     };
+    const onSignal = () => finish();
+    const onStdoutError = (err) => finish(isBrokenPipe(err) ? void 0 : err);
+    process.stdout.on("error", onStdoutError);
     process.on("SIGINT", onSignal);
     process.on("SIGTERM", onSignal);
+    try {
+      stop = outcome.start((obj) => {
+        void awaitableLog(JSON.stringify(obj) + "\n");
+      });
+    } catch (err) {
+      detach();
+      reject(err);
+    }
   });
 }
 
@@ -16220,24 +17729,6 @@ async function collectAppInfo(client, tool, metadata) {
   }
 }
 
-// src/handlers/skills-verify.ts
-function summarizeSkillVerification(reports) {
-  const failed = reports.filter((report) => report.outcome === "failed").length;
-  const incomplete = reports.filter(
-    (report) => report.outcome === "incomplete"
-  ).length;
-  const files = reports.reduce((sum, report) => sum + report.files.length, 0);
-  const mismatched = reports.reduce(
-    (sum, report) => sum + report.files.filter((file) => file.status === "mismatch").length,
-    0
-  );
-  const skillWord = reports.length === 1 ? "skill" : "skills";
-  const fileWord = files === 1 ? "file" : "files";
-  const incompleteClause = incomplete === 0 ? "" : ` ${incomplete} of ${reports.length} ${skillWord} could not be fully checked: the read bounds stopped the walk.`;
-  const headline = failed === 0 ? incomplete === 0 ? `Verified ${reports.length} ${skillWord} and ${files} ${fileWord}: no conformance errors.` : `Checked ${reports.length} ${skillWord} and ${files} ${fileWord}: no conformance errors in what was read.` : `${failed} of ${reports.length} ${skillWord} failed verification (${mismatched} digest/size mismatch across ${files} ${fileWord}).`;
-  return `${headline}${incompleteClause}`;
-}
-
 // ../../core/mcp/skillsVerification.ts
 function reasonOf(err) {
   return err instanceof Error ? err.message : String(err);
@@ -16430,7 +17921,11 @@ async function verifySkills(client, entries, metadata) {
       files,
       ...incomplete ? { incomplete } : {},
       ok: !hasError && !fileFailed,
-      outcome: hasError || fileFailed ? "failed" : incomplete !== void 0 ? "incomplete" : "verified"
+      // Precedence runs from the loudest verdict down: a broken MUST outranks
+      // an unfinished walk, and an unfinished walk outranks a skill that had
+      // nothing to hash — a `"dynamic"` skill past the run's catalog budget
+      // was not read at all, which `incomplete` already says more precisely.
+      outcome: hasError || fileFailed ? "failed" : incomplete !== void 0 ? "incomplete" : entry.resources === DYNAMIC_RESOURCES ? "unverifiable" : "verified"
     });
   }
   return reports;
@@ -16441,6 +17936,38 @@ function allSkillsVerified(reports) {
 function anySkillFailed(reports) {
   return reports.some((report) => report.outcome === "failed");
 }
+function anySkillUnverifiable(reports) {
+  return reports.some((report) => report.outcome === "unverifiable");
+}
+
+// src/handlers/skills-verify.ts
+function skillVerificationExitCode(reports, requireDigests) {
+  if (allSkillsVerified(reports)) return void 0;
+  if (anySkillFailed(reports)) return EXIT_CODES.SKILL_NONCONFORMANT;
+  if (reports.some((report) => report.outcome === "incomplete"))
+    return EXIT_CODES.SKILL_INCOMPLETE;
+  return requireDigests && anySkillUnverifiable(reports) ? EXIT_CODES.SKILL_UNVERIFIABLE : void 0;
+}
+function summarizeSkillVerification(reports) {
+  const failed = reports.filter((report) => report.outcome === "failed").length;
+  const incomplete = reports.filter(
+    (report) => report.outcome === "incomplete"
+  ).length;
+  const unverifiable = reports.filter(
+    (report) => report.outcome === "unverifiable"
+  ).length;
+  const files = reports.reduce((sum, report) => sum + report.files.length, 0);
+  const mismatched = reports.reduce(
+    (sum, report) => sum + report.files.filter((file) => file.status === "mismatch").length,
+    0
+  );
+  const skillWord = reports.length === 1 ? "skill" : "skills";
+  const fileWord = files === 1 ? "file" : "files";
+  const incompleteClause = incomplete === 0 ? "" : ` ${incomplete} of ${reports.length} ${skillWord} could not be fully checked: the read bounds stopped the walk.`;
+  const unverifiableClause = unverifiable === 0 ? "" : ` ${unverifiable} of ${reports.length} ${skillWord} advertised no digests (resources: "dynamic"), so ${unverifiable === 1 ? "its" : "their"} integrity was not checked.`;
+  const headline = failed !== 0 ? `${failed} of ${reports.length} ${skillWord} failed verification (${mismatched} digest/size mismatch across ${files} ${fileWord}).` : incomplete !== 0 ? `Checked ${reports.length} ${skillWord} and ${files} ${fileWord}: no conformance errors in what was read.` : unverifiable !== 0 ? `Checked ${reports.length} ${skillWord} and ${files} ${fileWord}: no conformance errors.` : `Verified ${reports.length} ${skillWord} and ${files} ${fileWord}: no conformance errors.`;
+  return `${headline}${incompleteClause}${unverifiableClause}`;
+}
 
 // src/handlers/run-method.ts
 function assertSkillsSupported(inspectorClient, method) {
@@ -16691,13 +18218,10 @@ async function runMethod(inspectorClient, args) {
           kind: "ndjson",
           lines: reports,
           summary: summarizeSkillVerification(reports),
-          // Three outcomes, three exit codes: a broken MUST is 7, a walk the
-          // read bounds cut short is 8, and everything checked and passing is
-          // 0. Collapsing the middle case into either of the others reports
-          // something untrue about the server (Copilot).
-          ...allSkillsVerified(reports) ? {} : {
-            exitCode: anySkillFailed(reports) ? EXIT_CODES.SKILL_NONCONFORMANT : EXIT_CODES.SKILL_INCOMPLETE
-          }
+          exitCode: skillVerificationExitCode(
+            reports,
+            args.requireDigests === true
+          )
         };
       }
       result = { skills };
@@ -16723,13 +18247,10 @@ async function runMethod(inspectorClient, args) {
           kind: "ndjson",
           lines: reports,
           summary: summarizeSkillVerification(reports),
-          // Three outcomes, three exit codes: a broken MUST is 7, a walk the
-          // read bounds cut short is 8, and everything checked and passing is
-          // 0. Collapsing the middle case into either of the others reports
-          // something untrue about the server (Copilot).
-          ...allSkillsVerified(reports) ? {} : {
-            exitCode: anySkillFailed(reports) ? EXIT_CODES.SKILL_NONCONFORMANT : EXIT_CODES.SKILL_INCOMPLETE
-          }
+          exitCode: skillVerificationExitCode(
+            reports,
+            args.requireDigests === true
+          )
         };
       }
       result = envelope;
@@ -16811,71 +18332,6 @@ import {
   discoverAuthorizationServerMetadata as discoverAuthorizationServerMetadata4
 } from "@modelcontextprotocol/client";
 
-// ../../core/auth/issuerBinding.ts
-import { AuthorizationServerMismatchError } from "@modelcontextprotocol/client";
-var MISSING_DISCOVERY_STATE_PHRASE = "discoveryState was not available";
-function isAuthorizationServerMismatchShape(err) {
-  if (err === null || typeof err !== "object") {
-    return false;
-  }
-  const candidate = err;
-  if (typeof candidate.recordedIssuer !== "string" || typeof candidate.currentIssuer !== "string") {
-    return false;
-  }
-  return AuthorizationServerMismatchError.isInstance(err) || candidate.name === "AuthorizationServerMismatchError";
-}
-function isMissingDiscoveryStatePlaceholder(recordedIssuer) {
-  if (recordedIssuer.includes(MISSING_DISCOVERY_STATE_PHRASE)) {
-    return true;
-  }
-  try {
-    const url = new URL(recordedIssuer);
-    return url.protocol !== "http:" && url.protocol !== "https:";
-  } catch {
-    return true;
-  }
-}
-function findIssuerBindingFailure(err) {
-  return findIssuerBindingFailureDeep(err, /* @__PURE__ */ new Set());
-}
-function findIssuerBindingFailureDeep(err, seen) {
-  if (err === null || typeof err !== "object" || seen.has(err)) {
-    return void 0;
-  }
-  seen.add(err);
-  if (isAuthorizationServerMismatchShape(err)) {
-    return classifyAuthorizationServerMismatch(err);
-  }
-  const nested = findIssuerBindingFailureDeep(
-    err.cause,
-    seen
-  );
-  if (nested) {
-    return nested;
-  }
-  const data = err.data;
-  if (data !== null && typeof data === "object") {
-    return findIssuerBindingFailureDeep(
-      data.cause,
-      seen
-    );
-  }
-  return void 0;
-}
-function classifyAuthorizationServerMismatch(err) {
-  if (isMissingDiscoveryStatePlaceholder(err.recordedIssuer)) {
-    return {
-      kind: "lost_authorization_state",
-      currentIssuer: err.currentIssuer
-    };
-  }
-  return {
-    kind: "issuer_mismatch",
-    recordedIssuer: err.recordedIssuer,
-    currentIssuer: err.currentIssuer
-  };
-}
-
 // ../../core/auth/node/oauth-callback-server.ts
 import { createServer } from "http";
 var DEFAULT_HOSTNAME = "127.0.0.1";
@@ -17171,8 +18627,28 @@ async function runRunnerInteractiveOAuth(options) {
 
 // src/open-url.ts
 import open from "open";
-async function openUrl(url) {
-  await open(typeof url === "string" ? url : url.href);
+var OPEN_URL_TIMEOUT_MS = 5e3;
+function launched(child) {
+  return new Promise((resolve7, reject) => {
+    child.on("error", reject);
+    child.once("spawn", () => resolve7());
+  });
+}
+async function openUrl(url, timeoutMs = OPEN_URL_TIMEOUT_MS) {
+  const href = typeof url === "string" ? url : url.href;
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`browser did not open within ${timeoutMs / 1e3}s`)),
+      timeoutMs
+    );
+  });
+  try {
+    const opened = Promise.resolve().then(() => open(href)).then(launched);
+    await Promise.race([opened, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
 }
 
 // src/style.ts
@@ -17238,7 +18714,12 @@ function createCliOAuthNavigation(options = {}) {
     if (!forced && !tty) return;
     try {
       await (options.openBrowser ?? openUrl)(href);
-    } catch {
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      write(
+        `Could not open a browser automatically (${reason}). Open the URL above manually.
+`
+      );
     }
   });
 }
@@ -17381,6 +18862,23 @@ function mergeSecretsIntoClientConfig(config, secrets) {
 }
 
 // ../../core/client/node-persistence.ts
+async function withClientConfigLock(filePath, action, body) {
+  let entered = false;
+  try {
+    return await withSecretFileLock(filePath, async () => {
+      entered = true;
+      return body();
+    });
+  } catch (error) {
+    if (!entered && error instanceof SecretFileLockHeldError) {
+      throw new SecretFileLockHeldError(
+        `Could not ${action} the client configuration: the file at ${filePath} is locked by another Inspector process and did not become available.`,
+        { cause: error }
+      );
+    }
+    throw error;
+  }
+}
 async function readIdpSecretFromKeychain(secretStore) {
   const secret = await secretStore.get(
     CLIENT_KEYCHAIN_ID,
@@ -17390,29 +18888,39 @@ async function readIdpSecretFromKeychain(secretStore) {
   return { [SECRET_FIELD_IDP_CLIENT_SECRET]: secret };
 }
 async function migrateClientPlaintextSecret(filePath, config, secretStore) {
-  const { stripped, secrets } = extractSecretsFromClientConfig(config);
-  const value = secrets[SECRET_FIELD_IDP_CLIENT_SECRET];
-  if (!value) return config;
   try {
-    const existing = await secretStoreGetStrict(
-      secretStore,
-      CLIENT_KEYCHAIN_ID,
-      SECRET_FIELD_IDP_CLIENT_SECRET
-    );
-    if (existing === null) {
-      await secretStore.set(
-        CLIENT_KEYCHAIN_ID,
-        SECRET_FIELD_IDP_CLIENT_SECRET,
-        value
-      );
-    }
-    if (!await secretStoreIsDurable(secretStore)) return config;
-    await writeStoreFile(filePath, serializeStore(stripped));
-    return stripped;
+    return await withClientConfigLock(filePath, "migrate", async () => {
+      const raw = await readStoreFile(filePath);
+      if (raw === null) return {};
+      const fresh = parseClientConfig(parseStore(raw));
+      const { stripped, secrets } = extractSecretsFromClientConfig(fresh);
+      const value = secrets[SECRET_FIELD_IDP_CLIENT_SECRET];
+      if (!value) return fresh;
+      try {
+        const existing = await secretStoreGetStrict(
+          secretStore,
+          CLIENT_KEYCHAIN_ID,
+          SECRET_FIELD_IDP_CLIENT_SECRET
+        );
+        if (existing === null) {
+          await secretStore.set(
+            CLIENT_KEYCHAIN_ID,
+            SECRET_FIELD_IDP_CLIENT_SECRET,
+            value
+          );
+        }
+        if (!await secretStoreIsDurable(secretStore)) return fresh;
+        await writeStoreFile(filePath, serializeStore(stripped));
+        return stripped;
+      } catch (err) {
+        if (err instanceof SecretStoreUnavailableError) {
+          return fresh;
+        }
+        throw err;
+      }
+    });
   } catch (err) {
-    if (err instanceof SecretStoreUnavailableError) {
-      return config;
-    }
+    if (err instanceof SecretFileLockHeldError) return config;
     throw err;
   }
 }
@@ -17764,7 +19272,7 @@ async function withCliAuthRecoveryRetry(inspectorClient, serverConfig, redirectU
 import { LoggingLevelSchema } from "@modelcontextprotocol/core";
 
 // ../../core/node/version.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { dirname as dirname5, join as join3, parse } from "path";
 import { fileURLToPath } from "url";
 var ROOT_PACKAGE_NAME = "@modelcontextprotocol/inspector";
@@ -17776,7 +19284,7 @@ function readInspectorVersion(callerUrl) {
     let manifest;
     try {
       manifest = JSON.parse(
-        readFileSync3(join3(dir, "package.json"), "utf-8")
+        readFileSync4(join3(dir, "package.json"), "utf-8")
       );
     } catch {
     }
@@ -17875,6 +19383,13 @@ async function callMethod(serverConfig, serverSettings, args, clientConfig, cliA
     ...serverSettings?.protocolEra && {
       versionNegotiation: eraToVersionNegotiation(serverSettings.protocolEra)
     },
+    // The CLI cannot render an MCP App, so it does not advertise the UI
+    // extension by default (#2403). `--advertise-apps` claims it explicitly,
+    // for a server that only exposes its App tools to a client that does —
+    // which is what an `--app-info` probe against such a server needs.
+    ...args.advertiseApps && {
+      advertisedExtensions: { [UI_EXTENSION_KEY]: true }
+    },
     ...clientAuthOptions
   });
   try {
@@ -17908,14 +19423,8 @@ function normalizeServerUrl2(serverUrl) {
   }
 }
 async function readOAuthSnapshot(statePath) {
-  const { readFile: readFile2 } = await import("fs/promises");
-  try {
-    const text = await readFile2(statePath, "utf8");
-    const snapshot = parseOAuthPersistBlob(text);
-    if (snapshot) return snapshot;
-  } catch {
-  }
-  return { servers: {}, idpSessions: {} };
+  const snapshot = await readOAuthStore(statePath);
+  return snapshot ?? { servers: {}, idpSessions: {} };
 }
 async function readOAuthServers(statePath) {
   return (await readOAuthSnapshot(statePath)).servers;
@@ -17990,17 +19499,44 @@ async function refreshStoredAuthToken(serverUrl, statePath, deps = {}) {
     );
   }
   servers[found.key] = { ...found.state, tokens };
-  await writeStoreFile(statePath, serializeOAuthPersistBlob(snapshot));
+  await writeOAuthSections(statePath, snapshot, { servers: [found.key] });
   return tokens.access_token;
 }
-async function waitForStoredToken(serverUrl, statePath, timeoutSec) {
+var DEADLINE_ELAPSED = /* @__PURE__ */ Symbol("deadline-elapsed");
+async function raceDeadline(promise, deadline) {
+  promise.catch(() => {
+  });
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) return DEADLINE_ELAPSED;
+  let timer;
+  const elapsed = new Promise((resolve7) => {
+    timer = setTimeout(() => resolve7(DEADLINE_ELAPSED), remaining);
+  });
+  try {
+    return await Promise.race([promise, elapsed]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function waitForStoredToken(serverUrl, statePath, timeoutSec, readServers = readOAuthServers) {
   const key = normalizeServerUrl2(serverUrl);
   const deadline = Date.now() + timeoutSec * 1e3;
+  let servers = {};
+  let lastError;
   for (; ; ) {
-    const servers = await readOAuthServers(statePath);
+    try {
+      const read = await raceDeadline(readServers(statePath), deadline);
+      if (read !== DEADLINE_ELAPSED) {
+        servers = read;
+        lastError = void 0;
+      }
+    } catch (error) {
+      if (!(error instanceof SecretFileLockHeldError)) lastError = error;
+    }
     const token = findStoredToken(servers, serverUrl);
     if (token) return token;
     if (Date.now() >= deadline) {
+      if (lastError !== void 0) throw lastError;
       const stored = Object.keys(servers);
       throw new CliExitCodeError(
         EXIT_CODES.AUTH_REQUIRED,
@@ -18008,7 +19544,9 @@ async function waitForStoredToken(serverUrl, statePath, timeoutSec) {
         { code: "auth_wait_timeout", url: serverUrl }
       );
     }
-    await new Promise((r) => setTimeout(r, 500));
+    await new Promise(
+      (r) => setTimeout(r, Math.min(500, deadline - Date.now()))
+    );
   }
 }
 function deepLinkTransport(serverUrl, transport) {
@@ -18164,12 +19702,18 @@ async function parseArgs(argv) {
   ).option(
     "--app-info",
     "Probe the tool's MCP App UI metadata (resourceUri, csp, permissions, domain) and emit it as one JSON line; exit 2 when the tool has no app. Use with --method tools/call --tool-name <name> (the tool itself is not invoked) or --method tools/list (one NDJSON line per tool)."
+  ).option(
+    "--advertise-apps",
+    "Advertise the MCP Apps UI extension (io.modelcontextprotocol/ui) at initialize. Off by default because the CLI cannot render an App; set it when a server only exposes its App tools to a client that claims App support, e.g. for an --app-info probe."
   ).option(
     "--strict",
     "Report tool-schema portability problems in full (path, issue, suggested fix) on stderr, and exit 6 if any is error-severity. Use with --method tools/list. Without it, a one-line count is printed instead."
   ).option(
     "--verify",
     "Run the SEP-2640 conformance and digest checks over the skills returned, emit one JSON report per skill on stdout, and exit 7 if any fails or 8 if any could not be fully checked within the read bounds. Use with --method skills/list or --method skills/get."
+  ).option(
+    "--require-digests",
+    'With --verify: exit 9 when a skill advertises no digests (resources: "dynamic"), instead of reporting it as unverifiable and exiting 0.'
   ).option(
     "--connect-timeout <ms>",
     `Connection timeout in ms (default ${DEFAULT_CONNECT_TIMEOUT_MS} for ad-hoc --server-url / target invocations; 0 = no timeout).`,
@@ -18284,6 +19828,14 @@ async function parseArgs(argv) {
       );
     }
   }
+  if (options.requireDigests && !options.verify) {
+    throw new Error("--require-digests requires --verify.");
+  }
+  if (options.advertiseApps && (options.listStoredAuth || options.printHandoff || options.method === "servers/list" || options.method === "servers/show")) {
+    throw new Error(
+      "--advertise-apps requires a command that connects to a server; it has no effect with --list-stored-auth, --print-handoff, or --method servers/list / servers/show."
+    );
+  }
   const oauthStatePath = getStateFilePath();
   if (options.listStoredAuth) {
     const servers = await readOAuthServers(oauthStatePath);
@@ -18449,8 +20001,10 @@ async function parseArgs(argv) {
     metadata: options.metadata,
     toolMeta: options.toolMetadata,
     appInfo: options.appInfo === true,
+    advertiseApps: options.advertiseApps === true,
     strict: options.strict === true,
     verify: options.verify === true,
+    requireDigests: options.requireDigests === true,
     cursor: options.cursor,
     format: options.format
   };