@nocobase/plugin-mcp-server 2.2.16 → 2.2.18

package/dist/node_modules/hono/dist/cjs/middleware/ip-restriction/index.js

@@ -22,11 +22,45 @@ __export(ip_restriction_exports, {
 module.exports = __toCommonJS(ip_restriction_exports);
 var import_http_exception = require("../../http-exception");
 var import_ipaddr = require("../../utils/ipaddr");
-const IS_CIDR_NOTATION_REGEX = /\/[0-9]{0,3}$/;
+const IS_CIDR_NOTATION_REGEX = /\/[^/]*$/;
+const parseCidrPrefix = (rule, prefix, max) => {
+  if (!/^[0-9]{1,3}$/.test(prefix)) {
+    throw new TypeError(`Invalid rule: ${rule}`);
+  }
+  const parsedPrefix = parseInt(prefix);
+  if (parsedPrefix > max) {
+    throw new TypeError(`Invalid rule: ${rule}`);
+  }
+  return parsedPrefix;
+};
 const buildMatcher = (rules) => {
   const functionRules = [];
   const staticRules = /* @__PURE__ */ new Set();
+  const staticIPv4Rules = /* @__PURE__ */ new Set();
+  const staticIPv6Rules = /* @__PURE__ */ new Set();
   const cidrRules = [];
+  const registerStaticRule = (rule) => {
+    const type = (0, import_ipaddr.distinctRemoteAddr)(rule);
+    if (type === void 0) {
+      throw new TypeError(`Invalid rule: ${rule}`);
+    }
+    if (type === "IPv4") {
+      const ipv4binary = (0, import_ipaddr.convertIPv4ToBinary)(rule);
+      staticRules.add(rule);
+      staticRules.add(`::ffff:${rule}`);
+      staticIPv4Rules.add(ipv4binary);
+      staticIPv6Rules.add(0xffffn << 32n | ipv4binary);
+    } else {
+      const ipv6binary = (0, import_ipaddr.convertIPv6ToBinary)(rule);
+      const ipv6Addr = (0, import_ipaddr.convertIPv6BinaryToString)(ipv6binary);
+      staticRules.add(ipv6Addr);
+      staticIPv6Rules.add(ipv6binary);
+      if ((0, import_ipaddr.isIPv4MappedIPv6)(ipv6binary)) {
+        staticRules.add(ipv6Addr.substring(7));
+        staticIPv4Rules.add((0, import_ipaddr.convertIPv4MappedIPv6ToIPv4)(ipv6binary));
+      }
+    }
+  };
   for (let rule of rules) {
     if (rule === "*") {
       return () => true;
@@ -36,17 +70,17 @@ const buildMatcher = (rules) => {
       if (IS_CIDR_NOTATION_REGEX.test(rule)) {
         const separatedRule = rule.split("/");
         const addrStr = separatedRule[0];
-        const type2 = (0, import_ipaddr.distinctRemoteAddr)(addrStr);
-        if (type2 === void 0) {
+        const type = (0, import_ipaddr.distinctRemoteAddr)(addrStr);
+        if (type === void 0) {
           throw new TypeError(`Invalid rule: ${rule}`);
         }
-        let isIPv4 = type2 === "IPv4";
-        let prefix = parseInt(separatedRule[1]);
+        let isIPv4 = type === "IPv4";
+        let prefix = parseCidrPrefix(rule, separatedRule[1], isIPv4 ? 32 : 128);
         if (isIPv4 ? prefix === 32 : prefix === 128) {
           rule = addrStr;
         } else {
           let addr = (isIPv4 ? import_ipaddr.convertIPv4ToBinary : import_ipaddr.convertIPv6ToBinary)(addrStr);
-          if (type2 === "IPv6" && (0, import_ipaddr.isIPv4MappedIPv6)(addr) && prefix >= 96) {
+          if (type === "IPv6" && (0, import_ipaddr.isIPv4MappedIPv6)(addr) && prefix >= 96) {
             isIPv4 = true;
             addr = (0, import_ipaddr.convertIPv4MappedIPv6ToIPv4)(addr);
             prefix -= 96;
@@ -56,21 +90,7 @@ const buildMatcher = (rules) => {
           continue;
         }
       }
-      const type = (0, import_ipaddr.distinctRemoteAddr)(rule);
-      if (type === void 0) {
-        throw new TypeError(`Invalid rule: ${rule}`);
-      }
-      if (type === "IPv4") {
-        staticRules.add(rule);
-        staticRules.add(`::ffff:${rule}`);
-      } else {
-        const ipv6binary = (0, import_ipaddr.convertIPv6ToBinary)(rule);
-        const ipv6Addr = (0, import_ipaddr.convertIPv6BinaryToString)(ipv6binary);
-        staticRules.add(ipv6Addr);
-        if ((0, import_ipaddr.isIPv4MappedIPv6)(ipv6binary)) {
-          staticRules.add(ipv6Addr.substring(7));
-        }
-      }
+      registerStaticRule(rule);
     }
   }
   return (remote) => {
@@ -79,6 +99,9 @@ const buildMatcher = (rules) => {
     }
     const remoteAddr = remote.binaryAddr ||= (remote.isIPv4 ? import_ipaddr.convertIPv4ToBinary : import_ipaddr.convertIPv6ToBinary)(remote.addr);
     const remoteIPv4Addr = remote.isIPv4 || (0, import_ipaddr.isIPv4MappedIPv6)(remoteAddr) ? remote.isIPv4 ? remoteAddr : (0, import_ipaddr.convertIPv4MappedIPv6ToIPv4)(remoteAddr) : void 0;
+    if ((remote.isIPv4 ? staticIPv4Rules : staticIPv6Rules).has(remoteAddr)) {
+      return true;
+    }
     for (const [isIPv4, addr, mask] of cidrRules) {
       if (isIPv4) {
         if (remoteIPv4Addr === void 0) {
@@ -121,14 +144,21 @@ const ipRestriction = (getIP, { denyList = [], allowList = [] }, onError) => {
     }
     const type = typeof connInfo !== "string" && connInfo.remote.addressType || (0, import_ipaddr.distinctRemoteAddr)(addr);
     const remoteData = { addr, type, isIPv4: type === "IPv4" };
-    if (denyMatcher(remoteData)) {
-      if (onError) {
-        return onError({ addr, type }, c);
+    try {
+      if (denyMatcher(remoteData)) {
+        if (onError) {
+          return onError({ addr, type }, c);
+        }
+        throw blockError(c);
       }
-      throw blockError(c);
-    }
-    if (allowMatcher(remoteData)) {
-      return await next();
+      if (allowMatcher(remoteData)) {
+        return await next();
+      }
+    } catch (e) {
+      if (e instanceof TypeError && e.code === import_ipaddr.INVALID_IP_ADDRESS_ERROR_CODE) {
+        throw blockError(c);
+      }
+      throw e;
     }
     if (allowLength === 0) {
       return await next();

package/dist/node_modules/hono/dist/cjs/middleware/jwk/jwk.js

@@ -38,14 +38,15 @@ const jwk = (options, init) => {
     let token;
     if (credentials) {
       const parts = credentials.split(/\s+/);
-      if (parts.length !== 2) {
+      if (parts.length !== 2 || parts[0].toLowerCase() !== "bearer") {
         const errDescription = "invalid credentials structure";
         throw new import_http_exception.HTTPException(401, {
           message: errDescription,
           res: unauthorizedResponse({
             ctx,
             error: "invalid_request",
-            errDescription
+            errDescription,
+            realm: options.realm
           })
         });
       } else {
@@ -83,7 +84,8 @@ const jwk = (options, init) => {
         res: unauthorizedResponse({
           ctx,
           error: "invalid_request",
-          errDescription
+          errDescription,
+          realm: options.realm
         })
       });
     }
@@ -110,7 +112,8 @@ const jwk = (options, init) => {
           ctx,
           error: "invalid_token",
           statusText: "Unauthorized",
-          errDescription: "token verification failure"
+          errDescription: "token verification failure",
+          realm: options.realm
         }),
         cause
       });
@@ -120,11 +123,13 @@ const jwk = (options, init) => {
   };
 };
 function unauthorizedResponse(opts) {
+  const realm = (opts.realm ?? opts.ctx.req.url).replace(/"/g, '\\"');
+  const errDescription = opts.errDescription.replace(/"/g, '\\"');
   return new Response("Unauthorized", {
     status: 401,
     statusText: opts.statusText,
     headers: {
-      "WWW-Authenticate": `Bearer realm="${opts.ctx.req.url}",error="${opts.error}",error_description="${opts.errDescription}"`
+      "WWW-Authenticate": `Bearer realm="${realm}",error="${opts.error}",error_description="${errDescription}"`
     }
   });
 }

package/dist/node_modules/hono/dist/cjs/middleware/jwt/jwt.js

@@ -45,14 +45,15 @@ const jwt = (options) => {
     let token;
     if (credentials) {
       const parts = credentials.split(/\s+/);
-      if (parts.length !== 2) {
+      if (parts.length !== 2 || parts[0].toLowerCase() !== "bearer") {
         const errDescription = "invalid credentials structure";
         throw new import_http_exception.HTTPException(401, {
           message: errDescription,
           res: unauthorizedResponse({
             ctx,
             error: "invalid_request",
-            errDescription
+            errDescription,
+            realm: options.realm
           })
         });
       } else {
@@ -87,7 +88,8 @@ const jwt = (options) => {
         res: unauthorizedResponse({
           ctx,
           error: "invalid_request",
-          errDescription
+          errDescription,
+          realm: options.realm
         })
       });
     }
@@ -108,7 +110,8 @@ const jwt = (options) => {
           ctx,
           error: "invalid_token",
           statusText: "Unauthorized",
-          errDescription: "token verification failure"
+          errDescription: "token verification failure",
+          realm: options.realm
         }),
         cause
       });
@@ -118,11 +121,13 @@ const jwt = (options) => {
   };
 };
 function unauthorizedResponse(opts) {
+  const realm = (opts.realm ?? opts.ctx.req.url).replace(/"/g, '\\"');
+  const errDescription = opts.errDescription.replace(/"/g, '\\"');
   return new Response("Unauthorized", {
     status: 401,
     statusText: opts.statusText,
     headers: {
-      "WWW-Authenticate": `Bearer realm="${opts.ctx.req.url}",error="${opts.error}",error_description="${opts.errDescription}"`
+      "WWW-Authenticate": `Bearer realm="${realm}",error="${opts.error}",error_description="${errDescription}"`
     }
   });
 }

package/dist/node_modules/hono/dist/cjs/middleware/language/language.js

@@ -69,34 +69,30 @@ const normalizeLanguage = (lang, options) => {
     if (exactIndex !== -1) {
       return options.supportedLanguages[exactIndex];
     }
-    const parts = compLang.split("-");
-    for (let i = parts.length - 1; i > 0; i--) {
-      const candidate = parts.slice(0, i).join("-");
-      const prefixIndex = compSupported.indexOf(candidate);
-      if (prefixIndex !== -1) {
-        return options.supportedLanguages[prefixIndex];
+    let longestMatchIndex = -1;
+    let longestMatchLength = -1;
+    for (let i = 0; i < compSupported.length; i++) {
+      const candidate = compSupported[i];
+      if (candidate.length < compLang.length && candidate.length > longestMatchLength && compLang.startsWith(candidate) && compLang[candidate.length] === "-") {
+        longestMatchIndex = i;
+        longestMatchLength = candidate.length;
       }
     }
+    if (longestMatchIndex !== -1) {
+      return options.supportedLanguages[longestMatchIndex];
+    }
     return void 0;
   } catch {
     return void 0;
   }
 };
 const detectFromQuery = (c, options) => {
-  try {
-    const query = c.req.query(options.lookupQueryString);
-    return normalizeLanguage(query, options);
-  } catch {
-    return void 0;
-  }
+  const query = c.req.query(options.lookupQueryString);
+  return normalizeLanguage(query, options);
 };
 const detectFromCookie = (c, options) => {
-  try {
-    const cookie = (0, import_cookie.getCookie)(c, options.lookupCookie);
-    return normalizeLanguage(cookie, options);
-  } catch {
-    return void 0;
-  }
+  const cookie = (0, import_cookie.getCookie)(c, options.lookupCookie);
+  return normalizeLanguage(cookie, options);
 };
 function detectFromHeader(c, options) {
   try {
@@ -117,14 +113,10 @@ function detectFromHeader(c, options) {
   }
 }
 function detectFromPath(c, options) {
-  try {
-    const url = new URL(c.req.url);
-    const pathSegments = url.pathname.split("/").filter(Boolean);
-    const langSegment = pathSegments[options.lookupFromPathIndex];
-    return normalizeLanguage(langSegment, options);
-  } catch {
-    return void 0;
-  }
+  const url = new URL(c.req.url);
+  const pathSegments = url.pathname.split("/").filter(Boolean);
+  const langSegment = pathSegments[options.lookupFromPathIndex];
+  return normalizeLanguage(langSegment, options);
 }
 const detectors = {
   querystring: detectFromQuery,
@@ -159,9 +151,6 @@ const detectLanguage = (c, options) => {
   let detectedLang;
   for (const detectorName of options.order) {
     const detector = detectors[detectorName];
-    if (!detector) {
-      continue;
-    }
     try {
       detectedLang = detector(c, options);
       if (detectedLang) {
@@ -194,15 +183,8 @@ const languageDetector = (userOptions) => {
   };
   validateOptions(options);
   return async function languageDetector2(ctx, next) {
-    try {
-      const lang = detectLanguage(ctx, options);
-      ctx.set("language", lang);
-    } catch (error) {
-      if (options.debug) {
-        console.error("Language detection failed:", error);
-      }
-      ctx.set("language", options.fallbackLanguage);
-    }
+    const lang = detectLanguage(ctx, options);
+    ctx.set("language", lang);
     await next();
   };
 };

package/dist/node_modules/hono/dist/cjs/middleware/method-not-allowed/index.js

@@ -0,0 +1,90 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var method_not_allowed_exports = {};
+__export(method_not_allowed_exports, {
+  methodNotAllowed: () => methodNotAllowed
+});
+module.exports = __toCommonJS(method_not_allowed_exports);
+var import_route = require("../../helper/route");
+var import_router = require("../../router");
+var import_trie_router = require("../../router/trie-router");
+const methodNotAllowed = (options) => {
+  let methodRouter;
+  return async function methodNotAllowed2(c, next) {
+    const routeIndex = c.req.routeIndex;
+    await next();
+    if (c.res.status !== 404) {
+      return;
+    }
+    if (c.error) {
+      return;
+    }
+    if (!methodRouter) {
+      const methodsByPath = /* @__PURE__ */ new Map();
+      for (const route of options.app.routes) {
+        if (route.method === import_router.METHOD_NAME_ALL || route.method === "HEAD") {
+          continue;
+        }
+        const methods2 = methodsByPath.get(route.path) ?? /* @__PURE__ */ new Set();
+        methods2.add(route.method);
+        if (route.method === "GET") {
+          methods2.add("HEAD");
+        }
+        methodsByPath.set(route.path, methods2);
+      }
+      methodRouter = new import_trie_router.TrieRouter();
+      for (const [path, methods2] of methodsByPath) {
+        methodRouter.add(import_router.METHOD_NAME_ALL, path, [...methods2]);
+      }
+    }
+    let requestPath = c.req.path;
+    const routes = (0, import_route.matchedRoutes)(c);
+    const currentRoute = routes[routeIndex];
+    const sourceRoute = options.app.routes.find((route) => route.handler === methodNotAllowed2);
+    if (currentRoute && sourceRoute) {
+      const currentBasePathParts = (0, import_route.basePath)(c, routeIndex).split("/").filter(Boolean);
+      const sourceBasePathLength = sourceRoute.basePath.split("/").filter(Boolean).length;
+      const mountBasePathParts = currentBasePathParts.slice(
+        0,
+        currentBasePathParts.length - sourceBasePathLength
+      );
+      if (mountBasePathParts.length > 0) {
+        const mountBasePath = `/${mountBasePathParts.join("/")}`;
+        requestPath = c.req.path.slice(mountBasePath.length) || "/";
+      }
+    }
+    const allowedMethods = /* @__PURE__ */ new Set();
+    for (const [methods2] of methodRouter.match(import_router.METHOD_NAME_ALL, requestPath)[0]) {
+      for (const method of methods2) {
+        allowedMethods.add(method);
+      }
+    }
+    if (allowedMethods.size === 0 || allowedMethods.has(c.req.method)) {
+      return;
+    }
+    c.res.headers.delete("Allow");
+    c.res.headers.delete("Content-Length");
+    const methods = [...allowedMethods];
+    const allow = methods.join(", ");
+    c.res = options.onMethodNotAllowed ? await options.onMethodNotAllowed(c, methods) : c.text("Method Not Allowed", 405, { Allow: allow });
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  methodNotAllowed
+});

package/dist/node_modules/hono/dist/cjs/middleware/method-override/index.js

@@ -49,7 +49,7 @@ const methodOverride = (options) => async function methodOverride2(c, next) {
         return app.fetch(request, c.env, getExecutionCtx(c));
       }
     }
-    if (contentType === "application/x-www-form-urlencoded") {
+    if (contentType?.startsWith("application/x-www-form-urlencoded")) {
       const params = await (0, import_body.parseBody)(clonedRequest);
       const method = params[methodFormName];
       if (method) {
@@ -80,11 +80,13 @@ const methodOverride = (options) => async function methodOverride2(c, next) {
     if (method) {
       const url = new URL(c.req.url);
       url.searchParams.delete(queryName);
-      const request = new Request(url.toString(), {
+      const requestInit = {
         body: c.req.raw.body,
         headers: c.req.raw.headers,
-        method
-      });
+        method,
+        duplex: c.req.raw.body ? "half" : void 0
+      };
+      const request = new Request(url.toString(), requestInit);
       return app.fetch(request, c.env, getExecutionCtx(c));
     }
   }

package/dist/node_modules/hono/dist/cjs/middleware/pretty-json/index.js

@@ -20,12 +20,14 @@ __export(pretty_json_exports, {
   prettyJSON: () => prettyJSON
 });
 module.exports = __toCommonJS(pretty_json_exports);
+const jsonContentTypeRegex = /^application\/(?:[a-z0-9._-]+\+)?json(?=$|[;\s])/i;
 const prettyJSON = (options) => {
   const targetQuery = options?.query ?? "pretty";
   return async function prettyJSON2(c, next) {
     const pretty = options?.force || c.req.query(targetQuery) || c.req.query(targetQuery) === "";
     await next();
-    if (pretty && c.res.headers.get("Content-Type")?.startsWith("application/json")) {
+    const contentType = c.res.headers.get("Content-Type");
+    if (pretty && contentType && jsonContentTypeRegex.test(contentType)) {
       const obj = await c.res.json();
       c.res = new Response(JSON.stringify(obj, null, options?.space ?? 2), c.res);
     }

package/dist/node_modules/hono/dist/cjs/middleware/secure-headers/secure-headers.js

@@ -71,14 +71,20 @@ const secureHeaders = (customOptions) => {
   const headersToSet = getFilteredHeaders(options);
   const callbacks = [];
   if (options.contentSecurityPolicy) {
-    const [callback, value] = getCSPDirectives(options.contentSecurityPolicy);
+    const [callback, value] = getCSPDirectives(
+      options.contentSecurityPolicy,
+      "Content-Security-Policy"
+    );
     if (callback) {
       callbacks.push(callback);
     }
     headersToSet.push(["Content-Security-Policy", value]);
   }
   if (options.contentSecurityPolicyReportOnly) {
-    const [callback, value] = getCSPDirectives(options.contentSecurityPolicyReportOnly);
+    const [callback, value] = getCSPDirectives(
+      options.contentSecurityPolicyReportOnly,
+      "Content-Security-Policy-Report-Only"
+    );
     if (callback) {
       callbacks.push(callback);
     }
@@ -111,7 +117,7 @@ function getFilteredHeaders(options) {
     return typeof overrideValue === "string" ? [defaultValue[0], overrideValue] : defaultValue;
   });
 }
-function getCSPDirectives(contentSecurityPolicy) {
+function getCSPDirectives(contentSecurityPolicy, headerName) {
   const callbacks = [];
   const resultValues = [];
   for (const [directive, value] of Object.entries(contentSecurityPolicy)) {
@@ -136,7 +142,7 @@ function getCSPDirectives(contentSecurityPolicy) {
   resultValues.pop();
   return callbacks.length === 0 ? [void 0, resultValues.join("")] : [
     (ctx, headersToSet) => headersToSet.map((values) => {
-      if (values[0] === "Content-Security-Policy" || values[0] === "Content-Security-Policy-Report-Only") {
+      if (values[0] === headerName) {
         const clone = values[1].slice();
         callbacks.forEach((cb) => {
           cb(ctx, clone);
@@ -153,14 +159,17 @@ function getPermissionsPolicyDirectives(policy) {
   return Object.entries(policy).map(([directive, value]) => {
     const kebabDirective = camelToKebab(directive);
     if (typeof value === "boolean") {
-      return `${kebabDirective}=${value ? "*" : "none"}`;
+      return `${kebabDirective}=${value ? "*" : "()"}`;
     }
     if (Array.isArray(value)) {
       if (value.length === 0) {
         return `${kebabDirective}=()`;
       }
-      if (value.length === 1 && (value[0] === "*" || value[0] === "none")) {
-        return `${kebabDirective}=${value[0]}`;
+      if (value.length === 1 && value[0] === "*") {
+        return `${kebabDirective}=*`;
+      }
+      if (value.length === 1 && value[0] === "none") {
+        return `${kebabDirective}=()`;
       }
       const allowlist = value.map((item) => ["self", "src"].includes(item) ? item : `"${item}"`);
       return `${kebabDirective}=(${allowlist.join(" ")})`;

package/dist/node_modules/hono/dist/cjs/middleware/serve-static/index.js

@@ -45,7 +45,7 @@ const serveStatic = (options) => {
     } else {
       try {
         filename = (0, import_url.tryDecodeURI)(c.req.path);
-        if (/(?:^|[\/\\])\.{1,2}(?:$|[\/\\])|[\/\\]{2,}/.test(filename)) {
+        if (/(?:^|[\/\\])\.{1,2}(?:$|[\/\\])|[\/\\]{2,}|\\/.test(filename)) {
           throw new Error();
         }
       } catch {
@@ -65,7 +65,7 @@ const serveStatic = (options) => {
     if (content instanceof Response) {
       return c.newResponse(content.body, content);
     }
-    if (content) {
+    if (content != null) {
       const mimeType = options.mimes && (0, import_mime.getMimeType)(path, options.mimes) || (0, import_mime.getMimeType)(path);
       c.header("Content-Type", mimeType || "application/octet-stream");
       if (options.precompressed && (!mimeType || import_compress.COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {

package/dist/node_modules/hono/dist/cjs/middleware/timing/timing.js

@@ -56,7 +56,9 @@ const timing = (config) => {
       endTime(c, "total");
     }
     if (options.autoEnd) {
-      timers.forEach((_, key) => endTime(c, key));
+      timers.forEach((_, key) => {
+        endTime(c, key);
+      });
     }
     const enabled = typeof options.enabled === "function" ? options.enabled(c) : options.enabled;
     if (enabled) {

package/dist/node_modules/hono/dist/cjs/middleware/trailing-slash/index.js

@@ -41,14 +41,14 @@ const trimTrailingSlash = (options) => {
 const appendTrailingSlash = (options) => {
   return async function appendTrailingSlash2(c, next) {
     if (options?.alwaysRedirect) {
-      if ((c.req.method === "GET" || c.req.method === "HEAD") && c.req.path.at(-1) !== "/") {
+      if ((c.req.method === "GET" || c.req.method === "HEAD") && c.req.path.at(-1) !== "/" && !options.skip?.(c.req.path)) {
         const url = new URL(c.req.url);
         url.pathname += "/";
         return c.redirect(url.toString(), 301);
       }
     }
     await next();
-    if (!options?.alwaysRedirect && c.res.status === 404 && (c.req.method === "GET" || c.req.method === "HEAD") && c.req.path.at(-1) !== "/") {
+    if (!options?.alwaysRedirect && c.res.status === 404 && (c.req.method === "GET" || c.req.method === "HEAD") && c.req.path.at(-1) !== "/" && !options?.skip?.(c.req.path)) {
       const url = new URL(c.req.url);
       url.pathname += "/";
       c.res = c.redirect(url.toString(), 301);