daytona 0.193.0 → 0.194.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3516e01775fd344454ee8e9a037e5397ac6d5e6c2f3680b99e77d6b0d2f457e8
-  data.tar.gz: 381863bb0b17a8d7ac0ec3c16df461a695bbd9ff1973ffe03aa465e824c40859
+  metadata.gz: 52e589fc8beb1606bed33e09a6caabe834daf349ec5042e36332eaee4bd23544
+  data.tar.gz: ffe431dbab005054179308e74c1b1c5d406f34925f096f01be7bf75e9a149b59
 SHA512:
-  metadata.gz: 96c549bcae03f6bd0a6b8c8f463ce59cb6f963814c9cca185f9ad695df853aff70fe09409e64b3da7c53d0e16dd4d26e4f8e56e096431e1ec4eda69a4dc8d779
-  data.tar.gz: 557be99206ff09de81f9330971abcc37021b603dc617a2fbaa52d43bca4b8e61e420e349159997a849899fc72f57ffaf1db2f67d9e3631a6ad987a8eb473bdcb
+  metadata.gz: 73d0b98ed2a79fbaafd27f5e49a12a78f3289e37d15bf512a6f99b37b5e0d3a1da44fb5b322fc4abd8226598e152372ba53b91335bfdcb1d1fa84416eace7294
+  data.tar.gz: e8244a2e9dd9f7737af789ab7855cbb2eee625f0774cbe34d845955195b3f9cc2e80c44872c468b7c29a595582f45faaddb32a1ca4ec8da2b6ae3e8441297822

data/lib/daytona/common/response.rb

@@ -37,6 +37,30 @@ module Daytona
     end
   end
 
+  # Cursor-paginated collection of Secrets returned by
+  # {Daytona::SecretService#list}. Pass +next_cursor+ back as the
+  # +cursor+ of the next call to fetch the following page; it is +nil+ when
+  # there are no more pages.
+  class ListSecretsResponse
+    # @return [Array<Daytona::Secret>]
+    attr_reader :items
+
+    # @return [Float]
+    attr_reader :total
+
+    # @return [String, nil]
+    attr_reader :next_cursor
+
+    # @param items [Array<Daytona::Secret>]
+    # @param total [Float]
+    # @param next_cursor [String, nil]
+    def initialize(items:, total:, next_cursor:)
+      @items = items
+      @total = total
+      @next_cursor = next_cursor
+    end
+  end
+
   # Query parameters for filtering and sorting when listing Sandboxes.
   #
   # All fields are optional and default to +nil+. Constructed via keyword

data/lib/daytona/file_system.rb

@@ -97,6 +97,9 @@ module Daytona
     #
     # @param path [String] Path to the directory to list contents from. Relative paths are resolved
     #   based on the sandbox working directory.
+    # @param depth [Integer, nil] How many levels deep to list. depth=1 (default) lists the
+    #   directory's entries, depth=2 also includes their children, and so on. Must be >= 1.
+    #   Each returned FileInfo carries a full path field.
     # @return [Array<DaytonaApiClient::FileInfo>] List of file and directory information
     # @raise [Daytona::Sdk::Error] If the operation fails
     #
@@ -112,8 +115,14 @@ module Daytona
     #   # List only directories
     #   dirs = files.select(&:is_dir)
     #   puts "Subdirectories: #{dirs.map(&:name).join(', ')}"
-    def list_files(path)
-      toolbox_api.list_files({ path: })
+    def list_files(path, depth: nil)
+      if !depth.nil? && (!depth.is_a?(Integer) || depth < 1)
+        raise Sdk::Error, 'Failed to list files: depth must be an integer of at least 1'
+      end
+
+      toolbox_api.list_files({ path:, depth: }.compact)
+    rescue Sdk::Error
+      raise
     rescue StandardError => e
       raise Sdk::Error, "Failed to list files: #{e.message}"
     end

data/lib/daytona/git.rb

@@ -85,6 +85,7 @@ module Daytona
     # @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.
+    # @param depth [Integer, nil] Create a shallow clone truncated to the given number of commits.
     # @return [void]
     # @raise [Daytona::Sdk::Error] if cloning repository fails
     #
@@ -110,7 +111,7 @@ module Daytona
     #     path: "workspace/repo-old",
     #     commit_id: "abc123"
     #   )
-    def clone(url:, path:, branch: nil, commit_id: nil, username: nil, password: nil, insecure_skip_tls: nil) # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+    def clone(url:, path:, branch: nil, commit_id: nil, username: nil, password: nil, insecure_skip_tls: nil, depth: nil) # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists, Layout/LineLength
       toolbox_api.clone_repository(
         DaytonaToolboxApiClient::GitCloneRequest.new(
           url: url,
@@ -119,7 +120,8 @@ module Daytona
           username: username,
           password: password,
           commit_id: commit_id,
-          insecure_skip_tls: insecure_skip_tls
+          insecure_skip_tls: insecure_skip_tls,
+          depth: depth
         )
       )
     rescue DaytonaToolboxApiClient::ApiError => e
@@ -170,6 +172,9 @@ module Daytona
     #   the sandbox working directory.
     # @param username [String, nil] Git username for authentication.
     # @param password [String, nil] Git password or token for authentication.
+    # @param branch [String, nil] Branch to push. Defaults to the current branch.
+    # @param remote [String, nil] Remote to push to. Defaults to "origin".
+    # @param set_upstream [Boolean] Record the pushed branch as the upstream tracking branch. Defaults to false.
     # @return [void]
     # @raise [Daytona::Sdk::Error] if pushing changes fails
     #
@@ -183,9 +188,12 @@ module Daytona
     #     username: "user",
     #     password: "github_token"
     #   )
-    def push(path:, username: nil, password: nil)
+    #
+    #   # Push a new branch and set its upstream
+    #   sandbox.git.push(path: "workspace/repo", branch: "feature", set_upstream: true)
+    def push(path:, username: nil, password: nil, branch: nil, remote: nil, set_upstream: false) # rubocop:disable Metrics/ParameterLists
       toolbox_api.push_changes(
-        DaytonaToolboxApiClient::GitRepoRequest.new(path:, username:, password:)
+        DaytonaToolboxApiClient::GitPushRequest.new(path:, username:, password:, branch:, remote:, set_upstream:)
       )
     rescue DaytonaToolboxApiClient::ApiError => e
       raise map_api_error(e, 'Failed to push changes')
@@ -200,6 +208,8 @@ module Daytona
     #   the sandbox working directory.
     # @param username [String, nil] Git username for authentication.
     # @param password [String, nil] Git password or token for authentication.
+    # @param branch [String, nil] Branch to pull. Defaults to the current branch's upstream.
+    # @param remote [String, nil] Remote to pull from. Defaults to "origin".
     # @return [void]
     # @raise [Daytona::Sdk::Error] if pulling changes fails
     #
@@ -214,9 +224,11 @@ module Daytona
     #     password: "github_token"
     #   )
     #
-    def pull(path:, username: nil, password: nil)
+    #   # Pull a specific branch from a specific remote
+    #   sandbox.git.pull(path: "workspace/repo", remote: "upstream", branch: "main")
+    def pull(path:, username: nil, password: nil, branch: nil, remote: nil)
       toolbox_api.pull_changes(
-        DaytonaToolboxApiClient::GitRepoRequest.new(path:, username:, password:)
+        DaytonaToolboxApiClient::GitPullRequest.new(path:, username:, password:, branch:, remote:)
       )
     rescue DaytonaToolboxApiClient::ApiError => e
       raise map_api_error(e, 'Failed to pull changes')
@@ -308,8 +320,222 @@ module Daytona
       raise Sdk::Error, "Failed to delete branch: #{e.message}"
     end
 
+    # Initializes a new Git repository at the specified path.
+    #
+    # @param path [String] Path where the repository should be initialized.
+    # @param bare [Boolean] Create a bare repository without a working tree. Defaults to false.
+    # @param initial_branch [String, nil] Name of the initial branch. If not specified, uses the Git default.
+    # @return [void]
+    # @raise [Daytona::Sdk::Error] if initializing repository fails
+    #
+    # @example
+    #   sandbox.git.init("workspace/repo", initial_branch: "main")
+    def init(path, bare: false, initial_branch: nil)
+      toolbox_api.init_repository(
+        DaytonaToolboxApiClient::GitInitRequest.new(path:, bare:, initial_branch:)
+      )
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to initialize repository')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to initialize repository: #{e.message}"
+    end
+
+    # Resets the current HEAD to the specified state.
+    #
+    # @param path [String] Path to the Git repository root.
+    # @param mode [String, nil] Reset mode, one of "soft", "mixed" (default), "hard", "merge" or "keep".
+    # @param target [String, nil] Revision to reset to. Defaults to HEAD.
+    # @param files [Array<String>, nil] Constrain the reset to the given paths.
+    # @return [void]
+    # @raise [Daytona::Sdk::Error] if resetting fails
+    #
+    # @example
+    #   # Unstage all changes (mixed reset to HEAD)
+    #   sandbox.git.reset("workspace/repo")
+    #
+    #   # Hard reset to a previous commit
+    #   sandbox.git.reset("workspace/repo", mode: "hard", target: "HEAD~1")
+    def reset(path, mode: nil, target: nil, files: nil)
+      toolbox_api.reset_changes(
+        DaytonaToolboxApiClient::GitResetRequest.new(path:, mode:, target:, files:)
+      )
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to reset')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to reset: #{e.message}"
+    end
+
+    # Restores working tree files or unstages changes.
+    #
+    # @param path [String] Path to the Git repository root.
+    # @param files [Array<String>] File paths to restore.
+    # @param staged [Boolean, nil] Restore the staging index for the given files.
+    # @param worktree [Boolean, nil] Restore the working tree for the given files. Defaults to true
+    #   when neither staged nor worktree is provided.
+    # @param source [String, nil] Restore file contents from the given revision instead of the index.
+    # @return [void]
+    # @raise [Daytona::Sdk::Error] if restoring fails
+    #
+    # @example
+    #   # Discard working tree changes
+    #   sandbox.git.restore("workspace/repo", ["file.txt"])
+    #
+    #   # Unstage changes
+    #   sandbox.git.restore("workspace/repo", ["file.txt"], staged: true)
+    def restore(path, files, staged: nil, worktree: nil, source: nil)
+      toolbox_api.restore_files(
+        DaytonaToolboxApiClient::GitRestoreRequest.new(path:, files:, staged:, worktree:, source:)
+      )
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to restore files')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to restore files: #{e.message}"
+    end
+
+    # Adds (or overwrites) a remote in the repository.
+    #
+    # @param path [String] Path to the Git repository root.
+    # @param name [String] Name of the remote.
+    # @param url [String] URL of the remote.
+    # @param fetch [Boolean] Fetch from the remote immediately after adding it. Defaults to false.
+    # @param overwrite [Boolean] Replace an existing remote with the same name. Defaults to false.
+    # @return [void]
+    # @raise [Daytona::Sdk::Error] if adding the remote fails
+    #
+    # @example
+    #   sandbox.git.remote_add("workspace/repo", "origin", "https://github.com/user/repo.git")
+    def remote_add(path, name, url, fetch: false, overwrite: false)
+      toolbox_api.add_remote(
+        DaytonaToolboxApiClient::GitAddRemoteRequest.new(path:, name:, url:, fetch:, overwrite:)
+      )
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to add remote')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to add remote: #{e.message}"
+    end
+
+    # Lists the remotes configured in the repository.
+    #
+    # @param path [String] Path to the Git repository root.
+    # @return [DaytonaToolboxApiClient::ListRemotesResponse] The configured remotes (name + URL).
+    # @raise [Daytona::Sdk::Error] if listing remotes fails
+    #
+    # @example
+    #   response = sandbox.git.remotes("workspace/repo")
+    #   response.remotes.each { |r| puts "#{r.name}: #{r.url}" }
+    def remotes(path)
+      toolbox_api.list_remotes(path)
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to list remotes')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to list remotes: #{e.message}"
+    end
+
+    # Gets the URL of a remote, or nil when it does not exist.
+    #
+    # @param path [String] Path to the Git repository root.
+    # @param name [String] Name of the remote.
+    # @return [String, nil] The remote URL, or nil when the remote does not exist.
+    # @raise [Daytona::Sdk::Error] if getting the remote fails
+    #
+    # @example
+    #   url = sandbox.git.remote_get("workspace/repo", "origin")
+    def remote_get(path, name)
+      toolbox_api.list_remotes(path).remotes.find { |r| r.name == name }&.url
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to get remote')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to get remote: #{e.message}"
+    end
+
+    # Sets a Git config value at the given scope.
+    #
+    # @param key [String] Config key in dotted form (e.g. "user.name").
+    # @param value [String] Config value.
+    # @param scope [String] Config scope, one of "global" (default), "local" or "system".
+    # @param path [String, nil] Repository path, required when scope is "local".
+    # @return [void]
+    # @raise [Daytona::Sdk::Error] if setting config fails
+    #
+    # @example
+    #   sandbox.git.set_config("user.name", "John Doe")
+    def set_config(key, value, scope: 'global', path: nil)
+      toolbox_api.set_git_config(
+        DaytonaToolboxApiClient::GitSetConfigRequest.new(key:, value:, scope:, path:)
+      )
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to set config')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to set config: #{e.message}"
+    end
+
+    # Gets a Git config value at the given scope, or nil when unset.
+    #
+    # @param key [String] Config key in dotted form (e.g. "user.name").
+    # @param scope [String] Config scope, one of "global" (default), "local" or "system".
+    # @param path [String, nil] Repository path, required when scope is "local".
+    # @return [String, nil] The config value, or nil when the key is not set.
+    # @raise [Daytona::Sdk::Error] if getting config fails
+    #
+    # @example
+    #   name = sandbox.git.get_config("user.name")
+    def get_config(key, scope: 'global', path: nil)
+      toolbox_api.get_git_config(key, scope: scope, path: path).value
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to get config')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to get config: #{e.message}"
+    end
+
+    # Configures the Git user name and email at the given scope.
+    #
+    # @param name [String] User name (user.name).
+    # @param email [String] User email (user.email).
+    # @param scope [String] Config scope, one of "global" (default), "local" or "system".
+    # @param path [String, nil] Repository path, required when scope is "local".
+    # @return [void]
+    # @raise [Daytona::Sdk::Error] if configuring user fails
+    #
+    # @example
+    #   sandbox.git.configure_user("John Doe", "john@example.com")
+    def configure_user(name, email, scope: 'global', path: nil)
+      toolbox_api.configure_user(
+        DaytonaToolboxApiClient::GitConfigureUserRequest.new(name:, email:, scope:, path:)
+      )
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to configure user')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to configure user: #{e.message}"
+    end
+
+    # Persists Git credentials globally so that subsequent operations against the
+    # given host authenticate automatically.
+    #
+    # WARNING: This stores the password in plaintext on disk via the Git credential store.
+    #
+    # @param username [String] Git username.
+    # @param password [String] Git password or token.
+    # @param host [String, nil] Host to authenticate against. Defaults to "github.com".
+    # @param protocol [String, nil] Protocol to authenticate against. Defaults to "https".
+    # @return [void]
+    # @raise [Daytona::Sdk::Error] if authenticating fails
+    #
+    # @example
+    #   sandbox.git.dangerously_authenticate("user", "github_token")
+    def dangerously_authenticate(username, password, host: nil, protocol: nil)
+      toolbox_api.authenticate(
+        DaytonaToolboxApiClient::GitAuthenticateRequest.new(username:, password:, host:, protocol:)
+      )
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to authenticate')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to authenticate: #{e.message}"
+    end
+
     instrument :add, :branches, :clone, :commit, :push, :pull, :status,
                :checkout_branch, :create_branch, :delete_branch,
+               :init, :reset, :restore, :remote_add, :remotes, :remote_get,
+               :set_config, :get_config, :configure_user, :dangerously_authenticate,
                component: 'Git'
 
     private

data/lib/daytona/sdk/version.rb

@@ -5,6 +5,6 @@
 
 module Daytona
   module Sdk
-    VERSION = '0.193.0'
+    VERSION = '0.194.0'
   end
 end

data/lib/daytona/secret_service.rb

@@ -50,11 +50,35 @@ module Daytona
     # @raise [DaytonaApiClient::ApiError] If no Secret with the given ID exists (404).
     def get(secret_id) = Secret.new(secret_api.get_secret(secret_id))
 
-    # List all Secrets.
+    # List Secrets with cursor-based pagination.
     #
-    # @return [Array<Daytona::Secret>]
-    def list
-      secret_api.list_secrets.map { |secret| Secret.new(secret) }
+    # @param cursor [String, nil] Pagination cursor from a previous response.
+    # @param limit [Integer, nil] Number of results per page (1-200, defaults to 100).
+    # @param name [String, nil] Filter by partial name match.
+    # @param sort [String, nil] Field to sort by: +name+, +createdAt+ or +updatedAt+
+    #   (defaults to +createdAt+).
+    # @param order [String, nil] Direction to sort by: +asc+ or +desc+ (defaults to +desc+).
+    # @return [Daytona::ListSecretsResponse]
+    # @raise [Daytona::Sdk::Error]
+    #
+    # @example
+    #   daytona = Daytona::Daytona.new
+    #   cursor = nil
+    #   loop do
+    #     page = daytona.secret.list(cursor:, limit: 100)
+    #     page.items.each { |secret| puts secret.name }
+    #     cursor = page.next_cursor
+    #     break if cursor.nil?
+    #   end
+    def list(cursor: nil, limit: nil, name: nil, sort: nil, order: nil)
+      raise Sdk::Error, 'limit must be positive integer' if limit && limit < 1
+
+      response = secret_api.list_secrets_paginated(cursor:, limit:, name:, sort:, order:)
+      ListSecretsResponse.new(
+        items: response.items.map { |secret| Secret.new(secret) },
+        total: response.total,
+        next_cursor: response.next_cursor
+      )
     end
 
     # Update a Secret.

data/scripts/generate-docs.rb

@@ -50,6 +50,14 @@ def add_frontmatter(content, class_name)
   frontmatter + content
 end
 
+def format_signature_params(parameters)
+  parameters.map do |name, default|
+    next name if default.nil?
+
+    name.end_with?(':') ? "#{name} #{default}" : "#{name} = #{default}"
+  end.join(', ')
+end
+
 def format_type(types)
   return 'Object' if types.nil? || types.empty?
 
@@ -176,8 +184,7 @@ def generate_markdown_for_object(obj)
 
       # Method signature
       content << '```ruby'
-      params_str = constructor.parameters.map { |p| p[0] }.join(', ')
-      content << "def initialize(#{params_str})"
+      content << "def initialize(#{format_signature_params(constructor.parameters)})"
       content << '```'
       content << ''
 
@@ -245,8 +252,7 @@ def generate_markdown_for_object(obj)
 
         # Method signature
         content << '```ruby'
-        params_str = method.parameters.map { |p| p[0] }.join(', ')
-        content << "def #{method.name}(#{params_str})"
+        content << "def #{method.name}(#{format_signature_params(method.parameters)})"
         content << '```'
         content << ''
 

metadata

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