sprites-ruby 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 696d67a3d2015a55e8eb2e5b6179e37b2594eecbd49c4f355000fc246e45827b
-  data.tar.gz: db6806ee207f88f94a251af9a5681d6c68b2910aa9b5f54d2db627f07bc55209
+  metadata.gz: 5da75311f037ca5acfc55a350835e258e792f06221d4f9fab135e7ba567676b0
+  data.tar.gz: c8ef0d1914539b8e618dea6aad2bf9641269d5396397950d1048a9295fc399f7
 SHA512:
-  metadata.gz: fcd1a087a9373e8c3a4d2cd82f2acd6070e5a78645c8b0e893310f2913585f805f0f4486d9a6475d1a3e4cd2dc271893af8b3b175deddb0a4bea15a12ae8d897
-  data.tar.gz: 1507c816cf3081bd407e391ab067160d04e4dd35cfd25a637a4e80ac7bad0bfecb880bb6f690f5058b4c2782980e99ad90644e87db5eb191039d11aff86d2a74
+  metadata.gz: cd6283f8bee73c8a9adcb7a039cef763d2109e980da95fd4ec9eccd852af89a89b4b894b5299c2d76afa87edb2bbb61edbe3c4bab5d17dab8169c0d9b037d523
+  data.tar.gz: 9e96fe5d15b8f974fce96a1ced6740aa83ba6a77f78abb7e2a682668b29c03b49c4cd7b4f5f7938c1c3073b1e84e5be9b37ce44864be736d1442f3bf9a887e14

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## 0.2.1
+
+- Fix parsing error for empty API responses
+
+## 0.2.0
+
+- Command execution via HTTP (`exec.create`)
+- WebSocket exec for interactive sessions (`run`, `interactive`, `connect`)
+- Session management (`exec.list`, `exec.attach`, `exec.kill`)
+- `wait_until_warm` option for sprite creation
+
+## 0.1.0
+
+- Initial release
+- Sprites CRUD operations
+- Checkpoints (create, list, retrieve, restore)
+- Network policies (retrieve, update)

data/README.md

@@ -1,13 +1,184 @@
-# Sprites Ruby
+# Sprites
 
-Ruby client for the [Sprites](https://sprites.dev) API.
+Ruby client for the [Sprites](https://sprites.dev) API - stateful sandbox environments.
 
 ## Installation
 
+Add this line to your application's Gemfile:
+
 ```ruby
 gem "sprites-ruby"
 ```
 
+## Getting Started
+
+Create a client
+
+```ruby
+client = Sprites::Client.new(token: ENV["SPRITES_TOKEN"])
+```
+
+Or configure globally
+
+```ruby
+Sprites.configure do |config|
+  config.token = ENV["SPRITES_TOKEN"]
+end
+
+client = Sprites::Client.new
+```
+
+## Sprites
+
+Create a sprite
+
+```ruby
+sprite = client.sprites.create(name: "my-sprite")
+```
+
+Create and wait until ready
+
+```ruby
+sprite = client.sprites.create(name: "my-sprite", wait: true)
+```
+
+List sprites
+
+```ruby
+collection = client.sprites.list
+collection.sprites.each { |s| puts s.name }
+```
+
+Get a sprite
+
+```ruby
+sprite = client.sprites.retrieve("my-sprite")
+sprite.status # => "warm"
+```
+
+Update a sprite
+
+```ruby
+sprite = client.sprites.update("my-sprite", url_settings: { auth: "public" })
+```
+
+Delete a sprite
+
+```ruby
+client.sprites.delete("my-sprite")
+```
+
+## Command Execution
+
+Run a command (HTTP, simple)
+
+```ruby
+result = client.exec.create("my-sprite", command: "echo hello")
+result[:output]    # => "hello\n"
+result[:exit_code] # => 0
+```
+
+Run a command (WebSocket, streaming)
+
+```ruby
+result = client.exec.run("my-sprite", ["ls", "-la"])
+result.stdout
+result.stderr
+result.exit_code
+```
+
+Interactive terminal session
+
+```ruby
+client.exec.interactive("my-sprite", ["bash"])
+```
+
+With custom I/O
+
+```ruby
+client.exec.interactive("my-sprite", ["bash"], input: $stdin, output: $stdout)
+```
+
+## Sessions
+
+List active sessions
+
+```ruby
+sessions = client.exec.list("my-sprite")
+sessions.each { |s| puts "#{s[:id]}: #{s[:command]}" }
+```
+
+Attach to a session
+
+```ruby
+client.exec.attach("my-sprite", session_id)
+```
+
+Kill a session
+
+```ruby
+client.exec.kill("my-sprite", session_id)
+```
+
+With a specific signal
+
+```ruby
+client.exec.kill("my-sprite", session_id, signal: "SIGKILL")
+```
+
+## Checkpoints
+
+Create a checkpoint
+
+```ruby
+client.checkpoints.create("my-sprite", comment: "before deploy")
+```
+
+List checkpoints
+
+```ruby
+checkpoints = client.checkpoints.list("my-sprite")
+```
+
+Restore a checkpoint
+
+```ruby
+client.checkpoints.restore("my-sprite", checkpoint_id)
+```
+
+## Network Policies
+
+Get current policy
+
+```ruby
+policy = client.policies.retrieve("my-sprite")
+policy[:egress][:policy] # => "allow-all"
+```
+
+Update policy
+
+```ruby
+client.policies.update("my-sprite", egress: { policy: "block-all" })
+```
+
+## Low-Level WebSocket API
+
+For advanced use cases, use `connect` directly
+
+```ruby
+client.exec.connect("my-sprite", command: ["bash"], tty: true) do |task, session|
+  session.on_stdout { |data| print data }
+  session.on_stderr { |data| $stderr.print data }
+  session.on_exit { |code| puts "Exit: #{code}" }
+
+  task.async do
+    while (line = $stdin.gets)
+      session.write(line)
+    end
+  end
+end
+```
+
 ## Development
 
 ```sh

data/lib/sprites/client.rb

@@ -4,24 +4,63 @@ require "faraday"
 require "json"
 
 module Sprites
+  # HTTP client for the Sprites API.
+  #
+  # @example
+  #   client = Sprites::Client.new(token: "your-token")
+  #   sprite = client.sprites.create(name: "my-sprite")
+  #
   class Client
+    # @return [String] the API token
+    attr_reader :token
+
+    # Create a new client.
+    #
+    # @param token [String, nil] API token (defaults to Sprites.configuration.token)
+    # @param base_url [String, nil] API base URL (defaults to https://api.sprites.dev)
     def initialize(token: nil, base_url: nil)
       @token = token || Sprites.configuration.token
       @base_url = base_url || Sprites.configuration.base_url
     end
 
+    # Access sprite operations.
+    #
+    # @return [Resources::Sprites]
     def sprites
       Resources::Sprites.new(self)
     end
 
+    # Access checkpoint operations.
+    #
+    # @return [Resources::Checkpoints]
     def checkpoints
       Resources::Checkpoints.new(self)
     end
 
+    # Access network policy operations.
+    #
+    # @return [Resources::Policies]
     def policies
       Resources::Policies.new(self)
     end
 
+    # Access command execution operations.
+    #
+    # @return [Resources::Exec]
+    def exec
+      Resources::Exec.new(self)
+    end
+
+    # @return [String] WebSocket URL derived from base URL
+    def websocket_url
+      @base_url.sub(/^http(s?)/) { "ws#{$1}" }
+    end
+
+    # @return [Array<Array<String>>] authorization headers for WebSocket connections
+    def auth_headers
+      [["authorization", "Bearer #{@token}"]]
+    end
+
     def get(path) = handle_response(connection.get(path))
 
     def post(path, body) = handle_response(connection.post(path, body.to_json, "Content-Type" => "application/json"))
@@ -65,7 +104,11 @@ module Sprites
       raise Error, body.strip
     end
 
-    def parse_json(json) = JSON.parse(json, symbolize_names: true)
+    def parse_json(json)
+      return nil if json.to_s.empty?
+
+      JSON.parse(json, symbolize_names: true)
+    end
 
     def parse_ndjson(body) = body.each_line.map { parse_json(it) }
 

data/lib/sprites/collection.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
 module Sprites
+  # Paginated collection of sprites.
   class Collection
-    attr_reader :sprites, :next_continuation_token
+    # @return [Array<Sprite>] sprites in this page
+    attr_reader :sprites
+
+    # @return [String, nil] token for fetching the next page
+    attr_reader :next_continuation_token
 
     def initialize(sprites:, has_more:, next_continuation_token:)
       @sprites = sprites
@@ -10,6 +15,9 @@ module Sprites
       @next_continuation_token = next_continuation_token
     end
 
+    # Check if more pages are available.
+    #
+    # @return [Boolean]
     def has_more?
       @has_more && !@next_continuation_token.nil?
     end

data/lib/sprites/resources/checkpoints.rb

@@ -2,23 +2,45 @@
 
 module Sprites
   module Resources
+    # Checkpoint operations for sprite snapshots.
     class Checkpoints
       def initialize(client)
         @client = client
       end
 
+      # List all checkpoints for a sprite.
+      #
+      # @param sprite_name [String] sprite name
+      # @return [Array<Hash>] checkpoints
       def list(sprite_name)
         @client.get("/v1/sprites/#{sprite_name}/checkpoints")
       end
 
+      # Retrieve a checkpoint by ID.
+      #
+      # @param sprite_name [String] sprite name
+      # @param checkpoint_id [String] checkpoint ID
+      # @return [Hash] checkpoint details
       def retrieve(sprite_name, checkpoint_id)
         @client.get("/v1/sprites/#{sprite_name}/checkpoints/#{checkpoint_id}")
       end
 
+      # Create a new checkpoint.
+      #
+      # @param sprite_name [String] sprite name
+      # @param comment [String, nil] optional comment
+      # @yield [Hash] streaming NDJSON events
+      # @return [Array<Hash>] all events if no block given
       def create(sprite_name, comment: nil, &block)
         @client.post_stream("/v1/sprites/#{sprite_name}/checkpoint", { comment: }, &block)
       end
 
+      # Restore a sprite to a checkpoint.
+      #
+      # @param sprite_name [String] sprite name
+      # @param checkpoint_id [String] checkpoint ID
+      # @yield [Hash] streaming NDJSON events
+      # @return [Array<Hash>] all events if no block given
       def restore(sprite_name, checkpoint_id, &block)
         @client.post_stream("/v1/sprites/#{sprite_name}/checkpoints/#{checkpoint_id}/restore", {}, &block)
       end

data/lib/sprites/resources/exec.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require "async"
+require "async/http/endpoint"
+require "async/websocket/client"
+require "io/console"
+require "io/stream"
+require "uri"
+
+module Sprites
+  module Resources
+    # Command execution on sprites via HTTP and WebSocket.
+    class Exec
+      STREAM_STDIN = 0
+      STREAM_STDOUT = 1
+      STREAM_STDERR = 2
+      STREAM_EXIT = 3
+      STREAM_STDIN_EOF = 4
+
+      def initialize(client)
+        @client = client
+      end
+
+      # Execute a command via HTTP POST (non-streaming).
+      #
+      # @param sprite_name [String] sprite name
+      # @param command [String] command to execute
+      # @return [Hash] result with :exit_code and :output
+      def create(sprite_name, command:)
+        @client.post("/v1/sprites/#{sprite_name}/exec", { command: })
+      end
+
+      # List active exec sessions.
+      #
+      # @param sprite_name [String] sprite name
+      # @return [Array<Hash>] sessions with :id, :command, :tty, :is_active, etc.
+      def list(sprite_name)
+        @client.get("/v1/sprites/#{sprite_name}/exec")
+      end
+
+      # Run a command via WebSocket and return the result (blocking).
+      #
+      # @param sprite_name [String] sprite name
+      # @param command [Array<String>] command and arguments
+      # @param options [Hash] WebSocket options (:cols, :rows, :path)
+      # @return [Result] with stdout, stderr, and exit_code
+      def run(sprite_name, command, **options)
+        stdout = +""
+        stderr = +""
+        exit_code = nil
+
+        connect(sprite_name, command: command, **options) do |_task, session|
+          session.on_stdout { |data| stdout << data }
+          session.on_stderr { |data| stderr << data }
+          session.on_exit { |code| exit_code = code }
+        end
+
+        Result.new(stdout: stdout, stderr: stderr, exit_code: exit_code)
+      end
+
+      # Start an interactive terminal session wired to stdin/stdout.
+      #
+      # @param sprite_name [String] sprite name
+      # @param command [Array<String>] command and arguments
+      # @param input [IO] input stream (default: $stdin)
+      # @param output [IO] output stream (default: $stdout)
+      # @param options [Hash] WebSocket options (:cols, :rows)
+      def interactive(sprite_name, command, input: $stdin, output: $stdout, **options)
+        run_interactive(input: input, output: output) do |block|
+          connect(sprite_name, command: command, tty: true, **options, &block)
+        end
+      end
+
+      # Attach to an existing exec session.
+      #
+      # @param sprite_name [String] sprite name
+      # @param session_id [Integer] session ID from #list
+      # @param input [IO] input stream (default: $stdin)
+      # @param output [IO] output stream (default: $stdout)
+      def attach(sprite_name, session_id, input: $stdin, output: $stdout)
+        run_interactive(input: input, output: output) do |block|
+          connect(sprite_name, session_id: session_id, tty: true, &block)
+        end
+      end
+
+      # Kill an exec session.
+      #
+      # @param sprite_name [String] sprite name
+      # @param session_id [Integer] session ID from #list
+      # @param signal [String, nil] signal to send (default: SIGTERM)
+      # @param timeout [String, nil] timeout waiting for exit (default: 10s)
+      # @yield [Hash] streaming NDJSON events (signal, exited, complete)
+      # @return [Array<Hash>] all events if no block given
+      def kill(sprite_name, session_id, signal: nil, timeout: nil, &block)
+        body = {}
+        body[:signal] = signal if signal
+        body[:timeout] = timeout if timeout
+        @client.post_stream("/v1/sprites/#{sprite_name}/exec/#{session_id}/kill", body, &block)
+      end
+
+      # Connect to a WebSocket exec session.
+      #
+      # Yields the Async task and session for concurrent I/O.
+      #
+      # @param sprite_name [String] sprite name
+      # @param command [Array<String>, nil] command and arguments
+      # @param tty [Boolean] enable TTY mode (default: false)
+      # @param options [Hash] WebSocket options (:session_id, :cols, :rows, :path, :stdin)
+      # @yield [Async::Task, Session] task and session for callbacks
+      #
+      # @example
+      #   client.exec.connect(sprite.name, command: ["bash"], tty: true) do |task, session|
+      #     session.on_stdout { |data| print data }
+      #     task.async do
+      #       while (line = $stdin.gets)
+      #         session.write(line)
+      #       end
+      #     end
+      #   end
+      def connect(sprite_name, command: nil, tty: false, **options, &block)
+        url = build_websocket_url(sprite_name, command, tty: tty, **options)
+        endpoint = Async::HTTP::Endpoint.parse(url, alpn_protocols: ["http/1.1"])
+        headers = Protocol::HTTP::Headers.new
+        headers["authorization"] = "Bearer #{@client.token}"
+
+        Async do |task|
+          Async::WebSocket::Client.connect(endpoint, headers: headers) do |connection|
+            session = Session.new(connection, tty: tty)
+
+            # Run user's block and read loop concurrently
+            task.async { block.call(task, session) }
+            session.read_loop
+          end
+        end
+      end
+
+      private
+
+      def run_interactive(input:, output:)
+        input.raw!
+        stdin = IO::Stream::Buffered.wrap(input)
+
+        yield proc { |task, session|
+          session.on_stdout do |data|
+            output.write(data)
+            output.flush
+          end
+          session.on_stderr do |data|
+            output.write(data)
+            output.flush
+          end
+
+          input_task = task.async do
+            while (char = stdin.read(1))
+              session.write(char)
+            end
+          rescue IOError
+            # Connection closed
+          end
+
+          session.on_exit { |_code| input_task.stop }
+        }
+      ensure
+        input.cooked!
+      end
+
+      def build_websocket_url(sprite_name, command, tty:, session_id: nil, **options)
+        base = "#{@client.websocket_url}/v1/sprites/#{sprite_name}/exec"
+        base = "#{base}/#{session_id}" if session_id
+
+        params = []
+        Array(command).each { |arg| params << ["cmd", arg] } unless session_id
+        params << ["tty", "true"] if tty
+        params << ["stdin", "true"] if options.fetch(:stdin, true)
+        params << ["cols", options[:cols].to_s] if options[:cols]
+        params << ["rows", options[:rows].to_s] if options[:rows]
+        params << ["path", options[:path]] if options[:path]
+
+        query = params.empty? ? "" : "?#{URI.encode_www_form(params)}"
+        "#{base}#{query}"
+      end
+
+      # Result of a blocking command execution.
+      # @!attribute [r] stdout
+      #   @return [String] standard output
+      # @!attribute [r] stderr
+      #   @return [String] standard error
+      # @!attribute [r] exit_code
+      #   @return [Integer] process exit code
+      Result = Data.define(:stdout, :stderr, :exit_code)
+
+      # WebSocket session for interactive command execution.
+      class Session
+        def initialize(connection, tty: false)
+          @connection = connection
+          @tty = tty
+          @callbacks = { stdout: [], stderr: [], exit: [] }
+          @exit_code = nil
+        end
+
+        # @return [Integer, nil] exit code once process exits
+        attr_reader :exit_code
+
+        # Register a callback for stdout data.
+        # @yield [String] stdout data
+        def on_stdout(&block) = @callbacks[:stdout] << block
+
+        # Register a callback for stderr data.
+        # @yield [String] stderr data
+        def on_stderr(&block) = @callbacks[:stderr] << block
+
+        # Register a callback for process exit.
+        # @yield [Integer] exit code
+        def on_exit(&block) = @callbacks[:exit] << block
+
+        # Write data to stdin.
+        # @param data [String] data to write
+        def write(data)
+          if @tty
+            @connection.write(Protocol::WebSocket::BinaryMessage.new(data))
+          else
+            message = [STREAM_STDIN].pack("C") + data
+            @connection.write(Protocol::WebSocket::BinaryMessage.new(message))
+          end
+          @connection.flush
+        end
+
+        # Signal end of stdin (non-TTY mode only).
+        def send_eof
+          return if @tty
+
+          message = [STREAM_STDIN_EOF].pack("C")
+          @connection.write(Protocol::WebSocket::BinaryMessage.new(message))
+          @connection.flush
+        end
+
+        # Close the WebSocket connection.
+        def close
+          @connection.close
+        end
+
+        def read_loop
+          loop do
+            message = @connection.read
+            break unless message
+
+            handle_message(message)
+            break if @exit_code
+          end
+        end
+
+        private
+
+        def handle_message(message)
+          data = message.respond_to?(:buffer) ? message.buffer : message.to_s
+
+          if data.start_with?("{")
+            handle_json_message(JSON.parse(data, symbolize_names: true))
+          elsif @tty
+            @callbacks[:stdout].each { |cb| cb.call(data) }
+          else
+            handle_binary_message(data)
+          end
+        end
+
+        def handle_json_message(parsed)
+          case parsed[:type]
+          when "exit"
+            @exit_code = parsed[:exit_code]
+            @callbacks[:exit].each { |cb| cb.call(@exit_code) }
+          end
+        end
+
+        def handle_binary_message(data)
+          return if data.nil? || data.empty?
+
+          stream_id = data.bytes[0]
+          payload = data[1..]
+
+          case stream_id
+          when STREAM_STDOUT
+            @callbacks[:stdout].each { |cb| cb.call(payload) }
+          when STREAM_STDERR
+            @callbacks[:stderr].each { |cb| cb.call(payload) }
+          when STREAM_EXIT
+            @exit_code = payload.unpack1("C")
+            @callbacks[:exit].each { |cb| cb.call(@exit_code) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sprites/resources/policies.rb

@@ -2,15 +2,25 @@
 
 module Sprites
   module Resources
+    # Network policy operations.
     class Policies
       def initialize(client)
         @client = client
       end
 
+      # Get current network policy for a sprite.
+      #
+      # @param sprite_name [String] sprite name
+      # @return [Hash] policy with :egress settings
       def retrieve(sprite_name)
         @client.get("/v1/sprites/#{sprite_name}/policies")
       end
 
+      # Update network policy for a sprite.
+      #
+      # @param sprite_name [String] sprite name
+      # @param attrs [Hash] policy attributes (:egress)
+      # @return [Hash] updated policy
       def update(sprite_name, **attrs)
         @client.post("/v1/sprites/#{sprite_name}/policies", attrs)
       end

data/lib/sprites/resources/sprites.rb

@@ -2,23 +2,66 @@
 
 module Sprites
   module Resources
+    # Sprite CRUD operations.
     class Sprites
       def initialize(client)
         @client = client
       end
 
+      # List all sprites.
+      #
+      # @return [Collection] paginated collection of sprites
       def list
         @client.get("/v1/sprites") => { sprites:, has_more:, next_continuation_token: }
         sprites = sprites.map(&Sprite)
         Collection.new(sprites:, has_more:, next_continuation_token:)
       end
 
+      # Retrieve a sprite by name.
+      #
+      # @param name [String] sprite name
+      # @return [Sprite]
       def retrieve(name) = @client.get("/v1/sprites/#{name}").then(&Sprite)
 
-      def create(name:) = @client.post("/v1/sprites", { name: }).then(&Sprite)
+      # Create a new sprite.
+      #
+      # @param name [String] sprite name
+      # @param wait [Boolean] block until sprite is warm (default: false)
+      # @param timeout [Integer] seconds to wait for warm status (default: 60)
+      # @return [Sprite]
+      def create(name:, wait: false, timeout: 60)
+        sprite = @client.post("/v1/sprites", { name: }).then(&Sprite)
+        wait ? wait_until_warm(sprite.name, timeout:) : sprite
+      end
+
+      # Poll until a sprite becomes warm.
+      #
+      # @param name [String] sprite name
+      # @param timeout [Integer] seconds to wait (default: 60)
+      # @return [Sprite]
+      # @raise [Error] if timeout is reached
+      def wait_until_warm(name, timeout: 60)
+        deadline = Time.now + timeout
+        loop do
+          sprite = retrieve(name)
+          return sprite if sprite.status == "warm"
+          raise Error, "Timed out waiting for sprite to become warm" if Time.now > deadline
+
+          sleep 0.5
+        end
+      end
 
+      # Update a sprite.
+      #
+      # @param name [String] sprite name
+      # @param attrs [Hash] attributes to update
+      # @return [Sprite]
       def update(name, **attrs) = @client.put("/v1/sprites/#{name}", attrs).then(&Sprite)
 
+      # Delete a sprite.
+      #
+      # @param name [String] sprite name
+      # @return [nil]
       def delete(name) = @client.delete("/v1/sprites/#{name}")
     end
   end

data/lib/sprites/sprite.rb

@@ -1,11 +1,40 @@
 # frozen_string_literal: true
 
 module Sprites
+  # A sprite instance.
   class Sprite
+    # @api private
     def self.to_proc = ->(attrs) { new(**attrs) }
 
-    attr_reader :id, :name, :status, :version, :url, :created_at, :updated_at,
-                :organization, :url_settings, :environment_version
+    # @return [String] unique sprite ID
+    attr_reader :id
+
+    # @return [String] sprite name
+    attr_reader :name
+
+    # @return [String] status ("cold", "warm")
+    attr_reader :status
+
+    # @return [String, nil] sprite version
+    attr_reader :version
+
+    # @return [String] public URL for the sprite
+    attr_reader :url
+
+    # @return [String] creation timestamp
+    attr_reader :created_at
+
+    # @return [String] last update timestamp
+    attr_reader :updated_at
+
+    # @return [String] organization slug
+    attr_reader :organization
+
+    # @return [Hash] URL authentication settings
+    attr_reader :url_settings
+
+    # @return [String, nil] environment version
+    attr_reader :environment_version
 
     def initialize(id:, name:, status:, version:, url:, created_at:, updated_at:,
                    organization:, url_settings:, environment_version:)

data/lib/sprites/version.rb

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

data/lib/sprites.rb

@@ -7,6 +7,7 @@ require_relative "sprites/sprite"
 require_relative "sprites/resources/sprites"
 require_relative "sprites/resources/checkpoints"
 require_relative "sprites/resources/policies"
+require_relative "sprites/resources/exec"
 require_relative "sprites/client"
 
 module Sprites

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sprites-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Ara Hacopian
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: async-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.30'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.30'
 description: Ruby client for the Sprites API - stateful sandbox environments
 email:
 - ara@hacopian.de
@@ -30,6 +44,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - lib/sprites.rb
@@ -37,6 +52,7 @@ files:
 - lib/sprites/collection.rb
 - lib/sprites/configuration.rb
 - lib/sprites/resources/checkpoints.rb
+- lib/sprites/resources/exec.rb
 - lib/sprites/resources/policies.rb
 - lib/sprites/resources/sprites.rb
 - lib/sprites/sprite.rb