daytona 0.173.0 → 0.175.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83d12903b0910a3d69cd7042e642fe9cc748ee97ec605ae669e1537f433cbe32
-  data.tar.gz: af534e94adbe126f60c62b8e27b1a7caa1e67230ab10e055e73c4092e13b2684
+  metadata.gz: 17bac4d118263d5f248ac719aafb05357330d337618db08f599b59c5bcfbf584
+  data.tar.gz: ac0e288d40bc79b1df009fbb4585face3b667b8b01949e13f556a368fbb3bc1b
 SHA512:
-  metadata.gz: b45b939dacd1b20b5864a90f0fdc02dcd2c4f34873b81148bd19de59c748d4b0f959b01136b3d1ad580b4f15fff7fef710c967f68cc66d5ce0dc9370fdbafbcd
-  data.tar.gz: 69cc63a19e83148b9f36206cf6bc4b59de091105bba7ed4709d815743b5689b29ef9e9c85da45ed332b58039e19a89b7730070f5f3d2b44c3c8563e07926570a
+  metadata.gz: 575d0f018a49ebddb4e7dcc2e70e96b762f93ea6e4ad219413506809413f4629935102f870e8b67adb0ed1cb2418d5a4a7e78da946e684b18db1d011611c5c18
+  data.tar.gz: b3cdd82c715982e6221263e7b2141cfd1562261d5faf49d45d42738ee0fa2a7cbeaf96a7c0e6c577e1208e41f82547242d0c44f12316fdfff76ceb25377a2cad

data/.rubocop.yml

@@ -14,3 +14,9 @@ Style/Documentation:
 
 Style/AccessorGrouping:
   EnforcedStyle: separated
+
+# RSpec describe / context blocks naturally span the whole file; the
+# stock 25-line cap forces noise instead of catching real complexity.
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'

data/lib/daytona/file_system.rb

@@ -162,10 +162,17 @@ module Daytona
     #   based on the sandbox working directory.
     # @param timeout [Integer] Timeout for the download operation in seconds. 0 means no timeout.
     #   Default is 30 minutes.
+    # @param on_progress [Proc, nil] Optional callback invoked with a Daytona::DownloadProgress
+    #   struct containing bytes_received (Integer) and total_bytes (Integer or nil).
+    # @param cancel_event [#set?, nil] Optional cancellation token (anything responding to +set?+;
+    #   the standard library's +Concurrent::Event+ or a small ad-hoc object both work). When set
+    #   during streaming, the next chunk raises Daytona::Sdk::Error and the underlying HTTP
+    #   connection is torn down.
     # @yield [chunk] Yields each chunk of file content as it arrives
     # @yieldparam chunk [String] A binary string chunk of file content
     # @return [Enumerator, nil] An Enumerator yielding chunks if no block given, nil otherwise
-    # @raise [Daytona::Sdk::Error] If the file does not exist or the operation fails
+    # @raise [Daytona::Sdk::Error] If the file does not exist, the operation fails, or
+    #   +cancel_event+ is set during streaming
     #
     # @example Stream to a local file without loading into memory
     #   File.open("local_copy.bin", "wb") do |f|
@@ -175,11 +182,12 @@ module Daytona
     # @example Collect chunks with an Enumerator
     #   content = sandbox.fs.download_file_stream("workspace/data.json").reduce(:+)
     #   puts content
-    def download_file_stream(remote_path, timeout: 30 * 60, &)
-      return enum_for(__method__, remote_path, timeout:) unless block_given?
+    def download_file_stream(remote_path, timeout: 30 * 60, on_progress: nil, cancel_event: nil, &)
+      return enum_for(__method__, remote_path, timeout:, on_progress:, cancel_event:) unless block_given?
 
       FileTransfer.stream_download(api_client: toolbox_api.api_client, remote_path: remote_path,
-                                   timeout: timeout, &)
+                                   timeout: timeout, on_progress: on_progress,
+                                   cancel_event: cancel_event, &)
       nil
     rescue StandardError => e
       raise Sdk::Error, "Failed to download file: #{e.message}"
@@ -225,6 +233,36 @@ module Daytona
       raise Sdk::Error, "Failed to upload file: #{e.message}"
     end
 
+    # Streams +source+ to the Sandbox without buffering its contents in memory, with
+    # optional progress reporting.
+    #
+    # @param source [String, IO] A local file path or any IO-like object responding to
+    #   +read(n)+. Strings that don't reference an existing file are uploaded as their
+    #   raw bytes (still streamed, just from memory).
+    # @param remote_path [String] Destination path in the Sandbox.
+    # @param timeout [Integer] Timeout in seconds. 0 means no timeout. Default 30 minutes.
+    # @param on_progress [Proc, nil] Optional callback invoked with a
+    #   +Daytona::UploadProgress+ struct as libcurl reports bytes actually uploaded.
+    # @param cancel_event [#set?, nil] Optional cancellation token. When set while
+    #   staging a non-file source or during the libcurl upload, the operation raises
+    #   Daytona::Sdk::Error and the in-progress upload is aborted (no destination file
+    #   is left on the sandbox thanks to the daemon's atomic-rename behaviour).
+    # @return [void]
+    # @raise [Daytona::Sdk::Error] If the operation fails or +cancel_event+ is set.
+    #
+    # @example
+    #   File.open("large.bin", "rb") do |f|
+    #     sandbox.fs.upload_file_stream(f, "tmp/large.bin",
+    #       on_progress: ->(p) { puts "#{p.bytes_sent} bytes sent" })
+    #   end
+    def upload_file_stream(source, remote_path, timeout: 30 * 60, on_progress: nil, cancel_event: nil)
+      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
+      raise Sdk::Error, "Failed to upload file: #{e.message}"
+    end
+
     # Uploads multiple files to the Sandbox. If files already exist at the destination paths,
     # they will be overwritten.
     #

data/lib/daytona/file_transfer.rb

@@ -4,11 +4,20 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'stringio'
+require 'tempfile'
 require 'typhoeus'
 
 module Daytona
+  # Progress information for a streaming download.
+  DownloadProgress = Struct.new(:bytes_received, :total_bytes, keyword_init: true)
+
+  # Progress information for a streaming upload.
+  UploadProgress = Struct.new(:bytes_sent, keyword_init: true)
+
   class MultipartDownloadStreamParser
     attr_reader :error_message
+    attr_reader :part_total_bytes
     attr_writer :boundary_token
 
     def initialize(&on_file_chunk)
@@ -17,6 +26,7 @@ module Daytona
       @buffer = String.new.b
       @state = :preamble
       @part_name = nil
+      @part_total_bytes = nil
       @error_buffer = String.new.b
     end
 
@@ -62,14 +72,14 @@ module Daytona
     end
 
     def consume_headers?
-      separator = "\r\n\r\n".b
-      index = @buffer.index(separator)
+      index = @buffer.index("\r\n\r\n".b)
       return false unless index
 
       headers = @buffer.byteslice(0, index)
-      @buffer = remaining_bytes(index + separator.bytesize)
-      @part_name = headers[/Content-Disposition:\s*[^\r\n]*\bname="([^"]+)"/i, 1]
-      raise Sdk::Error, 'Invalid multipart response' if @part_name.nil?
+      @buffer = remaining_bytes(index + 4)
+      @part_name = headers[/Content-Disposition:\s*[^\r\n]*\bname="([^"]+)"/i, 1] ||
+                   raise(Sdk::Error, 'Invalid multipart response')
+      @part_total_bytes = headers[/Content-Length:\s*(\d+)/i, 1]&.to_i
 
       @state = :body
       true
@@ -124,16 +134,11 @@ module Daytona
       false
     end
 
-    def remaining_bytes(offset)
-      @buffer.byteslice(offset, @buffer.bytesize - offset) || String.new.b
-    end
-
-    def boundary
-      "--#{@boundary_token}".b
-    end
+    def remaining_bytes(offset) = @buffer.byteslice(offset, @buffer.bytesize - offset) || String.new.b
+    def boundary = "--#{@boundary_token}".b
   end
 
-  module FileTransfer
+  module FileTransfer # rubocop:disable Metrics/ModuleLength
     def self.extract_multipart_boundary(content_type)
       match = content_type&.match(/boundary=(?:"([^"]+)"|([^;]+))/i)
       return unless match
@@ -141,9 +146,31 @@ module Daytona
       match.captures.compact.first
     end
 
-    def self.stream_download(api_client:, remote_path:, timeout:, &) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def self.assign_download_boundary(parser, content_type)
+      boundary = extract_multipart_boundary(content_type)
+      raise Sdk::Error, 'Missing multipart boundary in download response' unless boundary
+
+      parser.boundary_token = boundary
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def self.stream_download(api_client:, remote_path:, timeout:, on_progress: nil, cancel_event: nil, &block)
       config = api_client.config
-      parser = MultipartDownloadStreamParser.new(&)
+      bytes_received = 0
+      parser = nil
+      wrapped_block = proc do |chunk|
+        raise Sdk::Error, "Download cancelled: #{remote_path}" if cancel_event&.set?
+
+        if on_progress
+          bytes_received += chunk.bytesize
+          on_progress.call(DownloadProgress.new(
+                             bytes_received: bytes_received,
+                             total_bytes: parser&.part_total_bytes
+                           ))
+        end
+        block.call(chunk)
+      end
+      parser = MultipartDownloadStreamParser.new(&wrapped_block)
       response = nil
 
       request = Typhoeus::Request.new(
@@ -160,13 +187,15 @@ module Daytona
       )
 
       request.on_headers do |stream_response|
-        boundary = extract_multipart_boundary(stream_response.headers['Content-Type'])
-        raise Sdk::Error, 'Missing multipart boundary in download response' unless boundary
-
-        parser.boundary_token = boundary
+        assign_download_boundary(parser, stream_response.headers['Content-Type'])
       end
 
+      # Returning +:abort+ from the on_body callback tells libcurl to tear down the
+      # connection immediately, which is how cancellation actually severs the
+      # transfer rather than just stopping our own bookkeeping.
       request.on_body do |chunk|
+        next :abort if cancel_event&.set?
+
         parser << chunk
       end
 
@@ -177,8 +206,143 @@ module Daytona
 
       request.run
 
+      raise Sdk::Error, "Download cancelled: #{remote_path}" if cancel_event&.set?
       raise Sdk::Error, parser.error_message if parser.error_message
       raise Sdk::Error, "HTTP #{response.code}" if response && !response.success?
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    # Uploads +source+ to /files/bulk-upload via Typhoeus (libcurl), which streams the
+    # request body straight from disk without buffering it in memory. Local file paths
+    # are uploaded directly; in-memory IOs/bytes are first drained to a tempfile so we
+    # have a stable file handle for libcurl.
+    #
+    # The daemon owns atomicity (writes to a sibling tempfile then renames), so a
+    # client-side abort just leaves no destination file at all.
+    #
+    # @param api_client The OpenAPI-generated toolbox API client (auth/base-url only).
+    # @param remote_path [String] Destination path in the sandbox.
+    # @param source [String, IO] Local file path or any IO-like object responding to +read(n)+.
+    # @param timeout [Integer] Typhoeus timeout in seconds (0 disables).
+    # @param on_progress [Proc, nil] Optional callback invoked with +Daytona::UploadProgress+
+    #   as libcurl reports real network upload progress.
+    # @param cancel_event [#set?, nil] Optional cancellation token. Checked while staging
+    #   non-file sources and during the libcurl transfer itself.
+    # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+    def self.stream_upload(api_client:, remote_path:, source:, timeout:, on_progress: nil, cancel_event: nil)
+      with_upload_file(source, cancel_event, remote_path) do |upload_path|
+        config = api_client.config
+        progress_callback = upload_progress_callback(on_progress, cancel_event)
+        response = with_open_upload_file(upload_path) do |file|
+          upload_request(
+            api_client: api_client,
+            config: config,
+            remote_path: remote_path,
+            file: file,
+            timeout: timeout,
+            progress_callback: progress_callback
+          ).run
+        end
+        raise_upload_error(response, cancel_event, remote_path)
+      end
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
+
+    # Yields a path on disk that holds the source's bytes, ready for libcurl to stream.
+    # Local files are passed through unchanged; everything else is drained into a
+    # tempfile that gets unlinked when we return.
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def self.with_upload_file(source, cancel_event, remote_path)
+      raise Sdk::Error, "Upload cancelled: #{remote_path}" if cancel_event&.set?
+
+      return yield(source) if source.is_a?(String) && File.exist?(source)
+
+      tmp = Tempfile.new(['daytona-upload-', File.extname(remote_path).to_s])
+      tmp.binmode
+      begin
+        drain_source_to(source, tmp, cancel_event, remote_path)
+        tmp.flush
+        tmp.close
+        yield(tmp.path)
+      ensure
+        tmp.close unless tmp.closed?
+        begin
+          tmp.unlink
+        rescue StandardError
+          # tempfile already gone, nothing to do
+        end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def self.drain_source_to(source, sink, cancel_event, remote_path)
+      io, owns_io = open_drain_source(source)
+      begin
+        while (chunk = io.read(64 * 1024))
+          break if chunk.empty?
+          raise Sdk::Error, "Upload cancelled: #{remote_path}" if cancel_event&.set?
+
+          sink.write(chunk)
+        end
+      ensure
+        io.close if owns_io && io.respond_to?(:close)
+      end
+    end
+
+    def self.with_open_upload_file(upload_path)
+      file = File.open(upload_path, 'rb')
+      yield(file)
+    ensure
+      file.close if file && !file.closed?
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+    def self.upload_request(api_client:, config:, remote_path:, file:, timeout:, progress_callback:)
+      Typhoeus::Request.new(
+        "#{config.base_url}/files/bulk-upload",
+        method: :post,
+        headers: api_client.default_headers.dup.tap { |h| h.delete('Content-Type') },
+        body: {
+          'files[0].path' => remote_path,
+          'files[0].file' => file
+        },
+        timeout: timeout,
+        ssl_verifypeer: config.verify_ssl,
+        ssl_verifyhost: config.verify_ssl_host ? 2 : 0,
+        noprogress: false,
+        progressfunction: progress_callback,
+        xferinfofunction: progress_callback
+      )
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
+
+    def self.upload_progress_callback(on_progress, cancel_event)
+      last_bytes_sent = -1
+
+      proc do |_clientp, _dltotal, _dlnow, _ultotal, ulnow|
+        next 1 if cancel_event&.set?
+
+        bytes_sent = ulnow.to_i
+        if on_progress && bytes_sent > last_bytes_sent
+          last_bytes_sent = bytes_sent
+          on_progress.call(UploadProgress.new(bytes_sent: bytes_sent))
+        end
+
+        0
+      end
+    end
+
+    def self.raise_upload_error(response, _cancel_event, remote_path)
+      raise Sdk::Error, "Upload timed out: #{remote_path}" if response.timed_out?
+      raise Sdk::Error, "Upload cancelled: #{remote_path}" if response.return_code == :aborted_by_callback
+      raise Sdk::Error, "HTTP #{response.code}: #{response.body}" unless response.success?
+    end
+
+    def self.open_drain_source(source)
+      return [source, false] if source.respond_to?(:read)
+      return [StringIO.new(source.b), true] if source.is_a?(String)
+
+      raise Sdk::Error, "Unsupported upload source: #{source.class}"
+    end
   end
 end

data/lib/daytona/git.rb

@@ -45,6 +45,8 @@ module Daytona
     #   ])
     def add(path, files)
       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}"
     end
@@ -61,6 +63,8 @@ module Daytona
     #   puts "Branches: #{response.branches}"
     def branches(path)
       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}"
     end
@@ -114,6 +118,8 @@ module Daytona
           commit_id: commit_id
         )
       )
+    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}"
     end
@@ -146,6 +152,8 @@ module Daytona
         DaytonaToolboxApiClient::GitCommitRequest.new(path:, message:, author:, email:, allow_empty:)
       )
       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}"
     end
@@ -175,6 +183,8 @@ module Daytona
       toolbox_api.push_changes(
         DaytonaToolboxApiClient::GitRepoRequest.new(path:, username:, password:)
       )
+    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}"
     end
@@ -204,6 +214,8 @@ module Daytona
       toolbox_api.pull_changes(
         DaytonaToolboxApiClient::GitRepoRequest.new(path:, username:, password:)
       )
+    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}"
     end
@@ -222,6 +234,8 @@ module Daytona
     #   puts "Commits behind: #{status.behind}"
     def status(path)
       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}"
     end
@@ -241,6 +255,8 @@ module Daytona
       toolbox_api.checkout_branch(
         DaytonaToolboxApiClient::GitCheckoutRequest.new(path:, branch:)
       )
+    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}"
     end
@@ -261,6 +277,8 @@ module Daytona
       toolbox_api.create_branch(
         DaytonaToolboxApiClient::GitBranchRequest.new(path:, name:)
       )
+    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}"
     end
@@ -280,6 +298,8 @@ module Daytona
       toolbox_api.delete_branch(
         DaytonaToolboxApiClient::GitDeleteBranchRequest.new(path:, name:)
       )
+    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}"
     end
@@ -292,5 +312,19 @@ module Daytona
 
     # @return [Daytona::OtelState, nil]
     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
+    end
   end
 end

data/lib/daytona/sdk/version.rb

@@ -5,6 +5,6 @@
 
 module Daytona
   module Sdk
-    VERSION = '0.173.0'
+    VERSION = '0.175.0'
   end
 end

data/lib/daytona/sdk.rb

@@ -43,6 +43,13 @@ 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
 
     def self.logger = @logger ||= Logger.new($stdout, level: Logger::INFO)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daytona
 version: !ruby/object:Gem::Version
-  version: 0.173.0
+  version: 0.175.0
 platform: ruby
 authors:
 - Daytona Platforms Inc.
@@ -85,28 +85,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.173.0
+        version: 0.175.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.173.0
+        version: 0.175.0
 - !ruby/object:Gem::Dependency
   name: daytona_toolbox_api_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.173.0
+        version: 0.175.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.173.0
+        version: 0.175.0
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement