mcp-inspector 0.1.0

data/lib/mcp_inspector/data/config_manager.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+require "fileutils"
+
+module MCPInspector
+  module Data
+    class ConfigManager
+      class ConfigError < Error; end
+
+      DEFAULT_USER_CONFIG_PATH = File.expand_path("~/.mcp-inspector.json")
+      DEFAULT_PROJECT_CONFIG_PATH = "./.mcp-inspector.json"
+
+      def initialize(config_path: nil)
+        @config_path = config_path
+        @config = load_merged_config
+        validate_config!
+      end
+
+      def servers
+        @servers ||= build_server_configs
+      end
+
+      def server_names
+        servers.keys
+      end
+
+      def find_server(name)
+        servers[name] or raise ConfigError, "Server '#{name}' not found"
+      end
+
+      def defaults
+        @config["defaults"] || {}
+      end
+
+      def output_format
+        defaults["output"] || "json"
+      end
+
+      def pretty_print?
+        defaults.fetch("pretty", true)
+      end
+
+      def to_h
+        @config
+      end
+
+      def self.config_file_exists?(path = nil)
+        paths_to_check = if path
+                          [path]
+                        else
+                          [DEFAULT_PROJECT_CONFIG_PATH, DEFAULT_USER_CONFIG_PATH]
+                        end
+
+        paths_to_check.any? { |p| File.exist?(p) }
+      end
+
+      def self.create_example_config(path = DEFAULT_USER_CONFIG_PATH)
+        example_config = {
+          "servers" => [
+            {
+              "name" => "filesystem-server",
+              "transport" => "stdio",
+              "command" => ["npx", "-y", "@modelcontextprotocol/server-filesystem"],
+              "args" => ["/tmp"],
+              "env" => {}
+            },
+            {
+              "name" => "github-server",
+              "transport" => "stdio", 
+              "command" => ["npx", "-y", "@modelcontextprotocol/server-github"],
+              "env" => {
+                "GITHUB_TOKEN" => "${GITHUB_TOKEN}"
+              }
+            }
+          ],
+          "defaults" => {
+            "output" => "json",
+            "pretty" => true
+          }
+        }
+
+        File.write(path, JSON.pretty_generate(example_config))
+        path
+      end
+
+      private
+
+      attr_reader :config_path
+
+      def load_merged_config
+        configs = []
+
+        # Load in order of precedence (last wins)
+        configs << load_user_config if user_config_exists?
+        configs << load_project_config if project_config_exists?
+        configs << load_custom_config if custom_config_specified?
+
+        if configs.empty?
+          # Auto-create default config file like Claude Desktop does
+          created_config_path = auto_create_default_config
+          raise ConfigError, build_no_config_error_message(created_config_path)
+        end
+
+        merge_configs(configs)
+      end
+
+      def load_user_config
+        load_config_file(DEFAULT_USER_CONFIG_PATH)
+      end
+
+      def load_project_config
+        load_config_file(DEFAULT_PROJECT_CONFIG_PATH)
+      end
+
+      def load_custom_config
+        load_config_file(config_path)
+      end
+
+      def load_config_file(path)
+        content = File.read(path)
+        JSON.parse(content)
+      rescue JSON::ParserError => e
+        raise ConfigError, "Invalid JSON in config file '#{path}': #{e.message}"
+      rescue Errno::ENOENT
+        raise ConfigError, "Configuration file not found: #{path}"
+      rescue Errno::EACCES
+        raise ConfigError, "Configuration file not readable: #{path}"
+      end
+
+      def merge_configs(configs)
+        base_config = { "servers" => [], "defaults" => {} }
+        
+        configs.each do |config|
+          base_config = deep_merge(base_config, config)
+        end
+
+        base_config
+      end
+
+      def deep_merge(hash1, hash2)
+        result = hash1.dup
+        
+        hash2.each do |key, value|
+          if result[key].is_a?(Hash) && value.is_a?(Hash)
+            result[key] = deep_merge(result[key], value)
+          elsif key == "servers" && result[key].is_a?(Array) && value.is_a?(Array)
+            result[key] = merge_servers(result[key], value)
+          else
+            result[key] = value
+          end
+        end
+
+        result
+      end
+
+      def merge_servers(servers1, servers2)
+        merged = servers1.dup
+        servers2.each do |server|
+          existing_index = merged.find_index { |s| s["name"] == server["name"] }
+          if existing_index
+            merged[existing_index] = server
+          else
+            merged << server
+          end
+        end
+        merged
+      end
+
+      def validate_config!
+        raise ConfigError, "Configuration must be a hash" unless @config.is_a?(Hash)
+        raise ConfigError, "No 'servers' section found in configuration" unless @config["servers"]
+        raise ConfigError, "'servers' must be an array" unless @config["servers"].is_a?(Array)
+        raise ConfigError, "No servers configured" if @config["servers"].empty?
+      end
+
+      def build_server_configs
+        server_configs = {}
+        
+        @config["servers"].each do |server_hash|
+          begin
+            server_config = MCPInspector::Transport::ServerConfig.new(server_hash)
+            server_configs[server_config.name] = server_config
+          rescue MCPInspector::Transport::ServerConfig::ValidationError => e
+            raise ConfigError, "Invalid server configuration: #{e.message}"
+          end
+        end
+
+        server_configs
+      end
+
+      def user_config_exists?
+        File.exist?(DEFAULT_USER_CONFIG_PATH)
+      end
+
+      def project_config_exists?
+        File.exist?(DEFAULT_PROJECT_CONFIG_PATH)
+      end
+
+      def custom_config_specified?
+        config_path && File.exist?(config_path)
+      end
+
+      def auto_create_default_config
+        # Determine where to create the config file
+        config_file_path = config_path || DEFAULT_USER_CONFIG_PATH
+        
+        # Ensure the parent directory exists
+        parent_dir = File.dirname(config_file_path)
+        FileUtils.mkdir_p(parent_dir) unless File.directory?(parent_dir)
+        
+        # Create the config file with example servers
+        self.class.create_example_config(config_file_path)
+        
+        config_file_path
+      end
+
+      def build_no_config_error_message(created_config_path)
+        <<~ERROR
+          No configuration file found, so I created one for you at:
+            #{created_config_path}
+
+          This file contains example MCP server configurations. Please edit it to:
+          1. Add your actual MCP servers
+          2. Remove or modify the example servers as needed
+          3. Set any custom defaults
+
+          Then run your command again.
+
+          Example servers included:
+          - filesystem-server: For file system operations
+          - github-server: For GitHub operations (requires GITHUB_TOKEN)
+        ERROR
+      end
+    end
+  end
+end

data/lib/mcp_inspector/data/input_adapter.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "json"
+
+module MCPInspector
+  module Data
+    class InputAdapter
+      class ValidationError < Error; end
+
+      def initialize(args = [], options = {})
+        @args = args
+        @options = options
+      end
+
+      def parse_json_arguments(json_string)
+        return {} if json_string.nil? || json_string.empty?
+
+        JSON.parse(json_string)
+      rescue JSON::ParserError => e
+        raise ValidationError, "Invalid JSON arguments: #{e.message}\nExpected format: '{\"key\": \"value\"}'"
+      end
+
+      def validate_server_name!(server_name, available_servers)
+        return if available_servers.include?(server_name)
+
+        if available_servers.empty?
+          raise ValidationError, "No servers configured. Please add servers to your configuration file."
+        else
+          raise ValidationError, "Server '#{server_name}' not found. Available servers: #{available_servers.join(', ')}"
+        end
+      end
+
+      def validate_tool_name!(tool_name)
+        raise ValidationError, "Tool name is required" if tool_name.nil? || tool_name.empty?
+      end
+
+      def validate_resource_uri!(uri)
+        raise ValidationError, "Resource URI is required" if uri.nil? || uri.empty?
+      end
+
+      def validate_prompt_name!(prompt_name)
+        raise ValidationError, "Prompt name is required" if prompt_name.nil? || prompt_name.empty?
+      end
+
+      def validate_config_file!(config_path)
+        unless File.exist?(config_path)
+          raise ValidationError, "Configuration file not found: #{config_path}"
+        end
+
+        unless File.readable?(config_path)
+          raise ValidationError, "Configuration file is not readable: #{config_path}"
+        end
+      end
+
+      def transform_to_operation_params(command, subcommand = nil, *args)
+        {
+          command: command,
+          subcommand: subcommand,
+          target: args.first,
+          arguments: parse_json_arguments(@options[:args])
+        }.compact
+      end
+
+      private
+
+      attr_reader :args, :options
+    end
+  end
+end

data/lib/mcp_inspector/data/output_adapter.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module MCPInspector
+  module Data
+    class OutputAdapter
+      DEFAULT_FORMAT = "json"
+      VALID_FORMATS = %w[json terminal].freeze
+
+      def initialize(format: DEFAULT_FORMAT, pretty: true, output_destination: $stdout)
+        @format = validate_format(format)
+        @pretty = pretty
+        @output_destination = output_destination
+        @formatter = create_formatter
+      end
+
+      def output_success(data, metadata = {})
+        formatted_output = @formatter.format_success(data, metadata)
+        write_output(formatted_output)
+      end
+
+      def output_error(error, metadata = {})
+        formatted_output = @formatter.format_error(error, metadata)
+        write_output(formatted_output)
+      end
+
+      def output_tools_list(tools, metadata = {})
+        formatted_output = @formatter.format_tools_list(tools, metadata)
+        write_output(formatted_output)
+      end
+
+      def output_resources_list(resources, metadata = {})
+        formatted_output = @formatter.format_resources_list(resources, metadata)
+        write_output(formatted_output)
+      end
+
+      def output_prompts_list(prompts, metadata = {})
+        formatted_output = @formatter.format_prompts_list(prompts, metadata)
+        write_output(formatted_output)
+      end
+
+      def output_tool_result(result, metadata = {})
+        formatted_output = @formatter.format_tool_result(result, metadata)
+        write_output(formatted_output)
+      end
+
+      def output_resource_content(content, metadata = {})
+        formatted_output = @formatter.format_resource_content(content, metadata)
+        write_output(formatted_output)
+      end
+
+      def output_prompt_result(result, metadata = {})
+        formatted_output = @formatter.format_prompt_result(result, metadata)
+        write_output(formatted_output)
+      end
+
+      def output_server_info(info, metadata = {})
+        formatted_output = @formatter.format_server_info(info, metadata)
+        write_output(formatted_output)
+      end
+
+      def output_config_list(servers, metadata = {})
+        formatted_output = @formatter.format_config_list(servers, metadata)
+        write_output(formatted_output)
+      end
+
+      def output_config_details(server_config, metadata = {})
+        formatted_output = @formatter.format_config_details(server_config, metadata)
+        write_output(formatted_output)
+      end
+
+      private
+
+      attr_reader :format, :pretty, :output_destination, :formatter
+
+      def validate_format(format)
+        unless VALID_FORMATS.include?(format)
+          raise ArgumentError, "Invalid output format '#{format}'. Valid options: #{VALID_FORMATS.join(', ')}"
+        end
+        format
+      end
+
+      def create_formatter
+        case format
+        when "json"
+          MCPInspector::Presentation::JSONFormatter.new(pretty: pretty)
+        when "terminal"
+          # Placeholder for future terminal formatter
+          MCPInspector::Presentation::JSONFormatter.new(pretty: pretty)
+        else
+          raise ArgumentError, "Unsupported formatter: #{format}"
+        end
+      end
+
+      def write_output(formatted_output)
+        output_destination.puts(formatted_output)
+        output_destination.flush if output_destination.respond_to?(:flush)
+      end
+
+      def build_metadata(operation:, server: nil, **additional)
+        base_metadata = {
+          operation: operation,
+          timestamp: Time.now.iso8601
+        }
+        
+        base_metadata[:server] = server if server
+        base_metadata.merge(additional)
+      end
+    end
+  end
+end

data/lib/mcp_inspector/presentation/base_formatter.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module MCPInspector
+  module Presentation
+    class BaseFormatter
+      def initialize(pretty: true)
+        @pretty = pretty
+      end
+
+      def format_success(data, metadata = {})
+        raise NotImplementedError, "Subclasses must implement #format_success"
+      end
+
+      def format_error(error, metadata = {})
+        raise NotImplementedError, "Subclasses must implement #format_error"
+      end
+
+      def format_tools_list(tools, metadata = {})
+        raise NotImplementedError, "Subclasses must implement #format_tools_list"
+      end
+
+      def format_resources_list(resources, metadata = {})
+        raise NotImplementedError, "Subclasses must implement #format_resources_list"
+      end
+
+      def format_prompts_list(prompts, metadata = {})
+        raise NotImplementedError, "Subclasses must implement #format_prompts_list"
+      end
+
+      def format_tool_result(result, metadata = {})
+        raise NotImplementedError, "Subclasses must implement #format_tool_result"
+      end
+
+      def format_resource_content(content, metadata = {})
+        raise NotImplementedError, "Subclasses must implement #format_resource_content"
+      end
+
+      def format_prompt_result(result, metadata = {})
+        raise NotImplementedError, "Subclasses must implement #format_prompt_result"
+      end
+
+      def format_server_info(info, metadata = {})
+        raise NotImplementedError, "Subclasses must implement #format_server_info"
+      end
+
+      def format_config_list(servers, metadata = {})
+        raise NotImplementedError, "Subclasses must implement #format_config_list"
+      end
+
+      def format_config_details(server_config, metadata = {})
+        raise NotImplementedError, "Subclasses must implement #format_config_details"
+      end
+
+      protected
+
+      attr_reader :pretty
+
+      def build_response(status:, data: nil, error: nil, metadata: {})
+        response = {
+          status: status,
+          metadata: build_metadata(metadata)
+        }
+        
+        response[:data] = data if data
+        response[:error] = format_error_message(error) if error
+        
+        response
+      end
+
+      def build_metadata(metadata)
+        base_metadata = {
+          timestamp: Time.now.iso8601
+        }
+        
+        base_metadata.merge(metadata.compact)
+      end
+
+      def format_error_message(error)
+        case error
+        when String
+          error
+        when StandardError
+          {
+            type: error.class.name,
+            message: error.message
+          }
+        else
+          error.to_s
+        end
+      end
+    end
+  end
+end

data/lib/mcp_inspector/presentation/json_formatter.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "json"
+
+module MCPInspector
+  module Presentation
+    class JSONFormatter < BaseFormatter
+      def format_success(data, metadata = {})
+        response = build_response(status: "success", data: data, metadata: metadata)
+        to_json(response)
+      end
+
+      def format_error(error, metadata = {})
+        response = build_response(status: "error", error: error, metadata: metadata)
+        to_json(response)
+      end
+
+      def format_tools_list(tools, metadata = {})
+        data = {
+          tools: normalize_list_data(tools),
+          count: Array(tools).length
+        }
+        
+        metadata = metadata.merge(operation: "list_tools")
+        format_success(data, metadata)
+      end
+
+      def format_resources_list(resources, metadata = {})
+        data = {
+          resources: normalize_list_data(resources),
+          count: Array(resources).length
+        }
+        
+        metadata = metadata.merge(operation: "list_resources")
+        format_success(data, metadata)
+      end
+
+      def format_prompts_list(prompts, metadata = {})
+        data = {
+          prompts: normalize_list_data(prompts),
+          count: Array(prompts).length
+        }
+        
+        metadata = metadata.merge(operation: "list_prompts")
+        format_success(data, metadata)
+      end
+
+      def format_tool_result(result, metadata = {})
+        data = {
+          result: result
+        }
+        
+        metadata = metadata.merge(operation: "execute_tool")
+        format_success(data, metadata)
+      end
+
+      def format_resource_content(content, metadata = {})
+        data = {
+          content: content
+        }
+        
+        metadata = metadata.merge(operation: "read_resource")
+        format_success(data, metadata)
+      end
+
+      def format_prompt_result(result, metadata = {})
+        data = {
+          result: result
+        }
+        
+        metadata = metadata.merge(operation: "get_prompt")
+        format_success(data, metadata)
+      end
+
+      def format_server_info(info, metadata = {})
+        data = {
+          server_info: info
+        }
+        
+        metadata = metadata.merge(operation: "server_info")
+        format_success(data, metadata)
+      end
+
+      def format_config_list(servers, metadata = {})
+        server_list = servers.map do |name, config|
+          {
+            name: name,
+            transport: config.transport,
+            description: build_server_description(config)
+          }
+        end
+        
+        data = {
+          servers: server_list,
+          count: servers.length
+        }
+        
+        metadata = metadata.merge(operation: "config_list")
+        format_success(data, metadata)
+      end
+
+      def format_config_details(server_config, metadata = {})
+        data = {
+          server_config: server_config.to_h
+        }
+        
+        metadata = metadata.merge(operation: "config_show")
+        format_success(data, metadata)
+      end
+
+      private
+
+      def to_json(data)
+        if pretty
+          JSON.pretty_generate(data, {
+            indent: "  ",
+            space: " ",
+            object_nl: "\n",
+            array_nl: "\n"
+          })
+        else
+          JSON.generate(data)
+        end
+      end
+
+      def normalize_list_data(data)
+        case data
+        when Hash
+          data.fetch("items", [])
+        when Array
+          data
+        when NilClass
+          []
+        else
+          [data]
+        end
+      end
+
+      def build_server_description(config)
+        case config.transport
+        when "stdio"
+          "#{config.command.join(' ')} (stdio)"
+        when "sse"
+          "#{config.url} (sse)"
+        when "websocket"
+          "#{config.url} (websocket)"
+        else
+          "#{config.transport} transport"
+        end
+      end
+    end
+  end
+end