Process

Initialize a new Process instance

Constructors

new Process()

ruby

def initialize(sandbox_id:, toolbox_api:, get_preview_link:, language:, otel_state:)

Initialize a new Process instance

Parameters:

sandbox_id String - The ID of the Sandbox
toolbox_api DaytonaToolboxApiClient:ProcessApi - API client for Sandbox operations
get_preview_link Proc - Function to get preview link for a port
language String - The language for code execution
otel_state Daytona:OtelState, nil -

Returns:

Process - a new instance of Process

Methods

sandbox_id()

ruby

def sandbox_id()

Returns:

String - The ID of the Sandbox

toolbox_api()

ruby

def toolbox_api()

Returns:

DaytonaToolboxApiClient:ProcessApi - API client for Sandbox operations

get_preview_link()

ruby

def get_preview_link()

Returns:

Proc - Function to get preview link for a port

language()

ruby

def language()

Returns:

String - The language for code execution (e.g. 'python', 'typescript', 'javascript')

exec()

ruby

def exec(command:, cwd:, env:, timeout:)

Execute a shell command in the Sandbox

Parameters:

command String - Shell command to execute
cwd String, nil - Working directory for command execution. If not specified, uses the sandbox working directory
env Hash<String, String>, nil - Environment variables to set for the command
timeout Integer, nil - Maximum time in seconds to wait for the command to complete.

Returns:

ExecuteResponse - Command execution results containing exit_code, result, and artifacts

Examples:

ruby

# Simple command
response = sandbox.process.exec("echo 'Hello'")
puts response.artifacts.stdout
=> "Hello\n"

# Command with working directory
result = sandbox.process.exec("ls", cwd: "workspace/src")

# Command with timeout
result = sandbox.process.exec("sleep 10", timeout: 5)

code_run()

ruby

def code_run(code:, params:, timeout:)

Execute code in the Sandbox using the appropriate language runtime

Parameters:

code String - Code to execute
params CodeRunParams, nil - Parameters for code execution
timeout Integer, nil - Maximum time in seconds to wait for the code to complete. 0 means wait indefinitely

Returns:

ExecuteResponse - Code execution result containing exit_code, result, and artifacts

Examples:

ruby

# Run Python code
response = sandbox.process.code_run(<<~CODE)
  x = 10
  y = 20
  print(f"Sum: {x + y}")
CODE
puts response.artifacts.stdout  # Prints: Sum: 30

create_session()

ruby

def create_session(session_id)

Creates a new long-running background session in the Sandbox

Sessions are background processes that maintain state between commands, making them ideal for scenarios requiring multiple related commands or persistent environment setup.

Parameters:

session_id String - Unique identifier for the new session

Returns:

void

Examples:

ruby

# Create a new session
session_id = "my-session"
sandbox.process.create_session(session_id)
session = sandbox.process.get_session(session_id)
# Do work...
sandbox.process.delete_session(session_id)

get_session()

ruby

def get_session(session_id)

Gets a session in the Sandbox

Parameters:

session_id String - Unique identifier of the session to retrieve

Returns:

DaytonaApiClient:Session - Session information including session_id and commands

Examples:

ruby

session = sandbox.process.get_session("my-session")
session.commands.each do |cmd|
  puts "Command: #{cmd.command}"
end

get_entrypoint_session()

ruby

def get_entrypoint_session()

Gets the Sandbox entrypoint session

Returns:

DaytonaApiClient:Session - Entrypoint session information including session_id and commands

Examples:

ruby

session = sandbox.process.get_entrypoint_session()
session.commands.each do |cmd|
  puts "Command: #{cmd.command}"
end

get_session_command()

ruby

def get_session_command(session_id:, command_id:)

Gets information about a specific command executed in a session

Parameters:

session_id String - Unique identifier of the session
command_id String - Unique identifier of the command

Returns:

DaytonaApiClient:Command - Command information including id, command, and exit_code

Examples:

ruby

cmd = sandbox.process.get_session_command(session_id: "my-session", command_id: "cmd-123")
if cmd.exit_code == 0
  puts "Command #{cmd.command} completed successfully"
end

execute_session_command()

ruby

def execute_session_command(session_id:, req:)

Executes a command in the session

Parameters:

session_id String - Unique identifier of the session to use
req Daytona:SessionExecuteRequest - Command execution request containing command and run_async

Returns:

Daytona:SessionExecuteResponse - Command execution results containing cmd_id, output, stdout, stderr, and exit_code

Examples:

ruby

# Execute commands in sequence, maintaining state
session_id = "my-session"

# Change directory
req = Daytona::SessionExecuteRequest.new(command: "cd /workspace")
sandbox.process.execute_session_command(session_id:, req:)

# Create a file
req = Daytona::SessionExecuteRequest.new(command: "echo 'Hello' > test.txt")
sandbox.process.execute_session_command(session_id:, req:)

# Read the file
req = Daytona::SessionExecuteRequest.new(command: "cat test.txt")
result = sandbox.process.execute_session_command(session_id:, req:)
puts "Command stdout: #{result.stdout}"
puts "Command stderr: #{result.stderr}"

get_session_command_logs()

ruby

def get_session_command_logs(session_id:, command_id:)

Get the logs for a command executed in a session

Parameters:

session_id String - Unique identifier of the session
command_id String - Unique identifier of the command

Returns:

Daytona:SessionCommandLogsResponse - Command logs including output, stdout, and stderr

Examples:

ruby

logs = sandbox.process.get_session_command_logs(session_id: "my-session", command_id: "cmd-123")
puts "Command stdout: #{logs.stdout}"
puts "Command stderr: #{logs.stderr}"

get_session_command_logs_async()

ruby

def get_session_command_logs_async(session_id:, command_id:, on_stdout:, on_stderr:)

Asynchronously retrieves and processes the logs for a command executed in a session as they become available

Parameters:

session_id String - Unique identifier of the session
command_id String - Unique identifier of the command
on_stdout Proc - Callback function to handle stdout log chunks as they arrive
on_stderr Proc - Callback function to handle stderr log chunks as they arrive

Returns:

WebSocket:Client:Simple:Client

Examples:

ruby

sandbox.process.get_session_command_logs_async(
  session_id: "my-session",
  command_id: "cmd-123",
  on_stdout: ->(log) { puts "[STDOUT]: #{log}" },
  on_stderr: ->(log) { puts "[STDERR]: #{log}" }
)

get_entrypoint_logs()

ruby

def get_entrypoint_logs()

Get the sandbox entrypoint logs

Returns:

Daytona:SessionCommandLogsResponse - Entrypoint logs including output, stdout, and stderr

Examples:

ruby

logs = sandbox.process.get_entrypoint_logs()
puts "Command stdout: #{logs.stdout}"
puts "Command stderr: #{logs.stderr}"

get_entrypoint_logs_async()

ruby

def get_entrypoint_logs_async(on_stdout:, on_stderr:)

Asynchronously retrieves and processes the sandbox entrypoint logs as they become available

Parameters:

on_stdout Proc - Callback function to handle stdout log chunks as they arrive
on_stderr Proc - Callback function to handle stderr log chunks as they arrive

Returns:

WebSocket:Client:Simple:Client

Examples:

ruby

sandbox.process.get_entrypoint_logs_async(
  on_stdout: ->(log) { puts "[STDOUT]: #{log}" },
  on_stderr: ->(log) { puts "[STDERR]: #{log}" }
)

send_session_command_input()

ruby

def send_session_command_input(session_id:, command_id:, data:)

Sends input data to a command executed in a session

This method allows you to send input to an interactive command running in a session, such as responding to prompts or providing data to stdin.

Parameters:

session_id String - Unique identifier of the session
command_id String - Unique identifier of the command
data String - Input data to send to the command

Returns:

void

list_sessions()

ruby

def list_sessions()

Returns:

Array\<DaytonaApiClient:Session\> - List of all sessions in the Sandbox

Examples:

ruby

sessions = sandbox.process.list_sessions
sessions.each do |session|
  puts "Session #{session.session_id}:"
  puts "  Commands: #{session.commands.length}"
end

delete_session()

ruby

def delete_session(session_id)

Terminates and removes a session from the Sandbox, cleaning up any resources associated with it

Parameters:

session_id String - Unique identifier of the session to delete

Examples:

ruby

# Create and use a session
sandbox.process.create_session("temp-session")
# ... use the session ...

# Clean up when done
sandbox.process.delete_session("temp-session")

create_pty_session()

ruby

def create_pty_session(id:, cwd:, envs:, pty_size:)

Creates a new PTY (pseudo-terminal) session in the Sandbox.

Creates an interactive terminal session that can execute commands and handle user input. The PTY session behaves like a real terminal, supporting features like command history.

Parameters:

id String - Unique identifier for the PTY session. Must be unique within the Sandbox.
cwd String, nil - Working directory for the PTY session. Defaults to the sandbox's working directory.
envs Hash<String, String>, nil - Environment variables to set in the PTY session. These will be merged with the Sandbox's default environment variables.
pty_size PtySize, nil - Terminal size configuration. Defaults to 80x24 if not specified.

Returns:

PtyHandle - Handle for managing the created PTY session. Use this to send input, receive output, resize the terminal, and manage the session lifecycle.

Raises:

Daytona:Sdk:Error - If the PTY session creation fails or the session ID is already in use.

Examples:

ruby

# Create a basic PTY session
pty_handle = sandbox.process.create_pty_session(id: "my-pty")

# Create a PTY session with specific size and environment
pty_size = Daytona::PtySize.new(rows: 30, cols: 120)
pty_handle = sandbox.process.create_pty_session(
  id: "my-pty",
  cwd: "/workspace",
  envs: {"NODE_ENV" => "development"},
  pty_size: pty_size
)

# Use the PTY session
pty_handle.wait_for_connection
pty_handle.send_input("ls -la\n")
result = pty_handle.wait
pty_handle.disconnect

connect_pty_session()

ruby

def connect_pty_session(session_id)

Connects to an existing PTY session in the Sandbox.

Establishes a WebSocket connection to an existing PTY session, allowing you to interact with a previously created terminal session.

Parameters:

session_id String - Unique identifier of the PTY session to connect to.

Returns:

PtyHandle - Handle for managing the connected PTY session.

Raises:

Daytona:Sdk:Error - If the PTY session doesn't exist or connection fails.

Examples:

ruby

# Connect to an existing PTY session
pty_handle = sandbox.process.connect_pty_session("my-pty-session")
pty_handle.wait_for_connection
pty_handle.send_input("echo 'Hello World'\n")
result = pty_handle.wait
pty_handle.disconnect

resize_pty_session()

ruby

def resize_pty_session(session_id, pty_size)

Resizes a PTY session to the specified dimensions

Parameters:

session_id String - Unique identifier of the PTY session
pty_size PtySize - New terminal size

Returns:

DaytonaApiClient:PtySessionInfo - Updated PTY session information

Examples:

ruby

pty_size = Daytona::PtySize.new(rows: 30, cols: 120)
session_info = sandbox.process.resize_pty_session("my-pty", pty_size)
puts "PTY resized to #{session_info.cols}x#{session_info.rows}"

delete_pty_session()

ruby

def delete_pty_session(session_id)

Deletes a PTY session, terminating the associated process

Parameters:

session_id String - Unique identifier of the PTY session to delete

Returns:

void

Examples:

ruby

sandbox.process.delete_pty_session("my-pty")

list_pty_sessions()

ruby

def list_pty_sessions()

Lists all PTY sessions in the Sandbox

Returns:

Array\<DaytonaApiClient:PtySessionInfo\> - List of PTY session information

Examples:

ruby

sessions = sandbox.process.list_pty_sessions
sessions.each do |session|
  puts "PTY Session #{session.id}: #{session.cols}x#{session.rows}"
end

get_pty_session_info()

ruby

def get_pty_session_info(session_id)

Gets detailed information about a specific PTY session

Retrieves comprehensive information about a PTY session including its current state, configuration, and metadata.

Parameters:

session_id String - Unique identifier of the PTY session to retrieve information for

Returns:

DaytonaApiClient:PtySessionInfo - Detailed information about the PTY session including ID, state, creation time, working directory, environment variables, and more

Examples:

ruby

# Get details about a specific PTY session
session_info = sandbox.process.get_pty_session_info("my-session")
puts "Session ID: #{session_info.id}"
puts "Active: #{session_info.active}"
puts "Working Directory: #{session_info.cwd}"
puts "Terminal Size: #{session_info.cols}x#{session_info.rows}"