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) 


474
475
476
477
478
 
# File 'lib/daytona/computer_use.rb', line 474

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



466
467
468
 
# File 'lib/daytona/computer_use.rb', line 466

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



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

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:



558
559
560
561
562
 
# File 'lib/daytona/computer_use.rb', line 558

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:



576
577
578
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
 
# File 'lib/daytona/computer_use.rb', line 576

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:



543
544
545
546
547
 
# File 'lib/daytona/computer_use.rb', line 543

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:



526
527
528
529
530
 
# File 'lib/daytona/computer_use.rb', line 526

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:



491
492
493
494
495
496
 
# File 'lib/daytona/computer_use.rb', line 491

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:



508
509
510
511
512
513
 
# File 'lib/daytona/computer_use.rb', line 508

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