puppeteer-ruby 0.52.1 → 0.53.0

data/lib/puppeteer/screen_recorder.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'fileutils'
+require 'open3'
+require 'etc'
+
+class Puppeteer::ScreenRecorder
+  DEFAULT_FPS = 30
+  DEFAULT_QUALITY = 30
+  STOP = Object.new.freeze
+
+  # @rbs start_timestamp: Numeric -- First CDP frame timestamp
+  # @rbs previous_timestamp: Numeric -- Previous CDP frame timestamp
+  # @rbs timestamp: Numeric -- Current CDP frame timestamp
+  # @rbs fps: Numeric -- Output frame rate
+  # @rbs return: Integer -- Frames to emit for this interval
+  def self.count_frames(start_timestamp, previous_timestamp, timestamp, fps)
+    finish = ((timestamp - start_timestamp) * fps).round
+    start = ((previous_timestamp - start_timestamp) * fps).round
+    [0, finish - start].max
+  end
+
+  # @rbs page: Puppeteer::Page -- Recorded page
+  # @rbs width: Numeric -- Native viewport width
+  # @rbs height: Numeric -- Native viewport height
+  # @rbs options: Hash[Symbol, untyped] -- Recorder options
+  def initialize(page, width, height, options = {})
+    @page = page
+    @fps = options.fetch(:fps, DEFAULT_FPS)
+    @format = (options[:format] || 'webm').to_s
+    @path = options[:path]
+    @stopped = false
+    @stop_mutex = Mutex.new
+    @finished = false
+    @finish_mutex = Mutex.new
+    @frame_queue = Queue.new
+    @output = +''.b
+    @last_buffer = ''.b
+    @last_written_at = monotonic_time
+    @start_timestamp = nil
+    @previous_timestamp = nil
+    @previous_buffer = nil
+
+    ensure_output_directory
+    command = build_command(width, height, options)
+    @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(*command)
+    @stdin.binmode
+    @stdout.binmode
+
+    @writer_thread = Thread.new { write_frames }
+    @stdout_thread = Thread.new { read_output }
+    @stderr_thread = Thread.new { read_stderr }
+
+    @client = @page.main_frame.client
+    @frame_listener_id = @client.add_event_listener('Page.screencastFrame') do |event|
+      handle_frame(event)
+    end
+    @disconnect_listener_id = @client.once(CDPSessionEmittedEvents::Disconnected) do
+      stop
+    rescue StandardError => error
+      warn(error.message) if ENV['DEBUG']
+    end
+  end
+
+  # @rbs return: String -- Encoded bytes produced so far
+  def data
+    @output.dup
+  end
+
+  # @rbs return: void -- Stop recording and flush FFmpeg
+  def stop
+    should_stop = @stop_mutex.synchronize do
+      next false if @stopped
+
+      @stopped = true
+      true
+    end
+    unless should_stop
+      finish_process
+      return
+    end
+
+    begin
+      @page._stop_screencast
+    rescue StandardError
+      # The page or its CDP session may already be gone.
+    end
+    enqueue_last_frame
+    finish_process
+  end
+
+  private def ensure_output_directory
+    return unless @path
+
+    FileUtils.mkdir_p(File.dirname(File.expand_path(@path)))
+  end
+
+  private def build_command(width, height, options)
+    ffmpeg_path = options[:ffmpeg_path] || 'ffmpeg'
+    speed = options[:speed]
+    scale = options[:scale]
+    crop = options[:crop]
+    loop_count = options[:loop]
+    loop_count = -1 if loop_count.nil? || loop_count.zero?
+    delay = options.fetch(:delay, -1)
+    quality = options.fetch(:quality, DEFAULT_QUALITY)
+    colors = options.fetch(:colors, 256)
+
+    filters = [
+      "crop='min(#{width},iw):min(#{height},ih):0:0'",
+      "pad=#{width}:#{height}:0:0",
+    ]
+    filters << "setpts=#{1.0 / speed}*PTS" if speed
+    if crop
+      filters << "crop=#{crop[:width]}:#{crop[:height]}:#{crop[:x]}:#{crop[:y]}"
+    end
+    filters << "scale=iw*#{scale}:-1:flags=lanczos" if scale
+
+    format_args = format_args(@format, @fps, loop_count, delay, quality, colors)
+    if (vf_index = format_args.index('-vf'))
+      filters << format_args.slice!(vf_index, 2).last
+    end
+
+    [
+      ffmpeg_path,
+      '-loglevel', 'error',
+      '-avioflags', 'direct',
+      '-fpsprobesize', '0',
+      '-probesize', '32',
+      '-analyzeduration', '0',
+      '-fflags', 'nobuffer',
+      # -framerate is an input option and must precede -i.
+      '-framerate', @fps.to_s,
+      '-f', 'image2pipe',
+      '-vcodec', 'png',
+      '-i', 'pipe:0',
+      '-an',
+      '-threads', '1',
+      '-b:v', '0',
+      *format_args,
+      '-vf', filters.join(','),
+      options.fetch(:overwrite, true) ? '-y' : '-n',
+      'pipe:1'
+    ]
+  end
+
+  private def format_args(format, fps, loop_count, delay, quality, colors)
+    cpu_used = [Etc.nprocessors / 2.0, 8].min
+    cpu_used = cpu_used.to_i if cpu_used.to_i == cpu_used
+    libvpx = [
+      '-vcodec', 'vp9',
+      '-crf', quality.to_s,
+      '-deadline', 'realtime',
+      '-cpu-used', cpu_used.to_s
+    ]
+    case format
+    when 'webm'
+      [*libvpx, '-f', 'webm']
+    when 'gif'
+      gif_fps = fps == DEFAULT_FPS ? 20 : 'source_fps'
+      gif_loop = loop_count.infinite? ? 0 : loop_count
+      gif_delay = delay == -1 ? -1 : delay / 10.0
+      [
+        '-vf',
+        "fps=#{gif_fps},split[s0][s1];" \
+        "[s0]palettegen=stats_mode=diff:max_colors=#{colors}[p];" \
+        '[s1][p]paletteuse=dither=bayer',
+        '-loop', gif_loop.to_s,
+        '-final_delay', gif_delay.to_s,
+        '-f', 'gif'
+      ]
+    when 'mp4'
+      [*libvpx, '-movflags', 'hybrid_fragmented', '-f', 'mp4']
+    else
+      raise ArgumentError.new("Unknown screencast format: #{format}")
+    end
+  end
+
+  private def handle_frame(event)
+    @client.async_send_message(
+      'Page.screencastFrameAck',
+      sessionId: event['sessionId'],
+    )
+    timestamp = event.dig('metadata', 'timestamp')
+    return unless timestamp
+
+    buffer = Base64.decode64(event['data'])
+    if @previous_timestamp
+      @start_timestamp ||= @previous_timestamp
+      count = self.class.count_frames(
+        @start_timestamp,
+        @previous_timestamp,
+        timestamp,
+        @fps,
+      )
+      count.times { @frame_queue << @previous_buffer }
+      unless count.zero?
+        @last_buffer = @previous_buffer
+        @last_written_at = monotonic_time
+      end
+    end
+    @previous_timestamp = timestamp
+    @previous_buffer = buffer
+  end
+
+  private def enqueue_last_frame
+    buffer = @last_buffer
+    return if buffer.empty?
+
+    remaining = [1, (@fps * (monotonic_time - @last_written_at)).round].max
+    remaining.times { @frame_queue << buffer }
+  end
+
+  private def finish_process
+    @finish_mutex.synchronize do
+      return if @finished
+
+      begin
+        @client&.remove_event_listener(@frame_listener_id, @disconnect_listener_id)
+        @frame_queue << STOP if @writer_thread&.alive?
+        @writer_thread&.join
+        @stdin&.close unless @stdin&.closed?
+        @wait_thread&.join
+        @stdout_thread&.join
+        @stderr_thread&.join
+        File.binwrite(@path, @output) if @path
+        unless @wait_thread&.value&.success?
+          raise Puppeteer::Error.new("ffmpeg exited unsuccessfully: #{@ffmpeg_error}")
+        end
+      ensure
+        @finished = true
+      end
+    end
+    nil
+  end
+
+  private def write_frames
+    loop do
+      buffer = @frame_queue.pop
+      break if buffer.equal?(STOP)
+
+      @stdin.write(buffer)
+    end
+  rescue Errno::EPIPE, IOError
+    nil
+  ensure
+    @stdin.close unless @stdin.closed?
+  end
+
+  private def read_output
+    while (chunk = @stdout.read(16 * 1024)) && !chunk.empty?
+      @output << chunk
+    end
+  rescue IOError
+    nil
+  end
+
+  private def read_stderr
+    @ffmpeg_error = @stderr.read.to_s
+    warn(@ffmpeg_error) if ENV['DEBUG'] && !@ffmpeg_error.empty?
+  rescue IOError
+    nil
+  end
+
+  private def monotonic_time
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+end

data/lib/puppeteer/target.rb

@@ -6,11 +6,12 @@ class Puppeteer::Target
       @type = options['type']
       @title = options['title']
       @url = options['url']
+      @subtype = options['subtype']
       @attached = options['attached']
       @browser_context_id = options['browserContextId']
       @opener_id = options['openerId']
     end
-    attr_reader :target_id, :type, :title, :url, :attached, :browser_context_id, :opener_id
+    attr_reader :target_id, :type, :title, :url, :subtype, :attached, :browser_context_id, :opener_id
   end
 
   # @param {!Protocol.Target.TargetInfo} targetInfo
@@ -112,6 +113,10 @@ class Puppeteer::Target
     @is_initialized
   end
 
+  def exposed?
+    raw_type != 'tab' && !@target_info.subtype
+  end
+
   # @return [CDPSession|nil]
   def session
     @session
@@ -144,8 +149,7 @@ class Puppeteer::Target
 
   # @return [Puppeteer::Page]
   def as_page
-    existing_page = page
-    return existing_page if existing_page
+    return @page if @page
     return @as_page if @as_page
 
     client = @session || @session_factory.call(false)

data/lib/puppeteer/touch_screen.rb

@@ -13,6 +13,12 @@ class Puppeteer::TouchScreen
     @touches = []
   end
 
+  # @rbs client: Puppeteer::CDPSession -- Replacement CDP session
+  # @rbs return: void -- No return value
+  def update_client(client)
+    @client = client
+  end
+
   # @rbs x: Numeric -- X coordinate
   # @rbs y: Numeric -- Y coordinate
   # @rbs return: void -- No return value

data/lib/puppeteer/tracing.rb

@@ -5,6 +5,10 @@ class Puppeteer::Tracing
     @recording = false
   end
 
+  def update_client(client)
+    @client = client
+  end
+
   DEFAULT_CATEGORIES = [
     '-*',
     'devtools.timeline',

data/lib/puppeteer/version.rb

@@ -1,4 +1,4 @@
 module Puppeteer
-  VERSION = '0.52.1'
-  REF_PUPPETEER_VERSION = '24.42.0'
+  VERSION = '0.53.0'
+  REF_PUPPETEER_VERSION = '25.3.0'
 end

data/lib/puppeteer/wait_task.rb

@@ -174,7 +174,6 @@ class Puppeteer::WaitTask
   WAIT_FOR_PREDICATE_PAGE_FUNCTION = <<~JAVASCRIPT
   function _(root, predicateBody, polling, ...args) {
       const predicate = new Function('...args', predicateBody);
-      const observedRoot = root || document;
       if (polling === 'mutation' && typeof MutationObserver === 'undefined') {
           polling = 'raf';
       }
@@ -346,7 +345,7 @@ class Puppeteer::WaitTask
       if (polling === 'raf') {
           poller = new RAFPoller(runner);
       } else if (polling === 'mutation') {
-          poller = new MutationPoller(runner, observedRoot);
+          poller = new MutationPoller(runner, root || document);
       } else if (typeof polling === 'number') {
           poller = new IntervalPoller(runner, polling);
       } else {

data/lib/puppeteer/web_mcp.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+class Puppeteer::WebMCPTool
+  include Puppeteer::EventCallbackable
+
+  # @rbs web_mcp: Puppeteer::WebMCP -- Owning WebMCP instance
+  # @rbs tool: Hash[String, untyped] -- CDP tool payload
+  # @rbs frame: Puppeteer::Frame -- Defining frame
+  def initialize(web_mcp, tool, frame)
+    @web_mcp = web_mcp
+    @name = tool['name']
+    @description = tool['description']
+    @input_schema = tool['inputSchema']
+    @annotations = tool['annotations']
+    @frame = frame
+    @backend_node_id = tool['backendNodeId']
+    @raw_stack_trace = tool['stackTrace']
+    @form_element = nil
+
+    call_frame = @raw_stack_trace&.fetch('callFrames', [])&.first
+    if call_frame
+      @location = Puppeteer::ConsoleMessage::Location.new(
+        url: call_frame['url'],
+        line_number: call_frame['lineNumber'],
+        column_number: call_frame['columnNumber'],
+      )
+    end
+  end
+
+  attr_reader :name, :description, :input_schema, :annotations, :frame,
+              :location, :raw_stack_trace
+
+  # @rbs return: Puppeteer::ElementHandle? -- Declarative form element
+  def form_element
+    return @form_element if @form_element && !@form_element.disposed?
+    return nil unless @backend_node_id
+
+    @form_element = @frame.main_world.adopt_backend_node(@backend_node_id)
+  end
+
+  # @rbs input: Hash[untyped, untyped] -- Tool input
+  # @rbs return: Puppeteer::WebMCPToolCallResult -- Invocation result
+  def execute(input = {})
+    invocation_id = @web_mcp.invoke_tool(self, input).fetch('invocationId')
+    promise = Async::Promise.new
+    listener = nil
+    listener = @web_mcp.add_event_listener('toolresponded') do |result|
+      next unless result.id == invocation_id
+
+      @web_mcp.remove_event_listener(listener)
+      promise.resolve(result)
+    end
+    promise.wait
+  end
+end
+
+class Puppeteer::WebMCPToolCall
+  # @rbs id: String -- Invocation id
+  # @rbs tool: Puppeteer::WebMCPTool -- Invoked tool
+  # @rbs input: String -- JSON-encoded input
+  def initialize(id, tool, input)
+    @id = id
+    @tool = tool
+    @input = JSON.parse(input)
+  rescue JSON::ParserError => error
+    warn(error.message) if ENV['DEBUG']
+    @input = {}
+  end
+
+  attr_reader :id, :tool, :input
+end
+
+class Puppeteer::WebMCPToolCallResult
+  # @rbs id: String -- Invocation id
+  # @rbs call: Puppeteer::WebMCPToolCall? -- Corresponding call
+  # @rbs status: String -- Invocation status
+  # @rbs output: untyped -- Invocation output
+  # @rbs error_text: String? -- Error text
+  # @rbs exception: Hash[String, untyped]? -- Remote exception
+  def initialize(id:, call:, status:, output:, error_text:, exception:)
+    @id = id
+    @call = call
+    @status = status
+    @output = output
+    @error_text = error_text
+    @exception = exception
+  end
+
+  attr_reader :id, :call, :status, :output, :error_text, :exception
+end
+
+class Puppeteer::WebMCP
+  include Puppeteer::EventCallbackable
+  include Puppeteer::DebugPrint
+  using Puppeteer::DefineAsyncMethod
+
+  ToolsEvent = Struct.new(:tools, keyword_init: true)
+
+  # @rbs client: Puppeteer::CDPSession -- Primary page session
+  # @rbs frame_manager: Puppeteer::FrameManager -- Page frame manager
+  def initialize(client, frame_manager)
+    @client = client
+    @frame_manager = frame_manager
+    @tools = {}
+    @pending_calls = {}
+    @context_listener_ids = {}
+    bind_listeners
+  end
+
+  # @rbs return: void -- Enable the WebMCP CDP domain when available
+  def initialize_domain
+    @client.send_message('WebMCP.enable')
+  rescue => error
+    debug_puts(error)
+    nil
+  end
+
+  define_async_method :async_initialize_domain
+
+  # @rbs tool: Puppeteer::WebMCPTool -- Tool to invoke
+  # @rbs input: Hash[untyped, untyped] -- Invocation input
+  # @rbs return: Hash[String, untyped] -- Invocation metadata
+  def invoke_tool(tool, input)
+    @client.send_message('WebMCP.invokeTool', {
+      frameId: tool.frame.id,
+      toolName: tool.name,
+      input: input,
+    })
+  end
+
+  # @rbs return: Array[Puppeteer::WebMCPTool] -- Registered tools
+  def tools
+    @tools.values.flat_map(&:values)
+  end
+
+  # @rbs client: Puppeteer::CDPSession -- Replacement primary session
+  # @rbs return: void -- No return value
+  def update_client(client)
+    @client.remove_event_listener(*@listener_ids) if @listener_ids
+    @client = client
+    bind_listeners
+  end
+
+  private def bind_listeners
+    @listener_ids = []
+    @listener_ids << @client.add_event_listener('WebMCP.toolsAdded') do |event|
+      handle_tools_added(event)
+    end
+    @listener_ids << @client.add_event_listener('WebMCP.toolsRemoved') do |event|
+      handle_tools_removed(event)
+    end
+    @listener_ids << @client.add_event_listener('WebMCP.toolInvoked') do |event|
+      handle_tool_invoked(event)
+    end
+    @listener_ids << @client.add_event_listener('WebMCP.toolResponded') do |event|
+      handle_tool_responded(event)
+    end
+  end
+
+  private def handle_tools_added(event)
+    added = event.fetch('tools', []).filter_map do |payload|
+      frame = @frame_manager.frame(payload['frameId'])
+      next unless frame
+
+      frame_tools = (@tools[payload['frameId']] ||= {})
+      listen_to_context_destroyed(frame) if frame_tools.empty?
+      tool = Puppeteer::WebMCPTool.new(self, payload, frame)
+      frame_tools[tool.name] = tool
+      tool
+    end
+    emit_event('toolsadded', ToolsEvent.new(tools: added))
+  end
+
+  private def handle_tools_removed(event)
+    removed = event.fetch('tools', []).filter_map do |payload|
+      tool = @tools.dig(payload['frameId'], payload['name'])
+      @tools[payload['frameId']]&.delete(payload['name'])
+      tool
+    end
+    emit_event('toolsremoved', ToolsEvent.new(tools: removed))
+  end
+
+  private def handle_tool_invoked(event)
+    tool = @tools.dig(event['frameId'], event['toolName'])
+    return unless tool
+
+    call = Puppeteer::WebMCPToolCall.new(event['invocationId'], tool, event['input'])
+    @pending_calls[call.id] = call
+    tool.emit_event('toolinvoked', call)
+    emit_event('toolinvoked', call)
+  end
+
+  private def handle_tool_responded(event)
+    call = @pending_calls.delete(event['invocationId'])
+    result = Puppeteer::WebMCPToolCallResult.new(
+      id: event['invocationId'],
+      call: call,
+      status: event['status'],
+      output: event['output'],
+      error_text: event['errorText'],
+      exception: event['exception'],
+    )
+    emit_event('toolresponded', result)
+  end
+
+  private def listen_to_context_destroyed(frame)
+    context = frame.main_world.context
+    return unless context
+    return if @context_listener_ids[frame.id]
+
+    listener_id = context.once('disposed') do
+      handle_context_disposed(frame)
+    end
+    @context_listener_ids[frame.id] = [context, listener_id]
+  end
+
+  private def handle_context_disposed(frame)
+    @pending_calls.clear
+    @context_listener_ids.delete(frame.id)
+    frame_tools = @tools.delete(frame.id)
+    return unless frame_tools
+
+    removed = frame_tools.values
+    emit_event('toolsremoved', ToolsEvent.new(tools: removed)) unless removed.empty?
+  end
+end