bidi2pdf 0.1.0 → 0.1.2

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

@@ -25,22 +25,24 @@ module Bidi2pdf
         "goog:cdp.Page.screencastFrame"
       ].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
@@ -88,9 +90,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 +127,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 +143,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,18 +33,32 @@ 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
 
+      detect_zombie_processes
+
       return unless process_alive?
 
       kill_chromedriver timeout: timeout
@@ -51,10 +68,37 @@ module Bidi2pdf
 
     private
 
+    # rubocop:disable Metrics/AbcSize
+    def detect_zombie_processes
+      debug_show_all_children
+
+      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 }
+
+      return if zombie_processes.empty?
+
+      printable_zombie_processes = zombie_processes.map { |child| "#{child.name}:#{child.pid}" }
+      printable_zombie_processes_str = printable_zombie_processes.join(", ")
+
+      Bidi2pdf.logger.error "Zombie Processes detected #{printable_zombie_processes_str}"
+    end
+
+    # rubocop:enable Metrics/AbcSize
+
+    def debug_show_all_children
+      Bidi2pdf::ProcessTree.new(@pid).traverse do |process, level|
+        indent = "  " * level
+        prefix = level.zero? ? "" : "└─ "
+        Bidi2pdf.logger.debug "#{indent}#{prefix}PID #{process.pid} (#{process.name})"
+      end
+    end
+
     def close_session
       Bidi2pdf.logger.info "Closing session"
 
-      @session.close
+      @session&.close
       @session = nil
     end
 
@@ -126,8 +170,8 @@ module Bidi2pdf
 
     # rubocop: enable Metrics/AbcSize
 
-    def process_alive?
-      return false unless @pid
+    def process_alive?(pid = @pid)
+      return false unless pid
 
       begin
         Process.waitpid(@pid, Process::WNOHANG)

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/process_tree.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "sys/proctable"
+module Bidi2pdf
+  class ProcessTree
+    include Sys
+
+    def initialize(root_pid = nil)
+      @root_pid = root_pid
+      @process_map = build_process_map
+      connect_children
+    end
+
+    def children(of_pid)
+      return [] unless @process_map[of_pid]
+
+      direct_children = @process_map[of_pid][:children].map do |child_pid|
+        @process_map[child_pid][:info]
+      end
+
+      (direct_children + direct_children.flat_map { |child| children(child.pid) }).uniq
+    end
+
+    def traverse(&handler)
+      handler = method(:print_handler) unless handler.is_a?(Proc)
+
+      root_pids.each { |pid| traverse_branch(pid, &handler) }
+    end
+
+    private
+
+    def print_handler(process, level)
+      indent = "  " * level
+      prefix = level.zero? ? "" : "└─ "
+      puts "#{indent}#{prefix}PID #{process.pid} (#{process.name})"
+    end
+
+    def build_process_map
+      ProcTable.ps.each_with_object({}) do |process, map|
+        map[process.pid] = { info: process, children: [] }
+      end
+    end
+
+    def connect_children
+      @process_map.each_value do |entry|
+        parent_pid = entry[:info].ppid
+        @process_map[parent_pid][:children] << entry[:info].pid if parent_pid && @process_map.key?(parent_pid)
+      end
+    end
+
+    def root_pids
+      return [@root_pid] if @root_pid
+
+      @process_map.values
+                  .select { |entry| entry[:info].ppid.nil? || !@process_map.key?(entry[:info].ppid) }
+                  .map { |entry| entry[:info].pid }
+    end
+
+    def traverse_branch(pid, level = 0, &handler)
+      return unless @process_map[pid]
+
+      process = @process_map[pid][:info]
+
+      handler.call(process, level)
+
+      @process_map[pid][:children].each do |child_pid|
+        traverse_branch(child_pid, level + 1, &handler)
+      end
+    end
+  end
+end

data/lib/bidi2pdf/session_runner.rb

@@ -29,25 +29,25 @@ module Bidi2pdf
       browser = @session.browser
       user_context = browser.create_user_context
 
-      add_cookies(user_context)
-
       window = user_context.create_browser_window
       tab = window.create_browser_tab
 
       @window = window
       @tab = tab
 
+      add_cookies(tab)
+
       add_headers
       add_basic_auth
     end
 
-    def add_cookies(user_context)
+    def add_cookies(tab)
       @cookies.each do |name, value|
-        user_context.set_cookie(
+        tab.set_cookie(
           name: name,
           value: value,
           domain: domain,
-          source_origin: source_origin
+          secure: uri.scheme == "https"
         )
       end
     end

data/lib/bidi2pdf/version.rb

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

data/lib/bidi2pdf.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "bidi2pdf/utils"
+require_relative "bidi2pdf/process_tree"
 require_relative "bidi2pdf/launcher"
 require_relative "bidi2pdf/bidi/session"