mcp-use 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/commands/dev.js

@@ -1,23 +1,28 @@
-import {
-  resolvePort
-} from "../chunk-Q4PUTBMV.js";
 import {
   buildDevViewsManifest,
   discoverEntry,
   discoverViews,
+  ensureMcpEnvDeclaration,
   isViewPath,
   mcpUseViewsPlugin,
   resolveTailwindCss,
   resolveUserViteConfig,
   resolveWorkspacePaths
-} from "../chunk-UDLRVMML.js";
+} from "../chunk-IGVT7UV6.js";
+import {
+  loadProjectEnv,
+  nextStandaloneCompatPlugin,
+  nextStandaloneSsrOptions
+} from "../chunk-22Y3WIJP.js";
+import {
+  resolvePort
+} from "../chunk-QBAJXPRQ.js";
 
 // src/cli/dev.ts
 import { spawn as spawn2 } from "child_process";
 import { createServer as createNodeServer } from "http";
-import { existsSync } from "fs";
 import { networkInterfaces } from "os";
-import { join } from "path";
+import { join, resolve } from "path";
 import tailwindcss from "@tailwindcss/vite";
 import react from "@vitejs/plugin-react";
 import { createServer as createServer2, createServerModuleRunner } from "vite";
@@ -30,23 +35,46 @@ import {
 } from "@modelcontextprotocol/server";
 
 // src/cli/port.ts
-import { createServer } from "net";
+import { connect, createServer } from "net";
 var MAX_PROBES = 100;
+var CONNECT_PROBE_MS = 300;
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1"]);
 function isPortFree(port, host) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const probe = createServer();
     probe.unref();
-    probe.once("error", () => resolve(false));
+    probe.once("error", () => resolve2(false));
     probe.listen({ port, host }, () => {
-      probe.close(() => resolve(true));
+      probe.close(() => resolve2(true));
+    });
+  });
+}
+function canConnect(port, host) {
+  return new Promise((resolve2) => {
+    const socket = connect({ port, host });
+    socket.setTimeout(CONNECT_PROBE_MS);
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve2(true);
+    });
+    socket.once("timeout", () => {
+      socket.destroy();
+      resolve2(false);
+    });
+    socket.once("error", () => {
+      socket.destroy();
+      resolve2(false);
     });
   });
 }
+async function loopbackPortInUse(port) {
+  return await canConnect(port, "127.0.0.1") || await canConnect(port, "::1");
+}
 async function resolvePort2(requested, host) {
   for (let port = requested; port < requested + MAX_PROBES; port++) {
-    if (await isPortFree(port, host)) {
-      return { port, requested };
-    }
+    if (!await isPortFree(port, host)) continue;
+    if (LOOPBACK_HOSTS.has(host) && await loopbackPortInUse(port)) continue;
+    return { port, requested };
   }
   throw new Error(
     `No free port found between ${requested} and ${requested + MAX_PROBES - 1} on ${host}.`
@@ -99,10 +127,19 @@ var DEFAULT_TUNNEL_API = "https://local.mcp-use.run";
 function tunnelApiBase() {
   return process.env["MCP_USE_TUNNEL_API"] ?? DEFAULT_TUNNEL_API;
 }
+var RESPAWN_BACKOFF_INITIAL_MS = 1e3;
+var RESPAWN_BACKOFF_MAX_MS = 3e4;
 function createTunnelManager(stateFilePath) {
   let proc;
   let currentUrl = null;
   let currentSubdomain;
+  let activePort;
+  let intentionalStop = false;
+  let respawnInFlight;
+  let respawnBackoffMs = RESPAWN_BACKOFF_INITIAL_MS;
+  const sleep = (ms) => new Promise((resolve2) => {
+    setTimeout(resolve2, ms);
+  });
   const markShutdown = () => {
     if (proc !== void 0 && "markShutdown" in proc && typeof proc.markShutdown === "function") {
       proc.markShutdown();
@@ -140,7 +177,9 @@ function createTunnelManager(stateFilePath) {
       );
     }
   };
-  const spawnTunnel = (port, subdomain) => new Promise((resolve, reject) => {
+  let scheduleRespawn = () => {
+  };
+  const spawnTunnel = (port, subdomain) => new Promise((resolve2, reject) => {
     console.log(`[mcp-use] starting tunnel for port ${port}\u2026`);
     const userAgent = process.env["npm_config_user_agent"] ?? "";
     const [tunnelCommand, tunnelArgs] = userAgent.startsWith("pnpm/") ? ["pnpm", ["--silent", "dlx", "@mcp-use/tunnel", String(port)]] : userAgent.startsWith("bun/") ? ["bunx", ["@mcp-use/tunnel", String(port)]] : [
@@ -181,7 +220,7 @@ function createTunnelManager(stateFilePath) {
         }
         resolved = true;
         clearTimeout(setupTimeout);
-        resolve({ url, subdomain: extractedSubdomain, process: child });
+        resolve2({ url, subdomain: extractedSubdomain, process: child });
       }
     });
     child.stderr.on("data", (data) => {
@@ -207,7 +246,11 @@ function createTunnelManager(stateFilePath) {
       if (proc === child) {
         proc = void 0;
         currentUrl = null;
-        currentSubdomain = void 0;
+        if (intentionalStop) {
+          currentSubdomain = void 0;
+        } else {
+          scheduleRespawn();
+        }
       }
     });
     const setupTimeout = setTimeout(() => {
@@ -217,11 +260,62 @@ function createTunnelManager(stateFilePath) {
       }
     }, 3e4);
   });
+  scheduleRespawn = () => {
+    if (intentionalStop || activePort === void 0 || currentUrl !== null) {
+      return;
+    }
+    if (respawnInFlight !== void 0) {
+      return;
+    }
+    respawnInFlight = (async () => {
+      while (!intentionalStop && activePort !== void 0 && currentUrl === null) {
+        console.log("[mcp-use] tunnel disconnected, restarting\u2026");
+        const subdomain = currentSubdomain ?? await loadSavedSubdomain();
+        try {
+          if (subdomain !== void 0) {
+            await releaseSubdomain(subdomain);
+          }
+          let tunnelInfo;
+          try {
+            tunnelInfo = await spawnTunnel(activePort, subdomain);
+          } catch (error) {
+            if (subdomain !== void 0) {
+              console.log(
+                `[mcp-use] subdomain "${subdomain}" unavailable, requesting a new one\u2026`
+              );
+              tunnelInfo = await spawnTunnel(activePort, void 0);
+            } else {
+              throw error;
+            }
+          }
+          proc = tunnelInfo.process;
+          currentUrl = tunnelInfo.url;
+          currentSubdomain = tunnelInfo.subdomain;
+          await persistSubdomain(tunnelInfo.subdomain);
+          respawnBackoffMs = RESPAWN_BACKOFF_INITIAL_MS;
+          return;
+        } catch (error) {
+          console.warn(
+            `[mcp-use] tunnel restart failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+          await sleep(respawnBackoffMs);
+          respawnBackoffMs = Math.min(
+            respawnBackoffMs * 2,
+            RESPAWN_BACKOFF_MAX_MS
+          );
+        }
+      }
+    })().finally(() => {
+      respawnInFlight = void 0;
+    });
+  };
   return {
     status() {
       return { url: currentUrl };
     },
     async start(port) {
+      intentionalStop = false;
+      activePort = port;
       if (currentUrl !== null) {
         return {
           url: currentUrl,
@@ -253,7 +347,11 @@ function createTunnelManager(stateFilePath) {
       return { url: tunnelInfo.url, subdomain: tunnelInfo.subdomain };
     },
     async stop() {
+      intentionalStop = true;
       markShutdown();
+      if (respawnInFlight !== void 0) {
+        await respawnInFlight;
+      }
       if (currentSubdomain !== void 0) {
         await releaseSubdomain(currentSubdomain);
       }
@@ -261,8 +359,10 @@ function createTunnelManager(stateFilePath) {
         proc.kill("SIGINT");
         proc = void 0;
       }
+      activePort = void 0;
       currentUrl = null;
       currentSubdomain = void 0;
+      respawnBackoffMs = RESPAWN_BACKOFF_INITIAL_MS;
     }
   };
 }
@@ -338,15 +438,13 @@ function serverFrom(moduleExports) {
   return candidate;
 }
 async function runDev(options) {
+  process.env.MCP_USE_DEV_CLI = "1";
   const host = options.host ?? "127.0.0.1";
   const paths = resolveWorkspacePaths(options.cwd);
   const eventBus = new InMemoryServerEventBus((error) => {
     console.error("[mcp-use] notification delivery failed:", error);
   });
-  const envPath = join(options.cwd, ".env");
-  if (existsSync(envPath)) {
-    process.loadEnvFile(envPath);
-  }
+  loadProjectEnv(options.cwd, "development");
   const httpServer = createNodeServer();
   const { port, requested } = await resolvePort2(
     resolvePort(options.port),
@@ -357,8 +455,16 @@ async function runDev(options) {
   }
   process.env["PORT"] = String(port);
   const localFallbackMcpUrl = process.env["MCP_URL"] === void 0 && (host === "127.0.0.1" || host === "localhost" || host === "::1") ? `http://localhost:${port}` : void 0;
-  const entry = discoverEntry(options.cwd, options.entry);
-  let currentViews = discoverViews(options.cwd);
+  const sourceRoot = options.mcpDir === void 0 ? options.cwd : resolve(options.cwd, options.mcpDir);
+  const entry = options.entry === void 0 ? discoverEntry(sourceRoot) : discoverEntry(options.cwd, options.entry);
+  if (await ensureMcpEnvDeclaration(options.cwd, entry)) {
+    console.log("[mcp-use] created mcp-env.d.ts");
+  }
+  const viewsDirectory = options.viewsDir ?? (options.mcpDir === void 0 ? void 0 : join(options.mcpDir, "views"));
+  let currentViews = discoverViews(
+    options.cwd,
+    viewsDirectory
+  );
   const viewsAtStartup = currentViews.length > 0;
   const userViteConfig = resolveUserViteConfig(options.cwd);
   const loopbackOrWildcard = ["127.0.0.1", "localhost", "0.0.0.0", "::", "::1"];
@@ -367,18 +473,22 @@ async function runDev(options) {
   const vite = await createServer2({
     root: options.cwd,
     configFile: viewsAtStartup ? userViteConfig : false,
-    envFile: false,
+    envDir: false,
     logLevel: "warn",
     cacheDir: paths.cache,
-    resolve: { alias: { tailwindcss: resolveTailwindCss() } },
+    resolve: {
+      tsconfigPaths: true,
+      alias: { tailwindcss: resolveTailwindCss() }
+    },
     plugins: viewsAtStartup ? [
+      nextStandaloneCompatPlugin(options.cwd),
       tailwindcss(),
       mcpUseViewsPlugin({
         getViews: () => currentViews,
         dev: { reactRefresh: true }
       }),
       react()
-    ] : [],
+    ] : [nextStandaloneCompatPlugin(options.cwd)],
     server: {
       middlewareMode: true,
       // Absolute asset URLs in dev: without `origin`, Vite emits root-relative
@@ -395,7 +505,7 @@ async function runDev(options) {
       hmr: viewsAtStartup ? { server: httpServer } : false
     },
     ssr: {
-      external: true
+      ...nextStandaloneSsrOptions(options.cwd)
     }
   });
   const ssrEnvironment = vite.environments.ssr;
@@ -479,7 +589,7 @@ async function runDev(options) {
     })();
   };
   const onSsrFileEvent = (file) => {
-    if (isViewPath(file, options.cwd)) {
+    if (isViewPath(file, options.cwd, viewsDirectory)) {
       return;
     }
     const modules = ssrEnvironment.moduleGraph.getModulesByFile(file);
@@ -492,11 +602,11 @@ async function runDev(options) {
     reload();
   };
   const onViewFilesystemEvent = (file) => {
-    if (!isViewPath(file, options.cwd)) {
+    if (!isViewPath(file, options.cwd, viewsDirectory)) {
       return;
     }
     const previousViews = currentViews;
-    currentViews = discoverViews(options.cwd);
+    currentViews = discoverViews(options.cwd, viewsDirectory);
     const viewsChanged = previousViews.length !== currentViews.length || previousViews.some(
       (v, i) => v.name !== currentViews[i]?.name || v.entryPath !== currentViews[i]?.entryPath
     );
@@ -526,15 +636,10 @@ async function runDev(options) {
     const tunnelUrl = tunnelManager.status().url;
     const tunnelHost = tunnelUrl !== null ? new URL(tunnelUrl).hostname : null;
     const extra = tunnelHost !== null ? [tunnelHost] : [];
-    const readOnly = req.method === "GET" || req.method === "HEAD";
-    const hostResult = validateHostHeader(req.headers.host, [
+    const result = validateHostHeader(req.headers.host, [
       ...localhostAllowedHostnames(),
       ...extra
     ]);
-    const result = hostResult.ok && !readOnly ? validateOriginHeader(req.headers.origin, [
-      ...localhostAllowedOrigins(),
-      ...extra
-    ]) : hostResult;
     if (result.ok) {
       return false;
     }
@@ -574,7 +679,7 @@ async function runDev(options) {
     const url = req.url ?? "/";
     const pathname = new URL(url, "http://127.0.0.1").pathname;
     const viewsEnabled = viewsAtStartup && currentViews.length > 0;
-    const isViteRequest = req.method === "GET" && (pathname.startsWith("/@") || pathname.startsWith("/node_modules/") || pathname.startsWith("/.mcp-use/") || viewsEnabled && pathname.startsWith("/resources/"));
+    const isViteRequest = req.method === "GET" && (pathname.startsWith("/@") || pathname.startsWith("/node_modules/") || pathname.startsWith("/.mcp-use/") || viewsEnabled && pathname.startsWith("/views/"));
     if (viewsEnabled && isViteRequest) {
       applyViteModuleCors(req, res, {
         tunnelActive: tunnelManager.status().url !== null,
@@ -588,9 +693,9 @@ async function runDev(options) {
     }
   };
   httpServer.on("request", onRequest);
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     httpServer.once("error", reject);
-    httpServer.listen(port, host, () => resolve());
+    httpServer.listen(port, host, () => resolve2());
   });
   console.log(`[mcp-use] dev server ready`);
   if (currentViews.length > 0) {
@@ -623,7 +728,7 @@ async function runDev(options) {
   if (options.open !== false && process.stdout.isTTY === true) {
     openInBrowser(`${devOrigin}${basePath}/inspector`);
   }
-  await new Promise((resolve) => {
+  await new Promise((resolve2) => {
     let closing = false;
     const shutdown = () => {
       if (closing) return;
@@ -632,7 +737,7 @@ async function runDev(options) {
       process.off("SIGTERM", shutdown);
       void (async () => {
         await teardown();
-        resolve();
+        resolve2();
       })();
     };
     process.on("SIGINT", shutdown);