@modelcontextprotocol/inspector 2.8.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
 );
@@ -2601,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.`
       );
     }
@@ -2710,6 +2786,13 @@ function resolveSecretPassphrase(env = process.env, secretFilePath) {
   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(
@@ -2968,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),
@@ -3002,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()
@@ -3167,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;
   }
@@ -3213,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 };
@@ -3224,6 +3341,7 @@ var FileSecretStore = class {
     );
   }
   async set(serverId, field, value) {
+    assertSecretString(field, value);
     await this.serialize(
       () => this.mutate((map) => ({
         ...map,
@@ -3239,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 {
@@ -3254,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 }
+      );
     }
   }
 };
@@ -3630,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);
   }
@@ -3868,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)) {
@@ -4904,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;
   }
   /**
@@ -4953,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
@@ -4964,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,
@@ -4976,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;
   }
@@ -5022,7 +5186,7 @@ var OAuthStorageBase = class {
         clientRegistrationKind: options.registrationKind
       });
     }
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
   }
   async savePreregisteredClientInformation(serverUrl, clientInformation) {
     await this.ensureLoaded();
@@ -5030,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();
@@ -5038,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) {
@@ -5061,7 +5225,7 @@ var OAuthStorageBase = class {
         clientRegistrationKind: void 0
       });
     }
-    await this.persist();
+    await this.persist({ servers: [serverUrl] });
   }
   async getTokens(serverUrl, issuer) {
     await this.ensureLoaded();
@@ -5072,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
     );
   }
@@ -5098,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();
@@ -5117,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();
@@ -5127,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();
@@ -5142,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();
@@ -5157,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();
@@ -5171,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();
@@ -5194,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();
@@ -5213,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 });
   }
 };
 
@@ -5241,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
           }
         };
@@ -5258,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
           }
         };
@@ -5298,13 +5468,70 @@ var OAuthMemoryStore = class {
 };
 
 // ../../core/auth/oauth-persist.ts
+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 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: payload.servers ?? {},
-    idpSessions: payload.idpSessions ?? {}
+    servers,
+    idpSessions
   };
 }
 function parseOAuthPersistBlob(raw) {
@@ -5327,123 +5554,884 @@ function serializeOAuthPersistBlob(snapshot) {
   return serializeStore(snapshot);
 }
 
-// ../../core/auth/node/oauth-persist-file.ts
-function createFileOAuthPersistBackend(options) {
+// ../../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 {
-    async read() {
-      const raw = await readStoreFile(options.filePath);
-      return parseOAuthPersistBlob(raw);
-    },
-    async write(snapshot) {
-      await writeStoreFile(
-        options.filePath,
-        serializeOAuthPersistBlob(snapshot)
-      );
-    },
-    async remove() {
-      await deleteStoreFile(options.filePath);
+    ...info,
+    ...clientSecret !== void 0 && { client_secret: clientSecret },
+    ...registrationToken !== void 0 && {
+      registration_access_token: registrationToken
     }
   };
 }
-
-// ../../core/auth/node/storage-node.ts
-var DEFAULT_STATE_PATH = getStoreFilePath(getDefaultStorageDir(), "oauth");
-function getStateFilePath(customPath) {
-  if (customPath) return customPath;
-  if (process.env.MCP_INSPECTOR_OAUTH_STATE_PATH) {
-    return process.env.MCP_INSPECTOR_OAUTH_STATE_PATH;
+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 (process.env.MCP_STORAGE_DIR) {
-    return getStoreFilePath(process.env.MCP_STORAGE_DIR, "oauth");
+  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;
   }
-  return DEFAULT_STATE_PATH;
+  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 };
 }
-var memoryCache = /* @__PURE__ */ new Map();
-var storageCache = /* @__PURE__ */ new Map();
-function getSharedMemory(stateFilePath) {
-  const key = getStateFilePath(stateFilePath);
-  let memory = memoryCache.get(key);
-  if (!memory) {
-    memory = new OAuthMemoryStore();
-    memoryCache.set(key, memory);
+function parseStoredTokens(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (StorableTokensSchema.safeParse(parsed).success && hasSecretBearingTokenField(parsed)) {
+      return parsed;
+    }
+  } catch {
   }
-  return memory;
+  return void 0;
 }
-function resetNodeOAuthStorageCache(stateFilePath) {
-  const key = getStateFilePath(stateFilePath);
-  memoryCache.delete(key);
-  storageCache.delete(key);
+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;
 }
-var NodeOAuthStorage = class extends OAuthStorageBase {
-  /**
-   * @param storagePath - Optional path to state file. Default: ~/.mcp-inspector/storage/oauth.json
-   */
-  constructor(storagePath) {
-    const filePath = getStateFilePath(storagePath);
-    super(
-      getSharedMemory(storagePath),
-      createFileOAuthPersistBackend({ filePath })
+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
     );
   }
-};
-
-// ../../core/auth/revocation.ts
-import { selectClientAuthMethod } from "@modelcontextprotocol/client";
-import {
-  OAuthClientInformationSchema as OAuthClientInformationSchema2,
-  OAuthTokensSchema as OAuthTokensSchema2
-} from "@modelcontextprotocol/core";
-var DEFAULT_REVOCATION_TIMEOUT_MS = 5e3;
-var MIN_REVOCATION_REQUEST_BUDGET_MS = 5;
-function selectRevocableToken(tokens) {
-  if (!tokens) return null;
-  if (tokens.refresh_token) {
-    return { token: tokens.refresh_token, tokenTypeHint: "refresh_token" };
+  if (joined.preregisteredClientInformation) {
+    joined.preregisteredClientInformation = joinClientInformation(
+      joined.preregisteredClientInformation,
+      PREREG_CLIENT_INFO_FIELDS,
+      secrets
+    );
   }
-  if (tokens.access_token) {
-    return { token: tokens.access_token, tokenTypeHint: "access_token" };
+  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 null;
+  return { residue, secrets };
 }
-function revocationAuthMethods(metadata) {
-  return metadata.revocation_endpoint_auth_methods_supported ?? [
-    "client_secret_basic"
-  ];
+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 buildRevocationRequest(params) {
-  const body = new URLSearchParams({
-    token: params.token,
-    token_type_hint: params.tokenTypeHint
-  });
-  const headers = {
-    "Content-Type": "application/x-www-form-urlencoded",
-    Accept: "application/json"
-  };
-  const client = params.clientInformation;
-  if (client) {
-    const method = selectClientAuthMethod(client, params.supportedAuthMethods);
-    if (method === "client_secret_basic" && client.client_secret) {
-      const credentials = `${encodeURIComponent(client.client_id)}:${encodeURIComponent(client.client_secret)}`;
-      headers.Authorization = `Basic ${base64Encode(credentials)}`;
-    } else if (method === "client_secret_post" && client.client_secret) {
-      body.set("client_id", client.client_id);
-      body.set("client_secret", client.client_secret);
-    } else {
-      body.set("client_id", client.client_id);
-    }
+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 {
-    url: params.endpoint,
-    init: { method: "POST", headers, body: body.toString() }
-  };
+  return [...fields];
 }
-function base64Encode(value) {
-  if (typeof btoa === "function") return btoa(value);
-  return Buffer.from(value, "utf8").toString("base64");
+function clientInfoHasPlaintext(info) {
+  return info !== void 0 && (info.client_secret !== void 0 || info.registration_access_token !== void 0);
 }
-async function revokeToken(params) {
-  const timeoutMs = Math.max(
-    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() {
+      return readOAuthStore(options.filePath, secretStore);
+    },
+    async write(snapshot, sections) {
+      await writeOAuthSections(
+        options.filePath,
+        snapshot,
+        sections,
+        secretStore
+      );
+    },
+    async remove() {
+      await removeOAuthStore(options.filePath, secretStore);
+    }
+  };
+}
+
+// ../../core/auth/node/storage-node.ts
+var DEFAULT_STATE_PATH = getStoreFilePath(getDefaultStorageDir(), "oauth");
+function getStateFilePath(customPath) {
+  if (customPath) return customPath;
+  if (process.env.MCP_INSPECTOR_OAUTH_STATE_PATH) {
+    return process.env.MCP_INSPECTOR_OAUTH_STATE_PATH;
+  }
+  if (process.env.MCP_STORAGE_DIR) {
+    return getStoreFilePath(process.env.MCP_STORAGE_DIR, "oauth");
+  }
+  return DEFAULT_STATE_PATH;
+}
+var sharedStateCache = /* @__PURE__ */ new Map();
+var storageCache = /* @__PURE__ */ new Map();
+function getSharedState(stateFilePath) {
+  const key = getStateFilePath(stateFilePath);
+  let shared = sharedStateCache.get(key);
+  if (!shared) {
+    shared = {
+      memory: new OAuthMemoryStore(),
+      coordination: new OAuthStorageCoordination()
+    };
+    sharedStateCache.set(key, shared);
+  }
+  return shared;
+}
+function resetNodeOAuthStorageCache(stateFilePath) {
+  const key = getStateFilePath(stateFilePath);
+  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, secretStore) {
+    const filePath = getStateFilePath(storagePath);
+    const shared = getSharedState(storagePath);
+    super(
+      shared.memory,
+      createFileOAuthPersistBackend({ filePath, secretStore }),
+      shared.coordination
+    );
+  }
+};
+
+// ../../core/auth/revocation.ts
+import { selectClientAuthMethod } from "@modelcontextprotocol/client";
+import {
+  OAuthClientInformationSchema as OAuthClientInformationSchema2,
+  OAuthTokensSchema as OAuthTokensSchema4
+} from "@modelcontextprotocol/core";
+var DEFAULT_REVOCATION_TIMEOUT_MS = 5e3;
+var MIN_REVOCATION_REQUEST_BUDGET_MS = 5;
+function selectRevocableToken(tokens) {
+  if (!tokens) return null;
+  if (tokens.refresh_token) {
+    return { token: tokens.refresh_token, tokenTypeHint: "refresh_token" };
+  }
+  if (tokens.access_token) {
+    return { token: tokens.access_token, tokenTypeHint: "access_token" };
+  }
+  return null;
+}
+function revocationAuthMethods(metadata) {
+  return metadata.revocation_endpoint_auth_methods_supported ?? [
+    "client_secret_basic"
+  ];
+}
+function buildRevocationRequest(params) {
+  const body = new URLSearchParams({
+    token: params.token,
+    token_type_hint: params.tokenTypeHint
+  });
+  const headers = {
+    "Content-Type": "application/x-www-form-urlencoded",
+    Accept: "application/json"
+  };
+  const client = params.clientInformation;
+  if (client) {
+    const method = selectClientAuthMethod(client, params.supportedAuthMethods);
+    if (method === "client_secret_basic" && client.client_secret) {
+      const credentials = `${encodeURIComponent(client.client_id)}:${encodeURIComponent(client.client_secret)}`;
+      headers.Authorization = `Basic ${base64Encode(credentials)}`;
+    } else if (method === "client_secret_post" && client.client_secret) {
+      body.set("client_id", client.client_id);
+      body.set("client_secret", client.client_secret);
+    } else {
+      body.set("client_id", client.client_id);
+    }
+  }
+  return {
+    url: params.endpoint,
+    init: { method: "POST", headers, body: body.toString() }
+  };
+}
+function base64Encode(value) {
+  if (typeof btoa === "function") return btoa(value);
+  return Buffer.from(value, "utf8").toString("base64");
+}
+async function revokeToken(params) {
+  const timeoutMs = Math.max(
+    0,
     Math.round(params.timeoutMs ?? DEFAULT_REVOCATION_TIMEOUT_MS)
   );
   try {
@@ -5619,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);
@@ -6122,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] }
   },
   {
@@ -6141,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) : {};
     }
@@ -7089,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)) {
@@ -7146,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 {
@@ -8243,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();
@@ -8322,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
@@ -9547,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;
@@ -10023,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);
@@ -10229,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
@@ -10583,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
@@ -11008,6 +12027,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     }
     this.baseTransport = null;
     this.transport = null;
+    this.transportSettings = void 0;
     this.transportHasAuthProvider = false;
   }
   /**
@@ -11481,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);
       }
@@ -11682,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") {
@@ -12414,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)
    */
@@ -12465,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
@@ -13986,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) {
@@ -14000,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 }
@@ -15141,18 +16180,83 @@ function parseAddressPart(part) {
   if (/^[0-9]+$/.test(part)) return parseInt(part, 10);
   return NaN;
 }
-function isAllZeroIpv4(value) {
-  const parts = value.split(".");
-  if (parts.length > 4) return false;
-  return parts.every((part) => parseAddressPart(part) === 0);
+function isAllZeroIpv4(value) {
+  const parts = value.split(".");
+  if (parts.length > 4) return false;
+  return parts.every((part) => parseAddressPart(part) === 0);
+}
+function isAllInterfacesHost(host) {
+  const normalized = canonicalizeIpv6(stripBrackets(canonicalUrlHost(host)));
+  return ALL_INTERFACES_LITERALS.has(normalized) || isAllZeroIpv4(normalized);
+}
+function isLoopbackHost(host) {
+  const h = canonicalUrlHost(host).replace(/\.$/, "");
+  return h === "localhost" || h === "[::1]" || /^127(\.(25[0-5]|2[0-4]\d|1?\d?\d)){3}$/.test(h);
+}
+
+// ../../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 isAllInterfacesHost(host) {
-  const normalized = canonicalizeIpv6(stripBrackets(canonicalUrlHost(host)));
-  return ALL_INTERFACES_LITERALS.has(normalized) || isAllZeroIpv4(normalized);
+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 isLoopbackHost(host) {
-  const h = canonicalUrlHost(host).replace(/\.$/, "");
-  return h === "localhost" || h === "[::1]" || /^127(\.(25[0-5]|2[0-4]\d|1?\d?\d)){3}$/.test(h);
+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
@@ -15186,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) {
@@ -15221,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);
@@ -15242,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: {
@@ -15686,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);
@@ -15701,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);
+    }
   });
 }
 
@@ -16538,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);
@@ -16748,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;
@@ -16759,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) {
@@ -17009,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 };
@@ -17041,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;
@@ -17129,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";
@@ -17489,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
@@ -17556,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.
+`
+      );
     }
   });
 }
@@ -17699,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,
@@ -17708,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;
   }
 }
@@ -18193,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 {
@@ -18226,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;
@@ -18308,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,
@@ -18326,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) {
@@ -18482,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).`,
@@ -18602,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);
@@ -18767,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
   };