puppeteer-bidi 0.0.1.beta1

data/lib/puppeteer/bidi/serializer.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'puppeteer/bidi/lazy_arg'
+
+module Puppeteer
+  module Bidi
+    # Serializer converts Ruby values to BiDi Script.LocalValue format
+    # Based on Puppeteer's Serializer.ts
+    class Serializer
+      class << self
+        # Serialize a Ruby value to BiDi LocalValue format
+        # @param value [Object] Ruby value to serialize
+        # @return [Hash] BiDi LocalValue
+        # @raise [ArgumentError] for unsupported types or circular references
+        def serialize(value)
+          value = value.resolve while value.is_a?(LazyArg)
+
+          # Check for circular references first for complex objects
+          if complex_object?(value)
+            check_circular_reference(value)
+          end
+
+          case value
+          when JSHandle
+            # Handle references (either handle or sharedId)
+            serialize_handle(value)
+          when String
+            { type: 'string', value: value }
+          when Integer
+            { type: 'number', value: value }
+          when Float
+            serialize_number(value)
+          when TrueClass, FalseClass
+            { type: 'boolean', value: value }
+          when NilClass
+            { type: 'null' }
+          when Symbol
+            raise ArgumentError, 'Unable to serialize Symbol'
+          when Proc, Method
+            raise ArgumentError, 'Unable to serialize Proc/Function'
+          when Array
+            {
+              type: 'array',
+              value: value.map { |item| serialize(item) }
+            }
+          when Hash
+            # Plain Ruby Hash → BiDi object with [key, value] pairs
+            {
+              type: 'object',
+              value: value.map { |k, v| [k.to_s, serialize(v)] }
+            }
+          when Set
+            {
+              type: 'set',
+              value: value.map { |item| serialize(item) }
+            }
+          when Regexp
+            {
+              type: 'regexp',
+              value: {
+                pattern: value.source,
+                flags: regexp_flags(value)
+              }
+            }
+          when Time, Date, DateTime
+            # Convert to ISO 8601 string
+            time_value = value.is_a?(Time) ? value : value.to_time
+            {
+              type: 'date',
+              value: time_value.utc.iso8601(3)
+            }
+          else
+            # Unsupported type
+            raise ArgumentError, "Unable to serialize #{value.class}. Use plain objects instead"
+          end
+        end
+
+        private
+
+        # Check if value is a complex object that might have circular references
+        def complex_object?(value)
+          value.is_a?(Array) || value.is_a?(Hash) || value.is_a?(Set)
+        end
+
+        # Check for circular references using JSON encoding
+        # This matches Puppeteer's approach
+        def check_circular_reference(value)
+          JSON.generate(value)
+        rescue JSON::GeneratorError => e
+          if e.message.include?('circular') || e.message.include?('depth')
+            raise ArgumentError, 'Recursive objects are not allowed'
+          end
+          raise
+        end
+
+        # Serialize a JSHandle to a BiDi reference
+        def serialize_handle(handle)
+          remote_value = handle.remote_value
+
+          # Prefer handle over sharedId
+          if remote_value['sharedId']
+            { sharedId: remote_value['sharedId'] }
+          elsif remote_value['handle']
+            { handle: remote_value['handle'] }
+          else
+            # Fallback: return the full remote value
+            remote_value
+          end
+        end
+
+        # Serialize a Float to BiDi number format, handling special values
+        def serialize_number(num)
+          if num.nan?
+            { type: 'number', value: 'NaN' }
+          elsif num == Float::INFINITY
+            { type: 'number', value: 'Infinity' }
+          elsif num == -Float::INFINITY
+            { type: 'number', value: '-Infinity' }
+          elsif num.zero? && (1.0 / num).negative?
+            # Detect -0.0
+            { type: 'number', value: '-0' }
+          else
+            { type: 'number', value: num }
+          end
+        end
+
+        # Extract regexp flags from Ruby Regexp
+        def regexp_flags(regexp)
+          flags = []
+          flags << 'i' if (regexp.options & Regexp::IGNORECASE) != 0
+          flags << 'm' if (regexp.options & Regexp::MULTILINE) != 0
+          flags << 'x' if (regexp.options & Regexp::EXTENDED) != 0
+          flags.join
+        end
+      end
+    end
+  end
+end

data/lib/puppeteer/bidi/target.rb

@@ -0,0 +1,81 @@
+module Puppeteer
+  module Bidi
+    class BrowserTarget
+      def initialize(browser)
+        @browser = browser
+      end
+
+      def page
+        nil
+      end
+
+      def url
+        ''
+      end
+
+      def type
+        'browser'
+      end
+
+      def browser
+        @browser
+      end
+
+      def browser_context
+        @browser.default_browser_context
+      end
+    end
+
+    class PageTarget
+      def initialize(page)
+        @page = page
+      end
+
+      def page
+        @page
+      end
+
+      def url
+        @page.url
+      end
+
+      def type
+        'page'
+      end
+
+      def browser
+        @page.browser_context.browser
+      end
+
+      def browser_context
+        @page.browser_context
+      end
+    end
+
+    class FrameTarget
+      def initialize(frame)
+        @frame = frame
+      end
+
+      def page
+        @frame.page
+      end
+
+      def url
+        @frame.url
+      end
+
+      def type
+        'frame'
+      end
+
+      def browser
+        @frame.browser_context.browser
+      end
+
+      def browser_context
+        @frame.browser_context
+      end
+    end
+  end
+end

data/lib/puppeteer/bidi/task_manager.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Puppeteer
+  module Bidi
+    # TaskManager tracks active WaitTask instances to enable coordinated lifecycle management
+    # This is a faithful port of Puppeteer's TaskManager implementation:
+    # https://github.com/puppeteer/puppeteer/blob/main/packages/puppeteer-core/src/common/WaitTask.ts
+    class TaskManager
+      def initialize
+        @tasks = Set.new
+      end
+
+      # Add a task to the manager
+      # Corresponds to Puppeteer's add(task: WaitTask<any>): void
+      # @param task [WaitTask] Task to add
+      def add(task)
+        @tasks.add(task)
+      end
+
+      # Delete a task from the manager
+      # Corresponds to Puppeteer's delete(task: WaitTask<any>): void
+      # @param task [WaitTask] Task to delete
+      def delete(task)
+        @tasks.delete(task)
+      end
+
+      # Terminate all tasks with an optional error
+      # Corresponds to Puppeteer's terminateAll(error?: Error): void
+      # @param error [Exception, nil] Error to terminate with
+      def terminate_all(error = nil)
+        @tasks.each do |task|
+          task.terminate(error)
+        end
+        @tasks.clear
+      end
+
+      # Rerun all tasks in parallel
+      # Corresponds to Puppeteer's async rerunAll(): Promise<void>
+      def rerun_all
+        @tasks.each(&:rerun)
+      end
+    end
+  end
+end

data/lib/puppeteer/bidi/timeout_settings.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Puppeteer
+  module Bidi
+    # Minimal timeout settings helper to share default wait values across realms.
+    class TimeoutSettings
+      def initialize(default_timeout)
+        @default_timeout = default_timeout
+      end
+
+      def timeout
+        @default_timeout
+      end
+
+      def set_default_timeout(timeout)
+        @default_timeout = timeout
+      end
+    end
+  end
+end

data/lib/puppeteer/bidi/transport.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'async'
+require 'async/websocket/client'
+require 'async/http/endpoint'
+require 'json'
+require 'uri'
+
+module Puppeteer
+  module Bidi
+    # Transport handles WebSocket communication with BiDi server
+    # This is the lowest layer that manages raw WebSocket send/receive
+    class Transport
+      class ClosedError < Error; end
+
+      attr_reader :url
+
+      def initialize(url)
+        # BiDi WebSocket endpoint requires /session path
+        @url = url.end_with?('/session') ? url : "#{url}/session"
+        @endpoint = nil
+        @connection = nil
+        @task = nil
+        @connected = false
+        @closed = false
+        @on_message = nil
+        @on_close = nil
+      end
+
+      # Connect to WebSocket and start receiving messages
+      def connect
+        connection_promise = Async::Promise.new
+        @task = Async do |task|
+          endpoint = Async::HTTP::Endpoint.parse(@url)
+
+          # Connect to WebSocket - this matches minibidi's implementation
+          Async::WebSocket::Client.connect(endpoint) do |connection|
+            @connection = connection
+            @connected = true
+            connection_promise.resolve(connection)
+
+            # Start message receiving loop (this will block until connection closes)
+            receive_loop(connection)
+          end
+        rescue => e
+          warn "Transport connect error: #{e.class} - #{e.message}"
+          warn e.backtrace.join("\n")
+          connection_promise.reject(e)
+          close
+        ensure
+          @connected = false
+        end
+        connection_promise
+      end
+
+      # Send a message to BiDi server
+      def async_send_message(message)
+        raise ClosedError, 'Transport is closed' if @closed
+
+        debug_print_send(message)
+        json = JSON.generate(message)
+        Async do
+          @connection&.write(json)
+          @connection&.flush
+        end
+      end
+
+      # Register message handler
+      def on_message(&block)
+        @on_message = block
+      end
+
+      # Register close handler
+      def on_close(&block)
+        @on_close = block
+      end
+
+      # Close the WebSocket connection
+      def close
+        return if @closed
+
+        @closed = true
+        @connection&.close
+        @on_close&.call
+        @task&.stop
+      end
+
+      def closed?
+        @closed
+      end
+
+      def connected?
+        @connected && !@closed
+      end
+
+      private
+
+      def receive_loop(connection)
+        while (message = connection.read)
+          next if message.nil?
+
+          Async do
+            data = JSON.parse(message)
+            debug_print_receive(data)
+            @on_message&.call(data)
+          rescue JSON::ParserError => e
+            warn "Failed to parse BiDi message: #{e.message}"
+          end
+        end
+      rescue => e
+        warn "Transport receive error: #{e.message}"
+      ensure
+        close unless @closed
+      end
+
+      def debug_print_send(message)
+        if %w[1 true].include?(ENV['DEBUG_PROTOCOL'])
+          puts "SEND >> #{JSON.generate(message)}"
+        end
+      end
+
+      def debug_print_receive(message)
+        if %w[1 true].include?(ENV['DEBUG_PROTOCOL'])
+          puts "RECV << #{JSON.generate(message)}"
+        end
+      end
+    end
+  end
+end

data/lib/puppeteer/bidi/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Puppeteer
+  module Bidi
+    VERSION = "0.0.1.beta1"
+  end
+end