@zuplo/cli 7.12.3 → 7.12.5

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

@@ -16,8 +16,8 @@ function secs(str) {
   typeof str != "string" && invalidDuration();
   const matched = REGEX.exec(str);
   (!matched || matched[4] && matched[1]) && invalidDuration();
-  const value = parseFloat(matched[2]), numericDate2 = Math.round(value * multipliers[matched[3][0].toLowerCase()]);
-  return Number.isFinite(numericDate2) || invalidDuration(), matched[1] === "-" || matched[4] === "ago" ? -numericDate2 : numericDate2;
+  const value = parseFloat(matched[2]), durationSeconds = Math.round(value * multipliers[matched[3][0].toLowerCase()]);
+  return Number.isFinite(durationSeconds) || invalidDuration(), matched[1] === "-" || matched[4] === "ago" ? -durationSeconds : durationSeconds;
 }
 function validateInput(label, input) {
   if (!Number.isFinite(input))
@@ -39,34 +39,35 @@ const normalizeTyp = (value) => {
   const normalized = value.toLowerCase();
   return value.includes("/") ? normalized : `application/${normalized}`;
 }, checkAudiencePresence = (audPayload, audOption) => typeof audPayload == "string" ? audOption.includes(audPayload) : Array.isArray(audPayload) ? audOption.some((aud) => audPayload.includes(aud)) : !1;
-function validateNumericDate(payload, claim, required = !1) {
-  const value = payload[claim];
+function validateNumericDate(claimsSet, claim, required = !1) {
+  const value = claimsSet[claim];
   if (!(value === void 0 && !required)) {
     if (typeof value != "number")
-      throw new JWTClaimValidationFailed(`"${claim}" claim must be a number`, payload, claim, "invalid");
+      throw new JWTClaimValidationFailed(`"${claim}" claim must be a number`, claimsSet, claim, "invalid");
     return value;
   }
 }
-function unexpectedClaim(payload, claim) {
-  throw new JWTClaimValidationFailed(`unexpected "${claim}" claim value`, payload, claim, checkFailed);
+function unexpectedClaim(claimsSet, claim) {
+  throw new JWTClaimValidationFailed(`unexpected "${claim}" claim value`, claimsSet, claim, checkFailed);
 }
-function validateClaimsSet(protectedHeader, encodedPayload, options = {}) {
-  let payload;
+function validateClaimsSet(protectedHeader, claimsSetBytes, options = {}) {
+  let claimsSet;
   try {
-    payload = JSON.parse(strictDecoder.decode(encodedPayload));
-  } catch {
+    claimsSet = JSON.parse(strictDecoder.decode(claimsSetBytes));
+  } catch (cause) {
+    throw new JWTInvalid("JWT Claims Set must be a top-level JSON object", { cause });
   }
-  if (!isObject(payload))
+  if (!isObject(claimsSet))
     throw new JWTInvalid("JWT Claims Set must be a top-level JSON object");
   const { typ } = options;
   if (typ !== void 0 && (typeof protectedHeader.typ != "string" || normalizeTyp(protectedHeader.typ) !== normalizeTyp(typ)))
-    throw new JWTClaimValidationFailed('unexpected "typ" JWT header value', payload, "typ", checkFailed);
+    throw new JWTClaimValidationFailed('unexpected "typ" JWT header value', claimsSet, "typ", checkFailed);
   const { requiredClaims = [], issuer, subject, audience, maxTokenAge } = options, presenceCheck = [...requiredClaims];
   maxTokenAge !== void 0 && presenceCheck.push("iat"), audience !== void 0 && presenceCheck.push("aud"), subject !== void 0 && presenceCheck.push("sub"), issuer !== void 0 && presenceCheck.push("iss");
   for (const claim of new Set(presenceCheck.reverse()))
-    if (!Object.hasOwn(payload, claim))
-      throw new JWTClaimValidationFailed(`missing required "${claim}" claim`, payload, claim, "missing");
-  issuer !== void 0 && !(Array.isArray(issuer) ? issuer : [issuer]).includes(payload.iss) && unexpectedClaim(payload, "iss"), subject !== void 0 && payload.sub !== subject && unexpectedClaim(payload, "sub"), audience !== void 0 && !checkAudiencePresence(payload.aud, typeof audience == "string" ? [audience] : audience) && unexpectedClaim(payload, "aud");
+    if (!Object.hasOwn(claimsSet, claim))
+      throw new JWTClaimValidationFailed(`missing required "${claim}" claim`, claimsSet, claim, "missing");
+  issuer !== void 0 && !(Array.isArray(issuer) ? issuer : [issuer]).includes(claimsSet.iss) && unexpectedClaim(claimsSet, "iss"), subject !== void 0 && claimsSet.sub !== subject && unexpectedClaim(claimsSet, "sub"), audience !== void 0 && !checkAudiencePresence(claimsSet.aud, typeof audience == "string" ? [audience] : audience) && unexpectedClaim(claimsSet, "aud");
   const { clockTolerance } = options;
   let tolerance = 0;
   if (typeof clockTolerance == "string")
@@ -77,70 +78,70 @@ function validateClaimsSet(protectedHeader, encodedPayload, options = {}) {
     tolerance = clockTolerance;
   }
   validateInput("clockTolerance option", tolerance);
-  const { currentDate } = options, now = validateInput("currentDate option", epoch(currentDate === void 0 ? /* @__PURE__ */ new Date() : currentDate)), iat = validateNumericDate(payload, "iat", maxTokenAge !== void 0), nbf = validateNumericDate(payload, "nbf");
+  const { currentDate } = options, now = validateInput("currentDate option", epoch(currentDate === void 0 ? /* @__PURE__ */ new Date() : currentDate)), iat = validateNumericDate(claimsSet, "iat", maxTokenAge !== void 0), nbf = validateNumericDate(claimsSet, "nbf");
   if (nbf !== void 0 && nbf > now + tolerance)
-    throw new JWTClaimValidationFailed('"nbf" claim timestamp check failed', payload, "nbf", checkFailed);
-  const exp = validateNumericDate(payload, "exp");
+    throw new JWTClaimValidationFailed('"nbf" claim timestamp check failed', claimsSet, "nbf", checkFailed);
+  const exp = validateNumericDate(claimsSet, "exp");
   if (exp !== void 0 && exp <= now - tolerance)
-    throw new JWTExpired('"exp" claim timestamp check failed', payload, "exp", checkFailed);
+    throw new JWTExpired('"exp" claim timestamp check failed', claimsSet, "exp", checkFailed);
   if (maxTokenAge !== void 0) {
     const age = now - iat, max = validateInput("maxTokenAge option", typeof maxTokenAge == "number" ? maxTokenAge : secs(maxTokenAge));
     if (age - tolerance > max)
-      throw new JWTExpired('"iat" claim timestamp check failed (too far in the past)', payload, "iat", checkFailed);
+      throw new JWTExpired('"iat" claim timestamp check failed (too far in the past)', claimsSet, "iat", checkFailed);
     if (age < -tolerance)
-      throw new JWTClaimValidationFailed('"iat" claim timestamp check failed (it should be in the past)', payload, "iat", checkFailed);
+      throw new JWTClaimValidationFailed('"iat" claim timestamp check failed (it should be in the past)', claimsSet, "iat", checkFailed);
   }
-  return payload;
+  return claimsSet;
 }
-let producerPayloads;
-function producerPayload(producer) {
-  return producerPayloads.get(producer);
+let producerClaimsSets;
+function producerClaimsSet(producer) {
+  return producerClaimsSets.get(producer);
 }
-function jwtData(producer) {
-  const payload = producerPayload(producer);
+function jwtClaimsSetBytes(producer) {
+  const claimsSet = producerClaimsSet(producer);
   for (const claim of ["iat", "nbf", "exp"]) {
-    const value = payload[claim];
+    const value = claimsSet[claim];
     if (typeof value == "number" && !Number.isFinite(value))
       throw new TypeError(`"${claim}" claim must be a finite number`);
   }
-  return encoder.encode(JSON.stringify(payload));
+  return encoder.encode(JSON.stringify(claimsSet));
 }
 function jwtClaim(producer, claim) {
-  return producerPayload(producer)[claim];
+  return producerClaimsSet(producer)[claim];
 }
 class JWTClaimsBuilder {
-  constructor(payload = {}) {
-    if (!isObject(payload))
+  constructor(claimsSet = {}) {
+    if (!isObject(claimsSet))
       throw new TypeError("JWT Claims Set MUST be an object");
-    (producerPayloads ||= /* @__PURE__ */ new WeakMap()).set(this, structuredClone(payload));
+    (producerClaimsSets ||= /* @__PURE__ */ new WeakMap()).set(this, structuredClone(claimsSet));
   }
   setIssuer(value) {
-    return validateStringClaim("iss", value), producerPayload(this).iss = value, this;
+    return validateStringClaim("iss", value), producerClaimsSet(this).iss = value, this;
   }
   setSubject(value) {
-    return validateStringClaim("sub", value), producerPayload(this).sub = value, this;
+    return validateStringClaim("sub", value), producerClaimsSet(this).sub = value, this;
   }
   setAudience(value) {
-    return validateAudienceClaim(value), producerPayload(this).aud = value, this;
+    return validateAudienceClaim(value), producerClaimsSet(this).aud = value, this;
   }
   setJti(value) {
-    return validateStringClaim("jti", value), producerPayload(this).jti = value, this;
+    return validateStringClaim("jti", value), producerClaimsSet(this).jti = value, this;
   }
   setNotBefore(value) {
-    return producerPayload(this).nbf = numericDate(value, "setNotBefore"), this;
+    return producerClaimsSet(this).nbf = numericDate(value, "setNotBefore"), this;
   }
   setExpirationTime(value) {
-    return producerPayload(this).exp = numericDate(value, "setExpirationTime"), this;
+    return producerClaimsSet(this).exp = numericDate(value, "setExpirationTime"), this;
   }
   setIssuedAt(value) {
-    const payload = producerPayload(this);
-    return value === void 0 ? payload.iat = epoch(/* @__PURE__ */ new Date()) : typeof value == "string" ? payload.iat = validateInput("setIssuedAt", epoch(/* @__PURE__ */ new Date()) + secs(value)) : payload.iat = numericDate(value, "setIssuedAt"), this;
+    const claimsSet = producerClaimsSet(this);
+    return value === void 0 ? claimsSet.iat = epoch(/* @__PURE__ */ new Date()) : typeof value == "string" ? claimsSet.iat = validateInput("setIssuedAt", epoch(/* @__PURE__ */ new Date()) + secs(value)) : claimsSet.iat = numericDate(value, "setIssuedAt"), this;
   }
 }
 export {
   JWTClaimsBuilder,
   jwtClaim,
-  jwtData,
+  jwtClaimsSetBytes,
   secs,
   validateClaimsSet
 };

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

@@ -17,15 +17,15 @@ const tag = (key) => key[Symbol.toStringTag], jwkMatchesOp = (entry, key, usage)
   }
 };
 async function prepareKey(entry, key, usage) {
-  const { alg, secret } = entry, privateKey = usage === "decrypt" || usage === "sign";
+  const { alg, secret } = entry, requiresPrivateKey = usage === "decrypt" || usage === "sign";
   if (secret && key instanceof Uint8Array)
     return key;
   let normalized, keyObject;
   if (isObject(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`);
+    if (!(secret ? normalized.kty === "oct" && typeof normalized.k == "string" : normalized.kty !== "oct" && (requiresPrivateKey ? 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 ${requiresPrivateKey ? "private" : "public"} JWK`);
     if (jwkMatchesOp(entry, normalized, usage), normalized.kty === "oct")
       return decode(normalized.k);
     if (!Object.isFrozen(key)) {
@@ -35,7 +35,7 @@ async function prepareKey(entry, key, usage) {
   } else {
     if (!isKeyLike(key))
       throw invalidKeyType(alg, key, secret);
-    const expectedType = secret ? "secret" : privateKey ? "private" : "public";
+    const expectedType = secret ? "secret" : requiresPrivateKey ? "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))

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

@@ -26,32 +26,32 @@ async function deriveKey(p2s, alg, p2c, key) {
     throw new JWEInvalid("PBES2 Salt Input must be 8 or more octets");
   if (!Number.isSafeInteger(p2c) || Math.sign(p2c) !== 1)
     throw new JWEInvalid("PBES2 Count Input must be a positive integer");
-  const salt = concat(encode(alg), Uint8Array.of(0), p2s), keylen = parseInt(alg.slice(13, 16), 10), subtleAlg = {
+  const salt = concat(encode(alg), Uint8Array.of(0), p2s), keyLengthBits = parseInt(alg.slice(13, 16), 10), subtleAlg = {
     hash: `SHA-${alg.slice(8, 11)}`,
     iterations: p2c,
     name: "PBKDF2",
     salt
   }, cryptoKey = await rawKey(key, jweAlgorithm(alg).subtle, "deriveBits");
-  return new Uint8Array(await crypto.subtle.deriveBits(subtleAlg, cryptoKey, keylen));
+  return new Uint8Array(await crypto.subtle.deriveBits(subtleAlg, cryptoKey, keyLengthBits));
 }
 function lengthAndInput(input) {
   return concat(uint32be(input.length), input);
 }
-async function concatKdf(Z, L, OtherInfo) {
-  const dkLen = L >> 3, hashLen = 32, reps = Math.ceil(dkLen / hashLen), dk = new Uint8Array(reps * hashLen);
+async function concatKdf(Z, keyDataLength, OtherInfo) {
+  const dkLen = keyDataLength >> 3, hashLen = 32, reps = Math.ceil(dkLen / hashLen), dk = new Uint8Array(reps * hashLen);
   for (let i = 1; i <= reps; i++) {
     const hashResult = await digest("sha256", concat(uint32be(i), Z, OtherInfo));
     dk.set(hashResult, (i - 1) * hashLen);
   }
   return dk.slice(0, dkLen);
 }
-async function ecdhesDeriveKey(publicKey, privateKey, algorithm, keyLength, apu = new Uint8Array(), apv = new Uint8Array()) {
+async function ecdhesDeriveKey(publicKey, privateKey, algorithmId, keyDataLength, apu = new Uint8Array(), apv = new Uint8Array()) {
   checkEcdhCryptoKey(publicKey), checkEcdhCryptoKey(privateKey, "deriveBits");
-  const otherInfo = concat(lengthAndInput(encode(algorithm)), lengthAndInput(apu), lengthAndInput(apv), uint32be(keyLength)), Z = new Uint8Array(await crypto.subtle.deriveBits({
+  const otherInfo = concat(lengthAndInput(encode(algorithmId)), lengthAndInput(apu), lengthAndInput(apv), uint32be(keyDataLength)), Z = new Uint8Array(await crypto.subtle.deriveBits({
     name: publicKey.algorithm.name,
     public: publicKey
   }, privateKey, publicKey.algorithm.name === "X25519" ? 256 : Math.ceil(parseInt(publicKey.algorithm.namedCurve.slice(-3), 10) / 8) << 3));
-  return concatKdf(Z, keyLength, otherInfo);
+  return concatKdf(Z, keyDataLength, otherInfo);
 }
 function assertEcdhKey(key) {
   assertCryptoKey(key);
@@ -100,10 +100,10 @@ async function decryptKeyManagement(entry, enc, key, encryptedKey, joseHeader, m
       assertEcdhKey(key);
       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);
+      const derivedKey = await ecdhesDeriveKey(ephemeralPublicKey, key, direct ? enc.alg : alg, direct ? enc.cekBits : parseInt(alg.slice(-5, -2), 10), partyUInfo, partyVInfo);
       if (direct)
-        return sharedSecret;
-      key = sharedSecret;
+        return derivedKey;
+      key = derivedKey;
       break;
     }
     case "RSA-OAEP":
@@ -153,19 +153,19 @@ async function encryptKeyManagement(entry, enc, inputKey, joseHeader, providedCe
       providedApu !== void 0 && assertUint8Array(providedApu, '"apu"'), providedApv !== void 0 && assertUint8Array(providedApv, '"apv"');
       const apu = providedApu ?? partyInfo(joseHeader, "apu"), apv = providedApv ?? partyInfo(joseHeader, "apv");
       checkPartyInfo(apu, apv);
-      let ephemeralKey;
-      providedParameters.epk !== void 0 ? ephemeralKey = await prepareKey(entry, providedParameters.epk, "decrypt") : ephemeralKey = (await crypto.subtle.generateKey(key.algorithm, !0, ["deriveBits"])).privateKey;
+      let ephemeralPrivateKey;
+      providedParameters.epk !== void 0 ? ephemeralPrivateKey = await prepareKey(entry, providedParameters.epk, "decrypt") : ephemeralPrivateKey = (await crypto.subtle.generateKey(key.algorithm, !0, ["deriveBits"])).privateKey;
       const subtle = crypto.subtle;
-      let exportableEpk = ephemeralKey;
+      let exportableEpk = ephemeralPrivateKey;
       if (!exportableEpk.extractable) {
         if (typeof subtle.getPublicKey != "function")
           throw new TypeError('CryptoKey for "epk" must be extractable');
-        exportableEpk = await subtle.getPublicKey(ephemeralKey, []);
+        exportableEpk = await subtle.getPublicKey(ephemeralPrivateKey, []);
       }
-      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 };
+      const { x, y, crv, kty } = await subtle.exportKey("jwk", exportableEpk), direct = mode === "direct-key-agreement", derivedKey = await ecdhesDeriveKey(key, ephemeralPrivateKey, 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;
+        return [derivedKey, void 0, parameters];
+      key = derivedKey;
       break;
     }
     case "RSA-OAEP": {

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

@@ -32,23 +32,23 @@ function assertNotSet(value, name) {
 function decodeBase64url(value, label, ErrorClass) {
   try {
     return decode(value);
-  } catch {
-    throw new ErrorClass(`Failed to base64url decode the ${label}`);
+  } catch (cause) {
+    throw new ErrorClass(`Failed to base64url decode the ${label}`, { cause });
   }
 }
-function encodeBase64url(value, label, ErrorClass) {
+function encodeAsciiMember(value, label, ErrorClass) {
   try {
     return encode(value);
-  } catch {
-    throw new ErrorClass(`The ${label} is not a valid base64url string`);
+  } catch (cause) {
+    throw new ErrorClass(`The ${label} is not a valid base64url string`, { cause });
   }
 }
-function parseJoseHeader(b64, ErrorClass, message) {
+function parseJoseHeader(encodedProtectedHeader, ErrorClass, message) {
   let parsed;
   try {
-    parsed = JSON.parse(strictDecoder.decode(decode(b64)));
-  } catch {
-    throw new ErrorClass(message);
+    parsed = JSON.parse(strictDecoder.decode(decode(encodedProtectedHeader)));
+  } catch (cause) {
+    throw new ErrorClass(message, { cause });
   }
   if (!isObject(parsed))
     throw new ErrorClass(message);
@@ -109,7 +109,7 @@ export {
   assertNotSet,
   assertUint8Array,
   decodeBase64url,
-  encodeBase64url,
+  encodeAsciiMember,
   isDisjoint,
   isJwkSet,
   isObject,

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

@@ -5,28 +5,28 @@ import { JWTInvalid } from "./errors.js";
 function decodeJwt(jwt) {
   if (typeof jwt != "string")
     throw new JWTInvalid("JWTs must use Compact JWS serialization, JWT must be a string");
-  const { 1: payload, length } = jwt.split(".");
+  const { 1: encodedPayload, length } = jwt.split(".");
   if (length === 5)
     throw new JWTInvalid("Only JWTs using Compact JWS serialization can be decoded");
   if (length !== 3)
     throw new JWTInvalid("Invalid JWT");
-  if (!payload)
+  if (!encodedPayload)
     throw new JWTInvalid("JWTs must contain a payload");
-  let decoded;
+  let claimsSetBytes;
   try {
-    decoded = b64u(payload);
-  } catch {
-    throw new JWTInvalid("Failed to base64url decode the payload");
+    claimsSetBytes = b64u(encodedPayload);
+  } catch (cause) {
+    throw new JWTInvalid("Failed to base64url decode the payload", { cause });
   }
-  let result;
+  let claimsSet;
   try {
-    result = JSON.parse(strictDecoder.decode(decoded));
-  } catch {
-    throw new JWTInvalid("Failed to parse the decoded payload as JSON");
+    claimsSet = JSON.parse(strictDecoder.decode(claimsSetBytes));
+  } catch (cause) {
+    throw new JWTInvalid("Failed to parse the decoded payload as JSON", { cause });
   }
-  if (!isObject(result))
+  if (!isObject(claimsSet))
     throw new JWTInvalid("Invalid JWT Claims Set");
-  return result;
+  return claimsSet;
 }
 export {
   decodeJwt

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

@@ -1,18 +1,18 @@
 import { parseJoseHeader } from "../lib/validate.js";
 function decodeProtectedHeader(token) {
-  let protectedB64u;
+  let encodedProtectedHeader;
   if (typeof token == "string") {
     const parts = token.split(".");
-    (parts.length === 3 || parts.length === 5) && ([protectedB64u] = parts);
+    (parts.length === 3 || parts.length === 5) && ([encodedProtectedHeader] = parts);
   } else if (typeof token == "object" && token)
     if ("protected" in token)
-      protectedB64u = token.protected;
+      encodedProtectedHeader = token.protected;
     else
       throw new TypeError("Token does not contain a Protected Header");
   const invalid = "Invalid Token or Protected Header formatting";
-  if (typeof protectedB64u != "string" || !protectedB64u)
+  if (typeof encodedProtectedHeader != "string" || !encodedProtectedHeader)
     throw new TypeError(invalid);
-  return parseJoseHeader(protectedB64u, TypeError, invalid);
+  return parseJoseHeader(encodedProtectedHeader, TypeError, invalid);
 }
 export {
   decodeProtectedHeader

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

@@ -1,6 +1,6 @@
 {
   "name": "jose",
-  "version": "6.2.12",
+  "version": "6.2.13",
   "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/README.md

@@ -70,7 +70,7 @@ The `jose` module supports importing, exporting, and generating keys and secrets
 
 ### JSON Web Signature (JWS)
 
-The `jose` module supports signing and verification of JWS messages with arbitrary payloads in Compact, Flattened JSON, and General JSON serialization syntaxes.
+The `jose` module supports digital signature and MAC computation and validation over arbitrary JWS Payloads using the JWS Compact Serialization and the flattened and general JWS JSON Serialization syntaxes ([RFC 7515, Section 7](https://www.rfc-editor.org/info/rfc7515/#section-7)).
 
 - Signing - [Compact](docs/jws/compact/sign/classes/CompactSign.md), [Flattened JSON](docs/jws/flattened/sign/classes/FlattenedSign.md), [General JSON](docs/jws/general/sign/classes/GeneralSign.md)
 - Verification - [Compact](docs/jws/compact/verify/functions/compactVerify.md), [Flattened JSON](docs/jws/flattened/verify/functions/flattenedVerify.md), [General JSON](docs/jws/general/verify/functions/generalVerify.md)
@@ -81,7 +81,7 @@ The `jose` module supports signing and verification of JWS messages with arbitra
 
 ### JSON Web Encryption (JWE)
 
-The `jose` module supports encryption and decryption of JWE messages with arbitrary plaintext in Compact, Flattened JSON, and General JSON serialization syntaxes.
+The `jose` module supports encryption and authenticated decryption of arbitrary plaintext using the JWE Compact Serialization and the flattened and general JWE JSON Serialization syntaxes ([RFC 7516, Section 7](https://www.rfc-editor.org/info/rfc7516/#section-7)).
 
 - Encryption - [Compact](docs/jwe/compact/encrypt/classes/CompactEncrypt.md), [Flattened JSON](docs/jwe/flattened/encrypt/classes/FlattenedEncrypt.md), [General JSON](docs/jwe/general/encrypt/classes/GeneralEncrypt.md)
 - Decryption - [Compact](docs/jwe/compact/decrypt/functions/compactDecrypt.md), [Flattened JSON](docs/jwe/flattened/decrypt/functions/flattenedDecrypt.md), [General JSON](docs/jwe/general/decrypt/functions/generalDecrypt.md)

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

@@ -3,21 +3,22 @@ import type * as t from '../../types.d.ts';
 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.
+ * Authenticates and decrypts a JWE Compact Serialization.
  *
  * @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 with a dynamically resolved key, included in the result.
+ * Authenticates and decrypts a JWE Compact Serialization with a dynamically resolved key, included
+ * in the result.
  *
  * @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>>;
 /**
- * Decrypts a Compact JWE with a key or key resolver. The result includes `key` only when a resolver
- * is used.
+ * Authenticates and decrypts a JWE Compact Serialization with a key or key resolver. The result
+ * includes `key` only when a resolver is used.
  *
  * @param key Private key or shared secret, or a function resolving one.
  */

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

@@ -1,9 +1,9 @@
 import type * as t from '../../types.d.ts';
-/** Builds and encrypts Compact JWE strings. */
+/** Produces JWE Compact Serialization using authenticated encryption. */
 export declare class CompactEncrypt {
     #private;
     /**
-     * Creates a Compact JWE encryptor.
+     * Creates an encryptor for JWE Compact Serialization.
      *
      * @param plaintext Binary representation of the plaintext to encrypt.
      */
@@ -26,12 +26,12 @@ export declare class CompactEncrypt {
     setProtectedHeader(protectedHeader: t.CompactJWEHeaderParameters): this;
     /**
      * Sets key management inputs such as ECDH-ES "apu"/"apv" or PBES2 "p2c". Use this method instead
-     * of header setters; the resulting parameters are added to the JOSE header. May only be called
+     * of header setters; the resulting parameters are added to the JOSE Header. May only be called
      * once.
      */
     setKeyManagementParameters(parameters: t.JWEKeyManagementHeaderParameters): this;
     /**
-     * Encrypts the plaintext as a Compact JWE.
+     * Encrypts the plaintext and returns the JWE Compact Serialization.
      *
      * @param key Public key or shared secret. See
      *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.

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

@@ -3,21 +3,22 @@ import type * as t from '../../types.d.ts';
 export interface FlattenedDecryptGetKey<KeyType extends t.CryptoKey | Uint8Array = t.CryptoKey | Uint8Array> extends t.GetKeyFunction<t.JWEHeaderParameters | undefined, t.FlattenedJWE, KeyType | t.KeyObject | t.JWK> {
 }
 /**
- * Decrypts a Flattened JWE.
+ * Authenticates and decrypts a flattened JWE JSON Serialization.
  *
  * @param key Private key or shared secret. See
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  */
 export declare function flattenedDecrypt(jwe: t.FlattenedJWE, key: t.KeyInput, options?: t.DecryptOptions): Promise<t.FlattenedDecryptResult>;
 /**
- * Decrypts a Flattened JWE with a dynamically resolved key, included in the result.
+ * Authenticates and decrypts a flattened JWE JSON Serialization with a dynamically resolved key,
+ * included in the result.
  *
  * @param getKey Resolves a private key or shared secret from unverified token data.
  */
 export declare function flattenedDecrypt<KeyType extends t.CryptoKey | Uint8Array = t.CryptoKey | Uint8Array>(jwe: t.FlattenedJWE, getKey: FlattenedDecryptGetKey<KeyType>, options?: t.DecryptOptions): Promise<t.FlattenedDecryptResult & t.ResolvedKey<KeyType>>;
 /**
- * Decrypts a Flattened JWE with a key or key resolver. The result includes `key` only when a
- * resolver is used.
+ * Authenticates and decrypts a flattened JWE JSON Serialization with a key or key resolver. The
+ * result includes `key` only when a resolver is used.
  *
  * @param key Private key or shared secret, or a function resolving one.
  */

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/types/jwe/flattened/encrypt.d.ts

@@ -1,16 +1,16 @@
 import type * as t from '../../types.d.ts';
-/** Builds and encrypts Flattened JWE objects. */
+/** Produces flattened JWE JSON Serialization using authenticated encryption. */
 export declare class FlattenedEncrypt {
     #private;
     /**
-     * Creates a Flattened JWE encryptor.
+     * Creates an encryptor for flattened JWE JSON Serialization.
      *
      * @param plaintext Binary representation of the plaintext to encrypt.
      */
     constructor(plaintext: Uint8Array);
     /**
      * Sets key management inputs such as ECDH-ES "apu"/"apv" or PBES2 "p2c". Use this method instead
-     * of header setters; the resulting parameters are added to the JOSE header. May only be called
+     * of header setters; the resulting parameters are added to the JOSE Header. May only be called
      * once.
      */
     setKeyManagementParameters(parameters: t.JWEKeyManagementHeaderParameters): this;
@@ -20,7 +20,7 @@ export declare class FlattenedEncrypt {
     setSharedUnprotectedHeader(sharedUnprotectedHeader: t.JWEHeaderParameters): this;
     /** Sets the JWE Per-Recipient Unprotected Header. May only be called once. */
     setUnprotectedHeader(unprotectedHeader: t.JWEHeaderParameters): this;
-    /** Sets additional data to authenticate without encrypting it. */
+    /** Sets the JWE AAD, which is integrity protected but not encrypted. */
     setAdditionalAuthenticatedData(aad: Uint8Array): this;
     /**
      * Sets a content encryption key instead of generating a random one for the JWE "enc" algorithm.
@@ -37,7 +37,7 @@ export declare class FlattenedEncrypt {
      */
     setInitializationVector(iv: Uint8Array): this;
     /**
-     * Encrypts the plaintext as a Flattened JWE.
+     * Encrypts the plaintext and returns the flattened JWE JSON Serialization.
      *
      * @param key Public key or shared secret. See
      *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.

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

@@ -3,7 +3,7 @@ import type * as t from '../../types.d.ts';
 export interface GeneralDecryptGetKey<KeyType extends t.CryptoKey | Uint8Array = t.CryptoKey | Uint8Array> extends t.GetKeyFunction<t.JWEHeaderParameters | undefined, t.FlattenedJWE, KeyType | t.KeyObject | t.JWK> {
 }
 /**
- * Decrypts a General JWE.
+ * Authenticates and decrypts a general JWE JSON Serialization.
  *
  * > Note: Returns plaintext and headers from the first recipient that decrypts successfully. Other
  * > recipients may be inspected to enforce serialization rules, but their headers are not included in
@@ -14,14 +14,15 @@ export interface GeneralDecryptGetKey<KeyType extends t.CryptoKey | Uint8Array =
  */
 export declare function generalDecrypt(jwe: t.GeneralJWE, key: t.KeyInput, options?: t.DecryptOptions): Promise<t.GeneralDecryptResult>;
 /**
- * Decrypts a General JWE with a dynamically resolved key, included in the result.
+ * Authenticates and decrypts a general JWE JSON Serialization with a dynamically resolved key,
+ * included in the result.
  *
  * @param getKey Resolves a private key or shared secret from unverified token data.
  */
 export declare function generalDecrypt<KeyType extends t.CryptoKey | Uint8Array = t.CryptoKey | Uint8Array>(jwe: t.GeneralJWE, getKey: GeneralDecryptGetKey<KeyType>, options?: t.DecryptOptions): Promise<t.GeneralDecryptResult & t.ResolvedKey<KeyType>>;
 /**
- * Decrypts a General JWE with a key or key resolver. The result includes `key` only when a resolver
- * is used.
+ * Authenticates and decrypts a general JWE JSON Serialization with a key or key resolver. The
+ * result includes `key` only when a resolver is used.
  *
  * @param key Private key or shared secret, or a function resolving one.
  */

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/types/jwe/general/encrypt.d.ts

@@ -5,7 +5,7 @@ export interface Recipient {
     setUnprotectedHeader(unprotectedHeader: t.JWEHeaderParameters): Recipient;
     /**
      * Sets key management inputs such as ECDH-ES "apu"/"apv" or PBES2 "p2c". Use this method instead
-     * of header setters; the resulting parameters are added to the JOSE header. May only be called
+     * of header setters; the resulting parameters are added to the JOSE Header. May only be called
      * once.
      */
     setKeyManagementParameters(parameters: t.JWEKeyManagementHeaderParameters): Recipient;
@@ -24,11 +24,11 @@ export interface Recipient {
     /** Returns the enclosing {@link GeneralEncrypt} instance. */
     done(): GeneralEncrypt;
 }
-/** Builds and encrypts General JWE objects. */
+/** Produces general JWE JSON Serialization using authenticated encryption. */
 export declare class GeneralEncrypt {
     #private;
     /**
-     * Creates a General JWE encryptor.
+     * Creates an encryptor for general JWE JSON Serialization.
      *
      * @param plaintext Binary representation of the plaintext to encrypt.
      */
@@ -44,8 +44,8 @@ export declare class GeneralEncrypt {
     setProtectedHeader(protectedHeader: t.JWEHeaderParameters): this;
     /** Sets the JWE Shared Unprotected Header. May only be called once. */
     setSharedUnprotectedHeader(sharedUnprotectedHeader: t.JWEHeaderParameters): this;
-    /** Sets additional data to authenticate without encrypting it. */
+    /** Sets the JWE AAD, which is integrity protected but not encrypted. */
     setAdditionalAuthenticatedData(aad: Uint8Array): this;
-    /** Encrypts the plaintext as a General JWE. */
+    /** Encrypts the plaintext and returns the general JWE JSON Serialization. */
     encrypt(): Promise<t.GeneralJWE>;
 }

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/types/jws/compact/sign.d.ts

@@ -1,17 +1,18 @@
 import type * as t from '../../types.d.ts';
-/** Builds and signs Compact JWS strings. */
+/** Produces JWS Compact Serialization using a digital signature or MAC. */
 export declare class CompactSign {
     #private;
     /**
-     * Creates a Compact JWS signer.
+     * Creates a signer for JWS Compact Serialization.
      *
-     * @param payload Binary representation of the payload to sign.
+     * @param payload JWS Payload bytes to sign or MAC.
      */
     constructor(payload: Uint8Array);
     /** Sets the JWS Protected Header. May only be called once. */
     setProtectedHeader(protectedHeader: t.CompactJWSHeaderParameters): this;
     /**
-     * Signs the payload as a Compact JWS.
+     * Computes the JWS Signature (digital signature or MAC) and returns the JWS Compact
+     * Serialization.
      *
      * @param key Private key or shared secret. See
      *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.