@mcp-use/cli 3.2.0-canary.5 → 3.2.0-canary.7

package/dist/index.cjs

@@ -30,10 +30,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.14_tsx@4.21.0_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/cjs_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.9_tsx@4.21.0_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/cjs_shims.js
 var getImportMetaUrl, importMetaUrl;
 var init_cjs_shims = __esm({
-  "../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.14_tsx@4.21.0_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/cjs_shims.js"() {
+  "../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.9_tsx@4.21.0_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/cjs_shims.js"() {
     "use strict";
     getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
     importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
@@ -253,15 +253,15 @@ var init_wsl_utils = __esm({
       const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
       return stdout.trim();
     };
-    convertWslPathToWindows = async (path8) => {
-      if (/^[a-z]+:\/\//i.test(path8)) {
-        return path8;
+    convertWslPathToWindows = async (path11) => {
+      if (/^[a-z]+:\/\//i.test(path11)) {
+        return path11;
       }
       try {
-        const { stdout } = await execFile2("wslpath", ["-aw", path8], { encoding: "utf8" });
+        const { stdout } = await execFile2("wslpath", ["-aw", path11], { encoding: "utf8" });
         return stdout.trim();
       } catch {
-        return path8;
+        return path11;
       }
     };
   }
@@ -1280,13 +1280,13 @@ var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // src/index.ts
-var import_commander6 = require("commander");
+var import_commander7 = require("commander");
 var import_config8 = require("dotenv/config");
-var import_node_child_process9 = require("child_process");
-var import_node_fs11 = require("fs");
-var import_promises7 = require("fs/promises");
+var import_node_child_process11 = require("child_process");
+var import_node_fs14 = require("fs");
+var import_promises8 = require("fs/promises");
 var import_node_module2 = require("module");
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 var import_node_url3 = require("url");
 init_open();
 var import_vite_plugin_singlefile = require("vite-plugin-singlefile");
@@ -1524,8 +1524,8 @@ var McpUseAPI = class _McpUseAPI {
     return this.request(`/servers${q ? `?${q}` : ""}`);
   }
   async getServer(idOrSlug) {
-    const path8 = encodeURIComponent(idOrSlug);
-    return this.request(`/servers/${path8}`);
+    const path11 = encodeURIComponent(idOrSlug);
+    return this.request(`/servers/${path11}`);
   }
   async deleteServer(id) {
     await this.request(
@@ -2027,9 +2027,8 @@ async function whoamiCommand() {
 
 // src/commands/client.ts
 init_cjs_shims();
-var import_commander = require("commander");
-var import_client = require("mcp-use/client");
-var import_server = require("mcp-use/server");
+var import_commander2 = require("commander");
+var import_client3 = require("mcp-use/client");
 var import_node_readline2 = require("readline");
 
 // src/utils/format.ts
@@ -2623,6 +2622,121 @@ async function updateSessionInfo(name, serverInfo, capabilities) {
   }
 }
 
+// src/utils/session.ts
+init_cjs_shims();
+var import_client = require("mcp-use/client");
+var import_server = require("mcp-use/server");
+var activeSessions = /* @__PURE__ */ new Map();
+function getCliClientInfo() {
+  return {
+    name: "mcp-use CLI",
+    title: "mcp-use CLI",
+    version: (0, import_server.getPackageVersion)(),
+    description: "mcp-use CLI - Command-line interface for MCP servers",
+    icons: [
+      {
+        src: "https://manufact.com/logo.png"
+      }
+    ],
+    websiteUrl: "https://manufact.com"
+  };
+}
+async function cleanupAndExit(code) {
+  for (const [name, { client }] of activeSessions) {
+    try {
+      await client.closeAllSessions();
+    } catch {
+    }
+    activeSessions.delete(name);
+  }
+  process.exit(code);
+}
+async function getOrRestoreSession(sessionName) {
+  if (!sessionName) {
+    const active = await getActiveSession();
+    if (!active) {
+      console.error(
+        formatError("No active session. Connect to a server first.")
+      );
+      console.error(
+        formatInfo("Use: npx mcp-use client connect <url> --name <name>")
+      );
+      return null;
+    }
+    sessionName = active.name;
+  }
+  if (activeSessions.has(sessionName)) {
+    const { session } = activeSessions.get(sessionName);
+    return { name: sessionName, session };
+  }
+  const config = await getSession(sessionName);
+  if (!config) {
+    console.error(formatError(`Session '${sessionName}' not found`));
+    return null;
+  }
+  try {
+    const client = new import_client.MCPClient();
+    const cliClientInfo = getCliClientInfo();
+    let authProvider;
+    if (config.type === "http") {
+      if (config.authMode === "oauth") {
+        authProvider = await buildOAuthProvider(config.url);
+        client.addServer(sessionName, {
+          url: config.url,
+          authProvider,
+          clientInfo: cliClientInfo
+        });
+      } else {
+        client.addServer(sessionName, {
+          url: config.url,
+          headers: config.authToken ? { Authorization: `Bearer ${config.authToken}` } : void 0,
+          clientInfo: cliClientInfo
+        });
+      }
+    } else if (config.type === "stdio") {
+      client.addServer(sessionName, {
+        command: config.command,
+        args: config.args || [],
+        env: config.env,
+        clientInfo: cliClientInfo
+      });
+    } else {
+      console.error(formatError(`Unknown session type: ${config.type}`));
+      return null;
+    }
+    let session;
+    try {
+      session = await client.createSession(sessionName);
+    } catch (err) {
+      if (config.type === "http" && config.authMode === "oauth" && authProvider && isUnauthorized(err)) {
+        const reAuth = await promptYesNo(
+          `! Tokens for session '${sessionName}' expired and could not refresh. Re-authenticate now?`,
+          true
+        );
+        if (!reAuth) {
+          console.error(formatError(`Tokens expired and could not refresh.`));
+          console.error(
+            formatInfo(
+              `Run: mcp-use client connect ${config.url} --name ${sessionName}`
+            )
+          );
+          return null;
+        }
+        await runOAuthFlow(authProvider, config.url);
+        session = await client.createSession(sessionName);
+      } else {
+        throw err;
+      }
+    }
+    activeSessions.set(sessionName, { client, session });
+    console.error(formatInfo(`Reconnected to session '${sessionName}'`));
+    return { name: sessionName, session };
+  } catch (error) {
+    console.error(formatError(`Failed to restore session: ${error.message}`));
+    return null;
+  }
+}
+
 // src/commands/client-auth.ts
 init_cjs_shims();
 async function resolveSession(sessionArg) {
@@ -2738,121 +2852,764 @@ async function authLogoutCommand(sessionArg) {
   );
 }
 
-// src/commands/client.ts
-var activeSessions = /* @__PURE__ */ new Map();
-async function cleanupAndExit(code) {
-  for (const [name, { client }] of activeSessions) {
+// src/commands/screenshot.ts
+init_cjs_shims();
+var import_commander = require("commander");
+var import_client2 = require("mcp-use/client");
+var import_node_child_process9 = require("child_process");
+var import_node_fs8 = require("fs");
+var import_promises5 = require("fs/promises");
+var import_node_net = require("net");
+var import_node_path6 = __toESM(require("path"), 1);
+
+// src/utils/cdp-screenshot.ts
+init_cjs_shims();
+var import_node_child_process8 = require("child_process");
+var import_node_fs6 = require("fs");
+var import_node_os5 = __toESM(require("os"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_ws = __toESM(require("ws"), 1);
+var CdpClient = class {
+  constructor(ws) {
+    this.ws = ws;
+    ws.on("message", (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(data.toString());
+      } catch {
+        return;
+      }
+      if (typeof msg.id !== "number") return;
+      const cb = this.pending.get(msg.id);
+      if (!cb) return;
+      this.pending.delete(msg.id);
+      if (msg.error) {
+        cb.reject(new Error(msg.error.message ?? "CDP error"));
+      } else {
+        cb.resolve(msg.result ?? {});
+      }
+    });
+    ws.on("close", () => {
+      for (const cb of this.pending.values()) {
+        cb.reject(new Error("CDP WebSocket closed"));
+      }
+      this.pending.clear();
+    });
+    ws.on("error", (err) => {
+      for (const cb of this.pending.values()) {
+        cb.reject(err);
+      }
+      this.pending.clear();
+    });
+  }
+  nextId = 0;
+  pending = /* @__PURE__ */ new Map();
+  send(method, params = {}, sessionId) {
+    const id = ++this.nextId;
+    const payload = { id, method, params };
+    if (sessionId) payload.sessionId = sessionId;
+    return new Promise((resolve2, reject) => {
+      this.pending.set(id, {
+        resolve: (r) => resolve2(r),
+        reject
+      });
+      this.ws.send(JSON.stringify(payload));
+    });
+  }
+  close() {
     try {
-      await client.closeAllSessions();
+      this.ws.close();
     } catch {
     }
-    activeSessions.delete(name);
   }
-  process.exit(code);
+};
+function waitForDevToolsUrl(child, timeoutMs = 5e3) {
+  return new Promise((resolve2, reject) => {
+    let buf = "";
+    const onData = (d) => {
+      buf += d.toString();
+      const m = buf.match(/DevTools listening on (ws:\/\/\S+)/);
+      if (m) {
+        cleanup();
+        resolve2(m[1]);
+      }
+    };
+    const onExit = (code) => {
+      cleanup();
+      reject(
+        new Error(
+          `Chrome exited (code ${code}) before exposing a DevTools port. Last stderr: ${buf.slice(-500)}`
+        )
+      );
+    };
+    const cleanup = () => {
+      child.stderr?.off("data", onData);
+      child.off("exit", onExit);
+      clearTimeout(timer);
+    };
+    const timer = setTimeout(() => {
+      cleanup();
+      reject(
+        new Error(`Chrome did not expose a DevTools port within ${timeoutMs}ms`)
+      );
+    }, timeoutMs);
+    child.stderr?.on("data", onData);
+    child.on("exit", onExit);
+  });
 }
-async function getOrRestoreSession(sessionName) {
-  if (!sessionName) {
-    const active = await getActiveSession();
-    if (!active) {
-      console.error(
-        formatError("No active session. Connect to a server first.")
+async function captureScreenshot(opts) {
+  let userDataDir;
+  let child;
+  let cdp;
+  let cleanedUp = false;
+  const cleanup = () => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    cdp?.close();
+    if (child && !child.killed) {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      const localChild = child;
+      const killTimer = setTimeout(() => {
+        if (!localChild.killed) {
+          try {
+            localChild.kill("SIGKILL");
+          } catch {
+          }
+        }
+      }, 2e3);
+      killTimer.unref();
+    }
+    if (userDataDir) {
+      try {
+        (0, import_node_fs6.rmSync)(userDataDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  };
+  try {
+    let wsUrl;
+    if (opts.cdpUrl) {
+      wsUrl = opts.cdpUrl;
+    } else {
+      if (!opts.chromePath) {
+        throw new Error(
+          "captureScreenshot requires either `cdpUrl` or `chromePath`"
+        );
+      }
+      userDataDir = (0, import_node_fs6.mkdtempSync)(import_node_path4.default.join(import_node_os5.default.tmpdir(), "mcp-use-chrome-"));
+      const chromeArgs = [
+        "--headless=new",
+        "--remote-debugging-port=0",
+        `--user-data-dir=${userDataDir}`,
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-extensions",
+        "--disable-gpu",
+        "--hide-scrollbars",
+        "--mute-audio",
+        `--window-size=${opts.width},${opts.height}`,
+        "about:blank"
+      ];
+      child = (0, import_node_child_process8.spawn)(opts.chromePath, chromeArgs, {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      child.stdout?.resume();
+      wsUrl = await waitForDevToolsUrl(child);
+    }
+    const ws = new import_ws.default(wsUrl);
+    await new Promise((resolve2, reject) => {
+      const onOpen = () => {
+        ws.off("error", onError);
+        resolve2();
+      };
+      const onError = (err) => {
+        ws.off("open", onOpen);
+        reject(err);
+      };
+      ws.once("open", onOpen);
+      ws.once("error", onError);
+    });
+    cdp = new CdpClient(ws);
+    let sessionId;
+    if (opts.cdpUrl) {
+      const attachPromise = new Promise((resolve2, reject) => {
+        const timer = setTimeout(
+          () => reject(
+            new Error(
+              "Timed out waiting for Target.attachedToTarget event from remote CDP"
+            )
+          ),
+          1e4
+        );
+        const onMessage = (data) => {
+          try {
+            const msg = JSON.parse(data.toString());
+            if (msg.method === "Target.attachedToTarget" && msg.params?.targetInfo?.type === "page" && typeof msg.params.sessionId === "string") {
+              clearTimeout(timer);
+              ws.off("message", onMessage);
+              resolve2(msg.params.sessionId);
+            }
+          } catch {
+          }
+        };
+        ws.on("message", onMessage);
+      });
+      await cdp.send("Target.setAutoAttach", {
+        autoAttach: true,
+        waitForDebuggerOnStart: false,
+        flatten: true
+      });
+      sessionId = await attachPromise;
+    } else {
+      const { targetId } = await cdp.send(
+        "Target.createTarget",
+        { url: "about:blank" }
       );
-      console.error(
-        formatInfo("Use: npx mcp-use client connect <url> --name <name>")
+      const attach = await cdp.send(
+        "Target.attachToTarget",
+        { targetId, flatten: true }
       );
-      return null;
+      sessionId = attach.sessionId;
     }
-    sessionName = active.name;
+    await cdp.send("Page.enable", {}, sessionId);
+    await cdp.send(
+      "Emulation.setDeviceMetricsOverride",
+      {
+        width: opts.width,
+        height: opts.height,
+        deviceScaleFactor: 1,
+        mobile: false
+      },
+      sessionId
+    );
+    await cdp.send(
+      "Emulation.setEmulatedMedia",
+      {
+        features: [
+          { name: "prefers-color-scheme", value: opts.theme },
+          { name: "prefers-reduced-motion", value: "reduce" }
+        ]
+      },
+      sessionId
+    );
+    if (opts.bundle !== void 0) {
+      const payload = JSON.stringify(JSON.stringify(opts.bundle));
+      await cdp.send(
+        "Page.addScriptToEvaluateOnNewDocument",
+        {
+          source: `globalThis.__mcpUsePreviewBundle = JSON.parse(${payload});`,
+          runImmediately: true
+        },
+        sessionId
+      );
+    }
+    await cdp.send("Page.navigate", { url: opts.url }, sessionId);
+    const start = Date.now();
+    const exprSelector = JSON.stringify(opts.waitForSelector);
+    while (true) {
+      const r = await cdp.send(
+        "Runtime.evaluate",
+        {
+          expression: `!!document.querySelector(${exprSelector})`,
+          returnByValue: true
+        },
+        sessionId
+      );
+      if (r.result?.value === true) break;
+      if (Date.now() - start > opts.timeoutMs) {
+        throw new Error(
+          `Timed out after ${opts.timeoutMs}ms waiting for selector "${opts.waitForSelector}"`
+        );
+      }
+      await new Promise((res) => setTimeout(res, 100));
+    }
+    if (opts.delayMs && opts.delayMs > 0) {
+      await new Promise((res) => setTimeout(res, opts.delayMs));
+    }
+    const shot = await cdp.send(
+      "Page.captureScreenshot",
+      {
+        format: "png",
+        clip: {
+          x: 0,
+          y: 0,
+          width: opts.width,
+          height: opts.height,
+          scale: 1
+        }
+      },
+      sessionId
+    );
+    (0, import_node_fs6.writeFileSync)(opts.outputPath, Buffer.from(shot.data, "base64"));
+  } finally {
+    cleanup();
   }
-  if (activeSessions.has(sessionName)) {
-    const { session } = activeSessions.get(sessionName);
-    return { name: sessionName, session };
+}
+
+// src/utils/chrome-path.ts
+init_cjs_shims();
+var import_node_fs7 = require("fs");
+var import_node_path5 = __toESM(require("path"), 1);
+var ENV_VAR_NAMES = [
+  "MCP_USE_CHROME_PATH",
+  "PUPPETEER_EXECUTABLE_PATH",
+  "CHROME_PATH"
+];
+var DARWIN_PATHS = [
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+  "/Applications/Chromium.app/Contents/MacOS/Chromium",
+  "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+  "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
+];
+var LINUX_BINARIES = [
+  "google-chrome-stable",
+  "google-chrome",
+  "chromium",
+  "chromium-browser",
+  "microsoft-edge",
+  "microsoft-edge-stable",
+  "brave-browser"
+];
+var WIN_SUBPATHS = [
+  "Google\\Chrome\\Application\\chrome.exe",
+  "Microsoft\\Edge\\Application\\msedge.exe",
+  "BraveSoftware\\Brave-Browser\\Application\\brave.exe",
+  "Chromium\\Application\\chrome.exe"
+];
+function isAccessible(p) {
+  try {
+    (0, import_node_fs7.accessSync)(p, import_node_fs7.constants.F_OK);
+    return true;
+  } catch {
+    return false;
   }
-  const config = await getSession(sessionName);
-  if (!config) {
-    console.error(formatError(`Session '${sessionName}' not found`));
+}
+function findOnPath(binary) {
+  const PATH = process.env.PATH ?? "";
+  for (const dir of PATH.split(":")) {
+    if (!dir) continue;
+    const candidate = import_node_path5.default.posix.join(dir, binary);
+    if (isAccessible(candidate)) return candidate;
+  }
+  return null;
+}
+function findChrome() {
+  for (const name of ENV_VAR_NAMES) {
+    const v = process.env[name];
+    if (v && isAccessible(v)) return v;
+  }
+  if (process.platform === "darwin") {
+    for (const p of DARWIN_PATHS) {
+      if (isAccessible(p)) return p;
+    }
     return null;
   }
+  if (process.platform === "linux") {
+    for (const bin of LINUX_BINARIES) {
+      const p = findOnPath(bin);
+      if (p) return p;
+    }
+    return null;
+  }
+  if (process.platform === "win32") {
+    const dirs = [
+      process.env["ProgramFiles"],
+      process.env["ProgramFiles(x86)"],
+      process.env["LocalAppData"]
+    ].filter((d) => Boolean(d));
+    for (const dir of dirs) {
+      for (const sub of WIN_SUBPATHS) {
+        const candidate = import_node_path5.default.join(dir, sub);
+        if (isAccessible(candidate)) return candidate;
+      }
+    }
+    return null;
+  }
+  return null;
+}
+function resolveChromePath() {
+  const found = findChrome();
+  if (found) return found;
+  throw new Error(
+    "Could not find Chrome, Chromium, Edge, or Brave on this system. Install Chrome from https://google.com/chrome, or set MCP_USE_CHROME_PATH (or PUPPETEER_EXECUTABLE_PATH / CHROME_PATH) to a browser executable."
+  );
+}
+
+// src/commands/screenshot.ts
+function detectToolResourceUri(tool) {
+  if (!tool) return null;
+  const meta = tool._meta;
+  if (!meta) return null;
+  const uiMeta = meta.ui ?? void 0;
+  return uiMeta?.resourceUri ?? meta["openai/outputTemplate"] ?? null;
+}
+async function captureToolScreenshot(inputs, options = {}) {
+  const width = options.width ?? 800;
+  const height = options.height ?? 600;
+  const theme = options.theme ?? "light";
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const delayMs = options.delayMs ?? 0;
+  const chromePath = options.cdpUrl ? void 0 : resolveChromePath();
+  const view = extractViewName(inputs.resourceUri);
+  const devOptions = {
+    width: String(width),
+    height: String(height),
+    theme,
+    timeout: String(timeoutMs),
+    inspector: options.inspector,
+    quiet: options.quiet
+  };
+  let devHandle;
   try {
-    const client = new import_client.MCPClient();
-    const cliClientInfo = getCliClientInfo();
-    let authProvider;
-    if (config.type === "http") {
-      if (config.authMode === "oauth") {
-        authProvider = await buildOAuthProvider(config.url);
-        client.addServer(sessionName, {
-          url: config.url,
-          authProvider,
-          clientInfo: cliClientInfo
-        });
+    devHandle = await ensureDevServer(devOptions);
+    const resourceContents = await inputs.session.readResource(
+      inputs.resourceUri
+    );
+    const bundle = {
+      resourceUri: inputs.resourceUri,
+      resourceContents,
+      toolInput: inputs.toolArgs,
+      toolOutput: inputs.toolOutput
+    };
+    const previewUrl = new URL(`/inspector/preview/${view}`, devHandle.url);
+    previewUrl.searchParams.set("theme", theme);
+    const ts = timestampSuffix();
+    const outputPath = import_node_path6.default.resolve(options.output ?? `./${view}-${ts}.png`);
+    await (0, import_promises5.mkdir)(import_node_path6.default.dirname(outputPath), { recursive: true });
+    await captureScreenshot({
+      url: previewUrl.toString(),
+      width,
+      height,
+      theme,
+      waitForSelector: options.waitFor ?? 'body[data-view-ready="true"]',
+      timeoutMs,
+      outputPath,
+      chromePath,
+      cdpUrl: options.cdpUrl,
+      delayMs: Number.isFinite(delayMs) && delayMs > 0 ? delayMs : 0,
+      bundle
+    });
+    return { outputPath, width, height, view };
+  } finally {
+    killChild(devHandle?.child);
+  }
+}
+function getFreePort() {
+  return new Promise((resolve2, reject) => {
+    const srv = (0, import_node_net.createServer)();
+    srv.unref();
+    srv.on("error", reject);
+    srv.listen(0, () => {
+      const addr = srv.address();
+      if (typeof addr === "object" && addr) {
+        const port = addr.port;
+        srv.close(() => resolve2(port));
       } else {
-        client.addServer(sessionName, {
-          url: config.url,
-          headers: config.authToken ? { Authorization: `Bearer ${config.authToken}` } : void 0,
-          clientInfo: cliClientInfo
-        });
+        srv.close(() => reject(new Error("Failed to allocate free port")));
       }
-    } else if (config.type === "stdio") {
-      client.addServer(sessionName, {
-        command: config.command,
-        args: config.args || [],
-        env: config.env,
-        clientInfo: cliClientInfo
-      });
-    } else {
-      console.error(formatError(`Unknown session type: ${config.type}`));
+    });
+  });
+}
+async function probeServer(url, timeoutMs = 1500) {
+  const controller = new AbortController();
+  const t = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const u = new URL("/inspector/health", url);
+    const res = await fetch(u, { signal: controller.signal });
+    if (!res.ok) return false;
+    const ct = res.headers.get("content-type") ?? "";
+    if (!ct.includes("application/json")) return false;
+    const body = await res.json();
+    return body?.status === "ok";
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(t);
+  }
+}
+async function waitForHealth(url, timeoutMs = 15e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await probeServer(url)) return true;
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  return false;
+}
+function resolveInspectorCli() {
+  const candidateRoots = /* @__PURE__ */ new Set();
+  const moduleDir = typeof __dirname !== "undefined" ? __dirname : import_node_path6.default.dirname(new URL(importMetaUrl).pathname);
+  candidateRoots.add(moduleDir);
+  candidateRoots.add(process.cwd());
+  for (const start of candidateRoots) {
+    let dir = start;
+    while (true) {
+      const candidate = import_node_path6.default.join(
+        dir,
+        "node_modules",
+        "@mcp-use",
+        "inspector",
+        "dist",
+        "cli.js"
+      );
+      if ((0, import_node_fs8.existsSync)(candidate)) return candidate;
+      const parent = import_node_path6.default.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  throw new Error(
+    "Could not locate `@mcp-use/inspector` in node_modules. Install the inspector package or pass --inspector <url> to use an existing instance."
+  );
+}
+async function ensureDevServer(options) {
+  if (options.inspector) {
+    const ok = await probeServer(options.inspector);
+    if (!ok) {
+      throw new Error(
+        `Inspector at ${options.inspector} did not respond on /inspector/health with status:"ok"`
+      );
+    }
+    return { url: options.inspector };
+  }
+  const port = await getFreePort();
+  const url = `http://localhost:${port}`;
+  if (!options.quiet) {
+    console.error(formatInfo(`Starting inspector on port ${port}\u2026`));
+  }
+  const inspectorCli = resolveInspectorCli();
+  const child = (0, import_node_child_process9.spawn)(
+    process.execPath,
+    [inspectorCli, "--port", String(port), "--no-open"],
+    {
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, MCP_INSPECTOR_MODE: "standalone" }
+    }
+  );
+  const prefix = source_default.gray("[inspector]");
+  if (!options.quiet) {
+    child.stdout?.on("data", (d) => {
+      process.stderr.write(`${prefix} ${d}`);
+    });
+    child.stderr?.on("data", (d) => {
+      process.stderr.write(`${prefix} ${d}`);
+    });
+  } else {
+    child.stdout?.resume();
+    child.stderr?.resume();
+  }
+  const ready = await waitForHealth(url);
+  if (!ready) {
+    child.kill("SIGTERM");
+    throw new Error(`Inspector failed to come up on ${url} within 15s.`);
+  }
+  return { url, child };
+}
+function killChild(child) {
+  if (!child || child.killed) return;
+  try {
+    child.kill("SIGTERM");
+  } catch {
+  }
+}
+function timestampSuffix(date = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const datePart = `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+  const timePart = `${pad(date.getHours())}-${pad(date.getMinutes())}-${pad(date.getSeconds())}`;
+  return `${datePart}_${timePart}`;
+}
+function extractViewName(resourceUri) {
+  const m = resourceUri.match(/^ui:\/\/widget\/(.+)$/);
+  if (!m) return resourceUri;
+  return m[1].replace(/\.html$/, "").replace(/\.[0-9a-f]+$/i, "");
+}
+function parseDimension(raw, name) {
+  const n = parseInt(raw, 10);
+  if (!Number.isFinite(n) || n <= 0) {
+    throw new Error(`--${name} must be a positive integer (got "${raw}")`);
+  }
+  return n;
+}
+var AD_HOC_SESSION_NAME = "__screenshot_ad_hoc__";
+async function resolveSessionForScreenshot(options) {
+  if (options.session) {
+    const result2 = await getOrRestoreSession(options.session);
+    return result2?.session ?? null;
+  }
+  if (options.mcp) {
+    const client = new import_client2.MCPClient();
+    client.addServer(AD_HOC_SESSION_NAME, {
+      url: options.mcp,
+      clientInfo: getCliClientInfo()
+    });
+    try {
+      const session = await client.createSession(AD_HOC_SESSION_NAME);
+      activeSessions.set(AD_HOC_SESSION_NAME, { client, session });
+      return session;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(formatError(`Failed to connect to ${options.mcp}: ${msg}`));
       return null;
     }
-    let session;
+  }
+  const result = await getOrRestoreSession(null);
+  return result?.session ?? null;
+}
+async function screenshotCommand(options, argsList) {
+  let exitCode = 0;
+  try {
+    if (!options.tool) {
+      console.error(
+        formatError(
+          "--tool <name> is required (optionally with key=value args)."
+        )
+      );
+      exitCode = 1;
+      return;
+    }
     try {
-      session = await client.createSession(sessionName);
+      resolveChromePath();
     } catch (err) {
-      if (config.type === "http" && config.authMode === "oauth" && authProvider && isUnauthorized(err)) {
-        const reAuth = await promptYesNo(
-          `! Tokens for session '${sessionName}' expired and could not refresh. Re-authenticate now?`,
-          true
+      console.error(
+        formatError(err instanceof Error ? err.message : String(err))
+      );
+      exitCode = 1;
+      return;
+    }
+    const width = parseDimension(options.width, "width");
+    const height = parseDimension(options.height, "height");
+    const navTimeout = parseInt(options.timeout, 10) || 3e4;
+    const delayMs = options.delay ? parseInt(options.delay, 10) : 0;
+    const session = await resolveSessionForScreenshot(options);
+    if (!session) {
+      exitCode = 1;
+      return;
+    }
+    const tool = session.tools.find((t) => t.name === options.tool);
+    if (!tool) {
+      throw new Error(
+        `Tool "${options.tool}" not found. Available: ${session.tools.map((t) => t.name).join(", ")}`
+      );
+    }
+    const resourceUri = detectToolResourceUri(tool);
+    if (!resourceUri) {
+      throw new Error(
+        `Tool "${options.tool}" does not declare a UI resource (expected _meta.ui.resourceUri or openai/outputTemplate).`
+      );
+    }
+    let toolArgs = {};
+    if (argsList && argsList.length > 0) {
+      try {
+        toolArgs = parseToolArgs(
+          argsList,
+          tool.inputSchema
         );
-        if (!reAuth) {
-          console.error(formatError(`Tokens expired and could not refresh.`));
-          console.error(
-            formatInfo(
-              `Run: mcp-use client connect ${config.url} --name ${sessionName}`
-            )
-          );
-          return null;
+      } catch (err) {
+        console.error(
+          formatError(err instanceof Error ? err.message : String(err))
+        );
+        console.log("");
+        console.log(formatInfo("Usage:"));
+        console.log(
+          `  npx mcp-use screenshot --tool ${options.tool} key=value [key2=value2 ...]`
+        );
+        console.log(
+          `  npx mcp-use screenshot --tool ${options.tool} nested:='{"a":1}'   # JSON value`
+        );
+        console.log(
+          `  npx mcp-use screenshot --tool ${options.tool} '{"key":"value"}'   # full JSON object`
+        );
+        if (tool.inputSchema) {
+          console.log("");
+          console.log(formatInfo("Tool schema:"));
+          console.log(formatSchema(tool.inputSchema));
         }
-        await runOAuthFlow(authProvider, config.url);
-        session = await client.createSession(sessionName);
-      } else {
-        throw err;
+        exitCode = 1;
+        return;
       }
     }
-    activeSessions.set(sessionName, { client, session });
-    console.error(formatInfo(`Reconnected to session '${sessionName}'`));
-    return { name: sessionName, session };
-  } catch (error) {
-    console.error(formatError(`Failed to restore session: ${error.message}`));
-    return null;
-  }
-}
-function getCliClientInfo() {
-  return {
-    name: "mcp-use CLI",
-    title: "mcp-use CLI",
-    version: (0, import_server.getPackageVersion)(),
-    description: "mcp-use CLI - Command-line interface for MCP servers",
-    icons: [
+    const toolOutput = await session.callTool(options.tool, toolArgs);
+    const result = await captureToolScreenshot(
       {
-        src: "https://manufact.com/logo.png"
+        session,
+        toolName: options.tool,
+        toolArgs,
+        toolOutput,
+        resourceUri
+      },
+      {
+        width,
+        height,
+        theme: options.theme,
+        output: options.output,
+        waitFor: options.waitFor,
+        delayMs,
+        timeoutMs: navTimeout,
+        inspector: options.inspector,
+        quiet: options.quiet,
+        cdpUrl: options.cdpUrl
       }
-    ],
-    websiteUrl: "https://manufact.com"
-  };
+    );
+    console.log(
+      `Saved screenshot: ${result.outputPath} (${result.width}\xD7${result.height})`
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(formatError(`Screenshot failed: ${msg}`));
+    exitCode = 1;
+  } finally {
+    await cleanupAndExit(exitCode);
+  }
+}
+function createScreenshotCommand() {
+  return new import_commander.Command("screenshot").description(
+    "Render an MCP Apps view headlessly and save a PNG by calling a tool and rendering its UI resource with the result."
+  ).argument(
+    "[args...]",
+    "Tool args as key=value pairs (use key:=<json> for nested values, or pass a single JSON object)."
+  ).option(
+    "--tool <name>",
+    "Tool to call. Its UI resource is rendered with the result."
+  ).option("--width <px>", "Browser viewport width in pixels.", "800").option("--height <px>", "Browser viewport height in pixels.", "600").option(
+    "--inspector <url>",
+    "Inspector host that serves /inspector/preview/:view. When omitted, probes localhost:3000 then auto-spawns `mcp-use dev`."
+  ).option(
+    "--session <name>",
+    "Saved session name (from `mcp-use client connect`). Defaults to the active session."
+  ).option(
+    "--mcp <url>",
+    "Ad-hoc MCP server URL (escape hatch). Used only when no --session and no active saved session. No authentication."
+  ).option(
+    "--theme <light|dark>",
+    "Color scheme to render the view in.",
+    "light"
+  ).option(
+    "--output <path>",
+    "Output PNG path. Defaults to ./<view>-<timestamp>.png in cwd."
+  ).option(
+    "--wait-for <selector>",
+    'Override readiness selector (default: body[data-view-ready="true"]).'
+  ).option(
+    "--delay <ms>",
+    "Extra wait after readiness, to let chart animations / async layouts settle.",
+    "0"
+  ).option("--timeout <ms>", "Navigation + readiness timeout in ms.", "30000").option(
+    "--cdp-url <url>",
+    "Connect to an existing CDP WebSocket (ws:// or wss://) instead of spawning local Chrome. Useful for hosted browsers like Notte."
+  ).option("--quiet", "Suppress dev-server output.").action(async (args, opts) => {
+    await screenshotCommand(opts, args);
+  });
 }
+
+// src/commands/client.ts
 async function connectCommand(urlOrCommand, options) {
   try {
     const sessionName = options.name || `session-${Date.now()}`;
-    const client = new import_client.MCPClient();
+    const client = new import_client3.MCPClient();
     let session;
     const cliClientInfo = getCliClientInfo();
     if (options.stdio) {
@@ -3169,11 +3926,54 @@ async function callToolCommand(toolName, argsList, options) {
     const callResult = await session.callTool(toolName, args, {
       timeout: options?.timeout
     });
+    let screenshot = null;
+    let screenshotError = null;
+    if (options?.screenshot !== false) {
+      const tool2 = session.tools.find((t) => t.name === toolName);
+      const resourceUri = detectToolResourceUri(tool2);
+      if (resourceUri) {
+        console.error(
+          formatInfo(`Capturing widget screenshot (${resourceUri})...`)
+        );
+        try {
+          const shot = await captureToolScreenshot(
+            {
+              session,
+              toolName,
+              toolArgs: args,
+              toolOutput: callResult,
+              resourceUri
+            },
+            options?.screenshotOutput ? { output: options.screenshotOutput } : {}
+          );
+          screenshot = {
+            path: shot.outputPath,
+            width: shot.width,
+            height: shot.height,
+            view: shot.view
+          };
+        } catch (err) {
+          screenshotError = err?.message ?? String(err);
+        }
+      }
+    }
     if (options?.json) {
       console.log(formatJson(callResult));
     } else {
       console.log(formatToolCall(callResult));
     }
+    if (screenshot) {
+      console.error(
+        formatSuccess(
+          `Saved widget screenshot: ${screenshot.path} (${screenshot.width}\xD7${screenshot.height})`
+        )
+      );
+    }
+    if (screenshotError) {
+      console.error(
+        formatWarning(`Skipped widget screenshot: ${screenshotError}`)
+      );
+    }
     if (callResult.isError) {
       await cleanupAndExit(1);
     }
@@ -3567,7 +4367,7 @@ async function interactiveCommand(options) {
   }
 }
 function createClientCommand() {
-  const clientCommand = new import_commander.Command("client").description(
+  const clientCommand = new import_commander2.Command("client").description(
     "Interactive MCP client for terminal usage"
   );
   clientCommand.command("connect <url>").description("Connect to an MCP server").option("--name <name>", "Session name").option("--stdio", "Use stdio connector instead of HTTP").option("--auth <token>", "Static Bearer token (skips OAuth)").option(
@@ -3578,22 +4378,28 @@ function createClientCommand() {
     "OAuth loopback wait timeout in ms (default 300000)"
   ).action(connectCommand);
   clientCommand.command("disconnect [session]").description("Disconnect from a session").option("--all", "Disconnect all sessions").action(disconnectCommand);
-  const sessionsCommand = new import_commander.Command("sessions").description(
+  const sessionsCommand = new import_commander2.Command("sessions").description(
     "Manage CLI sessions"
   );
   sessionsCommand.command("list").description("List all saved sessions").action(listSessionsCommand);
   sessionsCommand.command("switch <name>").description("Switch to a different session").action(switchSessionCommand);
   clientCommand.addCommand(sessionsCommand);
-  const toolsCommand = new import_commander.Command("tools").description(
+  const toolsCommand = new import_commander2.Command("tools").description(
     "Interact with MCP tools"
   );
   toolsCommand.command("list").description("List available tools").option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(listToolsCommand);
   toolsCommand.command("call <name> [args...]").description(
     "Call a tool. Args as key=value pairs (use key:=<json> for nested values, or pass a JSON object)"
-  ).option("--session <name>", "Use specific session").option("--timeout <ms>", "Request timeout in milliseconds", parseInt).option("--json", "Output as JSON").action(callToolCommand);
+  ).option("--session <name>", "Use specific session").option("--timeout <ms>", "Request timeout in milliseconds", parseInt).option("--json", "Output as JSON").option(
+    "--no-screenshot",
+    "Skip the auto-screenshot for tools that render a widget"
+  ).option(
+    "--screenshot-output <path>",
+    "Output PNG path for the widget screenshot (defaults to ./<view>-<timestamp>.png)"
+  ).action((name, args, opts) => callToolCommand(name, args, opts));
   toolsCommand.command("describe <name>").description("Show tool details and schema").option("--session <name>", "Use specific session").action(describeToolCommand);
   clientCommand.addCommand(toolsCommand);
-  const resourcesCommand = new import_commander.Command("resources").description(
+  const resourcesCommand = new import_commander2.Command("resources").description(
     "Interact with MCP resources"
   );
   resourcesCommand.command("list").description("List available resources").option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(listResourcesCommand);
@@ -3601,7 +4407,7 @@ function createClientCommand() {
   resourcesCommand.command("subscribe <uri>").description("Subscribe to resource updates").option("--session <name>", "Use specific session").action(subscribeResourceCommand);
   resourcesCommand.command("unsubscribe <uri>").description("Unsubscribe from resource updates").option("--session <name>", "Use specific session").action(unsubscribeResourceCommand);
   clientCommand.addCommand(resourcesCommand);
-  const promptsCommand = new import_commander.Command("prompts").description(
+  const promptsCommand = new import_commander2.Command("prompts").description(
     "Interact with MCP prompts"
   );
   promptsCommand.command("list").description("List available prompts").option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(listPromptsCommand);
@@ -3610,7 +4416,7 @@ function createClientCommand() {
   ).option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(getPromptCommand);
   clientCommand.addCommand(promptsCommand);
   clientCommand.command("interactive").description("Start interactive REPL mode").option("--session <name>", "Use specific session").action(interactiveCommand);
-  const authCommand = new import_commander.Command("auth").description(
+  const authCommand = new import_commander2.Command("auth").description(
     "Manage OAuth tokens for HTTP sessions"
   );
   authCommand.command("status [session]").description("Show OAuth token status for a session").action(authStatusCommand);
@@ -3622,15 +4428,15 @@ function createClientCommand() {
 
 // src/commands/deploy.ts
 init_cjs_shims();
-var import_node_fs7 = require("fs");
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_fs10 = require("fs");
+var import_node_path8 = __toESM(require("path"), 1);
 init_open();
 
 // src/utils/git.ts
 init_cjs_shims();
-var import_node_child_process8 = require("child_process");
+var import_node_child_process10 = require("child_process");
 var import_node_util7 = require("util");
-var execFileAsync5 = (0, import_node_util7.promisify)(import_node_child_process8.execFile);
+var execFileAsync5 = (0, import_node_util7.promisify)(import_node_child_process10.execFile);
 async function gitCommand(args, cwd = process.cwd()) {
   try {
     const { stdout } = await execFileAsync5("git", args, { cwd });
@@ -3781,17 +4587,17 @@ function getMcpServerUrlForCloudServer(server) {
 
 // src/utils/project-link.ts
 init_cjs_shims();
-var import_node_fs6 = require("fs");
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_fs9 = require("fs");
+var import_node_path7 = __toESM(require("path"), 1);
 var MCP_USE_DIR = ".mcp-use";
 var MCP_USE_DIR_PROJECT = "project.json";
 function getMcpUseDirectory(cwd) {
-  return import_node_path4.default.join(cwd, MCP_USE_DIR);
+  return import_node_path7.default.join(cwd, MCP_USE_DIR);
 }
 async function getProjectLink(cwd) {
   try {
-    const linkPath = import_node_path4.default.join(getMcpUseDirectory(cwd), MCP_USE_DIR_PROJECT);
-    const content = await import_node_fs6.promises.readFile(linkPath, "utf-8");
+    const linkPath = import_node_path7.default.join(getMcpUseDirectory(cwd), MCP_USE_DIR_PROJECT);
+    const content = await import_node_fs9.promises.readFile(linkPath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     if (err.code === "ENOENT") return null;
@@ -3800,17 +4606,17 @@ async function getProjectLink(cwd) {
 }
 async function saveProjectLink(cwd, link) {
   const mcpUseDir = getMcpUseDirectory(cwd);
-  await import_node_fs6.promises.mkdir(mcpUseDir, { recursive: true });
-  const linkPath = import_node_path4.default.join(mcpUseDir, MCP_USE_DIR_PROJECT);
-  await import_node_fs6.promises.writeFile(linkPath, JSON.stringify(link, null, 2), "utf-8");
+  await import_node_fs9.promises.mkdir(mcpUseDir, { recursive: true });
+  const linkPath = import_node_path7.default.join(mcpUseDir, MCP_USE_DIR_PROJECT);
+  await import_node_fs9.promises.writeFile(linkPath, JSON.stringify(link, null, 2), "utf-8");
   await addToGitIgnore(cwd);
 }
 async function addToGitIgnore(cwd) {
-  const gitignorePath = import_node_path4.default.join(cwd, ".gitignore");
+  const gitignorePath = import_node_path7.default.join(cwd, ".gitignore");
   try {
     let content = "";
     try {
-      content = await import_node_fs6.promises.readFile(gitignorePath, "utf-8");
+      content = await import_node_fs9.promises.readFile(gitignorePath, "utf-8");
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
@@ -3819,7 +4625,7 @@ async function addToGitIgnore(cwd) {
 # mcp-use deployment
 ${MCP_USE_DIR}
 `;
-      await import_node_fs6.promises.writeFile(gitignorePath, newContent, "utf-8");
+      await import_node_fs9.promises.writeFile(gitignorePath, newContent, "utf-8");
     }
   } catch (err) {
   }
@@ -3828,7 +4634,7 @@ ${MCP_USE_DIR}
 // src/commands/deploy.ts
 async function parseEnvFile(filePath) {
   try {
-    const content = await import_node_fs7.promises.readFile(filePath, "utf-8");
+    const content = await import_node_fs10.promises.readFile(filePath, "utf-8");
     const envVars = {};
     const lines = content.split("\n");
     let currentKey = null;
@@ -3947,7 +4753,7 @@ async function buildEnvVars(options) {
 }
 async function isMcpProject(cwd = process.cwd()) {
   try {
-    const content = await import_node_fs7.promises.readFile(import_node_path5.default.join(cwd, "package.json"), "utf-8");
+    const content = await import_node_fs10.promises.readFile(import_node_path8.default.join(cwd, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     return !!(pkg.dependencies?.["mcp-use"] || pkg.dependencies?.["@modelcontextprotocol/sdk"] || pkg.devDependencies?.["mcp-use"] || pkg.devDependencies?.["@modelcontextprotocol/sdk"]);
   } catch {
@@ -3956,16 +4762,16 @@ async function isMcpProject(cwd = process.cwd()) {
 }
 async function getProjectName(cwd = process.cwd()) {
   try {
-    const content = await import_node_fs7.promises.readFile(import_node_path5.default.join(cwd, "package.json"), "utf-8");
+    const content = await import_node_fs10.promises.readFile(import_node_path8.default.join(cwd, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     if (pkg.name) return pkg.name;
   } catch {
   }
-  return import_node_path5.default.basename(cwd);
+  return import_node_path8.default.basename(cwd);
 }
 async function detectBuildCommand(cwd) {
   try {
-    const content = await import_node_fs7.promises.readFile(import_node_path5.default.join(cwd, "package.json"), "utf-8");
+    const content = await import_node_fs10.promises.readFile(import_node_path8.default.join(cwd, "package.json"), "utf-8");
     if (JSON.parse(content).scripts?.build) return "npm run build";
   } catch {
   }
@@ -3973,7 +4779,7 @@ async function detectBuildCommand(cwd) {
 }
 async function detectStartCommand(cwd) {
   try {
-    const content = await import_node_fs7.promises.readFile(import_node_path5.default.join(cwd, "package.json"), "utf-8");
+    const content = await import_node_fs10.promises.readFile(import_node_path8.default.join(cwd, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     if (pkg.scripts?.start) return "npm start";
     if (pkg.main) return `node ${pkg.main}`;
@@ -3984,7 +4790,7 @@ async function detectStartCommand(cwd) {
 async function detectRuntime(cwd) {
   for (const f of ["requirements.txt", "pyproject.toml", "setup.py"]) {
     try {
-      await import_node_fs7.promises.access(import_node_path5.default.join(cwd, f));
+      await import_node_fs10.promises.access(import_node_path8.default.join(cwd, f));
       return "python";
     } catch {
       continue;
@@ -4031,17 +4837,17 @@ var REQUIRED_IGNORES = [
   ".mcp-use"
 ];
 async function ensureGitignore(cwd) {
-  const gitignorePath = import_node_path5.default.join(cwd, ".gitignore");
+  const gitignorePath = import_node_path8.default.join(cwd, ".gitignore");
   let content = "";
   try {
-    content = await import_node_fs7.promises.readFile(gitignorePath, "utf-8");
+    content = await import_node_fs10.promises.readFile(gitignorePath, "utf-8");
   } catch {
   }
   const missing = REQUIRED_IGNORES.filter((entry) => !content.includes(entry));
   if (missing.length > 0) {
     const additions = missing.join("\n");
     const newContent = content + (content.endsWith("\n") ? "" : "\n") + additions + "\n";
-    await import_node_fs7.promises.writeFile(gitignorePath, newContent, "utf-8");
+    await import_node_fs10.promises.writeFile(gitignorePath, newContent, "utf-8");
   }
 }
 async function displayDeploymentProgress(api, deploymentId, progressOptions) {
@@ -4491,10 +5297,10 @@ async function deployCommand(options) {
     console.log(source_default.green("\u2713 GitHub connected\n"));
     let installationDbId;
     let githubInstallationId;
-    const projectDir = options.rootDir ? import_node_path5.default.resolve(cwd, options.rootDir) : cwd;
+    const projectDir = options.rootDir ? import_node_path8.default.resolve(cwd, options.rootDir) : cwd;
     if (options.rootDir) {
       try {
-        await import_node_fs7.promises.access(projectDir);
+        await import_node_fs10.promises.access(projectDir);
       } catch {
         console.log(
           source_default.red(`\u2717 Root directory not found: ${options.rootDir}`)
@@ -5004,7 +5810,7 @@ async function deployCommand(options) {
 
 // src/commands/deployments.ts
 init_cjs_shims();
-var import_commander2 = require("commander");
+var import_commander3 = require("commander");
 async function prompt2(question) {
   const readline = await import("readline");
   const rl = readline.createInterface({
@@ -5416,7 +6222,7 @@ async function startDeploymentCommand(deploymentId) {
   }
 }
 function createDeploymentsCommand() {
-  const deploymentsCommand = new import_commander2.Command("deployments").description(
+  const deploymentsCommand = new import_commander3.Command("deployments").description(
     "Manage cloud deployments"
   );
   deploymentsCommand.command("list").alias("ls").description("List all deployments").action(listDeploymentsCommand);
@@ -5433,11 +6239,11 @@ function createDeploymentsCommand() {
 
 // src/commands/servers.ts
 init_cjs_shims();
-var import_commander4 = require("commander");
+var import_commander5 = require("commander");
 
 // src/commands/env.ts
 init_cjs_shims();
-var import_commander3 = require("commander");
+var import_commander4 = require("commander");
 var ALL_ENVS = ["production", "preview", "development"];
 function parseEnvironments(raw) {
   const parts = raw.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
@@ -5582,7 +6388,7 @@ async function removeEnvCommand(varId, options) {
   }
 }
 function createEnvCommand() {
-  const envCommand = new import_commander3.Command("env").description(
+  const envCommand = new import_commander4.Command("env").description(
     "Manage environment variables for a server"
   );
   envCommand.command("list").alias("ls").description("List environment variables for a server").requiredOption("--server <id>", "Server UUID").option("--show-values", "Reveal non-sensitive values in output").action(listEnvCommand);
@@ -5866,7 +6672,7 @@ async function deleteServerCommand(serverId, options) {
   }
 }
 function createServersCommand() {
-  const serversCommand = new import_commander4.Command("servers").description(
+  const serversCommand = new import_commander5.Command("servers").description(
     "Manage cloud servers (Git-backed deploy targets)"
   );
   serversCommand.command("list").alias("ls").description("List servers for the current organization").option("--org <slug-or-id>", "Target organization (slug, id, or name)").option("--limit <n>", "Page size (1\u2013100, default 50)").option("--skip <n>", "Offset for pagination").option("--sort <field:asc|desc>", "Sort (e.g. updatedAt:desc)").action(listServersCommand);
@@ -5986,12 +6792,12 @@ async function orgCurrentCommand() {
 
 // src/commands/skills.ts
 init_cjs_shims();
-var import_commander5 = require("commander");
-var import_node_fs8 = require("fs");
-var import_node_os5 = require("os");
-var import_node_path6 = require("path");
+var import_commander6 = require("commander");
+var import_node_fs11 = require("fs");
+var import_node_os6 = require("os");
+var import_node_path9 = require("path");
 var import_node_stream = require("stream");
-var import_promises5 = require("stream/promises");
+var import_promises6 = require("stream/promises");
 var import_tar = require("tar");
 var REPO_OWNER = "mcp-use";
 var REPO_NAME = "mcp-use";
@@ -6026,42 +6832,42 @@ function sendInstallTelemetryEvent(agents, skills) {
 }
 async function addSkillsToProject(projectPath) {
   const tarballUrl = `https://codeload.github.com/${REPO_OWNER}/${REPO_NAME}/tar.gz/${REPO_BRANCH}`;
-  const tempDir = (0, import_node_fs8.mkdtempSync)((0, import_node_path6.join)((0, import_node_os5.tmpdir)(), "mcp-use-skills-"));
+  const tempDir = (0, import_node_fs11.mkdtempSync)((0, import_node_path9.join)((0, import_node_os6.tmpdir)(), "mcp-use-skills-"));
   try {
     const response = await fetch(tarballUrl);
     if (!response.ok) {
       throw new Error(`Failed to download tarball: ${response.statusText}`);
     }
-    await (0, import_promises5.pipeline)(
+    await (0, import_promises6.pipeline)(
       import_node_stream.Readable.fromWeb(response.body),
       (0, import_tar.extract)({
         cwd: tempDir,
-        filter: (path8) => path8.includes("/skills/"),
+        filter: (path11) => path11.includes("/skills/"),
         strip: 1
       })
     );
-    const skillsPath = (0, import_node_path6.join)(tempDir, "skills");
-    if (!(0, import_node_fs8.existsSync)(skillsPath)) {
+    const skillsPath = (0, import_node_path9.join)(tempDir, "skills");
+    if (!(0, import_node_fs11.existsSync)(skillsPath)) {
       throw new Error("Skills folder not found in repository");
     }
     for (const preset of ALL_PRESETS) {
       const folderName = AGENT_PRESET_FOLDERS[preset];
-      const outputPath = (0, import_node_path6.join)(projectPath, folderName, "skills");
-      (0, import_node_fs8.cpSync)(skillsPath, outputPath, { recursive: true });
+      const outputPath = (0, import_node_path9.join)(projectPath, folderName, "skills");
+      (0, import_node_fs11.cpSync)(skillsPath, outputPath, { recursive: true });
     }
-    const skillNames = (0, import_node_fs8.readdirSync)(skillsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const skillNames = (0, import_node_fs11.readdirSync)(skillsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     sendInstallTelemetryEvent(ALL_PRESETS.join(","), skillNames.join(","));
   } finally {
-    (0, import_node_fs8.rmSync)(tempDir, { recursive: true, force: true });
+    (0, import_node_fs11.rmSync)(tempDir, { recursive: true, force: true });
   }
 }
 function createSkillsCommand() {
-  const skills = new import_commander5.Command("skills").description(
+  const skills = new import_commander6.Command("skills").description(
     "Manage mcp-use AI agent skills"
   );
   const installAction = async (options) => {
-    const projectPath = (0, import_node_path6.resolve)(options.path);
-    if (!(0, import_node_fs8.existsSync)(projectPath)) {
+    const projectPath = (0, import_node_path9.resolve)(options.path);
+    if (!(0, import_node_fs11.existsSync)(projectPath)) {
       console.error(source_default.red(`Directory not found: ${projectPath}`));
       process.exit(1);
     }
@@ -6103,13 +6909,13 @@ function createSkillsCommand() {
 
 // src/utils/next-shims.ts
 init_cjs_shims();
-var import_node_fs9 = require("fs");
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_fs12 = require("fs");
+var import_node_path10 = __toESM(require("path"), 1);
 var import_node_url2 = require("url");
 async function detectNextJsProject(projectPath) {
   try {
-    const pkgPath = import_node_path7.default.join(projectPath, "package.json");
-    const content = await import_node_fs9.promises.readFile(pkgPath, "utf-8");
+    const pkgPath = import_node_path10.default.join(projectPath, "package.json");
+    const content = await import_node_fs12.promises.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     const deps = pkg.dependencies ?? {};
     const devDeps = pkg.devDependencies ?? {};
@@ -6127,9 +6933,9 @@ async function loadNextJsEnvFiles(projectPath) {
   ];
   const dotenv = await import("dotenv");
   for (const file of files) {
-    const abs = import_node_path7.default.join(projectPath, file);
+    const abs = import_node_path10.default.join(projectPath, file);
     try {
-      await import_node_fs9.promises.access(abs);
+      await import_node_fs12.promises.access(abs);
     } catch {
       continue;
     }
@@ -6139,20 +6945,20 @@ async function loadNextJsEnvFiles(projectPath) {
 function getThisDir() {
   if (typeof __dirname === "string") return __dirname;
   const url = importMetaUrl;
-  return import_node_path7.default.dirname((0, import_node_url2.fileURLToPath)(url));
+  return import_node_path10.default.dirname((0, import_node_url2.fileURLToPath)(url));
 }
 function resolveShimPath(filename) {
   const thisDir = getThisDir();
   const candidates = [
     // Production: `dist/` next to this module
-    import_node_path7.default.join(thisDir, "shims", filename),
+    import_node_path10.default.join(thisDir, "shims", filename),
     // Test / dev: one level up (e.g., from `dist/utils/` back to `src/shims/`)
-    import_node_path7.default.join(thisDir, "..", "shims", filename),
-    import_node_path7.default.join(thisDir, "..", "..", "src", "shims", filename),
-    import_node_path7.default.join(thisDir, "..", "src", "shims", filename)
+    import_node_path10.default.join(thisDir, "..", "shims", filename),
+    import_node_path10.default.join(thisDir, "..", "..", "src", "shims", filename),
+    import_node_path10.default.join(thisDir, "..", "src", "shims", filename)
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs9.existsSync)(candidate)) return candidate;
+    if ((0, import_node_fs12.existsSync)(candidate)) return candidate;
   }
   return void 0;
 }
@@ -6170,7 +6976,7 @@ async function registerNextShimsInProcess() {
   const cjsPath = getShimCjsPreloadPath();
   if (cjsPath) {
     const { createRequire: createRequire3 } = await import("module");
-    const req = createRequire3((0, import_node_url2.pathToFileURL)(getThisDir() + import_node_path7.default.sep).href);
+    const req = createRequire3((0, import_node_url2.pathToFileURL)(getThisDir() + import_node_path10.default.sep).href);
     req(cjsPath);
     anyRegistered = true;
   }
@@ -6178,7 +6984,7 @@ async function registerNextShimsInProcess() {
   if (loaderPath) {
     const { register } = await import("module");
     const loaderUrl = (0, import_node_url2.pathToFileURL)(loaderPath).href;
-    register(loaderUrl, (0, import_node_url2.pathToFileURL)(getThisDir() + import_node_path7.default.sep).href);
+    register(loaderUrl, (0, import_node_url2.pathToFileURL)(getThisDir() + import_node_path10.default.sep).href);
     anyRegistered = true;
   }
   return anyRegistered;
@@ -6204,13 +7010,13 @@ function quoteNodeOption(value) {
 
 // src/utils/update-check.ts
 init_cjs_shims();
-var import_node_fs10 = require("fs");
-var import_promises6 = require("fs/promises");
+var import_node_fs13 = require("fs");
+var import_promises7 = require("fs/promises");
 var import_node_module = require("module");
-var import_node_os6 = __toESM(require("os"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
-var CACHE_DIR = import_node_path8.default.join(import_node_os6.default.homedir(), ".mcp-use");
-var CACHE_FILE = import_node_path8.default.join(CACHE_DIR, "update-check.json");
+var import_node_os7 = __toESM(require("os"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
+var CACHE_DIR = import_node_path11.default.join(import_node_os7.default.homedir(), ".mcp-use");
+var CACHE_FILE = import_node_path11.default.join(CACHE_DIR, "update-check.json");
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 3e3;
 var PACKAGE_NAME = "mcp-use";
@@ -6235,7 +7041,7 @@ function isNewer(current, candidate) {
 }
 async function readCache() {
   try {
-    const content = await (0, import_promises6.readFile)(CACHE_FILE, "utf-8");
+    const content = await (0, import_promises7.readFile)(CACHE_FILE, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -6243,12 +7049,12 @@ async function readCache() {
 }
 async function writeCache(latestVersion) {
   try {
-    await (0, import_promises6.mkdir)(CACHE_DIR, { recursive: true });
+    await (0, import_promises7.mkdir)(CACHE_DIR, { recursive: true });
     const cache = {
       lastChecked: (/* @__PURE__ */ new Date()).toISOString(),
       latestVersion
     };
-    await (0, import_promises6.writeFile)(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
+    await (0, import_promises7.writeFile)(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
   } catch {
   }
 }
@@ -6293,16 +7099,16 @@ function resolveInstalledVersion(projectPath) {
   if (projectPath) {
     attempts.push(() => {
       const projectRequire = (0, import_node_module.createRequire)(
-        import_node_path8.default.join(projectPath, "package.json")
+        import_node_path11.default.join(projectPath, "package.json")
       );
       return projectRequire.resolve(`${PACKAGE_NAME}/package.json`);
     });
   }
-  attempts.push(() => import_node_path8.default.join(__dirname, "../../mcp-use/package.json"));
+  attempts.push(() => import_node_path11.default.join(__dirname, "../../mcp-use/package.json"));
   for (const attempt of attempts) {
     try {
       const pkgPath = attempt();
-      const json = JSON.parse((0, import_node_fs10.readFileSync)(pkgPath, "utf-8"));
+      const json = JSON.parse((0, import_node_fs13.readFileSync)(pkgPath, "utf-8"));
       if (typeof json.version === "string") return json.version;
     } catch {
     }
@@ -6334,9 +7140,9 @@ A new release of ${source_default.bold(PACKAGE_NAME)} is available: ${source_def
 }
 
 // src/index.ts
-var program = new import_commander6.Command();
-var packageContent = (0, import_node_fs11.readFileSync)(
-  import_node_path9.default.join(__dirname, "../package.json"),
+var program = new import_commander7.Command();
+var packageContent = (0, import_node_fs14.readFileSync)(
+  import_node_path12.default.join(__dirname, "../package.json"),
   "utf-8"
 );
 var packageJson = JSON.parse(packageContent);
@@ -6367,16 +7173,16 @@ function displayPackageVersions(projectPath) {
       if (projectPath) {
         try {
           const projectRequire = (0, import_node_module2.createRequire)(
-            import_node_path9.default.join(projectPath, "package.json")
+            import_node_path12.default.join(projectPath, "package.json")
           );
           pkgPath = projectRequire.resolve(`${pkg.name}/package.json`);
         } catch (resolveError) {
-          pkgPath = import_node_path9.default.join(__dirname, pkg.relativePath);
+          pkgPath = import_node_path12.default.join(__dirname, pkg.relativePath);
         }
       } else {
-        pkgPath = import_node_path9.default.join(__dirname, pkg.relativePath);
+        pkgPath = import_node_path12.default.join(__dirname, pkg.relativePath);
       }
-      const pkgContent = (0, import_node_fs11.readFileSync)(pkgPath, "utf-8");
+      const pkgContent = (0, import_node_fs14.readFileSync)(pkgPath, "utf-8");
       const pkgJson = JSON.parse(pkgContent);
       const version = pkgJson.version || "unknown";
       if (pkg.highlight) {
@@ -6431,7 +7237,7 @@ function normalizeBrowserHost(host) {
   return host === "0.0.0.0" ? "localhost" : host;
 }
 function runCommand(command, args, cwd, env2, filterStderr = false) {
-  const proc = (0, import_node_child_process9.spawn)(command, args, {
+  const proc = (0, import_node_child_process11.spawn)(command, args, {
     cwd,
     stdio: filterStderr ? ["inherit", "inherit", "pipe"] : "inherit",
     shell: process.platform === "win32",
@@ -6464,7 +7270,7 @@ async function startTunnel(port, subdomain) {
     if (subdomain) {
       tunnelArgs.push("--subdomain", subdomain);
     }
-    const proc = (0, import_node_child_process9.spawn)("npx", tunnelArgs, {
+    const proc = (0, import_node_child_process11.spawn)("npx", tunnelArgs, {
       stdio: ["ignore", "pipe", "pipe"],
       shell: process.platform === "win32"
     });
@@ -6528,21 +7334,21 @@ async function startTunnel(port, subdomain) {
 }
 async function resolveEntryFile(projectPath, cliEntry, mcpDir) {
   if (cliEntry) {
-    await (0, import_promises7.access)(import_node_path9.default.join(projectPath, cliEntry)).catch(() => {
+    await (0, import_promises8.access)(import_node_path12.default.join(projectPath, cliEntry)).catch(() => {
       throw new Error(`File not found: ${cliEntry}`);
     });
     return cliEntry;
   }
   if (mcpDir) {
     const mcpCandidates = [
-      import_node_path9.default.join(mcpDir, "index.ts"),
-      import_node_path9.default.join(mcpDir, "index.tsx"),
-      import_node_path9.default.join(mcpDir, "server.ts"),
-      import_node_path9.default.join(mcpDir, "server.tsx")
+      import_node_path12.default.join(mcpDir, "index.ts"),
+      import_node_path12.default.join(mcpDir, "index.tsx"),
+      import_node_path12.default.join(mcpDir, "server.ts"),
+      import_node_path12.default.join(mcpDir, "server.tsx")
     ];
     for (const candidate of mcpCandidates) {
       try {
-        await (0, import_promises7.access)(import_node_path9.default.join(projectPath, candidate));
+        await (0, import_promises8.access)(import_node_path12.default.join(projectPath, candidate));
         return candidate;
       } catch {
         continue;
@@ -6551,17 +7357,17 @@ async function resolveEntryFile(projectPath, cliEntry, mcpDir) {
     throw new Error(
       `No entry file found inside ${mcpDir}.
 
-Expected one of: ${mcpCandidates.map((c) => import_node_path9.default.relative(projectPath, import_node_path9.default.join(projectPath, c))).join(", ")}
+Expected one of: ${mcpCandidates.map((c) => import_node_path12.default.relative(projectPath, import_node_path12.default.join(projectPath, c))).join(", ")}
 
 Fix this by either:
-  1. Creating ${import_node_path9.default.join(mcpDir, "index.ts")}, or
+  1. Creating ${import_node_path12.default.join(mcpDir, "index.ts")}, or
   2. Passing --entry <file> on the command line`
     );
   }
   const candidates = ["index.ts", "src/index.ts", "server.ts", "src/server.ts"];
   for (const candidate of candidates) {
     try {
-      await (0, import_promises7.access)(import_node_path9.default.join(projectPath, candidate));
+      await (0, import_promises8.access)(import_node_path12.default.join(projectPath, candidate));
       return candidate;
     } catch {
       continue;
@@ -6579,7 +7385,7 @@ Fix this by either:
 }
 function resolveWidgetsDir(cliWidgetsDir, mcpDir) {
   if (cliWidgetsDir) return cliWidgetsDir;
-  if (mcpDir) return import_node_path9.default.join(mcpDir, "resources");
+  if (mcpDir) return import_node_path12.default.join(mcpDir, "resources");
   return "resources";
 }
 function makeWidgetServerOnlyGuard(widgetName) {
@@ -6614,8 +7420,8 @@ function isBunRuntime() {
   return typeof globalThis.Bun !== "undefined" || typeof process.versions.bun === "string";
 }
 async function generateToolRegistryTypesForServer(projectPath, serverFileRelative) {
-  const serverFile = import_node_path9.default.join(projectPath, serverFileRelative);
-  const serverFileExists = await (0, import_promises7.access)(serverFile).then(() => true).catch(() => false);
+  const serverFile = import_node_path12.default.join(projectPath, serverFileRelative);
+  const serverFileExists = await (0, import_promises8.access)(serverFile).then(() => true).catch(() => false);
   if (!serverFileExists) {
     throw new Error(`Server file not found: ${serverFile}`);
   }
@@ -6640,8 +7446,8 @@ async function generateToolRegistryTypesForServer(projectPath, serverFileRelativ
       await loadNextJsEnvFiles(projectPath);
       await registerNextShimsInProcess();
     }
-    const projectTsconfigPath = import_node_path9.default.join(projectPath, "tsconfig.json");
-    const hasTsconfig = await (0, import_promises7.access)(projectTsconfigPath).then(() => true).catch(() => false);
+    const projectTsconfigPath = import_node_path12.default.join(projectPath, "tsconfig.json");
+    const hasTsconfig = await (0, import_promises8.access)(projectTsconfigPath).then(() => true).catch(() => false);
     if (hasTsconfig) {
       process.env.TSX_TSCONFIG_PATH = projectTsconfigPath;
     }
@@ -6649,7 +7455,7 @@ async function generateToolRegistryTypesForServer(projectPath, serverFileRelativ
     if (previousCwd !== projectPath) process.chdir(projectPath);
     try {
       const projectRequire = (0, import_node_module2.createRequire)(
-        import_node_path9.default.join(projectPath, "package.json")
+        import_node_path12.default.join(projectPath, "package.json")
       );
       const tsxEsmApiPath = projectRequire.resolve("tsx/esm/api");
       const tsxEsmApi = await import((0, import_node_url3.pathToFileURL)(tsxEsmApiPath).href);
@@ -6676,8 +7482,8 @@ async function generateToolRegistryTypesForServer(projectPath, serverFileRelativ
         "No MCPServer instance found. Make sure your server file creates an MCPServer instance."
       );
     }
-    const mcpUsePath = import_node_path9.default.join(projectPath, "node_modules", "mcp-use");
-    const { generateToolRegistryTypes } = await import((0, import_node_url3.pathToFileURL)(import_node_path9.default.join(mcpUsePath, "dist", "src", "server", "index.js")).href).then((mod) => mod);
+    const mcpUsePath = import_node_path12.default.join(projectPath, "node_modules", "mcp-use");
+    const { generateToolRegistryTypes } = await import((0, import_node_url3.pathToFileURL)(import_node_path12.default.join(mcpUsePath, "dist", "src", "server", "index.js")).href).then((mod) => mod);
     if (!generateToolRegistryTypes) {
       throw new Error("generateToolRegistryTypes not found in mcp-use package");
     }
@@ -6695,10 +7501,10 @@ async function buildWidgets(projectPath, options = {}) {
   const { promises: fs11 } = await import("fs");
   const { build } = await import("vite");
   const widgetsDirRelative = options.widgetsDir ?? "resources";
-  const resourcesDir = import_node_path9.default.resolve(projectPath, widgetsDirRelative);
+  const resourcesDir = import_node_path12.default.resolve(projectPath, widgetsDirRelative);
   const mcpUrl = process.env.MCP_URL;
   try {
-    await (0, import_promises7.access)(resourcesDir);
+    await (0, import_promises8.access)(resourcesDir);
   } catch {
     console.log(
       source_default.gray(
@@ -6717,10 +7523,10 @@ async function buildWidgets(projectPath, options = {}) {
       if (dirent.isFile() && (dirent.name.endsWith(".tsx") || dirent.name.endsWith(".ts"))) {
         entries.push({
           name: dirent.name.replace(/\.tsx?$/, ""),
-          path: import_node_path9.default.join(resourcesDir, dirent.name)
+          path: import_node_path12.default.join(resourcesDir, dirent.name)
         });
       } else if (dirent.isDirectory()) {
-        const widgetPath = import_node_path9.default.join(resourcesDir, dirent.name, "widget.tsx");
+        const widgetPath = import_node_path12.default.join(resourcesDir, dirent.name, "widget.tsx");
         try {
           await fs11.access(widgetPath);
           entries.push({
@@ -6750,14 +7556,14 @@ async function buildWidgets(projectPath, options = {}) {
   );
   const react = (await import("@vitejs/plugin-react")).default;
   const tailwindcss = (await import("@tailwindcss/vite")).default;
-  const projectTsconfigPath = import_node_path9.default.join(projectPath, "tsconfig.json");
+  const projectTsconfigPath = import_node_path12.default.join(projectPath, "tsconfig.json");
   let hasProjectTsconfig = false;
   try {
-    await (0, import_promises7.access)(projectTsconfigPath);
+    await (0, import_promises8.access)(projectTsconfigPath);
     hasProjectTsconfig = true;
   } catch {
   }
-  const packageJsonPath = import_node_path9.default.join(projectPath, "package.json");
+  const packageJsonPath = import_node_path12.default.join(projectPath, "package.json");
   let favicon = "";
   try {
     const pkgContent = await fs11.readFile(packageJsonPath, "utf-8");
@@ -6769,16 +7575,16 @@ async function buildWidgets(projectPath, options = {}) {
     const widgetName = entry.name;
     const entryPath = entry.path.replace(/\\/g, "/");
     console.log(source_default.gray(`  - Building ${widgetName}...`));
-    const tempDir = import_node_path9.default.join(projectPath, ".mcp-use", widgetName);
+    const tempDir = import_node_path12.default.join(projectPath, ".mcp-use", widgetName);
     await fs11.mkdir(tempDir, { recursive: true });
-    const relativeResourcesPath = import_node_path9.default.relative(tempDir, resourcesDir).replace(/\\/g, "/");
-    const mcpUsePath = import_node_path9.default.join(projectPath, "node_modules", "mcp-use");
-    const relativeMcpUsePath = import_node_path9.default.relative(tempDir, mcpUsePath).replace(/\\/g, "/");
-    const projectSrcDir = import_node_path9.default.join(projectPath, "src");
+    const relativeResourcesPath = import_node_path12.default.relative(tempDir, resourcesDir).replace(/\\/g, "/");
+    const mcpUsePath = import_node_path12.default.join(projectPath, "node_modules", "mcp-use");
+    const relativeMcpUsePath = import_node_path12.default.relative(tempDir, mcpUsePath).replace(/\\/g, "/");
+    const projectSrcDir = import_node_path12.default.join(projectPath, "src");
     let projectSrcSourceLine = "";
     try {
-      await (0, import_promises7.access)(projectSrcDir);
-      const relativeProjectSrcPath = import_node_path9.default.relative(tempDir, projectSrcDir).replace(/\\/g, "/");
+      await (0, import_promises8.access)(projectSrcDir);
+      const relativeProjectSrcPath = import_node_path12.default.relative(tempDir, projectSrcDir).replace(/\\/g, "/");
       projectSrcSourceLine = `@source "${relativeProjectSrcPath}";
 `;
     } catch {
@@ -6789,7 +7595,7 @@ async function buildWidgets(projectPath, options = {}) {
 @source "${relativeResourcesPath}";
 @source "${relativeMcpUsePath}/**/*.{ts,tsx,js,jsx}";
 ${projectSrcSourceLine}`;
-    await fs11.writeFile(import_node_path9.default.join(tempDir, "styles.css"), cssContent, "utf8");
+    await fs11.writeFile(import_node_path12.default.join(tempDir, "styles.css"), cssContent, "utf8");
     const entryContent = `import React from 'react'
 import { createRoot } from 'react-dom/client'
 import './styles.css'
@@ -6814,9 +7620,9 @@ if (container && Component) {
     <script type="module" src="/entry.tsx"></script>
   </body>
 </html>`;
-    await fs11.writeFile(import_node_path9.default.join(tempDir, "entry.tsx"), entryContent, "utf8");
-    await fs11.writeFile(import_node_path9.default.join(tempDir, "index.html"), htmlContent, "utf8");
-    const outDir = import_node_path9.default.join(
+    await fs11.writeFile(import_node_path12.default.join(tempDir, "entry.tsx"), entryContent, "utf8");
+    await fs11.writeFile(import_node_path12.default.join(tempDir, "index.html"), htmlContent, "utf8");
+    const outDir = import_node_path12.default.join(
       projectPath,
       "dist",
       "resources",
@@ -6826,13 +7632,13 @@ if (container && Component) {
     const baseUrl = mcpUrl ? `${mcpUrl}/${widgetName}/` : `/mcp-use/widgets/${widgetName}/`;
     let widgetMetadata = {};
     try {
-      const metadataTempDir = import_node_path9.default.join(
+      const metadataTempDir = import_node_path12.default.join(
         projectPath,
         ".mcp-use",
         `${widgetName}-metadata`
       );
       await fs11.mkdir(metadataTempDir, { recursive: true });
-      const { createServer } = await import("vite");
+      const { createServer: createServer2 } = await import("vite");
       const nodeStubsPlugin = {
         name: "node-stubs",
         enforce: "pre",
@@ -6860,9 +7666,9 @@ export default PostHog;
         }
       };
       const serverOnlyGuard = makeWidgetServerOnlyGuard(widgetName);
-      const metadataServer = await createServer({
+      const metadataServer = await createServer2({
         root: metadataTempDir,
-        cacheDir: import_node_path9.default.join(metadataTempDir, ".vite-cache"),
+        cacheDir: import_node_path12.default.join(metadataTempDir, ".vite-cache"),
         plugins: [serverOnlyGuard, nodeStubsPlugin, tailwindcss(), react()],
         // When the project has a tsconfig, enable Vite's native tsconfig-paths
         // resolver so `@/*` (or any custom alias) resolves through the
@@ -7093,7 +7899,7 @@ export default {
             // Inline all assets under 100MB (effectively all)
           } : {},
           rolldownOptions: {
-            input: import_node_path9.default.join(tempDir, "index.html"),
+            input: import_node_path12.default.join(tempDir, "index.html"),
             external: (id) => {
               return false;
             }
@@ -7101,11 +7907,11 @@ export default {
         }
       });
       try {
-        const assetsDir = import_node_path9.default.join(outDir, "assets");
+        const assetsDir = import_node_path12.default.join(outDir, "assets");
         const assetFiles = await fs11.readdir(assetsDir);
         const jsFiles = assetFiles.filter((f) => f.endsWith(".js"));
         for (const jsFile of jsFiles) {
-          const jsPath = import_node_path9.default.join(assetsDir, jsFile);
+          const jsPath = import_node_path12.default.join(assetsDir, jsFile);
           let content = await fs11.readFile(jsPath, "utf8");
           const zodConfigPatterns = [
             // Non-minified: export const globalConfig = {}
@@ -7137,7 +7943,7 @@ export default {
       const mcpServerUrl = process.env.MCP_SERVER_URL;
       if (mcpServerUrl) {
         try {
-          const htmlPath = import_node_path9.default.join(outDir, "index.html");
+          const htmlPath = import_node_path12.default.join(outDir, "index.html");
           let html = await fs11.readFile(htmlPath, "utf8");
           const injectionScript = `<script>window.__getFile = (filename) => { return "${mcpUrl}/${widgetName}/"+filename }; window.__mcpPublicUrl = "${mcpServerUrl}/mcp-use/public"; window.__mcpPublicAssetsUrl = "${mcpUrl}/public";</script>`;
           if (!html.includes("window.__mcpPublicUrl")) {
@@ -7213,7 +8019,7 @@ async function collectTsFiles(projectPath, includePatterns, excludePatterns) {
   for (const file of literalFiles) {
     if (/\.tsx?$/.test(file) && !file.endsWith(".d.ts")) {
       try {
-        await (0, import_promises7.access)(import_node_path9.default.join(projectPath, file));
+        await (0, import_promises8.access)(import_node_path12.default.join(projectPath, file));
         files.push(file);
       } catch {
       }
@@ -7221,13 +8027,13 @@ async function collectTsFiles(projectPath, includePatterns, excludePatterns) {
   }
   const excludeSet = new Set(excludePatterns.map((e) => e.replace(/\*+/g, "")));
   for (const prefix of dirPrefixes) {
-    const dirPath = import_node_path9.default.join(projectPath, prefix);
+    const dirPath = import_node_path12.default.join(projectPath, prefix);
     try {
       const entries = await fs11.readdir(dirPath, { recursive: true });
       for (const entry of entries) {
         const entryStr = String(entry);
-        const rel = import_node_path9.default.join(prefix, entryStr);
-        if (/\.tsx?$/.test(entryStr) && !entryStr.endsWith(".d.ts") && !excludeSet.has(rel.split(import_node_path9.default.sep)[0])) {
+        const rel = import_node_path12.default.join(prefix, entryStr);
+        if (/\.tsx?$/.test(entryStr) && !entryStr.endsWith(".d.ts") && !excludeSet.has(rel.split(import_node_path12.default.sep)[0])) {
           files.push(rel);
         }
       }
@@ -7239,7 +8045,7 @@ async function collectTsFiles(projectPath, includePatterns, excludePatterns) {
 async function transpileWithEsbuild(projectPath) {
   const esbuild = await import("esbuild");
   const { promises: fs11 } = await import("fs");
-  const tsconfigPath = import_node_path9.default.join(projectPath, "tsconfig.json");
+  const tsconfigPath = import_node_path12.default.join(projectPath, "tsconfig.json");
   let tsconfig = {};
   try {
     const raw = await fs11.readFile(tsconfigPath, "utf-8");
@@ -7269,10 +8075,10 @@ async function transpileWithEsbuild(projectPath) {
   const target = (compilerOptions.target || "ES2022").toLowerCase();
   const moduleStr = (compilerOptions.module || "ESNext").toLowerCase();
   const format = moduleStr.includes("commonjs") ? "cjs" : "esm";
-  const outbase = compilerOptions.rootDir ? import_node_path9.default.resolve(projectPath, compilerOptions.rootDir) : projectPath;
+  const outbase = compilerOptions.rootDir ? import_node_path12.default.resolve(projectPath, compilerOptions.rootDir) : projectPath;
   await esbuild.build({
-    entryPoints: files.map((f) => import_node_path9.default.join(projectPath, f)),
-    outdir: import_node_path9.default.join(projectPath, outDir),
+    entryPoints: files.map((f) => import_node_path12.default.join(projectPath, f)),
+    outdir: import_node_path12.default.join(projectPath, outDir),
     outbase,
     bundle: true,
     packages: "external",
@@ -7299,7 +8105,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
   "Inline all JS/CSS into HTML (required for VS Code MCP Apps)"
 ).option("--no-inline", "Keep JS/CSS as separate files (default)").option("--no-typecheck", "Skip TypeScript type checking (faster builds)").action(async (options) => {
   try {
-    const projectPath = import_node_path9.default.resolve(options.path);
+    const projectPath = import_node_path12.default.resolve(options.path);
     const { promises: fs11 } = await import("fs");
     displayPackageVersions(projectPath);
     const mcpDir = options.mcpDir;
@@ -7359,7 +8165,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
     }
     if (options.typecheck !== false && !mcpDir) {
       console.log(source_default.gray("Type checking..."));
-      const tscBin = import_node_path9.default.join(
+      const tscBin = import_node_path12.default.join(
         projectPath,
         "node_modules",
         "typescript",
@@ -7382,7 +8188,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
       if (mcpDir) {
         entryPoint = sourceServerFile;
       } else {
-        const baseName = import_node_path9.default.basename(sourceServerFile, ".ts") + ".js";
+        const baseName = import_node_path12.default.basename(sourceServerFile, ".ts") + ".js";
         const possibleOutputs = [
           `dist/${baseName}`,
           // rootDir set to project root or src
@@ -7393,7 +8199,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
         ];
         for (const candidate of possibleOutputs) {
           try {
-            await (0, import_promises7.access)(import_node_path9.default.join(projectPath, candidate));
+            await (0, import_promises8.access)(import_node_path12.default.join(projectPath, candidate));
             entryPoint = candidate;
             break;
           } catch {
@@ -7402,17 +8208,17 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
         }
       }
     }
-    const publicDir = import_node_path9.default.join(projectPath, "public");
+    const publicDir = import_node_path12.default.join(projectPath, "public");
     try {
       await fs11.access(publicDir);
       console.log(source_default.gray("Copying public assets..."));
-      await fs11.cp(publicDir, import_node_path9.default.join(projectPath, "dist", "public"), {
+      await fs11.cp(publicDir, import_node_path12.default.join(projectPath, "dist", "public"), {
         recursive: true
       });
       console.log(source_default.green("\u2713 Public assets copied"));
     } catch {
     }
-    const manifestPath = import_node_path9.default.join(projectPath, "dist", "mcp-use.json");
+    const manifestPath = import_node_path12.default.join(projectPath, "dist", "mcp-use.json");
     let existingManifest = {};
     try {
       const existingContent = await fs11.readFile(manifestPath, "utf-8");
@@ -7437,7 +8243,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
       // Server entry point for `mcp-use start`
       widgets: widgetsData
     };
-    await fs11.mkdir(import_node_path9.default.dirname(manifestPath), { recursive: true });
+    await fs11.mkdir(import_node_path12.default.dirname(manifestPath), { recursive: true });
     await fs11.writeFile(
       manifestPath,
       JSON.stringify(manifest, null, 2),
@@ -7474,7 +8280,7 @@ program.command("dev").description("Run development server with auto-reload and
 ).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_path9.default.resolve(options.path);
+    const projectPath = import_node_path12.default.resolve(options.path);
     let port = parseInt(options.port, 10);
     const host = options.host;
     const useHmr = options.hmr !== false;
@@ -7502,10 +8308,10 @@ program.command("dev").description("Run development server with auto-reload and
     let tunnelUrl = void 0;
     if (options.tunnel) {
       try {
-        const manifestPath = import_node_path9.default.join(projectPath, "dist", "mcp-use.json");
+        const manifestPath = import_node_path12.default.join(projectPath, "dist", "mcp-use.json");
         let existingSubdomain;
         try {
-          const manifestContent = await (0, import_promises7.readFile)(manifestPath, "utf-8");
+          const manifestContent = await (0, import_promises8.readFile)(manifestPath, "utf-8");
           const manifest = JSON.parse(manifestContent);
           existingSubdomain = manifest.tunnel?.subdomain;
           if (existingSubdomain) {
@@ -7543,7 +8349,7 @@ program.command("dev").description("Run development server with auto-reload and
         try {
           let manifest = {};
           try {
-            const manifestContent = await (0, import_promises7.readFile)(manifestPath, "utf-8");
+            const manifestContent = await (0, import_promises8.readFile)(manifestPath, "utf-8");
             manifest = JSON.parse(manifestContent);
           } catch {
           }
@@ -7551,8 +8357,8 @@ program.command("dev").description("Run development server with auto-reload and
             manifest.tunnel = {};
           }
           manifest.tunnel.subdomain = tunnelSubdomain;
-          await (0, import_promises7.mkdir)(import_node_path9.default.dirname(manifestPath), { recursive: true });
-          await (0, import_promises7.writeFile)(
+          await (0, import_promises8.mkdir)(import_node_path12.default.dirname(manifestPath), { recursive: true });
+          await (0, import_promises8.writeFile)(
             manifestPath,
             JSON.stringify(manifest, null, 2),
             "utf-8"
@@ -7606,10 +8412,10 @@ program.command("dev").description("Run development server with auto-reload and
       let args;
       try {
         const projectRequire = createRequire4(
-          import_node_path9.default.join(projectPath, "package.json")
+          import_node_path12.default.join(projectPath, "package.json")
         );
         const tsxPkgPath = projectRequire.resolve("tsx/package.json");
-        const tsxPkg = JSON.parse(await (0, import_promises7.readFile)(tsxPkgPath, "utf-8"));
+        const tsxPkg = JSON.parse(await (0, import_promises8.readFile)(tsxPkgPath, "utf-8"));
         let binPath;
         if (typeof tsxPkg.bin === "string") {
           binPath = tsxPkg.bin;
@@ -7618,7 +8424,7 @@ program.command("dev").description("Run development server with auto-reload and
         } else {
           throw new Error("No bin field found in tsx package.json");
         }
-        const tsxBin = import_node_path9.default.resolve(import_node_path9.default.dirname(tsxPkgPath), binPath);
+        const tsxBin = import_node_path12.default.resolve(import_node_path12.default.dirname(tsxPkgPath), binPath);
         cmd = "node";
         args = [tsxBin, "watch", serverFile];
       } catch (error) {
@@ -7707,10 +8513,10 @@ program.command("dev").description("Run development server with auto-reload and
     const chokidar = chokidarModule.default || chokidarModule;
     const { fileURLToPath: fileURLToPath3 } = await import("url");
     const { createRequire: createRequire3 } = await import("module");
-    const projectTsconfigPath = import_node_path9.default.join(projectPath, "tsconfig.json");
+    const projectTsconfigPath = import_node_path12.default.join(projectPath, "tsconfig.json");
     let tsconfigAvailable = false;
     try {
-      await (0, import_promises7.access)(projectTsconfigPath);
+      await (0, import_promises8.access)(projectTsconfigPath);
       tsconfigAvailable = true;
       process.env.TSX_TSCONFIG_PATH = projectTsconfigPath;
       if (process.cwd() !== projectPath) process.chdir(projectPath);
@@ -7719,7 +8525,7 @@ program.command("dev").description("Run development server with auto-reload and
     let tsxLoaderActive = false;
     try {
       const projectRequire = createRequire3(
-        import_node_path9.default.join(projectPath, "package.json")
+        import_node_path12.default.join(projectPath, "package.json")
       );
       const tsxEsmApiPath = projectRequire.resolve("tsx/esm/api");
       const tsxEsmApi = await import((0, import_node_url3.pathToFileURL)(tsxEsmApiPath).href);
@@ -7750,7 +8556,7 @@ program.command("dev").description("Run development server with auto-reload and
         )
       );
     }
-    const serverFilePath = import_node_path9.default.join(projectPath, serverFile);
+    const serverFilePath = import_node_path12.default.join(projectPath, serverFile);
     const serverFileUrl = (0, import_node_url3.pathToFileURL)(serverFilePath).href;
     globalThis.__mcpUseHmrMode = true;
     const importServerModule = async () => {
@@ -7847,8 +8653,8 @@ program.command("dev").description("Run development server with auto-reload and
     }
     let watcher = chokidar.watch(".", {
       cwd: projectPath,
-      ignored: (path8, stats) => {
-        const normalizedPath = path8.replace(/\\/g, "/");
+      ignored: (path11, stats) => {
+        const normalizedPath = path11.replace(/\\/g, "/");
         if (/(^|\/)\.[^/]/.test(normalizedPath)) {
           return true;
         }
@@ -8022,10 +8828,10 @@ program.command("dev").description("Run development server with auto-reload and
       }
       tunnelUrl = void 0;
       if (withTunnel) {
-        const manifestPath = import_node_path9.default.join(projectPath, "dist", "mcp-use.json");
+        const manifestPath = import_node_path12.default.join(projectPath, "dist", "mcp-use.json");
         let existingSubdomain;
         try {
-          const manifestContent = await (0, import_promises7.readFile)(manifestPath, "utf-8");
+          const manifestContent = await (0, import_promises8.readFile)(manifestPath, "utf-8");
           const manifest = JSON.parse(manifestContent);
           existingSubdomain = manifest.tunnel?.subdomain;
           if (existingSubdomain) {
@@ -8059,16 +8865,16 @@ program.command("dev").description("Run development server with auto-reload and
         tunnelSubdomain = tunnelInfo.subdomain;
         process.env.MCP_URL = tunnelUrl;
         try {
-          const mPath = import_node_path9.default.join(projectPath, "dist", "mcp-use.json");
+          const mPath = import_node_path12.default.join(projectPath, "dist", "mcp-use.json");
           let manifest = {};
           try {
-            manifest = JSON.parse(await (0, import_promises7.readFile)(mPath, "utf-8"));
+            manifest = JSON.parse(await (0, import_promises8.readFile)(mPath, "utf-8"));
           } catch {
           }
           if (!manifest.tunnel) manifest.tunnel = {};
           manifest.tunnel.subdomain = tunnelSubdomain;
-          await (0, import_promises7.mkdir)(import_node_path9.default.dirname(mPath), { recursive: true });
-          await (0, import_promises7.writeFile)(mPath, JSON.stringify(manifest, null, 2), "utf-8");
+          await (0, import_promises8.mkdir)(import_node_path12.default.dirname(mPath), { recursive: true });
+          await (0, import_promises8.writeFile)(mPath, JSON.stringify(manifest, null, 2), "utf-8");
         } catch {
         }
       } else {
@@ -8171,7 +8977,7 @@ program.command("start").description("Start production server").option("-p, --pa
   "Folder holding the MCP entry + resources (e.g. 'src/mcp' for Next.js apps)"
 ).option("--port <port>", "Server port", "3000").option("--tunnel", "Expose server through a tunnel").action(async (options) => {
   try {
-    const projectPath = import_node_path9.default.resolve(options.path);
+    const projectPath = import_node_path12.default.resolve(options.path);
     const portFlagProvided = process.argv.includes("--port") || process.argv.includes("-p") || process.argv.some((arg) => arg.startsWith("--port=")) || process.argv.some((arg) => arg.startsWith("-p="));
     let port = portFlagProvided ? parseInt(options.port, 10) : parseInt(process.env.PORT || options.port || "3000", 10);
     if (!await isPortAvailable(port)) {
@@ -8189,10 +8995,10 @@ program.command("start").description("Start production server").option("-p, --pa
     let tunnelSubdomain = void 0;
     if (options.tunnel) {
       try {
-        const manifestPath2 = import_node_path9.default.join(projectPath, "dist", "mcp-use.json");
+        const manifestPath2 = import_node_path12.default.join(projectPath, "dist", "mcp-use.json");
         let existingSubdomain;
         try {
-          const manifestContent = await (0, import_promises7.readFile)(manifestPath2, "utf-8");
+          const manifestContent = await (0, import_promises8.readFile)(manifestPath2, "utf-8");
           const manifest = JSON.parse(manifestContent);
           existingSubdomain = manifest.tunnel?.subdomain;
           if (existingSubdomain) {
@@ -8236,7 +9042,7 @@ program.command("start").description("Start production server").option("-p, --pa
         try {
           let manifest = {};
           try {
-            const manifestContent = await (0, import_promises7.readFile)(manifestPath2, "utf-8");
+            const manifestContent = await (0, import_promises8.readFile)(manifestPath2, "utf-8");
             manifest = JSON.parse(manifestContent);
           } catch {
           }
@@ -8244,8 +9050,8 @@ program.command("start").description("Start production server").option("-p, --pa
             manifest.tunnel = {};
           }
           manifest.tunnel.subdomain = subdomain;
-          await (0, import_promises7.mkdir)(import_node_path9.default.dirname(manifestPath2), { recursive: true });
-          await (0, import_promises7.writeFile)(
+          await (0, import_promises8.mkdir)(import_node_path12.default.dirname(manifestPath2), { recursive: true });
+          await (0, import_promises8.writeFile)(
             manifestPath2,
             JSON.stringify(manifest, null, 2),
             "utf-8"
@@ -8263,12 +9069,12 @@ program.command("start").description("Start production server").option("-p, --pa
       }
     }
     let serverFile;
-    const manifestPath = import_node_path9.default.join(projectPath, "dist", "mcp-use.json");
+    const manifestPath = import_node_path12.default.join(projectPath, "dist", "mcp-use.json");
     try {
-      const manifestContent = await (0, import_promises7.readFile)(manifestPath, "utf-8");
+      const manifestContent = await (0, import_promises8.readFile)(manifestPath, "utf-8");
       const manifest = JSON.parse(manifestContent);
       if (manifest.entryPoint) {
-        await (0, import_promises7.access)(import_node_path9.default.join(projectPath, manifest.entryPoint));
+        await (0, import_promises8.access)(import_node_path12.default.join(projectPath, manifest.entryPoint));
         serverFile = manifest.entryPoint;
       }
     } catch {
@@ -8289,7 +9095,7 @@ program.command("start").description("Start production server").option("-p, --pa
       ];
       for (const candidate of serverCandidates) {
         try {
-          await (0, import_promises7.access)(import_node_path9.default.join(projectPath, candidate));
+          await (0, import_promises8.access)(import_node_path12.default.join(projectPath, candidate));
           serverFile = candidate;
           break;
         } catch {
@@ -8340,13 +9146,13 @@ Looked for:
     if (isTsEntry) {
       try {
         const projectRequire = (0, import_node_module2.createRequire)(
-          import_node_path9.default.join(projectPath, "package.json")
+          import_node_path12.default.join(projectPath, "package.json")
         );
         const tsxPkgPath = projectRequire.resolve("tsx/package.json");
-        const tsxPkg = JSON.parse(await (0, import_promises7.readFile)(tsxPkgPath, "utf-8"));
+        const tsxPkg = JSON.parse(await (0, import_promises8.readFile)(tsxPkgPath, "utf-8"));
         const binField = typeof tsxPkg.bin === "string" ? tsxPkg.bin : tsxPkg.bin?.tsx ?? Object.values(tsxPkg.bin ?? {})[0];
         if (!binField) throw new Error("tsx bin entry not found");
-        const tsxBin = import_node_path9.default.resolve(import_node_path9.default.dirname(tsxPkgPath), binField);
+        const tsxBin = import_node_path12.default.resolve(import_node_path12.default.dirname(tsxPkgPath), binField);
         spawnCmd = "node";
         spawnArgs = [tsxBin, serverFile];
       } catch (error) {
@@ -8359,7 +9165,7 @@ Looked for:
         spawnArgs = ["tsx", serverFile];
       }
     }
-    const serverProc = (0, import_node_child_process9.spawn)(spawnCmd, spawnArgs, {
+    const serverProc = (0, import_node_child_process11.spawn)(spawnCmd, spawnArgs, {
       cwd: projectPath,
       stdio: "inherit",
       env: env2
@@ -8492,10 +9298,11 @@ program.addCommand(createClientCommand());
 program.addCommand(createDeploymentsCommand());
 program.addCommand(createServersCommand());
 program.addCommand(createSkillsCommand());
+program.addCommand(createScreenshotCommand());
 program.command("generate-types").description(
   "Generate TypeScript type definitions for tools (writes .mcp-use/tool-registry.d.ts)"
 ).option("-p, --path <path>", "Path to project directory", process.cwd()).option("--server <file>", "Server entry file", "index.ts").action(async (options) => {
-  const projectPath = import_node_path9.default.resolve(options.path);
+  const projectPath = import_node_path12.default.resolve(options.path);
   try {
     console.log(source_default.blue("Generating tool registry types..."));
     const result = await generateToolRegistryTypesForServer(