foobara-mcp-connector 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7f2399bed1c8f29efdfd89bf12b38251d74eece5ece41708e5ce04bc8838fd3
-  data.tar.gz: e73a8e7afecf4792a62c87097b78488d52f7913e752c7d63ccc37ede25a2505d
+  metadata.gz: 907ef0b728ab96d109ef5db1a5938a322537dc97b442d36386fcdbb8826fbcee
+  data.tar.gz: afef5e6b376f2f50cc630b535d0edc0f110d4421c5540ce33322b55e4ffc5c89
 SHA512:
-  metadata.gz: 6f007511b3ea56495751b0d184b79190d6a07efc19e142bfa6e557f5ea039523762fb6ac0da55e67a89ffde52be40317e44a3b7a9c17ce97121122fd98139498
-  data.tar.gz: b2deac186cd83fd33268ca054f3d022c8ae47e60849d3f1f9347e608c709645d85a33107c4210e5b0b7dde9e07c8b610759841d1f87496fcd5f208f095063351
+  metadata.gz: a43ce9d80d6f3540b4cb62e52c616758d1fb322d43d418405e90bc2226ac30406663659171c2f87e43483d4d20118569777cf3b0ff04cf3f5d29ba278917fc6a
+  data.tar.gz: c8a6234d60d32123cd97cc7fd6abfe8f98cf183b43e627b079094806f84ff4a159772da5002d0f895dd88b56e32d12b88103546e1cd3de165c8441b408ee05d0

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.0.5] - 2025-05-03
+
+- Handle changes to CommandConnector interface
+
+## [0.0.4] - 2025-04-14
+
+- Do not log requests/responses/errors by default
+
 ## [0.0.3] - 2025-04-14
 
 - Grab version from gemspec instead of version.rb

data/README.md

@@ -6,6 +6,8 @@ Exposes Foobara commands according to the Model Context Protocol (MCP) specifica
 * [Foobara::McpConnector](#foobaramcpconnector)
   * [Installation](#installation)
   * [Usage](#usage)
+    * [Code demo video!](#code-demo-video)
+    * [Code examples](#code-examples)
     * [Super basic example](#super-basic-example)
     * [An example with entities](#an-example-with-entities)
     * [A destructive example](#a-destructive-example)
@@ -21,6 +23,12 @@ Typical stuff: add `gem "foobara-mcp-connector` to your Gemfile or .gemspec file
 
 ## Usage
 
+### Code demo video!
+
+You can watch a code demo here: https://youtu.be/_w3ZHdiJEGU
+
+### Code examples
+
 You can find examples in `examples/`
 
 ### Super basic example

data/src/jsonrpc_request.rb

@@ -2,12 +2,29 @@ module Foobara
   class McpConnector < CommandConnector
     # Isolating jsonrpc specific logic to this abstract class
     class JsonrpcRequest < CommandConnector::Request
-      class InvalidJsonrpcVersionError < StandardError; end
-      class InvalidJsonrpcMethodError < StandardError; end
-      class InvalidJsonrpcParamsError < StandardError; end
-      class InvalidJsonrpcRequestStructureError < StandardError; end
-      class EmptyBatchError < StandardError; end
-      class InvalidJsonError < StandardError; end
+      class InvalidJsonrpcVersionError < Foobara::Error
+        context({})
+      end
+
+      class InvalidJsonrpcMethodError < Foobara::Error
+        context({})
+      end
+
+      class InvalidJsonrpcParamsError < Foobara::Error
+        context({})
+      end
+
+      class InvalidJsonrpcRequestStructureError < Foobara::Error
+        context({})
+      end
+
+      class EmptyBatchError < Foobara::Error
+        context({})
+      end
+
+      class InvalidJsonError < Foobara::Error
+        context({})
+      end
 
       # TODO: push response into base class?
       attr_accessor :raw_request_json, :parsed_request_body, :request_id, :batch, :is_batch_child
@@ -45,7 +62,9 @@ module Foobara
                                      begin
                                        JSON.parse(raw_request_json)
                                      rescue => e
-                                       self.error = InvalidJsonError.new("Could not parse request: #{e.message}")
+                                       self.error = InvalidJsonError.new(
+                                         message: "Could not parse request: #{e.message}"
+                                       )
                                        error.set_backtrace(caller)
                                        nil
                                      end
@@ -62,7 +81,9 @@ module Foobara
 
       def verify_jsonrpc_version
         if parsed_request_body["jsonrpc"] != "2.0"
-          self.error = InvalidJsonrpcVersionError.new("Unsupported jsonrpc version: #{parsed_request_body["jsonrpc"]}")
+          self.error = InvalidJsonrpcVersionError.new(
+            message: "Unsupported jsonrpc version: #{parsed_request_body["jsonrpc"]}"
+          )
           error.set_backtrace(caller)
         end
       end
@@ -93,7 +114,9 @@ module Foobara
 
       def validate_batch_not_empty
         if batch? && batch.empty?
-          self.error = EmptyBatchError.new("An empty array/batch is not allowed")
+          self.error = EmptyBatchError.new(
+            message: "An empty array/batch is not allowed"
+          )
           error.set_backtrace(caller)
         end
       end
@@ -101,7 +124,7 @@ module Foobara
       def validate_request_structure
         unless parsed_request_body.is_a?(::Hash)
           self.error = InvalidJsonrpcRequestStructureError.new(
-            "Invalid jsonrpc request structure. Expected a hash but got a #{parsed_request_body.class}"
+            message: "Invalid jsonrpc request structure. Expected a hash but got a #{parsed_request_body.class}"
           )
           error.set_backtrace(caller)
         end

data/src/mcp_connector.rb

@@ -32,57 +32,49 @@ module Foobara
       "This is a Foobara MCP command connector which exposes Foobara commands to you as tools that you can invoke."
     end
 
-    # TODO: how to stream content out instead of buffering it up?
     def run(*args, **opts, &)
-      File.open("mcp-connector.log", "a") do |f|
-        f.puts("#{Time.now}: Request: #{args.first.strip}")
-        f.flush
-      end
-      super.body.tap do |response|
-        File.open("mcp-connector.log", "a") do |f|
-          f.puts("#{Time.now}: Response: #{response&.strip}")
-          f.flush
-        end
-      end
-    rescue => e
-      File.open("mcp-connector.log", "a") do |f|
-        f.puts("#{Time.now}: Error: #{e}")
-        f.flush
-      end
-      raise
+      super.body
     end
 
     def run_stdio_server(io_in: $stdin, io_out: $stdout, io_err: $stderr)
       StdioRunner.new(self).run(io_in: io_in, io_out: io_out, io_err: io_err)
     end
 
-    def request_to_command(request)
-      action = request.action
-
+    def request_to_command_class(request)
       return if request.error?
 
-      case action
-      when "initialize"
-        command_class = find_builtin_command_class("Initialize")
-      when "notifications/initialized", "notifications/cancelled", "notifications/progress",
-        "notifications/roots/list_changed"
-        command_class = find_builtin_command_class("Noop")
-      else
-        return super
-      end
+      builtin_command_class_name = case request.action
+                                   when "initialize"
+                                     "Initialize"
+                                   when "notifications/initialized", "notifications/cancelled",
+                                        "notifications/progress", "notifications/roots/list_changed"
+                                     "Noop"
+                                   else
+                                     return super
+                                   end
 
-      full_command_name = command_class.full_command_name
-      inputs = (request.params || {}).merge(request:)
+      command_class = find_builtin_command_class(builtin_command_class_name)
 
-      transformed_command_class = transformed_command_from_name(full_command_name) ||
-                                  transform_command_class(command_class)
+      full_command_name = command_class.full_command_name
 
-      transformed_command_class.new(inputs)
+      transformed_command_from_name(full_command_name) || transform_command_class(command_class)
     rescue CommandConnector::NoCommandFoundError => e
       request.error = e
       nil
     end
 
+    def request_to_command_inputs(request)
+      return if request.error?
+
+      case request.action
+      when "initialize", "notifications/initialized", "notifications/cancelled", "notifications/progress",
+        "notifications/roots/list_changed"
+        (request.params || {}).merge(request:)
+      else
+        super
+      end
+    end
+
     # TODO: figure out how to support multiple sessions
     def session_created(session)
       self.current_session = session

data/src/request.rb

@@ -3,8 +3,15 @@ require_relative "jsonrpc_request"
 module Foobara
   class McpConnector < CommandConnector
     class Request < JsonrpcRequest
-      class FoobaraCommandsDoNotAcceptArraysError < StandardError; end
-      class MethodNotYetSupportedError < StandardError; end
+      class FoobaraCommandsDoNotAcceptArraysError < Foobara::Error
+        context({})
+      end
+
+      class MethodNotYetSupportedError < Foobara::Error
+        context({})
+      end
+
+      attr_accessor :action_loaded
 
       def full_command_name
         return if error || batch?
@@ -24,11 +31,11 @@ module Foobara
         unless inputs.is_a?(::Hash)
           self.error = if inputs.is_a?(::Array)
                          FoobaraCommandsDoNotAcceptArraysError.new(
-                           "Foobara commands do not accept arrays as inputs"
+                           message: "Foobara commands do not accept arrays as inputs"
                          )
                        else
                          InvalidJsonrpcParamsError.new(
-                           "Invalid MCP arguments structure. Expected a hash got a #{inputs.class}"
+                           message: "Invalid MCP arguments structure. Expected a hash got a #{inputs.class}"
                          )
                        end
 
@@ -46,7 +53,14 @@ module Foobara
         !error && super
       end
 
+      def error?
+        action unless action_loaded
+        super
+      end
+
       def action
+        self.action_loaded = true
+
         case method
         when "tools/call"
           "run"
@@ -58,9 +72,9 @@ module Foobara
           method
         when "completion/complete", "logging/setLevel", "prompts/get", "prompts/list",
           "resources/list", "resources/read", "resources/subscribe", "resources/unsubscribe"
-          raise MethodNotYetSupportedError, "#{method} not yet supported!"
+          raise MethodNotYetSupportedError.new(message: "#{method} not yet supported!")
         else
-          self.error = InvalidJsonrpcMethodError.new("Unknown method: #{method}")
+          self.error = InvalidJsonrpcMethodError.new(message: "Unknown method: #{method}")
           error.set_backtrace(caller)
           nil
         end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foobara-mcp-connector
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Miles Georgi
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: foobara
@@ -78,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Gives an easy way to expose your Foobara commands to tools like Claude Code
   via the Model Context Protocol (MCP)