Open-source, secure environment with real-world tools for enterprise-grade agents.
Python agentaiai-agentai-agentscode-interpretercopilotdevelopmentdevtoolsgptgpt-4javascriptllmnextjsopenaipythonreactsoftwaretypescript
[skip ci] Release new versions
github-actions[bot]ee90cd222f5d
diff --git a/.changeset/smooth-foxes-cheat.md b/.changeset/smooth-foxes-cheat.mddeleted file mode 100644index 3a0645052..000000000--- a/.changeset/smooth-foxes-cheat.md+++ /dev/null@@ -1,5 +0,0 @@-----'@e2b/cli': patch------Update error message to display correct key namediff --git a/apps/web/src/app/(docs)/docs/sdk-reference/cli/v1.2.1/auth/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/cli/v1.2.1/auth/page.mdxnew file mode 100644index 000000000..2c82afa69--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/cli/v1.2.1/auth/page.mdx@@ -0,0 +1,58 @@+## e2b auth+++authentication commands++### Usage++```bash+e2b auth [options] [command]+```+## e2b auth login+++log in to CLI++### Usage++```bash+e2b auth login [options]+```+++## e2b auth logout+++log out of CLI++### Usage++```bash+e2b auth logout [options]+```+++## e2b auth info+++get information about the current user++### Usage++```bash+e2b auth info [options]+```+++## e2b auth configure+++configure user++### Usage++```bash+e2b auth configure [options]+```++diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/cli/v1.2.1/sandbox/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/cli/v1.2.1/sandbox/page.mdxnew file mode 100644index 000000000..53c9a5b35--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/cli/v1.2.1/sandbox/page.mdx@@ -0,0 +1,89 @@+## e2b sandbox+++work with sandboxes++### Usage++```bash+e2b sandbox [options] [command]+```+## e2b sandbox connect+++connect terminal to already running sandbox++### Usage++```bash+e2b sandbox connect [options] <sandboxID>+```+++## e2b sandbox list+++list all running sandboxes++### Usage++```bash+e2b sandbox list [options]+```+++## e2b sandbox kill+++kill sandbox++### Usage++```bash+e2b sandbox kill [options] [sandboxID]+```++### Options+++ - `-a, --all: kill all running sandboxes `+++## e2b sandbox spawn+++spawn sandbox and connect terminal to it++### Usage++```bash+e2b sandbox spawn [options] [template]+```++### Options+++ - `-p, --path <path>: change root directory where command is executed to <path> directory `+ - `--config <e2b-toml>: specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `+++## e2b sandbox logs+++show logs for sandbox++### Usage++```bash+e2b sandbox logs [options] <sandboxID>+```++### Options+++ - `--level <level>: filter logs by level (DEBUG, INFO, WARN, ERROR). The logs with the higher levels will be also shown. [default: INFO]`+ - `-f, --follow: keep streaming logs until the sandbox is closed `+ - `--format <format>: specify format for printing logs (json, pretty) [default: pretty]`+ - `--loggers [loggers]: filter logs by loggers. Specify multiple loggers by separating them with a comma. `++diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/cli/v1.2.1/template/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/cli/v1.2.1/template/page.mdxnew file mode 100644index 000000000..1211bb3b0--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/cli/v1.2.1/template/page.mdx@@ -0,0 +1,132 @@+## e2b template+++manage sandbox templates++### Usage++```bash+e2b template [options] [command]+```+## e2b template build+++build sandbox template defined by ./e2b.Dockerfile or ./Dockerfile in root directory. By default the root directory is the current working directory. This command also creates e2b.toml config.++### Usage++```bash+e2b template build [options] [template]+```++### Options+++ - `-p, --path <path>: change root directory where command is executed to <path> directory `+ - `-d, --dockerfile <file>: specify path to Dockerfile. By default E2B tries to find e2b.Dockerfile or Dockerfile in root directory. `+ - `-n, --name <template-name>: specify sandbox template name. You can use the template name to start the sandbox with SDK. The template name must be lowercase and contain only letters, numbers, dashes and underscores. `+ - `-c, --cmd <start-command>: specify command that will be executed when the sandbox is started. `+ - `-t, --team <team-id>: specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `+ - `--config <e2b-toml>: specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `+ - `--cpu-count <cpu-count>: specify the number of CPUs that will be used to run the sandbox. The default value is 2. `+ - `--memory-mb <memory-mb>: specify the amount of memory in megabytes that will be used to run the sandbox. Must be an even number. The default value is 512. `+ - `--build-arg <args...>: specify additional build arguments for the build command. The format should be <varname>=<value>. `+++## e2b template list+++list sandbox templates++### Usage++```bash+e2b template list [options]+```++### Options+++ - `-t, --team <team-id>: specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `+++## e2b template init+++create basic E2B Dockerfile (./e2b.Dockerfile) in root directory. You can then run e2b template build to build sandbox template from this Dockerfile++### Usage++```bash+e2b template init [options]+```++### Options+++ - `-p, --path <path>: change root directory where command is executed to <path> directory `+++## e2b template delete+++delete sandbox template and e2b.toml config++### Usage++```bash+e2b template delete [options] [template]+```++### Options+++ - `-p, --path <path>: change root directory where command is executed to <path> directory `+ - `--config <e2b-toml>: specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `+ - `-s, --select: select sandbox template from interactive list `+ - `-t, --team <team-id>: specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `+ - `-y, --yes: skip manual delete confirmation `+++## e2b template publish+++publish sandbox template++### Usage++```bash+e2b template publish [options] [template]+```++### Options+++ - `-p, --path <path>: change root directory where command is executed to <path> directory `+ - `--config <e2b-toml>: specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `+ - `-s, --select: select sandbox template from interactive list `+ - `-t, --team <team-id>: specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `+ - `-y, --yes: skip manual publish confirmation `+++## e2b template unpublish+++unpublish sandbox template++### Usage++```bash+e2b template unpublish [options] [template]+```++### Options+++ - `-p, --path <path>: change root directory where command is executed to <path> directory `+ - `--config <e2b-toml>: specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `+ - `-s, --select: select sandbox template from interactive list `+ - `-t, --team <team-id>: specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `+ - `-y, --yes: skip manual unpublish confirmation `++diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.1.0/sandbox_async/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.1.0/sandbox_async/page.mdxindex 209e48623..fc77f68f5 100644--- a/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.1.0/sandbox_async/page.mdx+++ b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.1.0/sandbox_async/page.mdx@@ -1,432 +1,455 @@-## SandboxApi--```python-class SandboxApi(SandboxApiBase)-```---### list+## AsyncCommandHandle```python-@classmethod-async def list(cls,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- request_timeout: Optional[float] = None) -> List[SandboxInfo]+class AsyncCommandHandle()```-List all running sandboxes.--**Arguments**:+Command execution handle.-- `api_key`: API key to use for authentication, defaults to `E2B_API_KEY` environment variable-- `request_timeout`: Timeout for the request in **seconds**+It provides methods for waiting for the command to finish, retrieving stdout/stderr, and killing the command.-**Returns**:-List of running sandboxes+### pid+```python+@property+def pid()+```+Command process ID.-## AsyncWatchHandle+### stdout```python-class AsyncWatchHandle()+@property+def stdout()```-Handle for watching a directory in the sandbox filesystem.--Use `.stop()` to stop watching the directory.+Command stdout output.-### stop+### stderr```python-async def stop()+@property+def stderr()```-Stop watching the directory.--+Command stderr output.-## Filesystem+### error```python-class Filesystem()+@property+def error()```-Module for interacting with the filesystem in the sandbox.+Command execution error message.-### read+### exit\_code```python-@overload-async def read(path: str,- format: Literal["text"] = "text",- user: Username = "user",- request_timeout: Optional[float] = None) -> str+@property+def exit_code()```-Read file content as a `str`.--**Arguments**:--- `path`: Path to the file-- `user`: Run the operation as this user-- `format`: Format of the file content—`text` by default-- `request_timeout`: Timeout for the request in **seconds**+Command execution exit code.-**Returns**:+`0` if the command finished successfully.-File content as a `str`+It is `None` if the command is still running.-### read+### disconnect```python-@overload-async def read(path: str,- format: Literal["bytes"],- user: Username = "user",- request_timeout: Optional[float] = None) -> bytearray+async def disconnect() -> None```-Read file content as a `bytearray`.--**Arguments**:--- `path`: Path to the file-- `user`: Run the operation as this user-- `format`: Format of the file content—`bytes`-- `request_timeout`: Timeout for the request in **seconds**--**Returns**:+Disconnects from the command.-File content as a `bytearray`+The command is not killed, but SDK stops receiving events from the command.+You can reconnect to the command using `sandbox.commands.connect` method.-### read+### wait```python-@overload-async def read(- path: str,- format: Literal["stream"],- user: Username = "user",- request_timeout: Optional[float] = None) -> AsyncIterator[bytes]+async def wait() -> CommandResult```-Read file content as a `AsyncIterator[bytes]`.--**Arguments**:+Wait for the command to finish and return the result.-- `path`: Path to the file-- `user`: Run the operation as this user-- `format`: Format of the file content—`stream`-- `request_timeout`: Timeout for the request in **seconds**+If the command exits with a non-zero exit code, it throws a `CommandExitException`.**Returns**:-File content as an `AsyncIterator[bytes]`+`CommandResult` result of command execution-### write+### kill```python-async def write(path: str,- data: Union[str, bytes, IO],- user: Username = "user",- request_timeout: Optional[float] = None) -> EntryInfo+async def kill() -> bool```-Write content to a file on the path.+Kills the command.-Writing to a file that doesn't exist creates the file.+It uses `SIGKILL` signal to kill the command-Writing to a file that already exists overwrites the file.+**Returns**:-Writing to a file at path that doesn't exist creates the necessary directories.+`True` if the command was killed successfully, `False` if the command was not found-**Arguments**:-- `path`: Path to the file-- `data`: Data to write to the file, can be a `str`, `bytes`, or `IO`.-- `user`: Run the operation as this user-- `request_timeout`: Timeout for the request in **seconds**-**Returns**:-Information about the written file+## Commands++```python+class Commands()+```++Module for executing commands in the sandbox.### list```python-async def list(path: str,- user: Username = "user",- request_timeout: Optional[float] = None) -> List[EntryInfo]+async def list(request_timeout: Optional[float] = None) -> List[ProcessInfo]```-List entries in a directory.+Lists all running commands and PTY sessions.**Arguments**:-- `path`: Path to the directory-- `user`: Run the operation as this user- `request_timeout`: Timeout for the request in **seconds****Returns**:-List of entries in the directory+List of running commands and PTY sessions-### exists+### kill```python-async def exists(path: str,- user: Username = "user",- request_timeout: Optional[float] = None) -> bool+async def kill(pid: int, request_timeout: Optional[float] = None) -> bool```-Check if a file or a directory exists.+Kill a running command specified by its process ID.++It uses `SIGKILL` signal to kill the command.**Arguments**:-- `path`: Path to a file or a directory-- `user`: Run the operation as this user+- `pid`: Process ID of the command. You can get the list of processes using `sandbox.commands.list()`- `request_timeout`: Timeout for the request in **seconds****Returns**:-`True` if the file or directory exists, `False` otherwise+`True` if the command was killed, `False` if the command was not found-### remove+### send\_stdin```python-async def remove(path: str,- user: Username = "user",- request_timeout: Optional[float] = None) -> None+async def send_stdin(pid: int,+ data: str,+ request_timeout: Optional[float] = None) -> None```-Remove a file or a directory.+Send data to command stdin.-**Arguments**:+:param pid Process ID of the command. You can get the list of processes using `sandbox.commands.list()`.+:param data: Data to send to the command+:param request_timeout: Timeout for the request in **seconds**-- `path`: Path to a file or a directory-- `user`: Run the operation as this user-- `request_timeout`: Timeout for the request in **seconds**-### rename+### run```python-async def rename(old_path: str,- new_path: str,- user: Username = "user",- request_timeout: Optional[float] = None) -> EntryInfo+@overload+async def run(cmd: str,+ background: Union[Literal[False], None] = None,+ envs: Optional[Dict[str, str]] = None,+ user: Username = "user",+ cwd: Optional[str] = None,+ on_stdout: Optional[OutputHandler[Stdout]] = None,+ on_stderr: Optional[OutputHandler[Stderr]] = None,+ timeout: Optional[float] = 60,+ request_timeout: Optional[float] = None) -> CommandResult```-Rename a file or directory.+Start a new command and wait until it finishes executing.**Arguments**:-- `old_path`: Path to the file or directory to rename-- `new_path`: New path to the file or directory-- `user`: Run the operation as this user+- `cmd`: Command to execute+- `background`: **`False` if the command should be executed in the foreground**, `True` if the command should be executed in the background+- `envs`: Environment variables used for the command+- `user`: User to run the command as+- `cwd`: Working directory to run the command+- `on_stdout`: Callback for command stdout output+- `on_stderr`: Callback for command stderr output+- `timeout`: Timeout for the command connection in **seconds**. Using `0` will not limit the command connection time- `request_timeout`: Timeout for the request in **seconds****Returns**:-Information about the renamed file or directory+`CommandResult` result of the command execution-### make\_dir+### run```python-async def make_dir(path: str,- user: Username = "user",- request_timeout: Optional[float] = None) -> bool+@overload+async def run(cmd: str,+ background: Literal[True],+ envs: Optional[Dict[str, str]] = None,+ user: Username = "user",+ cwd: Optional[str] = None,+ on_stdout: Optional[OutputHandler[Stdout]] = None,+ on_stderr: Optional[OutputHandler[Stderr]] = None,+ timeout: Optional[float] = 60,+ request_timeout: Optional[float] = None) -> AsyncCommandHandle```-Create a new directory and all directories along the way if needed on the specified path.+Start a new command and return a handle to interact with it.**Arguments**:-- `path`: Path to a new directory. For example '/dirA/dirB' when creating 'dirB'.-- `user`: Run the operation as this user+- `cmd`: Command to execute+- `background`: `False` if the command should be executed in the foreground, **`True` if the command should be executed in the background**+- `envs`: Environment variables used for the command+- `user`: User to run the command as+- `cwd`: Working directory to run the command+- `on_stdout`: Callback for command stdout output+- `on_stderr`: Callback for command stderr output+- `timeout`: Timeout for the command connection in **seconds**. Using `0` will not limit the command connection time- `request_timeout`: Timeout for the request in **seconds****Returns**:-`True` if the directory was created, `False` if the directory already exists+`AsyncCommandHandle` handle to interact with the running command-### watch\_dir+### connect```python-async def watch_dir(path: str,- on_event: OutputHandler[FilesystemEvent],- on_exit: Optional[OutputHandler[Exception]] = None,- user: Username = "user",- request_timeout: Optional[float] = None,- timeout: Optional[float] = 60,- recursive: bool = False) -> AsyncWatchHandle+async def connect(+ pid: int,+ timeout: Optional[float] = 60,+ request_timeout: Optional[float] = None,+ on_stdout: Optional[OutputHandler[Stdout]] = None,+ on_stderr: Optional[OutputHandler[Stderr]] = None+) -> AsyncCommandHandle```-Watch directory for filesystem events.+Connects to a running command.++You can use `AsyncCommandHandle.wait()` to wait for the command to finish and get execution results.**Arguments**:-- `path`: Path to a directory to watch-- `on_event`: Callback to call on each event in the directory-- `on_exit`: Callback to call when the watching ends-- `user`: Run the operation as this user-- `request_timeout`: Timeout for the request in **seconds**-- `timeout`: Timeout for the watch operation in **seconds**. Using `0` will not limit the watch time-- `recursive`: Watch directory recursively+- `pid`: Process ID of the command to connect to. You can get the list of processes using `sandbox.commands.list()`+- `request_timeout`: Request timeout in **seconds**+- `timeout`: Timeout for the command connection in **seconds**. Using `0` will not limit the command connection time+- `on_stdout`: Callback for command stdout output+- `on_stderr`: Callback for command stderr output**Returns**:-`AsyncWatchHandle` object for stopping watching directory--+`AsyncCommandHandle` handle to interact with the running command-## AsyncCommandHandle+## Pty```python-class AsyncCommandHandle()+class Pty()```-Command execution handle.--It provides methods for waiting for the command to finish, retrieving stdout/stderr, and killing the command.+Module for interacting with PTYs (pseudo-terminals) in the sandbox.-### pid+### kill```python-@property-def pid()+async def kill(pid: int, request_timeout: Optional[float] = None) -> bool```-Command process ID.+Kill PTY.+**Arguments**:-### stdout+- `pid`: Process ID of the PTY+- `request_timeout`: Timeout for the request in **seconds**-```python-@property-def stdout()-```+**Returns**:-Command stdout output.+`true` if the PTY was killed, `false` if the PTY was not found-### stderr+### send\_stdin```python-@property-def stderr()+async def send_stdin(pid: int,+ data: bytes,+ request_timeout: Optional[float] = None) -> None```-Command stderr output.+Send input to a PTY.+**Arguments**:++- `pid`: Process ID of the PTY+- `data`: Input data to send+- `request_timeout`: Timeout for the request in **seconds**-### error++### create```python-@property-def error()+async def create(+ size: PtySize,+ on_data: OutputHandler[PtyOutput],+ user: Username = "user",+ cwd: Optional[str] = None,+ envs: Optional[Dict[str, str]] = None,+ timeout: Optional[float] = 60,+ request_timeout: Optional[float] = None) -> AsyncCommandHandle```-Command execution error message.+Start a new PTY (pseudo-terminal).+**Arguments**:++- `size`: Size of the PTY+- `on_data`: Callback to handle PTY data+- `user`: User to use for the PTY+- `cwd`: Working directory for the PTY+- `envs`: Environment variables for the PTY+- `timeout`: Timeout for the PTY in **seconds**+- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++Handle to interact with the PTY-### exit\_code++### resize```python-@property-def exit_code()+async def resize(pid: int,+ size: PtySize,+ request_timeout: Optional[float] = None)```-Command execution exit code.+Resize PTY.-`0` if the command finished successfully.+Call this when the terminal window is resized and the number of columns and rows has changed.-It is `None` if the command is still running.+**Arguments**:++- `pid`: Process ID of the PTY+- `size`: New size of the PTY+- `request_timeout`: Timeout for the request in **seconds**-### disconnect+++## AsyncSandbox```python-async def disconnect() -> None+class AsyncSandbox(SandboxSetup, SandboxApi)```-Disconnects from the command.+E2B cloud sandbox is a secure and isolated cloud environment.-The command is not killed, but SDK stops receiving events from the command.-You can reconnect to the command using `sandbox.commands.connect` method.+The sandbox allows you to:+- Access Linux OS+- Create, list, and delete files and directories+- Run commands+- Run isolated code+- Access the internet+Check docs [here](https://e2b.dev/docs).-### wait+Use the `AsyncSandbox.create()` to create a new sandbox.++**Example**:```python-async def wait() -> CommandResult+from e2b import AsyncSandbox++sandbox = await AsyncSandbox.create()```-Wait for the command to finish and return the result.-If the command exits with a non-zero exit code, it throws a `CommandExitException`.+### files-**Returns**:+```python+@property+def files() -> Filesystem+```-`CommandResult` result of command execution+Module for interacting with the sandbox filesystem.-### kill+### commands```python-async def kill() -> bool+@property+def commands() -> Commands```-Kills the command.+Module for running commands in the sandbox.-It uses `SIGKILL` signal to kill the command-**Returns**:+### pty-`True` if the command was killed successfully, `False` if the command was not found+```python+@property+def pty() -> Pty+```++Module for interacting with the sandbox pseudo-terminal.+### sandbox\_id+```python+@property+def sandbox_id() -> str+```-## Commands+Unique identifier of the sandbox.+++### \_\_init\_\_```python-class Commands()+def __init__(**opts: Unpack[AsyncSandboxOpts])```-Module for executing commands in the sandbox.+Use `AsyncSandbox.create()` to create a new sandbox instead.-### list+### is\_running```python-async def list(request_timeout: Optional[float] = None) -> List[ProcessInfo]+async def is_running(request_timeout: Optional[float] = None) -> bool```-Lists all running commands and PTY sessions.+Check if the sandbox is running.**Arguments**:@@ -434,493 +457,470 @@ Lists all running commands and PTY sessions.**Returns**:-List of running commands and PTY sessions+`True` if the sandbox is running, `False` otherwise+Example+```python+sandbox = await AsyncSandbox.create()+await sandbox.is_running() # Returns True++await sandbox.kill()+await sandbox.is_running() # Returns False+```-### kill+### create```python-async def kill(pid: int, request_timeout: Optional[float] = None) -> bool+@classmethod+async def create(cls,+ template: Optional[str] = None,+ timeout: Optional[int] = None,+ metadata: Optional[Dict[str, str]] = None,+ envs: Optional[Dict[str, str]] = None,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ request_timeout: Optional[float] = None)```-Kill a running command specified by its process ID.+Create a new sandbox.-It uses `SIGKILL` signal to kill the command.+By default, the sandbox is created from the default `base` sandbox template.**Arguments**:-- `pid`: Process ID of the command. You can get the list of processes using `sandbox.commands.list()`+- `template`: Sandbox template name or ID+- `timeout`: Timeout for the sandbox in **seconds**, default to 300 seconds. Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.+- `metadata`: Custom metadata for the sandbox+- `envs`: Custom environment variables for the sandbox+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable- `request_timeout`: Timeout for the request in **seconds****Returns**:-`True` if the command was killed, `False` if the command was not found+sandbox instance for the new sandbox+Use this method instead of using the constructor to create a new sandbox.-### send\_stdin+### connect```python-async def send_stdin(pid: int,- data: str,- request_timeout: Optional[float] = None) -> None+@classmethod+async def connect(cls,+ sandbox_id: str,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None)```-Send data to command stdin.+Connect to an existing sandbox.-:param pid Process ID of the command. You can get the list of processes using `sandbox.commands.list()`.-:param data: Data to send to the command-:param request_timeout: Timeout for the request in **seconds**+With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).+**Arguments**:+- `sandbox_id`: Sandbox ID+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable-### run+**Returns**:+sandbox instance for the existing sandbox+@example```python-@overload-async def run(cmd: str,- background: Union[Literal[False], None] = None,- envs: Optional[Dict[str, str]] = None,- user: Username = "user",- cwd: Optional[str] = None,- on_stdout: Optional[OutputHandler[Stdout]] = None,- on_stderr: Optional[OutputHandler[Stderr]] = None,- timeout: Optional[float] = 60,- request_timeout: Optional[float] = None) -> CommandResult+sandbox = await AsyncSandbox.create()+sandbox_id = sandbox.sandbox_id++same_sandbox = await AsyncSandbox.connect(sandbox_id)+++### kill++```python+@overload+async def kill(request_timeout: Optional[float] = None) -> bool```-Start a new command and wait until it finishes executing.+Kill the sandbox.**Arguments**:-- `cmd`: Command to execute-- `background`: **`False` if the command should be executed in the foreground**, `True` if the command should be executed in the background-- `envs`: Environment variables used for the command-- `user`: User to run the command as-- `cwd`: Working directory to run the command-- `on_stdout`: Callback for command stdout output-- `on_stderr`: Callback for command stderr output-- `timeout`: Timeout for the command connection in **seconds**. Using `0` will not limit the command connection time- `request_timeout`: Timeout for the request in **seconds****Returns**:-`CommandResult` result of the command execution+`True` if the sandbox was killed, `False` if the sandbox was not found-### run+### kill```python@overload-async def run(cmd: str,- background: Literal[True],- envs: Optional[Dict[str, str]] = None,- user: Username = "user",- cwd: Optional[str] = None,- on_stdout: Optional[OutputHandler[Stdout]] = None,- on_stderr: Optional[OutputHandler[Stderr]] = None,- timeout: Optional[float] = 60,- request_timeout: Optional[float] = None) -> AsyncCommandHandle+@staticmethod+async def kill(sandbox_id: str,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ request_timeout: Optional[float] = None) -> bool```-Start a new command and return a handle to interact with it.+Kill the sandbox specified by sandbox ID.**Arguments**:-- `cmd`: Command to execute-- `background`: `False` if the command should be executed in the foreground, **`True` if the command should be executed in the background**-- `envs`: Environment variables used for the command-- `user`: User to run the command as-- `cwd`: Working directory to run the command-- `on_stdout`: Callback for command stdout output-- `on_stderr`: Callback for command stderr output-- `timeout`: Timeout for the command connection in **seconds**. Using `0` will not limit the command connection time+- `sandbox_id`: Sandbox ID+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable- `request_timeout`: Timeout for the request in **seconds****Returns**:-`AsyncCommandHandle` handle to interact with the running command+`True` if the sandbox was killed, `False` if the sandbox was not found-### connect+### set\_timeout```python-async def connect(- pid: int,- timeout: Optional[float] = 60,- request_timeout: Optional[float] = None,- on_stdout: Optional[OutputHandler[Stdout]] = None,- on_stderr: Optional[OutputHandler[Stderr]] = None-) -> AsyncCommandHandle+@overload+async def set_timeout(timeout: int,+ request_timeout: Optional[float] = None) -> None```-Connects to a running command.--You can use `AsyncCommandHandle.wait()` to wait for the command to finish and get execution results.--**Arguments**:--- `pid`: Process ID of the command to connect to. You can get the list of processes using `sandbox.commands.list()`-- `request_timeout`: Request timeout in **seconds**-- `timeout`: Timeout for the command connection in **seconds**. Using `0` will not limit the command connection time-- `on_stdout`: Callback for command stdout output-- `on_stderr`: Callback for command stderr output+Set the timeout of the sandbox.-**Returns**:+After the timeout expires the sandbox will be automatically killed.+This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.-`AsyncCommandHandle` handle to interact with the running command+Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.+**Arguments**:+- `timeout`: Timeout for the sandbox in **seconds**+- `request_timeout`: Timeout for the request in **seconds**-## Pty+### set\_timeout```python-class Pty()+@overload+@staticmethod+async def set_timeout(sandbox_id: str,+ timeout: int,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ request_timeout: Optional[float] = None) -> None```-Module for interacting with PTYs (pseudo-terminals) in the sandbox.---### kill+Set the timeout of the specified sandbox.-```python-async def kill(pid: int, request_timeout: Optional[float] = None) -> bool-```+After the timeout expires the sandbox will be automatically killed.+This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.-Kill PTY.+Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.**Arguments**:-- `pid`: Process ID of the PTY+- `sandbox_id`: Sandbox ID+- `timeout`: Timeout for the sandbox in **seconds**- `request_timeout`: Timeout for the request in **seconds**-**Returns**:-`true` if the PTY was killed, `false` if the PTY was not found-### send\_stdin+## Filesystem```python-async def send_stdin(pid: int,- data: bytes,- request_timeout: Optional[float] = None) -> None+class Filesystem()```-Send input to a PTY.--**Arguments**:--- `pid`: Process ID of the PTY-- `data`: Input data to send-- `request_timeout`: Timeout for the request in **seconds**+Module for interacting with the filesystem in the sandbox.-### create+### read```python-async def create(- size: PtySize,- on_data: OutputHandler[PtyOutput],- user: Username = "user",- cwd: Optional[str] = None,- envs: Optional[Dict[str, str]] = None,- timeout: Optional[float] = 60,- request_timeout: Optional[float] = None) -> AsyncCommandHandle+@overload+async def read(path: str,+ format: Literal["text"] = "text",+ user: Username = "user",+ request_timeout: Optional[float] = None) -> str```-Start a new PTY (pseudo-terminal).+Read file content as a `str`.**Arguments**:-- `size`: Size of the PTY-- `on_data`: Callback to handle PTY data-- `user`: User to use for the PTY-- `cwd`: Working directory for the PTY-- `envs`: Environment variables for the PTY-- `timeout`: Timeout for the PTY in **seconds**+- `path`: Path to the file+- `user`: Run the operation as this user+- `format`: Format of the file content—`text` by default- `request_timeout`: Timeout for the request in **seconds****Returns**:-Handle to interact with the PTY+File content as a `str`-### resize+### read```python-async def resize(pid: int,- size: PtySize,- request_timeout: Optional[float] = None)+@overload+async def read(path: str,+ format: Literal["bytes"],+ user: Username = "user",+ request_timeout: Optional[float] = None) -> bytearray```-Resize PTY.--Call this when the terminal window is resized and the number of columns and rows has changed.+Read file content as a `bytearray`.**Arguments**:-- `pid`: Process ID of the PTY-- `size`: New size of the PTY+- `path`: Path to the file+- `user`: Run the operation as this user+- `format`: Format of the file content—`bytes`- `request_timeout`: Timeout for the request in **seconds**+**Returns**:+File content as a `bytearray`-## AsyncSandbox+### read```python-class AsyncSandbox(SandboxSetup, SandboxApi)+@overload+async def read(+ path: str,+ format: Literal["stream"],+ user: Username = "user",+ request_timeout: Optional[float] = None) -> AsyncIterator[bytes]```-E2B cloud sandbox is a secure and isolated cloud environment.--The sandbox allows you to:-- Access Linux OS-- Create, list, and delete files and directories-- Run commands-- Run isolated code-- Access the internet--Check docs [here](https://e2b.dev/docs).+Read file content as a `AsyncIterator[bytes]`.-Use the `AsyncSandbox.create()` to create a new sandbox.+**Arguments**:-**Example**:+- `path`: Path to the file+- `user`: Run the operation as this user+- `format`: Format of the file content—`stream`+- `request_timeout`: Timeout for the request in **seconds**-```python-from e2b import AsyncSandbox+**Returns**:-sandbox = await AsyncSandbox.create()-```+File content as an `AsyncIterator[bytes]`-### files+### write```python-@property-def files() -> Filesystem+async def write(path: str,+ data: Union[str, bytes, IO],+ user: Username = "user",+ request_timeout: Optional[float] = None) -> EntryInfo```-Module for interacting with the sandbox filesystem.-+Write content to a file on the path.-### commands+Writing to a file that doesn't exist creates the file.-```python-@property-def commands() -> Commands-```+Writing to a file that already exists overwrites the file.-Module for running commands in the sandbox.+Writing to a file at path that doesn't exist creates the necessary directories.+**Arguments**:-### pty+- `path`: Path to the file+- `data`: Data to write to the file, can be a `str`, `bytes`, or `IO`.+- `user`: Run the operation as this user+- `request_timeout`: Timeout for the request in **seconds**-```python-@property-def pty() -> Pty-```+**Returns**:-Module for interacting with the sandbox pseudo-terminal.+Information about the written file-### sandbox\_id+### list```python-@property-def sandbox_id() -> str+async def list(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> List[EntryInfo]```-Unique identifier of the sandbox.+List entries in a directory.+**Arguments**:-### \_\_init\_\_+- `path`: Path to the directory+- `user`: Run the operation as this user+- `request_timeout`: Timeout for the request in **seconds**-```python-def __init__(**opts: Unpack[AsyncSandboxOpts])-```+**Returns**:-Use `AsyncSandbox.create()` to create a new sandbox instead.+List of entries in the directory-### is\_running+### exists```python-async def is_running(request_timeout: Optional[float] = None) -> bool+async def exists(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> bool```-Check if the sandbox is running.+Check if a file or a directory exists.**Arguments**:+- `path`: Path to a file or a directory+- `user`: Run the operation as this user- `request_timeout`: Timeout for the request in **seconds****Returns**:-`True` if the sandbox is running, `False` otherwise-Example-```python-sandbox = await AsyncSandbox.create()-await sandbox.is_running() # Returns True--await sandbox.kill()-await sandbox.is_running() # Returns False-```+`True` if the file or directory exists, `False` otherwise-### create+### remove```python-@classmethod-async def create(cls,- template: Optional[str] = None,- timeout: Optional[int] = None,- metadata: Optional[Dict[str, str]] = None,- envs: Optional[Dict[str, str]] = None,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- request_timeout: Optional[float] = None)+async def remove(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> None```-Create a new sandbox.--By default, the sandbox is created from the default `base` sandbox template.+Remove a file or a directory.**Arguments**:-- `template`: Sandbox template name or ID-- `timeout`: Timeout for the sandbox in **seconds**, default to 300 seconds. Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.-- `metadata`: Custom metadata for the sandbox-- `envs`: Custom environment variables for the sandbox-- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `path`: Path to a file or a directory+- `user`: Run the operation as this user- `request_timeout`: Timeout for the request in **seconds**-**Returns**:--sandbox instance for the new sandbox-Use this method instead of using the constructor to create a new sandbox.--### connect+### rename```python-@classmethod-async def connect(cls,- sandbox_id: str,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None)+async def rename(old_path: str,+ new_path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> EntryInfo```-Connect to an existing sandbox.--With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).+Rename a file or directory.**Arguments**:-- `sandbox_id`: Sandbox ID-- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `old_path`: Path to the file or directory to rename+- `new_path`: New path to the file or directory+- `user`: Run the operation as this user+- `request_timeout`: Timeout for the request in **seconds****Returns**:-sandbox instance for the existing sandbox-@example-```python-sandbox = await AsyncSandbox.create()-sandbox_id = sandbox.sandbox_id--same_sandbox = await AsyncSandbox.connect(sandbox_id)+Information about the renamed file or directory-### kill+### make\_dir```python-@overload-async def kill(request_timeout: Optional[float] = None) -> bool+async def make_dir(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> bool```-Kill the sandbox.+Create a new directory and all directories along the way if needed on the specified path.**Arguments**:+- `path`: Path to a new directory. For example '/dirA/dirB' when creating 'dirB'.+- `user`: Run the operation as this user- `request_timeout`: Timeout for the request in **seconds****Returns**:-`True` if the sandbox was killed, `False` if the sandbox was not found+`True` if the directory was created, `False` if the directory already exists-### kill+### watch\_dir```python-@overload-@staticmethod-async def kill(sandbox_id: str,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- request_timeout: Optional[float] = None) -> bool+async def watch_dir(path: str,+ on_event: OutputHandler[FilesystemEvent],+ on_exit: Optional[OutputHandler[Exception]] = None,+ user: Username = "user",+ request_timeout: Optional[float] = None,+ timeout: Optional[float] = 60,+ recursive: bool = False) -> AsyncWatchHandle```-Kill the sandbox specified by sandbox ID.+Watch directory for filesystem events.**Arguments**:-- `sandbox_id`: Sandbox ID-- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `path`: Path to a directory to watch+- `on_event`: Callback to call on each event in the directory+- `on_exit`: Callback to call when the watching ends+- `user`: Run the operation as this user- `request_timeout`: Timeout for the request in **seconds**+- `timeout`: Timeout for the watch operation in **seconds**. Using `0` will not limit the watch time+- `recursive`: Watch directory recursively**Returns**:-`True` if the sandbox was killed, `False` if the sandbox was not found+`AsyncWatchHandle` object for stopping watching directory-### set\_timeout+++## AsyncWatchHandle```python-@overload-async def set_timeout(timeout: int,- request_timeout: Optional[float] = None) -> None+class AsyncWatchHandle()```-Set the timeout of the sandbox.+Handle for watching a directory in the sandbox filesystem.-After the timeout expires the sandbox will be automatically killed.-This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.+Use `.stop()` to stop watching the directory.-Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.-**Arguments**:+### stop++```python+async def stop()+```++Stop watching the directory.-- `timeout`: Timeout for the sandbox in **seconds**-- `request_timeout`: Timeout for the request in **seconds**-### set\_timeout++## SandboxApi```python-@overload-@staticmethod-async def set_timeout(sandbox_id: str,- timeout: int,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- request_timeout: Optional[float] = None) -> None+class SandboxApi(SandboxApiBase)```-Set the timeout of the specified sandbox.-After the timeout expires the sandbox will be automatically killed.-This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.+### list-Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.+```python+@classmethod+async def list(cls,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ request_timeout: Optional[float] = None) -> List[SandboxInfo]+```++List all running sandboxes.**Arguments**:-- `sandbox_id`: Sandbox ID-- `timeout`: Timeout for the sandbox in **seconds**+- `api_key`: API key to use for authentication, defaults to `E2B_API_KEY` environment variable- `request_timeout`: Timeout for the request in **seconds**+**Returns**:++List of running sandboxes+++diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.1.0/sandbox_sync/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.1.0/sandbox_sync/page.mdxindex 24c2d59b6..2443f6c5a 100644--- a/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.1.0/sandbox_sync/page.mdx+++ b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.1.0/sandbox_sync/page.mdx@@ -1,904 +1,904 @@-## SandboxApi+## CommandHandle```python-class SandboxApi(SandboxApiBase)+class CommandHandle()```+Command execution handle.++It provides methods for waiting for the command to finish, retrieving stdout/stderr, and killing the command.-### list++### pid```python-@classmethod-def list(cls,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- request_timeout: Optional[float] = None) -> List[SandboxInfo]+@property+def pid()```-List all running sandboxes.+Command process ID.-**Arguments**:-- `api_key`: API key to use for authentication, defaults to `E2B_API_KEY` environment variable-- `request_timeout`: Timeout for the request in **seconds**+### \_\_iter\_\_-**Returns**:+```python+def __iter__()+```-List of sandbox info+Iterate over the command output.+**Returns**:+Generator of command outputs-## WatchHandle+### disconnect```python-class WatchHandle()+def disconnect() -> None```-Handle for watching filesystem events.-It is used to get the latest events that have occurred in the watched directory.+Disconnect from the command.-Use `.stop()` to stop watching the directory.+The command is not killed, but SDK stops receiving events from the command.+You can reconnect to the command using `sandbox.commands.connect` method.-### stop+### wait```python-def stop()+def wait(on_pty: Optional[Callable[[PtyOutput], None]] = None,+ on_stdout: Optional[Callable[[str], None]] = None,+ on_stderr: Optional[Callable[[str], None]] = None) -> CommandResult```-Stop watching the directory.-After you stop the watcher you won't be able to get the events anymore.+Wait for the command to finish and returns the result.++If the command exits with a non-zero exit code, it throws a `CommandExitException`.+**Arguments**:-### get\_new\_events+- `on_pty`: Callback for pty output+- `on_stdout`: Callback for stdout output+- `on_stderr`: Callback for stderr output++**Returns**:++`CommandResult` result of command execution+++### kill```python-def get_new_events() -> List[FilesystemEvent]+def kill() -> bool```-Get the latest events that have occurred in the watched directory since the last call, or from the beginning of the watching, up until now.+Kills the command.++It uses `SIGKILL` signal to kill the command.**Returns**:-List of filesystem events+Whether the command was killed successfully-## Filesystem+## Commands```python-class Filesystem()+class Commands()```-Module for interacting with the filesystem in the sandbox.+Module for executing commands in the sandbox.-### read+### list```python-@overload-def read(path: str,- format: Literal["text"] = "text",- user: Username = "user",- request_timeout: Optional[float] = None) -> str+def list(request_timeout: Optional[float] = None) -> List[ProcessInfo]```-Read file content as a `str`.+Lists all running commands and PTY sessions.**Arguments**:-- `path`: Path to the file-- `user`: Run the operation as this user-- `format`: Format of the file content—`text` by default- `request_timeout`: Timeout for the request in **seconds****Returns**:-File content as a `str`+List of running commands and PTY sessions-### read+### kill```python-@overload-def read(path: str,- format: Literal["bytes"],- user: Username = "user",- request_timeout: Optional[float] = None) -> bytearray+def kill(pid: int, request_timeout: Optional[float] = None) -> bool```-Read file content as a `bytearray`.+Kills a running command specified by its process ID.++It uses `SIGKILL` signal to kill the command.**Arguments**:-- `path`: Path to the file-- `user`: Run the operation as this user-- `format`: Format of the file content—`bytes`+- `pid`: Process ID of the command. You can get the list of processes using `sandbox.commands.list()`- `request_timeout`: Timeout for the request in **seconds****Returns**:-File content as a `bytearray`+`True` if the command was killed, `False` if the command was not found-### read+### send\_stdin```python-@overload-def read(path: str,- format: Literal["stream"],- user: Username = "user",- request_timeout: Optional[float] = None) -> Iterator[bytes]+def send_stdin(pid: int, data: str, request_timeout: Optional[float] = None)```-Read file content as a `Iterator[bytes]`.--**Arguments**:--- `path`: Path to the file-- `user`: Run the operation as this user-- `format`: Format of the file content—`stream`-- `request_timeout`: Timeout for the request in **seconds**+Send data to command stdin.-**Returns**:+:param pid Process ID of the command. You can get the list of processes using `sandbox.commands.list()`.+:param data: Data to send to the command+:param request_timeout: Timeout for the request in **seconds**-File content as an `Iterator[bytes]`-### write+### run```python-def write(path: str,- data: Union[str, bytes, IO],- user: Username = "user",- request_timeout: Optional[float] = None) -> EntryInfo+@overload+def run(cmd: str,+ background: Union[Literal[False], None] = None,+ envs: Optional[Dict[str, str]] = None,+ user: Username = "user",+ cwd: Optional[str] = None,+ on_stdout: Optional[Callable[[str], None]] = None,+ on_stderr: Optional[Callable[[str], None]] = None,+ timeout: Optional[float] = 60,+ request_timeout: Optional[float] = None) -> CommandResult```-Write content to a file on the path.--Writing to a file that doesn't exist creates the file.--Writing to a file that already exists overwrites the file.--Writing to a file at path that doesn't exist creates the necessary directories.+Start a new command and wait until it finishes executing.**Arguments**:-- `path`: Path to the file-- `data`: Data to write to the file, can be a `str`, `bytes`, or `IO`.-- `user`: Run the operation as this user+- `cmd`: Command to execute+- `background`: **`False` if the command should be executed in the foreground**, `True` if the command should be executed in the background+- `envs`: Environment variables used for the command+- `user`: User to run the command as+- `cwd`: Working directory to run the command+- `on_stdout`: Callback for command stdout output+- `on_stderr`: Callback for command stderr output+- `timeout`: Timeout for the command connection in **seconds**. Using `0` will not limit the command connection time- `request_timeout`: Timeout for the request in **seconds****Returns**:-Information about the written file+`CommandResult` result of the command execution-### list+### run```python-def list(path: str,- user: Username = "user",- request_timeout: Optional[float] = None) -> List[EntryInfo]+@overload+def run(cmd: str,+ background: Literal[True],+ envs: Optional[Dict[str, str]] = None,+ user: Username = "user",+ cwd: Optional[str] = None,+ on_stdout: None = None,+ on_stderr: None = None,+ timeout: Optional[float] = 60,+ request_timeout: Optional[float] = None) -> CommandHandle```-List entries in a directory.+Start a new command and return a handle to interact with it.**Arguments**:-- `path`: Path to the directory-- `user`: Run the operation as this user+- `cmd`: Command to execute+- `background`: `False` if the command should be executed in the foreground, **`True` if the command should be executed in the background**+- `envs`: Environment variables used for the command+- `user`: User to run the command as+- `cwd`: Working directory to run the command+- `timeout`: Timeout for the command connection in **seconds**. Using `0` will not limit the command connection time- `request_timeout`: Timeout for the request in **seconds****Returns**:-List of entries in the directory+`CommandHandle` handle to interact with the running command-### exists+### connect```python-def exists(path: str,- user: Username = "user",- request_timeout: Optional[float] = None) -> bool+def connect(pid: int,+ timeout: Optional[float] = 60,+ request_timeout: Optional[float] = None)```-Check if a file or a directory exists.+Connects to a running command.++You can use `CommandHandle.wait()` to wait for the command to finish and get execution results.**Arguments**:-- `path`: Path to a file or a directory-- `user`: Run the operation as this user+- `pid`: Process ID of the command to connect to. You can get the list of processes using `sandbox.commands.list()`+- `timeout`: Timeout for the connection in **seconds**. Using `0` will not limit the connection time- `request_timeout`: Timeout for the request in **seconds****Returns**:-`True` if the file or directory exists, `False` otherwise+`CommandHandle` handle to interact with the running command-### remove-```python-def remove(path: str,- user: Username = "user",- request_timeout: Optional[float] = None) -> None-```-Remove a file or a directory.+## Pty-**Arguments**:+```python+class Pty()+```-- `path`: Path to a file or a directory-- `user`: Run the operation as this user-- `request_timeout`: Timeout for the request in **seconds**+Module for interacting with PTYs (pseudo-terminals) in the sandbox.-### rename+### kill```python-def rename(old_path: str,- new_path: str,- user: Username = "user",- request_timeout: Optional[float] = None) -> EntryInfo+def kill(pid: int, request_timeout: Optional[float] = None) -> bool```-Rename a file or directory.+Kill PTY.**Arguments**:-- `old_path`: Path to the file or directory to rename-- `new_path`: New path to the file or directory-- `user`: Run the operation as this user+- `pid`: Process ID of the PTY- `request_timeout`: Timeout for the request in **seconds****Returns**:-Information about the renamed file or directory+`true` if the PTY was killed, `false` if the PTY was not found-### make\_dir+### send\_stdin```python-def make_dir(path: str,- user: Username = "user",- request_timeout: Optional[float] = None) -> bool+def send_stdin(pid: int,+ data: bytes,+ request_timeout: Optional[float] = None) -> None```-Create a new directory and all directories along the way if needed on the specified path.+Send input to a PTY.**Arguments**:-- `path`: Path to a new directory. For example '/dirA/dirB' when creating 'dirB'.-- `user`: Run the operation as this user+- `pid`: Process ID of the PTY+- `data`: Input data to send- `request_timeout`: Timeout for the request in **seconds**-**Returns**:--`True` if the directory was created, `False` if the directory already exists--### watch\_dir+### create```python-def watch_dir(path: str,- user: Username = "user",- request_timeout: Optional[float] = None,- recursive: bool = False) -> WatchHandle+def create(size: PtySize,+ user: Username = "user",+ cwd: Optional[str] = None,+ envs: Optional[Dict[str, str]] = None,+ timeout: Optional[float] = 60,+ request_timeout: Optional[float] = None) -> CommandHandle```-Watch directory for filesystem events.+Start a new PTY (pseudo-terminal).**Arguments**:-- `path`: Path to a directory to watch-- `user`: Run the operation as this user+- `size`: Size of the PTY+- `user`: User to use for the PTY+- `cwd`: Working directory for the PTY+- `envs`: Environment variables for the PTY+- `timeout`: Timeout for the PTY in **seconds**- `request_timeout`: Timeout for the request in **seconds**-- `recursive`: Watch directory recursively**Returns**:-`WatchHandle` object for stopping watching directory--+Handle to interact with the PTY-## CommandHandle+### resize```python-class CommandHandle()+def resize(pid: int,+ size: PtySize,+ request_timeout: Optional[float] = None) -> None```-Command execution handle.+Resize PTY.-It provides methods for waiting for the command to finish, retrieving stdout/stderr, and killing the command.+Call this when the terminal window is resized and the number of columns and rows has changed.+**Arguments**:-### pid+- `pid`: Process ID of the PTY+- `size`: New size of the PTY+- `request_timeout`: Timeout for the request in **seconds**s-```python-@property-def pid()-```-Command process ID.-### \_\_iter\_\_+## Sandbox```python-def __iter__()+class Sandbox(SandboxSetup, SandboxApi)```-Iterate over the command output.+E2B cloud sandbox is a secure and isolated cloud environment.-**Returns**:+The sandbox allows you to:+- Access Linux OS+- Create, list, and delete files and directories+- Run commands+- Run isolated code+- Access the internet-Generator of command outputs+Check docs [here](https://e2b.dev/docs).+Use the `Sandbox()` to create a new sandbox.-### disconnect+**Example**:```python-def disconnect() -> None-```--Disconnect from the command.+from e2b import Sandbox-The command is not killed, but SDK stops receiving events from the command.-You can reconnect to the command using `sandbox.commands.connect` method.+sandbox = Sandbox()+```-### wait+### files```python-def wait(on_pty: Optional[Callable[[PtyOutput], None]] = None,- on_stdout: Optional[Callable[[str], None]] = None,- on_stderr: Optional[Callable[[str], None]] = None) -> CommandResult+@property+def files() -> Filesystem```-Wait for the command to finish and returns the result.--If the command exits with a non-zero exit code, it throws a `CommandExitException`.--**Arguments**:--- `on_pty`: Callback for pty output-- `on_stdout`: Callback for stdout output-- `on_stderr`: Callback for stderr output--**Returns**:--`CommandResult` result of command execution+Module for interacting with the sandbox filesystem.-### kill+### commands```python-def kill() -> bool+@property+def commands() -> Commands```-Kills the command.--It uses `SIGKILL` signal to kill the command.+Module for running commands in the sandbox.-**Returns**:-Whether the command was killed successfully+### pty+```python+@property+def pty() -> Pty+```+Module for interacting with the sandbox pseudo-terminal.-## Commands+### sandbox\_id```python-class Commands()+@property+def sandbox_id() -> str```-Module for executing commands in the sandbox.+Unique identifier of the sandbox-### list+### \_\_init\_\_```python-def list(request_timeout: Optional[float] = None) -> List[ProcessInfo]+def __init__(template: Optional[str] = None,+ timeout: Optional[int] = None,+ metadata: Optional[Dict[str, str]] = None,+ envs: Optional[Dict[str, str]] = None,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ sandbox_id: Optional[str] = None,+ request_timeout: Optional[float] = None)```-Lists all running commands and PTY sessions.+Create a new sandbox.++By default, the sandbox is created from the default `base` sandbox template.**Arguments**:+- `template`: Sandbox template name or ID+- `timeout`: Timeout for the sandbox in **seconds**, default to 300 seconds. Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users+- `metadata`: Custom metadata for the sandbox+- `envs`: Custom environment variables for the sandbox+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable- `request_timeout`: Timeout for the request in **seconds****Returns**:-List of running commands and PTY sessions+sandbox instance for the new sandbox-### kill+### is\_running```python-def kill(pid: int, request_timeout: Optional[float] = None) -> bool+def is_running(request_timeout: Optional[float] = None) -> bool```-Kills a running command specified by its process ID.--It uses `SIGKILL` signal to kill the command.+Check if the sandbox is running.**Arguments**:-- `pid`: Process ID of the command. You can get the list of processes using `sandbox.commands.list()`- `request_timeout`: Timeout for the request in **seconds****Returns**:-`True` if the command was killed, `False` if the command was not found+`True` if the sandbox is running, `False` otherwise+Example+```python+sandbox = Sandbox()+sandbox.is_running() # Returns True++sandbox.kill()+sandbox.is_running() # Returns False+```-### send\_stdin+### connect```python-def send_stdin(pid: int, data: str, request_timeout: Optional[float] = None)+@classmethod+def connect(cls,+ sandbox_id: str,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None)```-Send data to command stdin.+Connects to an existing Sandbox.-:param pid Process ID of the command. You can get the list of processes using `sandbox.commands.list()`.-:param data: Data to send to the command-:param request_timeout: Timeout for the request in **seconds**+With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).+**Arguments**:+- `sandbox_id`: Sandbox ID+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable-### run+**Returns**:++sandbox instance for the existing sandbox+@example+```python+sandbox = Sandbox()+sandbox_id = sandbox.sandbox_id++same_sandbox = Sandbox.connect(sandbox_id)+```+++### kill```python@overload-def run(cmd: str,- background: Union[Literal[False], None] = None,- envs: Optional[Dict[str, str]] = None,- user: Username = "user",- cwd: Optional[str] = None,- on_stdout: Optional[Callable[[str], None]] = None,- on_stderr: Optional[Callable[[str], None]] = None,- timeout: Optional[float] = 60,- request_timeout: Optional[float] = None) -> CommandResult+def kill(request_timeout: Optional[float] = None) -> bool```-Start a new command and wait until it finishes executing.+Kill the sandbox.**Arguments**:-- `cmd`: Command to execute-- `background`: **`False` if the command should be executed in the foreground**, `True` if the command should be executed in the background-- `envs`: Environment variables used for the command-- `user`: User to run the command as-- `cwd`: Working directory to run the command-- `on_stdout`: Callback for command stdout output-- `on_stderr`: Callback for command stderr output-- `timeout`: Timeout for the command connection in **seconds**. Using `0` will not limit the command connection time- `request_timeout`: Timeout for the request in **seconds****Returns**:-`CommandResult` result of the command execution+`True` if the sandbox was killed, `False` if the sandbox was not found-### run+### kill```python@overload-def run(cmd: str,- background: Literal[True],- envs: Optional[Dict[str, str]] = None,- user: Username = "user",- cwd: Optional[str] = None,- on_stdout: None = None,- on_stderr: None = None,- timeout: Optional[float] = 60,- request_timeout: Optional[float] = None) -> CommandHandle+@staticmethod+def kill(sandbox_id: str,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ request_timeout: Optional[float] = None) -> bool```-Start a new command and return a handle to interact with it.+Kill the sandbox specified by sandbox ID.**Arguments**:-- `cmd`: Command to execute-- `background`: `False` if the command should be executed in the foreground, **`True` if the command should be executed in the background**-- `envs`: Environment variables used for the command-- `user`: User to run the command as-- `cwd`: Working directory to run the command-- `timeout`: Timeout for the command connection in **seconds**. Using `0` will not limit the command connection time+- `sandbox_id`: Sandbox ID+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable- `request_timeout`: Timeout for the request in **seconds****Returns**:-`CommandHandle` handle to interact with the running command+`True` if the sandbox was killed, `False` if the sandbox was not found-### connect+### kill```python-def connect(pid: int,- timeout: Optional[float] = 60,- request_timeout: Optional[float] = None)+@class_method_variant("_cls_kill")+def kill(request_timeout: Optional[float] = None) -> bool```-Connects to a running command.--You can use `CommandHandle.wait()` to wait for the command to finish and get execution results.+Kill the sandbox.**Arguments**:-- `pid`: Process ID of the command to connect to. You can get the list of processes using `sandbox.commands.list()`-- `timeout`: Timeout for the connection in **seconds**. Using `0` will not limit the connection time-- `request_timeout`: Timeout for the request in **seconds**+- `request_timeout`: Timeout for the request**Returns**:-`CommandHandle` handle to interact with the running command--+`True` if the sandbox was killed, `False` if the sandbox was not found-## Pty+### set\_timeout```python-class Pty()+@overload+def set_timeout(timeout: int, request_timeout: Optional[float] = None) -> None```-Module for interacting with PTYs (pseudo-terminals) in the sandbox.+Set the timeout of the sandbox.++After the timeout expires the sandbox will be automatically killed.+This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.+Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.-### kill+**Arguments**:++- `timeout`: Timeout for the sandbox in **seconds**+- `request_timeout`: Timeout for the request in **seconds**+++### set\_timeout```python-def kill(pid: int, request_timeout: Optional[float] = None) -> bool+@overload+@staticmethod+def set_timeout(sandbox_id: str,+ timeout: int,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ request_timeout: Optional[float] = None) -> None```-Kill PTY.+Set the timeout of the sandbox specified by sandbox ID.++After the timeout expires the sandbox will be automatically killed.+This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.++Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.**Arguments**:-- `pid`: Process ID of the PTY+- `sandbox_id`: Sandbox ID+- `timeout`: Timeout for the sandbox in **seconds**+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable- `request_timeout`: Timeout for the request in **seconds**-**Returns**:-`true` if the PTY was killed, `false` if the PTY was not found-### send\_stdin+## Filesystem```python-def send_stdin(pid: int,- data: bytes,- request_timeout: Optional[float] = None) -> None+class Filesystem()```-Send input to a PTY.--**Arguments**:--- `pid`: Process ID of the PTY-- `data`: Input data to send-- `request_timeout`: Timeout for the request in **seconds**+Module for interacting with the filesystem in the sandbox.-### create+### read```python-def create(size: PtySize,- user: Username = "user",- cwd: Optional[str] = None,- envs: Optional[Dict[str, str]] = None,- timeout: Optional[float] = 60,- request_timeout: Optional[float] = None) -> CommandHandle+@overload+def read(path: str,+ format: Literal["text"] = "text",+ user: Username = "user",+ request_timeout: Optional[float] = None) -> str```-Start a new PTY (pseudo-terminal).+Read file content as a `str`.**Arguments**:-- `size`: Size of the PTY-- `user`: User to use for the PTY-- `cwd`: Working directory for the PTY-- `envs`: Environment variables for the PTY-- `timeout`: Timeout for the PTY in **seconds**+- `path`: Path to the file+- `user`: Run the operation as this user+- `format`: Format of the file content—`text` by default- `request_timeout`: Timeout for the request in **seconds****Returns**:-Handle to interact with the PTY+File content as a `str`-### resize+### read```python-def resize(pid: int,- size: PtySize,- request_timeout: Optional[float] = None) -> None+@overload+def read(path: str,+ format: Literal["bytes"],+ user: Username = "user",+ request_timeout: Optional[float] = None) -> bytearray```-Resize PTY.--Call this when the terminal window is resized and the number of columns and rows has changed.+Read file content as a `bytearray`.**Arguments**:-- `pid`: Process ID of the PTY-- `size`: New size of the PTY-- `request_timeout`: Timeout for the request in **seconds**s+- `path`: Path to the file+- `user`: Run the operation as this user+- `format`: Format of the file content—`bytes`+- `request_timeout`: Timeout for the request in **seconds**+**Returns**:+File content as a `bytearray`-## Sandbox+### read```python-class Sandbox(SandboxSetup, SandboxApi)+@overload+def read(path: str,+ format: Literal["stream"],+ user: Username = "user",+ request_timeout: Optional[float] = None) -> Iterator[bytes]```-E2B cloud sandbox is a secure and isolated cloud environment.+Read file content as a `Iterator[bytes]`.-The sandbox allows you to:-- Access Linux OS-- Create, list, and delete files and directories-- Run commands-- Run isolated code-- Access the internet+**Arguments**:-Check docs [here](https://e2b.dev/docs).+- `path`: Path to the file+- `user`: Run the operation as this user+- `format`: Format of the file content—`stream`+- `request_timeout`: Timeout for the request in **seconds**-Use the `Sandbox()` to create a new sandbox.+**Returns**:-**Example**:+File content as an `Iterator[bytes]`-```python-from e2b import Sandbox-sandbox = Sandbox()+### write++```python+def write(path: str,+ data: Union[str, bytes, IO],+ user: Username = "user",+ request_timeout: Optional[float] = None) -> EntryInfo```+Write content to a file on the path.-### files+Writing to a file that doesn't exist creates the file.-```python-@property-def files() -> Filesystem-```+Writing to a file that already exists overwrites the file.-Module for interacting with the sandbox filesystem.+Writing to a file at path that doesn't exist creates the necessary directories.+**Arguments**:-### commands+- `path`: Path to the file+- `data`: Data to write to the file, can be a `str`, `bytes`, or `IO`.+- `user`: Run the operation as this user+- `request_timeout`: Timeout for the request in **seconds**-```python-@property-def commands() -> Commands-```+**Returns**:-Module for running commands in the sandbox.+Information about the written file-### pty+### list```python-@property-def pty() -> Pty+def list(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> List[EntryInfo]```-Module for interacting with the sandbox pseudo-terminal.+List entries in a directory.+**Arguments**:-### sandbox\_id+- `path`: Path to the directory+- `user`: Run the operation as this user+- `request_timeout`: Timeout for the request in **seconds**-```python-@property-def sandbox_id() -> str-```+**Returns**:-Unique identifier of the sandbox+List of entries in the directory-### \_\_init\_\_+### exists```python-def __init__(template: Optional[str] = None,- timeout: Optional[int] = None,- metadata: Optional[Dict[str, str]] = None,- envs: Optional[Dict[str, str]] = None,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- sandbox_id: Optional[str] = None,- request_timeout: Optional[float] = None)+def exists(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> bool```-Create a new sandbox.--By default, the sandbox is created from the default `base` sandbox template.+Check if a file or a directory exists.**Arguments**:-- `template`: Sandbox template name or ID-- `timeout`: Timeout for the sandbox in **seconds**, default to 300 seconds. Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users-- `metadata`: Custom metadata for the sandbox-- `envs`: Custom environment variables for the sandbox-- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `path`: Path to a file or a directory+- `user`: Run the operation as this user- `request_timeout`: Timeout for the request in **seconds****Returns**:-sandbox instance for the new sandbox+`True` if the file or directory exists, `False` otherwise-### is\_running+### remove```python-def is_running(request_timeout: Optional[float] = None) -> bool+def remove(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> None```-Check if the sandbox is running.+Remove a file or a directory.**Arguments**:+- `path`: Path to a file or a directory+- `user`: Run the operation as this user- `request_timeout`: Timeout for the request in **seconds**-**Returns**:--`True` if the sandbox is running, `False` otherwise-Example-```python-sandbox = Sandbox()-sandbox.is_running() # Returns True--sandbox.kill()-sandbox.is_running() # Returns False-```--### connect+### rename```python-@classmethod-def connect(cls,- sandbox_id: str,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None)+def rename(old_path: str,+ new_path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> EntryInfo```-Connects to an existing Sandbox.--With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).+Rename a file or directory.**Arguments**:-- `sandbox_id`: Sandbox ID-- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `old_path`: Path to the file or directory to rename+- `new_path`: New path to the file or directory+- `user`: Run the operation as this user+- `request_timeout`: Timeout for the request in **seconds****Returns**:-sandbox instance for the existing sandbox-@example-```python-sandbox = Sandbox()-sandbox_id = sandbox.sandbox_id--same_sandbox = Sandbox.connect(sandbox_id)-```+Information about the renamed file or directory-### kill+### make\_dir```python-@overload-def kill(request_timeout: Optional[float] = None) -> bool+def make_dir(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> bool```-Kill the sandbox.+Create a new directory and all directories along the way if needed on the specified path.**Arguments**:+- `path`: Path to a new directory. For example '/dirA/dirB' when creating 'dirB'.+- `user`: Run the operation as this user- `request_timeout`: Timeout for the request in **seconds****Returns**:-`True` if the sandbox was killed, `False` if the sandbox was not found+`True` if the directory was created, `False` if the directory already exists-### kill+### watch\_dir```python-@overload-@staticmethod-def kill(sandbox_id: str,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- request_timeout: Optional[float] = None) -> bool+def watch_dir(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None,+ recursive: bool = False) -> WatchHandle```-Kill the sandbox specified by sandbox ID.+Watch directory for filesystem events.**Arguments**:-- `sandbox_id`: Sandbox ID-- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `path`: Path to a directory to watch+- `user`: Run the operation as this user- `request_timeout`: Timeout for the request in **seconds**+- `recursive`: Watch directory recursively**Returns**:-`True` if the sandbox was killed, `False` if the sandbox was not found+`WatchHandle` object for stopping watching directory+-### kill++## WatchHandle```python-@class_method_variant("_cls_kill")-def kill(request_timeout: Optional[float] = None) -> bool+class WatchHandle()```-Kill the sandbox.+Handle for watching filesystem events.+It is used to get the latest events that have occurred in the watched directory.-**Arguments**:+Use `.stop()` to stop watching the directory.-- `request_timeout`: Timeout for the request-**Returns**:+### stop-`True` if the sandbox was killed, `False` if the sandbox was not found+```python+def stop()+```++Stop watching the directory.+After you stop the watcher you won't be able to get the events anymore.-### set\_timeout+### get\_new\_events```python-@overload-def set_timeout(timeout: int, request_timeout: Optional[float] = None) -> None+def get_new_events() -> List[FilesystemEvent]```-Set the timeout of the sandbox.+Get the latest events that have occurred in the watched directory since the last call, or from the beginning of the watching, up until now.-After the timeout expires the sandbox will be automatically killed.-This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.+**Returns**:-Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.+List of filesystem events-**Arguments**:-- `timeout`: Timeout for the sandbox in **seconds**-- `request_timeout`: Timeout for the request in **seconds**-### set\_timeout+## SandboxApi```python-@overload-@staticmethod-def set_timeout(sandbox_id: str,- timeout: int,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- request_timeout: Optional[float] = None) -> None+class SandboxApi(SandboxApiBase)```-Set the timeout of the sandbox specified by sandbox ID.-After the timeout expires the sandbox will be automatically killed.-This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.+### list-Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.+```python+@classmethod+def list(cls,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ request_timeout: Optional[float] = None) -> List[SandboxInfo]+```++List all running sandboxes.**Arguments**:-- `sandbox_id`: Sandbox ID-- `timeout`: Timeout for the sandbox in **seconds**-- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `api_key`: API key to use for authentication, defaults to `E2B_API_KEY` environment variable- `request_timeout`: Timeout for the request in **seconds**+**Returns**:++List of sandbox info+diff --git a/packages/cli/package.json b/packages/cli/package.jsonindex 813677525..cbf0c317a 100644--- a/packages/cli/package.json+++ b/packages/cli/package.json@@ -1,6 +1,6 @@{"name": "@e2b/cli",- "version": "1.2.0",+ "version": "1.2.1","description": "CLI for managing e2b sandbox templates","homepage": "https://e2b.dev","license": "MIT",