bidi2pdf 0.1.0

data/lib/bidi2pdf/bidi/user_context.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "browser_tab"
+
+module Bidi2pdf
+  module Bidi
+    class UserContext
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+        @context_id = nil
+      end
+
+      def context_id
+        @context_id ||= begin
+          res = client.send_cmd_and_wait("browser.createUserContext", {}) do |response|
+            response["result"]["userContext"]
+          end
+
+          Bidi2pdf.logger.debug "User context created: #{res.inspect}"
+
+          res
+        end
+      end
+
+      def set_cookie(
+        name:,
+        value:,
+        domain:,
+        source_origin:,
+        path: "/",
+        secure: true,
+        http_only: false,
+        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|
+          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|
+          browsing_context_id = response["result"]["context"]
+
+          BrowserTab.new(client, browsing_context_id, context_id)
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/bidi/web_socket_dispatcher.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "event_manager"
+
+module Bidi2pdf
+  module Bidi
+    class WebSocketDispatcher
+      attr_reader :socket_events, :session_events
+
+      def initialize(socket)
+        @socket = socket
+        @socket_events = EventManager.new("socket-event")
+        @session_events = EventManager.new("session-event")
+      end
+
+      def start_listening
+        Bidi2pdf.logger.debug "Registering WebSocket event listeners"
+
+        setup_connection_lifecycle_handlers
+        setup_message_handler
+      end
+
+      # Add listeners
+
+      def on_message(&block) = socket_events.on(:message, &block)
+
+      def on_event(name, &block) = session_events.on(name, &block)
+
+      def on_open(&block) = socket_events.on(:open, &block)
+
+      def on_close(&block) = socket_events.on(:close, &block)
+
+      def on_error(&block) = socket_events.on(:error, &block)
+
+      def remove_message_listener(block) = socket_events.off(:message, block)
+
+      def remove_event_listener(name, block) = session_events.off(name, block)
+
+      def remove_open_listener(block) = socket_events.off(:open, block)
+
+      def remove_close_listener(block) = socket_events.off(:close, block)
+
+      def remove_error_listener(block) = socket_events.off(:error, block)
+
+      def setup_message_handler
+        that = self
+
+        @socket.on(:message) do |msg|
+          data = JSON.parse(msg.data)
+          method = data["method"]
+
+          if method
+            Bidi2pdf.logger.debug "Dispatching session event: #{method}"
+            that.session_events.dispatch(method, data)
+          else
+            Bidi2pdf.logger.debug "Dispatching socket message"
+            that.socket_events.dispatch(:message, data)
+          end
+        end
+      end
+
+      def setup_connection_lifecycle_handlers
+        that = self
+        @socket.on(:open) { |e| that.socket_events.dispatch(:open, e) }
+        @socket.on(:close) { |e| that.socket_events.dispatch(:close, e) }
+        @socket.on(:error) { |e| that.socket_events.dispatch(:error, e) }
+      end
+    end
+  end
+end

data/lib/bidi2pdf/chromedriver_manager.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "chromedriver/binary"
+
+module Bidi2pdf
+  class ChromedriverManager
+    attr_reader :port, :pid, :session
+
+    def initialize(port: 0, headless: true)
+      @port = port
+      @headless = headless
+      @session = nil
+    end
+
+    def start
+      return @pid if @pid
+
+      update_chromedriver
+      cmd = build_cmd
+      Bidi2pdf.logger.info "Starting Chromedriver with command: #{cmd}"
+
+      r, w = IO.pipe
+      @pid = Process.spawn(cmd, out: w, err: w)
+      w.close # close writer in parent
+
+      parse_port_from_output(r)
+
+      Bidi2pdf.logger.info "Started Chromedriver on port #{@port}, PID #{@pid}"
+      wait_until_chromedriver_ready
+
+      at_exit { stop }
+
+      @session = Bidi::Session.new(@port, headless: @headless)
+
+      @pid
+    end
+
+    def stop(timeout: 5)
+      return unless @pid
+
+      close_session
+
+      term_chromedriver
+
+      return unless process_alive?
+
+      kill_chromedriver timeout: timeout
+    ensure
+      @pid = nil
+    end
+
+    private
+
+    def close_session
+      Bidi2pdf.logger.info "Closing session"
+
+      @session.close
+      @session = nil
+    end
+
+    def term_chromedriver
+      Bidi2pdf.logger.info "Stopping Chromedriver (PID #{@pid})"
+
+      Process.kill("TERM", @pid)
+    rescue Errno::ESRCH
+      Bidi2pdf.logger.debug "Process already gone"
+      @pid = nil
+    end
+
+    def kill_chromedriver(timeout: 5)
+      start_time = Time.now
+
+      while Time.now - start_time < timeout
+        return @pid = nil unless process_alive?
+
+        sleep 0.1
+      end
+
+      Bidi2pdf.logger.warn "ChromeDriver did not terminate gracefully — force killing PID #{@pid}"
+
+      begin
+        Process.kill("KILL", @pid)
+      rescue Errno::ESRCH
+        Bidi2pdf.logger.debug "Process already gone"
+      end
+    end
+
+    def build_cmd
+      bin = Chromedriver::Binary::ChromedriverDownloader.driver_path
+      user_data_dir = File.join(Dir.tmpdir, "bidi2pdf", "user_data")
+
+      cmd = [bin]
+      cmd << "--port=#{@port}" unless @port.zero?
+      cmd << "--headless" if @headless
+      cmd << "--user-data-dir "
+      cmd << user_data_dir
+      cmd.join(" ")
+    end
+
+    def update_chromedriver
+      Chromedriver::Binary::ChromedriverDownloader.update
+    end
+
+    # rubocop: disable Metrics/AbcSize
+    def parse_port_from_output(io, timeout: 5)
+      Thread.new do
+        io.each_line do |line|
+          Bidi2pdf.logger.debug line.chomp
+
+          next unless line =~ /ChromeDriver was started successfully on port (\d+)/
+
+          Bidi2pdf.logger.debug "Found port: #{::Regexp.last_match(1).to_i} setup port: #{@port}"
+
+          @port = ::Regexp.last_match(1).to_i if @port.nil? || @port.zero?
+
+          break
+        end
+      rescue IOError
+        # reader closed
+      ensure
+        io.close unless io.closed?
+      end.join(timeout)
+
+      raise "Chromedriver did not report a usable port in #{timeout}s" if @port.nil?
+    end
+
+    # rubocop: enable Metrics/AbcSize
+
+    def process_alive?
+      return false unless @pid
+
+      begin
+        Process.waitpid(@pid, Process::WNOHANG)
+        true
+      rescue Errno::ESRCH, Errno::EPERM, Errno::ECHILD
+        Bidi2pdf.logger.debug "Process already gone"
+        false
+      end
+    end
+
+    def wait_until_chromedriver_ready(timeout: 5)
+      uri = URI("http://127.0.0.1:#{@port}/status")
+      deadline = Time.now + timeout
+
+      until Time.now > deadline
+        begin
+          response = Net::HTTP.get_response(uri)
+          json = JSON.parse(response.body)
+          return true if json["value"] && json["value"]["ready"]
+        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, JSON::ParserError
+          # Just retry
+        end
+
+        sleep 0.1
+      end
+
+      raise "ChromeDriver did not become ready within #{timeout} seconds"
+    end
+  end
+end

data/lib/bidi2pdf/cli.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Bidi2pdf
+  class CLI < Thor
+    desc "render", "Render a URL to PDF using Chrome BiDi"
+    long_desc <<~USAGE, wrap: false
+      Example:
+
+        $ bidi2pdf render \\
+            --url http://localhost:3000/report \\
+            --output report.pdf \\
+            --cookie session=abc123 \\
+            --header X-API-KEY=topsecret \\
+            --auth admin:admin \\
+            --headless \\
+            --port 0 \\
+            --wait_window_loaded \\
+            --wait_network_idle \\
+            --log-level debug
+
+      This command will render the given URL to PDF using Chrome via BiDi protocol,
+      optionally passing cookies, headers, and basic authentication.
+
+      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 :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,
+           type: :boolean,
+           default: false,
+           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 :log_level,
+           type: :string,
+           default: "info", enum: %w[debug info warn error fatal unknown], desc: "Set log level"
+
+    def render
+      configure
+
+      Bidi2pdf.logger.info "Rendering: #{options[:url]} -> #{options[:output]}"
+
+      launcher.launch
+    end
+
+    private
+
+    # rubocop:disable  Metrics/AbcSize
+    def launcher
+      # rubocop:disable Layout/BeginEndAlignment
+      @launcher ||= begin
+                      username, password = parse_auth(options[:auth]) if options[:auth]
+
+                      Bidi2pdf::Launcher.new(
+                        url: options[:url],
+                        output: options[:output],
+                        cookies: parse_key_values(options[:cookie]),
+                        headers: parse_key_values(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]
+                      )
+                    end
+      # rubocop:enable Layout/BeginEndAlignment
+    end
+
+    # rubocop:enable Metrics/AbcSize
+
+    def configure
+      Bidi2pdf.configure do |config|
+        config.logger.level = log_level
+        config.default_timeout = options[:default_timeout]
+
+        Chromedriver::Binary.configure do |c|
+          c.logger.level = log_level
+        end
+      end
+    end
+
+    def log_level
+      case options[:log_level]
+      when "debug" then Logger::DEBUG
+      when "warn" then Logger::WARN
+      when "error" then Logger::ERROR
+      when "fatal" then Logger::FATAL
+      when "unknown" then Logger::UNKNOWN
+      else
+        Logger::INFO
+      end
+    end
+
+    def parse_key_values(pairs)
+      pairs.to_h do |pair|
+        k, v = pair.split("=", 2)
+        raise ArgumentError, "Invalid format for pair: #{pair}" unless k && v
+
+        [k.strip, v.strip]
+      end
+    end
+
+    def parse_auth(auth_string)
+      user, pass = auth_string.split(":", 2)
+      raise ArgumentError, "Auth must be in 'user:pass' format" unless user && pass
+
+      [user, pass]
+    end
+  end
+end

data/lib/bidi2pdf/launcher.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "chromedriver_manager"
+require_relative "session_runner"
+require_relative "bidi/session"
+
+module Bidi2pdf
+  class Launcher
+    def initialize(url:, output:, cookies:, headers:, auth:, headless: true, port: 0, wait_window_loaded: false,
+                   wait_network_idle: false, print_options: {})
+      @url = url
+      @port = port
+      @headless = headless
+      @output = output
+      @cookies = cookies
+      @headers = headers
+      @auth = auth
+      @manager = nil
+      @wait_window_loaded = wait_window_loaded
+      @wait_network_idle = wait_network_idle
+      @print_options = print_options || {}
+    end
+
+    def launch
+      @manager = ChromedriverManager.new(port: @port, headless: @headless)
+      @manager.start
+
+      runner = SessionRunner.new(
+        session: @manager.session,
+        url: @url,
+        output: @output,
+        cookies: @cookies,
+        headers: @headers,
+        auth: @auth,
+        wait_window_loaded: @wait_window_loaded,
+        wait_network_idle: @wait_network_idle,
+        print_options: @print_options
+      )
+      runner.run
+    end
+
+    def stop
+      @manager.stop
+    end
+  end
+end

data/lib/bidi2pdf/session_runner.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  class SessionRunner
+    def initialize(session:, url:, output:, cookies: {}, headers: {}, auth: {}, wait_window_loaded: false,
+                   wait_network_idle: false, print_options: {})
+      @session = session
+      @url = url
+      @output = output
+      @cookies = cookies || {}
+      @headers = headers || {}
+      @auth = auth || {}
+      @wait_window_loaded = wait_window_loaded
+      @wait_network_idle = wait_network_idle
+      @print_options = print_options || {}
+    end
+
+    def run
+      @session.start
+      @session.client.on_close { Bidi2pdf.logger.info "WebSocket closed" }
+
+      setup_browser
+      run_flow
+    end
+
+    private
+
+    def setup_browser
+      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_headers
+      add_basic_auth
+    end
+
+    def add_cookies(user_context)
+      @cookies.each do |name, value|
+        user_context.set_cookie(
+          name: name,
+          value: value,
+          domain: domain,
+          source_origin: source_origin
+        )
+      end
+    end
+
+    def add_headers
+      @headers.each do |name, value|
+        @tab.add_headers(
+          url_patterns: url_patterns,
+          headers: [{ name: name, value: value }]
+        )
+      end
+    end
+
+    def add_basic_auth
+      return unless @auth[:username] && @auth[:password]
+
+      @tab.basic_auth(
+        url_patterns: url_patterns,
+        username: @auth[:username],
+        password: @auth[:password]
+      )
+    end
+
+    def run_flow
+      @session.status
+      @session.user_contexts
+
+      @tab.open_page(@url)
+
+      if @wait_network_idle
+        Bidi2pdf.logger.info "Waiting for network idle"
+        @tab.wait_until_all_finished
+      end
+
+      if @wait_window_loaded
+        Bidi2pdf.logger.info "Waiting for window to be loaded"
+        @tab.execute_script <<-EOF_SCRIPT
+            new Promise(resolve => { const check = () => window.loaded ? resolve('done') : setTimeout(check, 100); check(); });
+        EOF_SCRIPT
+      end
+
+      @tab.print(@output, print_options: @print_options)
+    ensure
+      @tab.close
+      @window.close
+    end
+
+    def uri
+      @uri ||= URI(@url)
+    end
+
+    def domain
+      uri.host
+    end
+
+    def source_origin
+      origin = "#{uri.scheme}://#{uri.host}"
+      origin += ":#{uri.port}" unless [80, 443].include?(uri.port)
+      origin
+    end
+
+    def url_patterns
+      [
+        {
+          type: "pattern",
+          protocol: uri.scheme,
+          hostname: uri.host,
+          port: uri.port.to_s
+        }
+      ]
+    end
+  end
+end

data/lib/bidi2pdf/utils.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  module Utils
+    def timed(operation_name)
+      start_time = Time.now
+      result = yield
+      elapsed = Time.now - start_time
+      Bidi2pdf.logger.debug "#{operation_name} completed in #{elapsed.round(3)}s"
+      result
+    end
+
+    module_function :timed
+  end
+end

data/lib/bidi2pdf/version.rb

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

data/lib/bidi2pdf.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "bidi2pdf/utils"
+require_relative "bidi2pdf/launcher"
+require_relative "bidi2pdf/bidi/session"
+
+require "logger"
+
+module Bidi2pdf
+  class Error < StandardError; end
+
+  @logger = Logger.new($stdout)
+  @logger.level = Logger::DEBUG
+
+  @default_timeout = 60
+
+  class << self
+    attr_accessor :logger, :default_timeout
+
+    # Allow configuration through a block
+    def configure
+      yield self if block_given?
+    end
+  end
+end

data/sig/bidi2pdf/chrome/chromedriver_downloader.rbs

@@ -0,0 +1,11 @@
+module Bidi2pdf
+  module Chrome
+    class ChromedriverDownloader
+      def self.install_dir: -> String
+
+      def self.target: -> String
+
+      def self.update: -> String
+    end
+  end
+end

data/sig/bidi2pdf/chrome/downloader_helper.rbs

@@ -0,0 +1,9 @@
+module Bidi2pdf
+  module Chrome
+    module DownloaderHelper
+      def download_file: (String url, String destination) -> nil
+
+      def extract_zip: (String zip_file, String destination) -> nil
+    end
+  end
+end

data/sig/bidi2pdf/chrome/finder.rbs

@@ -0,0 +1,27 @@
+module Bidi2pdf
+  module Chrome
+    class Finder
+      def self.location: -> String
+
+      def self.version: -> String
+
+      def self.win_location: -> String
+
+      def self.mac_location: -> String
+
+      def self.linux_location: -> String
+
+      def self.win_version: (String location) -> String
+
+      def self.linux_version: (String location) -> String
+
+      def self.mac_version: (String location) -> String
+
+      def self.call: (String process, Array[String] arg) -> String
+
+      private
+
+      def self.find_in_paths: -> String
+    end
+  end
+end

data/sig/bidi2pdf/chrome/platform.rbs

@@ -0,0 +1,13 @@
+module Bidi2pdf
+  module Chrome
+    module Platform
+      def platform: -> String
+
+      def platform_id: -> String
+
+      def driver_filename: -> String
+
+      def file_name: -> String
+    end
+  end
+end