Process and Code Execution

The Daytona SDK provides powerful process and code execution capabilities through the process module in Sandboxes. This guide covers all available process operations and best practices.

Code Execution

Daytona SDK provides an option to execute code in Python and TypeScript.

Running Code

Daytona SDK provides an option to run code snippets in Python and TypeScript. You can execute code with input, timeout, and environment variables.

Python
TypeScript

# Run Python code
response = sandbox.process.code_run('''
def greet(name):
    return f"Hello, {name}!"

print(greet("Daytona"))
''')

print(response.result)

// Run TypeScript code
const response = await sandbox.process.codeRun(`
function greet(name: string): string {
    return \`Hello, \${name}!\`;
}

console.log(greet("Daytona"));
`);
console.log(response.result);

// Run code with input
const response = await sandbox.process.codeRun(
    'const name = prompt("Enter name: ");\nconsole.log(`Hello, ${name}!`);',
    { input: "Daytona" }
);
console.log(response.result);

// Run code with timeout
const response = await sandbox.process.codeRun(
    'setTimeout(() => console.log("Done"), 2000);',
    { timeout: 5000 }
);
console.log(response.result);

Process Execution

Daytona SDK provides an option to execute shell commands and manage background processes in Sandboxes.

Running Commands

Daytona SDK provides an option to execute shell commands in Python and TypeScript. You can run commands with input, timeout, and environment variables.

Python
TypeScript

# Execute shell command
response = sandbox.process.exec("ls -la")
print(response.output)

// Execute shell command
const response = await sandbox.process.executeCommand("ls -la");
console.log(response.output);

Sessions (Background Processes)

Daytona SDK provides an option to start, stop, and manage background process sessions in Sandboxes. You can run long-running commands, monitor process status, and list all running processes.

Managing Long-Running Processes

Daytona SDK provides an option to start and stop background processes. You can run long-running commands and monitor process status.

Python
TypeScript

# Check session's executed commands
session = sandbox.process.get_session(session_id)
print(f"Session {process_id}:")
for command in session.commands:
    print(f"Command: {command.command}, Exit Code: {command.exit_code}")

# List all running sessions

sessions = sandbox.process.list_sessions()
for session in sessions:
    print(f"PID: {session.id}, Commands: {session.commands}")

// Check session's executed commands
const session = await sandbox.process.getSession(sessionId);
console.log(`Session ${sessionId}:`);
for (const command of session.commands) {
    console.log(`Command: ${command.command}, Exit Code: ${command.exitCode}`);
}

// List all running sessions
const sessions = await sandbox.process.listSessions();
for (const session of sessions) {
    console.log(`PID: ${session.id}, Commands: ${session.commands}`);
}

Best Practices

Daytona SDK provides best practices for process and code execution in Sandboxes.

Resource Management

Use sessions for long-running operations
Clean up sessions after execution
Handle session exceptions properly

Python
TypeScript

# Python - Clean up session
session_id = "long-running-cmd"
try:
    sandbox.process.create_session(session_id)
    session = sandbox.process.get_session(session_id)
    # Do work...
finally:
    sandbox.process.delete_session(session.session_id)

// TypeScript - Clean up session
const sessionId = "long-running-cmd";
try {
    await sandbox.process.createSession(sessionId);
    const session = await sandbox.process.getSession(sessionId);
    // Do work...
} finally {
    await sandbox.process.deleteSession(session.sessionId);
}

Error Handling

Handle process exceptions properly
Log error details for debugging
Use try-catch blocks for error handling

Python
TypeScript

try:
    response = sandbox.process.code_run("invalid python code")
except ProcessExecutionError as e:
    print(f"Execution failed: {e}")
    print(f"Exit code: {e.exit_code}")
    print(f"Error output: {e.stderr}")

try {
    const response = await sandbox.process.codeRun("invalid typescript code");
} catch (e) {
    if (e instanceof ProcessExecutionError) {
        console.error("Execution failed:", e);
        console.error("Exit code:", e.exitCode);
        console.error("Error output:", e.stderr);
    }
}

Common Issues

Daytona SDK provides an option to troubleshoot common issues related to process execution and code execution.

Process Execution Failed

Check command syntax
Verify required dependencies
Ensure sufficient permissions

Process Timeout

Adjust timeout settings
Optimize long-running operations
Consider using background processes

Resource Limits

Monitor process memory usage
Handle process cleanup properly
Use appropriate resource constraints