chromate-rb 0.0.1.pre → 0.0.2.pre

data/lib/bot_browser/installer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'chromate/helpers'
+require 'chromate/c_logger'
+require 'bot_browser/downloader'
+
+module BotBrowser
+  class Installer
+    class << self
+      include Chromate::Helpers
+
+      def install(version = nil)
+        create_config_dir
+        binary_path, profile_path = Downloader.download(version)
+        bot_browser_path          = install_binary(binary_path)
+        bot_browser_profile_path  = install_profile(profile_path)
+
+        write_config(bot_browser_path, bot_browser_profile_path)
+      end
+
+      def config_dir
+        "#{Dir.home}/.botbrowser"
+      end
+
+      private
+
+      def install_binary(binary_path)
+        Chromate::CLogger.log("Installing binary from #{binary_path}")
+        return install_binary_mac(binary_path) if mac?
+        return install_binary_linux(binary_path) if linux?
+        return install_binary_windows(binary_path) if windows?
+
+        raise 'Unsupported platform'
+      end
+
+      def create_config_dir
+        Chromate::CLogger.log("Creating config directory at #{config_dir}")
+        `mkdir -p #{config_dir}`
+      end
+
+      def install_profile(profile_path)
+        Chromate::CLogger.log("Installing profile from #{profile_path}")
+        `cp #{profile_path} #{config_dir}/`
+
+        "#{config_dir}/#{File.basename(profile_path)}"
+      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`
+
+        '/Applications/Chromium.app/Contents/MacOS/Chromium'
+      end
+
+      def install_binary_linux(binary_path)
+        `sudo dpkg -i #{binary_path}`
+        `sudo apt-get install -f`
+
+        '/usr/bin/chromium'
+      end
+
+      def install_binary_windows(binary_path)
+        `7z x #{binary_path}`
+
+        'chromium.exe'
+      end
+
+      def write_config(bot_browser_path, bot_browser_profile_path)
+        Chromate::CLogger.log("Writing config to #{config_dir}/config.yml")
+        File.write(File.expand_path("#{config_dir}/config.yml"), <<~YAML)
+          ---
+          bot_browser_path: #{bot_browser_path}
+          profile: #{bot_browser_profile_path}
+        YAML
+      end
+    end
+  end
+end

data/lib/bot_browser.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'chromate/c_logger'
+require 'bot_browser/installer'
+
+module BotBrowser
+  class << self
+    def install(version = nil)
+      Installer.install(version)
+    end
+
+    def installed?
+      File.exist?("#{Dir.home}/.botbrowser/config.yml")
+    end
+
+    def load
+      yaml = YAML.load_file("#{Dir.home}/.botbrowser/config.yml")
+
+      Chromate.configure do |config|
+        ENV['CHROME_BIN'] = yaml['bot_browser_path']
+        config.args = [
+          "--bot-profile=#{yaml["profile"]}",
+          '--no-sandbox'
+        ]
+        config.startup_patch = false
+      end
+
+      Chromate::CLogger.log('BotBrowser loaded', level: :debug)
+    end
+  end
+end
+
+# Usage
+# require 'bot_browser'
+
+# BotBrowser.install
+# BotBrowser.load
+# browser = Chromate::Browser.new

data/lib/chromate/actions/dom.rb

@@ -3,36 +3,55 @@
 module Chromate
   module Actions
     module Dom
+      # @return [String]
+      def source
+        evaluate_script('document.documentElement.outerHTML')
+      end
+
+      # @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
 
-      def get_text(selector)
-        find_element(selector).text
-      end
-
-      def get_property(selector, property)
-        find_element(selector).attributes[property]
-      end
-
+      # @param selector [String] CSS selector
+      # @return [String]
       def select_option(selector, option)
         Chromate::Elements::Select.new(selector, @client).select_option(option)
       end
 
+      # @param selector [String] CSS selector
+      # @return [String]
       def evaluate_script(script)
-        @client.send_message('Runtime.evaluate', expression: script)
+        result = @client.send_message('Runtime.evaluate', expression: script)
+
+        case result['result']['type']
+        when 'string', 'number', 'boolean'
+          result['result']['value']
+        when 'object'
+          result['result']['objectId']
+        else
+          result['result']
+        end
       end
     end
   end

data/lib/chromate/actions/navigate.rb

@@ -17,11 +17,11 @@ module Chromate
         dom_content_loaded = false
         frame_stopped_loading = false
 
-        # Utiliser un Mutex pour la synchronisation
+        # Use Mutex for synchronization
         mutex = Mutex.new
         condition = ConditionVariable.new
 
-        # S'abonner aux messages WebSocket
+        # Subscribe to websocket messages
         listener = proc do |message|
           mutex.synchronize do
             case message['method']
@@ -40,15 +40,14 @@ module Chromate
 
         @client.on_message(&listener)
 
-        # Attendre les trois événements (DOMContent, Load et FrameStoppedLoading) avec un timeout
+        # Wait for all three events (DOMContent, Load and FrameStoppedLoading) with a timeout
         Timeout.timeout(15) do
           mutex.synchronize do
             condition.wait(mutex) until dom_content_loaded && page_loaded && frame_stopped_loading
           end
         end
 
-        # Nettoyer l'écouteur WebSocket
-        @client.on_message { |msg| } # Supprime tous les anciens écouteurs en ajoutant un listener vide
+        @client.on_message { |msg| } # Remove listener
 
         self
       end

data/lib/chromate/actions/screenshot.rb

@@ -3,12 +3,34 @@
 module Chromate
   module Actions
     module Screenshot
-      def screenshot_to_file(file_path, options = {})
-        image_data = screenshot(options)
+      # @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 [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
+      def screenshot(file_path = "#{Time.now.to_i}.png", options = {})
+        return xvfb_screenshot(file_path) if @xfvb
+        return screenshot_full_page(file_path, options) if options.delete(:full_page)
+
+        image_data = make_screenshot(options)
         File.binwrite(file_path, image_data)
         true
       end
 
+      private
+
+      # @param file_path [String] The path to save the screenshot to
+      # @return [Boolean] Whether the screenshot was successful
+      def xvfb_screenshot(file_path)
+        display = ENV['DISPLAY'] || ':99'
+        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 = {})
         metrics = @client.send_message('Page.getLayoutMetrics')
 
@@ -23,20 +45,17 @@ module Chromate
                                deviceScaleFactor: 1
                              })
 
-        screenshot_to_file(file_path, options)
+        screenshot(file_path, options)
 
         @client.send_message('Emulation.clearDeviceMetricsOverride')
         true
       end
 
-      def xvfb_screenshot(file_path)
-        display = ENV['DISPLAY'] || ':99'
-        system("xwd -root -display #{display} | convert xwd:- #{file_path}")
-      end
-
-      private
-
-      def screenshot(options = {})
+      # @param options [Hash] Options for the screenshot
+      # @option options [String] :format The format of the screenshot
+      # @option options [Boolean] :fromSurface Whether to take a screenshot from the surface
+      # @return [String] The image data
+      def make_screenshot(options = {})
         default_options = {
           format: 'png',
           fromSurface: true

data/lib/chromate/actions/stealth.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Chromate
+  module Actions
+    module Stealth
+      # @return [void]
+      def patch # rubocop:disable Metrics/MethodLength
+        @client.send_message('Network.enable')
+
+        # 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
+          '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',
+          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',
+            model: '',
+            mobile: false
+          }
+        }
+
+        # Apply User-Agent override and high-entropy data
+        @client.send_message('Network.setUserAgentOverride', user_agent_override)
+      end
+    end
+  end
+end

data/lib/chromate/browser.rb

@@ -14,6 +14,7 @@ require_relative 'user_agent'
 require_relative 'actions/navigate'
 require_relative 'actions/screenshot'
 require_relative 'actions/dom'
+require_relative 'actions/stealth'
 
 module Chromate
   class Browser
@@ -23,7 +24,15 @@ module Chromate
     include Actions::Navigate
     include Actions::Screenshot
     include Actions::Dom
-
+    include Actions::Stealth
+
+    # @param options [Hash] Options for the browser
+    # @option options [String] :chrome_path The path to the Chrome executable
+    # @option options [String] :user_data_dir The path to the user data directory
+    # @option options [Boolean] :headless Whether to run Chrome in headless mode
+    # @option options [Boolean] :xfvb Whether to run Chrome in Xvfb
+    # @option options [Boolean] :native_control Whether to use native controls
+    # @option options [Boolean] :record Whether to record the screen
     def initialize(options = {})
       @options        = config.options.merge(options)
       @chrome_path    = @options.fetch(:chrome_path)
@@ -38,8 +47,7 @@ module Chromate
       @client         = nil
       @args           = [
         @chrome_path,
-        "--user-data-dir=#{@user_data_dir}",
-        "--lang=#{@options[:lang] || "fr-FR"}"
+        "--user-data-dir=#{@user_data_dir}"
       ]
 
       trap('INT') { stop_and_exit }
@@ -48,13 +56,12 @@ module Chromate
       at_exit { stop }
     end
 
+    # @return [self]
     def start
       build_args
       @client = Client.new(self)
       @args << "--remote-debugging-port=#{@client.port}"
 
-      start_video_recording if @record
-
       if @xfvb
         if ENV['DISPLAY'].nil?
           ENV['DISPLAY'] = ':0'   if mac? # XQuartz generally uses :0 on Mac
@@ -63,49 +70,94 @@ module Chromate
         @args << "--display=#{ENV.fetch("DISPLAY", nil)}"
       end
 
+      Hardwares::MouseController.reset_mouse_position
+      Chromate::CLogger.log("Starting browser with args: #{@args}", level: :debug)
       @process = spawn(*@args, err: 'chrome_errors.log', out: 'chrome_output.log')
       sleep 2
 
       @client.start
+
+      start_video_recording if @record
+
+      patch if config.patch?
+
       self
     end
 
+    # @return [self]
     def stop
-      Process.kill('TERM', @process)        if @process
-      Process.kill('TERM', @record_process) if @record_process
-      Process.kill('TERM', @xfvb_process)   if @xfvb_process
+      stop_process(@process)        if @process
+      stop_process(@record_process) if @record_process
+      stop_process(@xfvb_process)   if @xfvb_process
       @client&.stop
+
+      self
     end
 
+    # @return [Boolean]
     def native_control?
       @native_control
     end
 
     private
 
+    # @return [Integer]
     def start_video_recording
-      outfile = File.join(Dir.pwd, "output_video_#{Time.now.to_i}.mp4")
-      @record_process = spawn("ffmpeg -f x11grab -r 25 -s 1920x1080 -i #{ENV.fetch("DISPLAY", ":99")} -pix_fmt yuv420p -y #{outfile}")
+      outname = @record.is_a?(String) ? @record : "output_video_#{Time.now.to_i}.mp4"
+      outfile = File.join(Dir.pwd, outname)
+      # TODO: get screen resolution dynamically
+      @record_process = spawn(
+        "ffmpeg -f x11grab -draw_mouse 1 -r 30 -s 1920x1080 -i #{ENV.fetch("DISPLAY")} -c:v libx264 -preset ultrafast -pix_fmt yuv420p -y #{outfile}"
+      )
     end
 
+    # @return [Array<String>]
     def build_args
       exclude_switches = config.exclude_switches || []
       exclude_switches += @options[:exclude_switches] if @options[:exclude_switches]
 
+      if @options.dig(:options, :args)
+        @args += @options[:options][:args]
+        @args << "--exclude-switches=#{exclude_switches.join(",")}" if exclude_switches.any?
+        return @args
+      end
       @args += config.generate_arguments(**@options)
-      @args += @options[:options][:args] if @options.dig(:options, :args)
       @args << "--user-agent=#{@options[:user_agent] || UserAgent.call}"
       @args << "--exclude-switches=#{exclude_switches.join(",")}" if exclude_switches.any?
 
       @args
     end
 
+    # @param pid [Integer] PID of the process to stop
+    # @param timeout [Integer] Timeout in seconds to wait for the process to stop
+    # @return [void]
+    def stop_process(pid, 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
+    end
+
+    # @return [void]
     def stop_and_exit
-      puts 'Stopping browser...'
+      CLogger.log('Stopping browser...', level: :debug)
       stop
       exit
     end
 
+    # @return [Chromate::Configuration]
     def config
       Chromate.configuration
     end

data/lib/chromate/c_logger.rb

@@ -4,6 +4,9 @@ require 'logger'
 
 module Chromate
   class CLogger < Logger
+    # @param [IO] logdev
+    # @param [Integer] shift_age
+    # @param [Integer] shift_size
     def initialize(logdev, shift_age: 0, shift_size: 1_048_576)
       super(logdev, shift_age, shift_size)
       self.formatter = proc do |severity, datetime, _progname, msg|
@@ -11,10 +14,14 @@ module Chromate
       end
     end
 
+    # @return [Chromate::CLogger]
     def self.logger
       @logger ||= new($stdout)
     end
 
+    # @param [String] message
+    # @param [Symbol] level
+    # @return [void]
     def self.log(message, level: :info)
       logger.send(level, message)
     end

data/lib/chromate/client.rb

@@ -7,18 +7,21 @@ module Chromate
   class Client
     include Helpers
 
+    # @return [Array<Proc>]
     def self.listeners
       @@listeners ||= [] # rubocop:disable Style/ClassVars
     end
 
     attr_reader :port, :ws, :browser
 
+    # @param [Chromate::Browser] browser
     def initialize(browser)
-      @browser = browser
-      options = browser.options
-      @port = options[:port] || find_available_port
+      @browser  = browser
+      options   = browser.options
+      @port     = options[:port] || find_available_port
     end
 
+    # @return [self]
     def start
       @ws_url = fetch_websocket_debug_url
       @ws = WebSocket::Client::Simple.connect(@ws_url)
@@ -29,7 +32,7 @@ module Chromate
 
       @ws.on :message do |msg|
         message = JSON.parse(msg.data)
-        client_self.handle_message(message)
+        client_self.send(:handle_message, message)
 
         Client.listeners.each do |listener|
           listener.call(message)
@@ -37,63 +40,82 @@ module Chromate
       end
 
       @ws.on :open do
-        puts "Connexion WebSocket établie avec #{@ws_url}"
+        Chromate::CLogger.log('Successfully connected to WebSocket', level: :debug)
       end
 
       @ws.on :error do |e|
-        puts "Erreur WebSocket : #{e.message}"
+        Chromate::CLogger.log("WebSocket error: #{e.message}", level: :error)
       end
 
       @ws.on :close do |_e|
-        puts 'Connexion WebSocket fermée'
+        Chromate::CLogger.log('WebSocket connection closed', level: :debug)
       end
 
-      sleep 0.2
+      sleep 0.2 # Wait for the connection to be established
       client_self.send_message('Target.setDiscoverTargets', { discover: true })
+
       client_self
     end
 
+    # @return [self]
     def stop
       @ws&.close
+
+      self
     end
 
+    # @param [String] method
+    # @param [Hash] params
+    # @return [Hash]
     def send_message(method, params = {})
       @id += 1
       message = { id: @id, method: method, params: params }
-      puts "Envoi du message : #{message}"
+      Chromate::CLogger.log("Sending WebSocket message: #{message}", level: :debug)
 
       begin
         @ws.send(message.to_json)
         @callbacks[@id] = Queue.new
         result = @callbacks[@id].pop
-        puts "Réponse reçue pour le message #{message[:id]} : #{result}"
+        Chromate::CLogger.log("Response received for message #{message[:id]}: #{result}", level: :debug)
         result
       rescue StandardError => e
-        puts "Erreur WebSocket lors de l'envoi du message : #{e.message}"
+        Chromate::CLogger.log("Error sending WebSocket message: #{e.message}", level: :error)
         reconnect
         retry
       end
     end
 
+    # @return [self]
     def reconnect
       @ws_url = fetch_websocket_debug_url
       @ws     = WebSocket::Client::Simple.connect(@ws_url)
-      puts 'Reconnexion WebSocket réussie'
+      Chromate::CLogger.log('Successfully reconnected to WebSocket')
+
+      self
     end
 
+    # Allowing different parts to subscribe to WebSocket messages
+    # @yieldparam [Hash] message
+    # @return [void]
+    def on_message(&block)
+      Client.listeners << block
+    end
+
+    private
+
+    # @param [Hash] message
+    # @return [self]
     def handle_message(message)
-      puts "Message reçu : #{message}"
+      Chromate::CLogger.log("Message received: #{message}", level: :debug)
       return unless message['id'] && @callbacks[message['id']]
 
       @callbacks[message['id']].push(message['result'])
       @callbacks.delete(message['id'])
-    end
 
-    # Allowing different parts to subscribe to WebSocket messages
-    def on_message(&block)
-      Client.listeners << block
+      self
     end
 
+    # @return [String]
     def fetch_websocket_debug_url
       uri = URI("http://localhost:#{@port}/json/list")
       response = Net::HTTP.get(uri)
@@ -108,8 +130,8 @@ module Chromate
       end
     end
 
+    # @return [String]
     def create_new_page_target
-      # Créer une nouvelle page
       uri = URI("http://localhost:#{@port}/json/new")
       response = Net::HTTP.get(uri)
       new_target = JSON.parse(response)