bidi2pdf 0.1.1 → 0.1.2

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,14 +33,26 @@ 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
@@ -83,7 +98,7 @@ module Bidi2pdf
     def close_session
       Bidi2pdf.logger.info "Closing session"
 
-      @session.close
+      @session&.close
       @session = nil
     end
 

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.2"
 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

data/sig/bidi2pdf/bidi/browser.rbs

@@ -0,0 +1,38 @@
+module Bidi2pdf
+  module Bidi
+    class Browser
+      @url: String
+      @chromedriver_manager: Bidi2pdf::ChromedriverManager
+      @browser: untyped
+      @timeout: Integer
+      @debug: bool
+
+      attr_reader browser: untyped
+      attr_reader timeout: Integer
+
+      def initialize: (
+          url: String,
+          chromedriver_manager: Bidi2pdf::ChromedriverManager,
+          ?timeout: Integer,
+          ?debug: bool
+        ) -> void
+
+      def navigate: (?reload: bool) -> void
+
+      def current_url: -> String
+
+      def wait_until: [T] (
+          ?timeout: Integer,
+          ?message: String
+        ) { () -> T? } -> T
+
+      def close: () -> void
+
+      private
+
+      def connect: () -> untyped
+
+      def setup_browser: () -> untyped
+    end
+  end
+end

data/sig/bidi2pdf/bidi/browser_tab.rbs

@@ -0,0 +1,42 @@
+module Bidi2pdf
+  module Bidi
+    class BrowserTab
+      @browser: Bidi2pdf::Bidi::Browser
+      @tab_id: String?
+      @session_id: String?
+      @timeout: Integer
+
+      attr_reader browser: Bidi2pdf::Bidi::Browser
+      attr_reader tab_id: String?
+      attr_reader session_id: String?
+
+      def initialize: (
+          browser: Bidi2pdf::Bidi::Browser,
+          ?tab_id: String?,
+          ?timeout: Integer
+        ) -> void
+
+      def navigate_to: (String url) -> void
+
+      def execute_script: [T] (String script, *untyped args) -> T
+
+      def wait_for_navigation: (?timeout: Integer) -> void
+
+      def wait_for_element: (
+          selector: String,
+          ?visible: bool,
+          ?timeout: Integer
+        ) -> untyped
+
+      def capture_screenshot: (?path: String?) -> String
+
+      def close: () -> void
+
+      private
+
+      def ensure_tab_active: () -> void
+
+      def connect_to_tab: () -> String?
+    end
+  end
+end

data/sig/bidi2pdf/bidi/client.rbs

@@ -0,0 +1,72 @@
+module Bidi2pdf
+  module Bidi
+    class Client
+      @next_id_mutex: Mutex
+      @ws_url: untyped
+
+      @id: untyped
+
+      @pending_responses: Hash[String, Thread::Queue]
+
+      @connected: untyped
+
+      @connection_mutex: Mutex
+
+      @send_cmd_mutex: Mutex
+
+      @connection_cv: untyped
+
+      @started: untyped
+
+      @socket: untyped
+
+      @dispatcher: untyped
+
+      include Bidi2pdf::Utils
+
+      attr_reader ws_url: untyped
+
+      def initialize: (untyped ws_url) -> void
+
+      def start: () -> untyped
+
+      def started?: () -> untyped
+
+      def wait_until_open: (?timeout: untyped) -> untyped
+
+      def send_cmd: (untyped method, ?::Hash[untyped, untyped] params) -> untyped
+
+      # rubocop:disable Metrics/AbcSize
+      def send_cmd_and_wait: (untyped method, ?::Hash[untyped, untyped] params, ?timeout: untyped) ?{ (untyped) -> untyped } -> untyped
+
+      # Event API for external consumers
+      def on_message: () { () -> untyped } -> untyped
+
+      def on_open: () { () -> untyped } -> untyped
+
+      def on_close: () { () -> untyped } -> untyped
+
+      def on_error: () { () -> untyped } -> untyped
+
+      def on_event: (*untyped names) { () -> untyped } -> untyped
+
+      def remove_message_listener: (untyped block) -> untyped
+
+      def remove_event_listener: (*untyped names) { () -> untyped } -> untyped
+
+      def add_headers_interceptor: (context: untyped, url_patterns: untyped, headers: untyped) -> untyped
+
+      def add_auth_interceptor: (context: untyped, url_patterns: untyped, username: untyped, password: untyped) -> untyped
+
+      private
+
+      def next_id: () -> untyped
+
+      def handle_open: () -> untyped
+
+      def handle_response_to_cmd: (untyped data) -> untyped
+
+      def redact_sensitive_fields: (untyped obj, ?::Array[untyped] sensitive_keys) -> untyped
+    end
+  end
+end

data/sig/bidi2pdf/bidi/event_manager.rbs

@@ -0,0 +1,29 @@
+module Bidi2pdf
+  module Bidi
+    class EventManager
+      @browser: Bidi2pdf::Bidi::Browser
+      @listeners: Hash[String, Array[Proc]]
+      @active: bool
+
+      def initialize: (browser: Bidi2pdf::Bidi::Browser) -> void
+
+      def on: (String event_name) { (Hash[String, untyped]) -> void } -> void
+
+      def off: (String event_name) -> void
+
+      def emit: (String event_name, Hash[String, untyped] params) -> void
+
+      def start_listening: () -> void
+
+      def stop_listening: () -> void
+
+      private
+
+      def register_browser_events: () -> void
+
+      def handle_event: (String event_name, Hash[String, untyped] params) -> void
+
+      def process_event: (String event_name, Hash[String, untyped] params) -> void
+    end
+  end
+end