daytona 0.200.0 → 0.201.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de70d9e56ce97468d9ef3bcf8c7dbe0b70f74ee7e64a7ac1d0e8642857a3c257
-  data.tar.gz: 3cec447b03a65f42bcd84c49e719cd8771a1404f496384afd5e797b429e47fb1
+  metadata.gz: 684e4304ffae6f21d39f795fbcd75754e0148adf43a86963e3c8303b6b9eb87e
+  data.tar.gz: 3d4dc419e7b759cce74db9df2cec0bb36900493c39d08b5640b04dd5c4863b11
 SHA512:
-  metadata.gz: 91c94980be6003996bbbf4b447b170e9165cbc3a47e78c47f91886f28accd5f7b083b04903fc59dede9bbe56ccdcaf9957da73e07202e762ca928203274b2c8b
-  data.tar.gz: db39e610c03a011d4c2468475393ca7b7bd17cc1087dbb0edd46c9fc6959da18e0ca61d861485ca0b27faa8ccb4061f631ec44c97d90d8e6bea7db75317db4e3
+  metadata.gz: 59a7fea3c20c801d9e3d09bad69f6a4318f5b2ae64d397e2848ee893e8f5e1117c973f626ba825fce6bb4604f2875e1f4d393391b0c7dc8b850459a7d7073bd1
+  data.tar.gz: ade5a786482e476b4e3baf42eea6828e0d422ec83e1dc1363130165a8ae09b9a5e0d99be687848d5c50f6e4c0ce09342244ddfa1553d9effbff882ad3bd58267

data/lib/daytona/code_interpreter.rb

@@ -232,8 +232,8 @@ module Daytona
     def create_context(cwd: nil)
       request = DaytonaToolboxApiClient::CreateContextRequest.new(cwd:)
       @toolbox_api.create_interpreter_context(request)
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to create interpreter context: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to create interpreter context')
     end
 
     # List all user-created interpreter contexts.
@@ -252,8 +252,8 @@ module Daytona
     def list_contexts
       response = @toolbox_api.list_interpreter_contexts
       response.contexts || []
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to list interpreter contexts: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to list interpreter contexts')
     end
 
     # Delete an interpreter context and shut down all associated processes.
@@ -272,8 +272,8 @@ module Daytona
     def delete_context(context)
       @toolbox_api.delete_interpreter_context(context.id)
       nil
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to delete interpreter context: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to delete interpreter context')
     end
 
     instrument :run_code, :create_context, :list_contexts, :delete_context,

data/lib/daytona/common/event_subscription_manager.rb

@@ -6,14 +6,29 @@
 require 'securerandom'
 
 module Daytona
+  # Tracks dispatcher subscriptions with TTL auto-expiry.
+  #
+  # All subscriptions share ONE lazily started expiry worker thread instead of a
+  # dedicated sleeping thread per subscription, so listing many sandboxes costs
+  # one thread total, not one thread each
+  # (https://github.com/daytona/clients/issues/108). #refresh only bumps the
+  # subscription deadline — it never creates or kills threads.
   class EventSubscriptionManager
     SUBSCRIPTION_TTL = 300
     private_constant :SUBSCRIPTION_TTL
 
-    def initialize(dispatcher = nil)
+    def initialize(dispatcher = nil, ttl_seconds: SUBSCRIPTION_TTL)
       @dispatcher = dispatcher
+      @ttl = ttl_seconds
       @subscriptions = {}
+      # Deadline-ordered [expires_at, sub_id] entries. Entries are lazily
+      # invalidated: a popped entry is discarded when its subscription is gone,
+      # or re-queued at the current deadline when it was refreshed meanwhile.
+      # Invariant: every live subscription has at least one queue entry.
+      @expiry_queue = []
       @mutex = Mutex.new
+      @cond = ConditionVariable.new
+      @worker = nil
       @closed = false
     end
 
@@ -24,7 +39,6 @@ module Daytona
 
       unsubscribe = @dispatcher.subscribe(resource_id, events:, &handler)
       sub_id = SecureRandom.hex(16)
-      timer_to_stop = nil
       rollback_unsubscribe = nil
 
       @mutex.synchronize do
@@ -34,8 +48,11 @@ module Daytona
           next
         end
 
-        @subscriptions[sub_id] = { unsubscribe:, timer: nil }
-        timer_to_stop = start_timer_locked(sub_id)
+        expires_at = monotonic_now + @ttl
+        @subscriptions[sub_id] = { unsubscribe:, expires_at: }
+        push_entry_locked(expires_at, sub_id)
+        ensure_worker_locked
+        @cond.signal
       end
 
       if rollback_unsubscribe
@@ -43,44 +60,36 @@ module Daytona
         return nil
       end
 
-      stop_thread(timer_to_stop)
       sub_id
     end
 
     def refresh(sub_id)
       @mutex.synchronize do
-        # Reject after shutdown to prevent use-after-close
         return false if @closed
-      end
-
-      timer_to_stop = nil
 
-      @mutex.synchronize do
-        return false unless @subscriptions.key?(sub_id)
+        subscription = @subscriptions[sub_id]
+        return false unless subscription
 
-        timer_to_stop = start_timer_locked(sub_id)
+        # No queue entry or worker wake-up needed: when the old deadline pops,
+        # the worker sees the newer expires_at and re-queues the subscription.
+        subscription[:expires_at] = monotonic_now + @ttl
+        true
       end
-
-      stop_thread(timer_to_stop)
-      true
     end
 
     def unsubscribe(sub_id)
-      subscription = nil
-      timer = nil
-
-      @mutex.synchronize do
-        subscription = @subscriptions.delete(sub_id)
-        if subscription
-          timer = subscription[:timer]
-          subscription[:timer] = nil
+      subscription = @mutex.synchronize do
+        removed = @subscriptions.delete(sub_id)
+        # The stale queue entry is discarded when the worker pops it — except
+        # when it was the last subscription: drop the leftovers and wake the
+        # worker so it exits now instead of idling until the old deadline.
+        if removed && @subscriptions.empty?
+          @expiry_queue.clear
+          @cond.signal
         end
+        removed
       end
-
-      return unless subscription
-
-      stop_thread(timer)
-      subscription[:unsubscribe].call
+      subscription&.dig(:unsubscribe)&.call
     end
 
     def shutdown
@@ -90,55 +99,96 @@ module Daytona
         @closed = true
         subscriptions = @subscriptions.values
         @subscriptions = {}
+        @expiry_queue.clear
+        @cond.broadcast
       end
 
-      subscriptions.each do |subscription|
-        stop_thread(subscription[:timer])
-        subscription[:unsubscribe].call
-      end
+      subscriptions.each { |subscription| subscription[:unsubscribe].call }
     end
 
     private
 
-    def start_timer_locked(sub_id)
-      subscription = @subscriptions[sub_id]
-      return unless subscription
+    def monotonic_now
+      ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+    end
 
-      previous_timer = cancel_timer_locked(sub_id)
-      timer = Thread.new do
-        sleep(SUBSCRIPTION_TTL)
+    # Caller must hold @mutex.
+    def push_entry_locked(expires_at, sub_id)
+      index = @expiry_queue.bsearch_index { |entry| entry[0] > expires_at } || @expiry_queue.length
+      @expiry_queue.insert(index, [expires_at, sub_id])
+    end
 
-        unsubscribe = @mutex.synchronize do
-          current_subscription = @subscriptions[sub_id]
-          next unless current_subscription && current_subscription[:timer] == Thread.current
+    # Caller must hold @mutex. The alive? check is a safety net: a worker that
+    # crashed for any reason leaves a dead-but-truthy reference, and a plain nil
+    # check would then block replacements forever, silently disabling expiry.
+    def ensure_worker_locked
+      return if @worker&.alive?
 
-          @subscriptions.delete(sub_id)&.dig(:unsubscribe)
-        end
+      @worker = Thread.new { expiry_loop }
+      @worker.name = 'daytona-subscription-expiry'
+      @worker.abort_on_exception = false
+    end
 
-        unsubscribe&.call
+    def expiry_loop
+      loop do
+        expired = collect_expired
+        return if expired.nil?
+
+        expired.each do |subscription|
+          subscription[:unsubscribe].call
+        rescue StandardError
+          # One failing dispatcher unsubscribe must not kill the shared worker
+          # and silently stop expiry for every other subscription.
+          nil
+        end
       end
-      timer.abort_on_exception = false
-      subscription[:timer] = timer
-      previous_timer
     end
 
-    def cancel_timer_locked(sub_id)
-      subscription = @subscriptions[sub_id]
-      return unless subscription
+    # Blocks until at least one subscription expires. Returns nil when the
+    # worker should exit (shutdown, or no live subscriptions remain).
+    def collect_expired
+      @mutex.synchronize do
+        expired = []
+
+        while expired.empty?
+          return nil if @closed
+
+          if @expiry_queue.empty?
+            # No live subscriptions remain (see queue invariant above):
+            # exit and let the next subscribe start a fresh worker.
+            @worker = nil
+            return nil
+          end
+
+          now = monotonic_now
+          deadline = @expiry_queue.first[0]
+          if deadline > now
+            @cond.wait(@mutex, deadline - now)
+            next
+          end
+
+          drain_due_entries_locked(now, expired)
+        end
 
-      timer = subscription[:timer]
-      subscription[:timer] = nil
-      timer
+        expired
+      end
     end
 
-    def stop_thread(thread)
-      return unless thread
-      return if thread == Thread.current
+    # Caller must hold @mutex.
+    def drain_due_entries_locked(now, expired)
+      while !@expiry_queue.empty? && @expiry_queue.first[0] <= now
+        _, sub_id = @expiry_queue.shift
+        subscription = @subscriptions[sub_id]
+        next unless subscription
 
-      thread.kill
-      thread.join
-    rescue StandardError
-      nil
+        if subscription[:expires_at] > now
+          push_entry_locked(subscription[:expires_at], sub_id)
+          next
+        end
+
+        @subscriptions.delete(sub_id)
+        expired << subscription
+      end
     end
   end
 end

data/lib/daytona/common/response.rb

@@ -89,6 +89,8 @@ module Daytona
     :created_at_before,
     :last_activity_after,
     :last_activity_before,
+    :auto_destroy_at_after,
+    :auto_destroy_at_before,
     :sort,
     :order
   ) do

data/lib/daytona/computer_use.rb

@@ -33,8 +33,8 @@ module Daytona
       #   puts "Mouse is at: #{position.x}, #{position.y}"
       def position
         toolbox_api.get_mouse_position
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to get mouse position: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to get mouse position')
       end
 
       # Moves the mouse cursor to the specified coordinates.
@@ -50,8 +50,8 @@ module Daytona
       def move(x:, y:)
         request = DaytonaToolboxApiClient::MouseMoveRequest.new(x:, y:)
         toolbox_api.move_mouse(request)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to move mouse: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to move mouse')
       end
 
       # Clicks the mouse at the specified coordinates.
@@ -75,8 +75,8 @@ module Daytona
       def click(x:, y:, button: 'left', double: false)
         request = DaytonaToolboxApiClient::MouseClickRequest.new(x:, y:, button:, double:)
         toolbox_api.click(request)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to click mouse: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to click mouse')
       end
 
       # Drags the mouse from start coordinates to end coordinates.
@@ -95,8 +95,8 @@ module Daytona
       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)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to drag mouse: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to drag mouse')
       end
 
       # Scrolls the mouse wheel at the specified coordinates.
@@ -118,8 +118,8 @@ module Daytona
         request = DaytonaToolboxApiClient::MouseScrollRequest.new(x:, y:, direction:, amount:)
         toolbox_api.scroll(request)
         true
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to scroll mouse: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to scroll mouse')
       end
 
       instrument :position, :move, :click, :drag, :scroll, component: 'Mouse'
@@ -164,8 +164,8 @@ module Daytona
       def type(text:, delay: nil)
         request = DaytonaToolboxApiClient::KeyboardTypeRequest.new(text:, delay:)
         toolbox_api.type_text(request)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to type text: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to type text')
       end
 
       # Presses a key with optional modifiers.
@@ -187,8 +187,8 @@ module Daytona
       def press(key:, modifiers: nil)
         request = DaytonaToolboxApiClient::KeyboardPressRequest.new(key:, modifiers: modifiers || [])
         toolbox_api.press_key(request)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to press key: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to press key')
       end
 
       # Presses a hotkey combination.
@@ -209,8 +209,8 @@ module Daytona
       def hotkey(keys:)
         request = DaytonaToolboxApiClient::KeyboardHotkeyRequest.new(keys:)
         toolbox_api.press_hotkey(request)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to press hotkey: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to press hotkey')
       end
 
       instrument :type, :press, :hotkey, component: 'Keyboard'
@@ -254,8 +254,8 @@ module Daytona
       #   with_cursor = sandbox.computer_use.screenshot.take_full_screen(show_cursor: true)
       def take_full_screen(show_cursor: false)
         toolbox_api.take_screenshot(show_cursor:)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to take screenshot: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to take screenshot')
       end
 
       # Takes a screenshot of a specific region.
@@ -271,8 +271,8 @@ module Daytona
       #   puts "Captured region: #{screenshot.region.width}x#{screenshot.region.height}"
       def take_region(region:, show_cursor: false)
         toolbox_api.take_region_screenshot(region.height, region.width, region.y, region.x, show_cursor:)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to take region screenshot: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to take region screenshot')
       end
 
       # Takes a compressed screenshot of the entire screen.
@@ -303,8 +303,8 @@ module Daytona
           format: options.fmt,
           show_cursor: options.show_cursor
         )
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to take compressed screenshot: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to take compressed screenshot')
       end
 
       # Takes a compressed screenshot of a specific region.
@@ -334,8 +334,8 @@ module Daytona
           format: options.fmt,
           show_cursor: options.show_cursor
         )
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to take compressed region screenshot: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to take compressed region screenshot')
       end
 
       instrument :take_full_screen, :take_region, :take_compressed, :take_compressed_region,
@@ -380,8 +380,8 @@ module Daytona
       #   end
       def info
         toolbox_api.get_display_info
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to get display info: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to get display info')
       end
 
       # Gets the list of open windows.
@@ -397,8 +397,8 @@ module Daytona
       #   end
       def windows
         toolbox_api.get_windows
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to get windows: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to get windows')
       end
 
       instrument :info, :windows, component: 'Display'
@@ -446,8 +446,8 @@ module Daytona
         opts[:max_depth] = max_depth unless max_depth.nil?
 
         toolbox_api.get_accessibility_tree(opts)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to get accessibility tree: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to get accessibility tree')
       end
 
       # Finds AT-SPI accessibility nodes matching the provided filters.
@@ -482,8 +482,8 @@ module Daytona
 
         request = DaytonaToolboxApiClient::FindAccessibilityNodesRequest.new(attrs)
         toolbox_api.find_accessibility_nodes(request)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to find accessibility nodes: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to find accessibility nodes')
       end
 
       # Focuses an AT-SPI accessibility node.
@@ -496,8 +496,8 @@ module Daytona
       def focus_node(id:)
         request = DaytonaToolboxApiClient::AccessibilityNodeRequest.new(id:)
         toolbox_api.focus_accessibility_node(request)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to focus accessibility node: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to focus accessibility node')
       end
 
       # Invokes an AT-SPI accessibility node action.
@@ -514,8 +514,8 @@ module Daytona
 
         request = DaytonaToolboxApiClient::AccessibilityInvokeRequest.new(attrs)
         toolbox_api.invoke_accessibility_node(request)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to invoke accessibility node: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to invoke accessibility node')
       end
 
       # Sets an AT-SPI accessibility node value.
@@ -529,8 +529,8 @@ module Daytona
       def set_node_value(id:, value:)
         request = DaytonaToolboxApiClient::AccessibilitySetValueRequest.new(id:, value:)
         toolbox_api.set_accessibility_node_value(request)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to set accessibility node value: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to set accessibility node value')
       end
 
       instrument :get_tree, :find_nodes, :focus_node, :invoke_node, :set_node_value,
@@ -627,8 +627,8 @@ module Daytona
       def start(label: nil)
         request = DaytonaToolboxApiClient::StartRecordingRequest.new(label:)
         toolbox_api.start_recording(request: request)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to start recording: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to start recording')
       end
 
       # Stops an active screen recording session.
@@ -644,8 +644,8 @@ module Daytona
       def stop(id:)
         request = DaytonaToolboxApiClient::StopRecordingRequest.new(id: id)
         toolbox_api.stop_recording(request)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to stop recording: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to stop recording')
       end
 
       # Lists all recordings (active and completed).
@@ -661,8 +661,8 @@ module Daytona
       #   end
       def list
         toolbox_api.list_recordings
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to list recordings: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to list recordings')
       end
 
       # Gets details of a specific recording by ID.
@@ -678,8 +678,8 @@ module Daytona
       #   puts "Duration: #{recording.duration_seconds} seconds"
       def get(id:)
         toolbox_api.get_recording(id)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to get recording: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to get recording')
       end
 
       # Deletes a recording by ID.
@@ -693,8 +693,8 @@ module Daytona
       #   puts "Recording deleted"
       def delete(id:)
         toolbox_api.delete_recording(id)
-      rescue StandardError => e
-        raise Sdk::Error, "Failed to delete recording: #{e.message}"
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to delete recording')
       end
 
       # Downloads a recording file and saves it to a local path.
@@ -815,8 +815,8 @@ module Daytona
     #   puts "Computer use processes started: #{result.message}"
     def start
       toolbox_api.start_computer_use
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to start computer use: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to start computer use')
     end
 
     # Stops all computer use processes.
@@ -829,8 +829,8 @@ module Daytona
     #   puts "Computer use processes stopped: #{result.message}"
     def stop
       toolbox_api.stop_computer_use
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to stop computer use: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to stop computer use')
     end
 
     # Gets the status of all computer use processes.
@@ -843,8 +843,8 @@ module Daytona
     #   puts "Computer use status: #{response.status}"
     def status
       toolbox_api.get_computer_use_status
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to get computer use status: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get computer use status')
     end
 
     # Gets the status of a specific VNC process.
@@ -858,8 +858,8 @@ module Daytona
     #   no_vnc_status = sandbox.computer_use.get_process_status("novnc")
     def get_process_status(process_name:)
       toolbox_api.get_process_status(process_name, sandbox_id)
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to get process status: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get process status')
     end
 
     # Restarts a specific VNC process.
@@ -873,8 +873,8 @@ module Daytona
     #   puts "XFCE4 process restarted: #{result.message}"
     def restart_process(process_name:)
       toolbox_api.restart_process(process_name, sandbox_id)
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to restart process: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to restart process')
     end
 
     # Gets logs for a specific VNC process.
@@ -888,8 +888,8 @@ module Daytona
     #   puts "NoVNC logs: #{logs}"
     def get_process_logs(process_name:)
       toolbox_api.get_process_logs(process_name, sandbox_id)
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to get process logs: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get process logs')
     end
 
     # Gets error logs for a specific VNC process.
@@ -903,8 +903,8 @@ module Daytona
     #   puts "X11VNC errors: #{errors}"
     def get_process_errors(process_name:)
       toolbox_api.get_process_errors(process_name, sandbox_id)
-    rescue StandardError => e
-      raise Sdk::Error, "Failed to get process errors: #{e.message}"
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to get process errors')
     end
 
     instrument :start, :stop, :status, :get_process_status, :restart_process,

data/lib/daytona/daytona.rb

@@ -127,9 +127,12 @@ module Daytona
     #
     # @param id [String]
     # @return [Daytona::Sandbox]
+    # @raise [Daytona::Sdk::Error]
     def get(id)
       sandbox_dto = sandbox_api.get_sandbox(id)
       to_sandbox(sandbox_dto:)
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, "Failed to get sandbox #{id}")
     end
 
     # Iterates over Sandboxes matching the given query.
@@ -222,11 +225,15 @@ module Daytona
         created_at_before: q.created_at_before,
         last_event_after: q.last_activity_after,
         last_event_before: q.last_activity_before,
+        auto_destroy_at_after: q.auto_destroy_at_after,
+        auto_destroy_at_before: q.auto_destroy_at_before,
         sort: q.sort,
         order: q.order
       }.compact
 
       sandbox_api.list_sandboxes(opts)
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to list sandboxes')
     end
 
     instrument :fetch_sandbox_page, component: 'Daytona.list'
@@ -334,6 +341,8 @@ module Daytona
       end
 
       sandbox
+    rescue *Sdk::API_ERROR_CLASSES => e
+      raise Sdk.wrap_error(e, 'Failed to create sandbox')
     end
 
     # @return [void]