lightpanda 0.0.1 → 0.1.1

data/lib/lightpanda/client.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "json"
+require "concurrent-ruby"
+
+require_relative "client/web_socket"
+require_relative "client/subscriber"
+
+module Lightpanda
+  class Client
+    attr_reader :ws_url, :options
+
+    def initialize(ws_url, options)
+      @ws_url = ws_url
+      @options = options
+      @ws = WebSocket.new(ws_url, options)
+      @command_id = 0
+      @pendings = Concurrent::Hash.new
+      @subscriber = Subscriber.new
+      @mutex = Mutex.new
+
+      start_message_thread
+    end
+
+    def command(method, params = {}, async: false, session_id: nil)
+      message = build_message(method, params, session_id: session_id)
+
+      if async
+        @ws.send_message(JSON.generate(message))
+        return true
+      end
+
+      pending = Concurrent::IVar.new
+      @pendings[message[:id]] = pending
+
+      @ws.send_message(JSON.generate(message))
+
+      response = pending.value!(@options.timeout)
+      raise TimeoutError, "Command #{method} timed out after #{@options.timeout}s" if response.nil?
+
+      handle_error(response) if response["error"]
+
+      response["result"]
+    ensure
+      @pendings.delete(message[:id]) if message
+    end
+
+    def on(event, &)
+      @subscriber.subscribe(event, &)
+    end
+
+    def off(event, block = nil)
+      @subscriber.unsubscribe(event, block)
+    end
+
+    def close
+      @running = false
+      @message_thread&.kill
+      @ws&.close
+      @subscriber.clear
+      @pendings.clear
+    end
+
+    def closed?
+      @ws.closed?
+    end
+
+    private
+
+    def build_message(method, params, session_id: nil)
+      id = next_command_id
+      message = { id: id, method: method, params: params }
+      message[:sessionId] = session_id if session_id
+
+      message
+    end
+
+    def next_command_id
+      @mutex.synchronize { @command_id += 1 }
+    end
+
+    def start_message_thread
+      @running = true
+
+      @message_thread = Thread.new do
+        Thread.current.abort_on_exception = true
+
+        while @running && !@ws.closed?
+          message = @ws.messages.pop
+          next unless message
+
+          handle_message(message)
+        end
+      end
+    end
+
+    def handle_message(message)
+      if message["id"]
+        pending = @pendings[message["id"]]
+        pending&.set(message)
+      elsif message["method"]
+        @subscriber.dispatch(message["method"], message["params"])
+      end
+    end
+
+    def handle_error(response)
+      error = response["error"]
+      message = error["message"]
+      error["code"]
+
+      case message
+      when /No node with given id found/i
+        raise NodeNotFoundError, message
+      when /Cannot find context with specified id/i, /Execution context was destroyed/i
+        raise NoExecutionContextError, message
+      else
+        raise BrowserError, error
+      end
+    end
+  end
+end

data/lib/lightpanda/configuration.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lightpanda
+  class Configuration
+    attr_accessor :binary_path
+
+    def initialize
+      @binary_path = nil
+    end
+  end
+end

data/lib/lightpanda/cookies.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Lightpanda
+  class Cookies
+    attr_reader :browser
+
+    def initialize(browser)
+      @browser = browser
+    end
+
+    def all
+      result = browser.command("Network.getAllCookies")
+
+      result["cookies"] || []
+    end
+
+    def get(name)
+      all.find { |cookie| cookie["name"] == name }
+    end
+
+    def set(name:, value:, domain: nil, path: "/", secure: false, http_only: false, expires: nil)
+      params = {
+        name: name,
+        value: value,
+        path: path,
+        secure: secure,
+        httpOnly: http_only,
+      }
+
+      params[:domain] = domain if domain
+      params[:expires] = expires.to_i if expires
+
+      browser.command("Network.setCookie", **params)
+    end
+
+    def remove(name:, domain: nil, path: "/")
+      params = { name: name, path: path }
+      params[:domain] = domain if domain
+
+      browser.command("Network.deleteCookies", **params)
+    end
+
+    def clear
+      browser.command("Network.clearBrowserCookies")
+    end
+  end
+end

data/lib/lightpanda/errors.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Lightpanda
+  class Error < StandardError; end
+
+  class ProcessTimeoutError < Error; end
+  class BinaryNotFoundError < Error; end
+  class BinaryError < Error; end
+  class UnsupportedPlatformError < Error; end
+
+  class DeadBrowserError < Error; end
+  class TimeoutError < Error; end
+
+  class BrowserError < Error
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+      super(response["message"])
+    end
+  end
+
+  class JavaScriptError < Error
+    attr_reader :class_name, :message
+
+    def initialize(response)
+      @class_name = response.dig("exceptionDetails", "exception", "className")
+      @message = response.dig("exceptionDetails", "exception",
+                              "description") || response.dig("exceptionDetails", "text")
+
+      super(@message)
+    end
+  end
+
+  class NodeNotFoundError < Error; end
+  class NoExecutionContextError < Error; end
+
+  class NoSuchPageError < Error; end
+  class StatusError < Error; end
+end

data/lib/lightpanda/network.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Lightpanda
+  class Network
+    attr_reader :browser
+
+    def initialize(browser)
+      @browser = browser
+      @traffic = []
+      @enabled = false
+    end
+
+    def enable
+      return if @enabled
+
+      browser.command("Network.enable")
+      subscribe
+      @enabled = true
+    end
+
+    def disable
+      return unless @enabled
+
+      browser.command("Network.disable")
+      @enabled = false
+    end
+
+    def traffic
+      @traffic.dup
+    end
+
+    def clear
+      @traffic.clear
+    end
+
+    def wait_for_idle(timeout: 5, connections: 0) # rubocop:disable Naming/PredicateMethod
+      started_at = Time.now
+
+      while Time.now - started_at < timeout
+        pending = @traffic.count { |t| t[:response].nil? }
+        return true if pending <= connections
+
+        sleep 0.1
+      end
+
+      false
+    end
+
+    private
+
+    def subscribe
+      browser.on("Network.requestWillBeSent") do |params|
+        @traffic << {
+          request_id: params["requestId"],
+          url: params.dig("request", "url"),
+          method: params.dig("request", "method"),
+          timestamp: params["timestamp"],
+          response: nil,
+        }
+      end
+
+      browser.on("Network.responseReceived") do |params|
+        request = @traffic.find { |t| t[:request_id] == params["requestId"] }
+
+        next unless request
+
+        request[:response] = {
+          status: params.dig("response", "status"),
+          headers: params.dig("response", "headers"),
+          mime_type: params.dig("response", "mimeType"),
+        }
+      end
+    end
+  end
+end

data/lib/lightpanda/options.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Lightpanda
+  class Options
+    DEFAULT_TIMEOUT = ENV.fetch("LIGHTPANDA_DEFAULT_TIMEOUT", 5).to_i
+    DEFAULT_PROCESS_TIMEOUT = ENV.fetch("LIGHTPANDA_PROCESS_TIMEOUT", 10).to_i
+    DEFAULT_HOST = "127.0.0.1"
+    DEFAULT_PORT = 9222
+    DEFAULT_WINDOW_SIZE = [1024, 768].freeze
+
+    attr_accessor :host, :port, :timeout, :process_timeout, :window_size, :browser_path, :headless
+    attr_writer :ws_url
+
+    def initialize(options = {})
+      @host = options.fetch(:host, DEFAULT_HOST)
+      @port = options.fetch(:port, DEFAULT_PORT)
+      @timeout = options.fetch(:timeout, DEFAULT_TIMEOUT)
+      @process_timeout = options.fetch(:process_timeout, DEFAULT_PROCESS_TIMEOUT)
+      @window_size = options.fetch(:window_size, DEFAULT_WINDOW_SIZE)
+      @browser_path = options[:browser_path]
+      @headless = options.fetch(:headless, true)
+      @ws_url = options[:ws_url]
+    end
+
+    def ws_url
+      @ws_url || "ws://#{host}:#{port}/"
+    end
+
+    def ws_url?
+      !@ws_url.nil?
+    end
+
+    def to_h
+      {
+        host: host,
+        port: port,
+        timeout: timeout,
+        process_timeout: process_timeout,
+        window_size: window_size,
+        browser_path: browser_path,
+        headless: headless,
+        ws_url: ws_url,
+      }
+    end
+  end
+end

data/lib/lightpanda/process.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Lightpanda
+  class Process
+    READY_PATTERN = /server running.*address=(\d+\.\d+\.\d+\.\d+:\d+)/
+
+    attr_reader :pid, :ws_url
+
+    def initialize(options)
+      @options = options
+      @pid = nil
+      @ws_url = nil
+      @stdout_r = nil
+      @stdout_w = nil
+      @stderr_r = nil
+      @stderr_w = nil
+    end
+
+    def start
+      binary_path = @options.browser_path || Binary.find_or_download
+
+      raise BinaryNotFoundError, "Lightpanda binary not found" unless binary_path
+
+      @stdout_r, @stdout_w = IO.pipe
+      @stderr_r, @stderr_w = IO.pipe
+
+      @pid = spawn_process(binary_path)
+
+      @stdout_w.close
+      @stderr_w.close
+
+      wait_for_ready
+    end
+
+    def stop
+      return unless @pid
+
+      begin
+        ::Process.kill("TERM", @pid)
+        ::Process.wait(@pid)
+      rescue Errno::ESRCH, Errno::ECHILD
+        # Process already dead
+      end
+
+      cleanup_pipes
+      @pid = nil
+    end
+
+    def alive?
+      return false unless @pid
+
+      ::Process.kill(0, @pid)
+      true
+    rescue Errno::ESRCH, Errno::EPERM
+      false
+    end
+
+    private
+
+    def spawn_process(binary_path)
+      args = build_args
+
+      ::Process.spawn(
+        binary_path, *args,
+        out: @stdout_w,
+        err: @stderr_w,
+        pgroup: true
+      )
+    end
+
+    def build_args
+      [
+        "serve",
+        "--host",
+        @options.host.to_s,
+        "--port",
+        @options.port.to_s,
+        "--log_level",
+        "info",
+      ]
+    end
+
+    def wait_for_ready
+      started_at = Time.now
+      output = +""
+
+      catch(:ready) do
+        while Time.now - started_at < @options.process_timeout
+          ready = IO.select([@stdout_r, @stderr_r], nil, nil, 0.1)
+
+          next unless ready
+
+          ready[0].each do |io|
+            chunk = io.read_nonblock(1024)
+            output << chunk
+
+            if (match = output.match(READY_PATTERN))
+              @ws_url = "ws://#{match[1]}/"
+              throw(:ready)
+            end
+          rescue IO::WaitReadable
+            # No data available yet
+          rescue EOFError
+            # Pipe closed
+          end
+        end
+
+        stop
+
+        raise ProcessTimeoutError,
+              "Lightpanda failed to start within #{@options.process_timeout} seconds.\nOutput: #{output}"
+      end
+    end
+
+    def cleanup_pipes
+      [@stdout_r, @stdout_w, @stderr_r, @stderr_w].each do |pipe|
+        pipe&.close unless pipe&.closed?
+      end
+    end
+  end
+end

data/lib/lightpanda/version.rb

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

data/lib/lightpanda.rb

@@ -1,8 +1,28 @@
 # frozen_string_literal: true
 
 require_relative "lightpanda/version"
+require_relative "lightpanda/errors"
+require_relative "lightpanda/configuration"
+require_relative "lightpanda/options"
+require_relative "lightpanda/binary"
+require_relative "lightpanda/process"
+require_relative "lightpanda/client"
+require_relative "lightpanda/network"
+require_relative "lightpanda/cookies"
+require_relative "lightpanda/browser"
 
 module Lightpanda
-  class Error < StandardError; end
-  # Your code goes here...
+  class << self
+    def new(**)
+      Browser.new(**)
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lightpanda
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - Marco Roth
@@ -29,39 +29,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: websocket-driver
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '0.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
-description: High-level Ruby API to control Lightpanda browser. Lightpanda is a fast,
-  lightweight headless browser built for web automation, AI agents, and scraping.
+        version: '0.8'
+description: High-level Ruby API to control the Lightpanda browser. Lightpanda is
+  a fast, lightweight headless browser built for web automation, AI agents, and scraping.
   This gem provides CDP-based browser control similar to Ferrum.
 email:
 - marco.roth@intergga.ch
-executables: []
+executables:
+- lightpanda
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE.txt
 - README.md
+- exe/lightpanda
 - lib/lightpanda.rb
+- lib/lightpanda/binary.rb
+- lib/lightpanda/browser.rb
+- lib/lightpanda/capybara.rb
+- lib/lightpanda/capybara/driver.rb
+- lib/lightpanda/capybara/node.rb
+- lib/lightpanda/client.rb
+- lib/lightpanda/client/subscriber.rb
+- lib/lightpanda/client/web_socket.rb
+- lib/lightpanda/configuration.rb
+- lib/lightpanda/cookies.rb
+- lib/lightpanda/errors.rb
+- lib/lightpanda/network.rb
+- lib/lightpanda/options.rb
+- lib/lightpanda/process.rb
 - lib/lightpanda/version.rb
 homepage: https://github.com/marcoroth/lightpanda-ruby
 licenses:
@@ -78,14 +95,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Ruby client for the Lightpanda headless browser via Chrome DevTools Protocol.
 test_files: []