e2b 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d76a27510ea8da9f113ba2efb9aecf7c06377d20a409153491f6a918ee506a72
-  data.tar.gz: c0b1dae2a55304bbddd9211a54dea1ba964be0dcf73557a479f936627ebd67c3
+  metadata.gz: 103831a7280b1f523e4a7299820e40b328d0fd840f65850f42336f8c8b0e23ee
+  data.tar.gz: d079861b11c20bc1e2280badc7e7e9032810a736a7bbca02a433802be27b2053
 SHA512:
-  metadata.gz: 8777bb85409fab9f15c62c7d8d39856c7901616e90cc150914b78deaf4e71ba32540545dced53513cfee7641fa234815254ff529f5ebd41f533513696af436de
-  data.tar.gz: b1bd243b3741b8cba7860ffc36f0398ed5b049cb82482d65a1fea0f5da55071d3664602b3144ff7cbb06c4c90708e991ae565c9ba032ced51dac0f4e0bd6e2fb
+  metadata.gz: 9fa1e68c98160a18f31afb994e66fc55d20647cc0769f80afbc8ab6fccc45df2c2e7d0f0033a37dd3e7a1571d373b0cd92060f98f6ab675241aa61309e0e70d9
+  data.tar.gz: 759cffe0f051858f7f851f2f7599d495b24ca6abad1d313bed0cc96a7794e2a47eecacfdd6ecc81577d6fba18c9094824ec235022b8746047d630dce697ace0c

data/README.md

@@ -17,10 +17,14 @@ Aligned with the [official E2B SDKs](https://github.com/e2b-dev/E2B) (Python/JS)
 
 ## Installation
 
-Add to your Gemfile:
+```bash
+gem install e2b
+```
+
+Or add to your Gemfile:
 
 ```ruby
-gem 'e2b', git: 'https://github.com/ya-luotao/e2b-ruby.git'
+gem 'e2b'
 ```
 
 Then:

data/lib/e2b/api/http_client.rb

@@ -10,6 +10,8 @@ module E2B
     #
     # Handles authentication, request/response processing, and error handling.
     class HttpClient
+      DetailedResponse = Struct.new(:body, :headers, keyword_init: true)
+
       # Default request timeout in seconds
       DEFAULT_TIMEOUT = 120
 
@@ -19,11 +21,13 @@ module E2B
       # Initialize a new HTTP client
       #
       # @param base_url [String] Base URL for API requests
-      # @param api_key [String] API key for authentication
+      # @param api_key [String, nil] API key for authentication
+      # @param access_token [String, nil] Access token for bearer authentication
       # @param logger [Logger, nil] Optional logger
-      def initialize(base_url:, api_key:, logger: nil)
+      def initialize(base_url:, api_key: nil, access_token: nil, logger: nil)
         @base_url = base_url.end_with?("/") ? base_url : "#{base_url}/"
         @api_key = api_key
+        @access_token = access_token
         @logger = logger
         @connection = build_connection
       end
@@ -34,8 +38,8 @@ module E2B
       # @param params [Hash] Query parameters
       # @param timeout [Integer] Request timeout in seconds
       # @return [Hash, Array, String] Parsed response body
-      def get(path, params: {}, timeout: DEFAULT_TIMEOUT)
-        handle_response do
+      def get(path, params: {}, timeout: DEFAULT_TIMEOUT, detailed: false)
+        handle_response(detailed: detailed) do
           @connection.get(normalize_path(path)) do |req|
             req.params = params
             req.options.timeout = timeout
@@ -49,8 +53,8 @@ module E2B
       # @param body [Hash, nil] Request body
       # @param timeout [Integer] Request timeout in seconds
       # @return [Hash, Array, String] Parsed response body
-      def post(path, body: nil, timeout: DEFAULT_TIMEOUT)
-        handle_response do
+      def post(path, body: nil, timeout: DEFAULT_TIMEOUT, detailed: false)
+        handle_response(detailed: detailed) do
           @connection.post(normalize_path(path)) do |req|
             req.body = body.to_json if body
             req.options.timeout = timeout
@@ -64,8 +68,8 @@ module E2B
       # @param body [Hash, nil] Request body
       # @param timeout [Integer] Request timeout in seconds
       # @return [Hash, Array, String] Parsed response body
-      def put(path, body: nil, timeout: DEFAULT_TIMEOUT)
-        handle_response do
+      def put(path, body: nil, timeout: DEFAULT_TIMEOUT, detailed: false)
+        handle_response(detailed: detailed) do
           @connection.put(normalize_path(path)) do |req|
             req.body = body.to_json if body
             req.options.timeout = timeout
@@ -76,11 +80,13 @@ module E2B
       # Perform a DELETE request
       #
       # @param path [String] API endpoint path
+      # @param body [Hash, nil] Request body
       # @param timeout [Integer] Request timeout in seconds
       # @return [Hash, Array, String, nil] Parsed response body
-      def delete(path, timeout: DEFAULT_TIMEOUT)
-        handle_response do
+      def delete(path, body: nil, timeout: DEFAULT_TIMEOUT, detailed: false)
+        handle_response(detailed: detailed) do
           @connection.delete(normalize_path(path)) do |req|
+            req.body = body.to_json if body
             req.options.timeout = timeout
           end
         end
@@ -100,22 +106,31 @@ module E2B
           conn.response :json, content_type: /\bjson$/
           conn.adapter Faraday.default_adapter
 
-          conn.headers["X-API-Key"] = @api_key
+          conn.headers["X-API-Key"] = @api_key if @api_key && !@api_key.empty?
+          conn.headers["Authorization"] = "Bearer #{@access_token}" if @access_token && !@access_token.empty?
           conn.headers["Content-Type"] = "application/json"
           conn.headers["Accept"] = "application/json"
           conn.headers["User-Agent"] = "e2b-ruby-sdk/#{E2B::VERSION}"
         end
       end
 
-      def handle_response
+      def handle_response(detailed: false)
         response = yield
         handle_error(response) unless response.success?
 
-        body = response.body
+        parsed_body = parse_body(response.body, response.headers)
+        return DetailedResponse.new(body: parsed_body, headers: response.headers.to_h) if detailed
+
+        parsed_body
+      rescue Faraday::TimeoutError => e
+        raise E2B::TimeoutError, "Request timed out: #{e.message}"
+      rescue Faraday::ConnectionFailed => e
+        raise E2B::E2BError, "Connection failed: #{e.message}"
+      end
 
-        # If body is a string but should be JSON, try to parse it
+      def parse_body(body, headers)
         if body.is_a?(String) && !body.empty?
-          content_type = response.headers["content-type"] rescue "unknown"
+          content_type = headers["content-type"] rescue "unknown"
           if content_type&.include?("json") || body.start_with?("{", "[")
             begin
               return JSON.parse(body)
@@ -126,10 +141,6 @@ module E2B
         end
 
         body
-      rescue Faraday::TimeoutError => e
-        raise E2B::TimeoutError, "Request timed out: #{e.message}"
-      rescue Faraday::ConnectionFailed => e
-        raise E2B::E2BError, "Connection failed: #{e.message}"
       end
 
       def handle_error(response)

data/lib/e2b/client.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rubygems/version"
+
 module E2B
   # Client for interacting with the E2B API
   #
@@ -14,6 +16,8 @@ module E2B
   # @example Using Sandbox directly (recommended, matches official SDK)
   #   sandbox = E2B::Sandbox.create(template: "base", api_key: "your-key")
   class Client
+    include SandboxHelpers
+
     # @return [Configuration] Client configuration
     attr_reader :config
 
@@ -30,10 +34,11 @@ module E2B
       @http_client = API::HttpClient.new(
         base_url: @config.api_url,
         api_key: @config.api_key,
+        access_token: @config.access_token,
         logger: @config.logger
       )
 
-      @domain = Sandbox::DEFAULT_DOMAIN
+      @domain = @config.domain
     end
 
     # Create a new sandbox
@@ -44,7 +49,9 @@ module E2B
     # @param metadata [Hash, nil] Custom metadata
     # @param envs [Hash{String => String}, nil] Environment variables
     # @return [Sandbox] The created sandbox instance
-    def create(template: "base", timeout: nil, timeout_ms: nil, metadata: nil, envs: nil, **_opts)
+    def create(template: "base", timeout: nil, timeout_ms: nil, metadata: nil, envs: nil,
+               secure: true, allow_internet_access: true, network: nil,
+               lifecycle: nil, auto_pause: nil, mcp: nil, request_timeout: nil, **_opts)
       # Support both seconds and milliseconds for backward compat
       timeout_seconds = if timeout
                           timeout
@@ -53,22 +60,37 @@ module E2B
                         else
                           (@config.sandbox_timeout_ms / 1000).to_i
                         end
+      template = resolved_template(template, mcp: mcp)
+      lifecycle = normalized_lifecycle(lifecycle: lifecycle, auto_pause: auto_pause)
 
       body = {
         templateID: template,
-        timeout: timeout_seconds
+        timeout: timeout_seconds,
+        secure: secure,
+        allow_internet_access: allow_internet_access,
+        autoPause: lifecycle[:on_timeout] == "pause"
       }
       body[:metadata] = metadata if metadata
       body[:envVars] = envs if envs
+      body[:mcp] = mcp if mcp
+      body[:network] = network if network
+      if body[:autoPause]
+        body[:autoResume] = { enabled: lifecycle[:auto_resume] }
+      end
 
-      response = @http_client.post("/sandboxes", body: body, timeout: 120)
+      response = @http_client.post("/sandboxes", body: body, timeout: request_timeout || @config.request_timeout || 120)
+      ensure_supported_envd_version!(response, @http_client)
 
-      Sandbox.new(
+      sandbox = Sandbox.new(
         sandbox_data: response,
         http_client: @http_client,
         api_key: @config.api_key,
         domain: @domain
       )
+
+      start_mcp_gateway(sandbox, mcp) if mcp
+
+      sandbox
     end
 
     # Connect to an existing sandbox
@@ -77,12 +99,9 @@ module E2B
     # @param timeout [Integer, nil] Timeout in seconds
     # @return [Sandbox]
     def connect(sandbox_id, timeout: nil)
-      if timeout
-        response = @http_client.post("/sandboxes/#{sandbox_id}/connect",
-          body: { timeout: timeout })
-      else
-        response = @http_client.get("/sandboxes/#{sandbox_id}")
-      end
+      timeout_seconds = timeout || ((@config.sandbox_timeout_ms || (Sandbox::DEFAULT_TIMEOUT * 1000)) / 1000).to_i
+      response = @http_client.post("/sandboxes/#{sandbox_id}/connect",
+        body: { timeout: timeout_seconds })
 
       Sandbox.new(
         sandbox_data: response,
@@ -112,29 +131,18 @@ module E2B
     # @param metadata [Hash, nil] Filter by metadata
     # @param state [String, nil] Filter by state
     # @param limit [Integer] Maximum results
-    # @return [Array<Sandbox>]
-    def list(metadata: nil, state: nil, limit: 100)
-      params = { limit: limit }
-      params[:metadata] = metadata.to_json if metadata
-      params[:state] = state if state
-
-      response = @http_client.get("/v2/sandboxes", params: params)
-
-      sandboxes = if response.is_a?(Array)
-                    response
-                  elsif response.is_a?(Hash)
-                    response["sandboxes"] || response[:sandboxes] || []
-                  else
-                    []
-                  end
-      Array(sandboxes).map do |sandbox_data|
-        Sandbox.new(
-          sandbox_data: sandbox_data,
-          http_client: @http_client,
-          api_key: @config.api_key,
-          domain: @domain
-        )
-      end
+    # @return [SandboxPaginator]
+    def list(metadata: nil, state: nil, limit: 100, next_token: nil)
+      query = {}
+      query[:metadata] = metadata if metadata
+      query[:state] = state if state
+
+      SandboxPaginator.new(
+        http_client: @http_client,
+        query: query.empty? ? nil : query,
+        limit: limit,
+        next_token: next_token
+      )
     end
 
     # Kill a sandbox
@@ -170,8 +178,8 @@ module E2B
     # @param timeout [Integer, nil] New timeout in seconds
     # @return [Sandbox]
     def resume(sandbox_id, timeout: nil)
-      body = {}
-      body[:timeout] = timeout if timeout
+      timeout_seconds = timeout || ((@config.sandbox_timeout_ms || (Sandbox::DEFAULT_TIMEOUT * 1000)) / 1000).to_i
+      body = { timeout: timeout_seconds }
 
       response = @http_client.post("/sandboxes/#{sandbox_id}/connect", body: body)
 
@@ -183,6 +191,41 @@ module E2B
       )
     end
 
+    # Create a snapshot from an existing sandbox.
+    #
+    # @param sandbox_id [String] Source sandbox ID
+    # @return [Models::SnapshotInfo]
+    def create_snapshot(sandbox_id)
+      response = @http_client.post("/sandboxes/#{sandbox_id}/snapshots")
+      Models::SnapshotInfo.from_hash(response)
+    end
+
+    # List snapshots for the team, optionally filtered by source sandbox.
+    #
+    # @param sandbox_id [String, nil] Filter snapshots by source sandbox ID
+    # @param limit [Integer] Maximum results per page
+    # @param next_token [String, nil] Pagination token
+    # @return [SnapshotPaginator]
+    def list_snapshots(sandbox_id: nil, limit: 100, next_token: nil)
+      SnapshotPaginator.new(
+        http_client: @http_client,
+        sandbox_id: sandbox_id,
+        limit: limit,
+        next_token: next_token
+      )
+    end
+
+    # Delete a snapshot template.
+    #
+    # @param snapshot_id [String] Snapshot identifier
+    # @return [Boolean]
+    def delete_snapshot(snapshot_id)
+      @http_client.delete("/templates/#{snapshot_id}")
+      true
+    rescue NotFoundError
+      false
+    end
+
     private
 
     def resolve_config(config_or_options)

data/lib/e2b/configuration.rb

@@ -16,12 +16,12 @@ module E2B
   #     config.request_timeout = 120
   #   end
   class Configuration
-    # Default API base URL
-    DEFAULT_API_URL = "https://api.e2b.app"
-
     # Default domain
     DEFAULT_DOMAIN = "e2b.app"
 
+    # Default API base URL
+    DEFAULT_API_URL = "https://api.#{DEFAULT_DOMAIN}"
+
     # Default request timeout in seconds
     DEFAULT_REQUEST_TIMEOUT = 60
 
@@ -32,7 +32,7 @@ module E2B
     DEFAULT_TIMEOUT_MS = 300_000
 
     # Default sandbox timeout in milliseconds (backward compat)
-    DEFAULT_SANDBOX_TIMEOUT_MS = 3_600_000
+    DEFAULT_SANDBOX_TIMEOUT_MS = 300_000
 
     # Maximum sandbox timeout (24 hours for Pro)
     MAX_SANDBOX_TIMEOUT_MS = 86_400_000
@@ -90,11 +90,11 @@ module E2B
       @api_key = api_key || ENV["E2B_API_KEY"]
       @access_token = access_token || ENV["E2B_ACCESS_TOKEN"]
       @domain = domain || ENV["E2B_DOMAIN"] || DEFAULT_DOMAIN
-      @api_url = api_url || ENV["E2B_API_URL"] || DEFAULT_API_URL
+      @debug = debug || ENV["E2B_DEBUG"]&.downcase == "true"
+      @api_url = api_url || ENV["E2B_API_URL"] || self.class.default_api_url(@domain, debug: @debug)
       @request_timeout = request_timeout
       @timeout_ms = timeout_ms
       @sandbox_timeout_ms = sandbox_timeout_ms
-      @debug = debug || ENV["E2B_DEBUG"]&.downcase == "true"
       @default_template = nil
       @logger = nil
     end
@@ -115,5 +115,11 @@ module E2B
     def valid?
       (!@api_key.nil? && !@api_key.empty?) || (!@access_token.nil? && !@access_token.empty?)
     end
+
+    def self.default_api_url(domain, debug: false)
+      return "http://localhost:3000" if debug
+
+      "https://api.#{domain}"
+    end
   end
 end

data/lib/e2b/dockerfile_parser.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "json"
+require "shellwords"
+
+module E2B
+  module DockerfileParser
+    module_function
+
+    def parse(dockerfile_content_or_path, template_builder)
+      instructions = parse_instructions(read_dockerfile(dockerfile_content_or_path))
+      from_instructions = instructions.select { |instruction| instruction[:keyword] == "FROM" }
+
+      raise TemplateError, "Multi-stage Dockerfiles are not supported" if from_instructions.length > 1
+      raise TemplateError, "Dockerfile must contain a FROM instruction" if from_instructions.empty?
+
+      base_image = normalize_base_image(from_instructions.first[:value])
+      user_changed = false
+      workdir_changed = false
+
+      template_builder.set_user("root")
+      template_builder.set_workdir("/")
+
+      instructions.each do |instruction|
+        keyword = instruction[:keyword]
+        value = instruction[:value]
+
+        case keyword
+        when "FROM"
+          next
+        when "RUN"
+          handle_run(value, template_builder)
+        when "COPY", "ADD"
+          handle_copy(value, template_builder)
+        when "WORKDIR"
+          handle_workdir(value, template_builder)
+          workdir_changed = true
+        when "USER"
+          handle_user(value, template_builder)
+          user_changed = true
+        when "ENV", "ARG"
+          handle_env(value, keyword, template_builder)
+        when "CMD", "ENTRYPOINT"
+          handle_cmd(value, template_builder)
+        end
+      end
+
+      template_builder.set_user("user") unless user_changed
+      template_builder.set_workdir("/home/user") unless workdir_changed
+
+      base_image
+    end
+
+    def read_dockerfile(dockerfile_content_or_path)
+      if File.file?(dockerfile_content_or_path)
+        File.read(dockerfile_content_or_path)
+      else
+        dockerfile_content_or_path
+      end
+    rescue StandardError
+      dockerfile_content_or_path
+    end
+
+    def parse_instructions(content)
+      instructions = []
+      current = +""
+
+      content.each_line do |raw_line|
+        line = raw_line.chomp
+        next if line.strip.empty? || line.lstrip.start_with?("#")
+
+        if line.rstrip.end_with?("\\")
+          current << line.rstrip.sub(/\\\s*\z/, "")
+          current << " "
+          next
+        end
+
+        current << line
+        instruction = current.strip
+        current = +""
+        next if instruction.empty?
+
+        keyword, value = instruction.split(/\s+/, 2)
+        instructions << { keyword: keyword.upcase, value: value.to_s.strip }
+      end
+
+      unless current.strip.empty?
+        keyword, value = current.strip.split(/\s+/, 2)
+        instructions << { keyword: keyword.upcase, value: value.to_s.strip }
+      end
+
+      instructions
+    end
+
+    def normalize_base_image(value)
+      value.sub(/\s+as\s+.+\z/i, "").strip
+    end
+
+    def handle_run(value, template_builder)
+      return if value.strip.empty?
+
+      template_builder.run_cmd(value.strip.gsub(/\s+/, " "))
+    end
+
+    def handle_copy(value, template_builder)
+      return if value.strip.empty?
+
+      parts = Shellwords.split(value)
+      user = nil
+      non_flag_parts = []
+
+      parts.each do |part|
+        if part.start_with?("--chown=")
+          user = part.delete_prefix("--chown=")
+        elsif !part.start_with?("--")
+          non_flag_parts << part
+        end
+      end
+
+      return unless non_flag_parts.length >= 2
+
+      src = non_flag_parts.first
+      dest = non_flag_parts.last
+      template_builder.copy(src, dest, user: user)
+    end
+
+    def handle_workdir(value, template_builder)
+      return if value.strip.empty?
+
+      template_builder.set_workdir(value.strip)
+    end
+
+    def handle_user(value, template_builder)
+      return if value.strip.empty?
+
+      template_builder.set_user(value.strip)
+    end
+
+    def handle_env(value, keyword, template_builder)
+      return if value.strip.empty?
+
+      parts = Shellwords.split(value)
+      envs = {}
+
+      if parts.length == 1
+        parse_single_env_part(parts.first, keyword, envs)
+      elsif parts.length == 2 && !(parts[0].include?("=") && parts[1].include?("="))
+        envs[parts[0]] = parts[1]
+      else
+        parts.each { |part| parse_single_env_part(part, keyword, envs) }
+      end
+
+      template_builder.set_envs(envs) unless envs.empty?
+    end
+
+    def parse_single_env_part(part, keyword, envs)
+      equal_index = part.index("=")
+      if equal_index && equal_index.positive?
+        envs[part[0...equal_index]] = part[(equal_index + 1)..]
+      elsif keyword == "ARG" && !part.strip.empty?
+        envs[part.strip] = ""
+      end
+    end
+
+    def handle_cmd(value, template_builder)
+      return if value.strip.empty?
+
+      command = value.strip
+      begin
+        parsed = JSON.parse(command)
+        command = parsed.join(" ") if parsed.is_a?(Array)
+      rescue JSON::ParserError
+        nil
+      end
+
+      template_builder.set_start_cmd(command, E2B.wait_for_timeout(20_000))
+    end
+  end
+end

data/lib/e2b/errors.rb

@@ -49,7 +49,30 @@ module E2B
   class NotEnoughSpaceError < E2BError; end
 
   # Error raised for template-related failures
-  class TemplateError < E2BError; end
+  class TemplateError < E2BError
+    attr_reader :source_location
+
+    def initialize(message = nil, status_code: nil, headers: {}, source_location: nil)
+      @source_location = source_location
+      super(message, status_code: status_code, headers: headers)
+      set_backtrace([source_location]) if source_location
+    end
+  end
+
+  # Error raised when a template build fails or returns an invalid status
+  class BuildError < E2BError
+    attr_reader :step, :source_location
+
+    def initialize(message = nil, status_code: nil, headers: {}, step: nil, source_location: nil)
+      @step = step
+      @source_location = source_location
+      super(message, status_code: status_code, headers: headers)
+      set_backtrace([source_location]) if source_location
+    end
+  end
+
+  # Error raised when file upload fails during a template build
+  class FileUploadError < BuildError; end
 
   # Error raised when a command exits with non-zero exit code
   #

data/lib/e2b/models/build_info.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module E2B
+  module Models
+    class BuildInfo
+      attr_reader :alias_name, :name, :tags, :template_id, :build_id, :build_step_origins
+
+      def self.from_hash(data)
+        new(
+          alias_name: data["alias"] || data[:alias],
+          name: data["name"] || data[:name],
+          tags: data["tags"] || data[:tags] || [],
+          template_id: data["templateID"] || data["template_id"] || data[:templateID],
+          build_id: data["buildID"] || data["build_id"] || data[:buildID],
+          build_step_origins: data["buildStepOrigins"] || data["build_step_origins"] || data[:buildStepOrigins] || []
+        )
+      end
+
+      def initialize(alias_name:, name:, tags:, template_id:, build_id:, build_step_origins: [])
+        @alias_name = alias_name
+        @name = name
+        @tags = tags || []
+        @template_id = template_id
+        @build_id = build_id
+        @build_step_origins = Array(build_step_origins).compact
+      end
+    end
+  end
+end

data/lib/e2b/models/build_status_reason.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module E2B
+  module Models
+    class BuildStatusReason
+      attr_reader :message, :step, :log_entries
+
+      def self.from_hash(data)
+        return nil if data.nil?
+
+        new(
+          message: data["message"] || data[:message],
+          step: data["step"] || data[:step],
+          log_entries: Array(data["logEntries"] || data["log_entries"] || data[:logEntries]).map do |entry|
+            TemplateLogEntry.from_hash(entry)
+          end
+        )
+      end
+
+      def initialize(message:, step: nil, log_entries: [])
+        @message = message
+        @step = step
+        @log_entries = log_entries || []
+      end
+    end
+  end
+end