selenium-webdriver 4.47.0 → 4.49.0

data/lib/selenium/webdriver/common/selenium_manager.rb

@@ -77,16 +77,20 @@ module Selenium
           elsif Platform.mac?
             "#{directory}/macos/selenium-manager"
           elsif Platform.linux?
-            "#{directory}/linux/selenium-manager"
+            "#{directory}/#{linux_directory}/selenium-manager"
           elsif Platform.unix?
             WebDriver.logger.warn('Selenium Manager binary may not be compatible with Unix',
                                   id: %i[selenium_manager unix_binary])
-            "#{directory}/linux/selenium-manager"
+            "#{directory}/#{linux_directory}/selenium-manager"
           else
             raise Error::WebDriverError, "unsupported platform: #{Platform.os}"
           end
         end
 
+        def linux_directory
+          RbConfig::CONFIG['host_cpu'].to_s.downcase == 'aarch64' ? 'linux-arm64' : 'linux-x86_64'
+        end
+
         def execute_command(*command)
           WebDriver.logger.debug("Executing Process #{command}", id: :selenium_manager)
 

data/lib/selenium/webdriver/common/websocket_connection.rb

@@ -21,6 +21,7 @@ require 'websocket'
 
 module Selenium
   module WebDriver
+    # @api private
     class WebSocketConnection
       CONNECTION_ERRORS = [
         Errno::ECONNRESET, # connection is aborted (browser process was killed)
@@ -35,6 +36,15 @@ module Selenium
 
       MAX_LOG_MESSAGE_SIZE = 9999
 
+      # websocket-ruby defaults to a 20MB limit and silently drops larger
+      # frames, which can stall the listener. CDP payloads (e.g. large data:
+      # URLs) can exceed that, so raise the ceiling for our connections.
+      # The gem only exposes the limit as process-global state, so it is
+      # raised (never lowered) and not restored on close - concurrent
+      # connections share the value. Other bindings rely on their own
+      # websocket clients' limits; this constant only affects websocket-ruby.
+      MAX_FRAME_SIZE = 100 * 1024 * 1024 # 100MB
+
       def initialize(url:)
         @callback_threads = ThreadGroup.new
 
@@ -46,26 +56,19 @@ module Selenium
         @session_id = nil
         @url = url
 
+        apply_frame_size_limit
         process_handshake
         @socket_thread = attach_socket_listener
       end
 
+      # Idempotent: the listener may already have initiated shutdown (see
+      # #frame_dropped?), so always close the socket and join threads rather
+      # than short-circuiting on @closing.
       def close
-        @closing_mtx.synchronize do
-          return if @closing
-
-          @closing = true
-        end
-
-        begin
-          socket.close
-        rescue *CONNECTION_ERRORS => e
-          WebDriver.logger.debug "WebSocket listener closed: #{e.class}: #{e.message}", id: :ws
-          # already closed
-        end
+        close_socket
 
         # Let threads unwind instead of calling exit
-        @socket_thread&.join(0.5)
+        @socket_thread&.join(0.5) unless @socket_thread == Thread.current
         @callback_threads.list.each do |thread|
           thread.join(0.5)
         rescue StandardError => e
@@ -97,6 +100,9 @@ module Selenium
       end
 
       def send_cmd(**payload)
+        # IOError to match what writing to an already-closed socket raises
+        raise IOError, 'WebSocket connection is closed' if @closing
+
         id = next_id
         data = payload.merge(id: id)
         WebDriver.logger.debug "WebSocket -> #{data}"[...MAX_LOG_MESSAGE_SIZE], id: :ws
@@ -109,7 +115,11 @@ module Selenium
           raise e, "WebSocket is closed (#{e.class}: #{e.message})"
         end
 
-        wait.until { @messages_mtx.synchronize { messages.delete(id) } }
+        wait.until do
+          raise IOError, 'WebSocket connection closed while waiting for a response' if @closing
+
+          @messages_mtx.synchronize { messages.delete(id) }
+        end
       end
 
       private
@@ -132,22 +142,51 @@ module Selenium
 
             incoming_frame << socket.readpartial(1024)
 
-            while (frame = incoming_frame.next)
-              break if @closing
-
-              message = process_frame(frame)
-              next unless message['method']
-
-              @messages_mtx.synchronize { callbacks[message['method']].dup }.each do |callback|
-                @callback_threads.add(callback_thread(message['params'], &callback))
-              end
-            end
+            process_incoming_frames
+            break if frame_dropped?
           end
         rescue *CONNECTION_ERRORS, WebSocket::Error => e
           WebDriver.logger.debug "WebSocket listener closed: #{e.class}: #{e.message}", id: :ws
         end
       end
 
+      def close_socket
+        @closing_mtx.synchronize { @closing = true }
+        socket.close
+      rescue *CONNECTION_ERRORS => e
+        WebDriver.logger.debug "WebSocket socket closed: #{e.class}: #{e.message}", id: :ws
+      end
+
+      def process_incoming_frames
+        while (frame = incoming_frame.next)
+          break if @closing
+
+          message = process_frame(frame)
+          next unless message['method']
+
+          @messages_mtx.synchronize { callbacks[message['method']].dup }.each do |callback|
+            @callback_threads.add(callback_thread(message['params'], &callback))
+          end
+        end
+      end
+
+      # True when the buffered frame could not be decoded (e.g. exceeds MAX_FRAME_SIZE).
+      # websocket-ruby swallows the error and keeps returning nil, so surface it and close
+      # the connection here instead of leaving a dead listener on an open socket.
+      def frame_dropped?
+        return false unless incoming_frame.error?
+
+        WebDriver.logger.error("WebSocket frame dropped (#{incoming_frame.error}); if payloads can legitimately " \
+                               "exceed #{WebSocket.max_frame_size} bytes, set WebSocket.max_frame_size " \
+                               'to a higher value', id: :ws)
+        close_socket
+        true
+      end
+
+      def apply_frame_size_limit
+        WebSocket.max_frame_size = MAX_FRAME_SIZE if WebSocket.max_frame_size < MAX_FRAME_SIZE
+      end
+
       def incoming_frame
         @incoming_frame ||= WebSocket::Frame::Incoming::Client.new(version: ws.version)
       end
@@ -204,8 +243,7 @@ module Selenium
       end
 
       def next_id
-        @id ||= 0
-        @id += 1
+        @id = (@id || 0) + 1
       end
     end # BiDi
   end # WebDriver

data/lib/selenium/webdriver/version.rb

@@ -19,6 +19,6 @@
 
 module Selenium
   module WebDriver
-    VERSION = '4.47.0'
+    VERSION = '4.49.0'
   end # WebDriver
 end # Selenium

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: selenium-webdriver
 version: !ruby/object:Gem::Version
-  version: 4.47.0
+  version: 4.49.0
 platform: ruby
 authors:
 - Alex Rodionov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-10 00:00:00.000000000 Z
+date: 2026-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -271,7 +271,8 @@ files:
 - LICENSE
 - NOTICE
 - README.md
-- bin/linux/selenium-manager
+- bin/linux-arm64/selenium-manager
+- bin/linux-x86_64/selenium-manager
 - bin/macos/selenium-manager
 - bin/selenium-manager-THIRD-PARTY-NOTICES.txt
 - bin/selenium-manager.cdx.json