daytona 0.223.0.alpha.2 → 0.223.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c61adcc242e709cff5697fa6001636c5baf5ece820d68bb158c449625f84af4
-  data.tar.gz: 652be235803821f815940b2230196ff4f57db02b54061445b58b0c5d920273b9
+  metadata.gz: 63db7dba8b656d1b2ba3c613a1ca9896211bf22b1c6430ed1d8e23e0e517a4c0
+  data.tar.gz: f8af7a09143410175e8936a76a1b8471578fded4267c5307b86cf3c9ddb1b834
 SHA512:
-  metadata.gz: 89f8d37abacbe2191b5792819fb5895de27ecd81dcc4ded547e1549c893db382231029eb1fa17525b529e00e7328c22d487b0018b2398ce61322100f3fcd50cd
-  data.tar.gz: d95e2b4af93d135fd06d4fd3ed3791edb485a5d1720ac9da4891fa929e0481bbb8b4fe49010eff7855bd226bf8d6f2c2a90063099a0b0b21be9521c479da4d22
+  metadata.gz: 497a18b1e9bd0f6077bac4195f05af4cc814140a875c2ae4308957a5be8389cf474ba0b504da18e2fa4f8414333111b4f9f64151f5ed111334b9d82e0b531df9
+  data.tar.gz: ed9e925a0c2516974204f11229e655eae7e7ca1365e018160e7d6d0a17e2790f491c044e3242f48bfeb4e25a4dfb01d8d8455a7848303b1fc41c33fc8ba53d9a

data/lib/daytona/computer_use.rb

@@ -60,6 +60,8 @@ module Daytona
       # @param y [Integer] The y coordinate to click at
       # @param button [String] The mouse button to click ('left', 'right', 'middle'). Defaults to 'left'
       # @param double [Boolean] Whether to perform a double-click. Defaults to false
+      # @param clicks [Integer, nil] Number of clicks to perform (1-10). Omitted when nil, which is distinct from an explicit 0
+      # @param modifiers [Array<String>, nil] Modifier keys to hold during the click. Canonical names are 'ctrl', 'alt', 'shift', and 'cmd'
       # @return [DaytonaToolboxApiClient::MouseClickResponse] Click operation result
       # @raise [Daytona::Sdk::Error] If the operation fails
       #
@@ -72,13 +74,74 @@ module Daytona
       #
       #   # Right click
       #   right_click = sandbox.computer_use.mouse.click(x: 100, y: 200, button: 'right')
-      def click(x:, y:, button: 'left', double: false)
-        request = DaytonaToolboxApiClient::MouseClickRequest.new(x:, y:, button:, double:)
+      #
+      #   # Triple click
+      #   triple_click = sandbox.computer_use.mouse.click(x: 100, y: 200, clicks: 3)
+      #
+      #   # Ctrl+click
+      #   ctrl_click = sandbox.computer_use.mouse.click(x: 100, y: 200, modifiers: ['ctrl'])
+      def click(x:, y:, button: 'left', double: false, clicks: nil, modifiers: nil)
+        attrs = { x:, y:, button:, double: }
+        attrs[:clicks] = clicks unless clicks.nil?
+        attrs[:modifiers] = modifiers unless modifiers.nil?
+
+        request = DaytonaToolboxApiClient::MouseClickRequest.new(attrs)
         toolbox_api.click(request)
       rescue *Sdk::API_ERROR_CLASSES => e
         raise Sdk.wrap_error(e, 'Failed to click mouse')
       end
 
+      # Presses and holds a mouse button, optionally moving to the coordinates first.
+      #
+      # The button stays held until a matching {#up} call.
+      #
+      # @param x [Integer, nil] The x coordinate to move to before pressing. Omitted when nil
+      # @param y [Integer, nil] The y coordinate to move to before pressing. Omitted when nil
+      # @param button [String] The mouse button to press ('left', 'right', 'middle'). Defaults to 'left'
+      # @return [DaytonaToolboxApiClient::MousePositionResponse] Cursor position after the press
+      # @raise [Daytona::Sdk::Error] If the operation fails
+      #
+      # @example
+      #   # Press at the current cursor position
+      #   sandbox.computer_use.mouse.down
+      #
+      #   # Move to coordinates and press
+      #   sandbox.computer_use.mouse.down(x: 100, y: 200, button: 'left')
+      def down(x: nil, y: nil, button: 'left')
+        attrs = { button: }
+        attrs[:x] = x unless x.nil?
+        attrs[:y] = y unless y.nil?
+
+        request = DaytonaToolboxApiClient::MouseDownRequest.new(attrs)
+        toolbox_api.mouse_down(request)
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to press mouse button')
+      end
+
+      # Releases a held mouse button, optionally moving to the coordinates first.
+      #
+      # @param x [Integer, nil] The x coordinate to move to before releasing. Omitted when nil
+      # @param y [Integer, nil] The y coordinate to move to before releasing. Omitted when nil
+      # @param button [String] The mouse button to release ('left', 'right', 'middle'). Defaults to 'left'
+      # @return [DaytonaToolboxApiClient::MousePositionResponse] Cursor position after the release
+      # @raise [Daytona::Sdk::Error] If the operation fails
+      #
+      # @example
+      #   # Drag by holding, moving, then releasing
+      #   sandbox.computer_use.mouse.down(x: 10, y: 10)
+      #   sandbox.computer_use.mouse.move(x: 200, y: 200)
+      #   sandbox.computer_use.mouse.up(x: 200, y: 200)
+      def up(x: nil, y: nil, button: 'left')
+        attrs = { button: }
+        attrs[:x] = x unless x.nil?
+        attrs[:y] = y unless y.nil?
+
+        request = DaytonaToolboxApiClient::MouseUpRequest.new(attrs)
+        toolbox_api.mouse_up(request)
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to release mouse button')
+      end
+
       # Drags the mouse from start coordinates to end coordinates.
       #
       # @param start_x [Integer] The starting x coordinate
@@ -86,14 +149,21 @@ module Daytona
       # @param end_x [Integer] The ending x coordinate
       # @param end_y [Integer] The ending y coordinate
       # @param button [String] The mouse button to use for dragging. Defaults to 'left'
+      # @param modifiers [Array<String>, nil] Modifier keys to hold during the drag. Canonical names are 'ctrl', 'alt', 'shift', and 'cmd'
       # @return [DaytonaToolboxApiClient::MouseDragResponse] Drag operation result
       # @raise [Daytona::Sdk::Error] If the operation fails
       #
       # @example
       #   result = sandbox.computer_use.mouse.drag(start_x: 50, start_y: 50, end_x: 150, end_y: 150)
       #   puts "Drag ended at #{result.x}, #{result.y}"
-      def drag(start_x:, start_y:, end_x:, end_y:, button: 'left')
-        request = DaytonaToolboxApiClient::MouseDragRequest.new(start_x:, start_y:, end_x:, end_y:, button:)
+      #
+      #   # Drag while holding Shift
+      #   sandbox.computer_use.mouse.drag(start_x: 50, start_y: 50, end_x: 150, end_y: 150, modifiers: ['shift'])
+      def drag(start_x:, start_y:, end_x:, end_y:, button: 'left', modifiers: nil)
+        attrs = { start_x:, start_y:, end_x:, end_y:, button: }
+        attrs[:modifiers] = modifiers unless modifiers.nil?
+
+        request = DaytonaToolboxApiClient::MouseDragRequest.new(attrs)
         toolbox_api.drag(request)
       rescue *Sdk::API_ERROR_CLASSES => e
         raise Sdk.wrap_error(e, 'Failed to drag mouse')
@@ -103,8 +173,9 @@ module Daytona
       #
       # @param x [Integer] The x coordinate to scroll at
       # @param y [Integer] The y coordinate to scroll at
-      # @param direction [String] The direction to scroll ('up' or 'down')
+      # @param direction [String] The direction to scroll ('up', 'down', 'left', or 'right')
       # @param amount [Integer] The amount to scroll. Defaults to 1
+      # @param modifiers [Array<String>, nil] Modifier keys to hold during the scroll. Canonical names are 'ctrl', 'alt', 'shift', and 'cmd'
       # @return [Boolean] Whether the scroll operation was successful
       # @raise [Daytona::Sdk::Error] If the operation fails
       #
@@ -114,15 +185,24 @@ module Daytona
       #
       #   # Scroll down
       #   scroll_down = sandbox.computer_use.mouse.scroll(x: 100, y: 200, direction: 'down', amount: 5)
-      def scroll(x:, y:, direction:, amount: 1)
-        request = DaytonaToolboxApiClient::MouseScrollRequest.new(x:, y:, direction:, amount:)
+      #
+      #   # Scroll horizontally
+      #   scroll_left = sandbox.computer_use.mouse.scroll(x: 100, y: 200, direction: 'left', amount: 2)
+      #
+      #   # Ctrl+scroll to zoom
+      #   zoom_in = sandbox.computer_use.mouse.scroll(x: 100, y: 200, direction: 'up', modifiers: ['ctrl'])
+      def scroll(x:, y:, direction:, amount: 1, modifiers: nil)
+        attrs = { x:, y:, direction:, amount: }
+        attrs[:modifiers] = modifiers unless modifiers.nil?
+
+        request = DaytonaToolboxApiClient::MouseScrollRequest.new(attrs)
         toolbox_api.scroll(request)
         true
       rescue *Sdk::API_ERROR_CLASSES => e
         raise Sdk.wrap_error(e, 'Failed to scroll mouse')
       end
 
-      instrument :position, :move, :click, :drag, :scroll, component: 'Mouse'
+      instrument :position, :move, :click, :down, :up, :drag, :scroll, component: 'Mouse'
 
       private
 
@@ -191,6 +271,43 @@ module Daytona
         raise Sdk.wrap_error(e, 'Failed to press key')
       end
 
+      # Presses and holds a key or modifier until a matching {#up} call.
+      #
+      # @param key [String] The key or modifier to hold. Uses the same normalized key contract as #press, so 'ctrl', 'shift', and 'a' are all valid
+      # @return [void]
+      # @raise [Daytona::Sdk::Error] If the operation fails
+      #
+      # @example
+      #   # Hold Shift while typing. Release in `ensure` so a failed press cannot
+      #   # leave Shift stuck down.
+      #   sandbox.computer_use.keyboard.down(key: 'shift')
+      #   begin
+      #     sandbox.computer_use.keyboard.press(key: 'a')
+      #   ensure
+      #     sandbox.computer_use.keyboard.up(key: 'shift')
+      #   end
+      def down(key:)
+        request = DaytonaToolboxApiClient::KeyboardKeyDownRequest.new(key:)
+        toolbox_api.key_down(request)
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to press key down')
+      end
+
+      # Releases a key or modifier that is currently held down.
+      #
+      # @param key [String] The key or modifier to release. Uses the same normalized key contract as #press
+      # @return [void]
+      # @raise [Daytona::Sdk::Error] If the operation fails
+      #
+      # @example
+      #   sandbox.computer_use.keyboard.up(key: 'ctrl')
+      def up(key:)
+        request = DaytonaToolboxApiClient::KeyboardKeyUpRequest.new(key:)
+        toolbox_api.key_up(request)
+      rescue *Sdk::API_ERROR_CLASSES => e
+        raise Sdk.wrap_error(e, 'Failed to release key')
+      end
+
       # Presses a hotkey combination.
       #
       # @param keys [String] A single atomic hotkey chord (e.g., 'ctrl+c', 'alt+tab', 'cmd+shift+t', 'ctrl + c', 'shift'). Uses the same normalized key contract as #press.
@@ -213,7 +330,7 @@ module Daytona
         raise Sdk.wrap_error(e, 'Failed to press hotkey')
       end
 
-      instrument :type, :press, :hotkey, component: 'Keyboard'
+      instrument :type, :press, :down, :up, :hotkey, component: 'Keyboard'
 
       private
 

data/lib/daytona/process.rb

@@ -40,6 +40,20 @@ module Daytona
 
     # Execute a shell command in the Sandbox
     #
+    # The command is run by the first available of zsh, bash or sh in the sandbox, which is zsh
+    # in the default snapshots. Quote arguments that contain glob characters, for example
+    # `pip install -e '.[test]'`, or wrap bash-specific scripts in `bash -c '...'`.
+    #
+    # The call returns when the command finishes. To start a long-running process such as a
+    # server, run it in the background with its output redirected, e.g.
+    # `python3 -m http.server 8000 > server.log 2>&1 &`, or use a session with `run_async: true`
+    # (see {#execute_session_command}). A background process that keeps the command's output open
+    # (`cmd &` without a redirect) can block the call until that process exits.
+    #
+    # Tools in the sandbox may report the host's CPU count and memory (for example `nproc` or
+    # `Etc.nprocessors`) rather than the sandbox's own limits. Size worker pools from the
+    # sandbox's cpu and memory instead, e.g. `pytest -n 2` rather than `pytest -n auto`.
+    #
     # @param command [String] Shell command to execute
     # @param cwd [String, nil] Working directory for command execution. If not specified, uses the sandbox working directory
     # @param env [Hash<String, String>, nil] Environment variables to set for the command
@@ -48,15 +62,18 @@ module Daytona
     #
     # @example
     #   # Simple command
-    #   response = sandbox.process.exec("echo 'Hello'")
+    #   response = sandbox.process.exec(command: "echo 'Hello'")
     #   puts response.artifacts.stdout
     #   => "Hello\n"
     #
     #   # Command with working directory
-    #   result = sandbox.process.exec("ls", cwd: "workspace/src")
+    #   result = sandbox.process.exec(command: "ls", cwd: "workspace/src")
     #
     #   # Command with timeout
-    #   result = sandbox.process.exec("sleep 10", timeout: 5)
+    #   result = sandbox.process.exec(command: "sleep 10", timeout: 5)
+    #
+    #   # Start a server in the background
+    #   sandbox.process.exec(command: "python3 -m http.server 8000 > server.log 2>&1 &")
     def exec(command:, cwd: nil, env: nil, timeout: nil)
       envs = env&.empty? ? nil : env
 

data/lib/daytona/sandbox.rb

@@ -364,6 +364,21 @@ module Daytona
       process_response(data)
     end
 
+    # Sets whether the Sandbox's preview URLs are publicly accessible.
+    # When public, preview URLs (see #preview_url) can be opened without a preview token or API key.
+    # When private, every preview request must authenticate.
+    #
+    # @param is_public [Boolean]
+    # @return [Boolean]
+    # @raise [Daytona::Sdk::Error]
+    #
+    # @example
+    #   sandbox.public = true
+    def public=(is_public)
+      sandbox_api.update_public_status(id, is_public)
+      @public = is_public
+    end
+
     # Sets the auto-stop interval for the Sandbox.
     # The Sandbox will automatically stop after being idle (no new events) for the specified interval.
     # Events include any state changes or interactions with the Sandbox through the SDK.
@@ -555,8 +570,21 @@ module Daytona
     # it will be opened automatically. For private sandboxes, a token is included to grant access
     # to the URL.
     #
+    # For a private sandbox, requests to the URL must authenticate, otherwise they are answered
+    # with 401 Unauthorized. Send the returned token in the X-Daytona-Preview-Token header, or
+    # send your Daytona API key as "Authorization: Bearer <api key>". To get a URL that works
+    # without extra headers (for example to open it in a browser or share it), use
+    # {#create_signed_preview_url} instead. Public sandboxes need no credentials.
+    #
     # @param port [Integer]
     # @return [DaytonaApiClient::PortPreviewUrl]
+    #
+    # @example
+    #   preview = sandbox.preview_url(3000)
+    #   uri = URI(preview.url)
+    #   request = Net::HTTP::Get.new(uri)
+    #   request['X-Daytona-Preview-Token'] = preview.token
+    #   response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(request) }
     def preview_url(port)
       sandbox_api.get_port_preview_url(id, port)
     end
@@ -633,9 +661,14 @@ module Daytona
 
     # Creates a signed preview URL for the sandbox at the specified port.
     #
+    # The access token is embedded in the returned URL, so it can be used without any headers,
+    # for example in a browser or by another service. The URL stops working when it expires or
+    # when it is expired with {#expire_signed_preview_url}.
+    #
     # @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.
+    #   will be valid for. Defaults to 60 seconds; set a longer value for links that need to
+    #   stay usable, e.g. 3600 for one hour.
     # @return [DaytonaApiClient::SignedPortPreviewUrl] The signed preview URL response object
     #
     # @example
@@ -951,7 +984,7 @@ module Daytona
       end
     end
 
-    with_events :archive, :auto_archive_interval=, :auto_delete_interval=, :auto_stop_interval=,
+    with_events :archive, :auto_archive_interval=, :auto_delete_interval=, :auto_stop_interval=, :public=,
                 :create_ssh_access, :delete, :get_user_home_dir, :get_work_dir, :labels=,
                 :preview_url, :create_signed_preview_url, :expire_signed_preview_url,
                 :refresh, :refresh_activity, :revoke_ssh_access, :start, :recover, :stop,
@@ -960,7 +993,7 @@ module Daytona
                 :fork, :create_snapshot, :pause
 
     instrument :archive, :auto_archive_interval=, :auto_delete_interval=, :auto_pause_interval=, :auto_stop_interval=,
-               :ttl_minutes=,
+               :ttl_minutes=, :public=,
                :update_network_settings, :update_secrets, :update_env,
                :create_ssh_access, :delete, :get_user_home_dir, :get_work_dir, :get_metrics, :get_metrics_latest,
                :labels=,

data/lib/daytona/sdk/version.rb

@@ -5,6 +5,6 @@
 
 module Daytona
   module Sdk
-    VERSION = '0.223.0.alpha.2'
+    VERSION = '0.223.1'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daytona
 version: !ruby/object:Gem::Version
-  version: 0.223.0.alpha.2
+  version: 0.223.1
 platform: ruby
 authors:
 - Daytona Platforms Inc.
@@ -91,42 +91,42 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.223.0.alpha.2
+        version: 0.223.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.223.0.alpha.2
+        version: 0.223.1
 - !ruby/object:Gem::Dependency
   name: daytona_api_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.223.0.alpha.2
+        version: 0.223.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.223.0.alpha.2
+        version: 0.223.1
 - !ruby/object:Gem::Dependency
   name: daytona_toolbox_api_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.223.0.alpha.2
+        version: 0.223.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.223.0.alpha.2
+        version: 0.223.1
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement