e2b 0.2.0

data/lib/e2b/errors.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module E2B
+  # Base error class for all E2B SDK errors
+  #
+  # @attr_reader [Integer, nil] status_code HTTP status code if available
+  # @attr_reader [Hash] headers Response headers if available
+  class E2BError < StandardError
+    attr_reader :status_code, :headers
+
+    # @param message [String] Error message
+    # @param status_code [Integer, nil] HTTP status code if available
+    # @param headers [Hash] Response headers if available
+    def initialize(message = nil, status_code: nil, headers: {})
+      @status_code = status_code
+      @headers = headers || {}
+      super(message)
+    end
+  end
+
+  # Alias matching official SDK naming
+  SandboxError = E2BError
+
+  # Error raised when a requested resource is not found (HTTP 404)
+  class NotFoundError < E2BError; end
+
+  # Error raised when rate limit is exceeded (HTTP 429)
+  class RateLimitError < E2BError; end
+
+  # Error raised when an operation times out
+  class TimeoutError < E2BError; end
+
+  # Error raised when authentication fails (HTTP 401/403)
+  class AuthenticationError < E2BError; end
+
+  # Error raised when configuration is invalid
+  class ConfigurationError < E2BError; end
+
+  # Error raised when sandbox is not in expected state
+  class SandboxStateError < E2BError; end
+
+  # Error raised for conflict errors (HTTP 409)
+  class ConflictError < E2BError; end
+
+  # Error raised for invalid arguments
+  class InvalidArgumentError < E2BError; end
+
+  # Error raised when there is not enough disk space
+  class NotEnoughSpaceError < E2BError; end
+
+  # Error raised for template-related failures
+  class TemplateError < E2BError; end
+
+  # Error raised when a command exits with non-zero exit code
+  #
+  # @attr_reader [String] stdout Command stdout output
+  # @attr_reader [String] stderr Command stderr output
+  # @attr_reader [Integer] exit_code Process exit code
+  # @attr_reader [String, nil] command_error Error message from the process
+  class CommandExitError < E2BError
+    attr_reader :stdout, :stderr, :exit_code, :command_error
+
+    # @param stdout [String] Command stdout
+    # @param stderr [String] Command stderr
+    # @param exit_code [Integer] Process exit code
+    # @param error [String, nil] Error message from the process
+    def initialize(stdout: "", stderr: "", exit_code: 1, error: nil)
+      @stdout = stdout
+      @stderr = stderr
+      @exit_code = exit_code
+      @command_error = error
+      message = "Command exited with code #{exit_code}"
+      message += ": #{error}" if error
+      message += "\nStderr: #{stderr}" if stderr && !stderr.empty?
+      super(message)
+    end
+
+    def success?
+      false
+    end
+  end
+
+  # Error raised when git authentication fails
+  class GitAuthError < AuthenticationError; end
+
+  # Error raised when git upstream is missing
+  class GitUpstreamError < E2BError; end
+end

data/lib/e2b/models/entry_info.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require "time"
+
+module E2B
+  module Models
+    # File types in the sandbox filesystem
+    #
+    # Maps to the protobuf FileType enum used by the filesystem service.
+    #
+    # @example
+    #   entry.type == E2B::Models::FileType::FILE
+    #   entry.type == E2B::Models::FileType::DIRECTORY
+    module FileType
+      # Regular file (FILE_TYPE_FILE = 1)
+      FILE = "FILE"
+
+      # Directory (FILE_TYPE_DIRECTORY = 2)
+      DIRECTORY = "DIRECTORY"
+    end
+
+    # Filesystem event types from directory watching
+    #
+    # Maps to the protobuf EventType enum used by the filesystem watcher service.
+    #
+    # @example
+    #   event.type == E2B::Models::FilesystemEventType::CREATE
+    module FilesystemEventType
+      # A new file or directory was created (EVENT_TYPE_CREATE = 1)
+      CREATE = "CREATE"
+
+      # A file was written to (EVENT_TYPE_WRITE = 2)
+      WRITE = "WRITE"
+
+      # A file or directory was removed (EVENT_TYPE_REMOVE = 3)
+      REMOVE = "REMOVE"
+
+      # A file or directory was renamed (EVENT_TYPE_RENAME = 4)
+      RENAME = "RENAME"
+
+      # File permissions were changed (EVENT_TYPE_CHMOD = 5)
+      CHMOD = "CHMOD"
+    end
+
+    # Represents a filesystem event from directory watching
+    #
+    # Filesystem events are emitted when files or directories change within
+    # a watched directory. Events are retrieved by polling via {WatchHandle#get_new_events}.
+    #
+    # @example
+    #   events = watch_handle.get_new_events
+    #   events.each do |event|
+    #     puts "#{event.name} was #{event.type}"
+    #   end
+    class FilesystemEvent
+      # @return [String] Name of the file or directory that changed
+      attr_reader :name
+
+      # @return [String] Type of event (one of {FilesystemEventType} constants)
+      attr_reader :type
+
+      # @param name [String] Name of the file or directory that changed
+      # @param type [String] Type of event (one of {FilesystemEventType} constants)
+      def initialize(name:, type:)
+        @name = name
+        @type = type
+      end
+
+      # Create from RPC response hash
+      #
+      # Handles both numeric protobuf enum values and string enum names.
+      #
+      # @param data [Hash] Raw event data from the RPC response
+      # @return [FilesystemEvent]
+      def self.from_hash(data)
+        type_value = data["type"] || data[:type]
+        type_name = case type_value
+                    when 1, "EVENT_TYPE_CREATE" then FilesystemEventType::CREATE
+                    when 2, "EVENT_TYPE_WRITE" then FilesystemEventType::WRITE
+                    when 3, "EVENT_TYPE_REMOVE" then FilesystemEventType::REMOVE
+                    when 4, "EVENT_TYPE_RENAME" then FilesystemEventType::RENAME
+                    when 5, "EVENT_TYPE_CHMOD" then FilesystemEventType::CHMOD
+                    else type_value.to_s
+                    end
+        new(name: data["name"] || data[:name], type: type_name)
+      end
+    end
+
+    # Information about a filesystem entry (file or directory) in the sandbox
+    #
+    # Represents the protobuf EntryInfo message returned by filesystem RPCs
+    # such as Stat, ListDir, and others. Contains metadata including name, type,
+    # path, size, permissions, ownership, and modification time.
+    #
+    # @example
+    #   entry = sandbox.files.stat("/home/user/hello.txt")
+    #   puts entry.name          # => "hello.txt"
+    #   puts entry.size          # => 13
+    #   puts entry.file?         # => true
+    #   puts entry.directory?    # => false
+    #   puts entry.permissions   # => "0644"
+    class EntryInfo
+      # @return [String] Name of the file or directory
+      attr_reader :name
+
+      # @return [String] Type of entry (one of {FileType} constants)
+      attr_reader :type
+
+      # @return [String] Full path to the entry in the sandbox filesystem
+      attr_reader :path
+
+      # @return [Integer] Size in bytes
+      attr_reader :size
+
+      # @return [Integer] Unix file mode (e.g., 0o644)
+      attr_reader :mode
+
+      # @return [String] Permissions string (e.g., "0644")
+      attr_reader :permissions
+
+      # @return [String] Owner username
+      attr_reader :owner
+
+      # @return [String] Group name
+      attr_reader :group
+
+      # @return [Time, nil] Last modification time
+      attr_reader :modified_time
+
+      # @return [String, nil] Symlink target path, if the entry is a symlink
+      attr_reader :symlink_target
+
+      # @param name [String] Name of the file or directory
+      # @param type [String] Type of entry (one of {FileType} constants)
+      # @param path [String] Full path in the sandbox filesystem
+      # @param size [Integer] Size in bytes
+      # @param mode [Integer] Unix file mode
+      # @param permissions [String] Permissions string
+      # @param owner [String] Owner username
+      # @param group [String] Group name
+      # @param modified_time [Time, nil] Last modification time
+      # @param symlink_target [String, nil] Symlink target path
+      def initialize(name:, type:, path:, size: 0, mode: 0, permissions: "",
+                     owner: "", group: "", modified_time: nil, symlink_target: nil)
+        @name = name
+        @type = type
+        @path = path
+        @size = size
+        @mode = mode
+        @permissions = permissions
+        @owner = owner
+        @group = group
+        @modified_time = modified_time
+        @symlink_target = symlink_target
+      end
+
+      # Check if this entry is a regular file
+      #
+      # @return [Boolean]
+      def file?
+        @type == FileType::FILE
+      end
+
+      # Check if this entry is a directory
+      #
+      # @return [Boolean]
+      def directory?
+        @type == FileType::DIRECTORY
+      end
+
+      # Create from RPC response hash
+      #
+      # Handles both numeric protobuf enum values and string enum names,
+      # as well as camelCase and snake_case key formats.
+      #
+      # @param data [Hash] Raw entry data from the RPC response
+      # @return [EntryInfo, nil] The parsed entry, or nil if data is not a Hash
+      def self.from_hash(data)
+        return nil unless data.is_a?(Hash)
+
+        type_value = data["type"] || data[:type]
+        type_name = case type_value
+                    when 1, "FILE_TYPE_FILE" then FileType::FILE
+                    when 2, "FILE_TYPE_DIRECTORY" then FileType::DIRECTORY
+                    else type_value.to_s
+                    end
+
+        modified = data["modifiedTime"] || data["modified_time"] || data[:modifiedTime] || data[:modified_time]
+        modified_time = parse_modified_time(modified)
+
+        new(
+          name: data["name"] || data[:name] || "",
+          type: type_name,
+          path: data["path"] || data[:path] || "",
+          size: (data["size"] || data[:size] || 0).to_i,
+          mode: (data["mode"] || data[:mode] || 0).to_i,
+          permissions: data["permissions"] || data[:permissions] || "",
+          owner: data["owner"] || data[:owner] || "",
+          group: data["group"] || data[:group] || "",
+          modified_time: modified_time,
+          symlink_target: data["symlinkTarget"] || data["symlink_target"] || data[:symlinkTarget] || data[:symlink_target]
+        )
+      end
+
+      # Parse a modified time value from various formats
+      #
+      # @param value [Hash, String, Time, nil] The raw modified time value
+      # @return [Time, nil] Parsed time, or nil if unparseable
+      def self.parse_modified_time(value)
+        if value.is_a?(Hash)
+          # Protobuf Timestamp format: { "seconds" => ..., "nanos" => ... }
+          seconds = value["seconds"] || value[:seconds] || 0
+          Time.at(seconds.to_i)
+        elsif value.is_a?(String)
+          Time.parse(value)
+        elsif value.is_a?(Time)
+          value
+        end
+      rescue ArgumentError
+        nil
+      end
+
+      private_class_method :parse_modified_time
+    end
+
+    # Information about a file write operation
+    #
+    # Returned after writing a file to confirm the path that was written.
+    #
+    # @example
+    #   info = sandbox.files.write("/home/user/output.txt", "content")
+    #   puts info.path  # => "/home/user/output.txt"
+    class WriteInfo
+      # @return [String] Path of the written file
+      attr_reader :path
+
+      # @param path [String] Path of the written file
+      def initialize(path:)
+        @path = path
+      end
+    end
+  end
+end

data/lib/e2b/models/process_result.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module E2B
+  module Models
+    # Result of a process execution
+    class ProcessResult
+      # @return [String] Standard output
+      attr_reader :stdout
+
+      # @return [String] Standard error
+      attr_reader :stderr
+
+      # @return [Integer] Exit code
+      attr_reader :exit_code
+
+      # @return [String, nil] Error message if any
+      attr_reader :error
+
+      # Create from API response hash
+      #
+      # @param data [Hash] API response data
+      # @return [ProcessResult]
+      def self.from_hash(data)
+        new(
+          stdout: data["stdout"] || data[:stdout] || "",
+          stderr: data["stderr"] || data[:stderr] || "",
+          exit_code: data["exitCode"] || data["exit_code"] || data[:exitCode] || 0,
+          error: data["error"] || data[:error]
+        )
+      end
+
+      # Create from Connect RPC response
+      #
+      # Connect RPC responses for process.Process/Start contain:
+      # - events: Array of streaming events
+      # - stdout: Accumulated stdout
+      # - stderr: Accumulated stderr
+      # - exit_code: Process exit code
+      #
+      # @param data [Hash] Connect RPC response data
+      # @return [ProcessResult]
+      def self.from_connect_response(data)
+        return from_hash(data) unless data.is_a?(Hash)
+
+        stdout = data[:stdout] || data["stdout"] || ""
+        stderr = data[:stderr] || data["stderr"] || ""
+        exit_code = data[:exit_code] || data["exit_code"] || data["exitCode"] || 0
+        error = data[:error] || data["error"]
+
+        # If no stdout but we have events, try to extract from events
+        if stdout.empty? && data[:events].is_a?(Array)
+          data[:events].each do |event|
+            next unless event.is_a?(Hash)
+
+            # Handle nested event structure
+            if event["event"]
+              ev = event["event"]
+              if ev["Stdout"]
+                stdout += decode_base64_safe(ev["Stdout"]["data"])
+              elsif ev["stdout"]
+                stdout += decode_base64_safe(ev["stdout"]["data"])
+              elsif ev["Stderr"]
+                stderr += decode_base64_safe(ev["Stderr"]["data"])
+              elsif ev["stderr"]
+                stderr += decode_base64_safe(ev["stderr"]["data"])
+              elsif ev["Exit"]
+                exit_code = ev["Exit"]["exitCode"] || ev["Exit"]["exit_code"] || exit_code
+              elsif ev["exit"]
+                exit_code = ev["exit"]["exitCode"] || ev["exit"]["exit_code"] || exit_code
+              end
+            end
+          end
+        end
+
+        new(stdout: stdout, stderr: stderr, exit_code: parse_exit_code(exit_code), error: error)
+      end
+
+      def self.decode_base64_safe(data)
+        return "" if data.nil? || data.empty?
+
+        Base64.decode64(data)
+      rescue
+        data.to_s
+      end
+
+      # Parse exit code from various formats
+      # Handles: integer 0, string "0", string "exit status 0"
+      def self.parse_exit_code(value)
+        return 0 if value.nil?
+        return value if value.is_a?(Integer)
+
+        str = value.to_s
+        if str =~ /exit status (\d+)/i
+          $1.to_i
+        elsif str =~ /(\d+)/
+          $1.to_i
+        else
+          str.include?("0") ? 0 : 1
+        end
+      end
+
+      def initialize(stdout: "", stderr: "", exit_code: 0, error: nil)
+        @stdout = stdout
+        @stderr = stderr
+        @exit_code = exit_code
+        @error = error
+      end
+
+      # Check if the process succeeded
+      #
+      # @return [Boolean]
+      def success?
+        @exit_code.zero? && @error.nil?
+      end
+
+      # Combined output (stdout + stderr)
+      #
+      # @return [String]
+      def output
+        "#{@stdout}#{@stderr}"
+      end
+
+      # Alias for compatibility with Daytona
+      alias result stdout
+    end
+  end
+end

data/lib/e2b/models/sandbox_info.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module E2B
+  module Models
+    # Information about a sandbox
+    class SandboxInfo
+      # @return [String] Sandbox ID
+      attr_reader :sandbox_id
+
+      # @return [String] Template ID used to create the sandbox
+      attr_reader :template_id
+
+      # @return [String, nil] Alias/name of the sandbox
+      attr_reader :alias_name
+
+      # @return [String] Client ID
+      attr_reader :client_id
+
+      # @return [Time] When the sandbox was started
+      attr_reader :started_at
+
+      # @return [Time] When the sandbox will end (timeout)
+      attr_reader :end_at
+
+      # @return [Integer] CPU count
+      attr_reader :cpu_count
+
+      # @return [Integer] Memory in MB
+      attr_reader :memory_mb
+
+      # @return [Hash] Metadata
+      attr_reader :metadata
+
+      # Create from API response hash
+      #
+      # @param data [Hash] API response data
+      # @return [SandboxInfo]
+      def self.from_hash(data)
+        new(
+          sandbox_id: data["sandboxID"] || data["sandbox_id"] || data[:sandboxID],
+          template_id: data["templateID"] || data["template_id"] || data[:templateID],
+          alias_name: data["alias"] || data[:alias],
+          client_id: data["clientID"] || data["client_id"] || data[:clientID],
+          started_at: parse_time(data["startedAt"] || data["started_at"] || data[:startedAt]),
+          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] || {}
+        )
+      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: {})
+        @sandbox_id = sandbox_id
+        @template_id = template_id
+        @alias_name = alias_name
+        @client_id = client_id
+        @started_at = started_at
+        @end_at = end_at
+        @cpu_count = cpu_count
+        @memory_mb = memory_mb
+        @metadata = metadata || {}
+      end
+
+      # Check if sandbox is still running (not past end_at)
+      #
+      # @return [Boolean]
+      def running?
+        return true if @end_at.nil?
+
+        Time.now < @end_at
+      end
+
+      # Time remaining until timeout
+      #
+      # @return [Integer] Seconds remaining, 0 if expired
+      def time_remaining
+        return 0 if @end_at.nil?
+
+        remaining = (@end_at - Time.now).to_i
+        remaining.positive? ? remaining : 0
+      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