@modelcontextprotocol/inspector-cli 0.16.1 → 0.16.3

package/build/cli.js

@@ -32,8 +32,26 @@ async function runWebClient(args) {
         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], {
+        await spawnPromise("node", [inspectorClientPath, ...startArgs], {
             signal: abort.signal,
             echoOutput: true,
         });
@@ -53,7 +71,17 @@ async function runCli(args) {
         abort.abort();
     });
     try {
-        await spawnPromise("node", [cliPath, args.command, ...args.args], {
+        // Build CLI arguments
+        const cliArgs = [cliPath];
+        // 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 command and remaining args
+        cliArgs.push(args.command, ...args.args);
+        await spawnPromise("node", cliArgs, {
             env: { ...process.env, ...args.envArgs },
             signal: abort.signal,
             echoOutput: true,
@@ -114,38 +142,88 @@ function parseArgs() {
         .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("--cli", "enable CLI mode")
+        .option("--transport <type>", "transport type (stdio, sse, http)")
+        .option("--server-url <url>", "server URL for SSE/HTTP transport");
     // 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.");
+    // 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);
-        return {
-            command: config.command,
-            args: [...(config.args || []), ...finalArgs],
-            envArgs: { ...(config.env || {}), ...(options.e || {}) },
-            cli: options.cli || false,
-        };
+        if (config.type === "stdio") {
+            return {
+                command: config.command,
+                args: [...(config.args || []), ...finalArgs],
+                envArgs: { ...(config.env || {}), ...(options.e || {}) },
+                cli: options.cli || false,
+                transport: "stdio",
+            };
+        }
+        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,
+            };
+        }
+        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",
+            };
+        }
     }
     // 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,
     };
 }
 async function main() {
@@ -155,7 +233,7 @@ async function main() {
     try {
         const args = parseArgs();
         if (args.cli) {
-            runCli(args);
+            await runCli(args);
         }
         else {
             await runWebClient(args);

package/build/client/connection.js

@@ -8,6 +8,11 @@ export const validLogLevels = [
 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)}`);

package/build/index.js

@@ -193,6 +193,8 @@ async function main() {
     try {
         const args = parseArgs();
         await callMethod(args);
+        // Explicitly exit to ensure process terminates in CI
+        process.exit(0);
     }
     catch (error) {
         handleError(error);

package/build/transport.js

@@ -2,20 +2,6 @@ import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { getDefaultEnvironment, StdioClientTransport, } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { findActualExecutable } from "spawn-rx";
-function createSSETransport(options) {
-    const baseUrl = new URL(options.url ?? "");
-    const sseUrl = baseUrl.pathname.endsWith("/sse")
-        ? baseUrl
-        : new URL("/sse", baseUrl);
-    return new SSEClientTransport(sseUrl);
-}
-function createHTTPTransport(options) {
-    const baseUrl = new URL(options.url ?? "");
-    const mcpUrl = baseUrl.pathname.endsWith("/mcp")
-        ? baseUrl
-        : new URL("/mcp", baseUrl);
-    return new StreamableHTTPClientTransport(mcpUrl);
-}
 function createStdioTransport(options) {
     let args = [];
     if (options.args !== undefined) {
@@ -46,11 +32,16 @@ export function createTransport(options) {
         if (transportType === "stdio") {
             return createStdioTransport(options);
         }
+        // If not STDIO, then it must be either SSE or HTTP.
+        if (!options.url) {
+            throw new Error("URL must be provided for SSE or HTTP transport types.");
+        }
+        const url = new URL(options.url);
         if (transportType === "sse") {
-            return createSSETransport(options);
+            return new SSEClientTransport(url);
         }
         if (transportType === "http") {
-            return createHTTPTransport(options);
+            return new StreamableHTTPClientTransport(url);
         }
         throw new Error(`Unsupported transport type: ${transportType}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelcontextprotocol/inspector-cli",
-  "version": "0.16.1",
+  "version": "0.16.3",
   "description": "CLI for the Model Context Protocol inspector",
   "license": "MIT",
   "author": "Anthropic, PBC (https://anthropic.com)",
@@ -21,7 +21,7 @@
   },
   "devDependencies": {},
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.13.1",
+    "@modelcontextprotocol/sdk": "^1.17.0",
     "commander": "^13.1.0",
     "spawn-rx": "^5.1.2"
   }