mcp-use 1.2.4 → 1.2.5-dev.1

package/dist/src/server/index.cjs

@@ -42,42 +42,9 @@ module.exports = __toCommonJS(server_exports);
 
 // src/server/mcp-server.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_hono = require("hono");
+var import_cors = require("hono/cors");
 var import_zod = require("zod");
-var import_express = __toESM(require("express"), 1);
-var import_cors = __toESM(require("cors"), 1);
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-var import_node_fs2 = require("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
 var import_server = require("@mcp-ui/server");
@@ -186,9 +153,117 @@ function createUIResourceFromDefinition(definition, params, config) {
 }
 __name(createUIResourceFromDefinition, "createUIResourceFromDefinition");
 
+// 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 {
+      body = await c.req.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
-var import_vite = require("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");
@@ -202,14 +277,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;
@@ -219,13 +294,13 @@ var McpServer = class {
       name: config.name,
       version: config.version
     });
-    this.app = (0, import_express.default)();
-    this.app.use(import_express.default.json());
+    this.app = new import_hono.Hono();
     this.app.use(
-      (0, import_cors.default)({
+      "*",
+      (0, import_cors.cors)({
         origin: "*",
-        methods: ["GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS"],
-        allowedHeaders: [
+        allowMethods: ["GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS"],
+        allowHeaders: [
           "Content-Type",
           "Accept",
           "Authorization",
@@ -236,7 +311,7 @@ var McpServer = class {
         ]
       })
     );
-    this.app.use(requestLogger);
+    this.app.use("*", requestLogger);
     return new Proxy(this, {
       get(target, prop) {
         if (prop in target) {
@@ -772,7 +847,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
@@ -780,14 +855,14 @@ var McpServer = class {
    * @private
    * @returns Build manifest or null if not found
    */
-  readBuildManifest() {
+  async readBuildManifest() {
     try {
-      const manifestPath = (0, import_node_path.join)(
-        process.cwd(),
+      const manifestPath = pathHelpers.join(
+        getCwd(),
         "dist",
         ".mcp-use-manifest.json"
       );
-      const content = (0, import_node_fs2.readFileSync)(manifestPath, "utf8");
+      const content = await fsHelpers.readFileSync(manifestPath, "utf8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -808,6 +883,10 @@ var McpServer = class {
     if (this.isProductionMode()) {
       await this.mountWidgetsProduction(options);
     } else {
+      if (isDeno) {
+        console.log("[WIDGETS] Skipping dev mode widget mounting in Deno runtime (use production build)");
+        return;
+      }
       await this.mountWidgetsDev(options);
     }
   }
@@ -828,7 +907,7 @@ var McpServer = class {
     const { promises: fs } = await import("fs");
     const baseRoute = options?.baseRoute || "/mcp-use/widgets";
     const resourcesDir = options?.resourcesDir || "resources";
-    const srcDir = (0, import_node_path.join)(process.cwd(), resourcesDir);
+    const srcDir = pathHelpers.join(getCwd(), resourcesDir);
     try {
       await fs.access(srcDir);
     } catch (error) {
@@ -840,7 +919,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) => (0, import_node_path.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;
@@ -849,9 +928,10 @@ var McpServer = class {
       console.log(`[WIDGETS] No widgets found in ${resourcesDir}/ directory`);
       return;
     }
-    const tempDir = (0, import_node_path.join)(process.cwd(), TMP_MCP_USE_DIR);
+    const tempDir = pathHelpers.join(getCwd(), TMP_MCP_USE_DIR);
     await fs.mkdir(tempDir, { recursive: true }).catch(() => {
     });
+    const { createServer } = await import("vite");
     const react = (await import("@vitejs/plugin-react")).default;
     const tailwindcss = (await import("@tailwindcss/vite")).default;
     console.log(react, tailwindcss);
@@ -865,11 +945,10 @@ var McpServer = class {
       };
     });
     for (const widget of widgets) {
-      const widgetTempDir = (0, import_node_path.join)(tempDir, widget.name);
+      const widgetTempDir = pathHelpers.join(tempDir, widget.name);
       await fs.mkdir(widgetTempDir, { recursive: true });
-      const resourcesPath = (0, import_node_path.join)(process.cwd(), resourcesDir);
-      const { relative } = await import("path");
-      const relativeResourcesPath = relative(
+      const resourcesPath = pathHelpers.join(getCwd(), resourcesDir);
+      const relativeResourcesPath = pathHelpers.relative(
         widgetTempDir,
         resourcesPath
       ).replace(/\\/g, "/");
@@ -878,7 +957,7 @@ var McpServer = class {
 /* Configure Tailwind to scan the resources directory */
 @source "${relativeResourcesPath}";
 `;
-      await fs.writeFile((0, import_node_path.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'
@@ -903,12 +982,12 @@ if (container && Component) {
   </body>
 </html>`;
       await fs.writeFile(
-        (0, import_node_path.join)(widgetTempDir, "entry.tsx"),
+        pathHelpers.join(widgetTempDir, "entry.tsx"),
         entryContent,
         "utf8"
       );
       await fs.writeFile(
-        (0, import_node_path.join)(widgetTempDir, "index.html"),
+        pathHelpers.join(widgetTempDir, "index.html"),
         htmlContent,
         "utf8"
       );
@@ -917,13 +996,13 @@ if (container && Component) {
     console.log(
       `[WIDGETS] Serving ${entries.length} widget(s) with shared Vite dev server and HMR`
     );
-    const viteServer = await (0, import_vite.createServer)({
+    const viteServer = await createServer({
       root: tempDir,
       base: baseRoute + "/",
       plugins: [tailwindcss(), react()],
       resolve: {
         alias: {
-          "@": (0, import_node_path.join)(process.cwd(), resourcesDir)
+          "@": pathHelpers.join(getCwd(), resourcesDir)
         }
       },
       server: {
@@ -931,22 +1010,95 @@ 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(/^\/([^/]+)/);
+    const adaptExpressMiddleware = /* @__PURE__ */ __name((middleware) => {
+      return async (c, next) => {
+        const req = c.req.raw;
+        let handled = false;
+        const responseBody = [];
+        let statusCode = 200;
+        const headers = {};
+        const res = {
+          statusCode: 200,
+          status: /* @__PURE__ */ __name((code) => {
+            statusCode = code;
+            res.statusCode = code;
+            return res;
+          }, "status"),
+          setHeader: /* @__PURE__ */ __name((name, value) => {
+            headers[name] = value;
+          }, "setHeader"),
+          getHeader: /* @__PURE__ */ __name((name) => headers[name], "getHeader"),
+          write: /* @__PURE__ */ __name((chunk) => {
+            responseBody.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
+          }, "write"),
+          end: /* @__PURE__ */ __name((chunk) => {
+            if (chunk) {
+              responseBody.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
+            }
+            handled = true;
+          }, "end"),
+          on: /* @__PURE__ */ __name(() => {
+          }, "on"),
+          once: /* @__PURE__ */ __name(() => {
+          }, "once"),
+          removeListener: /* @__PURE__ */ __name(() => {
+          }, "removeListener")
+        };
+        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())
+        };
+        await new Promise((resolve, reject) => {
+          middleware(expressReq, res, (err) => {
+            if (err) reject(err);
+            else resolve();
+          });
+        });
+        if (handled) {
+          const body = Buffer.concat(responseBody);
+          return new Response(body, {
+            status: statusCode,
+            headers
+          });
+        }
+        return next();
+      };
+    }, "adaptExpressMiddleware");
+    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);
+    this.app.use(`${baseRoute}/*`, adaptExpressMiddleware(viteServer.middlewares));
     widgets.forEach((widget) => {
       console.log(
         `[WIDGET] ${widget.name} mounted at ${baseRoute}/${widget.name}`
@@ -982,8 +1134,11 @@ if (container && Component) {
       console.log("[WIDGET dev] Metadata:", metadata);
       let html = "";
       try {
-        html = (0, import_node_fs2.readFileSync)((0, import_node_path.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;
@@ -1083,19 +1238,23 @@ if (container && Component) {
    */
   async mountWidgetsProduction(options) {
     const baseRoute = options?.baseRoute || "/mcp-use/widgets";
-    const widgetsDir = (0, import_node_path.join)(process.cwd(), "dist", "resources", "widgets");
-    if (!(0, import_node_fs.existsSync)(widgetsDir)) {
+    const widgetsDir = pathHelpers.join(getCwd(), "dist", "resources", "widgets");
+    if (!await fsHelpers.existsSync(widgetsDir)) {
       console.log(
         "[WIDGETS] No dist/resources/widgets/ directory found - skipping widget serving"
       );
       return;
     }
     this.setupWidgetRoutes();
-    const widgets = (0, import_node_fs.readdirSync)(widgetsDir).filter((name) => {
-      const widgetPath = (0, import_node_path.join)(widgetsDir, name);
-      const indexPath = (0, import_node_path.join)(widgetPath, "index.html");
-      return (0, import_node_fs.existsSync)(indexPath);
-    });
+    const allEntries = await fsHelpers.readdirSync(widgetsDir);
+    const widgets = [];
+    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);
+      }
+    }
     if (widgets.length === 0) {
       console.log(
         "[WIDGETS] No built widgets found in dist/resources/widgets/"
@@ -1106,13 +1265,13 @@ if (container && Component) {
       `[WIDGETS] Serving ${widgets.length} pre-built widget(s) from dist/resources/widgets/`
     );
     for (const widgetName of widgets) {
-      const widgetPath = (0, import_node_path.join)(widgetsDir, widgetName);
-      const indexPath = (0, import_node_path.join)(widgetPath, "index.html");
-      const metadataPath = (0, import_node_path.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 = (0, import_node_fs2.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;
@@ -1159,7 +1318,7 @@ if (container && Component) {
       let props = {};
       let description = `Widget: ${widgetName}`;
       try {
-        const metadataContent = (0, import_node_fs2.readFileSync)(metadataPath, "utf8");
+        const metadataContent = await fsHelpers.readFileSync(metadataPath, "utf8");
         metadata = JSON.parse(metadataContent);
         if (metadata.description) {
           description = metadata.description;
@@ -1242,47 +1401,178 @@ if (container && Component) {
     if (this.mcpMounted) return;
     const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
     const endpoint = "/mcp";
-    this.app.post(endpoint, import_express.default.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
@@ -1300,24 +1590,91 @@ 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.
+   *
+   * @returns Promise that resolves to the fetch handler function
+   *
+   * @example
+   * ```typescript
+   * // For Supabase Edge Functions
+   * const server = createMCPServer('my-server');
+   * server.tool({ ... });
+   * const handler = await server.getHandler();
+   * 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() {
+    await this.mountWidgets({
+      baseRoute: "/mcp-use/widgets",
+      resourcesDir: "resources"
     });
+    await this.mountMcp();
+    await this.mountInspector();
+    const fetchHandler = this.app.fetch.bind(this.app);
+    return async (req) => {
+      const result = await fetchHandler(req);
+      return result;
+    };
   }
   /**
    * Mount MCP Inspector UI at /inspector
@@ -1341,10 +1698,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)"
@@ -1352,19 +1709,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.
    *
@@ -1383,11 +1741,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 = (0, import_node_path.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",
@@ -1395,48 +1753,72 @@ 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 = (0, import_node_path.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 = (0, import_node_fs.readdirSync)(widgetsDir);
+        const widgets = await fsHelpers.readdirSync(widgetsDir);
         for (const widget of widgets) {
-          const assetPath = (0, import_node_path.join)(widgetsDir, widget, "assets", assetFile);
-          if ((0, import_node_fs.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 = (0, import_node_path.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 = (0, import_node_fs2.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();
+      }
     });
   }
   /**
@@ -1629,12 +2011,3 @@ function createMCPServer(name, config = {}) {
   return instance;
 }
 __name(createMCPServer, "createMCPServer");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  buildWidgetUrl,
-  createExternalUrlResource,
-  createMCPServer,
-  createRawHtmlResource,
-  createRemoteDomResource,
-  createUIResourceFromDefinition
-});