bidi2pdf 0.1.3 → 0.1.4

data/lib/bidi2pdf/bidi/commands/set_usercontext_cookie.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    module Commands
+      class SetUsercontextCookie < SetTabCookie
+        include Base
+
+        attr_reader :user_context_id, :source_origin
+
+        def initialize(name:,
+                       value:,
+                       domain:,
+                       user_context_id:,
+                       source_origin:,
+                       path: "/",
+                       secure: true,
+                       http_only: false,
+                       same_site: "strict",
+                       ttl: 30)
+          super(name: name, value: value,
+                domain: domain,
+                path: path,
+                secure: secure,
+                http_only: http_only,
+                same_site: same_site,
+                ttl: ttl,
+                browsing_context_id: nil)
+
+          @user_context_id = user_context_id
+          @source_origin = source_origin
+        end
+
+        def expiry
+          Time.now.to_i + ttl
+        end
+
+        def method_name
+          "storage.setCookie"
+        end
+
+        def params
+          {
+            cookie: {
+              name: name,
+              value: {
+                type: "string",
+                value: value
+              },
+              domain: domain,
+              path: path,
+              secure: secure,
+              httpOnly: http_only,
+              sameSite: same_site,
+              expiry: expiry
+            },
+            partition: {
+              type: "storageKey",
+              userContext: user_context_id,
+              sourceOrigin: source_origin
+            }
+          }.compact
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/commands.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    module Commands
+      require_relative "commands/base"
+      require_relative "commands/create_window"
+      require_relative "commands/create_tab"
+      require_relative "commands/add_intercept"
+      require_relative "commands/set_tab_cookie"
+      require_relative "commands/set_usercontext_cookie"
+      require_relative "commands/session_status"
+      require_relative "commands/get_user_contexts"
+      require_relative "commands/script_evaluate"
+      require_relative "commands/browser_create_user_context"
+      require_relative "commands/browser_close"
+      require_relative "commands/browsing_context_close"
+      require_relative "commands/browsing_context_navigate"
+      require_relative "commands/browsing_context_print"
+      require_relative "commands/session_subscribe"
+      require_relative "commands/session_end"
+      require_relative "commands/cancel_auth"
+      require_relative "commands/network_continue"
+      require_relative "commands/provide_credentials"
+    end
+  end
+end

data/lib/bidi2pdf/bidi/connection_manager.rb

@@ -6,28 +6,31 @@ module Bidi2pdf
       def initialize(logger:)
         @logger = logger
         @connected = false
-        @mutex = Mutex.new
-        @cv = ConditionVariable.new
+        @connection_queue = Thread::Queue.new
       end
 
       def mark_connected
-        @mutex.synchronize do
-          @connected = true
-          @cv.broadcast
-        end
+        return if @connected
+
+        @connected = true
+        @logger.debug "WebSocket connection is open"
+        @connection_queue.push(true)
       end
 
       def wait_until_open(timeout:)
-        @mutex.synchronize do
-          unless @connected
-            @logger.debug "Waiting for WebSocket connection to open"
-            @cv.wait(@mutex, timeout)
+        return true if @connected
+
+        @logger.debug "Waiting for WebSocket connection to open"
+
+        begin
+          Timeout.timeout(timeout) do
+            @connection_queue.pop
           end
+        rescue Timeout::Error
+          raise Bidi2pdf::WebsocketError, "WebSocket connection did not open in time #{timeout} sec."
         end
 
-        raise "WebSocket connection did not open in time" unless @connected
-
-        @logger.debug "WebSocket connection is open"
+        true
       end
     end
   end

data/lib/bidi2pdf/bidi/event_manager.rb

@@ -39,6 +39,8 @@ module Bidi2pdf
         end
       end
 
+      private
+
       def log_msg(prefix, data)
         message = truncate_large_values(data)
         Bidi2pdf.logger.debug "#{prefix}: #{message.inspect}"

data/lib/bidi2pdf/bidi/interceptor.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    module Interceptor
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def phases = raise(NotImplementedError, "Interceptors must implement phases")
+
+        def events = raise(NotImplementedError, "Interceptors must implement events")
+      end
+
+      def url_patterns = raise(NotImplementedError, "Interceptors must implement url_patterns")
+
+      def context = raise(NotImplementedError, "Interceptors must implement context")
+
+      def process_interception(_event_response, _navigation_id, _network_id, _url) = raise(NotImplementedError, "Interceptors must implement process_interception")
+
+      def register_with_client(client:)
+        @client = client
+
+        cmd = Bidi2pdf::Bidi::Commands::AddIntercept.new context: context, phases: self.class.phases, url_patterns: url_patterns
+
+        client.send_cmd_and_wait(cmd) do |response|
+          @interceptor_id = response["result"]["intercept"]
+
+          Bidi2pdf.logger.debug "Interceptor added: #{@interceptor_id}"
+
+          client.on_event(*self.class.events, &method(:handle_event))
+
+          self
+        end
+      end
+
+      # rubocop: disable Metrics/AbcSize
+      def handle_event(response)
+        event_response = response["params"]
+
+        return unless event_response["intercepts"]&.include?(interceptor_id) && event_response["isBlocked"]
+
+        navigation_id = event_response["navigation"]
+        network_id = event_response["request"]["request"]
+        url = event_response["request"]["url"]
+
+        # Log the interception
+        Bidi2pdf.logger.debug "Interceptor #{interceptor_id} handling event: #{navigation_id}/#{network_id}/#{url}"
+
+        process_interception(event_response, navigation_id, network_id, url)
+      rescue StandardError => e
+        Bidi2pdf.logger.error "Error handling event: #{e.message}"
+        Bidi2pdf.logger.error e.backtrace.join("\n")
+        raise e
+      end
+
+      # rubocop: enable Metrics/AbcSize
+
+      def interceptor_id
+        @interceptor_id
+      end
+
+      def client
+        @client
+      end
+
+      def validate_phases!
+        valid_phases = [Phases::BEFORE_REQUEST, Phases::RESPONSE_STARTED, Phases::AUTH_REQUIRED]
+
+        raise ArgumentError, "Unsupported phase(s): #{self.class.phases}" unless self.class.phases.all? { |phase| valid_phases.include?(phase) }
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/network_events.rb

@@ -68,7 +68,6 @@ module Bidi2pdf
           end
 
           if Time.now - start_time > timeout
-            # rubocop:disable Layout/LineLength
             Bidi2pdf.logger.warn "⏰ Timeout while waiting for network events to complete. Still in progress: #{in_progress.map(&:id)}"
             # rubocop:enable Layout/LineLength
             break

data/lib/bidi2pdf/bidi/session.rb

@@ -10,134 +10,208 @@ require_relative "user_context"
 module Bidi2pdf
   module Bidi
     class Session
-      SUBSCRIBE_EVENTS = %w[
-        log
-        script
-      ].freeze
+      SUBSCRIBE_EVENTS = %w[log script].freeze
+      DEFAULT_CHROME_ARGS = %w[--disable-gpu --disable-popup-blocking --disable-hang-monitor].freeze
 
-      attr_reader :session_uri, :started
+      attr_reader :session_uri, :started, :chrome_args
 
-      def initialize(session_url:, headless: true)
+      def initialize(session_url:, headless: true, chrome_args: DEFAULT_CHROME_ARGS)
         @session_uri = URI(session_url)
         @headless = headless
-        @client = nil
-        @browser = nil
-        @websocket_url = nil
         @started = false
+        @chrome_args = chrome_args.dup
       end
 
       def start
+        return if started?
+
         @started = true
         client
+      rescue StandardError => e
+        @started = false
+        raise e
       end
 
       def client
-        @client ||= @started ? create_client : nil
-      end
-
-      def close
-        client&.send_cmd_and_wait("session.end", {}) do |response|
-          Bidi2pdf.logger.debug "Session ended: #{response}"
-          @client&.close
-          @client = nil
-          @websocket_url = nil
-          @browser = nil
-        end
+        @client ||= started? ? create_client : nil
       end
 
       def browser
         @browser ||= create_browser
       end
 
-      def user_contexts
-        client&.send_cmd_and_wait("browser.getUserContexts", {}) do |response|
-          Bidi2pdf.logger.debug "User contexts: #{response}"
+      def close
+        return unless started?
+
+        2.times do |attempt|
+          client&.send_cmd_and_wait(Bidi2pdf::Bidi::Commands::SessionEnd.new, timeout: 1) do |response|
+            Bidi2pdf.logger.info "Session ended: #{response}"
+
+            cleanup
+          end
+          break
+        rescue CmdTimeoutError
+          Bidi2pdf.logger.error "Session end command timed out. Retrying... (#{attempt + 1})"
         end
       end
 
+      def user_contexts
+        send_cmd(Bidi2pdf::Bidi::Commands::GetUserContexts.new) { |resp| Bidi2pdf.logger.debug "User contexts: #{resp}" }
+      end
+
       def status
-        client&.send_cmd_and_wait("session.status", {}) do |response|
-          Bidi2pdf.logger.info "Session status: #{response.inspect}"
-        end
+        send_cmd(Bidi2pdf::Bidi::Commands::SessionStatus.new) { |resp| Bidi2pdf.logger.info "Session status: #{resp.inspect}" }
+      end
+
+      def started?
+        @started
+      end
+
+      def websocket_url
+        return @websocket_url if @websocket_url
+
+        @websocket_url = if %w[ws wss].include?(session_uri.scheme)
+                           session_uri.to_s
+                         else
+                           create_new_session
+                         end
       end
 
       private
 
+      def send_cmd(command, &block)
+        client&.send_cmd_and_wait(command, &block)
+      end
+
+      # rubocop: disable Metrics/AbcSize
       def create_browser
         start
-
-        @client.start
-        @client.wait_until_open
+        client.start
+        client.wait_until_open
 
         Bidi2pdf.logger.info "Subscribing to events"
 
-        event_client = Bidi::Client.new(websocket_url).tap(&:start)
-        event_client.wait_until_open
+        Bidi::Client.new(websocket_url).tap do |event_client|
+          event_client.start
+          event_client.wait_until_open
 
-        event_client.on_event(*SUBSCRIBE_EVENTS) do |data|
-          Bidi2pdf.logger.debug "Received event: #{data["method"]}, params: #{data["params"]}"
+          event_client.on_event(*SUBSCRIBE_EVENTS) do |data|
+            Bidi2pdf.logger.debug "Received event: #{data["method"]}, params: #{data["params"]}"
+          end
         end
 
-        Bidi::Browser.new(@client)
+        Bidi::Browser.new(client)
       end
 
+      # rubocop: enable Metrics/AbcSize
+
       def create_client
         Bidi::Client.new(websocket_url).tap(&:start)
       end
 
-      # rubocop:disable Metrics/AbcSize
-      def websocket_url
-        return @websocket_url if @websocket_url
+      def create_new_session
+        session_data = exec_api_call(session_request)
+        Bidi2pdf.logger.debug "Session data: #{session_data}"
 
-        if %w[ws wss].include?(session_uri.scheme)
-          @websocket_url = session_uri.to_s
-          return @websocket_url
-        end
+        value = session_data["value"]
+        handle_error(value) if value.nil? || value["error"]
 
-        args = %w[
-          --disable-gpu
-          --disable-popup-blocking
-          --disable-hang-monitor
-        ]
+        session_id = value["sessionId"]
+        ws_url = value["capabilities"]["webSocketUrl"]
+
+        Bidi2pdf.logger.info "Created session with ID: #{session_id}"
+        Bidi2pdf.logger.info "WebSocket URL: #{ws_url}"
+        ws_url
+      end
 
-        args << "--headless" if @headless
+      def session_request
+        session_chrome_args = chrome_args.dup
+        session_chrome_args << "--headless" if @headless
 
-        session_request = {
+        {
           "capabilities" => {
             "alwaysMatch" => {
               "browserName" => "chrome",
-              "goog:chromeOptions" => {
-                "args" => args
-              },
+              "goog:chromeOptions" => { "args" => session_chrome_args },
               "goog:prerenderingDisabled" => true,
-              "unhandledPromptBehavior" => {
-                default: "ignore"
-              },
+              "unhandledPromptBehavior" => { default: "ignore" },
               "acceptInsecureCerts" => true,
               "webSocketUrl" => true
             }
           }
         }
+      end
 
-        response = Net::HTTP.post(session_uri, session_request.to_json, "Content-Type" => "application/json")
+      def exec_api_call(payload)
+        response = Net::HTTP.post(session_uri, payload.to_json, "Content-Type" => "application/json")
+        body = response.body
+        code = response.code.to_i
 
-        Bidi2pdf.logger.debug "Response code: #{response.code}"
-        Bidi2pdf.logger.debug "Response body: #{response.body}"
+        if code != 200
+          log_api_error("Failed to create session", code, body)
+          return build_error("Session creation failed", "Response code: #{code}")
+        end
 
-        session_data = JSON.parse(response.body)
+        JSON.parse(body)
+      rescue StandardError => e
+        error_type = error_category(e)
+        build_error(error_type, "#{error_description(error_type)} #{e.message}", e.backtrace)
+      end
 
-        Bidi2pdf.logger.debug "Session data: #{session_data}"
+      def log_api_error(message, code, body)
+        Bidi2pdf.logger.error "#{message}. Response code: #{code}"
+        Bidi2pdf.logger.error "Response body: #{body}"
+      end
 
-        session_id = session_data["value"]["sessionId"]
-        @websocket_url = session_data["value"]["capabilities"]["webSocketUrl"]
+      def error_category(exception)
+        case exception
+        when Errno::ECONNREFUSED then "Connection refused"
+        when JSON::ParserError then "Invalid JSON response"
+        else "Unknown error"
+        end
+      end
 
-        Bidi2pdf.logger.info "Created session with ID: #{session_id}"
-        Bidi2pdf.logger.info "WebSocket URL: #{@websocket_url}"
+      def error_description(type)
+        {
+          "Connection refused" => "Could not connect to the session URL:",
+          "Invalid JSON response" => "Could not parse the response:",
+          "Unknown error" => "An unknown error occurred:"
+        }[type]
+      end
+
+      def build_error(error, message, backtrace = nil)
+        {
+          "value" => {
+            "error" => error,
+            "message" => message,
+            "stacktrace" => backtrace&.join("\n")
+          }.compact
+        }
+      end
 
-        @websocket_url
+      def handle_error(value)
+        error = value["error"]
+        return unless error
+
+        msg = value["message"]
+        trace = value["stacktrace"]
+
+        Bidi2pdf.logger.error "Error: #{error} message: #{msg}"
+        Bidi2pdf.logger.error "Stacktrace: #{trace}" if trace
+
+        if msg =~ /probably user data directory is already in use/
+          Bidi2pdf.logger.info "Container detected with headless-only support, ensure xvfb is started" unless @headless
+          Bidi2pdf.logger.info "Check chromedriver permissions and --user-data-dir"
+        end
+
+        raise SessionNotStartedError,
+              "Session not started. Check logs for more details. Error: #{error} message: #{msg}"
       end
 
-      # rubocop:enable Metrics/AbcSize
+      def cleanup
+        @client&.close
+        @client = @websocket_url = @browser = nil
+      end
     end
   end
 end

data/lib/bidi2pdf/bidi/user_context.rb

@@ -14,14 +14,16 @@ module Bidi2pdf
 
       def context_id
         @context_id ||= begin
-          res = client.send_cmd_and_wait("browser.createUserContext", {}) do |response|
-            response["result"]["userContext"]
-          end
+                          res = client.send_cmd_and_wait(Bidi2pdf::Bidi::Commands::BrowserCreateUserContext.new) do |response|
+                            raise "Error creating user context: #{response.inspect}" if response["error"]
 
-          Bidi2pdf.logger.debug "User context created: #{res.inspect}"
+                            response["result"]["userContext"]
+                          end
 
-          res
-        end
+                          Bidi2pdf.logger.debug "User context created: #{res.inspect}"
+
+                          res
+                        end
       end
 
       def set_cookie(
@@ -35,36 +37,28 @@ module Bidi2pdf
         same_site: "strict",
         ttl: 30
       )
-        expiry = Time.now.to_i + ttl
-        client.send_cmd_and_wait("storage.setCookie", {
-          cookie: {
-            name: name,
-            value: {
-              type: "string",
-              value: value
-            },
-            domain: domain,
-            path: path,
-            secure: secure,
-            httpOnly: http_only,
-            sameSite: same_site,
-            expiry: expiry
-          },
-          partition: {
-            type: "storageKey",
-            userContext: context_id,
-            sourceOrigin: source_origin
-          }
-        }) do |response|
+        cmd = Bidi2pdf::Bidi::Commands::SetUsercontextCookie.new(
+          user_context_id: context_id,
+          source_origin: source_origin,
+          name: name,
+          value: value,
+          domain: domain,
+          path: path,
+          secure: secure,
+          http_only: http_only,
+          same_site: same_site,
+          ttl: ttl
+        )
+
+        client.send_cmd_and_wait(cmd) do |response|
           Bidi2pdf.logger.debug "Cookie set: #{response.inspect}"
         end
       end
 
       def create_browser_window
-        client.send_cmd_and_wait("browsingContext.create", {
-          type: "window",
-          userContext: context_id
-        }) do |response|
+        cmd = Bidi2pdf::Bidi::Commands::CreateWindow.new(user_context_id: context_id)
+
+        client.send_cmd_and_wait(cmd) do |response|
           browsing_context_id = response["result"]["context"]
 
           BrowserTab.new(client, browsing_context_id, context_id)

data/lib/bidi2pdf/bidi/web_socket_dispatcher.rb

@@ -42,6 +42,8 @@ module Bidi2pdf
 
       def remove_error_listener(block) = socket_events.off(:error, block)
 
+      private
+
       def setup_message_handler
         that = self
 

data/lib/bidi2pdf/chromedriver_manager.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "chromedriver/binary"
+require "securerandom"
 
 module Bidi2pdf
   class ChromedriverManager
@@ -140,7 +141,7 @@ module Bidi2pdf
 
     def build_cmd
       bin = Chromedriver::Binary::ChromedriverDownloader.driver_path
-      user_data_dir = File.join(Dir.tmpdir, "bidi2pdf", "user_data")
+      user_data_dir = File.join(Dir.tmpdir, "bidi2pdf", "user_data", SecureRandom.hex(8))
 
       cmd = [bin]
       cmd << "--port=#{@port}" unless @port.zero?

data/lib/bidi2pdf/cli.rb

@@ -122,7 +122,7 @@ module Bidi2pdf
     end
 
     def validate_print_options(opts)
-      Bidi2pdf::Bidi::PrintParametersValidator.validate!(opts)
+      Bidi2pdf::Bidi::Commands::PrintParametersValidator.validate!(opts)
     rescue ArgumentError => e
       raise Thor::Error, "Invalid print option: #{e.message}"
     end
@@ -177,7 +177,6 @@ module Bidi2pdf
     end
 
     def launcher
-      # rubocop:disable Layout/BeginEndAlignment
       @launcher ||= begin
                       username, password = parse_auth(merged_options[:auth]) if merged_options[:auth]
 
@@ -195,7 +194,6 @@ module Bidi2pdf
                         print_options: print_options
                       )
                     end
-      # rubocop:enable Layout/BeginEndAlignment
     end
 
     # rubocop:enable Metrics/AbcSize

data/lib/bidi2pdf/launcher.rb

@@ -21,6 +21,7 @@ module Bidi2pdf
       @wait_network_idle = wait_network_idle
       @print_options = print_options || {}
       @remote_browser_url = remote_browser_url
+      @custom_session = nil
     end
 
     # rubocop:enable Metrics/ParameterLists
@@ -42,13 +43,14 @@ module Bidi2pdf
 
     def stop
       @manager&.stop
+      @custom_session&.close
     end
 
     private
 
     def session
       if @remote_browser_url
-        Bidi::Session.new(session_url: @remote_browser_url, headless: @headless)
+        @custom_session = Bidi::Session.new(session_url: @remote_browser_url, headless: @headless)
       else
         @manager = ChromedriverManager.new(port: @port, headless: @headless)
         @manager.start

data/lib/bidi2pdf/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bidi2pdf
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end