acp_ruby 0.1.0

data/lib/agent_client_protocol/stdio.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "async"
+
+module AgentClientProtocol
+  module Stdio
+    SHUTDOWN_TIMEOUT = 5 # seconds
+
+    module_function
+
+    def run_agent(agent)
+      Async do
+        reader = Transport::NdjsonReader.new($stdin)
+        writer = Transport::NdjsonWriter.new($stdout)
+
+        # Redirect any puts/print to stderr so stdout is reserved for protocol
+        $stdout = $stderr
+
+        conn = Agent::Connection.new(agent, reader, writer)
+        conn.listen
+      end
+    end
+
+    def spawn_agent_process(client, command, *args, env: nil, cwd: nil)
+      Async do |task|
+        pid, stdin_w, stdout_r = spawn_process(command, *args, env: env, cwd: cwd)
+
+        reader = Transport::NdjsonReader.new(stdout_r)
+        writer = Transport::NdjsonWriter.new(stdin_w)
+        conn = Client::Connection.new(client, reader, writer)
+
+        listen_task = task.async { conn.listen }
+
+        if block_given?
+          begin
+            yield conn, pid
+          ensure
+            shutdown_process(conn, pid, stdin_w, listen_task)
+          end
+        else
+          [conn, pid, listen_task]
+        end
+      end
+    end
+
+    def spawn_client_process(agent, command, *args, env: nil, cwd: nil)
+      Async do |task|
+        pid, stdin_w, stdout_r = spawn_process(command, *args, env: env, cwd: cwd)
+
+        reader = Transport::NdjsonReader.new(stdout_r)
+        writer = Transport::NdjsonWriter.new(stdin_w)
+        conn = Agent::Connection.new(agent, reader, writer)
+
+        listen_task = task.async { conn.listen }
+
+        if block_given?
+          begin
+            yield conn, pid
+          ensure
+            shutdown_process(conn, pid, stdin_w, listen_task)
+          end
+        else
+          [conn, pid, listen_task]
+        end
+      end
+    end
+
+    def spawn_process(command, *args, env: nil, cwd: nil)
+      spawn_env = clean_environment(env)
+      opts = {in: :pipe, out: :pipe, err: $stderr}
+      opts[:chdir] = cwd if cwd
+
+      stdin_r, stdin_w = IO.pipe
+      stdout_r, stdout_w = IO.pipe
+
+      pid = Process.spawn(spawn_env, command, *args, in: stdin_r, out: stdout_w, err: $stderr, **(cwd ? {chdir: cwd} : {}))
+
+      stdin_r.close
+      stdout_w.close
+
+      [pid, stdin_w, stdout_r]
+    end
+
+    def shutdown_process(conn, pid, stdin_w, listen_task)
+      listen_task&.stop
+      conn.close
+
+      # Close stdin to signal the subprocess
+      stdin_w.close unless stdin_w.closed?
+
+      # Use a thread for waitpid to avoid blocking the async reactor
+      reap_thread = Thread.new do
+        begin
+          Process.waitpid(pid)
+        rescue Errno::ECHILD, Errno::ESRCH
+          # Already reaped
+        end
+      end
+
+      unless reap_thread.join(SHUTDOWN_TIMEOUT)
+        begin
+          Process.kill("TERM", pid)
+        rescue Errno::ESRCH
+          # Already gone
+        end
+        unless reap_thread.join(SHUTDOWN_TIMEOUT)
+          begin
+            Process.kill("KILL", pid)
+          rescue Errno::ESRCH
+            # Already gone
+          end
+          reap_thread.join(1)
+        end
+      end
+    rescue Errno::ECHILD, Errno::ESRCH
+      # Process already gone
+    end
+
+    def clean_environment(extra = nil)
+      env = {}
+      # Minimal safe environment
+      %w[PATH HOME USER LANG TERM].each do |key|
+        env[key] = ENV[key] if ENV[key]
+      end
+      env.merge!(extra) if extra
+      env
+    end
+  end
+end

data/lib/agent_client_protocol/transport.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "json"
+
+module AgentClientProtocol
+  module Transport
+    MAX_LINE_BYTES = 50 * 1024 * 1024 # 50MB
+
+    class NdjsonWriter
+      def initialize(io)
+        @io = io
+        @io.sync = true
+        @mutex = Mutex.new
+      end
+
+      def write(message)
+        line = JSON.generate(message) + "\n"
+        @mutex.synchronize do
+          @io.write(line)
+          @io.flush
+        end
+      end
+
+      def close
+        @io.close unless @io.closed?
+      rescue IOError
+        # already closed
+      end
+    end
+
+    class NdjsonReader
+      def initialize(io, max_line_bytes: MAX_LINE_BYTES)
+        @io = io
+        @max_line_bytes = max_line_bytes
+      end
+
+      def each
+        return enum_for(:each) unless block_given?
+
+        loop do
+          line = read_line
+          break if line.nil?
+
+          line = line.strip
+          next if line.empty?
+
+          begin
+            yield JSON.parse(line)
+          rescue JSON::ParserError => e
+            raise AgentClientProtocol::RequestError.parse_error(e.message)
+          end
+        end
+      end
+
+      def close
+        @io.close unless @io.closed?
+      rescue IOError
+        # already closed
+      end
+
+      private
+
+      def read_line
+        @io.gets
+      rescue IOError, Errno::EBADF
+        nil
+      end
+    end
+  end
+end

data/lib/agent_client_protocol/version.rb

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

data/lib/agent_client_protocol.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "agent_client_protocol/version"
+require_relative "agent_client_protocol/meta"
+
+module AgentClientProtocol
+  autoload :RequestError, "agent_client_protocol/error"
+  autoload :Transport, "agent_client_protocol/transport"
+  autoload :Connection, "agent_client_protocol/connection"
+  autoload :Router, "agent_client_protocol/router"
+  autoload :AgentInterface, "agent_client_protocol/agent"
+  autoload :ClientInterface, "agent_client_protocol/client"
+  autoload :Helpers, "agent_client_protocol/helpers"
+
+  module Schema
+    autoload :BaseModel, "agent_client_protocol/schema/base_model"
+  end
+
+  # Load generated schema types
+  require_relative "agent_client_protocol/schema/generated"
+
+  module Agent
+    autoload :Connection, "agent_client_protocol/agent/connection"
+    autoload :Router, "agent_client_protocol/agent/router"
+  end
+
+  module Client
+    autoload :Connection, "agent_client_protocol/client/connection"
+    autoload :Router, "agent_client_protocol/client/router"
+  end
+
+  module Contrib
+    autoload :SessionAccumulator, "agent_client_protocol/contrib/session_accumulator"
+    autoload :ToolCallTracker, "agent_client_protocol/contrib/tool_call_tracker"
+    autoload :PermissionBroker, "agent_client_protocol/contrib/permission_broker"
+  end
+
+  module_function
+
+  def run_agent(agent)
+    require_relative "agent_client_protocol/stdio"
+    Stdio.run_agent(agent)
+  end
+
+  def spawn_agent_process(client, command, *args, **opts, &block)
+    require_relative "agent_client_protocol/stdio"
+    Stdio.spawn_agent_process(client, command, *args, **opts, &block)
+  end
+
+  def spawn_client_process(agent, command, *args, **opts, &block)
+    require_relative "agent_client_protocol/stdio"
+    Stdio.spawn_client_process(agent, command, *args, **opts, &block)
+  end
+end

data/schema/VERSION

@@ -0,0 +1 @@
+v0.10.8

data/schema/meta.json

@@ -0,0 +1,24 @@
+{
+  "agentMethods": {
+    "authenticate": "authenticate",
+    "initialize": "initialize",
+    "session_cancel": "session/cancel",
+    "session_load": "session/load",
+    "session_new": "session/new",
+    "session_prompt": "session/prompt",
+    "session_set_config_option": "session/set_config_option",
+    "session_set_mode": "session/set_mode"
+  },
+  "clientMethods": {
+    "fs_read_text_file": "fs/read_text_file",
+    "fs_write_text_file": "fs/write_text_file",
+    "session_request_permission": "session/request_permission",
+    "session_update": "session/update",
+    "terminal_create": "terminal/create",
+    "terminal_kill": "terminal/kill",
+    "terminal_output": "terminal/output",
+    "terminal_release": "terminal/release",
+    "terminal_wait_for_exit": "terminal/wait_for_exit"
+  },
+  "version": 1
+}