b4n1-web 0.16.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1bca04f5554abef830a51a42c237da9da3eb184f3feecc24c6c9ab6e4873077e
+  data.tar.gz: 88e3f08e1ef4ef23984e86a7d0bdb71a8bc56377456705392b5e75cbabf1e850
+SHA512:
+  metadata.gz: 37baa9b36f5ec03ff363ce45f5402ce9ad155856ca4b8e5ad78536ce2663c46e400e40b85c2c1b7efb6ba5e822db7459424378af2dcfb7d41fd2f719abfd1b19
+  data.tar.gz: 6c0fd5f2d3eae01dbbd274ce1623f3bdf100f185b06f794173d21fb43fe56d2c998b4361e9bce201d46e23038ab4eccca77749c41ad4b0aefbe11e84e8a04e76

data/EULA.txt

@@ -0,0 +1,79 @@
+B4N1-WEB — END USER LICENSE AGREEMENT (BINARIES)
+==================================================
+
+Version: 1.0 | Effective: 2026-09-27 | Applies to: b4n1-web 0.13.0+
+
+This End User License Agreement ("EULA") governs your use of the B4N1
+BINARY ARTIFACTS of b4n1-web — the bundled per-platform `b4n1web`
+executables (`b4n1web-linux-amd64`, `b4n1web-macos-arm64`,
+`b4n1web-windows-amd64.exe` and the remaining platform builds shipped
+under each SDK's `bin/` or `native/` directory), the packaged
+per-language bindings (`*.jar`, `*.nupkg`, `*.whl`, npm tarball),
+and the `b4n1web` standalone executable.
+
+The SDK wrapper source files (the thin per-language bindings) are licensed
+separately under the Business Source License 1.1 — see the `LICENSE` file
+and each registry's license metadata.
+
+1. DEFINITIONS
+   "Binaries" means the compiled artifacts described above.
+   "SDK" means the BSL 1.1 licensed wrapper source distributed for each language.
+   "Source" means the Rust implementation, build scripts, internal tests and
+   internal documentation of the B4N1 engine. Source is NOT distributed under
+   this EULA or any other license and remains proprietary.
+
+2. GRANT OF LICENSE
+   Subject to your compliance with this EULA and payment of any applicable
+   subscription, B4N1 grants you a limited, non-exclusive, non-transferable,
+   revocable license to install and use the Binaries within your own products
+   and internal tooling, in object form only.
+
+3. RESTRICTIONS (strictly enforced)
+   a. NO REDISTRIBUTION OF SOURCE. You may not publish, disclose, sublicense
+      or otherwise make the B4N1 Rust Source available, in whole or in part,
+      modified or unmodified, by any means, including in public repositories.
+   b. NO DECOMPILATION OR REVERSE ENGINEERING. You may not decompile,
+      disassemble, deobfuscate, or otherwise reverse engineer the Binaries
+      except to the extent such restriction is prohibited by applicable law
+      that cannot be waived.
+   c. NO REMOVAL OF NOTICES. You may not remove, alter, or obscure any
+      copyright, license, watermark, or proprietary notices in the Binaries.
+   d. NO RESALE AS A STANDALONE PRODUCT. The Binaries may not be resold,
+      sublicensed, or offered as a competing product.
+   e. COMPLIANCE AND AUDIT. You will cooperate with reasonable verification of
+      license status, including honoring embedded license validation.
+
+4. SUBSCRIPTION TIERS
+   The Binaries operate under the applicable tier, validated offline against a
+   license file (`.b4n1lic`):
+     - Community: free, with attribution/watermark obligations.
+     - Pro / Corporate / Enterprise: paid tiers, no watermark, per the
+       commercial license purchased from B4N1.
+   License files are validated fully offline; no network calls are made at
+   runtime to verify entitlement.
+
+5. TERMINATION
+   This EULA terminates automatically if you breach any term. Upon
+   termination you must cease all use and destroy the Binaries and copies.
+
+6. DISCLAIMER OF WARRANTY
+   The Binaries are provided "AS IS", WITHOUT WARRANTY OF ANY KIND, express or
+   implied, including merchantability, fitness for a particular purpose, and
+   non-infringement. B4N1 does not warrant that the Binaries will be
+   uninterrupted or error-free.
+
+7. LIMITATION OF LIABILITY
+   To the maximum extent permitted by law, B4N1 shall not be liable for any
+   indirect, incidental, special, consequential, or punitive damages, or for
+   any loss of profits, revenue, data, or goodwill, arising out of your use
+   of the Binaries, regardless of the legal theory, even if advised of the
+   possibility of such damages.
+
+8. GOVERNING LAW AND SEVERABILITY
+   This EULA is governed by applicable law. If any provision is held
+   unenforceable, the remaining provisions stay in full force.
+
+9. CONTACT
+   Licensing questions: licensing@b4n1.com | https://b4n1.com
+
+B4N1 — Todos los derechos reservados. Fuente proprietary: privada y secreta.

data/LICENSE

@@ -0,0 +1,95 @@
+Business Source License 1.1
+
+License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+-----------------------------------------------------------------------------
+
+Parameters
+
+Licensor:             B4N1 (b4n1.com)
+Licensed Work:        b4n1-web — Agentic browser engine for web automation,
+                      testing, and AI-powered browsing tasks.
+Additional Use Grant: You may use the Licensed Work in production, free of
+                      charge, provided that your organization's total annual
+                      gross revenue does not exceed USD $100,000. Organizations
+                      whose annual gross revenue exceeds USD $100,000 must
+                      obtain a commercial license from the Licensor before any
+                      production use. You may not resell or provide the
+                      Licensed Work as a managed commercial service without
+                      authorization from the Licensor.
+Change Date:          Four years after the first publicly available
+                      distribution of the Licensed Work under this License.
+Change License:       Apache License, Version 2.0
+
+For information about alternative licensing arrangements for the Licensed
+Work, please contact b4n1@b4n1.com.
+
+-----------------------------------------------------------------------------
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited
+production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE. MariaDB hereby grants you permission to use this License's text to
+license your works, and to refer to it using the trademark "Business Source
+License", as long as you comply with the Covenants of Licensor below.
+
+Covenants of Licensor
+
+In consideration of the right to use this License's text and the "Business
+Source License" name and trademark, Licensor covenants to MariaDB, and to all
+other recipients of the licensed work to be provided by Licensor:
+
+To specify as the Change License a license that is compatible with GPL
+Version 2.0 or a later version, where "compatible" means that software
+provided under the Change License can be included in a program with software
+provided under GPL Version 2.0 or a later version. Licensor may specify
+additional Change Licenses without limitation.
+
+To either: (a) specify an additional grant of rights to use that does not
+impose any additional restriction on the right granted in this License, as
+the Additional Use Grant; or (b) insert the text "None" to specify a Change
+License. Not to modify this License in any other way.
+
+Notice
+
+The Business Source License (this document, or the "License") is not an Open
+Source license. However, the Licensed Work will eventually be made available
+under an Open Source License, as stated in this License.

data/README.md

@@ -0,0 +1,66 @@
+# b4n1-web Ruby SDK
+
+Ultra-lightweight agentic browser for AI agents — Ruby gem wrapping the
+`b4n1web` binary.
+
+## Install
+
+```bash
+gem install b4n1-web
+```
+
+The gem resolves the browser binary in this order:
+
+1. `B4N1WEB_BIN_PATH` (explicit override)
+2. bundled binary inside the gem (when shipped)
+3. well-known user/system locations (`~/.local/bin`, `~/.b4n1web/bin`, …)
+4. `PATH`
+
+If nothing resolves, it fails loudly (no silent fallback) with an actionable
+install hint.
+
+## Usage
+
+```ruby
+require "b4n1web"
+
+browser = B4n1Web::AgentBrowser.new(mode: B4n1Web::BrowserMode::LIGHT)
+page = browser.goto("https://example.com")
+
+puts page.markdown          # extracted markdown
+puts page.links             # array of links (JSON-parsed)
+puts page.get_main_content  # main content heuristic
+puts page.find_links_by_text("docs")
+browser.close               # no-op (binary is stateless)
+
+# Execute JavaScript in the page context
+result = browser.evaluate("https://example.com", "document.title")
+```
+
+### Modes
+
+| Mode | Purpose |
+|------|---------|
+| `B4n1Web::BrowserMode::LIGHT` | Fast HTTP fetch, no JS (default) |
+| `B4n1Web::BrowserMode::JS` | Headless Chromium with JavaScript |
+| `B4n1Web::BrowserMode::RENDER` | Full render + wait-for selector |
+
+### CLI wrapper
+
+The gem installs a `b4n1web` executable that passes arguments straight to the
+resolved binary:
+
+```bash
+b4n1web goto https://example.com --mode light
+```
+
+### Options
+
+- `mode:` — browser mode (default `light`)
+- `timeout:` — seconds before killing the binary (default `30`)
+- `binary:` — explicit binary path (skips auto-resolution)
+- `runner:` — injectable process runner (tests only)
+
+## License
+
+BUSL-1.1 (see `LICENSE`). Binary use is subject to `EULA.txt`.

data/bin/b4n1web

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# CLI wrapper: resolves the bundled/system b4n1web binary and passes all
+# arguments through (e.g. `b4n1web goto https://example.com --mode light`).
+
+require_relative "../lib/b4n1web"
+
+binary = B4n1Web::Binary.resolve
+if binary.nil?
+  warn "ERROR: b4n1web binary not found."
+  warn "  Install: curl -sL https://raw.githubusercontent.com/B4N1-com/b4n1-web/master/scripts/install.sh | bash"
+  warn "  Or set B4N1WEB_BIN_PATH to an existing binary."
+  exit 1
+end
+
+exec(binary, *ARGV)

data/lib/b4n1web/agent_browser.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+require_relative "binary"
+require_relative "page"
+require_relative "errors"
+require_relative "version"
+
+module B4n1Web
+  # Browser modes accepted by the binary.
+  module BrowserMode
+    LIGHT  = "light"
+    JS     = "js"
+    RENDER = "render"
+  end
+
+  # Thin async-free wrapper over the b4n1web binary.
+  #
+  #   browser = B4n1Web::AgentBrowser.new(mode: B4n1Web::BrowserMode::LIGHT)
+  #   page = browser.goto("https://example.com")
+  #   puts page.markdown
+  #   browser.close
+  class AgentBrowser
+    attr_reader :mode, :timeout
+
+    # runner: injectable process runner (object responding to
+    #   run(argv, timeout:) -> [stdout, stderr, status_int]). Tests inject a
+    #   fake; production uses the real Open3-based runner below.
+    # binary: explicit binary path override (skips auto-resolution).
+    def initialize(mode: BrowserMode::LIGHT, timeout: 30, runner: nil, binary: nil)
+      @mode = mode
+      @timeout = timeout
+      @runner = runner || RealRunner.new
+      @binary = binary || Binary.resolve!
+    end
+
+    # Binary path resolved at construction (parity with the other SDKs).
+    def binary_path
+      @binary
+    end
+
+    # Navigate + extract. wait_for: CSS selector (render mode).
+    def goto(url, wait_for: nil)
+      argv = [@binary, "goto", url, "--mode", @mode]
+      argv.push("--wait-for", wait_for) if wait_for
+      stdout, stderr, status = @runner.run(argv, timeout: @timeout)
+      raise NavigationError, "b4n1web timed out after #{@timeout}s" if status.nil?
+      unless status.zero?
+        raise NavigationError, "b4n1web exited #{status}: #{stderr.to_s.strip}"
+      end
+
+      Page.parse(url, stdout)
+    end
+
+    # Execute JavaScript in the page context, return raw result string.
+    def evaluate(url, js)
+      argv = [@binary, "evaluate", url, js]
+      stdout, stderr, status = @runner.run(argv, timeout: @timeout)
+      raise NavigationError, "b4n1web timed out after #{@timeout}s" if status.nil?
+      unless status.zero?
+        raise NavigationError, "b4n1web exited #{status}: #{stderr.to_s.strip}"
+      end
+
+      stdout.to_s.strip
+    end
+
+    # The binary is stateless: close is a no-op kept for API parity.
+    def close; end
+
+    # Default runner: Open3 with hard timeout. On timeout the whole process
+    # GROUP is killed (the binary spawns Chromium children that inherit
+    # stdout; killing only the leader would leave them holding the pipe and
+    # the readers below would block past the timeout) and status is nil
+    # (so callers raise NavigationError). The group is also released after a
+    # NORMAL exit so a lingering descendant can never hang the reads (parity
+    # with the Go SDK's cmd.WaitDelay).
+    class RealRunner
+      def run(argv, timeout:)
+        stdout = +""
+        stderr = +""
+        status = nil
+        Open3.popen3(*argv, pgroup: true) do |pin, pout, perr, wait_thr|
+          pid = wait_thr.pid
+          reader = Thread.new { pout.read }
+          err_reader = Thread.new { perr.read }
+          begin
+            Timeout.timeout(timeout) { status = wait_thr.value.exitstatus }
+          rescue Timeout::Error
+            status = nil
+          end
+          # Leader done (exit or timeout): kill the whole group so no
+          # descendant keeps stdout/stderr open and blocks the drains.
+          begin
+            Process.kill("KILL", -pid) # negative pid = whole process group
+          rescue Errno::ESRCH, Errno::EPERM
+            Process.kill("KILL", pid) rescue nil
+          end
+          await_group_gone(pid)
+          stdout = drain(reader)
+          stderr = drain(err_reader)
+          pin.close rescue nil
+        end
+        [stdout, stderr, status]
+      end
+
+      private
+
+      # Join with a hard bound: after the group kill the pipes hit EOF
+      # immediately; a pathological holder cannot hang the SDK.
+      def drain(thread, seconds: 2)
+        return thread.value if thread.join(seconds)
+        thread.kill
+        +""
+      end
+
+      # Signal delivery is asynchronous: after the KILL above the group is
+      # signalled, not necessarily dead yet. Wait (bounded) until the group
+      # is actually gone so callers get a deterministic "dead on return"
+      # contract (parity with Go's cmd.WaitDelay). A killed orphan that is
+      # still awaiting reaping answers kill(0, ...) — the bound keeps this
+      # honest under any load.
+      def await_group_gone(pgid, seconds: 2)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + seconds
+        loop do
+          begin
+            Process.kill(0, -pgid)
+          rescue Errno::ESRCH
+            return
+          end
+          return if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+          sleep 0.01
+        end
+      end
+    end
+  end
+end

data/lib/b4n1web/binary.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+require_relative "errors"
+
+module B4n1Web
+  # Resolves the b4n1web binary. Order mirrors the Python/JS/C#/Java SDKs:
+  #   1. B4N1WEB_BIN_PATH (explicit override, must exist + be executable)
+  #   2. bundled binary shipped inside the gem (lib/b4n1web/bin/*)
+  #   well-known user/system locations
+  #   4. PATH scan
+  module Binary
+    PLATFORM_BINARIES = {
+      ["linux", "x86_64"]  => "b4n1web-linux-amd64",
+      ["linux", "aarch64"] => "b4n1web-linux-arm64",
+      ["linux", "i686"]    => "b4n1web-linux-ia32",
+      ["darwin", "x86_64"] => "b4n1web-macos-x64",
+      ["darwin", "arm64"]  => "b4n1web-macos-arm64",
+      ["mingw", "x64"]     => "b4n1web-windows-amd64.exe",
+      ["mswin", "x64"]     => "b4n1web-windows-amd64.exe"
+    }.freeze
+
+    module_function
+
+    def platform_binary_name
+      os = RbConfig::CONFIG["host_os"]
+      arch = RbConfig::CONFIG["host_cpu"]
+      arch = "x86_64" if arch == "amd64"
+      arch = "i686" if arch == "i386"
+      plat = case os
+             when /linux/ then "linux"
+             when /darwin|mac os/ then "darwin"
+             when /mingw|cygwin/ then "mingw"
+             when /mswin|windows/ then "mswin"
+             end
+      return nil unless plat
+      PLATFORM_BINARIES[[plat, arch]]
+    end
+
+    # Returns the absolute path of a runnable b4n1web binary or nil.
+    def resolve
+      env = ENV["B4N1WEB_BIN_PATH"]
+      return env if env && File.file?(env) && File.executable?(env)
+
+      name = platform_binary_name
+      if name
+        bundled = File.expand_path(File.join(__dir__, "bin", name))
+        return bundled if File.file?(bundled) && File.executable?(bundled)
+      end
+
+      candidates = []
+      candidates << ENV["B4N1WEB_BINARY"] if ENV["B4N1WEB_BINARY"]
+      home = Dir.home
+      candidates << File.join(home, ".local", "bin", "b4n1web")
+      candidates << File.join(home, ".b4n1web", "bin", "b4n1web")
+      candidates << "/usr/local/bin/b4n1web"
+      candidates << "/usr/bin/b4n1web"
+      ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).each do |dir|
+        candidates << File.join(dir, "b4n1web")
+      end
+
+      candidates.compact.find { |p| File.file?(p) && File.executable?(p) }
+    end
+
+    # Same as resolve but raises loudly (no silent nil).
+    def resolve!
+      resolve || raise(BinaryNotFoundError,
+                       "b4n1web binary not found. Install it (curl -sL " \
+                       "https://raw.githubusercontent.com/B4N1-com/b4n1-web/" \
+                       "master/scripts/install.sh | bash) or set B4N1WEB_BIN_PATH.")
+    end
+  end
+end

data/lib/b4n1web/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module B4n1Web
+  class Error < StandardError; end
+
+  # Raised when no b4n1web binary can be resolved (bundled/system/PATH).
+  class BinaryNotFoundError < Error; end
+
+  # Raised when the binary exits non-zero or times out.
+  class NavigationError < Error; end
+end

data/lib/b4n1web/page.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "json"
+
+module B4n1Web
+  # Structured page data returned by the b4n1web binary.
+  class Page
+    attr_reader :url, :markdown, :links, :screenshot
+
+    def initialize(url:, markdown:, links:, screenshot: nil)
+      @url = url
+      @markdown = markdown
+      @links = links
+      @screenshot = screenshot
+    end
+
+    # Parses the binary's text protocol:
+    #   URL: <url>
+    #   Markdown:
+    #   <free-form markdown lines...>
+    #   Links: ["https://...", ...]
+    #   Screenshot: <path>            (optional)
+    def self.parse(url, output)
+      markdown = +""
+      links = []
+      screenshot = nil
+      in_markdown = false
+
+      output.to_s.each_line do |line|
+        line = line.chomp
+        if line.start_with?("URL:")
+          next
+        elsif line.start_with?("Markdown:")
+          in_markdown = true
+          rest = line.delete_prefix("Markdown:").strip
+          markdown << "#{rest}\n" unless rest.empty?
+        elsif line.start_with?("Links:")
+          in_markdown = false
+          links = JSON.parse(line.delete_prefix("Links:").strip) || []
+        elsif line.start_with?("Screenshot:")
+          in_markdown = false
+          shot = line.delete_prefix("Screenshot:").strip
+          screenshot = shot.empty? ? nil : shot
+        else
+          markdown << "#{line}\n" if in_markdown
+        end
+      end
+
+      new(url: url, markdown: markdown.strip, links: links, screenshot: screenshot)
+    end
+
+    # Main content heuristics: drop the first two lines (title + empty line).
+    def get_main_content
+      lines = markdown.split("\n")
+      content = lines.length > 2 ? lines[2..] : lines
+      content.join("\n").strip
+    end
+
+    def find_links_by_text(text)
+      return [] if text.nil? || text.empty?
+      needle = text.downcase
+      links.select { |link| link.downcase.include?(needle) }
+    end
+  end
+end

data/lib/b4n1web/version.rb

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

data/lib/b4n1web.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "b4n1web/version"
+require_relative "b4n1web/errors"
+require_relative "b4n1web/binary"
+require_relative "b4n1web/page"
+require_relative "b4n1web/agent_browser"
+
+# B4n1Web Ruby SDK — ultra-lightweight agentic browser for AI agents.
+#
+#   require "b4n1web"
+#   browser = B4n1Web::AgentBrowser.new
+#   page = browser.goto("https://example.com")
+#   puts page.markdown
+#   browser.close
+module B4n1Web
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: b4n1-web
+version: !ruby/object:Gem::Version
+  version: 0.16.0
+platform: ruby
+authors:
+- Bani Montoya
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-10-20 00:00:00.000000000 Z
+dependencies: []
+description: Ultra-lightweight headless browser with bundled binary for AI agents.
+  Supports Light/JS/Render modes.
+email:
+- b4n1@b4n1.com
+executables:
+- b4n1web
+extensions: []
+extra_rdoc_files: []
+files:
+- EULA.txt
+- LICENSE
+- README.md
+- bin/b4n1web
+- lib/b4n1web.rb
+- lib/b4n1web/agent_browser.rb
+- lib/b4n1web/binary.rb
+- lib/b4n1web/errors.rb
+- lib/b4n1web/page.rb
+- lib/b4n1web/version.rb
+homepage: https://b4n1.com
+licenses:
+- BUSL-1.1
+metadata:
+  homepage_uri: https://b4n1.com
+  source_code_uri: https://github.com/B4N1-com/b4n1-web
+  changelog_uri: https://github.com/B4N1-com/b4n1-web/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/B4N1-com/b4n1-web/issues
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.5
+signing_key: 
+specification_version: 4
+summary: B4n1Web - Agentic Browser Engine for AI agents
+test_files: []