@mcp-use/cli 2.20.0-canary.5 → 2.20.0-canary.6

package/dist/index.cjs

@@ -4906,7 +4906,8 @@ async function startTunnel(port, subdomain) {
     proc.stdout?.on("data", (data) => {
       const text = data.toString();
       const isShutdownMessage = text.includes("Shutting down") || text.includes("\u{1F6D1}");
-      if (!isShuttingDown && !isShutdownMessage) {
+      const isErrorMessage = text.includes("\u2716") || text.includes("Error:");
+      if (!isShuttingDown && !isShutdownMessage && !isErrorMessage) {
         process.stdout.write(text);
       }
       const urlMatch = text.match(/https?:\/\/([a-z0-9-]+\.[a-z0-9.-]+)/i);
@@ -5708,6 +5709,7 @@ program.command("dev").description("Run development server with auto-reload and
   "0.0.0.0"
 ).option("--no-open", "Do not auto-open inspector").option("--no-hmr", "Disable hot module reloading (use tsx watch instead)").option("--tunnel", "Expose server through a tunnel").action(async (options) => {
   try {
+    process.env.MCP_USE_CLI_DEV = "1";
     const projectPath = import_node_path8.default.resolve(options.path);
     let port = parseInt(options.port, 10);
     const host = options.host;
@@ -5735,10 +5737,31 @@ program.command("dev").description("Run development server with auto-reload and
             console.log(
               source_default.gray(`Found existing subdomain: ${existingSubdomain}`)
             );
+            const apiBase = process.env.MCP_USE_TUNNEL_API || "https://local.mcp-use.run";
+            try {
+              await fetch(`${apiBase}/api/tunnels/${existingSubdomain}`, {
+                method: "DELETE"
+              });
+            } catch {
+            }
           }
         } catch {
         }
-        const tunnelInfo = await startTunnel(port, existingSubdomain);
+        let tunnelInfo;
+        try {
+          tunnelInfo = await startTunnel(port, existingSubdomain);
+        } catch (e) {
+          if (existingSubdomain) {
+            console.log(
+              source_default.yellow(
+                `Subdomain "${existingSubdomain}" unavailable, requesting a new one\u2026`
+              )
+            );
+            tunnelInfo = await startTunnel(port);
+          } else {
+            throw e;
+          }
+        }
         tunnelUrl = tunnelInfo.url;
         tunnelProcess = tunnelInfo.process;
         tunnelSubdomain = tunnelInfo.subdomain;
@@ -6006,7 +6029,7 @@ program.command("dev").description("Run development server with auto-reload and
       console.log(source_default.gray(`Watching for changes...
 `));
     }
-    const watcher = chokidar.watch(".", {
+    let watcher = chokidar.watch(".", {
       cwd: projectPath,
       ignored: (path7, stats) => {
         const normalizedPath = path7.replace(/\\/g, "/");
@@ -6047,7 +6070,7 @@ program.command("dev").description("Run development server with auto-reload and
     });
     let reloadTimeout = null;
     let isReloading = false;
-    watcher.on("change", async (filePath) => {
+    const hmrOnChange = async (filePath) => {
       if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx") || filePath.endsWith(".d.ts")) {
         return;
       }
@@ -6125,7 +6148,171 @@ program.command("dev").description("Run development server with auto-reload and
         }
         isReloading = false;
       }, 100);
-    });
+    };
+    watcher.on("change", hmrOnChange);
+    process.env.MCP_USE_PROJECT_PATH = projectPath;
+    globalThis.__mcpUseDevRestart = async (withTunnel) => {
+      console.log(
+        source_default.yellow(
+          `
+[DEV] Restarting ${withTunnel ? "with" : "without"} tunnel\u2026`
+        )
+      );
+      const origStderrWrite = process.stderr.write.bind(process.stderr);
+      const stderrFilter = (chunk, ...args) => {
+        const str = typeof chunk === "string" ? chunk : chunk?.toString?.() ?? "";
+        if (str.includes("TypeError: terminated") || str.includes("SocketError") || str.includes("UND_ERR_SOCKET")) {
+          return true;
+        }
+        return origStderrWrite(chunk, ...args);
+      };
+      process.stderr.write = stderrFilter;
+      watcher.close();
+      if (tunnelProcess && typeof tunnelProcess.kill === "function") {
+        if (typeof tunnelProcess.markShutdown === "function") {
+          tunnelProcess.markShutdown();
+        }
+        const dyingProc = tunnelProcess;
+        tunnelProcess = void 0;
+        dyingProc.kill("SIGINT");
+        await new Promise((resolve2) => {
+          const timeout = setTimeout(() => {
+            try {
+              dyingProc.kill("SIGKILL");
+            } catch {
+            }
+            resolve2();
+          }, 5e3);
+          dyingProc.on("exit", () => {
+            clearTimeout(timeout);
+            resolve2();
+          });
+        });
+      }
+      if (tunnelSubdomain) {
+        const apiBase = process.env.MCP_USE_API || "https://local.mcp-use.run";
+        try {
+          await fetch(`${apiBase}/api/tunnels/${tunnelSubdomain}`, {
+            method: "DELETE"
+          });
+        } catch {
+        }
+        tunnelSubdomain = void 0;
+      }
+      if (runningServer && typeof runningServer.forceClose === "function") {
+        await runningServer.forceClose();
+      } else if (runningServer && typeof runningServer.close === "function") {
+        await runningServer.close();
+      }
+      tunnelUrl = void 0;
+      if (withTunnel) {
+        const manifestPath = import_node_path8.default.join(projectPath, "dist", "mcp-use.json");
+        let existingSubdomain;
+        try {
+          const manifestContent = await (0, import_promises7.readFile)(manifestPath, "utf-8");
+          const manifest = JSON.parse(manifestContent);
+          existingSubdomain = manifest.tunnel?.subdomain;
+          if (existingSubdomain) {
+            const apiBase = process.env.MCP_USE_API || "https://local.mcp-use.run";
+            try {
+              await fetch(`${apiBase}/api/tunnels/${existingSubdomain}`, {
+                method: "DELETE"
+              });
+            } catch {
+            }
+          }
+        } catch {
+        }
+        let tunnelInfo;
+        try {
+          tunnelInfo = await startTunnel(port, existingSubdomain);
+        } catch {
+          if (existingSubdomain) {
+            console.log(
+              source_default.yellow(
+                `Subdomain "${existingSubdomain}" unavailable, requesting a new one\u2026`
+              )
+            );
+            tunnelInfo = await startTunnel(port);
+          } else {
+            throw new Error("Failed to start tunnel");
+          }
+        }
+        tunnelUrl = tunnelInfo.url;
+        tunnelProcess = tunnelInfo.process;
+        tunnelSubdomain = tunnelInfo.subdomain;
+        process.env.MCP_URL = tunnelUrl;
+        try {
+          const mPath = import_node_path8.default.join(projectPath, "dist", "mcp-use.json");
+          let manifest = {};
+          try {
+            manifest = JSON.parse(await (0, import_promises7.readFile)(mPath, "utf-8"));
+          } catch {
+          }
+          if (!manifest.tunnel) manifest.tunnel = {};
+          manifest.tunnel.subdomain = tunnelSubdomain;
+          await (0, import_promises7.mkdir)(import_node_path8.default.dirname(mPath), { recursive: true });
+          await (0, import_promises7.writeFile)(mPath, JSON.stringify(manifest, null, 2), "utf-8");
+        } catch {
+        }
+      } else {
+        process.env.MCP_URL = `http://${host}:${port}`;
+      }
+      console.log(source_default.gray(`Loading server from ${serverFile}...`));
+      runningServer = await importServerModule();
+      if (!runningServer) {
+        console.error(
+          source_default.red("Error: Could not find MCPServer instance after restart.")
+        );
+        return;
+      }
+      globalThis.__mcpUseHmrMode = false;
+      await runningServer.listen(port);
+      globalThis.__mcpUseHmrMode = true;
+      const browserHost = normalizeBrowserHost(host);
+      const mcpEndpoint = `http://${browserHost}:${port}/mcp`;
+      const autoConnectEndpoint = tunnelUrl ? `${tunnelUrl}/mcp` : mcpEndpoint;
+      console.log(source_default.green.bold(`\u2713 Restarted`));
+      console.log(source_default.whiteBright(`MCP:      ${mcpEndpoint}`));
+      if (tunnelUrl) {
+        console.log(source_default.whiteBright(`Tunnel:   ${tunnelUrl}/mcp`));
+      }
+      console.log(
+        source_default.whiteBright(
+          `Inspector: http://${browserHost}:${port}/inspector?autoConnect=${encodeURIComponent(autoConnectEndpoint)}`
+        )
+      );
+      console.log(source_default.gray(`Watching for changes...
+`));
+      watcher = chokidar.watch(".", {
+        cwd: projectPath,
+        ignored: (p, stats) => {
+          const np = p.replace(/\\/g, "/");
+          if (/(^|\/)\.[^/]/.test(np)) return true;
+          if (np.includes("/node_modules/") || np.endsWith("/node_modules"))
+            return true;
+          if (np.includes("/dist/") || np.endsWith("/dist")) return true;
+          if (np.includes("/resources/") || np.endsWith("/resources"))
+            return true;
+          if (stats?.isFile() && np.endsWith(".d.ts")) return true;
+          return false;
+        },
+        persistent: true,
+        ignoreInitial: true,
+        depth: 3
+      });
+      watcher.on("ready", () => console.log(source_default.gray(`[HMR] Watcher ready`))).on(
+        "error",
+        (err) => console.error(
+          source_default.red(
+            `[HMR] Watcher error: ${err instanceof Error ? err.message : String(err)}`
+          )
+        )
+      ).on("change", hmrOnChange);
+      setTimeout(() => {
+        process.stderr.write = origStderrWrite;
+      }, 2e3);
+    };
     let hmrCleanupInProgress = false;
     const cleanup = async () => {
       if (hmrCleanupInProgress) return;
@@ -6184,6 +6371,13 @@ program.command("start").description("Start production server").option("-p, --pa
             console.log(
               source_default.gray(`Found existing subdomain: ${existingSubdomain}`)
             );
+            const apiBase = process.env.MCP_USE_API || "https://local.mcp-use.run";
+            try {
+              await fetch(`${apiBase}/api/tunnels/${existingSubdomain}`, {
+                method: "DELETE"
+              });
+            } catch {
+            }
           }
         } catch (error) {
           console.debug(
@@ -6192,7 +6386,21 @@ program.command("start").description("Start production server").option("-p, --pa
             )
           );
         }
-        const tunnelInfo = await startTunnel(port, existingSubdomain);
+        let tunnelInfo;
+        try {
+          tunnelInfo = await startTunnel(port, existingSubdomain);
+        } catch (e) {
+          if (existingSubdomain) {
+            console.log(
+              source_default.yellow(
+                `Subdomain "${existingSubdomain}" unavailable, requesting a new one\u2026`
+              )
+            );
+            tunnelInfo = await startTunnel(port);
+          } else {
+            throw e;
+          }
+        }
         mcpUrl = tunnelInfo.url;
         tunnelProcess = tunnelInfo.process;
         const subdomain = tunnelInfo.subdomain;