rubygems_mcp 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1d6300f5e71b96d4ef7df1909e03c52555440cf794bc8afb46f5b1e6f75310e
-  data.tar.gz: 1727f6cbf963a35862eec6557da0d7008ea6fac4714614d2305aca1aec93a24c
+  metadata.gz: 792f4e1e9055f0daca5acf09de1b71cdaa64a203808f9f71463d5cb7d67544e1
+  data.tar.gz: cc8a4b2af63e9b96534aae1aee6aeeb572fee2fd602d1d648d29b50c391fb9e5
 SHA512:
-  metadata.gz: b4e6bf57c3302cac5c5c74e99b0060e12b192befec7d7007c36e81d41dd45f2892f12eb73e315a7502c29686ef38abbd0f652012ee9e310ca38eb96729590182
-  data.tar.gz: a756f8c5da8e2a7d36e4c9e1c07427a102e9ca97fae9ba895ff41ecfa37c4449d14c26e6991b656b74686cfa36ad9bfcfa42145136f9cd2ab72fb40d505ad614
+  metadata.gz: 5383415d5d7963b119273f486dca440c5af64e490065abfeaab9e3f9d21e03297cf3f0931252909f8fa2ba9d7e777c11101dcf483840ad70a9f1a6a3a96db816
+  data.tar.gz: ba60b3179ad4956457c4cd22e758e3a93a4f9ce4347697c899459003fc4002555077d8d56c0af525c7f0f8d74010fe5148c1ae4e6fb88d2b611e4f2177d28481

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # CHANGELOG
 
+## Unreleased
+
+## 0.2.0 (2026-09-08)
+
+- BREAKING: Require Ruby 3.4
+- BREAKING: Raise `fast-mcp` to `>= 1.6` and `nokogiri` to `~> 1.19`
+- BREAKING: `search_gems` paginates with `limit` and `offset` on the first search page
+- BREAKING: Raise when an MCP version tool receives an invalid sort order
+- Fetch gem changelogs only over HTTPS from GitHub, GitLab, RubyGems, and ruby-lang.org hosts
+- Include the changelog source host on fetch results
+- Read latest gem versions from gem info and keep rows whose dates fail to parse
+- Skip caching empty Ruby changelogs after a GitHub fetch failure
+- Stop reading HTTP bodies whose Content-Length exceeds 5MB
+- Cap the in-memory response cache
+- Paginate and cache the Ruby versions list on first fetch
+- Apply the HTTP size limit to GitHub Ruby changelogs
+- Limit latest-version lookups to 20 gem names
+
 ## 0.1.4 (2025-11-26)
 
 - Add `get_news_releases` tool to fetch all new gem releases from RubyGems.org with pagination (fetches from `/news?page=N`)
@@ -60,4 +78,3 @@
 - Comprehensive test suite with RSpec, VCR cassettes, and WebMock
 - Requires Ruby 3.1 or higher
 - All dependencies use latest compatible versions with pessimistic versioning for security
-

data/README.md

@@ -1,6 +1,6 @@
 # rubygems_mcp
 
-[![Gem Version](https://badge.fury.io/rb/rubygems_mcp.svg?v=0.1.3)](https://badge.fury.io/rb/rubygems_mcp) [![Test Status](https://github.com/amkisko/rubygems_mcp.rb/actions/workflows/test.yml/badge.svg)](https://github.com/amkisko/rubygems_mcp.rb/actions/workflows/test.yml) [![codecov](https://codecov.io/gh/amkisko/rubygems_mcp.rb/graph/badge.svg?token=APQ6AK7EC9)](https://codecov.io/gh/amkisko/rubygems_mcp.rb)
+[![Gem Version](https://badge.fury.io/rb/rubygems_mcp.svg?v=0.2.0)](https://badge.fury.io/rb/rubygems_mcp) [![Test Status](https://github.com/amkisko/rubygems_mcp.rb/actions/workflows/test.yml/badge.svg)](https://github.com/amkisko/rubygems_mcp.rb/actions/workflows/test.yml) [![codecov](https://codecov.io/gh/amkisko/rubygems_mcp.rb/graph/badge.svg?token=APQ6AK7EC9)](https://app.codecov.io/github/amkisko/rubygems_mcp.rb) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=amkisko_rubygems_mcp.rb&metric=alert_status)](https://sonarcloud.io/project/overview?id=amkisko_rubygems_mcp.rb)
 
 Ruby gem providing RubyGems and Ruby version information via MCP (Model Context Protocol) server tools. Integrates with MCP-compatible clients like Cursor IDE, Claude Desktop, and other MCP-enabled tools.
 
@@ -14,7 +14,7 @@ Sponsored by [Kisko Labs](https://www.kiskolabs.com).
 
 ## Requirements
 
-- **Ruby 3.1 or higher** (Ruby 3.0 and earlier are not supported)
+- **Ruby 3.4 or higher**
 
 ## Quick Start
 
@@ -103,7 +103,7 @@ The server will start and communicate via STDIN/STDOUT using the MCP protocol.
 
 - **RubyGems API Client**: Full-featured client for RubyGems REST API with comprehensive endpoint coverage
 - **Ruby Version Information**: Fetch Ruby release information, changelogs, and maintenance status from ruby-lang.org
-- **MCP Server Integration**: Ready-to-use MCP server with 19 tools and 4 resources, compatible with Cursor IDE, Claude Desktop, and other MCP-enabled tools
+- **MCP Server Integration**: Ready-to-use MCP server with 18 tools and 4 resources, compatible with Cursor IDE, Claude Desktop, and other MCP-enabled tools
 - **Pagination & Sorting**: Support for large result sets with customizable pagination and sorting options
 - **Caching**: In-memory caching with configurable TTL for improved performance
 - **Error Handling**: Graceful error handling with custom exceptions and response size limits
@@ -286,7 +286,7 @@ The MCP server provides the following tools:
    - Parameters: `gem_name` (string), `version` (optional string, uses latest if not provided)
 
 13. **search_gems** - Search for gems by name on RubyGems
-   - Parameters: `query` (string)
+   - Parameters: `query` (string), `limit` (optional integer), `offset` (optional integer)
 
 14. **get_ruby_roadmap** - Get Ruby roadmap information from bugs.ruby-lang.org showing planned versions and their issues
    - Parameters: none
@@ -327,10 +327,7 @@ The MCP server provides the following resources:
 
 ## Error Handling
 
-The client handles errors gracefully:
-- Returns empty arrays for failed requests
-- Returns empty hashes for failed gem info requests
-- Handles network errors and JSON parsing errors
+HTTP failures raise `NotFoundError`, `ServerError`, or `APIError`. Unreadable JSON or HTML raises `CorruptedDataError`. Bodies over 5MB raise `ResponseSizeExceededError`. Invalid input, including more than 20 names on `get_latest_versions`, raises `ValidationError`.
 
 ## Development
 
@@ -372,6 +369,18 @@ For more information, see [CONTRIBUTING.md](CONTRIBUTING.md).
 
 If you discover a security vulnerability, please report it responsibly. See [SECURITY.md](SECURITY.md) for details.
 
+## Links
+
+- [GitHub](https://github.com/amkisko/rubygems_mcp.rb)
+- [GitLab](https://gitlab.com/amkisko/rubygems_mcp.rb)
+- [RubyGems](https://rubygems.org/gems/rubygems_mcp)
+- [libraries.io](https://libraries.io/rubygems/rubygems_mcp)
+- [Deps.dev](https://deps.dev/rubygems/rubygems_mcp)
+- [SonarCloud](https://sonarcloud.io/project/overview?id=amkisko_rubygems_mcp.rb)
+- [Snyk](https://snyk.io/test/github/amkisko/rubygems_mcp.rb)
+- [Codecov](https://app.codecov.io/github/amkisko/rubygems_mcp.rb)
+- [OpenSSF Scorecard](https://scorecard.dev/viewer/?uri=github.com/amkisko/rubygems_mcp.rb)
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/rubygems_mcp/cache.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RubygemsMcp
+  class Cache
+    MAX_ENTRIES = 256
+
+    def initialize(max_entries: MAX_ENTRIES)
+      @cache = {}
+      @mutex = Mutex.new
+      @inflight = {}
+      @max_entries = max_entries
+    end
+
+    def get(key)
+      @mutex.synchronize { read_unlocked(key) }
+    end
+
+    def set(key, value, ttl_seconds)
+      @mutex.synchronize { write_unlocked(key, value, ttl_seconds) }
+    end
+
+    def fetch(key, ttl_seconds)
+      cached = get(key)
+      return cached unless cached.nil?
+
+      lock = @mutex.synchronize { @inflight[key] ||= Mutex.new }
+      lock.synchronize do
+        cached = get(key)
+        return cached unless cached.nil?
+
+        value = yield
+        set(key, value, ttl_seconds)
+        value
+      ensure
+        @mutex.synchronize { @inflight.delete(key) if @inflight[key].equal?(lock) }
+      end
+    end
+
+    def clear
+      @mutex.synchronize do
+        @cache.clear
+        @inflight.clear
+      end
+    end
+
+    def size
+      @mutex.synchronize { @cache.size }
+    end
+
+    private
+
+    def read_unlocked(key)
+      entry = @cache[key]
+      return nil unless entry
+
+      if entry[:expires_at] < Time.now
+        @cache.delete(key)
+        return nil
+      end
+
+      entry[:value]
+    end
+
+    def write_unlocked(key, value, ttl_seconds)
+      evict_unlocked if @cache.size >= @max_entries && !@cache.key?(key)
+      @cache.delete(key)
+      @cache[key] = {value: value, expires_at: Time.now + ttl_seconds}
+    end
+
+    def evict_unlocked
+      now = Time.now
+      @cache.delete_if { |_key, entry| entry[:expires_at] < now }
+      @cache.shift while @cache.size >= @max_entries
+    end
+  end
+end

data/lib/rubygems_mcp/client.rb

@@ -4,6 +4,8 @@ require "openssl"
 require "json"
 require "date"
 require "nokogiri"
+require_relative "cache"
+require_relative "network_policy"
 
 module RubygemsMcp
   # RubyGems and Ruby version API client
@@ -20,6 +22,7 @@ module RubygemsMcp
     # Validation constants
     VALID_SORT_ORDERS = %i[version_desc version_asc date_desc date_asc].freeze
     MAX_LIMIT = 1000 # Reasonable upper bound for pagination
+    MAX_GEM_NAMES = 20
 
     RUBYGEMS_API_BASE = "https://rubygems.org/api/v1"
     RUBYGEMS_API_V2_BASE = "https://rubygems.org/api/v2"
@@ -29,43 +32,8 @@ module RubygemsMcp
     RUBY_ROADMAP_URL = "https://bugs.ruby-lang.org/projects/ruby-master/roadmap"
     RUBY_BUGS_BASE = "https://bugs.ruby-lang.org"
     GITHUB_RUBY_REPO = "https://api.github.com/repos/ruby/ruby"
+    GITHUB_MISS_TTL = 300
 
-    # Simple in-memory cache with TTL
-    class Cache
-      def initialize
-        @cache = {}
-        @mutex = Mutex.new
-      end
-
-      def get(key)
-        @mutex.synchronize do
-          entry = @cache[key]
-          return nil unless entry
-
-          if entry[:expires_at] < Time.now
-            @cache.delete(key)
-            return nil
-          end
-
-          entry[:value]
-        end
-      end
-
-      def set(key, value, ttl_seconds)
-        @mutex.synchronize do
-          @cache[key] = {
-            value: value,
-            expires_at: Time.now + ttl_seconds
-          }
-        end
-      end
-
-      def clear
-        @mutex.synchronize { @cache.clear }
-      end
-    end
-
-    # Shared cache instance
     @cache = Cache.new
 
     class << self
@@ -85,19 +53,11 @@ module RubygemsMcp
     # @return [Array<Hash>] Array of hashes with selected fields
     def get_latest_versions(gem_names, fields: nil)
       raise ValidationError, "gem_names cannot be empty" if gem_names.nil? || gem_names.empty?
-      gem_names = gem_names.map { |name| validate_gem_name(name) }
-      gem_names.map do |name|
-        versions = get_gem_versions(name, limit: 1, fields: fields)
-        latest = versions.first # Versions are sorted by version number descending
-        if latest
-          result = latest.dup
-          result[:name] = name
-          result
-        else
-          base_result = {name: name, version: nil, release_date: nil, license: nil}
-          select_fields([base_result], fields).first || base_result
-        end
+      if gem_names.length > MAX_GEM_NAMES
+        raise ValidationError, "gem_names cannot exceed #{MAX_GEM_NAMES} names"
       end
+      gem_names = gem_names.map { |name| validate_gem_name(name) }
+      gem_names.map { |name| latest_version_from_gem_info(name, fields: fields) }
     end
 
     # Get all versions for a single gem
@@ -142,34 +102,7 @@ module RubygemsMcp
 
       return [] if response.empty?
 
-      versions = response.map do |version_data|
-        original_version = version_data["number"]
-        next unless original_version.match?(/^\d+\.\d+\.\d+$/)
-
-        version = Gem::Version.new(original_version)
-        release_date = version_data["created_at"] ? Date.parse(version_data["created_at"]) : nil
-        built_at = version_data["built_at"] ? Date.parse(version_data["built_at"]) : nil
-
-        version_hash = {
-          version: version.to_s,
-          release_date: release_date&.iso8601,
-          built_at: built_at&.iso8601,
-          license: version_data["licenses"]&.first,
-          prerelease: version_data["prerelease"] || false,
-          platform: version_data["platform"] || "ruby",
-          ruby_version: version_data["ruby_version"],
-          rubygems_version: version_data["rubygems_version"],
-          downloads_count: version_data["downloads_count"],
-          sha: version_data["sha"],
-          spec_sha: version_data["spec_sha"],
-          requirements: version_data["requirements"] || [],
-          metadata: version_data["metadata"] || {}
-        }
-
-        version_hash
-      end
-
-      versions = versions.compact
+      versions = response.filter_map { |version_data| gem_version_row(version_data) }
 
       # Cache for 1 hour (gem versions don't change once published)
       self.class.cache.set(cache_key, versions, 3600) if @cache_enabled
@@ -341,10 +274,13 @@ module RubygemsMcp
       end
 
       # Sort and convert dates to ISO 8601 strings for JSON serialization
-      versions.compact.sort_by { |v| Gem::Version.new(v[:version]) }.reverse.map do |v|
+      versions = versions.compact.sort_by { |v| Gem::Version.new(v[:version]) }.reverse.map do |v|
         v[:release_date] = v[:release_date]&.iso8601
         v
       end
+
+      self.class.cache.set(cache_key, versions, 86400) if @cache_enabled
+      apply_pagination_and_sort(versions, limit: limit, offset: offset, sort: sort)
     end
 
     # Get full changelog content for a Ruby version from release notes
@@ -386,8 +322,8 @@ module RubygemsMcp
         return cached if cached
       end
 
-      uri = URI(release_notes_url)
-      response = make_request(uri, parse_html: true)
+      uri, ip_address = NetworkPolicy.validate!(release_notes_url, host_suffixes: %w[ruby-lang.org])
+      response = make_request(uri, parse_html: true, ip_address: ip_address)
 
       content = nil
       github_changelog = nil
@@ -430,8 +366,7 @@ module RubygemsMcp
         github_changelog: github_changelog
       }
 
-      # Cache for 24 hours
-      self.class.cache.set(cache_key, result, 86400) if @cache_enabled
+      self.class.cache.set(cache_key, result, 86400) if @cache_enabled && !content.to_s.empty?
 
       result
     end
@@ -594,51 +529,34 @@ module RubygemsMcp
         return cached if cached
       end
 
-      # Try GitHub API
       uri = URI("#{GITHUB_RUBY_REPO}/releases/tags/#{tag_name}")
       begin
-        http = build_http_client(uri)
-        request = Net::HTTP::Get.new(uri)
-        request["Accept"] = "application/vnd.github+json"
-        request["User-Agent"] = "rubygems_mcp/#{RubygemsMcp::VERSION}"
-
-        response = http.request(request)
+        data = make_request(uri, headers: {"Accept" => "application/vnd.github+json"})
+        unless data.is_a?(Hash)
+          raise CorruptedDataError.new(
+            "Invalid JSON structure: expected Hash, got #{data.class}",
+            uri: uri.to_s
+          )
+        end
 
-        case response
-        when Net::HTTPSuccess
-          # Parse JSON response
-          body = response.body
-          return {version: version, tag_name: tag_name, name: nil, body: nil, published_at: nil, url: nil, error: "Empty response"} if body.nil? || body.empty?
+        result = {
+          version: version,
+          tag_name: tag_name,
+          name: data["name"],
+          body: data["body"],
+          published_at: data["published_at"],
+          url: data["html_url"]
+        }
 
-          begin
-            data = JSON.parse(body.force_encoding("UTF-8"))
-          rescue JSON::ParserError => e
-            raise CorruptedDataError.new(
-              "Failed to parse GitHub API response: #{e.message}",
-              original_error: e,
-              uri: uri.to_s
-            )
-          end
+        self.class.cache.set(cache_key, result, 86400) if @cache_enabled
+        result
+      rescue NotFoundError
+        github_miss_result(version, tag_name, "Release not found on GitHub")
+      rescue ClientError => error
+        raise unless error.status_code == 403
 
-          result = {
-            version: version,
-            tag_name: tag_name,
-            name: data["name"],
-            body: data["body"],
-            published_at: data["published_at"],
-            url: data["html_url"]
-          }
-
-          # Cache for 24 hours
-          self.class.cache.set(cache_key, result, 86400) if @cache_enabled
-
-          result
-        when Net::HTTPNotFound
-          {version: version, tag_name: tag_name, name: nil, body: nil, published_at: nil, url: nil, error: "Release not found on GitHub"}
-        else
-          handle_http_error(response, uri)
-        end
-      rescue APIError
+        github_miss_result(version, tag_name, "GitHub denied access to this release")
+      rescue ResponseSizeExceededError, CorruptedDataError, APIError
         raise
       rescue => e
         raise APIError.new(
@@ -795,12 +713,12 @@ module RubygemsMcp
       validate_version_string(version) if version
       # Get gem info to find changelog_uri
       gem_info = get_gem_info(gem_name)
-      return {gem_name: gem_name, version: nil, changelog_uri: nil, summary: nil, error: "Gem not found"} if gem_info.empty?
+      return {gem_name: gem_name, version: nil, changelog_uri: nil, source_host: nil, summary: nil, error: "Gem not found"} if gem_info.empty?
 
       version ||= gem_info[:version]
       changelog_uri = gem_info[:changelog_uri]
 
-      return {gem_name: gem_name, version: version, changelog_uri: nil, summary: nil, error: "No changelog URI available"} unless changelog_uri
+      return {gem_name: gem_name, version: version, changelog_uri: nil, source_host: nil, summary: nil, error: "No changelog URI available"} unless changelog_uri
 
       cache_key = "gem_changelog:#{gem_name}:#{version}"
 
@@ -809,9 +727,11 @@ module RubygemsMcp
         return cached if cached
       end
 
-      uri = URI(changelog_uri)
-      response = make_request(uri, parse_html: true)
-      return {gem_name: gem_name, version: version, changelog_uri: changelog_uri, summary: nil, error: "Failed to fetch changelog"} unless response
+      uri, ip_address = NetworkPolicy.validate!(changelog_uri)
+      response = make_request(uri, parse_html: true, ip_address: ip_address)
+      unless response
+        return {gem_name: gem_name, version: version, changelog_uri: changelog_uri, source_host: uri.host, summary: nil, error: "Failed to fetch changelog"}
+      end
 
       # Extract the main content - try GitHub release page first, then generic selectors
       content = if changelog_uri.include?("github.com") && changelog_uri.include?("/releases/")
@@ -918,6 +838,7 @@ module RubygemsMcp
         gem_name: gem_name,
         version: version,
         changelog_uri: changelog_uri,
+        source_host: uri.host,
         summary: summary
       }
 
@@ -972,7 +893,8 @@ module RubygemsMcp
         platform: response["platform"] || "ruby",
         sha: response["sha"],
         spec_sha: response["spec_sha"],
-        metadata: response["metadata"] || {}
+        metadata: response["metadata"] || {},
+        version_created_at: response["version_created_at"] || response["created_at"]
       }
 
       # Cache for 1 hour
@@ -1061,20 +983,12 @@ module RubygemsMcp
     #
     # @param query [String] Search query
     # @param limit [Integer, nil] Maximum number of results to return (nil = all)
-    # @param offset [Integer] Number of results to skip (for pagination)
-    # @param page [Integer, nil] Page number (1-based). If provided, overrides offset (page 1 = offset 0, page 2 = offset 30, etc.)
+    # @param offset [Integer] Number of results to skip within the first search.json page
     # @return [Array<Hash>] Array of hashes with gem information
-    def search_gems(query, limit: nil, offset: 0, page: nil)
+    def search_gems(query, limit: nil, offset: 0)
       raise ValidationError, "Search query cannot be empty" if query.nil? || query.strip.empty?
 
-      # Convert page to offset if provided (assuming 30 items per page, which is RubyGems default)
-      if page
-        raise ValidationError, "Page must be positive" if page < 1
-        offset = (page - 1) * 30
-      end
-
       validate_pagination_params(limit: limit, offset: offset)
-      # Don't cache search results as they can change frequently
       uri = URI("#{RUBYGEMS_API_BASE}/search.json")
       uri.query = URI.encode_www_form(query: query)
 
@@ -1092,7 +1006,10 @@ module RubygemsMcp
         }
       end
 
-      # Apply pagination
+      if offset > 0 && offset >= results.length
+        raise ValidationError, "Offset is past the returned results"
+      end
+
       results = results[offset..] if offset > 0
       results = results.first(limit) if limit
       results
@@ -1308,7 +1225,7 @@ module RubygemsMcp
     # @param offset [Integer] Offset value
     # @raise [ValidationError] If pagination parameters are invalid
     def validate_pagination_params(limit:, offset:)
-      raise ValidationError, "Limit must be positive" if limit && limit < 0
+      raise ValidationError, "Limit must be positive" if limit && limit < 1
       raise ValidationError, "Offset must be non-negative" if offset < 0
       raise ValidationError, "Limit cannot exceed #{MAX_LIMIT}" if limit && limit > MAX_LIMIT
     end
@@ -1363,6 +1280,135 @@ module RubygemsMcp
 
     private
 
+    def latest_version_from_gem_info(name, fields: nil)
+      latest_from_info(name, get_gem_info(name), fields: fields)
+    rescue NotFoundError
+      latest_from_info(name, {}, fields: fields)
+    end
+
+    def latest_from_info(name, info, fields: nil)
+      if info.empty?
+        base = {
+          name: name,
+          version: nil,
+          release_date: nil,
+          license: nil,
+          built_at: nil,
+          prerelease: nil,
+          platform: nil,
+          ruby_version: nil,
+          rubygems_version: nil,
+          downloads_count: nil,
+          sha: nil,
+          spec_sha: nil,
+          requirements: nil,
+          metadata: nil
+        }
+        return select_fields([base], fields).first || base
+      end
+
+      version = info[:version]
+      prerelease = begin
+        Gem::Version.new(version).prerelease?
+      rescue ArgumentError, TypeError
+        false
+      end
+
+      result = {
+        name: name,
+        version: version,
+        release_date: parse_optional_date(info[:version_created_at]),
+        license: Array(info[:licenses]).first,
+        built_at: nil,
+        prerelease: prerelease,
+        platform: info[:platform],
+        ruby_version: nil,
+        rubygems_version: nil,
+        downloads_count: info[:version_downloads] || info[:downloads],
+        sha: info[:sha],
+        spec_sha: info[:spec_sha],
+        requirements: nil,
+        metadata: info[:metadata]
+      }
+      select_fields([result], fields).first || result
+    end
+
+    def gem_version_row(version_data)
+      version = Gem::Version.new(version_data["number"])
+
+      {
+        version: version.to_s,
+        release_date: parse_optional_date(version_data["created_at"]),
+        built_at: parse_optional_date(version_data["built_at"]),
+        license: version_data["licenses"]&.first,
+        prerelease: version.prerelease? || version_data["prerelease"] || false,
+        platform: version_data["platform"] || "ruby",
+        ruby_version: version_data["ruby_version"],
+        rubygems_version: version_data["rubygems_version"],
+        downloads_count: version_data["downloads_count"],
+        sha: version_data["sha"],
+        spec_sha: version_data["spec_sha"],
+        requirements: version_data["requirements"] || [],
+        metadata: version_data["metadata"] || {}
+      }
+    rescue ArgumentError
+      nil
+    end
+
+    def parse_optional_date(value)
+      return nil if value.nil? || value.to_s.strip.empty?
+
+      Date.parse(value.to_s).iso8601
+    rescue Date::Error
+      nil
+    end
+
+    def github_miss_result(version, tag_name, error)
+      result = {
+        version: version,
+        tag_name: tag_name,
+        name: nil,
+        body: nil,
+        published_at: nil,
+        url: nil,
+        error: error
+      }
+      self.class.cache.set("ruby_github_changelog:#{version}", result, GITHUB_MISS_TTL) if @cache_enabled
+      result
+    end
+
+    def read_limited_body(response, uri, parse_html:)
+      content_length = response["Content-Length"]&.to_i
+      if content_length && content_length > MAX_RESPONSE_SIZE
+        raise ResponseSizeExceededError.new(content_length, MAX_RESPONSE_SIZE, uri: uri.to_s)
+      end
+
+      chunks = +""
+      response.read_body do |chunk|
+        chunks << chunk
+        if chunks.bytesize > MAX_RESPONSE_SIZE
+          raise ResponseSizeExceededError.new(chunks.bytesize, MAX_RESPONSE_SIZE, uri: uri.to_s)
+        end
+      end
+
+      if parse_html
+        validate_and_parse_html(chunks, uri)
+      else
+        validate_and_parse_json(chunks, uri)
+      end
+    end
+
+    def html_title(body)
+      match = body.match(%r{<title[^>]*>(.*?)</title>}im)
+      match && match[1]
+    end
+
+    def crawler_protection_title?(title)
+      return false if title.nil? || title.strip.empty?
+
+      title.match?(/cloudflare|ddos protection|access denied|captcha/i)
+    end
+
     # Apply pagination and sorting to a version array
     #
     # @param versions [Array<Hash>] Array of version hashes
@@ -1408,8 +1454,9 @@ module RubygemsMcp
     #
     # @param uri [URI] URI object for the request
     # @return [Net::HTTP] Configured HTTP client
-    def build_http_client(uri)
+    def build_http_client(uri, ip_address: nil)
       http = Net::HTTP.new(uri.host, uri.port)
+      http.ipaddr = ip_address if ip_address
       http.read_timeout = 10
       http.open_timeout = 10
 
@@ -1431,36 +1478,27 @@ module RubygemsMcp
       http
     end
 
-    def make_request(uri, parse_html: false)
-      http = build_http_client(uri)
+    def make_request(uri, parse_html: false, ip_address: nil, headers: {})
+      http = build_http_client(uri, ip_address: ip_address)
 
       request = Net::HTTP::Get.new(uri)
       request["Accept"] = parse_html ? "text/html" : "application/json"
       request["User-Agent"] = "rubygems_mcp/#{RubygemsMcp::VERSION}"
+      headers.each { |name, value| request[name] = value }
 
-      response = http.request(request)
+      parsed = nil
+      response = http.request(request) do |http_response|
+        next unless http_response.is_a?(Net::HTTPSuccess)
 
-      case response
-      when Net::HTTPSuccess
-        # Check response size before processing
-        # Note: response.body may be nil for some responses, so check first
-        response_body = response.body || ""
-        response_size = response_body.bytesize
-        if response_size > MAX_RESPONSE_SIZE
-          raise ResponseSizeExceededError.new(response_size, MAX_RESPONSE_SIZE, uri: uri.to_s)
-        end
+        parsed = read_limited_body(http_response, uri, parse_html: parse_html)
+      end
 
-        # Validate and parse response
-        if parse_html
-          validate_and_parse_html(response_body, uri)
-        else
-          validate_and_parse_json(response_body, uri)
-        end
+      if response.is_a?(Net::HTTPSuccess)
+        parsed
       else
         handle_http_error(response, uri)
       end
     rescue ResponseSizeExceededError, CorruptedDataError
-      # Re-raise our custom errors as-is (don't cache corrupted data)
       raise
     rescue OpenSSL::SSL::SSLError => e
       raise APIError.new(
@@ -1468,7 +1506,6 @@ module RubygemsMcp
         uri: uri.to_s
       )
     rescue APIError, NotFoundError, ServerError, ClientError
-      # Re-raise API errors as-is
       raise
     rescue => e
       raise APIError.new(
@@ -1483,9 +1520,7 @@ module RubygemsMcp
     # @return [Hash, Array] Parsed JSON data
     # @raise [CorruptedDataError] If JSON is invalid or corrupted
     def validate_and_parse_json(body, uri)
-      # Check for common crawler protection patterns
-      # Only check if body looks like HTML (starts with <) to avoid false positives
-      if body.strip.start_with?("<") && body.match?(/cloudflare|ddos protection|access denied|blocked|captcha/i)
+      if body.strip.start_with?("<") && crawler_protection_title?(html_title(body))
         raise CorruptedDataError.new(
           "Response appears to be a crawler protection page from #{uri}",
           response_size: body.bytesize,
@@ -1532,16 +1567,6 @@ module RubygemsMcp
     # @return [Nokogiri::HTML::Document] Parsed HTML document
     # @raise [CorruptedDataError] If HTML is invalid or appears to be an error page
     def validate_and_parse_html(body, uri)
-      # Check for common crawler protection patterns
-      if body.match?(/cloudflare|ddos protection|access denied|blocked|captcha|rate limit/i)
-        raise CorruptedDataError.new(
-          "Response appears to be a crawler protection page from #{uri}",
-          response_size: body.bytesize,
-          uri: uri.to_s
-        )
-      end
-
-      # Check if response is actually HTML
       unless body.strip.start_with?("<!DOCTYPE", "<html", "<HTML") || body.include?("<html")
         raise CorruptedDataError.new(
           "Response from #{uri} does not appear to be HTML",
@@ -1553,7 +1578,6 @@ module RubygemsMcp
       begin
         doc = Nokogiri::HTML(body)
 
-        # Check if HTML is empty or appears to be an error page
         if doc.text.strip.length < 50
           raise CorruptedDataError.new(
             "HTML response from #{uri} appears to be empty or too short",
@@ -1562,18 +1586,9 @@ module RubygemsMcp
           )
         end
 
-        # Check for common error page indicators
-        error_indicators = [
-          /error 404/i,
-          /page not found/i,
-          /access denied/i,
-          /forbidden/i,
-          /internal server error/i
-        ]
-
-        if error_indicators.any? { |pattern| doc.text.match?(pattern) }
+        if crawler_protection_title?(doc.at_css("title")&.text)
           raise CorruptedDataError.new(
-            "HTML response from #{uri} appears to be an error page",
+            "Response appears to be a crawler protection page from #{uri}",
             response_size: body.bytesize,
             uri: uri.to_s
           )

data/lib/rubygems_mcp/network_policy.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+require "socket"
+require "uri"
+
+module RubygemsMcp
+  class NetworkPolicy
+    ALLOWED_SCHEMES = %w[https].freeze
+    ALLOWED_HOST_SUFFIXES = %w[
+      github.com
+      githubusercontent.com
+      gitlab.com
+      rubygems.org
+      ruby-lang.org
+    ].freeze
+    FORBIDDEN_RANGES = %w[
+      0.0.0.0/8 10.0.0.0/8 100.64.0.0/10 127.0.0.0/8
+      169.254.0.0/16 172.16.0.0/12 192.0.0.0/24 192.0.2.0/24
+      192.88.99.0/24 192.168.0.0/16 198.18.0.0/15 198.51.100.0/24
+      203.0.113.0/24 224.0.0.0/4 240.0.0.0/4
+      ::/128 ::1/128 64:ff9b::/96 100::/64 2001::/23 2002::/16
+      fc00::/7 fe80::/10 ff00::/8
+    ].map { |range| IPAddr.new(range) }.freeze
+
+    def self.validate!(url, host_suffixes: ALLOWED_HOST_SUFFIXES)
+      uri = URI.parse(url.to_s)
+      reject! unless ALLOWED_SCHEMES.include?(uri.scheme&.downcase)
+      reject! if uri.host.to_s.empty? || uri.userinfo
+      reject! unless allowed_host?(uri.host, host_suffixes)
+
+      [uri, allowed_ip_address(uri)]
+    rescue URI::InvalidURIError
+      reject!
+    end
+
+    def self.allowed_host?(host, suffixes = ALLOWED_HOST_SUFFIXES)
+      hostname = host.to_s.downcase
+      suffixes.any? { |suffix| hostname == suffix || hostname.end_with?(".#{suffix}") }
+    end
+
+    def self.allowed_ip_address(uri)
+      addresses = Addrinfo.getaddrinfo(uri.host, uri.port, nil, :STREAM)
+        .map(&:ip_address)
+        .uniq
+      reject! if addresses.empty? || addresses.any? { |address| forbidden?(address) }
+
+      addresses.first
+    rescue SocketError, SystemCallError
+      reject!
+    end
+    private_class_method :allowed_ip_address
+
+    def self.forbidden?(address)
+      parsed = IPAddr.new(address.split("%", 2).first)
+      parsed = parsed.native if parsed.ipv4_mapped?
+      FORBIDDEN_RANGES.any? { |range| range.include?(parsed) }
+    rescue IPAddr::InvalidAddressError
+      true
+    end
+    private_class_method :forbidden?
+
+    def self.reject!
+      raise ValidationError, "URL destination is not allowed"
+    end
+    private_class_method :reject!
+  end
+end

data/lib/rubygems_mcp/server.rb

@@ -124,6 +124,15 @@ module RubygemsMcp
       def get_client
         Client.new
       end
+
+      def parse_sort_order(sort)
+        sort_value = sort.to_s
+        unless %w[version_desc version_asc date_desc date_asc].include?(sort_value)
+          raise ValidationError, "Invalid sort order. Must be one of: version_desc, version_asc, date_desc, date_asc"
+        end
+
+        sort_value.to_sym
+      end
     end
 
     # Get latest versions for a list of gems with release dates
@@ -132,7 +141,7 @@ module RubygemsMcp
       description "Get latest versions for a list of gems with release dates and licenses. Supports GraphQL-like field selection."
 
       arguments do
-        required(:gem_names).array(:string, min_size?: 1).description("Array of gem names (e.g., ['rails', 'nokogiri', 'rack'])")
+        required(:gem_names).array(:string, min_size?: 1, max_size?: Client::MAX_GEM_NAMES).description("Array of gem names, at most #{Client::MAX_GEM_NAMES} (e.g., ['rails', 'nokogiri', 'rack'])")
         optional(:fields).array(:string).description("GraphQL-like field selection. Available: name, version, release_date, license, built_at, prerelease, platform, ruby_version, rubygems_version, downloads_count, sha, spec_sha, requirements, metadata")
       end
 
@@ -155,14 +164,7 @@ module RubygemsMcp
       end
 
       def call(gem_name:, limit: nil, offset: 0, sort: "version_desc", fields: nil)
-        valid_sorts = %w[version_desc version_asc date_desc date_asc]
-        sort_value = sort.to_s
-        sort_sym = if valid_sorts.include?(sort_value)
-          sort_value.to_sym
-        else
-          :version_desc
-        end
-        get_client.get_gem_versions(gem_name, limit: limit, offset: offset, sort: sort_sym, fields: fields)
+        get_client.get_gem_versions(gem_name, limit: limit, offset: offset, sort: parse_sort_order(sort), fields: fields)
       end
     end
 
@@ -192,14 +194,7 @@ module RubygemsMcp
       end
 
       def call(limit: nil, offset: 0, sort: "version_desc")
-        valid_sorts = %w[version_desc version_asc date_desc date_asc]
-        sort_value = sort.to_s
-        sort_sym = if valid_sorts.include?(sort_value)
-          sort_value.to_sym
-        else
-          :version_desc
-        end
-        get_client.get_ruby_versions(limit: limit, offset: offset, sort: sort_sym)
+        get_client.get_ruby_versions(limit: limit, offset: offset, sort: parse_sort_order(sort))
       end
     end
 
@@ -350,13 +345,12 @@ module RubygemsMcp
 
       arguments do
         required(:query).filled(:string).description("Search query (e.g., 'rails')")
-        optional(:page).filled(:integer).description("Page number (1-based). If provided, overrides offset")
-        optional(:limit).filled(:integer).description("Maximum number of results to return")
-        optional(:offset).filled(:integer).description("Number of results to skip (for pagination)")
+        optional(:limit).filled(:integer).description("Maximum number of results from the first search.json response")
+        optional(:offset).filled(:integer).description("Number of results to skip within the first search.json response")
       end
 
-      def call(query:, page: nil, limit: nil, offset: 0)
-        get_client.search_gems(query, page: page, limit: limit, offset: offset)
+      def call(query:, limit: nil, offset: 0)
+        get_client.search_gems(query, limit: limit, offset: offset)
       end
     end
 
@@ -490,27 +484,41 @@ module RubygemsMcp
         latest = client.get_latest_ruby_version
         maintenance_status = client.get_ruby_maintenance_status
 
-        # Create a map of version to maintenance status for quick lookup
-        maintenance_status.each_with_object({}) do |status, map|
-          map[status[:version]] = status
-        end
-
         data = {
           latest: latest,
           recent_versions: ruby_versions,
-          maintenance_status: maintenance_status.first(10), # Most recent 10 versions
-          compatibility_notes: {
-            "3.4.x" => "Latest stable series. Normal maintenance. Supports all modern gems.",
-            "3.3.x" => "Stable series. Normal maintenance until 2027. Well-supported by most gems.",
-            "3.2.x" => "Security maintenance only. EOL expected 2026-03-31.",
-            "3.1.x" => "End of life (EOL: 2025-03-26). No longer supported.",
-            "3.0.x" => "End of life (EOL: 2024-04-23). No longer supported.",
-            "2.7.x" => "End of life. No longer supported."
-          }
+          maintenance_status: maintenance_status.first(10),
+          compatibility_notes: compatibility_notes_from(maintenance_status)
         }
 
         JSON.pretty_generate(data)
       end
+
+      private
+
+      def compatibility_notes_from(maintenance_status)
+        maintenance_status.each_with_object({}) do |status, notes|
+          series = status[:version]
+          next if series.nil? || series.empty?
+
+          notes["#{series}.x"] = maintenance_note(status)
+        end
+      end
+
+      def maintenance_note(status)
+        case status[:status]
+        when "normal maintenance"
+          "Normal maintenance until #{status[:normal_maintenance_until]}."
+        when "security maintenance"
+          "Security maintenance only. EOL expected #{status[:eol]}."
+        when "eol"
+          "End of life (EOL: #{status[:eol]}). No longer supported."
+        when "preview"
+          "Preview release."
+        else
+          status[:status].to_s
+        end
+      end
     end
 
     # Resource: Ruby maintenance status for all versions

data/lib/rubygems_mcp/version.rb

@@ -1,3 +1,3 @@
 module RubygemsMcp
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

data/sig/rubygems_mcp.rbs

@@ -34,22 +34,34 @@ module RubygemsMcp
   # Input validation errors
   class ValidationError < Error; end
 
+  class Cache
+    MAX_ENTRIES: Integer
+    def initialize: (?max_entries: Integer) -> void
+    def get: (String key) -> untyped?
+    def set: (String key, untyped value, Integer ttl_seconds) -> void
+    def fetch: (String key, Integer ttl_seconds) { () -> untyped } -> untyped
+    def clear: () -> void
+    def size: () -> Integer
+  end
+
+  class NetworkPolicy
+    ALLOWED_SCHEMES: Array[String]
+    ALLOWED_HOST_SUFFIXES: Array[String]
+    def self.validate!: (String | URI url, ?host_suffixes: Array[String]) -> [URI, String]
+    def self.allowed_host?: (String? host, ?Array[String] suffixes) -> bool
+  end
+
   class Client
     MAX_RESPONSE_SIZE: Integer
     VALID_SORT_ORDERS: Array[Symbol]
     MAX_LIMIT: Integer
-
-    class Cache
-      def initialize: () -> void
-      def get: (String key) -> untyped?
-      def set: (String key, untyped value, Integer ttl_seconds) -> void
-      def clear: () -> void
-    end
+    MAX_GEM_NAMES: Integer
+    GITHUB_MISS_TTL: Integer
 
     def self.cache: () -> Cache
 
     def initialize: (?cache_enabled: bool) -> void
-    def build_http_client: (URI uri) -> Net::HTTP
+    def build_http_client: (URI uri, ?ip_address: String?) -> Net::HTTP
     def validate_and_parse_json: (String body, URI uri) -> (Hash[untyped, untyped] | Array[untyped])
     def validate_and_parse_html: (String body, URI uri) -> Nokogiri::HTML::Document
 
@@ -202,7 +214,7 @@ module RubygemsMcp
     end
 
     class SearchGemsTool < BaseTool
-      def call: (String query) -> Array[Hash[Symbol, untyped]]
+      def call: (String query, ?Integer? limit, ?Integer offset) -> Array[Hash[Symbol, untyped]]
     end
 
     class GetRubyRoadmapTool < BaseTool
@@ -249,6 +261,13 @@ module RubygemsMcp
     def self.register_tools: (untyped server) -> void
     def self.register_resources: (untyped server) -> void
   end
+
+  class NetworkPolicy
+    ALLOWED_SCHEMES: Array[String]
+    FORBIDDEN_RANGES: Array[untyped]
+
+    def self.validate!: (String | URI url) -> [URI, String]
+  end
 end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubygems_mcp
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrei Makarov
@@ -15,7 +15,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.6'
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -25,7 +25,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.6'
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -35,14 +35,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '1.19'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '1.19'
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -85,6 +85,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: polyrun
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.0
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -105,14 +119,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '6.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '6.4'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -133,14 +147,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.22'
+        version: '1.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.22'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: rspec_junit_formatter
   requirement: !ruby/object:Gem::Requirement
@@ -161,14 +175,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: standard
   requirement: !ruby/object:Gem::Requirement
@@ -183,6 +197,76 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.52'
+- !ruby/object:Gem::Dependency
+  name: standard-custom
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: standard-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: standard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: rubocop-thread_safety
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -217,14 +301,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.9'
+        version: '4.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.9'
+        version: '4.2'
 description: Ruby gem providing RubyGems and Ruby version information via MCP server
   tools. Integrates with Cursor IDE via Model Context Protocol.
 email:
@@ -239,8 +323,10 @@ files:
 - README.md
 - bin/rubygems_mcp
 - lib/rubygems_mcp.rb
+- lib/rubygems_mcp/cache.rb
 - lib/rubygems_mcp/client.rb
 - lib/rubygems_mcp/errors.rb
+- lib/rubygems_mcp/network_policy.rb
 - lib/rubygems_mcp/server.rb
 - lib/rubygems_mcp/version.rb
 - sig/rubygems_mcp.rbs
@@ -260,14 +346,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: RubyGems MCP (Model Context Protocol) server for Cursor IDE integration
 test_files: []