Class: Daytona::ComputerUse

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

Defined Under Namespace

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

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(sandbox_id:, toolbox_api:) ⇒ ComputerUse

Initialize a new ComputerUse instance.

Parameters:

  • sandbox_id (String) —

    The ID of the sandbox

  • toolbox_api (DaytonaApiClient::ToolboxApi) —

    API client for sandbox operations



598
599
600
601
602
603
604
605
606
 
# File 'lib/daytona/computer_use.rb', line 598

def initialize(sandbox_id:, toolbox_api:)
  @sandbox_id = sandbox_id
  @toolbox_api = toolbox_api
  @mouse = Mouse.new(sandbox_id:, toolbox_api:)
  @keyboard = Keyboard.new(sandbox_id:, toolbox_api:)
  @screenshot = Screenshot.new(sandbox_id:, toolbox_api:)
  @display = Display.new(sandbox_id:, toolbox_api:)
  @recording = Recording.new(sandbox_id:, toolbox_api:)
end

Instance Attribute Details

#display ⇒ Display (readonly)

Returns Display operations interface.

Returns:

  • (Display) —

    Display operations interface



589
590
591
 
# File 'lib/daytona/computer_use.rb', line 589

def display
  @display
end

#keyboard ⇒ Keyboard (readonly)

Returns Keyboard operations interface.

Returns:

  • (Keyboard) —

    Keyboard operations interface



583
584
585
 
# File 'lib/daytona/computer_use.rb', line 583

def keyboard
  @keyboard
end

#mouse ⇒ Mouse (readonly)

Returns Mouse operations interface.

Returns:

  • (Mouse) —

    Mouse operations interface



580
581
582
 
# File 'lib/daytona/computer_use.rb', line 580

def mouse
  @mouse
end

#recording ⇒ Recording (readonly)

Returns Screen recording operations interface.

Returns:

  • (Recording) —

    Screen recording operations interface



592
593
594
 
# File 'lib/daytona/computer_use.rb', line 592

def recording
  @recording
end

#sandbox_id ⇒ String (readonly)

Returns The ID of the sandbox.

Returns:

  • (String) —

    The ID of the sandbox



574
575
576
 
# File 'lib/daytona/computer_use.rb', line 574

def sandbox_id
  @sandbox_id
end

#screenshot ⇒ Screenshot (readonly)

Returns Screenshot operations interface.

Returns:

  • (Screenshot) —

    Screenshot operations interface



586
587
588
 
# File 'lib/daytona/computer_use.rb', line 586

def screenshot
  @screenshot
end

#toolbox_api ⇒ DaytonaApiClient::ToolboxApi (readonly)

Returns API client for sandbox operations.

Returns:

  • (DaytonaApiClient::ToolboxApi) —

    API client for sandbox operations



577
578
579
 
# File 'lib/daytona/computer_use.rb', line 577

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:



704
705
706
707
708
 
# File 'lib/daytona/computer_use.rb', line 704

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:



689
690
691
692
693
 
# File 'lib/daytona/computer_use.rb', line 689

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:



659
660
661
662
663
 
# File 'lib/daytona/computer_use.rb', line 659

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:



674
675
676
677
678
 
# File 'lib/daytona/computer_use.rb', line 674

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:



616
617
618
619
620
 
# File 'lib/daytona/computer_use.rb', line 616

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:



644
645
646
647
648
 
# File 'lib/daytona/computer_use.rb', line 644

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:



630
631
632
633
634
 
# File 'lib/daytona/computer_use.rb', line 630

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