puppeteer-bidi 0.0.1.beta1

data/lib/puppeteer/bidi/browser.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'async'
+require 'async/promise'
+
+module Puppeteer
+  module Bidi
+    # Browser represents a browser instance with BiDi connection
+    class Browser
+      attr_reader :connection #: Connection
+      attr_reader :process #: untyped
+      attr_reader :default_browser_context #: BrowserContext
+
+      # @rbs connection: Connection
+      # @rbs launcher: BrowserLauncher?
+      # @rbs return: Browser
+      def self.create(connection:, launcher: nil)
+        # Create a new BiDi session
+        session = Core::Session.from(
+          connection: connection,
+          capabilities: {
+            alwaysMatch: {
+              acceptInsecureCerts: false,
+              webSocketUrl: true,
+            },
+          },
+        ).wait
+
+        # Subscribe to BiDi modules before creating browser
+        subscribe_modules = %w[
+          browsingContext
+          network
+          log
+          script
+          input
+        ]
+        session.subscribe(subscribe_modules).wait
+
+        core_browser = Core::Browser.from(session).wait
+        session.browser = core_browser
+
+        new(
+          connection: connection,
+          launcher: launcher,
+          core_browser: core_browser,
+          session: session,
+        )
+      end
+
+      # @rbs connection: Connection
+      # @rbs launcher: BrowserLauncher?
+      # @rbs core_browser: Core::Browser
+      # @rbs session: Core::Session
+      # @rbs return: void
+      def initialize(connection:, launcher:, core_browser:, session:)
+        @connection = connection
+        @launcher = launcher
+        @closed = false
+        @core_browser = core_browser
+        @session = session
+
+        # Create default browser context
+        default_user_context = @core_browser.default_user_context
+        @default_browser_context = BrowserContext.new(self, default_user_context)
+        @browser_contexts = {
+          default_user_context.id => @default_browser_context
+        }
+      end
+
+      # Launch a new Firefox browser instance
+      # @rbs **options: untyped
+      # @rbs return: Browser
+      def self.launch(**options)
+        launcher = BrowserLauncher.new(
+          executable_path: options[:executable_path],
+          user_data_dir: options[:user_data_dir],
+          headless: options.fetch(:headless, true),
+          args: options.fetch(:args, [])
+        )
+
+        ws_endpoint = launcher.launch
+
+        # Create transport and connection
+        transport = Transport.new(ws_endpoint)
+
+        # Start transport connection in background thread with Sync reactor
+        # Sync is the preferred way to run async code at the top level
+        AsyncUtils.async_timeout(options.fetch(:timeout, 30) * 1000, transport.connect).wait
+
+        connection = Connection.new(transport)
+
+        browser = create(connection: connection, launcher: launcher)
+        target = browser.wait_for_target { |target| target.type == 'page' }
+        browser
+      end
+
+      # Get BiDi session status
+      # @rbs return: untyped
+      def status
+        @connection.send_command('session.status')
+      end
+
+      # Create a new page (Puppeteer-like API)
+      # @rbs return: Page
+      def new_page
+        @default_browser_context.new_page
+      end
+
+      # Get all pages
+      # @rbs return: Array[Page]
+      def pages
+        @default_browser_context.pages
+      end
+
+      # Register event handler
+      # @rbs event: String | Symbol
+      # @rbs &block: (untyped) -> void
+      # @rbs return: void
+      def on(event, &block)
+        @connection.on(event, &block)
+      end
+
+      # Close the browser
+      # @rbs return: void
+      def close
+        return if @closed
+
+        @closed = true
+
+        begin
+          @connection.close
+        rescue => e
+          warn "Error closing connection: #{e.message}"
+        end
+
+        @launcher&.kill
+      end
+
+      # @rbs return: bool
+      def closed?
+        @closed
+      end
+
+      # Wait until a target (top-level browsing context) satisfies the predicate.
+      # @rbs timeout: Integer?
+      # @rbs &predicate: (Target) -> boolish
+      # @rbs return: Target
+      def wait_for_target(timeout: nil, &predicate)
+        predicate ||= ->(_target) { true }
+        timeout_ms = timeout || 30_000
+        raise ArgumentError, 'timeout must be >= 0' if timeout_ms && timeout_ms.negative?
+
+        if (target = find_target(predicate))
+          return target
+        end
+
+        promise = Async::Promise.new
+        session_listeners = []
+        browser_listeners = []
+
+        cleanup = lambda do
+          session_listeners.each do |event, listener|
+            @session.off(event, &listener)
+          end
+          session_listeners.clear
+
+          browser_listeners.each do |event, listener|
+            @core_browser.off(event, &listener)
+          end
+          browser_listeners.clear
+        end
+
+        check_and_resolve = lambda do
+          return if promise.resolved?
+
+          begin
+            if (match = find_target(predicate))
+              promise.resolve(match)
+              cleanup.call
+            end
+          rescue => error
+            promise.reject(error) unless promise.resolved?
+            cleanup.call
+          end
+        end
+
+        session_listener = proc { |_data| check_and_resolve.call }
+        session_events = [
+          :'browsingContext.contextCreated',
+          :'browsingContext.navigationStarted',
+          :'browsingContext.historyUpdated',
+          :'browsingContext.fragmentNavigated',
+          :'browsingContext.domContentLoaded',
+          :'browsingContext.load'
+        ]
+
+        session_events.each do |event|
+          @session.on(event, &session_listener)
+          session_listeners << [event, session_listener]
+        end
+
+        browser_disconnect_listener = proc do |data|
+          next if promise.resolved?
+
+          reason = data[:reason] || 'Browser disconnected'
+          promise.reject(Core::BrowserDisconnectedError.new(reason))
+          cleanup.call
+        end
+
+        @core_browser.on(:disconnected, &browser_disconnect_listener)
+        browser_listeners << [:disconnected, browser_disconnect_listener]
+
+        # Re-check after listeners are set up to avoid missing fast events.
+        check_and_resolve.call
+
+        begin
+          result = if timeout_ms
+                     AsyncUtils.async_timeout(timeout_ms, promise).wait
+                   else
+                     promise.wait
+                   end
+        rescue Async::TimeoutError
+          raise TimeoutError, "Waiting for target failed: timeout #{timeout_ms}ms exceeded"
+        ensure
+          cleanup.call
+        end
+
+        result
+      end
+
+      # Wait for browser process to exit
+      # @rbs return: void
+      def wait_for_exit
+        @launcher&.wait
+      end
+
+      private
+
+      # @rbs &block: (Target) -> void
+      # @rbs return: Enumerator[Target, void]
+      def each_target(&block)
+        return enum_for(:each_target) unless block_given?
+        return unless @core_browser
+
+        yield BrowserTarget.new(self)
+
+        @core_browser.user_contexts.each do |user_context|
+          next if user_context.disposed?
+
+          browser_context = browser_context_for(user_context)
+          next unless browser_context
+
+          user_context.browsing_contexts.each do |browsing_context|
+            next if browsing_context.disposed?
+
+            page = browser_context.page_for(browsing_context)
+            yield PageTarget.new(page) if page
+          end
+        end
+      end
+
+      # @rbs predicate: (Target) -> boolish
+      # @rbs return: Target?
+      def find_target(predicate)
+        each_target do |target|
+          return target if predicate.call(target)
+        end
+        nil
+      end
+
+      # @rbs user_context: Core::UserContext
+      # @rbs return: BrowserContext?
+      def browser_context_for(user_context)
+        return @browser_contexts[user_context.id] if @browser_contexts.key?(user_context.id)
+
+        context = BrowserContext.new(self, user_context)
+        user_context.once(:closed) do
+          @browser_contexts.delete(user_context.id)
+        end
+        @browser_contexts[user_context.id] = context
+      end
+    end
+  end
+end

data/lib/puppeteer/bidi/browser_context.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Puppeteer
+  module Bidi
+    # BrowserContext represents an isolated browsing session
+    # This is a high-level wrapper around Core::UserContext
+    class BrowserContext
+      attr_reader :user_context, :browser
+
+      def initialize(browser, user_context)
+        @browser = browser
+        @user_context = user_context
+        @pages = {}
+      end
+
+      # Create a new page (tab/window)
+      # @return [Page] New page instance
+      def new_page
+        browsing_context = @user_context.create_browsing_context('tab')
+        page_for(browsing_context)
+      end
+
+      # Get all pages in this context
+      # @return [Array<Page>] All pages
+      def pages
+        @pages.values
+      end
+
+      def page_for(browsing_context)
+        @pages[browsing_context.id] ||= begin
+          page = Page.new(self, browsing_context)
+
+          browsing_context.once(:closed) do
+            @pages.delete(browsing_context.id)
+          end
+
+          page
+        end
+      end
+
+      # Close the browser context
+      def close
+        @user_context.close
+      end
+
+      # Check if context is closed
+      # @return [Boolean] Whether the context is closed
+      def closed?
+        @user_context.disposed?
+      end
+    end
+  end
+end

data/lib/puppeteer/bidi/browser_launcher.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'tmpdir'
+require 'fileutils'
+require 'async'
+require 'async/http/endpoint'
+require 'json'
+require 'net/http'
+
+module Puppeteer
+  module Bidi
+    # BrowserLauncher handles launching Firefox with BiDi support
+    class BrowserLauncher
+      class LaunchError < Error; end
+
+      attr_reader :executable_path, :user_data_dir
+
+      def initialize(executable_path: nil, user_data_dir: nil, headless: true, args: [])
+        @executable_path = executable_path || find_firefox
+        @user_data_dir = user_data_dir
+        @headless = headless
+        @extra_args = args
+        @temp_user_data_dir = nil
+        @process = nil
+        @ws_endpoint = nil
+      end
+
+      # Launch Firefox and return BiDi WebSocket endpoint
+      # @return [String] WebSocket endpoint URL
+      def launch
+        setup_user_data_dir
+        port = find_available_port
+
+        args = build_launch_args(port)
+
+        # Launch Firefox process
+        stdin, stdout, stderr, wait_thr = Open3.popen3(@executable_path, *args)
+        @process = wait_thr
+
+        # Close stdin as we don't need it
+        stdin.close
+
+        # Wait for BiDi endpoint to be available
+        @ws_endpoint = wait_for_ws_endpoint(port, stdout, stderr)
+
+        unless @ws_endpoint
+          kill
+          raise LaunchError, 'Failed to get BiDi WebSocket endpoint'
+        end
+
+        @ws_endpoint
+      rescue => e
+        kill
+        raise LaunchError, "Failed to launch Firefox: #{e.message}"
+      end
+
+      # Kill the Firefox process
+      def kill
+        if @process && @process.alive?
+          begin
+            Process.kill('TERM', @process.pid)
+            # Give it time to shut down gracefully
+            sleep(0.5)
+            Process.kill('KILL', @process.pid) if @process.alive?
+          rescue Errno::ESRCH
+            # Process already dead
+          end
+        end
+
+        cleanup_temp_user_data_dir
+      end
+
+      # Wait for process to exit
+      def wait
+        @process&.value
+      end
+
+      private
+
+      def find_firefox
+        candidates = [
+          ENV['FIREFOX_PATH'],
+          '/usr/bin/firefox-nightly',
+          '/usr/bin/firefox-devedition',
+          '/usr/bin/firefox',
+          '/usr/bin/firefox-esr',
+          '/snap/bin/firefox',
+          '/Applications/Firefox Nightly.app/Contents/MacOS/firefox',
+          '/Applications/Firefox Developer Edition.app/Contents/MacOS/firefox',
+          '/Applications/Firefox.app/Contents/MacOS/firefox',
+        ].compact
+
+        candidates.each do |path|
+          return path if File.executable?(path)
+        end
+
+        raise LaunchError, 'Could not find Firefox executable. Set FIREFOX_PATH environment variable.'
+      end
+
+      def setup_user_data_dir
+        if @user_data_dir
+          FileUtils.mkdir_p(@user_data_dir)
+        else
+          @temp_user_data_dir = Dir.mktmpdir('puppeteer-firefox-')
+          @user_data_dir = @temp_user_data_dir
+        end
+
+        # Create prefs.js for BiDi support
+        create_prefs_file
+      end
+
+      def create_prefs_file
+        profile_dir = File.join(@user_data_dir, 'profile')
+        FileUtils.mkdir_p(profile_dir)
+
+        prefs_file = File.join(profile_dir, 'prefs.js')
+        prefs_content = default_prefs.map do |key, value|
+          value_str = value.is_a?(String) ? "\"#{value}\"" : value
+          "user_pref(\"#{key}\", #{value_str});"
+        end.join("\n")
+
+        File.write(prefs_file, prefs_content)
+      end
+
+      def default_prefs
+        {
+          # Force all web content to use a single content process. TODO: remove
+          # this once Firefox supports mouse event dispatch from the main frame
+          # context. See https://bugzilla.mozilla.org/show_bug.cgi?id=1773393.
+          'fission.webContentIsolationStrategy': 0,
+        }
+      end
+
+      def cleanup_temp_user_data_dir
+        if @temp_user_data_dir && Dir.exist?(@temp_user_data_dir)
+          FileUtils.rm_rf(@temp_user_data_dir)
+        end
+      end
+
+      def find_available_port
+        # Let Firefox choose a random port by using 0
+        # We'll read the actual port from the DevToolsActivePort file
+        0
+      end
+
+      def build_launch_args(port)
+        args = []
+
+        if RUBY_PLATFORM =~ /darwin/
+          args << '--foreground'
+        end
+
+        # Add headless flag if needed
+        args << '--headless' if @headless
+
+        # Add remote debugging port
+        args << '--remote-debugging-port' << port.to_s
+
+        # Add profile
+        profile_dir = File.join(@user_data_dir, 'profile')
+        args << '--profile' << profile_dir
+
+        # Add user arguments
+        args.concat(@extra_args)
+
+        args
+      end
+
+      def wait_for_ws_endpoint(port, stdout, stderr, timeout: 30)
+        deadline = Time.now + timeout
+
+        # Start threads to read output
+        output_lines = []
+        error_lines = []
+        ws_endpoint = nil
+        mutex = Mutex.new
+
+        stdout_thread = Thread.new do
+          stdout.each_line do |line|
+            mutex.synchronize { output_lines << line }
+            # Check for WebDriver BiDi endpoint in stdout
+            if line =~ /WebDriver BiDi listening on (ws:\/\/[^\s]+)/
+              mutex.synchronize { ws_endpoint = $1 }
+            end
+          end
+        rescue => e
+          warn "Error reading stdout: #{e.message}"
+        end
+
+        stderr_thread = Thread.new do
+          stderr.each_line do |line|
+            mutex.synchronize { error_lines << line }
+            # Debug: print all stderr lines to help diagnose
+            puts "[Firefox stderr] #{line}" if ENV['DEBUG_FIREFOX']
+            # Firefox outputs the BiDi WebSocket endpoint to stderr
+            if line =~ /WebDriver BiDi listening on (ws:\/\/[^\s]+)/
+              mutex.synchronize { ws_endpoint = $1 }
+            end
+          end
+        rescue => e
+          warn "Error reading stderr: #{e.message}"
+        end
+
+        # Wait for WebSocket endpoint to be detected
+        loop do
+          if Time.now > deadline
+            stdout_thread.kill
+            stderr_thread.kill
+            warn "Timeout waiting for BiDi endpoint. stdout: #{output_lines.join}"
+            warn "stderr: #{error_lines.join}"
+            return nil
+          end
+
+          # Check if process died
+          unless @process.alive?
+            warn "Firefox process died. stderr: #{error_lines.join}"
+            return nil
+          end
+
+          # Check if we found the endpoint
+          mutex.synchronize do
+            if ws_endpoint
+              # Keep threads running to consume output (detach them)
+              stdout_thread.join(0.1)
+              stderr_thread.join(0.1)
+              return ws_endpoint
+            end
+          end
+
+          sleep(0.1)
+        end
+      ensure
+        # Detach the output threads (let them run in background)
+        stdout_thread&.join(1)
+        stderr_thread&.join(1)
+      end
+    end
+  end
+end