@zuplo/cli 7.6.8 → 7.6.10

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

@@ -1,134 +1,90 @@
-import { concat, uint64be } from './buffer_utils.js';
-import { checkCryptoKey } from './crypto_key.js';
-import { invalidKeyInput } from './invalid_key_input.js';
-import { JWEDecryptionFailed, JWEInvalid } from '../util/errors.js';
-import { isCryptoKey } from './is_key_like.js';
-export const generateCek = (enc) => crypto.getRandomValues(new Uint8Array(enc.cekBits >> 3));
+import { concat, uint64be } from "./buffer_utils.js";
+import { rawKey, invalidKeyInput, isCryptoKey } from "./key.js";
+import { JWEDecryptionFailed, JWEInvalid } from "../util/errors.js";
+const generateCek = (enc) => crypto.getRandomValues(new Uint8Array(enc.cekBits >> 3));
 function checkCekLength(cek, expected) {
-    const actual = cek.byteLength << 3;
-    if (actual !== expected) {
-        throw new JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
-    }
+  const actual = cek.byteLength << 3;
+  if (actual !== expected)
+    throw new JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
 }
-export const generateIv = (enc) => crypto.getRandomValues(new Uint8Array(enc.ivBits >> 3));
-export function checkIvLength(enc, iv) {
-    if (iv.length << 3 !== enc.ivBits) {
-        throw new JWEInvalid('Invalid Initialization Vector length');
-    }
+const generateIv = (enc) => crypto.getRandomValues(new Uint8Array(enc.ivBits >> 3));
+function checkIvLength(enc, iv) {
+  if (iv.length << 3 !== enc.ivBits)
+    throw new JWEInvalid("Invalid Initialization Vector length");
 }
 async function cbcKeySetup(enc, cek, usage) {
-    if (!(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
-    }
-    const keySize = enc.cekBits >> 1;
-    const encKey = await crypto.subtle.importKey('raw', cek.subarray(keySize >> 3), 'AES-CBC', false, [usage]);
-    const macKey = await crypto.subtle.importKey('raw', cek.subarray(0, keySize >> 3), {
-        hash: `SHA-${keySize << 1}`,
-        name: 'HMAC',
-    }, false, ['sign']);
-    return [encKey, macKey, keySize];
+  if (!(cek instanceof Uint8Array))
+    throw new TypeError(invalidKeyInput(cek, "Uint8Array"));
+  const keySize = enc.cekBits >> 1, encKey = await crypto.subtle.importKey("raw", cek.subarray(keySize >> 3), "AES-CBC", !1, [usage]), macKey = await crypto.subtle.importKey("raw", cek.subarray(0, keySize >> 3), {
+    hash: `SHA-${keySize << 1}`,
+    name: "HMAC"
+  }, !1, ["sign"]);
+  return [encKey, macKey, keySize];
 }
 async function cbcHmacTag(macKey, macData, keySize) {
-    return new Uint8Array((await crypto.subtle.sign('HMAC', macKey, macData)).slice(0, keySize >> 3));
+  return new Uint8Array((await crypto.subtle.sign("HMAC", macKey, macData)).slice(0, keySize >> 3));
 }
 async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
-    const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, 'encrypt');
-    const ciphertext = new Uint8Array(await crypto.subtle.encrypt({
-        iv: iv,
-        name: 'AES-CBC',
-    }, encKey, plaintext));
-    const macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8));
-    const tag = await cbcHmacTag(macKey, macData, keySize);
-    return { ciphertext, tag, iv };
+  const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, "encrypt"), ciphertext = new Uint8Array(await crypto.subtle.encrypt({
+    iv,
+    name: "AES-CBC"
+  }, encKey, plaintext)), macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8)), tag = await cbcHmacTag(macKey, macData, keySize);
+  return { ciphertext, tag, iv };
 }
 async function timingSafeEqual(a, b) {
-    const algorithm = { name: 'HMAC', hash: 'SHA-256' };
-    const key = (await crypto.subtle.generateKey(algorithm, false, ['sign', 'verify']));
-    const aHmac = await crypto.subtle.sign(algorithm, key, a);
-    return crypto.subtle.verify(algorithm, key, aHmac, b);
+  const algorithm = { name: "HMAC", hash: "SHA-256" }, key = await crypto.subtle.generateKey(algorithm, !1, ["sign", "verify"]), aHmac = await crypto.subtle.sign(algorithm, key, a);
+  return crypto.subtle.verify(algorithm, key, aHmac, b);
 }
 async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
-    const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, 'decrypt');
-    const macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8));
-    const expectedTag = await cbcHmacTag(macKey, macData, keySize);
-    try {
-        if (await timingSafeEqual(tag, expectedTag)) {
-            return new Uint8Array(await crypto.subtle.decrypt({ iv: iv, name: 'AES-CBC' }, encKey, ciphertext));
-        }
-    }
-    catch {
-    }
-    throw new JWEDecryptionFailed();
-}
-async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
-    const encKey = cek instanceof Uint8Array
-        ? await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, [
-            'encrypt',
-        ])
-        : (checkCryptoKey(cek, enc.subtle, 'encrypt'), cek);
-    const encrypted = new Uint8Array(await crypto.subtle.encrypt({
-        additionalData: aad,
-        iv: iv,
-        name: 'AES-GCM',
-        tagLength: 128,
-    }, encKey, plaintext));
-    const tag = encrypted.slice(-16);
-    const ciphertext = encrypted.slice(0, -16);
-    return { ciphertext, tag, iv };
+  const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, "decrypt"), macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8)), expectedTag = await cbcHmacTag(macKey, macData, keySize);
+  try {
+    if (await timingSafeEqual(tag, expectedTag))
+      return new Uint8Array(await crypto.subtle.decrypt({ iv, name: "AES-CBC" }, encKey, ciphertext));
+  } catch {
+  }
+  throw new JWEDecryptionFailed();
 }
-async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
-    const encKey = cek instanceof Uint8Array
-        ? await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, [
-            'decrypt',
-        ])
-        : (checkCryptoKey(cek, enc.subtle, 'decrypt'), cek);
-    try {
-        return new Uint8Array(await crypto.subtle.decrypt({
-            additionalData: aad,
-            iv: iv,
-            name: 'AES-GCM',
-            tagLength: 128,
-        }, encKey, concat(ciphertext, tag)));
-    }
-    catch {
-        throw new JWEDecryptionFailed();
-    }
+async function encrypt(enc, plaintext, cek, iv, aad) {
+  if (!isCryptoKey(cek) && !(cek instanceof Uint8Array))
+    throw new TypeError(invalidKeyInput(cek, "CryptoKey", "KeyObject", "Uint8Array", "JSON Web Key"));
+  if (iv ? checkIvLength(enc, iv) : iv = generateIv(enc), cek instanceof Uint8Array && checkCekLength(cek, enc.cekBits), enc.cbc)
+    return cbcEncrypt(enc, plaintext, cek, iv, aad);
+  const encKey = await rawKey(cek, enc.subtle, "encrypt"), encrypted = new Uint8Array(await crypto.subtle.encrypt({
+    additionalData: aad,
+    iv,
+    name: "AES-GCM",
+    tagLength: 128
+  }, encKey, plaintext));
+  return { ciphertext: encrypted.subarray(0, -16), tag: encrypted.subarray(-16), iv };
 }
-export async function encrypt(enc, plaintext, cek, iv, aad) {
-    if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'KeyObject', 'Uint8Array', 'JSON Web Key'));
-    }
-    if (iv) {
-        checkIvLength(enc, iv);
-    }
-    else {
-        iv = generateIv(enc);
-    }
-    if (cek instanceof Uint8Array) {
-        checkCekLength(cek, enc.cekBits);
-    }
-    return enc.cbc
-        ? cbcEncrypt(enc, plaintext, cek, iv, aad)
-        : gcmEncrypt(enc, plaintext, cek, iv, aad);
-}
-export async function decrypt(enc, cek, ciphertext, iv, tag, aad) {
-    if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'KeyObject', 'Uint8Array', 'JSON Web Key'));
-    }
-    if (!iv) {
-        throw new JWEInvalid('JWE Initialization Vector missing');
-    }
-    if (!tag) {
-        throw new JWEInvalid('JWE Authentication Tag missing');
-    }
-    if (!enc.cbc && tag.length !== 16) {
-        throw new JWEInvalid('Invalid Authentication Tag length');
-    }
-    checkIvLength(enc, iv);
-    if (cek instanceof Uint8Array) {
-        checkCekLength(cek, enc.cekBits);
-    }
-    return enc.cbc
-        ? cbcDecrypt(enc, cek, ciphertext, iv, tag, aad)
-        : gcmDecrypt(enc, cek, ciphertext, iv, tag, aad);
+async function decrypt(enc, cek, ciphertext, iv, tag, aad) {
+  if (!isCryptoKey(cek) && !(cek instanceof Uint8Array))
+    throw new TypeError(invalidKeyInput(cek, "CryptoKey", "KeyObject", "Uint8Array", "JSON Web Key"));
+  if (!iv)
+    throw new JWEInvalid("JWE Initialization Vector missing");
+  if (!tag)
+    throw new JWEInvalid("JWE Authentication Tag missing");
+  if (!enc.cbc && tag.length !== 16)
+    throw new JWEInvalid("Invalid Authentication Tag length");
+  if (checkIvLength(enc, iv), cek instanceof Uint8Array && checkCekLength(cek, enc.cekBits), enc.cbc)
+    return cbcDecrypt(enc, cek, ciphertext, iv, tag, aad);
+  const encKey = await rawKey(cek, enc.subtle, "decrypt");
+  try {
+    return new Uint8Array(await crypto.subtle.decrypt({
+      additionalData: aad,
+      iv,
+      name: "AES-GCM",
+      tagLength: 128
+    }, encKey, concat(ciphertext, tag)));
+  } catch {
+    throw new JWEDecryptionFailed();
+  }
 }
+export {
+  checkCekLength,
+  checkIvLength,
+  decrypt,
+  encrypt,
+  generateCek,
+  generateIv
+};

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

@@ -1,52 +1,40 @@
-import { JOSENotSupported, JWEInvalid } from '../util/errors.js';
-import { concat } from './buffer_utils.js';
-export function validateZip(joseHeader, protectedHeader) {
-    if (joseHeader.zip !== undefined && joseHeader.zip !== 'DEF') {
-        throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
-    }
-    if (joseHeader.zip !== undefined && !protectedHeader?.zip) {
-        throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
-    }
+import { JOSENotSupported, JWEInvalid } from "../util/errors.js";
+import { concat } from "./buffer_utils.js";
+function validateZip(joseHeader, protectedHeader) {
+  if (joseHeader.zip !== void 0 && joseHeader.zip !== "DEF")
+    throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
+  if (joseHeader.zip !== void 0 && !protectedHeader?.zip)
+    throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
 }
 function supported(name) {
-    if (typeof globalThis[name] === 'undefined') {
-        throw new JOSENotSupported(`JWE "zip" (Compression Algorithm) Header Parameter requires the ${name} API.`);
-    }
+  if (typeof globalThis[name] > "u")
+    throw new JOSENotSupported(`JWE "zip" (Compression Algorithm) Header Parameter requires the ${name} API.`);
 }
-export async function compress(input) {
-    supported('CompressionStream');
-    const cs = new CompressionStream('deflate-raw');
-    const writer = cs.writable.getWriter();
-    writer.write(input).catch(() => { });
-    writer.close().catch(() => { });
-    const chunks = [];
-    const reader = cs.readable.getReader();
-    for (;;) {
-        const { value, done } = await reader.read();
-        if (done)
-            break;
-        chunks.push(value);
-    }
-    return concat(...chunks);
+async function transform(stream, input, maxLength = 1 / 0) {
+  const writer = stream.writable.getWriter();
+  writer.write(input).catch(() => {
+  }), writer.close().catch(() => {
+  });
+  const chunks = [];
+  let length = 0;
+  const reader = stream.readable.getReader();
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done)
+      break;
+    if (chunks.push(value), length += value.byteLength, maxLength !== 1 / 0 && length > maxLength)
+      throw new JWEInvalid("Decompressed plaintext exceeded the configured limit");
+  }
+  return concat(...chunks);
 }
-export async function decompress(input, maxLength) {
-    supported('DecompressionStream');
-    const ds = new DecompressionStream('deflate-raw');
-    const writer = ds.writable.getWriter();
-    writer.write(input).catch(() => { });
-    writer.close().catch(() => { });
-    const chunks = [];
-    let length = 0;
-    const reader = ds.readable.getReader();
-    for (;;) {
-        const { value, done } = await reader.read();
-        if (done)
-            break;
-        chunks.push(value);
-        length += value.byteLength;
-        if (maxLength !== Infinity && length > maxLength) {
-            throw new JWEInvalid('Decompressed plaintext exceeded the configured limit');
-        }
-    }
-    return concat(...chunks);
+async function compress(input) {
+  return supported("CompressionStream"), transform(new CompressionStream("deflate-raw"), input);
 }
+async function decompress(input, maxLength) {
+  return supported("DecompressionStream"), transform(new DecompressionStream("deflate-raw"), input, maxLength);
+}
+export {
+  compress,
+  decompress,
+  validateZip
+};

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

@@ -1,107 +1,116 @@
-import { JOSENotSupported } from '../util/errors.js';
-import { table } from './key_descriptor.js';
+import { JOSENotSupported } from "../util/errors.js";
+import { table } from "./key_descriptor.js";
 const wrap = [
-    ['encrypt', 'wrapKey'],
-    ['decrypt', 'unwrapKey'],
-];
-const derive = [[], ['deriveBits']];
-const none = [[], []];
+  ["encrypt", "wrapKey"],
+  ["decrypt", "unwrapKey"]
+], derive = [[], ["deriveBits"]], none = [[], []];
 function rsaes(bits) {
-    return {
-        kty: ['RSA'],
-        subtle: { name: 'RSA-OAEP', hash: `SHA-${bits}` },
-        usages: wrap,
-        ops: ['wrapKey', 'unwrapKey'],
-    };
+  return {
+    kty: ["RSA"],
+    mode: "key-encryption",
+    subtle: { name: "RSA-OAEP", hash: `SHA-${bits}` },
+    usages: wrap,
+    ops: ["wrapKey", "unwrapKey"]
+  };
 }
-function ecdh() {
-    return {
-        kty: ['EC', 'OKP'],
-        subtle: { name: 'ECDH' },
-        resolve: ({ kty, crv, asymmetricKeyType }) => {
-            if (crv === 'X25519' || asymmetricKeyType === 'x25519') {
-                return { name: 'X25519' };
-            }
-            if (kty === 'OKP') {
-                throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-            }
-            return { name: 'ECDH', namedCurve: crv };
-        },
-        usages: derive,
-        ops: [undefined, 'deriveBits'],
-    };
+function ecdh(mode) {
+  return {
+    kty: ["EC", "OKP"],
+    mode,
+    subtle: { name: "ECDH" },
+    resolve: ({ kty, crv, asymmetricKeyType }) => {
+      if (crv === "X25519" || asymmetricKeyType === "x25519")
+        return { name: "X25519" };
+      if (kty === "OKP")
+        throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+      return { name: "ECDH", namedCurve: crv };
+    },
+    usages: derive,
+    ops: [void 0, "deriveBits"]
+  };
 }
-function aeskw(bits, gcm = false) {
-    return {
-        kty: ['oct'],
-        secret: true,
-        subtle: { name: gcm ? 'AES-GCM' : 'AES-KW', length: bits },
-        usages: none,
-        ops: gcm ? ['encrypt', 'decrypt'] : ['wrapKey', 'unwrapKey'],
-    };
+function aeskw(bits, gcm = !1) {
+  return {
+    kty: ["oct"],
+    mode: "key-wrapping",
+    secret: !0,
+    subtle: { name: gcm ? "AES-GCM" : "AES-KW", length: bits },
+    usages: none,
+    ops: gcm ? ["encrypt", "decrypt"] : ["wrapKey", "unwrapKey"]
+  };
 }
 function pbes2() {
-    return {
-        kty: ['oct'],
-        secret: true,
-        subtle: { name: 'PBKDF2' },
-        usages: none,
-        ops: ['deriveBits', 'deriveBits'],
-    };
+  return {
+    kty: ["oct"],
+    mode: "key-wrapping",
+    secret: !0,
+    subtle: { name: "PBKDF2" },
+    usages: none,
+    ops: ["deriveBits", "deriveBits"]
+  };
 }
-export const JWE = table({
-    dir: {
-        kty: ['oct'],
-        secret: true,
-        subtle: { name: 'AES-GCM' },
-        usages: none,
-        ops: ['encrypt', 'decrypt'],
-    },
-    'RSA-OAEP': rsaes(1),
-    'RSA-OAEP-256': rsaes(256),
-    'RSA-OAEP-384': rsaes(384),
-    'RSA-OAEP-512': rsaes(512),
-    'ECDH-ES': ecdh(),
-    'ECDH-ES+A128KW': ecdh(),
-    'ECDH-ES+A192KW': ecdh(),
-    'ECDH-ES+A256KW': ecdh(),
-    A128KW: aeskw(128),
-    A192KW: aeskw(192),
-    A256KW: aeskw(256),
-    A128GCMKW: aeskw(128, true),
-    A192GCMKW: aeskw(192, true),
-    A256GCMKW: aeskw(256, true),
-    'PBES2-HS256+A128KW': pbes2(),
-    'PBES2-HS384+A192KW': pbes2(),
-    'PBES2-HS512+A256KW': pbes2(),
-});
-const contentOps = ['encrypt', 'decrypt'];
-function contentEncryption(bits, cbc = false) {
-    return {
-        kty: ['oct'],
-        secret: true,
-        subtle: { name: cbc ? 'AES-CBC' : 'AES-GCM', length: bits },
-        usages: none,
-        ops: contentOps,
-        cekBits: bits,
-        ivBits: cbc ? 128 : 96,
-        cbc,
-    };
+const JWE = table({
+  dir: {
+    kty: ["oct"],
+    mode: "direct-encryption",
+    secret: !0,
+    subtle: { name: "AES-GCM" },
+    usages: none,
+    ops: ["encrypt", "decrypt"]
+  },
+  "RSA-OAEP": rsaes(1),
+  "RSA-OAEP-256": rsaes(256),
+  "RSA-OAEP-384": rsaes(384),
+  "RSA-OAEP-512": rsaes(512),
+  "ECDH-ES": ecdh("direct-key-agreement"),
+  "ECDH-ES+A128KW": ecdh("key-agreement-with-key-wrapping"),
+  "ECDH-ES+A192KW": ecdh("key-agreement-with-key-wrapping"),
+  "ECDH-ES+A256KW": ecdh("key-agreement-with-key-wrapping"),
+  A128KW: aeskw(128),
+  A192KW: aeskw(192),
+  A256KW: aeskw(256),
+  A128GCMKW: aeskw(128, !0),
+  A192GCMKW: aeskw(192, !0),
+  A256GCMKW: aeskw(256, !0),
+  "PBES2-HS256+A128KW": pbes2(),
+  "PBES2-HS384+A192KW": pbes2(),
+  "PBES2-HS512+A256KW": pbes2()
+}), contentOps = ["encrypt", "decrypt"];
+function contentEncryption(bits, cbc = !1) {
+  return {
+    kty: ["oct"],
+    secret: !0,
+    subtle: { name: cbc ? "AES-CBC" : "AES-GCM", length: bits },
+    usages: none,
+    ops: contentOps,
+    cekBits: bits,
+    ivBits: cbc ? 128 : 96,
+    cbc
+  };
 }
 const ENC = table({
-    A128GCM: contentEncryption(128),
-    A192GCM: contentEncryption(192),
-    A256GCM: contentEncryption(256),
-    'A128CBC-HS256': contentEncryption(256, true),
-    'A192CBC-HS384': contentEncryption(384, true),
-    'A256CBC-HS512': contentEncryption(512, true),
+  A128GCM: contentEncryption(128),
+  A192GCM: contentEncryption(192),
+  A256GCM: contentEncryption(256),
+  "A128CBC-HS256": contentEncryption(256, !0),
+  "A192CBC-HS384": contentEncryption(384, !0),
+  "A256CBC-HS512": contentEncryption(512, !0)
 });
 function unsupported(parameter, name) {
-    throw new JOSENotSupported(`Invalid or unsupported "${parameter}" (JWE ${name}) header value`);
+  throw new JOSENotSupported(`Invalid or unsupported "${parameter}" (JWE ${name}) header value`);
+}
+function jweAlgorithm(alg) {
+  return (typeof alg == "string" ? JWE[alg] : void 0) ?? unsupported("alg", "Algorithm");
 }
-export function jweAlgorithm(alg) {
-    return (typeof alg === 'string' ? JWE[alg] : undefined) ?? unsupported('alg', 'Algorithm');
+function isJWECEKTransport(algorithm) {
+  return algorithm.mode === "key-wrapping" || algorithm.mode === "key-encryption" || algorithm.mode === "key-agreement-with-key-wrapping";
 }
-export function jweEncryption(enc) {
-    return ((typeof enc === 'string' ? ENC[enc] : undefined) ?? unsupported('enc', 'Encryption Algorithm'));
+function jweEncryption(enc) {
+  return (typeof enc == "string" ? ENC[enc] : void 0) ?? unsupported("enc", "Encryption Algorithm");
 }
+export {
+  JWE,
+  isJWECEKTransport,
+  jweAlgorithm,
+  jweEncryption
+};