mcp-use 1.2.4 → 1.2.5-dev.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,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
-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 +242,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 +259,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,7 +276,7 @@ var McpServer = class {
         ]
       })
     );
-    this.app.use(requestLogger);
+    this.app.use("*", requestLogger);
     return new Proxy(this, {
       get(target, prop) {
         if (prop in target) {
@@ -737,7 +812,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 +820,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"
       );
-      const content = readFileSync(manifestPath, "utf8");
+      const content = await fsHelpers.readFileSync(manifestPath, "utf8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -773,6 +848,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);
     }
   }
@@ -793,7 +872,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 +884,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,9 +893,10 @@ 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 { createServer } = await import("vite");
     const react = (await import("@vitejs/plugin-react")).default;
     const tailwindcss = (await import("@tailwindcss/vite")).default;
     console.log(react, tailwindcss);
@@ -830,11 +910,10 @@ 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(
+      const resourcesPath = pathHelpers.join(getCwd(), resourcesDir);
+      const relativeResourcesPath = pathHelpers.relative(
         widgetTempDir,
         resourcesPath
       ).replace(/\\/g, "/");
@@ -843,7 +922,7 @@ var McpServer = class {
 /* 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 +947,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 +967,7 @@ if (container && Component) {
       plugins: [tailwindcss(), react()],
       resolve: {
         alias: {
-          "@": join(process.cwd(), resourcesDir)
+          "@": pathHelpers.join(getCwd(), resourcesDir)
         }
       },
       server: {
@@ -896,22 +975,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}`
@@ -947,8 +1099,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,19 +1203,23 @@ 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");
+    if (!await fsHelpers.existsSync(widgetsDir)) {
       console.log(
         "[WIDGETS] No dist/resources/widgets/ directory found - skipping widget serving"
       );
       return;
     }
     this.setupWidgetRoutes();
-    const widgets = readdirSync(widgetsDir).filter((name) => {
-      const widgetPath = join(widgetsDir, name);
-      const indexPath = join(widgetPath, "index.html");
-      return 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/"
@@ -1071,13 +1230,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 +1283,7 @@ 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 +1366,178 @@ 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 +1555,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
@@ -1306,10 +1663,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 +1674,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 +1706,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 +1718,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 = 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();
+      }
     });
   }
   /**