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

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.14_tsx@4.21.0_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.9_tsx@4.21.0_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
 var getFilename = () => fileURLToPath(import.meta.url);
@@ -197,10 +197,10 @@ var ansi_styles_default = ansiStyles;
 import process2 from "process";
 import os from "os";
 import tty from "tty";
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+function hasFlag(flag, argv2 = globalThis.Deno ? globalThis.Deno.args : process2.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 } = process2;
@@ -503,13 +503,13 @@ var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // src/index.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 import "dotenv/config";
-import { spawn } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { readFileSync as readFileSync2 } from "fs";
-import { access, mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { access, mkdir as mkdir4, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
-import path8 from "path";
+import path11 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // ../../node_modules/.pnpm/open@11.0.0/node_modules/open/index.js
@@ -595,7 +595,7 @@ var is_wsl_default = process3.env.__IS_WSL_TEST__ ? isWsl : isWsl();
 
 // ../../node_modules/.pnpm/powershell-utils@0.1.0/node_modules/powershell-utils/index.js
 import process4 from "process";
-import { Buffer } from "buffer";
+import { Buffer as Buffer2 } from "buffer";
 import { promisify } from "util";
 import childProcess from "child_process";
 import fs4, { constants as fsConstants } from "fs/promises";
@@ -626,7 +626,7 @@ executePowerShell.argumentsPrefix = [
   "Bypass",
   "-EncodedCommand"
 ];
-executePowerShell.encodeCommand = (command) => Buffer.from(command, "utf16le").toString("base64");
+executePowerShell.encodeCommand = (command) => Buffer2.from(command, "utf16le").toString("base64");
 executePowerShell.escapeArgument = (value) => `'${String(value).replaceAll("'", "''")}'`;
 
 // ../../node_modules/.pnpm/wsl-utils@0.3.1/node_modules/wsl-utils/utilities.js
@@ -696,15 +696,15 @@ var wslDefaultBrowser = async () => {
   const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
   return stdout.trim();
 };
-var convertWslPathToWindows = async (path9) => {
-  if (/^[a-z]+:\/\//i.test(path9)) {
-    return path9;
+var convertWslPathToWindows = async (path12) => {
+  if (/^[a-z]+:\/\//i.test(path12)) {
+    return path12;
   }
   try {
-    const { stdout } = await execFile2("wslpath", ["-aw", path9], { encoding: "utf8" });
+    const { stdout } = await execFile2("wslpath", ["-aw", path12], { encoding: "utf8" });
     return stdout.trim();
   } catch {
-    return path9;
+    return path12;
   }
 };
 
@@ -1320,8 +1320,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."
@@ -1354,8 +1354,8 @@ var McpUseAPI = class _McpUseAPI {
     return this.request(`/servers${q ? `?${q}` : ""}`);
   }
   async getServer(idOrSlug) {
-    const path9 = encodeURIComponent(idOrSlug);
-    return this.request(`/servers/${path9}`);
+    const path12 = encodeURIComponent(idOrSlug);
+    return this.request(`/servers/${path12}`);
   }
   async deleteServer(id) {
     await this.request(
@@ -1855,52 +1855,110 @@ async function whoamiCommand() {
 }
 
 // src/commands/client.ts
-import { Command } from "commander";
-import { MCPClient } from "mcp-use/client";
-import { getPackageVersion } from "mcp-use/server";
-import { createInterface } from "readline";
+import { Command as Command2 } from "commander";
+import { MCPClient as MCPClient3 } from "mcp-use/client";
+import { createInterface as createInterface2 } from "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);
@@ -1909,20 +1967,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) {
@@ -1939,11 +2006,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) {
@@ -2096,28 +2172,223 @@ 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
+import {
+  auth,
+  NodeOAuthClientProvider,
+  OAuthFlowError,
+  UnauthorizedError
+} from "mcp-use/auth/node";
+import { createInterface } from "readline";
+async function buildOAuthProvider(serverUrl, options = {}) {
+  return 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 auth(provider, { serverUrl });
+    if (result === "AUTHORIZED") {
+      return;
+    }
+    if (result !== "REDIRECT") {
+      throw new OAuthFlowError(
+        "unexpected_auth_result",
+        `auth() returned ${result}`
+      );
+    }
+  }
+  const code = await provider.getAuthorizationCode();
+  await auth(provider, { serverUrl, authorizationCode: code });
+}
+function isUnauthorized(err) {
+  if (err instanceof 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 = 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
 import { homedir } from "os";
 import { join } from "path";
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { existsSync } from "fs";
 var SESSION_FILE_PATH = join(homedir(), ".mcp-use", "cli-sessions.json");
+var _dirEnsured = false;
 async function ensureSessionDir() {
-  const dir = join(homedir(), ".mcp-use");
-  if (!existsSync(dir)) {
-    await mkdir(dir, { recursive: true });
-  }
+  if (_dirEnsured) return;
+  await mkdir(join(homedir(), ".mcp-use"), { recursive: true });
+  _dirEnsured = true;
 }
 async function loadSessions() {
   try {
     await ensureSessionDir();
     if (!existsSync(SESSION_FILE_PATH)) {
-      return { activeSession: null, sessions: {} };
+      return { sessions: {} };
     }
     const content = await 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) {
@@ -2130,40 +2401,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) {
@@ -2176,40 +2429,68 @@ async function updateSessionInfo(name, serverInfo, capabilities) {
   }
 }
 
-// src/commands/client.ts
+// src/utils/session.ts
+import { MCPClient } from "mcp-use/client";
+import { getPackageVersion } from "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: 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 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,
@@ -2221,37 +2502,1028 @@ async function getOrRestoreSession(sessionName) {
       console.error(formatError(`Unknown session type: ${config.type}`));
       return null;
     }
-    const session = await client.createSession(sessionName);
-    activeSessions.set(sessionName, { client, session });
-    console.error(formatInfo(`Reconnected to session '${sessionName}'`));
-    return { name: sessionName, session };
-  } catch (error) {
-    console.error(formatError(`Failed to restore session: ${error.message}`));
-    return null;
+    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 });
+    return { name: sessionName, session };
+  } catch (error) {
+    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
+import { Command } from "commander";
+import { MCPClient as MCPClient2 } from "mcp-use/client";
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2 } from "fs/promises";
+import { createServer } from "net";
+import path6 from "path";
+
+// src/utils/cdp-screenshot.ts
+import { spawn } from "child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import os4 from "os";
+import path4 from "path";
+import WebSocket from "ws";
+var CdpClient = class {
+  constructor(ws) {
+    this.ws = ws;
+    ws.on("message", (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(data.toString());
+      } catch {
+        return;
+      }
+      if (typeof msg.id !== "number") return;
+      const cb = this.pending.get(msg.id);
+      if (!cb) return;
+      this.pending.delete(msg.id);
+      if (msg.error) {
+        cb.reject(new Error(msg.error.message ?? "CDP error"));
+      } else {
+        cb.resolve(msg.result ?? {});
+      }
+    });
+    ws.on("close", () => {
+      for (const cb of this.pending.values()) {
+        cb.reject(new Error("CDP WebSocket closed"));
+      }
+      this.pending.clear();
+    });
+    ws.on("error", (err) => {
+      for (const cb of this.pending.values()) {
+        cb.reject(err);
+      }
+      this.pending.clear();
+    });
+  }
+  nextId = 0;
+  pending = /* @__PURE__ */ new Map();
+  send(method, params = {}, sessionId) {
+    const id = ++this.nextId;
+    const payload = { id, method, params };
+    if (sessionId) payload.sessionId = sessionId;
+    return new Promise((resolve2, reject) => {
+      this.pending.set(id, {
+        resolve: (r) => resolve2(r),
+        reject
+      });
+      this.ws.send(JSON.stringify(payload));
+    });
+  }
+  close() {
+    try {
+      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 {
+        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 = mkdtempSync(path4.join(os4.tmpdir(), "mcp-use-chrome-"));
+      const chromeArgs = [
+        "--headless=new",
+        "--remote-debugging-port=0",
+        `--user-data-dir=${userDataDir}`,
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-extensions",
+        "--disable-gpu",
+        "--hide-scrollbars",
+        "--mute-audio",
+        `--window-size=${opts.width},${opts.height}`,
+        "about:blank"
+      ];
+      child = spawn(opts.chromePath, chromeArgs, {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      child.stdout?.resume();
+      wsUrl = await waitForDevToolsUrl(child);
+    }
+    const ws = new WebSocket(wsUrl);
+    await new Promise((resolve2, reject) => {
+      const onOpen = () => {
+        ws.off("error", onError);
+        resolve2();
+      };
+      const onError = (err) => {
+        ws.off("open", onOpen);
+        reject(err);
+      };
+      ws.once("open", onOpen);
+      ws.once("error", onError);
+    });
+    cdp = new CdpClient(ws);
+    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
+    );
+    writeFileSync(opts.outputPath, Buffer.from(shot.data, "base64"));
+  } finally {
+    cleanup();
+  }
+}
+
+// src/utils/chrome-path.ts
+import { accessSync, constants } from "fs";
+import path5 from "path";
+var ENV_VAR_NAMES = [
+  "MCP_USE_CHROME_PATH",
+  "PUPPETEER_EXECUTABLE_PATH",
+  "CHROME_PATH"
+];
+var DARWIN_PATHS = [
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+  "/Applications/Chromium.app/Contents/MacOS/Chromium",
+  "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+  "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
+];
+var LINUX_BINARIES = [
+  "google-chrome-stable",
+  "google-chrome",
+  "chromium",
+  "chromium-browser",
+  "microsoft-edge",
+  "microsoft-edge-stable",
+  "brave-browser"
+];
+var WIN_SUBPATHS = [
+  "Google\\Chrome\\Application\\chrome.exe",
+  "Microsoft\\Edge\\Application\\msedge.exe",
+  "BraveSoftware\\Brave-Browser\\Application\\brave.exe",
+  "Chromium\\Application\\chrome.exe"
+];
+function isAccessible(p) {
+  try {
+    accessSync(p, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findOnPath(binary) {
+  const PATH = process.env.PATH ?? "";
+  for (const dir of PATH.split(":")) {
+    if (!dir) continue;
+    const candidate = path5.posix.join(dir, binary);
+    if (isAccessible(candidate)) return candidate;
+  }
+  return null;
+}
+function findChrome() {
+  for (const name of ENV_VAR_NAMES) {
+    const v = process.env[name];
+    if (v && isAccessible(v)) return v;
+  }
+  if (process.platform === "darwin") {
+    for (const p of DARWIN_PATHS) {
+      if (isAccessible(p)) return p;
+    }
+    return null;
+  }
+  if (process.platform === "linux") {
+    for (const bin of LINUX_BINARIES) {
+      const p = findOnPath(bin);
+      if (p) return p;
+    }
+    return null;
+  }
+  if (process.platform === "win32") {
+    const dirs = [
+      process.env["ProgramFiles"],
+      process.env["ProgramFiles(x86)"],
+      process.env["LocalAppData"]
+    ].filter((d) => Boolean(d));
+    for (const dir of dirs) {
+      for (const sub of WIN_SUBPATHS) {
+        const candidate = path5.join(dir, sub);
+        if (isAccessible(candidate)) return candidate;
+      }
+    }
+    return null;
+  }
+  return null;
+}
+function resolveChromePath() {
+  const found = findChrome();
+  if (found) return found;
+  throw new Error(
+    "Could not find Chrome, Chromium, Edge, or Brave on this system. Install Chrome from https://google.com/chrome, or set MCP_USE_CHROME_PATH (or PUPPETEER_EXECUTABLE_PATH / CHROME_PATH) to a browser executable."
+  );
+}
+
+// src/commands/screenshot.ts
+function 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 = path6.resolve(options.output ?? `./${view}-${ts}.png`);
+    await mkdir2(path6.dirname(outputPath), { recursive: true });
+    await captureScreenshot({
+      url: previewUrl.toString(),
+      width,
+      height,
+      theme,
+      waitForSelector: options.waitFor ?? 'body[data-view-ready="true"]',
+      timeoutMs,
+      outputPath,
+      chromePath,
+      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 = 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 : path6.dirname(new URL(import.meta.url).pathname);
+  candidateRoots.add(moduleDir);
+  candidateRoots.add(process.cwd());
+  for (const start of candidateRoots) {
+    let dir = start;
+    while (true) {
+      const candidate = path6.join(
+        dir,
+        "node_modules",
+        "@mcp-use",
+        "inspector",
+        "dist",
+        "cli.js"
+      );
+      if (existsSync2(candidate)) return candidate;
+      const parent = path6.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  throw new Error(
+    "Could not locate `@mcp-use/inspector` in node_modules. Install the inspector package or pass --inspector <url> to use an existing instance."
+  );
+}
+async function ensureDevServer(options) {
+  if (options.inspector) {
+    const ok = await probeServer(options.inspector);
+    if (!ok) {
+      throw new Error(
+        `Inspector at ${options.inspector} did not respond on /inspector/health with status:"ok"`
+      );
+    }
+    return { url: options.inspector };
+  }
+  const port = await getFreePort();
+  const url = `http://localhost:${port}`;
+  if (!options.quiet) {
+    console.error(formatInfo(`Starting inspector on port ${port}\u2026`));
+  }
+  const inspectorCli = resolveInspectorCli();
+  const child = spawn2(
+    process.execPath,
+    [inspectorCli, "--port", String(port), "--no-open"],
+    {
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, MCP_INSPECTOR_MODE: "standalone" }
+    }
+  );
+  const prefix = source_default.gray("[inspector]");
+  if (!options.quiet) {
+    child.stdout?.on("data", (d) => {
+      process.stderr.write(`${prefix} ${d}`);
+    });
+    child.stderr?.on("data", (d) => {
+      process.stderr.write(`${prefix} ${d}`);
+    });
+  } else {
+    child.stdout?.resume();
+    child.stderr?.resume();
+  }
+  const ready = await waitForHealth(url);
+  if (!ready) {
+    child.kill("SIGTERM");
+    throw new Error(`Inspector failed to come up on ${url} within 15s.`);
+  }
+  return { url, child };
+}
+function killChild(child) {
+  if (!child || child.killed) return;
+  try {
+    child.kill("SIGTERM");
+  } catch {
+  }
+}
+function timestampSuffix(date = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const datePart = `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+  const timePart = `${pad(date.getHours())}-${pad(date.getMinutes())}-${pad(date.getSeconds())}`;
+  return `${datePart}_${timePart}`;
+}
+function extractViewName(resourceUri) {
+  const m = resourceUri.match(/^ui:\/\/widget\/(.+)$/);
+  if (!m) return resourceUri;
+  return m[1].replace(/\.html$/, "").replace(/\.[0-9a-f]+$/i, "");
+}
+function parseDimension(raw, name) {
+  const n = parseInt(raw, 10);
+  if (!Number.isFinite(n) || n <= 0) {
+    throw new Error(`--${name} must be a positive integer (got "${raw}")`);
+  }
+  return n;
+}
+var AD_HOC_SESSION_NAME = "__screenshot_ad_hoc__";
+async function resolveSessionForScreenshot(options, headers) {
+  if (options.session) {
+    const result = await getOrRestoreSession(options.session);
+    return result?.session ?? null;
+  }
+  if (options.mcp) {
+    const client = new MCPClient2();
+    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 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);
   }
-}
-function getCliClientInfo() {
-  return {
-    name: "mcp-use CLI",
-    title: "mcp-use CLI",
-    version: getPackageVersion(),
-    description: "mcp-use CLI - Command-line interface for MCP servers",
-    icons: [
-      {
-        src: "https://manufact.com/logo.png"
-      }
-    ],
-    websiteUrl: "https://manufact.com"
-  };
-}
-async function connectCommand(urlOrCommand, options) {
   try {
-    const sessionName = options.name || `session-${Date.now()}`;
-    const client = new MCPClient();
+    const client = new MCPClient3();
     let session;
     const cliClientInfo = getCliClientInfo();
     if (options.stdio) {
-      const parts = urlOrCommand.split(" ");
+      const parts = target.split(" ");
       const command = parts[0];
       const args = parts.slice(1);
       console.error(
@@ -2270,17 +3542,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()
       });
     }
@@ -2290,7 +3586,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:"));
@@ -2316,119 +3612,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);
@@ -2437,7 +3787,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("");
@@ -2451,94 +3801,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);
@@ -2549,13 +3972,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}`));
@@ -2573,13 +3999,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}`));
@@ -2587,53 +4015,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}'...`));
@@ -2655,12 +4106,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"));
@@ -2683,15 +4135,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 = createInterface({
+    const rl = createInterface2({
       input: process.stdin,
       output: process.stdout,
       prompt: source_default.cyan("mcp> ")
@@ -2706,7 +4154,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];
@@ -2806,22 +4254,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"
             )
           );
         }
@@ -2830,58 +4266,93 @@ 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 Command("client").description(
-    "Interactive MCP client for terminal usage"
+  const clientCommand = new Command2("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 Command2(`mcp-use client ${name}`).description(`Commands for server '${name}'`).showHelpAfterError(
+    `(Run \`mcp-use client ${name} --help\` to see available commands)`
+  );
+  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 Command2("tools").description("Interact with MCP tools").showHelpAfterError(
+    `(Run \`mcp-use client ${name} tools --help\` to see available actions)`
   );
-  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 Command("sessions").description(
-    "Manage CLI sessions"
+  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)
   );
-  sessionsCommand.command("list").description("List all saved sessions").action(listSessionsCommand);
-  sessionsCommand.command("switch <name>").description("Switch to a different session").action(switchSessionCommand);
-  clientCommand.addCommand(sessionsCommand);
-  const toolsCommand = new Command("tools").description(
-    "Interact with MCP tools"
+  toolsCommand.command("describe <tool>").description("Show tool details and schema").action((tool) => describeToolCommand(name, tool));
+  cmd.addCommand(toolsCommand);
+  const resourcesCommand = new Command2("resources").description("Interact with MCP resources").showHelpAfterError(
+    `(Run \`mcp-use client ${name} resources --help\` to see available actions)`
   );
-  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 Command("resources").description(
-    "Interact with MCP resources"
+  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 Command2("prompts").description("Interact with MCP prompts").showHelpAfterError(
+    `(Run \`mcp-use client ${name} prompts --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 Command("prompts").description(
-    "Interact with MCP prompts"
+  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)
   );
-  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;
+  cmd.addCommand(promptsCommand);
+  const authCommand = new Command2("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
 import { promises as fs9 } from "fs";
-import path5 from "path";
+import path8 from "path";
 
 // src/utils/git.ts
 import { execFile as execFile7 } from "child_process";
@@ -3036,15 +4507,15 @@ function getMcpServerUrlForCloudServer(server) {
 
 // src/utils/project-link.ts
 import { promises as fs8 } from "fs";
-import path4 from "path";
+import path7 from "path";
 var MCP_USE_DIR = ".mcp-use";
 var MCP_USE_DIR_PROJECT = "project.json";
 function getMcpUseDirectory(cwd) {
-  return path4.join(cwd, MCP_USE_DIR);
+  return path7.join(cwd, MCP_USE_DIR);
 }
 async function getProjectLink(cwd) {
   try {
-    const linkPath = path4.join(getMcpUseDirectory(cwd), MCP_USE_DIR_PROJECT);
+    const linkPath = path7.join(getMcpUseDirectory(cwd), MCP_USE_DIR_PROJECT);
     const content = await fs8.readFile(linkPath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
@@ -3055,12 +4526,12 @@ async function getProjectLink(cwd) {
 async function saveProjectLink(cwd, link) {
   const mcpUseDir = getMcpUseDirectory(cwd);
   await fs8.mkdir(mcpUseDir, { recursive: true });
-  const linkPath = path4.join(mcpUseDir, MCP_USE_DIR_PROJECT);
+  const linkPath = path7.join(mcpUseDir, MCP_USE_DIR_PROJECT);
   await fs8.writeFile(linkPath, JSON.stringify(link, null, 2), "utf-8");
   await addToGitIgnore(cwd);
 }
 async function addToGitIgnore(cwd) {
-  const gitignorePath = path4.join(cwd, ".gitignore");
+  const gitignorePath = path7.join(cwd, ".gitignore");
   try {
     let content = "";
     try {
@@ -3201,7 +4672,7 @@ async function buildEnvVars(options) {
 }
 async function isMcpProject(cwd = process.cwd()) {
   try {
-    const content = await fs9.readFile(path5.join(cwd, "package.json"), "utf-8");
+    const content = await fs9.readFile(path8.join(cwd, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     return !!(pkg.dependencies?.["mcp-use"] || pkg.dependencies?.["@modelcontextprotocol/sdk"] || pkg.devDependencies?.["mcp-use"] || pkg.devDependencies?.["@modelcontextprotocol/sdk"]);
   } catch {
@@ -3210,16 +4681,16 @@ async function isMcpProject(cwd = process.cwd()) {
 }
 async function getProjectName(cwd = process.cwd()) {
   try {
-    const content = await fs9.readFile(path5.join(cwd, "package.json"), "utf-8");
+    const content = await fs9.readFile(path8.join(cwd, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     if (pkg.name) return pkg.name;
   } catch {
   }
-  return path5.basename(cwd);
+  return path8.basename(cwd);
 }
 async function detectBuildCommand(cwd) {
   try {
-    const content = await fs9.readFile(path5.join(cwd, "package.json"), "utf-8");
+    const content = await fs9.readFile(path8.join(cwd, "package.json"), "utf-8");
     if (JSON.parse(content).scripts?.build) return "npm run build";
   } catch {
   }
@@ -3227,7 +4698,7 @@ async function detectBuildCommand(cwd) {
 }
 async function detectStartCommand(cwd) {
   try {
-    const content = await fs9.readFile(path5.join(cwd, "package.json"), "utf-8");
+    const content = await fs9.readFile(path8.join(cwd, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     if (pkg.scripts?.start) return "npm start";
     if (pkg.main) return `node ${pkg.main}`;
@@ -3238,7 +4709,7 @@ async function detectStartCommand(cwd) {
 async function detectRuntime(cwd) {
   for (const f of ["requirements.txt", "pyproject.toml", "setup.py"]) {
     try {
-      await fs9.access(path5.join(cwd, f));
+      await fs9.access(path8.join(cwd, f));
       return "python";
     } catch {
       continue;
@@ -3285,7 +4756,7 @@ var REQUIRED_IGNORES = [
   ".mcp-use"
 ];
 async function ensureGitignore(cwd) {
-  const gitignorePath = path5.join(cwd, ".gitignore");
+  const gitignorePath = path8.join(cwd, ".gitignore");
   let content = "";
   try {
     content = await fs9.readFile(gitignorePath, "utf-8");
@@ -3745,7 +5216,7 @@ async function deployCommand(options) {
     console.log(source_default.green("\u2713 GitHub connected\n"));
     let installationDbId;
     let githubInstallationId;
-    const projectDir = options.rootDir ? path5.resolve(cwd, options.rootDir) : cwd;
+    const projectDir = options.rootDir ? path8.resolve(cwd, options.rootDir) : cwd;
     if (options.rootDir) {
       try {
         await fs9.access(projectDir);
@@ -4257,7 +5728,7 @@ async function deployCommand(options) {
 }
 
 // src/commands/deployments.ts
-import { Command as Command2 } from "commander";
+import { Command as Command3 } from "commander";
 async function prompt2(question) {
   const readline = await import("readline");
   const rl = readline.createInterface({
@@ -4669,8 +6140,8 @@ async function startDeploymentCommand(deploymentId) {
   }
 }
 function createDeploymentsCommand() {
-  const deploymentsCommand = new Command2("deployments").description(
-    "Manage cloud deployments"
+  const deploymentsCommand = new Command3("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);
@@ -4685,10 +6156,10 @@ function createDeploymentsCommand() {
 }
 
 // src/commands/servers.ts
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 
 // src/commands/env.ts
-import { Command as Command3 } from "commander";
+import { Command as Command4 } from "commander";
 var ALL_ENVS = ["production", "preview", "development"];
 function parseEnvironments(raw) {
   const parts = raw.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
@@ -4833,9 +6304,7 @@ async function removeEnvCommand(varId, options) {
   }
 }
 function createEnvCommand() {
-  const envCommand = new Command3("env").description(
-    "Manage environment variables for a server"
-  );
+  const envCommand = new Command4("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>",
@@ -5117,8 +6586,8 @@ async function deleteServerCommand(serverId, options) {
   }
 }
 function createServersCommand() {
-  const serversCommand = new Command4("servers").description(
-    "Manage cloud servers (Git-backed deploy targets)"
+  const serversCommand = new Command5("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);
@@ -5235,8 +6704,8 @@ async function orgCurrentCommand() {
 }
 
 // src/commands/skills.ts
-import { Command as Command5 } from "commander";
-import { cpSync, existsSync as existsSync2, mkdtempSync, readdirSync, rmSync } from "fs";
+import { Command as Command6 } from "commander";
+import { cpSync, existsSync as existsSync3, mkdtempSync as mkdtempSync2, readdirSync, rmSync as rmSync2 } from "fs";
 import { tmpdir } from "os";
 import { join as join2, resolve } from "path";
 import { Readable } from "stream";
@@ -5275,7 +6744,7 @@ function sendInstallTelemetryEvent(agents, skills) {
 }
 async function addSkillsToProject(projectPath) {
   const tarballUrl = `https://codeload.github.com/${REPO_OWNER}/${REPO_NAME}/tar.gz/${REPO_BRANCH}`;
-  const tempDir = mkdtempSync(join2(tmpdir(), "mcp-use-skills-"));
+  const tempDir = mkdtempSync2(join2(tmpdir(), "mcp-use-skills-"));
   try {
     const response = await fetch(tarballUrl);
     if (!response.ok) {
@@ -5285,12 +6754,12 @@ async function addSkillsToProject(projectPath) {
       Readable.fromWeb(response.body),
       extract({
         cwd: tempDir,
-        filter: (path9) => path9.includes("/skills/"),
+        filter: (path12) => path12.includes("/skills/"),
         strip: 1
       })
     );
     const skillsPath = join2(tempDir, "skills");
-    if (!existsSync2(skillsPath)) {
+    if (!existsSync3(skillsPath)) {
       throw new Error("Skills folder not found in repository");
     }
     for (const preset of ALL_PRESETS) {
@@ -5301,16 +6770,16 @@ async function addSkillsToProject(projectPath) {
     const skillNames = readdirSync(skillsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     sendInstallTelemetryEvent(ALL_PRESETS.join(","), skillNames.join(","));
   } finally {
-    rmSync(tempDir, { recursive: true, force: true });
+    rmSync2(tempDir, { recursive: true, force: true });
   }
 }
 function createSkillsCommand() {
-  const skills = new Command5("skills").description(
-    "Manage mcp-use AI agent skills"
+  const skills = new Command6("skills").description("Manage mcp-use AI agent skills").showHelpAfterError(
+    "(Run `mcp-use skills --help` to see available commands)"
   );
   const installAction = async (options) => {
     const projectPath = resolve(options.path);
-    if (!existsSync2(projectPath)) {
+    if (!existsSync3(projectPath)) {
       console.error(source_default.red(`Directory not found: ${projectPath}`));
       process.exit(1);
     }
@@ -5351,12 +6820,12 @@ function createSkillsCommand() {
 }
 
 // src/utils/next-shims.ts
-import { existsSync as existsSync3, promises as fs10 } from "fs";
-import path6 from "path";
+import { existsSync as existsSync4, promises as fs10 } from "fs";
+import path9 from "path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
 async function detectNextJsProject(projectPath) {
   try {
-    const pkgPath = path6.join(projectPath, "package.json");
+    const pkgPath = path9.join(projectPath, "package.json");
     const content = await fs10.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     const deps = pkg.dependencies ?? {};
@@ -5375,7 +6844,7 @@ async function loadNextJsEnvFiles(projectPath) {
   ];
   const dotenv = await import("dotenv");
   for (const file of files) {
-    const abs = path6.join(projectPath, file);
+    const abs = path9.join(projectPath, file);
     try {
       await fs10.access(abs);
     } catch {
@@ -5387,20 +6856,20 @@ async function loadNextJsEnvFiles(projectPath) {
 function getThisDir() {
   if (typeof __dirname === "string") return __dirname;
   const url = import.meta.url;
-  return path6.dirname(fileURLToPath3(url));
+  return path9.dirname(fileURLToPath3(url));
 }
 function resolveShimPath(filename) {
   const thisDir = getThisDir();
   const candidates = [
     // Production: `dist/` next to this module
-    path6.join(thisDir, "shims", filename),
+    path9.join(thisDir, "shims", filename),
     // Test / dev: one level up (e.g., from `dist/utils/` back to `src/shims/`)
-    path6.join(thisDir, "..", "shims", filename),
-    path6.join(thisDir, "..", "..", "src", "shims", filename),
-    path6.join(thisDir, "..", "src", "shims", filename)
+    path9.join(thisDir, "..", "shims", filename),
+    path9.join(thisDir, "..", "..", "src", "shims", filename),
+    path9.join(thisDir, "..", "src", "shims", filename)
   ];
   for (const candidate of candidates) {
-    if (existsSync3(candidate)) return candidate;
+    if (existsSync4(candidate)) return candidate;
   }
   return void 0;
 }
@@ -5418,7 +6887,7 @@ async function registerNextShimsInProcess() {
   const cjsPath = getShimCjsPreloadPath();
   if (cjsPath) {
     const { createRequire: createRequire3 } = await import("module");
-    const req = createRequire3(pathToFileURL(getThisDir() + path6.sep).href);
+    const req = createRequire3(pathToFileURL(getThisDir() + path9.sep).href);
     req(cjsPath);
     anyRegistered = true;
   }
@@ -5426,7 +6895,7 @@ async function registerNextShimsInProcess() {
   if (loaderPath) {
     const { register } = await import("module");
     const loaderUrl = pathToFileURL(loaderPath).href;
-    register(loaderUrl, pathToFileURL(getThisDir() + path6.sep).href);
+    register(loaderUrl, pathToFileURL(getThisDir() + path9.sep).href);
     anyRegistered = true;
   }
   return anyRegistered;
@@ -5452,12 +6921,12 @@ function quoteNodeOption(value) {
 
 // src/utils/update-check.ts
 import { readFileSync } from "fs";
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { createRequire } from "module";
-import os4 from "os";
-import path7 from "path";
-var CACHE_DIR = path7.join(os4.homedir(), ".mcp-use");
-var CACHE_FILE = path7.join(CACHE_DIR, "update-check.json");
+import os5 from "os";
+import path10 from "path";
+var CACHE_DIR = path10.join(os5.homedir(), ".mcp-use");
+var CACHE_FILE = path10.join(CACHE_DIR, "update-check.json");
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 3e3;
 var PACKAGE_NAME = "mcp-use";
@@ -5490,7 +6959,7 @@ async function readCache() {
 }
 async function writeCache(latestVersion) {
   try {
-    await mkdir2(CACHE_DIR, { recursive: true });
+    await mkdir3(CACHE_DIR, { recursive: true });
     const cache = {
       lastChecked: (/* @__PURE__ */ new Date()).toISOString(),
       latestVersion
@@ -5540,12 +7009,12 @@ function resolveInstalledVersion(projectPath) {
   if (projectPath) {
     attempts.push(() => {
       const projectRequire = createRequire(
-        path7.join(projectPath, "package.json")
+        path10.join(projectPath, "package.json")
       );
       return projectRequire.resolve(`${PACKAGE_NAME}/package.json`);
     });
   }
-  attempts.push(() => path7.join(__dirname, "../../mcp-use/package.json"));
+  attempts.push(() => path10.join(__dirname, "../../mcp-use/package.json"));
   for (const attempt of attempts) {
     try {
       const pkgPath = attempt();
@@ -5581,14 +7050,14 @@ A new release of ${source_default.bold(PACKAGE_NAME)} is available: ${source_def
 }
 
 // src/index.ts
-var program = new Command6();
+var program = new Command7();
 var packageContent = readFileSync2(
-  path8.join(__dirname, "../package.json"),
+  path11.join(__dirname, "../package.json"),
   "utf-8"
 );
 var packageJson = JSON.parse(packageContent);
 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" },
@@ -5614,14 +7083,14 @@ function displayPackageVersions(projectPath) {
       if (projectPath) {
         try {
           const projectRequire = createRequire2(
-            path8.join(projectPath, "package.json")
+            path11.join(projectPath, "package.json")
           );
           pkgPath = projectRequire.resolve(`${pkg.name}/package.json`);
         } catch (resolveError) {
-          pkgPath = path8.join(__dirname, pkg.relativePath);
+          pkgPath = path11.join(__dirname, pkg.relativePath);
         }
       } else {
-        pkgPath = path8.join(__dirname, pkg.relativePath);
+        pkgPath = path11.join(__dirname, pkg.relativePath);
       }
       const pkgContent = readFileSync2(pkgPath, "utf-8");
       const pkgJson = JSON.parse(pkgContent);
@@ -5678,7 +7147,7 @@ function normalizeBrowserHost(host) {
   return host === "0.0.0.0" ? "localhost" : host;
 }
 function runCommand(command, args, cwd, env2, filterStderr = false) {
-  const proc = spawn(command, args, {
+  const proc = spawn3(command, args, {
     cwd,
     stdio: filterStderr ? ["inherit", "inherit", "pipe"] : "inherit",
     shell: process.platform === "win32",
@@ -5711,7 +7180,7 @@ async function startTunnel(port, subdomain) {
     if (subdomain) {
       tunnelArgs.push("--subdomain", subdomain);
     }
-    const proc = spawn("npx", tunnelArgs, {
+    const proc = spawn3("npx", tunnelArgs, {
       stdio: ["ignore", "pipe", "pipe"],
       shell: process.platform === "win32"
     });
@@ -5775,21 +7244,21 @@ async function startTunnel(port, subdomain) {
 }
 async function resolveEntryFile(projectPath, cliEntry, mcpDir) {
   if (cliEntry) {
-    await access(path8.join(projectPath, cliEntry)).catch(() => {
+    await access(path11.join(projectPath, cliEntry)).catch(() => {
       throw new Error(`File not found: ${cliEntry}`);
     });
     return cliEntry;
   }
   if (mcpDir) {
     const mcpCandidates = [
-      path8.join(mcpDir, "index.ts"),
-      path8.join(mcpDir, "index.tsx"),
-      path8.join(mcpDir, "server.ts"),
-      path8.join(mcpDir, "server.tsx")
+      path11.join(mcpDir, "index.ts"),
+      path11.join(mcpDir, "index.tsx"),
+      path11.join(mcpDir, "server.ts"),
+      path11.join(mcpDir, "server.tsx")
     ];
     for (const candidate of mcpCandidates) {
       try {
-        await access(path8.join(projectPath, candidate));
+        await access(path11.join(projectPath, candidate));
         return candidate;
       } catch {
         continue;
@@ -5798,17 +7267,17 @@ async function resolveEntryFile(projectPath, cliEntry, mcpDir) {
     throw new Error(
       `No entry file found inside ${mcpDir}.
 
-Expected one of: ${mcpCandidates.map((c) => path8.relative(projectPath, path8.join(projectPath, c))).join(", ")}
+Expected one of: ${mcpCandidates.map((c) => path11.relative(projectPath, path11.join(projectPath, c))).join(", ")}
 
 Fix this by either:
-  1. Creating ${path8.join(mcpDir, "index.ts")}, or
+  1. Creating ${path11.join(mcpDir, "index.ts")}, or
   2. Passing --entry <file> on the command line`
     );
   }
   const candidates = ["index.ts", "src/index.ts", "server.ts", "src/server.ts"];
   for (const candidate of candidates) {
     try {
-      await access(path8.join(projectPath, candidate));
+      await access(path11.join(projectPath, candidate));
       return candidate;
     } catch {
       continue;
@@ -5826,7 +7295,7 @@ Fix this by either:
 }
 function resolveWidgetsDir(cliWidgetsDir, mcpDir) {
   if (cliWidgetsDir) return cliWidgetsDir;
-  if (mcpDir) return path8.join(mcpDir, "resources");
+  if (mcpDir) return path11.join(mcpDir, "resources");
   return "resources";
 }
 function makeWidgetServerOnlyGuard(widgetName) {
@@ -5861,7 +7330,7 @@ function isBunRuntime() {
   return typeof globalThis.Bun !== "undefined" || typeof process.versions.bun === "string";
 }
 async function generateToolRegistryTypesForServer(projectPath, serverFileRelative) {
-  const serverFile = path8.join(projectPath, serverFileRelative);
+  const serverFile = path11.join(projectPath, serverFileRelative);
   const serverFileExists = await access(serverFile).then(() => true).catch(() => false);
   if (!serverFileExists) {
     throw new Error(`Server file not found: ${serverFile}`);
@@ -5887,7 +7356,7 @@ async function generateToolRegistryTypesForServer(projectPath, serverFileRelativ
       await loadNextJsEnvFiles(projectPath);
       await registerNextShimsInProcess();
     }
-    const projectTsconfigPath = path8.join(projectPath, "tsconfig.json");
+    const projectTsconfigPath = path11.join(projectPath, "tsconfig.json");
     const hasTsconfig = await access(projectTsconfigPath).then(() => true).catch(() => false);
     if (hasTsconfig) {
       process.env.TSX_TSCONFIG_PATH = projectTsconfigPath;
@@ -5896,7 +7365,7 @@ async function generateToolRegistryTypesForServer(projectPath, serverFileRelativ
     if (previousCwd !== projectPath) process.chdir(projectPath);
     try {
       const projectRequire = createRequire2(
-        path8.join(projectPath, "package.json")
+        path11.join(projectPath, "package.json")
       );
       const tsxEsmApiPath = projectRequire.resolve("tsx/esm/api");
       const tsxEsmApi = await import(pathToFileURL2(tsxEsmApiPath).href);
@@ -5923,8 +7392,8 @@ async function generateToolRegistryTypesForServer(projectPath, serverFileRelativ
         "No MCPServer instance found. Make sure your server file creates an MCPServer instance."
       );
     }
-    const mcpUsePath = path8.join(projectPath, "node_modules", "mcp-use");
-    const { generateToolRegistryTypes } = await import(pathToFileURL2(path8.join(mcpUsePath, "dist", "src", "server", "index.js")).href).then((mod) => mod);
+    const mcpUsePath = path11.join(projectPath, "node_modules", "mcp-use");
+    const { generateToolRegistryTypes } = await import(pathToFileURL2(path11.join(mcpUsePath, "dist", "src", "server", "index.js")).href).then((mod) => mod);
     if (!generateToolRegistryTypes) {
       throw new Error("generateToolRegistryTypes not found in mcp-use package");
     }
@@ -5942,7 +7411,7 @@ async function buildWidgets(projectPath, options = {}) {
   const { promises: fs11 } = await import("fs");
   const { build } = await import("vite");
   const widgetsDirRelative = options.widgetsDir ?? "resources";
-  const resourcesDir = path8.resolve(projectPath, widgetsDirRelative);
+  const resourcesDir = path11.resolve(projectPath, widgetsDirRelative);
   const mcpUrl = process.env.MCP_URL;
   try {
     await access(resourcesDir);
@@ -5964,10 +7433,10 @@ async function buildWidgets(projectPath, options = {}) {
       if (dirent.isFile() && (dirent.name.endsWith(".tsx") || dirent.name.endsWith(".ts"))) {
         entries.push({
           name: dirent.name.replace(/\.tsx?$/, ""),
-          path: path8.join(resourcesDir, dirent.name)
+          path: path11.join(resourcesDir, dirent.name)
         });
       } else if (dirent.isDirectory()) {
-        const widgetPath = path8.join(resourcesDir, dirent.name, "widget.tsx");
+        const widgetPath = path11.join(resourcesDir, dirent.name, "widget.tsx");
         try {
           await fs11.access(widgetPath);
           entries.push({
@@ -5997,14 +7466,14 @@ async function buildWidgets(projectPath, options = {}) {
   );
   const react = (await import("@vitejs/plugin-react")).default;
   const tailwindcss = (await import("@tailwindcss/vite")).default;
-  const projectTsconfigPath = path8.join(projectPath, "tsconfig.json");
+  const projectTsconfigPath = path11.join(projectPath, "tsconfig.json");
   let hasProjectTsconfig = false;
   try {
     await access(projectTsconfigPath);
     hasProjectTsconfig = true;
   } catch {
   }
-  const packageJsonPath = path8.join(projectPath, "package.json");
+  const packageJsonPath = path11.join(projectPath, "package.json");
   let favicon = "";
   try {
     const pkgContent = await fs11.readFile(packageJsonPath, "utf-8");
@@ -6016,16 +7485,16 @@ async function buildWidgets(projectPath, options = {}) {
     const widgetName = entry.name;
     const entryPath = entry.path.replace(/\\/g, "/");
     console.log(source_default.gray(`  - Building ${widgetName}...`));
-    const tempDir = path8.join(projectPath, ".mcp-use", widgetName);
+    const tempDir = path11.join(projectPath, ".mcp-use", widgetName);
     await fs11.mkdir(tempDir, { recursive: true });
-    const relativeResourcesPath = path8.relative(tempDir, resourcesDir).replace(/\\/g, "/");
-    const mcpUsePath = path8.join(projectPath, "node_modules", "mcp-use");
-    const relativeMcpUsePath = path8.relative(tempDir, mcpUsePath).replace(/\\/g, "/");
-    const projectSrcDir = path8.join(projectPath, "src");
+    const relativeResourcesPath = path11.relative(tempDir, resourcesDir).replace(/\\/g, "/");
+    const mcpUsePath = path11.join(projectPath, "node_modules", "mcp-use");
+    const relativeMcpUsePath = path11.relative(tempDir, mcpUsePath).replace(/\\/g, "/");
+    const projectSrcDir = path11.join(projectPath, "src");
     let projectSrcSourceLine = "";
     try {
       await access(projectSrcDir);
-      const relativeProjectSrcPath = path8.relative(tempDir, projectSrcDir).replace(/\\/g, "/");
+      const relativeProjectSrcPath = path11.relative(tempDir, projectSrcDir).replace(/\\/g, "/");
       projectSrcSourceLine = `@source "${relativeProjectSrcPath}";
 `;
     } catch {
@@ -6036,7 +7505,7 @@ async function buildWidgets(projectPath, options = {}) {
 @source "${relativeResourcesPath}";
 @source "${relativeMcpUsePath}/**/*.{ts,tsx,js,jsx}";
 ${projectSrcSourceLine}`;
-    await fs11.writeFile(path8.join(tempDir, "styles.css"), cssContent, "utf8");
+    await fs11.writeFile(path11.join(tempDir, "styles.css"), cssContent, "utf8");
     const entryContent = `import React from 'react'
 import { createRoot } from 'react-dom/client'
 import './styles.css'
@@ -6061,9 +7530,9 @@ if (container && Component) {
     <script type="module" src="/entry.tsx"></script>
   </body>
 </html>`;
-    await fs11.writeFile(path8.join(tempDir, "entry.tsx"), entryContent, "utf8");
-    await fs11.writeFile(path8.join(tempDir, "index.html"), htmlContent, "utf8");
-    const outDir = path8.join(
+    await fs11.writeFile(path11.join(tempDir, "entry.tsx"), entryContent, "utf8");
+    await fs11.writeFile(path11.join(tempDir, "index.html"), htmlContent, "utf8");
+    const outDir = path11.join(
       projectPath,
       "dist",
       "resources",
@@ -6073,13 +7542,13 @@ if (container && Component) {
     const baseUrl = mcpUrl ? `${mcpUrl}/${widgetName}/` : `/mcp-use/widgets/${widgetName}/`;
     let widgetMetadata = {};
     try {
-      const metadataTempDir = path8.join(
+      const metadataTempDir = path11.join(
         projectPath,
         ".mcp-use",
         `${widgetName}-metadata`
       );
       await fs11.mkdir(metadataTempDir, { recursive: true });
-      const { createServer } = await import("vite");
+      const { createServer: createServer2 } = await import("vite");
       const nodeStubsPlugin = {
         name: "node-stubs",
         enforce: "pre",
@@ -6107,9 +7576,9 @@ export default PostHog;
         }
       };
       const serverOnlyGuard = makeWidgetServerOnlyGuard(widgetName);
-      const metadataServer = await createServer({
+      const metadataServer = await createServer2({
         root: metadataTempDir,
-        cacheDir: path8.join(metadataTempDir, ".vite-cache"),
+        cacheDir: path11.join(metadataTempDir, ".vite-cache"),
         plugins: [serverOnlyGuard, nodeStubsPlugin, tailwindcss(), react()],
         // When the project has a tsconfig, enable Vite's native tsconfig-paths
         // resolver so `@/*` (or any custom alias) resolves through the
@@ -6340,7 +7809,7 @@ export default {
             // Inline all assets under 100MB (effectively all)
           } : {},
           rolldownOptions: {
-            input: path8.join(tempDir, "index.html"),
+            input: path11.join(tempDir, "index.html"),
             external: (id) => {
               return false;
             }
@@ -6348,11 +7817,11 @@ export default {
         }
       });
       try {
-        const assetsDir = path8.join(outDir, "assets");
+        const assetsDir = path11.join(outDir, "assets");
         const assetFiles = await fs11.readdir(assetsDir);
         const jsFiles = assetFiles.filter((f) => f.endsWith(".js"));
         for (const jsFile of jsFiles) {
-          const jsPath = path8.join(assetsDir, jsFile);
+          const jsPath = path11.join(assetsDir, jsFile);
           let content = await fs11.readFile(jsPath, "utf8");
           const zodConfigPatterns = [
             // Non-minified: export const globalConfig = {}
@@ -6384,7 +7853,7 @@ export default {
       const mcpServerUrl = process.env.MCP_SERVER_URL;
       if (mcpServerUrl) {
         try {
-          const htmlPath = path8.join(outDir, "index.html");
+          const htmlPath = path11.join(outDir, "index.html");
           let html = await fs11.readFile(htmlPath, "utf8");
           const injectionScript = `<script>window.__getFile = (filename) => { return "${mcpUrl}/${widgetName}/"+filename }; window.__mcpPublicUrl = "${mcpServerUrl}/mcp-use/public"; window.__mcpPublicAssetsUrl = "${mcpUrl}/public";</script>`;
           if (!html.includes("window.__mcpPublicUrl")) {
@@ -6460,7 +7929,7 @@ async function collectTsFiles(projectPath, includePatterns, excludePatterns) {
   for (const file of literalFiles) {
     if (/\.tsx?$/.test(file) && !file.endsWith(".d.ts")) {
       try {
-        await access(path8.join(projectPath, file));
+        await access(path11.join(projectPath, file));
         files.push(file);
       } catch {
       }
@@ -6468,13 +7937,13 @@ async function collectTsFiles(projectPath, includePatterns, excludePatterns) {
   }
   const excludeSet = new Set(excludePatterns.map((e) => e.replace(/\*+/g, "")));
   for (const prefix of dirPrefixes) {
-    const dirPath = path8.join(projectPath, prefix);
+    const dirPath = path11.join(projectPath, prefix);
     try {
       const entries = await fs11.readdir(dirPath, { recursive: true });
       for (const entry of entries) {
         const entryStr = String(entry);
-        const rel = path8.join(prefix, entryStr);
-        if (/\.tsx?$/.test(entryStr) && !entryStr.endsWith(".d.ts") && !excludeSet.has(rel.split(path8.sep)[0])) {
+        const rel = path11.join(prefix, entryStr);
+        if (/\.tsx?$/.test(entryStr) && !entryStr.endsWith(".d.ts") && !excludeSet.has(rel.split(path11.sep)[0])) {
           files.push(rel);
         }
       }
@@ -6486,7 +7955,7 @@ async function collectTsFiles(projectPath, includePatterns, excludePatterns) {
 async function transpileWithEsbuild(projectPath) {
   const esbuild = await import("esbuild");
   const { promises: fs11 } = await import("fs");
-  const tsconfigPath = path8.join(projectPath, "tsconfig.json");
+  const tsconfigPath = path11.join(projectPath, "tsconfig.json");
   let tsconfig = {};
   try {
     const raw = await fs11.readFile(tsconfigPath, "utf-8");
@@ -6516,10 +7985,10 @@ async function transpileWithEsbuild(projectPath) {
   const target = (compilerOptions.target || "ES2022").toLowerCase();
   const moduleStr = (compilerOptions.module || "ESNext").toLowerCase();
   const format = moduleStr.includes("commonjs") ? "cjs" : "esm";
-  const outbase = compilerOptions.rootDir ? path8.resolve(projectPath, compilerOptions.rootDir) : projectPath;
+  const outbase = compilerOptions.rootDir ? path11.resolve(projectPath, compilerOptions.rootDir) : projectPath;
   await esbuild.build({
-    entryPoints: files.map((f) => path8.join(projectPath, f)),
-    outdir: path8.join(projectPath, outDir),
+    entryPoints: files.map((f) => path11.join(projectPath, f)),
+    outdir: path11.join(projectPath, outDir),
     outbase,
     bundle: true,
     packages: "external",
@@ -6546,7 +8015,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
   "Inline all JS/CSS into HTML (required for VS Code MCP Apps)"
 ).option("--no-inline", "Keep JS/CSS as separate files (default)").option("--no-typecheck", "Skip TypeScript type checking (faster builds)").action(async (options) => {
   try {
-    const projectPath = path8.resolve(options.path);
+    const projectPath = path11.resolve(options.path);
     const { promises: fs11 } = await import("fs");
     displayPackageVersions(projectPath);
     const mcpDir = options.mcpDir;
@@ -6606,7 +8075,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
     }
     if (options.typecheck !== false && !mcpDir) {
       console.log(source_default.gray("Type checking..."));
-      const tscBin = path8.join(
+      const tscBin = path11.join(
         projectPath,
         "node_modules",
         "typescript",
@@ -6629,7 +8098,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
       if (mcpDir) {
         entryPoint = sourceServerFile;
       } else {
-        const baseName = path8.basename(sourceServerFile, ".ts") + ".js";
+        const baseName = path11.basename(sourceServerFile, ".ts") + ".js";
         const possibleOutputs = [
           `dist/${baseName}`,
           // rootDir set to project root or src
@@ -6640,7 +8109,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
         ];
         for (const candidate of possibleOutputs) {
           try {
-            await access(path8.join(projectPath, candidate));
+            await access(path11.join(projectPath, candidate));
             entryPoint = candidate;
             break;
           } catch {
@@ -6649,17 +8118,17 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
         }
       }
     }
-    const publicDir = path8.join(projectPath, "public");
+    const publicDir = path11.join(projectPath, "public");
     try {
       await fs11.access(publicDir);
       console.log(source_default.gray("Copying public assets..."));
-      await fs11.cp(publicDir, path8.join(projectPath, "dist", "public"), {
+      await fs11.cp(publicDir, path11.join(projectPath, "dist", "public"), {
         recursive: true
       });
       console.log(source_default.green("\u2713 Public assets copied"));
     } catch {
     }
-    const manifestPath = path8.join(projectPath, "dist", "mcp-use.json");
+    const manifestPath = path11.join(projectPath, "dist", "mcp-use.json");
     let existingManifest = {};
     try {
       const existingContent = await fs11.readFile(manifestPath, "utf-8");
@@ -6684,7 +8153,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
       // Server entry point for `mcp-use start`
       widgets: widgetsData
     };
-    await fs11.mkdir(path8.dirname(manifestPath), { recursive: true });
+    await fs11.mkdir(path11.dirname(manifestPath), { recursive: true });
     await fs11.writeFile(
       manifestPath,
       JSON.stringify(manifest, null, 2),
@@ -6721,7 +8190,7 @@ program.command("dev").description("Run development server with auto-reload and
 ).option("--no-open", "Do not auto-open inspector").option("--no-hmr", "Disable hot module reloading (use tsx watch instead)").option("--tunnel", "Expose server through a tunnel").action(async (options) => {
   try {
     process.env.MCP_USE_CLI_DEV = "1";
-    const projectPath = path8.resolve(options.path);
+    const projectPath = path11.resolve(options.path);
     let port = parseInt(options.port, 10);
     const host = options.host;
     const useHmr = options.hmr !== false;
@@ -6749,7 +8218,7 @@ program.command("dev").description("Run development server with auto-reload and
     let tunnelUrl = void 0;
     if (options.tunnel) {
       try {
-        const manifestPath = path8.join(projectPath, "dist", "mcp-use.json");
+        const manifestPath = path11.join(projectPath, "dist", "mcp-use.json");
         let existingSubdomain;
         try {
           const manifestContent = await readFile3(manifestPath, "utf-8");
@@ -6798,7 +8267,7 @@ program.command("dev").description("Run development server with auto-reload and
             manifest.tunnel = {};
           }
           manifest.tunnel.subdomain = tunnelSubdomain;
-          await mkdir3(path8.dirname(manifestPath), { recursive: true });
+          await mkdir4(path11.dirname(manifestPath), { recursive: true });
           await writeFile3(
             manifestPath,
             JSON.stringify(manifest, null, 2),
@@ -6853,7 +8322,7 @@ program.command("dev").description("Run development server with auto-reload and
       let args;
       try {
         const projectRequire = createRequire4(
-          path8.join(projectPath, "package.json")
+          path11.join(projectPath, "package.json")
         );
         const tsxPkgPath = projectRequire.resolve("tsx/package.json");
         const tsxPkg = JSON.parse(await readFile3(tsxPkgPath, "utf-8"));
@@ -6865,7 +8334,7 @@ program.command("dev").description("Run development server with auto-reload and
         } else {
           throw new Error("No bin field found in tsx package.json");
         }
-        const tsxBin = path8.resolve(path8.dirname(tsxPkgPath), binPath);
+        const tsxBin = path11.resolve(path11.dirname(tsxPkgPath), binPath);
         cmd = "node";
         args = [tsxBin, "watch", serverFile];
       } catch (error) {
@@ -6954,7 +8423,7 @@ program.command("dev").description("Run development server with auto-reload and
     const chokidar = chokidarModule.default || chokidarModule;
     const { fileURLToPath: fileURLToPath4 } = await import("url");
     const { createRequire: createRequire3 } = await import("module");
-    const projectTsconfigPath = path8.join(projectPath, "tsconfig.json");
+    const projectTsconfigPath = path11.join(projectPath, "tsconfig.json");
     let tsconfigAvailable = false;
     try {
       await access(projectTsconfigPath);
@@ -6966,7 +8435,7 @@ program.command("dev").description("Run development server with auto-reload and
     let tsxLoaderActive = false;
     try {
       const projectRequire = createRequire3(
-        path8.join(projectPath, "package.json")
+        path11.join(projectPath, "package.json")
       );
       const tsxEsmApiPath = projectRequire.resolve("tsx/esm/api");
       const tsxEsmApi = await import(pathToFileURL2(tsxEsmApiPath).href);
@@ -6997,7 +8466,7 @@ program.command("dev").description("Run development server with auto-reload and
         )
       );
     }
-    const serverFilePath = path8.join(projectPath, serverFile);
+    const serverFilePath = path11.join(projectPath, serverFile);
     const serverFileUrl = pathToFileURL2(serverFilePath).href;
     globalThis.__mcpUseHmrMode = true;
     const importServerModule = async () => {
@@ -7094,8 +8563,8 @@ program.command("dev").description("Run development server with auto-reload and
     }
     let watcher = chokidar.watch(".", {
       cwd: projectPath,
-      ignored: (path9, stats) => {
-        const normalizedPath = path9.replace(/\\/g, "/");
+      ignored: (path12, stats) => {
+        const normalizedPath = path12.replace(/\\/g, "/");
         if (/(^|\/)\.[^/]/.test(normalizedPath)) {
           return true;
         }
@@ -7269,7 +8738,7 @@ program.command("dev").description("Run development server with auto-reload and
       }
       tunnelUrl = void 0;
       if (withTunnel) {
-        const manifestPath = path8.join(projectPath, "dist", "mcp-use.json");
+        const manifestPath = path11.join(projectPath, "dist", "mcp-use.json");
         let existingSubdomain;
         try {
           const manifestContent = await readFile3(manifestPath, "utf-8");
@@ -7306,7 +8775,7 @@ program.command("dev").description("Run development server with auto-reload and
         tunnelSubdomain = tunnelInfo.subdomain;
         process.env.MCP_URL = tunnelUrl;
         try {
-          const mPath = path8.join(projectPath, "dist", "mcp-use.json");
+          const mPath = path11.join(projectPath, "dist", "mcp-use.json");
           let manifest = {};
           try {
             manifest = JSON.parse(await readFile3(mPath, "utf-8"));
@@ -7314,7 +8783,7 @@ program.command("dev").description("Run development server with auto-reload and
           }
           if (!manifest.tunnel) manifest.tunnel = {};
           manifest.tunnel.subdomain = tunnelSubdomain;
-          await mkdir3(path8.dirname(mPath), { recursive: true });
+          await mkdir4(path11.dirname(mPath), { recursive: true });
           await writeFile3(mPath, JSON.stringify(manifest, null, 2), "utf-8");
         } catch {
         }
@@ -7418,7 +8887,7 @@ program.command("start").description("Start production server").option("-p, --pa
   "Folder holding the MCP entry + resources (e.g. 'src/mcp' for Next.js apps)"
 ).option("--port <port>", "Server port", "3000").option("--tunnel", "Expose server through a tunnel").action(async (options) => {
   try {
-    const projectPath = path8.resolve(options.path);
+    const projectPath = path11.resolve(options.path);
     const portFlagProvided = process.argv.includes("--port") || process.argv.includes("-p") || process.argv.some((arg) => arg.startsWith("--port=")) || process.argv.some((arg) => arg.startsWith("-p="));
     let port = portFlagProvided ? parseInt(options.port, 10) : parseInt(process.env.PORT || options.port || "3000", 10);
     if (!await isPortAvailable(port)) {
@@ -7436,7 +8905,7 @@ program.command("start").description("Start production server").option("-p, --pa
     let tunnelSubdomain = void 0;
     if (options.tunnel) {
       try {
-        const manifestPath2 = path8.join(projectPath, "dist", "mcp-use.json");
+        const manifestPath2 = path11.join(projectPath, "dist", "mcp-use.json");
         let existingSubdomain;
         try {
           const manifestContent = await readFile3(manifestPath2, "utf-8");
@@ -7491,7 +8960,7 @@ program.command("start").description("Start production server").option("-p, --pa
             manifest.tunnel = {};
           }
           manifest.tunnel.subdomain = subdomain;
-          await mkdir3(path8.dirname(manifestPath2), { recursive: true });
+          await mkdir4(path11.dirname(manifestPath2), { recursive: true });
           await writeFile3(
             manifestPath2,
             JSON.stringify(manifest, null, 2),
@@ -7510,12 +8979,12 @@ program.command("start").description("Start production server").option("-p, --pa
       }
     }
     let serverFile;
-    const manifestPath = path8.join(projectPath, "dist", "mcp-use.json");
+    const manifestPath = path11.join(projectPath, "dist", "mcp-use.json");
     try {
       const manifestContent = await readFile3(manifestPath, "utf-8");
       const manifest = JSON.parse(manifestContent);
       if (manifest.entryPoint) {
-        await access(path8.join(projectPath, manifest.entryPoint));
+        await access(path11.join(projectPath, manifest.entryPoint));
         serverFile = manifest.entryPoint;
       }
     } catch {
@@ -7536,7 +9005,7 @@ program.command("start").description("Start production server").option("-p, --pa
       ];
       for (const candidate of serverCandidates) {
         try {
-          await access(path8.join(projectPath, candidate));
+          await access(path11.join(projectPath, candidate));
           serverFile = candidate;
           break;
         } catch {
@@ -7587,13 +9056,13 @@ Looked for:
     if (isTsEntry) {
       try {
         const projectRequire = createRequire2(
-          path8.join(projectPath, "package.json")
+          path11.join(projectPath, "package.json")
         );
         const tsxPkgPath = projectRequire.resolve("tsx/package.json");
         const tsxPkg = JSON.parse(await readFile3(tsxPkgPath, "utf-8"));
         const binField = typeof tsxPkg.bin === "string" ? tsxPkg.bin : tsxPkg.bin?.tsx ?? Object.values(tsxPkg.bin ?? {})[0];
         if (!binField) throw new Error("tsx bin entry not found");
-        const tsxBin = path8.resolve(path8.dirname(tsxPkgPath), binField);
+        const tsxBin = path11.resolve(path11.dirname(tsxPkgPath), binField);
         spawnCmd = "node";
         spawnArgs = [tsxBin, serverFile];
       } catch (error) {
@@ -7606,7 +9075,7 @@ Looked for:
         spawnArgs = ["tsx", serverFile];
       }
     }
-    const serverProc = spawn(spawnCmd, spawnArgs, {
+    const serverProc = spawn3(spawnCmd, spawnArgs, {
       cwd: projectPath,
       stdio: "inherit",
       env: env2
@@ -7739,10 +9208,11 @@ program.addCommand(createClientCommand());
 program.addCommand(createDeploymentsCommand());
 program.addCommand(createServersCommand());
 program.addCommand(createSkillsCommand());
+program.addCommand(createScreenshotCommand());
 program.command("generate-types").description(
   "Generate TypeScript type definitions for tools (writes .mcp-use/tool-registry.d.ts)"
 ).option("-p, --path <path>", "Path to project directory", process.cwd()).option("--server <file>", "Server entry file", "index.ts").action(async (options) => {
-  const projectPath = path8.resolve(options.path);
+  const projectPath = path11.resolve(options.path);
   try {
     console.log(source_default.blue("Generating tool registry types..."));
     const result = await generateToolRegistryTypesForServer(
@@ -7772,5 +9242,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.js.map