@bryan-thompson/inspector-assessment-cli 1.0.0

package/build/cli.js

@@ -0,0 +1,277 @@
+#!/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) {
+    // 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);
+    });
+    try {
+        const args = parseArgs();
+        if (args.cli) {
+            await runCli(args);
+        }
+        else {
+            await runWebClient(args);
+        }
+    }
+    catch (error) {
+        handleError(error);
+    }
+}
+main();

package/build/client/connection.js

@@ -0,0 +1,38 @@
+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/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/build/client/prompts.js

@@ -0,0 +1,38 @@
+// 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 {
+        // 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: stringArgs,
+        });
+        return response;
+    }
+    catch (error) {
+        throw new Error(`Failed to get prompt: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/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/build/client/tools.js

@@ -0,0 +1,74 @@
+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, 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,
+            arguments: convertedArgs,
+        });
+        return response;
+    }
+    catch (error) {
+        throw new Error(`Failed to call tool ${name}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/build/client/types.js

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

package/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/build/index.js

@@ -0,0 +1,232 @@
+#!/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";
+import { awaitableLog } from "./utils/awaitable-log.js";
+import packageJson from "../package.json" with { type: "json" };
+function createTransportOptions(target, transport, headers) {
+    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.");
+    }
+    let transportType;
+    if (transport) {
+        if (!isUrl && transport !== "stdio") {
+            throw new Error("Only stdio transport can be used with local commands.");
+        }
+        if (isUrl && transport === "stdio") {
+            throw new Error("stdio transport cannot be used with URLs.");
+        }
+        transportType = transport;
+    }
+    else if (isUrl) {
+        const url = new URL(command);
+        if (url.pathname.endsWith("/mcp")) {
+            transportType = "http";
+        }
+        else if (url.pathname.endsWith("/sse")) {
+            transportType = "sse";
+        }
+        else {
+            transportType = "sse";
+        }
+    }
+    else {
+        transportType = "stdio";
+    }
+    return {
+        transportType,
+        command: isUrl ? undefined : command,
+        args: isUrl ? undefined : commandArgs,
+        url: isUrl ? command : undefined,
+        headers,
+    };
+}
+async function callMethod(args) {
+    const transportOptions = createTransportOptions(args.target, args.transport, args.headers);
+    const transport = createTransport(transportOptions);
+    const [, name = packageJson.name] = packageJson.name.split("/");
+    const version = packageJson.version;
+    const clientIdentity = { name, version };
+    const client = new Client(clientIdentity);
+    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`);
+        }
+        await awaitableLog(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.`);
+    }
+    // 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() {
+    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;
+    })
+        //
+        // Transport options
+        //
+        .option("--transport <type>", "Transport type (sse, http, or stdio). Auto-detected from URL: /mcp → http, /sse → sse, commands → stdio", (value) => {
+        const validTransports = ["sse", "http", "stdio"];
+        if (!validTransports.includes(value)) {
+            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();
+    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,
+        headers: options.header, // commander.js uses 'header' field, map to 'headers'
+    };
+}
+async function main() {
+    process.on("uncaughtException", (error) => {
+        handleError(error);
+    });
+    try {
+        const args = parseArgs();
+        await callMethod(args);
+        // Explicitly exit to ensure process terminates in CI
+        process.exit(0);
+    }
+    catch (error) {
+        handleError(error);
+    }
+}
+main();

package/build/transport.js

@@ -0,0 +1,65 @@
+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 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 = {
+        ...defaultEnv,
+        ...processEnv,
+    };
+    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 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") {
+            const transportOptions = options.headers
+                ? {
+                    requestInit: {
+                        headers: options.headers,
+                    },
+                }
+                : undefined;
+            return new SSEClientTransport(url, transportOptions);
+        }
+        if (transportType === "http") {
+            const transportOptions = options.headers
+                ? {
+                    requestInit: {
+                        headers: options.headers,
+                    },
+                }
+                : undefined;
+            return new StreamableHTTPClientTransport(url, transportOptions);
+        }
+        throw new Error(`Unsupported transport type: ${transportType}`);
+    }
+    catch (error) {
+        throw new Error(`Failed to create transport: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

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

@@ -0,0 +1,41 @@
+{
+  "name": "@bryan-thompson/inspector-assessment-cli",
+  "version": "1.0.0",
+  "description": "CLI for the Enhanced MCP Inspector with assessment capabilities",
+  "license": "MIT",
+  "author": "Bryan Thompson <bryan@triepod.ai>",
+  "contributors": [
+    "Anthropic, PBC (original MCP Inspector)"
+  ],
+  "homepage": "https://github.com/triepod-ai/inspector-assessment",
+  "bugs": "https://github.com/triepod-ai/inspector-assessment/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/triepod-ai/inspector-assessment.git"
+  },
+  "main": "build/cli.js",
+  "type": "module",
+  "bin": {
+    "mcp-inspector-assess-cli": "build/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "build"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "postbuild": "node scripts/make-executable.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.18.0",
+    "commander": "^13.1.0",
+    "spawn-rx": "^5.1.2"
+  }
+}