copilot-sdk-supercharged 2.5.0 → 2.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efac3a7b2a63cd85324b0b7c36d9ed46efdc5c2a792ab13dc4d707cc6f5e71a9
-  data.tar.gz: 559699c4a862a0cbc494ecff5b5bdf5451f8f9e45800733264f937294a64055a
+  metadata.gz: f037082db29f02a659fb8872c0034e9917ea1542ba70dacf0fd608a741b34ab4
+  data.tar.gz: 5faaeffb467503b09766c52e1052b7dcf529821d8588343a0d47f76dfa347b6a
 SHA512:
-  metadata.gz: 94b76e5263549a3df7d9f248f099bc9c98ac0ad66f8a2a05bb7a686a8c5c5519c67e045b2d228ed51f1e4570c3ce799bd34012cb3c8d118ad81fa6277312f3cd
-  data.tar.gz: 38d704d797c11b42ad4ae921f25dd4bb98e3995fd58ddf36a0eaa3955f2361c6ab115ab41343ee2a1649445b600a086ae212278c61a6b4945d835296b736c00a
+  metadata.gz: 62a8d4f35acdfcae82332db0cc12cafa1db28e1aec8b877368fb7a9a5557caab6168646f8bc8eb87253ae07c35f93c85622978a520d5c7ab645a5229b5113974
+  data.tar.gz: 5866284c99f3107676ddd642184230d294a671745901319687b95f779ea22d60f1dff6d9b2410564ab3ec783278545811295722a7976e7ce5ccd2985c8f90a4e

data/lib/copilot/client.rb

@@ -5,6 +5,8 @@
 require "open3"
 require "socket"
 require "thread"
+require "fileutils"
+require "time"
 
 module Copilot
   # Main client for interacting with the Copilot CLI.
@@ -442,15 +444,18 @@ module Copilot
     #
     # @param initial_cwd [String, nil] Initial working directory
     # @param session_state_path [String, nil] Path for session state persistence
-    # @param conventions [Array<String>, nil] Convention strings
+    # @param conventions [String, nil] Filesystem conventions ("posix" or "windows").
+    #   Required by the CLI; defaults to the host platform's conventions when omitted.
     # @return [void]
     def set_session_fs_provider(initial_cwd: nil, session_state_path: nil, conventions: nil)
       raise_not_connected! unless @rpc_client
 
+      conventions ||= (RUBY_PLATFORM =~ /mswin|mingw|cygwin/ ? "windows" : "posix")
+
       params = {}
       params[:initialCwd] = initial_cwd if initial_cwd
       params[:sessionStatePath] = session_state_path if session_state_path
-      params[:conventions] = conventions if conventions
+      params[:conventions] = conventions
 
       @rpc_client.request("sessionFs.setProvider", params)
     end
@@ -647,6 +652,29 @@ module Copilot
       @rpc_client.on_request("exitPlanMode.request") do |params|
         handle_exit_plan_mode_request(params)
       end
+
+      register_session_fs_handlers
+    end
+
+    # Registers the client-side session filesystem request handlers.
+    #
+    # When a session filesystem provider is set via {#set_session_fs_provider},
+    # the CLI drives filesystem access by sending +sessionFs.*+ requests back to
+    # the client. These handlers service those requests against the real
+    # filesystem using the absolute paths supplied by the CLI. Errors are
+    # returned in-band as +{ code:, message: }+ (SessionFsError) rather than
+    # raised, matching the reference SDK contract.
+    def register_session_fs_handlers
+      @rpc_client.on_request("sessionFs.readFile") { |params| handle_session_fs_read_file(params) }
+      @rpc_client.on_request("sessionFs.writeFile") { |params| handle_session_fs_write_file(params) }
+      @rpc_client.on_request("sessionFs.appendFile") { |params| handle_session_fs_append_file(params) }
+      @rpc_client.on_request("sessionFs.exists") { |params| handle_session_fs_exists(params) }
+      @rpc_client.on_request("sessionFs.stat") { |params| handle_session_fs_stat(params) }
+      @rpc_client.on_request("sessionFs.mkdir") { |params| handle_session_fs_mkdir(params) }
+      @rpc_client.on_request("sessionFs.readdir") { |params| handle_session_fs_readdir(params) }
+      @rpc_client.on_request("sessionFs.readdirWithTypes") { |params| handle_session_fs_readdir_with_types(params) }
+      @rpc_client.on_request("sessionFs.rm") { |params| handle_session_fs_rm(params) }
+      @rpc_client.on_request("sessionFs.rename") { |params| handle_session_fs_rename(params) }
     end
 
     def verify_protocol_version
@@ -798,6 +826,135 @@ module Copilot
       end
     end
 
+    # ---- SessionFs provider request handlers ----
+    #
+    # These service the CLI's +sessionFs.*+ callbacks against the real
+    # filesystem. Success returns mirror the generated result shapes and errors
+    # are returned in-band as a SessionFsError (+{ code:, message: }+) so the CLI
+    # can distinguish a missing file (ENOENT) from other failures without the
+    # request failing at the JSON-RPC layer.
+
+    def handle_session_fs_read_file(params)
+      content = File.read(params["path"], encoding: "UTF-8")
+      { content: content }
+    rescue StandardError => e
+      { content: "", error: session_fs_error(e) }
+    end
+
+    def handle_session_fs_write_file(params)
+      path = params["path"]
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, params["content"].to_s)
+      File.chmod(params["mode"], path) if params["mode"]
+      nil
+    rescue StandardError => e
+      session_fs_error(e)
+    end
+
+    def handle_session_fs_append_file(params)
+      path = params["path"]
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, "a") { |f| f.write(params["content"].to_s) }
+      File.chmod(params["mode"], path) if params["mode"]
+      nil
+    rescue StandardError => e
+      session_fs_error(e)
+    end
+
+    def handle_session_fs_exists(params)
+      { exists: File.exist?(params["path"]) }
+    rescue StandardError
+      { exists: false }
+    end
+
+    def handle_session_fs_stat(params)
+      st = File.stat(params["path"])
+      {
+        isFile: st.file?,
+        isDirectory: st.directory?,
+        size: st.size,
+        mtime: st.mtime.utc.iso8601,
+        birthtime: session_fs_birthtime(st).utc.iso8601,
+      }
+    rescue StandardError => e
+      now = Time.now.utc.iso8601
+      {
+        isFile: false,
+        isDirectory: false,
+        size: 0,
+        mtime: now,
+        birthtime: now,
+        error: session_fs_error(e),
+      }
+    end
+
+    def handle_session_fs_mkdir(params)
+      path = params["path"]
+      if params["recursive"]
+        FileUtils.mkdir_p(path)
+      else
+        Dir.mkdir(path)
+      end
+      File.chmod(params["mode"], path) if params["mode"]
+      nil
+    rescue StandardError => e
+      session_fs_error(e)
+    end
+
+    def handle_session_fs_readdir(params)
+      { entries: Dir.children(params["path"]) }
+    rescue StandardError => e
+      { entries: [], error: session_fs_error(e) }
+    end
+
+    def handle_session_fs_readdir_with_types(params)
+      path = params["path"]
+      entries = Dir.children(path).map do |name|
+        { name: name, type: File.directory?(File.join(path, name)) ? "directory" : "file" }
+      end
+      { entries: entries }
+    rescue StandardError => e
+      { entries: [], error: session_fs_error(e) }
+    end
+
+    def handle_session_fs_rm(params)
+      path = params["path"]
+      force = params["force"]
+      if params["recursive"]
+        force ? FileUtils.rm_rf(path) : FileUtils.rm_r(path)
+      elsif force
+        FileUtils.rm_f(path)
+      else
+        File.delete(path)
+      end
+      nil
+    rescue Errno::ENOENT => e
+      params["force"] ? nil : session_fs_error(e)
+    rescue StandardError => e
+      session_fs_error(e)
+    end
+
+    def handle_session_fs_rename(params)
+      File.rename(params["src"], params["dest"])
+      nil
+    rescue StandardError => e
+      session_fs_error(e)
+    end
+
+    # Returns the creation time when the platform supports it, else falls back to mtime.
+    def session_fs_birthtime(stat)
+      stat.birthtime
+    rescue NotImplementedError
+      stat.mtime
+    end
+
+    # Maps a Ruby exception to a SessionFsError hash. Missing paths map to
+    # "ENOENT"; everything else maps to "UNKNOWN", matching the reference SDK.
+    def session_fs_error(err)
+      code = err.is_a?(Errno::ENOENT) ? "ENOENT" : "UNKNOWN"
+      { code: code, message: err.message }
+    end
+
     # ---- Payload builders ----
 
     def build_create_session_payload(config)

data/lib/copilot/json_rpc_client.rb

@@ -296,7 +296,11 @@ module Copilot
       # Execute handler (may be synchronous or may raise)
       begin
         result = handler.call(params)
-        result = {} if result.nil?
+        # sessionFs.* write-ops (writeFile/appendFile/mkdir/rm/rename) signal success
+        # as JSON null (the CLI decodes the result as `SessionFsError | undefined`).
+        # Coercing nil to {} would be decoded as a malformed SessionFsError
+        # ("missing field `code`"), so preserve nil for those methods only.
+        result = {} if result.nil? && !method.to_s.start_with?("sessionFs.")
         send_response(request_id, result)
       rescue JsonRpcError => e
         send_error_response(request_id, e.code, e.message, e.data)

data/lib/copilot/types.rb

@@ -599,6 +599,7 @@ module Copilot
     :session_fs,
     :copilot_home, :tcp_connection_token,
     :request_handler,
+    :on_get_trace_context,
     keyword_init: true
   )
 

data/lib/copilot/version.rb

@@ -3,5 +3,5 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 
 module Copilot
-  VERSION = "2.5.0"
+  VERSION = "2.5.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: copilot-sdk-supercharged
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.5.2
 platform: ruby
 authors:
 - Jeremiah Isaacson