mcp_cli 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bcbfec231c47b8e10fe71e552a116827b39b2c165f852c1d64983db8efcfa514
+  data.tar.gz: c03bc9fa15d96dff393bb31bd50afe9a91f5808a503ac7ba913398ce15eb8ca7
+SHA512:
+  metadata.gz: 4fcd6595e7045f359ec79fb5a3a24322badf17f17971ce2348b4103fb69fdca118214fdf069ef749204ad68f13233911062433299ed104dedc9e3934604cb0d0
+  data.tar.gz: 637a802a9efac0be603195855d070797dba4bd903ddc784faec8d569989a1fb4824e015eb57c938b4350cd9acd11cf71d5eb97604c90bf27090b6a83d0d6b581

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2025-10-30
+
+### Added
+- Initial release of MCP CLI
+- Support for stdio-based MCP servers
+- Support for HTTP-based MCP servers
+- Commands: list, tools, prompts, resources, call, prompt, info, version, config
+- Auto-discovery of config files (~/.claude.json, ~/.cursor/mcp.json, ~/.vscode/mcp.json)
+- Flexible argument parsing (JSON and flag-style)
+- Zero runtime dependencies (stdlib only)
+- Optimized for `gem exec` usage

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Josh Beckman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,217 @@
+# MCP CLI
+
+A zero-dependency command-line interface for interacting with [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) servers. MCP enables AI assistants to securely connect to local and remote resources through a standardized protocol.
+
+Perfect for developers who need to:
+- Test MCP server implementations
+- Debug server responses
+- Integrate MCP servers into scripts and workflows
+- Explore available tools and resources
+
+Supports both stdio and HTTP transports with automatic configuration discovery.
+
+## Requirements
+
+- Ruby 2.7 or higher
+- RubyGems 3.0 or higher
+- Compatible with macOS, Linux, and Windows
+
+## Quick Start (No Installation)
+
+The fastest way to use MCP CLI is with `gem exec` - no installation required:
+
+```bash
+gem exec mcp_cli list
+gem exec mcp_cli tools my-server
+gem exec mcp_cli call my-server my-tool --arg value
+```
+
+This is perfect for trying out the tool or using it in scripts without adding dependencies.
+
+## Installation (Optional)
+
+If you prefer to install the gem:
+
+```bash
+gem install mcp_cli
+```
+
+Then use it directly:
+
+```bash
+mcp list
+mcp tools my-server
+```
+
+## Configuration
+
+MCP CLI looks for server configurations in these locations (in order):
+
+1. `~/.claude.json`
+2. `~/.cursor/mcp.json`
+3. `~/.vscode/mcp.json`
+
+You can also specify a custom config file:
+
+```bash
+gem exec mcp_cli --mcp-config /path/to/config.json list
+```
+
+Or use shortcuts for default configs:
+
+```bash
+gem exec mcp_cli --mcp-config claude list
+gem exec mcp_cli --mcp-config cursor list
+gem exec mcp_cli --mcp-config vscode list
+```
+
+### Configuration Format
+
+Your config file should follow this structure:
+
+```json
+{
+  "mcpServers": {
+    "my-server": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["/path/to/server.js"],
+      "env": {
+        "API_KEY": "your-key"
+      }
+    },
+    "http-server": {
+      "type": "http",
+      "url": "https://example.com/mcp",
+      "headers": {
+        "Authorization": "Bearer token"
+      }
+    }
+  }
+}
+```
+
+## Usage
+
+### List Available Servers
+
+```bash
+gem exec mcp_cli list
+```
+
+### List Tools
+
+```bash
+# List all tools on a server
+gem exec mcp_cli tools my-server
+
+# Show details for a specific tool
+gem exec mcp_cli tools my-server search_all
+```
+
+### Call a Tool
+
+```bash
+# With JSON arguments
+gem exec mcp_cli call my-server search_all '{"query": "example"}'
+
+# With flag-style arguments
+gem exec mcp_cli call my-server search_all --query example
+
+# Boolean flags
+gem exec mcp_cli call my-server sync --force
+```
+
+### List Prompts
+
+```bash
+gem exec mcp_cli prompts my-server
+```
+
+### Get a Prompt
+
+```bash
+gem exec mcp_cli prompt my-server explain '{"topic": "MCP servers"}'
+```
+
+### List Resources
+
+```bash
+gem exec mcp_cli resources my-server
+```
+
+### Server Information
+
+```bash
+# Full server info
+gem exec mcp_cli info my-server
+
+# Just the version
+gem exec mcp_cli version my-server
+
+# Show configuration
+gem exec mcp_cli config my-server
+```
+
+### Options
+
+```bash
+# Use a specific protocol version
+gem exec mcp_cli --protocol-version 2025-06-18 tools my-server
+
+# Use a custom config file
+gem exec mcp_cli --mcp-config /path/to/config.json list
+
+# Show help
+gem exec mcp_cli --help
+
+# Show version
+gem exec mcp_cli --version
+```
+
+## Features
+
+- **Zero dependencies** - Uses only Ruby standard library
+- **Fast startup** - Minimal overhead for quick commands
+- **Flexible arguments** - Supports both JSON and flag-style arguments
+- **Multiple transports** - Works with stdio and HTTP MCP servers
+- **Config auto-discovery** - Finds your existing MCP configurations
+
+## Troubleshooting
+
+### Server not found
+Ensure your server name matches exactly what's in your config file. Server names are case-sensitive.
+
+### Connection timeout
+For stdio servers, verify the command path exists and is executable. Check that all required dependencies are installed.
+
+### Authentication errors
+Check that environment variables and headers are properly set in your config. For HTTP servers, ensure your authentication tokens are valid.
+
+### No config file found
+MCP CLI looks for configs in `~/.claude.json`, `~/.cursor/mcp.json`, or `~/.vscode/mcp.json`. Create one of these files or specify a custom path with `--mcp-config`.
+
+## Development
+
+```bash
+# Clone the repo
+git clone https://github.com/joshbeckman/mcp_cli.git
+cd mcp_cli
+
+# Install dependencies (just development tools)
+bundle install
+
+# Run tests
+bundle exec rspec
+
+# Test locally with gem exec
+gem exec -g mcp_cli.gemspec mcp list
+```
+
+## License
+
+MIT
+
+## Contributing
+
+Bug reports and pull requests welcome on GitHub at https://github.com/joshbeckman/mcp_cli.

data/exe/mcp

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'mcp_cli'
+
+MCPCli::CLI.new.run(ARGV)

data/lib/mcp_cli/client.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+
+module MCPCli
+  # Client for stdio-based MCP servers
+  class Client
+    def initialize(command, args, env, protocol_version = '2025-06-18')
+      @command = command
+      @args = args || []
+      @env = env
+      @protocol_version = protocol_version
+      @process = nil
+      @reader_thread = nil
+      @message_id = 0
+      @pending_requests = {}
+      @initialized = false
+      @server_info = nil
+    end
+
+    def list_tools
+      ensure_initialized
+      response = send_request('tools/list', {})
+      response['tools'] || []
+    end
+
+    def list_prompts
+      ensure_initialized
+      response = send_request('prompts/list', {})
+      response['prompts'] || []
+    end
+
+    def list_resources
+      ensure_initialized
+      response = send_request('resources/list', {})
+      response['resources'] || []
+    end
+
+    def call_tool(tool_name, arguments)
+      ensure_initialized
+      response = send_request('tools/call', {
+                                name: tool_name,
+                                arguments: arguments
+                              })
+      response['content'] || response
+    end
+
+    def get_prompt(prompt_name, arguments)
+      ensure_initialized
+      response = send_request('prompts/get', {
+                                name: prompt_name,
+                                arguments: arguments
+                              })
+      if response['messages']
+        response['messages'].map { |msg| msg['content']['text'] || msg['content'] }.join("\n\n")
+      else
+        response
+      end
+    end
+
+    def get_server_info
+      ensure_initialized
+      @server_info || {}
+    end
+
+    private
+
+    def ensure_initialized
+      return if @initialized
+
+      start_process
+      response = send_request('initialize', {
+                                protocolVersion: @protocol_version,
+                                capabilities: {
+                                  roots: { listChanged: true },
+                                  sampling: {}
+                                },
+                                clientInfo: {
+                                  name: 'MCP CLI',
+                                  version: MCPCli::VERSION
+                                }
+                              })
+
+      @server_info = response['serverInfo'] if response['serverInfo']
+      @initialized = true
+    end
+
+    def start_process
+      cmd = [@command] + @args
+      @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(@env, *cmd)
+
+      @reader_thread = Thread.new do
+        while (line = @stdout.gets)
+          handle_message(JSON.parse(line))
+        end
+      rescue StandardError => e
+        puts "Reader thread error: #{e.message}"
+      end
+    end
+
+    def send_request(method, params)
+      message_id = next_message_id
+      message = {
+        jsonrpc: '2.0',
+        id: message_id,
+        method: method,
+        params: params
+      }
+
+      @stdin.puts(JSON.generate(message))
+      @stdin.flush
+
+      wait_for_response(message_id)
+    end
+
+    def handle_message(message)
+      return unless message['id'] && @pending_requests[message['id']]
+
+      @pending_requests[message['id']][:response] = message
+      @pending_requests[message['id']][:condition].signal
+    end
+
+    def wait_for_response(message_id)
+      mutex = Mutex.new
+      condition = ConditionVariable.new
+      @pending_requests[message_id] = { condition: condition, response: nil }
+
+      mutex.synchronize do
+        condition.wait(mutex, 30)
+      end
+
+      response = @pending_requests[message_id][:response]
+      @pending_requests.delete(message_id)
+
+      if response.nil?
+        raise 'Timeout waiting for response'
+      elsif response['error']
+        raise "MCP Error: #{response['error']['message']}"
+      end
+
+      response['result']
+    end
+
+    def next_message_id
+      @message_id += 1
+    end
+
+    def cleanup
+      @reader_thread&.kill
+      @stdin&.close
+      @stdout&.close
+      @stderr&.close
+      @wait_thread&.kill
+    end
+  end
+end

data/lib/mcp_cli/http_client.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+require 'securerandom'
+
+module MCPCli
+  # Client for HTTP-based MCP servers
+  class HTTPClient
+    def initialize(url, headers = {}, protocol_version = '2025-06-18')
+      @url = url
+      @headers = headers
+      @protocol_version = protocol_version
+      @initialized = false
+      @server_info = nil
+    end
+
+    def list_tools
+      ensure_initialized
+      response = send_request('tools/list', {})
+      response['tools'] || []
+    end
+
+    def list_prompts
+      ensure_initialized
+      response = send_request('prompts/list', {})
+      response['prompts'] || []
+    end
+
+    def list_resources
+      ensure_initialized
+      response = send_request('resources/list', {})
+      response['resources'] || []
+    end
+
+    def call_tool(tool_name, arguments)
+      ensure_initialized
+      response = send_request('tools/call', {
+                                name: tool_name,
+                                arguments: arguments
+                              })
+      response['content'] || response
+    end
+
+    def get_prompt(prompt_name, arguments)
+      ensure_initialized
+      response = send_request('prompts/get', {
+                                name: prompt_name,
+                                arguments: arguments
+                              })
+      if response['messages']
+        response['messages'].map { |msg| msg['content']['text'] || msg['content'] }.join("\n\n")
+      else
+        response
+      end
+    end
+
+    def get_server_info
+      ensure_initialized
+      @server_info || {}
+    end
+
+    private
+
+    def ensure_initialized
+      return if @initialized
+
+      response = send_request('initialize', {
+                                protocolVersion: @protocol_version,
+                                capabilities: {
+                                  roots: { listChanged: true },
+                                  sampling: {}
+                                },
+                                clientInfo: {
+                                  name: 'MCP CLI',
+                                  version: MCPCli::VERSION
+                                }
+                              })
+
+      @server_info = response['serverInfo'] if response['serverInfo']
+      @initialized = true
+    end
+
+    def send_request(method, params)
+      uri = URI(@url)
+      message = {
+        jsonrpc: '2.0',
+        id: SecureRandom.uuid,
+        method: method,
+        params: params
+      }
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == 'https'
+      http.read_timeout = 30
+
+      request = Net::HTTP::Post.new(uri.path.empty? ? '/' : uri.path)
+      request['Content-Type'] = 'application/json'
+      request['Accept'] = 'text/event-stream, application/json'
+      @headers.each do |key, value|
+        request[key] = value
+      end
+      request.body = JSON.generate(message)
+
+      response = http.request(request)
+      unless response.code == '200'
+        puts "Response headers: #{response.to_hash}" if ENV['DEBUG']
+        puts "Response body: #{response.body}" if ENV['DEBUG']
+        raise "HTTP error: #{response.code} #{response.message}"
+      end
+
+      parse_sse_response(response.body)
+    end
+
+    def parse_sse_response(body)
+      lines = body.split("\n")
+      result = nil
+      error = nil
+
+      lines.each do |line|
+        next if line.strip.empty?
+
+        next unless line.start_with?('data: ')
+
+        data = line[6..]
+        next if data == '[DONE]'
+
+        begin
+          json = JSON.parse(data)
+          if json['error']
+            error = json['error']
+          elsif json['result']
+            result = json['result']
+          end
+        rescue JSON::ParserError
+          puts "Failed to parse SSE data: #{data}" if ENV['DEBUG']
+        end
+      end
+
+      if error
+        raise "MCP Error: #{error['message'] || error.to_s}"
+      elsif result.nil?
+        raise 'No result received from server'
+      end
+
+      result
+    end
+
+    def cleanup
+      # Nothing to clean up for HTTP client
+    end
+  end
+end

data/lib/mcp_cli/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MCPCli
+  VERSION = '1.0.0'
+end

data/lib/mcp_cli.rb

@@ -0,0 +1,554 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'optparse'
+require_relative 'mcp_cli/version'
+require_relative 'mcp_cli/client'
+require_relative 'mcp_cli/http_client'
+
+module MCPCli
+  # Main CLI interface for MCP servers
+  class CLI
+    FILE_NAME = 'mcp'
+
+    def initialize
+      @commands = {
+        'list' => method(:list_servers),
+        'tools' => method(:list_tools),
+        'prompts' => method(:list_prompts),
+        'resources' => method(:list_resources),
+        'call' => method(:call_tool),
+        'prompt' => method(:call_prompt),
+        'info' => method(:show_info),
+        'version' => method(:show_version),
+        'config' => method(:show_config)
+      }
+      @claude_config_path = File.expand_path('~/.claude.json')
+      @cursor_config_path = File.expand_path('~/.cursor/mcp.json')
+      @vscode_config_path = File.expand_path('~/.vscode/mcp.json')
+      @mcp_config_path = nil
+      @protocol_version = '2025-06-18'
+    end
+
+    def run(args)
+      parsed_args = parse_args(args)
+
+      if parsed_args[:version]
+        show_self_version
+        exit 0
+      end
+
+      if parsed_args[:help] || parsed_args[:command].nil?
+        show_help
+        exit 0
+      end
+
+      @mcp_config_path = parsed_args[:mcp_config] if parsed_args[:mcp_config]
+      @protocol_version = parsed_args[:protocol_version]
+      command = parsed_args[:command]
+
+      if @commands.key?(command)
+        @commands[command].call(parsed_args[:args])
+      else
+        puts "Unknown command: #{command}"
+        show_help
+        exit 1
+      end
+    rescue StandardError => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
+
+    private
+
+    def create_mcp_client(server_info)
+      case server_info[:type]
+      when 'stdio'
+        env = ENV.to_h.merge(server_info[:env] || {})
+        MCPCli::Client.new(server_info[:command], server_info[:args], env, @protocol_version)
+      when 'streamable-http', 'http'
+        MCPCli::HTTPClient.new(server_info[:url], server_info[:headers], @protocol_version)
+      else
+        raise "Unsupported server type: #{server_info[:type]}"
+      end
+    end
+
+    def parse_args(args)
+      result = { help: false, version: false, mcp_config: nil, protocol_version: '2025-06-18', command: nil, args: [] }
+      remaining_args = []
+
+      i = 0
+      while i < args.length
+        case args[i]
+        when '--help', '-h'
+          result[:help] = true
+          return result
+        when '--version', '-v'
+          result[:version] = true
+          return result
+        when '--mcp-config'
+          raise '--mcp-config requires a path argument' unless i + 1 < args.length
+
+          result[:mcp_config] = args[i + 1]
+          i += 1
+        when '--protocol-version'
+          raise '--protocol-version requires a version argument' unless i + 1 < args.length
+
+          result[:protocol_version] = args[i + 1]
+          i += 1
+
+        else
+          remaining_args << args[i]
+        end
+        i += 1
+      end
+
+      unless remaining_args.empty?
+        result[:command] = remaining_args[0]
+        result[:args] = remaining_args[1..] || []
+      end
+
+      result
+    end
+
+    def show_self_version
+      puts "#{MCPCli::VERSION} (MCP CLI)"
+    end
+
+    def show_help
+      puts <<~HELP
+        MCP CLI #{MCPCli::VERSION} - Call MCP servers from the command line
+
+        Usage:
+          #{FILE_NAME} list                                 List available MCP servers
+          #{FILE_NAME} tools <server_name> [tool_name]      List tools or show tool details
+          #{FILE_NAME} prompts <server_name>                List prompts available on a server
+          #{FILE_NAME} resources <server_name>              List resources available on a server
+          #{FILE_NAME} call <server_name> <tool> [args]     Call a tool on a server (JSON or --flags)
+          #{FILE_NAME} prompt <server_name> <prompt> [args] Get a prompt from a server
+          #{FILE_NAME} info <server_name>                   Get detailed server information
+          #{FILE_NAME} version <server_name>                Get server version only
+          #{FILE_NAME} config <server_name>                 Show server configuration
+
+        Options:
+          --mcp-config <path>        Path to MCP configuration JSON file
+                                     (defaults to first found: ~/.claude.json, ~/.cursor/mcp.json, ~/.vscode/mcp.json)
+                                     (use 'claude', 'cursor', or 'vscode' to specify a default)
+          --protocol-version <ver>   MCP protocol version (defaults to #{@protocol_version})
+
+        Examples:
+          #{FILE_NAME} list
+          #{FILE_NAME} tools vault
+          #{FILE_NAME} tools vault search_all
+          #{FILE_NAME} prompts vault
+          #{FILE_NAME} resources vault
+          #{FILE_NAME} call vault search_all '{"query": "example"}'
+          #{FILE_NAME} call vault search_all --query example
+          #{FILE_NAME} prompt vault explain '{"topic": "MCP servers"}'
+          #{FILE_NAME} info vault
+          #{FILE_NAME} version vault
+          #{FILE_NAME} config vault
+          #{FILE_NAME} --protocol-version #{@protocol_version} tools vault
+          #{FILE_NAME} --mcp-config /path/to/mcp.json tools vault
+      HELP
+    end
+
+    def list_servers(_args)
+      servers, config_path = load_mcp_servers_with_path
+
+      if servers.empty?
+        puts 'No MCP servers configured'
+      else
+        puts "Available MCP servers (from #{config_path}):"
+        servers.each do |name, config|
+          type = config['type'] || 'stdio'
+          case type
+          when 'stdio'
+            cmd_display = [config['command'], *config['args']].join(' ')
+            puts "  #{name}: #{cmd_display}"
+          when 'streamable-http', 'http'
+            puts "  #{name}: #{config['url']}"
+          else
+            puts "  #{name}: (#{type})"
+          end
+        end
+      end
+    end
+
+    def list_tools(args)
+      if args.empty?
+        puts 'Error: Server name required'
+        puts "Usage: #{FILE_NAME} tools <server_name> [tool_name]"
+        exit 1
+      end
+
+      server_name = args[0]
+      tool_name = args[1]
+
+      servers = load_mcp_servers
+      unless servers.key?(server_name)
+        puts "Error: Server '#{server_name}' not found"
+        exit 1
+      end
+
+      server_info = parse_server_config(server_name, servers[server_name])
+
+      mcp_client = create_mcp_client(server_info)
+      tools = mcp_client.list_tools
+
+      if tools.empty?
+        puts "No tools available on server '#{server_name}'"
+      elsif tool_name
+        # Show details for specific tool
+        tool = tools.find { |t| t['name'] == tool_name }
+        if tool.nil?
+          puts "Error: Tool '#{tool_name}' not found on server '#{server_name}'"
+          exit 1
+        end
+
+        puts "Tool: #{tool['name']}"
+        puts "Server: #{server_name}"
+        puts "\nDescription:"
+        puts "  #{tool['description']}" if tool['description']
+
+        if tool['inputSchema']
+          puts "\nInput Schema:"
+          puts JSON.pretty_generate(tool['inputSchema'])
+        end
+      else
+        # List all tools
+        puts "Tools available on '#{server_name}':"
+        tools.each do |tool|
+          puts "\n  #{tool['name']}"
+          puts "    Description: #{tool['description']}" if tool['description']
+          next unless tool['inputSchema'] && tool['inputSchema']['properties']
+
+          puts '    Parameters:'
+          tool['inputSchema']['properties'].each do |param, schema|
+            required = tool['inputSchema']['required']&.include?(param) ? ' (required)' : ''
+            puts "      - #{param}: #{schema['type']}#{required}"
+            puts "        #{schema['description']}" if schema['description']
+          end
+        end
+      end
+    end
+
+    def list_prompts(args)
+      if args.empty?
+        puts 'Error: Server name required'
+        puts "Usage: #{FILE_NAME} prompts <server_name>"
+        exit 1
+      end
+
+      server_name = args[0]
+      servers = load_mcp_servers
+      unless servers.key?(server_name)
+        puts "Error: Server '#{server_name}' not found"
+        exit 1
+      end
+
+      server_info = parse_server_config(server_name, servers[server_name])
+
+      mcp_client = create_mcp_client(server_info)
+      prompts = mcp_client.list_prompts
+
+      if prompts.empty?
+        puts "No prompts available on server '#{server_name}'"
+      else
+        puts "Prompts available on '#{server_name}':"
+        prompts.each do |prompt|
+          puts "\n  #{prompt['name']}"
+          puts "    Description: #{prompt['description']}" if prompt['description']
+          next unless prompt['arguments']
+
+          puts '    Arguments:'
+          prompt['arguments'].each do |arg|
+            required = arg['required'] ? ' (required)' : ''
+            puts "      - #{arg['name']}#{required}"
+            puts "        #{arg['description']}" if arg['description']
+          end
+        end
+      end
+    end
+
+    def list_resources(args)
+      if args.empty?
+        puts 'Error: Server name required'
+        puts "Usage: #{FILE_NAME} resources <server_name>"
+        exit 1
+      end
+
+      server_name = args[0]
+      servers = load_mcp_servers
+      unless servers.key?(server_name)
+        puts "Error: Server '#{server_name}' not found"
+        exit 1
+      end
+
+      server_info = parse_server_config(server_name, servers[server_name])
+
+      mcp_client = create_mcp_client(server_info)
+      resources = mcp_client.list_resources
+
+      if resources.empty?
+        puts "No resources available on server '#{server_name}'"
+      else
+        puts "Resources available on '#{server_name}':"
+        resources.each do |resource|
+          puts "\n  #{resource['uri']}"
+          puts "    Name: #{resource['name']}" if resource['name']
+          puts "    Description: #{resource['description']}" if resource['description']
+          puts "    MIME type: #{resource['mimeType']}" if resource['mimeType']
+        end
+      end
+    end
+
+    def call_tool(args)
+      if args.length < 2
+        puts 'Error: Server name and tool name required'
+        puts "Usage: #{FILE_NAME} call <server_name> <tool> [arguments]"
+        puts "Arguments can be JSON: '{\"key\": \"value\"}'"
+        puts "Or flags: --key value --key2 value2"
+        exit 1
+      end
+
+      server_name = args[0]
+      tool_name = args[1]
+      remaining_args = args[2..]
+      # Parse tool arguments - either JSON or flags
+      tool_args = if remaining_args.empty?
+        {}
+      elsif remaining_args.length == 1 && remaining_args[0].start_with?('{')
+        JSON.parse(remaining_args[0])
+      else
+        parse_tool_flags(remaining_args)
+      end
+
+      servers = load_mcp_servers
+      unless servers.key?(server_name)
+        puts "Error: Server '#{server_name}' not found"
+        exit 1
+      end
+
+      server_info = parse_server_config(server_name, servers[server_name])
+
+      mcp_client = create_mcp_client(server_info)
+      result = mcp_client.call_tool(tool_name, tool_args)
+
+      puts JSON.pretty_generate(result)
+    end
+
+    def call_prompt(args)
+      if args.length < 2
+        puts 'Error: Server name and prompt name required'
+        puts "Usage: #{FILE_NAME} prompt <server_name> <prompt> [arguments_json]"
+        exit 1
+      end
+
+      server_name = args[0]
+      prompt_name = args[1]
+      prompt_args = args[2] ? JSON.parse(args[2]) : {}
+
+      servers = load_mcp_servers
+      unless servers.key?(server_name)
+        puts "Error: Server '#{server_name}' not found"
+        exit 1
+      end
+
+      server_info = parse_server_config(server_name, servers[server_name])
+
+      mcp_client = create_mcp_client(server_info)
+      result = mcp_client.get_prompt(prompt_name, prompt_args)
+
+      puts result
+    end
+
+    def show_info(args)
+      if args.empty?
+        puts 'Error: Server name required'
+        puts "Usage: #{FILE_NAME} info <server_name>"
+        exit 1
+      end
+
+      server_name = args[0]
+      servers = load_mcp_servers
+      unless servers.key?(server_name)
+        puts "Error: Server '#{server_name}' not found"
+        exit 1
+      end
+
+      server_config = parse_server_config(server_name, servers[server_name])
+
+      mcp_client = create_mcp_client(server_config)
+      server_info = mcp_client.get_server_info
+
+      puts "Server: #{server_name}"
+      puts "Name: #{server_info['name']}" if server_info['name']
+      puts "Version: #{server_info['version']}" if server_info['version']
+      puts "Description: #{server_info['description']}" if server_info['description']
+
+      puts "Protocol Version: #{server_info['protocolVersion']}" if server_info['protocolVersion']
+
+      return unless server_info['capabilities']
+
+      puts "\nCapabilities:"
+      server_info['capabilities'].each do |cap, value|
+        puts "  #{cap}: #{value.inspect}"
+      end
+    end
+
+    def show_version(args)
+      if args.empty?
+        puts 'Error: Server name required'
+        puts "Usage: #{FILE_NAME} version <server_name>"
+        exit 1
+      end
+
+      server_name = args[0]
+      servers = load_mcp_servers
+      unless servers.key?(server_name)
+        puts "Error: Server '#{server_name}' not found"
+        exit 1
+      end
+
+      server_info = parse_server_config(server_name, servers[server_name])
+
+      mcp_client = create_mcp_client(server_info)
+      server_info = mcp_client.get_server_info
+
+      puts server_info['version'] || 'Version information not available'
+    end
+
+    def show_config(args)
+      if args.empty?
+        puts 'Error: Server name required'
+        puts "Usage: #{FILE_NAME} config <server_name>"
+        exit 1
+      end
+
+      server_name = args[0]
+      servers = load_mcp_servers
+      unless servers.key?(server_name)
+        puts "Error: Server '#{server_name}' not found"
+        exit 1
+      end
+
+      server_config = parse_server_config(server_name, servers[server_name])
+
+      puts "Server: #{server_name}"
+      puts "Type: #{server_config[:type]}"
+
+      case server_config[:type]
+      when 'stdio'
+        puts "Command: #{server_config[:command]}"
+        if server_config[:args] && !server_config[:args].empty?
+          puts 'Args:'
+          server_config[:args].each do |arg|
+            puts "  - #{arg}"
+          end
+        end
+        if server_config[:env] && !server_config[:env].empty?
+          puts 'Environment:'
+          server_config[:env].each do |key, value|
+            puts "  #{key}: #{value}"
+          end
+        end
+      when 'streamable-http', 'http'
+        puts "URL: #{server_config[:url]}"
+      end
+    end
+
+    def load_mcp_servers
+      servers, _ = load_mcp_servers_with_path
+      servers
+    end
+
+    def load_mcp_servers_with_path
+      if @mcp_config_path
+        config_path = case @mcp_config_path
+                      when 'claude'
+                        @claude_config_path
+                      when 'cursor'
+                        @cursor_config_path
+                      when 'vscode'
+                        @vscode_config_path
+                      else
+                        @mcp_config_path
+                      end
+        unless File.exist?(config_path)
+          raise "MCP configuration file not found at #{config_path}"
+        end
+      else
+        config_path = [@claude_config_path, @cursor_config_path, @vscode_config_path].find do |path|
+          File.exist?(path)
+        end
+
+        unless config_path
+          raise "No MCP configuration file found. Tried:\n  #{@claude_config_path}\n  #{@cursor_config_path}\n  #{@vscode_config_path}"
+        end
+      end
+
+      config = JSON.parse(File.read(config_path))
+      servers = config['mcpServers'] || config['servers'] || {}
+      [servers, config_path]
+    end
+
+    def parse_server_config(name, config)
+      type = config['type'] || 'stdio'
+
+      case type
+      when 'stdio', nil
+        {
+          name: name,
+          type: type,
+          command: config['command'],
+          args: config['args'] || [],
+          env: config['env'] || {}
+        }
+      when 'streamable-http', 'http'
+        {
+          name: name,
+          type: type,
+          url: config['url'],
+          headers: config['headers'] || {},
+        }
+      else
+        raise "Server '#{name}' has unsupported type: #{type}"
+      end
+    end
+
+    def parse_tool_flags(args)
+      result = {}
+      i = 0
+      while i < args.length
+        arg = args[i]
+        if arg.start_with?('--')
+          key = arg[2..] # Remove '--' prefix
+          # Check if there's a value following this flag
+          if i + 1 < args.length && !args[i + 1].start_with?('--')
+            # Next argument is the value
+            value = args[i + 1]
+            # Try to parse the value as JSON if it looks like JSON
+            result[key] = if value =~ /^(\{|\[|true|false|null|\d+(\.\d+)?$)/
+              begin
+                JSON.parse(value)
+              rescue JSON::ParserError
+                value # If parsing fails, use as string
+              end
+            else
+              value
+            end
+            i += 2
+          else
+            # Boolean flag without a value
+            result[key] = true
+            i += 1
+          end
+        else
+          raise "Invalid argument: '#{arg}'. Arguments must be in --key value format or JSON."
+        end
+      end
+      result
+    end
+  end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: mcp_cli
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Josh Beckman
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Command-line interface for interacting with MCP (Model Context Protocol)
+  servers. Supports stdio and HTTP transports.
+email:
+- josh@joshbeckman.org
+executables:
+- mcp
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- exe/mcp
+- lib/mcp_cli.rb
+- lib/mcp_cli/client.rb
+- lib/mcp_cli/http_client.rb
+- lib/mcp_cli/version.rb
+homepage: https://github.com/joshbeckman/mcp_cli
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/joshbeckman/mcp_cli
+  source_code_uri: https://github.com/joshbeckman/mcp_cli
+  documentation_uri: https://github.com/joshbeckman/mcp_cli#readme
+  changelog_uri: https://github.com/joshbeckman/mcp_cli/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: CLI for Model Context Protocol servers
+test_files: []