daytona 0.170.0 → 0.171.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7515dcf7e9ce6366233315925a09418cfe7714473f55ccf2062010f3d5ac692c
-  data.tar.gz: 85148ff08b50b7a9d647ac53ae8b73622e5e3d9d01f9a211229a1ec071f49979
+  metadata.gz: 7b07a148abb7ece5ebaef51d75a606301119c2e4b8bda891406e71acbe60dc9a
+  data.tar.gz: 66186d6b161ab68bf34df1c4860cc2e7b59c3d8983171efa2c3dbaddc36ef1a6
 SHA512:
-  metadata.gz: ccd9ad77b30a91e4aa4ca503d87d3d9a976978b553bf3c0a1ba6e80c912c804bfab99b520377edc71ab17abd4eb22790edac7ae683bf2f6a58bfe6419a08e390
-  data.tar.gz: 071d6d27256509829400a640d70b386c7a627e44731b07b0a2ba04559c3837bf31ec4f037c76f9f4bdbe5073af58d9660551d14ccac9e6fff5dd653712c0b04a
+  metadata.gz: 392310a933e9c7555db1787abe9247462fa1fffc421a4cdbe8714c620704346ac8416f595a18bc8534999aaed02a4e64569516a53aee41f08d8bef748c66c445
+  data.tar.gz: 64201581db64d5df476bed8e55cb22fbeb7d1dc8b8cd9f5b6d0232fc1bdd898303dd76cd9cd7a94c0db3b4b7da8feb6765f74779a2e14ecdc21c2aec6bed0b76

data/lib/daytona/code_interpreter.rb

@@ -103,15 +103,11 @@ module Daytona
         'Accept' => 'application/json'
       )
 
-      # Use queue for synchronization
       completion_queue = Queue.new
-      interpreter = self # Capture self for use in blocks
-      last_message_time = Time.now
-      message_mutex = Mutex.new
+      interpreter = self
 
       puts "[DEBUG] Connecting to WebSocket: #{ws_url}" if ENV['DEBUG']
 
-      # Connect to WebSocket and execute
       ws = WebSocket::Client::Simple.connect(ws_url, headers:)
 
       ws.on :open do
@@ -120,8 +116,6 @@ module Daytona
       end
 
       ws.on :message do |msg|
-        message_mutex.synchronize { last_message_time = Time.now }
-
         puts "[DEBUG] Received message (length=#{msg.data.length}): #{msg.data.inspect[0..200]}" if ENV['DEBUG']
 
         interpreter.send(:handle_message, msg.data, result, on_stdout, on_stderr, on_error, completion_queue)
@@ -146,72 +140,59 @@ module Daytona
         end
       end
 
-      # Wait for completion signal with idle timeout
-      # If timeout is specified, wait longer to detect actual timeout errors
-      # Otherwise use short idle timeout for normal completion
-      idle_timeout = timeout ? (timeout + 2.0) : 1.0
-      max_wait = (timeout || 300) + 3 # Add buffer to configured timeout
+      no_timeout = timeout.is_a?(Numeric) && timeout <= 0
+      max_wait = no_timeout ? nil : (timeout || 600) + 3
       start_time = Time.now
       completion_reason = nil
 
-      # Wait for completion or close event
       loop do
-        begin
-          completion = completion_queue.pop(true) # non-blocking
-          puts "[DEBUG] Got completion signal: #{completion[:type]}" if ENV['DEBUG']
-
-          # Control message (completed/interrupted) = normal completion
-          if completion[:type] == :completed
-            completion_reason = :completed
-            break
-          # If it's an error from close event (like timeout), raise it
-          elsif completion[:type] == :error_from_close
-            error_msg = completion[:error]
-            # Raise TimeoutError for timeout cases, regular Error for others
-            if error_msg.include?('timed out') || error_msg.include?('Execution timed out')
-              raise Sdk::TimeoutError, error_msg
-            end
-
-            raise Sdk::Error, error_msg
-
-          # Close event during execution (before control message) = likely timeout or error
-          elsif completion[:type] == :close
-            elapsed = Time.now - start_time
-            # If we got close near the timeout, it's likely a timeout
-            if timeout && elapsed >= timeout && elapsed < (timeout + 2)
-              raise Sdk::TimeoutError,
-                    'Execution timed out: operation exceeded the configured `timeout`. Provide a larger value if needed.'
-            end
-            # Otherwise normal close
-            completion_reason = :close
-            break
-          # WebSocket errors
-          elsif completion[:type] == :error && !completion[:error].message.include?('stream closed')
-            raise Sdk::Error, "WebSocket error: #{completion[:error].message}"
+        if max_wait
+          remaining = max_wait - (Time.now - start_time)
+          if remaining <= 0
+            ws.close
+            raise Sdk::TimeoutError,
+                  'Execution timed out: operation exceeded the configured `timeout`. Provide a larger value if needed.'
           end
-        rescue ThreadError
-          # Queue is empty, check idle timeout
         end
 
-        # Check idle timeout (no messages for N seconds = completion)
-        time_since_last_message = message_mutex.synchronize { Time.now - last_message_time }
-        if time_since_last_message > idle_timeout
-          puts "[DEBUG] Idle timeout reached (#{idle_timeout}s), assuming completion" if ENV['DEBUG']
-          completion_reason = :idle_complete
-          break
-        end
+        completion = completion_queue.pop(timeout: max_wait ? remaining : nil)
 
-        # Check for absolute timeout (safety net)
-        if Time.now - start_time > max_wait
+        if completion.nil?
           ws.close
           raise Sdk::TimeoutError,
                 'Execution timed out: operation exceeded the configured `timeout`. Provide a larger value if needed.'
         end
 
-        sleep 0.05 # Check every 50ms
+        puts "[DEBUG] Got completion signal: #{completion[:type]}" if ENV['DEBUG']
+
+        if completion[:type] == :completed
+          completion_reason = :completed
+          break
+        elsif completion[:type] == :error_from_close
+          error_msg = completion[:error]
+          if error_msg.include?('timed out') || error_msg.include?('Execution timed out')
+            raise Sdk::TimeoutError, error_msg
+          end
+
+          raise Sdk::Error, error_msg
+        elsif completion[:type] == :close
+          elapsed = Time.now - start_time
+          if timeout && timeout > 0 && elapsed >= timeout && elapsed < (timeout + 2)
+            raise Sdk::TimeoutError,
+                  'Execution timed out: operation exceeded the configured `timeout`. Provide a larger value if needed.'
+          end
+          completion_reason = :close
+          break
+        elsif completion[:type] == :error
+          unless completion[:error].message.include?('stream closed')
+            raise Sdk::Error, "WebSocket error: #{completion[:error].message}"
+          end
+
+          completion_reason = :close
+          break
+        end
       end
 
-      # Close WebSocket if not already closed
       ws.close if completion_reason != :close
       sleep 0.05
 

data/lib/daytona/computer_use.rb

@@ -91,7 +91,7 @@ module Daytona
       #
       # @example
       #   result = sandbox.computer_use.mouse.drag(start_x: 50, start_y: 50, end_x: 150, end_y: 150)
-      #   puts "Dragged from #{result.from_x},#{result.from_y} to #{result.to_x},#{result.to_y}"
+      #   puts "Drag ended at #{result.x}, #{result.y}"
       def drag(start_x:, start_y:, end_x:, end_y:, button: 'left')
         request = DaytonaToolboxApiClient::MouseDragRequest.new(start_x:, start_y:, end_x:, end_y:, button:)
         toolbox_api.drag(request)

data/lib/daytona/daytona.rb

@@ -224,8 +224,16 @@ module Daytona
     def ensure_access_token_defined
       return if config.api_key
 
-      raise Sdk::Error, 'API key or JWT token is required' unless config.jwt_token
-      raise Sdk::Error, 'Organization ID is required when using JWT token' unless config.organization_id
+      unless config.jwt_token
+        raise Sdk::Error,
+              'Authentication credentials not found. Set DAYTONA_API_KEY, or both DAYTONA_JWT_TOKEN and ' \
+              'DAYTONA_ORGANIZATION_ID. These can also be provided via Daytona::Config.'
+      end
+      return if config.organization_id
+
+      raise Sdk::Error,
+            'DAYTONA_ORGANIZATION_ID is required when authenticating with DAYTONA_JWT_TOKEN. ' \
+            'It can also be provided via Daytona::Config.'
     end
 
     # @return [DaytonaApiClient::ApiClient]

data/lib/daytona/file_system.rb

@@ -5,9 +5,10 @@
 
 require 'tempfile'
 require 'fileutils'
+require_relative 'file_transfer'
 
 module Daytona
-  class FileSystem
+  class FileSystem # rubocop:disable Metrics/ClassLength
     include Instrumentation
 
     # @return [String] The Sandbox ID
@@ -153,6 +154,37 @@ module Daytona
       raise Sdk::Error, "Failed to download file: #{e.message}"
     end
 
+    # Downloads a single file from the Sandbox as a stream without buffering the entire
+    # file into memory. Yields file content in chunks to the given block, or returns an
+    # Enumerator if no block is given.
+    #
+    # @param remote_path [String] Path to the file in the Sandbox. Relative paths are resolved
+    #   based on the sandbox working directory.
+    # @param timeout [Integer] Timeout for the download operation in seconds. 0 means no timeout.
+    #   Default is 30 minutes.
+    # @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
+    #
+    # @example Stream to a local file without loading into memory
+    #   File.open("local_copy.bin", "wb") do |f|
+    #     sandbox.fs.download_file_stream("workspace/large-file.bin") { |chunk| f.write(chunk) }
+    #   end
+    #
+    # @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?
+
+      FileTransfer.stream_download(api_client: toolbox_api.api_client, remote_path: remote_path,
+                                   timeout: timeout, &)
+      nil
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to download file: #{e.message}"
+    end
+
     # Uploads a file to the specified path in the Sandbox. If a file already exists at
     # the destination path, it will be overwritten.
     #
@@ -364,8 +396,8 @@ module Daytona
     end
 
     instrument :create_folder, :delete_file, :get_file_info, :list_files, :download_file,
-               :upload_file, :upload_files, :find_files, :search_files, :move_files,
-               :replace_in_files, :set_file_permissions,
+               :download_file_stream, :upload_file, :upload_files, :find_files,
+               :search_files, :move_files, :replace_in_files, :set_file_permissions,
                component: 'FileSystem'
 
     private

data/lib/daytona/file_transfer.rb

@@ -0,0 +1,184 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+require 'json'
+require 'typhoeus'
+
+module Daytona
+  class MultipartDownloadStreamParser
+    attr_reader :error_message
+    attr_writer :boundary_token
+
+    def initialize(&on_file_chunk)
+      @on_file_chunk = on_file_chunk
+      @boundary_token = nil
+      @buffer = String.new.b
+      @state = :preamble
+      @part_name = nil
+      @error_buffer = String.new.b
+    end
+
+    def <<(chunk)
+      @buffer << chunk.b
+      process!
+    end
+
+    def finish!
+      process!
+
+      return if @state == :done || @buffer.empty?
+
+      emit(@buffer)
+      finalize_part!
+      @buffer = String.new.b
+      @state = :done
+    end
+
+    private
+
+    def process!
+      loop do
+        advanced = case @state
+                   when :preamble then consume_preamble?
+                   when :headers then consume_headers?
+                   when :body then consume_body?
+                   else false
+                   end
+
+        break unless advanced
+      end
+    end
+
+    def consume_preamble?
+      start_marker = "#{boundary}\r\n".b
+      index = @buffer.index(start_marker)
+      return retain_tail?(start_marker.bytesize - 1) unless index
+
+      @buffer = remaining_bytes(index + start_marker.bytesize)
+      @state = :headers
+      true
+    end
+
+    def consume_headers?
+      separator = "\r\n\r\n".b
+      index = @buffer.index(separator)
+      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?
+
+      @state = :body
+      true
+    end
+
+    def consume_body? # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      marker = "\r\n#{boundary}".b
+      index = @buffer.index(marker)
+
+      if index
+        emit(@buffer.byteslice(0, index))
+        @buffer = remaining_bytes(index + marker.bytesize)
+        finalize_part!
+        @state = :done
+        return true
+      end
+
+      flushable = @buffer.bytesize - marker.bytesize + 1
+      return false if flushable <= 0
+
+      emit(@buffer.byteslice(0, flushable))
+      @buffer = remaining_bytes(flushable)
+      false
+    end
+
+    def emit(data)
+      return if data.nil? || data.empty?
+
+      case @part_name
+      when 'file'
+        @on_file_chunk.call(data)
+      when 'error'
+        @error_buffer << data
+      end
+    end
+
+    def finalize_part!
+      return unless @part_name == 'error'
+
+      @error_message = extract_error_message(@error_buffer)
+    end
+
+    def extract_error_message(payload)
+      parsed = JSON.parse(payload)
+      parsed['message'] || parsed['error'] || payload
+    rescue JSON::ParserError
+      payload
+    end
+
+    def retain_tail?(size)
+      @buffer = @buffer.byteslice(-size, size) || String.new.b if size.positive? && @buffer.bytesize > size
+      false
+    end
+
+    def remaining_bytes(offset)
+      @buffer.byteslice(offset, @buffer.bytesize - offset) || String.new.b
+    end
+
+    def boundary
+      "--#{@boundary_token}".b
+    end
+  end
+
+  module FileTransfer
+    def self.extract_multipart_boundary(content_type)
+      match = content_type&.match(/boundary=(?:"([^"]+)"|([^;]+))/i)
+      return unless match
+
+      match.captures.compact.first
+    end
+
+    def self.stream_download(api_client:, remote_path:, timeout:, &) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      config = api_client.config
+      parser = MultipartDownloadStreamParser.new(&)
+      response = nil
+
+      request = Typhoeus::Request.new(
+        "#{config.base_url}/files/bulk-download",
+        method: :post,
+        headers: api_client.default_headers.dup.merge(
+          'Accept' => 'multipart/form-data',
+          'Content-Type' => 'application/json'
+        ),
+        body: JSON.generate(paths: [remote_path]),
+        timeout: timeout,
+        ssl_verifypeer: config.verify_ssl,
+        ssl_verifyhost: config.verify_ssl_host ? 2 : 0
+      )
+
+      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
+      end
+
+      request.on_body do |chunk|
+        parser << chunk
+      end
+
+      request.on_complete do |completed_response|
+        response = completed_response
+        parser.finish!
+      end
+
+      request.run
+
+      raise Sdk::Error, parser.error_message if parser.error_message
+      raise Sdk::Error, "HTTP #{response.code}" if response && !response.success?
+    end
+  end
+end

data/lib/daytona/sdk/version.rb

@@ -5,6 +5,6 @@
 
 module Daytona
   module Sdk
-    VERSION = '0.170.0'
+    VERSION = '0.171.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daytona
 version: !ruby/object:Gem::Version
-  version: 0.170.0
+  version: 0.171.0
 platform: ruby
 authors:
 - Daytona Platforms Inc.
@@ -85,28 +85,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.170.0
+        version: 0.171.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.170.0
+        version: 0.171.0
 - !ruby/object:Gem::Dependency
   name: daytona_toolbox_api_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.170.0
+        version: 0.171.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.170.0
+        version: 0.171.0
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement
@@ -196,6 +196,7 @@ files:
 - lib/daytona/config.rb
 - lib/daytona/daytona.rb
 - lib/daytona/file_system.rb
+- lib/daytona/file_transfer.rb
 - lib/daytona/git.rb
 - lib/daytona/lsp_server.rb
 - lib/daytona/object_storage.rb