@zuplo/cli 7.6.8 → 7.6.10

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/base64.js

@@ -1,22 +0,0 @@
-export function encodeBase64(input) {
-    if (Uint8Array.prototype.toBase64) {
-        return input.toBase64();
-    }
-    const CHUNK_SIZE = 0x8000;
-    const arr = [];
-    for (let i = 0; i < input.length; i += CHUNK_SIZE) {
-        arr.push(String.fromCharCode.apply(null, input.subarray(i, i + CHUNK_SIZE)));
-    }
-    return btoa(arr.join(''));
-}
-export function decodeBase64(encoded) {
-    if (Uint8Array.fromBase64) {
-        return Uint8Array.fromBase64(encoded);
-    }
-    const binary = atob(encoded);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-        bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes;
-}

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/crypto_key.js

@@ -1,28 +0,0 @@
-const unusable = (name, prop = 'algorithm.name') => new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
-export function checkUsage(key, usage) {
-    if (usage && !key.usages.includes(usage)) {
-        throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`);
-    }
-}
-export 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`);
-    }
-}
-export 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 !== undefined && algorithm.length !== expected.length) {
-        throw unusable(expected.length, 'algorithm.length');
-    }
-    checkUsage(key, usage);
-}

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/helpers.js

@@ -1,42 +0,0 @@
-import { decode } from '../util/base64url.js';
-import { encode, strictDecoder } from './buffer_utils.js';
-import { isObject } from './type_checks.js';
-export const unprotected = Symbol();
-export function assertNotSet(value, name) {
-    if (value !== undefined) {
-        throw new TypeError(`${name} can only be called once`);
-    }
-}
-export function decodeBase64url(value, label, ErrorClass) {
-    try {
-        return decode(value);
-    }
-    catch {
-        throw new ErrorClass(`Failed to base64url decode the ${label}`);
-    }
-}
-export function encodeBase64url(value, label, ErrorClass) {
-    try {
-        return encode(value);
-    }
-    catch {
-        throw new ErrorClass(`The ${label} is not a valid base64url string`);
-    }
-}
-export async function digest(algorithm, data) {
-    const subtleDigest = `SHA-${algorithm.slice(-3)}`;
-    return new Uint8Array(await crypto.subtle.digest(subtleDigest, data));
-}
-export 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;
-}

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/invalid_key_input.js

@@ -1,26 +0,0 @@
-function message(msg, actual, ...types) {
-    if (types.length > 2) {
-        const last = types.pop();
-        msg += `one of type ${types.join(', ')}, or ${last}.`;
-    }
-    else if (types.length === 2) {
-        msg += `one of type ${types[0]} or ${types[1]}.`;
-    }
-    else {
-        msg += `of type ${types[0]}.`;
-    }
-    if (actual == null) {
-        msg += ` Received ${actual}`;
-    }
-    else if (typeof actual === 'function' && actual.name) {
-        msg += ` Received function ${actual.name}`;
-    }
-    else if (typeof actual === 'object' && actual != null) {
-        if (actual.constructor?.name) {
-            msg += ` Received an instance of ${actual.constructor.name}`;
-        }
-    }
-    return msg;
-}
-export const invalidKeyInput = (actual, ...types) => message('Key must be ', actual, ...types);
-export const withAlg = (alg, actual, ...types) => message(`Key for the ${alg} algorithm must be `, actual, ...types);

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/is_key_like.js

@@ -1,17 +0,0 @@
-export function assertCryptoKey(key) {
-    if (!isCryptoKey(key)) {
-        throw new Error('CryptoKey instance expected');
-    }
-}
-export const isCryptoKey = (key) => {
-    if (key?.[Symbol.toStringTag] === 'CryptoKey')
-        return true;
-    try {
-        return key instanceof CryptoKey;
-    }
-    catch {
-        return false;
-    }
-};
-export const isKeyObject = (key) => key?.[Symbol.toStringTag] === 'KeyObject';
-export const isKeyLike = (key) => isCryptoKey(key) || isKeyObject(key);

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/jwk_metadata.js

@@ -1,20 +0,0 @@
-export function snapshotJwk(jwk) {
-    return { __proto__: null, ...jwk };
-}
-export function normalizeJwk(jwk) {
-    const normalized = snapshotJwk(jwk);
-    if (normalized.ext !== undefined && typeof normalized.ext !== 'boolean') {
-        throw new TypeError('"ext" (Extractable) Parameter must be a boolean');
-    }
-    if (normalized.key_ops !== undefined) {
-        const value = normalized.key_ops;
-        const keyOps = Array.isArray(value) ? [...value] : undefined;
-        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;
-}

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/jwk_to_key.js

@@ -1,17 +0,0 @@
-import { JOSENotSupported } from '../util/errors.js';
-export async function jwkToKey(entry, jwk) {
-    if (jwk.kty === 'RSA' && 'oth' in jwk && jwk.oth !== undefined) {
-        throw new JOSENotSupported('RSA JWK "oth" (Other Primes Info) Parameter value is not supported');
-    }
-    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;
-    const isPrivate = !!(jwk.d || jwk.priv);
-    const keyData = { ...jwk };
-    if (keyData.kty !== 'AKP') {
-        delete keyData.alg;
-    }
-    delete keyData.use;
-    return crypto.subtle.importKey('jwk', keyData, algorithm, jwk.ext ?? !isPrivate, jwk.key_ops ?? entry.usages[isPrivate ? 1 : 0]);
-}

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/key_options.js

@@ -1,6 +0,0 @@
-export function validateExtractableOption(extractable) {
-    if (extractable !== undefined && typeof extractable !== 'boolean') {
-        throw new TypeError('"extractable" option must be a boolean');
-    }
-    return extractable;
-}

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/options.js

@@ -1,74 +0,0 @@
-import { JOSENotSupported, JWEInvalid, JWSInvalid } from '../util/errors.js';
-import { isObject } from './type_checks.js';
-export const JWS_RECOGNIZED = { __proto__: null, b64: true };
-export const JWE_RECOGNIZED = { __proto__: null };
-export function validateAlgorithms(option, algorithms) {
-    if (algorithms !== undefined &&
-        (!Array.isArray(algorithms) || algorithms.some((s) => typeof s !== 'string'))) {
-        throw new TypeError(`"${option}" option must be an array of strings`);
-    }
-    if (!algorithms) {
-        return undefined;
-    }
-    return new Set(algorithms);
-}
-export function validateCritDuplicates(Err, protectedHeader) {
-    const { crit } = protectedHeader ?? {};
-    if (Array.isArray(crit) && new Set(crit).size !== crit.length) {
-        throw new Err('"crit" (Critical) Header Parameter MUST NOT contain duplicate values');
-    }
-}
-export function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) {
-    if (joseHeader.crit !== undefined && protectedHeader?.crit === undefined) {
-        throw new Err('"crit" (Critical) Header Parameter MUST be integrity protected');
-    }
-    if (!protectedHeader || protectedHeader.crit === undefined) {
-        return [];
-    }
-    if (!Array.isArray(protectedHeader.crit) ||
-        protectedHeader.crit.length === 0 ||
-        protectedHeader.crit.some((input) => typeof input !== 'string' || input.length === 0)) {
-        throw new Err('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
-    }
-    const recognized = recognizedOption === undefined
-        ? recognizedDefault
-        : { __proto__: null, ...recognizedOption, ...recognizedDefault };
-    for (const parameter of protectedHeader.crit) {
-        if (!(parameter in recognized)) {
-            throw new JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`);
-        }
-        if (!Object.hasOwn(joseHeader, parameter) || joseHeader[parameter] === undefined) {
-            throw new Err(`Extension Header Parameter "${parameter}" is missing`);
-        }
-        if (recognized[parameter] &&
-            (!Object.hasOwn(protectedHeader, parameter) || protectedHeader[parameter] === undefined)) {
-            throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`);
-        }
-    }
-    return protectedHeader.crit;
-}
-export function validateB64(protectedHeader, extensions) {
-    if (extensions.includes('b64')) {
-        const b64 = protectedHeader.b64;
-        if (typeof b64 !== 'boolean') {
-            throw new JWSInvalid('The "b64" (base64url-encode payload) Header Parameter must be a boolean');
-        }
-        return b64;
-    }
-    return true;
-}
-export function serializeJoseHeader(Err, header) {
-    let serialized;
-    let parsed;
-    try {
-        serialized = JSON.stringify(header);
-        parsed = JSON.parse(serialized);
-    }
-    catch (cause) {
-        throw new Err('JOSE Header is not valid JSON', { cause });
-    }
-    if (!isObject(parsed)) {
-        throw new Err('JOSE Header is not a JSON object');
-    }
-    return [parsed, serialized];
-}

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/signing.js

@@ -1,26 +0,0 @@
-import { checkCryptoKey, checkModulusLength } from './crypto_key.js';
-async function getSigKey(entry, key, usage) {
-    if (key instanceof Uint8Array) {
-        return crypto.subtle.importKey('raw', key, entry.subtle, false, [
-            usage,
-        ]);
-    }
-    checkCryptoKey(key, entry.subtle, usage);
-    if (entry.minRsaBits)
-        checkModulusLength(entry.alg, key);
-    return key;
-}
-export async function sign(entry, key, data) {
-    const cryptoKey = await getSigKey(entry, key, 'sign');
-    const signature = await crypto.subtle.sign(entry.signing, cryptoKey, data);
-    return new Uint8Array(signature);
-}
-export async function verify(entry, key, signature, data) {
-    const cryptoKey = await getSigKey(entry, key, 'verify');
-    try {
-        return await crypto.subtle.verify(entry.signing, cryptoKey, signature, data);
-    }
-    catch {
-        return false;
-    }
-}

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/lib/type_checks.js

@@ -1,33 +0,0 @@
-export function assertUint8Array(input, label) {
-    if (!(input instanceof Uint8Array)) {
-        throw new TypeError(`${label} must be an instance of Uint8Array`);
-    }
-}
-export function isObject(input) {
-    if (typeof input !== 'object' ||
-        input === null ||
-        Object.prototype.toString.call(input) !== '[object Object]') {
-        return false;
-    }
-    const prototype = Object.getPrototypeOf(input);
-    return prototype === null || Object.getPrototypeOf(prototype) === null;
-}
-export function isJwkSet(input) {
-    return (isObject(input) &&
-        Array.isArray(input.keys) &&
-        Array.from(input.keys).every(isObject));
-}
-export function isDisjoint(...headers) {
-    const parameters = new Set();
-    for (const header of headers) {
-        if (!header)
-            continue;
-        for (const parameter of Object.keys(header)) {
-            if (parameters.has(parameter)) {
-                return false;
-            }
-            parameters.add(parameter);
-        }
-    }
-    return true;
-}