runbox 1.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 662927e34aedb615bcd9f472fd2d2841c75c0e4bc1cca64ef4122d46402a7acb
+  data.tar.gz: a2d0d12e759f2417194f22c8b4a6747c6a45bd66e1c0c50d629024924738f92e
+SHA512:
+  metadata.gz: 77ef8ccb39538cd98d3d5f95c62dc5f615e2204100c3a098bc896f714d70cae82b77282ab6ae329eb868bd311797ba1dbd61c7aa012cb3bc9594588a47c7a4df
+  data.tar.gz: ddb7f6e43783578a936cffb783965b4da7b48d2b5860517a93b5d9d633c54827d917aaeb9888996a02474fe58d227545ff414517bab3af0231a40db7512d1d9b

data/CHANGELOG.md

@@ -0,0 +1,148 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.2.1] - 2025-12-17
+
+### Changed
+
+- **Shell image updated**: Added bats-core (Bash Automated Testing System) to the shell execution environment for bash script testing support.
+
+## [1.2.0] - 2025-12-11
+
+### Breaking Changes
+
+- **Renamed `entrypoint` to `run_command`** in `run()` method.
+  - The `entrypoint` parameter (file path) is removed.
+  - New `run_command` parameter accepts a full shell command string.
+  - Example: `run_command: "python main.py"` instead of `entrypoint: "main.py"`.
+
+### Added
+
+- **`run_command` support**: Execute arbitrary shell commands (e.g. `pytest tests/`, `bundle exec rails test`).
+
+### Migration Guide
+
+**Before:**
+```ruby
+client.run(
+  entrypoint: "main.py",
+  # ...
+)
+```
+
+**After:**
+```ruby
+client.run(
+  run_command: "python main.py",
+  # ...
+)
+```
+
+## [1.1.0] - 2025-12-10
+
+### Added
+
+- **`new_dependencies` parameter** in `run()` method: Install dependencies on-the-fly before code execution
+  - Python: `["requests==2.31.0", "pytest"]`
+  - Ruby: `["rake", "rspec"]`
+  - Shell: `["curl", "jq", "git"]` (uses apk)
+- **`packages` field** in `Result`: Returns updated package list when dependencies are installed
+  - Only included when `new_dependencies` were provided
+  - Hash of package names to versions
+
+### Example
+
+```ruby
+# Install dependencies and run code
+result = client.run(
+  container_id: container_id,
+  files: [{ path: "main.py", content: "import requests; print(requests.__version__)" }],
+  entrypoint: "main.py",
+  new_dependencies: ["requests==2.31.0"]
+)
+
+puts result.packages  # {"pip"=>"23.0.1", "requests"=>"2.31.0", ...}
+```
+
+## [1.0.0] - 2025-12-10
+
+### Breaking Changes
+
+- **New API workflow**: The client now uses a two-step `setup()` + `run()` workflow instead of a single `run()` call
+- `run()` method signature changed:
+  - Now requires `container_id` (from `setup()` response) instead of `identifier` and `language`
+  - Removed `memory` and `network_allow` parameters (these are now in `setup()`)
+- `Result` object no longer includes `container_id` and `cached` fields (these are now in `SetupResult`)
+
+### Added
+
+- **`setup()` method**: Creates or reuses a container and returns environment information
+  - Returns `SetupResult` with `container_id`, `cached?`, and `environment_snapshot`
+  - `environment_snapshot` includes OS name/version, runtime name/version, and installed packages
+- **`SetupResult` class**: New result object for `setup()` responses
+- **`EnvironmentSnapshot` class**: Contains detailed environment information
+  - `os_name`, `os_version`: Operating system details
+  - `runtime_name`, `runtime_version`: Runtime details (e.g., Python 3.11.6)
+  - `packages`: Hash of installed package names and versions
+- **`NotFoundError`**: New error class for 404 responses (e.g., container not found)
+
+### Changed
+
+- Renamed `ExecutionError` to `RunError` to match new terminology
+- Updated error handling to include 404 Not Found responses
+- `run()` method is now focused solely on code execution in pre-setup containers
+
+### Migration Guide
+
+**Before (v0.1.0):**
+```ruby
+result = client.run(
+  identifier: "session-123",
+  language: "python",
+  files: [{ path: "main.py", content: "print('hi')" }],
+  entrypoint: "main.py"
+)
+
+puts result.container_id  # "runbox-session-123-python"
+puts result.cached?       # true/false
+```
+
+**After (v1.0.0):**
+```ruby
+# Step 1: Setup container
+setup = client.setup(
+  identifier: "session-123",
+  language: "python"
+)
+
+puts setup.container_id  # "runbox-session-123-python"
+puts setup.cached?       # true/false
+puts setup.environment_snapshot.runtime_version  # "3.11.6"
+
+# Step 2: Run code
+result = client.run(
+  container_id: setup.container_id,
+  files: [{ path: "main.py", content: "print('hi')" }],
+  entrypoint: "main.py"
+)
+
+# Note: result no longer has container_id or cached fields
+```
+
+## [0.1.0] - 2024-12-01
+
+### Added
+
+- Initial release
+- `run()` method for executing code in isolated containers
+- Support for Python, Ruby, and Shell languages
+- Container reuse via identifiers
+- Environment variables, timeouts, memory limits, network allowlisting
+- `delete_containers()` method for cleanup
+- `health()` method for health checks
+- Comprehensive error handling
+- Configuration via environment variables or config block

data/README.md

@@ -0,0 +1,285 @@
+## README.md
+
+# Runbox Ruby Client
+
+Official Ruby client for [Runbox](https://github.com/anywaye/runbox) - a fast, secure API for running code in isolated containers.
+
+[![Gem Version](https://badge.fury.io/rb/runbox.svg)](https://badge.fury.io/rb/runbox)
+[![CI](https://github.com/anywaye/runbox-rb/actions/workflows/ci.yml/badge.svg)](https://github.com/anywaye/runbox-rb/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "runbox"
+```
+
+Or install directly:
+
+```bash
+gem install runbox
+```
+
+## Quick Start
+
+```ruby
+require "runbox"
+
+# Configure (or use environment variables)
+Runbox.configure do |config|
+  config.url = "http://localhost:8080"
+  config.api_key = "your-api-key"
+end
+
+# Create a client
+client = Runbox::Client.new
+
+# Step 1: Set up a container and get environment info
+setup = client.setup(
+  identifier: "my-session",
+  language: "python"
+)
+
+puts setup.container_id  # => "runbox-my-session-python"
+puts setup.environment_snapshot.runtime_version  # => "3.11.6"
+puts setup.environment_snapshot.packages["requests"]  # => "2.31.0"
+
+# Step 2: Run code in the container
+result = client.run(
+  container_id: setup.container_id,
+  files: [{ path: "main.py", content: "print('Hello!')" }],
+  run_command: "python main.py"
+)
+
+puts result.stdout  # => "Hello!\n"
+puts result.success?  # => true
+```
+
+## Configuration
+
+### Using Environment Variables
+
+```bash
+export RUNBOX_URL=http://localhost:8080
+export RUNBOX_API_KEY=your-api-key
+```
+
+### Using Configuration Block
+
+```ruby
+Runbox.configure do |config|
+  config.url = "http://localhost:8080"
+  config.api_key = "your-api-key"
+  config.timeout = 60  # HTTP timeout
+end
+```
+
+### Per-Client Configuration
+
+```ruby
+client = Runbox::Client.new(
+  url: "http://localhost:8080",
+  api_key: "your-api-key"
+)
+```
+
+## Usage
+
+### Setting Up a Container
+
+```ruby
+setup = client.setup(
+  identifier: "session-123",
+  language: "python",
+  env: { "API_KEY" => "secret" },  # Optional: set environment variables
+  memory: "512m",                   # Optional: memory limit
+  network_allow: ["api.stripe.com"] # Optional: allowed network destinations
+)
+
+# Access environment information
+puts setup.container_id  # => "runbox-session-123-python"
+puts setup.cached?       # => false (true if container was reused)
+
+env = setup.environment_snapshot
+puts env.os_name          # => "debian"
+puts env.os_version       # => "12"
+puts env.runtime_name     # => "python"
+puts env.runtime_version  # => "3.11.6"
+puts env.packages         # => {"pip" => "23.0.1", "requests" => "2.31.0", ...}
+```
+
+### Running Code
+
+```ruby
+result = client.run(
+  container_id: "runbox-session-123-python",
+  files: [{ path: "main.py", content: "print('Hello!')" }],
+  run_command: "python main.py",
+  env: { "DEBUG" => "true" },  # Optional: runtime environment variables
+  timeout: 30                   # Optional: execution timeout in seconds
+)
+
+puts result.success?          # => true
+puts result.exit_code         # => 0
+puts result.stdout            # => "Hello!\n"
+puts result.stderr            # => ""
+puts result.execution_time_ms # => 42
+puts result.timeout?          # => false
+```
+
+### Installing Dependencies On-The-Fly
+
+Install new dependencies before running code:
+
+```ruby
+# Python example
+result = client.run(
+  container_id: container_id,
+  files: [{ path: "main.py", content: "import requests; print(requests.__version__)" }],
+  run_command: "python main.py",
+  new_dependencies: ["requests==2.31.0", "pytest"]
+)
+
+puts result.packages  # => {"pip"=>"23.0.1", "requests"=>"2.31.0", "pytest"=>"7.4.0", ...}
+
+# Ruby example
+result = client.run(
+  container_id: container_id,
+  files: [{ path: "main.rb", content: "require 'rake'; puts Rake::VERSION" }],
+  run_command: "ruby main.rb",
+  new_dependencies: ["rake", "rspec"]
+)
+
+# Shell example (uses apk)
+result = client.run(
+  container_id: container_id,
+  files: [{ path: "script.sh", content: "#!/bin/sh\ncurl --version" }],
+  run_command: "sh script.sh",
+  new_dependencies: ["curl", "jq", "git"]
+)
+```
+
+**Note:** The `packages` field is only included in the result when `new_dependencies` are provided.
+
+### Cleanup Containers
+
+```ruby
+deleted = client.delete_containers("session-123")
+puts deleted  # => ["runbox-session-123-python"]
+```
+
+### Check Health
+
+```ruby
+health = client.health
+puts health[:status]  # => "healthy"
+puts health[:version] # => "1.0.0"
+```
+
+## API Reference
+
+### `client.setup(identifier:, language:, **options)`
+
+Set up a container and get environment information.
+
+**Parameters:**
+- `identifier` (String, required): Unique identifier for container reuse
+- `language` (String, required): Programming language (`"python"`, `"ruby"`, `"shell"`)
+- `env` (Hash, optional): Environment variables to set
+- `timeout` (Integer, optional): Default timeout in seconds
+- `memory` (String, optional): Memory limit (e.g., `"256m"`, `"1g"`)
+- `network_allow` (Array<String>, optional): Allowed network destinations
+
+**Returns:** `SetupResult` with:
+- `container_id`: Container ID to use in `run()` calls
+- `cached?`: Whether container was reused
+- `environment_snapshot`: Environment information (OS, runtime, packages)
+
+### `client.run(container_id:, files:, run_command:, **options)`
+
+Run code in a container that was set up via `setup()`.
+
+**Parameters:**
+- `container_id` (String, required): Container ID from `setup()` response
+- `files` (Array<Hash>, required): Files to write before running
+- `run_command` (String, required): Command to run
+- `env` (Hash, optional): Runtime environment variables
+- `timeout` (Integer, optional): Execution timeout in seconds
+
+**Returns:** `Result` with:
+- `success?`: Whether run succeeded (exit code 0)
+- `exit_code`: Process exit code
+- `stdout`: Standard output
+- `stderr`: Standard error
+- `execution_time_ms`: Execution time in milliseconds
+- `timeout?`: Whether run timed out
+
+## Error Handling
+
+```ruby
+begin
+  setup = client.setup(identifier: "test", language: "python")
+  result = client.run(
+    container_id: setup.container_id,
+    files: [{ path: "main.py", content: "print('hi')" }],
+    run_command: "python main.py"
+  )
+rescue Runbox::AuthenticationError => e
+  puts "Invalid API key"
+rescue Runbox::NotFoundError => e
+  puts "Container not found (did you call setup first?)"
+rescue Runbox::ValidationError => e
+  puts "Invalid request: #{e.message}"
+rescue Runbox::RunError => e
+  puts "Run failed: #{e.message}"
+rescue Runbox::ConnectionError => e
+  puts "Could not connect to Runbox"
+end
+```
+
+## Development
+
+### Running Tests
+
+```bash
+bundle install
+bundle exec rake test
+```
+
+### Running Integration Tests
+
+Integration tests require a running Runbox server:
+
+```bash
+# Start Runbox server (in another terminal)
+cd ../runbox
+docker-compose up
+
+# Run integration tests
+export RUNBOX_URL=http://localhost:8080
+export RUNBOX_API_KEY=your-api-key
+ruby examples/integration_test.rb
+```
+
+### Linting
+
+```bash
+bundle exec rubocop
+```
+
+### CI/CD
+
+- **CI**: Runs on every push and PR
+  - Tests on Ruby 3.1, 3.2, 3.3
+  - Linting with RuboCop
+  - Integration tests against live Runbox server
+
+- **CD**: Publishes to RubyGems on version tags
+  - Create a tag: `git tag v1.0.0 && git push --tags`
+  - Requires `RUBYGEMS_API_KEY` secret in GitHub
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.

data/lib/runbox/client.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Runbox
+  class Client
+    attr_reader :url, :api_key
+
+    def initialize(url: nil, api_key: nil, timeout: nil, open_timeout: nil)
+      config = Runbox.configuration
+      @url = url || config.url
+      @api_key = api_key || config.api_key
+      @timeout = timeout || config.timeout
+      @open_timeout = open_timeout || config.open_timeout
+
+      validate_configuration!
+    end
+
+    # Set up a container and get environment information
+    #
+    # @param identifier [String] Unique identifier for container reuse
+    # @param language [String] Programming language (python, ruby, shell)
+    # @param env [Hash] Environment variables to set
+    # @param timeout [Integer] Default timeout in seconds
+    # @param memory [String] Memory limit (e.g., "256m")
+    # @param network_allow [Array<String>] Allowed network destinations
+    # @return [SetupResult] Setup result with container_id and environment_snapshot
+    def setup(identifier:, language:, env: {}, timeout: nil, memory: nil, network_allow: nil)
+      payload = {
+        identifier: identifier,
+        language: language,
+        env: env
+      }
+
+      payload[:timeout] = timeout if timeout
+      payload[:memory] = memory if memory
+      payload[:network_allow] = network_allow if network_allow
+
+      response = post("/v1/setup", payload)
+      SetupResult.new(response)
+    end
+
+    # Run code in a container that was set up via setup()
+    #
+    # @param container_id [String] Container ID from setup response
+    # @param files [Array<Hash>] Files to write before running
+    # @param run_command [String] Command to execute
+    # @param env [Hash] Runtime environment variables
+    # @param timeout [Integer] Timeout in seconds
+    # @param new_dependencies [Array<String>] New dependencies to install before running
+    # @return [Result] Run result with stdout, stderr, exit_code, and optional packages
+    def run(container_id:, files:, run_command:, env: {}, timeout: nil, new_dependencies: nil)
+      payload = {
+        container_id: container_id,
+        files: normalize_files(files),
+        run_command: run_command,
+        env: env
+      }
+
+      payload[:timeout] = timeout if timeout
+      payload[:new_dependencies] = new_dependencies if new_dependencies
+
+      response = post("/v1/run", payload)
+      Result.new(response)
+    end
+
+    def delete_containers(identifier)
+      response = delete("/v1/containers/#{identifier}")
+      response["deleted"] || []
+    end
+
+    def health
+      response = get("/v1/health", auth: false)
+      {
+        status: response["status"],
+        version: response["version"]
+      }
+    end
+
+    private
+
+    def validate_configuration!
+      raise ConfigurationError, "URL is required" if @url.nil? || @url.empty?
+      raise ConfigurationError, "API key is required" if @api_key.nil? || @api_key.empty?
+    end
+
+    def normalize_files(files)
+      files.map do |file|
+        if file.is_a?(Hash)
+          { path: file[:path] || file["path"], content: file[:content] || file["content"] }
+        else
+          file
+        end
+      end
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: @url) do |f|
+        f.request :json
+        f.response :json
+        f.options.timeout = @timeout
+        f.options.open_timeout = @open_timeout
+      end
+    end
+
+    def get(path, auth: true)
+      response = connection.get(path) do |req|
+        req.headers["Authorization"] = "Bearer #{@api_key}" if auth
+      end
+      handle_response(response)
+    rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
+      raise ConnectionError, "Failed to connect to Runbox: #{e.message}"
+    end
+
+    def post(path, body)
+      response = connection.post(path) do |req|
+        req.headers["Authorization"] = "Bearer #{@api_key}"
+        req.body = body
+      end
+      handle_response(response)
+    rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
+      raise ConnectionError, "Failed to connect to Runbox: #{e.message}"
+    end
+
+    def delete(path)
+      response = connection.delete(path) do |req|
+        req.headers["Authorization"] = "Bearer #{@api_key}"
+      end
+      handle_response(response)
+    rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
+      raise ConnectionError, "Failed to connect to Runbox: #{e.message}"
+    end
+
+    def handle_response(response)
+      case response.status
+      when 200..299
+        response.body
+      when 401
+        raise AuthenticationError, "Invalid API key"
+      when 404
+        body = response.body || {}
+        raise NotFoundError, body["detail"] || "Container not found"
+      when 400
+        body = response.body || {}
+        raise ValidationError.new(body["detail"] || "Validation error", details: body)
+      when 422
+        body = response.body || {}
+        raise ValidationError.new(body["detail"] || "Validation error", details: body)
+      when 500..599
+        body = response.body || {}
+        raise RunError, body["detail"] || "Run failed"
+      else
+        raise Error, "Unexpected response: #{response.status}"
+      end
+    end
+  end
+end

data/lib/runbox/configuration.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Runbox
+  class Configuration
+    attr_accessor :url, :api_key, :timeout, :open_timeout
+
+    def initialize
+      @url = ENV.fetch("RUNBOX_URL", "http://localhost:8080")
+      @api_key = ENV.fetch("RUNBOX_API_KEY", nil)
+      @timeout = 120 # HTTP timeout (longer than execution timeout)
+      @open_timeout = 10
+    end
+
+    def validate!
+      raise ConfigurationError, "API key is required" if api_key.nil? || api_key.empty?
+      raise ConfigurationError, "URL is required" if url.nil? || url.empty?
+    end
+  end
+end
+

data/lib/runbox/error.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Runbox
+  # Base error class
+  class Error < StandardError; end
+
+  # Configuration errors
+  class ConfigurationError < Error; end
+
+  # Connection errors
+  class ConnectionError < Error; end
+
+  # Authentication errors (401)
+  class AuthenticationError < Error; end
+
+  # Not found errors (404)
+  class NotFoundError < Error; end
+
+  # Validation errors (400)
+  class ValidationError < Error
+    attr_reader :details
+
+    def initialize(message, details: nil)
+      super(message)
+      @details = details
+    end
+  end
+
+  # Run errors (500)
+  class RunError < Error; end
+
+  # Timeout errors
+  class TimeoutError < Error; end
+end

data/lib/runbox/result.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Runbox
+  class Result
+    attr_reader :success, :exit_code, :stdout, :stderr,
+                :execution_time_ms, :timeout_exceeded, :packages
+
+    def initialize(data)
+      @success = data["success"] || data[:success]
+      @exit_code = data["exit_code"] || data[:exit_code]
+      @stdout = data["stdout"] || data[:stdout] || ""
+      @stderr = data["stderr"] || data[:stderr] || ""
+      @execution_time_ms = data["execution_time_ms"] || data[:execution_time_ms]
+      @timeout_exceeded = data["timeout_exceeded"] || data[:timeout_exceeded] || false
+      @packages = data["packages"] || data[:packages]
+    end
+
+    def success?
+      @success == true
+    end
+
+    def failed?
+      !success?
+    end
+
+    def timeout?
+      @timeout_exceeded == true
+    end
+
+    def to_h
+      hash = {
+        success: @success,
+        exit_code: @exit_code,
+        stdout: @stdout,
+        stderr: @stderr,
+        execution_time_ms: @execution_time_ms,
+        timeout_exceeded: @timeout_exceeded
+      }
+      hash[:packages] = @packages if @packages
+      hash
+    end
+  end
+end

data/lib/runbox/setup_result.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Runbox
+  class SetupResult
+    attr_reader :container_id, :cached, :environment_snapshot
+
+    def initialize(data)
+      @container_id = data["container_id"] || data[:container_id]
+      @cached = data["cached"] || data[:cached] || false
+      @environment_snapshot = EnvironmentSnapshot.new(
+        data["environment_snapshot"] || data[:environment_snapshot] || {}
+      )
+    end
+
+    def cached?
+      @cached == true
+    end
+
+    def to_h
+      {
+        container_id: @container_id,
+        cached: @cached,
+        environment_snapshot: @environment_snapshot.to_h
+      }
+    end
+  end
+
+  class EnvironmentSnapshot
+    attr_reader :os_name, :os_version, :runtime_name, :runtime_version, :packages
+
+    def initialize(data)
+      @os_name = data["os_name"] || data[:os_name]
+      @os_version = data["os_version"] || data[:os_version]
+      @runtime_name = data["runtime_name"] || data[:runtime_name]
+      @runtime_version = data["runtime_version"] || data[:runtime_version]
+      @packages = data["packages"] || data[:packages] || {}
+    end
+
+    def to_h
+      {
+        os_name: @os_name,
+        os_version: @os_version,
+        runtime_name: @runtime_name,
+        runtime_version: @runtime_version,
+        packages: @packages
+      }
+    end
+  end
+end

data/lib/runbox/version.rb

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

data/lib/runbox.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "runbox/version"
+require_relative "runbox/configuration"
+require_relative "runbox/error"
+require_relative "runbox/result"
+require_relative "runbox/setup_result"
+require_relative "runbox/client"
+
+module Runbox
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end
+

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: runbox
+version: !ruby/object:Gem::Version
+  version: 1.2.1
+platform: ruby
+authors:
+- Anywaye
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.21'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.19'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.19'
+description: Official Ruby client for Runbox, a fast and secure API for running code
+  in isolated containers.
+email:
+- hello@anywaye.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- lib/runbox.rb
+- lib/runbox/client.rb
+- lib/runbox/configuration.rb
+- lib/runbox/error.rb
+- lib/runbox/result.rb
+- lib/runbox/setup_result.rb
+- lib/runbox/version.rb
+homepage: https://github.com/anywaye/runbox-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/anywaye/runbox-rb
+  source_code_uri: https://github.com/anywaye/runbox-rb
+  changelog_uri: https://github.com/anywaye/runbox-rb/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Ruby client for Runbox - secure code execution API
+test_files: []