e2b 0.3.3 → 0.3.5

data/lib/e2b/services/base_service.rb

@@ -4,6 +4,7 @@ require "base64"
 require "net/http"
 require "openssl"
 require "rubygems/version"
+require_relative "envd_base64"
 
 module E2B
   module Services
@@ -14,7 +15,7 @@ module E2B
     # Connect RPC protocol (gRPC-over-HTTP with JSON encoding).
     class BaseService
       # Default envd port
-      ENVD_PORT = 49983
+      ENVD_PORT = 49_983
       DEFAULT_USERNAME = "user"
       ENVD_DEFAULT_USER_VERSION = Gem::Version.new("0.4.0")
       ENVD_RECURSIVE_WATCH_VERSION = Gem::Version.new("0.1.4")
@@ -149,7 +150,7 @@ module E2B
         end
       end
 
-      def initialize(base_url:, api_key:, access_token: nil, sandbox_id:, logger: nil)
+      def initialize(base_url:, api_key:, sandbox_id:, access_token: nil, logger: nil)
         @base_url = base_url.end_with?("/") ? base_url : "#{base_url}/"
         @api_key = api_key
         @access_token = access_token
@@ -202,16 +203,14 @@ module E2B
 
         log_debug("RPC #{service}/#{method}")
 
-        if on_event
-          return handle_streaming_rpc(path, envelope, timeout, on_event, headers)
-        end
+        return handle_streaming_rpc(path, envelope, timeout, on_event, headers) if on_event
 
         # 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}")
+            url = URI.parse("#{@base_url.chomp("/")}#{path}")
             http = build_http(url, timeout)
 
             request = Net::HTTP::Post.new(url.request_uri)
@@ -250,17 +249,35 @@ module E2B
       # 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.
+      # Retry policy:
+      #
+      # * `process.Process/Start` is **never retried**. The POST may have
+      #   already reached envd and triggered a process spawn before the
+      #   transport error surfaced; retrying would race a second process
+      #   against the first. We've seen `git clone` fail with "destination
+      #   already exists" exactly this way — first attempt spawns a process
+      #   that mkdir's the target, transport blips, retry spawns process #2
+      #   that finds the target non-empty. Caller decides what to do.
+      #
+      # * Other streaming paths (`Connect` re-attach, etc.) retry while no
+      #   events have been emitted yet. Once any byte has been delivered
+      #   via on_event, a retry would replay output to the caller, so we
+      #   abort.
       def handle_streaming_rpc(path, envelope, timeout, on_event, headers)
         result = { events: [], stdout: "", stderr: "", exit_code: nil }
         buffer = "".b
 
         full_path = normalize_path(path)
+        non_idempotent = path.end_with?("/Start")
+
+        retry_opts =
+          if non_idempotent
+            { max_retries: 0 }
+          else
+            { abort_if: -> { result[:events].any? } }
+          end
 
-        with_retry("Streaming RPC #{path}", abort_if: -> { result[:events].any? }) do
+        with_retry("Streaming RPC #{path}", **retry_opts) do
           ssl_verify = ENV.fetch("E2B_SSL_VERIFY", "true").downcase != "false"
 
           streaming_conn = Faraday.new(url: @base_url, ssl: { verify: ssl_verify }) do |conn|
@@ -286,10 +303,11 @@ module E2B
             req.body = envelope
             req.options.on_data = proc do |chunk, _overall_size, _env|
               next if chunk.nil? || chunk.empty?
+
               buffer << chunk
 
               while buffer.bytesize >= 5
-                flags = buffer.getbyte(0)
+                buffer.getbyte(0)
                 length = buffer.byteslice(1, 4).unpack1("N")
 
                 break if length.nil? || buffer.bytesize < 5 + length
@@ -315,29 +333,28 @@ module E2B
 
                     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"]
+                      stdout_data = EnvdBase64.decode_process_output(data_event["stdout"]) if data_event["stdout"]
+                      stderr_data = EnvdBase64.decode_process_output(data_event["stderr"]) if data_event["stderr"]
                       result[:stdout] += stdout_data if stdout_data
                       result[:stderr] += stderr_data if stderr_data
                     end
 
                     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"])
+                      result[:exit_code] =
+                        parse_exit_code(end_event["exitCode"] || end_event["exit_code"] || end_event["status"])
                     end
                   end
 
                   if msg["stdout"]
-                    stdout_data = decode_base64(msg["stdout"])
+                    stdout_data = EnvdBase64.decode_process_output(msg["stdout"])
                     result[:stdout] += stdout_data
                   end
                   if msg["stderr"]
-                    stderr_data = decode_base64(msg["stderr"])
+                    stderr_data = EnvdBase64.decode_process_output(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
+                  result[:exit_code] = parse_exit_code(msg["exitCode"] || msg["exit_code"]) if msg["exitCode"] || msg["exit_code"]
 
                   on_event.call(
                     stdout: stdout_data,
@@ -352,9 +369,7 @@ module E2B
             end
           end
 
-          unless response.status.between?(200, 299)
-            handle_error(response)
-          end
+          handle_error(response) unless response.status.between?(200, 299)
         end
 
         result
@@ -409,13 +424,20 @@ module E2B
       end
 
       def resolve_proxy(url)
-        no_proxy = ENV["no_proxy"] || ENV["NO_PROXY"]
+        no_proxy = ENV["no_proxy"] || ENV.fetch("NO_PROXY", nil)
         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"])
+        proxy_env = if url.scheme == "https"
+                      ENV["https_proxy"] || ENV.fetch("HTTPS_PROXY",
+                                                      nil)
+                    else
+                      ENV["http_proxy"] || ENV.fetch(
+                        "HTTP_PROXY", nil
+                      )
+                    end
         return nil unless proxy_env
 
         URI.parse(proxy_env)
@@ -436,14 +458,12 @@ module E2B
 
           retry_count += 1
 
-          if retry_count <= max_retries
-            sleep_time = 2**retry_count
-            log_debug("#{operation}: retry #{retry_count}/#{max_retries} after #{e.class}: #{e.message}")
-            sleep(sleep_time)
-            retry
-          else
-            raise E2B::E2BError, "#{operation} failed after #{max_retries} retries: #{e.message}"
-          end
+          raise E2B::E2BError, "#{operation} failed after #{max_retries} retries: #{e.message}" unless retry_count <= max_retries
+
+          sleep_time = 2**retry_count
+          log_debug("#{operation}: retry #{retry_count}/#{max_retries} after #{e.class}: #{e.message}")
+          sleep(sleep_time)
+          retry
         end
       end
 
@@ -454,7 +474,11 @@ module E2B
         body = response.body
 
         if body.is_a?(String) && !body.empty?
-          content_type = response.headers["content-type"] rescue "unknown"
+          content_type = begin
+            response.headers["content-type"]
+          rescue StandardError
+            "unknown"
+          end
           if content_type&.include?("json") || body.start_with?("{", "[")
             begin
               return JSON.parse(body)
@@ -471,7 +495,7 @@ module E2B
         raise E2B::E2BError, "Connection to sandbox failed: #{e.message}"
       end
 
-      def handle_rpc_response(service, method)
+      def handle_rpc_response(_service, _method)
         response = yield
 
         handle_error(response) unless response.success?
@@ -484,36 +508,32 @@ module E2B
         messages = parse_connect_stream(body)
 
         messages.each do |msg_str|
-          begin
-            msg = JSON.parse(msg_str)
-            msg = msg["result"] if msg["result"]
+          msg = JSON.parse(msg_str)
+          msg = msg["result"] if msg["result"]
 
-            result[:events] << msg
+          result[:events] << msg
 
-            if msg["event"]
-              event = msg["event"]
-
-              data_event = event["Data"] || event["data"]
-              if data_event
-                result[:stdout] += decode_base64(data_event["stdout"]) if data_event["stdout"]
-                result[:stderr] += decode_base64(data_event["stderr"]) if data_event["stderr"]
-              end
+          if msg["event"]
+            event = msg["event"]
 
-              end_event = event["End"] || event["end"]
-              if end_event
-                exit_value = end_event["exitCode"] || end_event["exit_code"] || end_event["status"]
-                result[:exit_code] = parse_exit_code(exit_value)
-              end
+            data_event = event["Data"] || event["data"]
+            if data_event
+              result[:stdout] += EnvdBase64.decode_process_output(data_event["stdout"]) if data_event["stdout"]
+              result[:stderr] += EnvdBase64.decode_process_output(data_event["stderr"]) if data_event["stderr"]
             end
 
-            result[:stdout] += decode_base64(msg["stdout"]) if msg["stdout"]
-            result[:stderr] += decode_base64(msg["stderr"]) if msg["stderr"]
-            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
+              exit_value = end_event["exitCode"] || end_event["exit_code"] || end_event["status"]
+              result[:exit_code] = parse_exit_code(exit_value)
             end
-          rescue JSON::ParserError
-            # Skip unparseable messages
           end
+
+          result[:stdout] += EnvdBase64.decode_process_output(msg["stdout"]) if msg["stdout"]
+          result[:stderr] += EnvdBase64.decode_process_output(msg["stderr"]) if msg["stderr"]
+          result[:exit_code] = parse_exit_code(msg["exitCode"] || msg["exit_code"]) if msg["exitCode"] || msg["exit_code"]
+        rescue JSON::ParserError
+          # Skip unparseable messages
         end
 
         result
@@ -568,22 +588,14 @@ module E2B
 
         str = value.to_s
         if str =~ /exit status (\d+)/i
-          $1.to_i
+          ::Regexp.last_match(1).to_i
         elsif str =~ /^(\d+)$/
-          $1.to_i
+          ::Regexp.last_match(1).to_i
         else
           1
         end
       end
 
-      def decode_base64(data)
-        return "" if data.nil? || data.empty?
-
-        Base64.decode64(data)
-      rescue StandardError
-        data.to_s
-      end
-
       def handle_error(response)
         message = extract_error_message(response)
         status = response.status

data/lib/e2b/services/command_handle.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "base64"
+require_relative "envd_base64"
 
 module E2B
   module Services
@@ -189,9 +189,7 @@ module E2B
       # @raise [CommandExitError] if exit code is non-zero
       def wait(on_stdout: nil, on_stderr: nil, on_pty: nil)
         consume_events(on_stdout: on_stdout, on_stderr: on_stderr, on_pty: on_pty)
-        unless @disconnected || completed?
-          raise E2BError, "Command ended without an end event"
-        end
+        raise E2BError, "Command ended without an end event" unless @disconnected || completed?
 
         build_result.tap do |cmd_result|
           unless cmd_result.success?
@@ -269,15 +267,9 @@ module E2B
         return if @finished
 
         each do |stdout_chunk, stderr_chunk, pty_chunk|
-          if stdout_chunk
-            on_stdout&.call(stdout_chunk)
-          end
-          if stderr_chunk
-            on_stderr&.call(stderr_chunk)
-          end
-          if pty_chunk
-            on_pty&.call(pty_chunk)
-          end
+          on_stdout&.call(stdout_chunk) if stdout_chunk
+          on_stderr&.call(stderr_chunk) if stderr_chunk
+          on_pty&.call(pty_chunk) if pty_chunk
         end
 
         @finished = true
@@ -306,7 +298,7 @@ module E2B
       #
       # @yield [stdout, stderr, pty]
       # @return [void]
-      def iterate_materialized_events
+      def iterate_materialized_events(&block)
         events = result_value(:events) || []
         while @materialized_event_index < events.length
           break if @disconnected
@@ -314,9 +306,7 @@ module E2B
           event_hash = events[@materialized_event_index]
           @materialized_event_index += 1
 
-          process_message(event_hash) do |stdout_chunk, stderr_chunk, pty_chunk|
-            yield stdout_chunk, stderr_chunk, pty_chunk
-          end
+          process_message(event_hash, &block)
         end
       end
 
@@ -327,14 +317,12 @@ module E2B
       #
       # @yield [stdout, stderr, pty]
       # @return [void]
-      def iterate_streaming_events
+      def iterate_streaming_events(&block)
         catch(:stop_iteration) do
           @events_proc.call do |event_hash|
             throw :stop_iteration if @disconnected
 
-            process_message(event_hash) do |stdout_chunk, stderr_chunk, pty_chunk|
-              yield stdout_chunk, stderr_chunk, pty_chunk
-            end
+            process_message(event_hash, &block)
           end
         end
       end
@@ -353,15 +341,15 @@ module E2B
       # @param message [Hash] A raw stream message
       # @yield [stdout, stderr, pty]
       # @return [void]
-      def process_message(message)
+      def process_message(message, &block)
         return unless message.is_a?(Hash)
 
         event = message["event"]
-        process_event(event) { |stdout_chunk, stderr_chunk, pty_chunk| yield stdout_chunk, stderr_chunk, pty_chunk } if event.is_a?(Hash)
+        process_event(event, &block) if event.is_a?(Hash)
 
         if event.nil?
-          stdout_chunk = decode_base64(message["stdout"])
-          stderr_chunk = decode_base64(message["stderr"])
+          stdout_chunk = EnvdBase64.decode_process_output(message["stdout"])
+          stderr_chunk = EnvdBase64.decode_process_output(message["stderr"])
 
           if stdout_chunk && !stdout_chunk.empty?
             append_stdout(stdout_chunk)
@@ -387,9 +375,9 @@ module E2B
         # Handle Data event
         data_event = event["Data"] || event["data"]
         if data_event
-          stdout_chunk = decode_base64(data_event["stdout"])
-          stderr_chunk = decode_base64(data_event["stderr"])
-          pty_chunk = decode_base64(data_event["pty"])
+          stdout_chunk = EnvdBase64.decode_process_output(data_event["stdout"])
+          stderr_chunk = EnvdBase64.decode_process_output(data_event["stderr"])
+          pty_chunk = EnvdBase64.decode_process_output(data_event["pty"])
 
           if stdout_chunk && !stdout_chunk.empty?
             append_stdout(stdout_chunk)
@@ -467,18 +455,6 @@ module E2B
         nil
       end
 
-      # Decode a base64-encoded string.
-      #
-      # @param data [String, nil] Base64-encoded data
-      # @return [String, nil] Decoded string, or nil if input is nil/empty
-      def decode_base64(data)
-        return nil if data.nil? || data.empty?
-
-        Base64.decode64(data).force_encoding("UTF-8")
-      rescue StandardError
-        data.to_s
-      end
-
       # Parse an exit code from various envd response formats.
       #
       # Handles integer values, string integers, and "exit status N" strings.

data/lib/e2b/services/commands.rb

@@ -25,6 +25,7 @@ module E2B
     #   handle.kill
     class Commands < BaseService
       include LiveStreamable
+
       # Run a command in the sandbox
       #
       # @param cmd [String] Command to execute (run via /bin/bash -l -c)
@@ -36,11 +37,15 @@ module E2B
       # @param on_stderr [Proc, nil] Callback for stderr data
       # @param timeout [Integer] Command timeout in seconds (default: 60)
       # @param request_timeout [Integer, nil] HTTP request timeout in seconds
+      # @param stdin [Boolean] Allocate a stdin pipe for the process. Required
+      #   when the caller plans to use {#send_stdin} or {CommandHandle#send_stdin}
+      #   on a background handle. Defaults to +false+ to mirror TS/Python SDKs.
       # @return [CommandResult, CommandHandle] Result or handle for background commands
       #
       # @raise [CommandExitError] If exit code is non-zero (foreground only)
       def run(cmd, background: false, envs: nil, user: nil, cwd: nil,
-              on_stdout: nil, on_stderr: nil, timeout: 60, request_timeout: nil, &block)
+              on_stdout: nil, on_stderr: nil, timeout: 60, request_timeout: nil,
+              stdin: false, &block)
         # Build the process spec - official SDK always uses /bin/bash -l -c
         process_spec = {
           cmd: "/bin/bash",
@@ -55,7 +60,7 @@ module E2B
 
         process_spec[:cwd] = cwd if cwd
 
-        body = { process: process_spec }
+        body = { process: process_spec, stdin: stdin }
         headers = user_auth_headers(user)
 
         # Set up streaming callback
@@ -89,10 +94,10 @@ module E2B
         end
 
         response = envd_rpc("process.Process", "Start",
-          body: body,
-          timeout: effective_timeout,
-          headers: headers,
-          on_event: streaming_callback)
+                            body: body,
+                            timeout: effective_timeout,
+                            headers: headers,
+                            on_event: streaming_callback)
 
         # Return CommandResult for foreground processes
         result = build_result(response)
@@ -116,16 +121,15 @@ module E2B
       # @return [Array<Hash>] List of running processes with pid, config, tag
       def list(request_timeout: nil)
         response = envd_rpc("process.Process", "List",
-          body: {},
-          timeout: request_timeout || 30)
+                            body: {},
+                            timeout: request_timeout || 30)
 
         processes = []
         events = response[:events] || []
         events.each do |event|
           next unless event.is_a?(Hash)
-          if event["processes"]
-            processes.concat(Array(event["processes"]))
-          end
+
+          processes.concat(Array(event["processes"])) if event["processes"]
         end
         processes
       end
@@ -137,12 +141,12 @@ module E2B
       # @return [Boolean] true if killed, false if not found
       def kill(pid, request_timeout: nil, headers: nil)
         envd_rpc("process.Process", "SendSignal",
-          body: {
-            process: { pid: pid },
-            signal: 9 # SIGKILL
-          },
-          headers: headers,
-          timeout: request_timeout || 30)
+                 body: {
+                   process: { pid: pid },
+                   signal: 9 # SIGKILL
+                 },
+                 headers: headers,
+                 timeout: request_timeout || 30)
         true
       rescue E2B::NotFoundError
         false
@@ -150,7 +154,11 @@ module E2B
         false
       end
 
-      # Send stdin data to a running process
+      # Send stdin data to a running process.
+      #
+      # The target process must have been started with +stdin: true+ (see {#run})
+      # — otherwise envd silently drops the input and the call is a no-op on the
+      # process side.
       #
       # @param pid [Integer] Process ID
       # @param data [String] Data to send to stdin
@@ -158,12 +166,12 @@ module E2B
       def send_stdin(pid, data, request_timeout: nil, headers: nil)
         encoded = Base64.strict_encode64(data.to_s)
         envd_rpc("process.Process", "SendInput",
-          body: {
-            process: { pid: pid },
-            input: { stdin: encoded }
-          },
-          headers: headers,
-          timeout: request_timeout || 30)
+                 body: {
+                   process: { pid: pid },
+                   input: { stdin: encoded }
+                 },
+                 headers: headers,
+                 timeout: request_timeout || 30)
       end
 
       # Close the stdin of a running process.
@@ -177,9 +185,9 @@ module E2B
       # @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)
+                 body: { process: { pid: pid } },
+                 headers: headers,
+                 timeout: request_timeout || 30)
       end
 
       # Connect to a running process
@@ -214,10 +222,9 @@ module E2B
         events = response[:events] || []
         events.each do |event|
           next unless event.is_a?(Hash) && event["event"]
+
           end_event = event["event"]["End"] || event["event"]["end"]
-          if end_event
-            error = end_event["error"] if end_event["error"] && !end_event["error"].empty?
-          end
+          error = end_event["error"] if end_event && end_event["error"] && !end_event["error"].empty?
         end
 
         CommandResult.new(

data/lib/e2b/services/envd_base64.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module E2B
+  module Services
+    # Base64 payloads from envd wrap raw subprocess / PTY bytes.
+    module EnvdBase64
+      module_function
+
+      # @param data [String, nil] base64-encoded chunk from envd
+      # @return [String] UTF-8 string with invalid byte sequences scrubbed; "" if +data+ is nil or empty
+      def decode_process_output(data)
+        return "" if data.nil? || data.empty?
+
+        Base64.decode64(data).force_encoding(Encoding::UTF_8).scrub
+      rescue StandardError
+        data.to_s
+      end
+    end
+  end
+end