puppeteer-ruby 0.52.1 → 0.53.0

data/lib/puppeteer/network_manager.rb

@@ -99,6 +99,7 @@ class Puppeteer::NetworkManager
     @extra_http_headers = {}
     @user_agent = nil
     @user_agent_metadata = nil
+    @accept_language = nil
 
     @attempted_authentications = Set.new
     @user_request_interception_enabled = false
@@ -146,12 +147,12 @@ class Puppeteer::NetworkManager
   end
 
   private def ignore_client_error?(error)
+    return true if error.is_a?(Puppeteer::TargetCloseError)
+
     message = error&.message
     return false unless message
 
     lowered = message.downcase
-    return true if lowered.include?('target closed')
-    return true if lowered.include?('session closed')
     return true if lowered.include?('not supported')
     return true if lowered.include?("wasn't found")
 
@@ -175,10 +176,12 @@ class Puppeteer::NetworkManager
   end
 
   private def apply_user_agent(client)
-    return unless @user_agent
+    user_agent = @user_agent || @frame_manager.page.browser.user_agent
+    return unless user_agent
 
     safe_send_message(client, 'Network.setUserAgentOverride', {
-      userAgent: @user_agent,
+      userAgent: user_agent,
+      acceptLanguage: @accept_language,
       userAgentMetadata: @user_agent_metadata,
     }.compact)
   end
@@ -212,6 +215,8 @@ class Puppeteer::NetworkManager
     if @internal_network_condition.active?
       safe_send_message(client, 'Network.emulateNetworkConditions', @internal_network_condition.params)
     end
+  rescue => err
+    raise unless ignore_client_error?(err)
   end
 
   # @param username [String|NilClass]
@@ -281,6 +286,13 @@ class Puppeteer::NetworkManager
   end
   alias_method :user_agent=, :set_user_agent
 
+  # @rbs accept_language: String? -- Accept-Language override
+  # @rbs return: void -- No return value
+  def set_accept_language(accept_language)
+    @accept_language = accept_language
+    apply_to_clients { |client| apply_user_agent(client) }
+  end
+
   def cache_enabled=(enabled)
     @user_cache_disabled = !enabled
     update_protocol_cache_disabled

data/lib/puppeteer/page.rb

@@ -40,32 +40,46 @@ class Puppeteer::Page
     @closed = false
     @client = client
     @target = target
-    @tab_id = nil
+    @tab_session = client.parent_session || client
+    @tab_target = @tab_session.target || target
+    @tab_id = @tab_target.target_id
     @keyboard = Puppeteer::Keyboard.new(client)
     @mouse = Puppeteer::Mouse.new(client, @keyboard)
     @timeout_settings = Puppeteer::TimeoutSettings.new
     @touchscreen = Puppeteer::TouchScreen.new(client, @keyboard)
-    # @accessibility = Accessibility.new(client)
     @frame_manager = Puppeteer::FrameManager.new(client, self, ignore_https_errors, @timeout_settings, network_enabled: network_enabled)
     @emulation_manager = Puppeteer::EmulationManager.new(client)
     @tracing = Puppeteer::Tracing.new(client)
+    @webmcp = Puppeteer::WebMCP.new(client, @frame_manager)
     @page_bindings = {}
     @page_binding_ids = {}
     @coverage = Puppeteer::Coverage.new(client)
     @javascript_enabled = true
     @screenshot_task_queue = ScreenshotTaskQueue.new
+    @screencast_session_count = 0
+    @screencast_start_promise = nil
+    @screencast_mutex = Mutex.new
     @inflight_requests = Set.new
     @request_intercepted_listener_map = ObjectSpace::WeakMap.new
     @attached_sessions = Set.new
+    @primary_session_listener_ids = []
 
     @workers = {}
     @user_drag_interception_enabled = false
     @service_worker_bypassed = false
 
-    @attached_session_listener_id = @client.add_event_listener(CDPSessionEmittedEvents::Ready) do |session|
-      handle_attached_to_session(session)
+    @swapped_session_listener_id = @tab_session.add_event_listener(CDPSessionEmittedEvents::Swapped) do |session|
+      Async do
+        handle_activation(session)
+      rescue => err
+        debug_puts(err)
+      end
     end
-    @target_gone_listener_id = @target.target_manager.add_event_listener(
+    @secondary_session_listener_id = @tab_session.add_event_listener(CDPSessionEmittedEvents::Ready) do |session|
+      handle_secondary_target(session)
+    end
+    @target_manager = @target.target_manager
+    @target_gone_listener_id = @target_manager.add_event_listener(
       TargetManagerEmittedEvents::TargetGone,
       &method(:handle_detached_from_target)
     )
@@ -102,47 +116,95 @@ class Puppeteer::Page
     @file_chooser_interception_is_disabled = false
     @file_chooser_interceptors = Set.new
 
-    @client.on_event('Page.domContentEventFired') do |event|
+    setup_primary_target_listeners(@client)
+  end
+
+  private def setup_primary_target_listeners(client)
+    listener_id = client.add_event_listener(CDPSessionEmittedEvents::Ready) do |session|
+      handle_attached_to_session(session)
+    end
+    @primary_session_listener_ids << [client, listener_id]
+
+    client.on_event('Page.domContentEventFired') do |event|
       emit_event(PageEmittedEvents::DOMContentLoaded)
     end
-    @client.on_event('Page.loadEventFired') do |event|
+    client.on_event('Page.loadEventFired') do |event|
       emit_event(PageEmittedEvents::Load)
     end
-    @client.add_event_listener('Runtime.consoleAPICalled') do |event|
+    client.add_event_listener('Runtime.consoleAPICalled') do |event|
       handle_console_api(event)
     end
-    @client.add_event_listener('Runtime.bindingCalled') do |event|
+    client.add_event_listener('Runtime.bindingCalled') do |event|
       handle_binding_called(event)
     end
-    @client.on_event('Page.javascriptDialogOpening') do |event|
+    client.on_event('Page.javascriptDialogOpening') do |event|
       handle_dialog_opening(event)
     end
-    @client.on_event('Runtime.exceptionThrown') do |exception|
+    client.on_event('Runtime.exceptionThrown') do |exception|
       handle_exception(exception['exceptionDetails'])
     end
-    @client.on_event('Inspector.targetCrashed') do |event|
+    client.on_event('Inspector.targetCrashed') do |event|
       handle_target_crashed
     end
-    @client.on_event('Performance.metrics') do |event|
+    client.on_event('Performance.metrics') do |event|
       emit_event(PageEmittedEvents::Metrics, MetricsEvent.new(event))
     end
-    @client.on_event('Log.entryAdded') do |event|
+    client.on_event('Log.entryAdded') do |event|
       handle_log_entry_added(event)
     end
-    @client.on_event('Page.fileChooserOpened') do |event|
+    client.on_event('Page.fileChooserOpened') do |event|
       handle_file_chooser(event)
     end
-    Async do
-      @target.is_closed_promise.wait
-      @client.remove_event_listener(@attached_session_listener_id)
-      @target.target_manager.remove_event_listener(@target_gone_listener_id)
+  end
+
+  private def handle_activation(session)
+    @client = session
+    @target = session.target
+    @target.instance_variable_set(:@page, self)
+    @keyboard.update_client(session)
+    @mouse.update_client(session)
+    @touchscreen.update_client(session)
+    @emulation_manager.update_client(session)
+    @tracing.update_client(session)
+    @webmcp.update_client(session)
+    @coverage.update_client(session)
+    @frame_manager.swap_frame_tree(session)
+    setup_primary_target_listeners(session)
+  end
+
+  private def handle_secondary_target(session)
+    target = session.target
+    return unless target&.target_info&.subtype == 'prerender'
 
-      emit_event(PageEmittedEvents::Close)
-      @closed = true
+    @frame_manager.register_speculative_session(session)
+    @emulation_manager.register_speculative_session(session)
+  end
+
+  private def mark_closed
+    return if @closed
+
+    cleanup_page_listeners
+    @closed = true
+    emit_event(PageEmittedEvents::Close)
+  end
+
+  private def cleanup_page_listeners
+    return if @page_listeners_cleaned
+
+    @page_listeners_cleaned = true
+    @primary_session_listener_ids.each do |session, listener_id|
+      session.remove_event_listener(listener_id)
     end
+    @tab_session.remove_event_listener(@swapped_session_listener_id, @secondary_session_listener_id)
+    @target_manager.remove_event_listener(@target_gone_listener_id)
   end
 
   private def handle_detached_from_target(target)
+    if target == @tab_target
+      mark_closed
+      return
+    end
+
     session_id = target.session&.id
     @frame_manager.handle_detached_from_target(target)
     return unless session_id
@@ -201,6 +263,7 @@ class Puppeteer::Page
       @frame_manager.async_init(@target.target_id),
       @client.async_send_message('Performance.enable'),
       @client.async_send_message('Log.enable'),
+      @webmcp.async_initialize_domain,
     )
   end
 
@@ -360,10 +423,23 @@ class Puppeteer::Page
   end
 
   # @rbs return: bool -- Whether DevTools is attached to this page
-  def has_devtools
+  def has_dev_tools
     !!browser._has_devtools_target(@target.target_id)
   end
 
+  # @rbs return: Puppeteer::Page -- Existing or newly opened DevTools page
+  def open_dev_tools
+    page_target_id = @target.target_id
+    devtools_target_id = browser._has_devtools_target(page_target_id)
+    if devtools_target_id
+      return browser._get_devtools_target_page(devtools_target_id)
+    end
+
+    browser._create_devtools_page(page_target_id)
+  end
+
+  define_async_method :async_open_dev_tools
+
   # @rbs extension: Puppeteer::Extension -- Extension to trigger
   # @rbs return: void -- No return value
   def trigger_extension_action(extension)
@@ -409,9 +485,14 @@ class Puppeteer::Page
     @frame_manager.main_frame
   end
 
-  attr_reader :touchscreen, :coverage, :tracing, :accessibility
+  attr_reader :touchscreen, :coverage, :tracing, :webmcp
   alias_method :touch_screen, :touchscreen
 
+  # @rbs return: Puppeteer::Accessibility -- Main-frame accessibility tree
+  def accessibility
+    main_frame.accessibility
+  end
+
   # @rbs block: Proc? -- Optional block for instance_eval
   # @rbs return: Puppeteer::Keyboard -- Keyboard instance
   def keyboard(&block)
@@ -1324,6 +1405,13 @@ class Puppeteer::Page
     end
   end
 
+  # @rbs locale: String? -- Locale to emulate, or nil to disable emulation
+  # @rbs return: void -- No return value
+  def emulate_locale(locale = nil)
+    @emulation_manager.emulate_locale(locale)
+    @frame_manager.network_manager.set_accept_language(locale)
+  end
+
   VISION_DEFICIENCY_TYPES = %w[
     none
     achromatopsia
@@ -1369,6 +1457,151 @@ class Puppeteer::Page
 
   attr_reader :viewport
 
+  # @rbs path: String? -- Output file path
+  # @rbs overwrite: bool -- Overwrite an existing output file
+  # @rbs format: String? -- webm, gif, or mp4
+  # @rbs crop: Hash[Symbol, Numeric]? -- Viewport crop rectangle
+  # @rbs scale: Numeric? -- Output scale
+  # @rbs speed: Numeric? -- Playback speed
+  # @rbs fps: Numeric? -- Output frame rate
+  # @rbs loop: Numeric? -- GIF loop count
+  # @rbs delay: Numeric? -- GIF loop delay
+  # @rbs quality: Numeric? -- VP9 CRF value
+  # @rbs colors: Numeric? -- GIF palette size
+  # @rbs ffmpeg_path: String? -- FFmpeg executable path
+  # @rbs return: Puppeteer::ScreenRecorder -- Active recorder
+  def screencast(
+    path: nil,
+    overwrite: true,
+    format: nil,
+    crop: nil,
+    scale: nil,
+    speed: nil,
+    fps: nil,
+    loop: nil,
+    delay: nil,
+    quality: nil,
+    colors: nil,
+    ffmpeg_path: nil
+  )
+    raise ArgumentError.new('`speed` must be greater than 0.') if speed && speed <= 0
+    raise ArgumentError.new('`scale` must be greater than 0.') if scale && scale <= 0
+    width, height, device_pixel_ratio = native_pixel_dimensions
+    normalized_crop = normalize_screencast_crop(crop, width, height, device_pixel_ratio)
+    options = {
+      path: path,
+      overwrite: overwrite,
+      format: format,
+      crop: normalized_crop,
+      scale: scale,
+      speed: speed,
+      fps: fps,
+      loop: loop,
+      delay: delay,
+      quality: quality,
+      colors: colors,
+      ffmpeg_path: ffmpeg_path,
+    }.compact
+    recorder = Puppeteer::ScreenRecorder.new(self, width, height, options)
+    begin
+      _start_screencast
+    rescue
+      recorder.stop
+      raise
+    end
+    recorder
+  end
+
+  # @rbs return: void -- Start a shared CDP screencast session
+  def _start_screencast
+    start_promise, first_session = @screencast_mutex.synchronize do
+      @screencast_session_count += 1
+      next [@screencast_start_promise, false] if @screencast_start_promise
+
+      @screencast_start_promise = Async::Promise.new
+      [@screencast_start_promise, true]
+    end
+    if first_session
+      first_frame = Async::Promise.new
+      client = main_frame.client
+      listener_id = client.once('Page.screencastFrame') do
+        first_frame.resolve(nil) unless first_frame.resolved?
+      end
+      begin
+        client.send_message('Page.startScreencast', format: 'png')
+        first_frame.wait
+        start_promise.resolve(nil)
+      rescue => error
+        start_promise.reject(error) unless start_promise.resolved?
+      ensure
+        client.remove_event_listener(listener_id) if listener_id
+      end
+    end
+    start_promise.wait
+  end
+
+  # @rbs return: void -- Stop a shared CDP screencast session
+  def _stop_screencast
+    should_stop = @screencast_mutex.synchronize do
+      @screencast_session_count -= 1 if @screencast_session_count.positive?
+      next false unless @screencast_start_promise
+
+      @screencast_start_promise = nil
+      @screencast_session_count.zero?
+    end
+    main_frame.client.send_message('Page.stopScreencast') if should_stop
+  end
+
+  private def native_pixel_dimensions
+    original_viewport = @viewport
+    if original_viewport && original_viewport.device_scale_factor != 0
+      self.viewport = original_viewport.merge(device_scale_factor: 0)
+    end
+    main_frame.puppeteer_world.evaluate(<<~JAVASCRIPT)
+      () => [
+        window.visualViewport.width * window.devicePixelRatio,
+        window.visualViewport.height * window.devicePixelRatio,
+        window.devicePixelRatio,
+      ]
+    JAVASCRIPT
+  ensure
+    self.viewport = original_viewport if original_viewport && @viewport != original_viewport
+  end
+
+  private def normalize_screencast_crop(crop, width, height, device_pixel_ratio)
+    return nil unless crop
+
+    value = ->(name) do
+      crop.respond_to?(name) ? crop.public_send(name) : crop[name] || crop[name.to_s]
+    end
+    x = value.call(:x).floor
+    y = value.call(:y).floor
+    crop_width = value.call(:width).ceil
+    crop_height = value.call(:height).ceil
+    if x.negative? || y.negative?
+      raise ArgumentError.new('`crop.x` and `crop.y` must be greater than or equal to 0.')
+    end
+    if crop_width <= 0 || crop_height <= 0
+      raise ArgumentError.new(
+        '`crop.height` and `crop.width` must be greater than or equal to 0.',
+      )
+    end
+    viewport_width = width / device_pixel_ratio
+    viewport_height = height / device_pixel_ratio
+    if x + crop_width > viewport_width
+      raise ArgumentError.new("`crop.width` cannot be larger than the viewport width (#{viewport_width}).")
+    end
+    if y + crop_height > viewport_height
+      raise ArgumentError.new("`crop.height` cannot be larger than the viewport height (#{viewport_height}).")
+    end
+    {
+      x: x * device_pixel_ratio,
+      y: y * device_pixel_ratio,
+      width: crop_width * device_pixel_ratio,
+      height: crop_height * device_pixel_ratio,
+    }
+  end
+
   # @rbs page_function: String -- page_function parameter
   # @rbs args: Array[untyped] -- args parameter
   # @rbs return: untyped -- Result
@@ -1619,13 +1852,7 @@ class Puppeteer::Page
         @client.send_message('Page.close')
       else
         @client.connection.send_message('Target.closeTarget', targetId: @target.target_id)
-        @target.is_closed_promise.wait
-
-        # @closed sometimes remains false, so wait for @closed = true with 100ms timeout.
-        25.times do
-          break if @closed
-          Puppeteer::AsyncUtils.sleep_seconds(0.004)
-        end
+        @tab_target.is_closed_promise.wait
       end
     rescue Puppeteer::Connection::ProtocolError => err
       raise unless err.message.match?(/Target closed/i)
@@ -1644,11 +1871,10 @@ class Puppeteer::Page
   # @rbs selector: String -- CSS selector
   # @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 return: void -- No return value
-  def click(selector, delay: nil, button: nil, click_count: nil, count: nil)
-    main_frame.click(selector, delay: delay, button: button, click_count: click_count, count: count)
+  def click(selector, delay: nil, button: nil, count: nil)
+    main_frame.click(selector, delay: delay, button: button, count: count)
   end
 
   define_async_method :async_click

data/lib/puppeteer/puppeteer.rb

@@ -33,6 +33,7 @@ class Puppeteer::Puppeteer
   # @rbs network_enabled: bool? -- Enable network domain
   # @rbs issues_enabled: bool? -- Enable issues domain
   # @rbs block_list: Array[String]? -- URL block list patterns
+  # @rbs allow_list: Array[String]? -- URL allow list patterns
   # @rbs enable_extensions: (bool | Array[String])? -- Enable extensions or load unpacked extensions
   # @rbs default_viewport: Puppeteer::Viewport? -- Default viewport
   # @rbs slow_mo: Integer? -- Delay between operations (ms)
@@ -61,6 +62,7 @@ class Puppeteer::Puppeteer
     network_enabled: true,
     issues_enabled: true,
     block_list: nil,
+    allow_list: nil,
     enable_extensions: false,
     default_viewport: NoViewport.new,
     slow_mo: nil,
@@ -93,6 +95,7 @@ class Puppeteer::Puppeteer
       network_enabled: network_enabled,
       issues_enabled: issues_enabled,
       block_list: block_list,
+      allow_list: allow_list,
       enable_extensions: enable_extensions,
       default_viewport: default_viewport,
       slow_mo: slow_mo,
@@ -145,6 +148,7 @@ class Puppeteer::Puppeteer
   # @rbs network_enabled: bool? -- Enable network domain
   # @rbs issues_enabled: bool? -- Enable issues domain
   # @rbs block_list: Array[String]? -- URL block list patterns
+  # @rbs allow_list: Array[String]? -- URL allow list patterns
   # @rbs default_viewport: Puppeteer::Viewport? -- Default viewport
   # @rbs slow_mo: Integer? -- Delay between operations (ms)
   # @rbs protocol_timeout: Integer? -- CDP protocol timeout in milliseconds
@@ -159,6 +163,7 @@ class Puppeteer::Puppeteer
     network_enabled: true,
     issues_enabled: true,
     block_list: nil,
+    allow_list: nil,
     default_viewport: NoViewport.new,
     slow_mo: nil,
     protocol_timeout: nil,
@@ -173,6 +178,7 @@ class Puppeteer::Puppeteer
       network_enabled: network_enabled,
       issues_enabled: issues_enabled,
       block_list: block_list,
+      allow_list: allow_list,
       slow_mo: slow_mo,
       protocol_timeout: protocol_timeout,
     }.compact
@@ -226,11 +232,6 @@ class Puppeteer::Puppeteer
     )
   end
 
-  # @rbs return: String -- Product name
-  def product
-    launcher.product
-  end
-
   private def async_context?
     task = Async::Task.current
     !task.nil?