daytona 0.200.0 → 0.201.0

data/lib/daytona/file_system.rb

@@ -46,8 +46,8 @@ module Daytona
     def create_folder(path, mode)
       Sdk.logger.debug("Creating folder #{path} with mode #{mode}")
       toolbox_api.create_folder(path, mode)
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to create folder: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to create folder')
     end
 
     # Deletes a file from the Sandbox.
@@ -65,8 +65,8 @@ module Daytona
     #   sandbox.fs.delete_file("workspace/old_dir", recursive: true)
     def delete_file(path, recursive: false)
       toolbox_api.delete_file(path, { recursive: })
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to delete file: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to delete file')
     end
 
     # Gets detailed information about a file or directory, including its
@@ -89,8 +89,8 @@ module Daytona
     #   puts "Path is a directory" if info.is_dir
     def get_file_info(path)
       toolbox_api.get_file_info(path)
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to get file info: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get file info')
     end
 
     # Lists files and directories in a given path and returns their information, similar to the ls -l command.
@@ -123,8 +123,8 @@ module Daytona
       toolbox_api.list_files({ path:, depth: }.compact)
     rescue Sdk::Error
       raise
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to list files: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to list files')
     end
 
     # Downloads a file from the Sandbox. Returns the file contents as a string.
@@ -159,7 +159,9 @@ module Daytona
       else
         file
       end
-    rescue StandardError => e
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to download file')
+    rescue IOError, SystemCallError => e
       raise Sdk::Error, "Failed to download file: #{e.message}"
     end
 
@@ -198,7 +200,9 @@ module Daytona
                                    timeout: timeout, on_progress: on_progress,
                                    cancel_event: cancel_event, &)
       nil
-    rescue StandardError => e
+    rescue *Sdk::API_ERROR_CLASSES, Sdk::Error => e
+      raise Sdk.wrap_error(e, 'Failed to download file')
+    rescue IOError, SystemCallError => e
       raise Sdk::Error, "Failed to download file: #{e.message}"
     end
 
@@ -222,13 +226,13 @@ module Daytona
     #   # Upload binary data
     #   data = { key: "value" }.to_json
     #   sandbox.fs.upload_file(data, "tmp/config.json")
-    def upload_file(source, remote_path)
+    def upload_file(source, remote_path) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       if source.is_a?(String) && File.exist?(source)
         # Source is a file path
-        File.open(source, 'rb') { |file| toolbox_api.upload_file(remote_path, file) }
+        File.open(source, 'rb') { |file| toolbox_api.upload_file(remote_path, file: file) }
       elsif source.respond_to?(:read)
         # Source is an IO object
-        toolbox_api.upload_file(remote_path, source)
+        toolbox_api.upload_file(remote_path, file: source)
       else
         # Tempfile.create yields a ::File (works with Typhoeus) but deletes
         # on block exit — too early if curl reads asynchronously. Write via
@@ -238,12 +242,14 @@ module Daytona
           tmp.binmode
           tmp.write(source.to_s.b)
           tmp.close
-          File.open(tmp.path, 'rb') { |file| toolbox_api.upload_file(remote_path, file) }
+          File.open(tmp.path, 'rb') { |file| toolbox_api.upload_file(remote_path, file: file) }
         ensure
           tmp.unlink
         end
       end
-    rescue StandardError => e
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to upload file')
+    rescue IOError, SystemCallError => e
       raise Sdk::Error, "Failed to upload file: #{e.message}"
     end
 
@@ -273,7 +279,9 @@ module Daytona
       FileTransfer.stream_upload(api_client: toolbox_api.api_client, remote_path: remote_path,
                                  source: source, timeout: timeout, on_progress: on_progress,
                                  cancel_event: cancel_event)
-    rescue StandardError => e
+    rescue *Sdk::API_ERROR_CLASSES, Sdk::Error => e
+      raise Sdk.wrap_error(e, 'Failed to upload file')
+    rescue IOError, SystemCallError => e
       raise Sdk::Error, "Failed to upload file: #{e.message}"
     end
 
@@ -294,8 +302,8 @@ module Daytona
     #   sandbox.fs.upload_files(files)
     def upload_files(files)
       files.each { |file_upload| upload_file(file_upload.source, file_upload.destination) }
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to upload files: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES, Sdk::Error => e
+      raise Sdk.wrap_error(e, 'Failed to upload files')
     end
 
     # Searches for files containing a pattern, similar to the grep command.
@@ -315,8 +323,8 @@ module Daytona
     #   end
     def find_files(path, pattern)
       toolbox_api.find_in_files(path, pattern)
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to find files: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to find files')
     end
 
     # Searches for files and directories whose names match the specified pattern.
@@ -339,8 +347,8 @@ module Daytona
     #   puts "Found #{result.files.length} test files"
     def search_files(path, pattern)
       toolbox_api.search_files(path, pattern)
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to search files: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to search files')
     end
 
     # Moves or renames a file or directory. The parent directory of the destination must exist.
@@ -372,8 +380,8 @@ module Daytona
     #   )
     def move_files(source, destination)
       toolbox_api.move_file(source, destination)
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to move files: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to move files')
     end
 
     # Performs search and replace operations across multiple files.
@@ -408,8 +416,8 @@ module Daytona
         new_value: new_value
       )
       toolbox_api.replace_in_files(replace_request)
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to replace in files: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to replace in files')
     end
 
     # Sets permissions and ownership for a file or directory. Any of the parameters can be nil
@@ -443,8 +451,8 @@ module Daytona
       opts[:group] = group if group
 
       toolbox_api.set_file_permissions(path, opts)
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to set file permissions: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to set file permissions')
     end
 
     instrument :create_folder, :delete_file, :get_file_info, :list_files, :download_file,

data/lib/daytona/git.rb

@@ -47,8 +47,8 @@ module Daytona
       toolbox_api.add_files(DaytonaToolboxApiClient::GitAddRequest.new(path:, files:))
     rescue DaytonaToolboxApiClient::ApiError => e
       raise map_api_error(e, 'Failed to add files')
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to add files: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to add files')
     end
 
     # Lists branches in the repository.
@@ -65,8 +65,8 @@ module Daytona
       toolbox_api.list_branches(path)
     rescue DaytonaToolboxApiClient::ApiError => e
       raise map_api_error(e, 'Failed to list branches')
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to list branches: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to list branches')
     end
 
     # Clones a Git repository into the specified path. It supports
@@ -126,8 +126,8 @@ module Daytona
       )
     rescue DaytonaToolboxApiClient::ApiError => e
       raise map_api_error(e, 'Failed to clone repository')
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to clone repository: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to clone repository')
     end
 
     # Creates a new commit with the staged changes. Make sure to stage
@@ -160,8 +160,8 @@ module Daytona
       GitCommitResponse.new(sha: response._hash)
     rescue DaytonaToolboxApiClient::ApiError => e
       raise map_api_error(e, 'Failed to commit changes')
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to commit changes: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to commit changes')
     end
 
     # Pushes all local commits on the current branch to the remote
@@ -197,8 +197,8 @@ module Daytona
       )
     rescue DaytonaToolboxApiClient::ApiError => e
       raise map_api_error(e, 'Failed to push changes')
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to push changes: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to push changes')
     end
 
     # Pulls changes from the remote repository. If the remote repository requires authentication,
@@ -232,8 +232,8 @@ module Daytona
       )
     rescue DaytonaToolboxApiClient::ApiError => e
       raise map_api_error(e, 'Failed to pull changes')
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to pull changes: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to pull changes')
     end
 
     # Gets the current Git repository status.
@@ -252,8 +252,8 @@ module Daytona
       toolbox_api.get_status(path)
     rescue DaytonaToolboxApiClient::ApiError => e
       raise map_api_error(e, 'Failed to get status')
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to get status: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get status')
     end
 
     # Checkout branch in the repository.
@@ -273,8 +273,8 @@ module Daytona
       )
     rescue DaytonaToolboxApiClient::ApiError => e
       raise map_api_error(e, 'Failed to checkout branch')
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to checkout branch: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to checkout branch')
     end
 
     # Create branch in the repository.
@@ -295,8 +295,8 @@ module Daytona
       )
     rescue DaytonaToolboxApiClient::ApiError => e
       raise map_api_error(e, 'Failed to create branch')
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to create branch: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to create branch')
     end
 
     # Delete branch in the repository.
@@ -316,8 +316,8 @@ module Daytona
       )
     rescue DaytonaToolboxApiClient::ApiError => e
       raise map_api_error(e, 'Failed to delete branch')
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to delete branch: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to delete branch')
     end
 
     # Initializes a new Git repository at the specified path.
@@ -544,17 +544,7 @@ module Daytona
     attr_reader :otel_state
 
     def map_api_error(api_error, prefix)
-      msg = "#{prefix}: #{api_error.message}"
-      case api_error.code
-      when 400 then Sdk::ValidationError.new(msg)
-      when 401 then Sdk::AuthenticationError.new(msg)
-      when 403 then Sdk::ForbiddenError.new(msg)
-      when 404 then Sdk::NotFoundError.new(msg)
-      when 409 then Sdk::ConflictError.new(msg)
-      when 429 then Sdk::RateLimitError.new(msg)
-      when 500..599 then Sdk::ServerError.new(msg)
-      else Sdk::Error.new(msg)
-      end
+      Sdk.wrap_error(api_error, prefix)
     end
   end
 end

data/lib/daytona/lsp_server.rb

@@ -59,6 +59,8 @@ module Daytona
           position: DaytonaToolboxApiClient::LspPosition.new(line: position.line, character: position.character)
         )
       )
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get LSP completions')
     end
 
     # Notify the language server that a file has been closed.
@@ -71,6 +73,8 @@ module Daytona
       toolbox_api.did_close(
         DaytonaToolboxApiClient::LspDocumentRequest.new(language_id:, path_to_project:, uri: uri(path))
       )
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to notify LSP server of closed document')
     end
 
     # Notifies the language server that a file has been opened.
@@ -84,20 +88,30 @@ module Daytona
       toolbox_api.did_open(
         DaytonaToolboxApiClient::LspDocumentRequest.new(language_id:, path_to_project:, uri: uri(path))
       )
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to notify LSP server of opened document')
     end
 
     # Gets symbol information (functions, classes, variables, etc.) from a document.
     #
     # @param path [String]
     # @return [Array<DaytonaToolboxApiClient::LspSymbol]
-    def document_symbols(path) = toolbox_api.document_symbols(language_id, path_to_project, uri(path))
+    def document_symbols(path)
+      toolbox_api.document_symbols(language_id, path_to_project, uri(path))
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get LSP document symbols')
+    end
 
     # Searches for symbols matching the query string across all files
     # in the Sandbox.
     #
     # @param query [String]
     # @return [Array<DaytonaToolboxApiClient::LspSymbol]
-    def sandbox_symbols(query) = toolbox_api.workspace_symbols(query, language_id, path_to_project)
+    def sandbox_symbols(query)
+      toolbox_api.workspace_symbols(query, language_id, path_to_project)
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get LSP workspace symbols')
+    end
 
     # Starts the language server.
     # This method must be called before using any other LSP functionality.
@@ -108,6 +122,8 @@ module Daytona
       toolbox_api.start(
         DaytonaToolboxApiClient::LspServerRequest.new(language_id:, path_to_project:)
       )
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to start LSP server')
     end
 
     # Stops the language server.
@@ -119,6 +135,8 @@ module Daytona
       toolbox_api.stop(
         DaytonaToolboxApiClient::LspServerRequest.new(language_id:, path_to_project:)
       )
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to stop LSP server')
     end
 
     instrument :completions, :did_close, :did_open, :document_symbols, :sandbox_symbols,

data/lib/daytona/object_storage.rb

@@ -25,9 +25,9 @@ module Daytona
     # @param aws_secret_access_key [String] The secret access key for the object storage service
     # @param aws_session_token [String] The session token for the object storage service
     # @param bucket_name [String] The name of the bucket to use (defaults to "daytona-volume-builds")
-    # @param region [String] AWS region (defaults to us-east-1)
+    # @param region [String] Region of the storage backend
     def initialize(endpoint_url:, aws_access_key_id:, aws_secret_access_key:, aws_session_token:, # rubocop:disable Metrics/ParameterLists
-                   bucket_name: DEFAULT_BUCKET_NAME, region: DEFAULT_REGION)
+                   region:, bucket_name: DEFAULT_BUCKET_NAME)
       @bucket_name = bucket_name
       @s3_client = Aws::S3::Client.new(
         region:,
@@ -165,8 +165,5 @@ module Daytona
 
     DEFAULT_BUCKET_NAME = 'daytona-volume-builds'
     private_constant :DEFAULT_BUCKET_NAME
-
-    DEFAULT_REGION = 'us-east-1'
-    private_constant :DEFAULT_REGION
   end
 end

data/lib/daytona/process.rb

@@ -68,6 +68,8 @@ module Daytona
         result:,
         artifacts: ExecutionArtifacts.new(result, [])
       )
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to execute command')
     end
 
     # Execute code in the Sandbox using the appropriate language runtime
@@ -99,6 +101,8 @@ module Daytona
           Charts.parse_chart(c)
         end)
       )
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to run code')
     end
 
     # Creates a new long-running background session in the Sandbox
@@ -118,6 +122,8 @@ module Daytona
     #   sandbox.process.delete_session(session_id)
     def create_session(session_id)
       toolbox_api.create_session(DaytonaToolboxApiClient::CreateSessionRequest.new(session_id:))
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to create session')
     end
 
     # Gets a session in the Sandbox
@@ -130,7 +136,11 @@ module Daytona
     #   session.commands.each do |cmd|
     #     puts "Command: #{cmd.command}"
     #   end
-    def get_session(session_id) = toolbox_api.get_session(session_id)
+    def get_session(session_id)
+      toolbox_api.get_session(session_id)
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get session')
+    end
 
     # Gets the Sandbox entrypoint session
     #
@@ -141,7 +151,11 @@ module Daytona
     #   session.commands.each do |cmd|
     #     puts "Command: #{cmd.command}"
     #   end
-    def get_entrypoint_session = toolbox_api.get_entrypoint_session
+    def get_entrypoint_session
+      toolbox_api.get_entrypoint_session
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get entrypoint session')
+    end
 
     # Gets information about a specific command executed in a session
     #
@@ -156,6 +170,8 @@ module Daytona
     #   end
     def get_session_command(session_id:, command_id:)
       toolbox_api.get_session_command(session_id, command_id)
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get session command')
     end
 
     # Executes a command in the session
@@ -196,6 +212,8 @@ module Daytona
         exit_code: response.exit_code,
         additional_properties: {}
       )
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to execute session command')
     end
 
     # Get the logs for a command executed in a session
@@ -211,6 +229,8 @@ module Daytona
     def get_session_command_logs(session_id:, command_id:)
       response = toolbox_api.get_session_command_logs(session_id, command_id)
       SessionCommandLogsResponse.new(output: response.output, stdout: response.stdout, stderr: response.stderr)
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get session command logs')
     end
 
     # Asynchronously retrieves and processes the logs for a command executed in a session as they become available
@@ -282,6 +302,8 @@ module Daytona
     def get_entrypoint_logs
       response = toolbox_api.get_entrypoint_logs
       SessionCommandLogsResponse.new(output: response.output, stdout: response.stdout, stderr: response.stderr)
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get entrypoint logs')
     end
 
     # Asynchronously retrieves and processes the sandbox entrypoint logs as they become available
@@ -353,6 +375,8 @@ module Daytona
         command_id,
         DaytonaToolboxApiClient::SessionSendInputRequest.new(data:)
       )
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to send session command input')
     end
 
     #
@@ -364,7 +388,11 @@ module Daytona
     #     puts "Session #{session.session_id}:"
     #     puts "  Commands: #{session.commands.length}"
     #   end
-    def list_sessions = toolbox_api.list_sessions
+    def list_sessions
+      toolbox_api.list_sessions
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to list sessions')
+    end
 
     # Terminates and removes a session from the Sandbox, cleaning up any resources associated with it
     #
@@ -377,7 +405,11 @@ module Daytona
     #
     #   # Clean up when done
     #   sandbox.process.delete_session("temp-session")
-    def delete_session(session_id) = toolbox_api.delete_session(session_id)
+    def delete_session(session_id)
+      toolbox_api.delete_session(session_id)
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to delete session')
+    end
 
     # Creates a new PTY (pseudo-terminal) session in the Sandbox.
     #
@@ -499,6 +531,8 @@ module Daytona
           rows: pty_size.rows
         )
       )
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to resize PTY session')
     end
 
     # Deletes a PTY session, terminating the associated process
@@ -510,6 +544,8 @@ module Daytona
     #   sandbox.process.delete_pty_session("my-pty")
     def delete_pty_session(session_id)
       toolbox_api.delete_pty_session(session_id)
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to delete PTY session')
     end
 
     # Lists all PTY sessions in the Sandbox
@@ -526,6 +562,8 @@ module Daytona
       return [] if response.nil?
 
       response.respond_to?(:sessions) ? (response.sessions || []) : response
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to list PTY sessions')
     end
 
     # Gets detailed information about a specific PTY session
@@ -546,6 +584,8 @@ module Daytona
     #   puts "Terminal Size: #{session_info.cols}x#{session_info.rows}"
     def get_pty_session_info(session_id)
       toolbox_api.get_pty_session(session_id)
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get PTY session info')
     end
 
     instrument :exec, :code_run, :create_session, :get_session, :get_session_command,