@mcp-use/cli 3.1.5-canary.3 → 3.2.0-canary.10

package/dist/index.cjs

@@ -23,7 +23,7 @@ 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 = () => 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;
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
@@ -217,10 +217,10 @@ var ansi_styles_default = ansiStyles;
 var import_node_process = __toESM(require("process"), 1);
 var import_node_os = __toESM(require("os"), 1);
 var import_node_tty = __toESM(require("tty"), 1);
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
+function hasFlag(flag, argv2 = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
   const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-  const position = argv.indexOf(prefix + flag);
-  const terminatorPosition = argv.indexOf("--");
+  const position = argv2.indexOf(prefix + flag);
+  const terminatorPosition = argv2.indexOf("--");
   return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
 }
 var { env } = import_node_process.default;
@@ -523,13 +523,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");
 
 // ../../node_modules/.pnpm/open@11.0.0/node_modules/open/index.js
@@ -716,15 +716,15 @@ var wslDefaultBrowser = async () => {
   const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
   return stdout.trim();
 };
-var convertWslPathToWindows = async (path8) => {
-  if (/^[a-z]+:\/\//i.test(path8)) {
-    return path8;
+var 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;
   }
 };
 
@@ -1340,8 +1340,8 @@ var McpUseAPI = class _McpUseAPI {
   // ── Organization ID resolution ──────────────────────────────────
   async resolveOrganizationId() {
     if (this.orgId) return this.orgId;
-    const auth = await this.testAuth();
-    const id = auth.default_org_id;
+    const auth2 = await this.testAuth();
+    const id = auth2.default_org_id;
     if (!id) {
       throw new Error(
         "No organization set. Run `mcp-use org switch` or use --org to specify one."
@@ -1374,8 +1374,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(
@@ -1875,52 +1875,110 @@ async function whoamiCommand() {
 }
 
 // src/commands/client.ts
-var import_commander = require("commander");
-var import_client = require("mcp-use/client");
-var import_server = require("mcp-use/server");
-var import_node_readline = require("readline");
+var import_commander2 = require("commander");
+var import_client3 = require("mcp-use/client");
+var import_node_readline2 = require("readline");
 
 // src/utils/format.ts
-function formatTable(data, columns) {
+var ANSI_RE = /\x1b\[[0-9;]*m/g;
+var GUTTER = "  ";
+var MIN_TRUNCATABLE_WIDTH = 8;
+var DEFAULT_MAX_WIDTH = 100;
+function stripAnsi(s) {
+  return s.replace(ANSI_RE, "");
+}
+function visibleWidth(s) {
+  return stripAnsi(s).length;
+}
+function padCell(s, width) {
+  const w = visibleWidth(s);
+  if (w >= width) return s;
+  return s + " ".repeat(width - w);
+}
+function truncateCell(s, width) {
+  if (width <= 0) return "";
+  const plain = stripAnsi(s);
+  if (plain.length <= width) return s;
+  if (width === 1) return "\u2026";
+  return plain.slice(0, width - 1) + "\u2026";
+}
+function formatTable(data, columns, options = {}) {
+  const tsv = options.tsv ?? !process.stdout.isTTY;
+  if (tsv) {
+    return data.map(
+      (row) => columns.map(
+        (c) => stripAnsi(String(row[c.key] ?? "")).replace(/[\t\r\n]+/g, " ")
+      ).join("	")
+    ).join("\n");
+  }
   if (data.length === 0) {
     return source_default.gray("No items found");
   }
-  const widths = columns.map((col) => {
-    const maxDataWidth = Math.max(
-      ...data.map((row) => String(row[col.key] || "").length)
-    );
-    const headerWidth = col.header.length;
-    return col.width || Math.max(maxDataWidth, headerWidth, 10);
+  const maxWidth = options.maxWidth ?? process.stdout.columns ?? DEFAULT_MAX_WIDTH;
+  const natural = columns.map((col) => {
+    const headerW = col.header.length;
+    const dataW = data.reduce((m, row) => {
+      return Math.max(m, visibleWidth(String(row[col.key] ?? "")));
+    }, 0);
+    return Math.max(headerW, dataW);
   });
-  const createRow = (values, bold = false) => {
-    const cells = values.map((val, i) => {
-      const padded = val.padEnd(widths[i]);
-      return bold ? source_default.bold(padded) : padded;
-    });
-    return `\u2502 ${cells.join(" \u2502 ")} \u2502`;
-  };
-  const separator = (char) => {
-    const parts = widths.map((w) => char.repeat(w + 2));
-    if (char === "\u2500") {
-      return `\u251C${parts.join("\u253C")}\u2524`;
+  const widths = columns.map((c, i) => c.width ?? natural[i]);
+  const overhead = GUTTER.length * (columns.length - 1);
+  const totalWidth = () => widths.reduce((s, w) => s + w, 0) + overhead;
+  if (totalWidth() > maxWidth) {
+    const truncIdxs = columns.map((c, i) => c.truncate ? i : -1).filter((i) => i >= 0);
+    if (truncIdxs.length > 0) {
+      const fixedSum = columns.reduce(
+        (s, c, i) => s + (c.truncate ? 0 : widths[i]),
+        0
+      );
+      const remaining = Math.max(
+        truncIdxs.length * MIN_TRUNCATABLE_WIDTH,
+        maxWidth - fixedSum - overhead
+      );
+      const truncSum = truncIdxs.reduce((s, i) => s + widths[i], 0) || 1;
+      let used = 0;
+      truncIdxs.forEach((i, idx) => {
+        if (idx === truncIdxs.length - 1) {
+          widths[i] = Math.max(MIN_TRUNCATABLE_WIDTH, remaining - used);
+        } else {
+          const share = Math.max(
+            MIN_TRUNCATABLE_WIDTH,
+            Math.floor(widths[i] / truncSum * remaining)
+          );
+          widths[i] = share;
+          used += share;
+        }
+      });
     }
-    return `\u2514${parts.join("\u2534")}\u2518`;
-  };
+  }
   const lines = [];
-  lines.push(`\u250C${widths.map((w) => "\u2500".repeat(w + 2)).join("\u252C")}\u2510`);
-  lines.push(
-    createRow(
-      columns.map((c) => c.header),
-      true
-    )
-  );
-  lines.push(separator("\u2500"));
-  data.forEach((row) => {
-    lines.push(createRow(columns.map((c) => String(row[c.key] || ""))));
+  const headerCells = columns.map((c, i) => {
+    const text = c.header.toUpperCase();
+    const cell = i === columns.length - 1 ? text : padCell(text, widths[i]);
+    return source_default.bold(cell);
   });
-  lines.push(separator("\u2500"));
+  lines.push(headerCells.join(GUTTER).trimEnd());
+  for (const row of data) {
+    const cells = columns.map((c, i) => {
+      let v = String(row[c.key] ?? "");
+      if (visibleWidth(v) > widths[i]) {
+        v = truncateCell(v, widths[i]);
+      }
+      return i === columns.length - 1 ? v : padCell(v, widths[i]);
+    });
+    lines.push(cells.join(GUTTER).trimEnd());
+  }
   return lines.join("\n");
 }
+function isStdoutTty() {
+  return Boolean(process.stdout.isTTY);
+}
+function formatToolMode(annotations) {
+  if (annotations?.readOnlyHint === true) return source_default.green("read-only");
+  if (annotations?.destructiveHint === true) return source_default.red("destructive");
+  return source_default.yellow("write");
+}
 function formatJson(data, pretty = true) {
   if (pretty) {
     return JSON.stringify(data, null, 2);
@@ -1929,20 +1987,29 @@ function formatJson(data, pretty = true) {
 }
 function formatToolCall(result) {
   const lines = [];
-  if (result.isError) {
+  const { isError, structuredContent } = result;
+  const hasStructured = structuredContent !== void 0 && structuredContent !== null;
+  const visibleContent = (result.content ?? []).filter(
+    (item) => !hasStructured || item.type !== "text"
+  );
+  const hasVisibleContent = visibleContent.length > 0;
+  if (isError) {
     lines.push(source_default.red("\u2717 Tool execution failed"));
     lines.push("");
   } else {
     lines.push(source_default.green("\u2713 Tool executed successfully"));
     lines.push("");
   }
-  if (result.content && result.content.length > 0) {
-    result.content.forEach((item, index) => {
-      if (result.content.length > 1) {
+  if (hasVisibleContent) {
+    if (isError) {
+      lines.push(source_default.red.bold("Error details:"));
+    }
+    visibleContent.forEach((item, index) => {
+      if (visibleContent.length > 1) {
         lines.push(source_default.bold(`Content ${index + 1}:`));
       }
       if (item.type === "text") {
-        lines.push(item.text);
+        lines.push(isError ? source_default.red(item.text) : item.text);
       } else if (item.type === "image") {
         lines.push(source_default.cyan(`[Image: ${item.mimeType || "unknown type"}]`));
         if (item.data) {
@@ -1959,11 +2026,20 @@ function formatToolCall(result) {
       } else {
         lines.push(source_default.gray(`[Unknown content type: ${item.type}]`));
       }
-      if (index < result.content.length - 1) {
+      if (index < visibleContent.length - 1) {
         lines.push("");
       }
     });
   }
+  if (hasStructured) {
+    if (isError) {
+      lines.push(source_default.bold("Structured error data:"));
+    }
+    lines.push(formatJson(structuredContent));
+  }
+  if (isError && !hasVisibleContent && !hasStructured) {
+    lines.push(source_default.gray("(no error details provided by server)"));
+  }
   return lines.join("\n");
 }
 function formatResourceContent(content) {
@@ -2116,28 +2192,218 @@ function formatPromptMessages(messages) {
   return lines.join("\n");
 }
 
+// src/utils/parse-args.ts
+function parseToolArgs(rawArgs, inputSchema) {
+  if (!rawArgs || rawArgs.length === 0) return {};
+  if (rawArgs.length === 1) {
+    const trimmed = rawArgs[0].trim();
+    if (trimmed.startsWith("{")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+          throw new Error("expected a JSON object");
+        }
+        return parsed;
+      } catch (err) {
+        throw new Error(`Invalid JSON arguments: ${err.message}`);
+      }
+    }
+  }
+  const props = inputSchema?.properties ?? {};
+  const result = {};
+  for (const raw of rawArgs) {
+    const token = raw.startsWith("--") ? raw.slice(2) : raw;
+    const jsonIdx = token.indexOf(":=");
+    const eqIdx = token.indexOf("=");
+    let key;
+    let rawValue;
+    let forceJson = false;
+    if (jsonIdx !== -1 && (eqIdx === -1 || jsonIdx < eqIdx)) {
+      key = token.slice(0, jsonIdx);
+      rawValue = token.slice(jsonIdx + 2);
+      forceJson = true;
+    } else if (eqIdx !== -1) {
+      key = token.slice(0, eqIdx);
+      rawValue = token.slice(eqIdx + 1);
+    } else {
+      throw new Error(
+        `Invalid argument '${raw}'. Use key=value or key:=jsonvalue.`
+      );
+    }
+    if (!key) {
+      throw new Error(`Empty key in argument '${raw}'`);
+    }
+    result[key] = coerceArgValue(rawValue, props[key], forceJson, key);
+  }
+  return result;
+}
+function coerceArgValue(value, propSchema, forceJson, key) {
+  if (forceJson) {
+    try {
+      return JSON.parse(value);
+    } catch (err) {
+      throw new Error(
+        `Invalid JSON value for '${key}': ${err.message}`
+      );
+    }
+  }
+  const types = Array.isArray(propSchema?.type) ? propSchema.type : propSchema?.type ? [propSchema.type] : [];
+  if (types.includes("null") && (value === "null" || value === "")) {
+    return null;
+  }
+  if (types.includes("integer")) {
+    const n = Number(value);
+    if (!Number.isFinite(n) || !Number.isInteger(n)) {
+      throw new Error(`Expected integer for '${key}', got '${value}'`);
+    }
+    return n;
+  }
+  if (types.includes("number")) {
+    const n = Number(value);
+    if (!Number.isFinite(n)) {
+      throw new Error(`Expected number for '${key}', got '${value}'`);
+    }
+    return n;
+  }
+  if (types.includes("boolean")) {
+    if (value === "true" || value === "1") return true;
+    if (value === "false" || value === "0") return false;
+    throw new Error(
+      `Expected boolean (true/false) for '${key}', got '${value}'`
+    );
+  }
+  if (types.includes("array") || types.includes("object")) {
+    try {
+      return JSON.parse(value);
+    } catch (err) {
+      const wanted = types.includes("array") ? "array" : "object";
+      throw new Error(
+        `Expected JSON ${wanted} for '${key}'. Tip: use ${key}:=<json>. ${err.message}`
+      );
+    }
+  }
+  return value;
+}
+function parsePromptArgs(rawArgs) {
+  if (!rawArgs || rawArgs.length === 0) return {};
+  if (rawArgs.length === 1) {
+    const trimmed = rawArgs[0].trim();
+    if (trimmed.startsWith("{")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+          throw new Error("expected a JSON object");
+        }
+        const out = {};
+        for (const [k, v] of Object.entries(parsed)) {
+          out[k] = typeof v === "string" ? v : JSON.stringify(v);
+        }
+        return out;
+      } catch (err) {
+        throw new Error(`Invalid JSON arguments: ${err.message}`);
+      }
+    }
+  }
+  const result = {};
+  for (const raw of rawArgs) {
+    const token = raw.startsWith("--") ? raw.slice(2) : raw;
+    const eqIdx = token.indexOf("=");
+    if (eqIdx === -1) {
+      throw new Error(`Invalid argument '${raw}'. Use key=value.`);
+    }
+    const key = token.slice(0, eqIdx);
+    const value = token.slice(eqIdx + 1);
+    if (!key) {
+      throw new Error(`Empty key in argument '${raw}'`);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+
+// src/utils/oauth.ts
+var import_node = require("mcp-use/auth/node");
+var import_node_readline = require("readline");
+async function buildOAuthProvider(serverUrl, options = {}) {
+  return import_node.NodeOAuthClientProvider.create(serverUrl, {
+    clientName: "mcp-use CLI",
+    clientUri: "https://mcp-use.com",
+    storageKeyPrefix: "mcp:auth",
+    ...options,
+    openBrowser: async (url) => {
+      console.error(`
+  Open this URL in a browser to authenticate:`);
+      console.error(`  ${url}
+`);
+    }
+  });
+}
+async function runOAuthFlow(provider, serverUrl, print = console.error.bind(console)) {
+  print(`\u2192 OAuth authentication required.`);
+  print(
+    `  Listening on http://127.0.0.1:${provider.callbackPort}/callback (waiting up to 5m)`
+  );
+  if (!provider.hasPendingFlow) {
+    const result = await (0, import_node.auth)(provider, { serverUrl });
+    if (result === "AUTHORIZED") {
+      return;
+    }
+    if (result !== "REDIRECT") {
+      throw new import_node.OAuthFlowError(
+        "unexpected_auth_result",
+        `auth() returned ${result}`
+      );
+    }
+  }
+  const code = await provider.getAuthorizationCode();
+  await (0, import_node.auth)(provider, { serverUrl, authorizationCode: code });
+}
+function isUnauthorized(err) {
+  if (err instanceof import_node.UnauthorizedError) return true;
+  if (err instanceof Error && err.name === "UnauthorizedError") return true;
+  if (err instanceof Error && err.code === 401) {
+    return true;
+  }
+  return false;
+}
+async function promptYesNo(question, defaultYes = true) {
+  if (!process.stdin.isTTY) return false;
+  const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = await new Promise((resolve2) => {
+      rl.question(`${question} ${defaultYes ? "[Y/n] " : "[y/N] "}`, resolve2);
+    });
+    const trimmed = answer.trim().toLowerCase();
+    if (!trimmed) return defaultYes;
+    return trimmed === "y" || trimmed === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
 // src/utils/session-storage.ts
 var import_node_os4 = require("os");
 var import_node_path3 = require("path");
 var import_promises4 = require("fs/promises");
 var import_node_fs5 = require("fs");
 var SESSION_FILE_PATH = (0, import_node_path3.join)((0, import_node_os4.homedir)(), ".mcp-use", "cli-sessions.json");
+var _dirEnsured = false;
 async function ensureSessionDir() {
-  const dir = (0, import_node_path3.join)((0, import_node_os4.homedir)(), ".mcp-use");
-  if (!(0, import_node_fs5.existsSync)(dir)) {
-    await (0, import_promises4.mkdir)(dir, { recursive: true });
-  }
+  if (_dirEnsured) return;
+  await (0, import_promises4.mkdir)((0, import_node_path3.join)((0, import_node_os4.homedir)(), ".mcp-use"), { recursive: true });
+  _dirEnsured = true;
 }
 async function loadSessions() {
   try {
     await ensureSessionDir();
     if (!(0, import_node_fs5.existsSync)(SESSION_FILE_PATH)) {
-      return { activeSession: null, sessions: {} };
+      return { sessions: {} };
     }
     const content = await (0, import_promises4.readFile)(SESSION_FILE_PATH, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    return { activeSession: null, sessions: {} };
+    const parsed = JSON.parse(content);
+    return { sessions: parsed?.sessions ?? {} };
+  } catch {
+    return { sessions: {} };
   }
 }
 async function saveSessions(storage) {
@@ -2150,40 +2416,22 @@ async function saveSession(name, config) {
     ...config,
     lastUsed: (/* @__PURE__ */ new Date()).toISOString()
   };
-  if (!storage.activeSession) {
-    storage.activeSession = name;
-  }
   await saveSessions(storage);
 }
-async function getActiveSession() {
+async function removeSession(name) {
   const storage = await loadSessions();
-  if (!storage.activeSession || !storage.sessions[storage.activeSession]) {
-    return null;
-  }
-  return {
-    name: storage.activeSession,
-    config: storage.sessions[storage.activeSession]
-  };
+  delete storage.sessions[name];
+  await saveSessions(storage);
 }
 async function getSession(name) {
   const storage = await loadSessions();
   return storage.sessions[name] || null;
 }
-async function setActiveSession(name) {
-  const storage = await loadSessions();
-  if (!storage.sessions[name]) {
-    throw new Error(`Session '${name}' not found`);
-  }
-  storage.activeSession = name;
-  storage.sessions[name].lastUsed = (/* @__PURE__ */ new Date()).toISOString();
-  await saveSessions(storage);
-}
 async function listAllSessions() {
   const storage = await loadSessions();
   return Object.entries(storage.sessions).map(([name, config]) => ({
     name,
-    config,
-    isActive: name === storage.activeSession
+    config
   }));
 }
 async function updateSessionInfo(name, serverInfo, capabilities) {
@@ -2196,40 +2444,68 @@ async function updateSessionInfo(name, serverInfo, capabilities) {
   }
 }
 
-// src/commands/client.ts
+// src/utils/session.ts
+var import_client = require("mcp-use/client");
+var import_server = require("mcp-use/server");
 var activeSessions = /* @__PURE__ */ new Map();
-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;
+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 {
     }
-    sessionName = active.name;
+    activeSessions.delete(name);
   }
+  process.exit(code);
+}
+async function getOrRestoreSession(sessionName) {
   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`));
+    console.error(formatError(`Server '${sessionName}' not found`));
+    console.error(
+      formatInfo(
+        `Connect with: npx mcp-use client connect ${sessionName} <url>`
+      )
+    );
     return null;
   }
   try {
     const client = new import_client.MCPClient();
     const cliClientInfo = getCliClientInfo();
+    let authProvider;
     if (config.type === "http") {
-      client.addServer(sessionName, {
-        url: config.url,
-        headers: config.authToken ? { Authorization: `Bearer ${config.authToken}` } : void 0,
-        clientInfo: cliClientInfo
-      });
+      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,
@@ -2241,37 +2517,1028 @@ async function getOrRestoreSession(sessionName) {
       console.error(formatError(`Unknown session type: ${config.type}`));
       return null;
     }
-    const session = await client.createSession(sessionName);
+    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 server '${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 ${sessionName} ${config.url}`
+            )
+          );
+          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}`));
+    console.error(formatError(`Failed to restore server: ${error.message}`));
+    return null;
+  }
+}
+
+// src/commands/client-auth.ts
+async function resolveSession(name) {
+  const config = await getSession(name);
+  if (!config) {
+    console.error(formatError(`Server '${name}' not found`));
+    return null;
+  }
+  if (config.type !== "http") {
+    console.error(formatError("Auth commands only apply to HTTP servers"));
+    return null;
+  }
+  if (config.authMode !== "oauth") {
+    console.error(
+      formatError(
+        `Server '${name}' was not authenticated via OAuth (authMode=${config.authMode ?? "bearer"})`
+      )
+    );
+    return null;
+  }
+  return { name, url: config.url };
+}
+function formatExpiresIn(expSec) {
+  const ms = expSec * 1e3 - Date.now();
+  if (ms <= 0) return "expired";
+  const mins = Math.round(ms / 6e4);
+  if (mins < 60) return `${mins}m`;
+  const hours = Math.floor(mins / 60);
+  const rem = mins % 60;
+  return rem ? `${hours}h${rem}m` : `${hours}h`;
+}
+function decodeJwtExp(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length < 2) return null;
+    const payload = JSON.parse(
+      Buffer.from(parts[1], "base64url").toString("utf-8")
+    );
+    return typeof payload.exp === "number" ? payload.exp : null;
+  } catch {
+    return null;
+  }
+}
+async function authStatusCommand(name) {
+  const target = await resolveSession(name);
+  if (!target) {
+    process.exit(1);
+  }
+  const { name: serverName, url } = target;
+  const provider = await buildOAuthProvider(url);
+  const tokens = await provider.tokens();
+  const fields = {
+    server: serverName,
+    url,
+    tokens: tokens?.access_token ? "present" : "missing"
+  };
+  if (tokens?.scope) fields.scope = tokens.scope;
+  if (tokens?.access_token) {
+    const exp = decodeJwtExp(tokens.access_token);
+    fields.expires_in = exp ? formatExpiresIn(exp) : "unknown (opaque token)";
+  }
+  fields.refresh = tokens?.refresh_token ? "available" : "missing";
+  console.log(formatKeyValue(fields));
+  if (!tokens?.access_token) process.exit(1);
+}
+async function authRefreshCommand(name) {
+  const target = await resolveSession(name);
+  if (!target) {
+    process.exit(1);
+  }
+  const { name: serverName, url } = target;
+  const provider = await buildOAuthProvider(url);
+  const refreshed = await provider.forceRefresh();
+  if (!refreshed) {
+    console.error(
+      formatError(
+        "Refresh failed (no refresh_token, or server rejected). Re-connect to re-authenticate."
+      )
+    );
+    console.error(
+      formatInfo(`Run: mcp-use client connect ${serverName} ${url}`)
+    );
+    process.exit(1);
+  }
+  const exp = refreshed.access_token ? decodeJwtExp(refreshed.access_token) : null;
+  console.log(
+    formatSuccess(
+      `Refreshed access token${exp ? ` (expires in ${formatExpiresIn(exp)})` : ""}`
+    )
+  );
+}
+async function authLogoutCommand(name) {
+  const target = await resolveSession(name);
+  if (!target) {
+    process.exit(1);
+  }
+  const { name: serverName, url } = target;
+  const provider = await buildOAuthProvider(url);
+  await provider.invalidateCredentials("all");
+  console.log(formatSuccess(`Removed tokens for ${url}`));
+  console.log(
+    formatInfo(
+      `Server '${serverName}' kept; reconnect with \`mcp-use client connect\`.`
+    )
+  );
+}
+
+// src/commands/screenshot.ts
+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
+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 {
+      this.ws.close();
+    } catch {
+    }
+  }
+};
+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 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" }
+      );
+      const attach = await cdp.send(
+        "Target.attachToTarget",
+        { targetId, flatten: true }
+      );
+      sessionId = attach.sessionId;
+    }
+    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();
+  }
+}
+
+// src/utils/chrome-path.ts
+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;
+  }
+}
+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;
   }
-}
-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 connectCommand(urlOrCommand, options) {
+  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 parseHeaderArg(raw) {
+  const idx = raw.indexOf(":");
+  if (idx === -1) {
+    throw new Error(
+      `Invalid --header value "${raw}". Expected "Key: Value" (e.g. "Authorization: Bearer xyz").`
+    );
+  }
+  const key = raw.slice(0, idx).trim();
+  const value = raw.slice(idx + 1).trim();
+  if (!key) {
+    throw new Error(`Invalid --header value "${raw}". Header name is empty.`);
+  }
+  return [key, value];
+}
+function parseHeaderArgs(args) {
+  const headers = {};
+  for (const raw of args) {
+    const [key, value] = parseHeaderArg(raw);
+    headers[key] = value;
+  }
+  return headers;
+}
+function collectHeader(value, previous = []) {
+  return previous.concat([value]);
+}
+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 {
+    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 {
+        srv.close(() => reject(new Error("Failed to allocate free port")));
+      }
+    });
+  });
+}
+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, headers) {
+  if (options.session) {
+    const result = await getOrRestoreSession(options.session);
+    return result?.session ?? null;
+  }
+  if (options.mcp) {
+    const client = new import_client2.MCPClient();
+    client.addServer(AD_HOC_SESSION_NAME, {
+      url: options.mcp,
+      ...headers ? { headers } : {},
+      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;
+    }
+  }
+  console.error(
+    formatError(
+      "No MCP target. Pass --session <name> (a saved server) or --mcp <url> (ad-hoc)."
+    )
+  );
+  return 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;
+    }
+    let headers;
+    if (options.header && options.header.length > 0) {
+      if (!options.mcp) {
+        console.error(
+          formatError(
+            "--header is only supported with --mcp <url>. Saved sessions (use --session) carry their own auth from `mcp-use client connect`."
+          )
+        );
+        exitCode = 1;
+        return;
+      }
+      try {
+        headers = parseHeaderArgs(options.header);
+      } catch (err) {
+        console.error(
+          formatError(err instanceof Error ? err.message : String(err))
+        );
+        exitCode = 1;
+        return;
+      }
+    }
+    try {
+      resolveChromePath();
+    } catch (err) {
+      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, headers);
+    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
+        );
+      } 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));
+        }
+        exitCode = 1;
+        return;
+      }
+    }
+    const toolOutput = await session.callTool(options.tool, toolArgs);
+    const result = await captureToolScreenshot(
+      {
+        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
+      }
+    );
+    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 server name (from `mcp-use client connect <name> <url>`)."
+  ).option(
+    "--mcp <url>",
+    "Ad-hoc MCP server URL (escape hatch). Use when you don't have a saved server. No authentication unless --header is supplied."
+  ).option(
+    "-H, --header <header>",
+    'HTTP header to send to the --mcp <url> server, formatted "Key: Value". Repeatable. Use to pass an Authorization bearer token or other auth headers when screenshotting an authenticated MCP server.',
+    collectHeader,
+    []
+  ).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
+var RESERVED_CLIENT_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "connect",
+  "list",
+  "remove",
+  "help"
+]);
+var PER_CLIENT_SCOPES = /* @__PURE__ */ new Set([
+  "tools",
+  "resources",
+  "prompts",
+  "auth",
+  "disconnect",
+  "interactive"
+]);
+async function connectCommand(name, urlOrCommand, options) {
+  if (!name || !urlOrCommand) {
+    const looksLikeUrl = !!name && /^https?:\/\//i.test(name);
+    if (looksLikeUrl && !urlOrCommand && !options.stdio) {
+      console.error(formatError("Missing server name."));
+      console.error("");
+      console.error(
+        formatInfo(
+          "Each saved server needs a short name you'll use to address it later."
+        )
+      );
+      console.error("");
+      console.error("Try:");
+      console.error(`  mcp-use client connect <name> ${name}`);
+      console.error("");
+      console.error("Example:");
+      console.error(`  mcp-use client connect my-server ${name}`);
+      console.error("  mcp-use client my-server tools list");
+    } else if (name && !urlOrCommand) {
+      console.error(
+        formatError(options.stdio ? "Missing <command>." : "Missing <url>.")
+      );
+      console.error("");
+      console.error(formatInfo("Usage:"));
+      console.error(
+        options.stdio ? `  mcp-use client connect ${name} "<command>" --stdio` : `  mcp-use client connect ${name} <url>`
+      );
+    } else {
+      console.error(formatError("Missing required arguments: <name> <url>."));
+      console.error("");
+      console.error(formatInfo("Usage:"));
+      console.error("  mcp-use client connect <name> <url>");
+      console.error("");
+      console.error("Example:");
+      console.error(
+        "  mcp-use client connect manufact https://mcp.manufact.com/mcp"
+      );
+    }
+    await cleanupAndExit(1);
+  }
+  const sessionName = name;
+  const target = urlOrCommand;
+  if (PER_CLIENT_SCOPES.has(sessionName)) {
+    console.error(
+      formatError(
+        `'${sessionName}' is a reserved name and can't be used for a saved server.`
+      )
+    );
+    console.error("");
+    console.error(
+      `Reserved names: ${Array.from(PER_CLIENT_SCOPES).sort().join(", ")}`
+    );
+    console.error("");
+    console.error("Pick a different name, e.g.:");
+    console.error(`  mcp-use client connect my-${sessionName} ${target}`);
+    await cleanupAndExit(1);
+  }
   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) {
-      const parts = urlOrCommand.split(" ");
+      const parts = target.split(" ");
       const command = parts[0];
       const args = parts.slice(1);
       console.error(
@@ -2290,17 +3557,41 @@ async function connectCommand(urlOrCommand, options) {
         lastUsed: (/* @__PURE__ */ new Date()).toISOString()
       });
     } else {
-      console.error(formatInfo(`Connecting to ${urlOrCommand}...`));
+      console.error(formatInfo(`Connecting to ${target}...`));
+      const wantOAuth = !options.auth && options.oauth !== false;
+      let authProvider;
+      if (wantOAuth) {
+        const authTimeoutMs = options.authTimeout ? Number.parseInt(options.authTimeout, 10) : void 0;
+        authProvider = await buildOAuthProvider(target, {
+          ...authTimeoutMs ? { authTimeoutMs } : {}
+        });
+      }
       client.addServer(sessionName, {
-        url: urlOrCommand,
-        headers: options.auth ? { Authorization: `Bearer ${options.auth}` } : void 0,
+        url: target,
+        ...authProvider ? { authProvider } : options.auth ? { headers: { Authorization: `Bearer ${options.auth}` } } : {},
         clientInfo: cliClientInfo
       });
-      session = await client.createSession(sessionName);
+      try {
+        session = await client.createSession(sessionName);
+      } catch (err) {
+        if (authProvider && isUnauthorized(err)) {
+          console.error(
+            formatWarning(
+              "Server requires authentication. Starting OAuth flow."
+            )
+          );
+          await runOAuthFlow(authProvider, target);
+          console.error(formatSuccess("Authentication successful"));
+          session = await client.createSession(sessionName);
+        } else {
+          throw err;
+        }
+      }
       await saveSession(sessionName, {
         type: "http",
-        url: urlOrCommand,
-        authToken: options.auth,
+        url: target,
+        authMode: authProvider ? "oauth" : options.auth ? "bearer" : void 0,
+        authToken: authProvider ? void 0 : options.auth,
         lastUsed: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
@@ -2310,7 +3601,7 @@ async function connectCommand(urlOrCommand, options) {
     if (serverInfo) {
       await updateSessionInfo(sessionName, serverInfo, capabilities);
     }
-    console.log(formatSuccess(`Connected to ${sessionName}`));
+    console.log(formatSuccess(`Connected as '${sessionName}'`));
     if (serverInfo) {
       console.log("");
       console.log(formatHeader("Server Information:"));
@@ -2336,119 +3627,173 @@ async function connectCommand(urlOrCommand, options) {
     );
   } catch (error) {
     console.error(formatError(`Connection failed: ${error.message}`));
-    process.exit(1);
+    await cleanupAndExit(1);
   }
+  await cleanupAndExit(0);
 }
-async function disconnectCommand(sessionName, options) {
+async function disconnectCommand(name) {
   try {
-    if (options?.all) {
-      for (const [name, { client }] of activeSessions.entries()) {
-        await client.closeAllSessions();
-        activeSessions.delete(name);
-        console.log(formatSuccess(`Disconnected from ${name}`));
-      }
-      return;
-    }
-    if (!sessionName) {
-      const active = await getActiveSession();
-      if (!active) {
-        console.error(formatError("No active session to disconnect"));
-        return;
-      }
-      sessionName = active.name;
-    }
-    const sessionData = activeSessions.get(sessionName);
+    const sessionData = activeSessions.get(name);
     if (sessionData) {
       await sessionData.client.closeAllSessions();
-      activeSessions.delete(sessionName);
-      console.log(formatSuccess(`Disconnected from ${sessionName}`));
+      activeSessions.delete(name);
+      console.log(formatSuccess(`Disconnected from ${name}`));
     } else {
-      console.log(formatInfo(`Session '${sessionName}' is not connected`));
+      console.log(formatInfo(`Server '${name}' is not connected`));
     }
   } catch (error) {
     console.error(formatError(`Failed to disconnect: ${error.message}`));
-    process.exit(1);
+    await cleanupAndExit(1);
+  }
+  await cleanupAndExit(0);
+}
+async function removeClientCommand(name) {
+  try {
+    const config = await getSession(name);
+    if (!config) {
+      console.error(formatError(`Server '${name}' not found`));
+      console.error("");
+      console.error("See your saved servers with:");
+      console.error("  mcp-use client list");
+      await cleanupAndExit(1);
+    }
+    const sessionData = activeSessions.get(name);
+    if (sessionData) {
+      await sessionData.client.closeAllSessions();
+      activeSessions.delete(name);
+    }
+    const isOAuthHttp = config.type === "http" && config.authMode === "oauth" && typeof config.url === "string";
+    const sharedUrlSibling = isOAuthHttp ? (await listAllSessions()).find(
+      (s) => s.name !== name && s.config.type === "http" && s.config.url === config.url
+    ) : void 0;
+    await removeSession(name);
+    console.log(formatSuccess(`Removed saved server '${name}'`));
+    if (isOAuthHttp) {
+      if (sharedUrlSibling) {
+        console.log(
+          formatInfo(
+            `OAuth tokens for ${config.url} were kept because saved server '${sharedUrlSibling.name}' still uses that URL.`
+          )
+        );
+      } else {
+        try {
+          const provider = await buildOAuthProvider(config.url);
+          await provider.invalidateCredentials("all");
+          console.log(formatInfo(`Removed OAuth tokens for ${config.url}`));
+        } catch (error) {
+          console.error(
+            formatWarning(
+              `Saved entry removed, but failed to clear OAuth tokens for ${config.url}: ${error.message}`
+            )
+          );
+        }
+      }
+    }
+  } catch (error) {
+    console.error(formatError(`Failed to remove server: ${error.message}`));
+    await cleanupAndExit(1);
   }
+  await cleanupAndExit(0);
 }
-async function listSessionsCommand() {
+async function listClientsCommand() {
   try {
     const sessions = await listAllSessions();
     if (sessions.length === 0) {
-      console.log(formatInfo("No saved sessions"));
-      console.log(
-        formatInfo("Connect to a server with: npx mcp-use client connect <url>")
-      );
+      if (isStdoutTty()) {
+        console.log(formatInfo("No saved servers"));
+        console.log(
+          formatInfo(
+            "Connect to a server with: npx mcp-use client connect <name> <url>"
+          )
+        );
+      }
       return;
     }
-    console.log(formatHeader("Saved Sessions:"));
-    console.log("");
+    const tty2 = isStdoutTty();
+    if (tty2) {
+      console.log(formatHeader("Saved Servers:"));
+      console.log("");
+    }
     const tableData = sessions.map((s) => ({
-      name: s.isActive ? source_default.green.bold(`${s.name} *`) : s.name,
+      name: s.name,
       type: s.config.type,
       target: s.config.type === "http" ? s.config.url || "" : `${s.config.command} ${(s.config.args || []).join(" ")}`,
-      server: s.config.serverInfo?.name || "unknown",
-      status: activeSessions.has(s.name) ? source_default.green("connected") : source_default.gray("disconnected")
+      server: s.config.serverInfo?.name || "unknown"
     }));
     console.log(
       formatTable(tableData, [
         { key: "name", header: "Name" },
         { key: "type", header: "Type" },
-        { key: "target", header: "Target", width: 40 },
-        { key: "server", header: "Server" },
-        { key: "status", header: "Status" }
+        { key: "target", header: "Target", truncate: true },
+        { key: "server", header: "Server" }
       ])
     );
-    console.log("");
-    console.log(source_default.gray("* = active session"));
-  } catch (error) {
-    console.error(formatError(`Failed to list sessions: ${error.message}`));
-    process.exit(1);
-  }
-}
-async function switchSessionCommand(name) {
-  try {
-    await setActiveSession(name);
-    console.log(formatSuccess(`Switched to session '${name}'`));
   } catch (error) {
-    console.error(formatError(`Failed to switch session: ${error.message}`));
-    process.exit(1);
+    console.error(formatError(`Failed to list servers: ${error.message}`));
+    await cleanupAndExit(1);
   }
+  await cleanupAndExit(0);
 }
-async function listToolsCommand(options) {
+async function listToolsCommand(name, options) {
   try {
-    const result = await getOrRestoreSession(options.session || null);
-    if (!result) return;
+    const result = await getOrRestoreSession(name);
+    if (!result) {
+      await cleanupAndExit(1);
+    }
     const { session } = result;
     const tools = await session.listTools();
     if (options.json) {
       console.log(formatJson(tools));
-      return;
-    }
-    if (tools.length === 0) {
-      console.log(formatInfo("No tools available"));
-      return;
+    } else if (tools.length === 0) {
+      if (isStdoutTty()) console.log(formatInfo("No tools available"));
+    } else {
+      const tty2 = isStdoutTty();
+      if (tty2) {
+        console.log(formatHeader(`Available Tools (${tools.length}):`));
+        console.log("");
+      }
+      const tableData = tools.map((tool) => {
+        const props = tool.inputSchema?.properties ?? {};
+        const required = tool.inputSchema?.required ?? [];
+        const total = Object.keys(props).length;
+        const reqCount = Array.isArray(required) ? required.length : 0;
+        const argsCell = total === 0 ? source_default.gray("\u2014") : `${reqCount}/${total}`;
+        return {
+          name: source_default.bold(tool.name),
+          mode: formatToolMode(tool.annotations),
+          args: argsCell,
+          description: tool.description || source_default.gray("(no description)")
+        };
+      });
+      console.log(
+        formatTable(tableData, [
+          { key: "name", header: "Tool" },
+          { key: "mode", header: "Mode" },
+          { key: "args", header: "Args" },
+          { key: "description", header: "Description", truncate: true }
+        ])
+      );
+      if (tty2) {
+        console.log("");
+        console.log(
+          source_default.gray(
+            "ARGS shows required/total. Modes: read-only \xB7 write \xB7 destructive."
+          )
+        );
+      }
     }
-    console.log(formatHeader(`Available Tools (${tools.length}):`));
-    console.log("");
-    const tableData = tools.map((tool) => ({
-      name: source_default.bold(tool.name),
-      description: tool.description || source_default.gray("No description")
-    }));
-    console.log(
-      formatTable(tableData, [
-        { key: "name", header: "Tool", width: 25 },
-        { key: "description", header: "Description", width: 50 }
-      ])
-    );
   } catch (error) {
     console.error(formatError(`Failed to list tools: ${error.message}`));
-    process.exit(1);
+    await cleanupAndExit(1);
   }
+  await cleanupAndExit(0);
 }
-async function describeToolCommand(toolName, options) {
+async function describeToolCommand(name, toolName) {
   try {
-    const result = await getOrRestoreSession(options.session || null);
-    if (!result) return;
+    const result = await getOrRestoreSession(name);
+    if (!result) {
+      await cleanupAndExit(1);
+    }
     const { session } = result;
     const tools = session.tools;
     const tool = tools.find((t) => t.name === toolName);
@@ -2457,7 +3802,7 @@ async function describeToolCommand(toolName, options) {
       console.log("");
       console.log(formatInfo("Available tools:"));
       tools.forEach((t) => console.log(`  \u2022 ${t.name}`));
-      return;
+      await cleanupAndExit(1);
     }
     console.log(formatHeader(`Tool: ${tool.name}`));
     console.log("");
@@ -2471,94 +3816,167 @@ async function describeToolCommand(toolName, options) {
     }
   } catch (error) {
     console.error(formatError(`Failed to describe tool: ${error.message}`));
-    process.exit(1);
+    await cleanupAndExit(1);
   }
+  await cleanupAndExit(0);
 }
-async function callToolCommand(toolName, argsJson, options) {
+async function callToolCommand(name, toolName, argsList, options) {
   try {
-    const result = await getOrRestoreSession(options?.session || null);
-    if (!result) return;
+    const result = await getOrRestoreSession(name);
+    if (!result) {
+      await cleanupAndExit(1);
+    }
     const { session } = result;
+    const tools = session.tools;
+    const tool = tools.find((t) => t.name === toolName);
     let args = {};
-    if (argsJson) {
+    if (argsList && argsList.length > 0) {
       try {
-        args = JSON.parse(argsJson);
+        args = parseToolArgs(argsList, tool?.inputSchema);
       } catch (error) {
-        console.error(formatError("Invalid JSON arguments"));
-        return;
-      }
-    } else {
-      const tools = session.tools;
-      const tool = tools.find((t) => t.name === toolName);
-      if (tool?.inputSchema?.required && tool.inputSchema.required.length > 0) {
-        console.error(
-          formatError(
-            "This tool requires arguments. Provide them as a JSON string."
-          )
-        );
+        console.error(formatError(error.message));
         console.log("");
-        console.log(formatInfo("Example:"));
+        console.log(formatInfo("Usage:"));
         console.log(
-          `  npx mcp-use client tools call ${toolName} '{"param": "value"}'`
+          `  npx mcp-use client ${name} tools call ${toolName} key=value [key2=value2 ...]`
         );
-        console.log("");
-        console.log(formatInfo("Tool schema:"));
-        console.log(formatSchema(tool.inputSchema));
-        return;
+        console.log(
+          `  npx mcp-use client ${name} tools call ${toolName} nested:='{"a":1}'   # JSON value`
+        );
+        console.log(
+          `  npx mcp-use client ${name} tools call ${toolName} '{"key":"value"}'   # full JSON object`
+        );
+        if (tool?.inputSchema) {
+          console.log("");
+          console.log(formatInfo("Tool schema:"));
+          console.log(formatSchema(tool.inputSchema));
+        }
+        await cleanupAndExit(1);
       }
+    } else if (tool?.inputSchema?.required && tool.inputSchema.required.length > 0) {
+      console.error(formatError("This tool requires arguments."));
+      console.log("");
+      console.log(formatInfo("Provide arguments as key=value pairs:"));
+      console.log(
+        `  npx mcp-use client ${name} tools call ${toolName} key=value [key2=value2 ...]`
+      );
+      console.log("");
+      console.log(formatInfo("Tool schema:"));
+      console.log(formatSchema(tool.inputSchema));
+      await cleanupAndExit(1);
     }
     console.error(formatInfo(`Calling tool '${toolName}'...`));
     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);
+    }
   } catch (error) {
     console.error(formatError(`Failed to call tool: ${error.message}`));
-    process.exit(1);
+    if (error?.data !== void 0) {
+      console.error(
+        source_default.gray(
+          typeof error.data === "string" ? error.data : formatJson(error.data)
+        )
+      );
+    }
+    await cleanupAndExit(1);
   }
+  await cleanupAndExit(0);
 }
-async function listResourcesCommand(options) {
+async function listResourcesCommand(name, options) {
   try {
-    const result = await getOrRestoreSession(options.session || null);
-    if (!result) return;
+    const result = await getOrRestoreSession(name);
+    if (!result) {
+      await cleanupAndExit(1);
+    }
     const { session } = result;
     const resourcesResult = await session.listAllResources();
     const resources = resourcesResult.resources;
     if (options.json) {
       console.log(formatJson(resources));
-      return;
-    }
-    if (resources.length === 0) {
-      console.log(formatInfo("No resources available"));
-      return;
+    } else if (resources.length === 0) {
+      if (isStdoutTty()) console.log(formatInfo("No resources available"));
+    } else {
+      const tty2 = isStdoutTty();
+      if (tty2) {
+        console.log(formatHeader(`Available Resources (${resources.length}):`));
+        console.log("");
+      }
+      const tableData = resources.map((resource) => ({
+        name: source_default.bold(resource.name || "(no name)"),
+        type: resource.mimeType || source_default.gray("unknown"),
+        uri: resource.uri
+      }));
+      console.log(
+        formatTable(tableData, [
+          { key: "name", header: "Name" },
+          { key: "type", header: "Type" },
+          { key: "uri", header: "URI", truncate: true }
+        ])
+      );
     }
-    console.log(formatHeader(`Available Resources (${resources.length}):`));
-    console.log("");
-    const tableData = resources.map((resource) => ({
-      uri: resource.uri,
-      name: resource.name || source_default.gray("(no name)"),
-      type: resource.mimeType || source_default.gray("unknown")
-    }));
-    console.log(
-      formatTable(tableData, [
-        { key: "uri", header: "URI", width: 40 },
-        { key: "name", header: "Name", width: 20 },
-        { key: "type", header: "Type", width: 15 }
-      ])
-    );
   } catch (error) {
     console.error(formatError(`Failed to list resources: ${error.message}`));
-    process.exit(1);
+    await cleanupAndExit(1);
   }
+  await cleanupAndExit(0);
 }
-async function readResourceCommand(uri, options) {
+async function readResourceCommand(name, uri, options) {
   try {
-    const result = await getOrRestoreSession(options.session || null);
-    if (!result) return;
+    const result = await getOrRestoreSession(name);
+    if (!result) {
+      await cleanupAndExit(1);
+    }
     const { session } = result;
     console.error(formatInfo(`Reading resource: ${uri}`));
     const resource = await session.readResource(uri);
@@ -2569,13 +3987,16 @@ async function readResourceCommand(uri, options) {
     }
   } catch (error) {
     console.error(formatError(`Failed to read resource: ${error.message}`));
-    process.exit(1);
+    await cleanupAndExit(1);
   }
+  await cleanupAndExit(0);
 }
-async function subscribeResourceCommand(uri, options) {
+async function subscribeResourceCommand(name, uri) {
   try {
-    const result = await getOrRestoreSession(options.session || null);
-    if (!result) return;
+    const result = await getOrRestoreSession(name);
+    if (!result) {
+      await cleanupAndExit(1);
+    }
     const { session } = result;
     await session.subscribeToResource(uri);
     console.log(formatSuccess(`Subscribed to resource: ${uri}`));
@@ -2593,13 +4014,15 @@ async function subscribeResourceCommand(uri, options) {
     console.error(
       formatError(`Failed to subscribe to resource: ${error.message}`)
     );
-    process.exit(1);
+    await cleanupAndExit(1);
   }
 }
-async function unsubscribeResourceCommand(uri, options) {
+async function unsubscribeResourceCommand(name, uri) {
   try {
-    const result = await getOrRestoreSession(options.session || null);
-    if (!result) return;
+    const result = await getOrRestoreSession(name);
+    if (!result) {
+      await cleanupAndExit(1);
+    }
     const { session } = result;
     await session.unsubscribeFromResource(uri);
     console.log(formatSuccess(`Unsubscribed from resource: ${uri}`));
@@ -2607,53 +4030,76 @@ async function unsubscribeResourceCommand(uri, options) {
     console.error(
       formatError(`Failed to unsubscribe from resource: ${error.message}`)
     );
-    process.exit(1);
+    await cleanupAndExit(1);
   }
+  await cleanupAndExit(0);
 }
-async function listPromptsCommand(options) {
+async function listPromptsCommand(name, options) {
   try {
-    const result = await getOrRestoreSession(options.session || null);
-    if (!result) return;
+    const result = await getOrRestoreSession(name);
+    if (!result) {
+      await cleanupAndExit(1);
+    }
     const { session } = result;
     const promptsResult = await session.listPrompts();
     const prompts = promptsResult.prompts;
     if (options.json) {
       console.log(formatJson(prompts));
-      return;
-    }
-    if (prompts.length === 0) {
-      console.log(formatInfo("No prompts available"));
-      return;
+    } else if (prompts.length === 0) {
+      if (isStdoutTty()) console.log(formatInfo("No prompts available"));
+    } else {
+      const tty2 = isStdoutTty();
+      if (tty2) {
+        console.log(formatHeader(`Available Prompts (${prompts.length}):`));
+        console.log("");
+      }
+      const tableData = prompts.map((prompt4) => {
+        const args = prompt4.arguments ?? [];
+        const reqCount = Array.isArray(args) ? args.filter((a) => a?.required).length : 0;
+        const total = Array.isArray(args) ? args.length : 0;
+        const argsCell = total === 0 ? source_default.gray("\u2014") : `${reqCount}/${total}`;
+        return {
+          name: source_default.bold(prompt4.name),
+          args: argsCell,
+          description: prompt4.description || source_default.gray("(no description)")
+        };
+      });
+      console.log(
+        formatTable(tableData, [
+          { key: "name", header: "Prompt" },
+          { key: "args", header: "Args" },
+          { key: "description", header: "Description", truncate: true }
+        ])
+      );
     }
-    console.log(formatHeader(`Available Prompts (${prompts.length}):`));
-    console.log("");
-    const tableData = prompts.map((prompt4) => ({
-      name: source_default.bold(prompt4.name),
-      description: prompt4.description || source_default.gray("No description")
-    }));
-    console.log(
-      formatTable(tableData, [
-        { key: "name", header: "Prompt", width: 25 },
-        { key: "description", header: "Description", width: 50 }
-      ])
-    );
   } catch (error) {
     console.error(formatError(`Failed to list prompts: ${error.message}`));
-    process.exit(1);
+    await cleanupAndExit(1);
   }
+  await cleanupAndExit(0);
 }
-async function getPromptCommand(promptName, argsJson, options) {
+async function getPromptCommand(name, promptName, argsList, options) {
   try {
-    const result = await getOrRestoreSession(options?.session || null);
-    if (!result) return;
+    const result = await getOrRestoreSession(name);
+    if (!result) {
+      await cleanupAndExit(1);
+    }
     const { session } = result;
     let args = {};
-    if (argsJson) {
+    if (argsList && argsList.length > 0) {
       try {
-        args = JSON.parse(argsJson);
+        args = parsePromptArgs(argsList);
       } catch (error) {
-        console.error(formatError("Invalid JSON arguments"));
-        return;
+        console.error(formatError(error.message));
+        console.log("");
+        console.log(formatInfo("Usage:"));
+        console.log(
+          `  npx mcp-use client ${name} prompts get ${promptName} key=value [key2=value2 ...]`
+        );
+        console.log(
+          `  npx mcp-use client ${name} prompts get ${promptName} '{"key":"value"}'   # full JSON object`
+        );
+        await cleanupAndExit(1);
       }
     }
     console.error(formatInfo(`Getting prompt '${promptName}'...`));
@@ -2675,12 +4121,13 @@ async function getPromptCommand(promptName, argsJson, options) {
     }
   } catch (error) {
     console.error(formatError(`Failed to get prompt: ${error.message}`));
-    process.exit(1);
+    await cleanupAndExit(1);
   }
+  await cleanupAndExit(0);
 }
-async function interactiveCommand(options) {
+async function interactiveCommand(name) {
   try {
-    const result = await getOrRestoreSession(options.session || null);
+    const result = await getOrRestoreSession(name);
     if (!result) return;
     const { name: sessionName, session } = result;
     console.log(formatHeader("MCP Interactive Mode"));
@@ -2703,15 +4150,11 @@ async function interactiveCommand(options) {
       source_default.gray("  prompts list            - List available prompts")
     );
     console.log(source_default.gray("  prompts get <name>      - Get a prompt"));
-    console.log(source_default.gray("  sessions list           - List all sessions"));
-    console.log(
-      source_default.gray("  sessions switch <name>  - Switch to another session")
-    );
     console.log(
       source_default.gray("  exit, quit              - Exit interactive mode")
     );
     console.log("");
-    const rl = (0, import_node_readline.createInterface)({
+    const rl = (0, import_node_readline2.createInterface)({
       input: process.stdin,
       output: process.stdout,
       prompt: source_default.cyan("mcp> ")
@@ -2726,7 +4169,7 @@ async function interactiveCommand(options) {
       if (trimmed === "exit" || trimmed === "quit") {
         console.log(formatInfo("Goodbye!"));
         rl.close();
-        process.exit(0);
+        await cleanupAndExit(0);
       }
       const parts = trimmed.split(" ");
       const scope = parts[0];
@@ -2826,22 +4269,10 @@ async function interactiveCommand(options) {
               )
             );
           }
-        } else if (scope === "sessions") {
-          if (command === "list") {
-            await listSessionsCommand();
-          } else if (command === "switch" && arg) {
-            console.log(
-              formatWarning(
-                "Session switching in interactive mode will be available in a future version"
-              )
-            );
-          } else {
-            console.error(formatError("Invalid command. Try: sessions list"));
-          }
         } else {
           console.error(
             formatError(
-              "Unknown command. Type a valid scope: tools, resources, prompts, sessions"
+              "Unknown command. Type a valid scope: tools, resources, prompts"
             )
           );
         }
@@ -2850,63 +4281,98 @@ async function interactiveCommand(options) {
       }
       rl.prompt();
     });
-    rl.on("close", () => {
+    rl.on("close", async () => {
       console.log("");
       console.log(formatInfo("Goodbye!"));
-      process.exit(0);
+      await cleanupAndExit(0);
     });
   } catch (error) {
     console.error(
       formatError(`Failed to start interactive mode: ${error.message}`)
     );
-    process.exit(1);
+    await cleanupAndExit(1);
   }
 }
 function createClientCommand() {
-  const clientCommand = new import_commander.Command("client").description(
-    "Interactive MCP client for terminal usage"
+  const clientCommand = new import_commander2.Command("client").description(
+    "Interactive MCP client for terminal usage. Use `mcp-use client <name> ...` to run commands against a saved server."
+  ).showHelpAfterError(
+    "(Run `mcp-use client --help` to see available commands)"
+  );
+  clientCommand.command("connect [name] [url]").description(
+    "Connect to an MCP server and save it under a short name. Use the name to address it in later commands (e.g. `mcp-use client <name> tools list`)."
+  ).option("--stdio", "Use stdio connector instead of HTTP").option("--auth <token>", "Static Bearer token (skips OAuth)").option(
+    "--no-oauth",
+    "Don't auto-trigger OAuth on 401; fail with the 401 instead"
+  ).option(
+    "--auth-timeout <ms>",
+    "OAuth loopback wait timeout in ms (default 300000)"
+  ).action(connectCommand);
+  clientCommand.command("list").description("List saved servers").action(listClientsCommand);
+  clientCommand.command("remove <name>").description(
+    "Remove a saved server. Also clears any OAuth tokens for that URL, unless another saved server still uses it."
+  ).action(removeClientCommand);
+  return clientCommand;
+}
+function createPerClientCommand(name) {
+  const cmd = new import_commander2.Command(`mcp-use client ${name}`).description(`Commands for server '${name}'`).showHelpAfterError(
+    `(Run \`mcp-use client ${name} --help\` to see available commands)`
   );
-  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>", "Authentication token").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(
-    "Manage CLI sessions"
+  cmd.command("disconnect").description("Disconnect from this server").action(() => disconnectCommand(name));
+  cmd.command("interactive").description("Start interactive REPL mode for this server").action(() => interactiveCommand(name));
+  const toolsCommand = new import_commander2.Command("tools").description("Interact with MCP tools").showHelpAfterError(
+    `(Run \`mcp-use client ${name} tools --help\` to see available actions)`
   );
-  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(
-    "Interact with MCP tools"
+  toolsCommand.command("list").description("List available tools").option("--json", "Output as JSON").action((options) => listToolsCommand(name, options));
+  toolsCommand.command("call <tool> [args...]").description(
+    "Call a tool. Args as key=value pairs (use key:=<json> for nested values, or pass a JSON object)"
+  ).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(
+    (tool, args, options) => callToolCommand(name, tool, args, options)
   );
-  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 with arguments (JSON string)").option("--session <name>", "Use specific session").option("--timeout <ms>", "Request timeout in milliseconds", parseInt).option("--json", "Output as JSON").action(callToolCommand);
-  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(
-    "Interact with MCP resources"
+  toolsCommand.command("describe <tool>").description("Show tool details and schema").action((tool) => describeToolCommand(name, tool));
+  cmd.addCommand(toolsCommand);
+  const resourcesCommand = new import_commander2.Command("resources").description("Interact with MCP resources").showHelpAfterError(
+    `(Run \`mcp-use client ${name} resources --help\` to see available actions)`
   );
-  resourcesCommand.command("list").description("List available resources").option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(listResourcesCommand);
-  resourcesCommand.command("read <uri>").description("Read a resource by URI").option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(readResourceCommand);
-  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(
-    "Interact with MCP prompts"
+  resourcesCommand.command("list").description("List available resources").option("--json", "Output as JSON").action((options) => listResourcesCommand(name, options));
+  resourcesCommand.command("read <uri>").description("Read a resource by URI").option("--json", "Output as JSON").action((uri, options) => readResourceCommand(name, uri, options));
+  resourcesCommand.command("subscribe <uri>").description("Subscribe to resource updates").action((uri) => subscribeResourceCommand(name, uri));
+  resourcesCommand.command("unsubscribe <uri>").description("Unsubscribe from resource updates").action((uri) => unsubscribeResourceCommand(name, uri));
+  cmd.addCommand(resourcesCommand);
+  const promptsCommand = new import_commander2.Command("prompts").description("Interact with MCP prompts").showHelpAfterError(
+    `(Run \`mcp-use client ${name} prompts --help\` to see available actions)`
   );
-  promptsCommand.command("list").description("List available prompts").option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(listPromptsCommand);
-  promptsCommand.command("get <name> [args]").description("Get a prompt with arguments (JSON string)").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);
-  return clientCommand;
+  promptsCommand.command("list").description("List available prompts").option("--json", "Output as JSON").action((options) => listPromptsCommand(name, options));
+  promptsCommand.command("get <prompt> [args...]").description(
+    "Get a prompt. Args as key=value pairs (or pass a JSON object)"
+  ).option("--json", "Output as JSON").action(
+    (prompt4, args, options) => getPromptCommand(name, prompt4, args, options)
+  );
+  cmd.addCommand(promptsCommand);
+  const authCommand = new import_commander2.Command("auth").description("Manage OAuth tokens for HTTP servers").showHelpAfterError(
+    `(Run \`mcp-use client ${name} auth --help\` to see available actions)`
+  );
+  authCommand.command("status").description("Show OAuth token status for this server").action(() => authStatusCommand(name));
+  authCommand.command("refresh").description("Force-refresh the OAuth access token").action(() => authRefreshCommand(name));
+  authCommand.command("logout").description("Remove stored OAuth tokens for this server's URL").action(() => authLogoutCommand(name));
+  cmd.addCommand(authCommand);
+  return cmd;
 }
 
 // src/commands/deploy.ts
-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);
 
 // src/utils/git.ts
-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 });
@@ -3055,17 +4521,17 @@ function getMcpServerUrlForCloudServer(server) {
 }
 
 // src/utils/project-link.ts
-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;
@@ -3074,17 +4540,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;
     }
@@ -3093,7 +4559,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) {
   }
@@ -3102,7 +4568,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;
@@ -3221,7 +4687,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 {
@@ -3230,16 +4696,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 {
   }
@@ -3247,7 +4713,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}`;
@@ -3258,7 +4724,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;
@@ -3305,17 +4771,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) {
@@ -3765,10 +5231,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}`)
@@ -4277,7 +5743,7 @@ async function deployCommand(options) {
 }
 
 // src/commands/deployments.ts
-var import_commander2 = require("commander");
+var import_commander3 = require("commander");
 async function prompt2(question) {
   const readline = await import("readline");
   const rl = readline.createInterface({
@@ -4689,8 +6155,8 @@ async function startDeploymentCommand(deploymentId) {
   }
 }
 function createDeploymentsCommand() {
-  const deploymentsCommand = new import_commander2.Command("deployments").description(
-    "Manage cloud deployments"
+  const deploymentsCommand = new import_commander3.Command("deployments").description("Manage cloud deployments").showHelpAfterError(
+    "(Run `mcp-use deployments --help` to see available commands)"
   );
   deploymentsCommand.command("list").alias("ls").description("List all deployments").action(listDeploymentsCommand);
   deploymentsCommand.command("get").argument("<deployment-id>", "Deployment ID").description("Get deployment details").action(getDeploymentCommand);
@@ -4705,10 +6171,10 @@ function createDeploymentsCommand() {
 }
 
 // src/commands/servers.ts
-var import_commander4 = require("commander");
+var import_commander5 = require("commander");
 
 // src/commands/env.ts
-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);
@@ -4853,9 +6319,7 @@ async function removeEnvCommand(varId, options) {
   }
 }
 function createEnvCommand() {
-  const envCommand = new import_commander3.Command("env").description(
-    "Manage environment variables for a server"
-  );
+  const envCommand = new import_commander4.Command("env").description("Manage environment variables for a server").showHelpAfterError("(Run `mcp-use env --help` to see available commands)");
   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);
   envCommand.command("add").argument("<KEY=VALUE>", "Variable assignment, e.g. API_KEY=abc123").description("Add an environment variable to a server").requiredOption("--server <id>", "Server UUID").option(
     "--env <environments>",
@@ -5137,8 +6601,8 @@ async function deleteServerCommand(serverId, options) {
   }
 }
 function createServersCommand() {
-  const serversCommand = new import_commander4.Command("servers").description(
-    "Manage cloud servers (Git-backed deploy targets)"
+  const serversCommand = new import_commander5.Command("servers").description("Manage cloud servers (Git-backed deploy targets)").showHelpAfterError(
+    "(Run `mcp-use servers --help` to see available commands)"
   );
   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);
   serversCommand.command("get").argument("<id-or-slug>", "Server UUID or slug").option("--org <slug-or-id>", "Resolve org context before fetch").description("Show server details and recent deployments").action(getServerCommand);
@@ -5255,12 +6719,12 @@ async function orgCurrentCommand() {
 }
 
 // src/commands/skills.ts
-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";
@@ -5295,42 +6759,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(
-    "Manage mcp-use AI agent skills"
+  const skills = new import_commander6.Command("skills").description("Manage mcp-use AI agent skills").showHelpAfterError(
+    "(Run `mcp-use skills --help` to see available commands)"
   );
   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);
     }
@@ -5371,13 +6835,13 @@ function createSkillsCommand() {
 }
 
 // src/utils/next-shims.ts
-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 ?? {};
@@ -5395,9 +6859,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;
     }
@@ -5407,20 +6871,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;
 }
@@ -5438,7 +6902,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;
   }
@@ -5446,7 +6910,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;
@@ -5471,13 +6935,13 @@ function quoteNodeOption(value) {
 }
 
 // src/utils/update-check.ts
-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";
@@ -5502,7 +6966,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;
@@ -5510,12 +6974,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 {
   }
 }
@@ -5560,16 +7024,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 {
     }
@@ -5601,14 +7065,14 @@ 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);
 var packageVersion = packageJson.version || "unknown";
-program.name("mcp-use").description("Create and run MCP servers with ui resources widgets").version(packageVersion);
+program.name("mcp-use").description("Create and run MCP servers with ui resources widgets").version(packageVersion).showHelpAfterError("(Run `mcp-use --help` to see available commands)");
 function displayPackageVersions(projectPath) {
   const packages = [
     { name: "@mcp-use/cli", relativePath: "../package.json" },
@@ -5634,16 +7098,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) {
@@ -5698,7 +7162,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",
@@ -5731,7 +7195,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"
     });
@@ -5795,21 +7259,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;
@@ -5818,17 +7282,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;
@@ -5846,7 +7310,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) {
@@ -5881,8 +7345,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}`);
   }
@@ -5907,8 +7371,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;
     }
@@ -5916,7 +7380,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);
@@ -5943,8 +7407,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");
     }
@@ -5962,10 +7426,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(
@@ -5984,10 +7448,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({
@@ -6017,14 +7481,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");
@@ -6036,16 +7500,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 {
@@ -6056,7 +7520,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'
@@ -6081,9 +7545,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",
@@ -6093,13 +7557,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",
@@ -6127,9 +7591,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
@@ -6360,7 +7824,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;
             }
@@ -6368,11 +7832,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 = {}
@@ -6404,7 +7868,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")) {
@@ -6480,7 +7944,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 {
       }
@@ -6488,13 +7952,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);
         }
       }
@@ -6506,7 +7970,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");
@@ -6536,10 +8000,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",
@@ -6566,7 +8030,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;
@@ -6626,7 +8090,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",
@@ -6649,7 +8113,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
@@ -6660,7 +8124,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 {
@@ -6669,17 +8133,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");
@@ -6704,7 +8168,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),
@@ -6741,7 +8205,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;
@@ -6769,10 +8233,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) {
@@ -6810,7 +8274,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 {
           }
@@ -6818,8 +8282,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"
@@ -6873,10 +8337,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;
@@ -6885,7 +8349,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) {
@@ -6974,10 +8438,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);
@@ -6986,7 +8450,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);
@@ -7017,7 +8481,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 () => {
@@ -7114,8 +8578,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;
         }
@@ -7289,10 +8753,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) {
@@ -7326,16 +8790,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 {
@@ -7438,7 +8902,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)) {
@@ -7456,10 +8920,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) {
@@ -7503,7 +8967,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 {
           }
@@ -7511,8 +8975,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"
@@ -7530,12 +8994,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 {
@@ -7556,7 +9020,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 {
@@ -7607,13 +9071,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) {
@@ -7626,7 +9090,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
@@ -7759,10 +9223,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(
@@ -7792,5 +9257,49 @@ program.hook("preAction", async (_thisCommand, actionCommand) => {
   const projectPath = actionCommand.opts().path;
   await notifyIfUpdateAvailable(projectPath);
 });
-program.parse();
+var argv = process.argv;
+var clientIdx = argv[2] === "client" ? 2 : -1;
+var perClientName = clientIdx !== -1 && argv.length > clientIdx + 1 && !argv[clientIdx + 1].startsWith("-") && !RESERVED_CLIENT_SUBCOMMANDS.has(argv[clientIdx + 1]) ? argv[clientIdx + 1] : null;
+if (perClientName) {
+  if (PER_CLIENT_SCOPES.has(perClientName)) {
+    const rest2 = argv.slice(clientIdx + 1).join(" ");
+    console.error(formatError("Missing server name."));
+    console.error("");
+    console.error(
+      `'${perClientName}' is a per-server subcommand, not a server name. Address it through a saved server:`
+    );
+    console.error("");
+    console.error(`  mcp-use client <name> ${rest2}`);
+    console.error("");
+    console.error("See your saved servers with:");
+    console.error("  mcp-use client list");
+    process.exit(1);
+  }
+  const rest = argv.slice(clientIdx + 2);
+  const isHelpOnly = rest.length === 0 || rest.length === 1 && (rest[0] === "--help" || rest[0] === "-h");
+  (async () => {
+    if (isHelpOnly) {
+      const config = await getSession(perClientName);
+      if (!config) {
+        console.error(formatError(`Server '${perClientName}' not found.`));
+        console.error("");
+        console.error("Connect to an MCP server and save it under this name:");
+        console.error(`  mcp-use client connect ${perClientName} <url>`);
+        console.error("");
+        console.error("See your saved servers with:");
+        console.error("  mcp-use client list");
+        process.exit(1);
+      }
+    }
+    await createPerClientCommand(perClientName).parseAsync(rest, {
+      from: "user"
+    });
+  })().catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(formatError(message));
+    process.exit(1);
+  });
+} else {
+  program.parse();
+}
 //# sourceMappingURL=index.cjs.map