daytona 0.196.0 → 0.198.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95de6205d02f5efc95082860ba7b1cc47d7aaa4a80add3b2799d7b62ece1d67c
-  data.tar.gz: 11c927bf961766c0eae71d6196a538688844913d06de0746497510b09137293e
+  metadata.gz: e2003b4293b8ee69d171ad86402151e2924b814022649097deb51da19da6ff58
+  data.tar.gz: 30884a506c2dd332c804f995dd2d3afc654cf75b0fa66e4bf54cdd4a38909c12
 SHA512:
-  metadata.gz: 6f30debf54313e1bd30c6392b7ec2fd6c316306aad88eb3e1cd58fa0a51326f4036468c76fb2fe9388c41139aa40f0efecaa680d31eab6c16736f2f9dd9c250c
-  data.tar.gz: cf1ac1f0075f85966d2c9a00eb3c02d3c0e7080c8d7773fe9e5004c5e91bfd5e11670da7946ad15d5fcea13db6772d6c5918935d02f1f4a0cef61e010ae2f695
+  metadata.gz: f4627f864da4ae028a19d856a014da0f3513e30a5a8c7299148d89d815a82b13a2c0de3bc8fc3dc4e96ca7a455ee9ef9e291fe71dd58f57e12af8e85ebcbd3d1
+  data.tar.gz: c8b07b46dfb64043794af1d4d33db1ca3ac49c1271ebde8eae3b2c9e05ca66030e780d2fbb5cede035c564c03a69f0abba68d87ff098bac36d198fe3ab1d2636

data/lib/daytona/common/daytona.rb

@@ -28,6 +28,11 @@ module Daytona
     # @return [Integer, nil] Auto-stop interval in minutes
     attr_accessor :auto_stop_interval
 
+    # @return [Integer, nil] Auto-pause interval in minutes (nil = server default: 60 for
+    #   non-ephemeral pause-supporting sandbox classes with auto-stop disabled; 0 = disabled).
+    #   Not allowed for ephemeral sandboxes
+    attr_accessor :auto_pause_interval
+
     # @return [Integer, nil] Auto-archive interval in minutes
     attr_accessor :auto_archive_interval
 
@@ -69,6 +74,7 @@ module Daytona
     # @param public [Boolean, nil] Whether the Sandbox should be public
     # @param timeout [Float, nil] Timeout in seconds for Sandbox to be created and started
     # @param auto_stop_interval [Integer, nil] Auto-stop interval in minutes
+    # @param auto_pause_interval [Integer, nil] Auto-pause interval in minutes
     # @param auto_archive_interval [Integer, nil] Auto-archive interval in minutes
     # @param auto_delete_interval [Integer, nil] Auto-delete interval in minutes
     # @param volumes [Array<DaytonaApiClient::SandboxVolume>, nil] List of volumes mounts to attach to the Sandbox
@@ -87,6 +93,7 @@ module Daytona
       public: nil,
       timeout: nil,
       auto_stop_interval: nil,
+      auto_pause_interval: nil,
       auto_archive_interval: nil,
       auto_delete_interval: nil,
       volumes: nil,
@@ -104,6 +111,7 @@ module Daytona
       @public = public
       @timeout = timeout
       @auto_stop_interval = auto_stop_interval
+      @auto_pause_interval = auto_pause_interval
       @auto_archive_interval = auto_archive_interval
       @auto_delete_interval = auto_delete_interval
       @volumes = volumes
@@ -130,6 +138,7 @@ module Daytona
         public:,
         timeout:,
         auto_stop_interval:,
+        auto_pause_interval:,
         auto_archive_interval:,
         auto_delete_interval:,
         volumes:,
@@ -148,12 +157,15 @@ module Daytona
     #
     # @return [void]
     def handle_ephemeral_auto_delete_conflict
-      return unless ephemeral && auto_delete_interval && !auto_delete_interval.zero?
+      return unless ephemeral
+
+      if auto_delete_interval && !auto_delete_interval.zero?
+        warn(
+          "'ephemeral' and 'auto_delete_interval' cannot be used together. " \
+          'If ephemeral is true, auto_delete_interval will be ignored and set to 0.'
+        )
+      end
 
-      warn(
-        "'ephemeral' and 'auto_delete_interval' cannot be used together. " \
-        'If ephemeral is true, auto_delete_interval will be ignored and set to 0.'
-      )
       @auto_delete_interval = 0
     end
   end
@@ -178,6 +190,7 @@ module Daytona
     # @param public [Boolean, nil] Whether the Sandbox should be public
     # @param timeout [Float, nil] Timeout in seconds for Sandbox to be created and started
     # @param auto_stop_interval [Integer, nil] Auto-stop interval in minutes
+    # @param auto_pause_interval [Integer, nil] Auto-pause interval in minutes
     # @param auto_archive_interval [Integer, nil] Auto-archive interval in minutes
     # @param auto_delete_interval [Integer, nil] Auto-delete interval in minutes
     # @param volumes [Array<DaytonaApiClient::SandboxVolume>, nil] List of volumes mounts to attach to the Sandbox
@@ -219,6 +232,7 @@ module Daytona
     # @param public [Boolean, nil] Whether the Sandbox should be public
     # @param timeout [Float, nil] Timeout in seconds for Sandbox to be created and started
     # @param auto_stop_interval [Integer, nil] Auto-stop interval in minutes
+    # @param auto_pause_interval [Integer, nil] Auto-pause interval in minutes
     # @param auto_archive_interval [Integer, nil] Auto-archive interval in minutes
     # @param auto_delete_interval [Integer, nil] Auto-delete interval in minutes
     # @param volumes [Array<DaytonaApiClient::SandboxVolume>, nil] List of volumes mounts to attach to the Sandbox

data/lib/daytona/common/event_dispatcher.rb

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+require_relative 'socketio_client'
+
+module Daytona
+  # Manages a Socket.IO connection and dispatches events to per-resource handlers.
+  # Generic — works for sandboxes, volumes, snapshots, runners, etc.
+  class EventDispatcher
+    DISCONNECT_DELAY = 30
+
+    # @param api_url [String]
+    # @param token [String]
+    # @param organization_id [String, nil]
+    def initialize(api_url:, token:, organization_id: nil, source: nil, sdk_version: nil)
+      @api_url = api_url
+      @token = token
+      @organization_id = organization_id
+      @source = source
+      @sdk_version = sdk_version
+      @client = nil
+      @connected = false
+      @failed = false
+      @fail_error = nil
+      @listeners = {}
+      @registered_events = Set.new
+      @mutex = Mutex.new
+      @disconnect_timer = nil
+      @disconnect_generation = 0
+      @reconnect_thread = nil
+      @connect_thread = nil
+      @reconnecting = false
+      @connecting = false
+      @close_requested = false
+      @closed = false
+      @max_reconnects = 100
+    end
+
+    # Idempotent: ensure a connection attempt is in progress or already established.
+    # Non-blocking. Starts a background Thread to connect if not already connected
+    # and no attempt is currently running.
+    # @return [void]
+    def ensure_connected
+      @mutex.synchronize do
+        return if @closed || @connected || @connecting || @connect_thread&.alive?
+
+        @connect_thread = Thread.new do
+          connect
+        rescue StandardError
+          # Callers check connected? when they need it
+        ensure
+          @mutex.synchronize do
+            @connect_thread = nil if @connect_thread == Thread.current
+          end
+        end
+      end
+    end
+
+    # Establish the Socket.IO connection.
+    # @return [void]
+    # @raise [StandardError] on connection failure
+    def connect
+      @mutex.synchronize do
+        return if @closed || @connected || @connecting
+
+        @connecting = true
+      end
+
+      # Close any existing stale connection before creating a fresh one
+      @client&.close rescue nil # rubocop:disable Style/RescueModifier
+
+      client = SocketIOClient.new(
+        api_url: @api_url,
+        token: @token,
+        organization_id: @organization_id,
+        source: @source,
+        sdk_version: @sdk_version,
+        on_event: method(:handle_event),
+        on_disconnect: method(:handle_disconnect)
+      )
+
+      @mutex.synchronize do
+        @client = client
+        @close_requested = false
+      end
+
+      client.connect
+
+      @mutex.synchronize do
+        @connected = true
+        @failed = false
+        @fail_error = nil
+        schedule_delayed_disconnect_locked if @listeners.empty?
+      end
+    rescue StandardError => e
+      @mutex.synchronize do
+        @failed = true
+        @fail_error = "WebSocket connection failed: #{e.message}"
+      end
+    ensure
+      @mutex.synchronize { @connecting = false }
+    end
+
+    # Subscribe to specific events for a resource.
+    # @param resource_id [String] The ID of the resource (e.g. sandbox ID, volume ID).
+    # @param events [Array<String>] List of Socket.IO event names to listen for.
+    # @yield [event_name, data] Called with raw event name and data hash.
+    # @return [Proc] Unsubscribe function.
+    def subscribe(resource_id, events:, &handler)
+      @mutex.synchronize do
+        # No-op after disconnect
+        return -> {} if @closed
+
+        @disconnect_timer&.kill
+        @disconnect_timer = nil
+        @disconnect_generation += 1
+
+        @listeners[resource_id] ||= []
+        @listeners[resource_id] << handler
+        # Mark events in filter under lock to avoid dropping first event
+        events.each { |evt| @registered_events.add(evt) }
+      end
+
+      ensure_connected
+
+      lambda {
+        return if @close_requested || @closed
+
+        should_schedule = false
+        @mutex.synchronize do
+          @listeners[resource_id]&.delete(handler)
+          unsubscribe_resource_locked(resource_id) if @listeners[resource_id] && @listeners[resource_id].empty?
+          should_schedule = @listeners.empty?
+
+          schedule_delayed_disconnect_locked if should_schedule
+        end
+      }
+    end
+
+    # @return [Boolean]
+    def connected?
+      @connected
+    end
+
+    # @return [Boolean]
+    def failed?
+      @failed
+    end
+
+    # @return [String, nil]
+    attr_reader :fail_error
+
+    # Disconnect and clean up.
+    def disconnect
+      thread_state = @mutex.synchronize do
+        begin_disconnect_locked(permanent: true, skip_thread: Thread.current)
+      end
+
+      finalize_disconnect(thread_state)
+    end
+
+    private
+
+    def unsubscribe_resource_locked(resource_id)
+      @listeners.delete(resource_id)
+    end
+
+    def schedule_delayed_disconnect_locked
+      @disconnect_timer&.kill
+      generation = @disconnect_generation
+      @disconnect_timer = Thread.new do
+        sleep(DISCONNECT_DELAY)
+        thread_state = @mutex.synchronize do
+          next unless generation == @disconnect_generation
+          next unless @listeners.empty?
+
+          begin_disconnect_locked(permanent: false, skip_thread: Thread.current)
+        end
+
+        finalize_disconnect(thread_state) if thread_state
+      end
+      @disconnect_timer.abort_on_exception = false
+    end
+
+    def handle_event(event_name, data)
+      # Read registered_events under lock for thread safety
+      registered = @mutex.synchronize { @registered_events.include?(event_name) }
+      return unless registered
+
+      resource_id = extract_id_from_event(data)
+      return unless resource_id
+
+      dispatch(resource_id, event_name, data)
+    end
+
+    # Extract resource ID from an event payload.
+    # Handles two payload shapes:
+    #   - Wrapper: {sandbox: {id: ...}, ...} -> nested resource ID
+    #   - Direct: {id: ...} -> top-level ID
+    def extract_id_from_event(data)
+      return nil unless data.is_a?(Hash)
+
+      %w[sandbox volume snapshot runner].each do |key|
+        nested = data[key]
+        next unless nested.is_a?(Hash)
+
+        sid = nested['id']
+        return sid if sid.is_a?(String)
+      end
+
+      top_id = data['id']
+      return top_id if top_id.is_a?(String)
+
+      nil
+    end
+
+    def dispatch(resource_id, event_name, data)
+      handlers = @mutex.synchronize { @listeners[resource_id]&.dup || [] }
+      handlers.each do |handler|
+        handler.call(event_name, data)
+      rescue StandardError
+        # Don't let handler errors break other handlers
+      end
+    end
+
+    def handle_disconnect
+      @connected = false
+      return if @close_requested
+
+      @reconnect_thread = Thread.new { reconnect_loop }
+    end
+
+    def reconnect_loop
+      @mutex.synchronize do
+        return if @reconnecting
+
+        @reconnecting = true
+      end
+
+      attempt = 0
+      while attempt < @max_reconnects
+        if @close_requested
+          @mutex.synchronize { @reconnecting = false }
+          return
+        end
+
+        delay = [2**attempt, 30].min
+        sleep(delay)
+        if @close_requested
+          @mutex.synchronize { @reconnecting = false }
+          return
+        end
+
+        begin
+          connect
+          if @connected
+            @mutex.synchronize { @reconnecting = false }
+            return
+          end
+        rescue StandardError
+          # Continue retrying
+        end
+
+        attempt += 1
+      end
+
+      # All attempts failed
+      @mutex.synchronize do
+        @failed = true
+        @fail_error = "WebSocket reconnection failed after #{@max_reconnects} attempts"
+        @reconnecting = false
+      end
+    end
+
+    def begin_disconnect_locked(permanent:, skip_thread:)
+      @closed = true if permanent
+      @close_requested = true
+
+      thread_state = {
+        client: @client,
+        reconnect_thread: @reconnect_thread,
+        connect_thread: @connect_thread,
+        disconnect_timer: @disconnect_timer,
+        skip_thread:
+      }
+
+      @client = nil
+      @reconnect_thread = nil
+      @connect_thread = nil
+      @disconnect_timer = nil
+      @connected = false
+      @connecting = false
+      @listeners.clear
+      @registered_events.clear
+
+      thread_state
+    end
+
+    def finalize_disconnect(thread_state)
+      return unless thread_state
+
+      [thread_state[:reconnect_thread], thread_state[:connect_thread], thread_state[:disconnect_timer]].each do |thread|
+        next unless thread
+        next if thread == thread_state[:skip_thread]
+
+        stop_thread(thread)
+      end
+
+      thread_state[:client]&.close
+    rescue StandardError
+      nil
+    end
+
+    def stop_thread(thread)
+      return unless thread
+      return if thread == Thread.current
+
+      thread.kill
+      thread.join
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/daytona/common/event_subscription_manager.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+require 'securerandom'
+
+module Daytona
+  class EventSubscriptionManager
+    SUBSCRIPTION_TTL = 300
+    private_constant :SUBSCRIPTION_TTL
+
+    def initialize(dispatcher = nil)
+      @dispatcher = dispatcher
+      @subscriptions = {}
+      @mutex = Mutex.new
+      @closed = false
+    end
+
+    def subscribe(resource_id:, handler:, events:)
+      @mutex.synchronize do
+        return nil if @closed || @dispatcher.nil?
+      end
+
+      unsubscribe = @dispatcher.subscribe(resource_id, events:, &handler)
+      sub_id = SecureRandom.hex(16)
+      timer_to_stop = nil
+      rollback_unsubscribe = nil
+
+      @mutex.synchronize do
+        if @closed
+          # Rollback dispatcher subscription on failure
+          rollback_unsubscribe = unsubscribe
+          next
+        end
+
+        @subscriptions[sub_id] = { unsubscribe:, timer: nil }
+        timer_to_stop = start_timer_locked(sub_id)
+      end
+
+      if rollback_unsubscribe
+        rollback_unsubscribe.call
+        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)
+
+        timer_to_stop = start_timer_locked(sub_id)
+      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
+        end
+      end
+
+      return unless subscription
+
+      stop_thread(timer)
+      subscription[:unsubscribe].call
+    end
+
+    def shutdown
+      subscriptions = nil
+
+      @mutex.synchronize do
+        @closed = true
+        subscriptions = @subscriptions.values
+        @subscriptions = {}
+      end
+
+      subscriptions.each do |subscription|
+        stop_thread(subscription[:timer])
+        subscription[:unsubscribe].call
+      end
+    end
+
+    private
+
+    def start_timer_locked(sub_id)
+      subscription = @subscriptions[sub_id]
+      return unless subscription
+
+      previous_timer = cancel_timer_locked(sub_id)
+      timer = Thread.new do
+        sleep(SUBSCRIPTION_TTL)
+
+        unsubscribe = @mutex.synchronize do
+          current_subscription = @subscriptions[sub_id]
+          next unless current_subscription && current_subscription[:timer] == Thread.current
+
+          @subscriptions.delete(sub_id)&.dig(:unsubscribe)
+        end
+
+        unsubscribe&.call
+      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
+
+      timer = subscription[:timer]
+      subscription[:timer] = nil
+      timer
+    end
+
+    def stop_thread(thread)
+      return unless thread
+      return if thread == Thread.current
+
+      thread.kill
+      thread.join
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/daytona/common/pty.rb

@@ -7,6 +7,10 @@ require 'json'
 require 'observer'
 
 module Daytona
+  # Capability token advertised on PTY WebSocket connects so the daemon sends the
+  # "exited" control message; clients that don't send it only get the close frame.
+  PTY_EXIT_CONTROL_SUBPROTOCOL = 'X-Daytona-Pty-Exit-Control'
+
   class PtySize
     # @return [Integer] Number of terminal rows (height)
     attr_reader :rows
@@ -68,6 +72,7 @@ module Daytona
       @handle_kill = handle_kill
       @exit_code = nil
       @error = nil
+      @exited = false
       @logger = Sdk.logger
 
       @status = Status::INIT
@@ -77,21 +82,23 @@ module Daytona
     # Check if connected to the PTY session
     #
     # @return [Boolean] true if connected, false otherwise
-    def connected? = websocket.open?
+    # A PTY that has exited is not usable even while the socket briefly stays
+    # open before the close frame, so treat it as disconnected.
+    def connected? = websocket.open? && !@exited
 
     # Wait for the PTY connection to be established
     #
     # @param timeout [Float] Maximum time in seconds to wait for connection. Defaults to 10.0
     # @return [void]
     # @raise [Daytona::Sdk::Error] If connection timeout is exceeded
-    def wait_for_connection(timeout: DEFAULT_TIMEOUT)
-      return if status == Status::CONNECTED
+    def wait_for_connection(timeout: DEFAULT_TIMEOUT) # rubocop:disable Metrics/CyclomaticComplexity
+      return if status == Status::CONNECTED || @exited
 
       start_time = Time.now
 
-      sleep(SLEEP_INTERVAL) until status == Status::CONNECTED || (Time.now - start_time) > timeout
+      sleep(SLEEP_INTERVAL) until status == Status::CONNECTED || @exited || (Time.now - start_time) > timeout
 
-      raise Sdk::Error, 'PTY connection timeout' unless status == Status::CONNECTED
+      raise Sdk::Error, 'PTY connection timeout' unless status == Status::CONNECTED || @exited
     end
 
     # Send input to the PTY session
@@ -127,8 +134,9 @@ module Daytona
     #
     # @param on_data [Proc, nil] Optional callback to handle output data
     # @return [Daytona::PtyResult] Result containing exit code and error information
-    def wait(timeout: nil, &on_data)
+    def wait(timeout: nil, &on_data) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/AbcSize
       timeout ||= Float::INFINITY
+      return PtyResult.new(exit_code:, error:) if @exited
       return unless status == Status::CONNECTED
 
       start_time = Time.now
@@ -239,11 +247,17 @@ module Daytona
 
     # @param data [WebSocket::Frame::Data]
     # @return [void]
-    def process_websocket_control_message(data) # rubocop:disable Metrics/MethodLength
+    def process_websocket_control_message(data) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
       case data[:status]
       when WebSocketControlStatus::CONNECTED
         logger.debug('[control] connected')
         @status = Status::CONNECTED
+      when WebSocketControlStatus::EXITED
+        logger.debug("[control] exited: code=#{data[:exitCode]}")
+        @exit_code = data[:exitCode]
+        @error = data[:exitReason] if data[:exitReason]
+        @exited = true
+        @status = Status::CLOSED
       when WebSocketControlStatus::ERROR
         logger.debug("[control] error: #{error.inspect}")
         @status = Status::ERROR
@@ -302,6 +316,7 @@ module Daytona
     module WebSocketControlStatus
       ALL = [
         CONNECTED = 'connected',
+        EXITED = 'exited',
         ERROR = 'error'
       ].freeze
     end