puppeteer-bidi 0.0.1.beta1

data/lib/puppeteer/bidi/core/request.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+module Puppeteer
+  module Bidi
+    module Core
+      # Request represents a network request
+      class Request < EventEmitter
+        include Disposable::DisposableMixin
+
+        # Create a request instance from a beforeRequestSent event
+        # @param browsing_context [BrowsingContext] The browsing context
+        # @param event [Hash] The beforeRequestSent event data
+        # @return [Request] New request instance
+        def self.from(browsing_context, event)
+          request = new(browsing_context, event)
+          request.send(:initialize_request)
+          request
+        end
+
+        attr_reader :browsing_context, :error, :response
+
+        def initialize(browsing_context, event)
+          super()
+          @browsing_context = browsing_context
+          @event = event
+          @error = nil
+          @redirect = nil
+          @response = nil
+          @response_content_promise = nil
+          @request_body_promise = nil
+          @disposables = Disposable::DisposableStack.new
+        end
+
+        # Get request ID
+        # @return [String] Request ID
+        def id
+          @event.dig('request', 'request')
+        end
+
+        # Get request URL
+        # @return [String] Request URL
+        def url
+          @event.dig('request', 'url')
+        end
+
+        # Get request method
+        # @return [String] Request method (GET, POST, etc.)
+        def method
+          @event.dig('request', 'method')
+        end
+
+        # Get request headers
+        # @return [Array<Hash>] Request headers
+        def headers
+          @event.dig('request', 'headers') || []
+        end
+
+        # Get navigation ID if this is a navigation request
+        # @return [String, nil] Navigation ID
+        def navigation
+          @event['navigation']
+        end
+
+        # Get redirect request if this request was redirected
+        # @return [Request, nil] Redirect request
+        def redirect
+          @redirect
+        end
+
+        # Get the last redirect in the chain
+        # @return [Request, nil] Last redirect request
+        def last_redirect
+          redirect_request = @redirect
+          while redirect_request
+            break unless redirect_request.redirect
+            redirect_request = redirect_request.redirect
+          end
+          redirect_request
+        end
+
+        # Get request initiator information
+        # @return [Hash, nil] Initiator info
+        def initiator
+          initiator_data = @event['initiator']
+          return nil unless initiator_data
+
+          {
+            **initiator_data,
+            url: @event.dig('request', 'goog:resourceInitiator', 'url'),
+            stack: @event.dig('request', 'goog:resourceInitiator', 'stack')
+          }.compact
+        end
+
+        # Check if the request is blocked
+        # @return [Boolean] Whether the request is blocked
+        def blocked?
+          @event['isBlocked'] == true
+        end
+
+        # Get resource type (non-standard)
+        # @return [String, nil] Resource type
+        def resource_type
+          @event.dig('request', 'goog:resourceType')
+        end
+
+        # Get POST data (non-standard)
+        # @return [String, nil] POST data
+        def post_data
+          @event.dig('request', 'goog:postData')
+        end
+
+        # Check if request has POST data
+        # @return [Boolean] Whether request has POST data
+        def has_post_data?
+          (@event.dig('request', 'bodySize') || 0) > 0
+        end
+
+        # Get timing information
+        # @return [Hash] Timing info
+        def timing
+          @event.dig('request', 'timings') || {}
+        end
+
+        # Continue the request with optional modifications
+        # @param url [String, nil] Modified URL
+        # @param method [String, nil] Modified method
+        # @param headers [Array<Hash>, nil] Modified headers
+        # @param cookies [Array<Hash>, nil] Modified cookies
+        # @param body [Hash, nil] Modified body
+        def continue_request(url: nil, method: nil, headers: nil, cookies: nil, body: nil)
+          params = { request: id }
+          params[:url] = url if url
+          params[:method] = method if method
+          params[:headers] = headers if headers
+          params[:cookies] = cookies if cookies
+          params[:body] = body if body
+
+          session.send_command('network.continueRequest', params)
+        end
+
+        # Fail the request
+        def fail_request
+          session.send_command('network.failRequest', { request: id })
+        end
+
+        # Provide a response for the request
+        # @param status_code [Integer, nil] Response status code
+        # @param reason_phrase [String, nil] Response reason phrase
+        # @param headers [Array<Hash>, nil] Response headers
+        # @param body [Hash, nil] Response body
+        def provide_response(status_code: nil, reason_phrase: nil, headers: nil, body: nil)
+          params = { request: id }
+          params[:statusCode] = status_code if status_code
+          params[:reasonPhrase] = reason_phrase if reason_phrase
+          params[:headers] = headers if headers
+          params[:body] = body if body
+
+          session.send_command('network.provideResponse', params)
+        end
+
+        # Fetch POST data for the request
+        # @return [String, nil] POST data
+        def fetch_post_data
+          return nil unless has_post_data?
+          return @request_body_promise if @request_body_promise
+
+          @request_body_promise = begin
+            result = session.send_command('network.getData', {
+              dataType: 'request',
+              request: id
+            })
+
+            bytes = result['bytes']
+            if bytes['type'] == 'string'
+              bytes['value']
+            else
+              raise "Collected request body data of type #{bytes['type']} is not supported"
+            end
+          end
+        end
+
+        # Get response content
+        # @return [String] Response content as binary string
+        def response_content
+          return @response_content_promise if @response_content_promise
+
+          @response_content_promise = begin
+            result = session.send_command('network.getData', {
+              dataType: 'response',
+              request: id
+            })
+
+            bytes = result['bytes']
+            if bytes['type'] == 'base64'
+              [bytes['value']].pack('m0')
+            else
+              bytes['value']
+            end
+          rescue => e
+            if e.message.include?('No resource with given identifier found')
+              raise 'Could not load response body for this request. This might happen if the request is a preflight request.'
+            end
+            raise
+          end
+        end
+
+        # Continue with authentication
+        # @param action [String] 'provideCredentials', 'default', or 'cancel'
+        # @param credentials [Hash, nil] Credentials hash with username and password
+        def continue_with_auth(action:, credentials: nil)
+          params = {
+            request: id,
+            action: action
+          }
+          params[:credentials] = credentials if action == 'provideCredentials'
+
+          session.send_command('network.continueWithAuth', params)
+        end
+
+        protected
+
+        def perform_dispose
+          @disposables.dispose
+          super
+        end
+
+        private
+
+        def session
+          @browsing_context.user_context.browser.session
+        end
+
+        def initialize_request
+          # Listen for browsing context closure
+          @browsing_context.once(:closed) do |data|
+            @error = data[:reason]
+            emit(:error, @error)
+            dispose
+          end
+
+          # Listen for redirect
+          session.on('network.beforeRequestSent') do |event|
+            next unless event['context'] == @browsing_context.id
+            next unless event.dig('request', 'request') == id
+
+            # Check if this is a redirect
+            previous_has_auth = @event.dig('request', 'headers')&.any? do |h|
+              h['name'].downcase == 'authorization'
+            end
+            new_has_auth = event.dig('request', 'headers')&.any? do |h|
+              h['name'].downcase == 'authorization'
+            end
+            is_after_auth = new_has_auth && !previous_has_auth
+
+            next unless event['redirectCount'] == @event['redirectCount'] + 1 || is_after_auth
+
+            @redirect = Request.from(@browsing_context, event)
+            emit(:redirect, @redirect)
+            dispose
+          end
+
+          # Listen for authentication required
+          session.on('network.authRequired') do |event|
+            next unless event['context'] == @browsing_context.id
+            next unless event.dig('request', 'request') == id
+            next unless event['isBlocked']
+
+            emit(:authenticate, nil)
+          end
+
+          # Listen for fetch error
+          session.on('network.fetchError') do |event|
+            next unless event['context'] == @browsing_context.id
+            next unless event.dig('request', 'request') == id
+            next unless event['redirectCount'] == @event['redirectCount']
+
+            @error = event['errorText']
+            emit(:error, @error)
+            dispose
+          end
+
+          # Listen for response completed
+          session.on('network.responseCompleted') do |event|
+            next unless event['context'] == @browsing_context.id
+            next unless event.dig('request', 'request') == id
+            next unless event['redirectCount'] == @event['redirectCount']
+
+            @response = event['response']
+            @event['request']['timings'] = event.dig('request', 'timings')
+            emit(:success, @response)
+
+            # Don't dispose if this is a redirect
+            status = @response['status']
+            dispose unless status >= 300 && status < 400
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppeteer/bidi/core/session.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Puppeteer
+  module Bidi
+    module Core
+      # Session represents a BiDi session with the browser
+      # It wraps a Connection and provides session-specific functionality
+      class Session < EventEmitter
+        include Disposable::DisposableMixin
+
+        # Create a new session from an existing connection
+        # @param connection [Puppeteer::Bidi::Connection] The BiDi connection
+        # @param capabilities [Hash] Session capabilities
+        # @return [Session] New session instance
+        def self.from(connection:, capabilities:)
+          Async do
+            result = connection.async_send_command('session.new', { capabilities: capabilities }).wait
+            session = new(connection, result)
+            session.send(:initialize_session).wait
+            session
+          end
+        end
+
+        attr_reader :connection, :id, :capabilities
+        attr_accessor :browser
+
+        def initialize(connection, info)
+          super()
+          @connection = connection
+          @info = info
+          @id = info['sessionId']
+          @capabilities = info['capabilities']
+          @reason = nil
+          @disposables = Disposable::DisposableStack.new
+
+          # Forward BiDi events from connection to session
+          setup_event_forwarding
+        end
+
+        # Check if the session has ended
+        def ended?
+          !@reason.nil?
+        end
+
+        alias disposed? ended?
+
+        # Send a BiDi command through this session
+        # @param method [String] BiDi method name
+        # @param params [Hash] Command parameters
+        # @return [Hash] Command result
+        def async_send_command(method, params = {})
+          raise SessionEndedError, @reason if ended?
+          @connection.async_send_command(method, params)
+        end
+
+        # Subscribe to BiDi events
+        # @param events [Array<String>] Event names to subscribe to
+        # @param contexts [Array<String>, nil] Context IDs (optional)
+        def subscribe(events, contexts = nil)
+          raise SessionEndedError, @reason if ended?
+          params = { events: events }
+          params[:contexts] = contexts if contexts
+          async_send_command('session.subscribe', params)
+        end
+
+        # Add intercepts (same as subscribe but for interception events)
+        # @param events [Array<String>] Event names to intercept
+        # @param contexts [Array<String>, nil] Context IDs (optional)
+        def add_intercepts(events, contexts = nil)
+          subscribe(events, contexts)
+        end
+
+        # End the session
+        def end_session
+          return if ended?
+
+          begin
+            send_command('session.end', {})
+          ensure
+            dispose_session('Session ended')
+          end
+        end
+
+        protected
+
+        def perform_dispose
+          @reason ||= 'Session destroyed, probably because the connection broke'
+          emit(:ended, { reason: @reason })
+          @disposables.dispose
+          super
+        end
+
+        private
+
+        def initialize_session
+          # Subscribe to BiDi modules
+          # Based on Puppeteer's subscribeModules: browsingContext, network, log, script, input
+          subscribe_modules = %w[
+            browsingContext
+            network
+            log
+            script
+            input
+          ]
+
+          subscribe(subscribe_modules)
+        end
+
+        def dispose_session(reason)
+          @reason = reason
+          dispose
+        end
+
+        def setup_event_forwarding
+          # Forward all BiDi events from connection to this session
+          # The existing Connection class uses #on method for event handling
+          # We need to set up listeners for all possible BiDi events
+
+          # For now, we'll use a workaround: store the connection's event listeners
+          # and forward to our EventEmitter
+
+          # List of common BiDi events to forward
+          bidi_events = [
+            'browsingContext.contextCreated',
+            'browsingContext.contextDestroyed',
+            'browsingContext.navigationStarted',
+            'browsingContext.fragmentNavigated',
+            'browsingContext.domContentLoaded',
+            'browsingContext.load',
+            'browsingContext.historyUpdated',
+            'browsingContext.userPromptOpened',
+            'browsingContext.userPromptClosed',
+            'network.beforeRequestSent',
+            'network.responseStarted',
+            'network.responseCompleted',
+            'network.fetchError',
+            'network.authRequired',
+            'script.realmCreated',
+            'script.realmDestroyed',
+            'log.entryAdded',
+            'input.fileDialogOpened',
+          ]
+
+          bidi_events.each do |event_name|
+            @connection.on(event_name) do |params|
+              emit(event_name.to_sym, params)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppeteer/bidi/core/user_context.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Puppeteer
+  module Bidi
+    module Core
+      # UserContext represents an isolated browsing context (like an incognito session)
+      class UserContext < EventEmitter
+        include Disposable::DisposableMixin
+
+        DEFAULT = 'default'
+
+        # Create a user context
+        # @param browser [Browser] Parent browser
+        # @param id [String] Context ID
+        # @return [UserContext] New user context
+        def self.create(browser, id)
+          context = new(browser, id)
+          context.send(:initialize_context)
+          context
+        end
+
+        attr_reader :browser, :id
+
+        def initialize(browser, id)
+          super()
+          @browser = browser
+          @id = id
+          @reason = nil
+          @disposables = Disposable::DisposableStack.new
+          @browsing_contexts = {}
+        end
+
+        # Check if the context is closed
+        def closed?
+          !@reason.nil?
+        end
+
+        alias disposed? closed?
+
+        # Get all browsing contexts in this user context
+        # @return [Array<BrowsingContext>] Top-level browsing contexts
+        def browsing_contexts
+          @browsing_contexts.values
+        end
+
+        # Create a new browsing context (tab or window)
+        # @param type [String] 'tab' or 'window'
+        # @param options [Hash] Creation options
+        # @option options [BrowsingContext] :reference_context Reference context
+        # @return [BrowsingContext] New browsing context
+        def create_browsing_context(type, **options)
+          raise UserContextClosedError, @reason if closed?
+
+          params = {
+            type: type,
+            userContext: @id
+          }
+          params[:referenceContext] = options[:reference_context].id if options[:reference_context]
+          params.merge!(options.except(:reference_context))
+
+          result = session.async_send_command('browsingContext.create', params).wait
+          context_id = result['context']
+
+          # Since event handling might be async or not working properly,
+          # check if the context was already created by the event handler
+          browsing_context = @browsing_contexts[context_id]
+
+          # If not created by event handler, create it manually
+          if browsing_context.nil?
+            browsing_context = BrowsingContext.from(
+              self,
+              nil, # parent
+              context_id,
+              'about:blank',  # Initial URL
+              nil # originalOpener
+            )
+            @browsing_contexts[context_id] = browsing_context
+
+            browsing_context.once(:closed) do
+              @browsing_contexts.delete(context_id)
+            end
+          end
+
+          browsing_context
+        end
+
+        # Remove this user context
+        def remove
+          return if closed?
+
+          begin
+            session.async_send_command('browser.removeUserContext', { userContext: @id })
+          ensure
+            dispose_context('User context removed')
+          end
+        end
+
+        # Get cookies for this user context
+        # @param options [Hash] Cookie filter options
+        # @option options [String] :source_origin Source origin
+        # @return [Array<Hash>] Cookies
+        def get_cookies(**options)
+          raise UserContextClosedError, @reason if closed?
+
+          source_origin = options.delete(:source_origin)
+          params = options.dup
+          params[:partition] = {
+            type: 'storageKey',
+            userContext: @id
+          }
+          params[:partition][:sourceOrigin] = source_origin if source_origin
+
+          result = session.async_send_command('storage.getCookies', params)
+          result['cookies']
+        end
+
+        # Set a cookie in this user context
+        # @param cookie [Hash] Cookie data
+        # @option options [String] :source_origin Source origin
+        def set_cookie(cookie, **options)
+          raise UserContextClosedError, @reason if closed?
+
+          source_origin = options[:source_origin]
+          params = {
+            cookie: cookie,
+            partition: {
+              type: 'storageKey',
+              userContext: @id
+            }
+          }
+          params[:partition][:sourceOrigin] = source_origin if source_origin
+
+          session.async_send_command('storage.setCookie', params)
+        end
+
+        # Set permissions for an origin
+        # @param origin [String] Origin URL
+        # @param descriptor [Hash] Permission descriptor
+        # @param state [String] Permission state
+        def set_permissions(origin, descriptor, state)
+          raise UserContextClosedError, @reason if closed?
+
+          session.async_send_command('permissions.setPermission', {
+            origin: origin,
+            descriptor: descriptor,
+            state: state,
+            userContext: @id
+          })
+        end
+
+        protected
+
+        def perform_dispose
+          @reason ||= 'User context closed, probably because the browser disconnected'
+          emit(:closed, { reason: @reason })
+          @disposables.dispose
+          super
+        end
+
+        private
+
+        def session
+          @browser.session
+        end
+
+        def initialize_context
+          # Listen for browser closure/disconnection
+          @browser.once(:closed) do |data|
+            dispose_context("User context closed: #{data[:reason]}")
+          end
+
+          @browser.once(:disconnected) do |data|
+            dispose_context("User context closed: #{data[:reason]}")
+          end
+
+          # Listen for browsing context creation
+          session.on(:'browsingContext.contextCreated') do |info|
+            # Only handle top-level contexts (no parent)
+            next if info['parent']
+            next if info['userContext'] != @id
+
+            browsing_context = BrowsingContext.from(
+              self,
+              nil, # parent
+              info['context'],
+              info['url'],
+              info['originalOpener']
+            )
+
+            @browsing_contexts[browsing_context.id] = browsing_context
+
+            # Listen for context closure
+            browsing_context.once(:closed) do
+              @browsing_contexts.delete(browsing_context.id)
+            end
+
+            emit(:browsingcontext, { browsing_context: browsing_context })
+          end
+        end
+
+        def dispose_context(reason)
+          @reason = reason
+          dispose
+        end
+      end
+    end
+  end
+end