elelem-mcp 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a05829dc49559ed0c16cfc5eaf5ac9241fc885c66b5cb6916ade3d6b68047742
+  data.tar.gz: 47b5e8f31f8904bd25ee8e4324cd0a76c710a4c967c98f2758f334f4d484508f
+SHA512:
+  metadata.gz: ae2d3fc5652d3c659b4848d3cc11ad2eb6810d1618c9bd057536ed99598c8c084a86d9f9c4109ef154530d7c6f752bddc4c0b31da9b16644b88d29d0df722026
+  data.tar.gz: b0292705cd0fdc52c9834186fadaed62201c8d61d4ff17c5c311c196bceb203c664b19556edec8c2b27a9ebc190b2665a7b4c8b26d5f6f7ca7cecec5ed425529

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 mo khan
+
+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/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/lib/elelem/mcp/client.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module Elelem
+  module MCP
+    # https://modelcontextprotocol.io/specification/2025-11-25/server/tools.md
+    class Client
+      CONFIG_PATHS = [
+        "~/.agents/mcp.json",
+        ".agents/mcp.json"
+      ].freeze
+
+      def self.memoized
+        @memoized ||= new.tap { |client| at_exit { client.close } }
+      end
+
+      def initialize(configurations = CONFIG_PATHS)
+        @config = load_config(configurations)
+        @servers = {}
+      end
+
+      def tools
+        @config.fetch("mcpServers", {}).flat_map do |name, _|
+          server(name).tools.map do |tool|
+            [
+              "#{name}_#{tool["name"]}",
+              {
+                description: tool["description"],
+                params: tool.dig("inputSchema", "properties") || {},
+                required: tool.dig("inputSchema", "required") || [],
+                fn: ->(a) { server(name).call(tool["name"], a) }
+              }
+            ]
+          end
+        end.to_h
+      end
+
+      def close
+        @servers.each_value(&:close)
+      end
+
+      private
+
+      def load_config(configurations)
+        configurations.each_with_object({}) do |path, merged|
+          file = File.expand_path(path)
+          next unless File.exist?(file)
+
+          config = JSON.parse(IO.read(file))
+          servers = config.fetch("mcpServers", {})
+          merged["mcpServers"] = (merged["mcpServers"] || {}).merge(servers)
+        end
+      end
+
+      def server(name)
+        @servers[name] ||= build_server(@config.dig("mcpServers", name))
+      end
+
+      def build_server(config)
+        if config["type"] == "http"
+          HttpServer.new(url: config["url"], headers: config["headers"] || {})
+        else
+          Server.new(**config.transform_keys(&:to_sym))
+        end
+      end
+    end
+
+    module ServerInterface
+      def tools
+        request("tools/list")["tools"]
+      end
+
+      def call(name, args)
+        result = request("tools/call", { name: name, arguments: args })
+        Elelem.logger.info({ tool: name, args: args, result: result }.to_json)
+        content = extract_content(result)
+        result["isError"] ? { error: content } : { content: content }
+      end
+
+      def extract_content(result)
+        if (structured = result["structuredContent"])
+          structured
+        else
+          result["content"]&.map { |c| c["text"] }&.join("\n")
+        end
+      end
+
+      private
+
+      def handshake!
+        request("initialize", {
+          protocolVersion: "2025-06-18",
+          capabilities: {},
+          clientInfo: { name: "elelem", version: Elelem::MCP::VERSION }
+        })
+        notify("notifications/initialized")
+      end
+    end
+
+    class Server
+      include ServerInterface
+
+      def initialize(command:, args: [], env: {})
+        resolved_env = env.transform_values do |v|
+          v.gsub(/\$\{(\w+)\}/) { ENV[$1] || raise("Missing environment variable: #{$1}") }
+        end
+        @stdin, @stdout, @stderr, @wait = Open3.popen3(resolved_env, command, *args)
+        @id = 0
+        handshake!
+      end
+
+      def close
+        [@stdin, @stdout, @stderr].each do |io|
+          io.close
+        rescue IOError
+          nil
+        end
+        @wait.kill
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def request(method, params = {})
+        send_msg(id: @id += 1, method: method, params: params)
+        read_response(@id)
+      end
+
+      def notify(method, params = {})
+        send_msg(method: method, params: params)
+      end
+
+      def send_msg(msg)
+        @stdin.puts({ jsonrpc: "2.0", **msg }.to_json)
+        @stdin.flush
+      end
+
+      def read_response(id)
+        loop do
+          line = @stdout.gets
+          raise "Server closed" unless line
+
+          msg = JSON.parse(line)
+          return msg["result"] if msg["id"] == id
+          raise msg["error"]["message"] if msg["error"]
+        end
+      end
+    end
+
+    class HttpServer
+      include ServerInterface
+
+      def initialize(url:, headers: {}, read_timeout: 3600, open_timeout: 10)
+        @uri = URI.parse(url)
+        @headers = resolve_headers(headers)
+        @read_timeout = read_timeout
+        @open_timeout = open_timeout
+        @id = 0
+        @session_id = nil
+        handshake!
+      end
+
+      def close; end
+
+      private
+
+      def resolve_headers(headers)
+        headers.transform_values do |v|
+          v.gsub(/\$\{(\w+)\}/) do
+            ENV[$1] || raise("Missing environment variable: #{$1}")
+          end
+        end
+      end
+
+      def request(method, params = {})
+        msg = { jsonrpc: "2.0", id: @id += 1, method: method, params: params }
+        response = post(msg)
+        raise response["error"]["message"] if response["error"]
+
+        response["result"]
+      end
+
+      def notify(method, params = {})
+        msg = { jsonrpc: "2.0", method: method, params: params }
+        post(msg)
+      end
+
+      def post(msg)
+        request = Net::HTTP::Post.new(@uri)
+        request["content-type"] = "application/json"
+        request_headers.each { |k, v| request[k] = v }
+        request.body = JSON.generate(msg)
+
+        http = Net::HTTP.new(@uri.host, @uri.port)
+        http.use_ssl = @uri.scheme == "https"
+        http.read_timeout = @read_timeout
+        http.open_timeout = @open_timeout
+
+        http.start do |conn|
+          conn.request(request) do |response|
+            case response
+            when Net::HTTPSuccess
+              @session_id ||= response["Mcp-Session-Id"]
+              return parse_response(response)
+            when Net::HTTPUnauthorized
+              response.body
+              raise "MCP: server requires OAuth (not yet supported)"
+            else
+              raise "HTTP #{response.code}: #{response.body}"
+            end
+          end
+        end
+      end
+
+      def request_headers
+        base = { "Accept" => "application/json, text/event-stream" }
+        base["Mcp-Session-Id"] = @session_id if @session_id
+        @headers.merge(base)
+      end
+
+      def parse_response(response)
+        if response.content_type&.include?("text/event-stream")
+          parse_sse(response)
+        elsif response.body && !response.body.empty?
+          JSON.parse(response.body)
+        end
+      end
+
+      def parse_sse(response)
+        buffer = String.new
+        result = nil
+
+        response.read_body do |chunk|
+          buffer << chunk
+
+          while (index = buffer.index("\n"))
+            line = buffer.slice!(0, index + 1).strip
+            next unless line.start_with?("data: ")
+
+            result = JSON.parse(line.delete_prefix("data: "))
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/elelem/mcp/token_storage.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Elelem
+  module MCP
+    class TokenStorage
+      STORAGE_DIR = File.expand_path("~/.config/elelem/tokens")
+
+      def initialize
+        FileUtils.mkdir_p(STORAGE_DIR, mode: 0o700)
+      end
+
+      def save(resource_url, access_token:, refresh_token: nil, expires_in: nil)
+        data = {
+          access_token: access_token,
+          refresh_token: refresh_token,
+          expires_at: expires_in ? Time.now.to_i + expires_in : nil
+        }
+        path = token_path(resource_url)
+        File.write(path, data.to_json)
+        File.chmod(0o600, path)
+      end
+
+      def load(resource_url)
+        path = token_path(resource_url)
+        return nil unless File.exist?(path)
+
+        JSON.parse(File.read(path), symbolize_names: true)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def save_client(resource_url, client_data)
+        path = client_path(resource_url)
+        File.write(path, client_data.to_json)
+        File.chmod(0o600, path)
+      end
+
+      def load_client(resource_url)
+        path = client_path(resource_url)
+        return nil unless File.exist?(path)
+
+        JSON.parse(File.read(path), symbolize_names: true)
+      rescue JSON::ParserError
+        nil
+      end
+
+      private
+
+      def token_path(resource_url)
+        hash = Digest::SHA256.hexdigest(resource_url)[0, 16]
+        File.join(STORAGE_DIR, "#{hash}.json")
+      end
+
+      def client_path(resource_url)
+        hash = Digest::SHA256.hexdigest(resource_url)[0, 16]
+        File.join(STORAGE_DIR, "#{hash}_client.json")
+      end
+    end
+  end
+end

data/lib/elelem/mcp/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Elelem
+  module MCP
+    VERSION = "0.1.0"
+  end
+end

data/lib/elelem/mcp.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "digest"
+require "elelem"
+require "fileutils"
+require "json"
+require "net/http"
+require "open3"
+require "uri"
+
+require_relative "mcp/version"
+require_relative "mcp/token_storage"
+require_relative "mcp/client"
+
+Elelem::Plugins.register(:mcp) do |agent|
+  mcp = Elelem::MCP::Client.memoized
+
+  Thread.new do
+    mcp.tools.each do |name, tool|
+      next if agent.toolbox.tools.key?(name)
+
+      agent.toolbox.add(
+        name,
+        description: tool[:description],
+        params: tool[:params],
+        required: tool[:required],
+        &tool[:fn]
+      )
+    end
+  rescue => e
+    warn "MCP failed: #{e.message}"
+  end
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: elelem-mcp
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- mo khan
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: digest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: elelem
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: fileutils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.21'
+- !ruby/object:Gem::Dependency
+  name: net-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: open3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: uri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Adds MCP server tool discovery (stdio and HTTP transports) as elelem
+  tools.
+email:
+- mo@mokhan.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- Rakefile
+- lib/elelem/mcp.rb
+- lib/elelem/mcp/client.rb
+- lib/elelem/mcp/token_storage.rb
+- lib/elelem/mcp/version.rb
+homepage: https://src.mokhan.ca/elelem/mcp
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://src.mokhan.ca/elelem/mcp
+  source_code_uri: https://src.mokhan.ca/elelem/mcp
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: MCP (Model Context Protocol) client support for elelem.
+test_files: []