Address PR review feedback

- Change sidebarTitle to "Interactive terminal"
- Remove imports from JS snippet examples
- Use sync Python code instead of async for examples
- Add user parameter to create examples
- Explain end='' in Python (prevents extra newlines)
- Explain b'' byte string syntax in Python
- Clarify cols/rows are in characters, not pixels
- Clarify sendInput returns Promise, output goes to callback
- Update timeout description to mention "connection to PTY session"

Author: beran-t

docs/sandbox/pty.mdx

@@ -1,6 +1,6 @@
 ---
 title: "Interactive terminal (PTY)"
-sidebarTitle: PTY
+sidebarTitle: Interactive terminal
 ---
 
 The PTY (pseudo-terminal) module allows you to create interactive terminal sessions in the sandbox with real-time, bidirectional communication.
@@ -17,44 +17,38 @@ Use `sandbox.pty.create()` to start an interactive bash shell.
 
 <CodeGroup>
 ```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
 const terminal = await sandbox.pty.create({
-  cols: 80,              // Terminal width in columns
-  rows: 24,              // Terminal height in rows
+  cols: 80,              // Terminal width in characters
+  rows: 24,              // Terminal height in characters
   onData: (data) => {
     // Called whenever terminal outputs data
     process.stdout.write(data)
   },
   envs: { MY_VAR: 'hello' },  // Optional environment variables
   cwd: '/home/user',          // Optional working directory
+  user: 'root',               // Optional user to run as
 })
 
 // terminal.pid contains the process ID
 console.log('Terminal PID:', terminal.pid)
 ```
 
 ```python Python
-from e2b_code_interpreter import AsyncSandbox
-from e2b.sandbox_async.commands.pty import PtySize
-import asyncio
+from e2b_code_interpreter import Sandbox
 
-async def main():
-    sandbox = await AsyncSandbox.create()
+sandbox = Sandbox()
 
-    terminal = await sandbox.pty.create(
-        size=PtySize(cols=80, rows=24),
-        on_data=lambda data: print(data.decode(), end=''),  # Called on output
-        envs={'MY_VAR': 'hello'},  # Optional environment variables
-        cwd='/home/user',          # Optional working directory
-    )
-
-    # terminal.pid contains the process ID
-    print('Terminal PID:', terminal.pid)
+terminal = sandbox.pty.create(
+    cols=80,              # Terminal width in characters
+    rows=24,              # Terminal height in characters
+    on_data=lambda data: print(data.decode(), end=''),  # Prints output without adding newlines
+    envs={'MY_VAR': 'hello'},  # Optional environment variables
+    cwd='/home/user',          # Optional working directory
+    user='root',               # Optional user to run as
+)
 
-asyncio.run(main())
+# terminal.pid contains the process ID
+print('Terminal PID:', terminal.pid)
 ```
 </CodeGroup>
 
@@ -64,7 +58,7 @@ The PTY runs an interactive bash shell with `TERM=xterm-256color`, which support
 
 ## Timeout
 
-By default, PTY sessions have a **60-second timeout** which limits the total duration of the session. When the timeout is reached, the connection will be closed regardless of activity.
+By default, PTY sessions have a **60-second timeout** which limits the total duration of the session. When the timeout is reached, the connection to the PTY session will be closed regardless of activity.
 
 For long-running sessions, set `timeoutMs: 0` (JavaScript) or `timeout=0` (Python) to disable the timeout.
 
@@ -79,8 +73,9 @@ const terminal = await sandbox.pty.create({
 ```
 
 ```python Python
-terminal = await sandbox.pty.create(
-    size=PtySize(cols=80, rows=24),
+terminal = sandbox.pty.create(
+    cols=80,
+    rows=24,
     on_data=lambda data: print(data.decode(), end=''),
     timeout=0,  # No timeout for long-running sessions
 )
@@ -89,14 +84,10 @@ terminal = await sandbox.pty.create(
 
 ## Send input to PTY
 
-Use `sendInput()` in JavaScript or `send_stdin()` in Python to send data to the terminal.
+Use `sendInput()` in JavaScript or `send_stdin()` in Python to send data to the terminal. These methods return a Promise (JavaScript) or complete synchronously (Python) - the actual output will be delivered to your `onData` callback.
 
 <CodeGroup>
 ```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
 const terminal = await sandbox.pty.create({
   cols: 80,
   rows: 24,
@@ -111,65 +102,46 @@ await sandbox.pty.sendInput(
 ```
 
 ```python Python
-from e2b_code_interpreter import AsyncSandbox
-from e2b.sandbox_async.commands.pty import PtySize
-import asyncio
-
-async def main():
-    sandbox = await AsyncSandbox.create()
-
-    terminal = await sandbox.pty.create(
-        size=PtySize(cols=80, rows=24),
-        on_data=lambda data: print(data.decode(), end=''),
-    )
-
-    # Send a command (don't forget the newline!)
-    await sandbox.pty.send_stdin(terminal.pid, b'echo "Hello from PTY"\n')
+terminal = sandbox.pty.create(
+    cols=80,
+    rows=24,
+    on_data=lambda data: print(data.decode(), end=''),
+)
 
-asyncio.run(main())
+# Send a command as bytes (b'...' is Python's byte string syntax)
+# Don't forget the newline!
+sandbox.pty.send_stdin(terminal.pid, b'echo "Hello from PTY"\n')
 ```
 </CodeGroup>
 
 ## Resize the terminal
 
-When the user's terminal window changes size, notify the PTY with `resize()`.
+When the user's terminal window changes size, notify the PTY with `resize()`. The `cols` and `rows` parameters are measured in characters, not pixels.
 
 <CodeGroup>
 ```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
 const terminal = await sandbox.pty.create({
   cols: 80,
   rows: 24,
   onData: (data) => process.stdout.write(data),
 })
 
-// Resize to new dimensions
+// Resize to new dimensions (in characters)
 await sandbox.pty.resize(terminal.pid, {
   cols: 120,
   rows: 40,
 })
 ```
 
 ```python Python
-from e2b_code_interpreter import AsyncSandbox
-from e2b.sandbox_async.commands.pty import PtySize
-import asyncio
-
-async def main():
-    sandbox = await AsyncSandbox.create()
-
-    terminal = await sandbox.pty.create(
-        size=PtySize(cols=80, rows=24),
-        on_data=lambda data: print(data.decode(), end=''),
-    )
-
-    # Resize to new dimensions
-    await sandbox.pty.resize(terminal.pid, PtySize(cols=120, rows=40))
+terminal = sandbox.pty.create(
+    cols=80,
+    rows=24,
+    on_data=lambda data: print(data.decode(), end=''),
+)
 
-asyncio.run(main())
+# Resize to new dimensions (in characters)
+sandbox.pty.resize(terminal.pid, cols=120, rows=40)
 ```
 </CodeGroup>
 
@@ -182,10 +154,6 @@ You can disconnect from a PTY session while keeping it running, then reconnect l
 
 <CodeGroup>
 ```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
 // Create a PTY session
 const terminal = await sandbox.pty.create({
   cols: 80,
@@ -214,41 +182,35 @@ await reconnected.wait()
 ```
 
 ```python Python
-from e2b_code_interpreter import AsyncSandbox
-from e2b.sandbox_async.commands.pty import PtySize
-import asyncio
+import time
 
-async def main():
-    sandbox = await AsyncSandbox.create()
-
-    # Create a PTY session
-    terminal = await sandbox.pty.create(
-        size=PtySize(cols=80, rows=24),
-        on_data=lambda data: print('Handler 1:', data.decode()),
-    )
-
-    pid = terminal.pid
+# Create a PTY session
+terminal = sandbox.pty.create(
+    cols=80,
+    rows=24,
+    on_data=lambda data: print('Handler 1:', data.decode()),
+)
 
-    # Send a command
-    await sandbox.pty.send_stdin(pid, b'echo hello\n')
-    await asyncio.sleep(0.5)
+pid = terminal.pid
 
-    # Disconnect - PTY keeps running in the background
-    await terminal.disconnect()
+# Send a command
+sandbox.pty.send_stdin(pid, b'echo hello\n')
+time.sleep(0.5)
 
-    # Later: reconnect with a new data handler
-    reconnected = await sandbox.pty.connect(
-        pid,
-        on_data=lambda data: print('Handler 2:', data.decode()),
-    )
+# Disconnect - PTY keeps running in the background
+terminal.disconnect()
 
-    # Continue using the session
-    await sandbox.pty.send_stdin(pid, b'echo world\n')
+# Later: reconnect with a new data handler
+reconnected = sandbox.pty.connect(
+    pid,
+    on_data=lambda data: print('Handler 2:', data.decode()),
+)
 
-    # Wait for the terminal to exit
-    await reconnected.wait()
+# Continue using the session
+sandbox.pty.send_stdin(pid, b'echo world\n')
 
-asyncio.run(main())
+# Wait for the terminal to exit
+reconnected.wait()
 ```
 </CodeGroup>
 
@@ -258,10 +220,6 @@ Terminate the PTY session with `kill()`.
 
 <CodeGroup>
 ```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
 const terminal = await sandbox.pty.create({
   cols: 80,
   rows: 24,
@@ -277,26 +235,18 @@ console.log('Killed:', killed)  // true if successful
 ```
 
 ```python Python
-from e2b_code_interpreter import AsyncSandbox
-from e2b.sandbox_async.commands.pty import PtySize
-import asyncio
-
-async def main():
-    sandbox = await AsyncSandbox.create()
-
-    terminal = await sandbox.pty.create(
-        size=PtySize(cols=80, rows=24),
-        on_data=lambda data: print(data.decode(), end=''),
-    )
-
-    # Kill the PTY
-    killed = await sandbox.pty.kill(terminal.pid)
-    print('Killed:', killed)  # True if successful
+terminal = sandbox.pty.create(
+    cols=80,
+    rows=24,
+    on_data=lambda data: print(data.decode(), end=''),
+)
 
-    # Or use the handle method
-    # await terminal.kill()
+# Kill the PTY
+killed = sandbox.pty.kill(terminal.pid)
+print('Killed:', killed)  # True if successful
 
-asyncio.run(main())
+# Or use the handle method
+# terminal.kill()
 ```
 </CodeGroup>
 
@@ -306,10 +256,6 @@ Use `wait()` to wait for the terminal session to end (e.g., when the user types
 
 <CodeGroup>
 ```js JavaScript & TypeScript
-import { Sandbox } from '@e2b/code-interpreter'
-
-const sandbox = await Sandbox.create()
-
 const terminal = await sandbox.pty.create({
   cols: 80,
   rows: 24,
@@ -325,26 +271,18 @@ console.log('Exit code:', result.exitCode)
 ```
 
 ```python Python
-from e2b_code_interpreter import AsyncSandbox
-from e2b.sandbox_async.commands.pty import PtySize
-import asyncio
-
-async def main():
-    sandbox = await AsyncSandbox.create()
-
-    terminal = await sandbox.pty.create(
-        size=PtySize(cols=80, rows=24),
-        on_data=lambda data: print(data.decode(), end=''),
-    )
-
-    # Send exit command
-    await sandbox.pty.send_stdin(terminal.pid, b'exit\n')
+terminal = sandbox.pty.create(
+    cols=80,
+    rows=24,
+    on_data=lambda data: print(data.decode(), end=''),
+)
 
-    # Wait for the terminal to exit
-    result = await terminal.wait()
-    print('Exit code:', result.exit_code)
+# Send exit command
+sandbox.pty.send_stdin(terminal.pid, b'exit\n')
 
-asyncio.run(main())
+# Wait for the terminal to exit
+result = terminal.wait()
+print('Exit code:', result.exit_code)
 ```
 </CodeGroup>