@zuplo/cli 7.6.8 → 7.6.9

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/jwks/remote.js

@@ -1,149 +1,101 @@
-import { JOSEError, JWKSNoMatchingKey, JWKSTimeout } from '../util/errors.js';
-import { createLocalJWKSet } from './local.js';
-import { isJwkSet } from '../lib/type_checks.js';
+import { JOSEError, JWKSNoMatchingKey, JWKSTimeout } from "../util/errors.js";
+import { createLocalJWKSet } from "./local.js";
+import { isJwkSet } from "../lib/type_checks.js";
 function isCloudflareWorkers() {
-    return (typeof WebSocketPair !== 'undefined' ||
-        (typeof navigator !== 'undefined' && navigator.userAgent === 'Cloudflare-Workers') ||
-        (typeof EdgeRuntime !== 'undefined' && EdgeRuntime === 'vercel'));
+  return typeof WebSocketPair < "u" || typeof navigator < "u" && navigator.userAgent === "Cloudflare-Workers" || typeof EdgeRuntime < "u" && EdgeRuntime === "vercel";
 }
 let USER_AGENT;
-if (typeof navigator === 'undefined' || !navigator.userAgent?.startsWith?.('Mozilla/5.0 ')) {
-    const NAME = 'jose';
-    const VERSION = 'v6.2.10';
-    USER_AGENT = `${NAME}/${VERSION}`;
-}
-export const customFetch = Symbol();
+(typeof navigator > "u" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) && (USER_AGENT = "jose/v6.2.11");
+const customFetch = /* @__PURE__ */ Symbol();
 async function fetchJwks(url, headers, signal, fetchImpl = fetch) {
-    const response = await fetchImpl(url, {
-        method: 'GET',
-        signal,
-        redirect: 'manual',
-        headers,
-    }).catch((err) => {
-        if (err.name === 'TimeoutError') {
-            throw new JWKSTimeout();
-        }
-        throw err;
-    });
-    if (response.status !== 200) {
-        throw new JOSEError('Expected 200 OK from the JSON Web Key Set HTTP response');
-    }
-    try {
-        return await response.json();
-    }
-    catch {
-        throw new JOSEError('Failed to parse the JSON Web Key Set HTTP response as JSON');
-    }
+  const response = await fetchImpl(url, {
+    method: "GET",
+    signal,
+    redirect: "manual",
+    headers
+  }).catch((err) => {
+    throw err.name === "TimeoutError" ? new JWKSTimeout() : err;
+  });
+  if (response.status !== 200)
+    throw new JOSEError("Expected 200 OK from the JSON Web Key Set HTTP response");
+  try {
+    return await response.json();
+  } catch {
+    throw new JOSEError("Failed to parse the JSON Web Key Set HTTP response as JSON");
+  }
 }
-export const jwksCache = Symbol();
+const jwksCache = /* @__PURE__ */ Symbol();
 function isFreshFor(timestamp, duration) {
-    return Number.isFinite(timestamp) && Date.now() < timestamp + duration;
+  return Number.isFinite(timestamp) && Date.now() < timestamp + duration;
 }
 function validateDuration(value, fallback, option) {
-    if (Number.isNaN(value)) {
-        throw new TypeError(`"${option}" option must not be NaN`);
-    }
-    return typeof value === 'number' ? value : fallback;
+  if (Number.isNaN(value))
+    throw new TypeError(`"${option}" option must not be NaN`);
+  return typeof value == "number" ? value : fallback;
 }
-export function createRemoteJWKSet(url, options) {
-    if (!(url instanceof URL)) {
-        throw new TypeError('url must be an instance of URL');
-    }
-    const href = new URL(url.href).href;
-    const opts = options ?? {};
-    const timeoutOption = opts.timeoutDuration;
-    if (typeof timeoutOption === 'number' &&
-        (!Number.isInteger(timeoutOption) || timeoutOption < 0)) {
-        throw new TypeError('"timeoutDuration" option must be a non-negative integer');
+function createRemoteJWKSet(url, options) {
+  if (!(url instanceof URL))
+    throw new TypeError("url must be an instance of URL");
+  const href = new URL(url.href).href, opts = options ?? {}, timeoutOption = opts.timeoutDuration;
+  if (typeof timeoutOption == "number" && (!Number.isInteger(timeoutOption) || timeoutOption < 0))
+    throw new TypeError('"timeoutDuration" option must be a non-negative integer');
+  const timeoutDuration = typeof timeoutOption == "number" ? timeoutOption : 5e3, cooldownDuration = validateDuration(opts.cooldownDuration, 3e4, "cooldownDuration"), cacheMaxAge = validateDuration(opts.cacheMaxAge, 6e5, "cacheMaxAge"), headers = new Headers(opts.headers);
+  USER_AGENT && !headers.has("User-Agent") && headers.set("User-Agent", USER_AGENT), headers.has("accept") || headers.set("accept", "application/json, application/jwk-set+json");
+  const fetchImpl = opts[customFetch], cache = opts[jwksCache];
+  let jwksTimestamp, pendingFetch, reloadSequence = 0, appliedSequence = 0, local;
+  if (cache && typeof cache == "object") {
+    const { uat, jwks } = cache;
+    isFreshFor(uat, cacheMaxAge) && isJwkSet(jwks) && (jwksTimestamp = uat, local = createLocalJWKSet(jwks));
+  }
+  const reload = async () => {
+    if (pendingFetch && isCloudflareWorkers() && (pendingFetch = void 0), !pendingFetch) {
+      const sequence = ++reloadSequence, current = pendingFetch = fetchJwks(href, headers, AbortSignal.timeout(timeoutDuration), fetchImpl).then((json) => {
+        const next = createLocalJWKSet(json);
+        if (sequence <= appliedSequence)
+          return;
+        local = next;
+        const updatedAt = Date.now();
+        cache && (cache.uat = updatedAt, cache.jwks = json), jwksTimestamp = updatedAt, appliedSequence = sequence;
+      }).finally(() => {
+        pendingFetch === current && (pendingFetch = void 0);
+      });
     }
-    const timeoutDuration = typeof timeoutOption === 'number' ? timeoutOption : 5000;
-    const cooldownDuration = validateDuration(opts.cooldownDuration, 30000, 'cooldownDuration');
-    const cacheMaxAge = validateDuration(opts.cacheMaxAge, 600000, 'cacheMaxAge');
-    const headers = new Headers(opts.headers);
-    if (USER_AGENT && !headers.has('User-Agent')) {
-        headers.set('User-Agent', USER_AGENT);
-    }
-    if (!headers.has('accept')) {
-        headers.set('accept', 'application/json, application/jwk-set+json');
+    await pendingFetch;
+  };
+  return Object.defineProperties(async (protectedHeader, token) => {
+    (!local || !isFreshFor(jwksTimestamp, cacheMaxAge)) && await reload();
+    try {
+      return await local(protectedHeader, token);
+    } catch (err) {
+      if (err instanceof JWKSNoMatchingKey && !isFreshFor(jwksTimestamp, cooldownDuration))
+        return await reload(), local(protectedHeader, token);
+      throw err;
     }
-    const fetchImpl = opts[customFetch];
-    const cache = opts[jwksCache];
-    let jwksTimestamp;
-    let pendingFetch;
-    let reloadSequence = 0;
-    let appliedSequence = 0;
-    let local;
-    if (cache && typeof cache === 'object') {
-        const { uat, jwks } = cache;
-        if (isFreshFor(uat, cacheMaxAge) && isJwkSet(jwks)) {
-            jwksTimestamp = uat;
-            local = createLocalJWKSet(jwks);
-        }
+  }, {
+    coolingDown: {
+      get: () => isFreshFor(jwksTimestamp, cooldownDuration),
+      enumerable: !0
+    },
+    fresh: {
+      get: () => isFreshFor(jwksTimestamp, cacheMaxAge),
+      enumerable: !0
+    },
+    reload: {
+      value: reload,
+      enumerable: !0
+    },
+    reloading: {
+      get: () => !!pendingFetch,
+      enumerable: !0
+    },
+    jwks: {
+      value: () => local?.jwks(),
+      enumerable: !0
     }
-    const reload = async () => {
-        if (pendingFetch && isCloudflareWorkers()) {
-            pendingFetch = undefined;
-        }
-        if (!pendingFetch) {
-            const sequence = ++reloadSequence;
-            const current = (pendingFetch = fetchJwks(href, headers, AbortSignal.timeout(timeoutDuration), fetchImpl)
-                .then((json) => {
-                const next = createLocalJWKSet(json);
-                if (sequence <= appliedSequence) {
-                    return;
-                }
-                local = next;
-                const updatedAt = Date.now();
-                if (cache) {
-                    cache.uat = updatedAt;
-                    cache.jwks = json;
-                }
-                jwksTimestamp = updatedAt;
-                appliedSequence = sequence;
-            })
-                .finally(() => {
-                if (pendingFetch === current) {
-                    pendingFetch = undefined;
-                }
-            }));
-        }
-        await pendingFetch;
-    };
-    const remoteJWKSet = async (protectedHeader, token) => {
-        if (!local || !isFreshFor(jwksTimestamp, cacheMaxAge)) {
-            await reload();
-        }
-        try {
-            return await local(protectedHeader, token);
-        }
-        catch (err) {
-            if (err instanceof JWKSNoMatchingKey && !isFreshFor(jwksTimestamp, cooldownDuration)) {
-                await reload();
-                return local(protectedHeader, token);
-            }
-            throw err;
-        }
-    };
-    return Object.defineProperties(remoteJWKSet, {
-        coolingDown: {
-            get: () => isFreshFor(jwksTimestamp, cooldownDuration),
-            enumerable: true,
-        },
-        fresh: {
-            get: () => isFreshFor(jwksTimestamp, cacheMaxAge),
-            enumerable: true,
-        },
-        reload: {
-            value: reload,
-            enumerable: true,
-        },
-        reloading: {
-            get: () => !!pendingFetch,
-            enumerable: true,
-        },
-        jwks: {
-            value: () => local?.jwks(),
-            enumerable: true,
-        },
-    });
+  });
 }
+export {
+  createRemoteJWKSet,
+  customFetch,
+  jwksCache
+};

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/jws/compact/sign.js

@@ -1,22 +1,22 @@
-import { createCompactSignature } from '../../lib/jws_sign.js';
-import { assertNotSet } from '../../lib/helpers.js';
-export class CompactSign {
-    #payload;
-    #protectedHeader;
-    constructor(payload) {
-        if (!(payload instanceof Uint8Array)) {
-            throw new TypeError('payload must be an instance of Uint8Array');
-        }
-        this.#payload = payload;
-    }
-    setProtectedHeader(protectedHeader) {
-        assertNotSet(this.#protectedHeader, 'setProtectedHeader');
-        this.#protectedHeader = protectedHeader;
-        return this;
-    }
-    async sign(key, options) {
-        return createCompactSignature(this.#payload, this.#protectedHeader, options?.crit, key, () => {
-            throw new TypeError('use the flattened module for creating JWS with b64: false');
-        });
-    }
+import { createCompactSignature } from "../../lib/jws_sign.js";
+import { assertNotSet } from "../../lib/helpers.js";
+class CompactSign {
+  #payload;
+  #protectedHeader;
+  constructor(payload) {
+    if (!(payload instanceof Uint8Array))
+      throw new TypeError("payload must be an instance of Uint8Array");
+    this.#payload = payload;
+  }
+  setProtectedHeader(protectedHeader) {
+    return assertNotSet(this.#protectedHeader, "setProtectedHeader"), this.#protectedHeader = protectedHeader, this;
+  }
+  async sign(key, options) {
+    return createCompactSignature(this.#payload, this.#protectedHeader, options?.crit, key, () => {
+      throw new TypeError("use the flattened module for creating JWS with b64: false");
+    });
+  }
 }
+export {
+  CompactSign
+};

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/jws/compact/verify.js

@@ -1,9 +1,8 @@
-import { prepareVerify, verifyCompact } from '../../lib/jws_verify.js';
-export async function compactVerify(jws, key, options) {
-    const verified = await verifyCompact(jws, prepareVerify(options), key);
-    const result = { payload: verified[0], protectedHeader: verified[1] };
-    if (typeof key === 'function') {
-        return { ...result, key: verified[3] };
-    }
-    return result;
+import { prepareVerify, verifyCompact } from "../../lib/jws_verify.js";
+async function compactVerify(jws, key, options) {
+  const verified = await verifyCompact(jws, prepareVerify(options), key), result = { payload: verified[0], protectedHeader: verified[1] };
+  return typeof key == "function" ? { ...result, key: verified[3] } : result;
 }
+export {
+  compactVerify
+};

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/jws/flattened/sign.js

@@ -1,32 +1,30 @@
-import { createSignature } from '../../lib/jws_sign.js';
-import { assertNotSet } from '../../lib/helpers.js';
-export class FlattenedSign {
-    #payload;
-    #protectedHeader;
-    #unprotectedHeader;
-    constructor(payload) {
-        if (!(payload instanceof Uint8Array)) {
-            throw new TypeError('payload must be an instance of Uint8Array');
-        }
-        this.#payload = payload;
-    }
-    setProtectedHeader(protectedHeader) {
-        assertNotSet(this.#protectedHeader, 'setProtectedHeader');
-        this.#protectedHeader = protectedHeader;
-        return this;
-    }
-    setUnprotectedHeader(unprotectedHeader) {
-        assertNotSet(this.#unprotectedHeader, 'setUnprotectedHeader');
-        this.#unprotectedHeader = unprotectedHeader;
-        return this;
-    }
-    async sign(key, options) {
-        const [jws] = await createSignature({
-            payload: this.#payload,
-            protectedHeader: this.#protectedHeader,
-            unprotectedHeader: this.#unprotectedHeader,
-            crit: options?.crit,
-        }, key);
-        return jws;
-    }
+import { createSignature } from "../../lib/jws_sign.js";
+import { assertNotSet } from "../../lib/helpers.js";
+class FlattenedSign {
+  #payload;
+  #protectedHeader;
+  #unprotectedHeader;
+  constructor(payload) {
+    if (!(payload instanceof Uint8Array))
+      throw new TypeError("payload must be an instance of Uint8Array");
+    this.#payload = payload;
+  }
+  setProtectedHeader(protectedHeader) {
+    return assertNotSet(this.#protectedHeader, "setProtectedHeader"), this.#protectedHeader = protectedHeader, this;
+  }
+  setUnprotectedHeader(unprotectedHeader) {
+    return assertNotSet(this.#unprotectedHeader, "setUnprotectedHeader"), this.#unprotectedHeader = unprotectedHeader, this;
+  }
+  async sign(key, options) {
+    const [jws] = await createSignature({
+      payload: this.#payload,
+      protectedHeader: this.#protectedHeader,
+      unprotectedHeader: this.#unprotectedHeader,
+      crit: options?.crit
+    }, key);
+    return jws;
+  }
 }
+export {
+  FlattenedSign
+};

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/jws/flattened/verify.js

@@ -1,25 +1,22 @@
-import { JWSInvalid } from '../../util/errors.js';
-import { isObject } from '../../lib/type_checks.js';
-import { encodeJsonUnencodedPayload, prepareVerify, snapshotJws, verifySignature, verifyResult, } from '../../lib/jws_verify.js';
-export async function flattenedVerify(jws, key, options) {
-    if (!isObject(jws)) {
-        throw new JWSInvalid('Flattened JWS must be an object');
-    }
-    const snapshot = snapshotJws(jws);
-    if (snapshot.protected === undefined && snapshot.header === undefined) {
-        throw new JWSInvalid('Flattened JWS must have either of the "protected" or "header" members');
-    }
-    if (snapshot.protected !== undefined && typeof snapshot.protected !== 'string') {
-        throw new JWSInvalid('JWS Protected Header incorrect type');
-    }
-    if (snapshot.payload === undefined) {
-        throw new JWSInvalid('JWS Payload missing');
-    }
-    if (typeof snapshot.signature !== 'string') {
-        throw new JWSInvalid('JWS Signature missing or incorrect type');
-    }
-    if (snapshot.header !== undefined && !isObject(snapshot.header)) {
-        throw new JWSInvalid('JWS Unprotected Header incorrect type');
-    }
-    return verifyResult(snapshot, await verifySignature(snapshot, prepareVerify(options), key, encodeJsonUnencodedPayload));
+import { JWSInvalid } from "../../util/errors.js";
+import { isObject } from "../../lib/type_checks.js";
+import { encodeJsonUnencodedPayload, prepareVerify, snapshotJws, verifySignature, verifyResult } from "../../lib/jws_verify.js";
+async function flattenedVerify(jws, key, options) {
+  if (!isObject(jws))
+    throw new JWSInvalid("Flattened JWS must be an object");
+  const snapshot = snapshotJws(jws);
+  if (snapshot.protected === void 0 && snapshot.header === void 0)
+    throw new JWSInvalid('Flattened JWS must have either of the "protected" or "header" members');
+  if (snapshot.protected !== void 0 && typeof snapshot.protected != "string")
+    throw new JWSInvalid("JWS Protected Header incorrect type");
+  if (snapshot.payload === void 0)
+    throw new JWSInvalid("JWS Payload missing");
+  if (typeof snapshot.signature != "string")
+    throw new JWSInvalid("JWS Signature missing or incorrect type");
+  if (snapshot.header !== void 0 && !isObject(snapshot.header))
+    throw new JWSInvalid("JWS Unprotected Header incorrect type");
+  return verifyResult(snapshot, await verifySignature(snapshot, prepareVerify(options), key, encodeJsonUnencodedPayload));
 }
+export {
+  flattenedVerify
+};

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/jws/general/sign.js

@@ -1,76 +1,65 @@
-import { createSignature } from '../../lib/jws_sign.js';
-import { JWSInvalid } from '../../util/errors.js';
-import { assertNotSet } from '../../lib/helpers.js';
+import { createSignature } from "../../lib/jws_sign.js";
+import { JWSInvalid } from "../../util/errors.js";
+import { assertNotSet } from "../../lib/helpers.js";
 class IndividualSignature {
-    #parent;
-    state;
-    constructor(sig, key, options) {
-        this.#parent = sig;
-        this.state = [undefined, undefined, key, options?.crit];
-    }
-    setProtectedHeader(protectedHeader) {
-        assertNotSet(this.state[0], 'setProtectedHeader');
-        this.state[0] = protectedHeader;
-        return this;
-    }
-    setUnprotectedHeader(unprotectedHeader) {
-        assertNotSet(this.state[1], 'setUnprotectedHeader');
-        this.state[1] = unprotectedHeader;
-        return this;
-    }
-    addSignature(...args) {
-        return this.#parent.addSignature(...args);
-    }
-    sign(...args) {
-        return this.#parent.sign(...args);
-    }
-    done() {
-        return this.#parent;
-    }
+  #parent;
+  state;
+  constructor(sig, key, options) {
+    this.#parent = sig, this.state = [void 0, void 0, key, options?.crit];
+  }
+  setProtectedHeader(protectedHeader) {
+    return assertNotSet(this.state[0], "setProtectedHeader"), this.state[0] = protectedHeader, this;
+  }
+  setUnprotectedHeader(unprotectedHeader) {
+    return assertNotSet(this.state[1], "setUnprotectedHeader"), this.state[1] = unprotectedHeader, this;
+  }
+  addSignature(...args) {
+    return this.#parent.addSignature(...args);
+  }
+  sign(...args) {
+    return this.#parent.sign(...args);
+  }
+  done() {
+    return this.#parent;
+  }
 }
-export class GeneralSign {
-    #payload;
-    #signatures = [];
-    constructor(payload) {
-        this.#payload = payload;
-    }
-    addSignature(key, options) {
-        const signature = new IndividualSignature(this, key, options);
-        this.#signatures.push(signature);
-        return signature;
-    }
-    async sign() {
-        if (!this.#signatures.length) {
-            throw new JWSInvalid('at least one signature must be added');
-        }
-        if (!(this.#payload instanceof Uint8Array)) {
-            throw new TypeError('payload must be an instance of Uint8Array');
-        }
-        const jws = {
-            signatures: [],
-            payload: '',
-        };
-        const encoded = [];
-        let b64;
-        for (let i = 0; i < this.#signatures.length; i++) {
-            const signature = this.#signatures[i];
-            const [protectedHeader, unprotectedHeader, key, crit] = signature.state;
-            const [{ payload, ...rest }, signatureB64] = await createSignature({
-                payload: this.#payload,
-                protectedHeader,
-                unprotectedHeader,
-                crit,
-                encoded,
-            }, key);
-            if (b64 === undefined) {
-                b64 = signatureB64;
-                jws.payload = payload;
-            }
-            else if (b64 !== signatureB64) {
-                throw new JWSInvalid('inconsistent use of JWS Unencoded Payload (RFC7797)');
-            }
-            jws.signatures.push(rest);
-        }
-        return jws;
+class GeneralSign {
+  #payload;
+  #signatures = [];
+  constructor(payload) {
+    this.#payload = payload;
+  }
+  addSignature(key, options) {
+    const signature = new IndividualSignature(this, key, options);
+    return this.#signatures.push(signature), signature;
+  }
+  async sign() {
+    if (!this.#signatures.length)
+      throw new JWSInvalid("at least one signature must be added");
+    if (!(this.#payload instanceof Uint8Array))
+      throw new TypeError("payload must be an instance of Uint8Array");
+    const jws = {
+      signatures: [],
+      payload: ""
+    }, encoded = [];
+    let b64;
+    for (let i = 0; i < this.#signatures.length; i++) {
+      const signature = this.#signatures[i], [protectedHeader, unprotectedHeader, key, crit] = signature.state, [{ payload, ...rest }, signatureB64] = await createSignature({
+        payload: this.#payload,
+        protectedHeader,
+        unprotectedHeader,
+        crit,
+        encoded
+      }, key);
+      if (b64 === void 0)
+        b64 = signatureB64, jws.payload = payload;
+      else if (b64 !== signatureB64)
+        throw new JWSInvalid("inconsistent use of JWS Unencoded Payload (RFC7797)");
+      jws.signatures.push(rest);
     }
+    return jws;
+  }
 }
+export {
+  GeneralSign
+};