@zuplo/cli 7.6.9 → 7.6.10

package/node_modules/@modelcontextprotocol/client/node_modules/jose/dist/webapi/lib/key.js

@@ -1,9 +1,6 @@
-import { withAlg as invalidKeyInput } from "./invalid_key_input.js";
-import { isKeyLike, isCryptoKey } from "./is_key_like.js";
-import { isObject } from "./type_checks.js";
+import { isObject } from "./validate.js";
 import { decode } from "../util/base64url.js";
-import { jwkToKey } from "./jwk_to_key.js";
-import { normalizeJwk } from "./jwk_metadata.js";
+import { JOSENotSupported } from "../util/errors.js";
 const tag = (key) => key[Symbol.toStringTag], jwkMatchesOp = (entry, key, usage) => {
   const { alg } = entry;
   if (key.use !== void 0) {
@@ -19,35 +16,44 @@ const tag = (key) => key[Symbol.toStringTag], jwkMatchesOp = (entry, key, usage)
       throw new TypeError(`Invalid key for this operation, its "key_ops" must include "${expectedKeyOp}" when present`);
   }
 };
-function checkKeyType(entry, key, usage) {
+async function prepareKey(entry, key, usage) {
   const { alg, secret } = entry, privateKey = usage === "decrypt" || usage === "sign";
   if (secret && key instanceof Uint8Array)
-    return [BYTES, key];
+    return key;
+  let normalized, keyObject;
   if (isObject(key)) {
-    const normalized = normalizeJwk(key);
-    if (typeof normalized.kty != "string")
-      throw new TypeError(secret ? invalidKeyInput(alg, key, "CryptoKey", "KeyObject", "JSON Web Key", "Uint8Array") : invalidKeyInput(alg, key, "CryptoKey", "KeyObject", "JSON Web Key"));
+    if (normalized = normalizeJwk(key), typeof normalized.kty != "string")
+      throw invalidKeyType(alg, key, secret);
     if (!(secret ? normalized.kty === "oct" && typeof normalized.k == "string" : normalized.kty !== "oct" && (privateKey ? normalized.kty === "AKP" && typeof normalized.priv == "string" || typeof normalized.d == "string" : normalized.d === void 0 && normalized.priv === void 0)))
       throw new TypeError(secret ? 'JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present' : `JSON Web Key for this operation must be a ${privateKey ? "private" : "public"} JWK`);
-    return jwkMatchesOp(entry, normalized, usage), [JWK, key, normalized];
-  }
-  if (!isKeyLike(key))
-    throw new TypeError(secret ? invalidKeyInput(alg, key, "CryptoKey", "KeyObject", "JSON Web Key", "Uint8Array") : invalidKeyInput(alg, key, "CryptoKey", "KeyObject", "JSON Web Key"));
-  if (secret) {
-    if (key.type !== "secret")
-      throw new TypeError(`${tag(key)} instances for symmetric algorithms must be of type "secret"`);
-  } else {
-    if (key.type === "secret")
-      throw new TypeError(`${tag(key)} instances for asymmetric algorithms must not be of type "secret"`);
-    const expectedType = privateKey ? "private" : "public";
-    if ((key.type === "public" || key.type === "private") && key.type !== expectedType) {
-      const operation = usage === "sign" ? "signing" : usage === "verify" ? "verifying" : `${usage.slice(0, -1)}tion`;
-      throw new TypeError(`${tag(key)} instances for asymmetric algorithm ${operation} must be of type "${expectedType}"`);
+    if (jwkMatchesOp(entry, normalized, usage), normalized.kty === "oct")
+      return decode(normalized.k);
+    if (!Object.isFrozen(key)) {
+      const { key_ops } = key;
+      Array.isArray(key_ops) && Object.freeze(key_ops), Object.freeze(key);
     }
+  } else {
+    if (!isKeyLike(key))
+      throw invalidKeyType(alg, key, secret);
+    const expectedType = secret ? "secret" : privateKey ? "private" : "public";
+    if (key.type !== expectedType && (secret || ["secret", "public", "private"].includes(key.type)))
+      throw new TypeError(`${tag(key)} instances must be of type "${expectedType}" for the ${alg} algorithm`);
+    if (isCryptoKey(key))
+      return key;
+    if (keyObject = key, keyObject.type === "secret")
+      return keyObject.export();
+  }
+  cache ||= /* @__PURE__ */ new WeakMap();
+  const cacheKey = key;
+  let cached = cache.get(cacheKey);
+  if (cached?.[alg])
+    return cached[alg];
+  if (cached || cache.set(cacheKey, cached = {}), keyObject && typeof keyObject.toCryptoKey == "function") {
+    const isPublic = keyObject.type === "public", crv = nist[keyObject.asymmetricKeyDetails?.namedCurve], params = entry.resolve?.({ crv, asymmetricKeyType: keyObject.asymmetricKeyType }) ?? entry.subtle;
+    return cached[alg] = keyObject.toCryptoKey(params, isPublic, entry.usages[isPublic ? 0 : 1]);
   }
-  return isCryptoKey(key) ? [CRYPTO, key] : [KEYOBJECT, key];
+  return normalized ??= keyObject.export({ format: "jwk" }), normalized.alg = alg, cached[alg] = await jwkToKey(entry, normalized);
 }
-const BYTES = 0, CRYPTO = 1, KEYOBJECT = 2, JWK = 3;
 let cache;
 const nist = {
   __proto__: null,
@@ -55,41 +61,95 @@ const nist = {
   secp384r1: "P-384",
   secp521r1: "P-521"
 };
-function cached(key, alg, value) {
-  cache ||= /* @__PURE__ */ new WeakMap();
-  const entry = cache.get(key);
-  return value && (entry ? entry[alg] = value : cache.set(key, { [alg]: value })), value ?? entry?.[alg];
+function assertCryptoKey(key) {
+  if (!isCryptoKey(key))
+    throw new Error("CryptoKey instance expected");
 }
-const handleJWK = async (key, jwk, entry) => cached(key, entry.alg) ?? cached(key, entry.alg, await jwkToKey(entry, { ...jwk, alg: entry.alg })), handleKeyObject = (keyObject, entry) => {
-  const hit = cached(keyObject, entry.alg);
-  if (hit)
-    return hit;
-  const isPublic = keyObject.type === "public", usages = entry.usages[isPublic ? 0 : 1], { asymmetricKeyType } = keyObject, crv = nist[keyObject.asymmetricKeyDetails?.namedCurve], params = entry.resolve?.({ crv, asymmetricKeyType }) ?? entry.subtle;
-  return cached(keyObject, entry.alg, keyObject.toCryptoKey(params, isPublic, usages));
-};
-async function prepareKey(entry, key, usage) {
-  const tagged = checkKeyType(entry, key, usage);
-  switch (tagged[0]) {
-    case BYTES:
-    case CRYPTO:
-      return tagged[1];
-    case JWK: {
-      const key2 = tagged[1], normalized = tagged[2];
-      if (normalized.kty === "oct")
-        return decode(normalized.k);
-      if (!Object.isFrozen(key2)) {
-        const { key_ops } = key2;
-        Array.isArray(key_ops) && Object.freeze(key_ops), Object.freeze(key2);
-      }
-      return handleJWK(key2, normalized, entry);
-    }
-    case KEYOBJECT: {
-      const keyObject = tagged[1];
-      return keyObject.type === "secret" ? keyObject.export() : "toCryptoKey" in keyObject && typeof keyObject.toCryptoKey == "function" ? handleKeyObject(keyObject, entry) : handleJWK(keyObject, keyObject.export({ format: "jwk" }), entry);
-    }
+const isCryptoKey = (key) => {
+  if (key?.[Symbol.toStringTag] === "CryptoKey")
+    return !0;
+  try {
+    return key instanceof CryptoKey;
+  } catch {
+    return !1;
   }
+}, isKeyObject = (key) => key?.[Symbol.toStringTag] === "KeyObject", isKeyLike = (key) => isCryptoKey(key) || isKeyObject(key);
+function message(msg, actual, ...types) {
+  if (types.length > 2) {
+    const last = types.pop();
+    msg += `one of type ${types.join(", ")}, or ${last}.`;
+  } else types.length === 2 ? msg += `one of type ${types[0]} or ${types[1]}.` : msg += `of type ${types[0]}.`;
+  return actual == null ? msg += ` Received ${actual}` : typeof actual == "function" && actual.name ? msg += ` Received function ${actual.name}` : typeof actual == "object" && actual != null && actual.constructor?.name && (msg += ` Received an instance of ${actual.constructor.name}`), msg;
+}
+const invalidKeyInput = (actual, ...types) => message("Key must be ", actual, ...types);
+function invalidKeyType(alg, actual, secret) {
+  const types = ["CryptoKey", "KeyObject", "JSON Web Key"];
+  return secret && types.push("Uint8Array"), new TypeError(message(`Key for the ${alg} algorithm must be `, actual, ...types));
+}
+const unusable = (name, prop = "algorithm.name") => new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
+function checkUsage(key, usage) {
+  if (usage && !key.usages.includes(usage))
+    throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`);
+}
+function checkModulusLength(alg, key) {
+  const { modulusLength } = key.algorithm;
+  if (typeof modulusLength != "number" || modulusLength < 2048)
+    throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
+}
+function checkCryptoKey(key, expected, usage) {
+  const algorithm = key.algorithm;
+  if (algorithm.name !== expected.name)
+    throw unusable(expected.name);
+  if (expected.hash && algorithm.hash?.name !== expected.hash)
+    throw unusable(expected.hash, "algorithm.hash");
+  if (expected.namedCurve && algorithm.namedCurve !== expected.namedCurve)
+    throw unusable(expected.namedCurve, "algorithm.namedCurve");
+  if (expected.length !== void 0 && algorithm.length !== expected.length)
+    throw unusable(expected.length, "algorithm.length");
+  checkUsage(key, usage);
+}
+function snapshotJwk(jwk) {
+  return { __proto__: null, ...jwk };
+}
+function normalizeJwk(jwk) {
+  const normalized = snapshotJwk(jwk);
+  if (normalized.ext !== void 0 && typeof normalized.ext != "boolean")
+    throw new TypeError('"ext" (Extractable) Parameter must be a boolean');
+  if (normalized.key_ops !== void 0) {
+    const value = normalized.key_ops, keyOps = Array.isArray(value) ? [...value] : void 0;
+    if (!keyOps || keyOps.some((operation) => typeof operation != "string") || new Set(keyOps).size !== keyOps.length)
+      throw new TypeError('"key_ops" (Key Operations) Parameter must be an array of unique strings');
+    normalized.key_ops = keyOps;
+  }
+  return normalized;
+}
+function validateExtractableOption(extractable) {
+  if (extractable !== void 0 && typeof extractable != "boolean")
+    throw new TypeError('"extractable" option must be a boolean');
+  return extractable;
+}
+async function jwkToKey(entry, jwk, extractable) {
+  if (!entry.kty.includes(jwk.kty))
+    throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+  const algorithm = entry.resolve?.({ kty: jwk.kty, crv: jwk.crv }) ?? entry.subtle, isPrivate = !!(jwk.d || jwk.priv), keyData = { ...jwk, ext: extractable ?? jwk.ext };
+  return keyData.kty !== "AKP" && delete keyData.alg, delete keyData.use, crypto.subtle.importKey("jwk", keyData, algorithm, keyData.ext ?? !isPrivate, jwk.key_ops ?? entry.usages[isPrivate ? 1 : 0]);
+}
+async function rawKey(key, expected, usage, extractable = !1) {
+  return key instanceof Uint8Array && (key = await crypto.subtle.importKey("raw", key, expected, extractable, [usage])), checkCryptoKey(key, expected, usage), key;
 }
 export {
-  checkKeyType,
-  prepareKey
+  assertCryptoKey,
+  checkCryptoKey,
+  checkModulusLength,
+  checkUsage,
+  invalidKeyInput,
+  isCryptoKey,
+  isKeyLike,
+  isKeyObject,
+  jwkToKey,
+  normalizeJwk,
+  prepareKey,
+  rawKey,
+  snapshotJwk,
+  validateExtractableOption
 };

package/node_modules/@modelcontextprotocol/client/node_modules/jose/dist/webapi/lib/key_management.js

@@ -1,41 +1,26 @@
 import { encode as b64u } from "../util/base64url.js";
-import { prepareKey } from "./key.js";
-import { jwkToKey } from "./jwk_to_key.js";
-import { jweAlgorithm, jweEncryption } from "./jwe_algorithms.js";
+import { prepareKey, rawKey, jwkToKey, checkCryptoKey, checkModulusLength, checkUsage, assertCryptoKey } from "./key.js";
+import { jweAlgorithm, jweEncryption, isJWECEKTransport } from "./jwe_algorithms.js";
 import { JOSENotSupported, JWEInvalid } from "../util/errors.js";
-import { decodeBase64url, digest } from "./helpers.js";
-import { generateCek, encrypt, decrypt } from "./content_encryption.js";
-import { assertUint8Array, isObject } from "./type_checks.js";
-import { checkCryptoKey, checkModulusLength, checkUsage } from "./crypto_key.js";
-import { concat, encode, uint32be } from "./buffer_utils.js";
-import { assertCryptoKey } from "./is_key_like.js";
+import { decodeBase64url, assertUint8Array, isObject } from "./validate.js";
+import { digest, concat, encode, uint32be } from "./buffer_utils.js";
+import { checkCekLength, generateCek, encrypt, decrypt } from "./content_encryption.js";
 function checkEcdhCryptoKey(key, usage) {
   if (key.algorithm.name !== "ECDH" && key.algorithm.name !== "X25519")
     throw new TypeError("CryptoKey does not support this operation, its algorithm.name must be ECDH or X25519");
   checkUsage(key, usage);
 }
-async function aeskwCryptoKey(key, alg, usage) {
-  const expected = jweAlgorithm(alg).subtle, cryptoKey = key instanceof Uint8Array ? await crypto.subtle.importKey("raw", key, "AES-KW", !0, [
-    usage
-  ]) : key;
-  return checkCryptoKey(cryptoKey, expected, usage), cryptoKey;
-}
 async function aeskwWrap(alg, key, cek) {
-  const cryptoKey = await aeskwCryptoKey(key, alg, "wrapKey"), cryptoKeyCek = await crypto.subtle.importKey("raw", cek, { hash: "SHA-256", name: "HMAC" }, !0, ["sign"]);
+  const cryptoKey = await rawKey(key, jweAlgorithm(alg).subtle, "wrapKey", !0), cryptoKeyCek = await crypto.subtle.importKey("raw", cek, { hash: "SHA-256", name: "HMAC" }, !0, ["sign"]);
   return new Uint8Array(await crypto.subtle.wrapKey("raw", cryptoKeyCek, cryptoKey, "AES-KW"));
 }
 async function aeskwUnwrap(alg, key, encryptedKey) {
-  const cryptoKey = await aeskwCryptoKey(key, alg, "unwrapKey"), cryptoKeyCek = await crypto.subtle.unwrapKey("raw", encryptedKey, cryptoKey, "AES-KW", { hash: "SHA-256", name: "HMAC" }, !0, ["sign"]);
+  const cryptoKey = await rawKey(key, jweAlgorithm(alg).subtle, "unwrapKey", !0), cryptoKeyCek = await crypto.subtle.unwrapKey("raw", encryptedKey, cryptoKey, "AES-KW", { hash: "SHA-256", name: "HMAC" }, !0, ["sign"]);
   return new Uint8Array(await crypto.subtle.exportKey("raw", cryptoKeyCek));
 }
 function checkRsaKey(alg, key, usage) {
   checkCryptoKey(key, jweAlgorithm(alg).subtle, usage), checkModulusLength(alg, key);
 }
-function pbes2CryptoKey(key, alg) {
-  return key instanceof Uint8Array ? crypto.subtle.importKey("raw", key, "PBKDF2", !1, [
-    "deriveBits"
-  ]) : (checkCryptoKey(key, jweAlgorithm(alg).subtle, "deriveBits"), key);
-}
 async function deriveKey(p2s, alg, p2c, key) {
   if (!(p2s instanceof Uint8Array) || p2s.length < 8)
     throw new JWEInvalid("PBES2 Salt Input must be 8 or more octets");
@@ -46,7 +31,7 @@ async function deriveKey(p2s, alg, p2c, key) {
     iterations: p2c,
     name: "PBKDF2",
     salt
-  }, cryptoKey = await pbes2CryptoKey(key, alg);
+  }, cryptoKey = await rawKey(key, jweAlgorithm(alg).subtle, "deriveBits");
   return new Uint8Array(await crypto.subtle.deriveBits(subtleAlg, cryptoKey, keylen));
 }
 function lengthAndInput(input) {
@@ -104,19 +89,11 @@ function validateMaxPBES2Count(value) {
 }
 async function decryptKeyManagement(entry, enc, key, encryptedKey, joseHeader, maxPBES2Count) {
   const { alg } = entry, mode = entry.mode;
-  switch (mode) {
-    case "direct-encryption":
-      return assertNoEncryptedKey(encryptedKey), key;
-    case "direct-key-agreement":
-    case "key-wrapping":
-    case "key-encryption":
-    case "key-agreement-with-key-wrapping":
-      break;
-  }
-  switch (entry.subtle.name) {
+  if (mode === "direct-encryption")
+    return assertNoEncryptedKey(encryptedKey), key;
+  const direct = mode === "direct-key-agreement";
+  switch (direct ? assertNoEncryptedKey(encryptedKey) : assertEncryptedKey(encryptedKey), entry.subtle.name) {
     case "ECDH": {
-      const direct = mode === "direct-key-agreement";
-      direct && assertNoEncryptedKey(encryptedKey);
       const { epk } = joseHeader;
       if (!isObject(epk) || ["d", "k", "p", "q", "dp", "dq", "qi", "oth", "priv"].some((parameter) => Object.hasOwn(epk, parameter)))
         throw new JWEInvalid('JOSE Header "epk" (Ephemeral Public Key) missing or invalid');
@@ -124,12 +101,15 @@ async function decryptKeyManagement(entry, enc, key, encryptedKey, joseHeader, m
       const ephemeralPublicKey = await jwkToKey(entry, epk), partyUInfo = partyInfo(joseHeader, "apu"), partyVInfo = partyInfo(joseHeader, "apv");
       checkPartyInfo(partyUInfo, partyVInfo);
       const sharedSecret = await ecdhesDeriveKey(ephemeralPublicKey, key, direct ? enc.alg : alg, direct ? enc.cekBits : parseInt(alg.slice(-5, -2), 10), partyUInfo, partyVInfo);
-      return direct ? sharedSecret : (assertEncryptedKey(encryptedKey), aeskwUnwrap(alg.slice(-6), sharedSecret, encryptedKey));
+      if (direct)
+        return sharedSecret;
+      key = sharedSecret;
+      break;
     }
     case "RSA-OAEP":
-      return assertEncryptedKey(encryptedKey), assertCryptoKey(key), checkRsaKey(alg, key, "decrypt"), new Uint8Array(await crypto.subtle.decrypt("RSA-OAEP", key, encryptedKey));
+      return assertCryptoKey(key), checkRsaKey(alg, key, "decrypt"), new Uint8Array(await crypto.subtle.decrypt("RSA-OAEP", key, encryptedKey));
     case "PBKDF2": {
-      if (assertEncryptedKey(encryptedKey), typeof joseHeader.p2c != "number")
+      if (typeof joseHeader.p2c != "number")
         throw new JWEInvalid('JOSE Header "p2c" (PBES2 Count) missing or invalid');
       validateMaxPBES2Count(maxPBES2Count);
       const p2cLimit = maxPBES2Count ?? 1e4;
@@ -137,39 +117,35 @@ async function decryptKeyManagement(entry, enc, key, encryptedKey, joseHeader, m
         throw new JWEInvalid('JOSE Header "p2c" (PBES2 Count) out is of acceptable bounds');
       if (typeof joseHeader.p2s != "string")
         throw new JWEInvalid('JOSE Header "p2s" (PBES2 Salt) missing or invalid');
-      const p2s = decodeBase64url(joseHeader.p2s, "p2s", JWEInvalid), derived = await deriveKey(p2s, alg, joseHeader.p2c, key);
-      return aeskwUnwrap(alg.slice(-6), derived, encryptedKey);
+      const p2s = decodeBase64url(joseHeader.p2s, "p2s", JWEInvalid);
+      key = await deriveKey(p2s, alg, joseHeader.p2c, key);
+      break;
     }
-    case "AES-KW":
-      return assertEncryptedKey(encryptedKey), aeskwUnwrap(alg, key, encryptedKey);
     case "AES-GCM": {
-      if (assertEncryptedKey(encryptedKey), typeof joseHeader.iv != "string")
+      if (typeof joseHeader.iv != "string")
         throw new JWEInvalid('JOSE Header "iv" (Initialization Vector) missing or invalid');
       if (typeof joseHeader.tag != "string")
         throw new JWEInvalid('JOSE Header "tag" (Authentication Tag) missing or invalid');
-      let iv;
-      iv = decodeBase64url(joseHeader.iv, "iv", JWEInvalid);
-      let tag;
-      if (tag = decodeBase64url(joseHeader.tag, "tag", JWEInvalid), iv.byteLength !== 12)
+      const iv = decodeBase64url(joseHeader.iv, "iv", JWEInvalid), tag = decodeBase64url(joseHeader.tag, "tag", JWEInvalid);
+      if (iv.byteLength !== 12)
         throw new JWEInvalid("Invalid Initialization Vector length");
       if (tag.byteLength !== 16)
         throw new JWEInvalid("Invalid Authentication Tag length");
       return decrypt(jweEncryption(alg.slice(0, -2)), key, encryptedKey, iv, tag, new Uint8Array());
     }
   }
-}
-async function encryptKeyManagement(entry, enc, key, joseHeader, providedCek, providedParameters = {}) {
-  let encryptedKey, parameters, cek;
-  const { alg } = entry, mode = entry.mode;
-  switch (mode) {
-    case "direct-encryption":
-      return [key, void 0, void 0];
-    case "direct-key-agreement":
-    case "key-wrapping":
-    case "key-encryption":
-    case "key-agreement-with-key-wrapping":
-      break;
-  }
+  return aeskwUnwrap(alg.slice(-6), key, encryptedKey);
+}
+async function encryptKeyManagement(entry, enc, inputKey, joseHeader, providedCek, providedParameters = {}) {
+  const { alg, mode } = entry, transport = isJWECEKTransport(entry);
+  if (providedCek !== void 0 && !transport)
+    throw new TypeError(`setContentEncryptionKey cannot be called with JWE "alg" (Algorithm) Header ${alg}`);
+  let key = await prepareKey(mode === "direct-encryption" ? enc : entry, inputKey, "encrypt");
+  if (mode === "direct-encryption")
+    return [key, void 0, void 0];
+  const cek = transport ? providedCek ?? generateCek(enc) : void 0;
+  cek && checkCekLength(cek, enc.cekBits);
+  let encryptedKey, parameters;
   switch (entry.subtle.name) {
     case "ECDH": {
       assertEcdhKey(key);
@@ -186,42 +162,31 @@ async function encryptKeyManagement(entry, enc, key, joseHeader, providedCek, pr
           throw new TypeError('CryptoKey for "epk" must be extractable');
         exportableEpk = await subtle.getPublicKey(ephemeralKey, []);
       }
-      const { x, y, crv, kty } = await subtle.exportKey("jwk", exportableEpk), direct = mode === "direct-key-agreement", sharedSecret = await ecdhesDeriveKey(key, ephemeralKey, direct ? enc.alg : alg, direct ? enc.cekBits : parseInt(alg.slice(-5, -2), 10), apu, apv);
-      if (parameters = { epk: { x, crv, kty } }, kty === "EC" && (parameters.epk.y = y), providedApu !== void 0 && (parameters.apu = b64u(providedApu)), providedApv !== void 0 && (parameters.apv = b64u(providedApv)), direct) {
-        cek = sharedSecret;
-        break;
-      }
-      cek = providedCek ?? generateCek(enc);
-      const kwAlg = alg.slice(-6);
-      encryptedKey = await aeskwWrap(kwAlg, sharedSecret, cek);
+      const { x, y, crv, kty } = await subtle.exportKey("jwk", exportableEpk), direct = mode === "direct-key-agreement", sharedSecret = await ecdhesDeriveKey(key, ephemeralKey, direct ? enc.alg : alg, direct ? enc.cekBits : parseInt(alg.slice(-5, -2), 10), apu, apv), epk = { x, crv, kty };
+      if (kty === "EC" && (epk.y = y), parameters = { epk }, providedApu !== void 0 && (parameters.apu = b64u(providedApu)), providedApv !== void 0 && (parameters.apv = b64u(providedApv)), direct)
+        return [sharedSecret, void 0, parameters];
+      key = sharedSecret;
       break;
     }
     case "RSA-OAEP": {
-      cek = providedCek ?? generateCek(enc), assertCryptoKey(key), checkRsaKey(alg, key, "encrypt"), encryptedKey = new Uint8Array(await crypto.subtle.encrypt("RSA-OAEP", key, cek));
+      assertCryptoKey(key), checkRsaKey(alg, key, "encrypt"), encryptedKey = new Uint8Array(await crypto.subtle.encrypt("RSA-OAEP", key, cek));
       break;
     }
     case "PBKDF2": {
-      cek = providedCek ?? generateCek(enc);
-      const { p2c = 2048, p2s = crypto.getRandomValues(new Uint8Array(16)) } = providedParameters, derived = await deriveKey(p2s, alg, p2c, key);
-      encryptedKey = await aeskwWrap(alg.slice(-6), derived, cek), parameters = { p2c, p2s: b64u(p2s) };
-      break;
-    }
-    case "AES-KW": {
-      cek = providedCek ?? generateCek(enc), encryptedKey = await aeskwWrap(alg, key, cek);
+      const { p2c = 2048, p2s = crypto.getRandomValues(new Uint8Array(16)) } = providedParameters;
+      key = await deriveKey(p2s, alg, p2c, key), parameters = { p2c, p2s: b64u(p2s) };
       break;
     }
     case "AES-GCM": {
-      cek = providedCek ?? generateCek(enc);
       const iv = providedParameters.iv === void 0 ? crypto.getRandomValues(new Uint8Array(12)) : providedParameters.iv;
       if (!(iv instanceof Uint8Array))
         throw new TypeError('"iv" must be an instance of Uint8Array');
       const wrapped = await encrypt(jweEncryption(alg.slice(0, -2)), cek, key, iv, new Uint8Array());
       encryptedKey = wrapped.ciphertext, parameters = { iv: b64u(wrapped.iv), tag: b64u(wrapped.tag) };
-      break;
     }
   }
-  if (cek === void 0)
-    throw new TypeError("Invalid JWE key management algorithm");
+  if (encryptedKey ??= await aeskwWrap(alg.slice(-6), key, cek), !(encryptedKey instanceof Uint8Array) || !encryptedKey.byteLength)
+    throw new TypeError("JWE key management algorithm did not produce an Encrypted Key");
   return [cek, encryptedKey, parameters];
 }
 export {

package/node_modules/@modelcontextprotocol/client/node_modules/jose/dist/webapi/lib/{options.js → validate.js}

@@ -1,11 +1,64 @@
 import { JOSENotSupported, JWSInvalid } from "../util/errors.js";
-import { isObject } from "./type_checks.js";
+import { decode } from "../util/base64url.js";
+import { encode, strictDecoder } from "./buffer_utils.js";
+function assertUint8Array(input, label) {
+  if (!(input instanceof Uint8Array))
+    throw new TypeError(`${label} must be an instance of Uint8Array`);
+}
+function isObject(input) {
+  if (typeof input != "object" || input === null || Object.prototype.toString.call(input) !== "[object Object]")
+    return !1;
+  const prototype = Object.getPrototypeOf(input);
+  return prototype === null || Object.getPrototypeOf(prototype) === null;
+}
+function isJwkSet(input) {
+  return isObject(input) && Array.isArray(input.keys) && Array.from(input.keys).every(isObject);
+}
+function isDisjoint(...headers) {
+  const parameters = /* @__PURE__ */ new Set();
+  for (const header of headers)
+    if (header)
+      for (const parameter of Object.keys(header)) {
+        if (parameters.has(parameter))
+          return !1;
+        parameters.add(parameter);
+      }
+  return !0;
+}
+function assertNotSet(value, name) {
+  if (value !== void 0)
+    throw new TypeError(`${name} can only be called once`);
+}
+function decodeBase64url(value, label, ErrorClass) {
+  try {
+    return decode(value);
+  } catch {
+    throw new ErrorClass(`Failed to base64url decode the ${label}`);
+  }
+}
+function encodeBase64url(value, label, ErrorClass) {
+  try {
+    return encode(value);
+  } catch {
+    throw new ErrorClass(`The ${label} is not a valid base64url string`);
+  }
+}
+function parseJoseHeader(b64, ErrorClass, message) {
+  let parsed;
+  try {
+    parsed = JSON.parse(strictDecoder.decode(decode(b64)));
+  } catch {
+    throw new ErrorClass(message);
+  }
+  if (!isObject(parsed))
+    throw new ErrorClass(message);
+  return parsed;
+}
 const JWS_RECOGNIZED = { __proto__: null, b64: !0 }, JWE_RECOGNIZED = { __proto__: null };
 function validateAlgorithms(option, algorithms) {
   if (algorithms !== void 0 && (!Array.isArray(algorithms) || algorithms.some((s) => typeof s != "string")))
     throw new TypeError(`"${option}" option must be an array of strings`);
-  if (algorithms)
-    return new Set(algorithms);
+  return algorithms === void 0 ? void 0 : new Set(algorithms);
 }
 function validateCritDuplicates(Err, protectedHeader) {
   const { crit } = protectedHeader ?? {};
@@ -53,6 +106,14 @@ function serializeJoseHeader(Err, header) {
 export {
   JWE_RECOGNIZED,
   JWS_RECOGNIZED,
+  assertNotSet,
+  assertUint8Array,
+  decodeBase64url,
+  encodeBase64url,
+  isDisjoint,
+  isJwkSet,
+  isObject,
+  parseJoseHeader,
   serializeJoseHeader,
   validateAlgorithms,
   validateB64,

package/node_modules/@modelcontextprotocol/client/node_modules/jose/dist/webapi/util/base64url.js

@@ -1,28 +1,14 @@
-import { encoder, decoder } from "../lib/buffer_utils.js";
-import { encodeBase64, decodeBase64 } from "../lib/base64.js";
+import { encoder, decoder, encodeBase64, decodeBase64 } from "../lib/buffer_utils.js";
 const invalid = "The input to be decoded is not correctly encoded.";
 function decode(input) {
-  if (Uint8Array.fromBase64)
-    try {
-      return Uint8Array.fromBase64(typeof input == "string" ? input : decoder.decode(input), {
-        alphabet: "base64url"
-      });
-    } catch (cause) {
-      throw new TypeError(invalid, { cause });
-    }
-  let encoded = input;
-  if (encoded instanceof Uint8Array && (encoded = decoder.decode(encoded)), encoded.includes("+") || encoded.includes("/"))
-    throw new TypeError(invalid);
-  encoded = encoded.replace(/-/g, "+").replace(/_/g, "/");
   try {
-    return decodeBase64(encoded);
-  } catch {
-    throw new TypeError(invalid);
+    return decodeBase64(typeof input == "string" ? input : decoder.decode(input), !0);
+  } catch (cause) {
+    throw new TypeError(invalid, { cause });
   }
 }
 function encode(input) {
-  let unencoded = input;
-  return typeof unencoded == "string" && (unencoded = encoder.encode(unencoded)), Uint8Array.prototype.toBase64 ? unencoded.toBase64({ alphabet: "base64url", omitPadding: !0 }) : encodeBase64(unencoded).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  return encodeBase64(typeof input == "string" ? encoder.encode(input) : input, !0);
 }
 export {
   decode,

package/node_modules/@modelcontextprotocol/client/node_modules/jose/dist/webapi/util/decode_jwt.js

@@ -1,6 +1,6 @@
 import { decode as b64u } from "./base64url.js";
 import { strictDecoder } from "../lib/buffer_utils.js";
-import { isObject } from "../lib/type_checks.js";
+import { isObject } from "../lib/validate.js";
 import { JWTInvalid } from "./errors.js";
 function decodeJwt(jwt) {
   if (typeof jwt != "string")

package/node_modules/@modelcontextprotocol/client/node_modules/jose/dist/webapi/util/decode_protected_header.js

@@ -1,4 +1,4 @@
-import { parseJoseHeader } from "../lib/helpers.js";
+import { parseJoseHeader } from "../lib/validate.js";
 function decodeProtectedHeader(token) {
   let protectedB64u;
   if (typeof token == "string") {

package/node_modules/@modelcontextprotocol/client/node_modules/jose/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jose",
-  "version": "6.2.11",
+  "version": "6.2.12",
   "description": "JWA, JWS, JWE, JWT, JWK, JWKS for Node.js, Browser, Cloudflare Workers, Deno, Bun, and other Web-interoperable runtimes",
   "keywords": [
     "akp",

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/types/index.d.ts

@@ -48,8 +48,7 @@ import * as base64url from './util/base64url.js';
 export { base64url };
 export type { AnyJWK, CompactDecryptResult, CompactJWEHeaderParameters, CompactJWSHeaderParameters, CompactVerifyResult, CritOption, CryptoKey, DecryptOptions, EncryptOptions, FlattenedDecryptResult, FlattenedJWE, FlattenedJWS, FlattenedJWSInput, FlattenedVerifyResult, GeneralDecryptResult, GeneralJWE, GeneralJWS, GeneralJWSInput, GeneralVerifyResult, GetKeyFunction, JoseHeaderParameters, JSONWebKeySet, JWEContentEncryptionAlgorithm, JWEHeaderParameters, JWEKeyManagementAlgorithm, JWEKeyManagementHeaderParameters, JWK_AKP_Private, JWK_AKP_Public, JWK_EC_Private, JWK_EC_Public, JWK_oct, JWK_OKP_Private, JWK_OKP_Public, JWK_RSA_Private, JWK_RSA_Public, JWK, JWKKeyType, JWKParameters, JWSAlgorithm, JWSHeaderParameters, JWTClaimVerificationOptions, JWTDecryptResult, JWTHeaderParameters, JWTPayload, JWTVerifyResult, KeyInput, KeyObject, ProduceJWT, ResolvedKey, SignOptions, VerifyOptions, } from './types.d.ts';
 /**
- * In prior releases this indicated whether a Node.js-specific build was loaded, this is now fixed
- * to `"WebCryptoAPI"`
+ * Identified the loaded runtime-specific build in prior releases; now always `"WebCryptoAPI"`.
  *
  * @deprecated Remove any runtime branching on this value; it is always `"WebCryptoAPI"`.
  */

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/types/jwe/compact/decrypt.d.ts

@@ -1,28 +1,24 @@
 import type * as t from '../../types.d.ts';
-/** Dynamic key resolver for Compact JWE decryption. */
+/** Resolves a key for Compact JWE decryption from unverified headers and token data. */
 export interface CompactDecryptGetKey<KeyType extends t.CryptoKey | Uint8Array = t.CryptoKey | Uint8Array> extends t.GetKeyFunction<t.CompactJWEHeaderParameters, t.FlattenedJWE, KeyType | t.KeyObject | t.JWK> {
 }
 /**
  * Decrypts a Compact JWE.
  *
- * @param key Private Key or Secret to decrypt the JWE with. See
+ * @param key Private key or shared secret. See
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  */
 export declare function compactDecrypt(jwe: string | Uint8Array, key: t.KeyInput, options?: t.DecryptOptions): Promise<t.CompactDecryptResult>;
 /**
- * Decrypts a Compact JWE, resolving the key dynamically. The result additionally carries the
- * {@link t.ResolvedKey.key resolved key}.
+ * Decrypts a Compact JWE with a dynamically resolved key, included in the result.
  *
- * @param getKey Function resolving Private Key or Secret to decrypt the JWE with. See
- *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
+ * @param getKey Resolves a private key or shared secret from unverified token data.
  */
 export declare function compactDecrypt<KeyType extends t.CryptoKey | Uint8Array = t.CryptoKey | Uint8Array>(jwe: string | Uint8Array, getKey: CompactDecryptGetKey<KeyType>, options?: t.DecryptOptions): Promise<t.CompactDecryptResult & t.ResolvedKey<KeyType>>;
 /**
- * Accepts either form of the `key` argument. Use this overload when forwarding a value that may be
- * either a key or a key resolution function; `key` is present on the result only when a resolution
- * function was used.
+ * Decrypts a Compact JWE with a key or key resolver. The result includes `key` only when a resolver
+ * is used.
  *
- * @param key Private Key or Secret, or a function resolving one, to decrypt the JWE with. See
- *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
+ * @param key Private key or shared secret, or a function resolving one.
  */
 export declare function compactDecrypt(jwe: string | Uint8Array, key: t.KeyInput | CompactDecryptGetKey, options?: t.DecryptOptions): Promise<t.CompactDecryptResult & Partial<t.ResolvedKey>>;