daytona 0.200.1 → 0.201.0

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,

data/lib/daytona/sandbox.rb

@@ -5,6 +5,7 @@
 
 require 'time'
 require 'timeout'
+require_relative 'utils/file_url_signing'
 
 module Daytona
   # A single point-in-time sample of historical Sandbox resource usage.
@@ -196,6 +197,8 @@ module Daytona
       @analytics_api_url_provider = analytics_api_url_provider
       @subscription_manager = subscription_manager
       @sub_id = nil
+      @signing_key = nil
+      @signing_key_fetched_at = 0
 
       # Create toolbox API clients with dynamic configuration
       @toolbox_api_config = build_toolbox_api_config
@@ -435,8 +438,8 @@ module Daytona
     #   puts "Sandbox user home: #{user_home_dir}"
     def get_user_home_dir
       @info_api.get_user_home_dir.dir
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to get user home directory: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get user home directory')
     end
 
     # Gets the working directory path inside the Sandbox.
@@ -449,8 +452,8 @@ module Daytona
     #   puts "Sandbox working directory: #{work_dir}"
     def get_work_dir
       @info_api.get_work_dir.dir
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to get working directory path: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get working directory path')
     end
 
     # Updates the Sandbox daemon's process environment. Newly spawned processes, sessions
@@ -524,6 +527,76 @@ module Daytona
       sandbox_api.get_port_preview_url(id, port)
     end
 
+    # Creates a pre-signed URL for downloading a file from the Sandbox.
+    #
+    # The URL works with any HTTP client without auth headers and stays valid across
+    # sandbox restarts (downloads succeed only while the sandbox is running). The signing
+    # key is cached locally for up to 15 seconds; if the key was rotated from another
+    # client, URLs may be rejected until the cache refreshes.
+    #
+    # @param path [String] Path to the file in the Sandbox.
+    # @param ttl_seconds [Integer, nil] How long the URL stays valid, in seconds.
+    #   Defaults to 3600. Zero or negative means the URL never expires.
+    # @return [String] Pre-signed download URL.
+    # @raise [Daytona::Sdk::Error] if the signing key cannot be fetched.
+    #
+    # @example
+    #   url = sandbox.download_url('/home/user/report.pdf')
+    #   # curl "$url" -o report.pdf
+    def download_url(path, ttl_seconds: nil)
+      Utils::FileUrlSigning.build_signed_file_url(
+        @toolbox_proxy_url,
+        id,
+        '/files/download',
+        'GET',
+        path,
+        ensure_signing_key,
+        ttl_seconds
+      )
+    end
+
+    # Creates a pre-signed URL for uploading a file to the Sandbox.
+    #
+    # Send a POST request with the file as multipart/form-data. The URL works with any
+    # HTTP client without auth headers. The signing key is cached locally for up to
+    # 15 seconds; if the key was rotated from another client, URLs may be rejected
+    # until the cache refreshes.
+    #
+    # @param path [String] Destination path for the uploaded file in the Sandbox.
+    # @param ttl_seconds [Integer, nil] How long the URL stays valid, in seconds.
+    #   Defaults to 3600. Zero or negative means the URL never expires.
+    # @return [String] Pre-signed upload URL.
+    # @raise [Daytona::Sdk::Error] if the signing key cannot be fetched.
+    #
+    # @example
+    #   url = sandbox.upload_url('/home/user/data.bin')
+    #   # curl -X POST -F "file=@local.bin" "$url"
+    def upload_url(path, ttl_seconds: nil)
+      Utils::FileUrlSigning.build_signed_file_url(
+        @toolbox_proxy_url,
+        id,
+        '/files/upload-v2',
+        'POST',
+        path,
+        ensure_signing_key,
+        ttl_seconds
+      )
+    end
+
+    # Rotates the sandbox signing key, invalidating all previously signed URLs.
+    #
+    # @return [void]
+    # @raise [DaytonaApiClient::ApiError] if the signing key rotation request fails.
+    #
+    # @example
+    #   sandbox.rotate_signing_key
+    #   puts 'All previously signed URLs are now invalid.'
+    def rotate_signing_key
+      @signing_key = @sandbox_api.rotate_signing_key(id)
+      @signing_key_fetched_at = Time.now.to_f
+      nil
+    end
+
     # Creates a signed preview URL for the sandbox at the specified port.
     #
     # @param port [Integer] The port to open the preview link on
@@ -570,8 +643,8 @@ module Daytona
     def refresh_activity
       sandbox_api.update_last_activity(id)
       nil
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to refresh sandbox activity: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to refresh sandbox activity')
     end
 
     # Revokes an SSH access token for the sandbox.
@@ -619,8 +692,8 @@ module Daytona
           error_states: [DaytonaApiClient::SandboxState::ERROR, DaytonaApiClient::SandboxState::BUILD_FAILED]
         )
       end
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to recover sandbox: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to recover sandbox')
     end
 
     # Stops the Sandbox and waits for it to be stopped.
@@ -841,7 +914,8 @@ module Daytona
                :update_network_settings, :update_secrets, :update_env,
                :create_ssh_access, :delete, :get_user_home_dir, :get_work_dir, :get_metrics, :get_metrics_latest,
                :labels=,
-               :preview_url, :create_signed_preview_url, :expire_signed_preview_url,
+               :preview_url, :download_url, :upload_url, :rotate_signing_key,
+               :create_signed_preview_url, :expire_signed_preview_url,
                :refresh, :refresh_activity, :revoke_ssh_access, :start, :recover, :stop,
                :create_lsp_server, :validate_ssh_access, :wait_for_sandbox_start,
                :wait_for_sandbox_stop, :resize, :wait_for_resize_complete,
@@ -964,6 +1038,16 @@ module Daytona
       @toolbox_api_config.base_path = uri.path.empty? ? '/' : uri.path
     end
 
+    def ensure_signing_key
+      key = @signing_key
+      if key.nil? || (Time.now.to_f - @signing_key_fetched_at) > 15
+        key = @sandbox_api.get_sandbox_signing_key(id)
+        @signing_key = key
+        @signing_key_fetched_at = Time.now.to_f
+      end
+      key
+    end
+
     # @params sandbox_dto [DaytonaApiClient::Sandbox, DaytonaApiClient::SandboxListItem]
     # @return [void]
     def process_response(sandbox_dto) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize

data/lib/daytona/sdk/deprecated.rb

@@ -0,0 +1,18 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+# =============================================================================
+# Backward-compatibility aliases. New functionality belongs in errors.rb, not
+# here. Every name below exists solely so pre-typed-error-model user code
+# keeps working, and this file can be removed as a whole in a future major
+# release.
+# =============================================================================
+module Daytona
+  module Sdk
+    # @deprecated Use {BadRequestError} instead. Kept as an alias so existing
+    #   `rescue Daytona::Sdk::ValidationError` blocks keep working.
+    ValidationError = BadRequestError
+  end
+end