daytona 0.173.0 → 0.176.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83d12903b0910a3d69cd7042e642fe9cc748ee97ec605ae669e1537f433cbe32
-  data.tar.gz: af534e94adbe126f60c62b8e27b1a7caa1e67230ab10e055e73c4092e13b2684
+  metadata.gz: 7535ad9431345bb3c463fe8bfbeb3e0f296fb5aefd6e8a2208376aa71893fb77
+  data.tar.gz: 74f70acd3c6cb193bc8d471e437345ea6ed68bf65d6b8735fc1d0826306c8a03
 SHA512:
-  metadata.gz: b45b939dacd1b20b5864a90f0fdc02dcd2c4f34873b81148bd19de59c748d4b0f959b01136b3d1ad580b4f15fff7fef710c967f68cc66d5ce0dc9370fdbafbcd
-  data.tar.gz: 69cc63a19e83148b9f36206cf6bc4b59de091105bba7ed4709d815743b5689b29ef9e9c85da45ed332b58039e19a89b7730070f5f3d2b44c3c8563e07926570a
+  metadata.gz: e80742f74b83913585be67091015a0b39c6bbd4acb1c7d0743e73bde841940fe9cdce49d4a466cead18bd54b550888ba873925b80cb034995ae4dc0f7bb986d3
+  data.tar.gz: b123fc8cfd3c45d122f750777194f493982256550bb93525c5cb981b795d0aaa8e2f5d707ce0e00bb4ca2c76fabbfcc464bb3370787c6243e184ea1c21fbf61e

data/.rubocop.yml

@@ -14,3 +14,9 @@ Style/Documentation:
 
 Style/AccessorGrouping:
   EnforcedStyle: separated
+
+# RSpec describe / context blocks naturally span the whole file; the
+# stock 25-line cap forces noise instead of catching real complexity.
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'

data/lib/daytona/computer_use.rb

@@ -409,6 +409,139 @@ module Daytona
       attr_reader :otel_state
     end
 
+    # Accessibility operations for computer use functionality.
+    class Accessibility
+      include Instrumentation
+
+      # @return [String] The ID of the sandbox
+      attr_reader :sandbox_id
+
+      # @return [DaytonaToolboxApiClient::ComputerUseApi] API client for sandbox operations
+      attr_reader :toolbox_api
+
+      # @param sandbox_id [String] The ID of the sandbox
+      # @param toolbox_api [DaytonaToolboxApiClient::ComputerUseApi] API client for sandbox operations
+      # @param otel_state [Daytona::OtelState, nil]
+      def initialize(sandbox_id:, toolbox_api:, otel_state: nil)
+        @sandbox_id = sandbox_id
+        @toolbox_api = toolbox_api
+        @otel_state = otel_state
+      end
+
+      # Fetches the AT-SPI accessibility tree.
+      #
+      # @param scope [String, nil] Tree scope to inspect: "focused", "pid", or "all"
+      # @param pid [Integer, nil] Process ID when scope is "pid"
+      # @param max_depth [Integer, nil] Maximum depth to descend; 0 returns only the root
+      # @return [DaytonaToolboxApiClient::AccessibilityTreeResponse] Accessibility tree response
+      # @raise [Daytona::Sdk::Error] If the operation fails
+      #
+      # @example
+      #   tree = sandbox.computer_use.accessibility.get_tree(scope: "all", max_depth: 3)
+      #   puts tree.root.name
+      def get_tree(scope: nil, pid: nil, max_depth: nil)
+        opts = {}
+        opts[:scope] = scope unless scope.nil?
+        opts[:pid] = pid unless pid.nil?
+        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}"
+      end
+
+      # Finds AT-SPI accessibility nodes matching the provided filters.
+      #
+      # @param scope [String, nil] Search scope: "focused", "pid", or "all"
+      # @param pid [Integer, nil] Process ID when scope is "pid"
+      # @param role [String, nil] Accessibility role to match, such as "button"
+      # @param name [String, nil] Accessible name to match
+      # @param name_match [String, nil] Name match mode, such as "exact" or "substring"
+      # @param states [Array<String>, nil] Required accessibility states
+      # @param limit [Integer, nil] Maximum number of matches
+      # @return [DaytonaToolboxApiClient::AccessibilityNodesResponse] Matching accessibility nodes
+      # @raise [Daytona::Sdk::Error] If the operation fails
+      #
+      # @example
+      #   buttons = sandbox.computer_use.accessibility.find_nodes(
+      #     scope: "all",
+      #     role: "button",
+      #     name: "Submit",
+      #     name_match: "substring"
+      #   )
+      #   puts buttons.matches.length
+      def find_nodes(scope: nil, pid: nil, role: nil, name: nil, name_match: nil, states: nil, limit: nil)
+        attrs = {}
+        attrs[:scope] = scope unless scope.nil?
+        attrs[:pid] = pid unless pid.nil?
+        attrs[:role] = role unless role.nil?
+        attrs[:name] = name unless name.nil?
+        attrs[:name_match] = name_match unless name_match.nil?
+        attrs[:states] = states unless states.nil?
+        attrs[:limit] = limit unless limit.nil?
+
+        request = DaytonaToolboxApiClient::FindAccessibilityNodesRequest.new(attrs)
+        toolbox_api.find_accessibility_nodes(request)
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to find accessibility nodes: #{e.message}"
+      end
+
+      # Focuses an AT-SPI accessibility node.
+      #
+      # @param id [String] Accessibility node ID returned by get_tree or find_nodes
+      # @raise [Daytona::Sdk::Error] If the operation fails
+      #
+      # @example
+      #   sandbox.computer_use.accessibility.focus_node(id: node.id)
+      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}"
+      end
+
+      # Invokes an AT-SPI accessibility node action.
+      #
+      # @param id [String] Accessibility node ID returned by get_tree or find_nodes
+      # @param action [String, nil] Action name to invoke, or nil for the primary action
+      # @raise [Daytona::Sdk::Error] If the operation fails
+      #
+      # @example
+      #   sandbox.computer_use.accessibility.invoke_node(id: node.id, action: "click")
+      def invoke_node(id:, action: nil)
+        attrs = { id: }
+        attrs[:action] = action unless action.nil?
+
+        request = DaytonaToolboxApiClient::AccessibilityInvokeRequest.new(attrs)
+        toolbox_api.invoke_accessibility_node(request)
+      rescue StandardError => e
+        raise Sdk::Error, "Failed to invoke accessibility node: #{e.message}"
+      end
+
+      # Sets an AT-SPI accessibility node value.
+      #
+      # @param id [String] Accessibility node ID returned by get_tree or find_nodes
+      # @param value [String] Value to write to the node
+      # @raise [Daytona::Sdk::Error] If the operation fails
+      #
+      # @example
+      #   sandbox.computer_use.accessibility.set_node_value(id: node.id, value: "hello")
+      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}"
+      end
+
+      instrument :get_tree, :find_nodes, :focus_node, :invoke_node, :set_node_value,
+                 component: 'Accessibility'
+
+      private
+
+      # @return [Daytona::OtelState, nil]
+      attr_reader :otel_state
+    end
+
     # Region coordinates for screenshot operations.
     class ScreenshotRegion
       # @return [Integer] X coordinate of the region
@@ -652,6 +785,9 @@ module Daytona
     # @return [Recording] Screen recording operations interface
     attr_reader :recording
 
+    # @return [Accessibility] Accessibility operations interface
+    attr_reader :accessibility
+
     # Initialize a new ComputerUse instance.
     #
     # @param sandbox_id [String] The ID of the sandbox
@@ -666,6 +802,7 @@ module Daytona
       @screenshot = Screenshot.new(sandbox_id:, toolbox_api:, otel_state:)
       @display = Display.new(sandbox_id:, toolbox_api:, otel_state:)
       @recording = Recording.new(sandbox_id:, toolbox_api:, otel_state:)
+      @accessibility = Accessibility.new(sandbox_id:, toolbox_api:, otel_state:)
     end
 
     # Starts all computer use processes (Xvfb, xfce4, x11vnc, novnc).

data/lib/daytona/file_system.rb

@@ -162,10 +162,17 @@ module Daytona
     #   based on the sandbox working directory.
     # @param timeout [Integer] Timeout for the download operation in seconds. 0 means no timeout.
     #   Default is 30 minutes.
+    # @param on_progress [Proc, nil] Optional callback invoked with a Daytona::DownloadProgress
+    #   struct containing bytes_received (Integer) and total_bytes (Integer or nil).
+    # @param cancel_event [#set?, nil] Optional cancellation token (anything responding to +set?+;
+    #   the standard library's +Concurrent::Event+ or a small ad-hoc object both work). When set
+    #   during streaming, the next chunk raises Daytona::Sdk::Error and the underlying HTTP
+    #   connection is torn down.
     # @yield [chunk] Yields each chunk of file content as it arrives
     # @yieldparam chunk [String] A binary string chunk of file content
     # @return [Enumerator, nil] An Enumerator yielding chunks if no block given, nil otherwise
-    # @raise [Daytona::Sdk::Error] If the file does not exist or the operation fails
+    # @raise [Daytona::Sdk::Error] If the file does not exist, the operation fails, or
+    #   +cancel_event+ is set during streaming
     #
     # @example Stream to a local file without loading into memory
     #   File.open("local_copy.bin", "wb") do |f|
@@ -175,11 +182,12 @@ module Daytona
     # @example Collect chunks with an Enumerator
     #   content = sandbox.fs.download_file_stream("workspace/data.json").reduce(:+)
     #   puts content
-    def download_file_stream(remote_path, timeout: 30 * 60, &)
-      return enum_for(__method__, remote_path, timeout:) unless block_given?
+    def download_file_stream(remote_path, timeout: 30 * 60, on_progress: nil, cancel_event: nil, &)
+      return enum_for(__method__, remote_path, timeout:, on_progress:, cancel_event:) unless block_given?
 
       FileTransfer.stream_download(api_client: toolbox_api.api_client, remote_path: remote_path,
-                                   timeout: timeout, &)
+                                   timeout: timeout, on_progress: on_progress,
+                                   cancel_event: cancel_event, &)
       nil
     rescue StandardError => e
       raise Sdk::Error, "Failed to download file: #{e.message}"
@@ -225,6 +233,36 @@ module Daytona
       raise Sdk::Error, "Failed to upload file: #{e.message}"
     end
 
+    # Streams +source+ to the Sandbox without buffering its contents in memory, with
+    # optional progress reporting.
+    #
+    # @param source [String, IO] A local file path or any IO-like object responding to
+    #   +read(n)+. Strings that don't reference an existing file are uploaded as their
+    #   raw bytes (still streamed, just from memory).
+    # @param remote_path [String] Destination path in the Sandbox.
+    # @param timeout [Integer] Timeout in seconds. 0 means no timeout. Default 30 minutes.
+    # @param on_progress [Proc, nil] Optional callback invoked with a
+    #   +Daytona::UploadProgress+ struct as libcurl reports bytes actually uploaded.
+    # @param cancel_event [#set?, nil] Optional cancellation token. When set while
+    #   staging a non-file source or during the libcurl upload, the operation raises
+    #   Daytona::Sdk::Error and the in-progress upload is aborted (no destination file
+    #   is left on the sandbox thanks to the daemon's atomic-rename behaviour).
+    # @return [void]
+    # @raise [Daytona::Sdk::Error] If the operation fails or +cancel_event+ is set.
+    #
+    # @example
+    #   File.open("large.bin", "rb") do |f|
+    #     sandbox.fs.upload_file_stream(f, "tmp/large.bin",
+    #       on_progress: ->(p) { puts "#{p.bytes_sent} bytes sent" })
+    #   end
+    def upload_file_stream(source, remote_path, timeout: 30 * 60, on_progress: nil, cancel_event: nil)
+      FileTransfer.stream_upload(api_client: toolbox_api.api_client, remote_path: remote_path,
+                                 source: source, timeout: timeout, on_progress: on_progress,
+                                 cancel_event: cancel_event)
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to upload file: #{e.message}"
+    end
+
     # Uploads multiple files to the Sandbox. If files already exist at the destination paths,
     # they will be overwritten.
     #

data/lib/daytona/file_transfer.rb

@@ -4,11 +4,20 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'stringio'
+require 'tempfile'
 require 'typhoeus'
 
 module Daytona
+  # Progress information for a streaming download.
+  DownloadProgress = Struct.new(:bytes_received, :total_bytes, keyword_init: true)
+
+  # Progress information for a streaming upload.
+  UploadProgress = Struct.new(:bytes_sent, keyword_init: true)
+
   class MultipartDownloadStreamParser
     attr_reader :error_message
+    attr_reader :part_total_bytes
     attr_writer :boundary_token
 
     def initialize(&on_file_chunk)
@@ -17,6 +26,7 @@ module Daytona
       @buffer = String.new.b
       @state = :preamble
       @part_name = nil
+      @part_total_bytes = nil
       @error_buffer = String.new.b
     end
 
@@ -62,14 +72,14 @@ module Daytona
     end
 
     def consume_headers?
-      separator = "\r\n\r\n".b
-      index = @buffer.index(separator)
+      index = @buffer.index("\r\n\r\n".b)
       return false unless index
 
       headers = @buffer.byteslice(0, index)
-      @buffer = remaining_bytes(index + separator.bytesize)
-      @part_name = headers[/Content-Disposition:\s*[^\r\n]*\bname="([^"]+)"/i, 1]
-      raise Sdk::Error, 'Invalid multipart response' if @part_name.nil?
+      @buffer = remaining_bytes(index + 4)
+      @part_name = headers[/Content-Disposition:\s*[^\r\n]*\bname="([^"]+)"/i, 1] ||
+                   raise(Sdk::Error, 'Invalid multipart response')
+      @part_total_bytes = headers[/Content-Length:\s*(\d+)/i, 1]&.to_i
 
       @state = :body
       true
@@ -124,16 +134,11 @@ module Daytona
       false
     end
 
-    def remaining_bytes(offset)
-      @buffer.byteslice(offset, @buffer.bytesize - offset) || String.new.b
-    end
-
-    def boundary
-      "--#{@boundary_token}".b
-    end
+    def remaining_bytes(offset) = @buffer.byteslice(offset, @buffer.bytesize - offset) || String.new.b
+    def boundary = "--#{@boundary_token}".b
   end
 
-  module FileTransfer
+  module FileTransfer # rubocop:disable Metrics/ModuleLength
     def self.extract_multipart_boundary(content_type)
       match = content_type&.match(/boundary=(?:"([^"]+)"|([^;]+))/i)
       return unless match
@@ -141,9 +146,31 @@ module Daytona
       match.captures.compact.first
     end
 
-    def self.stream_download(api_client:, remote_path:, timeout:, &) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def self.assign_download_boundary(parser, content_type)
+      boundary = extract_multipart_boundary(content_type)
+      raise Sdk::Error, 'Missing multipart boundary in download response' unless boundary
+
+      parser.boundary_token = boundary
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def self.stream_download(api_client:, remote_path:, timeout:, on_progress: nil, cancel_event: nil, &block)
       config = api_client.config
-      parser = MultipartDownloadStreamParser.new(&)
+      bytes_received = 0
+      parser = nil
+      wrapped_block = proc do |chunk|
+        raise Sdk::Error, "Download cancelled: #{remote_path}" if cancel_event&.set?
+
+        if on_progress
+          bytes_received += chunk.bytesize
+          on_progress.call(DownloadProgress.new(
+                             bytes_received: bytes_received,
+                             total_bytes: parser&.part_total_bytes
+                           ))
+        end
+        block.call(chunk)
+      end
+      parser = MultipartDownloadStreamParser.new(&wrapped_block)
       response = nil
 
       request = Typhoeus::Request.new(
@@ -160,13 +187,15 @@ module Daytona
       )
 
       request.on_headers do |stream_response|
-        boundary = extract_multipart_boundary(stream_response.headers['Content-Type'])
-        raise Sdk::Error, 'Missing multipart boundary in download response' unless boundary
-
-        parser.boundary_token = boundary
+        assign_download_boundary(parser, stream_response.headers['Content-Type'])
       end
 
+      # Returning +:abort+ from the on_body callback tells libcurl to tear down the
+      # connection immediately, which is how cancellation actually severs the
+      # transfer rather than just stopping our own bookkeeping.
       request.on_body do |chunk|
+        next :abort if cancel_event&.set?
+
         parser << chunk
       end
 
@@ -177,8 +206,143 @@ module Daytona
 
       request.run
 
+      raise Sdk::Error, "Download cancelled: #{remote_path}" if cancel_event&.set?
       raise Sdk::Error, parser.error_message if parser.error_message
       raise Sdk::Error, "HTTP #{response.code}" if response && !response.success?
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    # Uploads +source+ to /files/bulk-upload via Typhoeus (libcurl), which streams the
+    # request body straight from disk without buffering it in memory. Local file paths
+    # are uploaded directly; in-memory IOs/bytes are first drained to a tempfile so we
+    # have a stable file handle for libcurl.
+    #
+    # The daemon owns atomicity (writes to a sibling tempfile then renames), so a
+    # client-side abort just leaves no destination file at all.
+    #
+    # @param api_client The OpenAPI-generated toolbox API client (auth/base-url only).
+    # @param remote_path [String] Destination path in the sandbox.
+    # @param source [String, IO] Local file path or any IO-like object responding to +read(n)+.
+    # @param timeout [Integer] Typhoeus timeout in seconds (0 disables).
+    # @param on_progress [Proc, nil] Optional callback invoked with +Daytona::UploadProgress+
+    #   as libcurl reports real network upload progress.
+    # @param cancel_event [#set?, nil] Optional cancellation token. Checked while staging
+    #   non-file sources and during the libcurl transfer itself.
+    # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+    def self.stream_upload(api_client:, remote_path:, source:, timeout:, on_progress: nil, cancel_event: nil)
+      with_upload_file(source, cancel_event, remote_path) do |upload_path|
+        config = api_client.config
+        progress_callback = upload_progress_callback(on_progress, cancel_event)
+        response = with_open_upload_file(upload_path) do |file|
+          upload_request(
+            api_client: api_client,
+            config: config,
+            remote_path: remote_path,
+            file: file,
+            timeout: timeout,
+            progress_callback: progress_callback
+          ).run
+        end
+        raise_upload_error(response, cancel_event, remote_path)
+      end
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
+
+    # Yields a path on disk that holds the source's bytes, ready for libcurl to stream.
+    # Local files are passed through unchanged; everything else is drained into a
+    # tempfile that gets unlinked when we return.
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def self.with_upload_file(source, cancel_event, remote_path)
+      raise Sdk::Error, "Upload cancelled: #{remote_path}" if cancel_event&.set?
+
+      return yield(source) if source.is_a?(String) && File.exist?(source)
+
+      tmp = Tempfile.new(['daytona-upload-', File.extname(remote_path).to_s])
+      tmp.binmode
+      begin
+        drain_source_to(source, tmp, cancel_event, remote_path)
+        tmp.flush
+        tmp.close
+        yield(tmp.path)
+      ensure
+        tmp.close unless tmp.closed?
+        begin
+          tmp.unlink
+        rescue StandardError
+          # tempfile already gone, nothing to do
+        end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def self.drain_source_to(source, sink, cancel_event, remote_path)
+      io, owns_io = open_drain_source(source)
+      begin
+        while (chunk = io.read(64 * 1024))
+          break if chunk.empty?
+          raise Sdk::Error, "Upload cancelled: #{remote_path}" if cancel_event&.set?
+
+          sink.write(chunk)
+        end
+      ensure
+        io.close if owns_io && io.respond_to?(:close)
+      end
+    end
+
+    def self.with_open_upload_file(upload_path)
+      file = File.open(upload_path, 'rb')
+      yield(file)
+    ensure
+      file.close if file && !file.closed?
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+    def self.upload_request(api_client:, config:, remote_path:, file:, timeout:, progress_callback:)
+      Typhoeus::Request.new(
+        "#{config.base_url}/files/bulk-upload",
+        method: :post,
+        headers: api_client.default_headers.dup.tap { |h| h.delete('Content-Type') },
+        body: {
+          'files[0].path' => remote_path,
+          'files[0].file' => file
+        },
+        timeout: timeout,
+        ssl_verifypeer: config.verify_ssl,
+        ssl_verifyhost: config.verify_ssl_host ? 2 : 0,
+        noprogress: false,
+        progressfunction: progress_callback,
+        xferinfofunction: progress_callback
+      )
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
+
+    def self.upload_progress_callback(on_progress, cancel_event)
+      last_bytes_sent = -1
+
+      proc do |_clientp, _dltotal, _dlnow, _ultotal, ulnow|
+        next 1 if cancel_event&.set?
+
+        bytes_sent = ulnow.to_i
+        if on_progress && bytes_sent > last_bytes_sent
+          last_bytes_sent = bytes_sent
+          on_progress.call(UploadProgress.new(bytes_sent: bytes_sent))
+        end
+
+        0
+      end
+    end
+
+    def self.raise_upload_error(response, _cancel_event, remote_path)
+      raise Sdk::Error, "Upload timed out: #{remote_path}" if response.timed_out?
+      raise Sdk::Error, "Upload cancelled: #{remote_path}" if response.return_code == :aborted_by_callback
+      raise Sdk::Error, "HTTP #{response.code}: #{response.body}" unless response.success?
+    end
+
+    def self.open_drain_source(source)
+      return [source, false] if source.respond_to?(:read)
+      return [StringIO.new(source.b), true] if source.is_a?(String)
+
+      raise Sdk::Error, "Unsupported upload source: #{source.class}"
+    end
   end
 end

data/lib/daytona/git.rb

@@ -45,6 +45,8 @@ module Daytona
     #   ])
     def add(path, files)
       toolbox_api.add_files(DaytonaToolboxApiClient::GitAddRequest.new(path:, files:))
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to add files')
     rescue StandardError => e
       raise Sdk::Error, "Failed to add files: #{e.message}"
     end
@@ -61,6 +63,8 @@ module Daytona
     #   puts "Branches: #{response.branches}"
     def branches(path)
       toolbox_api.list_branches(path)
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to list branches')
     rescue StandardError => e
       raise Sdk::Error, "Failed to list branches: #{e.message}"
     end
@@ -114,6 +118,8 @@ module Daytona
           commit_id: commit_id
         )
       )
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to clone repository')
     rescue StandardError => e
       raise Sdk::Error, "Failed to clone repository: #{e.message}"
     end
@@ -146,6 +152,8 @@ module Daytona
         DaytonaToolboxApiClient::GitCommitRequest.new(path:, message:, author:, email:, allow_empty:)
       )
       GitCommitResponse.new(sha: response._hash)
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to commit changes')
     rescue StandardError => e
       raise Sdk::Error, "Failed to commit changes: #{e.message}"
     end
@@ -175,6 +183,8 @@ module Daytona
       toolbox_api.push_changes(
         DaytonaToolboxApiClient::GitRepoRequest.new(path:, username:, password:)
       )
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to push changes')
     rescue StandardError => e
       raise Sdk::Error, "Failed to push changes: #{e.message}"
     end
@@ -204,6 +214,8 @@ module Daytona
       toolbox_api.pull_changes(
         DaytonaToolboxApiClient::GitRepoRequest.new(path:, username:, password:)
       )
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to pull changes')
     rescue StandardError => e
       raise Sdk::Error, "Failed to pull changes: #{e.message}"
     end
@@ -222,6 +234,8 @@ module Daytona
     #   puts "Commits behind: #{status.behind}"
     def status(path)
       toolbox_api.get_status(path)
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to get status')
     rescue StandardError => e
       raise Sdk::Error, "Failed to get status: #{e.message}"
     end
@@ -241,6 +255,8 @@ module Daytona
       toolbox_api.checkout_branch(
         DaytonaToolboxApiClient::GitCheckoutRequest.new(path:, branch:)
       )
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to checkout branch')
     rescue StandardError => e
       raise Sdk::Error, "Failed to checkout branch: #{e.message}"
     end
@@ -261,6 +277,8 @@ module Daytona
       toolbox_api.create_branch(
         DaytonaToolboxApiClient::GitBranchRequest.new(path:, name:)
       )
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to create branch')
     rescue StandardError => e
       raise Sdk::Error, "Failed to create branch: #{e.message}"
     end
@@ -280,6 +298,8 @@ module Daytona
       toolbox_api.delete_branch(
         DaytonaToolboxApiClient::GitDeleteBranchRequest.new(path:, name:)
       )
+    rescue DaytonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to delete branch')
     rescue StandardError => e
       raise Sdk::Error, "Failed to delete branch: #{e.message}"
     end
@@ -292,5 +312,19 @@ module Daytona
 
     # @return [Daytona::OtelState, nil]
     attr_reader :otel_state
+
+    def map_api_error(api_error, prefix)
+      msg = "#{prefix}: #{api_error.message}"
+      case api_error.code
+      when 400 then Sdk::ValidationError.new(msg)
+      when 401 then Sdk::AuthenticationError.new(msg)
+      when 403 then Sdk::ForbiddenError.new(msg)
+      when 404 then Sdk::NotFoundError.new(msg)
+      when 409 then Sdk::ConflictError.new(msg)
+      when 429 then Sdk::RateLimitError.new(msg)
+      when 500..599 then Sdk::ServerError.new(msg)
+      else Sdk::Error.new(msg)
+      end
+    end
   end
 end

data/lib/daytona/sdk/version.rb

@@ -5,6 +5,6 @@
 
 module Daytona
   module Sdk
-    VERSION = '0.173.0'
+    VERSION = '0.176.0'
   end
 end

data/lib/daytona/sdk.rb

@@ -43,6 +43,13 @@ module Daytona
   module Sdk
     class Error < StandardError; end
     class TimeoutError < Error; end
+    class AuthenticationError < Error; end
+    class ForbiddenError < Error; end
+    class NotFoundError < Error; end
+    class ConflictError < Error; end
+    class ValidationError < Error; end
+    class RateLimitError < Error; end
+    class ServerError < Error; end
 
     def self.logger = @logger ||= Logger.new($stdout, level: Logger::INFO)
   end

data/scripts/generate-docs.rb

@@ -23,6 +23,7 @@ CLASSES_TO_DOCUMENT = [
   ['volume.rb', 'volume.mdx', 'Daytona::Volume'],
   ['object_storage.rb', 'object-storage.mdx', 'Daytona::ObjectStorage'],
   ['computer_use.rb', 'computer-use.mdx', 'Daytona::ComputerUse'],
+  ['computer_use.rb', 'computer-use.mdx', 'Daytona::ComputerUse::Accessibility'],
   ['snapshot_service.rb', 'snapshot.mdx', 'Daytona::SnapshotService'],
   ['volume_service.rb', 'volume-service.mdx', 'Daytona::VolumeService'],
   ['common/charts.rb', 'charts.mdx', 'Daytona::Chart'],
@@ -371,7 +372,11 @@ def generate_docs_for_class(file_path, output_filename, class_name)
 
     # Write to output file
     output_path = File.join(DOCS_OUTPUT_DIR, output_filename)
-    File.write(output_path, final_content)
+    if File.exist?(output_path)
+      File.write(output_path, "#{File.read(output_path).rstrip}\n\n#{markdown_content}")
+    else
+      File.write(output_path, final_content)
+    end
 
     puts "✅ Generated: #{output_filename}"
   rescue StandardError => e

metadata

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