puppeteer-ruby 0.52.0 → 0.53.0

data/lib/puppeteer/browser_connector.rb

@@ -1,4 +1,5 @@
 require_relative './browser'
+require_relative './chrome_user_data_dir'
 require_relative './launcher/browser_options'
 
 class Puppeteer::BrowserConnector
@@ -7,6 +8,7 @@ class Puppeteer::BrowserConnector
     @browser_ws_endpoint = options[:browser_ws_endpoint]
     @browser_url = options[:browser_url]
     @transport = options[:transport]
+    @channel = options[:channel]
   end
 
   # @return [Puppeteer::Browser]
@@ -30,6 +32,7 @@ class Puppeteer::BrowserConnector
       network_enabled: @browser_options.network_enabled,
       issues_enabled: @browser_options.issues_enabled,
       block_list: @browser_options.block_list,
+      allow_list: @browser_options.allow_list,
       process: nil,
       close_callback: -> { connection.send_message('Browser.close') },
       target_filter_callback: @browser_options.target_filter,
@@ -38,16 +41,24 @@ class Puppeteer::BrowserConnector
   end
 
   private def connection
-    @connection ||=
-      if @browser_ws_endpoint && @browser_url.nil? && @transport.nil?
+    @connection ||= begin
+      connection_options = [@browser_ws_endpoint, @browser_url, @transport, @channel]
+      unless connection_options.count { |option| !!option } == 1
+        raise ArgumentError.new('Exactly one of browserWSEndpoint, browserURL, transport or channel must be passed to puppeteer.connect')
+      end
+
+      if @transport
+        connect_with_transport(@transport)
+      elsif @browser_ws_endpoint
         connect_with_browser_ws_endpoint(@browser_ws_endpoint)
-      elsif @browser_ws_endpoint.nil? && @browser_url && @transport.nil?
+      elsif @browser_url
         connect_with_browser_url(@browser_url)
-      elsif @browser_ws_endpoint.nil? && @browser_url.nil? && @transport
-        connect_with_transport(@transport)
+      elsif @channel
+        connect_with_channel(@channel)
       else
-        raise ArgumentError.new("Exactly one of browserWSEndpoint, browserURL or transport must be passed to puppeteer.connect")
+        raise ArgumentError.new('Invalid connection options')
       end
+    end
   end
 
   # @return [Puppeteer::Connection]
@@ -72,6 +83,31 @@ class Puppeteer::BrowserConnector
     connect_with_browser_ws_endpoint(connection_url)
   end
 
+  # @return [Puppeteer::Connection]
+  private def connect_with_channel(channel)
+    port_path = File.join(
+      Puppeteer::ChromeUserDataDir.resolve_default(channel),
+      'DevToolsActivePort',
+    )
+
+    begin
+      file_content = File.read(port_path, mode: 'r:ASCII')
+      raw_port, raw_path = file_content.lines.map(&:strip).reject(&:empty?)
+      unless raw_port && raw_path
+        raise Puppeteer::Error.new("Invalid DevToolsActivePort '#{file_content}' found")
+      end
+
+      port = raw_port.to_i
+      if port <= 0 || port > 65_535
+        raise Puppeteer::Error.new("Invalid port '#{raw_port}' found")
+      end
+
+      connect_with_browser_ws_endpoint("ws://localhost:#{port}#{raw_path}")
+    rescue StandardError
+      raise Puppeteer::Error.new("Could not find DevToolsActivePort for #{channel} at #{port_path}")
+    end
+  end
+
   # @return [Puppeteer::Connection]
   private def connect_with_transport(transport)
     Puppeteer::Connection.new(

data/lib/puppeteer/browser_context.rb

@@ -241,7 +241,6 @@ class Puppeteer::BrowserContext
       if partition_key
         normalized['partitionKey'] = convert_partition_key_from_cdp(partition_key)
       end
-      normalized['sameParty'] = cookie['sameParty'] || false
       normalized
     end
   end

data/lib/puppeteer/cdp_session.rb

@@ -66,9 +66,14 @@ class Puppeteer::CDPSession
   # @rbs return: Async::Promise[Hash[String, untyped]] -- Async CDP response
   def async_send_message(method, params = {})
     if !@connection
-      raise Error.new("Protocol error (#{method}): Session closed. Most likely the #{@target_type} has been closed.")
+      raise Puppeteer::TargetCloseError.new(
+        method: method,
+        error_message: "Session closed. Most likely the #{@target_type} has been closed.",
+      )
     end
 
+    @connection.ensure_command_allowed!(method)
+
     promise = Async::Promise.new
 
     @connection.generate_id do |id|
@@ -81,6 +86,12 @@ class Puppeteer::CDPSession
     promise
   end
 
+  # @rbs id: Integer -- CDP command id
+  # @rbs return: bool -- True when the session owns the callback
+  def callback?(id)
+    @callbacks_mutex.synchronize { @callbacks.key?(id) }
+  end
+
   # @rbs message: Hash[String, untyped] -- Raw CDP message
   # @rbs return: void -- No return value
   def handle_message(message)
@@ -97,11 +108,21 @@ class Puppeteer::CDPSession
 
   private def callback_with_message(callback, message)
     if message['error']
-      callback.reject(
-        Puppeteer::Connection::ProtocolError.new(
-          method: callback.method,
-          error_message: message['error']['message'],
-          error_data: message['error']['data']))
+      if message['error']['message'].include?('Session with given id not found')
+        handle_closed
+        callback.reject(
+          Puppeteer::TargetCloseError.new(
+            method: callback.method,
+            error_message: 'Session with given id not found.',
+          ),
+        )
+      else
+        callback.reject(
+          Puppeteer::Connection::ProtocolError.new(
+            method: callback.method,
+            error_message: message['error']['message'],
+            error_data: message['error']['data']))
+      end
     else
       callback.resolve(message['result'])
     end
@@ -122,9 +143,9 @@ class Puppeteer::CDPSession
     end
     callbacks.each do |callback|
       callback.reject(
-        Puppeteer::Connection::ProtocolError.new(
+        Puppeteer::TargetCloseError.new(
           method: callback.method,
-          error_message: 'Target Closed.'))
+          error_message: 'Target closed'))
     end
     @ready_promise.reject(Error.new("Session closed")) unless @ready_promise.resolved?
     @connection = nil

data/lib/puppeteer/chrome_target_manager.rb

@@ -2,7 +2,7 @@ class Puppeteer::ChromeTargetManager
   include Puppeteer::DebugPrint
   include Puppeteer::EventCallbackable
 
-  def initialize(connection:, target_factory:, target_filter_callback:, block_list: nil)
+  def initialize(connection:, target_factory:, target_filter_callback:, block_list: nil, allow_list: nil)
     @discovered_targets_by_target_id = {}
     @attached_targets_by_target_id = {}
     @attached_targets_by_session_id = {}
@@ -13,10 +13,17 @@ class Puppeteer::ChromeTargetManager
     @connection = connection
     @target_filter_callback = target_filter_callback
     @target_factory = target_factory
-    @block_list = block_list
-    if @block_list && !@block_list.is_a?(Array)
+    if block_list && allow_list
+      raise ArgumentError.new('Cannot specify both blocklist and allowlist')
+    end
+    if block_list && !block_list.is_a?(Array)
       raise ArgumentError.new('block_list must be an Array of URL patterns')
     end
+    if allow_list && !allow_list.is_a?(Array)
+      raise ArgumentError.new('allow_list must be an Array of URL patterns')
+    end
+    @block_list = map_patterns(block_list)
+    @allow_list = map_patterns(allow_list)
     @target_interceptors = {}
     @initialize_promise = Async::Promise.new
     @initial_attach_done = false
@@ -44,10 +51,7 @@ class Puppeteer::ChromeTargetManager
     Async do
       @connection.async_send_message('Target.setDiscoverTargets', {
         discover: true,
-        filter: [
-          { type: 'tab', exclude: true },
-          {},
-        ],
+        filter: [{}],
       }).wait
       store_existing_targets_for_init
     rescue => err
@@ -57,7 +61,7 @@ class Puppeteer::ChromeTargetManager
 
   private def store_existing_targets_for_init
     @discovered_targets_by_target_id.each do |target_id, target_info|
-      if @target_filter_callback.call(target_info) && target_info.type != 'browser' && url_allowed?(target_info.url)
+      if @target_filter_callback.call(target_info) && target_info.type == 'tab' && url_allowed?(target_info.url)
         @target_ids_for_init << target_id
       end
     end
@@ -68,6 +72,10 @@ class Puppeteer::ChromeTargetManager
       waitForDebuggerOnStart: true,
       flatten: true,
       autoAttach: true,
+      filter: [
+        { type: 'page', exclude: true },
+        {},
+      ],
     })
     @initial_attach_done = true
     finish_initialization_if_ready
@@ -83,6 +91,19 @@ class Puppeteer::ChromeTargetManager
     @attached_targets_by_target_id
   end
 
+  def remove_extension_service_workers(extension_id)
+    extension_url = "chrome-extension://#{extension_id}/"
+    target_ids = @discovered_targets_by_target_id.filter_map do |target_id, target_info|
+      if target_info.type == 'service_worker' && target_info.url.start_with?(extension_url)
+        target_id
+      end
+    end
+    target_ids.each do |target_id|
+      @ignored_targets << target_id
+      handle_target_destroyed('targetId' => target_id)
+    end
+  end
+
   def wait_for_service_worker_detach(target_id)
     promise = @service_worker_detach_promises[target_id]
     return unless promise
@@ -171,6 +192,10 @@ class Puppeteer::ChromeTargetManager
       return
     end
     original_target = @attached_targets_by_target_id[target_info.target_id]
+    if original_target&.target_info&.subtype && !target_info.subtype
+      session = original_target.session
+      session&.parent_session&.emit_event(CDPSessionEmittedEvents::Swapped, session)
+    end
     emit_event(TargetManagerEmittedEvents::TargetChanged, original_target, target_info) if original_target
   end
 
@@ -189,7 +214,7 @@ class Puppeteer::ChromeTargetManager
         begin
           Puppeteer::AsyncUtils.await(session.async_send_message('Runtime.runIfWaitingForDebugger'))
         rescue => err
-          Logger.new($stderr).warn(err)
+          debug_puts(err)
         end
 
         # We don't use `session.detach()` because that dispatches all commands on
@@ -199,7 +224,7 @@ class Puppeteer::ChromeTargetManager
             sessionId: session.id,
           }))
         rescue => err
-          Logger.new($stderr).warn(err)
+          debug_puts(err)
         ensure
           if detached_promise && !detached_promise.resolved?
             detached_promise.resolve(true)
@@ -208,7 +233,16 @@ class Puppeteer::ChromeTargetManager
       end
     }
 
-    return unless @connection.auto_attached?(target_info.target_id)
+    unless @connection.auto_attached?(target_info.target_id)
+      Async do
+        maybe_setup_network_conditions(session, target_info)
+      rescue => err
+        debug_puts(err)
+      ensure
+        session.mark_ready
+      end
+      return
+    end
 
     if !@initial_attach_done && !url_allowed?(target_info.url)
       finish_initialization_if_ready(target_info.target_id)
@@ -225,6 +259,23 @@ class Puppeteer::ChromeTargetManager
     # CDP.
     if target_info.type == 'service_worker' && @connection.auto_attached?(target_info.target_id)
       finish_initialization_if_ready(target_info.target_id)
+      unless url_allowed?(target_info.url)
+        Async do
+          setup_task = Async do
+            maybe_setup_network_conditions(session, target_info)
+          rescue => err
+            debug_puts(err)
+          end
+          run_promise = session.async_send_message('Runtime.runIfWaitingForDebugger')
+          Puppeteer::AsyncUtils.await(run_promise)
+          Puppeteer::AsyncUtils.await(setup_task)
+        rescue => err
+          debug_puts(err)
+        ensure
+          session.mark_ready
+        end
+        return
+      end
       @service_worker_detach_promises[target_info.target_id] ||= Async::Promise.new
       silent_detach.call(@service_worker_detach_promises[target_info.target_id])
       return if @attached_targets_by_target_id.has_key?(target_info.target_id)
@@ -238,7 +289,8 @@ class Puppeteer::ChromeTargetManager
 
     unless @target_filter_callback.call(target_info)
       @ignored_targets << target_info.target_id
-      finish_initialization_if_ready(target_info.target_id)
+      parent_target = parent_session.is_a?(Puppeteer::CDPSession) ? parent_session.target : nil
+      finish_initialization_if_ready(parent_target.target_id) if parent_target&.raw_type == 'tab'
       silent_detach.call
 
       return
@@ -267,25 +319,39 @@ class Puppeteer::ChromeTargetManager
       end
     end
 
-    @target_ids_for_init.delete(target.target_id)
     unless is_existing_target
       Async do
         Puppeteer::AsyncUtils.future_with_logging { emit_event(TargetManagerEmittedEvents::TargetAvailable, target) }.call
       end
     end
+    parent_target = parent_session.is_a?(Puppeteer::CDPSession) ? parent_session.target : nil
+    finish_initialization_if_ready(parent_target.target_id) if parent_target&.raw_type == 'tab'
     finish_initialization_if_ready
     parent_session.emit_event(CDPSessionEmittedEvents::Ready, session)
 
     Async do
-      Puppeteer::AsyncUtils.await(session.async_send_message('Target.setAutoAttach', {
-        waitForDebuggerOnStart: true,
-        flatten: true,
-        autoAttach: true,
-      }))
-      maybe_setup_network_conditions(session)
-      Puppeteer::AsyncUtils.await(session.async_send_message('Runtime.runIfWaitingForDebugger'))
+      setup_task = Async do
+        maybe_setup_network_conditions(session, target_info)
+      rescue => err
+        debug_puts(err)
+      end
+      promises = [
+        session.async_send_message('Target.setAutoAttach', {
+          waitForDebuggerOnStart: true,
+          flatten: true,
+          autoAttach: true,
+          filter: [{}],
+        }),
+        session.async_send_message('Runtime.runIfWaitingForDebugger'),
+        setup_task,
+      ]
+      promises.each do |promise|
+        Puppeteer::AsyncUtils.await(promise)
+      rescue => err
+        debug_puts(err)
+      end
     rescue => err
-      Logger.new($stderr).warn(err)
+      debug_puts(err)
     ensure
       session.mark_ready
     end
@@ -307,32 +373,77 @@ class Puppeteer::ChromeTargetManager
   end
 
   private def url_allowed?(url)
-    return true if @block_list.nil? || @block_list.empty?
+    block_list = @block_list || []
+    allow_list = @allow_list || []
+    return true if block_list.empty? && allow_list.empty?
     return true if url.nil? || url.empty? || url == 'about:blank'
 
-    @block_list.none? do |pattern|
-      File.fnmatch?(pattern, url, File::FNM_EXTGLOB)
-    rescue ArgumentError
-      false
+    blocked = block_list.any? { |item| item[:pattern].test?(url) }
+    return false if blocked
+
+    return true if allow_list.empty?
+
+    allow_list.any? { |item| item[:pattern].test?(url) }
+  end
+  public :url_allowed?
+
+  private def map_patterns(rules)
+    return nil if rules.nil?
+
+    rules.map do |rule|
+      {
+        pattern: URLPattern::URLPattern.new(rule),
+        rule: rule,
+      }
     end
   end
 
-  private def maybe_setup_network_conditions(session)
-    return if @block_list.nil? || @block_list.empty?
+  private def maybe_setup_network_conditions(session, target_info)
+    block_list = @block_list || []
+    allow_list = @allow_list || []
+    return if block_list.empty? && allow_list.empty?
 
-    matched_network_conditions = @block_list.map do |pattern|
+    matched_network_conditions = block_list.map do |item|
       {
-        urlPattern: pattern,
+        urlPattern: item[:rule],
+        offline: true,
         latency: 0,
         downloadThroughput: -1,
         uploadThroughput: -1,
       }
     end
-    Puppeteer::AsyncUtils.await(session.async_send_message('Network.enable'))
-    Puppeteer::AsyncUtils.await(session.async_send_message('Network.emulateNetworkConditionsByRule', {
+    allow_list.each do |item|
+      matched_network_conditions << {
+        urlPattern: item[:rule],
+        offline: false,
+        latency: 0,
+        downloadThroughput: -1,
+        uploadThroughput: -1,
+      }
+    end
+    unless allow_list.empty?
+      matched_network_conditions << {
+        urlPattern: '',
+        offline: true,
+        latency: 0,
+        downloadThroughput: -1,
+        uploadThroughput: -1,
+      }
+    end
+
+    promises = []
+    worker_types = ['worker', 'service_worker', 'shared_worker']
+    promises << session.async_send_message('Network.enable') if worker_types.include?(target_info.type)
+    params = {
+      offline: block_list.empty? ? nil : true,
       matchedNetworkConditions: matched_network_conditions,
-      offline: true,
-    }))
+    }.compact
+    promises << session.async_send_message('Network.emulateNetworkConditionsByRule', params)
+    promises.each do |promise|
+      Puppeteer::AsyncUtils.await(promise)
+    rescue => err
+      debug_puts(err)
+    end
   rescue => err
     message = err.message.to_s.downcase
     return if message.include?('target closed') || message.include?('session closed') || message.include?('not found')

data/lib/puppeteer/chrome_user_data_dir.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative './env'
+
+module Puppeteer::ChromeUserDataDir
+  CHANNELS = %w[chrome chrome-beta chrome-canary chrome-dev].freeze #: Array[String]
+
+  MAC_DIR_NAMES = {
+    'chrome' => 'Chrome',
+    'chrome-beta' => 'Chrome Beta',
+    'chrome-canary' => 'Chrome Canary',
+    'chrome-dev' => 'Chrome Dev',
+  }.freeze #: Hash[String, String]
+
+  LINUX_DIR_NAMES = {
+    'chrome' => 'google-chrome',
+    'chrome-beta' => 'google-chrome-beta',
+    'chrome-canary' => 'google-chrome-canary',
+    'chrome-dev' => 'google-chrome-unstable',
+  }.freeze #: Hash[String, String]
+
+  WINDOWS_DIR_NAMES = {
+    'chrome' => ['Google', 'Chrome', 'User Data'],
+    'chrome-beta' => ['Google', 'Chrome Beta', 'User Data'],
+    'chrome-canary' => ['Google', 'Chrome SxS', 'User Data'],
+    'chrome-dev' => ['Google', 'Chrome Dev', 'User Data'],
+  }.freeze #: Hash[String, Array[String]]
+
+  # @rbs channel: (String | Symbol) -- Chrome release channel
+  # @rbs platform: Symbol? -- Optional platform override
+  # @rbs env: Hash[String, String] -- Environment variables
+  # @rbs home: String? -- Home directory override
+  # @rbs return: String -- Default user data directory
+  def self.resolve_default(channel, platform: nil, env: ENV, home: nil)
+    channel = normalize_channel(channel)
+    platform ||= current_platform
+    home ||= Dir.home
+
+    case platform.to_sym
+    when :windows
+      base = env['LOCALAPPDATA']
+      base = join_path(:windows, home, 'AppData', 'Local') if base.nil? || base.empty?
+      join_path(:windows, base, *WINDOWS_DIR_NAMES.fetch(channel))
+    when :darwin
+      join_path(:darwin, home, 'Library', 'Application Support', 'Google', MAC_DIR_NAMES.fetch(channel))
+    when :linux
+      base = env['CHROME_CONFIG_HOME']
+      base = env['XDG_CONFIG_HOME'] if base.nil? || base.empty?
+      base = join_path(:linux, home, '.config') if base.nil? || base.empty?
+      join_path(:linux, base, LINUX_DIR_NAMES.fetch(channel))
+    else
+      raise ArgumentError.new("Unsupported platform: #{platform}")
+    end
+  end
+
+  # @rbs channel: (String | Symbol) -- Chrome release channel
+  # @rbs return: String -- Normalized channel
+  def self.normalize_channel(channel)
+    normalized_channel = channel.to_s
+    return normalized_channel if CHANNELS.include?(normalized_channel)
+
+    raise ArgumentError.new("Invalid channel: '#{channel}'. Allowed channel is #{CHANNELS}")
+  end
+
+  # @rbs return: Symbol -- Current platform
+  def self.current_platform
+    if Puppeteer.env.windows?
+      :windows
+    elsif Puppeteer.env.darwin?
+      :darwin
+    else
+      :linux
+    end
+  end
+  private_class_method :current_platform
+
+  # @rbs platform: Symbol -- Target platform
+  # @rbs parts: String -- Path segments
+  # @rbs return: String -- Joined path
+  def self.join_path(platform, *parts)
+    if platform == :windows
+      parts.map(&:to_s).reject(&:empty?).join('\\')
+    else
+      File.join(*parts)
+    end
+  end
+  private_class_method :join_path
+end

data/lib/puppeteer/connection.rb

@@ -44,6 +44,7 @@ class Puppeteer::Connection
     @callbacks_mutex = Mutex.new
     @delay = delay
     @protocol_timeout = protocol_timeout
+    @reject_emulate_network_conditions_calls = false
 
     @network_message_queue = Async::Queue.new
     @network_message_task = nil
@@ -71,6 +72,16 @@ class Puppeteer::Connection
   end
 
   attr_reader :protocol_timeout
+  attr_writer :reject_emulate_network_conditions_calls
+
+  def ensure_command_allowed!(method)
+    return unless method == 'Network.emulateNetworkConditions'
+    return unless @reject_emulate_network_conditions_calls
+
+    raise Puppeteer::Error.new(
+      'Cannot reset network conditions: rule-based emulation is enabled.',
+    )
+  end
 
   # used only in Browser#connected?
   def closed?
@@ -176,6 +187,7 @@ class Puppeteer::Connection
   end
 
   def async_send_message(method, params = {})
+    ensure_command_allowed!(method)
     promise = Async::Promise.new
 
     generate_id do |id|
@@ -332,6 +344,10 @@ class Puppeteer::Connection
         else
           callback.resolve(message['result'])
         end
+      else
+        sessions = @sessions_mutex.synchronize { @sessions.values }
+        session = sessions.find { |candidate| candidate.callback?(message['id']) }
+        session&.handle_message(message)
       end
     else
       emit_event(message['method'], message['params'])
@@ -396,3 +412,6 @@ class Puppeteer::Connection
     @sessions_mutex.synchronize { @sessions[session_id] }.tap { |session| session&.mark_ready }
   end
 end
+
+# ref: https://github.com/puppeteer/puppeteer/blob/main/packages/puppeteer-core/src/common/Errors.ts
+class Puppeteer::TargetCloseError < Puppeteer::Connection::ProtocolError; end

data/lib/puppeteer/coverage.rb

@@ -5,6 +5,11 @@ class Puppeteer::Coverage
     @css = Puppeteer::CSSCoverage.new(client)
   end
 
+  def update_client(client)
+    @js.update_client(client)
+    @css.update_client(client)
+  end
+
   def start_js_coverage(
         reset_on_navigation: nil,
         report_anonymous_scripts: nil,

data/lib/puppeteer/css_coverage.rb

@@ -20,6 +20,10 @@ class Puppeteer::CSSCoverage
     @stylesheet_sources = {}
   end
 
+  def update_client(client)
+    @client = client
+  end
+
   def start(reset_on_navigation: nil)
     raise 'CSSCoverage is already enabled' if @enabled
 

data/lib/puppeteer/dialog.rb

@@ -16,6 +16,11 @@ class Puppeteer::Dialog
   attr_reader :message #: String
   attr_reader :default_value #: String
 
+  # @rbs return: bool -- Whether the dialog has already been handled
+  def handled?
+    @handled
+  end
+
   # @rbs prompt_text: String? -- Text entered into the prompt
   # @rbs return: void -- No return value
   def accept(prompt_text = nil)

data/lib/puppeteer/element_handle.rb

@@ -374,14 +374,13 @@ class Puppeteer::ElementHandle < Puppeteer::JSHandle
 
   # @rbs delay: Numeric? -- Delay between down and up (ms)
   # @rbs button: String? -- Mouse button
-  # @rbs click_count: Integer? -- Deprecated: use count (click_count only sets clickCount)
   # @rbs count: Integer? -- Number of clicks to perform
   # @rbs offset: Puppeteer::ElementHandle::Offset | Hash[Symbol, Numeric] | nil -- Click offset
   # @rbs return: void -- No return value
-  def click(delay: nil, button: nil, click_count: nil, count: nil, offset: nil)
+  def click(delay: nil, button: nil, count: nil, offset: nil)
     scroll_into_view_if_needed
     point = clickable_point(offset)
-    @page.mouse.click(point.x, point.y, delay: delay, button: button, click_count: click_count, count: count)
+    @page.mouse.click(point.x, point.y, delay: delay, button: button, count: count)
   end
 
   define_async_method :async_click