copilot-sdk-supercharged 2.4.0 → 2.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d80c4e262952967db3b9ed58e8899587afa12b158074ab57d7f475af58ccd68
-  data.tar.gz: 302abe246cec1dd679f2036f49407a10b01756c421634a3c97f6fb1105743606
+  metadata.gz: 8a7fd46a011b45876248c40e46f1b283271631d2c52e99ebd6a782797dc534cc
+  data.tar.gz: b05f12f98a4a459b5d8dd3de5fd0606c3d6fd3f0311ec51b2061430832dbd0e1
 SHA512:
-  metadata.gz: e7aa7ee115dfe39db890cffa6d1d4535caf0b6926cde80b0346b5ce3e8e5a9ca24b688af91c49b223aa5fbdb1e95733052f142b4bcef42d18d69101ccae1fde5
-  data.tar.gz: f51f8baeb7ede5fb5db28855db3e94f397379e78d75e9f6aa871a6c970733b8bfd80ab5d3013acc21510add30f29be55e7db79cb6251061355470b220e95655a
+  metadata.gz: 60622159ecd94b6140cf217816bab128558e1f9f2e5be7f814fdba56e8aa8158a992b67e1ff24e5499ad99cf657e729db6b5ee7867257f104596b31fc872f53c
+  data.tar.gz: 58606a5efea0407d47eb7e8453ce2c1c572ffe2e513be46c3cfe339c70822dad16666f7cb11438c99d76b2c97bbb86d845bb0077c508bd9b0955d05a4563c81a

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)
@@ -859,6 +1016,20 @@ module Copilot
       payload[:otlpProtocol] = config[:otlp_protocol] if config[:otlp_protocol]
       payload[:enableWebSocketResponses] = config[:enable_web_socket_responses] unless config[:enable_web_socket_responses].nil?
       payload[:expAssignments] = config[:exp_assignments] if config[:exp_assignments]
+      # --- Second upstream-sync batch (2026-08 parity with @github/copilot-sdk) ---
+      payload[:rewindEnabled] = config[:rewind_enabled] unless config[:rewind_enabled].nil? # enable session rewind
+      payload[:additionalDirectories] = config[:additional_directories] if config[:additional_directories]
+      payload[:disabledMcpServers] = config[:disabled_mcp_servers] if config[:disabled_mcp_servers]
+      payload[:githubMcpToolConfig] = config[:github_mcp_tool_config] if config[:github_mcp_tool_config]
+      payload[:canvasProvider] = config[:canvas_provider] if config[:canvas_provider]
+      payload[:customAgentsLocalOnly] = config[:custom_agents_local_only] unless config[:custom_agents_local_only].nil?
+      payload[:builtinPluginDirectories] = config[:builtin_plugin_directories] if config[:builtin_plugin_directories]
+      payload[:argsSchema] = config[:args_schema] if config[:args_schema] # agent-factory authoring schema
+      payload[:decisionContext] = config[:decision_context] if config[:decision_context] # permission decision context
+      payload[:toolSearch] = config[:tool_search] unless config[:tool_search].nil?
+      payload[:inProcess] = config[:in_process] unless config[:in_process].nil?
+      payload[:experimentalMode] = config[:experimental_mode] unless config[:experimental_mode].nil?
+      payload[:contentExclusion] = config[:content_exclusion] unless config[:content_exclusion].nil?
       # MCP OAuth host token handler: signal to the runtime that a handler is registered.
       payload[:mcpAuthHandler] = true if config[:on_mcp_auth_request]
 

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/session.rb

@@ -349,6 +349,7 @@ module Copilot
         "preToolUse"          => hooks.on_pre_tool_use,
         "postToolUse"         => hooks.on_post_tool_use,
         "userPromptSubmitted" => hooks.on_user_prompt_submitted,
+        "userPromptTransformed" => hooks.on_user_prompt_transformed,
         "sessionStart"        => hooks.on_session_start,
         "sessionEnd"          => hooks.on_session_end,
         "errorOccurred"       => hooks.on_error_occurred,

data/lib/copilot/types.rb

@@ -553,11 +553,13 @@ module Copilot
   # Hook configuration for a session. Each value is a callable or nil.
   SessionHooks = Struct.new(
     :on_pre_tool_use, :on_post_tool_use, :on_user_prompt_submitted,
+    :on_user_prompt_transformed,
     :on_session_start, :on_session_end, :on_error_occurred,
     keyword_init: true
   ) do
     def any_handler?
       [on_pre_tool_use, on_post_tool_use, on_user_prompt_submitted,
+       on_user_prompt_transformed,
        on_session_start, on_session_end, on_error_occurred].any?
     end
   end
@@ -597,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.1.0"
+  VERSION = "2.5.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: copilot-sdk-supercharged
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.5.1
 platform: ruby
 authors:
 - Jeremiah Isaacson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-08 00:00:00.000000000 Z
+date: 2026-08-21 00:00:00.000000000 Z
 dependencies: []
 description: |
   A Ruby SDK for interacting with the GitHub Copilot CLI server via JSON-RPC 2.0.