robot_lab 0.3.1 → 0.5.0

data/lib/robot_lab/mcp/transports/stdio.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-require "open3"
-require "json"
-require "timeout"
-
-module RobotLab
-  module MCP
-    module Transports
-      # StdIO transport for local MCP servers
-      #
-      # Spawns a subprocess and communicates via stdin/stdout.
-      # All blocking I/O is wrapped with a configurable timeout
-      # so a missing or hung server cannot block the caller forever.
-      #
-      # @example
-      #   transport = Stdio.new(
-      #     { command: "mcp-server-filesystem", args: ["--root", "/data"] },
-      #     timeout: 10
-      #   )
-      #
-      # :reek:InstanceVariableAssumption -- @config and @timeout are assigned in Base#initialize (reek does not trace super).
-      # :reek:RepeatedConditional -- @connected is the connection-lifecycle guard; every IO operation must check it.
-      class Stdio < Base
-        # Creates a new Stdio transport.
-        #
-        # @param config [Hash] transport configuration
-        # @option config [String] :command the command to execute
-        # @option config [Array<String>] :args command arguments
-        # @option config [Hash] :env environment variables
-        # @option config [Numeric] :timeout request timeout in seconds (default: 15)
-        def initialize(config)
-          super
-          @stdin = nil
-          @stdout = nil
-          @stderr = nil
-          @wait_thread = nil
-          @connected = false
-        end
-
-        # Connect to the MCP server via stdio.
-        #
-        # @return [self]
-        # @raise [MCPError] if the server process cannot be started or does not
-        #   respond to the MCP initialize handshake within the timeout period
-        # :reek:TooManyStatements -- linear spawn/verify/handshake sequence with per-failure-mode rescues.
-        def connect
-          return self if @connected
-
-          command = @config[:command]
-          args = @config[:args] || []
-          env = @config[:env] || {}
-
-          full_env = ENV.to_h.merge(env.transform_keys(&:to_s))
-
-          @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(full_env, command, *args)
-
-          # Verify the process actually started
-          unless @wait_thread.alive?
-            raise MCPError, "MCP server process exited immediately (command: #{command})"
-          end
-
-          @connected = true
-
-          # Initialize MCP protocol — this must complete within the timeout
-          send_initialize
-
-          self
-        rescue Errno::ENOENT => e
-          cleanup_process
-          raise MCPError, "MCP server command not found: #{command} (#{e.message})"
-        rescue Timeout::Error
-          cleanup_process
-          raise MCPError, "MCP server '#{command}' did not respond within #{@timeout}s"
-        end
-
-        # Send a JSON-RPC request to the MCP server.
-        #
-        # @param message [Hash] JSON-RPC message
-        # @return [Hash] the response
-        # @raise [MCPError] if not connected, no response, or timeout
-        # :reek:TooManyStatements -- write-then-read loop must stay inside the one Timeout block.
-        def send_request(message)
-          raise MCPError, "Not connected" unless @connected
-
-          Timeout.timeout(@timeout, Timeout::Error) do
-            json = message.to_json
-            @stdin.puts(json)
-            @stdin.flush
-
-            loop do
-              response_line = @stdout.gets
-              raise MCPError, "No response from MCP server (EOF on stdout)" unless response_line
-
-              parsed = JSON.parse(response_line, symbolize_names: true)
-
-              # Skip notifications (messages without an id)
-              next if parsed[:method] && !parsed.key?(:id)
-
-              return parsed
-            end
-          end
-        rescue Timeout::Error
-          raise MCPError, "MCP server did not respond within #{@timeout}s"
-        rescue Errno::EPIPE, IOError => e
-          @connected = false
-          raise MCPError, "MCP server connection lost: #{e.message}"
-        end
-
-        # Close the connection to the MCP server.
-        #
-        # @return [self]
-        def close
-          return self unless @connected
-
-          cleanup_process
-          self
-        end
-
-        # Check if the transport is connected.
-        #
-        # @return [Boolean] true if connected and process is alive
-        def connected?
-          @connected && @wait_thread&.alive?
-        end
-
-        # Expose the underlying IO objects so ConnectionPoller can
-        # register them in its IO.select loop.
-        #
-        # @api private
-        attr_reader :stdin, :stdout
-
-        private
-
-        def send_initialize
-          send_request(
-            jsonrpc: "2.0",
-            id: 0,
-            method: "initialize",
-            params: {
-              protocolVersion: "2024-11-05",
-              capabilities: {},
-              clientInfo: {
-                name: "RobotLab",
-                version: RobotLab::VERSION
-              }
-            }
-          )
-
-          # Send initialized notification
-          @stdin.puts({ jsonrpc: "2.0", method: "notifications/initialized" }.to_json)
-          @stdin.flush
-        end
-
-        # :reek:TooManyStatements -- best-effort teardown; each handle is closed and nilled independently.
-        def cleanup_process
-          @connected = false
-          @stdin&.close  rescue nil
-          @stdout&.close rescue nil
-          @stderr&.close rescue nil
-          @wait_thread&.kill if @wait_thread&.alive?
-          @stdin = nil
-          @stdout = nil
-          @stderr = nil
-          @wait_thread = nil
-        end
-      end
-    end
-  end
-end

data/lib/robot_lab/mcp/transports/streamable_http.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-module RobotLab
-  module MCP
-    module Transports
-      # Streamable HTTP transport for MCP servers
-      #
-      # Supports session management and reconnection.
-      #
-      # @example
-      #   transport = StreamableHTTP.new(
-      #     url: "https://server.smithery.ai/neon/mcp",
-      #     session_id: "abc123"
-      #   )
-      #
-      # :reek:InstanceVariableAssumption -- @config is assigned in Base#initialize (reek does not trace super).
-      # :reek:RepeatedConditional -- @connected is the connection-lifecycle guard; every operation must check it.
-      class StreamableHTTP < Base
-        # Creates a new StreamableHTTP transport.
-        #
-        # @param config [Hash] transport configuration
-        # @option config [String] :url HTTP server URL
-        # @option config [String] :session_id optional session identifier
-        # @option config [Proc] :auth_provider optional authentication callback
-        def initialize(config)
-          super
-          @client = nil
-          @connected = false
-          @session_id = config[:session_id]
-        end
-
-        # Connect to the MCP server via HTTP.
-        #
-        # @return [self]
-        # @raise [MCPError] if async-http gem is not available
-        # :reek:TooManyStatements -- linear require/connect/handshake sequence inside the Async block.
-        def connect
-          return self if @connected
-
-          require "async"
-          require "async/http/client"
-          require "async/http/endpoint"
-
-          url = @config[:url]
-
-          Async do
-            endpoint = Async::HTTP::Endpoint.parse(url)
-            @client = Async::HTTP::Client.new(endpoint)
-            @connected = true
-
-            # Initialize MCP protocol
-            result = send_initialize
-            @session_id ||= result&.dig(:serverInfo, :sessionId)
-          end
-
-          self
-        rescue LoadError => e
-          raise MCPError, "async-http gem required for HTTP transport: #{e.message}"
-        end
-
-        # Send a JSON-RPC request to the MCP server.
-        #
-        # @param message [Hash] JSON-RPC message
-        # @return [Hash] the response
-        # @raise [MCPError] if not connected
-        # :reek:TooManyStatements -- header assembly and POST must stay inside the one Async block.
-        def send_request(message)
-          raise MCPError, "Not connected" unless @connected
-
-          require "async"
-
-          Async do
-            headers = {
-              "Content-Type" => "application/json",
-              "Accept" => "application/json"
-            }
-            headers["X-Session-ID"] = @session_id if @session_id
-
-            # Add auth if configured
-            if @config[:auth_provider]
-              auth_header = @config[:auth_provider].call
-              headers["Authorization"] = auth_header if auth_header
-            end
-
-            response = @client.post(
-              @config[:url],
-              headers,
-              [message.to_json]
-            )
-
-            body = response.read
-            JSON.parse(body, symbolize_names: true)
-          end.wait
-        end
-
-        # Close the HTTP connection.
-        #
-        # @return [self]
-        def close
-          return self unless @connected
-
-          @client&.close
-          @connected = false
-          @client = nil
-
-          self
-        end
-
-        # Check if the transport is connected.
-        #
-        # @return [Boolean] true if connected
-        def connected?
-          @connected
-        end
-
-        # Returns the session identifier.
-        #
-        # @return [String, nil] the session ID
-        attr_reader :session_id
-
-        private
-
-        def send_initialize
-          send_request(
-            jsonrpc: "2.0",
-            id: 0,
-            method: "initialize",
-            params: {
-              protocolVersion: "2024-11-05",
-              capabilities: {},
-              clientInfo: {
-                name: "RobotLab",
-                version: RobotLab::VERSION
-              }
-            }
-          )
-        end
-      end
-    end
-  end
-end

data/lib/robot_lab/mcp/transports/websocket.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module RobotLab
-  module MCP
-    module Transports
-      # WebSocket transport for MCP servers
-      #
-      # Uses async-websocket for non-blocking communication.
-      #
-      # @example
-      #   transport = WebSocket.new(url: "ws://localhost:8080")
-      #
-      # :reek:InstanceVariableAssumption -- @config is assigned in Base#initialize (reek does not trace super).
-      # :reek:RepeatedConditional -- @connected is the connection-lifecycle guard; every operation must check it.
-      class WebSocket < Base
-        # Creates a new WebSocket transport.
-        #
-        # @param config [Hash] transport configuration
-        # @option config [String] :url WebSocket server URL
-        def initialize(config)
-          super
-          @connection = nil
-          @connected = false
-          @pending_requests = {}
-        end
-
-        # Connect to the MCP server via WebSocket.
-        #
-        # @return [self]
-        # @raise [MCPError] if async-websocket gem is not available
-        # :reek:TooManyStatements -- linear require/connect/handshake sequence inside the Async block.
-        def connect
-          return self if @connected
-
-          require "async"
-          require "async/websocket/client"
-
-          url = @config[:url]
-
-          Async do
-            endpoint = Async::HTTP::Endpoint.parse(url)
-            @connection = Async::WebSocket::Client.connect(endpoint)
-            @connected = true
-
-            # Initialize MCP protocol
-            send_initialize
-          end
-
-          self
-        rescue LoadError => e
-          raise MCPError, "async-websocket gem required for WebSocket transport: #{e.message}"
-        end
-
-        # Send a JSON-RPC request to the MCP server.
-        #
-        # @param message [Hash] JSON-RPC message
-        # @return [Hash] the response
-        # @raise [MCPError] if not connected
-        def send_request(message)
-          raise MCPError, "Not connected" unless @connected
-
-          Async do
-            @connection.write(message.to_json)
-            @connection.flush
-
-            response_text = @connection.read
-            JSON.parse(response_text, symbolize_names: true)
-          end.wait
-        end
-
-        # Close the WebSocket connection.
-        #
-        # @return [self]
-        def close
-          return self unless @connected
-
-          @connection&.close
-          @connected = false
-          @connection = nil
-
-          self
-        end
-
-        # Check if the transport is connected.
-        #
-        # @return [Boolean] true if connected
-        def connected?
-          @connected
-        end
-
-        private
-
-        def send_initialize
-          send_request(
-            jsonrpc: "2.0",
-            id: 0,
-            method: "initialize",
-            params: {
-              protocolVersion: "2024-11-05",
-              capabilities: {},
-              clientInfo: {
-                name: "RobotLab",
-                version: RobotLab::VERSION
-              }
-            }
-          )
-        end
-      end
-    end
-  end
-end