daytona 0.184.0 → 0.185.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a915942565b3350f301af5bc17108ed23fd4c17ab2fabf794c55d061f7001b05
-  data.tar.gz: b7c4ae7fb09fd196a84b5b63fb06e66300ca16ef30d18f5b87c8026e0aa0366c
+  metadata.gz: '0846ab327fc5ae0c55ee61872fb3c29bf266979387b8f362846d0856dee50b0d'
+  data.tar.gz: 6ea941ba9e0c6182cbd9c364174ff58ec32eba00fa9c252d2decb5131bd19676
 SHA512:
-  metadata.gz: a849bfb163dbd2ec05b7fbc152877d702195526bf28c1c74e3da19b79d454d338deed08f4bc503998594ba65549f1b7960af64383bc6da67402751faebd09d45
-  data.tar.gz: 7769c3074cda40aad265165e41755e6e6de16144a36b1bbc1e739f8b3e5b9c20d0d57c4eec20dccaa97322b412068c663f3d86f2ecf1514c3cb18aceb39337c7
+  metadata.gz: 8f7da0103eee9ba48d742003281d86530482aa1504e4c8d60734841c2c1229b47270c1d646b17cd70071e0fb314feb3c3fa262c92348324dd2015a062d67a853
+  data.tar.gz: 801300d22b0ebc53f76d870a4f98eca73b0bf267b8b877d33f6be41cf3c6c35790971d9abbec4e5241f4335ef7c0aa44b2e9958ea8fe7579d562e778fb8a49de

data/lib/daytona/code_interpreter.rb

@@ -108,40 +108,40 @@ module Daytona
 
       puts "[DEBUG] Connecting to WebSocket: #{ws_url}" if ENV['DEBUG']
 
-      ws = WebSocket::Client::Simple.connect(ws_url, headers:)
-
-      ws.on :open do
-        puts '[DEBUG] WebSocket opened, sending request' if ENV['DEBUG']
-        ws.send(JSON.dump(request))
-      end
-
-      ws.on :message do |msg|
-        puts "[DEBUG] Received message (length=#{msg.data.length}): #{msg.data.inspect[0..200]}" if ENV['DEBUG']
+      ws = WebSocket::Client::Simple.connect(ws_url, headers:) do |client|
+        client.on :open do
+          puts '[DEBUG] WebSocket opened, sending request' if ENV['DEBUG']
+          client.send(JSON.dump(request))
+        end
 
-        interpreter.send(:handle_message, msg.data, result, on_stdout, on_stderr, on_error, completion_queue)
-      end
+        client.on :message do |msg|
+          puts "[DEBUG] Received message (length=#{msg.data.length}): #{msg.data.inspect[0..200]}" if ENV['DEBUG']
 
-      ws.on :error do |e|
-        puts "[DEBUG] WebSocket error: #{e.message}" if ENV['DEBUG']
-        completion_queue.push({ type: :error, error: e })
-      end
+          interpreter.send(:handle_message, msg.data, result, on_stdout, on_stderr, on_error, completion_queue)
+        end
 
-      ws.on :close do |e|
-        if ENV['DEBUG']
-          code = e&.code || 'nil'
-          reason = e&.reason || 'nil'
-          puts "[DEBUG] WebSocket closed: code=#{code}, reason=#{reason}"
+        client.on :error do |e|
+          puts "[DEBUG] WebSocket error: #{e.message}" if ENV['DEBUG']
+          completion_queue.push({ type: :error, error: e })
         end
-        error_info = interpreter.send(:handle_close, e)
-        if error_info
-          completion_queue.push({ type: :error_from_close, error: error_info })
-        else
-          completion_queue.push({ type: :close })
+
+        client.on :close do |e|
+          if ENV['DEBUG']
+            code = e&.code || 'nil'
+            reason = e&.reason || 'nil'
+            puts "[DEBUG] WebSocket closed: code=#{code}, reason=#{reason}"
+          end
+          error_info = interpreter.send(:handle_close, e)
+          if error_info
+            completion_queue.push({ type: :error_from_close, error: error_info })
+          else
+            completion_queue.push({ type: :close })
+          end
         end
       end
 
       no_timeout = timeout.is_a?(Numeric) && timeout <= 0
-      max_wait = no_timeout ? nil : (timeout || 600) + 3
+      max_wait = no_timeout ? nil : (timeout || 600) + 30
       start_time = Time.now
       completion_reason = nil
 

data/lib/daytona/common/response.rb

@@ -6,6 +6,7 @@
 module Daytona
   # Re-export of api-client enum constants under the Daytona namespace so
   # SDK consumers never need to import from DaytonaApiClient directly.
+  SandboxClass = DaytonaApiClient::SandboxClass
   SandboxState = DaytonaApiClient::SandboxState
   SandboxListSortField = DaytonaApiClient::SandboxListSortField
   SandboxListSortDirection = DaytonaApiClient::SandboxListSortDirection

data/lib/daytona/common/snapshot.rb

@@ -23,17 +23,22 @@ module Daytona
     #   Defaults to organization default region if not specified.
     attr_reader :region_id
 
+    # @return [DaytonaApiClient::SandboxClass, nil] Target sandbox class.
+    attr_reader :sandbox_class
+
     # @param name [String] Name of the snapshot
     # @param image [String, Daytona::Image] Image of the snapshot
     # @param resources [Daytona::Resources, nil] Resources of the snapshot
     # @param entrypoint [Array<String>, nil] Entrypoint of the snapshot
     # @param region_id [String, nil] ID of the region where the snapshot will be available
-    def initialize(name:, image:, resources: nil, entrypoint: nil, region_id: nil)
+    # @param sandbox_class [DaytonaApiClient::SandboxClass, nil] Target sandbox class
+    def initialize(name:, image:, resources: nil, entrypoint: nil, region_id: nil, sandbox_class: nil)
       @name = name
       @image = image
       @resources = resources
       @entrypoint = entrypoint
       @region_id = region_id
+      @sandbox_class = sandbox_class
     end
   end
 

data/lib/daytona/file_system.rb

@@ -213,7 +213,7 @@ module Daytona
     #   # Upload binary data
     #   data = { key: "value" }.to_json
     #   sandbox.fs.upload_file(data, "tmp/config.json")
-    def upload_file(source, remote_path) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def upload_file(source, remote_path)
       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) }
@@ -221,12 +221,17 @@ module Daytona
         # Source is an IO object
         toolbox_api.upload_file(remote_path, source)
       else
-        # Source is string content - create a temporary file
-        Tempfile.create('daytona_upload') do |file|
-          file.binmode
-          file.write(source)
-          file.rewind
-          toolbox_api.upload_file(remote_path, file)
+        # Tempfile.create yields a ::File (works with Typhoeus) but deletes
+        # on block exit — too early if curl reads asynchronously. Write via
+        # Tempfile, close it, then reopen as ::File for the upload.
+        tmp = Tempfile.new('daytona_upload')
+        begin
+          tmp.binmode
+          tmp.write(source.to_s.b)
+          tmp.close
+          File.open(tmp.path, 'rb') { |file| toolbox_api.upload_file(remote_path, file) }
+        ensure
+          tmp.unlink
         end
       end
     rescue StandardError => e

data/lib/daytona/file_transfer.rb

@@ -18,6 +18,7 @@ module Daytona
   class MultipartDownloadStreamParser
     attr_reader :error_message
     attr_reader :part_total_bytes
+    attr_reader :part_bytes_emitted
     attr_writer :boundary_token
 
     def initialize(&on_file_chunk)
@@ -27,6 +28,7 @@ module Daytona
       @state = :preamble
       @part_name = nil
       @part_total_bytes = nil
+      @part_bytes_emitted = 0
       @error_buffer = String.new.b
     end
 
@@ -35,15 +37,13 @@ module Daytona
       process!
     end
 
+    # Raises if the response ended before the closing multipart boundary, so
+    # truncations surface as typed errors instead of silently short downloads.
     def finish!
       process!
+      return if @state == :done
 
-      return if @state == :done || @buffer.empty?
-
-      emit(@buffer)
-      finalize_part!
-      @buffer = String.new.b
-      @state = :done
+      raise Sdk::Error, "Truncated multipart response: closing boundary not received (state=#{@state})"
     end
 
     private
@@ -110,6 +110,7 @@ module Daytona
 
       case @part_name
       when 'file'
+        @part_bytes_emitted += data.bytesize
         @on_file_chunk.call(data)
       when 'error'
         @error_buffer << data
@@ -201,7 +202,7 @@ module Daytona
 
       request.on_complete do |completed_response|
         response = completed_response
-        parser.finish!
+        parser.finish! unless cancel_event&.set?
       end
 
       request.run
@@ -209,6 +210,16 @@ module Daytona
       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?
+
+      assert_download_length!(parser, remote_path)
+    end
+
+    def self.assert_download_length!(parser, remote_path)
+      return unless parser.part_total_bytes && parser.part_bytes_emitted != parser.part_total_bytes
+
+      raise Sdk::Error,
+            "Multipart response length mismatch for #{remote_path}: " \
+            "got #{parser.part_bytes_emitted} bytes, expected #{parser.part_total_bytes}"
     end
     # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
@@ -232,6 +243,7 @@ module Daytona
     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
+        expected_bytes = File.size(upload_path)
         progress_callback = upload_progress_callback(on_progress, cancel_event)
         response = with_open_upload_file(upload_path) do |file|
           upload_request(
@@ -244,6 +256,7 @@ module Daytona
           ).run
         end
         raise_upload_error(response, cancel_event, remote_path)
+        verify_upload_response(response, remote_path, expected_bytes)
       end
     end
     # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
@@ -338,6 +351,28 @@ module Daytona
       raise Sdk::Error, "HTTP #{response.code}: #{response.body}" unless response.success?
     end
 
+    # Compares the daemon's reported bytes-written against what the SDK sent.
+    # Catches server-side miscounts (or extra-byte injection) at the upload
+    # call site instead of surfacing later as a download mismatch.
+    def self.verify_upload_response(response, remote_path, expected_bytes)
+      recorded = recorded_upload_bytes(response.body, remote_path)
+      return if recorded.nil? || recorded == expected_bytes
+
+      raise Sdk::Error,
+            "Upload size mismatch for #{remote_path}: sent #{expected_bytes} bytes, " \
+            "daemon recorded #{recorded}"
+    end
+
+    def self.recorded_upload_bytes(body, remote_path)
+      parsed = JSON.parse(body) rescue nil # rubocop:disable Style/RescueModifier
+      return nil unless parsed.is_a?(Hash)
+
+      files = Array(parsed['files'])
+      match = files.find { |f| f.is_a?(Hash) && f['path'] == remote_path }
+      bytes = match&.dig('bytes')
+      bytes.is_a?(Integer) ? bytes : nil
+    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)

data/lib/daytona/git.rb

@@ -82,6 +82,9 @@ module Daytona
     #   the repository will be left in a detached HEAD state at this commit.
     # @param username [String, nil] Git username for authentication.
     # @param password [String, nil] Git password or token for authentication.
+    # @param insecure_skip_tls [Boolean, nil] Skip TLS certificate verification (insecure).
+    #   Use only for trusted internal Git servers with self-signed or private-CA certs;
+    #   credentials, if supplied, are transmitted over an unverified TLS connection.
     # @return [void]
     # @raise [Daytona::Sdk::Error] if cloning repository fails
     #
@@ -107,7 +110,7 @@ module Daytona
     #     path: "workspace/repo-old",
     #     commit_id: "abc123"
     #   )
-    def clone(url:, path:, branch: nil, commit_id: nil, username: nil, password: nil) # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+    def clone(url:, path:, branch: nil, commit_id: nil, username: nil, password: nil, insecure_skip_tls: nil) # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
       toolbox_api.clone_repository(
         DaytonaToolboxApiClient::GitCloneRequest.new(
           url: url,
@@ -115,7 +118,8 @@ module Daytona
           path: path,
           username: username,
           password: password,
-          commit_id: commit_id
+          commit_id: commit_id,
+          insecure_skip_tls: insecure_skip_tls
         )
       )
     rescue DaytonaToolboxApiClient::ApiError => e

data/lib/daytona/process.rb

@@ -235,34 +235,34 @@ module Daytona
 
       completion_queue = Queue.new
 
-      ws = WebSocket::Client::Simple.connect(
+      WebSocket::Client::Simple.connect(
         url.to_s,
         headers: toolbox_api.api_client.default_headers.dup.merge(
           'X-Daytona-Preview-Token' => preview_link.token,
           'Content-Type' => 'text/plain',
           'Accept' => 'text/plain'
         )
-      )
+      ) do |client|
+        client.on(:message) do |message|
+          if message.type == :close
+            client.close
+            completion_queue.push(:close)
+          else
+            stdout, stderr = Util.demux(message.data.to_s)
+
+            on_stdout.call(stdout) unless stdout.empty?
+            on_stderr.call(stderr) unless stderr.empty?
+          end
+        end
 
-      ws.on(:message) do |message|
-        if message.type == :close
-          ws.close
+        client.on(:close) do
           completion_queue.push(:close)
-        else
-          stdout, stderr = Util.demux(message.data.to_s)
-
-          on_stdout.call(stdout) unless stdout.empty?
-          on_stderr.call(stderr) unless stderr.empty?
         end
-      end
-
-      ws.on(:close) do
-        completion_queue.push(:close)
-      end
 
-      ws.on(:error) do |e|
-        completion_queue.push(:error)
-        raise Sdk::Error, "WebSocket error: #{e.message}"
+        client.on(:error) do |e|
+          completion_queue.push(:error)
+          raise Sdk::Error, "WebSocket error: #{e.message}"
+        end
       end
 
       # Wait for completion
@@ -302,34 +302,34 @@ module Daytona
 
       completion_queue = Queue.new
 
-      ws = WebSocket::Client::Simple.connect(
+      WebSocket::Client::Simple.connect(
         url.to_s,
         headers: toolbox_api.api_client.default_headers.dup.merge(
           'X-Daytona-Preview-Token' => preview_link.token,
           'Content-Type' => 'text/plain',
           'Accept' => 'text/plain'
         )
-      )
+      ) do |client|
+        client.on(:message) do |message|
+          if message.type == :close
+            client.close
+            completion_queue.push(:close)
+          else
+            stdout, stderr = Util.demux(message.data.to_s)
+
+            on_stdout.call(stdout) unless stdout.empty?
+            on_stderr.call(stderr) unless stderr.empty?
+          end
+        end
 
-      ws.on(:message) do |message|
-        if message.type == :close
-          ws.close
+        client.on(:close) do
           completion_queue.push(:close)
-        else
-          stdout, stderr = Util.demux(message.data.to_s)
-
-          on_stdout.call(stdout) unless stdout.empty?
-          on_stderr.call(stderr) unless stderr.empty?
         end
-      end
-
-      ws.on(:close) do
-        completion_queue.push(:close)
-      end
 
-      ws.on(:error) do |e|
-        completion_queue.push(:error)
-        raise Sdk::Error, "WebSocket error: #{e.message}"
+        client.on(:error) do |e|
+          completion_queue.push(:error)
+          raise Sdk::Error, "WebSocket error: #{e.message}"
+        end
       end
 
       # Wait for completion
@@ -448,18 +448,21 @@ module Daytona
       url.scheme = url.scheme == 'https' ? 'wss' : 'ws'
       url.path = "/process/pty/#{session_id}/connect"
 
-      PtyHandle.new(
-        WebSocket::Client::Simple.connect(
-          url.to_s,
-          headers: toolbox_api.api_client.default_headers.dup.merge(
-            'X-Daytona-Preview-Token' => preview_link.token
-          )
-        ),
-        session_id:,
-
-        handle_resize: ->(pty_size) { resize_pty_session(session_id, pty_size) },
-        handle_kill: -> { delete_pty_session(session_id) }
-      ).tap(&:wait_for_connection)
+      handle = nil
+      WebSocket::Client::Simple.connect(
+        url.to_s,
+        headers: toolbox_api.api_client.default_headers.dup.merge(
+          'X-Daytona-Preview-Token' => preview_link.token
+        )
+      ) do |client|
+        handle = PtyHandle.new(
+          client,
+          session_id:,
+          handle_resize: ->(pty_size) { resize_pty_session(session_id, pty_size) },
+          handle_kill: -> { delete_pty_session(session_id) }
+        )
+      end
+      handle.tap(&:wait_for_connection)
     end
 
     # Resizes a PTY session to the specified dimensions

data/lib/daytona/sdk/version.rb

@@ -5,6 +5,6 @@
 
 module Daytona
   module Sdk
-    VERSION = '0.184.0'
+    VERSION = '0.185.0'
   end
 end

data/lib/daytona/snapshot_service.rb

@@ -111,6 +111,7 @@ module Daytona
       end
 
       create_snapshot_req.region_id = params.region_id || @default_region_id
+      create_snapshot_req.sandbox_class = params.sandbox_class
 
       snapshot = snapshots_api.create_snapshot(create_snapshot_req)
 

metadata

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