@modelcontextprotocol/inspector-cli 0.16.5 → 0.16.7

package/build/cli.js

@@ -54,6 +54,10 @@ async function runWebClient(args) {
         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) {
@@ -73,18 +77,28 @@ async function runCli(args) {
     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 command and remaining args
-        cliArgs.push(args.command, ...args.args);
+        // 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) {
@@ -126,6 +140,18 @@ function parseKeyValuePair(value, previous = {}) {
     }
     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("--");
@@ -144,7 +170,8 @@ function parseArgs() {
         .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("--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();
@@ -186,6 +213,7 @@ function parseArgs() {
                 envArgs: { ...(config.env || {}), ...(options.e || {}) },
                 cli: options.cli || false,
                 transport: "stdio",
+                headers: options.header,
             };
         }
         else if (config.type === "sse" || config.type === "streamable-http") {
@@ -196,6 +224,7 @@ function parseArgs() {
                 cli: options.cli || false,
                 transport: config.type,
                 serverUrl: config.url,
+                headers: options.header,
             };
         }
         else {
@@ -206,6 +235,7 @@ function parseArgs() {
                 envArgs: { ...(config.env || {}), ...(options.e || {}) },
                 cli: options.cli || false,
                 transport: "stdio",
+                headers: options.header,
             };
         }
     }
@@ -224,6 +254,7 @@ function parseArgs() {
         cli: options.cli || false,
         transport: transport,
         serverUrl: options.serverUrl,
+        headers: options.header,
     };
 }
 async function main() {

package/build/client/prompts.js

@@ -11,9 +11,24 @@ export async function listPrompts(client) {
 // Get a prompt
 export async function getPrompt(client, name, args) {
     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 response = await client.getPrompt({
             name,
-            arguments: args || {},
+            arguments: stringArgs,
         });
         return response;
     }

package/build/client/tools.js

@@ -49,8 +49,18 @@ export async function callTool(client, name, args) {
         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);
+            // 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 };
+            }
         }
         const response = await client.callTool({
             name: name,

package/build/index.js

@@ -4,7 +4,8 @@ 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, transport) {
+import { awaitableLog } from "./utils/awaitable-log.js";
+function createTransportOptions(target, transport, headers) {
     if (target.length === 0) {
         throw new Error("Target is required. Specify a URL or a command to execute.");
     }
@@ -46,10 +47,11 @@ function createTransportOptions(target, transport) {
         command: isUrl ? undefined : command,
         args: isUrl ? undefined : commandArgs,
         url: isUrl ? command : undefined,
+        headers,
     };
 }
 async function callMethod(args) {
-    const transportOptions = createTransportOptions(args.target, args.transport);
+    const transportOptions = createTransportOptions(args.target, args.transport, args.headers);
     const transport = createTransport(transportOptions);
     const client = new Client({
         name: "inspector-cli",
@@ -101,7 +103,7 @@ async function callMethod(args) {
         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));
+        await awaitableLog(JSON.stringify(result, null, 2));
     }
     finally {
         try {
@@ -119,6 +121,27 @@ function parseKeyValuePair(value, previous = {}) {
     if (val === undefined || val === "") {
         throw new Error(`Invalid parameter format: ${value}. Use key=value format.`);
     }
+    // Try to parse as JSON first
+    let parsedValue;
+    try {
+        parsedValue = JSON.parse(val);
+    }
+    catch {
+        // If JSON parsing fails, keep as string
+        parsedValue = val;
+    }
+    return { ...previous, [key]: parsedValue };
+}
+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() {
@@ -171,7 +194,11 @@ function parseArgs() {
             throw new Error(`Invalid transport type: ${value}. Valid types are: ${validTransports.join(", ")}`);
         }
         return value;
-    });
+    })
+        //
+        // HTTP headers
+        //
+        .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();
@@ -184,6 +211,7 @@ function parseArgs() {
     return {
         target: finalArgs,
         ...options,
+        headers: options.header, // commander.js uses 'header' field, map to 'headers'
     };
 }
 async function main() {

package/build/transport.js

@@ -38,10 +38,24 @@ export function createTransport(options) {
         }
         const url = new URL(options.url);
         if (transportType === "sse") {
-            return new SSEClientTransport(url);
+            const transportOptions = options.headers
+                ? {
+                    requestInit: {
+                        headers: options.headers,
+                    },
+                }
+                : undefined;
+            return new SSEClientTransport(url, transportOptions);
         }
         if (transportType === "http") {
-            return new StreamableHTTPClientTransport(url);
+            const transportOptions = options.headers
+                ? {
+                    requestInit: {
+                        headers: options.headers,
+                    },
+                }
+                : undefined;
+            return new StreamableHTTPClientTransport(url, transportOptions);
         }
         throw new Error(`Unsupported transport type: ${transportType}`);
     }

package/build/utils/awaitable-log.js

@@ -0,0 +1,7 @@
+export function awaitableLog(logValue) {
+    return new Promise((resolve) => {
+        process.stdout.write(logValue, () => {
+            resolve();
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelcontextprotocol/inspector-cli",
-  "version": "0.16.5",
+  "version": "0.16.7",
   "description": "CLI for the Model Context Protocol inspector",
   "license": "MIT",
   "author": "Anthropic, PBC (https://anthropic.com)",
@@ -17,11 +17,14 @@
   "scripts": {
     "build": "tsc",
     "postbuild": "node scripts/make-executable.js",
-    "test": "node scripts/cli-tests.js"
+    "test": "node scripts/cli-tests.js && node scripts/cli-tool-tests.js && node scripts/cli-header-tests.js",
+    "test:cli": "node scripts/cli-tests.js",
+    "test:cli-tools": "node scripts/cli-tool-tests.js",
+    "test:cli-headers": "node scripts/cli-header-tests.js"
   },
   "devDependencies": {},
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.17.3",
+    "@modelcontextprotocol/sdk": "^1.18.0",
     "commander": "^13.1.0",
     "spawn-rx": "^5.1.2"
   }