daytona 0.126.0.pre.alpha.5 → 0.134.0.alpha.1

data/lib/daytona/git.rb

@@ -37,7 +37,7 @@ module Daytona
     #     "README.md"
     #   ])
     def add(path, files)
-      toolbox_api.git_add_files(DaytonaToolboxApiClient::GitAddRequest.new(path:, files:))
+      toolbox_api.add_files(DaytonaToolboxApiClient::GitAddRequest.new(path:, files:))
     rescue StandardError => e
       raise Sdk::Error, "Failed to add files: #{e.message}"
     end
@@ -53,7 +53,7 @@ module Daytona
     #   response = sandbox.git.branches("workspace/repo")
     #   puts "Branches: #{response.branches}"
     def branches(path)
-      toolbox_api.git_list_branches(path)
+      toolbox_api.list_branches(path)
     rescue StandardError => e
       raise Sdk::Error, "Failed to list branches: #{e.message}"
     end
@@ -97,7 +97,7 @@ module Daytona
     #     commit_id: "abc123"
     #   )
     def clone(url:, path:, branch: nil, commit_id: nil, username: nil, password: nil) # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
-      toolbox_api.git_clone_repository(
+      toolbox_api.clone_repository(
         DaytonaToolboxApiClient::GitCloneRequest.new(
           url: url,
           branch: branch,
@@ -135,7 +135,7 @@ module Daytona
     #   )
     #   puts "Commit SHA: #{commit_response.sha}"
     def commit(path:, message:, author:, email:, allow_empty: false)
-      response = toolbox_api.git_commit_changes(
+      response = toolbox_api.commit_changes(
         DaytonaToolboxApiClient::GitCommitRequest.new(path:, message:, author:, email:, allow_empty:)
       )
       GitCommitResponse.new(sha: response.hash)
@@ -165,7 +165,7 @@ module Daytona
     #     password: "github_token"
     #   )
     def push(path:, username: nil, password: nil)
-      toolbox_api.git_push_changes(
+      toolbox_api.push_changes(
         DaytonaToolboxApiClient::GitRepoRequest.new(path:, username:, password:)
       )
     rescue StandardError => e
@@ -194,7 +194,7 @@ module Daytona
     #   )
     #
     def pull(path:, username: nil, password: nil)
-      toolbox_api.git_pull_changes(
+      toolbox_api.pull_changes(
         DaytonaToolboxApiClient::GitRepoRequest.new(path:, username:, password:)
       )
     rescue StandardError => e
@@ -214,7 +214,7 @@ module Daytona
     #   puts "Commits ahead: #{status.ahead}"
     #   puts "Commits behind: #{status.behind}"
     def status(path)
-      toolbox_api.git_get_status(path)
+      toolbox_api.get_status(path)
     rescue StandardError => e
       raise Sdk::Error, "Failed to get status: #{e.message}"
     end
@@ -231,7 +231,7 @@ module Daytona
     #   # Checkout a branch
     #   sandbox.git.checkout_branch("workspace/repo", "feature-branch")
     def checkout_branch(path, branch)
-      toolbox_api.git_checkout_branch(
+      toolbox_api.checkout_branch(
         DaytonaToolboxApiClient::GitCheckoutRequest.new(path:, branch:)
       )
     rescue StandardError => e
@@ -251,7 +251,7 @@ module Daytona
     #   sandbox.git.create_branch("workspace/repo", "new-feature")
     #
     def create_branch(path, name)
-      toolbox_api.git_create_branch(
+      toolbox_api.create_branch(
         DaytonaToolboxApiClient::GitBranchRequest.new(path:, name:)
       )
     rescue StandardError => e
@@ -270,7 +270,7 @@ module Daytona
     #   # Delete a branch
     #   sandbox.git.delete_branch("workspace/repo", "old-feature")
     def delete_branch(path, name)
-      toolbox_api.git_delete_branch(
+      toolbox_api.delete_branch(
         DaytonaToolboxApiClient::GitDeleteBranchRequest.new(path:, name:)
       )
     rescue StandardError => e

data/lib/daytona/lsp_server.rb

@@ -44,7 +44,7 @@ module Daytona
     # @param position [Daytona::LspServer::Position]
     # @return [DaytonaApiClient::CompletionList]
     def completions(path:, position:)
-      toolbox_api.lsp_completions(
+      toolbox_api.completions(
         DaytonaToolboxApiClient::LspCompletionParams.new(
           language_id:,
           path_to_project:,
@@ -61,7 +61,7 @@ module Daytona
     # @param path [String]
     # @return [void]
     def did_close(path)
-      toolbox_api.lsp_did_close(
+      toolbox_api.did_close(
         DaytonaToolboxApiClient::LspDocumentRequest.new(language_id:, path_to_project:, uri: uri(path))
       )
     end
@@ -74,7 +74,7 @@ module Daytona
     # @param path [String]
     # @return [void]
     def did_open(path)
-      toolbox_api.lsp_did_open(
+      toolbox_api.did_open(
         DaytonaToolboxApiClient::LspDocumentRequest.new(language_id:, path_to_project:, uri: uri(path))
       )
     end
@@ -83,14 +83,14 @@ module Daytona
     #
     # @param path [String]
     # @return [Array<DaytonaToolboxApiClient::LspSymbol]
-    def document_symbols(path) = toolbox_api.lsp_document_symbols(language_id, path_to_project, uri(path))
+    def document_symbols(path) = toolbox_api.document_symbols(language_id, path_to_project, uri(path))
 
     # Searches for symbols matching the query string across all files
     # in the Sandbox.
     #
     # @param query [String]
     # @return [Array<DaytonaToolboxApiClient::LspSymbol]
-    def sandbox_symbols(query) = toolbox_api.lsp_workspace_symbols(language_id, path_to_project, query)
+    def sandbox_symbols(query) = toolbox_api.workspace_symbols(query, language_id, path_to_project)
 
     # Starts the language server.
     # This method must be called before using any other LSP functionality.
@@ -98,7 +98,7 @@ module Daytona
     #
     # @return [void]
     def start
-      toolbox_api.lsp_start(
+      toolbox_api.start(
         DaytonaToolboxApiClient::LspServerRequest.new(language_id:, path_to_project:)
       )
     end
@@ -109,7 +109,7 @@ module Daytona
     #
     # @return [void]
     def stop
-      toolbox_api.lsp_stop(
+      toolbox_api.stop(
         DaytonaToolboxApiClient::LspServerRequest.new(language_id:, path_to_project:)
       )
     end

data/lib/daytona/object_storage.rb

@@ -110,8 +110,8 @@ module Daytona
           .glob(File.join(abs_path_str, '**', '*'))
           .select { |path| File.directory?(path) && Dir.empty?(path) }
           .each do |empty_dir|
-          rel_dir = Pathname.new(empty_dir).relative_path_from(Pathname.new(abs_path_str)).to_s
-          md5_hasher.update(rel_dir)
+            rel_dir = Pathname.new(empty_dir).relative_path_from(Pathname.new(abs_path_str)).to_s
+            md5_hasher.update(rel_dir)
         end
       end
 

data/lib/daytona/process.rb

@@ -222,26 +222,40 @@ module Daytona
       url.path = "/process/session/#{session_id}/command/#{command_id}/logs"
       url.query = 'follow=true'
 
-      WebSocket::Client::Simple.connect(
+      completion_queue = Queue.new
+
+      ws = 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 |ws|
-        ws.on(:message) do |message|
-          if message.type == :close
-            ws.close
-            next
-          else
-            stdout, stderr = Util.demux(message.data.to_s)
-
-            on_stdout.call(stdout) unless stdout.empty?
-            on_stderr.call(stderr) unless stderr.empty?
-          end
+      )
+
+      ws.on(:message) do |message|
+        if message.type == :close
+          ws.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(:close) do
+        completion_queue.push(:close)
+      end
+
+      ws.on(:error) do |e|
+        completion_queue.push(:error)
+        raise Sdk::Error, "WebSocket error: #{e.message}"
+      end
+
+      # Wait for completion
+      completion_queue.pop
     end
 
     #

data/lib/daytona/sandbox.rb

@@ -109,6 +109,9 @@ module Daytona
     # @return [Daytona::ComputerUse]
     attr_reader :computer_use
 
+    # @return [Daytona::CodeInterpreter]
+    attr_reader :code_interpreter
+
     # @params code_toolbox [Daytona::SandboxPythonCodeToolbox, Daytona::SandboxTsCodeToolbox]
     # @params config [Daytona::Config]
     # @params sandbox_api [DaytonaApiClient::SandboxApi]
@@ -127,6 +130,9 @@ module Daytona
       create_authenticated_client = lambda do
         client = DaytonaToolboxApiClient::ApiClient.new(toolbox_api_config)
         client.default_headers['Authorization'] = "Bearer #{config.api_key || config.jwt_token}"
+        client.default_headers['X-Daytona-Source'] = 'ruby-sdk'
+        client.default_headers['X-Daytona-SDK-Version'] = Sdk::VERSION
+        client.default_headers['X-Daytona-Organization-ID'] = config.organization_id if config.jwt_token
         client
       end
 
@@ -135,6 +141,8 @@ module Daytona
       git_api = DaytonaToolboxApiClient::GitApi.new(create_authenticated_client.call)
       lsp_api = DaytonaToolboxApiClient::LspApi.new(create_authenticated_client.call)
       computer_use_api = DaytonaToolboxApiClient::ComputerUseApi.new(create_authenticated_client.call)
+      interpreter_api = DaytonaToolboxApiClient::InterpreterApi.new(create_authenticated_client.call)
+      info_api = DaytonaToolboxApiClient::InfoApi.new(create_authenticated_client.call)
 
       @process = Process.new(
         sandbox_id: id,
@@ -145,7 +153,13 @@ module Daytona
       @fs = FileSystem.new(sandbox_id: id, toolbox_api: fs_api)
       @git = Git.new(sandbox_id: id, toolbox_api: git_api)
       @computer_use = ComputerUse.new(sandbox_id: id, toolbox_api: computer_use_api)
+      @code_interpreter = CodeInterpreter.new(
+        sandbox_id: id,
+        toolbox_api: interpreter_api,
+        get_preview_link: proc { |port| preview_url(port) }
+      )
       @lsp_api = lsp_api
+      @info_api = info_api
     end
 
     # Archives the sandbox, making it inactive and preserving its state. When sandboxes are
@@ -211,6 +225,33 @@ module Daytona
       refresh
     end
 
+    # Gets the user's home directory path for the logged in user inside the Sandbox.
+    #
+    # @return [String] The absolute path to the Sandbox user's home directory for the logged in user
+    #
+    # @example
+    #   user_home_dir = sandbox.get_user_home_dir
+    #   puts "Sandbox user home: #{user_home_dir}"
+    def get_user_home_dir
+      @info_api.get_user_home_dir.dir
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to get user home directory: #{e.message}"
+    end
+
+    # Gets the working directory path inside the Sandbox.
+    #
+    # @return [String] The absolute path to the Sandbox working directory. Uses the WORKDIR specified
+    #   in the Dockerfile if present, or falling back to the user's home directory if not.
+    #
+    # @example
+    #   work_dir = sandbox.get_work_dir
+    #   puts "Sandbox working directory: #{work_dir}"
+    def get_work_dir
+      @info_api.get_work_dir.dir
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to get working directory path: #{e.message}"
+    end
+
     # Sets labels for the Sandbox.
     #
     # @param labels [Hash<String, String>]
@@ -227,11 +268,54 @@ module Daytona
     # @return [DaytonaApiClient::PortPreviewUrl]
     def preview_url(port) = sandbox_api.get_port_preview_url(id, port)
 
+    # Creates a signed preview URL for the sandbox at the specified port.
+    #
+    # @param port [Integer] The port to open the preview link on
+    # @param expires_in_seconds [Integer, nil] The number of seconds the signed preview URL
+    #   will be valid for. Defaults to 60 seconds.
+    # @return [DaytonaApiClient::SignedPortPreviewUrl] The signed preview URL response object
+    #
+    # @example
+    #   signed_url = sandbox.create_signed_preview_url(3000, 120)
+    #   puts "Signed URL: #{signed_url.url}"
+    #   puts "Token: #{signed_url.token}"
+    def create_signed_preview_url(port, expires_in_seconds = nil)
+      sandbox_api.get_signed_port_preview_url(id, port, { expires_in_seconds: })
+    end
+
+    # Expires a signed preview URL for the sandbox at the specified port.
+    #
+    # @param port [Integer] The port to expire the signed preview URL on
+    # @param token [String] The token to expire
+    # @return [void]
+    #
+    # @example
+    #   sandbox.expire_signed_preview_url(3000, "token-value")
+    def expire_signed_preview_url(port, token)
+      sandbox_api.expire_signed_port_preview_url(id, port, token)
+    end
+
     # Refresh the Sandbox data from the API.
     #
     # @return [void]
     def refresh = process_response(sandbox_api.get_sandbox(id))
 
+    # Refreshes the sandbox activity to reset the timer for automated lifecycle management actions.
+    #
+    # This method updates the sandbox's last activity timestamp without changing its state.
+    # It is useful for keeping long-running sessions alive while there is still user activity.
+    #
+    # @return [void]
+    #
+    # @example
+    #   sandbox.refresh_activity
+    def refresh_activity
+      sandbox_api.update_last_activity(id)
+      nil
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to refresh sandbox activity: #{e.message}"
+    end
+
     # Revokes an SSH access token for the sandbox.
     #
     # @param token [String]
@@ -250,6 +334,25 @@ module Daytona
       ) { wait_for_states(operation: OPERATION_START, target_states: [DaytonaApiClient::SandboxState::STARTED]) }
     end
 
+    # Recovers the Sandbox from a recoverable error and waits for it to be ready.
+    #
+    # @param timeout [Numeric] Maximum wait time in seconds (defaults to 60 s).
+    # @return [void]
+    #
+    # @example
+    #   sandbox = daytona.get('my-sandbox-id')
+    #   sandbox.recover(timeout: 40)  # Wait up to 40 seconds
+    #   puts 'Sandbox recovered successfully'
+    def recover(timeout = DEFAULT_TIMEOUT)
+      with_timeout(
+        timeout:,
+        message: "Sandbox #{id} failed to recover within the #{timeout} seconds timeout period",
+        setup: proc { process_response(sandbox_api.recover_sandbox(id)) }
+      ) { wait_for_states(operation: OPERATION_START, target_states: [DaytonaApiClient::SandboxState::STARTED]) }
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to recover sandbox: #{e.message}"
+    end
+
     # Stops the Sandbox and waits for it to be stopped.
     #
     # @param timeout [Numeric] Maximum wait time in seconds (defaults to 60 s).
@@ -297,6 +400,17 @@ module Daytona
       wait_for_states(operation: OPERATION_START, target_states: [DaytonaApiClient::SandboxState::STARTED])
     end
 
+    # Waits for the Sandbox to reach the 'stopped' state. Polls the Sandbox status until it
+    # reaches the 'stopped' state or encounters an error.
+    # Treats destroyed as stopped to cover ephemeral sandboxes that are automatically deleted after stopping.
+    #
+    # @param timeout [Numeric] Maximum wait time in seconds (defaults to 60 s).
+    # @return [void]
+    def wait_for_sandbox_stop(_timeout = DEFAULT_TIMEOUT)
+      wait_for_states(operation: OPERATION_STOP, target_states: [DaytonaApiClient::SandboxState::STOPPED,
+                                                                 DaytonaApiClient::SandboxState::DESTROYED])
+    end
+
     private
 
     # Build toolbox API configuration with dynamic base URL from preview link
@@ -304,7 +418,7 @@ module Daytona
     def build_toolbox_api_config
       DaytonaToolboxApiClient::Configuration.new.configure do |cfg|
         # Get the proxy toolbox URL and append sandbox ID
-        proxy_toolbox_url = @get_proxy_toolbox_url.call
+        proxy_toolbox_url = @get_proxy_toolbox_url.call(id, target)
         proxy_toolbox_url += '/' unless proxy_toolbox_url.end_with?('/')
         full_url = "#{proxy_toolbox_url}#{id}"
         uri = URI(full_url)

data/lib/daytona/sdk/version.rb

@@ -2,6 +2,6 @@
 
 module Daytona
   module Sdk
-    VERSION = '0.126.0.pre.alpha.5'
+    VERSION = '0.134.0.alpha.1'
   end
 end

data/lib/daytona/sdk.rb

@@ -2,8 +2,6 @@
 
 require 'logger'
 
-require 'dotenv'
-Dotenv.load('.env.local', '.env')
 require 'daytona_api_client'
 require 'daytona_toolbox_api_client'
 require 'toml'
@@ -12,6 +10,7 @@ require 'websocket-client-simple'
 require_relative 'sdk/version'
 require_relative 'config'
 require_relative 'common/charts'
+require_relative 'common/code_interpreter'
 require_relative 'common/code_language'
 require_relative 'common/daytona'
 require_relative 'common/file_system'
@@ -22,9 +21,11 @@ require_relative 'common/pty'
 require_relative 'common/resources'
 require_relative 'common/response'
 require_relative 'common/snapshot'
+require_relative 'code_interpreter'
 require_relative 'computer_use'
 require_relative 'code_toolbox/sandbox_python_code_toolbox'
 require_relative 'code_toolbox/sandbox_ts_code_toolbox'
+require_relative 'code_toolbox/sandbox_js_code_toolbox'
 require_relative 'daytona'
 require_relative 'file_system'
 require_relative 'git'
@@ -40,6 +41,7 @@ require_relative 'process'
 module Daytona
   module Sdk
     class Error < StandardError; end
+    class TimeoutError < Error; end
 
     def self.logger = @logger ||= Logger.new($stdout, level: Logger::INFO)
   end

data/lib/daytona/snapshot_service.rb

@@ -8,9 +8,11 @@ module Daytona
 
     # @param snapshots_api [DaytonaApiClient::SnapshotsApi] The snapshots API client
     # @param object_storage_api [DaytonaApiClient::ObjectStorageApi] The object storage API client
-    def initialize(snapshots_api:, object_storage_api:)
+    # @param default_region_id [String, nil] Default region ID for snapshot creation
+    def initialize(snapshots_api:, object_storage_api:, default_region_id: nil)
       @snapshots_api = snapshots_api
       @object_storage_api = object_storage_api
+      @default_region_id = default_region_id
     end
 
     # List all Snapshots.
@@ -97,9 +99,12 @@ module Daytona
         create_snapshot_req.disk = params.resources.disk
       end
 
+      create_snapshot_req.region_id = params.region_id || @default_region_id
+
       snapshot = snapshots_api.create_snapshot(create_snapshot_req)
 
-      snapshot = stream_logs(snapshot, on_logs:) if on_logs
+      # Always wait for snapshot to be ready, regardless of on_logs
+      snapshot = wait_for_snapshot(snapshot, on_logs:)
 
       if [DaytonaApiClient::SnapshotState::ERROR, DaytonaApiClient::SnapshotState::BUILD_FAILED].include?(snapshot.state)
         raise Sdk::Error, "Failed to create snapshot #{snapshot.name}, reason: #{snapshot.error_reason}"
@@ -148,10 +153,16 @@ module Daytona
     # @return [DaytonaApiClient::ObjectStorageApi, nil] The object storage API client
     attr_reader :object_storage_api
 
+    # @return [String, nil] Default region ID for snapshot creation
+    attr_reader :default_region_id
+
+    # Wait for snapshot to reach a terminal state (ACTIVE, ERROR, or BUILD_FAILED)
+    # Optionally streams logs if on_logs callback is provided
+    #
     # @param snapshot [DaytonaApiClient::SnapshotDto]
-    # @param on_logs [Proc]
+    # @param on_logs [Proc, nil]
     # @return [DaytonaApiClient::SnapshotDto]
-    def stream_logs(snapshot, on_logs:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def wait_for_snapshot(snapshot, on_logs:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       terminal_states = [
         DaytonaApiClient::SnapshotState::ACTIVE,
         DaytonaApiClient::SnapshotState::ERROR,
@@ -160,13 +171,25 @@ module Daytona
 
       thread = nil
       previous_state = snapshot.state
+
+      # Log initial state if callback provided
+      on_logs&.call("Creating snapshot #{snapshot.name} (#{snapshot.state})")
+
       until terminal_states.include?(snapshot.state)
         Sdk.logger.debug("Waiting for snapshot to be created: #{snapshot.state}")
-        if thread.nil? && snapshot.state != DaytonaApiClient::SnapshotState::BUILD_PENDING
+
+        # Start log streaming thread if callback provided and snapshot is building
+        if on_logs && thread.nil? && snapshot.state != DaytonaApiClient::SnapshotState::PENDING
           thread = start_log_streaming(snapshot, on_logs:)
         end
 
-        on_logs.call("Creating snapshot #{snapshot.name} (#{snapshot.state})") if previous_state != snapshot.state
+        # Log state changes if callback provided
+        if on_logs && previous_state != snapshot.state
+          if snapshot.state != DaytonaApiClient::SnapshotState::PENDING && thread.nil?
+            thread = start_log_streaming(snapshot, on_logs:)
+          end
+          on_logs.call("Creating snapshot #{snapshot.name} (#{snapshot.state})")
+        end
 
         sleep(1)
         previous_state = snapshot.state
@@ -175,7 +198,7 @@ module Daytona
 
       thread&.join
 
-      if snapshot.state == DaytonaApiClient::SnapshotState::ACTIVE
+      if on_logs && snapshot.state == DaytonaApiClient::SnapshotState::ACTIVE
         on_logs.call("Created snapshot #{snapshot.name} (#{snapshot.state})")
       end
 
@@ -186,9 +209,9 @@ module Daytona
     # @param on_logs [Proc]
     # @return [Thread]
     def start_log_streaming(snapshot, on_logs:)
-      uri = URI.parse(snapshots_api.api_client.config.base_url)
-      uri.path = "/api/snapshots/#{snapshot.id}/build-logs"
-      uri.query = 'follow=true'
+      # Get build logs URL from API
+      build_logs_response = snapshots_api.get_snapshot_build_logs_url(snapshot.id)
+      uri = URI.parse("#{build_logs_response.url}?follow=true")
 
       headers = {}
       snapshots_api.api_client.update_params_for_auth!(headers, nil, ['bearer'])

data/lib/daytona.rb

@@ -5,4 +5,3 @@
 #   require 'daytona'
 
 require_relative 'daytona/sdk'
-

data/project.json

@@ -24,7 +24,7 @@
       "executor": "nx:run-commands",
       "options": {
         "cwd": "{projectRoot}",
-        "command": "if [ -n \"$RUBYGEMS_PKG_VERSION\" ] || [ -n \"$DEFAULT_PACKAGE_VERSION\" ]; then VER=${RUBYGEMS_PKG_VERSION:-$DEFAULT_PACKAGE_VERSION}; sed -i \"s/VERSION = '[^']*'/VERSION = '$VER'/\" lib/daytona/sdk/version.rb && echo \"Changed version to $VER\"; else echo \"Using version from version.rb\"; fi"
+        "command": "if [ -n \"$RUBYGEMS_PKG_VERSION\" ]; then sed -i \"s/VERSION = '[^']*'/VERSION = '$RUBYGEMS_PKG_VERSION'/\" lib/daytona/sdk/version.rb && echo \"Changed version to $RUBYGEMS_PKG_VERSION\"; else echo \"Using version from version.rb\"; fi"
       }
     },
     "lint": {
@@ -49,11 +49,22 @@
         "parallel": false
       }
     },
+    "docs": {
+      "executor": "nx:run-commands",
+      "options": {
+        "cwd": "{projectRoot}",
+        "command": "bash -O extglob -c 'rm -rf ../../apps/docs/src/content/docs/en/ruby-sdk/!(index.mdx)' && bundle exec ruby scripts/generate-docs.rb"
+      }
+    },
     "publish": {
       "executor": "nx:run-commands",
       "options": {
         "cwd": "{projectRoot}",
-        "command": "gem push daytona-*.gem --key rubygems --host https://rubygems.org"
+        "commands": [
+          "mkdir -p ~/.gem && echo \":rubygems: $RUBYGEMS_API_KEY\" > ~/.gem/credentials && chmod 0600 ~/.gem/credentials",
+          "gem push daytona-*.gem --key rubygems --host https://rubygems.org"
+        ],
+        "parallel": false
       },
       "dependsOn": [
         {