bidi2pdf 0.1.16 → 0.1.18

data/lib/bidi2pdf/cli.rb

@@ -5,11 +5,13 @@ require "yaml"
 require "tempfile"
 
 require_relative "cli/json_output"
+require_relative "cli/session_commands"
 
 module Bidi2pdf
   # rubocop:disable Metrics/AbcSize
   class CLI < Thor
     include JsonOutput
+    include SessionCommands
 
     class_option :config, type: :string, desc: "Load configuration from YAML file"
 
@@ -183,6 +185,47 @@ module Bidi2pdf
     end
     map "run" => :run_recipe
 
+    desc "sessions", "List the Chrome sessions a remote chromedriver holds: id, age, tabs, responsive (no URLs)"
+    option :remote_browser_url, type: :string, required: true, desc: "The chromedriver's new-session URL (http://host:3000/session)"
+    option :scope, type: :string, default: "all", enum: %w[all recorded], desc: "all sessions, or only those bidi2pdf recorded"
+    option :json, type: :boolean, default: false, desc: "Emit a JSON array instead of a table"
+
+    def sessions
+      return print_sessions(chrome_sweeper.sessions) unless options[:json]
+
+      reserve_stdout_for_machine_output { puts JSON.generate(chrome_sweeper.sessions.map { |info| session_hash(info) }) }
+    end
+
+    desc "sweep", "Close leaked Chrome sessions on a remote chromedriver (too old, unresponsive, or over a limit)"
+    long_desc <<~USAGE, wrap: false
+      Closes sessions older than --older-than seconds, sessions that failed --unresponsive-checks
+      checks in a row (taken --check-interval seconds apart, so a sweep takes that long), and while
+      more than --max-sessions exist, the oldest ones. A session younger than --min-age seconds is
+      never closed, and neither is one a running bidi2pdf process holds (its lease is renewed). --scope all looks at
+      every session on that chromedriver - use it only for a chromedriver your application owns;
+      --scope recorded (default) only at sessions bidi2pdf recorded on this machine.
+      Exits 1 when a close failed or the limit is still exceeded.
+    USAGE
+    option :remote_browser_url, type: :string, required: true, desc: "The chromedriver's new-session URL (http://host:3000/session)"
+    option :scope, type: :string, default: "recorded", enum: %w[recorded all], desc: "Which sessions may be closed"
+    option :older_than, type: :numeric, desc: "Close sessions older than this many seconds (default 600)"
+    option :max_sessions, type: :numeric, desc: "Close the oldest sessions while more than this many exist"
+    option :min_age, type: :numeric, desc: "Never close a session younger than this many seconds (default 60)"
+    option :unresponsive_checks, type: :numeric, desc: "Close a session after this many failed checks in a row (default 2)"
+    option :check_interval, type: :numeric, default: 10, desc: "Seconds between those checks; 0 sweeps at once, without the unresponsive rule"
+    option :pressure, type: :boolean, default: false, desc: "Last resort: close every session no live process holds that is past --min-age"
+    option :dry_run, type: :boolean, default: false, desc: "Report what would be closed, close nothing"
+    option :json, type: :boolean, default: false, desc: "Emit the sweep result as JSON"
+
+    def sweep
+      result = if options[:json]
+                 reserve_stdout_for_machine_output { run_sweep.tap { |swept| puts JSON.generate(sweep_hash(swept)) } }
+               else
+                 run_sweep.tap { |swept| print_sweep(swept) }
+               end
+      exit(1) if result.errors.any? || result.limit_exceeded
+    end
+
     desc "template", "Generate a config file template"
     option :output, default: "bidi2pdf.yml", desc: "Output configuration filename"
 

data/lib/bidi2pdf/dsl.rb

@@ -47,7 +47,8 @@ module Bidi2pdf
                     Bidi2pdf::Bidi::Session.new(
                       session_url: remote_browser_url,
                       headless: true, # remote is always headless
-                      chrome_args: chrome_args
+                      chrome_args: chrome_args,
+                      registry: Bidi2pdf::SessionRegistry.new(remote_browser_url)
                     )
                   else
                     manager = Bidi2pdf::ChromedriverManager.new(port: port, headless: headless, chrome_args: chrome_args)

data/lib/bidi2pdf/launcher.rb

@@ -109,7 +109,8 @@ module Bidi2pdf
 
     def session
       if @remote_browser_url
-        @custom_session = Bidi::Session.new(session_url: @remote_browser_url, headless: @headless, chrome_args: @chrome_args)
+        @custom_session = Bidi::Session.new(session_url: @remote_browser_url, headless: @headless, chrome_args: @chrome_args,
+                                            registry: Bidi2pdf::SessionRegistry.new(@remote_browser_url))
       else
         @manager = ChromedriverManager.new(port: @port, headless: @headless, chrome_args: @chrome_args)
         @manager.start

data/lib/bidi2pdf/session_registry/heartbeat.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Bidi2pdf
+  class SessionRegistry
+    # Keeps the leases of every session this process holds fresh: one thread per process renews
+    # them in their registry files every +interval+ seconds, so a sweeper in another process (a
+    # second Puma worker, a job worker sharing the registry directory) can tell a live session
+    # from one whose process died. The thread runs only while something is held.
+    #
+    # Fork-aware: a child process (Puma forks its workers) starts with nothing held and without the
+    # parent's thread - the parent's sessions are the parent's to renew.
+    module Heartbeat
+      DEFAULT_INTERVAL = DEFAULT_LEASE_TTL / 3.0
+
+      @mutex = Mutex.new
+
+      class << self
+        # @return [Numeric] seconds between renewals - keep it well below the sweeper's lease_ttl.
+        attr_writer :interval
+
+        def interval = @interval || DEFAULT_INTERVAL
+
+        def hold(registry, session_id)
+          synchronize do
+            (held[registry.path] ||= [registry, Set.new])[1] << session_id.to_s
+            @thread = Thread.new { beat_loop } unless @thread&.alive?
+          end
+        end
+
+        def release(registry, session_id)
+          synchronize do
+            ids = held.dig(registry.path, 1)
+            next unless ids
+
+            ids.delete(session_id.to_s)
+            held.delete(registry.path) if ids.empty?
+          end
+        end
+
+        # @return [Array<String>] the session ids this process holds in +registry+'s file.
+        def held_ids(registry)
+          synchronize { held.dig(registry.path, 1).to_a }
+        end
+
+        # Renews every held lease now.
+        def beat!(now: Time.now.to_i)
+          synchronize { held.values.map { |registry, ids| [registry, ids.to_a] } }
+            .each { |registry, ids| registry.renew(ids, at: now) }
+        end
+
+        private
+
+        def beat_loop
+          loop do
+            sleep interval
+            break if synchronize { held.empty? }
+
+            beat!
+          end
+        rescue StandardError => e
+          Bidi2pdf.logger.warn "session registry heartbeat stopped: #{e.message}"
+        end
+
+        def held
+          reset_after_fork
+          @held ||= {}
+        end
+
+        def reset_after_fork
+          return if @pid == Process.pid
+
+          @pid = Process.pid
+          @held = {}
+          @thread = nil
+        end
+
+        def synchronize(&)
+          @mutex.synchronize(&)
+        end
+      end
+    end
+  end
+end

data/lib/bidi2pdf/session_registry.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+require "socket"
+require "tmpdir"
+
+module Bidi2pdf
+  # Remembers which sessions bidi2pdf opened on a shared (remote) chromedriver, when, by which
+  # process, and whether that process is still alive - in a small JSON file per chromedriver URL - so
+  # a process started later, or a ChromeSweeper, can find and close the ones a process that died
+  # without a clean shutdown left behind (see SessionSweeper). chromedriver itself keeps a session
+  # until someone deletes it, and it drops any tag we could attach to one (a custom capability is
+  # accepted but echoed nowhere - checked against chromedriver 153), hence a file.
+  #
+  # Liveness is a lease: a session the process #hold s is renewed by its Heartbeat every
+  # Heartbeat.interval seconds. A session whose lease is fresh belongs to a live process - a render
+  # in flight or a warm spare - and no sweeper closes it; one whose lease ran out belongs to a dead
+  # process. #record alone writes an entry nobody renews.
+  #
+  # Everything here is best effort and fail-open: a directory that is not writable, a locked-out or
+  # corrupt file only switches orphan tracking off for this process (one warning, one
+  # +session_warmer.registry_unavailable.bidi2pdf+ notification) - rendering never depends on it.
+  # The file is created 0600 and every change happens under an exclusive lock, so processes sharing
+  # the directory (Puma workers, a job worker, a spec run) can record at the same time.
+  class SessionRegistry
+    FILE_PREFIX = "bidi2pdf-sessions-"
+    # Seconds a lease stays fresh without a renewal.
+    DEFAULT_LEASE_TTL = 60
+
+    attr_reader :path
+
+    def self.owner = "#{Socket.gethostname}:#{Process.pid}"
+
+    def initialize(session_url, dir: nil)
+      @path = File.join(dir || Dir.tmpdir, "#{FILE_PREFIX}#{Digest::SHA256.hexdigest(session_url.to_s)[0, 16]}.json")
+      @warned = false
+    end
+
+    # Records a session the caller opened and keeps its lease fresh while this process lives.
+    def hold(session_id)
+      return false if session_id.nil?
+
+      recorded = record(session_id)
+      Heartbeat.hold(self, session_id)
+      recorded
+    end
+
+    # Stops renewing the lease but keeps the entry - for a session this process could not close, so
+    # a sweeper takes it once the lease ran out.
+    def release(session_id)
+      Heartbeat.release(self, session_id) unless session_id.nil?
+    end
+
+    # Writes an entry, leased from +created_at+ on but not renewed (see #hold).
+    def record(session_id, created_at: Time.now.to_i)
+      return false if session_id.nil?
+
+      update do |entries|
+        entries[session_id.to_s] = { "created_at" => created_at.to_i, "renewed_at" => created_at.to_i, "owner" => self.class.owner }
+      end
+    end
+
+    # Forgets a session the caller closed itself (or found gone).
+    def forget(session_id)
+      return false if session_id.nil?
+
+      release(session_id)
+      update { |entries| entries.delete(session_id.to_s) }
+    end
+
+    # Renews the leases of +session_ids+ that are still recorded.
+    def renew(session_ids, at: Time.now.to_i)
+      update do |entries|
+        session_ids.each { |id| entries[id]["renewed_at"] = at.to_i if entries.key?(id) }
+      end
+    end
+
+    # Every recorded session: { id => opened at (epoch seconds) }.
+    def recorded
+      read.transform_values { |entry| entry["created_at"] }
+    end
+
+    # The recorded session ids whose lease was renewed within +ttl+ seconds before +now+ - sessions
+    # of a live process.
+    def leased(now: Time.now.to_i, ttl: DEFAULT_LEASE_TTL)
+      read.select { |_, entry| entry["renewed_at"].to_i >= now - ttl }.keys
+    end
+
+    # The recorded session ids opened at or before +cutoff+ (epoch seconds).
+    def recorded_before(cutoff)
+      recorded.select { |_, created_at| created_at <= cutoff }.keys
+    end
+
+    private
+
+    def read
+      return {} unless File.exist?(path)
+
+      File.open(path, File::RDONLY) do |file|
+        file.flock(File::LOCK_SH)
+        parse(file.read)
+      end
+    rescue SystemCallError, IOError => e
+      unavailable!(e)
+      {}
+    end
+
+    def update
+      File.open(path, File::RDWR | File::CREAT, 0o600) do |file|
+        file.flock(File::LOCK_EX)
+        entries = parse(file.read)
+        yield entries
+        file.rewind
+        file.truncate(0)
+        file.write(JSON.generate(entries))
+        file.flush
+      end
+      true
+    rescue SystemCallError, IOError => e
+      unavailable!(e)
+      false
+    end
+
+    # A corrupt or foreign file counts as empty rather than as an error; an entry of the first
+    # format (just the creation time) has no lease.
+    def parse(text)
+      data = text.to_s.empty? ? {} : JSON.parse(text)
+      return {} unless data.is_a?(Hash)
+
+      data.filter_map { |id, entry| [id, normalize(entry)] if id.is_a?(String) && normalize(entry) }.to_h
+    rescue JSON::ParserError
+      {}
+    end
+
+    def normalize(entry)
+      return { "created_at" => entry } if entry.is_a?(Integer)
+
+      entry if entry.is_a?(Hash) && entry["created_at"].is_a?(Integer)
+    end
+
+    def unavailable!(error)
+      return if @warned
+
+      @warned = true
+      Bidi2pdf.logger.warn "session_warmer: session registry #{path} unavailable, leftover sessions will not be tracked: #{error.message}"
+      Bidi2pdf.notification_service.instrument("session_warmer.registry_unavailable.bidi2pdf", { path: path, error: error.class.name })
+    end
+  end
+end
+
+require_relative "session_registry/heartbeat"

data/lib/bidi2pdf/session_sweeper.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module Bidi2pdf
+  # Closes sessions a SessionWarmer recorded (SessionRegistry) on a shared chromedriver that are
+  # older than a cutoff - left behind by a process that died without a clean shutdown, and holding a
+  # whole Chrome each until someone deletes them. Run once when a warmer starts.
+  #
+  # Only recorded sessions are ever touched - another tool's sessions on the same chromedriver never
+  # are, and neither is one whose lease a live process keeps renewing (SessionRegistry#hold). A
+  # recorded session that is already gone ("invalid session id" / 404) is just forgotten.
+  # Fail-open: any error is logged and ends the sweep; it never raises.
+  class SessionSweeper
+    # @param session_url [String] the chromedriver's new-session URL (".../session").
+    # @param registry [SessionRegistry]
+    # @param http [#call, nil] (method, url) -> status code; injectable for tests.
+    def initialize(session_url, registry, http: nil)
+      @session_url = session_url.to_s.chomp("/")
+      @registry = registry
+      @http = http || method(:net_http)
+    end
+
+    # Closes recorded sessions opened more than +older_than+ seconds before +now+.
+    #
+    # @return [Integer] how many sessions were actually closed.
+    def sweep(older_than:, now: Time.now.to_i)
+      leftovers = @registry.recorded_before(now - older_than) - @registry.leased(now: now)
+      closed = leftovers.count { |id| closed_now?(id) }
+      report(closed)
+      closed
+    rescue StandardError => e
+      Bidi2pdf.logger.warn "session_warmer: sweeping leftover sessions failed: #{e.message}"
+      Bidi2pdf.notification_service.instrument("session_warmer.sweep_failed.bidi2pdf", { error: e.class.name })
+      0
+    end
+
+    private
+
+    # True when this call closed the session; a session already gone is forgotten but not counted.
+    def closed_now?(id)
+      status = @http.call(:delete, "#{@session_url}/#{id}")
+      return false unless [200, 404].include?(status)
+
+      @registry.forget(id)
+      status == 200
+    end
+
+    def report(closed)
+      return if closed.zero?
+
+      Bidi2pdf.logger.info "session_warmer: closed #{closed} leftover session(s) on #{@session_url}"
+      Bidi2pdf.notification_service.instrument("session_warmer.orphans_closed.bidi2pdf", { count: closed })
+    end
+
+    # chromedriver answers a DELETE of a session it no longer has with 404 "invalid session id".
+    def net_http(method, url)
+      uri = URI(url)
+      request = method == :delete ? Net::HTTP::Delete.new(uri) : Net::HTTP::Get.new(uri)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", open_timeout: 5, read_timeout: 30) do |http|
+        http.request(request).code.to_i
+      end
+    end
+  end
+end

data/lib/bidi2pdf/session_warmer.rb

@@ -50,6 +50,24 @@ module Bidi2pdf
       #   1.25x this value even when no render ever comes. +nil+ disables the limit.
       attr_accessor :max_idle_age
 
+      # @return [Numeric, Symbol, nil] Seconds after which a session recorded by any warmer on the
+      #   same remote chromedriver counts as left behind - its process died without closing it - and
+      #   is closed when a warmer starts (SessionSweeper). +:auto+ (the default) is twice
+      #   max_idle_age: a live warmer recycles its own spares within ~1.25x of that, so no live
+      #   process's slot is ever taken. +nil+ disables the sweep. Remote mode only.
+      attr_accessor :orphan_age
+
+      # @return [String, nil] Directory for the session registry file (SessionRegistry); +nil+ means
+      #   Dir.tmpdir. Every process that should clean up after the others must share it.
+      attr_accessor :registry_dir
+
+      # @return [Hash, nil] Options for a ChromeSweeper on the remote chromedriver (+scope+,
+      #   +orphan_age+, +min_age+, +unresponsive_checks+, +max_sessions+, +pids_limit+, +interval+,
+      #   ...), or +nil+ (default) for none. This warmer's own sessions are never touched by it; with
+      #   an +interval+ it sweeps in the background, and a session that fails to start triggers one
+      #   sweep and one retry. Remote mode only.
+      attr_accessor :sweeper
+
       DEFAULT_MAX_IDLE_AGE = 300
 
       def initialize
@@ -59,12 +77,23 @@ module Bidi2pdf
         @remote_browser_url = nil
         @slot_factory = nil
         @max_idle_age = DEFAULT_MAX_IDLE_AGE
+        @orphan_age = :auto
+        @registry_dir = nil
+        @sweeper = nil
+      end
+
+      # The orphan age in seconds, or nil when the sweep is off (also when +:auto+ has no
+      # max_idle_age to derive it from).
+      def effective_orphan_age
+        orphan_age == :auto ? max_idle_age && (max_idle_age * 2) : orphan_age
       end
 
       # @raise [ArgumentError] if a setting can't be honored - checked once, at construction.
       def validate!
         validate_size!
         validate_max_idle_age!
+        validate_orphan_age!
+        validate_sweeper!
       end
 
       private
@@ -80,6 +109,18 @@ module Bidi2pdf
 
         raise ArgumentError, "max_idle_age must be nil or a positive number of seconds, got #{max_idle_age.inspect}"
       end
+
+      def validate_orphan_age!
+        return if orphan_age.nil? || orphan_age == :auto || (orphan_age.is_a?(Numeric) && orphan_age.positive?)
+
+        raise ArgumentError, "orphan_age must be :auto, nil or a positive number of seconds, got #{orphan_age.inspect}"
+      end
+
+      def validate_sweeper!
+        return if sweeper.nil? || sweeper.is_a?(Hash)
+
+        raise ArgumentError, "sweeper must be nil or a Hash of ChromeSweeper options, got #{sweeper.inspect}"
+      end
     end
 
     class << self
@@ -140,6 +181,12 @@ module Bidi2pdf
         instance.with_tab(&)
       end
 
+      # Sweeps the remote chromedriver with the configured sweeper; nil when there is none (or no
+      # warmer yet - this never creates one).
+      def sweep!(reason: :manual)
+        @instance&.sweep!(reason: reason)
+      end
+
       # Retires every currently-warm spare and resets the singleton.
       def shutdown
         @instance&.shutdown
@@ -181,8 +228,19 @@ module Bidi2pdf
       @warming = 0
       @shutdown = false
       @reaper_wakeup = Thread::Queue.new
+      @own_sessions = []
+      @registry = build_registry
+      sweep_leftovers
+      @sweeper = build_sweeper
       prewarm
-      @reaper = Thread.new { reap_loop } if @config.max_idle_age
+      start_background_work
+    end
+
+    # Sweeps the remote chromedriver now - for an application that suspects leaked sessions.
+    #
+    # @return [ChromeSweeper::Result, nil] nil when no sweeper is configured.
+    def sweep!(reason: :manual)
+      @sweeper&.sweep!(reason: reason)
     end
 
     # Checks out a slot, creates an isolated UserContext/Window/Tab for one render, yields the tab,
@@ -218,6 +276,7 @@ module Bidi2pdf
 
       @reaper_wakeup << :stop
       @reaper&.join
+      @sweeper&.stop
       threads.each(&:join)
       spares.each { |slot| retire(slot) }
     end
@@ -235,7 +294,54 @@ module Bidi2pdf
     end
 
     def create_slot
+      slot = new_slot
+      id = session_id_of(slot)
+      @registry&.hold(id)
+      @mutex.synchronize { @own_sessions << id } if id
+      slot
+    end
+
+    # A chromedriver out of room for another Chrome refuses the session; with a sweeper, close
+    # everything nobody holds (a pressure sweep) and try once more.
+    def new_slot
       @slot_factory.call
+    rescue Bidi2pdf::SessionNotStartedError
+      raise unless @sweeper
+
+      @sweeper.sweep!(reason: :create_failed, pressure: true)
+      @slot_factory.call
+    end
+
+    def start_background_work
+      @reaper = Thread.new { reap_loop } if @config.max_idle_age
+      @sweeper.start if @sweeper&.interval
+    end
+
+    def build_sweeper
+      return unless @config.remote_browser_url && @config.sweeper
+
+      options = { registry: @registry }.merge(@config.sweeper)
+      Bidi2pdf::ChromeSweeper.new(@config.remote_browser_url, own_sessions: -> { @mutex.synchronize { @own_sessions.dup } }, **options)
+    end
+
+    # Remote mode with an orphan age or a sweeper: sessions are recorded, so a later start (or the
+    # sweeper, whose default scope is :recorded) can close the ones this process leaves behind if it
+    # dies uncleanly. The start-up sweep itself needs the orphan age - see #sweep_leftovers.
+    def build_registry
+      return unless @config.remote_browser_url && (@config.effective_orphan_age || @config.sweeper)
+
+      Bidi2pdf::SessionRegistry.new(@config.remote_browser_url, dir: @config.registry_dir)
+    end
+
+    def sweep_leftovers
+      return unless @registry && @config.effective_orphan_age
+
+      Bidi2pdf::SessionSweeper.new(@config.remote_browser_url, @registry).sweep(older_than: @config.effective_orphan_age)
+    end
+
+    def session_id_of(slot)
+      session = slot[:session]
+      session.session_id if session.respond_to?(:session_id)
     end
 
     # Session#started? is just an internal flag set once at startup - it never flips back if Chrome,
@@ -366,8 +472,13 @@ module Bidi2pdf
       retire(slot) if discard
     end
 
+    # Forgotten only after closing: a process that dies in between leaves a record whose session is
+    # already gone - the next sweep just drops it - never an open session nobody knows about.
     def retire(slot)
       self.class.retire_slot(session: slot[:session], manager: slot[:manager])
+      id = session_id_of(slot)
+      @registry&.forget(id)
+      @mutex.synchronize { @own_sessions.delete(id) }
     end
 
     def safe_close(label, &)

data/lib/bidi2pdf/version.rb

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

data/lib/bidi2pdf.rb

@@ -10,6 +10,10 @@ require_relative "bidi2pdf/dsl"
 require_relative "bidi2pdf/notifications"
 require_relative "bidi2pdf/notifications/logging_subscriber"
 require_relative "bidi2pdf/notifications/json_subscriber"
+require_relative "bidi2pdf/session_registry"
+require_relative "bidi2pdf/session_sweeper"
+require_relative "bidi2pdf/chromedriver_api"
+require_relative "bidi2pdf/chrome_sweeper"
 require_relative "bidi2pdf/session_warmer"
 require_relative "bidi2pdf/verbose_logger"
 

data/sig/bidi2pdf/bidi/buffered_web_socket_client.rbs

@@ -59,6 +59,13 @@ module Bidi2pdf
 
       def emit: (untyped event, *untyped) -> untyped
 
+      # The reader closes the socket from its own thread when the peer hangs up, and #close does not
+      # wait for a write in flight - so a write can fail with "stream closed in another thread" (or
+      # EPIPE) because *we* closed it. By then the connection is over and :close has been emitted;
+      # there is nothing left to report. Seen in the handshake write of #connect, which had no
+      # rescue: a server that answered and hung up at once made #connect raise although the
+      # handshake went through. Any other write failure still raises (#send and #say_goodbye
+      # handle it).
       def write: (untyped bytes) -> untyped
 
       def say_goodbye: () -> untyped

data/sig/bidi2pdf/bidi/commands/browsing_context_get_tree.rbs

@@ -0,0 +1,12 @@
+module Bidi2pdf
+  module Bidi
+    module Commands
+      # browsingContext.getTree - the session's top-level browsing contexts (tabs/windows).
+      class BrowsingContextGetTree
+        include Base
+
+        def method_name: () -> "browsingContext.getTree"
+      end
+    end
+  end
+end

data/sig/bidi2pdf/bidi/commands/cdp_send_command.rbs

@@ -0,0 +1,23 @@
+module Bidi2pdf
+  module Bidi
+    module Commands
+      # goog:cdp.sendCommand - chromedriver's BiDi extension that runs one Chrome DevTools Protocol
+      # command; without a +session+ it runs at browser level (e.g. SystemInfo.getProcessInfo).
+      class CdpSendCommand
+        @cdp_method: untyped
+
+        @cdp_params: untyped
+
+        @session: untyped
+
+        include Base
+
+        def initialize: (method: untyped, ?params: ::Hash[untyped, untyped], ?session: untyped?) -> void
+
+        def params: () -> untyped
+
+        def method_name: () -> "goog:cdp.sendCommand"
+      end
+    end
+  end
+end