@nocobase/plugin-mcp-server 2.3.0-beta.12 → 2.3.0-beta.13

package/dist/node_modules/hono/dist/cjs/jsx/components.js

@@ -34,8 +34,9 @@ const childrenToString = async (children) => {
     return children.flat().map((c) => c == null || typeof c === "boolean" ? "" : c.toString());
   } catch (e) {
     if (e instanceof Promise) {
+      const resume = (0, import_context.captureRenderContext)();
       await e;
-      return childrenToString(children);
+      return resume(() => childrenToString(children));
     } else {
       throw e;
     }
@@ -63,51 +64,68 @@ const ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) =>
     children = [children];
   }
   const nonce = (0, import_context.useContext)(import_streaming.StreamingContext)?.scriptNonce;
-  let fallbackStr;
-  const resolveFallbackStr = async () => {
+  let resume;
+  const getResume = () => resume ||= (0, import_context.captureRenderContext)();
+  let fallbackStrPromise;
+  const resolveFallbackStr = () => fallbackStrPromise ||= (async () => {
     const awaitedFallback = await fallback;
     if (typeof awaitedFallback === "string") {
-      fallbackStr = awaitedFallback;
+      return awaitedFallback;
     } else {
-      fallbackStr = await awaitedFallback?.toString();
-      if (typeof fallbackStr === "string") {
-        fallbackStr = (0, import_html.raw)(fallbackStr);
+      const fallbackResult = await getResume()(() => awaitedFallback?.toString());
+      if (typeof fallbackResult === "string") {
+        return (0, import_html.raw)(
+          fallbackResult,
+          fallbackResult.callbacks || awaitedFallback?.callbacks
+        );
       }
     }
-  };
-  const fallbackRes = (error) => {
-    onError?.(error);
-    return fallbackStr || fallbackRender && (0, import_base.jsx)(import_base.Fragment, {}, fallbackRender(error)) || "";
+  })();
+  const renderFallback = async (error) => {
+    const fallbackStr = await resolveFallbackStr();
+    return getResume()(async () => {
+      onError?.(error);
+      const fallbackRes = fallbackStr !== void 0 ? fallbackStr : fallbackRender && (0, import_base.jsx)(import_base.Fragment, {}, fallbackRender(error)) || "";
+      const fallbackResString = await (0, import_base.Fragment)({
+        children: fallbackRes
+      }).toString();
+      return (0, import_html.raw)(
+        fallbackResString,
+        fallbackResString.callbacks || fallbackRes.callbacks
+      );
+    });
   };
   let resArray = [];
   try {
     resArray = children.map(resolveChildEarly);
   } catch (e) {
-    await resolveFallbackStr();
+    const resume2 = getResume();
     if (e instanceof Promise) {
       resArray = [
-        e.then(() => childrenToString(children)).catch((e2) => fallbackRes(e2))
+        e.then(() => resume2(() => childrenToString(children))).catch((e2) => renderFallback(e2))
       ];
     } else {
-      resArray = [fallbackRes(e)];
+      resArray = [await renderFallback(e)];
     }
   }
   if (resArray.some((res) => res instanceof Promise)) {
-    await resolveFallbackStr();
+    getResume();
     const index = errorBoundaryCounter++;
     const replaceRe = RegExp(`(<template id="E:${index}"></template>.*?)(.*?)(<!--E:${index}-->)`);
-    const caught = false;
+    let caught = false;
     const catchCallback = async ({ error: error2, buffer }) => {
       if (caught) {
         return "";
       }
-      const fallbackResString = await (0, import_base.Fragment)({
-        children: fallbackRes(error2)
-      }).toString();
+      caught = true;
+      const fallbackResString = await renderFallback(error2);
+      const fallbackCallbacks = fallbackResString.callbacks;
       if (buffer) {
         buffer[0] = buffer[0].replace(replaceRe, fallbackResString);
+        return fallbackCallbacks?.length ? (0, import_html.raw)("", fallbackCallbacks) : "";
       }
-      return buffer ? "" : `<template data-hono-target="E:${index}">${fallbackResString}</template><script>
+      return (0, import_html.raw)(
+        `<template data-hono-target="E:${index}">${fallbackResString}</template><script>
 ((d,c,n) => {
 c=d.currentScript.previousSibling
 d=d.getElementById('E:${index}')
@@ -115,7 +133,9 @@ if(!d)return
 do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='E:${index}')
 d.replaceWith(c.content)
 })(document)
-</script>`;
+</script>`,
+        fallbackCallbacks
+      );
     };
     let error;
     const promiseAll = Promise.all(resArray).catch((e) => error = e);

package/dist/node_modules/hono/dist/cjs/jsx/context.js

@@ -17,8 +17,10 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var context_exports = {};
 __export(context_exports, {
+  captureRenderContext: () => captureRenderContext,
   createContext: () => createContext,
   globalContexts: () => globalContexts,
+  runWithRenderContext: () => runWithRenderContext,
   useContext: () => useContext
 });
 module.exports = __toCommonJS(context_exports);
@@ -27,21 +29,143 @@ var import_base = require("./base");
 var import_constants = require("./constants");
 var import_context = require("./dom/context");
 const globalContexts = [];
+let alsProbed = false;
+let asyncLocalStorage;
+let fallbackStore;
+let fallbackRendersInFlight = 0;
+let warnedFallbackDefault = false;
+const loadAsyncLocalStorage = () => {
+  if (alsProbed) {
+    return asyncLocalStorage;
+  }
+  alsProbed = true;
+  const global = globalThis;
+  let AsyncLocalStorage;
+  for (const probe of [
+    // Node.js >= 20.16, Deno, Bun, Cloudflare Workers (nodejs_compat). Property
+    // access only, so bundlers don't statically resolve `node:async_hooks`.
+    () => global.process?.getBuiltinModule?.("node:async_hooks")?.AsyncLocalStorage,
+    // Node.js < 20.16 has no `process.getBuiltinModule`, but a CJS entrypoint
+    // exposes the main module's `require` here.
+    () => global.process?.mainModule?.require?.("node:async_hooks")?.AsyncLocalStorage
+  ]) {
+    try {
+      AsyncLocalStorage = probe();
+    } catch {
+    }
+    if (AsyncLocalStorage) {
+      break;
+    }
+  }
+  if (AsyncLocalStorage) {
+    asyncLocalStorage = new AsyncLocalStorage();
+  }
+  return asyncLocalStorage;
+};
+const getCurrentStore = () => {
+  return loadAsyncLocalStorage()?.getStore() || fallbackStore;
+};
+const warnIfStorelessAccess = () => {
+  if (fallbackRendersInFlight > 0 && !warnedFallbackDefault) {
+    warnedFallbackDefault = true;
+    console.warn(
+      "hono/jsx: AsyncLocalStorage is unavailable in this runtime, so useContext() after an await in an async component falls back to the context default value during server-side rendering. To get provided values across await boundaries, use a runtime with AsyncLocalStorage (Node.js >= 20.16, Deno, Bun, or Cloudflare Workers with the nodejs_compat flag)."
+    );
+  }
+};
+const getContextValuesIn = (store, context) => {
+  if (!store) {
+    warnIfStorelessAccess();
+    return context.values;
+  }
+  let values = store.get(context);
+  if (!values) {
+    values = [context.values[0]];
+    store.set(context, values);
+  }
+  return values;
+};
+const readContextValueIn = (store, context) => {
+  if (!store) {
+    warnIfStorelessAccess();
+    return context.values.at(-1);
+  }
+  const values = store.get(context);
+  return values?.length ? values.at(-1) : context.values[0];
+};
+const captureContextValues = (store) => (store ? globalContexts.filter((c) => store.has(c)) : globalContexts).map((c) => [
+  c,
+  readContextValueIn(store, c)
+]);
+const resumeWithContextValues = (callback, store, contexts) => runWithRenderContext(() => {
+  const currentStore = getCurrentStore();
+  const valuesPerContext = contexts.map(([context, value]) => {
+    const values = getContextValuesIn(currentStore, context);
+    values.push(value);
+    return values;
+  });
+  const popContextValues = () => {
+    valuesPerContext.forEach((values) => {
+      values.pop();
+    });
+  };
+  try {
+    const result = callback();
+    if (result instanceof Promise) {
+      return result.finally(popContextValues);
+    }
+    popContextValues();
+    return result;
+  } catch (e) {
+    popContextValues();
+    throw e;
+  }
+}, store);
+const runWithRenderContext = (callback, resumeStore) => {
+  if (getCurrentStore()) {
+    return callback();
+  }
+  const store = resumeStore ?? /* @__PURE__ */ new WeakMap();
+  const storage = loadAsyncLocalStorage();
+  if (storage) {
+    return storage.run(store, callback);
+  }
+  fallbackStore = store;
+  let result;
+  try {
+    result = callback();
+  } finally {
+    fallbackStore = void 0;
+  }
+  if (!warnedFallbackDefault && result instanceof Promise) {
+    fallbackRendersInFlight++;
+    result = result.finally(() => {
+      fallbackRendersInFlight--;
+    });
+  }
+  return result;
+};
+const captureRenderContext = () => {
+  const store = getCurrentStore();
+  const contexts = captureContextValues(store);
+  return (callback) => resumeWithContextValues(callback, store, contexts);
+};
 const createContext = (defaultValue) => {
   const values = [defaultValue];
   const context = ((props) => {
-    values.push(props.value);
+    const contextValues = getContextValuesIn(getCurrentStore(), context);
+    contextValues.push(props.value);
     let string;
     try {
       string = props.children ? (Array.isArray(props.children) ? new import_base.JSXFragmentNode("", {}, props.children) : props.children).toString() : "";
     } catch (e) {
-      values.pop();
+      contextValues.pop();
       throw e;
     }
     if (string instanceof Promise) {
-      return string.finally(() => values.pop()).then((resString) => (0, import_html.raw)(resString, resString.callbacks));
+      return string.finally(() => contextValues.pop()).then((resString) => (0, import_html.raw)(resString, resString.callbacks));
     } else {
-      values.pop();
+      contextValues.pop();
       return (0, import_html.raw)(string);
     }
   });
@@ -52,11 +176,13 @@ const createContext = (defaultValue) => {
   return context;
 };
 const useContext = (context) => {
-  return context.values.at(-1);
+  return readContextValueIn(getCurrentStore(), context);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  captureRenderContext,
   createContext,
   globalContexts,
+  runWithRenderContext,
   useContext
 });

package/dist/node_modules/hono/dist/cjs/jsx/dom/render.js

@@ -78,6 +78,7 @@ const applySelectValue = (select, props) => {
     select.selectedIndex = 0;
   }
 };
+const isIgnorableAttributeError = (error) => error instanceof DOMException && error.name === "InvalidCharacterError";
 const applyProps = (container, attributes, oldAttributes) => {
   attributes ||= {};
   for (let key in attributes) {
@@ -100,6 +101,7 @@ const applyProps = (container, attributes, oldAttributes) => {
       } else if (key === "dangerouslySetInnerHTML" && value) {
         container.innerHTML = value.__html;
       } else if (key === "ref") {
+        refCleanupMap.get(container)?.();
         let cleanup;
         if (typeof value === "function") {
           cleanup = value(container) || (() => value(null));
@@ -136,14 +138,20 @@ const applyProps = (container, attributes, oldAttributes) => {
           container[key] = value;
         }
         const k = toAttributeName(container, key);
-        if (value === null || value === void 0 || value === false) {
-          container.removeAttribute(k);
-        } else if (value === true) {
-          container.setAttribute(k, "");
-        } else if (typeof value === "string" || typeof value === "number") {
-          container.setAttribute(k, value);
-        } else {
-          container.setAttribute(k, value.toString());
+        try {
+          if (value === null || value === void 0 || value === false) {
+            container.removeAttribute(k);
+          } else if (value === true) {
+            container.setAttribute(k, "");
+          } else if (typeof value === "string" || typeof value === "number") {
+            container.setAttribute(k, value);
+          } else {
+            container.setAttribute(k, value.toString());
+          }
+        } catch (e) {
+          if (!isIgnorableAttributeError(e)) {
+            throw e;
+          }
         }
       }
     }
@@ -158,8 +166,15 @@ const applyProps = (container, attributes, oldAttributes) => {
           container.removeEventListener(eventSpec[0], value, eventSpec[1]);
         } else if (key === "ref") {
           refCleanupMap.get(container)?.();
+          refCleanupMap.delete(container);
         } else {
-          container.removeAttribute(toAttributeName(container, key));
+          try {
+            container.removeAttribute(toAttributeName(container, key));
+          } catch (e) {
+            if (!isIgnorableAttributeError(e)) {
+              throw e;
+            }
+          }
         }
       }
     }

package/dist/node_modules/hono/dist/cjs/jsx/hooks/index.js

@@ -263,7 +263,7 @@ const useCallback = (callback, deps) => {
   }
   return callback;
 };
-const useRef = (initialValue) => {
+function useRef(initialValue) {
   const buildData = import_render.buildDataStack.at(-1);
   if (!buildData) {
     return { current: initialValue };
@@ -272,7 +272,7 @@ const useRef = (initialValue) => {
   const refArray = node[import_constants.DOM_STASH][1][STASH_REF] ||= [];
   const hookIndex = node[import_constants.DOM_STASH][0]++;
   return refArray[hookIndex] ||= { current: initialValue };
-};
+}
 const use = (promise) => {
   const cachedRes = resolvedPromiseValueMap.get(promise);
   if (cachedRes) {
@@ -330,19 +330,22 @@ const useSyncExternalStore = (subscribe, getSnapshot, getServerSnapshot) => {
     }
     return getServerSnapshot();
   }
-  const [serverSnapshotIsUsed] = useState(!!(buildData[0][4] && getServerSnapshot));
-  const [state, setState] = useState(
-    () => serverSnapshotIsUsed ? getServerSnapshot() : getSnapshot()
-  );
+  const snapshot = buildData[0][4] && getServerSnapshot ? getServerSnapshot() : getSnapshot();
+  const [, setVersion] = useState(0);
+  const latestSnapshot = useRef([snapshot, getSnapshot]);
+  latestSnapshot.current = [snapshot, getSnapshot];
+  const unsubscribeRef = useRef(null);
   useEffect(() => {
-    if (serverSnapshotIsUsed) {
-      setState(getSnapshot());
+    const update2 = () => setVersion((version) => version + 1);
+    unsubscribeRef.current?.();
+    unsubscribeRef.current = subscribe(update2);
+    const [snapshot2, getSnapshot2] = latestSnapshot.current;
+    if (!Object.is(snapshot2, getSnapshot2())) {
+      update2();
     }
-    return subscribe(() => {
-      setState(getSnapshot());
-    });
-  }, []);
-  return state;
+  }, [subscribe]);
+  useEffect(() => () => unsubscribeRef.current?.(), []);
+  return snapshot;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/node_modules/hono/dist/cjs/jsx/intrinsic-element/components.js

@@ -101,7 +101,7 @@ const documentMetadataTag = (tag, children, props, sort) => {
   const string = new import_base.JSXNode(tag, restProps, (0, import_children.toArray)(children || [])).toString();
   if (string instanceof Promise) {
     return string.then(
-      (resString) => (0, import_html.raw)(string, [
+      (resString) => (0, import_html.raw)(resString, [
         ...resString.callbacks || [],
         insertIntoHead(tag, resString, restProps, precedence)
       ])

package/dist/node_modules/hono/dist/cjs/jsx/jsx-runtime.js

@@ -31,6 +31,9 @@ var import_html = require("../helper/html");
 var import_html2 = require("../utils/html");
 var import_utils = require("./utils");
 const jsxAttr = (key, v) => {
+  if (!(0, import_utils.isValidAttributeName)(key)) {
+    return (0, import_html.raw)("");
+  }
   const buffer = [`${key}="`];
   if (key === "style" && typeof v === "object") {
     let styleStr = "";

package/dist/node_modules/hono/dist/cjs/jsx/streaming.js

@@ -42,9 +42,8 @@ const Suspense = async ({
   const nonce = (0, import_context.useContext)(StreamingContext)?.scriptNonce;
   let resArray = [];
   const stackNode = { [import_constants.DOM_STASH]: [0, []] };
-  const popNodeStack = (value) => {
+  const popNodeStack = () => {
     import_render.buildDataStack.pop();
-    return value;
   };
   try {
     stackNode[import_constants.DOM_STASH][0] = 0;
@@ -54,12 +53,15 @@ const Suspense = async ({
     );
   } catch (e) {
     if (e instanceof Promise) {
+      const resume = (0, import_context.captureRenderContext)();
       resArray = [
-        e.then(() => {
-          stackNode[import_constants.DOM_STASH][0] = 0;
-          import_render.buildDataStack.push([[], stackNode]);
-          return (0, import_components.childrenToString)(children).then(popNodeStack);
-        })
+        e.then(
+          () => resume(() => {
+            stackNode[import_constants.DOM_STASH][0] = 0;
+            import_render.buildDataStack.push([[], stackNode]);
+            return (0, import_components.childrenToString)(children).finally(popNodeStack);
+          })
+        )
       ];
     } else {
       throw e;

package/dist/node_modules/hono/dist/cjs/jsx/utils.js

@@ -17,6 +17,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var utils_exports = {};
 __export(utils_exports, {
+  isValidAttributeName: () => isValidAttributeName,
+  isValidTagName: () => isValidTagName,
   normalizeIntrinsicElementKey: () => normalizeIntrinsicElementKey,
   styleObjectForEach: () => styleObjectForEach
 });
@@ -32,19 +34,167 @@ const normalizeElementKeyMap = /* @__PURE__ */ new Map([
   ["formAction", "formaction"]
 ]);
 const normalizeIntrinsicElementKey = (key) => normalizeElementKeyMap.get(key) || key;
+const invalidAttributeNameCharRe = /[\s"'<>/=`\\\x00-\x1f\x7f-\x9f]/;
+const validAttributeNameCache = /* @__PURE__ */ new Set();
+const validAttributeNameCacheMax = 1024;
+const invalidTagNameCharRe = /^[!?]|[\s"'<>/=`\\\x00-\x1f\x7f-\x9f]/;
+const validTagNameCache = /* @__PURE__ */ new Set();
+const validTagNameCacheMax = 256;
+const cacheValidName = (cache, max, name) => {
+  if (cache.size >= max) {
+    cache.clear();
+  }
+  cache.add(name);
+};
+const isValidTagName = (name) => {
+  if (validTagNameCache.has(name)) {
+    return true;
+  }
+  if (typeof name !== "string") {
+    return false;
+  }
+  if (name.length === 0) {
+    return true;
+  }
+  if (invalidTagNameCharRe.test(name)) {
+    return false;
+  }
+  cacheValidName(validTagNameCache, validTagNameCacheMax, name);
+  return true;
+};
+const isValidAttributeName = (name) => {
+  if (validAttributeNameCache.has(name)) {
+    return true;
+  }
+  const len = name.length;
+  if (len === 0) {
+    return false;
+  }
+  for (let i = 0; i < len; i++) {
+    const c = name.charCodeAt(i);
+    if (!(c >= 97 && c <= 122 || // a-z
+    c >= 65 && c <= 90 || // A-Z
+    c >= 48 && c <= 57 || // 0-9
+    c === 45 || // -
+    c === 95 || // _
+    c === 46 || // .
+    c === 58)) {
+      if (!invalidAttributeNameCharRe.test(name)) {
+        cacheValidName(validAttributeNameCache, validAttributeNameCacheMax, name);
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }
+  cacheValidName(validAttributeNameCache, validAttributeNameCacheMax, name);
+  return true;
+};
+const invalidStylePropertyNameCharRe = /[\s"'():;\\/\[\]{}\x00-\x1f\x7f-\x9f]/;
+const validStylePropertyNameCache = /* @__PURE__ */ new Set();
+const validStylePropertyNameCacheMax = 1024;
+const isValidStylePropertyName = (name) => {
+  if (validStylePropertyNameCache.has(name)) {
+    return true;
+  }
+  const len = name.length;
+  if (len === 0) {
+    return false;
+  }
+  for (let i = 0; i < len; i++) {
+    const c = name.charCodeAt(i);
+    if (!(c >= 97 && c <= 122 || // a-z
+    c >= 65 && c <= 90 || // A-Z
+    c >= 48 && c <= 57 || // 0-9
+    c === 45 || // -
+    c === 95)) {
+      if (!invalidStylePropertyNameCharRe.test(name)) {
+        cacheValidName(validStylePropertyNameCache, validStylePropertyNameCacheMax, name);
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }
+  cacheValidName(validStylePropertyNameCache, validStylePropertyNameCacheMax, name);
+  return true;
+};
+const unsafeStyleValueCharRe = /[;"'\\/\[\](){}]/;
+const hasUnsafeStyleValue = (value) => {
+  if (!unsafeStyleValueCharRe.test(value)) {
+    return false;
+  }
+  let quote = 0;
+  const blockStack = [];
+  for (let i = 0, len = value.length; i < len; i++) {
+    const c = value.charCodeAt(i);
+    if (c === 92) {
+      if (i === len - 1) {
+        return true;
+      }
+      i++;
+    } else if (quote !== 0) {
+      if (c === 10 || c === 12 || c === 13) {
+        return true;
+      }
+      if (c === quote) {
+        quote = 0;
+      }
+    } else if (c === 47 && value.charCodeAt(i + 1) === 42) {
+      const end = value.indexOf("*/", i + 2);
+      if (end === -1) {
+        return true;
+      }
+      i = end + 1;
+    } else if (c === 34 || c === 39) {
+      quote = c;
+    } else if (c === 40) {
+      blockStack.push(41);
+    } else if (c === 91) {
+      blockStack.push(93);
+    } else if (c === 123 || c === 125) {
+      return true;
+    } else if (c === 41 || c === 93) {
+      if (blockStack[blockStack.length - 1] !== c) {
+        return true;
+      }
+      blockStack.pop();
+    } else if (c === 59 && blockStack.length === 0) {
+      return true;
+    }
+  }
+  return quote !== 0 || blockStack.length !== 0;
+};
 const styleObjectForEach = (style, fn) => {
   for (const [k, v] of Object.entries(style)) {
     const key = k[0] === "-" || !/[A-Z]/.test(k) ? k : k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
-    fn(
-      key,
-      v == null ? null : typeof v === "number" ? !key.match(
+    if (!isValidStylePropertyName(key)) {
+      continue;
+    }
+    if (v == null) {
+      fn(key, null);
+      continue;
+    }
+    let value;
+    if (typeof v === "number") {
+      value = !key.match(
         /^(?:a|border-im|column(?:-c|s)|flex(?:$|-[^b])|grid-(?:ar|[^a])|font-w|li|or|sca|st|ta|wido|z)|ty$/
-      ) ? `${v}px` : `${v}` : v
-    );
+      ) ? `${v}px` : `${v}`;
+    } else if (typeof v === "string") {
+      if (hasUnsafeStyleValue(v)) {
+        continue;
+      }
+      value = v;
+    } else {
+      continue;
+    }
+    fn(key, value);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  isValidAttributeName,
+  isValidTagName,
   normalizeIntrinsicElementKey,
   styleObjectForEach
 });

package/dist/node_modules/hono/dist/cjs/middleware/bearer-auth/index.js

@@ -27,7 +27,7 @@ const PREFIX = "Bearer";
 const HEADER = "Authorization";
 const bearerAuth = (options) => {
   if (!("token" in options || "verifyToken" in options)) {
-    throw new Error('bearer auth middleware requires options for "token"');
+    throw new Error('bearer auth middleware requires options for "token" or "verifyToken"');
   }
   if (!options.realm) {
     options.realm = "";