encom 0.1.0

data/lib/encom/transport/stdio.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'open3'
+require 'timeout'
+require 'json'
+
+module Encom
+  module Transport
+    class Stdio
+      attr_reader :process_pid
+
+      def initialize(
+        command:,
+        args: []
+      )
+        super()
+        @command = command
+        @args = args
+        @process = nil
+        @read_buffer = +''  # Use mutable string
+        @callbacks = {
+          error: [],
+          close: [],
+          data: []
+        }
+        @mutex = Mutex.new
+        @json_buffer = '' # Buffer for accumulating JSON messages
+      end
+
+      # Register event handlers
+      def on_error(&block)
+        @callbacks[:error] << block
+        self
+      end
+
+      def on_close(&block)
+        @callbacks[:close] << block
+        self
+      end
+
+      def on_data(&block)
+        @callbacks[:data] << block
+        self
+      end
+
+      def start
+        raise 'StdioClientTransport already started!' if @process
+
+        env = ENV.to_h
+
+        command = @command
+        args = @args
+
+        @stdin, @stdout, @stderr, @process = Open3.popen3(
+          env,
+          command,
+          *args
+          # chdir: @server_params[:cwd]
+        )
+
+        @process_pid = @process.pid
+
+        start_stdout_thread
+        start_stderr_thread
+        start_process_monitor_thread
+
+        self
+      end
+
+      def send(data)
+        return false unless @process && @stdin
+
+        data = "#{data}\n" unless data.end_with?("\n")
+
+        begin
+          @stdin.write(data)
+          @stdin.flush
+          true
+        rescue IOError, Errno::EPIPE => e
+          trigger_error(e)
+          false
+        end
+      end
+
+      def send_line(data)
+        send("#{data}\n")
+      end
+
+      def close
+        return unless @process
+
+        begin
+          @stdin.close
+        rescue StandardError
+          nil
+        end
+
+        begin
+          Timeout.timeout(2) do
+            Process.wait(@process.pid)
+          rescue StandardError
+            nil
+          end
+        rescue Timeout::Error
+          begin
+            Process.kill('TERM', @process.pid)
+          rescue StandardError
+            nil
+          end
+
+          begin
+            Timeout.timeout(1) do
+              Process.wait(@process.pid)
+            rescue StandardError
+              nil
+            end
+          rescue Timeout::Error
+            begin
+              Process.kill('KILL', @process.pid)
+            rescue StandardError
+              nil
+            end
+          end
+        end
+
+        # Clean up resources
+        begin
+          @stdout.close
+        rescue StandardError
+          nil
+        end
+        begin
+          @stderr.close
+        rescue StandardError
+          nil
+        end
+
+        trigger_close
+
+        @process = nil
+      end
+
+      private
+
+      def start_stdout_thread
+        Thread.new do
+          loop do
+            chunk = @stdout.read_nonblock(1024)
+            if chunk && !chunk.empty?
+              @mutex.synchronize do
+                @read_buffer << chunk
+              end
+              process_read_buffer
+            end
+          rescue IO::WaitReadable
+            IO.select([@stdout], nil, nil, 0.1)
+            retry
+          rescue EOFError
+            break
+          end
+        rescue IOError, Errno::EPIPE => e
+          trigger_error(e) unless @process.nil?
+        ensure
+          trigger_close if @process && !@stdout.closed?
+        end
+      end
+
+      def start_stderr_thread
+        Thread.new do
+          while (line = @stderr.gets)
+            trigger_error(RuntimeError.new("Process stderr: #{line.strip}"))
+          end
+        rescue IOError, Errno::EPIPE => e
+          trigger_error(e) unless @process.nil?
+        end
+      end
+
+      def start_process_monitor_thread
+        Thread.new do
+          Process.wait(@process.pid)
+          exit_status = $CHILD_STATUS.exitstatus
+          trigger_close(exit_status)
+        rescue Errno::ECHILD, Errno::ESRCH
+          trigger_close
+        end
+      end
+
+      def process_read_buffer
+        data = nil
+
+        @mutex.synchronize do
+          data = @read_buffer.dup
+          @read_buffer.clear
+        end
+
+        return unless data && !data.empty?
+
+        @json_buffer += data
+
+        process_json_messages
+      end
+
+      def process_json_messages
+        while @json_buffer.include?("\n")
+          message, remainder = @json_buffer.split("\n", 2)
+
+          if message && !message.empty?
+            begin
+              JSON.parse(message)
+
+              trigger_data(message)
+            rescue JSON::ParserError
+              @json_buffer = "#{message}\n#{remainder || ''}"
+              return
+            end
+          end
+
+          @json_buffer = remainder || ''
+        end
+      end
+
+      def trigger_error(error)
+        @callbacks[:error].each { |callback| callback.call(error) }
+      end
+
+      def trigger_close(exit_status = nil)
+        @callbacks[:close].each { |callback| callback.call(exit_status) }
+      end
+
+      def trigger_data(data)
+        @callbacks[:data].each { |callback| callback.call(data) }
+      end
+    end
+  end
+end

data/lib/encom/version.rb

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

data/lib/encom.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'encom/version'
+
+module Encom
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/encom.rbs

@@ -0,0 +1,4 @@
+module Encom
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: encom
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kyle Byrne
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-03-07 00:00:00.000000000 Z
+dependencies: []
+description: Library for implementing MCP (Model context protocol) servers and clients
+  in Ruby
+email:
+- kyletbyrne96@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".standard.yml"
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/filesystem_demo.rb
+- lib/encom.rb
+- lib/encom/client.rb
+- lib/encom/error_codes.rb
+- lib/encom/server.rb
+- lib/encom/server/tool.rb
+- lib/encom/server_transport/base.rb
+- lib/encom/server_transport/stdio.rb
+- lib/encom/transport/stdio.rb
+- lib/encom/version.rb
+- sig/encom.rbs
+homepage: https://github.com/kylebyrne/encom
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/kylebyrne/encom
+  source_code_uri: https://github.com/kylebyrne/encom
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Ruby implementation of MCP
+test_files: []