Class: Daytona::ComputerUse

Inherits:
Object
  • Object
show all
Includes:
Instrumentation
Defined in:
lib/daytona/computer_use.rb

Defined Under Namespace

Classes: Accessibility, Display, Keyboard, Mouse, Recording, Screenshot, ScreenshotOptions, ScreenshotRegion

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Instrumentation

included

Constructor Details

#initialize(sandbox_id:, toolbox_api:, otel_state: nil) ⇒ ComputerUse

Initialize a new ComputerUse instance.

Parameters:

  • sandbox_id (String) —

    The ID of the sandbox

  • toolbox_api (DaytonaApiClient::ToolboxApi) —

    API client for sandbox operations

  • otel_state (Daytona::OtelState, nil) (defaults to: nil) 


796
797
798
799
800
801
802
803
804
805
806
 
# File 'lib/daytona/computer_use.rb', line 796

def initialize(sandbox_id:, toolbox_api:, otel_state: nil)
  @sandbox_id = sandbox_id
  @toolbox_api = toolbox_api
  @otel_state = otel_state
  @mouse = Mouse.new(sandbox_id:, toolbox_api:, otel_state:)
  @keyboard = Keyboard.new(sandbox_id:, toolbox_api:, otel_state:)
  @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

Instance Attribute Details

#accessibility ⇒ Accessibility (readonly)

Returns Accessibility operations interface.

Returns:



789
790
791
 
# File 'lib/daytona/computer_use.rb', line 789

def accessibility
  @accessibility
end

#display ⇒ Display (readonly)

Returns Display operations interface.

Returns:

  • (Display) —

    Display operations interface



783
784
785
 
# File 'lib/daytona/computer_use.rb', line 783

def display
  @display
end

#keyboard ⇒ Keyboard (readonly)

Returns Keyboard operations interface.

Returns:

  • (Keyboard) —

    Keyboard operations interface



777
778
779
 
# File 'lib/daytona/computer_use.rb', line 777

def keyboard
  @keyboard
end

#mouse ⇒ Mouse (readonly)

Returns Mouse operations interface.

Returns:

  • (Mouse) —

    Mouse operations interface



774
775
776
 
# File 'lib/daytona/computer_use.rb', line 774

def mouse
  @mouse
end

#recording ⇒ Recording (readonly)

Returns Screen recording operations interface.

Returns:

  • (Recording) —

    Screen recording operations interface



786
787
788
 
# File 'lib/daytona/computer_use.rb', line 786

def recording
  @recording
end

#sandbox_id ⇒ String (readonly)

Returns The ID of the sandbox.

Returns:

  • (String) —

    The ID of the sandbox



768
769
770
 
# File 'lib/daytona/computer_use.rb', line 768

def sandbox_id
  @sandbox_id
end

#screenshot ⇒ Screenshot (readonly)

Returns Screenshot operations interface.

Returns:

  • (Screenshot) —

    Screenshot operations interface



780
781
782
 
# File 'lib/daytona/computer_use.rb', line 780

def screenshot
  @screenshot
end

#toolbox_api ⇒ DaytonaApiClient::ToolboxApi (readonly)

Returns API client for sandbox operations.

Returns:

  • (DaytonaApiClient::ToolboxApi) —

    API client for sandbox operations



771
772
773
 
# File 'lib/daytona/computer_use.rb', line 771

def toolbox_api
  @toolbox_api
end

Instance Method Details

#get_process_errors(process_name:) ⇒ DaytonaApiClient::ProcessErrorsResponse

Gets error logs for a specific VNC process.

Examples:

errors = sandbox.computer_use.get_process_errors("x11vnc")
puts "X11VNC errors: #{errors}"

Parameters:

  • process_name (String) —

    Name of the process to get error logs for

Returns:

  • (DaytonaApiClient::ProcessErrorsResponse) —

    Process error logs

Raises:



904
905
906
907
908
 
# File 'lib/daytona/computer_use.rb', line 904

def get_process_errors(process_name:)
  toolbox_api.get_process_errors(process_name, sandbox_id)
rescue StandardError => e
  raise Sdk::Error, "Failed to get process errors: #{e.message}"
end

#get_process_logs(process_name:) ⇒ DaytonaApiClient::ProcessLogsResponse

Gets logs for a specific VNC process.

Examples:

logs = sandbox.computer_use.get_process_logs("novnc")
puts "NoVNC logs: #{logs}"

Parameters:

  • process_name (String) —

    Name of the process to get logs for

Returns:

  • (DaytonaApiClient::ProcessLogsResponse) —

    Process logs

Raises:



889
890
891
892
893
 
# File 'lib/daytona/computer_use.rb', line 889

def get_process_logs(process_name:)
  toolbox_api.get_process_logs(process_name, sandbox_id)
rescue StandardError => e
  raise Sdk::Error, "Failed to get process logs: #{e.message}"
end

#get_process_status(process_name:) ⇒ DaytonaApiClient::ProcessStatusResponse

Gets the status of a specific VNC process.

Examples:

xvfb_status = sandbox.computer_use.get_process_status("xvfb")
no_vnc_status = sandbox.computer_use.get_process_status("novnc")

Parameters:

  • process_name (String) —

    Name of the process to check

Returns:

  • (DaytonaApiClient::ProcessStatusResponse) —

    Status information about the specific process

Raises:



859
860
861
862
863
 
# File 'lib/daytona/computer_use.rb', line 859

def get_process_status(process_name:)
  toolbox_api.get_process_status(process_name, sandbox_id)
rescue StandardError => e
  raise Sdk::Error, "Failed to get process status: #{e.message}"
end

#restart_process(process_name:) ⇒ DaytonaApiClient::ProcessRestartResponse

Restarts a specific VNC process.

Examples:

result = sandbox.computer_use.restart_process("xfce4")
puts "XFCE4 process restarted: #{result.message}"

Parameters:

  • process_name (String) —

    Name of the process to restart

Returns:

  • (DaytonaApiClient::ProcessRestartResponse) —

    Process restart response

Raises:



874
875
876
877
878
 
# File 'lib/daytona/computer_use.rb', line 874

def restart_process(process_name:)
  toolbox_api.restart_process(process_name, sandbox_id)
rescue StandardError => e
  raise Sdk::Error, "Failed to restart process: #{e.message}"
end

#start ⇒ DaytonaApiClient::ComputerUseStartResponse

Starts all computer use processes (Xvfb, xfce4, x11vnc, novnc).

Examples:

result = sandbox.computer_use.start
puts "Computer use processes started: #{result.message}"

Returns:

  • (DaytonaApiClient::ComputerUseStartResponse) —

    Computer use start response

Raises:



816
817
818
819
820
 
# File 'lib/daytona/computer_use.rb', line 816

def start
  toolbox_api.start_computer_use
rescue StandardError => e
  raise Sdk::Error, "Failed to start computer use: #{e.message}"
end

#status ⇒ DaytonaApiClient::ComputerUseStatusResponse

Gets the status of all computer use processes.

Examples:

response = sandbox.computer_use.get_status
puts "Computer use status: #{response.status}"

Returns:

  • (DaytonaApiClient::ComputerUseStatusResponse) —

    Status information about all VNC desktop processes

Raises:



844
845
846
847
848
 
# File 'lib/daytona/computer_use.rb', line 844

def status
  toolbox_api.get_computer_use_status
rescue StandardError => e
  raise Sdk::Error, "Failed to get computer use status: #{e.message}"
end

#stop ⇒ DaytonaApiClient::ComputerUseStopResponse

Stops all computer use processes.

Examples:

result = sandbox.computer_use.stop
puts "Computer use processes stopped: #{result.message}"

Returns:

  • (DaytonaApiClient::ComputerUseStopResponse) —

    Computer use stop response

Raises:



830
831
832
833
834
 
# File 'lib/daytona/computer_use.rb', line 830

def stop
  toolbox_api.stop_computer_use
rescue StandardError => e
  raise Sdk::Error, "Failed to stop computer use: #{e.message}"
end