e2b 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 103831a7280b1f523e4a7299820e40b328d0fd840f65850f42336f8c8b0e23ee
-  data.tar.gz: d079861b11c20bc1e2280badc7e7e9032810a736a7bbca02a433802be27b2053
+  metadata.gz: ae958d79e7fb00debc2a5ea2690aeb1678e0d5ae5dad95d5db7b38a469da943c
+  data.tar.gz: d749554ef9cab965bd0711b010df41690c568e9992d22ae4bee0ac7377f8b95e
 SHA512:
-  metadata.gz: 9fa1e68c98160a18f31afb994e66fc55d20647cc0769f80afbc8ab6fccc45df2c2e7d0f0033a37dd3e7a1571d373b0cd92060f98f6ab675241aa61309e0e70d9
-  data.tar.gz: 759cffe0f051858f7f851f2f7599d495b24ca6abad1d313bed0cc96a7794e2a47eecacfdd6ecc81577d6fba18c9094824ec235022b8746047d630dce697ace0c
+  metadata.gz: ac6c3ec8f071cf7abadaf0750daa7900c7909edda3932b755523e82ad9d06e7dba7afb3f211b0f64ad928d52f3f7e7cacaf21244b32c52d3fb05c64683d7d4ef
+  data.tar.gz: a38f523b38adc6799fcca5bdeaf51efa4f29dc31ba0e3a56a2a9d817f727f974dc93ba417d6fa89129a5819f5377b6943b72d1a16c948b1ece1375dcc4aa035a

data/README.md

@@ -132,6 +132,7 @@ sandbox = client.create(template: "base")
 | `list` | List running processes |
 | `kill(pid)` | Kill a process |
 | `send_stdin(pid, data)` | Send stdin to a process |
+| `close_stdin(pid)` | Close stdin (send EOF) |
 | `connect(pid)` | Connect to running process |
 
 ### Filesystem (`sandbox.files`)

data/lib/e2b/models/entry_info.rb

@@ -216,7 +216,7 @@ module E2B
         elsif value.is_a?(Time)
           value
         end
-      rescue ArgumentError
+      rescue ArgumentError, TypeError
         nil
       end
 

data/lib/e2b/models/sandbox_info.rb

@@ -102,8 +102,8 @@ module E2B
         return nil if value.nil?
         return value if value.is_a?(Time)
 
-        Time.parse(value)
-      rescue ArgumentError
+        Time.parse(value.to_s)
+      rescue ArgumentError, TypeError
         nil
       end
     end

data/lib/e2b/models/template_log_entry.rb

@@ -29,8 +29,8 @@ module E2B
         return nil if value.nil?
         return value if value.is_a?(Time)
 
-        Time.parse(value)
-      rescue ArgumentError
+        Time.parse(value.to_s)
+      rescue ArgumentError, TypeError
         nil
       end
 

data/lib/e2b/sandbox.rb

@@ -177,11 +177,15 @@ module E2B
 
       # List running sandboxes
       #
+      # Returns a paginator that yields sandbox info hashes one page at a time.
+      # Use {SandboxPaginator#has_next?} and {SandboxPaginator#next_items} to
+      # iterate through pages.
+      #
       # @param query [Hash, nil] Filter parameters (metadata, state)
       # @param limit [Integer] Maximum results per page
       # @param next_token [String, nil] Pagination token
       # @param api_key [String, nil] API key
-      # @return [Array<Hash>] List of sandbox info hashes
+      # @return [SandboxPaginator]
       def list(query: nil, limit: 100, next_token: nil, api_key: nil, access_token: nil, domain: nil)
         credentials = resolve_credentials(api_key: api_key, access_token: access_token)
         http_client = build_http_client(**credentials, domain: resolve_domain(domain))
@@ -225,10 +229,15 @@ module E2B
         false
       end
 
-      # Kill a sandbox by ID
+      # Kill a sandbox by ID (idempotent)
+      #
+      # Returns `true` if the sandbox was killed, *and* if it was already gone
+      # (NotFound). To distinguish "actually killed" from "already gone", use
+      # {.list} or {Sandbox#running?} before calling.
       #
       # @param sandbox_id [String] Sandbox ID to kill
       # @param api_key [String, nil] API key
+      # @return [Boolean] always true
       def kill(sandbox_id, api_key: nil, access_token: nil, domain: nil)
         credentials = resolve_credentials(api_key: api_key, access_token: access_token)
         http_client = build_http_client(**credentials, domain: resolve_domain(domain))
@@ -294,9 +303,16 @@ module E2B
       @end_at = Time.now + timeout
     end
 
-    # Kill/terminate the sandbox
+    # Kill/terminate the sandbox (idempotent)
+    #
+    # Returns `true` whether the sandbox was running or already gone.
+    #
+    # @return [Boolean] always true
     def kill
       @http_client.delete("/sandboxes/#{@sandbox_id}")
+      true
+    rescue E2B::NotFoundError
+      true
     end
 
     # Pause the sandbox (saves state for later resume)
@@ -305,10 +321,16 @@ module E2B
       @state = "paused"
     end
 
-    # Resume a paused sandbox
+    # @deprecated Use {#resume} instead. The instance-level `#connect`
+    #   collides in name with the class-level {Sandbox.connect}, which has
+    #   different semantics (it builds a new Sandbox instance from a
+    #   sandbox_id). The instance method only resumes the current sandbox.
     #
     # @param timeout [Integer, nil] New timeout in seconds
     def connect(timeout: nil)
+      warn "[DEPRECATION] Sandbox#connect is deprecated; use Sandbox#resume " \
+           "instead. (Sandbox.connect class method is unchanged.) " \
+           "Called from #{caller(1, 1).first}"
       resume(timeout: timeout)
       self
     end
@@ -456,11 +478,13 @@ module E2B
 
       @sandbox_id = data["sandboxID"] || data["sandbox_id"] || data[:sandboxID] || @sandbox_id
       @template_id = data["templateID"] || data["template_id"] || data[:templateID] || @template_id
-      @alias_name = data["alias"] || data[:alias]
-      @client_id = data["clientID"] || data["client_id"] || data[:clientID]
-      @cpu_count = data["cpuCount"] || data["cpu_count"] || data[:cpuCount]
-      @memory_mb = data["memoryMB"] || data["memory_mb"] || data[:memoryMB]
-      @metadata = data["metadata"] || data[:metadata] || {}
+      @alias_name = data["alias"] || data[:alias] || @alias_name
+      @client_id = data["clientID"] || data["client_id"] || data[:clientID] || @client_id
+      @cpu_count = data["cpuCount"] || data["cpu_count"] || data[:cpuCount] || @cpu_count
+      @memory_mb = data["memoryMB"] || data["memory_mb"] || data[:memoryMB] || @memory_mb
+      metadata = data["metadata"] || data[:metadata]
+      @metadata = metadata if metadata
+      @metadata ||= {}
       @state = data["state"] || data[:state] || @state
       @domain = data["domain"] || data[:domain] || @domain
 
@@ -468,8 +492,10 @@ module E2B
       @envd_access_token = data["envdAccessToken"] || data["envd_access_token"] || data[:envdAccessToken] || @envd_access_token
       @traffic_access_token = data["trafficAccessToken"] || data["traffic_access_token"] || data[:trafficAccessToken] || @traffic_access_token
 
-      @started_at = parse_time(data["startedAt"] || data["started_at"] || data[:startedAt])
-      @end_at = parse_time(data["endAt"] || data["end_at"] || data[:endAt])
+      started_at = parse_time(data["startedAt"] || data["started_at"] || data[:startedAt])
+      @started_at = started_at if started_at
+      end_at = parse_time(data["endAt"] || data["end_at"] || data[:endAt])
+      @end_at = end_at if end_at
     end
 
     def initialize_services
@@ -494,8 +520,8 @@ module E2B
       return nil if value.nil?
       return value if value.is_a?(Time)
 
-      Time.parse(value)
-    rescue ArgumentError
+      Time.parse(value.to_s)
+    rescue ArgumentError, TypeError
       nil
     end
 

data/lib/e2b/services/base_service.rb

@@ -3,7 +3,6 @@
 require "base64"
 require "net/http"
 require "openssl"
-require "ostruct"
 require "rubygems/version"
 
 module E2B
@@ -105,7 +104,13 @@ module E2B
       private
 
       def build_envd_client
-        envd_url = "https://#{ENVD_PORT}-#{@sandbox_id}.#{@sandbox_domain}"
+        # Ensure envd traffic bypasses HTTP proxy — the proxy often can't
+        # CONNECT-tunnel to sandbox subdomains. Append the sandbox domain
+        # to no_proxy so Net::HTTP and Faraday connect directly.
+        ensure_no_proxy_for_domain!(@sandbox_domain)
+
+        scheme = ENV.fetch("E2B_ENVD_SCHEME", "https")
+        envd_url = "#{scheme}://#{ENVD_PORT}-#{@sandbox_id}.#{@sandbox_domain}"
 
         EnvdHttpClient.new(
           base_url: envd_url,
@@ -115,6 +120,19 @@ module E2B
           logger: @logger
         )
       end
+
+      # Append domain to no_proxy/NO_PROXY env vars at runtime so that
+      # both Net::HTTP and Faraday bypass the HTTP proxy for envd traffic.
+      def ensure_no_proxy_for_domain!(domain)
+        return if domain.nil? || domain.empty?
+
+        %w[no_proxy NO_PROXY].each do |var|
+          current = ENV[var].to_s
+          next if current.split(",").any? { |h| h.strip == domain }
+
+          ENV[var] = current.empty? ? domain : "#{current},#{domain}"
+        end
+      end
     end
 
     # HTTP client for envd daemon communication
@@ -125,6 +143,12 @@ module E2B
     class EnvdHttpClient
       DEFAULT_TIMEOUT = 120
 
+      RpcResponse = Struct.new(:status, :body, :headers, keyword_init: true) do
+        def success?
+          status >= 200 && status < 300
+        end
+      end
+
       def initialize(base_url:, api_key:, access_token: nil, sandbox_id:, logger: nil)
         @base_url = base_url.end_with?("/") ? base_url : "#{base_url}/"
         @api_key = api_key
@@ -182,6 +206,9 @@ module E2B
           return handle_streaming_rpc(path, envelope, timeout, on_event, headers)
         end
 
+        # Unary RPCs: try Connect protocol first, fall back to plain JSON.
+        # Some envd versions (e.g., 0.5.4 on self-hosted) reject
+        # application/connect+json for unary calls but accept application/json.
         handle_rpc_response(service, method) do
           with_retry("RPC #{service}/#{method}") do
             url = URI.parse("#{@base_url.chomp('/')}#{path}")
@@ -196,9 +223,21 @@ module E2B
 
             response = http.request(request)
 
-            OpenStruct.new(
+            # Fall back to plain JSON if Connect protocol is unsupported (HTTP 415)
+            if response.code.to_i == 415
+              log_debug("Connect protocol unsupported for #{service}/#{method}, falling back to plain JSON")
+              request = Net::HTTP::Post.new(url.request_uri)
+              request["Content-Type"] = "application/json"
+              request["X-Access-Token"] = @access_token if @access_token
+              request["Connection"] = "keep-alive"
+              apply_custom_headers(request, headers)
+              request.body = json_body
+
+              response = http.request(request)
+            end
+
+            RpcResponse.new(
               status: response.code.to_i,
-              success?: response.code.to_i >= 200 && response.code.to_i < 300,
               body: response.body,
               headers: response.to_hash
             )
@@ -206,98 +245,116 @@ module E2B
         end
       end
 
-      # Streaming RPC with chunked response processing
+      # Streaming RPC with chunked response processing.
+      # Uses Faraday for the HTTP connection (same as non-streaming RPCs) to
+      # inherit proxy configuration and SSL settings. The streaming is handled
+      # via Faraday's on_data callback for chunked response processing.
+      #
+      # Streaming RPCs are NOT idempotent (e.g. process.Process/Start spawns a
+      # process), so we only retry while no events have been emitted to the
+      # caller yet. Once any byte has been delivered via on_event, a retry
+      # would replay output AND start a second process server-side.
       def handle_streaming_rpc(path, envelope, timeout, on_event, headers)
         result = { events: [], stdout: "", stderr: "", exit_code: nil }
         buffer = "".b
 
-        url = URI.parse("#{@base_url.chomp('/')}#{path}")
-
-        with_retry("Streaming RPC #{path}") do
-          http = build_http(url, timeout)
+        full_path = normalize_path(path)
 
-          request = Net::HTTP::Post.new(url.request_uri)
-          request["Content-Type"] = "application/connect+json"
-          request["X-Access-Token"] = @access_token if @access_token
-          request["Connection"] = "keep-alive"
-          apply_custom_headers(request, headers)
-          request.body = envelope
+        with_retry("Streaming RPC #{path}", abort_if: -> { result[:events].any? }) do
+          ssl_verify = ENV.fetch("E2B_SSL_VERIFY", "true").downcase != "false"
 
-          http.start do |conn|
-            conn.request(request) do |response|
-              unless response.code.to_i.between?(200, 299)
-                body = response.body
-                handle_error(OpenStruct.new(status: response.code.to_i, success?: false, body: body, headers: response.to_hash))
-              end
+          streaming_conn = Faraday.new(url: @base_url, ssl: { verify: ssl_verify }) do |conn|
+            conn.options.timeout = timeout
+            conn.options.open_timeout = 30
+            conn.adapter Faraday.default_adapter
+          end
 
-              response.read_body do |chunk|
-                next if chunk.nil? || chunk.empty?
-                buffer << chunk
+          req_headers = {
+            "Content-Type" => "application/connect+json",
+            "Connection" => "keep-alive",
+            "E2b-Sandbox-Id" => @sandbox_id,
+            "E2b-Sandbox-Port" => "#{BaseService::ENVD_PORT}",
+            "X-API-Key" => @api_key
+          }
+          req_headers["X-Access-Token"] = @access_token if @access_token
+          if headers
+            headers.each { |k, v| req_headers[k.to_s] = v.to_s if v }
+          end
 
-                while buffer.bytesize >= 5
-                  flags = buffer.getbyte(0)
-                  length = buffer.byteslice(1, 4).unpack1("N")
+          response = streaming_conn.post(full_path) do |req|
+            req.headers.merge!(req_headers)
+            req.body = envelope
+            req.options.on_data = proc do |chunk, _overall_size, _env|
+              next if chunk.nil? || chunk.empty?
+              buffer << chunk
 
-                  break if length.nil? || buffer.bytesize < 5 + length
+              while buffer.bytesize >= 5
+                flags = buffer.getbyte(0)
+                length = buffer.byteslice(1, 4).unpack1("N")
 
-                  message_bytes = buffer.byteslice(5, length)
-                  buffer = buffer.byteslice(5 + length..-1) || "".b
+                break if length.nil? || buffer.bytesize < 5 + length
 
-                  next if message_bytes.nil? || message_bytes.empty?
+                message_bytes = buffer.byteslice(5, length)
+                buffer = buffer.byteslice(5 + length..-1) || "".b
 
-                  message_str = message_bytes.force_encoding("UTF-8")
+                next if message_bytes.nil? || message_bytes.empty?
 
-                  begin
-                    msg = JSON.parse(message_str)
-                    msg = msg["result"] if msg["result"]
+                message_str = message_bytes.force_encoding("UTF-8")
 
-                    result[:events] << msg
+                begin
+                  msg = JSON.parse(message_str)
+                  msg = msg["result"] if msg["result"]
 
-                    stdout_data = nil
-                    stderr_data = nil
+                  result[:events] << msg
 
-                    if msg["event"]
-                      event = msg["event"]
+                  stdout_data = nil
+                  stderr_data = nil
 
-                      data_event = event["Data"] || event["data"]
-                      if data_event
-                        stdout_data = decode_base64(data_event["stdout"]) if data_event["stdout"]
-                        stderr_data = decode_base64(data_event["stderr"]) if data_event["stderr"]
-                        result[:stdout] += stdout_data if stdout_data
-                        result[:stderr] += stderr_data if stderr_data
-                      end
+                  if msg["event"]
+                    event = msg["event"]
 
-                      end_event = event["End"] || event["end"]
-                      if end_event
-                        result[:exit_code] = parse_exit_code(end_event["exitCode"] || end_event["exit_code"] || end_event["status"])
-                      end
+                    data_event = event["Data"] || event["data"]
+                    if data_event
+                      stdout_data = decode_base64(data_event["stdout"]) if data_event["stdout"]
+                      stderr_data = decode_base64(data_event["stderr"]) if data_event["stderr"]
+                      result[:stdout] += stdout_data if stdout_data
+                      result[:stderr] += stderr_data if stderr_data
                     end
 
-                    if msg["stdout"]
-                      stdout_data = decode_base64(msg["stdout"])
-                      result[:stdout] += stdout_data
-                    end
-                    if msg["stderr"]
-                      stderr_data = decode_base64(msg["stderr"])
-                      result[:stderr] += stderr_data
-                    end
-                    if msg["exitCode"] || msg["exit_code"]
-                      result[:exit_code] = parse_exit_code(msg["exitCode"] || msg["exit_code"])
+                    end_event = event["End"] || event["end"]
+                    if end_event
+                      result[:exit_code] = parse_exit_code(end_event["exitCode"] || end_event["exit_code"] || end_event["status"])
                     end
+                  end
 
-                    on_event.call(
-                      stdout: stdout_data,
-                      stderr: stderr_data,
-                      exit_code: result[:exit_code],
-                      event: msg
-                    )
-                  rescue JSON::ParserError
-                    # Skip unparseable messages
+                  if msg["stdout"]
+                    stdout_data = decode_base64(msg["stdout"])
+                    result[:stdout] += stdout_data
+                  end
+                  if msg["stderr"]
+                    stderr_data = decode_base64(msg["stderr"])
+                    result[:stderr] += stderr_data
                   end
+                  if msg["exitCode"] || msg["exit_code"]
+                    result[:exit_code] = parse_exit_code(msg["exitCode"] || msg["exit_code"])
+                  end
+
+                  on_event.call(
+                    stdout: stdout_data,
+                    stderr: stderr_data,
+                    exit_code: result[:exit_code],
+                    event: msg
+                  )
+                rescue JSON::ParserError
+                  # Skip unparseable messages
                 end
               end
             end
           end
+
+          unless response.status.between?(200, 299)
+            handle_error(response)
+          end
         end
 
         result
@@ -328,24 +385,55 @@ module E2B
       end
 
       def build_http(url, timeout)
-        http = Net::HTTP.new(url.host, url.port)
-        http.use_ssl = true
+        # Respect HTTP proxy env vars (http_proxy, https_proxy, no_proxy) —
+        # Faraday handles this automatically for non-streaming RPCs, but
+        # Net::HTTP requires explicit proxy configuration.
+        proxy = resolve_proxy(url)
+        http = if proxy
+                 Net::HTTP.new(url.host, url.port, proxy.host, proxy.port, proxy.user, proxy.password)
+               else
+                 Net::HTTP.new(url.host, url.port)
+               end
+
+        http.use_ssl = (url.scheme == "https")
         http.open_timeout = 30
         http.read_timeout = timeout
         http.keep_alive_timeout = 30
 
-        ssl_verify = ENV.fetch("E2B_SSL_VERIFY", "true").downcase != "false"
-        http.verify_mode = ssl_verify ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+        if http.use_ssl?
+          ssl_verify = ENV.fetch("E2B_SSL_VERIFY", "true").downcase != "false"
+          http.verify_mode = ssl_verify ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+        end
 
         http
       end
 
-      def with_retry(operation, max_retries: 3)
+      def resolve_proxy(url)
+        no_proxy = ENV["no_proxy"] || ENV["NO_PROXY"]
+        if no_proxy
+          no_proxy_hosts = no_proxy.split(",").map(&:strip)
+          return nil if no_proxy_hosts.any? { |h| url.host.end_with?(h) || h == "*" }
+        end
+
+        proxy_env = url.scheme == "https" ? (ENV["https_proxy"] || ENV["HTTPS_PROXY"]) : (ENV["http_proxy"] || ENV["HTTP_PROXY"])
+        return nil unless proxy_env
+
+        URI.parse(proxy_env)
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def with_retry(operation, max_retries: 3, abort_if: nil)
         retry_count = 0
 
         begin
           yield
         rescue OpenSSL::SSL::SSLError, Errno::ECONNRESET, EOFError, Net::OpenTimeout, Net::ReadTimeout => e
+          if abort_if && abort_if.call
+            log_debug("#{operation}: not retrying (#{e.class}); request had observable side effects")
+            raise E2B::E2BError, "#{operation} failed after partial response: #{e.message}"
+          end
+
           retry_count += 1
 
           if retry_count <= max_retries
@@ -467,7 +555,11 @@ module E2B
       def create_connect_envelope(json_message)
         flags = "\x00".b
         length = [json_message.bytesize].pack("N")
-        flags + length + json_message
+        # Force binary encoding on the payload so concatenation with the binary
+        # frame header (flags + length) doesn't raise Encoding::CompatibilityError
+        # when the packed length contains bytes >= 0x80 (json_message.bytesize >= 32768)
+        # or json_message itself has multibyte UTF-8 characters.
+        flags + length + json_message.b
       end
 
       def parse_exit_code(value)
@@ -480,7 +572,7 @@ module E2B
         elsif str =~ /^(\d+)$/
           $1.to_i
         else
-          str.include?("0") ? 0 : 1
+          1
         end
       end
 

data/lib/e2b/services/commands.rb

@@ -166,6 +166,22 @@ module E2B
           timeout: request_timeout || 30)
       end
 
+      # Close the stdin of a running process.
+      #
+      # After calling this, no more input can be sent to the process via
+      # {#send_stdin}.
+      #
+      # @param pid [Integer] Process ID
+      # @param request_timeout [Integer, nil] Request timeout in seconds
+      # @return [void]
+      # @raise [E2B::E2BError] if the process is not found
+      def close_stdin(pid, request_timeout: nil, headers: nil)
+        envd_rpc("process.Process", "CloseStdin",
+          body: { process: { pid: pid } },
+          headers: headers,
+          timeout: request_timeout || 30)
+      end
+
       # Connect to a running process
       #
       # @param pid [Integer] Process ID to connect to

data/lib/e2b/services/filesystem.rb

@@ -109,6 +109,10 @@ module E2B
 
       # Check if a path exists
       #
+      # Only NotFoundError is treated as "does not exist". Other errors
+      # (auth, network, server) propagate so callers can distinguish
+      # "file is gone" from "we couldn't ask".
+      #
       # @param path [String] Path to check
       # @param user [String] Username context
       # @param request_timeout [Integer] Request timeout in seconds
@@ -116,7 +120,7 @@ module E2B
       def exists?(path, user: nil, request_timeout: 30)
         get_info(path, user: user, request_timeout: request_timeout)
         true
-      rescue E2B::NotFoundError, E2B::E2BError
+      rescue E2B::NotFoundError
         false
       end
 

data/lib/e2b/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module E2B
-  VERSION = "0.3.0"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: e2b
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Tao Luo
 bindir: bin
 cert_chain: []
-date: 2026-03-13 00:00:00.000000000 Z
+date: 2026-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -57,20 +57,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
-- !ruby/object:Gem::Dependency
-  name: ostruct
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.6'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement