Process

Initialize a new Process instance

Constructors

new Process()

def initialize(sandbox_id:, toolbox_api:, get_preview_link:, language: 'python', otel_state: nil)

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()

def sandbox_id()

Returns:

• String - The ID of the Sandbox

toolbox_api()

def toolbox_api()

Returns:

• DaytonaToolboxApiClient:ProcessApi - API client for Sandbox operations

get_preview_link()

def get_preview_link()

Returns:

• Proc - Function to get preview link for a port

language()

def language()

Returns:

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

exec()

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

Execute a shell command in the Sandbox

The command is run by the first available of zsh, bash or sh in the sandbox, which is zsh in the default snapshots. Quote arguments that contain glob characters, for example pip install -e '.[test]', or wrap bash-specific scripts in bash -c '...'.

The call returns when the command finishes. To start a long-running process such as a server, run it in the background with its output redirected, e.g. python3 -m http.server 8000 > server.log 2>&1 &, or use a session with run_async: true (see execute_session_command). A background process that keeps the command's output open (cmd & without a redirect) can block the call until that process exits.

Tools in the sandbox may report the host's CPU count and memory (for example nproc or Etc.nprocessors) rather than the sandbox's own limits. Size worker pools from the sandbox's cpu and memory instead, e.g. pytest -n 2 rather than pytest -n auto.

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:

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

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

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

# Start a server in the background
sandbox.process.exec(command: "python3 -m http.server 8000 > server.log 2>&1 &")

code_run()

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

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:

# 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()

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:

# 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()

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:

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

get_entrypoint_session()

def get_entrypoint_session()

Gets the Sandbox entrypoint session

Returns:

• DaytonaApiClient:Session - Entrypoint session information including session_id and commands

Examples:

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

get_session_command()

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:

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()

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:

# 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()

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:

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()

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:

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()

def get_entrypoint_logs()

Get the sandbox entrypoint logs

Returns:

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

Examples:

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

get_entrypoint_logs_async()

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:

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

send_session_command_input()

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()

def list_sessions()

Returns:

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

Examples:

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

delete_session()

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:

# 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()

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

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:

# 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()

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:

# 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()

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:

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()

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:

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

list_pty_sessions()

def list_pty_sessions()

Lists all PTY sessions in the Sandbox

Returns:

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

Examples:

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()

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:

# 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}"