bidi2pdf 0.1.0

data/lib/bidi2pdf/bidi/client.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require "json"
+require "websocket-client-simple"
+
+require_relative "web_socket_dispatcher"
+require_relative "add_headers_interceptor"
+require_relative "auth_interceptor"
+
+module Bidi2pdf
+  module Bidi
+    class Client
+      include Bidi2pdf::Utils
+
+      attr_reader :ws_url
+
+      def initialize(ws_url)
+        @ws_url = ws_url
+        @id = 0
+        @pending_responses = {}
+
+        @connected = false
+        @connection_mutex = Mutex.new
+        @send_cmd_mutex = Mutex.new
+        @connection_cv = ConditionVariable.new
+
+        @started = false
+      end
+
+      def start
+        return @socket if started?
+
+        @socket = WebSocket::Client::Simple.connect(ws_url)
+        @dispatcher = WebSocketDispatcher.new(@socket)
+
+        @dispatcher.on_open { handle_open }
+        @dispatcher.on_message { |data| handle_response_to_cmd(data) }
+
+        @dispatcher.start_listening
+
+        @started = true
+
+        @socket
+      end
+
+      def started?
+        @started
+      end
+
+      def wait_until_open(timeout: Bidi2pdf.default_timeout)
+        @connection_mutex.synchronize do
+          unless @connected
+            Bidi2pdf.logger.debug "Waiting for WebSocket connection to open"
+            @connection_cv.wait(@connection_mutex, timeout)
+          end
+        end
+
+        raise "WebSocket connection did not open in time" unless @connected
+
+        Bidi2pdf.logger.debug "WebSocket connection is open"
+      end
+
+      def send_cmd(method, params = {})
+        next_id.tap do |cmd_id|
+          payload = {
+            id: cmd_id,
+            method: method,
+            params: params
+          }
+
+          Bidi2pdf.logger.debug "Sending command: #{redact_sensitive_fields(payload).inspect}"
+
+          @socket.send(payload.to_json)
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def send_cmd_and_wait(method, params = {}, timeout: Bidi2pdf.default_timeout)
+        timed("Command #{method}") do
+          id = send_cmd(method, params)
+          queue = @pending_responses[id]
+
+          begin
+            response = queue.pop(true)
+          rescue ThreadError
+            response = queue.pop(timeout: timeout)
+          end
+
+          if response.nil?
+            # rubocop:disable Layout/LineLength
+            Bidi2pdf.logger.error "Timeout waiting for response to command #{id}, cmd: #{method}, params: #{redact_sensitive_fields(params).inspect}"
+            # rubocop:enable Layout/LineLength
+
+            raise "Timeout waiting for response to command ID #{id}"
+          end
+
+          raise "Error response: #{response["error"]}" if response["error"]
+
+          result = response
+
+          result = yield response if block_given?
+
+          result
+        ensure
+          @pending_responses.delete(id)
+        end
+      end
+
+      # rubocop:enable Metrics/AbcSize
+
+      # Event API for external consumers
+      def on_message(&block) = @dispatcher.on_message(&block)
+
+      def on_open(&block) = @dispatcher.on_open(&block)
+
+      def on_close(&block) = @dispatcher.on_close(&block)
+
+      def on_error(&block) = @dispatcher.on_error(&block)
+
+      def on_event(*names, &block)
+        names.each do |name|
+          @dispatcher.on_event(name, &block)
+        end
+
+        send_cmd "session.subscribe", { events: names } if names.any?
+      end
+
+      def remove_message_listener(block) = @dispatcher.remove_message_listener(block)
+
+      def remove_event_listener(*names, &block)
+        names.each do |event_name|
+          @dispatcher.remove_event_listener(event_name, block)
+        end
+      end
+
+      def add_headers_interceptor(
+        context:,
+        url_patterns:,
+        headers:
+      )
+        send_cmd_and_wait("network.addIntercept", {
+          context: context,
+          phases: ["beforeRequestSent"],
+          urlPatterns: url_patterns
+        }) do |response|
+          id = response["result"]["intercept"]
+          Bidi2pdf.logger.debug "Interceptor added: #{id}"
+
+          AddHeadersInterceptor.new(id, headers, self).tap do |interceptor|
+            on_event "network.beforeRequestSent", &interceptor.method(:handle_event)
+          end
+        end
+      end
+
+      def add_auth_interceptor(
+        context:,
+        url_patterns:,
+        username:,
+        password:
+      )
+        send_cmd_and_wait("network.addIntercept", {
+          context: context,
+          phases: ["authRequired"],
+          urlPatterns: url_patterns
+        }) do |response|
+          id = response["result"]["intercept"]
+          Bidi2pdf.logger.debug "Interceptor added: #{id}"
+
+          AuthInterceptor.new(id, username, password, self).tap do |interceptor|
+            on_event "network.authRequired", &interceptor.method(:handle_event)
+          end
+        end
+      end
+
+      private
+
+      def next_id
+        cmd_id = nil
+
+        @send_cmd_mutex.synchronize do
+          @id += 1
+          cmd_id = @id
+          @pending_responses[cmd_id] = Queue.new
+        end
+
+        cmd_id
+      end
+
+      def handle_open
+        @connection_mutex.synchronize do
+          @connected = true
+          @connection_cv.broadcast
+        end
+      end
+
+      def handle_response_to_cmd(data)
+        if (id = data["id"]) && @pending_responses.key?(id)
+          @pending_responses[id]&.push(data)
+        elsif (data = data["error"])
+          Bidi2pdf.logger.error "Error response: #{data.inspect}"
+        else
+          Bidi2pdf.logger.warn "Unknown response: #{data.inspect}"
+        end
+      end
+
+      def redact_sensitive_fields(obj, sensitive_keys = %w[value token password authorization username])
+        case obj
+        when Hash
+          obj.each_with_object({}) do |(k, v), result|
+            result[k] = if sensitive_keys.include?(k.to_s.downcase)
+                          "[REDACTED]"
+                        else
+                          redact_sensitive_fields(v, sensitive_keys)
+                        end
+          end
+        when Array
+          obj.map { |item| redact_sensitive_fields(item, sensitive_keys) }
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/event_manager.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    class EventManager
+      attr_reader :type
+
+      def initialize(type)
+        @listeners = Hash.new { |h, k| h[k] = [] }
+        @type = type
+      end
+
+      def on(*event_names, &block)
+        event_names.each { |event_name| @listeners[event_name.to_sym] << block }
+
+        block
+      end
+
+      def off(event_name, block) = @listeners[event_name.to_sym].delete(block)
+
+      def dispatch(event_name, *args)
+        listeners = @listeners[event_name.to_sym] || []
+
+        if event_name.to_s.include?(".")
+          toplevel_event_name = event_name.to_s.split(".").first
+          listeners += @listeners[toplevel_event_name.to_sym]
+        end
+
+        log_msg("Dispatching #{type} '#{event_name}' to #{listeners.size} listeners", args)
+
+        listeners.each { |listener| listener.call(*args) }
+      end
+
+      def clear(event_name = nil)
+        if event_name
+          @listeners[event_name].clear
+        else
+          @listeners.clear
+        end
+      end
+
+      def log_msg(prefix, data)
+        message = truncate_large_values(data)
+        Bidi2pdf.logger.debug "#{prefix}: #{message.inspect}"
+      end
+
+      # rubocop: disable all
+      def truncate_large_values(org, max_length = 50, max_depth = 5, current_depth = 0)
+        return "...(too deep)..." if current_depth >= max_depth
+
+        obj = org.dup
+
+        case obj
+        when Hash
+          obj.each_with_object({}) do |(k, v), result|
+            result[k] = if %w[username password].include?(k.to_s.downcase)
+                          "[REDACTED]"
+                        else
+                          truncate_large_values(v, max_length, max_depth, current_depth + 1)
+                        end
+          end
+        when Array
+          if obj.size > 10
+            obj.take(10).map do |v|
+              truncate_large_values(v, max_length, max_depth, current_depth + 1)
+            end + ["...(#{obj.size - 10} more items)"]
+          else
+            obj.map { |v| truncate_large_values(v, max_length, max_depth, current_depth + 1) }
+          end
+        when String
+          if obj.length > max_length
+            "#{obj[0...max_length]}... (truncated, total length: #{obj.length})"
+          else
+            obj
+          end
+        else
+          obj
+        end
+      end
+
+      # rubocop: enable all
+    end
+  end
+end

data/lib/bidi2pdf/bidi/network_event.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    class NetworkEvent
+      attr_reader :id, :url, :state, :start_timestamp, :end_timestamp, :timing
+
+      STATE_MAP = {
+        "network.responseStarted" => "started",
+        "network.responseCompleted" => "completed",
+        "network.fetchError" => "error"
+      }.freeze
+
+      def initialize(id:, url:, timestamp:, timing:, state:)
+        @id = id
+        @url = url
+        @start_timestamp = timestamp
+        @timing = timing
+        @state = map_state(state)
+      end
+
+      def update_state(new_state, timestamp: nil, timing: nil)
+        @state = map_state(new_state)
+        @end_timestamp = timestamp if timestamp
+        @timing = timing if timing
+      end
+
+      def map_state(state)
+        STATE_MAP.fetch(state, state)
+      end
+
+      def format_timestamp(timestamp)
+        return "N/A" unless timestamp
+
+        Time.at(timestamp / 1000.0).utc.strftime("%Y-%m-%d %H:%M:%S.%L UTC")
+      end
+
+      def duration_seconds
+        return nil unless @start_timestamp && @end_timestamp
+
+        ((@end_timestamp - @start_timestamp) / 1000.0).round(3)
+      end
+
+      def in_progress? = state == "started"
+
+      def to_s
+        took_str = duration_seconds ? "took #{duration_seconds} sec" : "in progress"
+        "#<NetworkEvent id=#{@id} url=#{@url} state=#{@state} " \
+          "start=#{format_timestamp(@start_timestamp)} " \
+          "end=#{format_timestamp(@end_timestamp)} #{took_str}>"
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/network_events.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "network_event"
+
+module Bidi2pdf
+  module Bidi
+    class NetworkEvents
+      attr_reader :context_id, :events
+
+      def initialize(context_id)
+        @context_id = context_id
+        @events = {}
+      end
+
+      def handle_event(data)
+        event = data["params"]
+        method = data["method"]
+
+        if event["context"] == context_id
+          handle_response(method, event)
+        else
+          Bidi2pdf.logger.debug "Ignoring Network event: #{method}, #{context_id}, params: #{event}"
+        end
+      rescue StandardError => e
+        Bidi2pdf.logger.error "Error handling network event: #{e.message}"
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def handle_response(method, event)
+        return unless event && event["request"]
+
+        request = event["request"]
+
+        id = request["request"]
+        url = request["url"]
+        timing = request["timings"]
+
+        timestamp = event["timestamp"]
+
+        if method == "network.responseStarted"
+          events[id] ||= NetworkEvent.new(
+            id: id,
+            url: url,
+            timestamp: timestamp,
+            timing: timing,
+            state: method
+          )
+        elsif events.key?(id)
+          events[id].update_state(method, timestamp: timestamp, timing: timing)
+        else
+          Bidi2pdf.logger.warn "Received response for unknown request ID: #{id}, URL: #{url}"
+        end
+      end
+
+      # rubocop:enable Metrics/AbcSize
+
+      def all_events
+        events.values.sort_by(&:start_timestamp)
+      end
+
+      def wait_until_all_finished(timeout: 10, poll_interval: 0.1)
+        start_time = Time.now
+
+        loop do
+          unless events.values.any?(&:in_progress?)
+            Bidi2pdf.logger.debug "✅ All network events completed."
+            break
+          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
+          end
+
+          sleep(poll_interval)
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/print_parameters_validator.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    # Validates parameters for the BiDi method `browsingContext.print`.
+    #
+    # Allowed structure of the params hash:
+    #
+    # {
+    #   background: Boolean (optional, default: false) – print background graphics,
+    #   margin: {
+    #     top: Float >= 0.0 (optional, default: 1.0),
+    #     bottom: Float >= 0.0 (optional, default: 1.0),
+    #     left: Float >= 0.0 (optional, default: 1.0),
+    #     right: Float >= 0.0 (optional, default: 1.0)
+    #   },
+    #   orientation: "portrait" or "landscape" (optional, default: "portrait"),
+    #   page: {
+    #     width: Float >= 0.0352 (optional, default: 21.59),
+    #     height: Float >= 0.0352 (optional, default: 27.94)
+    #   },
+    #   pageRanges: Array of Integers or Strings (optional),
+    #   scale: Float between 0.1 and 2.0 (optional, default: 1.0),
+    #   shrinkToFit: Boolean (optional, default: true)
+    # }
+    #
+    # This validator checks presence, types, allowed ranges, and values,
+    # and raises ArgumentError with a descriptive message if validation fails.
+    class PrintParametersValidator
+      def self.validate!(params)
+        new(params).validate!
+      end
+
+      def initialize(params)
+        @params = params
+      end
+
+      def validate!
+        raise ArgumentError, "params must be a Hash" unless @params.is_a?(Hash)
+
+        validate_boolean(:background)
+        validate_boolean(:shrinkToFit)
+        validate_orientation
+        validate_scale
+        validate_page_ranges
+        validate_margin
+        validate_page_size
+
+        true
+      end
+
+      private
+
+      def validate_boolean(key)
+        return unless @params.key?(key)
+        return if [true, false].include?(@params[key])
+
+        raise ArgumentError, ":#{key} must be a boolean"
+      end
+
+      def validate_orientation
+        return unless @params.key?(:orientation)
+        return if %w[portrait landscape].include?(@params[:orientation])
+
+        raise ArgumentError, ":orientation must be 'portrait' or 'landscape'"
+      end
+
+      def validate_scale
+        return unless @params.key?(:scale)
+
+        scale = @params[:scale]
+        return if scale.is_a?(Numeric) && scale >= 0.1 && scale <= 2.0
+
+        raise ArgumentError, ":scale must be a number between 0.1 and 2.0"
+      end
+
+      def validate_page_ranges
+        return unless @params.key?(:pageRanges)
+        unless @params[:pageRanges].is_a?(Array) &&
+               @params[:pageRanges].all? { |v| v.is_a?(Integer) || v.is_a?(String) }
+          raise ArgumentError, ":pageRanges must be an array of integers or strings"
+        end
+      end
+
+      def validate_margin
+        return unless @params.key?(:margin)
+
+        margin = @params[:margin]
+        raise ArgumentError, ":margin must be a Hash" unless margin.is_a?(Hash)
+
+        %i[top bottom left right].each do |side|
+          next unless margin.key?(side)
+
+          val = margin[side]
+          raise ArgumentError, "margin[:#{side}] must be a float >= 0.0" unless val.is_a?(Numeric) && val >= 0.0
+        end
+      end
+
+      def validate_page_size
+        return unless @params.key?(:page)
+
+        page = @params[:page]
+        raise ArgumentError, ":page must be a Hash" unless page.is_a?(Hash)
+
+        %i[width height].each do |dim|
+          next unless page.key?(dim)
+
+          val = page[dim]
+          raise ArgumentError, "page[:#{dim}] must be a float >= 0.0352" unless val.is_a?(Numeric) && val >= 0.0352
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/session.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require_relative "client"
+require_relative "browser"
+require_relative "user_context"
+
+module Bidi2pdf
+  module Bidi
+    class Session
+      SUBSCRIBE_EVENTS = [
+        "browsingContext",
+        "network",
+        "log",
+        "script",
+        "goog:cdp.Debugger.scriptParsed",
+        "goog:cdp.CSS.styleSheetAdded",
+        "goog:cdp.Runtime.executionContextsCleared",
+        # Tracing
+        "goog:cdp.Tracing.tracingComplete",
+        "goog:cdp.Network.requestWillBeSent",
+        "goog:cdp.Debugger.scriptParsed",
+        "goog:cdp.Page.screencastFrame"
+      ].freeze
+
+      attr_reader :port, :websocket_url
+
+      def initialize(port, headless: true)
+        @port = port
+        @headless = headless
+        @client = nil
+        @browser = nil
+        @websocket_url = nil
+      end
+
+      def start
+        client
+      end
+
+      def client
+        @client ||= create_client
+      end
+
+      def close
+        client&.send_cmd_and_wait("session.end", {}) do |response|
+          Bidi2pdf.logger.debug "Session ended: #{response}"
+          @client = nil
+          @websocket_url = nil
+          @browser = nil
+        end
+      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}"
+        end
+      end
+
+      def status
+        client&.send_cmd_and_wait("session.status", {}) do |response|
+          Bidi2pdf.logger.info "Session status: #{response.inspect}"
+        end
+      end
+
+      private
+
+      def create_browser
+        start
+
+        @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
+
+        event_client.on_event(*SUBSCRIBE_EVENTS) do |data|
+          Bidi2pdf.logger.debug "Received event: #{data["method"]}, params: #{data["params"]}"
+        end
+
+        Bidi::Browser.new(@client)
+      end
+
+      # rubocop: disable Metrics/AbcSize
+      def create_client
+        uri = URI("http://localhost:#{port}/session")
+        args = %w[
+          --disable-gpu
+          --disable-popup-blocking
+          --disable-hang-monitor
+        ]
+
+        args << "--headless" if @headless
+
+        session_request = {
+          "capabilities" => {
+            "alwaysMatch" => {
+              "browserName" => "chrome",
+              "goog:chromeOptions" => {
+                "args" => args
+              },
+              "goog:prerenderingDisabled" => true,
+              "unhandledPromptBehavior" => {
+                default: "ignore"
+              },
+              "acceptInsecureCerts" => true,
+              "webSocketUrl" => true
+            }
+          }
+        }
+        response = Net::HTTP.post(uri, session_request.to_json, "Content-Type" => "application/json")
+        session_data = JSON.parse(response.body)
+
+        Bidi2pdf.logger.debug "Session data: #{session_data}"
+
+        session_id = session_data["value"]["sessionId"]
+        @websocket_url = session_data["value"]["capabilities"]["webSocketUrl"]
+
+        Bidi2pdf.logger.info "Created session with ID: #{session_id}"
+        Bidi2pdf.logger.info "WebSocket URL: #{@websocket_url}"
+
+        Bidi::Client.new(@websocket_url).tap(&:start)
+      end
+
+      # rubocop: enable Metrics/AbcSize
+    end
+  end
+end