daytona 0.179.0 → 0.180.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea639b85defa7ec8ea3220b340850e2a8528258b4d84c99dafc48934f2527e78
-  data.tar.gz: 4599b389e4591ea8b1a2776950b003f419c4636a5a66b2551c71b28255e2ce4e
+  metadata.gz: 5ef29fb3887fb9d38af38910afa732e55a63f6f6006f1096aa00f4a56aaa47ab
+  data.tar.gz: 4dd900933102173c986bc0c34683fa5f575da8fc18e2b94eb836f8c5caa254aa
 SHA512:
-  metadata.gz: 2abc3f082a36a04e971d67c62f01f08126ba3c8fe81a2258c607fad204805ecb4551bd434c07d2ad55e569fb17fdef95ac068a426adb39518868f6e1dc6a6319
-  data.tar.gz: 0ce97e0c6749c4473d995b78d4f4b29ec96363ff7c850a8d5f9ea051b2c9f08209302bbe05d7f53b96c44a3a6f0a5da01d4f6e4d9a6ebd5bfb210f0ccd26bf03
+  metadata.gz: 6653a399ac8b2689e2f515c675f7999ae2280ab9a802629b08c3fc017bcd530e11ab39a9524c4a0a5cc4ba61d102ce610ddc6a5ad3970cad1edd741685da6f65
+  data.tar.gz: a3136c2d3a5976a3c8177f0f1952929afbfb63cab2bcfc98730b945264ad4b6d76f53bdb0dae4c78f201f28acd212abcb12346a5d592952d0c4bc1c7fcb20f94

data/lib/daytona/common/response.rb

@@ -4,6 +4,12 @@
 # frozen_string_literal: true
 
 module Daytona
+  # Re-export of api-client enum constants under the Daytona namespace so
+  # SDK consumers never need to import from DaytonaApiClient directly.
+  SandboxState = DaytonaApiClient::SandboxState
+  SandboxListSortField = DaytonaApiClient::SandboxListSortField
+  SandboxListSortDirection = DaytonaApiClient::SandboxListSortDirection
+
   class PaginatedResource
     # @return [Array<Object>]
     attr_reader :items
@@ -28,4 +34,48 @@ module Daytona
       @total_pages = total_pages
     end
   end
+
+  # Query parameters for filtering and sorting when listing Sandboxes.
+  #
+  # All fields are optional and default to +nil+. Constructed via keyword
+  # arguments and immutable (Ruby 3.2+ Data semantics).
+  #
+  # @example
+  #   query = Daytona::ListSandboxesQuery.new(labels: { 'env' => 'prod' }, limit: 10)
+  #   daytona.list(query).each { |sandbox| puts sandbox.id }
+  ListSandboxesQuery = Data.define(
+    :limit,
+    :id,
+    :name,
+    :labels,
+    :states,
+    :snapshots,
+    :targets,
+    :min_cpu,
+    :max_cpu,
+    :min_memory_gib,
+    :max_memory_gib,
+    :min_disk_gib,
+    :max_disk_gib,
+    :is_public,
+    :is_recoverable,
+    :created_at_after,
+    :created_at_before,
+    :last_activity_after,
+    :last_activity_before,
+    :sort,
+    :order
+  ) do
+    # All members default to nil so callers pass only the filters they care about.
+    DEFAULTS = members.to_h { |m| [m, nil] }.freeze
+
+    class << self
+      alias_method :_data_new, :new
+      def new(**attrs) = _data_new(**DEFAULTS, **attrs)
+    end
+
+    # Idiomatic Ruby boolean predicate aliases.
+    def public? = is_public
+    def recoverable? = is_recoverable
+  end
 end

data/lib/daytona/daytona.rb

@@ -95,28 +95,32 @@ module Daytona
       to_sandbox(sandbox_dto:)
     end
 
-    # Lists Sandboxes filtered by labels.
+    # Iterates over Sandboxes matching the given query.
     #
-    # @param labels [Hash<String, String>]
-    # @param page [Integer, Nil]
-    # @param limit [Integer, Nil]
-    # @return [Daytona::PaginatedResource]
+    # @param query [Daytona::ListSandboxesQuery, nil] Optional filters, sorting, and per-page size.
+    # @return [Enumerator<Daytona::Sandbox>]
     # @raise [Daytona::Sdk::Error]
-    def list(labels = {}, page: nil, limit: nil)
-      raise Sdk::Error, 'page must be positive integer' if page && page < 1
-
-      raise Sdk::Error, 'limit must be positive integer' if limit && limit < 1
-
-      response = sandbox_api.list_sandboxes_paginated(labels: JSON.dump(labels), page:, limit:)
-
-      PaginatedResource.new(
-        total: response.total,
-        page: response.page,
-        total_pages: response.total_pages,
-        items: response.items.map do |sandbox_dto|
-          to_sandbox(sandbox_dto:)
+    #
+    # @example
+    #   daytona.list(Daytona::ListSandboxesQuery.new(labels: { 'env' => 'dev' })).each do |sandbox|
+    #     puts sandbox.id
+    #   end
+    def list(query = nil)
+      q = query || ListSandboxesQuery.new
+
+      Enumerator.new do |yielder|
+        cursor = nil
+        first_page = true
+        while first_page || cursor
+          first_page = false
+          response = fetch_sandbox_page(q, cursor)
+          response.items.each do |sandbox_dto|
+            yielder << to_sandbox(sandbox_dto: sandbox_dto)
+          end
+          cursor = response.next_cursor
+          break if cursor.nil? || (cursor.respond_to?(:empty?) && cursor.empty?)
         end
-      )
+      end
     end
 
     # Starts a Sandbox and waits for it to be ready.
@@ -133,13 +137,51 @@ module Daytona
     # @return [void]
     def stop(sandbox, timeout = Sandbox::DEFAULT_TIMEOUT) = sandbox.stop(timeout)
 
-    instrument :create, :delete, :get, :list, :start, :stop, component: 'Daytona'
+    instrument :create, :delete, :get, :start, :stop, component: 'Daytona'
 
     private
 
     # @return [Daytona::OtelState, nil]
     attr_reader :otel_state
 
+    # Fetches a single page of sandboxes. Each call produces one OTel span
+    # ("Daytona.list_fetch_page") so that paginated iteration emits N spans
+    # for N pages.
+    #
+    # @param q [Daytona::ListSandboxesQuery]
+    # @param cursor [String, nil]
+    # @return [DaytonaApiClient::ListSandboxesResponse]
+    def fetch_sandbox_page(q, cursor)
+      opts = {
+        cursor: cursor,
+        limit: q.limit,
+        id: q.id,
+        name: q.name,
+        labels: q.labels ? JSON.dump(q.labels) : nil,
+        states: q.states,
+        snapshots: q.snapshots,
+        region_ids: q.targets,
+        min_cpu: q.min_cpu,
+        max_cpu: q.max_cpu,
+        min_memory_gi_b: q.min_memory_gib,
+        max_memory_gi_b: q.max_memory_gib,
+        min_disk_gi_b: q.min_disk_gib,
+        max_disk_gi_b: q.max_disk_gib,
+        is_public: q.is_public,
+        is_recoverable: q.is_recoverable,
+        created_at_after: q.created_at_after,
+        created_at_before: q.created_at_before,
+        last_event_after: q.last_activity_after,
+        last_event_before: q.last_activity_before,
+        sort: q.sort,
+        order: q.order
+      }.compact
+
+      sandbox_api.list_sandboxes(opts)
+    end
+
+    instrument :fetch_sandbox_page, component: 'Daytona.list'
+
     # Creates a sandbox with the specified parameters
     #
     # @param params [Daytona::CreateSandboxFromSnapshotParams, Daytona::CreateSandboxFromImageParams] Sandbox creation parameters
@@ -262,7 +304,7 @@ module Daytona
       end
     end
 
-    # @param sandbox_dto [DaytonaApiClient::Sandbox]
+    # @param sandbox_dto [DaytonaApiClient::Sandbox, DaytonaApiClient::SandboxListItem]
     # @return [Daytona::Sandbox]
     def to_sandbox(sandbox_dto:)
       Sandbox.new(

data/lib/daytona/sandbox.rb

@@ -23,7 +23,8 @@ module Daytona
     # @return [String] The user associated with the project
     attr_reader :user
 
-    # @return [Hash<String, String>] Environment variables for the sandbox
+    # @return [Hash<String, String>, nil] Environment variables for the sandbox.
+    #   Not returned by list results; call #refresh on each item to populate.
     attr_reader :env
 
     # @return [Hash<String, String>] Labels for the sandbox
@@ -32,10 +33,12 @@ module Daytona
     # @return [Boolean] Whether the sandbox http preview is public
     attr_reader :public
 
-    # @return [Boolean] Whether to block all network access for the sandbox
+    # @return [Boolean, nil] Whether to block all network access for the sandbox.
+    #   Not returned by list results; call #refresh on each item to populate.
     attr_reader :network_block_all
 
-    # @return [String] Comma-separated list of allowed CIDR network addresses for the sandbox
+    # @return [String, nil] Comma-separated list of allowed CIDR network addresses for the sandbox.
+    #   Not returned by list results; call #refresh on each item to populate.
     attr_reader :network_allow_list
 
     # @return [String] The target environment for the sandbox
@@ -65,7 +68,8 @@ module Daytona
     # @return [String] The state of the backup
     attr_reader :backup_state
 
-    # @return [String] The creation timestamp of the last backup
+    # @return [String, nil] The creation timestamp of the last backup.
+    #   Not returned by list results; call #refresh on each item to populate.
     attr_reader :backup_created_at
 
     # @return [Float] Auto-stop interval in minutes (0 means disabled)
@@ -78,10 +82,13 @@ module Daytona
     # (negative value means disabled, 0 means delete immediately upon stopping)
     attr_reader :auto_delete_interval
 
-    # @return [Array<DaytonaApiClient::SandboxVolume>] Array of volumes attached to the sandbox
+    # @return [Array<DaytonaApiClient::SandboxVolume>, nil] Volumes attached to the sandbox.
+    #   Not returned by list results; call #refresh on each item to populate.
     attr_reader :volumes
 
-    # @return [DaytonaApiClient::BuildInfo] Build information for the sandbox
+    # @return [DaytonaApiClient::BuildInfo, nil] Build information for the sandbox if it was
+    #   created from a dynamic build.
+    #   Not returned by list results; call #refresh on each item to populate.
     attr_reader :build_info
 
     # @return [String] The creation timestamp of the sandbox
@@ -119,7 +126,7 @@ module Daytona
 
     # @params config [Daytona::Config]
     # @params sandbox_api [DaytonaApiClient::SandboxApi]
-    # @params sandbox_dto [DaytonaApiClient::Sandbox]
+    # @params sandbox_dto [DaytonaApiClient::Sandbox, DaytonaApiClient::SandboxListItem]
     # @params otel_state [Daytona::OtelState, nil]
     def initialize(sandbox_dto:, config:, sandbox_api:, otel_state: nil) # rubocop:disable Metrics/MethodLength
       process_response(sandbox_dto)
@@ -565,14 +572,14 @@ module Daytona
       end
     end
 
-    # @params sandbox_dto [DaytonaApiClient::Sandbox]
+    # @params sandbox_dto [DaytonaApiClient::Sandbox, DaytonaApiClient::SandboxListItem]
     # @return [void]
     def process_response(sandbox_dto) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      # Fields shared by both DaytonaApiClient::Sandbox and DaytonaApiClient::SandboxListItem.
       @id = sandbox_dto.id
       @organization_id = sandbox_dto.organization_id
       @snapshot = sandbox_dto.snapshot
       @user = sandbox_dto.user
-      @env = sandbox_dto.env
       @labels = sandbox_dto.labels
       @public = sandbox_dto.public
       @target = sandbox_dto.target
@@ -584,19 +591,25 @@ module Daytona
       @desired_state = sandbox_dto.desired_state
       @error_reason = sandbox_dto.error_reason
       @backup_state = sandbox_dto.backup_state
-      @backup_created_at = sandbox_dto.backup_created_at
       @auto_stop_interval = sandbox_dto.auto_stop_interval
       @auto_archive_interval = sandbox_dto.auto_archive_interval
       @auto_delete_interval = sandbox_dto.auto_delete_interval
-      @volumes = sandbox_dto.volumes
-      @build_info = sandbox_dto.build_info
       @created_at = sandbox_dto.created_at
       @updated_at = sandbox_dto.updated_at
       @last_activity_at = sandbox_dto.last_activity_at
       @daemon_version = sandbox_dto.daemon_version
+      @toolbox_proxy_url = sandbox_dto.toolbox_proxy_url
+
+      # Fields only present on the full DaytonaApiClient::Sandbox DTO (not returned by list
+      # results; call #refresh on each item to populate them).
+      return unless sandbox_dto.is_a?(DaytonaApiClient::Sandbox)
+
+      @env = sandbox_dto.env
       @network_block_all = sandbox_dto.network_block_all
       @network_allow_list = sandbox_dto.network_allow_list
-      @toolbox_proxy_url = sandbox_dto.toolbox_proxy_url
+      @volumes = sandbox_dto.volumes
+      @build_info = sandbox_dto.build_info
+      @backup_created_at = sandbox_dto.backup_created_at
     end
 
     # Monitors block not to exceed max execution time.

data/lib/daytona/sdk/version.rb

@@ -5,6 +5,6 @@
 
 module Daytona
   module Sdk
-    VERSION = '0.179.0'
+    VERSION = '0.180.0.alpha.1'
   end
 end

metadata

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