mcp-use 2.0.0-beta.8 → 2.0.0

package/dist/commands/dev.js

@@ -1,656 +0,0 @@
-import {
-  resolvePort
-} from "../chunk-IG2BCCMU.js";
-import {
-  buildDevViewsManifest,
-  discoverEntry,
-  discoverViews,
-  ensureToolsDeclaration,
-  isViewPath,
-  mcpUseViewsPlugin,
-  resolveTailwindCss,
-  resolveUserViteConfig,
-  resolveWorkspacePaths
-} from "../chunk-DQ7LE4ZA.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 tailwindcss from "@tailwindcss/vite";
-import react from "@vitejs/plugin-react";
-import { createServer as createServer2, createServerModuleRunner } from "vite";
-import {
-  InMemoryServerEventBus,
-  localhostAllowedHostnames,
-  localhostAllowedOrigins,
-  validateHostHeader,
-  validateOriginHeader
-} from "@modelcontextprotocol/server";
-
-// src/cli/port.ts
-import { createServer } from "net";
-var MAX_PROBES = 100;
-function isPortFree(port, host) {
-  return new Promise((resolve) => {
-    const probe = createServer();
-    probe.unref();
-    probe.once("error", () => resolve(false));
-    probe.listen({ port, host }, () => {
-      probe.close(() => resolve(true));
-    });
-  });
-}
-async function resolvePort2(requested, host) {
-  for (let port = requested; port < requested + MAX_PROBES; port++) {
-    if (await isPortFree(port, host)) {
-      return { port, requested };
-    }
-  }
-  throw new Error(
-    `No free port found between ${requested} and ${requested + MAX_PROBES - 1} on ${host}.`
-  );
-}
-
-// src/cli/dev-api.ts
-function createDevApiHandler(options, fallback) {
-  const devInfo = () => {
-    const basePath = options.getBasePath();
-    const { url: tunnelUrl } = options.tunnel.status();
-    return {
-      mcpUrl: tunnelUrl !== null ? `${tunnelUrl.replace(/\/+$/, "")}${basePath}` : null,
-      port: options.port,
-      fromCli: true,
-      tunnelUrl
-    };
-  };
-  return async (request) => {
-    const basePath = options.getBasePath();
-    const infoPath = `${basePath}/inspector/api/dev/info`;
-    const startPath = `${basePath}/inspector/api/dev/start-tunnel`;
-    const stopPath = `${basePath}/inspector/api/dev/stop-tunnel`;
-    const pathname = new URL(request.url).pathname;
-    if (request.method === "GET" && pathname === infoPath) {
-      return Response.json(devInfo());
-    }
-    if (request.method === "POST" && pathname === startPath) {
-      try {
-        await options.tunnel.start(options.port);
-        return Response.json({ ok: true, restarting: false });
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "Failed to start tunnel";
-        return Response.json({ error: message }, { status: 500 });
-      }
-    }
-    if (request.method === "POST" && pathname === stopPath) {
-      await options.tunnel.stop();
-      return Response.json({ ok: true });
-    }
-    return fallback(request);
-  };
-}
-
-// src/cli/tunnel.ts
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { spawn } from "child_process";
-import { dirname } from "path";
-var DEFAULT_TUNNEL_API = "https://local.mcp-use.run";
-function tunnelApiBase() {
-  return process.env["MCP_USE_TUNNEL_API"] ?? DEFAULT_TUNNEL_API;
-}
-function createTunnelManager(stateFilePath) {
-  let proc;
-  let currentUrl = null;
-  let currentSubdomain;
-  const markShutdown = () => {
-    if (proc !== void 0 && "markShutdown" in proc && typeof proc.markShutdown === "function") {
-      proc.markShutdown();
-    }
-  };
-  const releaseSubdomain = async (subdomain) => {
-    try {
-      await fetch(`${tunnelApiBase()}/api/tunnels/${subdomain}`, {
-        method: "DELETE",
-        signal: AbortSignal.timeout(2e3)
-      });
-    } catch {
-    }
-  };
-  const loadSavedSubdomain = async () => {
-    try {
-      const content = await readFile(stateFilePath, "utf8");
-      const state = JSON.parse(content);
-      return typeof state.subdomain === "string" ? state.subdomain : void 0;
-    } catch {
-      return void 0;
-    }
-  };
-  const persistSubdomain = async (subdomain) => {
-    try {
-      await mkdir(dirname(stateFilePath), { recursive: true });
-      await writeFile(
-        stateFilePath,
-        JSON.stringify({ subdomain }, null, 2),
-        "utf8"
-      );
-    } catch (error) {
-      console.warn(
-        `[mcp-use] failed to save tunnel subdomain: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  };
-  const spawnTunnel = (port, subdomain) => new Promise((resolve, 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)]] : [
-      "npx",
-      ["--yes", "--prefer-offline", "@mcp-use/tunnel", String(port)]
-    ];
-    if (subdomain !== void 0) {
-      tunnelArgs.push("--subdomain", subdomain);
-    }
-    const child = spawn(tunnelCommand, tunnelArgs, {
-      stdio: ["ignore", "pipe", "pipe"],
-      shell: process.platform === "win32"
-    });
-    let resolved = false;
-    let shuttingDown = false;
-    const markChildShutdown = () => {
-      shuttingDown = true;
-    };
-    child.markShutdown = markChildShutdown;
-    child.stdout.on("data", (data) => {
-      const text = data.toString();
-      const isShutdownMessage = text.includes("Shutting down") || text.includes("\u{1F6D1}");
-      const isErrorMessage = text.includes("\u2716") || text.includes("Error:");
-      if (!shuttingDown && !isShutdownMessage && !isErrorMessage) {
-        process.stdout.write(text);
-      }
-      const urlMatch = text.match(/https?:\/\/([a-z0-9-]+\.[a-z0-9.-]+)/i);
-      if (urlMatch !== null && !resolved) {
-        const url = urlMatch[0];
-        const fullDomain = urlMatch[1] ?? "";
-        const subdomainMatch = fullDomain.match(/^([a-z0-9-]+)\./i);
-        let extractedSubdomain = subdomainMatch?.[1] ?? fullDomain.split(".")[0] ?? "";
-        if (!/^[a-z0-9-]+$/i.test(extractedSubdomain)) {
-          console.warn(
-            `[mcp-use] warning: extracted subdomain "${extractedSubdomain}" does not match expected format`
-          );
-          extractedSubdomain = "";
-        }
-        resolved = true;
-        clearTimeout(setupTimeout);
-        resolve({ url, subdomain: extractedSubdomain, process: child });
-      }
-    });
-    child.stderr.on("data", (data) => {
-      const text = data.toString();
-      if (!shuttingDown && !text.includes("INFO") && !text.includes("bore_cli") && !text.includes("Shutting down") && // npx inherits pnpm-only npm_config_* env vars (e.g.
-      // minimum-release-age, verify-deps-before-run) and warns about
-      // every key it doesn't recognize — pure noise for the user.
-      !/npm warn Unknown (?:env|project|user|builtin) config/.test(text)) {
-        process.stderr.write(data);
-      }
-    });
-    child.on("error", (error) => {
-      if (!resolved) {
-        clearTimeout(setupTimeout);
-        reject(new Error(`Failed to start tunnel: ${error.message}`));
-      }
-    });
-    child.on("exit", (code) => {
-      if (code !== 0 && code !== null && !resolved) {
-        clearTimeout(setupTimeout);
-        reject(new Error(`Tunnel process exited with code ${code}`));
-      }
-      if (proc === child) {
-        proc = void 0;
-        currentUrl = null;
-        currentSubdomain = void 0;
-      }
-    });
-    const setupTimeout = setTimeout(() => {
-      if (!resolved) {
-        child.kill();
-        reject(new Error("Tunnel setup timed out"));
-      }
-    }, 3e4);
-  });
-  return {
-    status() {
-      return { url: currentUrl };
-    },
-    async start(port) {
-      if (currentUrl !== null) {
-        return {
-          url: currentUrl,
-          subdomain: currentSubdomain ?? ""
-        };
-      }
-      const existingSubdomain = await loadSavedSubdomain();
-      if (existingSubdomain !== void 0) {
-        console.log(`[mcp-use] found existing subdomain: ${existingSubdomain}`);
-        await releaseSubdomain(existingSubdomain);
-      }
-      let tunnelInfo;
-      try {
-        tunnelInfo = await spawnTunnel(port, existingSubdomain);
-      } catch (error) {
-        if (existingSubdomain !== void 0) {
-          console.log(
-            `[mcp-use] subdomain "${existingSubdomain}" unavailable, requesting a new one\u2026`
-          );
-          tunnelInfo = await spawnTunnel(port, void 0);
-        } else {
-          throw error;
-        }
-      }
-      proc = tunnelInfo.process;
-      currentUrl = tunnelInfo.url;
-      currentSubdomain = tunnelInfo.subdomain;
-      await persistSubdomain(tunnelInfo.subdomain);
-      return { url: tunnelInfo.url, subdomain: tunnelInfo.subdomain };
-    },
-    async stop() {
-      markShutdown();
-      if (currentSubdomain !== void 0) {
-        await releaseSubdomain(currentSubdomain);
-      }
-      if (proc !== void 0) {
-        proc.kill("SIGINT");
-        proc = void 0;
-      }
-      currentUrl = null;
-      currentSubdomain = void 0;
-    }
-  };
-}
-
-// src/cli/dev.ts
-function openInBrowser(url) {
-  const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? (
-    // `start` is a cmd built-in; the empty string is the window title.
-    ["cmd", ["/c", "start", "", url]]
-  ) : ["xdg-open", [url]];
-  try {
-    const child = spawn2(command, args, { stdio: "ignore", detached: true });
-    child.on("error", () => {
-    });
-    child.unref();
-  } catch {
-  }
-}
-function lanAddress() {
-  for (const addresses of Object.values(networkInterfaces())) {
-    for (const address of addresses ?? []) {
-      if (!address.internal && address.family === "IPv4") {
-        return address.address;
-      }
-    }
-  }
-  return void 0;
-}
-function appendVaryOrigin(res) {
-  const existing = res.getHeader("Vary");
-  const current = typeof existing === "string" ? existing : Array.isArray(existing) ? existing.join(", ") : existing !== void 0 ? String(existing) : "";
-  if (current.split(",").map((token) => token.trim().toLowerCase()).includes("origin")) {
-    return;
-  }
-  res.setHeader("Vary", current === "" ? "Origin" : `${current}, Origin`);
-}
-function applyViteModuleCors(req, res, options) {
-  if (options.tunnelActive) {
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    return;
-  }
-  if (!options.localhostBind) {
-    return;
-  }
-  const originHeader = req.headers.origin;
-  if (originHeader === "null") {
-    res.setHeader("Access-Control-Allow-Origin", "null");
-    return;
-  }
-  if (typeof originHeader !== "string" || originHeader === "") {
-    return;
-  }
-  const result = validateOriginHeader(originHeader, localhostAllowedOrigins());
-  if (!result.ok || result.origin === void 0) {
-    return;
-  }
-  res.setHeader("Access-Control-Allow-Origin", result.origin);
-  appendVaryOrigin(res);
-}
-function serverFrom(moduleExports) {
-  const server = moduleExports["default"];
-  if (server === null || typeof server !== "object") {
-    throw new Error(
-      "The server entry must default-export the MCPServer instance (`export default server`) and never call listen() itself \u2014 `mcp-use dev` owns the socket."
-    );
-  }
-  const candidate = server;
-  if (typeof candidate.getHandler !== "function") {
-    throw new Error(
-      "The entry's default export has no getHandler() \u2014 it must be the MCPServer instance (`export default server`)."
-    );
-  }
-  return candidate;
-}
-async function runDev(options) {
-  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);
-  }
-  const httpServer = createNodeServer();
-  const { port, requested } = await resolvePort2(
-    resolvePort(options.port),
-    host
-  );
-  if (port !== requested) {
-    console.log(`[mcp-use] port ${requested} is taken, using ${port}`);
-  }
-  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);
-  if (await ensureToolsDeclaration(options.cwd, entry)) {
-    console.log("[mcp-use] created tools.d.ts");
-  }
-  let currentViews = discoverViews(options.cwd);
-  const viewsAtStartup = currentViews.length > 0;
-  const userViteConfig = resolveUserViteConfig(options.cwd);
-  const loopbackOrWildcard = ["127.0.0.1", "localhost", "0.0.0.0", "::", "::1"];
-  const browsableHost = loopbackOrWildcard.includes(host) ? "localhost" : host;
-  const devOrigin = `http://${browsableHost.includes(":") ? `[${browsableHost}]` : browsableHost}:${port}`;
-  const vite = await createServer2({
-    root: options.cwd,
-    configFile: viewsAtStartup ? userViteConfig : false,
-    envFile: false,
-    logLevel: "warn",
-    cacheDir: paths.cache,
-    resolve: { alias: { tailwindcss: resolveTailwindCss() } },
-    plugins: viewsAtStartup ? [
-      tailwindcss(),
-      mcpUseViewsPlugin({
-        getViews: () => currentViews,
-        dev: { reactRefresh: true }
-      }),
-      react()
-    ] : [],
-    server: {
-      middlewareMode: true,
-      // Absolute asset URLs in dev: without `origin`, Vite emits root-relative
-      // paths that resolve against the host page inside srcdoc iframes.
-      ...viewsAtStartup && { origin: devOrigin },
-      // CORS on module URLs is owned by onRequest below (permissive ACAO
-      // only while the tunnel is active), not by Vite's own middleware —
-      // whose default localhost-only policy would block tunnel-rendering
-      // hosts, and whose headers would fight the tunnel-gated ones.
-      cors: false,
-      // View HMR rides the one HTTP listener: Vite attaches its websocket
-      // upgrade handler to our server, so no dedicated HMR port exists to
-      // collide when several dev processes run side by side.
-      hmr: viewsAtStartup ? { server: httpServer } : false
-    },
-    ssr: {
-      external: true
-    }
-  });
-  const ssrEnvironment = vite.environments.ssr;
-  const runner = createServerModuleRunner(ssrEnvironment, {
-    hmr: false,
-    sourcemapInterceptor: "node"
-  });
-  const importServer = async () => {
-    const load = async () => {
-      const moduleExports = await runner.import(entry);
-      const server = serverFrom(moduleExports);
-      if (currentViews.length > 0) {
-        const viewsManifest = buildDevViewsManifest(currentViews);
-        if (typeof server.__primeViews !== "function") {
-          throw new Error(
-            "Loaded MCPServer instance does not support __primeViews."
-          );
-        }
-        server.__primeViews(viewsManifest, {
-          dev: true,
-          projectRoot: options.cwd
-        });
-      }
-      return server;
-    };
-    if (localFallbackMcpUrl === void 0) {
-      return load();
-    }
-    const previousMcpUrl = process.env["MCP_URL"];
-    try {
-      process.env["MCP_URL"] = localFallbackMcpUrl;
-      return await load();
-    } finally {
-      if (previousMcpUrl === void 0) {
-        delete process.env["MCP_URL"];
-      } else {
-        process.env["MCP_URL"] = previousMcpUrl;
-      }
-    }
-  };
-  let currentHandler;
-  let basePath;
-  try {
-    const server = await importServer();
-    currentHandler = server.getHandler({ bus: eventBus });
-    basePath = server.basePath ?? "/mcp";
-  } catch (error) {
-    await runner.close();
-    await vite.close();
-    throw error;
-  }
-  let reloading = false;
-  let dirty = false;
-  const reload = () => {
-    if (reloading) {
-      dirty = true;
-      return;
-    }
-    reloading = true;
-    void (async () => {
-      do {
-        dirty = false;
-        try {
-          runner.evaluatedModules.clear();
-          const server = await importServer();
-          const nextHandler = server.getHandler({ bus: eventBus });
-          currentHandler = nextHandler;
-          basePath = server.basePath ?? "/mcp";
-          eventBus.publish({ kind: "tools_list_changed" });
-          eventBus.publish({ kind: "prompts_list_changed" });
-          eventBus.publish({ kind: "resources_list_changed" });
-          console.log("[mcp-use] reloaded server entry");
-        } catch (error) {
-          console.error(
-            "[mcp-use] reload failed \u2014 keeping the previous server:\n",
-            error
-          );
-        }
-      } while (dirty);
-      reloading = false;
-    })();
-  };
-  const onSsrFileEvent = (file) => {
-    if (isViewPath(file, options.cwd)) {
-      return;
-    }
-    const modules = ssrEnvironment.moduleGraph.getModulesByFile(file);
-    if (modules === void 0 || modules.size === 0) {
-      return;
-    }
-    for (const mod of modules) {
-      ssrEnvironment.moduleGraph.invalidateModule(mod);
-    }
-    reload();
-  };
-  const onViewFilesystemEvent = (file) => {
-    if (!isViewPath(file, options.cwd)) {
-      return;
-    }
-    const previousViews = currentViews;
-    currentViews = discoverViews(options.cwd);
-    const viewsChanged = previousViews.length !== currentViews.length || previousViews.some(
-      (v, i) => v.name !== currentViews[i]?.name || v.entryPath !== currentViews[i]?.entryPath
-    );
-    if (viewsChanged) {
-      reload();
-    }
-  };
-  const onFileAddOrUnlink = (file) => {
-    onViewFilesystemEvent(file);
-    onSsrFileEvent(file);
-  };
-  vite.watcher.on("change", onSsrFileEvent);
-  vite.watcher.on("add", onFileAddOrUnlink);
-  vite.watcher.on("unlink", onFileAddOrUnlink);
-  const tunnelManager = createTunnelManager(paths.tunnel);
-  httpServer.prependListener("upgrade", (req) => {
-    const tunnelUrl = tunnelManager.status().url;
-    if (tunnelUrl === null) return;
-    const tunnelHost = new URL(tunnelUrl).hostname;
-    const requestHost = req.headers.host?.split(":")[0];
-    if (requestHost === tunnelHost) {
-      req.headers.host = `localhost:${port}`;
-    }
-  });
-  const localhostBind = ["127.0.0.1", "localhost", "::1"].includes(host);
-  const rejectDisallowedRequest = (req, res) => {
-    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, [
-      ...localhostAllowedHostnames(),
-      ...extra
-    ]);
-    const result = hostResult.ok && !readOnly ? validateOriginHeader(req.headers.origin, [
-      ...localhostAllowedOrigins(),
-      ...extra
-    ]) : hostResult;
-    if (result.ok) {
-      return false;
-    }
-    res.writeHead(403, { "content-type": "application/json" });
-    res.end(
-      JSON.stringify({
-        jsonrpc: "2.0",
-        error: { code: -32e3, message: result.message },
-        id: null
-      })
-    );
-    return true;
-  };
-  const teardown = async () => {
-    vite.watcher.off("change", onSsrFileEvent);
-    vite.watcher.off("add", onFileAddOrUnlink);
-    vite.watcher.off("unlink", onFileAddOrUnlink);
-    await tunnelManager.stop();
-    await new Promise((done) => httpServer.close(() => done()));
-    await runner.close();
-    await vite.close();
-  };
-  const devFetch = createDevApiHandler(
-    {
-      getBasePath: () => basePath,
-      port,
-      tunnel: tunnelManager
-    },
-    (request) => currentHandler(request)
-  );
-  const { toNodeHandler } = await import("../node-bridge.js");
-  const nodeListener = toNodeHandler({ fetch: devFetch });
-  const onRequest = (req, res) => {
-    if (localhostBind && rejectDisallowedRequest(req, res)) {
-      return;
-    }
-    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/"));
-    if (viewsEnabled && isViteRequest) {
-      applyViteModuleCors(req, res, {
-        tunnelActive: tunnelManager.status().url !== null,
-        localhostBind
-      });
-      vite.middlewares(req, res, () => {
-        void nodeListener(req, res);
-      });
-    } else {
-      void nodeListener(req, res);
-    }
-  };
-  httpServer.on("request", onRequest);
-  await new Promise((resolve, reject) => {
-    httpServer.once("error", reject);
-    httpServer.listen(port, host, () => resolve());
-  });
-  console.log(`[mcp-use] dev server ready`);
-  if (currentViews.length > 0) {
-    console.log(
-      `  \u279C Views:         ${currentViews.map((v) => v.name).join(", ")}`
-    );
-  }
-  console.log(`  \u279C MCP endpoint:  ${devOrigin}${basePath}`);
-  console.log(`  \u279C Inspector:     ${devOrigin}${basePath}/inspector`);
-  if (host === "0.0.0.0" || host === "::") {
-    const lan = lanAddress();
-    if (lan !== void 0) {
-      console.log(`  \u279C Network:       http://${lan}:${port}${basePath}`);
-    }
-  }
-  if (!localhostBind) {
-    console.warn(
-      `[mcp-use] --host ${host} serves beyond this machine without Host validation or authentication \u2014 anyone with network access can call the MCP endpoint and dev routes.`
-    );
-  }
-  if (options.tunnel === true) {
-    try {
-      const { url } = await tunnelManager.start(port);
-      console.log(`  \u279C Tunnel:        ${url}${basePath}`);
-    } catch (error) {
-      await teardown();
-      throw error;
-    }
-  }
-  if (options.open !== false && process.stdout.isTTY === true) {
-    openInBrowser(`${devOrigin}${basePath}/inspector`);
-  }
-  await new Promise((resolve) => {
-    let closing = false;
-    const shutdown = () => {
-      if (closing) return;
-      closing = true;
-      process.off("SIGINT", shutdown);
-      process.off("SIGTERM", shutdown);
-      void (async () => {
-        await teardown();
-        resolve();
-      })();
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-    if (options.signal !== void 0) {
-      if (options.signal.aborted) {
-        shutdown();
-      } else {
-        options.signal.addEventListener("abort", shutdown, { once: true });
-      }
-    }
-  });
-}
-export {
-  runDev
-};
-//# sourceMappingURL=dev.js.map