@modelcontextprotocol/inspector 1.0.1 → 2.0.0-rc.2

package/cli/build/cli.js

@@ -1,290 +0,0 @@
-#!/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));
-/**
- * v1 deprecation notice. Written to stderr, never stdout: `--cli` mode emits
- * JSON on stdout and callers pipe it, so a banner there would corrupt output.
- */
-const DEPRECATION_NOTICE = [
-    "⚠️  @modelcontextprotocol/inspector v1 is deprecated.",
-    "    Upgrade:  npx @modelcontextprotocol/inspector@latest",
-    "    v1 receives security fixes only.",
-].join("\n");
-function printDeprecationNotice() {
-    console.error(`\n${DEPRECATION_NOTICE}\n`);
-}
-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) {
-    // Path to the client entry point
-    const inspectorClientPath = resolve(__dirname, "../../", "client", "bin", "start.js");
-    const abort = new AbortController();
-    let cancelled = false;
-    process.on("SIGINT", () => {
-        cancelled = true;
-        abort.abort();
-    });
-    // Build arguments to pass to start.js
-    const startArgs = [];
-    // Pass environment variables
-    for (const [key, value] of Object.entries(args.envArgs)) {
-        startArgs.push("-e", `${key}=${value}`);
-    }
-    // Pass transport type if specified
-    if (args.transport) {
-        startArgs.push("--transport", args.transport);
-    }
-    // Pass server URL if specified
-    if (args.serverUrl) {
-        startArgs.push("--server-url", args.serverUrl);
-    }
-    // Pass command and args (using -- to separate them)
-    if (args.command) {
-        startArgs.push("--", args.command, ...args.args);
-    }
-    try {
-        await spawnPromise("node", [inspectorClientPath, ...startArgs], {
-            signal: abort.signal,
-            echoOutput: true,
-            // pipe the stdout through here, prevents issues with buffering and
-            // dropping the end of console.out after 8192 chars due to node
-            // closing the stdout pipe before the output has finished flushing
-            stdio: "inherit",
-        });
-    }
-    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 {
-        // Build CLI arguments
-        const cliArgs = [cliPath];
-        // Add target URL/command first
-        cliArgs.push(args.command, ...args.args);
-        // Add transport flag if specified
-        if (args.transport && args.transport !== "stdio") {
-            // Convert streamable-http back to http for CLI mode
-            const cliTransport = args.transport === "streamable-http" ? "http" : args.transport;
-            cliArgs.push("--transport", cliTransport);
-        }
-        // Add headers if specified
-        if (args.headers) {
-            for (const [key, value] of Object.entries(args.headers)) {
-                cliArgs.push("--header", `${key}: ${value}`);
-            }
-        }
-        await spawnPromise("node", cliArgs, {
-            env: { ...process.env, ...args.envArgs },
-            signal: abort.signal,
-            echoOutput: true,
-            // pipe the stdout through here, prevents issues with buffering and
-            // dropping the end of console.out after 8192 chars due to node
-            // closing the stdout pipe before the output has finished flushing
-            stdio: "inherit",
-        });
-    }
-    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 parseHeaderPair(value, previous = {}) {
-    const colonIndex = value.indexOf(":");
-    if (colonIndex === -1) {
-        throw new Error(`Invalid header format: ${value}. Use "HeaderName: Value" format.`);
-    }
-    const key = value.slice(0, colonIndex).trim();
-    const val = value.slice(colonIndex + 1).trim();
-    if (key === "" || val === "") {
-        throw new Error(`Invalid header format: ${value}. Use "HeaderName: 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")
-        .option("--transport <type>", "transport type (stdio, sse, http)")
-        .option("--server-url <url>", "server URL for SSE/HTTP transport")
-        .option("--header <headers...>", 'HTTP headers as "HeaderName: Value" pairs (for HTTP/SSE transports)', parseHeaderPair, {});
-    // 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 config and server options
-    if (!options.config && options.server) {
-        throw new Error("--server requires --config to be specified");
-    }
-    // If config is provided without server, try to auto-select
-    if (options.config && !options.server) {
-        const configContent = fs.readFileSync(path.isAbsolute(options.config)
-            ? options.config
-            : path.resolve(process.cwd(), options.config), "utf8");
-        const parsedConfig = JSON.parse(configContent);
-        const servers = Object.keys(parsedConfig.mcpServers || {});
-        if (servers.length === 1) {
-            // Use the only server if there's just one
-            options.server = servers[0];
-        }
-        else if (servers.length === 0) {
-            throw new Error("No servers found in config file");
-        }
-        else {
-            // Multiple servers, require explicit selection
-            throw new Error(`Multiple servers found in config file. Please specify one with --server.\nAvailable servers: ${servers.join(", ")}`);
-        }
-    }
-    // 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);
-        if (config.type === "stdio") {
-            return {
-                command: config.command,
-                args: [...(config.args || []), ...finalArgs],
-                envArgs: { ...(config.env || {}), ...(options.e || {}) },
-                cli: options.cli || false,
-                transport: "stdio",
-                headers: options.header,
-            };
-        }
-        else if (config.type === "sse" || config.type === "streamable-http") {
-            return {
-                command: config.url,
-                args: finalArgs,
-                envArgs: options.e || {},
-                cli: options.cli || false,
-                transport: config.type,
-                serverUrl: config.url,
-                headers: options.header,
-            };
-        }
-        else {
-            // Backwards compatibility: if no type field, assume stdio
-            return {
-                command: config.command || "",
-                args: [...(config.args || []), ...finalArgs],
-                envArgs: { ...(config.env || {}), ...(options.e || {}) },
-                cli: options.cli || false,
-                transport: "stdio",
-                headers: options.header,
-            };
-        }
-    }
-    // Otherwise use command line arguments
-    const command = finalArgs[0] || "";
-    const args = finalArgs.slice(1);
-    // Map "http" shorthand to "streamable-http"
-    let transport = options.transport;
-    if (transport === "http") {
-        transport = "streamable-http";
-    }
-    return {
-        command,
-        args,
-        envArgs: options.e || {},
-        cli: options.cli || false,
-        transport: transport,
-        serverUrl: options.serverUrl,
-        headers: options.header,
-    };
-}
-async function main() {
-    process.on("uncaughtException", (error) => {
-        handleError(error);
-    });
-    printDeprecationNotice();
-    try {
-        const args = parseArgs();
-        if (args.cli) {
-            await runCli(args);
-        }
-        else {
-            await runWebClient(args);
-        }
-    }
-    catch (error) {
-        handleError(error);
-    }
-}
-main();

package/cli/build/client/connection.js

@@ -1,38 +0,0 @@
-export const validLogLevels = [
-    "trace",
-    "debug",
-    "info",
-    "warn",
-    "error",
-];
-export async function connect(client, transport) {
-    try {
-        await client.connect(transport);
-        if (client.getServerCapabilities()?.logging) {
-            // default logging level is undefined in the spec, but the user of the
-            // inspector most likely wants debug.
-            await client.setLoggingLevel("debug");
-        }
-    }
-    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

@@ -1,6 +0,0 @@
-// 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

@@ -1,43 +0,0 @@
-// List available prompts
-export async function listPrompts(client, metadata) {
-    try {
-        const params = metadata && Object.keys(metadata).length > 0 ? { _meta: metadata } : {};
-        const response = await client.listPrompts(params);
-        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, metadata) {
-    try {
-        // Convert all arguments to strings for prompt arguments
-        const stringArgs = {};
-        if (args) {
-            for (const [key, value] of Object.entries(args)) {
-                if (typeof value === "string") {
-                    stringArgs[key] = value;
-                }
-                else if (value === null || value === undefined) {
-                    stringArgs[key] = String(value);
-                }
-                else {
-                    stringArgs[key] = JSON.stringify(value);
-                }
-            }
-        }
-        const params = {
-            name,
-            arguments: stringArgs,
-        };
-        if (metadata && Object.keys(metadata).length > 0) {
-            params._meta = metadata;
-        }
-        const response = await client.getPrompt(params);
-        return response;
-    }
-    catch (error) {
-        throw new Error(`Failed to get prompt: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}

package/cli/build/client/resources.js

@@ -1,36 +0,0 @@
-// List available resources
-export async function listResources(client, metadata) {
-    try {
-        const params = metadata && Object.keys(metadata).length > 0 ? { _meta: metadata } : {};
-        const response = await client.listResources(params);
-        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, metadata) {
-    try {
-        const params = { uri };
-        if (metadata && Object.keys(metadata).length > 0) {
-            params._meta = metadata;
-        }
-        const response = await client.readResource(params);
-        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, metadata) {
-    try {
-        const params = metadata && Object.keys(metadata).length > 0 ? { _meta: metadata } : {};
-        const response = await client.listResourceTemplates(params);
-        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

@@ -1,87 +0,0 @@
-export async function listTools(client, metadata) {
-    try {
-        const params = metadata && Object.keys(metadata).length > 0 ? { _meta: metadata } : {};
-        const response = await client.listTools(params);
-        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, generalMetadata, toolSpecificMetadata) {
-    try {
-        const toolsResponse = await listTools(client, generalMetadata);
-        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, but only for string values
-            // since we now accept pre-parsed values from the CLI
-            const stringArgs = {};
-            for (const [key, value] of Object.entries(args)) {
-                if (typeof value === "string") {
-                    stringArgs[key] = value;
-                }
-            }
-            if (Object.keys(stringArgs).length > 0) {
-                const convertedStringArgs = convertParameters(tool, stringArgs);
-                convertedArgs = { ...args, ...convertedStringArgs };
-            }
-        }
-        // Merge general metadata with tool-specific metadata
-        // Tool-specific metadata takes precedence over general metadata
-        let mergedMetadata;
-        if (generalMetadata || toolSpecificMetadata) {
-            mergedMetadata = {
-                ...(generalMetadata || {}),
-                ...(toolSpecificMetadata || {}),
-            };
-        }
-        const response = await client.callTool({
-            name: name,
-            arguments: convertedArgs,
-            _meta: mergedMetadata && Object.keys(mergedMetadata).length > 0
-                ? mergedMetadata
-                : undefined,
-        });
-        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

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

package/cli/build/error-handler.js

@@ -1,18 +0,0 @@
-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);
-}