mcp-use 1.2.4 → 1.2.5-canary.1

package/dist/src/server/index.js

@@ -7,42 +7,9 @@ import {
   McpServer as OfficialMcpServer,
   ResourceTemplate
 } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
 import { z } from "zod";
-import express from "express";
-import cors from "cors";
-import { existsSync, readdirSync } from "fs";
-import { join } from "path";
-import { readFileSync } from "fs";
-
-// src/server/logging.ts
-function requestLogger(req, res, next) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().substring(11, 23);
-  const method = req.method;
-  const url = req.url;
-  const originalEnd = res.end.bind(res);
-  res.end = function(chunk, encoding, cb) {
-    const statusCode = res.statusCode;
-    let statusColor = "";
-    if (statusCode >= 200 && statusCode < 300) {
-      statusColor = "\x1B[32m";
-    } else if (statusCode >= 300 && statusCode < 400) {
-      statusColor = "\x1B[33m";
-    } else if (statusCode >= 400 && statusCode < 500) {
-      statusColor = "\x1B[31m";
-    } else if (statusCode >= 500) {
-      statusColor = "\x1B[35m";
-    }
-    let logMessage = `[${timestamp}] ${method} \x1B[1m${url}\x1B[0m`;
-    if (method === "POST" && url === "/mcp" && req.body?.method) {
-      logMessage += ` \x1B[1m[${req.body.method}]\x1B[0m`;
-    }
-    logMessage += ` ${statusColor}${statusCode}\x1B[0m`;
-    console.log(logMessage);
-    return originalEnd(chunk, encoding, cb);
-  };
-  next();
-}
-__name(requestLogger, "requestLogger");
 
 // src/server/adapters/mcp-ui-adapter.ts
 import { createUIResource } from "@mcp-ui/server";
@@ -151,9 +118,264 @@ function createUIResourceFromDefinition(definition, params, config) {
 }
 __name(createUIResourceFromDefinition, "createUIResourceFromDefinition");
 
+// src/server/connect-adapter.ts
+function isExpressMiddleware(middleware) {
+  if (!middleware || typeof middleware !== "function") {
+    return false;
+  }
+  const paramCount = middleware.length;
+  if (paramCount === 3 || paramCount === 4) {
+    return true;
+  }
+  if (paramCount === 2) {
+    const fnString = middleware.toString();
+    const expressPatterns = [
+      /\bres\.(send|json|status|end|redirect|render|sendFile|download)\b/,
+      /\breq\.(body|params|query|cookies|session)\b/,
+      /\breq\.get\s*\(/,
+      /\bres\.set\s*\(/
+    ];
+    const hasExpressPattern = expressPatterns.some(
+      (pattern) => pattern.test(fnString)
+    );
+    if (hasExpressPattern) {
+      return true;
+    }
+    return false;
+  }
+  return false;
+}
+__name(isExpressMiddleware, "isExpressMiddleware");
+async function adaptMiddleware(middleware, middlewarePath = "*") {
+  if (isExpressMiddleware(middleware)) {
+    return adaptConnectMiddleware(middleware, middlewarePath);
+  }
+  return middleware;
+}
+__name(adaptMiddleware, "adaptMiddleware");
+async function adaptConnectMiddleware(connectMiddleware, middlewarePath) {
+  let createRequest;
+  let createResponse;
+  try {
+    const httpMocks = await import("node-mocks-http");
+    createRequest = httpMocks.createRequest;
+    createResponse = httpMocks.createResponse;
+  } catch (error) {
+    console.error(
+      "[WIDGETS] node-mocks-http not available. Install connect and node-mocks-http for Vite middleware support."
+    );
+    throw error;
+  }
+  let normalizedPath = middlewarePath;
+  if (normalizedPath.endsWith("*")) {
+    normalizedPath = normalizedPath.slice(0, -1);
+  }
+  if (normalizedPath.endsWith("/")) {
+    normalizedPath = normalizedPath.slice(0, -1);
+  }
+  const honoMiddleware = /* @__PURE__ */ __name(async (c, next) => {
+    const request = c.req.raw;
+    const parsedURL = new URL(request.url, "http://localhost");
+    const query = {};
+    for (const [key, value] of parsedURL.searchParams.entries()) {
+      query[key] = value;
+    }
+    let middlewarePathname = parsedURL.pathname;
+    if (normalizedPath && middlewarePathname.startsWith(normalizedPath)) {
+      middlewarePathname = middlewarePathname.substring(normalizedPath.length);
+      if (middlewarePathname === "") {
+        middlewarePathname = "/";
+      } else if (!middlewarePathname.startsWith("/")) {
+        middlewarePathname = "/" + middlewarePathname;
+      }
+    }
+    const mockRequest = createRequest({
+      method: request.method.toUpperCase(),
+      url: middlewarePathname + parsedURL.search,
+      headers: Object.fromEntries(request.headers.entries()),
+      query,
+      ...request.body && { body: request.body }
+    });
+    const mockResponse = createResponse();
+    let responseResolved = false;
+    const res = await new Promise((resolve) => {
+      const originalEnd = mockResponse.end.bind(mockResponse);
+      mockResponse.end = (...args) => {
+        const result = originalEnd(...args);
+        if (!responseResolved && mockResponse.writableEnded) {
+          responseResolved = true;
+          const statusCode = mockResponse.statusCode;
+          const noBodyStatuses = [204, 304];
+          const responseBody = noBodyStatuses.includes(statusCode) ? null : mockResponse._getData() || mockResponse._getBuffer() || null;
+          const connectResponse = new Response(responseBody, {
+            status: statusCode,
+            statusText: mockResponse.statusMessage,
+            headers: mockResponse.getHeaders()
+          });
+          resolve(connectResponse);
+        }
+        return result;
+      };
+      connectMiddleware(mockRequest, mockResponse, () => {
+        if (!responseResolved && !mockResponse.writableEnded) {
+          responseResolved = true;
+          const statusCode = mockResponse.statusCode;
+          const noBodyStatuses = [204, 304];
+          const responseBody = noBodyStatuses.includes(statusCode) ? null : mockResponse._getData() || mockResponse._getBuffer() || null;
+          const preparedHeaders = c.newResponse(null, 204, {}).headers;
+          for (const key of [...preparedHeaders.keys()]) {
+            if (preparedHeaders.has(key)) {
+              c.header(key, void 0);
+            }
+            if (c.res && c.res.headers.has(key)) {
+              c.res.headers.delete(key);
+            }
+          }
+          const connectHeaders = mockResponse.getHeaders();
+          for (const [key, value] of Object.entries(connectHeaders)) {
+            if (value !== void 0) {
+              c.header(
+                key,
+                Array.isArray(value) ? value.join(", ") : String(value)
+              );
+            }
+          }
+          c.status(statusCode);
+          if (noBodyStatuses.includes(statusCode)) {
+            resolve(c.newResponse(null, statusCode));
+          } else if (responseBody) {
+            resolve(c.body(responseBody));
+          } else {
+            resolve(void 0);
+          }
+        }
+      });
+    });
+    if (res) {
+      c.res = res;
+      return res;
+    }
+    await next();
+  }, "honoMiddleware");
+  return honoMiddleware;
+}
+__name(adaptConnectMiddleware, "adaptConnectMiddleware");
+
+// src/server/logging.ts
+async function requestLogger(c, next) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().substring(11, 23);
+  const method = c.req.method;
+  const url = c.req.url;
+  let body = null;
+  if (method === "POST" && url.includes("/mcp")) {
+    try {
+      const clonedRequest = c.req.raw.clone();
+      body = await clonedRequest.json().catch(() => null);
+    } catch {
+    }
+  }
+  await next();
+  const statusCode = c.res.status;
+  let statusColor = "";
+  if (statusCode >= 200 && statusCode < 300) {
+    statusColor = "\x1B[32m";
+  } else if (statusCode >= 300 && statusCode < 400) {
+    statusColor = "\x1B[33m";
+  } else if (statusCode >= 400 && statusCode < 500) {
+    statusColor = "\x1B[31m";
+  } else if (statusCode >= 500) {
+    statusColor = "\x1B[35m";
+  }
+  let logMessage = `[${timestamp}] ${method} \x1B[1m${new URL(url).pathname}\x1B[0m`;
+  if (method === "POST" && url.includes("/mcp") && body?.method) {
+    logMessage += ` \x1B[1m[${body.method}]\x1B[0m`;
+  }
+  logMessage += ` ${statusColor}${statusCode}\x1B[0m`;
+  console.log(logMessage);
+}
+__name(requestLogger, "requestLogger");
+
 // src/server/mcp-server.ts
-import { createServer } from "vite";
 var TMP_MCP_USE_DIR = ".mcp-use";
+var isDeno = typeof globalThis.Deno !== "undefined";
+function getEnv(key) {
+  if (isDeno) {
+    return globalThis.Deno.env.get(key);
+  }
+  return process.env[key];
+}
+__name(getEnv, "getEnv");
+function getCwd() {
+  if (isDeno) {
+    return globalThis.Deno.cwd();
+  }
+  return process.cwd();
+}
+__name(getCwd, "getCwd");
+var fsHelpers = {
+  async readFileSync(path, encoding = "utf8") {
+    if (isDeno) {
+      return await globalThis.Deno.readTextFile(path);
+    }
+    const { readFileSync } = await import("fs");
+    const result = readFileSync(path, encoding);
+    return typeof result === "string" ? result : result.toString(encoding);
+  },
+  async readFile(path) {
+    if (isDeno) {
+      const data = await globalThis.Deno.readFile(path);
+      return data.buffer;
+    }
+    const { readFileSync } = await import("fs");
+    const buffer = readFileSync(path);
+    return buffer.buffer.slice(
+      buffer.byteOffset,
+      buffer.byteOffset + buffer.byteLength
+    );
+  },
+  async existsSync(path) {
+    if (isDeno) {
+      try {
+        await globalThis.Deno.stat(path);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    const { existsSync } = await import("fs");
+    return existsSync(path);
+  },
+  async readdirSync(path) {
+    if (isDeno) {
+      const entries = [];
+      for await (const entry of globalThis.Deno.readDir(path)) {
+        entries.push(entry.name);
+      }
+      return entries;
+    }
+    const { readdirSync } = await import("fs");
+    return readdirSync(path);
+  }
+};
+var pathHelpers = {
+  join(...paths) {
+    if (isDeno) {
+      return paths.join("/").replace(/\/+/g, "/");
+    }
+    return paths.join("/").replace(/\/+/g, "/");
+  },
+  relative(from, to) {
+    const fromParts = from.split("/").filter((p) => p);
+    const toParts = to.split("/").filter((p) => p);
+    let i = 0;
+    while (i < fromParts.length && i < toParts.length && fromParts[i] === toParts[i]) {
+      i++;
+    }
+    const upCount = fromParts.length - i;
+    const relativeParts = [...Array(upCount).fill(".."), ...toParts.slice(i)];
+    return relativeParts.join("/");
+  }
+};
 var McpServer = class {
   static {
     __name(this, "McpServer");
@@ -167,14 +389,14 @@ var McpServer = class {
   serverHost;
   serverBaseUrl;
   /**
-   * Creates a new MCP server instance with Express integration
+   * Creates a new MCP server instance with Hono integration
    *
    * Initializes the server with the provided configuration, sets up CORS headers,
    * configures widget serving routes, and creates a proxy that allows direct
-   * access to Express methods while preserving MCP server functionality.
+   * access to Hono methods while preserving MCP server functionality.
    *
    * @param config - Server configuration including name, version, and description
-   * @returns A proxied McpServer instance that supports both MCP and Express methods
+   * @returns A proxied McpServer instance that supports both MCP and Hono methods
    */
   constructor(config) {
     this.config = config;
@@ -184,13 +406,13 @@ var McpServer = class {
       name: config.name,
       version: config.version
     });
-    this.app = express();
-    this.app.use(express.json());
+    this.app = new Hono();
     this.app.use(
+      "*",
       cors({
         origin: "*",
-        methods: ["GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS"],
-        allowedHeaders: [
+        allowMethods: ["GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS"],
+        allowHeaders: [
           "Content-Type",
           "Accept",
           "Authorization",
@@ -201,9 +423,55 @@ var McpServer = class {
         ]
       })
     );
-    this.app.use(requestLogger);
+    this.app.use("*", requestLogger);
     return new Proxy(this, {
       get(target, prop) {
+        if (prop === "use") {
+          return (...args) => {
+            const hasPath = typeof args[0] === "string";
+            const path = hasPath ? args[0] : "*";
+            const handlers = hasPath ? args.slice(1) : args;
+            const adaptedHandlers = handlers.map((handler) => {
+              if (isExpressMiddleware(handler)) {
+                return { __isExpressMiddleware: true, handler, path };
+              }
+              return handler;
+            });
+            const hasExpressMiddleware = adaptedHandlers.some(
+              (h) => h.__isExpressMiddleware
+            );
+            if (hasExpressMiddleware) {
+              Promise.all(
+                adaptedHandlers.map(async (h) => {
+                  if (h.__isExpressMiddleware) {
+                    const adapted = await adaptConnectMiddleware(
+                      h.handler,
+                      h.path
+                    );
+                    if (hasPath) {
+                      target.app.use(path, adapted);
+                    } else {
+                      target.app.use(adapted);
+                    }
+                  } else {
+                    if (hasPath) {
+                      target.app.use(path, h);
+                    } else {
+                      target.app.use(h);
+                    }
+                  }
+                })
+              ).catch((err) => {
+                console.error(
+                  "[MIDDLEWARE] Failed to adapt Express middleware:",
+                  err
+                );
+              });
+              return target;
+            }
+            return target.app.use(...args);
+          };
+        }
         if (prop in target) {
           return target[prop];
         }
@@ -737,7 +1005,7 @@ var McpServer = class {
    * @returns true if in production mode, false otherwise
    */
   isProductionMode() {
-    return process.env.NODE_ENV === "production";
+    return getEnv("NODE_ENV") === "production";
   }
   /**
    * Read build manifest file
@@ -745,14 +1013,14 @@ var McpServer = class {
    * @private
    * @returns Build manifest or null if not found
    */
-  readBuildManifest() {
+  async readBuildManifest() {
     try {
-      const manifestPath = join(
-        process.cwd(),
+      const manifestPath = pathHelpers.join(
+        getCwd(),
         "dist",
-        ".mcp-use-manifest.json"
+        "mcp-use.json"
       );
-      const content = readFileSync(manifestPath, "utf8");
+      const content = await fsHelpers.readFileSync(manifestPath, "utf8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -770,9 +1038,11 @@ var McpServer = class {
    * @returns Promise that resolves when all widgets are mounted
    */
   async mountWidgets(options) {
-    if (this.isProductionMode()) {
+    if (this.isProductionMode() || isDeno) {
+      console.log("[WIDGETS] Mounting widgets in production mode");
       await this.mountWidgetsProduction(options);
     } else {
+      console.log("[WIDGETS] Mounting widgets in development mode");
       await this.mountWidgetsDev(options);
     }
   }
@@ -793,7 +1063,7 @@ var McpServer = class {
     const { promises: fs } = await import("fs");
     const baseRoute = options?.baseRoute || "/mcp-use/widgets";
     const resourcesDir = options?.resourcesDir || "resources";
-    const srcDir = join(process.cwd(), resourcesDir);
+    const srcDir = pathHelpers.join(getCwd(), resourcesDir);
     try {
       await fs.access(srcDir);
     } catch (error) {
@@ -805,7 +1075,7 @@ var McpServer = class {
     let entries = [];
     try {
       const files = await fs.readdir(srcDir);
-      entries = files.filter((f) => f.endsWith(".tsx") || f.endsWith(".ts")).map((f) => join(srcDir, f));
+      entries = files.filter((f) => f.endsWith(".tsx") || f.endsWith(".ts")).map((f) => pathHelpers.join(srcDir, f));
     } catch (error) {
       console.log(`[WIDGETS] No widgets found in ${resourcesDir}/ directory`);
       return;
@@ -814,12 +1084,32 @@ var McpServer = class {
       console.log(`[WIDGETS] No widgets found in ${resourcesDir}/ directory`);
       return;
     }
-    const tempDir = join(process.cwd(), TMP_MCP_USE_DIR);
+    const tempDir = pathHelpers.join(getCwd(), TMP_MCP_USE_DIR);
     await fs.mkdir(tempDir, { recursive: true }).catch(() => {
     });
-    const react = (await import("@vitejs/plugin-react")).default;
-    const tailwindcss = (await import("@tailwindcss/vite")).default;
-    console.log(react, tailwindcss);
+    let createServer;
+    let react;
+    let tailwindcss;
+    try {
+      const viteModule = await new Function('return import("vite")')();
+      createServer = viteModule.createServer;
+      const reactModule = await new Function(
+        'return import("@vitejs/plugin-react")'
+      )();
+      react = reactModule.default;
+      const tailwindModule = await new Function(
+        'return import("@tailwindcss/vite")'
+      )();
+      tailwindcss = tailwindModule.default;
+    } catch (error) {
+      console.error(
+        "[WIDGETS] Dev dependencies not available. Install vite, @vitejs/plugin-react, and @tailwindcss/vite for widget development."
+      );
+      console.error(
+        "[WIDGETS] For production, use 'mcp-use build' to pre-build widgets."
+      );
+      return;
+    }
     const widgets = entries.map((entry) => {
       const baseName = entry.split("/").pop()?.replace(/\.tsx?$/, "") || "widget";
       const widgetName = baseName;
@@ -830,20 +1120,20 @@ var McpServer = class {
       };
     });
     for (const widget of widgets) {
-      const widgetTempDir = join(tempDir, widget.name);
+      const widgetTempDir = pathHelpers.join(tempDir, widget.name);
       await fs.mkdir(widgetTempDir, { recursive: true });
-      const resourcesPath = join(process.cwd(), resourcesDir);
-      const { relative } = await import("path");
-      const relativeResourcesPath = relative(
-        widgetTempDir,
-        resourcesPath
-      ).replace(/\\/g, "/");
+      const resourcesPath = pathHelpers.join(getCwd(), resourcesDir);
+      const relativeResourcesPath = pathHelpers.relative(widgetTempDir, resourcesPath).replace(/\\/g, "/");
       const cssContent = `@import "tailwindcss";
 
 /* Configure Tailwind to scan the resources directory */
 @source "${relativeResourcesPath}";
 `;
-      await fs.writeFile(join(widgetTempDir, "styles.css"), cssContent, "utf8");
+      await fs.writeFile(
+        pathHelpers.join(widgetTempDir, "styles.css"),
+        cssContent,
+        "utf8"
+      );
       const entryContent = `import React from 'react'
 import { createRoot } from 'react-dom/client'
 import './styles.css'
@@ -868,12 +1158,12 @@ if (container && Component) {
   </body>
 </html>`;
       await fs.writeFile(
-        join(widgetTempDir, "entry.tsx"),
+        pathHelpers.join(widgetTempDir, "entry.tsx"),
         entryContent,
         "utf8"
       );
       await fs.writeFile(
-        join(widgetTempDir, "index.html"),
+        pathHelpers.join(widgetTempDir, "index.html"),
         htmlContent,
         "utf8"
       );
@@ -888,7 +1178,7 @@ if (container && Component) {
       plugins: [tailwindcss(), react()],
       resolve: {
         alias: {
-          "@": join(process.cwd(), resourcesDir)
+          "@": pathHelpers.join(getCwd(), resourcesDir)
         }
       },
       server: {
@@ -896,22 +1186,38 @@ if (container && Component) {
         origin: serverOrigin
       }
     });
-    this.app.use(baseRoute, (req, res, next) => {
-      const urlPath = req.url || "";
-      const [pathname, queryString] = urlPath.split("?");
-      const widgetMatch = pathname.match(/^\/([^/]+)/);
+    this.app.use(`${baseRoute}/*`, async (c, next) => {
+      const url = new URL(c.req.url);
+      const pathname = url.pathname;
+      const widgetMatch = pathname.replace(baseRoute, "").match(/^\/([^/]+)/);
       if (widgetMatch) {
         const widgetName = widgetMatch[1];
         const widget = widgets.find((w) => w.name === widgetName);
         if (widget) {
-          if (pathname === `/${widgetName}` || pathname === `/${widgetName}/`) {
-            req.url = `/${widgetName}/index.html${queryString ? "?" + queryString : ""}`;
+          const relativePath = pathname.replace(baseRoute, "");
+          if (relativePath === `/${widgetName}` || relativePath === `/${widgetName}/`) {
+            const newUrl = new URL(c.req.url);
+            newUrl.pathname = `${baseRoute}/${widgetName}/index.html`;
+            const newRequest = new Request(newUrl.toString(), c.req.raw);
+            Object.defineProperty(c, "req", {
+              value: {
+                ...c.req,
+                url: newUrl.toString(),
+                raw: newRequest
+              },
+              writable: false,
+              configurable: true
+            });
           }
         }
       }
-      next();
+      await next();
     });
-    this.app.use(baseRoute, viteServer.middlewares);
+    const viteMiddleware = await adaptConnectMiddleware(
+      viteServer.middlewares,
+      `${baseRoute}/*`
+    );
+    this.app.use(`${baseRoute}/*`, viteMiddleware);
     widgets.forEach((widget) => {
       console.log(
         `[WIDGET] ${widget.name} mounted at ${baseRoute}/${widget.name}`
@@ -947,8 +1253,11 @@ if (container && Component) {
       console.log("[WIDGET dev] Metadata:", metadata);
       let html = "";
       try {
-        html = readFileSync(join(tempDir, widget.name, "index.html"), "utf8");
-        const mcpUrl = process.env.MCP_URL || "/";
+        html = await fsHelpers.readFileSync(
+          pathHelpers.join(tempDir, widget.name, "index.html"),
+          "utf8"
+        );
+        const mcpUrl = getEnv("MCP_URL") || "/";
         if (mcpUrl && html) {
           const htmlWithoutComments = html.replace(/<!--[\s\S]*?-->/g, "");
           const baseTagRegex = /<base\s+[^>]*\/?>/i;
@@ -1048,22 +1357,46 @@ if (container && Component) {
    */
   async mountWidgetsProduction(options) {
     const baseRoute = options?.baseRoute || "/mcp-use/widgets";
-    const widgetsDir = join(process.cwd(), "dist", "resources", "widgets");
-    if (!existsSync(widgetsDir)) {
+    const widgetsDir = pathHelpers.join(
+      getCwd(),
+      "dist",
+      "resources",
+      "widgets"
+    );
+    console.log("widgetsDir", widgetsDir);
+    this.setupWidgetRoutes();
+    const manifestPath = pathHelpers.join(getCwd(), "dist", "mcp-use.json");
+    let widgets = [];
+    try {
+      const manifestContent = await fsHelpers.readFileSync(manifestPath, "utf8");
+      const manifest = JSON.parse(manifestContent);
+      if (manifest.widgets && Array.isArray(manifest.widgets)) {
+        widgets = manifest.widgets;
+        console.log(`[WIDGETS] Loaded ${widgets.length} widget(s) from manifest`);
+      } else {
+        console.log("[WIDGETS] No widgets array found in manifest");
+      }
+    } catch (error) {
       console.log(
-        "[WIDGETS] No dist/resources/widgets/ directory found - skipping widget serving"
+        "[WIDGETS] Could not read manifest file, falling back to directory listing:",
+        error
       );
-      return;
+      try {
+        const allEntries = await fsHelpers.readdirSync(widgetsDir);
+        for (const name of allEntries) {
+          const widgetPath = pathHelpers.join(widgetsDir, name);
+          const indexPath = pathHelpers.join(widgetPath, "index.html");
+          if (await fsHelpers.existsSync(indexPath)) {
+            widgets.push(name);
+          }
+        }
+      } catch (dirError) {
+        console.log("[WIDGETS] Directory listing also failed:", dirError);
+      }
     }
-    this.setupWidgetRoutes();
-    const widgets = readdirSync(widgetsDir).filter((name) => {
-      const widgetPath = join(widgetsDir, name);
-      const indexPath = join(widgetPath, "index.html");
-      return existsSync(indexPath);
-    });
     if (widgets.length === 0) {
       console.log(
-        "[WIDGETS] No built widgets found in dist/resources/widgets/"
+        "[WIDGETS] No built widgets found"
       );
       return;
     }
@@ -1071,13 +1404,13 @@ if (container && Component) {
       `[WIDGETS] Serving ${widgets.length} pre-built widget(s) from dist/resources/widgets/`
     );
     for (const widgetName of widgets) {
-      const widgetPath = join(widgetsDir, widgetName);
-      const indexPath = join(widgetPath, "index.html");
-      const metadataPath = join(widgetPath, "metadata.json");
+      const widgetPath = pathHelpers.join(widgetsDir, widgetName);
+      const indexPath = pathHelpers.join(widgetPath, "index.html");
+      const metadataPath = pathHelpers.join(widgetPath, "metadata.json");
       let html = "";
       try {
-        html = readFileSync(indexPath, "utf8");
-        const mcpUrl = process.env.MCP_URL || "/";
+        html = await fsHelpers.readFileSync(indexPath, "utf8");
+        const mcpUrl = getEnv("MCP_URL") || "/";
         if (mcpUrl && html) {
           const htmlWithoutComments = html.replace(/<!--[\s\S]*?-->/g, "");
           const baseTagRegex = /<base\s+[^>]*\/?>/i;
@@ -1124,7 +1457,10 @@ if (container && Component) {
       let props = {};
       let description = `Widget: ${widgetName}`;
       try {
-        const metadataContent = readFileSync(metadataPath, "utf8");
+        const metadataContent = await fsHelpers.readFileSync(
+          metadataPath,
+          "utf8"
+        );
         metadata = JSON.parse(metadataContent);
         if (metadata.description) {
           description = metadata.description;
@@ -1207,47 +1543,182 @@ if (container && Component) {
     if (this.mcpMounted) return;
     const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
     const endpoint = "/mcp";
-    this.app.post(endpoint, express.json(), async (req, res) => {
+    const createExpressLikeObjects = /* @__PURE__ */ __name((c) => {
+      const req = c.req.raw;
+      const responseBody = [];
+      let statusCode = 200;
+      const headers = {};
+      let ended = false;
+      let headersSent = false;
+      const expressReq = {
+        ...req,
+        url: new URL(req.url).pathname + new URL(req.url).search,
+        originalUrl: req.url,
+        baseUrl: "",
+        path: new URL(req.url).pathname,
+        query: Object.fromEntries(new URL(req.url).searchParams),
+        params: {},
+        body: {},
+        headers: Object.fromEntries(req.headers.entries()),
+        method: req.method
+      };
+      const expressRes = {
+        statusCode: 200,
+        headersSent: false,
+        status: /* @__PURE__ */ __name((code) => {
+          statusCode = code;
+          expressRes.statusCode = code;
+          return expressRes;
+        }, "status"),
+        setHeader: /* @__PURE__ */ __name((name, value) => {
+          if (!headersSent) {
+            headers[name] = Array.isArray(value) ? value.join(", ") : value;
+          }
+        }, "setHeader"),
+        getHeader: /* @__PURE__ */ __name((name) => headers[name], "getHeader"),
+        write: /* @__PURE__ */ __name((chunk, encoding, callback) => {
+          if (!ended) {
+            const data = typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
+            responseBody.push(data);
+          }
+          if (typeof encoding === "function") {
+            encoding();
+          } else if (callback) {
+            callback();
+          }
+          return true;
+        }, "write"),
+        end: /* @__PURE__ */ __name((chunk, encoding, callback) => {
+          if (chunk && !ended) {
+            const data = typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
+            responseBody.push(data);
+          }
+          ended = true;
+          if (typeof encoding === "function") {
+            encoding();
+          } else if (callback) {
+            callback();
+          }
+        }, "end"),
+        on: /* @__PURE__ */ __name((event, handler) => {
+          if (event === "close") {
+            expressRes._closeHandler = handler;
+          }
+        }, "on"),
+        once: /* @__PURE__ */ __name(() => {
+        }, "once"),
+        removeListener: /* @__PURE__ */ __name(() => {
+        }, "removeListener"),
+        writeHead: /* @__PURE__ */ __name((code, _headers) => {
+          statusCode = code;
+          expressRes.statusCode = code;
+          headersSent = true;
+          if (_headers) {
+            Object.assign(headers, _headers);
+          }
+          return expressRes;
+        }, "writeHead"),
+        flushHeaders: /* @__PURE__ */ __name(() => {
+          headersSent = true;
+        }, "flushHeaders"),
+        send: /* @__PURE__ */ __name((body) => {
+          if (!ended) {
+            expressRes.write(body);
+            expressRes.end();
+          }
+        }, "send")
+      };
+      return {
+        expressReq,
+        expressRes,
+        getResponse: /* @__PURE__ */ __name(() => {
+          if (ended) {
+            if (responseBody.length > 0) {
+              const body = isDeno ? Buffer.concat(responseBody) : Buffer.concat(responseBody);
+              return new Response(body, {
+                status: statusCode,
+                headers
+              });
+            } else {
+              return new Response(null, {
+                status: statusCode,
+                headers
+              });
+            }
+          }
+          return null;
+        }, "getResponse")
+      };
+    }, "createExpressLikeObjects");
+    this.app.post(endpoint, async (c) => {
+      const { expressReq, expressRes, getResponse } = createExpressLikeObjects(c);
+      try {
+        expressReq.body = await c.req.json();
+      } catch {
+        expressReq.body = {};
+      }
       const transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: void 0,
         enableJsonResponse: true
       });
-      res.on("close", () => {
-        transport.close();
-      });
+      if (expressRes._closeHandler) {
+        c.req.raw.signal?.addEventListener("abort", () => {
+          transport.close();
+        });
+      }
       await this.server.connect(transport);
-      await transport.handleRequest(req, res, req.body);
+      await transport.handleRequest(expressReq, expressRes, expressReq.body);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      const response = getResponse();
+      if (response) {
+        return response;
+      }
+      return c.text("", 200);
     });
-    this.app.get(endpoint, async (req, res) => {
+    this.app.get(endpoint, async (c) => {
+      const { expressReq, expressRes, getResponse } = createExpressLikeObjects(c);
       const transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: void 0,
         enableJsonResponse: true
       });
-      res.on("close", () => {
+      c.req.raw.signal?.addEventListener("abort", () => {
         transport.close();
       });
       await this.server.connect(transport);
-      await transport.handleRequest(req, res);
+      await transport.handleRequest(expressReq, expressRes);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      const response = getResponse();
+      if (response) {
+        return response;
+      }
+      return c.text("", 200);
     });
-    this.app.delete(endpoint, async (req, res) => {
+    this.app.delete(endpoint, async (c) => {
+      const { expressReq, expressRes, getResponse } = createExpressLikeObjects(c);
       const transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: void 0,
         enableJsonResponse: true
       });
-      res.on("close", () => {
+      c.req.raw.signal?.addEventListener("abort", () => {
         transport.close();
       });
       await this.server.connect(transport);
-      await transport.handleRequest(req, res);
+      await transport.handleRequest(expressReq, expressRes);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      const response = getResponse();
+      if (response) {
+        return response;
+      }
+      return c.text("", 200);
     });
     this.mcpMounted = true;
     console.log(`[MCP] Server mounted at ${endpoint}`);
   }
   /**
-   * Start the Express server with MCP endpoints
+   * Start the Hono server with MCP endpoints
    *
    * Initiates the server startup process by mounting MCP endpoints, configuring
-   * the inspector UI (if available), and starting the Express server to listen
+   * the inspector UI (if available), and starting the server to listen
    * for incoming connections. This is the main entry point for running the server.
    *
    * The server will be accessible at the specified port with MCP endpoints at /mcp
@@ -1265,24 +1736,125 @@ if (container && Component) {
    * ```
    */
   async listen(port) {
-    this.serverPort = port || (process.env.PORT ? parseInt(process.env.PORT, 10) : 3001);
-    if (process.env.HOST) {
-      this.serverHost = process.env.HOST;
+    const portEnv = getEnv("PORT");
+    this.serverPort = port || (portEnv ? parseInt(portEnv, 10) : 3001);
+    const hostEnv = getEnv("HOST");
+    if (hostEnv) {
+      this.serverHost = hostEnv;
     }
     await this.mountWidgets({
       baseRoute: "/mcp-use/widgets",
       resourcesDir: "resources"
     });
     await this.mountMcp();
-    this.mountInspector();
-    this.app.listen(this.serverPort, () => {
+    await this.mountInspector();
+    if (isDeno) {
+      globalThis.Deno.serve(
+        { port: this.serverPort, hostname: this.serverHost },
+        this.app.fetch
+      );
       console.log(
         `[SERVER] Listening on http://${this.serverHost}:${this.serverPort}`
       );
       console.log(
         `[MCP] Endpoints: http://${this.serverHost}:${this.serverPort}/mcp`
       );
+    } else {
+      const { serve } = await import("@hono/node-server");
+      serve(
+        {
+          fetch: this.app.fetch,
+          port: this.serverPort,
+          hostname: this.serverHost
+        },
+        (_info) => {
+          console.log(
+            `[SERVER] Listening on http://${this.serverHost}:${this.serverPort}`
+          );
+          console.log(
+            `[MCP] Endpoints: http://${this.serverHost}:${this.serverPort}/mcp`
+          );
+        }
+      );
+    }
+  }
+  /**
+   * Get the fetch handler for the server after mounting all endpoints
+   *
+   * This method prepares the server by mounting MCP endpoints, widgets, and inspector
+   * (if available), then returns the fetch handler. This is useful for integrating
+   * with external server frameworks like Supabase Edge Functions, Cloudflare Workers,
+   * or other platforms that handle the server lifecycle themselves.
+   *
+   * Unlike `listen()`, this method does not start a server - it only prepares the
+   * routes and returns the handler function that can be used with external servers.
+   *
+   * @param options - Optional configuration for the handler
+   * @param options.provider - Platform provider (e.g., 'supabase') to handle platform-specific path rewriting
+   * @returns Promise that resolves to the fetch handler function
+   *
+   * @example
+   * ```typescript
+   * // For Supabase Edge Functions (handles path rewriting automatically)
+   * const server = createMCPServer('my-server');
+   * server.tool({ ... });
+   * const handler = await server.getHandler({ provider: 'supabase' });
+   * Deno.serve(handler);
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // For Cloudflare Workers
+   * const server = createMCPServer('my-server');
+   * server.tool({ ... });
+   * const handler = await server.getHandler();
+   * export default { fetch: handler };
+   * ```
+   */
+  async getHandler(options) {
+    console.log("[MCP] Mounting widgets");
+    await this.mountWidgets({
+      baseRoute: "/mcp-use/widgets",
+      resourcesDir: "resources"
     });
+    console.log("[MCP] Mounted widgets");
+    await this.mountMcp();
+    console.log("[MCP] Mounted MCP");
+    console.log("[MCP] Mounting inspector");
+    await this.mountInspector();
+    console.log("[MCP] Mounted inspector");
+    const fetchHandler = this.app.fetch.bind(this.app);
+    if (options?.provider === "supabase") {
+      return async (req) => {
+        const url = new URL(req.url);
+        const pathname = url.pathname;
+        let newPathname = pathname;
+        const functionsMatch = pathname.match(
+          /^\/functions\/v1\/[^/]+(\/.*)?$/
+        );
+        if (functionsMatch) {
+          newPathname = functionsMatch[1] || "/";
+        } else {
+          const functionNameMatch = pathname.match(/^\/([^/]+)(\/.*)?$/);
+          if (functionNameMatch && functionNameMatch[2]) {
+            newPathname = functionNameMatch[2] || "/";
+          }
+        }
+        const newUrl = new URL(newPathname + url.search, url.origin);
+        const newReq = new Request(newUrl, {
+          method: req.method,
+          headers: req.headers,
+          body: req.body,
+          redirect: req.redirect
+        });
+        const result = await fetchHandler(newReq);
+        return result;
+      };
+    }
+    return async (req) => {
+      const result = await fetchHandler(req);
+      return result;
+    };
   }
   /**
    * Mount MCP Inspector UI at /inspector
@@ -1306,10 +1878,10 @@ if (container && Component) {
    * - Server continues to function normally
    * - No inspector UI available
    */
-  mountInspector() {
+  async mountInspector() {
     if (this.inspectorMounted) return;
     if (this.isProductionMode()) {
-      const manifest = this.readBuildManifest();
+      const manifest = await this.readBuildManifest();
       if (!manifest?.includeInspector) {
         console.log(
           "[INSPECTOR] Skipped in production (use --with-inspector flag during build)"
@@ -1317,19 +1889,20 @@ if (container && Component) {
         return;
       }
     }
-    import("@mcp-use/inspector").then(({ mountInspector }) => {
+    try {
+      const { mountInspector } = await import("@mcp-use/inspector");
       mountInspector(this.app);
       this.inspectorMounted = true;
       console.log(
         `[INSPECTOR] UI available at http://${this.serverHost}:${this.serverPort}/inspector`
       );
-    }).catch(() => {
-    });
+    } catch {
+    }
   }
   /**
    * Setup default widget serving routes
    *
-   * Configures Express routes to serve MCP UI widgets and their static assets.
+   * Configures Hono routes to serve MCP UI widgets and their static assets.
    * Widgets are served from the dist/resources/widgets directory and can
    * be accessed via HTTP endpoints for embedding in web applications.
    *
@@ -1348,11 +1921,11 @@ if (container && Component) {
    * - http://localhost:3001/mcp-use/widgets/assets/script.js (auto-discovered)
    */
   setupWidgetRoutes() {
-    this.app.get("/mcp-use/widgets/:widget/assets/*", (req, res, next) => {
-      const widget = req.params.widget;
-      const assetFile = req.params[0];
-      const assetPath = join(
-        process.cwd(),
+    this.app.get("/mcp-use/widgets/:widget/assets/*", async (c) => {
+      const widget = c.req.param("widget");
+      const assetFile = c.req.path.split("/assets/")[1];
+      const assetPath = pathHelpers.join(
+        getCwd(),
         "dist",
         "resources",
         "widgets",
@@ -1360,48 +1933,82 @@ if (container && Component) {
         "assets",
         assetFile
       );
-      res.sendFile(assetPath, (err) => err ? next() : void 0);
+      try {
+        if (await fsHelpers.existsSync(assetPath)) {
+          const content = await fsHelpers.readFile(assetPath);
+          const ext = assetFile.split(".").pop()?.toLowerCase();
+          const contentType = ext === "js" ? "application/javascript" : ext === "css" ? "text/css" : ext === "png" ? "image/png" : ext === "jpg" || ext === "jpeg" ? "image/jpeg" : ext === "svg" ? "image/svg+xml" : "application/octet-stream";
+          return new Response(content, {
+            status: 200,
+            headers: { "Content-Type": contentType }
+          });
+        }
+        return c.notFound();
+      } catch {
+        return c.notFound();
+      }
     });
-    this.app.get("/mcp-use/widgets/assets/*", (req, res, next) => {
-      const assetFile = req.params[0];
-      const widgetsDir = join(process.cwd(), "dist", "resources", "widgets");
+    this.app.get("/mcp-use/widgets/assets/*", async (c) => {
+      const assetFile = c.req.path.split("/assets/")[1];
+      const widgetsDir = pathHelpers.join(
+        getCwd(),
+        "dist",
+        "resources",
+        "widgets"
+      );
       try {
-        const widgets = readdirSync(widgetsDir);
+        const widgets = await fsHelpers.readdirSync(widgetsDir);
         for (const widget of widgets) {
-          const assetPath = join(widgetsDir, widget, "assets", assetFile);
-          if (existsSync(assetPath)) {
-            return res.sendFile(assetPath);
+          const assetPath = pathHelpers.join(
+            widgetsDir,
+            widget,
+            "assets",
+            assetFile
+          );
+          if (await fsHelpers.existsSync(assetPath)) {
+            const content = await fsHelpers.readFile(assetPath);
+            const ext = assetFile.split(".").pop()?.toLowerCase();
+            const contentType = ext === "js" ? "application/javascript" : ext === "css" ? "text/css" : ext === "png" ? "image/png" : ext === "jpg" || ext === "jpeg" ? "image/jpeg" : ext === "svg" ? "image/svg+xml" : "application/octet-stream";
+            return new Response(content, {
+              status: 200,
+              headers: { "Content-Type": contentType }
+            });
           }
         }
-        next();
+        return c.notFound();
       } catch {
-        next();
+        return c.notFound();
       }
     });
-    this.app.get("/mcp-use/widgets/:widget", (req, res, next) => {
-      const filePath = join(
-        process.cwd(),
+    this.app.get("/mcp-use/widgets/:widget", async (c) => {
+      const widget = c.req.param("widget");
+      const filePath = pathHelpers.join(
+        getCwd(),
         "dist",
         "resources",
         "widgets",
-        req.params.widget,
+        widget,
         "index.html"
       );
-      let html = readFileSync(filePath, "utf8");
-      html = html.replace(
-        /src="\/mcp-use\/widgets\/([^"]+)"/g,
-        `src="${this.serverBaseUrl}/mcp-use/widgets/$1"`
-      );
-      html = html.replace(
-        /href="\/mcp-use\/widgets\/([^"]+)"/g,
-        `href="${this.serverBaseUrl}/mcp-use/widgets/$1"`
-      );
-      html = html.replace(
-        /<head[^>]*>/i,
-        `<head>
-    <script>window.__getFile = (filename) => { return "${this.serverBaseUrl}/mcp-use/widgets/${req.params.widget}/"+filename }</script>`
-      );
-      res.send(html);
+      try {
+        let html = await fsHelpers.readFileSync(filePath, "utf8");
+        html = html.replace(
+          /src="\/mcp-use\/widgets\/([^"]+)"/g,
+          `src="${this.serverBaseUrl}/mcp-use/widgets/$1"`
+        );
+        html = html.replace(
+          /href="\/mcp-use\/widgets\/([^"]+)"/g,
+          `href="${this.serverBaseUrl}/mcp-use/widgets/$1"`
+        );
+        html = html.replace(
+          /<head[^>]*>/i,
+          `<head>
+    <script>window.__getFile = (filename) => { return "${this.serverBaseUrl}/mcp-use/widgets/${widget}/"+filename }</script>`
+        );
+        return c.html(html);
+      } catch {
+        return c.notFound();
+      }
     });
   }
   /**
@@ -1595,10 +2202,13 @@ function createMCPServer(name, config = {}) {
 }
 __name(createMCPServer, "createMCPServer");
 export {
+  adaptConnectMiddleware,
+  adaptMiddleware,
   buildWidgetUrl,
   createExternalUrlResource,
   createMCPServer,
   createRawHtmlResource,
   createRemoteDomResource,
-  createUIResourceFromDefinition
+  createUIResourceFromDefinition,
+  isExpressMiddleware
 };