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

package/dist/index.js

@@ -9,12 +9,12 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// ../../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/esm_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/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
 var getFilename, getDirname, __dirname;
 var init_esm_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/esm_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/esm_shims.js"() {
     "use strict";
     getFilename = () => fileURLToPath(import.meta.url);
     getDirname = () => path.dirname(getFilename());
@@ -235,15 +235,15 @@ var init_wsl_utils = __esm({
       const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
       return stdout.trim();
     };
-    convertWslPathToWindows = async (path9) => {
-      if (/^[a-z]+:\/\//i.test(path9)) {
-        return path9;
+    convertWslPathToWindows = async (path12) => {
+      if (/^[a-z]+:\/\//i.test(path12)) {
+        return path12;
       }
       try {
-        const { stdout } = await execFile2("wslpath", ["-aw", path9], { encoding: "utf8" });
+        const { stdout } = await execFile2("wslpath", ["-aw", path12], { encoding: "utf8" });
         return stdout.trim();
       } catch {
-        return path9;
+        return path12;
       }
     };
   }
@@ -1263,13 +1263,13 @@ var source_default = chalk;
 
 // src/index.ts
 init_open();
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 import "dotenv/config";
-import { spawn } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { readFileSync as readFileSync2 } from "fs";
-import { access, mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { access, mkdir as mkdir4, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
-import path8 from "path";
+import path11 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { viteSingleFile } from "vite-plugin-singlefile";
 import { toJSONSchema } from "zod";
@@ -1506,8 +1506,8 @@ var McpUseAPI = class _McpUseAPI {
     return this.request(`/servers${q ? `?${q}` : ""}`);
   }
   async getServer(idOrSlug) {
-    const path9 = encodeURIComponent(idOrSlug);
-    return this.request(`/servers/${path9}`);
+    const path12 = encodeURIComponent(idOrSlug);
+    return this.request(`/servers/${path12}`);
   }
   async deleteServer(id) {
     await this.request(
@@ -2009,9 +2009,8 @@ async function whoamiCommand() {
 
 // src/commands/client.ts
 init_esm_shims();
-import { Command } from "commander";
-import { MCPClient } from "mcp-use/client";
-import { getPackageVersion } from "mcp-use/server";
+import { Command as Command2 } from "commander";
+import { MCPClient as MCPClient3 } from "mcp-use/client";
 import { createInterface as createInterface2 } from "readline";
 
 // src/utils/format.ts
@@ -2610,6 +2609,121 @@ async function updateSessionInfo(name, serverInfo, capabilities) {
   }
 }
 
+// src/utils/session.ts
+init_esm_shims();
+import { MCPClient } from "mcp-use/client";
+import { getPackageVersion } from "mcp-use/server";
+var activeSessions = /* @__PURE__ */ new Map();
+function getCliClientInfo() {
+  return {
+    name: "mcp-use CLI",
+    title: "mcp-use CLI",
+    version: 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 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_esm_shims();
 async function resolveSession(sessionArg) {
@@ -2725,121 +2839,711 @@ 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_esm_shims();
+import { Command } from "commander";
+import { MCPClient as MCPClient2 } from "mcp-use/client";
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2 } from "fs/promises";
+import { createServer } from "net";
+import path6 from "path";
+
+// src/utils/cdp-screenshot.ts
+init_esm_shims();
+import { spawn } from "child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import os4 from "os";
+import path4 from "path";
+import WebSocket from "ws";
+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) {
+  const userDataDir = mkdtempSync(path4.join(os4.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"
+  ];
+  const child = spawn(opts.chromePath, chromeArgs, {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  child.stdout?.resume();
+  let cdp;
+  let cleanedUp = false;
+  const cleanup = () => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    cdp?.close();
+    if (!child.killed) {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      const killTimer = setTimeout(() => {
+        if (!child.killed) {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+        }
+      }, 2e3);
+      killTimer.unref();
+    }
+    try {
+      rmSync(userDataDir, { recursive: true, force: true });
+    } catch {
+    }
+  };
+  try {
+    const wsUrl = await waitForDevToolsUrl(child);
+    const ws = new WebSocket(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);
+    const { targetId } = await cdp.send(
+      "Target.createTarget",
+      { url: "about:blank" }
+    );
+    const { sessionId } = await cdp.send(
+      "Target.attachToTarget",
+      { targetId, flatten: true }
+    );
+    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
       );
-      console.error(
-        formatInfo("Use: npx mcp-use client connect <url> --name <name>")
+    }
+    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
       );
-      return null;
+      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));
     }
-    sessionName = active.name;
+    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
+    );
+    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_esm_shims();
+import { accessSync, constants } from "fs";
+import path5 from "path";
+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 {
+    accessSync(p, 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 = path5.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 = path5.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 = 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 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 = path6.resolve(options.output ?? `./${view}-${ts}.png`);
+    await mkdir2(path6.dirname(outputPath), { recursive: true });
+    await captureScreenshot({
+      url: previewUrl.toString(),
+      width,
+      height,
+      theme,
+      waitForSelector: options.waitFor ?? 'body[data-view-ready="true"]',
+      timeoutMs,
+      outputPath,
+      chromePath,
+      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 = 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 : path6.dirname(new URL(import.meta.url).pathname);
+  candidateRoots.add(moduleDir);
+  candidateRoots.add(process.cwd());
+  for (const start of candidateRoots) {
+    let dir = start;
+    while (true) {
+      const candidate = path6.join(
+        dir,
+        "node_modules",
+        "@mcp-use",
+        "inspector",
+        "dist",
+        "cli.js"
+      );
+      if (existsSync2(candidate)) return candidate;
+      const parent = path6.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 = spawn2(
+    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 MCPClient2();
+    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: 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
       }
-    ],
-    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 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("--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 MCPClient();
+    const client = new MCPClient3();
     let session;
     const cliClientInfo = getCliClientInfo();
     if (options.stdio) {
@@ -3156,11 +3860,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);
     }
@@ -3554,7 +4301,7 @@ async function interactiveCommand(options) {
   }
 }
 function createClientCommand() {
-  const clientCommand = new Command("client").description(
+  const clientCommand = new Command2("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(
@@ -3565,22 +4312,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 Command("sessions").description(
+  const sessionsCommand = new Command2("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 Command("tools").description(
+  const toolsCommand = new Command2("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 Command("resources").description(
+  const resourcesCommand = new Command2("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);
@@ -3588,7 +4341,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 Command("prompts").description(
+  const promptsCommand = new Command2("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);
@@ -3597,7 +4350,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 Command("auth").description(
+  const authCommand = new Command2("auth").description(
     "Manage OAuth tokens for HTTP sessions"
   );
   authCommand.command("status [session]").description("Show OAuth token status for a session").action(authStatusCommand);
@@ -3611,7 +4364,7 @@ function createClientCommand() {
 init_esm_shims();
 init_open();
 import { promises as fs9 } from "fs";
-import path5 from "path";
+import path8 from "path";
 
 // src/utils/git.ts
 init_esm_shims();
@@ -3769,15 +4522,15 @@ function getMcpServerUrlForCloudServer(server) {
 // src/utils/project-link.ts
 init_esm_shims();
 import { promises as fs8 } from "fs";
-import path4 from "path";
+import path7 from "path";
 var MCP_USE_DIR = ".mcp-use";
 var MCP_USE_DIR_PROJECT = "project.json";
 function getMcpUseDirectory(cwd) {
-  return path4.join(cwd, MCP_USE_DIR);
+  return path7.join(cwd, MCP_USE_DIR);
 }
 async function getProjectLink(cwd) {
   try {
-    const linkPath = path4.join(getMcpUseDirectory(cwd), MCP_USE_DIR_PROJECT);
+    const linkPath = path7.join(getMcpUseDirectory(cwd), MCP_USE_DIR_PROJECT);
     const content = await fs8.readFile(linkPath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
@@ -3788,12 +4541,12 @@ async function getProjectLink(cwd) {
 async function saveProjectLink(cwd, link) {
   const mcpUseDir = getMcpUseDirectory(cwd);
   await fs8.mkdir(mcpUseDir, { recursive: true });
-  const linkPath = path4.join(mcpUseDir, MCP_USE_DIR_PROJECT);
+  const linkPath = path7.join(mcpUseDir, MCP_USE_DIR_PROJECT);
   await fs8.writeFile(linkPath, JSON.stringify(link, null, 2), "utf-8");
   await addToGitIgnore(cwd);
 }
 async function addToGitIgnore(cwd) {
-  const gitignorePath = path4.join(cwd, ".gitignore");
+  const gitignorePath = path7.join(cwd, ".gitignore");
   try {
     let content = "";
     try {
@@ -3934,7 +4687,7 @@ async function buildEnvVars(options) {
 }
 async function isMcpProject(cwd = process.cwd()) {
   try {
-    const content = await fs9.readFile(path5.join(cwd, "package.json"), "utf-8");
+    const content = await fs9.readFile(path8.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 {
@@ -3943,16 +4696,16 @@ async function isMcpProject(cwd = process.cwd()) {
 }
 async function getProjectName(cwd = process.cwd()) {
   try {
-    const content = await fs9.readFile(path5.join(cwd, "package.json"), "utf-8");
+    const content = await fs9.readFile(path8.join(cwd, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     if (pkg.name) return pkg.name;
   } catch {
   }
-  return path5.basename(cwd);
+  return path8.basename(cwd);
 }
 async function detectBuildCommand(cwd) {
   try {
-    const content = await fs9.readFile(path5.join(cwd, "package.json"), "utf-8");
+    const content = await fs9.readFile(path8.join(cwd, "package.json"), "utf-8");
     if (JSON.parse(content).scripts?.build) return "npm run build";
   } catch {
   }
@@ -3960,7 +4713,7 @@ async function detectBuildCommand(cwd) {
 }
 async function detectStartCommand(cwd) {
   try {
-    const content = await fs9.readFile(path5.join(cwd, "package.json"), "utf-8");
+    const content = await fs9.readFile(path8.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}`;
@@ -3971,7 +4724,7 @@ async function detectStartCommand(cwd) {
 async function detectRuntime(cwd) {
   for (const f of ["requirements.txt", "pyproject.toml", "setup.py"]) {
     try {
-      await fs9.access(path5.join(cwd, f));
+      await fs9.access(path8.join(cwd, f));
       return "python";
     } catch {
       continue;
@@ -4018,7 +4771,7 @@ var REQUIRED_IGNORES = [
   ".mcp-use"
 ];
 async function ensureGitignore(cwd) {
-  const gitignorePath = path5.join(cwd, ".gitignore");
+  const gitignorePath = path8.join(cwd, ".gitignore");
   let content = "";
   try {
     content = await fs9.readFile(gitignorePath, "utf-8");
@@ -4478,7 +5231,7 @@ async function deployCommand(options) {
     console.log(source_default.green("\u2713 GitHub connected\n"));
     let installationDbId;
     let githubInstallationId;
-    const projectDir = options.rootDir ? path5.resolve(cwd, options.rootDir) : cwd;
+    const projectDir = options.rootDir ? path8.resolve(cwd, options.rootDir) : cwd;
     if (options.rootDir) {
       try {
         await fs9.access(projectDir);
@@ -4991,7 +5744,7 @@ async function deployCommand(options) {
 
 // src/commands/deployments.ts
 init_esm_shims();
-import { Command as Command2 } from "commander";
+import { Command as Command3 } from "commander";
 async function prompt2(question) {
   const readline = await import("readline");
   const rl = readline.createInterface({
@@ -5403,7 +6156,7 @@ async function startDeploymentCommand(deploymentId) {
   }
 }
 function createDeploymentsCommand() {
-  const deploymentsCommand = new Command2("deployments").description(
+  const deploymentsCommand = new Command3("deployments").description(
     "Manage cloud deployments"
   );
   deploymentsCommand.command("list").alias("ls").description("List all deployments").action(listDeploymentsCommand);
@@ -5420,11 +6173,11 @@ function createDeploymentsCommand() {
 
 // src/commands/servers.ts
 init_esm_shims();
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 
 // src/commands/env.ts
 init_esm_shims();
-import { Command as Command3 } from "commander";
+import { Command as Command4 } from "commander";
 var ALL_ENVS = ["production", "preview", "development"];
 function parseEnvironments(raw) {
   const parts = raw.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
@@ -5569,7 +6322,7 @@ async function removeEnvCommand(varId, options) {
   }
 }
 function createEnvCommand() {
-  const envCommand = new Command3("env").description(
+  const envCommand = new Command4("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);
@@ -5853,7 +6606,7 @@ async function deleteServerCommand(serverId, options) {
   }
 }
 function createServersCommand() {
-  const serversCommand = new Command4("servers").description(
+  const serversCommand = new Command5("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);
@@ -5973,8 +6726,8 @@ async function orgCurrentCommand() {
 
 // src/commands/skills.ts
 init_esm_shims();
-import { Command as Command5 } from "commander";
-import { cpSync, existsSync as existsSync2, mkdtempSync, readdirSync, rmSync } from "fs";
+import { Command as Command6 } from "commander";
+import { cpSync, existsSync as existsSync3, mkdtempSync as mkdtempSync2, readdirSync, rmSync as rmSync2 } from "fs";
 import { tmpdir } from "os";
 import { join as join2, resolve } from "path";
 import { Readable } from "stream";
@@ -6013,7 +6766,7 @@ function sendInstallTelemetryEvent(agents, skills) {
 }
 async function addSkillsToProject(projectPath) {
   const tarballUrl = `https://codeload.github.com/${REPO_OWNER}/${REPO_NAME}/tar.gz/${REPO_BRANCH}`;
-  const tempDir = mkdtempSync(join2(tmpdir(), "mcp-use-skills-"));
+  const tempDir = mkdtempSync2(join2(tmpdir(), "mcp-use-skills-"));
   try {
     const response = await fetch(tarballUrl);
     if (!response.ok) {
@@ -6023,12 +6776,12 @@ async function addSkillsToProject(projectPath) {
       Readable.fromWeb(response.body),
       extract({
         cwd: tempDir,
-        filter: (path9) => path9.includes("/skills/"),
+        filter: (path12) => path12.includes("/skills/"),
         strip: 1
       })
     );
     const skillsPath = join2(tempDir, "skills");
-    if (!existsSync2(skillsPath)) {
+    if (!existsSync3(skillsPath)) {
       throw new Error("Skills folder not found in repository");
     }
     for (const preset of ALL_PRESETS) {
@@ -6039,16 +6792,16 @@ async function addSkillsToProject(projectPath) {
     const skillNames = readdirSync(skillsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     sendInstallTelemetryEvent(ALL_PRESETS.join(","), skillNames.join(","));
   } finally {
-    rmSync(tempDir, { recursive: true, force: true });
+    rmSync2(tempDir, { recursive: true, force: true });
   }
 }
 function createSkillsCommand() {
-  const skills = new Command5("skills").description(
+  const skills = new Command6("skills").description(
     "Manage mcp-use AI agent skills"
   );
   const installAction = async (options) => {
     const projectPath = resolve(options.path);
-    if (!existsSync2(projectPath)) {
+    if (!existsSync3(projectPath)) {
       console.error(source_default.red(`Directory not found: ${projectPath}`));
       process.exit(1);
     }
@@ -6090,12 +6843,12 @@ function createSkillsCommand() {
 
 // src/utils/next-shims.ts
 init_esm_shims();
-import { existsSync as existsSync3, promises as fs10 } from "fs";
-import path6 from "path";
+import { existsSync as existsSync4, promises as fs10 } from "fs";
+import path9 from "path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
 async function detectNextJsProject(projectPath) {
   try {
-    const pkgPath = path6.join(projectPath, "package.json");
+    const pkgPath = path9.join(projectPath, "package.json");
     const content = await fs10.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     const deps = pkg.dependencies ?? {};
@@ -6114,7 +6867,7 @@ async function loadNextJsEnvFiles(projectPath) {
   ];
   const dotenv = await import("dotenv");
   for (const file of files) {
-    const abs = path6.join(projectPath, file);
+    const abs = path9.join(projectPath, file);
     try {
       await fs10.access(abs);
     } catch {
@@ -6126,20 +6879,20 @@ async function loadNextJsEnvFiles(projectPath) {
 function getThisDir() {
   if (typeof __dirname === "string") return __dirname;
   const url = import.meta.url;
-  return path6.dirname(fileURLToPath3(url));
+  return path9.dirname(fileURLToPath3(url));
 }
 function resolveShimPath(filename) {
   const thisDir = getThisDir();
   const candidates = [
     // Production: `dist/` next to this module
-    path6.join(thisDir, "shims", filename),
+    path9.join(thisDir, "shims", filename),
     // Test / dev: one level up (e.g., from `dist/utils/` back to `src/shims/`)
-    path6.join(thisDir, "..", "shims", filename),
-    path6.join(thisDir, "..", "..", "src", "shims", filename),
-    path6.join(thisDir, "..", "src", "shims", filename)
+    path9.join(thisDir, "..", "shims", filename),
+    path9.join(thisDir, "..", "..", "src", "shims", filename),
+    path9.join(thisDir, "..", "src", "shims", filename)
   ];
   for (const candidate of candidates) {
-    if (existsSync3(candidate)) return candidate;
+    if (existsSync4(candidate)) return candidate;
   }
   return void 0;
 }
@@ -6157,7 +6910,7 @@ async function registerNextShimsInProcess() {
   const cjsPath = getShimCjsPreloadPath();
   if (cjsPath) {
     const { createRequire: createRequire3 } = await import("module");
-    const req = createRequire3(pathToFileURL(getThisDir() + path6.sep).href);
+    const req = createRequire3(pathToFileURL(getThisDir() + path9.sep).href);
     req(cjsPath);
     anyRegistered = true;
   }
@@ -6165,7 +6918,7 @@ async function registerNextShimsInProcess() {
   if (loaderPath) {
     const { register } = await import("module");
     const loaderUrl = pathToFileURL(loaderPath).href;
-    register(loaderUrl, pathToFileURL(getThisDir() + path6.sep).href);
+    register(loaderUrl, pathToFileURL(getThisDir() + path9.sep).href);
     anyRegistered = true;
   }
   return anyRegistered;
@@ -6192,12 +6945,12 @@ function quoteNodeOption(value) {
 // src/utils/update-check.ts
 init_esm_shims();
 import { readFileSync } from "fs";
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { createRequire } from "module";
-import os4 from "os";
-import path7 from "path";
-var CACHE_DIR = path7.join(os4.homedir(), ".mcp-use");
-var CACHE_FILE = path7.join(CACHE_DIR, "update-check.json");
+import os5 from "os";
+import path10 from "path";
+var CACHE_DIR = path10.join(os5.homedir(), ".mcp-use");
+var CACHE_FILE = path10.join(CACHE_DIR, "update-check.json");
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 3e3;
 var PACKAGE_NAME = "mcp-use";
@@ -6230,7 +6983,7 @@ async function readCache() {
 }
 async function writeCache(latestVersion) {
   try {
-    await mkdir2(CACHE_DIR, { recursive: true });
+    await mkdir3(CACHE_DIR, { recursive: true });
     const cache = {
       lastChecked: (/* @__PURE__ */ new Date()).toISOString(),
       latestVersion
@@ -6280,12 +7033,12 @@ function resolveInstalledVersion(projectPath) {
   if (projectPath) {
     attempts.push(() => {
       const projectRequire = createRequire(
-        path7.join(projectPath, "package.json")
+        path10.join(projectPath, "package.json")
       );
       return projectRequire.resolve(`${PACKAGE_NAME}/package.json`);
     });
   }
-  attempts.push(() => path7.join(__dirname, "../../mcp-use/package.json"));
+  attempts.push(() => path10.join(__dirname, "../../mcp-use/package.json"));
   for (const attempt of attempts) {
     try {
       const pkgPath = attempt();
@@ -6321,9 +7074,9 @@ A new release of ${source_default.bold(PACKAGE_NAME)} is available: ${source_def
 }
 
 // src/index.ts
-var program = new Command6();
+var program = new Command7();
 var packageContent = readFileSync2(
-  path8.join(__dirname, "../package.json"),
+  path11.join(__dirname, "../package.json"),
   "utf-8"
 );
 var packageJson = JSON.parse(packageContent);
@@ -6354,14 +7107,14 @@ function displayPackageVersions(projectPath) {
       if (projectPath) {
         try {
           const projectRequire = createRequire2(
-            path8.join(projectPath, "package.json")
+            path11.join(projectPath, "package.json")
           );
           pkgPath = projectRequire.resolve(`${pkg.name}/package.json`);
         } catch (resolveError) {
-          pkgPath = path8.join(__dirname, pkg.relativePath);
+          pkgPath = path11.join(__dirname, pkg.relativePath);
         }
       } else {
-        pkgPath = path8.join(__dirname, pkg.relativePath);
+        pkgPath = path11.join(__dirname, pkg.relativePath);
       }
       const pkgContent = readFileSync2(pkgPath, "utf-8");
       const pkgJson = JSON.parse(pkgContent);
@@ -6418,7 +7171,7 @@ function normalizeBrowserHost(host) {
   return host === "0.0.0.0" ? "localhost" : host;
 }
 function runCommand(command, args, cwd, env2, filterStderr = false) {
-  const proc = spawn(command, args, {
+  const proc = spawn3(command, args, {
     cwd,
     stdio: filterStderr ? ["inherit", "inherit", "pipe"] : "inherit",
     shell: process.platform === "win32",
@@ -6451,7 +7204,7 @@ async function startTunnel(port, subdomain) {
     if (subdomain) {
       tunnelArgs.push("--subdomain", subdomain);
     }
-    const proc = spawn("npx", tunnelArgs, {
+    const proc = spawn3("npx", tunnelArgs, {
       stdio: ["ignore", "pipe", "pipe"],
       shell: process.platform === "win32"
     });
@@ -6515,21 +7268,21 @@ async function startTunnel(port, subdomain) {
 }
 async function resolveEntryFile(projectPath, cliEntry, mcpDir) {
   if (cliEntry) {
-    await access(path8.join(projectPath, cliEntry)).catch(() => {
+    await access(path11.join(projectPath, cliEntry)).catch(() => {
       throw new Error(`File not found: ${cliEntry}`);
     });
     return cliEntry;
   }
   if (mcpDir) {
     const mcpCandidates = [
-      path8.join(mcpDir, "index.ts"),
-      path8.join(mcpDir, "index.tsx"),
-      path8.join(mcpDir, "server.ts"),
-      path8.join(mcpDir, "server.tsx")
+      path11.join(mcpDir, "index.ts"),
+      path11.join(mcpDir, "index.tsx"),
+      path11.join(mcpDir, "server.ts"),
+      path11.join(mcpDir, "server.tsx")
     ];
     for (const candidate of mcpCandidates) {
       try {
-        await access(path8.join(projectPath, candidate));
+        await access(path11.join(projectPath, candidate));
         return candidate;
       } catch {
         continue;
@@ -6538,17 +7291,17 @@ async function resolveEntryFile(projectPath, cliEntry, mcpDir) {
     throw new Error(
       `No entry file found inside ${mcpDir}.
 
-Expected one of: ${mcpCandidates.map((c) => path8.relative(projectPath, path8.join(projectPath, c))).join(", ")}
+Expected one of: ${mcpCandidates.map((c) => path11.relative(projectPath, path11.join(projectPath, c))).join(", ")}
 
 Fix this by either:
-  1. Creating ${path8.join(mcpDir, "index.ts")}, or
+  1. Creating ${path11.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 access(path8.join(projectPath, candidate));
+      await access(path11.join(projectPath, candidate));
       return candidate;
     } catch {
       continue;
@@ -6566,7 +7319,7 @@ Fix this by either:
 }
 function resolveWidgetsDir(cliWidgetsDir, mcpDir) {
   if (cliWidgetsDir) return cliWidgetsDir;
-  if (mcpDir) return path8.join(mcpDir, "resources");
+  if (mcpDir) return path11.join(mcpDir, "resources");
   return "resources";
 }
 function makeWidgetServerOnlyGuard(widgetName) {
@@ -6601,7 +7354,7 @@ function isBunRuntime() {
   return typeof globalThis.Bun !== "undefined" || typeof process.versions.bun === "string";
 }
 async function generateToolRegistryTypesForServer(projectPath, serverFileRelative) {
-  const serverFile = path8.join(projectPath, serverFileRelative);
+  const serverFile = path11.join(projectPath, serverFileRelative);
   const serverFileExists = await access(serverFile).then(() => true).catch(() => false);
   if (!serverFileExists) {
     throw new Error(`Server file not found: ${serverFile}`);
@@ -6627,7 +7380,7 @@ async function generateToolRegistryTypesForServer(projectPath, serverFileRelativ
       await loadNextJsEnvFiles(projectPath);
       await registerNextShimsInProcess();
     }
-    const projectTsconfigPath = path8.join(projectPath, "tsconfig.json");
+    const projectTsconfigPath = path11.join(projectPath, "tsconfig.json");
     const hasTsconfig = await access(projectTsconfigPath).then(() => true).catch(() => false);
     if (hasTsconfig) {
       process.env.TSX_TSCONFIG_PATH = projectTsconfigPath;
@@ -6636,7 +7389,7 @@ async function generateToolRegistryTypesForServer(projectPath, serverFileRelativ
     if (previousCwd !== projectPath) process.chdir(projectPath);
     try {
       const projectRequire = createRequire2(
-        path8.join(projectPath, "package.json")
+        path11.join(projectPath, "package.json")
       );
       const tsxEsmApiPath = projectRequire.resolve("tsx/esm/api");
       const tsxEsmApi = await import(pathToFileURL2(tsxEsmApiPath).href);
@@ -6663,8 +7416,8 @@ async function generateToolRegistryTypesForServer(projectPath, serverFileRelativ
         "No MCPServer instance found. Make sure your server file creates an MCPServer instance."
       );
     }
-    const mcpUsePath = path8.join(projectPath, "node_modules", "mcp-use");
-    const { generateToolRegistryTypes } = await import(pathToFileURL2(path8.join(mcpUsePath, "dist", "src", "server", "index.js")).href).then((mod) => mod);
+    const mcpUsePath = path11.join(projectPath, "node_modules", "mcp-use");
+    const { generateToolRegistryTypes } = await import(pathToFileURL2(path11.join(mcpUsePath, "dist", "src", "server", "index.js")).href).then((mod) => mod);
     if (!generateToolRegistryTypes) {
       throw new Error("generateToolRegistryTypes not found in mcp-use package");
     }
@@ -6682,7 +7435,7 @@ async function buildWidgets(projectPath, options = {}) {
   const { promises: fs11 } = await import("fs");
   const { build } = await import("vite");
   const widgetsDirRelative = options.widgetsDir ?? "resources";
-  const resourcesDir = path8.resolve(projectPath, widgetsDirRelative);
+  const resourcesDir = path11.resolve(projectPath, widgetsDirRelative);
   const mcpUrl = process.env.MCP_URL;
   try {
     await access(resourcesDir);
@@ -6704,10 +7457,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: path8.join(resourcesDir, dirent.name)
+          path: path11.join(resourcesDir, dirent.name)
         });
       } else if (dirent.isDirectory()) {
-        const widgetPath = path8.join(resourcesDir, dirent.name, "widget.tsx");
+        const widgetPath = path11.join(resourcesDir, dirent.name, "widget.tsx");
         try {
           await fs11.access(widgetPath);
           entries.push({
@@ -6737,14 +7490,14 @@ async function buildWidgets(projectPath, options = {}) {
   );
   const react = (await import("@vitejs/plugin-react")).default;
   const tailwindcss = (await import("@tailwindcss/vite")).default;
-  const projectTsconfigPath = path8.join(projectPath, "tsconfig.json");
+  const projectTsconfigPath = path11.join(projectPath, "tsconfig.json");
   let hasProjectTsconfig = false;
   try {
     await access(projectTsconfigPath);
     hasProjectTsconfig = true;
   } catch {
   }
-  const packageJsonPath = path8.join(projectPath, "package.json");
+  const packageJsonPath = path11.join(projectPath, "package.json");
   let favicon = "";
   try {
     const pkgContent = await fs11.readFile(packageJsonPath, "utf-8");
@@ -6756,16 +7509,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 = path8.join(projectPath, ".mcp-use", widgetName);
+    const tempDir = path11.join(projectPath, ".mcp-use", widgetName);
     await fs11.mkdir(tempDir, { recursive: true });
-    const relativeResourcesPath = path8.relative(tempDir, resourcesDir).replace(/\\/g, "/");
-    const mcpUsePath = path8.join(projectPath, "node_modules", "mcp-use");
-    const relativeMcpUsePath = path8.relative(tempDir, mcpUsePath).replace(/\\/g, "/");
-    const projectSrcDir = path8.join(projectPath, "src");
+    const relativeResourcesPath = path11.relative(tempDir, resourcesDir).replace(/\\/g, "/");
+    const mcpUsePath = path11.join(projectPath, "node_modules", "mcp-use");
+    const relativeMcpUsePath = path11.relative(tempDir, mcpUsePath).replace(/\\/g, "/");
+    const projectSrcDir = path11.join(projectPath, "src");
     let projectSrcSourceLine = "";
     try {
       await access(projectSrcDir);
-      const relativeProjectSrcPath = path8.relative(tempDir, projectSrcDir).replace(/\\/g, "/");
+      const relativeProjectSrcPath = path11.relative(tempDir, projectSrcDir).replace(/\\/g, "/");
       projectSrcSourceLine = `@source "${relativeProjectSrcPath}";
 `;
     } catch {
@@ -6776,7 +7529,7 @@ async function buildWidgets(projectPath, options = {}) {
 @source "${relativeResourcesPath}";
 @source "${relativeMcpUsePath}/**/*.{ts,tsx,js,jsx}";
 ${projectSrcSourceLine}`;
-    await fs11.writeFile(path8.join(tempDir, "styles.css"), cssContent, "utf8");
+    await fs11.writeFile(path11.join(tempDir, "styles.css"), cssContent, "utf8");
     const entryContent = `import React from 'react'
 import { createRoot } from 'react-dom/client'
 import './styles.css'
@@ -6801,9 +7554,9 @@ if (container && Component) {
     <script type="module" src="/entry.tsx"></script>
   </body>
 </html>`;
-    await fs11.writeFile(path8.join(tempDir, "entry.tsx"), entryContent, "utf8");
-    await fs11.writeFile(path8.join(tempDir, "index.html"), htmlContent, "utf8");
-    const outDir = path8.join(
+    await fs11.writeFile(path11.join(tempDir, "entry.tsx"), entryContent, "utf8");
+    await fs11.writeFile(path11.join(tempDir, "index.html"), htmlContent, "utf8");
+    const outDir = path11.join(
       projectPath,
       "dist",
       "resources",
@@ -6813,13 +7566,13 @@ if (container && Component) {
     const baseUrl = mcpUrl ? `${mcpUrl}/${widgetName}/` : `/mcp-use/widgets/${widgetName}/`;
     let widgetMetadata = {};
     try {
-      const metadataTempDir = path8.join(
+      const metadataTempDir = path11.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",
@@ -6847,9 +7600,9 @@ export default PostHog;
         }
       };
       const serverOnlyGuard = makeWidgetServerOnlyGuard(widgetName);
-      const metadataServer = await createServer({
+      const metadataServer = await createServer2({
         root: metadataTempDir,
-        cacheDir: path8.join(metadataTempDir, ".vite-cache"),
+        cacheDir: path11.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
@@ -7080,7 +7833,7 @@ export default {
             // Inline all assets under 100MB (effectively all)
           } : {},
           rolldownOptions: {
-            input: path8.join(tempDir, "index.html"),
+            input: path11.join(tempDir, "index.html"),
             external: (id) => {
               return false;
             }
@@ -7088,11 +7841,11 @@ export default {
         }
       });
       try {
-        const assetsDir = path8.join(outDir, "assets");
+        const assetsDir = path11.join(outDir, "assets");
         const assetFiles = await fs11.readdir(assetsDir);
         const jsFiles = assetFiles.filter((f) => f.endsWith(".js"));
         for (const jsFile of jsFiles) {
-          const jsPath = path8.join(assetsDir, jsFile);
+          const jsPath = path11.join(assetsDir, jsFile);
           let content = await fs11.readFile(jsPath, "utf8");
           const zodConfigPatterns = [
             // Non-minified: export const globalConfig = {}
@@ -7124,7 +7877,7 @@ export default {
       const mcpServerUrl = process.env.MCP_SERVER_URL;
       if (mcpServerUrl) {
         try {
-          const htmlPath = path8.join(outDir, "index.html");
+          const htmlPath = path11.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")) {
@@ -7200,7 +7953,7 @@ async function collectTsFiles(projectPath, includePatterns, excludePatterns) {
   for (const file of literalFiles) {
     if (/\.tsx?$/.test(file) && !file.endsWith(".d.ts")) {
       try {
-        await access(path8.join(projectPath, file));
+        await access(path11.join(projectPath, file));
         files.push(file);
       } catch {
       }
@@ -7208,13 +7961,13 @@ async function collectTsFiles(projectPath, includePatterns, excludePatterns) {
   }
   const excludeSet = new Set(excludePatterns.map((e) => e.replace(/\*+/g, "")));
   for (const prefix of dirPrefixes) {
-    const dirPath = path8.join(projectPath, prefix);
+    const dirPath = path11.join(projectPath, prefix);
     try {
       const entries = await fs11.readdir(dirPath, { recursive: true });
       for (const entry of entries) {
         const entryStr = String(entry);
-        const rel = path8.join(prefix, entryStr);
-        if (/\.tsx?$/.test(entryStr) && !entryStr.endsWith(".d.ts") && !excludeSet.has(rel.split(path8.sep)[0])) {
+        const rel = path11.join(prefix, entryStr);
+        if (/\.tsx?$/.test(entryStr) && !entryStr.endsWith(".d.ts") && !excludeSet.has(rel.split(path11.sep)[0])) {
           files.push(rel);
         }
       }
@@ -7226,7 +7979,7 @@ async function collectTsFiles(projectPath, includePatterns, excludePatterns) {
 async function transpileWithEsbuild(projectPath) {
   const esbuild = await import("esbuild");
   const { promises: fs11 } = await import("fs");
-  const tsconfigPath = path8.join(projectPath, "tsconfig.json");
+  const tsconfigPath = path11.join(projectPath, "tsconfig.json");
   let tsconfig = {};
   try {
     const raw = await fs11.readFile(tsconfigPath, "utf-8");
@@ -7256,10 +8009,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 ? path8.resolve(projectPath, compilerOptions.rootDir) : projectPath;
+  const outbase = compilerOptions.rootDir ? path11.resolve(projectPath, compilerOptions.rootDir) : projectPath;
   await esbuild.build({
-    entryPoints: files.map((f) => path8.join(projectPath, f)),
-    outdir: path8.join(projectPath, outDir),
+    entryPoints: files.map((f) => path11.join(projectPath, f)),
+    outdir: path11.join(projectPath, outDir),
     outbase,
     bundle: true,
     packages: "external",
@@ -7286,7 +8039,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 = path8.resolve(options.path);
+    const projectPath = path11.resolve(options.path);
     const { promises: fs11 } = await import("fs");
     displayPackageVersions(projectPath);
     const mcpDir = options.mcpDir;
@@ -7346,7 +8099,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 = path8.join(
+      const tscBin = path11.join(
         projectPath,
         "node_modules",
         "typescript",
@@ -7369,7 +8122,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
       if (mcpDir) {
         entryPoint = sourceServerFile;
       } else {
-        const baseName = path8.basename(sourceServerFile, ".ts") + ".js";
+        const baseName = path11.basename(sourceServerFile, ".ts") + ".js";
         const possibleOutputs = [
           `dist/${baseName}`,
           // rootDir set to project root or src
@@ -7380,7 +8133,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
         ];
         for (const candidate of possibleOutputs) {
           try {
-            await access(path8.join(projectPath, candidate));
+            await access(path11.join(projectPath, candidate));
             entryPoint = candidate;
             break;
           } catch {
@@ -7389,17 +8142,17 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
         }
       }
     }
-    const publicDir = path8.join(projectPath, "public");
+    const publicDir = path11.join(projectPath, "public");
     try {
       await fs11.access(publicDir);
       console.log(source_default.gray("Copying public assets..."));
-      await fs11.cp(publicDir, path8.join(projectPath, "dist", "public"), {
+      await fs11.cp(publicDir, path11.join(projectPath, "dist", "public"), {
         recursive: true
       });
       console.log(source_default.green("\u2713 Public assets copied"));
     } catch {
     }
-    const manifestPath = path8.join(projectPath, "dist", "mcp-use.json");
+    const manifestPath = path11.join(projectPath, "dist", "mcp-use.json");
     let existingManifest = {};
     try {
       const existingContent = await fs11.readFile(manifestPath, "utf-8");
@@ -7424,7 +8177,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
       // Server entry point for `mcp-use start`
       widgets: widgetsData
     };
-    await fs11.mkdir(path8.dirname(manifestPath), { recursive: true });
+    await fs11.mkdir(path11.dirname(manifestPath), { recursive: true });
     await fs11.writeFile(
       manifestPath,
       JSON.stringify(manifest, null, 2),
@@ -7461,7 +8214,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 = path8.resolve(options.path);
+    const projectPath = path11.resolve(options.path);
     let port = parseInt(options.port, 10);
     const host = options.host;
     const useHmr = options.hmr !== false;
@@ -7489,7 +8242,7 @@ program.command("dev").description("Run development server with auto-reload and
     let tunnelUrl = void 0;
     if (options.tunnel) {
       try {
-        const manifestPath = path8.join(projectPath, "dist", "mcp-use.json");
+        const manifestPath = path11.join(projectPath, "dist", "mcp-use.json");
         let existingSubdomain;
         try {
           const manifestContent = await readFile3(manifestPath, "utf-8");
@@ -7538,7 +8291,7 @@ program.command("dev").description("Run development server with auto-reload and
             manifest.tunnel = {};
           }
           manifest.tunnel.subdomain = tunnelSubdomain;
-          await mkdir3(path8.dirname(manifestPath), { recursive: true });
+          await mkdir4(path11.dirname(manifestPath), { recursive: true });
           await writeFile3(
             manifestPath,
             JSON.stringify(manifest, null, 2),
@@ -7593,7 +8346,7 @@ program.command("dev").description("Run development server with auto-reload and
       let args;
       try {
         const projectRequire = createRequire4(
-          path8.join(projectPath, "package.json")
+          path11.join(projectPath, "package.json")
         );
         const tsxPkgPath = projectRequire.resolve("tsx/package.json");
         const tsxPkg = JSON.parse(await readFile3(tsxPkgPath, "utf-8"));
@@ -7605,7 +8358,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 = path8.resolve(path8.dirname(tsxPkgPath), binPath);
+        const tsxBin = path11.resolve(path11.dirname(tsxPkgPath), binPath);
         cmd = "node";
         args = [tsxBin, "watch", serverFile];
       } catch (error) {
@@ -7694,7 +8447,7 @@ program.command("dev").description("Run development server with auto-reload and
     const chokidar = chokidarModule.default || chokidarModule;
     const { fileURLToPath: fileURLToPath4 } = await import("url");
     const { createRequire: createRequire3 } = await import("module");
-    const projectTsconfigPath = path8.join(projectPath, "tsconfig.json");
+    const projectTsconfigPath = path11.join(projectPath, "tsconfig.json");
     let tsconfigAvailable = false;
     try {
       await access(projectTsconfigPath);
@@ -7706,7 +8459,7 @@ program.command("dev").description("Run development server with auto-reload and
     let tsxLoaderActive = false;
     try {
       const projectRequire = createRequire3(
-        path8.join(projectPath, "package.json")
+        path11.join(projectPath, "package.json")
       );
       const tsxEsmApiPath = projectRequire.resolve("tsx/esm/api");
       const tsxEsmApi = await import(pathToFileURL2(tsxEsmApiPath).href);
@@ -7737,7 +8490,7 @@ program.command("dev").description("Run development server with auto-reload and
         )
       );
     }
-    const serverFilePath = path8.join(projectPath, serverFile);
+    const serverFilePath = path11.join(projectPath, serverFile);
     const serverFileUrl = pathToFileURL2(serverFilePath).href;
     globalThis.__mcpUseHmrMode = true;
     const importServerModule = async () => {
@@ -7834,8 +8587,8 @@ program.command("dev").description("Run development server with auto-reload and
     }
     let watcher = chokidar.watch(".", {
       cwd: projectPath,
-      ignored: (path9, stats) => {
-        const normalizedPath = path9.replace(/\\/g, "/");
+      ignored: (path12, stats) => {
+        const normalizedPath = path12.replace(/\\/g, "/");
         if (/(^|\/)\.[^/]/.test(normalizedPath)) {
           return true;
         }
@@ -8009,7 +8762,7 @@ program.command("dev").description("Run development server with auto-reload and
       }
       tunnelUrl = void 0;
       if (withTunnel) {
-        const manifestPath = path8.join(projectPath, "dist", "mcp-use.json");
+        const manifestPath = path11.join(projectPath, "dist", "mcp-use.json");
         let existingSubdomain;
         try {
           const manifestContent = await readFile3(manifestPath, "utf-8");
@@ -8046,7 +8799,7 @@ program.command("dev").description("Run development server with auto-reload and
         tunnelSubdomain = tunnelInfo.subdomain;
         process.env.MCP_URL = tunnelUrl;
         try {
-          const mPath = path8.join(projectPath, "dist", "mcp-use.json");
+          const mPath = path11.join(projectPath, "dist", "mcp-use.json");
           let manifest = {};
           try {
             manifest = JSON.parse(await readFile3(mPath, "utf-8"));
@@ -8054,7 +8807,7 @@ program.command("dev").description("Run development server with auto-reload and
           }
           if (!manifest.tunnel) manifest.tunnel = {};
           manifest.tunnel.subdomain = tunnelSubdomain;
-          await mkdir3(path8.dirname(mPath), { recursive: true });
+          await mkdir4(path11.dirname(mPath), { recursive: true });
           await writeFile3(mPath, JSON.stringify(manifest, null, 2), "utf-8");
         } catch {
         }
@@ -8158,7 +8911,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 = path8.resolve(options.path);
+    const projectPath = path11.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)) {
@@ -8176,7 +8929,7 @@ program.command("start").description("Start production server").option("-p, --pa
     let tunnelSubdomain = void 0;
     if (options.tunnel) {
       try {
-        const manifestPath2 = path8.join(projectPath, "dist", "mcp-use.json");
+        const manifestPath2 = path11.join(projectPath, "dist", "mcp-use.json");
         let existingSubdomain;
         try {
           const manifestContent = await readFile3(manifestPath2, "utf-8");
@@ -8231,7 +8984,7 @@ program.command("start").description("Start production server").option("-p, --pa
             manifest.tunnel = {};
           }
           manifest.tunnel.subdomain = subdomain;
-          await mkdir3(path8.dirname(manifestPath2), { recursive: true });
+          await mkdir4(path11.dirname(manifestPath2), { recursive: true });
           await writeFile3(
             manifestPath2,
             JSON.stringify(manifest, null, 2),
@@ -8250,12 +9003,12 @@ program.command("start").description("Start production server").option("-p, --pa
       }
     }
     let serverFile;
-    const manifestPath = path8.join(projectPath, "dist", "mcp-use.json");
+    const manifestPath = path11.join(projectPath, "dist", "mcp-use.json");
     try {
       const manifestContent = await readFile3(manifestPath, "utf-8");
       const manifest = JSON.parse(manifestContent);
       if (manifest.entryPoint) {
-        await access(path8.join(projectPath, manifest.entryPoint));
+        await access(path11.join(projectPath, manifest.entryPoint));
         serverFile = manifest.entryPoint;
       }
     } catch {
@@ -8276,7 +9029,7 @@ program.command("start").description("Start production server").option("-p, --pa
       ];
       for (const candidate of serverCandidates) {
         try {
-          await access(path8.join(projectPath, candidate));
+          await access(path11.join(projectPath, candidate));
           serverFile = candidate;
           break;
         } catch {
@@ -8327,13 +9080,13 @@ Looked for:
     if (isTsEntry) {
       try {
         const projectRequire = createRequire2(
-          path8.join(projectPath, "package.json")
+          path11.join(projectPath, "package.json")
         );
         const tsxPkgPath = projectRequire.resolve("tsx/package.json");
         const tsxPkg = JSON.parse(await readFile3(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 = path8.resolve(path8.dirname(tsxPkgPath), binField);
+        const tsxBin = path11.resolve(path11.dirname(tsxPkgPath), binField);
         spawnCmd = "node";
         spawnArgs = [tsxBin, serverFile];
       } catch (error) {
@@ -8346,7 +9099,7 @@ Looked for:
         spawnArgs = ["tsx", serverFile];
       }
     }
-    const serverProc = spawn(spawnCmd, spawnArgs, {
+    const serverProc = spawn3(spawnCmd, spawnArgs, {
       cwd: projectPath,
       stdio: "inherit",
       env: env2
@@ -8479,10 +9232,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 = path8.resolve(options.path);
+  const projectPath = path11.resolve(options.path);
   try {
     console.log(source_default.blue("Generating tool registry types..."));
     const result = await generateToolRegistryTypesForServer(