e2b 0.2.0 → 0.3.0

data/lib/e2b/models/sandbox_info.rb

@@ -31,6 +31,15 @@ module E2B
       # @return [Hash] Metadata
       attr_reader :metadata
 
+      # @return [String, nil] Current sandbox state
+      attr_reader :state
+
+      # @return [String, nil] Domain where the sandbox is hosted
+      attr_reader :sandbox_domain
+
+      # @return [String, nil] Envd version reported by the control plane
+      attr_reader :envd_version
+
       # Create from API response hash
       #
       # @param data [Hash] API response data
@@ -45,12 +54,16 @@ module E2B
           end_at: parse_time(data["endAt"] || data["end_at"] || data[:endAt]),
           cpu_count: data["cpuCount"] || data["cpu_count"] || data[:cpuCount],
           memory_mb: data["memoryMB"] || data["memory_mb"] || data[:memoryMB],
-          metadata: data["metadata"] || data[:metadata] || {}
+          metadata: data["metadata"] || data[:metadata] || {},
+          state: data["state"] || data[:state],
+          sandbox_domain: data["domain"] || data[:domain],
+          envd_version: data["envdVersion"] || data["envd_version"] || data[:envdVersion]
         )
       end
 
       def initialize(sandbox_id:, template_id:, alias_name: nil, client_id: nil,
-                     started_at: nil, end_at: nil, cpu_count: nil, memory_mb: nil, metadata: {})
+                     started_at: nil, end_at: nil, cpu_count: nil, memory_mb: nil, metadata: {},
+                     state: nil, sandbox_domain: nil, envd_version: nil)
         @sandbox_id = sandbox_id
         @template_id = template_id
         @alias_name = alias_name
@@ -60,12 +73,16 @@ module E2B
         @cpu_count = cpu_count
         @memory_mb = memory_mb
         @metadata = metadata || {}
+        @state = state
+        @sandbox_domain = sandbox_domain
+        @envd_version = envd_version
       end
 
       # Check if sandbox is still running (not past end_at)
       #
       # @return [Boolean]
       def running?
+        return false if @state == "paused"
         return true if @end_at.nil?
 
         Time.now < @end_at

data/lib/e2b/models/snapshot_info.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module E2B
+  module Models
+    class SnapshotInfo
+      attr_reader :snapshot_id
+
+      def self.from_hash(data)
+        new(
+          snapshot_id: data["snapshotID"] || data["snapshot_id"] || data[:snapshotID]
+        )
+      end
+
+      def initialize(snapshot_id:)
+        @snapshot_id = snapshot_id
+      end
+    end
+  end
+end

data/lib/e2b/models/template_build_status_response.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module E2B
+  module Models
+    class TemplateBuildStatusResponse
+      attr_reader :build_id, :template_id, :status, :log_entries, :logs, :reason
+
+      def self.from_hash(data)
+        new(
+          build_id: data["buildID"] || data["build_id"] || data[:buildID],
+          template_id: data["templateID"] || data["template_id"] || data[:templateID],
+          status: data["status"] || data[:status],
+          log_entries: Array(data["logEntries"] || data["log_entries"] || data[:logEntries]).map do |entry|
+            TemplateLogEntry.from_hash(entry)
+          end,
+          logs: data["logs"] || data[:logs] || [],
+          reason: BuildStatusReason.from_hash(data["reason"] || data[:reason])
+        )
+      end
+
+      def initialize(build_id:, template_id:, status:, log_entries:, logs:, reason:)
+        @build_id = build_id
+        @template_id = template_id
+        @status = status
+        @log_entries = log_entries || []
+        @logs = logs || []
+        @reason = reason
+      end
+    end
+  end
+end

data/lib/e2b/models/template_log_entry.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "time"
+
+module E2B
+  module Models
+    class TemplateLogEntry
+      attr_reader :timestamp, :level, :message
+
+      def self.from_hash(data)
+        new(
+          timestamp: parse_time(data["timestamp"] || data[:timestamp]),
+          level: data["level"] || data[:level],
+          message: data["message"] || data[:message]
+        )
+      end
+
+      def initialize(timestamp:, level:, message:)
+        @timestamp = timestamp
+        @level = level
+        @message = self.class.strip_ansi_escape_codes(message.to_s)
+      end
+
+      def to_s
+        "[#{@timestamp&.iso8601}] [#{@level}] #{@message}"
+      end
+
+      def self.parse_time(value)
+        return nil if value.nil?
+        return value if value.is_a?(Time)
+
+        Time.parse(value)
+      rescue ArgumentError
+        nil
+      end
+
+      def self.strip_ansi_escape_codes(message)
+        message.gsub(/\e\[[0-9;?]*[ -\/]*[@-~]/, "")
+      end
+    end
+
+    class TemplateLogEntryStart < TemplateLogEntry
+      def initialize(timestamp:, message:)
+        super(timestamp: timestamp, level: "debug", message: message)
+      end
+    end
+
+    class TemplateLogEntryEnd < TemplateLogEntry
+      def initialize(timestamp:, message:)
+        super(timestamp: timestamp, level: "debug", message: message)
+      end
+    end
+  end
+end

data/lib/e2b/models/template_tag.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "time"
+
+module E2B
+  module Models
+    class TemplateTag
+      attr_reader :tag, :build_id, :created_at
+
+      def self.from_hash(data)
+        new(
+          tag: data["tag"] || data[:tag],
+          build_id: data["buildID"] || data["build_id"] || data[:buildID],
+          created_at: parse_time(data["createdAt"] || data["created_at"] || data[:createdAt])
+        )
+      end
+
+      def initialize(tag:, build_id:, created_at:)
+        @tag = tag
+        @build_id = build_id
+        @created_at = created_at
+      end
+
+      def self.parse_time(value)
+        return nil if value.nil?
+        return value if value.is_a?(Time)
+
+        Time.parse(value)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/e2b/models/template_tag_info.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module E2B
+  module Models
+    class TemplateTagInfo
+      attr_reader :build_id, :tags
+
+      def self.from_hash(data)
+        new(
+          build_id: data["buildID"] || data["build_id"] || data[:buildID],
+          tags: data["tags"] || data[:tags] || []
+        )
+      end
+
+      def initialize(build_id:, tags:)
+        @build_id = build_id
+        @tags = tags || []
+      end
+    end
+  end
+end

data/lib/e2b/paginator.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module E2B
+  class BasePaginator
+    attr_reader :next_token
+
+    def initialize(limit:, next_token: nil, &fetch_page)
+      @limit = limit
+      @next_token = next_token
+      @fetch_page = fetch_page
+      @has_next = true
+    end
+
+    def has_next?
+      @has_next
+    end
+
+    def next_items
+      raise E2BError, "No more items to fetch" unless has_next?
+
+      items, token = @fetch_page.call(limit: @limit, next_token: @next_token)
+      @next_token = token
+      @has_next = !@next_token.nil? && !@next_token.empty?
+      items
+    end
+  end
+
+  class SandboxPaginator < BasePaginator
+    def initialize(http_client:, query: nil, limit: 100, next_token: nil)
+      normalized_query = normalize_query(query)
+
+      super(limit: limit, next_token: next_token) do |limit:, next_token:|
+        params = { limit: limit }
+        params[:nextToken] = next_token if next_token
+        if normalized_query[:metadata]
+          params[:metadata] = self.class.encode_metadata(normalized_query[:metadata])
+        end
+        params[:state] = normalized_query[:state] if normalized_query[:state]
+
+        response = http_client.get("/v2/sandboxes", params: params, detailed: true)
+        sandboxes = extract_sandboxes(response.body)
+
+        [
+          Array(sandboxes).map { |sandbox_data| Models::SandboxInfo.from_hash(sandbox_data) },
+          response.headers["x-next-token"]
+        ]
+      end
+    end
+
+    def self.encode_metadata(metadata)
+      encoded_pairs = metadata.to_h.each_with_object({}) do |(key, value), result|
+        result[URI.encode_www_form_component(key.to_s)] = URI.encode_www_form_component(value.to_s)
+      end
+
+      URI.encode_www_form(encoded_pairs)
+    end
+
+    private
+
+    def normalize_query(query)
+      return {} unless query
+
+      state = query[:state] || query["state"]
+      {
+        metadata: query[:metadata] || query["metadata"],
+        state: state ? Array(state).map(&:to_s) : nil
+      }
+    end
+
+    def extract_sandboxes(body)
+      return body if body.is_a?(Array)
+      return body["sandboxes"] || body[:sandboxes] || [] if body.is_a?(Hash)
+
+      []
+    end
+  end
+
+  class SnapshotPaginator < BasePaginator
+    def initialize(http_client:, sandbox_id: nil, limit: 100, next_token: nil)
+      super(limit: limit, next_token: next_token) do |limit:, next_token:|
+        params = { limit: limit }
+        params[:sandboxID] = sandbox_id if sandbox_id
+        params[:nextToken] = next_token if next_token
+
+        response = http_client.get("/snapshots", params: params, detailed: true)
+        snapshots = response.body.is_a?(Array) ? response.body : []
+
+        [
+          snapshots.map { |snapshot_data| Models::SnapshotInfo.from_hash(snapshot_data) },
+          response.headers["x-next-token"]
+        ]
+      end
+    end
+  end
+end

data/lib/e2b/ready_cmd.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module E2B
+  class ReadyCmd
+    def initialize(cmd)
+      @cmd = cmd
+    end
+
+    def get_cmd
+      @cmd
+    end
+  end
+
+  class << self
+    def wait_for_port(port)
+      ReadyCmd.new("ss -tuln | grep :#{port}")
+    end
+
+    def wait_for_url(url, status_code = 200)
+      ReadyCmd.new(%(curl -s -o /dev/null -w "%{http_code}" #{url} | grep -q "#{status_code}"))
+    end
+
+    def wait_for_process(process_name)
+      ReadyCmd.new("pgrep #{process_name} > /dev/null")
+    end
+
+    def wait_for_file(filename)
+      ReadyCmd.new("[ -f #{filename} ]")
+    end
+
+    def wait_for_timeout(timeout)
+      seconds = [1, timeout.to_i / 1000].max
+      ReadyCmd.new("sleep #{seconds}")
+    end
+  end
+end