@nocobase/plugin-mcp-server 2.4.0-alpha.8 → 2.4.0-alpha.9

package/dist/node_modules/fast-uri/test/urn-full-input.test.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+test('URN parsing validates the complete scheme-specific input', (t) => {
+  const embedded = fastURI.parse('urn:x|foo:bar')
+  t.equal(embedded.error, 'URN can not be parsed.', 'does not search for a later nid:nss substring')
+  t.equal(embedded.nid, undefined, 'does not adopt the later nid')
+  t.equal(embedded.nss, undefined, 'does not adopt the later nss')
+
+  const trailing = fastURI.parse('urn:foo:bar|ignored')
+  t.equal(trailing.error, 'URN can not be parsed.', 'rejects trailing input outside the RFC 2141 NSS grammar')
+  t.equal(trailing.nid, undefined, 'does not return an nid from a partial match')
+  t.equal(trailing.nss, undefined, 'does not return a truncated nss')
+
+  t.end()
+})
+
+test('URN parsing preserves the complete RFC 2141 NSS', (t) => {
+  const parsed = fastURI.parse('urn:foo:allowed/evil')
+  t.equal(parsed.error, undefined, 'accepts slash in an RFC 2141 NSS')
+  t.equal(parsed.nid, 'foo', 'parses the nid')
+  t.equal(parsed.nss, 'allowed/evil', 'preserves the complete NSS')
+  t.equal(fastURI.normalize('urn:foo:allowed/evil'), 'urn:foo:allowed/evil', 'normalization retains slash data')
+  t.equal(fastURI.equal('urn:foo:allowed/evil', 'urn:foo:allowed'), false, 'distinct NSS values do not compare equal')
+
+  t.end()
+})

package/dist/node_modules/fast-uri/test/util.test.js

@@ -2,22 +2,37 @@
 
 const test = require('tape')
 const {
-  stringArrayToHexStripped
+  stringArrayToHexStripped,
+  removeDotSegments
 } = require('../lib/utils')
 
 test('stringArrayToHexStripped', (t) => {
   const testCases = [
-    [[['0', '0', '0', '0']], ''],
-    [[['0', '0', '0', '0'], false], ''],
-    [[['0', '0', '0', '0'], true], '0'],
-    [[['0', '1', '0', '0'], false], '100'],
-    [[['1', '0', '0', '0'], false], '1000'],
-    [[['1', '0', '0', '0'], true], '1000']
+    [['0', '0', '0', '0'], ''],
+    [['0', '0', '0', '1'], '1'],
+    [['0', '0', '1', '0'], '10'],
+    [['0', '1', '0', '0'], '100'],
+    [['1', '0', '0', '0'], '1000'],
+    [['1', '0', '0', '1'], '1001'],
   ]
 
   t.plan(testCases.length)
 
   testCases.forEach(([input, expected]) => {
-    t.same(stringArrayToHexStripped(input[0], input[1]), expected)
+    t.same(stringArrayToHexStripped(input), expected)
+  })
+})
+
+// Just fixtures, because this function already tested by resolve
+test('removeDotSegments', (t) => {
+  const testCases = []
+  // https://github.com/fastify/fast-uri/issues/139
+  testCases.push(['WS:/WS://1305G130505:1&%0D:1&C(XXXXX*)))))))XXX130505:UUVUaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$aaaaaaaaaaaa13a',
+    'WS:/WS://1305G130505:1&%0D:1&C(XXXXX*)))))))XXX130505:UUVUaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$aaaaaaaaaaaa13a'])
+
+  t.plan(testCases.length)
+
+  testCases.forEach(([input, expected]) => {
+    t.same(removeDotSegments(input), expected)
   })
 })

package/dist/node_modules/fast-uri/test/websocket-query-preservation.test.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+test('WebSocket queries preserve additional question marks', (t) => {
+  for (const scheme of ['ws', 'wss']) {
+    const uri = `${scheme}://example.com/chat?a?b`
+    const truncatedURI = `${scheme}://example.com/chat?a`
+    const parsed = fastURI.parse(uri)
+
+    t.equal(parsed.resourceName, '/chat?a?b', `${scheme} parse preserves the resource name`)
+    t.equal(fastURI.serialize(parsed), uri, `${scheme} parsed components round-trip`)
+    t.equal(
+      fastURI.serialize({ scheme, host: 'example.com', resourceName: '/chat?a?b' }),
+      uri,
+      `${scheme} resource name serializes without truncation`
+    )
+    t.equal(fastURI.normalize(uri), uri, `${scheme} normalization preserves the full query`)
+    t.equal(fastURI.equal(uri, truncatedURI), false, `${scheme} equality distinguishes the full query`)
+  }
+
+  t.end()
+})

package/dist/node_modules/fast-uri/tsconfig.json

@@ -0,0 +1,9 @@
+{
+    "compilerOptions": {
+        "allowJs": true,
+        "checkJs": true,
+        "strict": true,
+        "noImplicitAny": true,
+        "target": "es2015"
+    }
+}

package/dist/node_modules/fast-uri/types/index.d.ts

@@ -10,6 +10,11 @@ declare namespace fastUri {
     query?: string;
     fragment?: string;
     reference?: string;
+    nid?: string;
+    nss?: string;
+    resourceName?: string;
+    secure?: boolean;
+    uuid?: string;
     error?: string;
   }
   export interface Options {
@@ -19,6 +24,8 @@ declare namespace fastUri {
     domainHost?: boolean;
     absolutePath?: boolean;
     tolerant?: boolean;
+    skipEscape?: boolean;
+    nid?: string;
   }
 
   /**
@@ -30,21 +37,21 @@ declare namespace fastUri {
    */
   export type URIComponents = URIComponent
 
-  export function normalize(uri: string, opts?: Options): string;
-  export function normalize(uri: URIComponent, opts?: Options): URIComponent;
-  export function normalize(uri: any, opts?: Options): any;
+  export function normalize (uri: string, opts?: Options): string
+  export function normalize (uri: URIComponent, opts?: Options): URIComponent
+  export function normalize (uri: any, opts?: Options): any
 
-  export function resolve(baseURI: string, relativeURI: string, options?: Options): string
+  export function resolve (baseURI: string, relativeURI: string, options?: Options): string
 
-  export function resolveComponent(base: URIComponent, relative: URIComponent, options?: Options, skipNormalization?: boolean): URIComponent
+  export function resolveComponent (base: URIComponent, relative: URIComponent, options?: Options, skipNormalization?: boolean): URIComponent
 
-  export function parse(uri: string, opts?: Options): URIComponent;
+  export function parse (uri: string, opts?: Options): URIComponent
 
-  export function serialize(component: URIComponent, opts?: Options): string;
+  export function serialize (component: URIComponent, opts?: Options): string
 
-  export function equal(uriA: string, uriB: string): boolean;
+  export function equal (uriA: string, uriB: string): boolean
 
-  export function resolve(base: string, path: string): string;
+  export function resolve (base: string, path: string): string
 
   export const fastUri: FastUri
   export { fastUri as default }

package/dist/node_modules/fast-uri/types/index.test-d.ts

@@ -1,14 +1,14 @@
-import uri, { URIComponents, URIComponent, Options, options } from "..";
-import { expectDeprecated, expectType } from "tsd";
+import uri, { URIComponents, URIComponent, Options, options } from '..'
+import { expectDeprecated, expectType } from 'tsd'
 
-const parsed = uri.parse("foo");
-expectType<URIComponents>(parsed);
-const parsed2 = uri.parse("foo", {
-    domainHost: true,
-    scheme: 'https',
-    unicodeSupport: false
+const parsed = uri.parse('foo')
+expectType<URIComponents>(parsed)
+const parsed2 = uri.parse('foo', {
+  domainHost: true,
+  scheme: 'https',
+  unicodeSupport: false
 })
-expectType<URIComponents>(parsed2);
+expectType<URIComponents>(parsed2)
 
 expectType<URIComponent>({} as URIComponents)
 expectDeprecated({} as URIComponents)

package/dist/node_modules/hono/README.md

@@ -64,7 +64,7 @@ Contributions Welcome! You can contribute in the following ways.
 
 - Create an Issue - Propose a new feature. Report a bug.
 - Pull Request - Fix a bug or typo. Refactor the code.
-- Create third-party middleware - See instructions below.
+- Create third-party middleware - See [Third-party middleware](docs/CONTRIBUTING.md#third-party-middleware).
 - Share - Share your thoughts on the Blog, X, and others.
 - Make your application - Please try to use Hono.
 

package/dist/node_modules/hono/dist/adapter/aws-lambda/handler.js

@@ -1,4 +1,5 @@
 // src/adapter/aws-lambda/handler.ts
+import { pipeline } from "node:stream/promises";
 import { decodeBase64, encodeBase64 } from "../../utils/encode.js";
 function sanitizeHeaderValue(value) {
   const hasNonAscii = /[^\x00-\x7F]/.test(value);
@@ -10,14 +11,14 @@ function sanitizeHeaderValue(value) {
 var getRequestContext = (event) => {
   return event.requestContext;
 };
-var streamToNodeStream = async (reader, writer) => {
+async function* readWebStream(reader) {
   let readResult = await reader.read();
   while (!readResult.done) {
-    writer.write(readResult.value);
+    yield readResult.value;
     readResult = await reader.read();
   }
-  writer.end();
-};
+}
+var streamToNodeStream = (reader, writer) => pipeline(readWebStream(reader), writer);
 var streamHandle = (app) => {
   return awslambda.streamifyResponse(
     async (event, responseStream, context) => {
@@ -62,8 +63,15 @@ var streamHandle = (app) => {
 var handle = (app, { isContentTypeBinary } = { isContentTypeBinary: void 0 }) => {
   return async (event, lambdaContext) => {
     const processor = getProcessor(event);
-    const req = processor.createRequest(event);
-    const requestContext = getRequestContext(event);
+    let req, requestContext;
+    try {
+      req = processor.createRequest(event);
+      requestContext = getRequestContext(event);
+    } catch (error) {
+      console.error("Error processing request:", error);
+      const errorResponse = error instanceof TypeError ? new Response("Invalid request", { status: 400 }) : new Response("Internal Server Error", { status: 500 });
+      return processor.createResult(event, errorResponse, { isContentTypeBinary });
+    }
     const res = await app.fetch(req, {
       event,
       requestContext,
@@ -102,7 +110,9 @@ var EventProcessor = class {
       method
     };
     if (event.body) {
-      requestInit.body = event.isBase64Encoded ? decodeBase64(event.body) : event.body;
+      const body = event.isBase64Encoded ? decodeBase64(event.body) : new TextEncoder().encode(event.body);
+      requestInit.body = body;
+      headers.set("content-length", body.length.toString());
     }
     return new Request(url, requestInit);
   }
@@ -192,7 +202,7 @@ var EventV1Processor = class extends EventProcessor {
         ([key, values]) => values.map((value) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&")
       ).join("&");
     } else {
-      return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value || "")}`).join("&");
+      return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value !== void 0).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value || "")}`).join("&");
     }
   }
   getCookies(_event, _headers) {
@@ -200,21 +210,17 @@ var EventV1Processor = class extends EventProcessor {
   getHeaders(event) {
     const headers = new Headers();
     this.getCookies(event, headers);
-    if (event.headers) {
-      for (const [k, v] of Object.entries(event.headers)) {
-        if (v) {
-          headers.set(k, sanitizeHeaderValue(v));
-        }
-      }
-    }
     if (event.multiValueHeaders) {
       for (const [k, values] of Object.entries(event.multiValueHeaders)) {
         if (values) {
-          const foundK = headers.get(k);
-          values.forEach((v) => {
-            const sanitizedValue = sanitizeHeaderValue(v);
-            return (!foundK || !foundK.includes(sanitizedValue)) && headers.append(k, sanitizedValue);
-          });
+          values.forEach((v) => headers.append(k, sanitizeHeaderValue(v)));
+        }
+      }
+    }
+    if (event.headers) {
+      for (const [k, v] of Object.entries(event.headers)) {
+        if (v && !headers.has(k)) {
+          headers.set(k, sanitizeHeaderValue(v));
         }
       }
     }
@@ -256,7 +262,7 @@ var ALBProcessor = class extends EventProcessor {
     if (event.multiValueQueryStringParameters) {
       return Object.entries(event.multiValueQueryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value.join(`&${key}=`)}`).join("&");
     } else {
-      return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value}`).join("&");
+      return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value !== void 0).map(([key, value]) => `${key}=${value}`).join("&");
     }
   }
   getCookies(event, headers) {
@@ -274,7 +280,7 @@ var ALBProcessor = class extends EventProcessor {
     if (result.multiValueHeaders) {
       result.multiValueHeaders["set-cookie"] = cookies;
     } else {
-      result.headers["set-cookie"] = cookies.join(", ");
+      result.headers["set-cookie"] = cookies[0];
     }
   }
 };
@@ -294,11 +300,7 @@ var LatticeV2Processor = class extends EventProcessor {
     if (event.headers) {
       for (const [k, values] of Object.entries(event.headers)) {
         if (values) {
-          const foundK = headers.get(k);
-          values.forEach((v) => {
-            const sanitizedValue = sanitizeHeaderValue(v);
-            return (!foundK || !foundK.includes(sanitizedValue)) && headers.append(k, sanitizedValue);
-          });
+          values.forEach((v) => headers.append(k, sanitizeHeaderValue(v)));
         }
       }
     }
@@ -309,7 +311,7 @@ var LatticeV2Processor = class extends EventProcessor {
   setCookiesToResult(result, cookies) {
     result.headers = {
       ...result.headers,
-      "set-cookie": cookies.join(", ")
+      "set-cookie": cookies
     };
   }
 };
@@ -333,7 +335,7 @@ var isProxyEventALB = (event) => {
   return false;
 };
 var isProxyEventV2 = (event) => {
-  return Object.hasOwn(event, "rawPath");
+  return Object.hasOwn(event, "rawPath") && Object.hasOwn(event.requestContext ?? {}, "http");
 };
 var isLatticeEventV2 = (event) => {
   if (event.requestContext) {
@@ -342,15 +344,15 @@ var isLatticeEventV2 = (event) => {
   return false;
 };
 var defaultIsContentTypeBinary = (contentType) => {
-  return !/^text\/(?:plain|html|css|javascript|csv)|(?:\/|\+)(?:json|xml)\s*(?:;|$)/.test(
+  if (/^application\/vnd\.(?:apple\.installer|mozilla\.xul)\+xml\s*(?:;|$)/i.test(contentType)) {
+    return true;
+  }
+  return !/^text\/(?:plain|html|css|javascript|csv)|(?:\/|\+)(?:json|xml)\s*(?:;|$)/i.test(
     contentType
   );
 };
 var isContentEncodingBinary = (contentEncoding) => {
-  if (contentEncoding === null) {
-    return false;
-  }
-  return /^(gzip|deflate|compress|br)/.test(contentEncoding);
+  return !!contentEncoding && !/^identity$/i.test(contentEncoding);
 };
 export {
   ALBProcessor,

package/dist/node_modules/hono/dist/adapter/bun/serve-static.js

@@ -2,7 +2,7 @@
 import { stat } from "node:fs/promises";
 import { join } from "node:path";
 import { serveStatic as baseServeStatic } from "../../middleware/serve-static/index.js";
-var serveStatic = (options) => {
+var serveStatic = (options = {}) => {
   return async function serveStatic2(c, next) {
     const getContent = async (path) => {
       const file = Bun.file(path);

package/dist/node_modules/hono/dist/adapter/bun/websocket.js

@@ -24,7 +24,9 @@ var upgradeWebSocket = defineWebSocketHelper((c, events) => {
     data: {
       events,
       url: new URL(c.req.url),
-      protocol: c.req.url
+      // The first requested subprotocol, exposed via WSContext.protocol to
+      // match the deno and cloudflare adapters.
+      protocol: c.req.header("sec-websocket-protocol")?.split(",")[0]?.trim() ?? ""
     }
   });
   if (upgradeResult) {

package/dist/node_modules/hono/dist/adapter/cloudflare-workers/serve-static.js

@@ -1,7 +1,7 @@
 // src/adapter/cloudflare-workers/serve-static.ts
 import { serveStatic as baseServeStatic } from "../../middleware/serve-static/index.js";
 import { getContentFromKVAsset } from "./utils.js";
-var serveStatic = (options) => {
+var serveStatic = (options = {}) => {
   return async function serveStatic2(c, next) {
     const getContent = async (path) => {
       return getContentFromKVAsset(path, {

package/dist/node_modules/hono/dist/adapter/deno/serve-static.js

@@ -2,7 +2,7 @@
 import { join } from "node:path";
 import { serveStatic as baseServeStatic } from "../../middleware/serve-static/index.js";
 var { open, lstatSync, errors } = Deno;
-var serveStatic = (options) => {
+var serveStatic = (options = {}) => {
   return async function serveStatic2(c, next) {
     const getContent = async (path) => {
       try {

package/dist/node_modules/hono/dist/adapter/deno/websocket.js

@@ -4,7 +4,11 @@ var upgradeWebSocket = defineWebSocketHelper(async (c, events, options) => {
   if (c.req.header("upgrade") !== "websocket") {
     return;
   }
-  const { response, socket } = Deno.upgradeWebSocket(c.req.raw, options ?? {});
+  const subprotocol = c.req.header("sec-websocket-protocol")?.split(",")[0]?.trim();
+  const { response, socket } = Deno.upgradeWebSocket(c.req.raw, {
+    ...subprotocol ? { protocol: subprotocol } : {},
+    ...options
+  });
   const wsContext = new WSContext({
     close: (code, reason) => socket.close(code, reason),
     get protocol() {

package/dist/node_modules/hono/dist/adapter/lambda-edge/handler.js

@@ -15,21 +15,32 @@ var convertHeaders = (headers) => {
 var handle = (app) => {
   return async (event, ...args) => {
     const [context, callback] = args;
-    const res = await app.fetch(createRequest(event), {
+    let callbackError = null;
+    let callbackResult;
+    const cf = getCloudFrontRecord(event);
+    const res = await app.fetch(createRequest(cf), {
       event,
       context,
       callback: (err, result) => {
+        if (!callbackError && !callbackResult) {
+          callbackError = err;
+          callbackResult = result;
+        }
         callback?.(err, result);
       },
-      config: event.Records[0].cf.config,
-      request: event.Records[0].cf.request,
-      response: event.Records[0].cf.response
+      config: cf.config,
+      request: cf.request,
+      response: cf.response
     });
-    return createResult(res);
+    if (callbackError) {
+      throw callbackError;
+    }
+    return callbackResult ?? createResult(res);
   };
 };
 var createResult = async (res) => {
-  const isBase64Encoded = isContentTypeBinary(res.headers.get("content-type") || "");
+  const contentEncoding = res.headers.get("content-encoding");
+  const isBase64Encoded = isContentTypeBinary(res.headers.get("content-type") || "") || !!contentEncoding && !/^identity$/i.test(contentEncoding);
   const body = isBase64Encoded ? encodeBase64(await res.arrayBuffer()) : await res.text();
   return {
     status: res.status.toString(),
@@ -38,18 +49,34 @@ var createResult = async (res) => {
     ...isBase64Encoded && { bodyEncoding: "base64" }
   };
 };
-var createRequest = (event) => {
-  const queryString = event.Records[0].cf.request.querystring;
-  const host = event.Records[0].cf.request.headers?.host?.[0]?.value || event.Records[0].cf.config.distributionDomainName;
-  const urlPath = `https://${host}${event.Records[0].cf.request.uri}`;
+var getCloudFrontRecord = (event) => {
+  const cf = event?.Records?.[0]?.cf;
+  if (!cf?.request) {
+    throw new TypeError(
+      "Unable to map the CloudFront event to a Request: expected `Records[0].cf.request` in the Lambda@Edge event."
+    );
+  }
+  return cf;
+};
+var createRequest = (cf) => {
+  const request = cf.request;
+  const queryString = request.querystring;
+  const host = request.headers?.host?.[0]?.value || cf.config?.distributionDomainName;
+  const urlPath = `https://${host}${request.uri}`;
   const url = queryString ? `${urlPath}?${queryString}` : urlPath;
   const headers = new Headers();
-  Object.entries(event.Records[0].cf.request.headers).forEach(([k, v]) => {
-    v.forEach((header) => headers.set(k, header.value));
+  Object.entries(request.headers ?? {}).forEach(([k, v]) => {
+    v.forEach((header) => headers.append(k, header.value));
   });
-  const requestBody = event.Records[0].cf.request.body;
-  const method = event.Records[0].cf.request.method;
-  const body = createBody(method, requestBody);
+  const requestBody = request.body;
+  const method = request.method;
+  const rawBody = createBody(method, requestBody);
+  let body = rawBody;
+  if (rawBody !== void 0) {
+    const bytes = typeof rawBody === "string" ? new TextEncoder().encode(rawBody) : rawBody;
+    body = bytes;
+    headers.set("content-length", bytes.length.toString());
+  }
   return new Request(url, {
     headers,
     method,
@@ -69,7 +96,10 @@ var createBody = (method, requestBody) => {
   return requestBody.data;
 };
 var isContentTypeBinary = (contentType) => {
-  return !/^(text\/(plain|html|css|javascript|csv).*|application\/(.*json|.*xml).*|image\/svg\+xml.*)$/.test(
+  if (/^application\/vnd\.(?:apple\.installer|mozilla\.xul)\+xml\s*(?:;|$)/i.test(contentType)) {
+    return true;
+  }
+  return !/^text\/(?:plain|html|css|javascript|csv)|(?:\/|\+)(?:json|xml)\s*(?:;|$)/i.test(
     contentType
   );
 };