@bryan-thompson/inspector-assessment 1.0.0

package/cli/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/cli/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/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,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/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,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/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);
+}