@mcp-use/cli 2.8.4 → 2.9.0-canary.1

package/dist/index.cjs

@@ -4794,11 +4794,12 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
     process.exit(1);
   }
 });
-program.command("dev").description("Run development server with auto-reload and inspector").option("-p, --path <path>", "Path to project directory", process.cwd()).option("--port <port>", "Server port", "3000").option("--host <host>", "Server host", "localhost").option("--no-open", "Do not auto-open inspector").action(async (options) => {
+program.command("dev").description("Run development server with auto-reload and inspector").option("-p, --path <path>", "Path to project directory", process.cwd()).option("--port <port>", "Server port", "3000").option("--host <host>", "Server host", "localhost").option("--no-open", "Do not auto-open inspector").option("--no-hmr", "Disable hot module reloading (use tsx watch instead)").action(async (options) => {
   try {
     const projectPath = import_node_path6.default.resolve(options.path);
     let port = parseInt(options.port, 10);
     const host = options.host;
+    const useHmr = options.hmr !== false;
     console.log(source_default.cyan.bold(`mcp-use v${packageJson.version}`));
     if (!await isPortAvailable(port, host)) {
       console.log(source_default.yellow.bold(`\u26A0\uFE0F  Port ${port} is already in use`));
@@ -4807,62 +4808,251 @@ program.command("dev").description("Run development server with auto-reload and
       port = availablePort;
     }
     const serverFile = await findServerFile(projectPath);
-    const processes = [];
-    const env2 = {
-      PORT: String(port),
-      HOST: host,
-      NODE_ENV: "development"
-    };
-    const serverCommand = runCommand(
-      "npx",
-      ["tsx", "watch", serverFile],
-      projectPath,
-      env2,
-      true
+    process.env.PORT = String(port);
+    process.env.HOST = host;
+    process.env.NODE_ENV = "development";
+    if (!useHmr) {
+      console.log(source_default.gray("HMR disabled, using tsx watch (full restart)"));
+      const processes = [];
+      const env2 = {
+        PORT: String(port),
+        HOST: host,
+        NODE_ENV: "development"
+      };
+      const { createRequire: createRequire2 } = await import("module");
+      let cmd;
+      let args;
+      try {
+        const projectRequire = createRequire2(
+          import_node_path6.default.join(projectPath, "package.json")
+        );
+        const tsxPkgPath = projectRequire.resolve("tsx/package.json");
+        const tsxPkg = JSON.parse(await (0, import_promises5.readFile)(tsxPkgPath, "utf-8"));
+        let binPath;
+        if (typeof tsxPkg.bin === "string") {
+          binPath = tsxPkg.bin;
+        } else if (tsxPkg.bin && typeof tsxPkg.bin === "object") {
+          binPath = tsxPkg.bin.tsx || Object.values(tsxPkg.bin)[0];
+        } else {
+          throw new Error("No bin field found in tsx package.json");
+        }
+        const tsxBin = import_node_path6.default.resolve(import_node_path6.default.dirname(tsxPkgPath), binPath);
+        cmd = "node";
+        args = [tsxBin, "watch", serverFile];
+      } catch (error) {
+        console.log(
+          source_default.yellow(
+            `Could not resolve local tsx: ${error instanceof Error ? error.message : "unknown error"}`
+          )
+        );
+        cmd = "npx";
+        args = ["tsx", "watch", serverFile];
+      }
+      const serverCommand = runCommand(cmd, args, projectPath, env2, true);
+      processes.push(serverCommand.process);
+      if (options.open !== false) {
+        const startTime = Date.now();
+        const ready = await waitForServer(port, host);
+        if (ready) {
+          const mcpEndpoint = `http://${host}:${port}/mcp`;
+          const inspectorUrl = `http://${host}:${port}/inspector?autoConnect=${encodeURIComponent(mcpEndpoint)}`;
+          const readyTime = Date.now() - startTime;
+          console.log(source_default.green.bold(`\u2713 Ready in ${readyTime}ms`));
+          console.log(source_default.whiteBright(`Local:    http://${host}:${port}`));
+          console.log(source_default.whiteBright(`Network:  http://${host}:${port}`));
+          console.log(source_default.whiteBright(`MCP:      ${mcpEndpoint}`));
+          console.log(source_default.whiteBright(`Inspector: ${inspectorUrl}
+`));
+          await open_default(inspectorUrl);
+        }
+      }
+      const cleanup2 = () => {
+        console.log(source_default.gray("\n\nShutting down..."));
+        processes.forEach((proc) => {
+          if (proc && typeof proc.kill === "function") {
+            proc.kill("SIGINT");
+          }
+        });
+        setTimeout(() => process.exit(0), 1e3);
+      };
+      process.on("SIGINT", cleanup2);
+      process.on("SIGTERM", cleanup2);
+      await new Promise(() => {
+      });
+      return;
+    }
+    console.log(
+      source_default.gray(
+        "HMR enabled - changes will hot reload without dropping connections"
+      )
     );
-    processes.push(serverCommand.process);
-    if (options.open !== false) {
+    const chokidarModule = await import("chokidar");
+    const chokidar = chokidarModule.default || chokidarModule;
+    const { pathToFileURL } = await import("url");
+    const { createRequire } = await import("module");
+    let tsImport = null;
+    try {
+      const projectRequire = createRequire(
+        import_node_path6.default.join(projectPath, "package.json")
+      );
+      const tsxApiPath = projectRequire.resolve("tsx/esm/api");
+      const tsxApi = await import(pathToFileURL(tsxApiPath).href);
+      tsImport = tsxApi.tsImport;
+    } catch {
+      console.log(
+        source_default.yellow(
+          "Warning: tsx not found in project dependencies. TypeScript HMR may not work.\nAdd tsx to your devDependencies: npm install -D tsx"
+        )
+      );
+    }
+    const serverFilePath = import_node_path6.default.join(projectPath, serverFile);
+    const serverFileUrl = pathToFileURL(serverFilePath).href;
+    globalThis.__mcpUseHmrMode = true;
+    const importServerModule = async () => {
+      if (tsImport) {
+        await tsImport(`${serverFilePath}?t=${Date.now()}`, importMetaUrl);
+      } else {
+        await import(`${serverFileUrl}?t=${Date.now()}`);
+      }
+      const instance = globalThis.__mcpUseLastServer;
+      return instance || null;
+    };
+    console.log(source_default.gray(`Loading server from ${serverFile}...`));
+    let runningServer;
+    try {
+      runningServer = await importServerModule();
+      if (!runningServer) {
+        console.error(
+          source_default.red(
+            "Error: Could not find MCPServer instance.\nMake sure your server file creates an MCPServer:\n  const server = new MCPServer({ name: 'my-server', version: '1.0.0' });"
+          )
+        );
+        process.exit(1);
+      }
+      if (typeof runningServer.listen !== "function") {
+        console.error(
+          source_default.red("Error: MCPServer instance must have a listen() method")
+        );
+        process.exit(1);
+      }
       const startTime = Date.now();
-      const ready = await waitForServer(port, host);
-      if (ready) {
-        const mcpEndpoint = `http://${host}:${port}/mcp`;
-        const inspectorUrl = `http://${host}:${port}/inspector?autoConnect=${encodeURIComponent(mcpEndpoint)}`;
-        const readyTime = Date.now() - startTime;
-        console.log(source_default.green.bold(`\u2713 Ready in ${readyTime}ms`));
-        console.log(source_default.whiteBright(`Local:    http://${host}:${port}`));
-        console.log(source_default.whiteBright(`Network:  http://${host}:${port}`));
-        console.log(source_default.whiteBright(`MCP:      ${mcpEndpoint}`));
-        console.log(source_default.whiteBright(`Inspector: ${inspectorUrl}
+      globalThis.__mcpUseHmrMode = false;
+      await runningServer.listen(port);
+      globalThis.__mcpUseHmrMode = true;
+      if (options.open !== false) {
+        const ready = await waitForServer(port, host);
+        if (ready) {
+          const mcpEndpoint = `http://${host}:${port}/mcp`;
+          const inspectorUrl = `http://${host}:${port}/inspector?autoConnect=${encodeURIComponent(mcpEndpoint)}`;
+          const readyTime = Date.now() - startTime;
+          console.log(source_default.green.bold(`\u2713 Ready in ${readyTime}ms`));
+          console.log(source_default.whiteBright(`Local:    http://${host}:${port}`));
+          console.log(source_default.whiteBright(`Network:  http://${host}:${port}`));
+          console.log(source_default.whiteBright(`MCP:      ${mcpEndpoint}`));
+          console.log(source_default.whiteBright(`Inspector: ${inspectorUrl}`));
+          console.log(source_default.gray(`Watching for changes...
 `));
-        await open_default(inspectorUrl);
+          await open_default(inspectorUrl);
+        }
       }
+    } catch (error) {
+      console.error(
+        source_default.red("Failed to start server:"),
+        error?.message || error
+      );
+      if (error?.stack) {
+        console.error(source_default.gray(error.stack));
+      }
+      process.exit(1);
     }
+    if (options.open === false) {
+      const mcpEndpoint = `http://${host}:${port}/mcp`;
+      console.log(source_default.green.bold(`\u2713 Server ready`));
+      console.log(source_default.whiteBright(`Local:    http://${host}:${port}`));
+      console.log(source_default.whiteBright(`MCP:      ${mcpEndpoint}`));
+      console.log(source_default.gray(`Watching for changes...
+`));
+    }
+    const watcher = chokidar.watch(".", {
+      cwd: projectPath,
+      ignored: [
+        /(^|[/\\])\../,
+        // dotfiles
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/resources/**",
+        // widgets are watched separately by vite
+        "**/*.d.ts"
+        // type definitions
+      ],
+      persistent: true,
+      ignoreInitial: true,
+      depth: 3
+      // Limit depth to avoid watching too many files
+    });
+    watcher.on("ready", () => {
+      const watched = watcher.getWatched();
+      const dirs = Object.keys(watched);
+      console.log(
+        source_default.gray(`[HMR] Watcher ready, watching ${dirs.length} paths`)
+      );
+    }).on("error", (error) => {
+      console.error(
+        source_default.red(
+          `[HMR] Watcher error: ${error instanceof Error ? error.message : String(error)}`
+        )
+      );
+    });
+    let reloadTimeout = null;
+    let isReloading = false;
+    watcher.on("change", async (filePath) => {
+      if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx") || filePath.endsWith(".d.ts")) {
+        return;
+      }
+      if (isReloading) return;
+      if (reloadTimeout) {
+        clearTimeout(reloadTimeout);
+      }
+      reloadTimeout = setTimeout(async () => {
+        isReloading = true;
+        console.log(source_default.yellow(`
+[HMR] File changed: ${filePath}`));
+        try {
+          const newServer = await importServerModule();
+          if (!newServer) {
+            console.warn(
+              source_default.yellow(
+                "[HMR] Warning: No MCPServer instance found after reload, skipping"
+              )
+            );
+            isReloading = false;
+            return;
+          }
+          if (typeof runningServer.syncRegistrationsFrom !== "function") {
+            console.warn(
+              source_default.yellow(
+                "[HMR] Warning: Server does not support hot reload (missing syncRegistrationsFrom)"
+              )
+            );
+            isReloading = false;
+            return;
+          }
+          runningServer.syncRegistrationsFrom(newServer);
+          console.log(
+            source_default.green(
+              `[HMR] \u2713 Reloaded: ${runningServer.registeredTools?.length || 0} tools, ${runningServer.registeredPrompts?.length || 0} prompts, ${runningServer.registeredResources?.length || 0} resources`
+            )
+          );
+        } catch (error) {
+          console.error(source_default.red(`[HMR] Reload failed: ${error.message}`));
+        }
+        isReloading = false;
+      }, 100);
+    });
     const cleanup = () => {
       console.log(source_default.gray("\n\nShutting down..."));
-      const processesToKill = processes.length;
-      let killedCount = 0;
-      const checkAndExit = () => {
-        killedCount++;
-        if (killedCount >= processesToKill) {
-          process.exit(0);
-        }
-      };
-      processes.forEach((proc) => {
-        if (proc && typeof proc.kill === "function") {
-          proc.on("exit", checkAndExit);
-          proc.kill("SIGINT");
-        } else {
-          checkAndExit();
-        }
-      });
-      setTimeout(() => {
-        processes.forEach((proc) => {
-          if (proc && typeof proc.kill === "function" && proc.exitCode === null) {
-            proc.kill("SIGKILL");
-          }
-        });
-        process.exit(0);
-      }, 1e3);
+      watcher.close();
+      process.exit(0);
     };
     process.on("SIGINT", cleanup);
     process.on("SIGTERM", cleanup);