daytona 0.200.1 → 0.201.0

data/lib/daytona/sdk/errors.rb

@@ -0,0 +1,279 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+require 'json'
+
+module Daytona
+  module Sdk # rubocop:disable Metrics/ModuleLength
+    # ApiError classes raised by the generated OpenAPI clients. Kept here so
+    # the error module can resolve them without depending on `sdk.rb`.
+    API_ERROR_CLASSES = [DaytonaApiClient::ApiError, DaytonaToolboxApiClient::ApiError].freeze
+
+    # Wire-format `source` values set by the translation layer when a
+    # Daytona service stamps them on the wire envelope. `nil` source means
+    # the response did not carry a structured envelope (treat as opaque).
+    SOURCE_API     = 'DAYTONA_API'
+    SOURCE_DAEMON  = 'DAYTONA_DAEMON'
+    SOURCE_PROXY   = 'DAYTONA_PROXY'
+
+    # ---------------------------------------------------------------------
+    # Base
+    # ---------------------------------------------------------------------
+
+    # Base class for every error raised by the Daytona SDK.
+    #
+    # @example Catching any SDK error
+    #   begin
+    #     daytona.create(params)
+    #   rescue Daytona::Sdk::Error => e
+    #     puts e.status_code, e.code, e.source
+    #   end
+    class Error < StandardError
+      def initialize(message = nil, status_code: nil, code: nil, source: nil, headers: nil)
+        super(message)
+        @status_code = status_code
+        @code = code
+        @source = source
+        @headers = headers
+      end
+
+      def status_code = @status_code || metadata_from_cause[:status_code]
+
+      def code = @code || metadata_from_cause[:code]
+
+      def headers = @headers || metadata_from_cause[:headers] || {}
+
+      # Returns the originating service, or `nil` if unknown. Falls back to
+      # metadata carried by `cause` so a re-raised ApiError keeps its
+      # server-stamped source.
+      def source = @source || metadata_from_cause[:source]
+
+      private
+
+      def metadata_from_cause
+        @metadata_from_cause ||= Sdk.api_error_details(cause)
+      end
+    end
+
+    # ---------------------------------------------------------------------
+    # HTTP status-class errors
+    # ---------------------------------------------------------------------
+
+    # HTTP 400 — request was rejected as malformed or invalid.
+    class BadRequestError < Error; end
+
+    # HTTP 401 — authentication failed or credentials missing.
+    class AuthenticationError < Error; end
+
+    # HTTP 403 — caller is authenticated but not allowed.
+    class ForbiddenError < Error; end
+
+    # HTTP 404 — target resource does not exist.
+    class NotFoundError < Error; end
+
+    # HTTP 408 / 504 / client-side timeouts.
+    class TimeoutError < Error; end
+
+    # HTTP 409 — request conflicts with current resource state.
+    class ConflictError < Error; end
+
+    # HTTP 410 — resource is permanently gone.
+    class GoneError < Error; end
+
+    # HTTP 422 — request is well-formed but semantically invalid.
+    class UnprocessableEntityError < Error; end
+
+    # HTTP 429 — rate limit was exceeded.
+    class RateLimitError < Error; end
+
+    # Generic 5xx fallback when a more specific class doesn't apply.
+    class ServerError < Error; end
+
+    # HTTP 500 — server-side bug or unhandled condition.
+    class InternalServerError < ServerError; end
+
+    # HTTP 502 — an upstream dependency rejected or dropped the request.
+    class BadGatewayError < ServerError; end
+
+    # HTTP 503 — the service is temporarily refusing traffic.
+    class ServiceUnavailableError < ServerError; end
+
+    # Transport-level failure (no HTTP response received).
+    class ConnectionError < Error; end
+
+    # Transport-level timeout. Subclass of ConnectionError so callers that
+    # catch the broader connection-failure category also match.
+    class ConnectionTimeoutError < ConnectionError; end
+
+    # ---------------------------------------------------------------------
+    # Domain subclasses — each inherits from the HTTP-status parent that
+    # matches its server-side status code.
+    # ---------------------------------------------------------------------
+
+    # Daemon: git
+    class GitAuthFailedError < AuthenticationError; end
+    class GitRepoNotFoundError < NotFoundError; end
+    class GitBranchNotFoundError < NotFoundError; end
+    class GitBranchExistsError < ConflictError; end
+    class GitPushRejectedError < ConflictError; end
+    class GitDirtyWorktreeError < ConflictError; end
+    class GitMergeConflictError < ConflictError; end
+
+    # Daemon: filesystem
+    class FileNotFoundError < NotFoundError; end
+    class FileAccessDeniedError < ForbiddenError; end
+
+    # Daemon: LSP
+    class LspServerNotInitializedError < BadRequestError; end
+
+    # Daemon: process / session
+    class ProcessExecutionTimeoutError < TimeoutError; end
+    class ProcessNotFoundError < NotFoundError; end
+    class SessionEndedError < GoneError; end
+    class CommandAlreadyCompletedError < GoneError; end
+
+    # Daemon: computer-use
+    class A11yUnavailableError < ServiceUnavailableError; end
+    class RecordingStillActiveError < ConflictError; end
+    class RecordingFfmpegNotFoundError < ServiceUnavailableError; end
+
+    # ---------------------------------------------------------------------
+    # Routing tables
+    # ---------------------------------------------------------------------
+
+    STATUS_CODE_TO_ERROR = {
+      400 => BadRequestError,
+      401 => AuthenticationError,
+      403 => ForbiddenError,
+      404 => NotFoundError,
+      408 => TimeoutError,
+      409 => ConflictError,
+      410 => GoneError,
+      422 => UnprocessableEntityError,
+      429 => RateLimitError,
+      500 => InternalServerError,
+      502 => BadGatewayError,
+      503 => ServiceUnavailableError,
+      504 => TimeoutError
+    }.freeze
+
+    # (source, code) tuple → exception class. Resolved BEFORE the status
+    # code, so a server-stamped domain code always wins over the generic
+    # status class.
+    CODE_TO_ERROR = {
+      # Daemon: git
+      [SOURCE_DAEMON, 'GIT_AUTH_FAILED'] => GitAuthFailedError,
+      [SOURCE_DAEMON, 'GIT_REPO_NOT_FOUND'] => GitRepoNotFoundError,
+      [SOURCE_DAEMON, 'GIT_BRANCH_NOT_FOUND'] => GitBranchNotFoundError,
+      [SOURCE_DAEMON, 'GIT_BRANCH_EXISTS'] => GitBranchExistsError,
+      [SOURCE_DAEMON, 'GIT_PUSH_REJECTED'] => GitPushRejectedError,
+      [SOURCE_DAEMON, 'GIT_DIRTY_WORKTREE'] => GitDirtyWorktreeError,
+      [SOURCE_DAEMON, 'GIT_MERGE_CONFLICT'] => GitMergeConflictError,
+
+      # Daemon: filesystem
+      [SOURCE_DAEMON, 'FILE_NOT_FOUND'] => FileNotFoundError,
+      [SOURCE_DAEMON, 'FILE_ACCESS_DENIED'] => FileAccessDeniedError,
+
+      # Daemon: LSP
+      [SOURCE_DAEMON, 'LSP_SERVER_NOT_INITIALIZED'] => LspServerNotInitializedError,
+
+      # Daemon: process / session
+      [SOURCE_DAEMON, 'PROCESS_EXECUTION_TIMEOUT'] => ProcessExecutionTimeoutError,
+      [SOURCE_DAEMON, 'PROCESS_NOT_FOUND'] => ProcessNotFoundError,
+      [SOURCE_DAEMON, 'SESSION_ENDED'] => SessionEndedError,
+      [SOURCE_DAEMON, 'COMMAND_ALREADY_COMPLETED'] => CommandAlreadyCompletedError,
+
+      # Daemon: computer-use
+      [SOURCE_DAEMON, 'A11Y_UNAVAILABLE'] => A11yUnavailableError,
+      [SOURCE_DAEMON, 'RECORDING_STILL_ACTIVE'] => RecordingStillActiveError,
+      [SOURCE_DAEMON, 'RECORDING_FFMPEG_NOT_FOUND'] => RecordingFfmpegNotFoundError
+    }.freeze
+
+    # ---------------------------------------------------------------------
+    # Public translation helpers (module-level functions on Daytona::Sdk)
+    # ---------------------------------------------------------------------
+
+    # Translate an OpenAPI-client error into the most specific Daytona SDK
+    # exception. Accepts an optional `prefix` that's prepended to the
+    # message for context (e.g. "Failed to create sandbox"). When `error`
+    # is already an `Sdk::Error` (e.g. raised by the streaming transfer
+    # helpers for cancel/timeout), its class is preserved and only the
+    # message is prefixed.
+    def self.wrap_error(error, prefix = nil)
+      if error.is_a?(Error)
+        message = prefix ? "#{prefix}: #{error.message}" : error.message
+        return error.class.new(message, status_code: error.status_code, code: error.code,
+                                        source: error.source, headers: error.headers)
+      end
+
+      details = api_error_details(error)
+      base_message = parsed_message(error) || error.message
+      message = prefix ? "#{prefix}: #{base_message}" : base_message
+      error_class_for(details).new(message, **details.slice(:status_code, :code, :source, :headers))
+    end
+
+    # Extract status code, code, source and headers from a raised OpenAPI
+    # error. Returns an empty hash when the error is not one of the
+    # generated client types.
+    def self.api_error_details(error)
+      return {} unless API_ERROR_CLASSES.any? { |c| error.is_a?(c) }
+
+      data = parse_error_body(error.respond_to?(:response_body) ? error.response_body : nil)
+      {
+        status_code: error.respond_to?(:code) ? error.code : nil,
+        code: data[:code],
+        source: data[:source],
+        headers: error.respond_to?(:response_headers) ? error.response_headers : nil
+      }
+    end
+
+    # Choose the exception class for a parsed error: (source, code) match
+    # wins, then HTTP status code, then the base Error.
+    def self.error_class_for(details)
+      code = details[:code]
+      source = details[:source]
+      if code && source
+        cls = CODE_TO_ERROR[[source, code]]
+        return cls if cls
+      end
+      status_code = details[:status_code]
+      exact_status_error = STATUS_CODE_TO_ERROR[status_code]
+      return exact_status_error if exact_status_error
+
+      return ServerError if status_code.is_a?(Integer) && status_code >= 500
+
+      Error
+    end
+
+    def self.parse_error_body(response_body)
+      return {} if response_body.nil? || response_body.empty?
+
+      data = JSON.parse(response_body)
+      return {} unless data.is_a?(Hash)
+
+      {
+        message: string_or_nil(data['message']) || string_or_nil(data['error']),
+        code: string_or_nil(data['code'] || data['error_code']),
+        source: string_or_nil(data['source'])
+      }
+    rescue JSON::ParserError
+      {}
+    end
+
+    # @api private
+    def self.parsed_message(error)
+      return nil unless API_ERROR_CLASSES.any? { |c| error.is_a?(c) }
+      return nil unless error.respond_to?(:response_body)
+
+      parse_error_body(error.response_body)[:message]
+    end
+
+    def self.string_or_nil(value)
+      value.is_a?(String) && !value.empty? ? value : nil
+    end
+
+    private_class_method :error_class_for, :parse_error_body, :parsed_message, :string_or_nil
+  end
+end

data/lib/daytona/sdk/file_download_patch.rb

@@ -0,0 +1,131 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+# Patches the OpenAPI-generated `download_file` and `call_api` helpers in both
+# API clients so that streaming responses (return_type == 'File') do not lose
+# the response body when the server returns an error status.
+#
+# Background:
+#   For File downloads the generated `download_file` attaches Typhoeus
+#   `on_body` callbacks to stream the response into a Tempfile. The presence
+#   of `on_body` prevents Typhoeus from populating `response.body`, which
+#   means the daemon's structured error envelope (code/source/message) is
+#   discarded when the response is an error. The generated `call_api` then
+#   raises `ApiError` with an empty `response_body`.
+#
+# Fix:
+#   * In `download_file`, defer tempfile creation until `on_headers` and
+#     inspect the status code. For 2xx responses, behave exactly like the
+#     upstream code. For non-2xx responses, accumulate the body into a
+#     buffer stored as an instance variable on the ApiClient.
+#   * In `call_api`, rescue the `ApiError`, and if our buffer is populated,
+#     re-raise with `response_body` set to the buffered envelope.
+
+require 'tempfile'
+
+module Daytona
+  module Sdk
+    # rubocop:disable Metrics/AbcSize, Metrics/BlockLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    module FileDownloadPatch
+      def self.apply!(api_client_class, api_error_class)
+        return if api_client_class.method_defined?(:_daytona_orig_call_api)
+
+        api_client_class.class_eval do
+          define_method(:_daytona_error_body_key) do
+            @daytona_error_body_key ||= :"daytona_file_download_error_body_#{object_id}"
+          end
+
+          define_method(:download_file) do |request, &block|
+            tempfile = nil
+            encoding = nil
+            stream_to_tempfile = false
+            error_body = String.new.b
+            Thread.current.thread_variable_set(_daytona_error_body_key, nil)
+
+            request.on_headers do |response|
+              stream_to_tempfile = response.code && response.code >= 200 && response.code < 300
+              next unless stream_to_tempfile
+
+              content_disposition = response.headers['Content-Disposition']
+              if content_disposition && content_disposition =~ /filename=/i
+                filename = content_disposition[/filename=['"]?([^'"\s]+)['"]?/, 1]
+                prefix = sanitize_filename(filename)
+              else
+                prefix = 'download-'
+              end
+              prefix += '-' unless prefix.end_with?('-')
+              encoding = response.body.encoding
+              tempfile = Tempfile.open(prefix, @config.temp_folder_path, encoding: encoding)
+            end
+
+            request.on_body do |chunk|
+              if stream_to_tempfile
+                chunk.force_encoding(encoding)
+                tempfile.write(chunk)
+              else
+                error_body << chunk.b
+              end
+            end
+
+            request.on_complete do
+              if stream_to_tempfile
+                if tempfile.nil?
+                  raise api_error_class,
+                        "Failed to create the tempfile based on the HTTP response from the server: #{request.inspect}"
+                end
+                tempfile.close
+                @config.logger.info(
+                  "Temp file written to #{tempfile.path}, please copy the file to a proper folder " \
+                  "with e.g. `FileUtils.cp(tempfile.path, '/new/file/path')` otherwise the temp file " \
+                  'will be deleted automatically with GC. It\'s also recommended to delete the temp file ' \
+                  'explicitly with `tempfile.delete`'
+                )
+                block&.call(tempfile)
+              else
+                Thread.current.thread_variable_set(_daytona_error_body_key, error_body) unless error_body.empty?
+              end
+            end
+          end
+
+          alias_method :_daytona_orig_call_api, :call_api
+
+          define_method(:call_api) do |http_method, path, opts = {}|
+            _daytona_orig_call_api(http_method, path, opts)
+          rescue api_error_class => e
+            error_body = Thread.current.thread_variable_get(_daytona_error_body_key)
+            if opts[:return_type] == 'File' && error_body && !error_body.empty?
+              new_err = api_error_class.new(
+                code: e.code,
+                response_headers: e.response_headers,
+                response_body: error_body
+              )
+              raise new_err, e.message
+            end
+            raise
+          ensure
+            Thread.current.thread_variable_set(_daytona_error_body_key, nil)
+          end
+
+          private :_daytona_error_body_key
+        end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/BlockLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+  end
+end
+
+if Object.const_defined?(:DaytonaApiClient) &&
+   DaytonaApiClient.const_defined?(:ApiClient) &&
+   DaytonaApiClient.const_defined?(:ApiError)
+  Daytona::Sdk::FileDownloadPatch.apply!(DaytonaApiClient::ApiClient, DaytonaApiClient::ApiError)
+end
+
+if Object.const_defined?(:DaytonaToolboxApiClient) &&
+   DaytonaToolboxApiClient.const_defined?(:ApiClient) &&
+   DaytonaToolboxApiClient.const_defined?(:ApiError)
+  Daytona::Sdk::FileDownloadPatch.apply!(
+    DaytonaToolboxApiClient::ApiClient, DaytonaToolboxApiClient::ApiError
+  )
+end

data/lib/daytona/sdk/version.rb

@@ -5,6 +5,6 @@
 
 module Daytona
   module Sdk
-    VERSION = '0.200.1'
+    VERSION = '0.201.0'
   end
 end

data/lib/daytona/sdk.rb

@@ -3,6 +3,7 @@
 # Copyright Daytona Platforms Inc.
 # SPDX-License-Identifier: Apache-2.0
 
+require 'json'
 require 'logger'
 
 require 'daytona_api_client'
@@ -12,6 +13,9 @@ require 'toml'
 require 'websocket-client-simple'
 
 require_relative 'sdk/version'
+require_relative 'sdk/errors'
+require_relative 'sdk/deprecated'
+require_relative 'sdk/file_download_patch'
 require_relative 'config'
 require_relative 'otel'
 require_relative 'common/charts'
@@ -47,15 +51,9 @@ require_relative 'process'
 
 module Daytona
   module Sdk
-    class Error < StandardError; end
-    class TimeoutError < Error; end
-    class AuthenticationError < Error; end
-    class ForbiddenError < Error; end
-    class NotFoundError < Error; end
-    class ConflictError < Error; end
-    class ValidationError < Error; end
-    class RateLimitError < Error; end
-    class ServerError < Error; end
+    # The error hierarchy and translation helpers live in `sdk/errors.rb`.
+    # This file just provides cross-cutting bits that need to be loaded
+    # alongside them.
 
     def self.logger = @logger ||= Logger.new($stdout, level: Logger::INFO)
   end

data/lib/daytona/snapshot_service.rb

@@ -147,7 +147,8 @@ module Daytona
         aws_access_key_id: push_access_creds.access_key,
         aws_secret_access_key: push_access_creds.secret,
         aws_session_token: push_access_creds.session_token,
-        bucket_name: push_access_creds.bucket
+        bucket_name: push_access_creds.bucket,
+        region: push_access_creds.region
       )
 
       image.context_list.map do |context|

data/lib/daytona/utils/file_url_signing.rb

@@ -0,0 +1,56 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+require 'base64'
+require 'openssl'
+require 'uri'
+
+module Daytona
+  module Utils
+    module FileUrlSigning
+      SIGNATURE_V1_PREFIX = 'v1_'
+      private_constant :SIGNATURE_V1_PREFIX
+
+      DEFAULT_TTL_SECONDS = 3600
+      private_constant :DEFAULT_TTL_SECONDS
+
+      module_function
+
+      def compute_file_url_signature(signing_key, method, path, expires)
+        canonical = "v1:files:#{method}:#{path}:#{expires}"
+        digest = OpenSSL::HMAC.digest('sha256', signing_key, canonical)
+
+        "#{SIGNATURE_V1_PREFIX}#{Base64.urlsafe_encode64(digest, padding: false)}"
+      end
+
+      def resolve_expires(ttl_seconds)
+        return Time.now.to_i + DEFAULT_TTL_SECONDS if ttl_seconds.nil?
+
+        return 0 if ttl_seconds <= 0
+
+        Time.now.to_i + ttl_seconds
+      end
+
+      def build_signed_file_url(toolbox_proxy_url, sandbox_id, operation_path, method, file_path, signing_key,
+                                ttl_seconds)
+        if signing_key.nil? || signing_key.empty?
+          raise Daytona::Sdk::Error,
+                'Sandbox signing key is not available. Call refresh or fetch the sandbox by ID to load it.'
+        end
+
+        if toolbox_proxy_url.nil? || toolbox_proxy_url.empty?
+          raise Daytona::Sdk::Error,
+                'Sandbox toolbox proxy URL is not available. Call refresh or fetch the sandbox by ID to load it.'
+        end
+
+        expires = resolve_expires(ttl_seconds)
+        signature = compute_file_url_signature(signing_key, method, file_path, expires)
+        query = URI.encode_www_form(path: file_path, expires: expires.to_s, signature:)
+
+        "#{toolbox_proxy_url.sub(%r{/+\z}, '')}/#{sandbox_id}#{operation_path}?#{query}"
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daytona
 version: !ruby/object:Gem::Version
-  version: 0.200.1
+  version: 0.201.0
 platform: ruby
 authors:
 - Daytona Platforms Inc.
@@ -85,56 +85,62 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.200.1
+        version: 0.201.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.200.1
+        version: 0.201.0
 - !ruby/object:Gem::Dependency
   name: daytona_api_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.200.1
+        version: 0.201.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.200.1
+        version: 0.201.0
 - !ruby/object:Gem::Dependency
   name: daytona_toolbox_api_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.200.1
+        version: 0.201.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.200.1
+        version: 0.201.0
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: observer
   requirement: !ruby/object:Gem::Requirement
@@ -221,11 +227,15 @@ files:
 - lib/daytona/process.rb
 - lib/daytona/sandbox.rb
 - lib/daytona/sdk.rb
+- lib/daytona/sdk/deprecated.rb
+- lib/daytona/sdk/errors.rb
+- lib/daytona/sdk/file_download_patch.rb
 - lib/daytona/sdk/version.rb
 - lib/daytona/secret.rb
 - lib/daytona/secret_service.rb
 - lib/daytona/snapshot_service.rb
 - lib/daytona/util.rb
+- lib/daytona/utils/file_url_signing.rb
 - lib/daytona/volume.rb
 - lib/daytona/volume_service.rb
 - project.json