chromate-rb 0.0.2.pre → 0.0.3.pre

data/lib/bot_browser/downloader.rb

@@ -1,49 +1,61 @@
 # frozen_string_literal: true
 
+# Special thanks to the BotBrowser project (https://github.com/MiddleSchoolStudent/BotBrowser)
+# for providing an amazing foundation for browser automation and making this work possible.
+
+require 'chromate/binary'
+
 module BotBrowser
   class Downloader
     class << self
-      def download(version = nil)
+      def download(version = nil, profile = nil, platform = :mac)
         version ||= versions.keys.first
+        profile ||= profiles[version].keys.first
         version       = version.to_sym
-        platform      = :mac
-        arch          = :arm64
-        binary_path   = download_file(versions[version][platform][arch][:binary], "/tmp/botbrowser_#{version}_#{platform}_#{arch}.dmg")
-        profile_path  = download_file(versions[version][platform][arch][:profile], "/tmp/botbrowser_#{version}_#{platform}_#{arch}.json")
+        binary_path   = download_file(versions[version][platform], "/tmp/botbrowser_#{version}_#{platform}.dmg")
+        profile_path  = download_file(profiles[version][profile], "/tmp/botbrowser_#{version}_#{platform}.json")
 
         [binary_path, profile_path]
       end
 
       def download_file(url, path)
         Chromate::CLogger.log("Downloading #{url} to #{path}")
-        `curl -L #{url} >> #{path}`
+        Chromate::Binary.run('curl', ['-L', url, '-o', path])
 
         path
       end
 
       def versions
         {
+          v132: {
+            mac: 'https://github.com/MiddleSchoolStudent/BotBrowser/releases/download/20250204/botbrowser_132.0.6834.84_mac_arm64.dmg',
+            linux: 'https://github.com/MiddleSchoolStudent/BotBrowser/releases/download/20250204/botbrowser_132.0.6834.84_amd64.deb',
+            windows: 'https://github.com/MiddleSchoolStudent/BotBrowser/releases/download/20250204/botbrowser_132.0.6834.84_win_x86_64.7z'
+          },
+          v130: {
+            mac: 'https://github.com/MiddleSchoolStudent/BotBrowser/releases/download/v130/botbrowser_130.0.6723.92_mac_arm64.dmg',
+            linux: 'https://github.com/MiddleSchoolStudent/BotBrowser/releases/download/v130/botbrowser_130.0.6723.117_amd64.deb',
+            windows: 'https://github.com/MiddleSchoolStudent/BotBrowser/releases/download/v130/botbrowser_130.0.6723.117_win_x86_64.7z'
+          }
+        }
+      end
+
+      def profiles
+        {
+          v128: {
+            mac: 'https://raw.githubusercontent.com/MiddleSchoolStudent/BotBrowser/refs/heads/main/profiles/v128/chrome128_mac_arm64.enc',
+            win: 'https://raw.githubusercontent.com/MiddleSchoolStudent/BotBrowser/refs/heads/main/profiles/v128/chrome128_win10_x86_64.enc'
+          },
+          v129: {
+            mac: 'https://raw.githubusercontent.com/MiddleSchoolStudent/BotBrowser/refs/heads/main/profiles/v129/chrome129_mac_arm64.enc'
+          },
           v130: {
-            mac: {
-              arm64: {
-                binary: 'https://github.com/MiddleSchoolStudent/BotBrowser/releases/download/v130/botbrowser_130.0.6723.92_mac_arm64.dmg',
-                profile: 'https://raw.githubusercontent.com/MiddleSchoolStudent/BotBrowser/refs/heads/main/profiles/v130/chrome130-macarm.enc'
-              }
-            },
-            linux: {
-              x64: {
-                binary: 'https://github.com/MiddleSchoolStudent/BotBrowser/releases/download/v130/botbrowser_130.0.6723.117_amd64.deb',
-                # no specifi linux profile for moment
-                profile: 'https://raw.githubusercontent.com/MiddleSchoolStudent/BotBrowser/refs/heads/main/profiles/v130/chrome130-macarm.enc'
-              }
-            },
-            windows: {
-              x64: {
-                binary: 'https://github.com/MiddleSchoolStudent/BotBrowser/releases/download/v130/botbrowser_130.0.6723.117_win_x86_64.7z',
-                # no specific windows profile for moment
-                profile: 'https://raw.githubusercontent.com/MiddleSchoolStudent/BotBrowser/refs/heads/main/profiles/v130/chrome130-macarm.enc'
-              }
-            }
+            mac: 'https://raw.githubusercontent.com/MiddleSchoolStudent/BotBrowser/refs/heads/main/profiles/v130/chrome130_mac_arm64.enc',
+            iphone: 'https://raw.githubusercontent.com/MiddleSchoolStudent/BotBrowser/refs/heads/main/profiles/v130/chrome130_iphone.enc'
+          },
+          v132: {
+            mac: 'https://github.com/MiddleSchoolStudent/BotBrowser/blob/main/profiles/v132/chrome132_mac_arm64.enc',
+            win: 'https://github.com/MiddleSchoolStudent/BotBrowser/blob/main/profiles/v132/chrome132_win10_x86_64.enc'
           }
         }
       end

data/lib/bot_browser/installer.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require 'yaml'
 require 'chromate/helpers'
 require 'chromate/c_logger'
 require 'bot_browser/downloader'
 
 module BotBrowser
   class Installer
+    class NotInstalledError < StandardError; end
     class << self
       include Chromate::Helpers
 
@@ -22,6 +24,22 @@ module BotBrowser
         "#{Dir.home}/.botbrowser"
       end
 
+      def installed?
+        File.exist?("#{config_dir}/config.yml")
+      end
+
+      def uninstall
+        raise NotInstalledError, 'BotBrowser is not installed' unless installed?
+
+        config = YAML.load_file("#{config_dir}/config.yml")
+        Chromate::CLogger.log("Uninstalling binary at #{config["bot_browser_path"]}")
+        FileUtils.rm_rf(config['bot_browser_path'])
+        Chromate::CLogger.log("Uninstalling profile at #{config["profile"]}")
+        FileUtils.rm_rf(config['profile'])
+        FileUtils.rm_rf(config_dir)
+        Chromate::CLogger.log('Uninstalled')
+      end
+
       private
 
       def install_binary(binary_path)
@@ -35,7 +53,7 @@ module BotBrowser
 
       def create_config_dir
         Chromate::CLogger.log("Creating config directory at #{config_dir}")
-        `mkdir -p #{config_dir}`
+        FileUtils.mkdir_p(config_dir)
       end
 
       def install_profile(profile_path)
@@ -46,24 +64,24 @@ module BotBrowser
       end
 
       def install_binary_mac(binary_path)
-        `hdiutil attach #{binary_path}`
-        `cp -r /Volumes/Chromium/Chromium.app /Applications/`
-        `hdiutil detach /Volumes/Chromium`
-        `xattr -rd com.apple.quarantine /Applications/Chromium.app`
-        `codesign --force --deep --sign - /Applications/Chromium.app`
+        Chromate::Binary.run('hdiutil', ['attach', binary_path])
+        Chromate::Binary.run('cp', ['-r', '/Volumes/Chromium/Chromium.app', '/Applications/'])
+        Chromate::Binary.run('hdiutil', ['detach', '/Volumes/Chromium'])
+        Chromate::Binary.run('xattr', ['-rd', 'com.apple.quarantine', '/Applications/Chromium.app'])
+        Chromate::Binary.run('codesign', ['--force', '--deep', '--sign', '-', '/Applications/Chromium.app'], need_success: false)
 
         '/Applications/Chromium.app/Contents/MacOS/Chromium'
       end
 
       def install_binary_linux(binary_path)
-        `sudo dpkg -i #{binary_path}`
-        `sudo apt-get install -f`
+        Chromate::Binary.run('sudo', ['dpkg', '-i', binary_path])
+        Chromate::Binary.run('sudo', ['apt-get', 'install', '-f'])
 
         '/usr/bin/chromium'
       end
 
       def install_binary_windows(binary_path)
-        `7z x #{binary_path}`
+        Chromate::Binary.run('7z', ['x', binary_path])
 
         'chromium.exe'
       end

data/lib/bot_browser.rb

@@ -10,8 +10,12 @@ module BotBrowser
       Installer.install(version)
     end
 
+    def uninstall
+      Installer.uninstall
+    end
+
     def installed?
-      File.exist?("#{Dir.home}/.botbrowser/config.yml")
+      Installer.installed?
     end
 
     def load

data/lib/chromate/actions/dom.rb

@@ -11,47 +11,36 @@ module Chromate
       # @param selector [String] CSS selector
       # @return [Chromate::Element]
       def find_element(selector)
-        Chromate::Element.new(selector, @client)
-      end
-
-      # @param selector [String] CSS selector
-      # @return [Chromate::Element]
-      def click_element(selector)
-        find_element(selector).click
-      end
-
-      # @param selector [String] CSS selector
-      # @return [Chromate::Element]
-      def hover_element(selector)
-        find_element(selector).hover
-      end
-
-      # @param selector [String] CSS selector
-      # @param text [String] Text to type
-      # @return [Chromate::Element]
-      def type_text(selector, text)
-        find_element(selector).type(text)
-      end
-
-      # @param selector [String] CSS selector
-      # @return [String]
-      def select_option(selector, option)
-        Chromate::Elements::Select.new(selector, @client).select_option(option)
+        base_element = Chromate::Element.new(selector, @client)
+
+        options = {
+          object_id: base_element.object_id,
+          node_id: base_element.node_id,
+          root_id: base_element.root_id
+        }
+
+        if base_element.select?
+          Chromate::Elements::Select.new(selector, @client, **options)
+        elsif base_element.option?
+          Chromate::Elements::Option.new(selector, @client, **options)
+        elsif base_element.radio?
+          Chromate::Elements::Radio.new(selector, @client, **options)
+        elsif base_element.checkbox?
+          Chromate::Elements::Checkbox.new(selector, @client, **options)
+        else
+          base_element
+        end
       end
 
       # @param selector [String] CSS selector
       # @return [String]
       def evaluate_script(script)
-        result = @client.send_message('Runtime.evaluate', expression: script)
+        result = @client.send_message('Runtime.evaluate', expression: script, returnByValue: true)
 
-        case result['result']['type']
-        when 'string', 'number', 'boolean'
-          result['result']['value']
-        when 'object'
-          result['result']['objectId']
-        else
-          result['result']
-        end
+        result['result']['value']
+      rescue StandardError => e
+        Chromate::CLogger.log("Error evaluating script: #{e.message}", :error)
+        nil
       end
     end
   end

data/lib/chromate/actions/navigate.rb

@@ -27,12 +27,15 @@ module Chromate
             case message['method']
             when 'Page.domContentEventFired'
               dom_content_loaded = true
+              Chromate::CLogger.log('DOMContentEventFired')
               condition.signal if dom_content_loaded && page_loaded && frame_stopped_loading
             when 'Page.loadEventFired'
               page_loaded = true
+              Chromate::CLogger.log('LoadEventFired')
               condition.signal if dom_content_loaded && page_loaded && frame_stopped_loading
             when 'Page.frameStoppedLoading'
               frame_stopped_loading = true
+              Chromate::CLogger.log('FrameStoppedLoading')
               condition.signal if dom_content_loaded && page_loaded && frame_stopped_loading
             end
           end

data/lib/chromate/actions/screenshot.rb

@@ -5,17 +5,30 @@ module Chromate
     module Screenshot
       # @param file_path [String] The path to save the screenshot to
       # @param options [Hash] Options for the screenshot
-      # @option options [String] :format The format of the screenshot
+      # @option options [String] :format The format of the screenshot (default: 'png')
       # @option options [Boolean] :full_page Whether to take a screenshot of the full page
       # @option options [Boolean] :fromSurface Whether to take a screenshot from the surface
-      # @return [Boolean] Whether the screenshot was successful
+      # @return [Hash] A hash containing the path and base64-encoded image data of the screenshot
       def screenshot(file_path = "#{Time.now.to_i}.png", options = {})
+        file_path ||= "#{Time.now.to_i}.png"
         return xvfb_screenshot(file_path) if @xfvb
-        return screenshot_full_page(file_path, options) if options.delete(:full_page)
+
+        if options[:full_page]
+          original_viewport = fetch_viewport_size
+          update_screen_size_to_full_page!
+        end
 
         image_data = make_screenshot(options)
+        reset_screen_size! if options[:full_page]
+
         File.binwrite(file_path, image_data)
-        true
+
+        {
+          path: file_path,
+          base64: Base64.encode64(image_data)
+        }
+      ensure
+        restore_viewport_size(original_viewport) if options[:full_page]
       end
 
       private
@@ -27,13 +40,10 @@ module Chromate
         system("xwd -root -display #{display} | convert xwd:- #{file_path}")
       end
 
-      # @param file_path [String] The path to save the screenshot to
-      # @param options [Hash] Options for the screenshot
-      # @option options [String] :format The format of the screenshot
-      # @return [Boolean] Whether the screenshot was successful
-      def screenshot_full_page(file_path, options = {})
+      # Updates the screen size to match the full page dimensions
+      # @return [void]
+      def update_screen_size_to_full_page!
         metrics = @client.send_message('Page.getLayoutMetrics')
-
         content_size = metrics['contentSize']
         width = content_size['width'].ceil
         height = content_size['height'].ceil
@@ -44,11 +54,36 @@ module Chromate
                                height: height,
                                deviceScaleFactor: 1
                              })
+      end
 
-        screenshot(file_path, options)
-
+      # Resets the device metrics override
+      # @return [void]
+      def reset_screen_size!
         @client.send_message('Emulation.clearDeviceMetricsOverride')
-        true
+      end
+
+      # Fetches the current viewport size
+      # @return [Hash] The current viewport dimensions
+      def fetch_viewport_size
+        metrics = @client.send_message('Page.getLayoutMetrics')
+        {
+          width: metrics['layoutViewport']['clientWidth'],
+          height: metrics['layoutViewport']['clientHeight']
+        }
+      end
+
+      # Restores the viewport size to its original dimensions
+      # @param viewport [Hash] The original viewport dimensions
+      # @return [void]
+      def restore_viewport_size(viewport)
+        return unless viewport
+
+        @client.send_message('Emulation.setDeviceMetricsOverride', {
+                               mobile: false,
+                               width: viewport[:width],
+                               height: viewport[:height],
+                               deviceScaleFactor: 1
+                             })
       end
 
       # @param options [Hash] Options for the screenshot
@@ -58,12 +93,15 @@ module Chromate
       def make_screenshot(options = {})
         default_options = {
           format: 'png',
-          fromSurface: true
+          fromSurface: true,
+          captureBeyondViewport: true
         }
 
         params = default_options.merge(options)
 
         @client.send_message('Page.enable')
+        @client.send_message('DOM.enable')
+        @client.send_message('DOM.getDocument', depth: -1, pierce: true)
 
         result = @client.send_message('Page.captureScreenshot', params)
 

data/lib/chromate/actions/stealth.rb

@@ -1,45 +1,60 @@
 # frozen_string_literal: true
 
+require 'user_agent_parser'
+
 module Chromate
   module Actions
     module Stealth
       # @return [void]
-      def patch # rubocop:disable Metrics/MethodLength
+      def patch
         @client.send_message('Network.enable')
+        inject_stealth_script
+
+        # TODO: Improve dynamic user agent overriding
+        # It currently breaks fingerprint validation (pixcelscan.com)
+        # override_user_agent(@user_agent)
+      end
+
+      # @return [void]
+      def inject_stealth_script
+        stealth_script = File.read(File.join(__dir__, '../files/stealth.js'))
+        @client.send_message('Page.addScriptToEvaluateOnNewDocument', { source: stealth_script })
+      end
+
+      # @param user_agent [String]
+      # @return [void]
+      def override_user_agent(user_agent) # rubocop:disable Metrics/MethodLength
+        u_agent     = UserAgentParser.parse(user_agent)
+        platform    = Chromate::UserAgent.os
+        version     = u_agent.version
+        brands      = [
+          { brand: u_agent.family || 'Not_A_Brand', version: version.major },
+          { brand: u_agent.device.brand || 'Not_A_Brand', version: u_agent.os.version.to_s }
+        ]
 
-        # Define custom headers
         custom_headers = {
-          'User-Agent' => UserAgent.call,
-          'Accept-Language' => 'fr-FR,fr;q=0.9,en-US;q=0.8,en;q=0.7,und;q=0.6,es;q=0.5,pt;q=0.4',
-          'Sec-CH-UA' => '"Google Chrome";v="131", "Chromium";v="131", "Not_A Brand";v="24"',
-          'Sec-CH-UA-Platform' => '"' + UserAgent.os + '"', # rubocop:disable Style/StringConcatenation
+          'User-Agent' => user_agent,
+          'Accept-Language' => 'en-US,en;q=0.9',
+          'Sec-CH-UA' => brands.map { |brand| "\"#{brand[:brand]}\";v=\"#{brand[:version]}\"" }.join(', '),
+          'Sec-CH-UA-Platform' => "\"#{u_agent.device.family}\"",
           'Sec-CH-UA-Mobile' => '?0'
         }
-
-        # Apply custom headers
         @client.send_message('Network.setExtraHTTPHeaders', headers: custom_headers)
 
-        # Override User-Agent and high-entropy data to avoid fingerprinting
         user_agent_override = {
-          userAgent: UserAgent.call,
-          platform: UserAgent.os,
-          acceptLanguage: 'fr-FR,fr;q=0.9,en-US;q=0.8',
+          userAgent: user_agent,
+          platform: platform,
+          acceptLanguage: 'en-US,en;q=0.9',
           userAgentMetadata: {
-            brands: [
-              { brand: 'Google Chrome', version: '131' },
-              { brand: 'Chromium', version: '131' },
-              { brand: 'Not_A Brand', version: '24' }
-            ],
-            fullVersion: '131.0.0.0',
-            platform: UserAgent.os,
-            platformVersion: UserAgent.os_version,
-            architecture: 'x86_64',
+            brands: brands,
+            fullVersion: version.to_s,
+            platform: platform,
+            platformVersion: u_agent.os.version.to_s,
+            architecture: Chromate::UserAgent.arch,
             model: '',
             mobile: false
           }
         }
-
-        # Apply User-Agent override and high-entropy data
         @client.send_message('Network.setUserAgentOverride', user_agent_override)
       end
     end

data/lib/chromate/binary.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Chromate
+  class Binary
+    def self.run(path, args, need_success: true)
+      command = [path] + args
+      stdout, stderr, status = Open3.capture3(*command)
+      raise stderr if need_success && !status.success?
+
+      stdout
+    end
+
+    attr_reader :pid
+
+    # @param [String] path
+    # @param [Array<String>] args
+    def initialize(path, args)
+      @path = path
+      @args = args || []
+      @pid  = nil
+    end
+
+    # @return [self]
+    def start
+      command = [@path] + @args
+      _stdin, _stdout, _stderr, wait_thr = Open3.popen3(*command)
+      CLogger.log("Started process with pid #{wait_thr.pid}", level: :debug)
+      Process.detach(wait_thr.pid)
+      CLogger.log("Process detached with pid #{wait_thr.pid}", level: :debug)
+      @pid = wait_thr.pid
+
+      self
+    end
+
+    # @return [Boolean]
+    def started?
+      !@pid.nil?
+    end
+
+    def running?
+      return false unless started?
+
+      Process.getpgid(@pid).is_a?(Integer)
+    rescue Errno::ESRCH
+      false
+    end
+
+    # @return [self]
+    def stop
+      stop_process
+    end
+
+    # @return [Boolean]
+    def stopped?
+      @pid.nil?
+    end
+
+    private
+
+    def stop_process(timeout: 5)
+      return unless pid
+
+      # Send SIGINT to the process to stop it gracefully
+      Process.kill('INT', pid)
+      begin
+        Timeout.timeout(timeout) do
+          Process.wait(pid)
+        end
+      rescue Timeout::Error
+        # If the process does not stop gracefully, send SIGKILL
+        CLogger.log("Process #{pid} did not stop gracefully. Sending SIGKILL...", level: :debug)
+        Process.kill('KILL', pid)
+        Process.wait(pid)
+      end
+    rescue Errno::ESRCH
+      # The process has already stopped
+    ensure
+      @pid = nil
+    end
+  end
+end