@modelcontextprotocol/inspector 0.10.1 → 0.11.0

package/cli/build/cli.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import fs from "node:fs";
+import path from "node:path";
+import { dirname, resolve } from "path";
+import { spawnPromise } from "spawn-rx";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function handleError(error) {
+    let message;
+    if (error instanceof Error) {
+        message = error.message;
+    }
+    else if (typeof error === "string") {
+        message = error;
+    }
+    else {
+        message = "Unknown error";
+    }
+    console.error(message);
+    process.exit(1);
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms, true));
+}
+async function runWebClient(args) {
+    const inspectorServerPath = resolve(__dirname, "../../", "server", "build", "index.js");
+    // Path to the client entry point
+    const inspectorClientPath = resolve(__dirname, "../../", "client", "bin", "client.js");
+    const CLIENT_PORT = process.env.CLIENT_PORT ?? "6274";
+    const SERVER_PORT = process.env.SERVER_PORT ?? "6277";
+    console.log("Starting MCP inspector...");
+    const abort = new AbortController();
+    let cancelled = false;
+    process.on("SIGINT", () => {
+        cancelled = true;
+        abort.abort();
+    });
+    let server;
+    let serverOk;
+    try {
+        server = spawnPromise("node", [
+            inspectorServerPath,
+            ...(args.command ? [`--env`, args.command] : []),
+            ...(args.args ? [`--args=${args.args.join(" ")}`] : []),
+        ], {
+            env: {
+                ...process.env,
+                PORT: SERVER_PORT,
+                MCP_ENV_VARS: JSON.stringify(args.envArgs),
+            },
+            signal: abort.signal,
+            echoOutput: true,
+        });
+        // Make sure server started before starting client
+        serverOk = await Promise.race([server, delay(2 * 1000)]);
+    }
+    catch (error) { }
+    if (serverOk) {
+        try {
+            await spawnPromise("node", [inspectorClientPath], {
+                env: { ...process.env, PORT: CLIENT_PORT },
+                signal: abort.signal,
+                echoOutput: true,
+            });
+        }
+        catch (e) {
+            if (!cancelled || process.env.DEBUG)
+                throw e;
+        }
+    }
+}
+async function runCli(args) {
+    const projectRoot = resolve(__dirname, "..");
+    const cliPath = resolve(projectRoot, "build", "index.js");
+    const abort = new AbortController();
+    let cancelled = false;
+    process.on("SIGINT", () => {
+        cancelled = true;
+        abort.abort();
+    });
+    try {
+        await spawnPromise("node", [cliPath, args.command, ...args.args], {
+            env: { ...process.env, ...args.envArgs },
+            signal: abort.signal,
+            echoOutput: true,
+        });
+    }
+    catch (e) {
+        if (!cancelled || process.env.DEBUG) {
+            throw e;
+        }
+    }
+}
+function loadConfigFile(configPath, serverName) {
+    try {
+        const resolvedConfigPath = path.isAbsolute(configPath)
+            ? configPath
+            : path.resolve(process.cwd(), configPath);
+        if (!fs.existsSync(resolvedConfigPath)) {
+            throw new Error(`Config file not found: ${resolvedConfigPath}`);
+        }
+        const configContent = fs.readFileSync(resolvedConfigPath, "utf8");
+        const parsedConfig = JSON.parse(configContent);
+        if (!parsedConfig.mcpServers || !parsedConfig.mcpServers[serverName]) {
+            const availableServers = Object.keys(parsedConfig.mcpServers || {}).join(", ");
+            throw new Error(`Server '${serverName}' not found in config file. Available servers: ${availableServers}`);
+        }
+        const serverConfig = parsedConfig.mcpServers[serverName];
+        return serverConfig;
+    }
+    catch (err) {
+        if (err instanceof SyntaxError) {
+            throw new Error(`Invalid JSON in config file: ${err.message}`);
+        }
+        throw err;
+    }
+}
+function parseKeyValuePair(value, previous = {}) {
+    const parts = value.split("=");
+    const key = parts[0];
+    const val = parts.slice(1).join("=");
+    if (val === undefined || val === "") {
+        throw new Error(`Invalid parameter format: ${value}. Use key=value format.`);
+    }
+    return { ...previous, [key]: val };
+}
+function parseArgs() {
+    const program = new Command();
+    const argSeparatorIndex = process.argv.indexOf("--");
+    let preArgs = process.argv;
+    let postArgs = [];
+    if (argSeparatorIndex !== -1) {
+        preArgs = process.argv.slice(0, argSeparatorIndex);
+        postArgs = process.argv.slice(argSeparatorIndex + 1);
+    }
+    program
+        .name("inspector-bin")
+        .allowExcessArguments()
+        .allowUnknownOption()
+        .option("-e <env>", "environment variables in KEY=VALUE format", parseKeyValuePair, {})
+        .option("--config <path>", "config file path")
+        .option("--server <n>", "server name from config file")
+        .option("--cli", "enable CLI mode");
+    // Parse only the arguments before --
+    program.parse(preArgs);
+    const options = program.opts();
+    const remainingArgs = program.args;
+    // Add back any arguments that came after --
+    const finalArgs = [...remainingArgs, ...postArgs];
+    // Validate that config and server are provided together
+    if ((options.config && !options.server) ||
+        (!options.config && options.server)) {
+        throw new Error("Both --config and --server must be provided together. If you specify one, you must specify the other.");
+    }
+    // If config file is specified, load and use the options from the file. We must merge the args
+    // from the command line and the file together, or we will miss the method options (--method,
+    // etc.)
+    if (options.config && options.server) {
+        const config = loadConfigFile(options.config, options.server);
+        return {
+            command: config.command,
+            args: [...(config.args || []), ...finalArgs],
+            envArgs: { ...(config.env || {}), ...(options.e || {}) },
+            cli: options.cli || false,
+        };
+    }
+    // Otherwise use command line arguments
+    const command = finalArgs[0] || "";
+    const args = finalArgs.slice(1);
+    return {
+        command,
+        args,
+        envArgs: options.e || {},
+        cli: options.cli || false,
+    };
+}
+async function main() {
+    process.on("uncaughtException", (error) => {
+        handleError(error);
+    });
+    try {
+        const args = parseArgs();
+        if (args.cli) {
+            runCli(args);
+        }
+        else {
+            await runWebClient(args);
+        }
+    }
+    catch (error) {
+        handleError(error);
+    }
+}
+main();

package/cli/build/client/connection.js

@@ -0,0 +1,33 @@
+export const validLogLevels = [
+    "trace",
+    "debug",
+    "info",
+    "warn",
+    "error",
+];
+export async function connect(client, transport) {
+    try {
+        await client.connect(transport);
+    }
+    catch (error) {
+        throw new Error(`Failed to connect to MCP server: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export async function disconnect(transport) {
+    try {
+        await transport.close();
+    }
+    catch (error) {
+        throw new Error(`Failed to disconnect from MCP server: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// Set logging level
+export async function setLoggingLevel(client, level) {
+    try {
+        const response = await client.setLoggingLevel(level);
+        return response;
+    }
+    catch (error) {
+        throw new Error(`Failed to set logging level: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/cli/build/client/index.js

@@ -0,0 +1,6 @@
+// Re-export everything from the client modules
+export * from "./connection.js";
+export * from "./prompts.js";
+export * from "./resources.js";
+export * from "./tools.js";
+export * from "./types.js";

package/cli/build/client/prompts.js

@@ -0,0 +1,23 @@
+// List available prompts
+export async function listPrompts(client) {
+    try {
+        const response = await client.listPrompts();
+        return response;
+    }
+    catch (error) {
+        throw new Error(`Failed to list prompts: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// Get a prompt
+export async function getPrompt(client, name, args) {
+    try {
+        const response = await client.getPrompt({
+            name,
+            arguments: args || {},
+        });
+        return response;
+    }
+    catch (error) {
+        throw new Error(`Failed to get prompt: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/cli/build/client/resources.js

@@ -0,0 +1,30 @@
+// List available resources
+export async function listResources(client) {
+    try {
+        const response = await client.listResources();
+        return response;
+    }
+    catch (error) {
+        throw new Error(`Failed to list resources: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// Read a resource
+export async function readResource(client, uri) {
+    try {
+        const response = await client.readResource({ uri });
+        return response;
+    }
+    catch (error) {
+        throw new Error(`Failed to read resource ${uri}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// List resource templates
+export async function listResourceTemplates(client) {
+    try {
+        const response = await client.listResourceTemplates();
+        return response;
+    }
+    catch (error) {
+        throw new Error(`Failed to list resource templates: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/cli/build/client/tools.js

@@ -0,0 +1,64 @@
+export async function listTools(client) {
+    try {
+        const response = await client.listTools();
+        return response;
+    }
+    catch (error) {
+        throw new Error(`Failed to list tools: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function convertParameterValue(value, schema) {
+    if (!value) {
+        return value;
+    }
+    if (schema.type === "number" || schema.type === "integer") {
+        return Number(value);
+    }
+    if (schema.type === "boolean") {
+        return value.toLowerCase() === "true";
+    }
+    if (schema.type === "object" || schema.type === "array") {
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            return value;
+        }
+    }
+    return value;
+}
+function convertParameters(tool, params) {
+    const result = {};
+    const properties = tool.inputSchema.properties || {};
+    for (const [key, value] of Object.entries(params)) {
+        const paramSchema = properties[key];
+        if (paramSchema) {
+            result[key] = convertParameterValue(value, paramSchema);
+        }
+        else {
+            // If no schema is found for this parameter, keep it as string
+            result[key] = value;
+        }
+    }
+    return result;
+}
+export async function callTool(client, name, args) {
+    try {
+        const toolsResponse = await listTools(client);
+        const tools = toolsResponse.tools;
+        const tool = tools.find((t) => t.name === name);
+        let convertedArgs = args;
+        if (tool) {
+            // Convert parameters based on the tool's schema
+            convertedArgs = convertParameters(tool, args);
+        }
+        const response = await client.callTool({
+            name: name,
+            arguments: convertedArgs,
+        });
+        return response;
+    }
+    catch (error) {
+        throw new Error(`Failed to call tool ${name}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/cli/build/client/types.js

@@ -0,0 +1 @@
+export {};

package/cli/build/error-handler.js

@@ -0,0 +1,18 @@
+function formatError(error) {
+    let message;
+    if (error instanceof Error) {
+        message = error.message;
+    }
+    else if (typeof error === "string") {
+        message = error;
+    }
+    else {
+        message = "Unknown error";
+    }
+    return message;
+}
+export function handleError(error) {
+    const errorMessage = formatError(error);
+    console.error(errorMessage);
+    process.exit(1);
+}

package/cli/build/index.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { Command } from "commander";
+import { callTool, connect, disconnect, getPrompt, listPrompts, listResources, listResourceTemplates, listTools, readResource, setLoggingLevel, validLogLevels, } from "./client/index.js";
+import { handleError } from "./error-handler.js";
+import { createTransport } from "./transport.js";
+function createTransportOptions(target) {
+    if (target.length === 0) {
+        throw new Error("Target is required. Specify a URL or a command to execute.");
+    }
+    const [command, ...commandArgs] = target;
+    if (!command) {
+        throw new Error("Command is required.");
+    }
+    const isUrl = command.startsWith("http://") || command.startsWith("https://");
+    if (isUrl && commandArgs.length > 0) {
+        throw new Error("Arguments cannot be passed to a URL-based MCP server.");
+    }
+    return {
+        transportType: isUrl ? "sse" : "stdio",
+        command: isUrl ? undefined : command,
+        args: isUrl ? undefined : commandArgs,
+        url: isUrl ? command : undefined,
+    };
+}
+async function callMethod(args) {
+    const transportOptions = createTransportOptions(args.target);
+    const transport = createTransport(transportOptions);
+    const client = new Client({
+        name: "inspector-cli",
+        version: "0.5.1",
+    });
+    try {
+        await connect(client, transport);
+        let result;
+        // Tools methods
+        if (args.method === "tools/list") {
+            result = await listTools(client);
+        }
+        else if (args.method === "tools/call") {
+            if (!args.toolName) {
+                throw new Error("Tool name is required for tools/call method. Use --tool-name to specify the tool name.");
+            }
+            result = await callTool(client, args.toolName, args.toolArg || {});
+        }
+        // Resources methods
+        else if (args.method === "resources/list") {
+            result = await listResources(client);
+        }
+        else if (args.method === "resources/read") {
+            if (!args.uri) {
+                throw new Error("URI is required for resources/read method. Use --uri to specify the resource URI.");
+            }
+            result = await readResource(client, args.uri);
+        }
+        else if (args.method === "resources/templates/list") {
+            result = await listResourceTemplates(client);
+        }
+        // Prompts methods
+        else if (args.method === "prompts/list") {
+            result = await listPrompts(client);
+        }
+        else if (args.method === "prompts/get") {
+            if (!args.promptName) {
+                throw new Error("Prompt name is required for prompts/get method. Use --prompt-name to specify the prompt name.");
+            }
+            result = await getPrompt(client, args.promptName, args.promptArgs || {});
+        }
+        // Logging methods
+        else if (args.method === "logging/setLevel") {
+            if (!args.logLevel) {
+                throw new Error("Log level is required for logging/setLevel method. Use --log-level to specify the log level.");
+            }
+            result = await setLoggingLevel(client, args.logLevel);
+        }
+        else {
+            throw new Error(`Unsupported method: ${args.method}. Supported methods include: tools/list, tools/call, resources/list, resources/read, resources/templates/list, prompts/list, prompts/get, logging/setLevel`);
+        }
+        console.log(JSON.stringify(result, null, 2));
+    }
+    finally {
+        try {
+            await disconnect(transport);
+        }
+        catch (disconnectError) {
+            throw disconnectError;
+        }
+    }
+}
+function parseKeyValuePair(value, previous = {}) {
+    const parts = value.split("=");
+    const key = parts[0];
+    const val = parts.slice(1).join("=");
+    if (val === undefined || val === "") {
+        throw new Error(`Invalid parameter format: ${value}. Use key=value format.`);
+    }
+    return { ...previous, [key]: val };
+}
+function parseArgs() {
+    const program = new Command();
+    // Find if there's a -- in the arguments and split them
+    const argSeparatorIndex = process.argv.indexOf("--");
+    let preArgs = process.argv;
+    let postArgs = [];
+    if (argSeparatorIndex !== -1) {
+        preArgs = process.argv.slice(0, argSeparatorIndex);
+        postArgs = process.argv.slice(argSeparatorIndex + 1);
+    }
+    program
+        .name("inspector-cli")
+        .allowUnknownOption()
+        .argument("<target...>", "Command and arguments or URL of the MCP server")
+        //
+        // Method selection
+        //
+        .option("--method <method>", "Method to invoke")
+        //
+        // Tool-related options
+        //
+        .option("--tool-name <toolName>", "Tool name (for tools/call method)")
+        .option("--tool-arg <pairs...>", "Tool argument as key=value pair", parseKeyValuePair, {})
+        //
+        // Resource-related options
+        //
+        .option("--uri <uri>", "URI of the resource (for resources/read method)")
+        //
+        // Prompt-related options
+        //
+        .option("--prompt-name <promptName>", "Name of the prompt (for prompts/get method)")
+        .option("--prompt-args <pairs...>", "Prompt arguments as key=value pairs", parseKeyValuePair, {})
+        //
+        // Logging options
+        //
+        .option("--log-level <level>", "Logging level (for logging/setLevel method)", (value) => {
+        if (!validLogLevels.includes(value)) {
+            throw new Error(`Invalid log level: ${value}. Valid levels are: ${validLogLevels.join(", ")}`);
+        }
+        return value;
+    });
+    // Parse only the arguments before --
+    program.parse(preArgs);
+    const options = program.opts();
+    let remainingArgs = program.args;
+    // Add back any arguments that came after --
+    const finalArgs = [...remainingArgs, ...postArgs];
+    if (!options.method) {
+        throw new Error("Method is required. Use --method to specify the method to invoke.");
+    }
+    return {
+        target: finalArgs,
+        ...options,
+    };
+}
+async function main() {
+    process.on("uncaughtException", (error) => {
+        handleError(error);
+    });
+    try {
+        const args = parseArgs();
+        await callMethod(args);
+    }
+    catch (error) {
+        handleError(error);
+    }
+}
+main();

package/cli/build/transport.js

@@ -0,0 +1,47 @@
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { getDefaultEnvironment, StdioClientTransport, } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { findActualExecutable } from "spawn-rx";
+function createSSETransport(options) {
+    const baseUrl = new URL(options.url ?? "");
+    const sseUrl = new URL("/sse", baseUrl);
+    return new SSEClientTransport(sseUrl);
+}
+function createStdioTransport(options) {
+    let args = [];
+    if (options.args !== undefined) {
+        args = options.args;
+    }
+    const processEnv = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value !== undefined) {
+            processEnv[key] = value;
+        }
+    }
+    const defaultEnv = getDefaultEnvironment();
+    const env = {
+        ...processEnv,
+        ...defaultEnv,
+    };
+    const { cmd: actualCommand, args: actualArgs } = findActualExecutable(options.command ?? "", args);
+    return new StdioClientTransport({
+        command: actualCommand,
+        args: actualArgs,
+        env,
+        stderr: "pipe",
+    });
+}
+export function createTransport(options) {
+    const { transportType } = options;
+    try {
+        if (transportType === "stdio") {
+            return createStdioTransport(options);
+        }
+        if (transportType === "sse") {
+            return createSSETransport(options);
+        }
+        throw new Error(`Unsupported transport type: ${transportType}`);
+    }
+    catch (error) {
+        throw new Error(`Failed to create transport: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/client/dist/assets/OAuthCallback-kYD-IoGw.js

@@ -0,0 +1,84 @@
+import { u as useToast, r as reactExports, j as jsxRuntimeExports, S as SESSION_KEYS, I as InspectorOAuthClientProvider, a as auth } from "./index-DoxCWJPh.js";
+const parseOAuthCallbackParams = (location) => {
+  const params = new URLSearchParams(location);
+  const code = params.get("code");
+  if (code) {
+    return { successful: true, code };
+  }
+  const error = params.get("error");
+  const error_description = params.get("error_description");
+  const error_uri = params.get("error_uri");
+  if (error) {
+    return { successful: false, error, error_description, error_uri };
+  }
+  return {
+    successful: false,
+    error: "invalid_request",
+    error_description: "Missing code or error in response",
+    error_uri: null
+  };
+};
+const generateOAuthErrorDescription = (params) => {
+  const error = params.error;
+  const errorDescription = params.error_description;
+  const errorUri = params.error_uri;
+  return [
+    `Error: ${error}.`,
+    errorDescription ? `Details: ${errorDescription}.` : "",
+    errorUri ? `More info: ${errorUri}.` : ""
+  ].filter(Boolean).join("\n");
+};
+const OAuthCallback = ({ onConnect }) => {
+  const { toast } = useToast();
+  const hasProcessedRef = reactExports.useRef(false);
+  reactExports.useEffect(() => {
+    const handleCallback = async () => {
+      if (hasProcessedRef.current) {
+        return;
+      }
+      hasProcessedRef.current = true;
+      const notifyError = (description) => void toast({
+        title: "OAuth Authorization Error",
+        description,
+        variant: "destructive"
+      });
+      const params = parseOAuthCallbackParams(window.location.search);
+      if (!params.successful) {
+        return notifyError(generateOAuthErrorDescription(params));
+      }
+      const serverUrl = sessionStorage.getItem(SESSION_KEYS.SERVER_URL);
+      if (!serverUrl) {
+        return notifyError("Missing Server URL");
+      }
+      let result;
+      try {
+        const serverAuthProvider = new InspectorOAuthClientProvider(serverUrl);
+        result = await auth(serverAuthProvider, {
+          serverUrl,
+          authorizationCode: params.code
+        });
+      } catch (error) {
+        console.error("OAuth callback error:", error);
+        return notifyError(`Unexpected error occurred: ${error}`);
+      }
+      if (result !== "AUTHORIZED") {
+        return notifyError(
+          `Expected to be authorized after providing auth code, got: ${result}`
+        );
+      }
+      toast({
+        title: "Success",
+        description: "Successfully authenticated with OAuth",
+        variant: "default"
+      });
+      onConnect(serverUrl);
+    };
+    handleCallback().finally(() => {
+      window.history.replaceState({}, document.title, "/");
+    });
+  }, [toast, onConnect]);
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "flex items-center justify-center h-screen", children: /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: "text-lg text-gray-500", children: "Processing OAuth callback..." }) });
+};
+export {
+  OAuthCallback as default
+};