Class: Daytona::ComputerUse::Recording

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

Overview

Recording operations for computer use functionality.

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Instrumentation

included

Constructor Details

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

Returns a new instance of Recording.

Parameters:

  • sandbox_id (String) —

    The ID of the sandbox

  • toolbox_api (DaytonaToolboxApiClient::ComputerUseApi) —

    API client for sandbox operations

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


477
478
479
480
481
 
# File 'lib/daytona/computer_use.rb', line 477

def initialize(sandbox_id:, toolbox_api:, otel_state: nil)
  @sandbox_id = sandbox_id
  @toolbox_api = toolbox_api
  @otel_state = otel_state
end

Instance Attribute Details

#sandbox_id ⇒ String (readonly)

Returns The ID of the sandbox.

Returns:

  • (String) —

    The ID of the sandbox



469
470
471
 
# File 'lib/daytona/computer_use.rb', line 469

def sandbox_id
  @sandbox_id
end

#toolbox_api ⇒ DaytonaToolboxApiClient::ComputerUseApi (readonly)

Returns API client for sandbox operations.

Returns:

  • (DaytonaToolboxApiClient::ComputerUseApi) —

    API client for sandbox operations



472
473
474
 
# File 'lib/daytona/computer_use.rb', line 472

def toolbox_api
  @toolbox_api
end

Instance Method Details

#delete(id:) ⇒ void

This method returns an undefined value.

Deletes a recording by ID.

Examples:

sandbox.computer_use.recording.delete(id: recording_id)
puts "Recording deleted"

Parameters:

  • id (String) —

    The ID of the recording to delete

Raises:



561
562
563
564
565
 
# File 'lib/daytona/computer_use.rb', line 561

def delete(id:)
  toolbox_api.delete_recording(id)
rescue StandardError => e
  raise Sdk::Error, "Failed to delete recording: #{e.message}"
end

#download(id:, local_path:) ⇒ void

This method returns an undefined value.

Downloads a recording file and saves it to a local path.

The file is streamed directly to disk without loading the entire content into memory.

Examples:

sandbox.computer_use.recording.download(id: recording_id, local_path: "local_recording.mp4")
puts "Recording downloaded"

Parameters:

  • id (String) —

    The ID of the recording to download

  • local_path (String) —

    Path to save the recording file locally

Raises:



579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
 
# File 'lib/daytona/computer_use.rb', line 579

def download(id:, local_path:)
  require 'fileutils'
  require 'typhoeus'

  # Get the API configuration and build the download URL
  api_client = toolbox_api.api_client
  config = api_client.config
  base_url = config.base_url
  download_url = "#{base_url}/computeruse/recordings/#{id}/download"

  # Create parent directory if it doesn't exist
  parent_dir = File.dirname(local_path)
  FileUtils.mkdir_p(parent_dir) unless parent_dir.empty?

  # Stream the download directly to file
  file = File.open(local_path, 'wb')
  request = Typhoeus::Request.new(
    download_url,
    method: :get,
    headers: api_client.default_headers,
    timeout: config.timeout,
    ssl_verifypeer: config.verify_ssl,
    ssl_verifyhost: config.verify_ssl_host ? 2 : 0
  )

  # Stream chunks directly to file
  request.on_body do |chunk|
    file.write(chunk)
  end

  request.on_complete do |response|
    file.close
    unless response.success?
      File.delete(local_path) if File.exist?(local_path)
      raise Sdk::Error, "Failed to download recording: HTTP #{response.code}"
    end
  end

  request.run
rescue StandardError => e
  file&.close
  File.delete(local_path) if File.exist?(local_path)
  raise Sdk::Error, "Failed to download recording: #{e.message}"
end

#get(id:) ⇒ DaytonaToolboxApiClient::Recording

Gets details of a specific recording by ID.

Examples:

recording = sandbox.computer_use.recording.get(id: recording_id)
puts "Recording: #{recording.file_name}"
puts "Status: #{recording.status}"
puts "Duration: #{recording.duration_seconds} seconds"

Parameters:

  • id (String) —

    The ID of the recording to retrieve

Returns:

  • (DaytonaToolboxApiClient::Recording) —

    Recording details

Raises:



546
547
548
549
550
 
# File 'lib/daytona/computer_use.rb', line 546

def get(id:)
  toolbox_api.get_recording(id)
rescue StandardError => e
  raise Sdk::Error, "Failed to get recording: #{e.message}"
end

#list ⇒ DaytonaToolboxApiClient::ListRecordingsResponse

Lists all recordings (active and completed).

Examples:

recordings = sandbox.computer_use.recording.list
puts "Found #{recordings.recordings.length} recordings"
recordings.recordings.each do |rec|
  puts "- #{rec.file_name}: #{rec.status}"
end

Returns:

  • (DaytonaToolboxApiClient::ListRecordingsResponse) —

    List of all recordings

Raises:



529
530
531
532
533
 
# File 'lib/daytona/computer_use.rb', line 529

def list
  toolbox_api.list_recordings
rescue StandardError => e
  raise Sdk::Error, "Failed to list recordings: #{e.message}"
end

#start(label: nil) ⇒ DaytonaToolboxApiClient::Recording

Starts a new screen recording session.

Examples:

# Start a recording with a label
recording = sandbox.computer_use.recording.start(label: "my-test-recording")
puts "Recording started: #{recording.id}"
puts "File: #{recording.file_path}"

Parameters:

  • label (String, nil) (defaults to: nil) —

    Optional custom label for the recording

Returns:

  • (DaytonaToolboxApiClient::Recording) —

    Started recording details

Raises:



494
495
496
497
498
499
 
# File 'lib/daytona/computer_use.rb', line 494

def start(label: nil)
  request = DaytonaToolboxApiClient::StartRecordingRequest.new(label:)
  toolbox_api.start_recording(request: request)
rescue StandardError => e
  raise Sdk::Error, "Failed to start recording: #{e.message}"
end

#stop(id:) ⇒ DaytonaToolboxApiClient::Recording

Stops an active screen recording session.

Examples:

result = sandbox.computer_use.recording.stop(id: recording.id)
puts "Recording stopped: #{result.duration_seconds} seconds"
puts "Saved to: #{result.file_path}"

Parameters:

  • id (String) —

    The ID of the recording to stop

Returns:

  • (DaytonaToolboxApiClient::Recording) —

    Stopped recording details

Raises:



511
512
513
514
515
516
 
# File 'lib/daytona/computer_use.rb', line 511

def stop(id:)
  request = DaytonaToolboxApiClient::StopRecordingRequest.new(id: id)
  toolbox_api.stop_recording(request)
rescue StandardError => e
  raise Sdk::Error, "Failed to stop recording: #{e.message}"
end