puppeteer-bidi 0.0.1.beta10 → 0.0.1

data/development/generate_api_coverage.rb

@@ -0,0 +1,411 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+require "pathname"
+require "time"
+
+ROOT = Pathname.new(__dir__).join("..").expand_path
+CACHE_SCHEMA_VERSION = 1
+
+def run_capture(*command, chdir: nil)
+  output = if chdir
+    IO.popen(command, chdir: chdir.to_s, err: %i[child out], &:read)
+  else
+    IO.popen(command, err: %i[child out], &:read)
+  end
+  status = $?
+  raise "Command failed: #{command.join(" ")}\n#{output}" unless status&.success?
+
+  output
+end
+
+def read_puppeteer_commit(puppeteer_dir)
+  run_capture("git", "rev-parse", "HEAD", chdir: puppeteer_dir.to_s).strip
+rescue StandardError
+  "unknown"
+end
+
+def find_puppeteer_doc_paths(puppeteer_dir)
+  candidates = []
+
+  api_md = puppeteer_dir.join("docs/api.md")
+  candidates << api_md if api_md.file?
+
+  api_dir = puppeteer_dir.join("docs/api")
+  if api_dir.directory?
+    Dir.glob(api_dir.join("**/*.md")).sort.each do |path|
+      candidates << Pathname.new(path)
+    end
+  end
+
+  candidates.uniq
+end
+
+def extract_frontmatter_value(markdown, key)
+  in_frontmatter = false
+  markdown.each_line do |line|
+    stripped = line.strip
+    if stripped == "---"
+      in_frontmatter = !in_frontmatter
+      next
+    end
+    next unless in_frontmatter
+
+    next unless stripped.start_with?("#{key}:")
+
+    value = stripped.delete_prefix("#{key}:").strip
+    value = value[1..-2] if (value.start_with?('"') && value.end_with?('"')) || (value.start_with?("'") && value.end_with?("'"))
+    return value.strip
+  end
+  nil
+end
+
+def extract_heading_api_references(markdown, source:)
+  refs = []
+
+  markdown.each_line do |line|
+    next unless line.start_with?("#")
+
+    heading = line.sub(/\A#+\s+/, "").strip
+    next if heading.empty?
+
+    token = heading.split(/[\s(:—-]/, 2).first.to_s.strip
+    next if token.empty?
+    next if token.start_with?("event:", "type:", "class:", "interface:")
+
+    token = token.delete_suffix("method")
+    token = token.delete_suffix("property")
+    token = token.delete_suffix("class")
+    token = token.delete_suffix("()")
+    token = token.sub(/\Anew\s+/, "")
+    token = token[1..-2] if token.start_with?("`") && token.end_with?("`") && token.length >= 2
+
+    owner = nil
+    member = nil
+
+    if token.include?(".")
+      owner, member = token.split(".", 2)
+    elsif token.include?("#")
+      owner, member = token.split("#", 2)
+    end
+
+    next if owner.nil? || member.nil?
+    next if owner.empty? || member.empty?
+
+    refs << { "owner" => owner, "member" => member, "source" => source }
+  end
+
+  refs
+end
+
+def extract_puppeteer_api(puppeteer_dir)
+  doc_paths = find_puppeteer_doc_paths(puppeteer_dir)
+  raise "Could not find Puppeteer docs under #{puppeteer_dir}" if doc_paths.empty?
+
+  entries = []
+  doc_paths.each do |path|
+    markdown = path.read
+    rel = path.relative_path_from(puppeteer_dir).to_s
+
+    sidebar_label = extract_frontmatter_value(markdown, "sidebar_label")
+    if sidebar_label && (sidebar_label.include?(".") || sidebar_label.include?("#"))
+      token = sidebar_label.strip
+      token = token[1..-2] if token.start_with?("`") && token.end_with?("`") && token.length >= 2
+      owner = nil
+      member = nil
+      if token.include?(".")
+        owner, member = token.split(".", 2)
+      elsif token.include?("#")
+        owner, member = token.split("#", 2)
+      end
+      if owner && member && !owner.empty? && !member.empty?
+        entries << { "owner" => owner, "member" => member, "source" => rel }
+        next
+      end
+    end
+
+    entries.concat(extract_heading_api_references(markdown, source: rel))
+  end
+
+  dedup = {}
+  entries.each do |e|
+    key = "#{e["owner"]}.#{e["member"]}"
+    dedup[key] ||= e
+  end
+
+  dedup.values.sort_by { |e| [e["owner"].downcase, e["member"].downcase] }
+end
+
+def camel_to_snake(name)
+  name
+    .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+    .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+    .tr("-", "_")
+    .downcase
+end
+
+SPECIAL_MEMBER_MAPPINGS = {
+  "$" => "query_selector",
+  "$$" => "query_selector_all",
+  "$eval" => "eval_on_selector",
+  "$$eval" => "eval_on_selector_all",
+  "waitForSelector" => "wait_for_selector",
+  "waitForXPath" => "wait_for_xpath",
+  "waitForFunction" => "wait_for_function",
+  "waitForNavigation" => "wait_for_navigation",
+  "waitForRequest" => "wait_for_request",
+  "waitForResponse" => "wait_for_response",
+  "waitForFileChooser" => "wait_for_file_chooser",
+  "evaluateHandle" => "evaluate_handle",
+  "evaluateOnNewDocument" => "evaluate_on_new_document",
+  "setContent" => "set_content",
+  "setViewport" => "set_viewport",
+  "setUserAgent" => "set_user_agent",
+  "setExtraHTTPHeaders" => "set_extra_http_headers",
+  "isClosed" => "closed?"
+}.freeze
+
+def ruby_member_candidates(node_member)
+  mapped = SPECIAL_MEMBER_MAPPINGS[node_member]
+  return [mapped] if mapped
+
+  snake = camel_to_snake(node_member)
+  candidates = [snake]
+
+  if snake.start_with?("is_") && !snake.end_with?("?")
+    candidates << "#{snake.delete_prefix("is_")}?"
+  end
+
+  candidates.uniq
+end
+
+NODE_OWNER_ALIASES = {
+  "puppeteer" => "Puppeteer",
+  "Puppeteer" => "Puppeteer",
+  "PuppeteerNode" => "Puppeteer",
+  "browser" => "Browser",
+  "Browser" => "Browser",
+  "browsercontext" => "BrowserContext",
+  "browserContext" => "BrowserContext",
+  "BrowserContext" => "BrowserContext",
+  "page" => "Page",
+  "Page" => "Page",
+  "frame" => "Frame",
+  "Frame" => "Frame",
+  "elementhandle" => "ElementHandle",
+  "elementHandle" => "ElementHandle",
+  "ElementHandle" => "ElementHandle",
+  "jshandle" => "JSHandle",
+  "jsHandle" => "JSHandle",
+  "JSHandle" => "JSHandle",
+  "keyboard" => "Keyboard",
+  "Keyboard" => "Keyboard",
+  "mouse" => "Mouse",
+  "Mouse" => "Mouse",
+  "httprequest" => "HTTPRequest",
+  "httpRequest" => "HTTPRequest",
+  "HTTPRequest" => "HTTPRequest",
+  "httpresponse" => "HTTPResponse",
+  "httpResponse" => "HTTPResponse",
+  "HTTPResponse" => "HTTPResponse",
+  "filechooser" => "FileChooser",
+  "fileChooser" => "FileChooser",
+  "FileChooser" => "FileChooser",
+  "target" => "Target",
+  "Target" => "Target"
+}.freeze
+
+def canonical_node_owner(owner)
+  NODE_OWNER_ALIASES[owner] || NODE_OWNER_ALIASES[owner.downcase] || owner
+end
+
+RUBY_OWNER_CONSTANTS = {
+  "Puppeteer" => "Puppeteer::Bidi",
+  "Browser" => "Puppeteer::Bidi::Browser",
+  "BrowserContext" => "Puppeteer::Bidi::BrowserContext",
+  "Page" => "Puppeteer::Bidi::Page",
+  "Frame" => "Puppeteer::Bidi::Frame",
+  "ElementHandle" => "Puppeteer::Bidi::ElementHandle",
+  "JSHandle" => "Puppeteer::Bidi::JSHandle",
+  "Keyboard" => "Puppeteer::Bidi::Keyboard",
+  "Mouse" => "Puppeteer::Bidi::Mouse",
+  "HTTPRequest" => "Puppeteer::Bidi::HTTPRequest",
+  "HTTPResponse" => "Puppeteer::Bidi::HTTPResponse",
+  "FileChooser" => "Puppeteer::Bidi::FileChooser",
+  "Target" => "Puppeteer::Bidi::Target"
+}.freeze
+
+def safe_constantize(name)
+  name.split("::").inject(Object) { |mod, const_name| mod.const_get(const_name) }
+rescue NameError
+  nil
+end
+
+def extract_ruby_public_api
+  $LOAD_PATH.unshift(ROOT.join("lib").to_s)
+  require "puppeteer/bidi"
+
+  api = {}
+  lib_root = ROOT.join("lib").to_s
+
+  RUBY_OWNER_CONSTANTS.each do |label, const_name|
+    constant = safe_constantize(const_name)
+    next unless constant
+
+    if constant.is_a?(Module) && !constant.is_a?(Class)
+      methods = constant.singleton_methods(true).map(&:to_s)
+      methods.select! do |method_name|
+        method_obj = constant.method(method_name)
+        owner_name = method_obj.owner.name
+        owner_name&.start_with?("Puppeteer::Bidi") ||
+          (method_obj.source_location && method_obj.source_location.first.start_with?(lib_root))
+      rescue NameError
+        false
+      end
+      api[label] = { kind: :module, const_name: const_name, methods: methods.sort.uniq }
+      next
+    end
+
+    methods = constant.public_instance_methods(true).map(&:to_s)
+    methods.select! do |method_name|
+      owner_name = constant.instance_method(method_name).owner.name
+      owner_name&.start_with?("Puppeteer::Bidi")
+    rescue NameError
+      false
+    end
+    api[label] = { kind: :class, const_name: const_name, methods: methods.sort.uniq }
+  end
+
+  api
+end
+
+def load_cache(cache_file, expected_commit:)
+  return nil unless cache_file.file?
+
+  data = JSON.parse(cache_file.read)
+  return nil unless data.is_a?(Hash)
+  return nil unless data["schema_version"] == CACHE_SCHEMA_VERSION
+  return nil unless data["puppeteer_commit"] == expected_commit
+
+  entries = data["entries"]
+  return nil unless entries.is_a?(Array)
+
+  entries
+rescue JSON::ParserError
+  nil
+end
+
+def write_cache(cache_file, puppeteer_commit:, entries:)
+  cache_file.parent.mkpath
+  payload = {
+    "schema_version" => CACHE_SCHEMA_VERSION,
+    "puppeteer_commit" => puppeteer_commit,
+    "generated_at" => Time.now.utc.iso8601,
+    "entries" => entries
+  }
+  cache_file.write(JSON.pretty_generate(payload) + "\n")
+end
+
+def generate_markdown(puppeteer_commit:, entries:, ruby_api:)
+  supported_owners = RUBY_OWNER_CONSTANTS.keys.to_h { |k| [k, true] }
+  filtered = entries.select { |e| supported_owners[canonical_node_owner(e["owner"])] }
+  grouped = filtered.group_by { |e| canonical_node_owner(e["owner"]) }
+
+  total = 0
+  supported = 0
+
+  sections = []
+
+  grouped.keys.sort_by(&:downcase).each do |node_owner_label|
+    group = grouped.fetch(node_owner_label)
+    ruby_owner_const = RUBY_OWNER_CONSTANTS[node_owner_label]
+    ruby_owner = ruby_owner_const ? ruby_api[node_owner_label] : nil
+
+    heading = ruby_owner_const ? "#{node_owner_label} (#{ruby_owner_const})" : node_owner_label
+    section_lines = []
+    section_lines << "## #{heading}"
+    section_lines << ""
+    section_lines << "| Node.js | Ruby | Supported |"
+    section_lines << "| --- | --- | :---: |"
+
+    ruby_methods = ruby_owner ? ruby_owner.fetch(:methods) : []
+    ruby_kind = ruby_owner ? ruby_owner.fetch(:kind) : nil
+
+    group.sort_by { |e| e["member"].downcase }.each do |entry|
+      node_owner = entry.fetch("owner")
+      node_member = entry.fetch("member")
+      node_ref = "#{node_owner}.#{node_member}"
+
+      ruby_candidates = ruby_member_candidates(node_member)
+      ruby_supported_method = ruby_candidates.find { |m| ruby_methods.include?(m) }
+
+      total += 1
+      if ruby_supported_method
+        supported += 1
+      end
+
+      ruby_ref = "-"
+      if ruby_owner_const && ruby_candidates.any?
+        separator = ruby_kind == :module ? "." : "#"
+        ruby_method_name = ruby_supported_method || ruby_candidates.first
+        ruby_ref = "#{ruby_owner_const}#{separator}#{ruby_method_name}"
+      end
+
+      status = ruby_supported_method ? "✅" : "❌"
+      section_lines << "| `#{node_ref}` | `#{ruby_ref}` | #{status} |"
+    end
+
+    section_lines << ""
+    sections << section_lines.join("\n")
+  end
+
+  coverage = total.zero? ? 0.0 : (supported.to_f / total) * 100.0
+  lines = []
+  lines << "# API Coverage"
+  lines << ""
+  lines << "- Puppeteer commit: `#{puppeteer_commit}`"
+  lines << "- Generated by: `development/generate_api_coverage.rb`"
+  lines << "- Coverage: `#{supported}/#{total}` (`#{format("%.2f", coverage)}%`)"
+  lines << ""
+  lines << sections.join("\n")
+
+  lines.join("\n") + "\n"
+end
+
+options = {
+  puppeteer_dir: ROOT.join("development", "puppeteer").to_s,
+  cache_dir: ROOT.join("development", "cache").to_s,
+  output: ROOT.join("API_COVERAGE.md").to_s
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: bundle exec ruby development/generate_api_coverage.rb [options]"
+  opts.on("--puppeteer-dir=PATH", "Path to a checked out puppeteer/puppeteer repo") { |v| options[:puppeteer_dir] = v }
+  opts.on("--cache-dir=PATH", "Cache directory (default: development/cache)") { |v| options[:cache_dir] = v }
+  opts.on("--output=PATH", "Output path (default: API_COVERAGE.md)") { |v| options[:output] = v }
+end.parse!
+
+puppeteer_dir = Pathname.new(options.fetch(:puppeteer_dir)).expand_path
+cache_dir = Pathname.new(options.fetch(:cache_dir)).expand_path
+output_path = Pathname.new(options.fetch(:output)).expand_path
+
+raise "Puppeteer repo not found: #{puppeteer_dir}" unless puppeteer_dir.directory?
+
+puppeteer_commit = read_puppeteer_commit(puppeteer_dir)
+cache_file = cache_dir.join("puppeteer_api.json")
+
+entries = load_cache(cache_file, expected_commit: puppeteer_commit)
+unless entries
+  entries = extract_puppeteer_api(puppeteer_dir)
+  write_cache(cache_file, puppeteer_commit: puppeteer_commit, entries: entries)
+end
+
+ruby_api = extract_ruby_public_api
+output_path.write(
+  generate_markdown(
+    puppeteer_commit: puppeteer_commit,
+    entries: entries,
+    ruby_api: ruby_api
+  )
+)

data/development/puppeteer_revision.txt

@@ -0,0 +1 @@
+7d750c25cb29764f2fb31cb90b750a8eec350199

data/lib/puppeteer/bidi/browser.rb

@@ -11,32 +11,26 @@ module Puppeteer
       attr_reader :connection #: Connection
       attr_reader :process #: untyped
       attr_reader :default_browser_context #: BrowserContext
+      attr_reader :ws_endpoint #: String?
 
       # @rbs connection: Connection -- BiDi connection
       # @rbs launcher: BrowserLauncher? -- Browser launcher instance
+      # @rbs ws_endpoint: String? -- WebSocket endpoint URL
+      # @rbs accept_insecure_certs: bool -- Accept insecure certificates
       # @rbs return: Browser -- Browser instance
-      def self.create(connection:, launcher: nil)
+      def self.create(connection:, launcher: nil, ws_endpoint: nil, accept_insecure_certs: false)
         # Create a new BiDi session
         session = Core::Session.from(
           connection: connection,
           capabilities: {
             alwaysMatch: {
-              acceptInsecureCerts: false,
+              acceptInsecureCerts: accept_insecure_certs,
+              unhandledPromptBehavior: { default: 'ignore' },
               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
 
@@ -45,6 +39,7 @@ module Puppeteer
           launcher: launcher,
           core_browser: core_browser,
           session: session,
+          ws_endpoint: ws_endpoint,
         )
       end
 
@@ -52,13 +47,16 @@ module Puppeteer
       # @rbs launcher: BrowserLauncher? -- Browser launcher instance
       # @rbs core_browser: Core::Browser -- Core browser instance
       # @rbs session: Core::Session -- BiDi session
+      # @rbs ws_endpoint: String? -- WebSocket endpoint URL
       # @rbs return: void
-      def initialize(connection:, launcher:, core_browser:, session:)
+      def initialize(connection:, launcher:, core_browser:, session:, ws_endpoint:)
         @connection = connection
         @launcher = launcher
         @closed = false
+        @disconnected = false
         @core_browser = core_browser
         @session = session
+        @ws_endpoint = ws_endpoint
 
         # Create default browser context
         default_user_context = @core_browser.default_user_context
@@ -74,8 +72,10 @@ module Puppeteer
       # @rbs headless: bool -- Run browser in headless mode
       # @rbs args: Array[String]? -- Additional browser arguments
       # @rbs timeout: Numeric? -- Launch timeout in seconds
+      # @rbs accept_insecure_certs: bool -- Accept insecure certificates
       # @rbs return: Browser -- Browser instance
-      def self.launch(executable_path: nil, user_data_dir: nil, headless: true, args: nil, timeout: nil)
+      def self.launch(executable_path: nil, user_data_dir: nil, headless: true, args: nil, timeout: nil,
+                      accept_insecure_certs: false)
         launcher = BrowserLauncher.new(
           executable_path: executable_path,
           user_data_dir: user_data_dir,
@@ -87,6 +87,7 @@ module Puppeteer
 
         # Create transport and connection
         transport = Transport.new(ws_endpoint)
+        ws_endpoint = transport.url
 
         # Start transport connection in background thread with Sync reactor
         # Sync is the preferred way to run async code at the top level
@@ -94,19 +95,32 @@ module Puppeteer
 
         connection = Connection.new(transport)
 
-        browser = create(connection: connection, launcher: launcher)
-        target = browser.wait_for_target { |target| target.type == 'page' }
+        browser = create(connection: connection, launcher: launcher, ws_endpoint: ws_endpoint,
+                         accept_insecure_certs: accept_insecure_certs)
+        _target = browser.wait_for_target { |target| target.type == 'page' }
         browser
       end
 
       # Connect to an existing Firefox browser instance
       # @rbs ws_endpoint: String -- WebSocket endpoint URL
+      # @rbs timeout: Numeric? -- Connect timeout in seconds
+      # @rbs accept_insecure_certs: bool -- Accept insecure certificates
       # @rbs return: Browser -- Browser instance
-      def self.connect(ws_endpoint)
+      def self.connect(ws_endpoint, timeout: nil, accept_insecure_certs: false)
         transport = Transport.new(ws_endpoint)
-        AsyncUtils.async_timeout(30 * 1000, transport.connect).wait
+        ws_endpoint = transport.url
+        timeout_ms = ((timeout || 30) * 1000).to_i
+        AsyncUtils.async_timeout(timeout_ms, transport.connect).wait
         connection = Connection.new(transport)
-        create(connection: connection, launcher: nil)
+
+        # Verify that this endpoint speaks WebDriver BiDi (and is ready) before creating a new session.
+        status = connection.async_send_command('session.status', {}, timeout: timeout_ms).wait
+        unless status.is_a?(Hash) && status['ready'] == true
+          raise Error, "WebDriver BiDi endpoint is not ready: #{status.inspect}"
+        end
+
+        create(connection: connection, launcher: nil, ws_endpoint: ws_endpoint,
+               accept_insecure_certs: accept_insecure_certs)
       end
 
       # Get BiDi session status
@@ -115,18 +129,63 @@ module Puppeteer
         @connection.async_send_command('session.status').wait
       end
 
+      # Get the browser's original user agent
+      # @rbs return: String -- User agent string
+      def user_agent
+        @session.capabilities["userAgent"]
+      end
+
       # Create a new page (Puppeteer-like API)
       # @rbs return: Page -- New page instance
       def new_page
         @default_browser_context.new_page
       end
 
+      # Create a new browser context
+      # @rbs return: BrowserContext -- New browser context
+      def create_browser_context
+        user_context = @core_browser.create_user_context.wait
+        browser_context_for(user_context)
+      end
+
       # Get all pages
       # @rbs return: Array[Page] -- All pages
       def pages
+        return [] if @closed || @disconnected
+
         @default_browser_context.pages
       end
 
+      # Get all cookies in the default browser context.
+      # @rbs return: Array[Hash[String, untyped]] -- Cookies
+      def cookies
+        @default_browser_context.cookies
+      end
+
+      # Set cookies in the default browser context.
+      # @rbs *cookies: Array[Hash[String, untyped]] -- Cookie data
+      # @rbs **cookie: untyped -- Single cookie via keyword arguments
+      # @rbs return: void
+      def set_cookie(*cookies, **cookie)
+        @default_browser_context.set_cookie(*cookies, **cookie)
+      end
+
+      # Delete cookies in the default browser context.
+      # @rbs *cookies: Array[Hash[String, untyped]] -- Cookies to delete
+      # @rbs **cookie: untyped -- Single cookie via keyword arguments
+      # @rbs return: void
+      def delete_cookie(*cookies, **cookie)
+        @default_browser_context.delete_cookie(*cookies, **cookie)
+      end
+
+      # Delete cookies matching the provided filters in the default browser context.
+      # @rbs *filters: Array[Hash[String, untyped]] -- Cookie filters
+      # @rbs **filter: untyped -- Single filter via keyword arguments
+      # @rbs return: void
+      def delete_matching_cookies(*filters, **filter)
+        @default_browser_context.delete_matching_cookies(*filters, **filter)
+      end
+
       # Register event handler
       # @rbs event: String | Symbol -- Event name
       # @rbs &block: (untyped) -> void -- Event handler
@@ -143,19 +202,50 @@ module Puppeteer
         @closed = true
 
         begin
-          @connection.close
+          begin
+            @connection.async_send_command('browser.close', {}).wait
+          rescue StandardError => e
+            debug_error(e)
+          ensure
+            @connection.close
+          end
         rescue => e
-          warn "Error closing connection: #{e.message}"
+          debug_error(e)
         end
 
         @launcher&.kill
       end
 
+      # Disconnect from the browser (does not close the browser process).
+      # @rbs return: void
+      def disconnect
+        return if @closed || @disconnected
+
+        @disconnected = true
+
+        begin
+          @session.end_session
+        rescue StandardError => e
+          debug_error(e)
+        ensure
+          begin
+            @connection.close
+          rescue StandardError => e
+            debug_error(e)
+          end
+        end
+      end
+
       # @rbs return: bool
       def closed?
         @closed
       end
 
+      # @rbs return: bool
+      def disconnected?
+        @disconnected
+      end
+
       # Wait until a target (top-level browsing context) satisfies the predicate.
       # @rbs timeout: Integer? -- Timeout in milliseconds (default: 30000)
       # @rbs &predicate: (BrowserTarget | PageTarget | FrameTarget) -> boolish -- Predicate evaluated against each Target
@@ -251,6 +341,12 @@ module Puppeteer
 
       private
 
+      def debug_error(error)
+        return unless ENV['DEBUG_BIDI_COMMAND']
+
+        warn(error.full_message)
+      end
+
       # @rbs &block: (BrowserTarget | PageTarget | FrameTarget) -> void -- Block to yield each target to
       # @rbs return: Enumerator[BrowserTarget | PageTarget | FrameTarget, void] -- Enumerator of targets
       def each_target(&block)
@@ -284,7 +380,7 @@ module Puppeteer
       end
 
       # @rbs user_context: Core::UserContext -- User context to get browser context for
-      # @rbs return: BrowserContext? -- Browser context or nil
+      # @rbs return: BrowserContext -- Browser context
       def browser_context_for(user_context)
         return @browser_contexts[user_context.id] if @browser_contexts.key?(user_context.id)