puppeteer-bidi 0.0.1.beta1

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Puppeteer
+  module Bidi
+    module Core
+      # Base error class for Core module
+      class Error < Puppeteer::Bidi::Error
+      end
+
+      # Raised when attempting to use a disposed resource
+      class DisposedError < Error
+        attr_reader :resource_type, :reason
+
+        def initialize(resource_type, reason)
+          @resource_type = resource_type
+          @reason = reason
+          super("#{resource_type} already disposed: #{reason}")
+        end
+      end
+
+      # Raised when a realm has been destroyed
+      class RealmDestroyedError < DisposedError
+        def initialize(reason)
+          super('Realm', reason)
+        end
+      end
+
+      # Raised when a browsing context has been closed
+      class BrowsingContextClosedError < DisposedError
+        def initialize(reason)
+          super('Browsing context', reason)
+        end
+      end
+
+      # Raised when a user context has been closed
+      class UserContextClosedError < DisposedError
+        def initialize(reason)
+          super('User context', reason)
+        end
+      end
+
+      # Raised when a user prompt has been closed
+      class UserPromptClosedError < DisposedError
+        def initialize(reason)
+          super('User prompt', reason)
+        end
+      end
+
+      # Raised when a session has ended
+      class SessionEndedError < DisposedError
+        def initialize(reason)
+          super('Session', reason)
+        end
+      end
+
+      # Raised when a browser has been disconnected
+      class BrowserDisconnectedError < DisposedError
+        def initialize(reason)
+          super('Browser', reason)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Puppeteer
+  module Bidi
+    module Core
+      # EventEmitter provides event subscription and emission capabilities
+      # Similar to Node.js EventEmitter but simpler
+      class EventEmitter
+        def initialize
+          @listeners = Hash.new { |h, k| h[k] = [] }
+          @disposed = false
+        end
+
+        # Register an event listener
+        # @param event [Symbol, String] Event name
+        # @param block [Proc] Event handler
+        def on(event, &block)
+          return if @disposed
+          @listeners[event.to_sym] << block
+        end
+
+        # Register a one-time event listener
+        # @param event [Symbol, String] Event name
+        # @param block [Proc] Event handler
+        def once(event, &block)
+          return if @disposed
+          wrapper = lambda do |*args|
+            off(event, &wrapper)
+            block.call(*args)
+          end
+          on(event, &wrapper)
+        end
+
+        # Remove an event listener
+        # @param event [Symbol, String] Event name
+        # @param block [Proc] Event handler to remove (optional)
+        def off(event, &block)
+          event_sym = event.to_sym
+          if block
+            @listeners[event_sym].delete(block)
+          else
+            @listeners.delete(event_sym)
+          end
+        end
+
+        # Remove all listeners for an event or all events
+        # @param event [Symbol, String, nil] Event name (optional)
+        def remove_all_listeners(event = nil)
+          if event
+            @listeners.delete(event.to_sym)
+          else
+            @listeners.clear
+          end
+        end
+
+        # Emit an event to all registered listeners
+        # @param event [Symbol, String] Event name
+        # @param data [Object] Event data
+        def emit(event, data = nil)
+          return if @disposed
+          listeners = @listeners[event.to_sym].dup
+          listeners.each do |listener|
+            begin
+              listener.call(data)
+            rescue => e
+              warn "Error in event listener for #{event}: #{e.message}\n#{e.backtrace.join("\n")}"
+            end
+          end
+        end
+
+        # Dispose the event emitter
+        def dispose
+          @disposed = true
+          @listeners.clear
+        end
+
+        def disposed?
+          @disposed
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Puppeteer
+  module Bidi
+    module Core
+      # Navigation represents a single navigation operation
+      class Navigation < EventEmitter
+        include Disposable::DisposableMixin
+
+        # Create a navigation instance
+        # @param browsing_context [BrowsingContext] The browsing context
+        # @return [Navigation] New navigation instance
+        def self.from(browsing_context)
+          navigation = new(browsing_context)
+          navigation.send(:initialize_navigation)
+          navigation
+        end
+
+        attr_reader :browsing_context, :request
+
+        def initialize(browsing_context)
+          super()
+          @browsing_context = browsing_context
+          @request = nil
+          @navigation = nil
+          @id = nil
+          @disposables = Disposable::DisposableStack.new
+        end
+
+        # Get the nested navigation if any
+        # @return [Navigation, nil] Nested navigation
+        def navigation
+          @navigation
+        end
+
+        protected
+
+        def perform_dispose
+          @disposables.dispose
+          super
+        end
+
+        private
+
+        def session
+          @browsing_context.user_context.browser.session
+        end
+
+        def initialize_navigation
+          # Listen for browsing context closure
+          @browsing_context.once(:closed) do
+            emit(:failed, {
+              url: @browsing_context.url,
+              timestamp: Time.now
+            })
+            dispose
+          end
+
+          # Listen for requests with navigation ID
+          @browsing_context.on(:request) do |data|
+            request = data[:request]
+            next unless request.navigation
+            next unless matches?(request.navigation)
+
+            @request = request
+            emit(:request, request)
+
+            # Listen for redirects
+            request.on(:redirect) do |redirect_request|
+              @request = redirect_request
+            end
+          end
+
+          # Listen for nested navigation
+          session.on('browsingContext.navigationStarted') do |info|
+            next unless info['context'] == @browsing_context.id
+            next if @navigation && !@navigation.disposed?
+
+            @navigation = Navigation.from(@browsing_context)
+          end
+
+          # Listen for navigation completion events
+          %w[browsingContext.domContentLoaded browsingContext.load].each do |event_name|
+            session.on(event_name) do |info|
+              next unless info['context'] == @browsing_context.id
+              next if info['navigation'].nil?
+              next unless matches?(info['navigation'])
+
+              dispose
+            end
+          end
+
+          # Listen for navigation end events
+          {
+            'browsingContext.fragmentNavigated' => :fragment,
+            'browsingContext.navigationFailed' => :failed,
+            'browsingContext.navigationAborted' => :aborted
+          }.each do |event_name, emit_event|
+            session.on(event_name) do |info|
+              next unless info['context'] == @browsing_context.id
+              next unless matches?(info['navigation'])
+
+              emit(emit_event, {
+                url: info['url'],
+                timestamp: Time.at(info['timestamp'] / 1000.0)
+              })
+              dispose
+            end
+          end
+        end
+
+        def matches?(navigation_id)
+          # If nested navigation exists and is not disposed, this navigation doesn't match
+          return false if @navigation && !@navigation.disposed?
+
+          # First navigation event sets the ID
+          if @id.nil?
+            @id = navigation_id
+            return true
+          end
+
+          # Check if the navigation ID matches
+          @id == navigation_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+module Puppeteer
+  module Bidi
+    module Core
+      # Realm is the base class for script execution realms
+      class Realm < EventEmitter
+        include Disposable::DisposableMixin
+
+        attr_reader :id, :origin
+
+        def initialize(id, origin)
+          super()
+          @id = id
+          @origin = origin
+          @reason = nil
+          @execution_context_id = nil
+          @disposables = Disposable::DisposableStack.new
+        end
+
+        # Get the target for script execution
+        # @return [Hash] BiDi target descriptor
+        def target
+          { realm: @id }
+        end
+
+        # Disown handles (remove references)
+        # @param handles [Array<String>] Handle IDs to disown
+        def disown(handles)
+          raise RealmDestroyedError, @reason if disposed?
+          session.async_send_command('script.disown', {
+            target: target,
+            handles: handles
+          })
+        end
+
+        # Call a function in the realm
+        # @param function_declaration [String] Function source code
+        # @param await_promise [Boolean] Whether to await promise results (Note: different from returnByValue!)
+        # @param options [Hash] Additional options (arguments, serializationOptions, resultOwnership, etc.)
+        # @return [Hash] Evaluation result (with 'type', 'realm', and optionally 'result'/'exceptionDetails')
+        def call_function(function_declaration, await_promise, **options)
+          raise RealmDestroyedError, @reason if disposed?
+
+          # Note: In Puppeteer, returnByValue controls serialization, not awaitPromise
+          # awaitPromise controls whether to wait for promises
+          # For BiDi, we use 'root' ownership by default to keep handles alive
+          # Only use 'none' if explicitly requested
+          params = {
+            functionDeclaration: function_declaration,
+            awaitPromise: await_promise,
+            target: target,
+            resultOwnership: 'root',
+            **options
+          }
+
+          session.async_send_command('script.callFunction', params)
+        end
+
+        # Evaluate an expression in the realm
+        # @param expression [String] JavaScript expression
+        # @param await_promise [Boolean] Whether to await promise results
+        # @param options [Hash] Additional options (serializationOptions, resultOwnership, etc.)
+        # @return [Hash] Evaluation result (with 'type', 'realm', and optionally 'result'/'exceptionDetails')
+        def evaluate(expression, await_promise, **options)
+          raise RealmDestroyedError, @reason if disposed?
+
+          # Use 'root' ownership by default to keep handles alive
+          params = {
+            expression: expression,
+            awaitPromise: await_promise,
+            target: target,
+            resultOwnership: 'root',
+            **options
+          }
+
+          session.async_send_command('script.evaluate', params)
+        end
+
+        # Resolve the CDP execution context ID for this realm
+        # @return [Integer] Execution context ID
+        def resolve_execution_context_id
+          return @execution_context_id if @execution_context_id
+
+          # This uses a Chrome-specific extension to BiDi
+          result = session.connection.send_command('goog:cdp.resolveRealm', { realm: @id })
+          @execution_context_id = result['executionContextId']
+        end
+
+        protected
+
+        # Abstract method - must be implemented by subclasses
+        # @return [Session] The session for this realm
+        def session
+          raise NotImplementedError, 'Subclasses must implement #session'
+        end
+
+        def perform_dispose
+          @reason ||= 'Realm destroyed, probably because all associated browsing contexts closed'
+          emit(:destroyed, { reason: @reason })
+          @disposables.dispose
+          super
+        end
+      end
+
+      # WindowRealm represents a JavaScript realm in a window or iframe
+      class WindowRealm < Realm
+        # Create a window realm
+        # @param browsing_context [BrowsingContext] The browsing context
+        # @param sandbox [String, nil] Sandbox name
+        # @return [WindowRealm] New window realm
+        def self.from(browsing_context, sandbox = nil)
+          realm = new(browsing_context, sandbox)
+          realm.send(:initialize_realm)
+          realm
+        end
+
+        attr_reader :browsing_context, :sandbox
+
+        def initialize(browsing_context, sandbox = nil)
+          super('', '') # ID and origin will be set when realm is created
+          @browsing_context = browsing_context
+          @sandbox = sandbox
+          @workers = {}
+        end
+
+        # Set the environment (Frame) for this realm
+        # This is set by Frame when it's created
+        # @param frame [Frame] The frame environment
+        def environment=(frame)
+          @environment = frame
+        end
+
+        # Get the environment (Frame) for this realm
+        # @return [Frame] The frame environment
+        def environment
+          @environment
+        end
+
+        # Override target to use context-based target
+        # @return [Hash] BiDi target descriptor
+        def target
+          result = { context: @browsing_context.id }
+          result[:sandbox] = @sandbox if @sandbox
+          result
+        end
+
+        protected
+
+        def session
+          @browsing_context.user_context.browser.session
+        end
+
+        private
+
+        def initialize_realm
+          # Listen for browsing context closure
+          @browsing_context.once(:closed) do |data|
+            dispose_realm(data[:reason])
+          end
+
+          # Listen for realm creation (this realm)
+          session.on('script.realmCreated') do |info|
+            next unless info['type'] == 'window'
+            next unless info['context'] == @browsing_context.id
+            next unless info['sandbox'] == @sandbox
+
+            # Set the ID and origin for this realm
+            @id = info['realm']
+            @origin = info['origin']
+            @execution_context_id = nil
+            emit(:updated, self)
+          end
+
+          # Listen for dedicated worker creation
+          session.on('script.realmCreated') do |info|
+            next unless info['type'] == 'dedicated-worker'
+            next unless info['owners']&.include?(@id)
+
+            worker = DedicatedWorkerRealm.from(self, info['realm'], info['origin'])
+            @workers[worker.id] = worker
+
+            worker.once(:destroyed) do
+              @workers.delete(worker.id)
+            end
+
+            emit(:worker, worker)
+          end
+        end
+
+        def dispose_realm(reason)
+          @reason = reason
+          dispose
+        end
+      end
+
+      # DedicatedWorkerRealm represents a JavaScript realm in a dedicated worker
+      class DedicatedWorkerRealm < Realm
+        # Create a dedicated worker realm
+        # @param owner [WindowRealm, DedicatedWorkerRealm, SharedWorkerRealm] Owner realm
+        # @param id [String] Realm ID
+        # @param origin [String] Realm origin
+        # @return [DedicatedWorkerRealm] New dedicated worker realm
+        def self.from(owner, id, origin)
+          realm = new(owner, id, origin)
+          realm.send(:initialize_realm)
+          realm
+        end
+
+        attr_reader :owners
+
+        def initialize(owner, id, origin)
+          super(id, origin)
+          @owners = Set.new([owner])
+          @workers = {}
+        end
+
+        protected
+
+        def session
+          # Get session from any owner
+          @owners.first.session
+        end
+
+        private
+
+        def initialize_realm
+          # Listen for realm destruction
+          session.on('script.realmDestroyed') do |info|
+            next unless info['realm'] == @id
+            dispose_realm('Realm destroyed')
+          end
+
+          # Listen for nested dedicated worker creation
+          session.on('script.realmCreated') do |info|
+            next unless info['type'] == 'dedicated-worker'
+            next unless info['owners']&.include?(@id)
+
+            worker = DedicatedWorkerRealm.from(self, info['realm'], info['origin'])
+            @workers[worker.id] = worker
+
+            worker.once(:destroyed) do
+              @workers.delete(worker.id)
+            end
+
+            emit(:worker, worker)
+          end
+        end
+
+        def dispose_realm(reason)
+          @reason = reason
+          dispose
+        end
+      end
+
+      # SharedWorkerRealm represents a JavaScript realm in a shared worker
+      class SharedWorkerRealm < Realm
+        # Create a shared worker realm
+        # @param browser [Browser] Browser instance
+        # @param id [String] Realm ID
+        # @param origin [String] Realm origin
+        # @return [SharedWorkerRealm] New shared worker realm
+        def self.from(browser, id, origin)
+          realm = new(browser, id, origin)
+          realm.send(:initialize_realm)
+          realm
+        end
+
+        attr_reader :browser
+
+        def initialize(browser, id, origin)
+          super(id, origin)
+          @browser = browser
+          @workers = {}
+        end
+
+        protected
+
+        def session
+          @browser.session
+        end
+
+        private
+
+        def initialize_realm
+          # Listen for realm destruction
+          session.on('script.realmDestroyed') do |info|
+            next unless info['realm'] == @id
+            dispose_realm('Realm destroyed')
+          end
+
+          # Listen for dedicated worker creation
+          session.on('script.realmCreated') do |info|
+            next unless info['type'] == 'dedicated-worker'
+            next unless info['owners']&.include?(@id)
+
+            worker = DedicatedWorkerRealm.from(self, info['realm'], info['origin'])
+            @workers[worker.id] = worker
+
+            worker.once(:destroyed) do
+              @workers.delete(worker.id)
+            end
+
+            emit(:worker, worker)
+          end
+        end
+
+        def dispose_realm(reason)
+          @reason = reason
+          dispose
+        end
+      end
+    end
+  end
+end