e2b 0.2.0 → 0.3.0

data/lib/e2b/services/filesystem.rb

@@ -5,6 +5,7 @@ require "net/http"
 require "openssl"
 require "uri"
 require "json"
+require "stringio"
 
 module E2B
   module Services
@@ -24,8 +25,6 @@ module E2B
     #   entries = sandbox.files.list("/home/user")
     class Filesystem < BaseService
       # Default username for file operations
-      DEFAULT_USER = "user"
-
       # Read file content
       #
       # @param path [String] File path in the sandbox
@@ -36,10 +35,20 @@ module E2B
       #
       # @example
       #   content = sandbox.files.read("/home/user/config.json")
-      def read(path, format: "text", user: DEFAULT_USER, request_timeout: 120)
+      def read(path, format: "text", user: nil, request_timeout: 120)
         url = build_file_url("/files", path: path, user: user)
         response = rest_get(url, timeout: request_timeout)
-        response
+
+        case format
+        when "text"
+          response.dup.force_encoding("UTF-8")
+        when "bytes"
+          response.b
+        when "stream"
+          StringIO.new(response.b)
+        else
+          raise ArgumentError, "Unsupported read format '#{format}'"
+        end
       end
 
       # Write content to a file using REST upload
@@ -48,14 +57,15 @@ module E2B
       # @param data [String, IO] Content to write (string or IO object)
       # @param user [String] Username context for the operation
       # @param request_timeout [Integer] Request timeout in seconds
-      # @return [Models::EntryInfo, nil] Info about the written file
+      # @return [Models::WriteInfo] Info about the written file
       #
       # @example
       #   sandbox.files.write("/home/user/output.txt", "Hello, World!")
-      def write(path, data, user: DEFAULT_USER, request_timeout: 120)
+      def write(path, data, user: nil, request_timeout: 120)
         url = build_file_url("/files", path: path, user: user)
         content = data.is_a?(IO) || data.respond_to?(:read) ? data.read : data.to_s
-        rest_upload(url, content, timeout: request_timeout)
+        result = rest_upload(url, content, timeout: request_timeout)
+        build_write_info(result, default_path: path)
       end
 
       # Write multiple files at once
@@ -70,7 +80,7 @@ module E2B
       #     { path: "/home/user/a.txt", data: "Content A" },
       #     { path: "/home/user/b.txt", data: "Content B" }
       #   ])
-      def write_files(files, user: DEFAULT_USER, request_timeout: 120)
+      def write_files(files, user: nil, request_timeout: 120)
         files.map do |file|
           write(file[:path], file[:data] || file[:content], user: user, request_timeout: request_timeout)
         end
@@ -87,10 +97,11 @@ module E2B
       # @example
       #   entries = sandbox.files.list("/home/user")
       #   entries.each { |e| puts "#{e.name} (#{e.type})" }
-      def list(path, depth: 1, user: DEFAULT_USER, request_timeout: 60)
+      def list(path, depth: 1, user: nil, request_timeout: 60)
         response = envd_rpc("filesystem.Filesystem", "ListDir",
           body: { path: path, depth: depth },
-          timeout: request_timeout)
+          timeout: request_timeout,
+          headers: user_auth_headers(user))
 
         entries = extract_entries(response)
         entries.map { |e| Models::EntryInfo.from_hash(e) }
@@ -102,7 +113,7 @@ module E2B
       # @param user [String] Username context
       # @param request_timeout [Integer] Request timeout in seconds
       # @return [Boolean]
-      def exists?(path, user: DEFAULT_USER, request_timeout: 30)
+      def exists?(path, user: nil, request_timeout: 30)
         get_info(path, user: user, request_timeout: request_timeout)
         true
       rescue E2B::NotFoundError, E2B::E2BError
@@ -115,10 +126,11 @@ module E2B
       # @param user [String] Username context
       # @param request_timeout [Integer] Request timeout in seconds
       # @return [Models::EntryInfo] File/directory info
-      def get_info(path, user: DEFAULT_USER, request_timeout: 30)
+      def get_info(path, user: nil, request_timeout: 30)
         response = envd_rpc("filesystem.Filesystem", "Stat",
           body: { path: path },
-          timeout: request_timeout)
+          timeout: request_timeout,
+          headers: user_auth_headers(user))
 
         entry_data = extract_entry(response)
         Models::EntryInfo.from_hash(entry_data)
@@ -129,10 +141,11 @@ module E2B
       # @param path [String] Path to remove
       # @param user [String] Username context
       # @param request_timeout [Integer] Request timeout in seconds
-      def remove(path, user: DEFAULT_USER, request_timeout: 30)
+      def remove(path, user: nil, request_timeout: 30)
         envd_rpc("filesystem.Filesystem", "Remove",
           body: { path: path },
-          timeout: request_timeout)
+          timeout: request_timeout,
+          headers: user_auth_headers(user))
       end
 
       # Rename/move a file or directory
@@ -142,10 +155,11 @@ module E2B
       # @param user [String] Username context
       # @param request_timeout [Integer] Request timeout in seconds
       # @return [Models::EntryInfo] Info about the moved entry
-      def rename(old_path, new_path, user: DEFAULT_USER, request_timeout: 30)
+      def rename(old_path, new_path, user: nil, request_timeout: 30)
         response = envd_rpc("filesystem.Filesystem", "Move",
           body: { source: old_path, destination: new_path },
-          timeout: request_timeout)
+          timeout: request_timeout,
+          headers: user_auth_headers(user))
 
         entry_data = extract_entry(response)
         Models::EntryInfo.from_hash(entry_data)
@@ -157,10 +171,11 @@ module E2B
       # @param user [String] Username context
       # @param request_timeout [Integer] Request timeout in seconds
       # @return [Boolean] true if created successfully
-      def make_dir(path, user: DEFAULT_USER, request_timeout: 30)
+      def make_dir(path, user: nil, request_timeout: 30)
         envd_rpc("filesystem.Filesystem", "MakeDir",
           body: { path: path },
-          timeout: request_timeout)
+          timeout: request_timeout,
+          headers: user_auth_headers(user))
         true
       end
 
@@ -180,10 +195,16 @@ module E2B
       #   events = handle.get_new_events
       #   events.each { |e| puts "#{e.type}: #{e.name}" }
       #   handle.stop
-      def watch_dir(path, recursive: false, user: DEFAULT_USER, request_timeout: 30)
+      def watch_dir(path, recursive: false, user: nil, request_timeout: 30)
+        if recursive && !supports_recursive_watch?
+          raise E2B::TemplateError,
+            "You need to update the template to use recursive watching. You can do this by running `e2b template build` in the directory with the template."
+        end
+
         response = envd_rpc("filesystem.Filesystem", "CreateWatcher",
           body: { path: path, recursive: recursive },
-          timeout: request_timeout)
+          timeout: request_timeout,
+          headers: user_auth_headers(user))
 
         watcher_id = response[:events]&.first&.dig("watcherId") ||
                      response["watcherId"] ||
@@ -192,7 +213,11 @@ module E2B
         raise E2B::E2BError, "Failed to create watcher: no watcher_id returned" unless watcher_id
 
         rpc_proc = method(:envd_rpc)
-        WatchHandle.new(watcher_id: watcher_id, envd_rpc_proc: rpc_proc)
+        WatchHandle.new(
+          watcher_id: watcher_id,
+          envd_rpc_proc: rpc_proc,
+          headers: user_auth_headers(user)
+        )
       end
 
       # Backward-compatible aliases
@@ -209,6 +234,7 @@ module E2B
 
       # Build URL for file operations
       def build_file_url(endpoint, path: nil, user: nil)
+        user = resolve_username(user)
         base = "https://#{ENVD_PORT}-#{@sandbox_id}.#{@sandbox_domain}"
         url = "#{base}#{endpoint}"
         params = []
@@ -255,7 +281,7 @@ module E2B
             raise E2B::E2BError, "File upload failed: HTTP #{response.code}"
           end
 
-          true
+          parse_upload_response(response.body)
         end
       end
 
@@ -287,6 +313,14 @@ module E2B
         request["User-Agent"] = "e2b-ruby-sdk/#{E2B::VERSION}"
       end
 
+      def parse_upload_response(body)
+        return [] if body.nil? || body.empty?
+
+        JSON.parse(body)
+      rescue JSON::ParserError
+        []
+      end
+
       def ssl_verify_mode
         ssl_verify = ENV.fetch("E2B_SSL_VERIFY", "true").downcase != "false"
         ssl_verify ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
@@ -368,6 +402,19 @@ module E2B
 
         nil
       end
+
+      def build_write_info(result, default_path:)
+        case result
+        when Array
+          entry = result.first
+          return build_write_info(entry, default_path: default_path) if entry
+        when Hash
+          path = result["path"] || result[:path] || default_path
+          return Models::WriteInfo.new(path: path)
+        end
+
+        Models::WriteInfo.new(path: default_path)
+      end
     end
   end
 end

data/lib/e2b/services/live_streamable.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module E2B
+  module Services
+    # Shared live-stream handle builder for Commands and Pty.
+    #
+    # Both services need to start a background thread that runs an envd RPC,
+    # extract the PID from the first Start event, and return a CommandHandle
+    # wired to a LiveEventStream. This module keeps that logic in one place.
+    module LiveStreamable
+      private
+
+      def build_live_handle(rpc_method:, body:, timeout:, headers: nil, on_stdout: nil, on_stderr: nil, &block)
+        stream = LiveEventStream.new
+        start_queue = Queue.new
+        start_signal_sent = false
+        pid = nil
+        stream_block = block
+
+        stream_thread = Thread.new do
+          Thread.current.report_on_exception = false if Thread.current.respond_to?(:report_on_exception=)
+
+          begin
+            envd_rpc("process.Process", rpc_method,
+              body: body,
+              timeout: timeout,
+              headers: headers,
+              on_event: lambda { |event_data|
+                stream_event = event_data[:event]
+                stream.push(stream_event) if stream_event
+
+                stdout_chunk = event_data[:stdout]
+                stderr_chunk = event_data[:stderr]
+
+                on_stdout&.call(stdout_chunk) if stdout_chunk && !stdout_chunk.empty?
+                on_stderr&.call(stderr_chunk) if stderr_chunk && !stderr_chunk.empty?
+
+                stream_block&.call(:stdout, stdout_chunk) if stdout_chunk && !stdout_chunk.empty?
+                stream_block&.call(:stderr, stderr_chunk) if stderr_chunk && !stderr_chunk.empty?
+
+                unless start_signal_sent
+                  extracted_pid = extract_pid_from_event(stream_event)
+                  if extracted_pid
+                    pid = extracted_pid
+                    start_signal_sent = true
+                    start_queue << [:pid, pid]
+                  end
+                end
+              })
+
+            unless start_signal_sent
+              start_signal_sent = true
+              start_queue << [:error, E2BError.new("Failed to start process: expected start event")]
+            end
+          rescue StandardError => e
+            unless start_signal_sent
+              start_signal_sent = true
+              start_queue << [:error, e]
+            end
+
+            stream.fail(e)
+          ensure
+            stream.close
+          end
+        end
+
+        start_state, start_value = start_queue.pop
+        raise start_value if start_state == :error
+
+        CommandHandle.new(
+          pid: pid,
+          handle_kill: -> { kill(pid, headers: headers) },
+          handle_send_stdin: ->(data) { send_stdin(pid, data, headers: headers) },
+          handle_disconnect: -> { disconnect_live_stream(stream_thread, stream) },
+          events_proc: ->(&events_block) { stream.each(&events_block) }
+        )
+      end
+
+      def extract_pid_from_event(event)
+        return nil unless event.is_a?(Hash) && event["event"].is_a?(Hash)
+
+        start_event = event["event"]["Start"] || event["event"]["start"]
+        return nil unless start_event && start_event["pid"]
+
+        start_event["pid"].to_i
+      end
+
+      def disconnect_live_stream(stream_thread, stream)
+        stream.close(discard_pending: true)
+        stream_thread.kill if stream_thread&.alive?
+      end
+    end
+  end
+end

data/lib/e2b/services/pty.rb

@@ -53,6 +53,7 @@ module E2B
     # @example Connect to an existing PTY
     #   handle = pty.connect(pid)
     class Pty < BaseService
+      include LiveStreamable
       # Default shell to use for PTY sessions
       DEFAULT_SHELL = "/bin/bash"
 
@@ -84,6 +85,7 @@ module E2B
       def create(size: PtySize.new, user: nil, cwd: nil, envs: nil,
                  cmd: DEFAULT_SHELL, args: DEFAULT_SHELL_ARGS, timeout: 60)
         envs = build_pty_envs(envs)
+        headers = user_auth_headers(user)
 
         process_spec = {
           cmd: cmd,
@@ -99,34 +101,11 @@ module E2B
           }
         }
 
-        pid = nil
-
-        # Use streaming RPC to capture the StartEvent and extract the PID
-        on_event = ->(event_data) {
-          event = event_data[:event]
-          if event.is_a?(Hash) && event["event"]
-            start_event = event["event"]["Start"] || event["event"]["start"]
-            if start_event && start_event["pid"]
-              pid = start_event["pid"]
-            end
-          end
-        }
-
-        response = envd_rpc(
-          "process.Process", "Start",
+        build_live_handle(
+          rpc_method: "Start",
           body: body,
-          timeout: timeout + 30,
-          on_event: on_event
-        )
-
-        # If PID was not captured from streaming, try the accumulated result
-        pid ||= extract_pid_from_result(response)
-
-        CommandHandle.new(
-          pid: pid,
-          handle_kill: -> { kill(pid) },
-          handle_send_stdin: ->(data) { send_stdin(pid, data) },
-          result: response
+          headers: headers,
+          timeout: timeout + 30
         )
       end
 
@@ -148,18 +127,12 @@ module E2B
           process: { pid: pid }
         }
 
-        response = envd_rpc(
-          "process.Process", "Connect",
+        build_live_handle(
+          rpc_method: "Connect",
           body: body,
+          headers: user_auth_headers(nil),
           timeout: timeout + 30
         )
-
-        CommandHandle.new(
-          pid: pid,
-          handle_kill: -> { kill(pid) },
-          handle_send_stdin: ->(data) { send_stdin(pid, data) },
-          result: response
-        )
       end
 
       # Send input data to a PTY.
@@ -178,12 +151,12 @@ module E2B
       #
       # @example Send Ctrl+C
       #   sandbox.pty.send_stdin(pid, "\x03")
-      def send_stdin(pid, data)
+      def send_stdin(pid, data, headers: nil)
         encoded = Base64.strict_encode64(data.is_a?(String) ? data : data.to_s)
         envd_rpc("process.Process", "SendInput", body: {
           process: { pid: pid },
           input: { pty: encoded }
-        })
+        }, headers: headers)
       end
 
       # Kill a PTY process with SIGKILL.
@@ -193,11 +166,11 @@ module E2B
       #
       # @example
       #   sandbox.pty.kill(12345)
-      def kill(pid)
+      def kill(pid, headers: nil)
         envd_rpc("process.Process", "SendSignal", body: {
           process: { pid: pid },
           signal: 9 # SIGKILL
-        })
+        }, headers: headers)
         true
       rescue E2B::E2BError
         false
@@ -268,30 +241,6 @@ module E2B
         result
       end
 
-      # Extract PID from the StartEvent in a pre-materialized RPC result.
-      #
-      # The result hash from {EnvdHttpClient#handle_streaming_rpc} or
-      # {EnvdHttpClient#handle_rpc_response} contains an :events array.
-      # The first event with a Start sub-event carries the PID.
-      #
-      # @param response [Hash] RPC response hash with :events key
-      # @return [Integer, nil] Process ID, or nil if not found
-      def extract_pid_from_result(response)
-        return nil unless response.is_a?(Hash)
-
-        events = response[:events] || []
-        events.each do |event_hash|
-          next unless event_hash.is_a?(Hash) && event_hash["event"]
-
-          event = event_hash["event"]
-          start_event = event["Start"] || event["start"]
-          if start_event && start_event["pid"]
-            return start_event["pid"]
-          end
-        end
-
-        nil
-      end
     end
   end
 end

data/lib/e2b/services/watch_handle.rb

@@ -38,9 +38,10 @@ module E2B
       # @param envd_rpc_proc [Proc] A callable that performs RPC calls. It must accept
       #   three positional arguments (service, method) and keyword arguments (body:, timeout:).
       #   Typically a lambda wrapping {BaseService#envd_rpc}.
-      def initialize(watcher_id:, envd_rpc_proc:)
+      def initialize(watcher_id:, envd_rpc_proc:, headers: nil)
         @watcher_id = watcher_id
         @envd_rpc_proc = envd_rpc_proc
+        @headers = headers
         @stopped = false
       end
 
@@ -56,7 +57,8 @@ module E2B
 
         response = @envd_rpc_proc.call(
           "filesystem.Filesystem", "GetWatcherEvents",
-          body: { watcherId: @watcher_id }
+          body: { watcherId: @watcher_id },
+          headers: @headers
         )
 
         events = extract_events(response)
@@ -75,7 +77,8 @@ module E2B
 
         @envd_rpc_proc.call(
           "filesystem.Filesystem", "RemoveWatcher",
-          body: { watcherId: @watcher_id }
+          body: { watcherId: @watcher_id },
+          headers: @headers
         )
         @stopped = true
       rescue StandardError