bidi2pdf 0.1.1 → 0.1.3

data/lib/bidi2pdf/bidi/command_manager.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    class CommandManager
+      def initialize(socket, logger:)
+        @socket = socket
+        @logger = logger
+
+        @id = 0
+        @next_id_mutex = Mutex.new
+        @pending_responses = {}
+      end
+
+      def send_cmd(method, params = {})
+        id = next_id
+        payload = { id: id, method: method, params: params }
+
+        @logger.debug "Sending command: #{redact_sensitive_fields(payload).inspect}"
+        @socket.send(payload.to_json)
+
+        id
+      end
+
+      def send_cmd_and_wait(method, params = {}, timeout: Bidi2pdf.default_timeout)
+        id = send_cmd(method, params)
+        queue = @pending_responses[id]
+
+        response = queue.pop(timeout: timeout)
+        raise_timeout_error(id, method, params) if response.nil?
+        raise "Error response: #{response["error"]}" if response["error"]
+
+        block_given? ? yield(response) : response
+      ensure
+        @pending_responses.delete(id)
+      end
+
+      def queue_for(id)
+        @pending_responses[id]
+      end
+
+      def handle_response(data)
+        if (id = data["id"]) && @pending_responses.key?(id)
+          @pending_responses[id]&.push(data)
+        else
+          false
+        end
+      end
+
+      private
+
+      def next_id
+        @next_id_mutex.synchronize do
+          @id += 1
+          @pending_responses[@id] = Thread::Queue.new
+          @id
+        end
+      end
+
+      def redact_sensitive_fields(obj, sensitive_keys = %w[value token password authorization username])
+        case obj
+        when Hash
+          obj.transform_values.with_index do |v, idx|
+            k = obj.keys[idx]
+            sensitive_keys.include?(k.to_s.downcase) ? "[REDACTED]" : redact_sensitive_fields(v, sensitive_keys)
+          end
+        when Array
+          obj.map { |item| redact_sensitive_fields(item, sensitive_keys) }
+        else
+          obj
+        end
+      end
+
+      def raise_timeout_error(id, method, params)
+        # rubocop:disable Layout/LineLength
+        @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
+    end
+  end
+end

data/lib/bidi2pdf/bidi/connection_manager.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Bidi
+    class ConnectionManager
+      def initialize(logger:)
+        @logger = logger
+        @connected = false
+        @mutex = Mutex.new
+        @cv = ConditionVariable.new
+      end
+
+      def mark_connected
+        @mutex.synchronize do
+          @connected = true
+          @cv.broadcast
+        end
+      end
+
+      def wait_until_open(timeout:)
+        @mutex.synchronize do
+          unless @connected
+            @logger.debug "Waiting for WebSocket connection to open"
+            @cv.wait(@mutex, timeout)
+          end
+        end
+
+        raise "WebSocket connection did not open in time" unless @connected
+
+        @logger.debug "WebSocket connection is open"
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/session.rb

@@ -10,42 +10,35 @@ 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"
+      SUBSCRIBE_EVENTS = %w[
+        log
+        script
       ].freeze
 
-      attr_reader :port, :websocket_url
+      attr_reader :session_uri, :started
 
-      def initialize(port, headless: true)
-        @port = port
+      def initialize(session_url:, headless: true)
+        @session_uri = URI(session_url)
         @headless = headless
         @client = nil
         @browser = nil
         @websocket_url = nil
+        @started = false
       end
 
       def start
+        @started = true
         client
       end
 
       def client
-        @client ||= create_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
@@ -88,9 +81,19 @@ module Bidi2pdf
         Bidi::Browser.new(@client)
       end
 
-      # rubocop: disable Metrics/AbcSize
       def create_client
-        uri = URI("http://localhost:#{port}/session")
+        Bidi::Client.new(websocket_url).tap(&:start)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def websocket_url
+        return @websocket_url if @websocket_url
+
+        if %w[ws wss].include?(session_uri.scheme)
+          @websocket_url = session_uri.to_s
+          return @websocket_url
+        end
+
         args = %w[
           --disable-gpu
           --disable-popup-blocking
@@ -115,7 +118,12 @@ module Bidi2pdf
             }
           }
         }
-        response = Net::HTTP.post(uri, session_request.to_json, "Content-Type" => "application/json")
+
+        response = Net::HTTP.post(session_uri, session_request.to_json, "Content-Type" => "application/json")
+
+        Bidi2pdf.logger.debug "Response code: #{response.code}"
+        Bidi2pdf.logger.debug "Response body: #{response.body}"
+
         session_data = JSON.parse(response.body)
 
         Bidi2pdf.logger.debug "Session data: #{session_data}"
@@ -126,10 +134,10 @@ module Bidi2pdf
         Bidi2pdf.logger.info "Created session with ID: #{session_id}"
         Bidi2pdf.logger.info "WebSocket URL: #{@websocket_url}"
 
-        Bidi::Client.new(@websocket_url).tap(&:start)
+        @websocket_url
       end
 
-      # rubocop: enable Metrics/AbcSize
+      # rubocop:enable Metrics/AbcSize
     end
   end
 end

data/lib/bidi2pdf/chromedriver_manager.rb

@@ -4,17 +4,20 @@ require "chromedriver/binary"
 
 module Bidi2pdf
   class ChromedriverManager
-    attr_reader :port, :pid, :session
+    attr_reader :port, :pid, :started
 
     def initialize(port: 0, headless: true)
       @port = port
       @headless = headless
       @session = nil
+      @started = false
     end
 
     def start
       return @pid if @pid
 
+      @started = true
+
       update_chromedriver
       cmd = build_cmd
       Bidi2pdf.logger.info "Starting Chromedriver with command: #{cmd}"
@@ -30,19 +33,33 @@ module Bidi2pdf
 
       at_exit { stop }
 
-      @session = Bidi::Session.new(@port, headless: @headless)
-
       @pid
     end
 
+    def session
+      return unless @started
+
+      @session ||= Bidi::Session.new(session_url: session_url, headless: @headless)
+    end
+
+    def session_url
+      return unless @started
+
+      "http://localhost:#{@port}/session"
+    end
+
     def stop(timeout: 5)
       return unless @pid
 
+      @started = false
+
       close_session
 
-      term_chromedriver
+      debug_show_all_children
+
+      old_childprocesses = term_chromedriver
 
-      detect_zombie_processes
+      detect_zombie_processes old_childprocesses
 
       return unless process_alive?
 
@@ -53,14 +70,10 @@ module Bidi2pdf
 
     private
 
-    # rubocop:disable Metrics/AbcSize
-    def detect_zombie_processes
-      debug_show_all_children
+    def detect_zombie_processes(old_childprocesses)
+      Bidi2pdf.logger.debug "Old child processes for #{@pid}: #{old_childprocesses.map(&:pid).join(", ")}"
 
-      child_processes = Bidi2pdf::ProcessTree.new(@pid).children(@pid)
-      Bidi2pdf.logger.debug "Found child processes: #{child_processes.map(&:pid).join(", ")}"
-
-      zombie_processes = child_processes.select { |child| process_alive? child.pid }
+      zombie_processes = old_childprocesses.select { |child| process_alive? child.pid }
 
       return if zombie_processes.empty?
 
@@ -68,9 +81,18 @@ module Bidi2pdf
       printable_zombie_processes_str = printable_zombie_processes.join(", ")
 
       Bidi2pdf.logger.error "Zombie Processes detected #{printable_zombie_processes_str}"
+
+      term_zombie_processes zombie_processes
     end
 
-    # rubocop:enable Metrics/AbcSize
+    def term_zombie_processes(zombie_processes)
+      Bidi2pdf.logger.info "Terminating zombie processes: #{zombie_processes.map(&:pid).join(", ")}"
+
+      zombie_processes.each do |child|
+        Bidi2pdf.logger.debug "Terminating PID #{child.pid} (#{child.name})"
+        Process.kill("TERM", child.pid)
+      end
+    end
 
     def debug_show_all_children
       Bidi2pdf::ProcessTree.new(@pid).traverse do |process, level|
@@ -83,14 +105,16 @@ module Bidi2pdf
     def close_session
       Bidi2pdf.logger.info "Closing session"
 
-      @session.close
+      @session&.close
       @session = nil
     end
 
     def term_chromedriver
-      Bidi2pdf.logger.info "Stopping Chromedriver (PID #{@pid})"
+      Bidi2pdf::ProcessTree.new(@pid).children(@pid).tap do |_child_processes|
+        Bidi2pdf.logger.info "Stopping Chromedriver (PID #{@pid})"
 
-      Process.kill("TERM", @pid)
+        Process.kill("TERM", @pid)
+      end
     rescue Errno::ESRCH
       Bidi2pdf.logger.debug "Process already gone"
       @pid = nil

data/lib/bidi2pdf/cli.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
 require "thor"
+require "yaml"
 
 module Bidi2pdf
+  # rubocop:disable Metrics/AbcSize
   class CLI < Thor
+    class_option :config, type: :string, desc: "Load configuration from YAML file"
+
     desc "render", "Render a URL to PDF using Chrome BiDi"
     long_desc <<~USAGE, wrap: false
       Example:
@@ -26,11 +30,11 @@ module Bidi2pdf
       Set --port to 0 for a random ChromeDriver port.
     USAGE
 
-    option :url, required: true, desc: "The URL to render"
-    option :output, default: "output.pdf", desc: "Filename for the output PDF"
-    option :cookie, type: :array, default: [], banner: "name=value", desc: "One or more cookies"
-    option :header, type: :array, default: [], banner: "name=value", desc: "One or more custom headers"
-    option :auth, type: :string, banner: "user:pass", desc: "Basic auth credentials"
+    option :url, desc: "The URL to render"
+    option :output, default: "output.pdf", desc: "Filename for the output PDF", aliases: "-o"
+    option :cookie, type: :array, default: [], banner: "name=value", desc: "One or more cookies", aliases: "-C"
+    option :header, type: :array, default: [], banner: "name=value", desc: "One or more custom headers", aliases: "-H"
+    option :auth, type: :string, banner: "user:pass", desc: "Basic auth credentials", aliases: "-a"
     option :headless, type: :boolean, default: true, desc: "Run Chrome in headless mode"
     option :port, type: :numeric, default: 0, desc: "Port to run ChromeDriver on (0 = auto)"
     option :wait_window_loaded,
@@ -39,36 +43,156 @@ module Bidi2pdf
            desc: "Wait for the window to be fully loaded (windoow.loaded set by your script)"
     option :wait_network_idle, type: :boolean, default: false, desc: "Wait for network to be idle"
     option :default_timeout, type: :numeric, default: 60, desc: "Default timeout for commands"
+    option :remote_browser_url, type: :string, desc: "Remote browser URL for ChromeDriver"
     option :log_level,
            type: :string,
            default: "info", enum: %w[debug info warn error fatal unknown], desc: "Set log level"
 
+    option :background, type: :boolean, default: true, desc: "Print background graphics"
+    option :margin_top, type: :numeric, default: 1.0, desc: "Top margin in inches"
+    option :margin_bottom, type: :numeric, default: 1.0, desc: "Bottom margin in inches"
+    option :margin_left, type: :numeric, default: 1.0, desc: "Left margin in inches"
+    option :margin_right, type: :numeric, default: 1.0, desc: "Right margin in inches"
+    option :orientation, type: :string, default: "portrait", enum: %w[portrait landscape], desc: "Page orientation"
+    option :page_width, type: :numeric, default: 21.59, desc: "Page width in cm (min 0.0352)"
+    option :page_height, type: :numeric, default: 27.94, desc: "Page height in cm (min 0.0352)"
+    option :page_ranges, type: :array, desc: "Page ranges to print (e.g., 1-2 4 6)"
+    option :scale, type: :numeric, default: 1.0, desc: "Scale between 0.1 and 2.0"
+    option :shrink_to_fit, type: :boolean, default: true, desc: "Shrink content to fit page"
+
     def render
+      load_config
+
+      validate_required_options! :url
+
       configure
 
-      Bidi2pdf.logger.info "Rendering: #{options[:url]} -> #{options[:output]}"
+      Bidi2pdf.logger.info "Rendering: #{merged_options[:url]} -> #{merged_options[:output]}"
+      Bidi2pdf.logger.info "Print options: #{print_options.inspect}" if print_options
+
+      validate_print_options(print_options) if print_options
 
       launcher.launch
+    ensure
+      launcher.stop if defined?(@launcher) && @launcher
+    end
+
+    desc "version", "Show bidi2pdf version"
+
+    def version
+      puts "bidi2pdf #{Bidi2pdf::VERSION}"
+    end
+
+    desc "template", "Generate a config file template"
+    option :output, default: "bidi2pdf.yml", desc: "Output configuration filename"
+
+    def template
+      config = {
+        "url" => "https://example.com",
+        "output" => "output.pdf",
+        "headless" => true,
+        "print_options" => {
+          "background" => true,
+          "orientation" => "portrait",
+          "margin" => {
+            "top" => 1.0,
+            "bottom" => 1.0,
+            "left" => 1.0,
+            "right" => 1.0
+          }
+        }
+      }
+
+      File.write(merged_options[:output], config.to_yaml)
+      puts "Config template written to #{merged_options[:output]}"
     end
 
     private
 
-    # rubocop:disable  Metrics/AbcSize
+    def load_config
+      return unless options[:config] && File.exist?(options[:config])
+
+      YAML.load_file(options[:config]).transform_keys(&:to_sym)
+    end
+
+    def validate_required_options!(*keys)
+      keys.each do |key|
+        raise Thor::Error, "Missing required option: --#{key.to_s.tr("_", "-")}" unless merged_options[key]
+      end
+    end
+
+    def validate_print_options(opts)
+      Bidi2pdf::Bidi::PrintParametersValidator.validate!(opts)
+    rescue ArgumentError => e
+      raise Thor::Error, "Invalid print option: #{e.message}"
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def print_options
+      opts = {}
+
+      assign_if_provided(opts, :background)
+      assign_if_provided(opts, :orientation)
+      opts[:pageRanges] = merged_options[:page_ranges] if merged_options[:page_ranges]
+
+      if option_provided?(:scale)
+        scale = merged_options[:scale]
+        raise ArgumentError, "Scale must be between 0.1 and 2.0" unless (0.1..2.0).include?(scale)
+
+        opts[:scale] = scale
+      end
+
+      assign_if_provided(opts, :shrinkToFit, :shrink_to_fit)
+
+      # Margins
+      margin_keys = {
+        top: :margin_top,
+        bottom: :margin_bottom,
+        left: :margin_left,
+        right: :margin_right
+      }
+      margins = {}
+      margin_keys.each do |short, full|
+        assign_if_provided(margins, short, full)
+      end
+      opts[:margin] = margins unless margins.empty?
+
+      # Page size
+      page = {}
+      assign_if_provided(page, :width, :page_width)
+      assign_if_provided(page, :height, :page_height)
+      opts[:page] = page unless page.empty?
+
+      opts.empty? ? nil : opts
+    end
+
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    def option_provided?(key)
+      ARGV.include?("--#{key.to_s.tr("_", "-")}") || ARGV.include?("--#{key}")
+    end
+
+    def assign_if_provided(hash, key, option_key = key)
+      hash[key] = merged_options[option_key] if option_provided?(option_key)
+    end
+
     def launcher
       # rubocop:disable Layout/BeginEndAlignment
       @launcher ||= begin
-                      username, password = parse_auth(options[:auth]) if options[:auth]
+                      username, password = parse_auth(merged_options[:auth]) if merged_options[:auth]
 
                       Bidi2pdf::Launcher.new(
-                        url: options[:url],
-                        output: options[:output],
-                        cookies: parse_key_values(options[:cookie]),
-                        headers: parse_key_values(options[:header]),
+                        url: merged_options[:url],
+                        output: merged_options[:output],
+                        cookies: parse_key_values(merged_options[:cookie]),
+                        headers: parse_key_values(merged_options[:header]),
                         auth: { username: username, password: password },
-                        port: options[:port],
-                        headless: options[:headless],
-                        wait_window_loaded: options[:wait_window_loaded],
-                        wait_network_idle: options[:wait_network_idle]
+                        port: merged_options[:port],
+                        remote_browser_url: merged_options[:remote_browser_url],
+                        headless: merged_options[:headless],
+                        wait_window_loaded: merged_options[:wait_window_loaded],
+                        wait_network_idle: merged_options[:wait_network_idle],
+                        print_options: print_options
                       )
                     end
       # rubocop:enable Layout/BeginEndAlignment
@@ -79,7 +203,7 @@ module Bidi2pdf
     def configure
       Bidi2pdf.configure do |config|
         config.logger.level = log_level
-        config.default_timeout = options[:default_timeout]
+        config.default_timeout = merged_options[:default_timeout]
 
         Chromedriver::Binary.configure do |c|
           c.logger.level = log_level
@@ -88,7 +212,7 @@ module Bidi2pdf
     end
 
     def log_level
-      case options[:log_level]
+      case merged_options[:log_level]
       when "debug" then Logger::DEBUG
       when "warn" then Logger::WARN
       when "error" then Logger::ERROR
@@ -114,5 +238,10 @@ module Bidi2pdf
 
       [user, pass]
     end
+
+    def merged_options
+      defaults = load_config || {}
+      Thor::CoreExt::HashWithIndifferentAccess.new(defaults.merge(options))
+    end
   end
 end

data/lib/bidi2pdf/launcher.rb

@@ -6,8 +6,9 @@ require_relative "bidi/session"
 
 module Bidi2pdf
   class Launcher
+    # rubocop:disable Metrics/ParameterLists
     def initialize(url:, output:, cookies:, headers:, auth:, headless: true, port: 0, wait_window_loaded: false,
-                   wait_network_idle: false, print_options: {})
+                   wait_network_idle: false, print_options: {}, remote_browser_url: nil)
       @url = url
       @port = port
       @headless = headless
@@ -19,14 +20,14 @@ module Bidi2pdf
       @wait_window_loaded = wait_window_loaded
       @wait_network_idle = wait_network_idle
       @print_options = print_options || {}
+      @remote_browser_url = remote_browser_url
     end
 
-    def launch
-      @manager = ChromedriverManager.new(port: @port, headless: @headless)
-      @manager.start
+    # rubocop:enable Metrics/ParameterLists
 
+    def launch
       runner = SessionRunner.new(
-        session: @manager.session,
+        session: session,
         url: @url,
         output: @output,
         cookies: @cookies,
@@ -40,7 +41,19 @@ module Bidi2pdf
     end
 
     def stop
-      @manager.stop
+      @manager&.stop
+    end
+
+    private
+
+    def session
+      if @remote_browser_url
+        Bidi::Session.new(session_url: @remote_browser_url, headless: @headless)
+      else
+        @manager = ChromedriverManager.new(port: @port, headless: @headless)
+        @manager.start
+        @manager.session
+      end
     end
   end
 end

data/lib/bidi2pdf/version.rb

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

data/sig/bidi2pdf/bidi/add_headers_interceptor.rbs

@@ -0,0 +1,20 @@
+module Bidi2pdf
+  module Bidi
+    class AddHeadersInterceptor
+      @id: String
+      @client: untyped
+      @headers: Hash[String, String]
+
+      attr_reader id: String
+      attr_reader headers: Hash[String, String]
+
+      def initialize: (String id, Hash[String, String] headers, untyped client) -> void
+
+      def handle_event: (Hash[String, untyped] response) -> (nil | untyped)
+
+      private
+
+      attr_reader client: untyped
+    end
+  end
+end

data/sig/bidi2pdf/bidi/auth_interceptor.rbs

@@ -0,0 +1,17 @@
+module Bidi2pdf
+  module Bidi
+    class AuthInterceptor
+      @credentials: Hash[Symbol, String]?
+
+      def initialize: (?credentials: Hash[Symbol, String]?) -> void
+
+      def intercept: (untyped request) -> untyped
+
+      private
+
+      def add_auth_header: (untyped request) -> void
+
+      def auth_header_value: () -> String?
+    end
+  end
+end