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]774dfd7667ae
diff --git a/.changeset/angry-ties-carry.md b/.changeset/angry-ties-carry.mddeleted file mode 100644index 8f6bcb9dd..000000000--- a/.changeset/angry-ties-carry.md+++ /dev/null@@ -1,8 +0,0 @@-----'@e2b/python-sdk': major-'e2b': major-'@e2b/cli': major------- Add beta module (pause and resume)-- Update list method to allow list paused sandboxesdiff --git a/.changeset/strange-hornets-judge.md b/.changeset/strange-hornets-judge.mddeleted file mode 100644index cb559f6ab..000000000--- a/.changeset/strange-hornets-judge.md+++ /dev/null@@ -1,5 +0,0 @@-----'@e2b/python-sdk': minor------Refactor connection config and parameters for all calls to APIdiff --git a/apps/web/package.json b/apps/web/package.jsonindex b1536c060..31b23b889 100644--- a/apps/web/package.json+++ b/apps/web/package.json@@ -41,7 +41,7 @@"autoprefixer": "^10.4.7","class-variance-authority": "^0.7.0","clsx": "^1.2.1",- "e2b": "^1.13.2",+ "e2b": "^2.0.0","fast-glob": "^3.3.0","fast-xml-parser": "4.4.1","flexsearch": "^0.7.31",diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/cli/v2.0.0/auth/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/cli/v2.0.0/auth/page.mdxnew file mode 100644index 000000000..2c82afa69--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/cli/v2.0.0/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/v2.0.0/sandbox/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/cli/v2.0.0/sandbox/page.mdxnew file mode 100644index 000000000..3d7744ce8--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/cli/v2.0.0/sandbox/page.mdx@@ -0,0 +1,114 @@+## 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 sandboxes, by default it list only running ones++### Usage++```bash+e2b sandbox list [options]+```++### Options+++ - `-s, --state <state>: filter by state, eg. running, paused. Defaults to running `+ - `-m, --metadata <metadata>: filter by metadata, eg. key1=value1 `+ - `-l, --limit <limit>: limit the number of sandboxes returned `+++## e2b sandbox kill+++kill sandbox++### Usage++```bash+e2b sandbox kill [options] [sandboxID]+```++### Options+++ - `-a, --all: kill all running sandboxes `+++## e2b sandbox create+++create sandbox and connect terminal to it++### Usage++```bash+e2b sandbox create [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. `+++## e2b sandbox metrics+++show metrics for sandbox++### Usage++```bash+e2b sandbox metrics [options] <sandboxID>+```++### Options+++ - `-f, --follow: keep streaming metrics until the sandbox is closed `+ - `--format <format>: specify format for printing metrics (json, pretty) [default: pretty]`++diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/cli/v2.0.0/template/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/cli/v2.0.0/template/page.mdxnew file mode 100644index 000000000..d41cd8537--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/cli/v2.0.0/template/page.mdx@@ -0,0 +1,134 @@+## 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. `+ - `--ready-cmd <ready-command>: specify command that will need to exit 0 for the template to be ready. `+ - `-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>. `+ - `--no-cache: skip cache when building the template. `+++## 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/js-sdk/v2.0.0/commands/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v2.0.0/commands/page.mdxnew file mode 100644index 000000000..a4d1a2527--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v2.0.0/commands/page.mdx@@ -0,0 +1,504 @@+### Commands++Module for starting and interacting with commands in the sandbox.++#### Constructors++```ts+new Commands(transport: Transport, connectionConfig: ConnectionConfig): Commands+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `transport` | `Transport` |+| `connectionConfig` | `ConnectionConfig` |++###### Returns++`Commands`++#### Methods++### connect()++```ts+connect(pid: number, opts?: CommandConnectOpts): Promise<CommandHandle>+```++Connect to a running command.+You can use CommandHandle.wait to wait for the command to finish and get execution results.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `pid` | `number` | process ID of the command to connect to. You can get the list of running commands using Commands.list. |+| `opts`? | `CommandConnectOpts` | connection options. |++###### Returns++`Promise`\<`CommandHandle`\>++`CommandHandle` handle to interact with the running command.++### kill()++```ts+kill(pid: number, opts?: CommandRequestOpts): Promise<boolean>+```++Kill a running command specified by its process ID.+It uses `SIGKILL` signal to kill the command.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `pid` | `number` | process ID of the command. You can get the list of running commands using Commands.list. |+| `opts`? | `CommandRequestOpts` | connection options. |++###### Returns++`Promise`\<`boolean`\>++`true` if the command was killed, `false` if the command was not found.++### list()++```ts+list(opts?: CommandRequestOpts): Promise<ProcessInfo[]>+```++List all running commands and PTY sessions.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `opts`? | `CommandRequestOpts` | connection options. |++###### Returns++`Promise`\<`ProcessInfo`[]\>++list of running commands and PTY sessions.++### run()++###### run(cmd, opts)++```ts+run(cmd: string, opts?: CommandStartOpts & object): Promise<CommandResult>+```++Start a new command and wait until it finishes executing.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `cmd` | `string` | command to execute. |+| `opts`? | `CommandStartOpts` & `object` | options for starting the command. |++###### Returns++`Promise`\<`CommandResult`\>++`CommandResult` result of the command execution.++###### run(cmd, opts)++```ts+run(cmd: string, opts: CommandStartOpts & object): Promise<CommandHandle>+```++Start a new command in the background.+You can use CommandHandle.wait to wait for the command to finish and get its result.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `cmd` | `string` | command to execute. |+| `opts` | `CommandStartOpts` & `object` | options for starting the command |++###### Returns++`Promise`\<`CommandHandle`\>++`CommandHandle` handle to interact with the running command.++###### run(cmd, opts)++```ts+run(cmd: string, opts?: CommandStartOpts & object): Promise<CommandResult | CommandHandle>+```++Start a new command.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `cmd` | `string` | command to execute. |+| `opts`? | `CommandStartOpts` & `object` | options for starting the command. - `opts.background: true` - runs in background, returns `CommandHandle` - `opts.background: false | undefined` - waits for completion, returns `CommandResult` |++###### Returns++`Promise`\<`CommandResult` \| `CommandHandle`\>++Either a `CommandHandle` or a `CommandResult` (depending on `opts.background`).++### sendStdin()++```ts+sendStdin(+ pid: number,+ data: string,+opts?: CommandRequestOpts): Promise<void>+```++Send data to command stdin.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `pid` | `number` | process ID of the command. You can get the list of running commands using Commands.list. |+| `data` | `string` | data to send to the command. |+| `opts`? | `CommandRequestOpts` | connection options. |++###### Returns++`Promise`\<`void`\>++***++### Pty++Module for interacting with PTYs (pseudo-terminals) in the sandbox.++#### Constructors++```ts+new Pty(transport: Transport, connectionConfig: ConnectionConfig): Pty+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `transport` | `Transport` |+| `connectionConfig` | `ConnectionConfig` |++###### Returns++`Pty`++#### Methods++### create()++```ts+create(opts: PtyCreateOpts): Promise<CommandHandle>+```++Create a new PTY (pseudo-terminal).++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `opts` | `PtyCreateOpts` | options for creating the PTY. |++###### Returns++`Promise`\<`CommandHandle`\>++handle to interact with the PTY.++### kill()++```ts+kill(pid: number, opts?: Pick<ConnectionOpts, "requestTimeoutMs">): Promise<boolean>+```++Kill a running PTY specified by process ID.+It uses `SIGKILL` signal to kill the PTY.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `pid` | `number` | process ID of the PTY. |+| `opts`? | `Pick`\<`ConnectionOpts`, `"requestTimeoutMs"`\> | connection options. |++###### Returns++`Promise`\<`boolean`\>++`true` if the PTY was killed, `false` if the PTY was not found.++### resize()++```ts+resize(+ pid: number,+ size: object,+opts?: Pick<ConnectionOpts, "requestTimeoutMs">): Promise<void>+```++Resize PTY.+Call this when the terminal window is resized and the number of columns and rows has changed.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `pid` | `number` | process ID of the PTY. |+| `size` | `object` | new size of the PTY. |+| `size.cols` | `number` | - |+| `size.rows`? | `number` | - |+| `opts`? | `Pick`\<`ConnectionOpts`, `"requestTimeoutMs"`\> | connection options. |++###### Returns++`Promise`\<`void`\>++### sendInput()++```ts+sendInput(+ pid: number,+ data: Uint8Array,+opts?: Pick<ConnectionOpts, "requestTimeoutMs">): Promise<void>+```++Send input to a PTY.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `pid` | `number` | process ID of the PTY. |+| `data` | `Uint8Array` | input data to send to the PTY. |+| `opts`? | `Pick`\<`ConnectionOpts`, `"requestTimeoutMs"`\> | connection options. |++###### Returns++`Promise`\<`void`\>++## Interfaces++### CommandRequestOpts++Options for sending a command request.++#### Extended by++- `CommandStartOpts`++#### Properties++### requestTimeoutMs?++```ts+optional requestTimeoutMs: number;+```++Timeout for requests to the API in **milliseconds**.++###### Default++```ts+60_000 // 60 seconds+```++***++### CommandStartOpts++Options for starting a new command.++#### Properties++### background?++```ts+optional background: boolean;+```++If true, starts command in the background and the method returns immediately.+You can use CommandHandle.wait to wait for the command to finish.++### cwd?++```ts+optional cwd: string;+```++Working directory for the command.++###### Default++```ts+// home directory of the user used to start the command+```++### envs?++```ts+optional envs: Record<string, string>;+```++Environment variables used for the command.++This overrides the default environment variables from `Sandbox` constructor.++###### Default++`{}`++### onStderr()?++```ts+optional onStderr: (data: string) => void | Promise<void>;+```++Callback for command stderr output.++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `data` | `string` |++###### Returns++`void` \| `Promise`\<`void`\>++### onStdout()?++```ts+optional onStdout: (data: string) => void | Promise<void>;+```++Callback for command stdout output.++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `data` | `string` |++###### Returns++`void` \| `Promise`\<`void`\>++### requestTimeoutMs?++```ts+optional requestTimeoutMs: number;+```++Timeout for requests to the API in **milliseconds**.++###### Default++```ts+60_000 // 60 seconds+```++### timeoutMs?++```ts+optional timeoutMs: number;+```++Timeout for the command in **milliseconds**.++###### Default++```ts+60_000 // 60 seconds+```++### user?++```ts+optional user: Username;+```++User to run the command as.++###### Default++`user`++***++### ProcessInfo++Information about a command, PTY session or start command running in the sandbox as process.++#### Properties++### args++```ts+args: string[];+```++Command arguments.++### cmd++```ts+cmd: string;+```++Command that was executed.++### cwd?++```ts+optional cwd: string;+```++Executed command working directory.++### envs++```ts+envs: Record<string, string>;+```++Environment variables used for the command.++### pid++```ts+pid: number;+```++Process ID.++### tag?++```ts+optional tag: string;+```++Custom tag used for identifying special commands like start command in the custom template.++## Type Aliases++### CommandConnectOpts++```ts+type CommandConnectOpts: Pick<CommandStartOpts, "onStderr" | "onStdout" | "timeoutMs"> & CommandRequestOpts;+```++Options for connecting to a command.diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v2.0.0/errors/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v2.0.0/errors/page.mdxnew file mode 100644index 000000000..c5aa2cc14--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v2.0.0/errors/page.mdx@@ -0,0 +1,211 @@+### AuthenticationError++Thrown when authentication fails.++#### Constructors++```ts+new AuthenticationError(message: any): AuthenticationError+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `any` |++###### Returns++`AuthenticationError`++***++### InvalidArgumentError++Thrown when an invalid argument is provided.++#### Constructors++```ts+new InvalidArgumentError(message: string): InvalidArgumentError+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `string` |++###### Returns++`InvalidArgumentError`++***++### NotEnoughSpaceError++Thrown when there is not enough disk space.++#### Constructors++```ts+new NotEnoughSpaceError(message: string): NotEnoughSpaceError+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `string` |++###### Returns++`NotEnoughSpaceError`++***++### NotFoundError++Thrown when a resource is not found.++#### Constructors++```ts+new NotFoundError(message: string): NotFoundError+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `string` |++###### Returns++`NotFoundError`++***++### RateLimitError++Thrown when the API rate limit is exceeded.++#### Constructors++```ts+new RateLimitError(message: any): RateLimitError+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `any` |++###### Returns++`RateLimitError`++***++### SandboxError++Base class for all sandbox errors.++Thrown when general sandbox errors occur.++#### Extended by++- `TimeoutError`+- `InvalidArgumentError`+- `NotEnoughSpaceError`+- `NotFoundError`+- `AuthenticationError`+- `TemplateError`+- `RateLimitError`++#### Constructors++```ts+new SandboxError(message: any): SandboxError+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `any` |++###### Returns++`SandboxError`++***++### TemplateError++Thrown when the template uses old envd version. It isn't compatible with the new SDK.++#### Constructors++```ts+new TemplateError(message: string): TemplateError+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `string` |++###### Returns++`TemplateError`++***++### TimeoutError++Thrown when a timeout error occurs.++The [unavailable] error type is caused by sandbox timeout.++The [canceled] error type is caused by exceeding request timeout.++The [deadline_exceeded] error type is caused by exceeding the timeout for command execution, watch, etc.++The [unknown] error type is sometimes caused by the sandbox timeout when the request is not processed correctly.++#### Constructors++```ts+new TimeoutError(message: string): TimeoutError+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `string` |++###### Returns++`TimeoutError`++## Functions++### formatSandboxTimeoutError()++```ts+function formatSandboxTimeoutError(message: string): TimeoutError+```++#### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `string` |++#### Returns++`TimeoutError`diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v2.0.0/filesystem/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v2.0.0/filesystem/page.mdxnew file mode 100644index 000000000..03f9a1390--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v2.0.0/filesystem/page.mdx@@ -0,0 +1,622 @@+### FileType++Sandbox filesystem object type.++#### Enumeration Members++| Enumeration Member | Value | Description |+| ------ | ------ | ------ |+| `DIR` | `"dir"` | Filesystem object is a directory. |+| `FILE` | `"file"` | Filesystem object is a file. |++## Classes++### Filesystem++Module for interacting with the sandbox filesystem.++#### Constructors++```ts+new Filesystem(+ transport: Transport,+ envdApi: EnvdApiClient,+ connectionConfig: ConnectionConfig): Filesystem+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `transport` | `Transport` |+| `envdApi` | `EnvdApiClient` |+| `connectionConfig` | `ConnectionConfig` |++###### Returns++`Filesystem`++#### Methods++### exists()++```ts+exists(path: string, opts?: FilesystemRequestOpts): Promise<boolean>+```++Check if a file or a directory exists.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to a file or a directory |+| `opts`? | `FilesystemRequestOpts` | connection options. |++###### Returns++`Promise`\<`boolean`\>++`true` if the file or directory exists, `false` otherwise++### getInfo()++```ts+getInfo(path: string, opts?: FilesystemRequestOpts): Promise<EntryInfo>+```++Get information about a file or directory.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to a file or directory. |+| `opts`? | `FilesystemRequestOpts` | connection options. |++###### Returns++`Promise`\<`EntryInfo`\>++information about the file or directory like name, type, and path.++### list()++```ts+list(path: string, opts?: FilesystemListOpts): Promise<EntryInfo[]>+```++List entries in a directory.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to the directory. |+| `opts`? | `FilesystemListOpts` | connection options. |++###### Returns++`Promise`\<`EntryInfo`[]\>++list of entries in the sandbox filesystem directory.++### makeDir()++```ts+makeDir(path: string, opts?: FilesystemRequestOpts): Promise<boolean>+```++Create a new directory and all directories along the way if needed on the specified path.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to a new directory. For example '/dirA/dirB' when creating 'dirB'. |+| `opts`? | `FilesystemRequestOpts` | connection options. |++###### Returns++`Promise`\<`boolean`\>++`true` if the directory was created, `false` if it already exists.++### read()++###### read(path, opts)++```ts+read(path: string, opts?: FilesystemRequestOpts & object): Promise<string>+```++Read file content as a `string`.++You can pass `text`, `bytes`, `blob`, or `stream` to `opts.format` to change the return type.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to the file. |+| `opts`? | `FilesystemRequestOpts` & `object` | connection options. |++###### Returns++`Promise`\<`string`\>++file content as string++###### read(path, opts)++```ts+read(path: string, opts?: FilesystemRequestOpts & object): Promise<Uint8Array>+```++Read file content as a `Uint8Array`.++You can pass `text`, `bytes`, `blob`, or `stream` to `opts.format` to change the return type.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to the file. |+| `opts`? | `FilesystemRequestOpts` & `object` | connection options. |++###### Returns++`Promise`\<`Uint8Array`\>++file content as `Uint8Array`++###### read(path, opts)++```ts+read(path: string, opts?: FilesystemRequestOpts & object): Promise<Blob>+```++Read file content as a `Blob`.++You can pass `text`, `bytes`, `blob`, or `stream` to `opts.format` to change the return type.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to the file. |+| `opts`? | `FilesystemRequestOpts` & `object` | connection options. |++###### Returns++`Promise`\<`Blob`\>++file content as `Blob`++###### read(path, opts)++```ts+read(path: string, opts?: FilesystemRequestOpts & object): Promise<ReadableStream<Uint8Array>>+```++Read file content as a `ReadableStream`.++You can pass `text`, `bytes`, `blob`, or `stream` to `opts.format` to change the return type.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to the file. |+| `opts`? | `FilesystemRequestOpts` & `object` | connection options. |++###### Returns++`Promise`\<`ReadableStream`\<`Uint8Array`\>\>++file content as `ReadableStream`++### remove()++```ts+remove(path: string, opts?: FilesystemRequestOpts): Promise<void>+```++Remove a file or directory.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to a file or directory. |+| `opts`? | `FilesystemRequestOpts` | connection options. |++###### Returns++`Promise`\<`void`\>++### rename()++```ts+rename(+ oldPath: string,+ newPath: string,+opts?: FilesystemRequestOpts): Promise<EntryInfo>+```++Rename a file or directory.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `oldPath` | `string` | path to the file or directory to rename. |+| `newPath` | `string` | new path for the file or directory. |+| `opts`? | `FilesystemRequestOpts` | connection options. |++###### Returns++`Promise`\<`EntryInfo`\>++information about renamed file or directory.++### watchDir()++```ts+watchDir(+ path: string,+ onEvent: (event: FilesystemEvent) => void | Promise<void>,+opts?: WatchOpts & object): Promise<WatchHandle>+```++Start watching a directory for filesystem events.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to directory to watch. |+| `onEvent` | (`event`: `FilesystemEvent`) => `void` \| `Promise`\<`void`\> | callback to call when an event in the directory occurs. |+| `opts`? | `WatchOpts` & `object` | connection options. |++###### Returns++`Promise`\<`WatchHandle`\>++`WatchHandle` object for stopping watching directory.++### write()++###### write(path, data, opts)++```ts+write(+ path: string,+ data: string | ArrayBuffer | Blob | ReadableStream<any>,+opts?: FilesystemRequestOpts): Promise<WriteInfo>+```++Write content to a file.++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.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to file. |+| `data` | `string` \| `ArrayBuffer` \| `Blob` \| `ReadableStream`\<`any`\> | data to write to the file. Data can be a string, `ArrayBuffer`, `Blob`, or `ReadableStream`. |+| `opts`? | `FilesystemRequestOpts` | connection options. |++###### Returns++`Promise`\<`WriteInfo`\>++information about the written file++###### write(files, opts)++```ts+write(files: WriteEntry[], opts?: FilesystemRequestOpts): Promise<WriteInfo[]>+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `files` | `WriteEntry`[] |+| `opts`? | `FilesystemRequestOpts` |++###### Returns++`Promise`\<`WriteInfo`[]\>++## Interfaces++### EntryInfo++Sandbox filesystem object information.++#### Properties++### group++```ts+group: string;+```++Group owner of the filesystem object.++### mode++```ts+mode: number;+```++File mode and permission bits.++### modifiedTime?++```ts+optional modifiedTime: Date;+```++Last modification time of the filesystem object.++### name++```ts+name: string;+```++Name of the filesystem object.++### owner++```ts+owner: string;+```++Owner of the filesystem object.++### path++```ts+path: string;+```++Path to the filesystem object.++### permissions++```ts+permissions: string;+```++String representation of file permissions (e.g. 'rwxr-xr-x').++### size++```ts+size: number;+```++Size of the filesystem object in bytes.++### symlinkTarget?++```ts+optional symlinkTarget: string;+```++If the filesystem object is a symlink, this is the target of the symlink.++### type?++```ts+optional type: FileType;+```++Type of the filesystem object.++***++### FilesystemListOpts++Options for the sandbox filesystem operations.++#### Properties++### depth?++```ts+optional depth: number;+```++Depth of the directory to list.++### requestTimeoutMs?++```ts+optional requestTimeoutMs: number;+```++Timeout for requests to the API in **milliseconds**.++###### Default++```ts+60_000 // 60 seconds+```++### user?++```ts+optional user: Username;+```++User to use for the operation in the sandbox.+This affects the resolution of relative paths and ownership of the created filesystem objects.++***++### FilesystemRequestOpts++Options for the sandbox filesystem operations.++#### Extended by++- `FilesystemListOpts`+- `WatchOpts`++#### Properties++### requestTimeoutMs?++```ts+optional requestTimeoutMs: number;+```++Timeout for requests to the API in **milliseconds**.++###### Default++```ts+60_000 // 60 seconds+```++### user?++```ts+optional user: Username;+```++User to use for the operation in the sandbox.+This affects the resolution of relative paths and ownership of the created filesystem objects.++***++### WatchOpts++Options for watching a directory.++#### Properties++### onExit()?++```ts+optional onExit: (err?: Error) => void | Promise<void>;+```++Callback to call when the watch operation stops.++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `err`? | `Error` |++###### Returns++`void` \| `Promise`\<`void`\>++### recursive?++```ts+optional recursive: boolean;+```++Watch the directory recursively++### requestTimeoutMs?++```ts+optional requestTimeoutMs: number;+```++Timeout for requests to the API in **milliseconds**.++###### Default++```ts+60_000 // 60 seconds+```++### timeoutMs?++```ts+optional timeoutMs: number;+```++Timeout for the watch operation in **milliseconds**.+You can pass `0` to disable the timeout.++###### Default++```ts+60_000 // 60 seconds+```++### user?++```ts+optional user: Username;+```++User to use for the operation in the sandbox.+This affects the resolution of relative paths and ownership of the created filesystem objects.++***++### WriteInfo++Sandbox filesystem object information.++#### Extended by++- `EntryInfo`++#### Properties++### name++```ts+name: string;+```++Name of the filesystem object.++### path++```ts+path: string;+```++Path to the filesystem object.++### type?++```ts+optional type: FileType;+```++Type of the filesystem object.++## Type Aliases++### WriteEntry++```ts+type WriteEntry: object;+```++#### Type declaration++| Name | Type |+| ------ | ------ |+| `data` | `string` \| `ArrayBuffer` \| `Blob` \| `ReadableStream` |+| `path` | `string` |diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v2.0.0/sandbox/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v2.0.0/sandbox/page.mdxnew file mode 100644index 000000000..ca82c7ce3--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v2.0.0/sandbox/page.mdx@@ -0,0 +1,678 @@+### Sandbox++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.++Use Sandbox.create to create a new sandbox.++#### Example++```ts+import { Sandbox } from 'e2b'++const sandbox = await Sandbox.create()+```++#### Properties++| Property | Modifier | Type | Description |+| ------ | ------ | ------ | ------ |+| `commands` | `readonly` | `Commands` | Module for running commands in the sandbox |+| `files` | `readonly` | `Filesystem` | Module for interacting with the sandbox filesystem |+| `pty` | `readonly` | `Pty` | Module for interacting with the sandbox pseudo-terminals |+| `sandboxDomain` | `readonly` | `string` | Domain where the sandbox is hosted. |+| `sandboxId` | `readonly` | `string` | Unique identifier of the sandbox. |++#### Methods++### betaPause()++```ts+betaPause(opts?: ConnectionOpts): Promise<boolean>+```++**`Beta`**++This feature is in beta and may change in the future.++Pause a sandbox by its ID.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `opts`? | `ConnectionOpts` | connection options. |++###### Returns++`Promise`\<`boolean`\>++sandbox ID that can be used to resume the sandbox.++### connect()++```ts+connect(opts?: SandboxBetaCreateOpts): Promise<Sandbox>+```++Connect to a sandbox. If the sandbox is paused, it will be automatically resumed.+Sandbox must be either running or be paused.++With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `opts`? | `SandboxBetaCreateOpts` | connection options. |++###### Returns++`Promise`\<`Sandbox`\>++A running sandbox instance++###### Example++```ts+const sandbox = await Sandbox.create()+await sandbox.betaPause()++// Connect to the same sandbox.+const sameSandbox = await sandbox.connect()+```++### downloadUrl()++```ts+downloadUrl(path: string, opts?: SandboxUrlOpts): Promise<string>+```++Get the URL to download a file from the sandbox.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to the file in the sandbox. |+| `opts`? | `SandboxUrlOpts` | download url options. |++###### Returns++`Promise`\<`string`\>++URL for downloading file.++### getHost()++```ts+getHost(port: number): string+```++Get the host address for the specified sandbox port.+You can then use this address to connect to the sandbox port from outside the sandbox via HTTP or WebSocket.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `port` | `number` | number of the port in the sandbox. |++###### Returns++`string`++host address of the sandbox port.++###### Example++```ts+const sandbox = await Sandbox.create()+// Start an HTTP server+await sandbox.commands.exec('python3 -m http.server 3000')+// Get the hostname of the HTTP server+const serverURL = sandbox.getHost(3000)+```++### getInfo()++```ts+getInfo(opts?: Pick<SandboxOpts, "requestTimeoutMs">): Promise<SandboxInfo>+```++Get sandbox information like sandbox ID, template, metadata, started at/end at date.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `opts`? | `Pick`\<`SandboxOpts`, `"requestTimeoutMs"`\> | connection options. |++###### Returns++`Promise`\<`SandboxInfo`\>++information about the sandbox++### getMetrics()++```ts+getMetrics(opts?: SandboxMetricsOpts): Promise<SandboxMetrics[]>+```++Get the metrics of the sandbox.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `opts`? | `SandboxMetricsOpts` | connection options. |++###### Returns++`Promise`\<`SandboxMetrics`[]\>++List of sandbox metrics containing CPU, memory and disk usage information.++### isRunning()++```ts+isRunning(opts?: Pick<ConnectionOpts, "requestTimeoutMs">): Promise<boolean>+```++Check if the sandbox is running.++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `opts`? | `Pick`\<`ConnectionOpts`, `"requestTimeoutMs"`\> |++###### Returns++`Promise`\<`boolean`\>++`true` if the sandbox is running, `false` otherwise.++###### Example++```ts+const sandbox = await Sandbox.create()+await sandbox.isRunning() // Returns true++await sandbox.kill()+await sandbox.isRunning() // Returns false+```++### kill()++```ts+kill(opts?: Pick<SandboxOpts, "requestTimeoutMs">): Promise<void>+```++Kill the sandbox.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `opts`? | `Pick`\<`SandboxOpts`, `"requestTimeoutMs"`\> | connection options. |++###### Returns++`Promise`\<`void`\>++### setTimeout()++```ts+setTimeout(timeoutMs: number, opts?: Pick<SandboxOpts, "requestTimeoutMs">): Promise<void>+```++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 `.setTimeout`.+Maximum time a sandbox can be kept alive is 24 hours (86_400_000 milliseconds) for Pro users and 1 hour (3_600_000 milliseconds) for Hobby users.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `timeoutMs` | `number` | timeout in **milliseconds**. |+| `opts`? | `Pick`\<`SandboxOpts`, `"requestTimeoutMs"`\> | connection options. |++###### Returns++`Promise`\<`void`\>++### uploadUrl()++```ts+uploadUrl(path?: string, opts?: SandboxUrlOpts): Promise<string>+```++Get the URL to upload a file to the sandbox.++You have to send a POST request to this URL with the file as multipart/form-data.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path`? | `string` | path to the file in the sandbox. |+| `opts`? | `SandboxUrlOpts` | download url options. |++###### Returns++`Promise`\<`string`\>++URL for uploading file.++### betaCreate()++###### betaCreate(this, opts)++```ts+static betaCreate<S>(this: S, opts?: SandboxBetaCreateOpts): Promise<InstanceType<S>>+```++**`Beta`**++This feature is in beta and may change in the future.++Create a new sandbox from the default `base` sandbox template.++###### Type Parameters++| Type Parameter |+| ------ |+| `S` *extends* *typeof* `Sandbox` |++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `this` | `S` | - |+| `opts`? | `SandboxBetaCreateOpts` | connection options. |++###### Returns++`Promise`\<`InstanceType`\<`S`\>\>++sandbox instance for the new sandbox.++###### Example++```ts+const sandbox = await Sandbox.betaCreate()+```++###### Constructs++Sandbox++###### betaCreate(this, template, opts)++```ts+static betaCreate<S>(+ this: S,+ template: string,+opts?: SandboxBetaCreateOpts): Promise<InstanceType<S>>+```++**`Beta`**++This feature is in beta and may change in the future.++Create a new sandbox from the specified sandbox template.++###### Type Parameters++| Type Parameter |+| ------ |+| `S` *extends* *typeof* `Sandbox` |++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `this` | `S` | - |+| `template` | `string` | sandbox template name or ID. |+| `opts`? | `SandboxBetaCreateOpts` | connection options. |++###### Returns++`Promise`\<`InstanceType`\<`S`\>\>++sandbox instance for the new sandbox.++###### Example++```ts+const sandbox = await Sandbox.betaCreate('<template-name-or-id>')+```++###### Constructs++Sandbox++### betaPause()++```ts+static betaPause(sandboxId: string, opts?: SandboxApiOpts): Promise<boolean>+```++Pause the sandbox specified by sandbox ID.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `sandboxId` | `string` | sandbox ID. |+| `opts`? | `SandboxApiOpts` | connection options. |++###### Returns++`Promise`\<`boolean`\>++`true` if the sandbox got paused, `false` if the sandbox was already paused.++### connect()++```ts+static connect<S>(+ this: S,+ sandboxId: string,+opts?: SandboxConnectOpts): Promise<InstanceType<S>>+```++Connect to a sandbox. If the sandbox is paused, it will be automatically resumed.+Sandbox must be either running or be paused.++With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).++###### Type Parameters++| Type Parameter |+| ------ |+| `S` *extends* *typeof* `Sandbox` |++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `this` | `S` | - |+| `sandboxId` | `string` | sandbox ID. |+| `opts`? | `SandboxConnectOpts` | connection options. |++###### Returns++`Promise`\<`InstanceType`\<`S`\>\>++A running sandbox instance++###### Example++```ts+const sandbox = await Sandbox.create()+const sandboxId = sandbox.sandboxId++// Connect to the same sandbox.+const sameSandbox = await Sandbox.connect(sandboxId)+```++### create()++###### create(this, opts)++```ts+static create<S>(this: S, opts?: SandboxOpts): Promise<InstanceType<S>>+```++Create a new sandbox from the default `base` sandbox template.++###### Type Parameters++| Type Parameter |+| ------ |+| `S` *extends* *typeof* `Sandbox` |++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `this` | `S` | - |+| `opts`? | `SandboxOpts` | connection options. |++###### Returns++`Promise`\<`InstanceType`\<`S`\>\>++sandbox instance for the new sandbox.++###### Example++```ts+const sandbox = await Sandbox.create()+```++###### Constructs++Sandbox++###### create(this, template, opts)++```ts+static create<S>(+ this: S,+ template: string,+opts?: SandboxOpts): Promise<InstanceType<S>>+```++Create a new sandbox from the specified sandbox template.++###### Type Parameters++| Type Parameter |+| ------ |+| `S` *extends* *typeof* `Sandbox` |++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `this` | `S` | - |+| `template` | `string` | sandbox template name or ID. |+| `opts`? | `SandboxOpts` | connection options. |++###### Returns++`Promise`\<`InstanceType`\<`S`\>\>++sandbox instance for the new sandbox.++###### Example++```ts+const sandbox = await Sandbox.create('<template-name-or-id>')+```++###### Constructs++Sandbox++### getFullInfo()++```ts+static getFullInfo(sandboxId: string, opts?: SandboxApiOpts): Promise<object>+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `sandboxId` | `string` |+| `opts`? | `SandboxApiOpts` |++###### Returns++`Promise`\<`object`\>++| Name | Type | Default value |+| ------ | ------ | ------ |+| `cpuCount` | `number` | res.data.cpuCount |+| `endAt` | `Date` | - |+| `envdAccessToken` | `undefined` \| `string` | res.data.envdAccessToken |+| `envdVersion` | `string` | res.data.envdVersion |+| `memoryMB` | `number` | res.data.memoryMB |+| `metadata` | `object` | - |+| `name`? | `string` | res.data.alias |+| `sandboxDomain` | `undefined` \| `string` | - |+| `sandboxId` | `string` | res.data.sandboxID |+| `startedAt` | `Date` | - |+| `state` | `"running"` \| `"paused"` | res.data.state |+| `templateId` | `string` | res.data.templateID |++### getInfo()++```ts+static getInfo(sandboxId: string, opts?: SandboxApiOpts): Promise<SandboxInfo>+```++Get sandbox information like sandbox ID, template, metadata, started at/end at date.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `sandboxId` | `string` | sandbox ID. |+| `opts`? | `SandboxApiOpts` | connection options. |++###### Returns++`Promise`\<`SandboxInfo`\>++sandbox information.++### getMetrics()++```ts+static getMetrics(sandboxId: string, opts?: SandboxMetricsOpts): Promise<SandboxMetrics[]>+```++Get the metrics of the sandbox.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `sandboxId` | `string` | sandbox ID. |+| `opts`? | `SandboxMetricsOpts` | sandbox metrics options. |++###### Returns++`Promise`\<`SandboxMetrics`[]\>++List of sandbox metrics containing CPU, memory and disk usage information.++### kill()++```ts+static kill(sandboxId: string, opts?: SandboxApiOpts): Promise<boolean>+```++Kill the sandbox specified by sandbox ID.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `sandboxId` | `string` | sandbox ID. |+| `opts`? | `SandboxApiOpts` | connection options. |++###### Returns++`Promise`\<`boolean`\>++`true` if the sandbox was found and killed, `false` otherwise.++### list()++```ts+static list(opts?: SandboxListOpts): SandboxPaginator+```++List all sandboxes.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `opts`? | `SandboxListOpts` | connection options. |++###### Returns++`SandboxPaginator`++paginator for listing sandboxes.++### setTimeout()++```ts+static setTimeout(+ sandboxId: string,+ timeoutMs: number,+opts?: SandboxApiOpts): Promise<void>+```++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 Sandbox.setTimeout.++Maximum time a sandbox can be kept alive is 24 hours (86_400_000 milliseconds) for Pro users and 1 hour (3_600_000 milliseconds) for Hobby users.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `sandboxId` | `string` | sandbox ID. |+| `timeoutMs` | `number` | timeout in **milliseconds**. |+| `opts`? | `SandboxApiOpts` | connection options. |++###### Returns++`Promise`\<`void`\>++## Interfaces++### SandboxUrlOpts++Options for sandbox upload/download URL generation.++#### Properties++### user?++```ts+optional user: Username;+```++User that will be used to access the file.++### useSignatureExpiration?++```ts+optional useSignatureExpiration: number;+```++Use signature expiration for the URL.+Optional parameter to set the expiration time for the signature in seconds.diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v2.0.0/exceptions/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v2.0.0/exceptions/page.mdxnew file mode 100644index 000000000..17864645d--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v2.0.0/exceptions/page.mdx@@ -0,0 +1,84 @@++++## SandboxException++```python+class SandboxException(Exception)+```++Base class for all sandbox errors.++Raised when a general sandbox exception occurs.+++## TimeoutException++```python+class TimeoutException(SandboxException)+```++Raised when a timeout occurs.++The `unavailable` exception type is caused by sandbox timeout.++The `canceled` exception type is caused by exceeding request timeout.++The `deadline_exceeded` exception type is caused by exceeding the timeout for process, watch, etc.++The `unknown` exception type is sometimes caused by the sandbox timeout when the request is not processed correctly.+++## InvalidArgumentException++```python+class InvalidArgumentException(SandboxException)+```++Raised when an invalid argument is provided.+++## NotEnoughSpaceException++```python+class NotEnoughSpaceException(SandboxException)+```++Raised when there is not enough disk space.+++## NotFoundException++```python+class NotFoundException(SandboxException)+```++Raised when a resource is not found.+++## AuthenticationException++```python+class AuthenticationException(SandboxException)+```++Raised when authentication fails.+++## TemplateException++```python+class TemplateException(SandboxException)+```++Exception raised when the template uses old envd version. It isn't compatible with the new SDK.+++## RateLimitException++```python+class RateLimitException(SandboxException)+```++Raised when the API rate limit is exceeded.+diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v2.0.0/sandbox_async/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v2.0.0/sandbox_async/page.mdxnew file mode 100644index 000000000..0e6825d10--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v2.0.0/sandbox_async/page.mdx@@ -0,0 +1,1281 @@++++## SandboxApi++```python+class SandboxApi(SandboxBase)+```+++### list++```python+@staticmethod+def list(query: Optional[SandboxQuery] = None,+ limit: Optional[int] = None,+ next_token: Optional[str] = None,+ **opts: Unpack[ApiParams]) -> AsyncSandboxPaginator+```++List all running sandboxes.++**Arguments**:++- `query`: Filter the list of sandboxes by metadata or state, e.g. `SandboxListQuery(metadata={"key": "value"})` or `SandboxListQuery(state=[SandboxState.RUNNING])`+- `limit`: Maximum number of sandboxes to return per page+- `next_token`: Token for pagination++**Returns**:++List of running sandboxes+++++## Commands++```python+class Commands()+```++Module for executing commands in the sandbox.+++### list++```python+async def list(request_timeout: Optional[float] = None) -> List[ProcessInfo]+```++Lists all running commands and PTY sessions.++**Arguments**:++- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++List of running commands and PTY sessions+++### kill++```python+async def kill(pid: int, request_timeout: Optional[float] = None) -> bool+```++Kill a running command specified by its process ID.++It uses `SIGKILL` signal to kill the command.++**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+++### send\_stdin++```python+async def send_stdin(pid: int,+ data: str,+ request_timeout: Optional[float] = None) -> None+```++Send data to command stdin.++: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**++++### run++```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+```++Start a new command and wait until it finishes executing.++**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+++### run++```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+```++Start a new command and return a handle to interact with it.++**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**:++`AsyncCommandHandle` handle to interact with the running command+++### connect++```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+```++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++**Returns**:++`AsyncCommandHandle` handle to interact with the running command+++++## AsyncCommandHandle++```python+class AsyncCommandHandle()+```++Command execution handle.++It provides methods for waiting for the command to finish, retrieving stdout/stderr, and killing the command.+++### pid++```python+@property+def pid()+```++Command process ID.+++### stdout++```python+@property+def stdout()+```++Command stdout output.+++### stderr++```python+@property+def stderr()+```++Command stderr output.+++### error++```python+@property+def error()+```++Command execution error message.+++### exit\_code++```python+@property+def exit_code()+```++Command execution exit code.++`0` if the command finished successfully.++It is `None` if the command is still running.+++### disconnect++```python+async def disconnect() -> None+```++Disconnects from the command.++The command is not killed, but SDK stops receiving events from the command.+You can reconnect to the command using `sandbox.commands.connect` method.+++### wait++```python+async def wait() -> CommandResult+```++Wait for the command to finish and return the result.++If the command exits with a non-zero exit code, it throws a `CommandExitException`.++**Returns**:++`CommandResult` result of command execution+++### kill++```python+async def kill() -> bool+```++Kills the command.++It uses `SIGKILL` signal to kill the command++**Returns**:++`True` if the command was killed successfully, `False` if the command was not found+++++## Pty++```python+class Pty()+```++Module for interacting with PTYs (pseudo-terminals) in the sandbox.+++### kill++```python+async def kill(pid: int, request_timeout: Optional[float] = None) -> bool+```++Kill PTY.++**Arguments**:++- `pid`: Process ID of the PTY+- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++`true` if the PTY was killed, `false` if the PTY was not found+++### send\_stdin++```python+async def send_stdin(pid: int,+ data: bytes,+ request_timeout: Optional[float] = None) -> None+```++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**+++### create++```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+```++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+++### resize++```python+async def resize(pid: int,+ size: PtySize,+ request_timeout: Optional[float] = None)+```++Resize PTY.++Call this when the terminal window is resized and the number of columns and rows has changed.++**Arguments**:++- `pid`: Process ID of the PTY+- `size`: New size of the PTY+- `request_timeout`: Timeout for the request in **seconds**+++++## AsyncWatchHandle++```python+class AsyncWatchHandle()+```++Handle for watching a directory in the sandbox filesystem.++Use `.stop()` to stop watching the directory.+++### stop++```python+async def stop()+```++Stop watching the directory.+++++## Filesystem++```python+class Filesystem()+```++Module for interacting with the filesystem in the sandbox.+++### read++```python+@overload+async def read(path: str,+ format: Literal["text"] = "text",+ user: Username = "user",+ request_timeout: Optional[float] = None) -> str+```++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**++**Returns**:++File content as a `str`+++### read++```python+@overload+async def read(path: str,+ format: Literal["bytes"],+ user: Username = "user",+ request_timeout: Optional[float] = None) -> bytearray+```++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**:++File content as a `bytearray`+++### read++```python+@overload+async def read(+ path: str,+ format: Literal["stream"],+ user: Username = "user",+ request_timeout: Optional[float] = None) -> AsyncIterator[bytes]+```++Read file content as a `AsyncIterator[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**++**Returns**:++File content as an `AsyncIterator[bytes]`+++### write++```python+async def write(path: str,+ data: Union[str, bytes, IO],+ user: Username = "user",+ request_timeout: Optional[float] = None) -> WriteInfo+```++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.++**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+++### write\_files++```python+async def write_files(+ files: List[WriteEntry],+ user: Username = "user",+ request_timeout: Optional[float] = None) -> List[WriteInfo]+```++Writes multiple files.++Writes a list of files to the filesystem.+When writing to a file that doesn't exist, the file will get created.+When writing to a file that already exists, the file will get overwritten.+When writing to a file that's in a directory that doesn't exist, you'll get an error.++**Arguments**:++- `files`: list of files to write as `WriteEntry` objects, each containing `path` and `data`+- `user`: Run the operation as this user+- `request_timeout`: Timeout for the request++**Returns**:++Information about the written files+++### list++```python+async def list(path: str,+ depth: Optional[int] = 1,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> List[EntryInfo]+```++List entries in a directory.++**Arguments**:++- `path`: Path to the directory+- `depth`: Depth of the directory to list+- `user`: Run the operation as this user+- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++List of entries in the directory+++### exists++```python+async def exists(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> bool+```++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 file or directory exists, `False` otherwise+++### get\_info++```python+async def get_info(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> EntryInfo+```++Get information about a file or 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**:++Information about the file or directory like name, type, and path+++### remove++```python+async def remove(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> None+```++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**+++### rename++```python+async def rename(old_path: str,+ new_path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> EntryInfo+```++Rename a file or directory.++**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+- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++Information about the renamed file or directory+++### make\_dir++```python+async def make_dir(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> bool+```++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 directory was created, `False` if the directory already exists+++### watch\_dir++```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+```++Watch directory for filesystem events.++**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++**Returns**:++`AsyncWatchHandle` object for stopping watching directory+++++## AsyncSandboxPaginator++```python+class AsyncSandboxPaginator(SandboxPaginatorBase)+```++Paginator for listing sandboxes.++**Example**:++```python+paginator = AsyncSandbox.list()++while paginator.has_next:+ sandboxes = await paginator.next_items()+ print(sandboxes)+```+++### next\_items++```python+async def next_items() -> List[SandboxInfo]+```++Returns the next page of sandboxes.++Call this method only if `has_next` is `True`, otherwise it will raise an exception.++**Returns**:++List of sandboxes+++++## AsyncSandbox++```python+class AsyncSandbox(SandboxApi)+```++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).++Use the `AsyncSandbox.create()` to create a new sandbox.++**Example**:++```python+from e2b import AsyncSandbox++sandbox = await AsyncSandbox.create()+```+++### files++```python+@property+def files() -> Filesystem+```++Module for interacting with the sandbox filesystem.+++### commands++```python+@property+def commands() -> Commands+```++Module for running commands in the sandbox.+++### pty++```python+@property+def pty() -> Pty+```++Module for interacting with the sandbox pseudo-terminal.+++### \_\_init\_\_++```python+def __init__(**opts: Unpack[SandboxOpts])+```++Use `AsyncSandbox.create()` to create a new sandbox instead.+++### is\_running++```python+async def is_running(request_timeout: Optional[float] = None) -> bool+```++Check if the sandbox is running.++**Arguments**:++- `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+```+++### create++```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,+ secure: Optional[bool] = True,+ allow_internet_access: bool = True,+ **opts: Unpack[ApiParams]) -> Self+```++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. The 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+- `secure`: Envd is secured with access token and cannot be used without it, defaults to `True`.+- `allow_internet_access`: Allow sandbox to access the internet, defaults to `True`.++**Returns**:++A Sandbox instance for the new sandbox+Use this method instead of using the constructor to create a new sandbox.+++### connect++```python+@overload+async def connect(timeout: Optional[int] = None,+ **opts: Unpack[ApiParams]) -> Self+```++Connect to a sandbox. If the sandbox is paused, it will be automatically resumed.++Sandbox must be either running or be paused.++With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).++**Arguments**:++- `timeout`: Timeout for the sandbox in **seconds**++**Returns**:++A running sandbox instance+@example+```python+sandbox = await AsyncSandbox.create()+await sandbox.beta_pause()++same_sandbox = await sandbox.connect()+```+++### connect++```python+@overload+@classmethod+async def connect(cls,+ sandbox_id: str,+ timeout: Optional[int] = None,+ **opts: Unpack[ApiParams]) -> Self+```++Connect to a sandbox. If the sandbox is paused, it will be automatically resumed.++Sandbox must be either running or be paused.++With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).++**Arguments**:++- `sandbox_id`: Sandbox ID+- `timeout`: Timeout for the sandbox in **seconds**++**Returns**:++A running sandbox instance+@example+```python+sandbox = await AsyncSandbox.create()+await AsyncSandbox.beta_pause(sandbox.sandbox_id)++same_sandbox = await AsyncSandbox.connect(sandbox.sandbox_id))+```+++### connect++```python+@class_method_variant("_cls_connect")+async def connect(timeout: Optional[int] = None,+ **opts: Unpack[ApiParams]) -> Self+```++Connect to a sandbox. If the sandbox is paused, it will be automatically resumed.++Sandbox must be either running or be paused.++With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).++**Arguments**:++- `timeout`: Timeout for the sandbox in **seconds**++**Returns**:++A running sandbox instance+@example+```python+sandbox = await AsyncSandbox.create()+await sandbox.beta_pause()++same_sandbox = await sandbox.connect()+```+++### kill++```python+@overload+async def kill(**opts: Unpack[ApiParams]) -> bool+```++Kill the sandbox.++**Returns**:++`True` if the sandbox was killed, `False` if the sandbox was not found+++### kill++```python+@overload+@staticmethod+async def kill(sandbox_id: str, **opts: Unpack[ApiParams]) -> bool+```++Kill the sandbox specified by sandbox ID.++**Arguments**:++- `sandbox_id`: Sandbox ID++**Returns**:++`True` if the sandbox was killed, `False` if the sandbox was not found+++### kill++```python+@class_method_variant("_cls_kill")+async def kill(**opts: Unpack[ApiParams]) -> bool+```++Kill the sandbox specified by sandbox ID.++**Returns**:++`True` if the sandbox was killed, `False` if the sandbox was not found+++### set\_timeout++```python+@overload+async def set_timeout(timeout: int, **opts: Unpack[ApiParams]) -> None+```++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`.++The 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**+++### set\_timeout++```python+@overload+@staticmethod+async def set_timeout(sandbox_id: str, timeout: int,+ **opts: Unpack[ApiParams]) -> None+```++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`.++The 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**:++- `sandbox_id`: Sandbox ID+- `timeout`: Timeout for the sandbox in **seconds**+++### set\_timeout++```python+@class_method_variant("_cls_set_timeout")+async def set_timeout(timeout: int, **opts: Unpack[ApiParams]) -> None+```++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`.++The 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**+++### get\_info++```python+@overload+async def get_info(**opts: Unpack[ApiParams]) -> SandboxInfo+```++Get sandbox information like sandbox ID, template, metadata, started at/end at date.++**Returns**:++Sandbox info+++### get\_info++```python+@overload+@staticmethod+async def get_info(sandbox_id: str, **opts: Unpack[ApiParams]) -> SandboxInfo+```++Get sandbox information like sandbox ID, template, metadata, started at/end at date.++**Arguments**:++- `sandbox_id`: Sandbox ID++**Returns**:++Sandbox info+++### get\_info++```python+@class_method_variant("_cls_get_info")+async def get_info(**opts: Unpack[ApiParams]) -> SandboxInfo+```++Get sandbox information like sandbox ID, template, metadata, started at/end at date.++**Returns**:++Sandbox info+++### get\_metrics++```python+@overload+async def get_metrics(start: Optional[datetime.datetime] = None,+ end: Optional[datetime.datetime] = None,+ **opts: Unpack[ApiParams]) -> List[SandboxMetrics]+```++Get the metrics of the current sandbox.++**Arguments**:++- `start`: Start time for the metrics, defaults to the start of the sandbox+- `end`: End time for the metrics, defaults to the current time++**Returns**:++List of sandbox metrics containing CPU, memory and disk usage information+++### get\_metrics++```python+@overload+@staticmethod+async def get_metrics(sandbox_id: str,+ start: Optional[datetime.datetime] = None,+ end: Optional[datetime.datetime] = None,+ **opts: Unpack[ApiParams]) -> List[SandboxMetrics]+```++Get the metrics of the sandbox specified by sandbox ID.++**Arguments**:++- `sandbox_id`: Sandbox ID+- `start`: Start time for the metrics, defaults to the start of the sandbox+- `end`: End time for the metrics, defaults to the current time++**Returns**:++List of sandbox metrics containing CPU, memory and disk usage information+++### get\_metrics++```python+@class_method_variant("_cls_get_metrics")+async def get_metrics(start: Optional[datetime.datetime] = None,+ end: Optional[datetime.datetime] = None,+ **opts: Unpack[ApiParams]) -> List[SandboxMetrics]+```++Get the metrics of the current sandbox.++**Arguments**:++- `start`: Start time for the metrics, defaults to the start of the sandbox+- `end`: End time for the metrics, defaults to the current time++**Returns**:++List of sandbox metrics containing CPU, memory and disk usage information+++### beta\_create++```python+@classmethod+async def beta_create(cls,+ template: Optional[str] = None,+ timeout: Optional[int] = None,+ auto_pause: bool = False,+ metadata: Optional[Dict[str, str]] = None,+ envs: Optional[Dict[str, str]] = None,+ secure: bool = True,+ allow_internet_access: bool = True,+ **opts: Unpack[ApiParams]) -> Self+```++[BETA] This feature is in beta and may change in the future.++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. The 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.+- `auto_pause`: Automatically pause the sandbox after the timeout expires. Defaults to `False`.+- `metadata`: Custom metadata for the sandbox+- `envs`: Custom environment variables for the sandbox+- `secure`: Envd is secured with access token and cannot be used without it, defaults to `True`.+- `allow_internet_access`: Allow sandbox to access the internet, defaults to `True`.++**Returns**:++A Sandbox instance for the new sandbox+Use this method instead of using the constructor to create a new sandbox.+++### beta\_pause++```python+@overload+async def beta_pause(**opts: Unpack[ApiParams]) -> None+```++[BETA] This feature is in beta and may change in the future.++Pause the sandbox.++**Returns**:++Sandbox ID that can be used to resume the sandbox+++### beta\_pause++```python+@overload+@staticmethod+async def beta_pause(sandbox_id: str, **opts: Unpack[ApiParams]) -> None+```++[BETA] This feature is in beta and may change in the future.++Pause the sandbox specified by sandbox ID.++**Arguments**:++- `sandbox_id`: Sandbox ID++**Returns**:++Sandbox ID that can be used to resume the sandbox+++### beta\_pause++```python+@class_method_variant("_cls_pause")+async def beta_pause(**opts: Unpack[ApiParams]) -> None+```++[BETA] This feature is in beta and may change in the future.++Pause the sandbox.++**Returns**:++Sandbox ID that can be used to resume the sandbox+++diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v2.0.0/sandbox_sync/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v2.0.0/sandbox_sync/page.mdxnew file mode 100644index 000000000..dc03a866e--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v2.0.0/sandbox_sync/page.mdx@@ -0,0 +1,1240 @@++++## SandboxApi++```python+class SandboxApi(SandboxBase)+```+++### list++```python+@staticmethod+def list(query: Optional[SandboxQuery] = None,+ limit: Optional[int] = None,+ next_token: Optional[str] = None,+ **opts: Unpack[ApiParams]) -> SandboxPaginator+```++List all running sandboxes.++**Arguments**:++- `query`: Filter the list of sandboxes by metadata or state, e.g. `SandboxListQuery(metadata={"key": "value"})` or `SandboxListQuery(state=[SandboxState.RUNNING])`+- `limit`: Maximum number of sandboxes to return per page+- `next_token`: Token for pagination++**Returns**:++List of running sandboxes+++++## Commands++```python+class Commands()+```++Module for executing commands in the sandbox.+++### list++```python+def list(request_timeout: Optional[float] = None) -> List[ProcessInfo]+```++Lists all running commands and PTY sessions.++**Arguments**:++- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++List of running commands and PTY sessions+++### kill++```python+def kill(pid: int, request_timeout: Optional[float] = None) -> bool+```++Kills a running command specified by its process ID.++It uses `SIGKILL` signal to kill the command.++**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+++### send\_stdin++```python+def send_stdin(pid: int, data: str, request_timeout: Optional[float] = None)+```++Send data to command stdin.++: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**++++### run++```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+```++Start a new command and wait until it finishes executing.++**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+++### run++```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+```++Start a new command and return a handle to interact with it.++**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+- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++`CommandHandle` handle to interact with the running command+++### connect++```python+def connect(pid: int,+ timeout: Optional[float] = 60,+ request_timeout: Optional[float] = None)+```++Connects to a running command.++You can use `CommandHandle.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()`+- `timeout`: Timeout for the connection in **seconds**. Using `0` will not limit the connection time+- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++`CommandHandle` handle to interact with the running command+++++## CommandHandle++```python+class CommandHandle()+```++Command execution handle.++It provides methods for waiting for the command to finish, retrieving stdout/stderr, and killing the command.+++### pid++```python+@property+def pid()+```++Command process ID.+++### \_\_iter\_\_++```python+def __iter__()+```++Iterate over the command output.++**Returns**:++Generator of command outputs+++### disconnect++```python+def disconnect() -> None+```++Disconnect from the command.++The command is not killed, but SDK stops receiving events from the command.+You can reconnect to the command using `sandbox.commands.connect` method.+++### wait++```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+```++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+++### kill++```python+def kill() -> bool+```++Kills the command.++It uses `SIGKILL` signal to kill the command.++**Returns**:++Whether the command was killed successfully+++++## Pty++```python+class Pty()+```++Module for interacting with PTYs (pseudo-terminals) in the sandbox.+++### kill++```python+def kill(pid: int, request_timeout: Optional[float] = None) -> bool+```++Kill PTY.++**Arguments**:++- `pid`: Process ID of the PTY+- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++`true` if the PTY was killed, `false` if the PTY was not found+++### send\_stdin++```python+def send_stdin(pid: int,+ data: bytes,+ request_timeout: Optional[float] = None) -> None+```++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**+++### create++```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+```++Start a new PTY (pseudo-terminal).++**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**+- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++Handle to interact with the PTY+++### resize++```python+def resize(pid: int,+ size: PtySize,+ request_timeout: Optional[float] = None) -> None+```++Resize PTY.++Call this when the terminal window is resized and the number of columns and rows has changed.++**Arguments**:++- `pid`: Process ID of the PTY+- `size`: New size of the PTY+- `request_timeout`: Timeout for the request in **seconds**s+++++## WatchHandle++```python+class WatchHandle()+```++Handle for watching filesystem events.+It is used to get the latest events that have occurred in the watched directory.++Use `.stop()` to stop watching the directory.+++### stop++```python+def stop()+```++Stop watching the directory.+After you stop the watcher you won't be able to get the events anymore.+++### get\_new\_events++```python+def get_new_events() -> List[FilesystemEvent]+```++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.++**Returns**:++List of filesystem events+++++## Filesystem++```python+class Filesystem()+```++Module for interacting with the filesystem in the sandbox.+++### read++```python+@overload+def read(path: str,+ format: Literal["text"] = "text",+ user: Username = "user",+ request_timeout: Optional[float] = None) -> str+```++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**++**Returns**:++File content as a `str`+++### read++```python+@overload+def read(path: str,+ format: Literal["bytes"],+ user: Username = "user",+ request_timeout: Optional[float] = None) -> bytearray+```++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**:++File content as a `bytearray`+++### read++```python+@overload+def read(path: str,+ format: Literal["stream"],+ user: Username = "user",+ request_timeout: Optional[float] = None) -> Iterator[bytes]+```++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**++**Returns**:++File content as an `Iterator[bytes]`+++### write++```python+def write(path: str,+ data: Union[str, bytes, IO],+ user: Username = "user",+ request_timeout: Optional[float] = None) -> WriteInfo+```++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.++**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+++### write\_files++```python+def write_files(files: List[WriteEntry],+ user: Username = "user",+ request_timeout: Optional[float] = None) -> List[WriteInfo]+```++Writes a list of files to the filesystem.++When writing to a file that doesn't exist, the file will get created.+When writing to a file that already exists, the file will get overwritten.+When writing to a file that's in a directory that doesn't exist, you'll get an error.++**Arguments**:++- `files`: list of files to write as `WriteEntry` objects, each containing `path` and `data`+- `user`: Run the operation as this user+- `request_timeout`: Timeout for the request++**Returns**:++Information about the written files+++### list++```python+def list(path: str,+ depth: Optional[int] = 1,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> List[EntryInfo]+```++List entries in a directory.++**Arguments**:++- `path`: Path to the directory+- `depth`: Depth of the directory to list+- `user`: Run the operation as this user+- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++List of entries in the directory+++### exists++```python+def exists(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> bool+```++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 file or directory exists, `False` otherwise+++### get\_info++```python+def get_info(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> EntryInfo+```++Get information about a file or 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**:++Information about the file or directory like name, type, and path+++### remove++```python+def remove(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> None+```++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**+++### rename++```python+def rename(old_path: str,+ new_path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> EntryInfo+```++Rename a file or directory.++**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+- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++Information about the renamed file or directory+++### make\_dir++```python+def make_dir(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None) -> bool+```++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 directory was created, `False` if the directory already exists+++### watch\_dir++```python+def watch_dir(path: str,+ user: Username = "user",+ request_timeout: Optional[float] = None,+ recursive: bool = False) -> WatchHandle+```++Watch directory for filesystem events.++**Arguments**:++- `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**:++`WatchHandle` object for stopping watching directory+++++## SandboxPaginator++```python+class SandboxPaginator(SandboxPaginatorBase)+```++Paginator for listing sandboxes.++**Example**:++```python+paginator = AsyncSandbox.list()++while paginator.has_next:+ sandboxes = await paginator.next_items()+ print(sandboxes)+```+++### next\_items++```python+def next_items() -> List[SandboxInfo]+```++Returns the next page of sandboxes.++Call this method only if `has_next` is `True`, otherwise it will raise an exception.++**Returns**:++List of sandboxes+++++## Sandbox++```python+class Sandbox(SandboxApi)+```++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).++Use the `Sandbox.create()` to create a new sandbox.++**Example**:++```python+from e2b import Sandbox++sandbox = Sandbox.create()+```+++### files++```python+@property+def files() -> Filesystem+```++Module for interacting with the sandbox filesystem.+++### commands++```python+@property+def commands() -> Commands+```++Module for running commands in the sandbox.+++### pty++```python+@property+def pty() -> Pty+```++Module for interacting with the sandbox pseudo-terminal.+++### \_\_init\_\_++```python+def __init__(**opts: Unpack[SandboxOpts])+```++:deprecated: This constructor is deprecated++Use `Sandbox.create()` to create a new sandbox instead.+++### is\_running++```python+def is_running(request_timeout: Optional[float] = None) -> bool+```++Check if the sandbox is running.++**Arguments**:++- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++`True` if the sandbox is running, `False` otherwise+Example+```python+sandbox = Sandbox.create()+sandbox.is_running() # Returns True++sandbox.kill()+sandbox.is_running() # Returns False+```+++### create++```python+@classmethod+def create(cls,+ template: Optional[str] = None,+ timeout: Optional[int] = None,+ metadata: Optional[Dict[str, str]] = None,+ envs: Optional[Dict[str, str]] = None,+ secure: bool = True,+ allow_internet_access: bool = True,+ **opts: Unpack[ApiParams]) -> Self+```++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. The 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+- `secure`: Envd is secured with access token and cannot be used without it, defaults to `True`.+- `allow_internet_access`: Allow sandbox to access the internet, defaults to `True`.++**Returns**:++A Sandbox instance for the new sandbox+Use this method instead of using the constructor to create a new sandbox.+++### connect++```python+@overload+def connect(timeout: Optional[int] = None, **opts: Unpack[ApiParams]) -> Self+```++Connect to a sandbox. If the sandbox is paused, it will be automatically resumed.++Sandbox must be either running or be paused.++With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).++**Arguments**:++- `timeout`: Timeout for the sandbox in **seconds**++**Returns**:++A running sandbox instance+@example+```python+sandbox = Sandbox.create()+sandbox.beta_pause()++same_sandbox = sandbox.connect()+++### connect++```python+@overload+@classmethod+def connect(cls,+ sandbox_id: str,+ timeout: Optional[int] = None,+ **opts: Unpack[ApiParams]) -> Self+```++Connect to a sandbox. If the sandbox is paused, it will be automatically resumed.++Sandbox must be either running or be paused.++With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).++**Arguments**:++- `sandbox_id`: Sandbox ID+- `timeout`: Timeout for the sandbox in **seconds**++**Returns**:++A running sandbox instance+@example+```python+sandbox = Sandbox.create()+Sandbox.beta_pause(sandbox.sandbox_id)++same_sandbox = Sandbox.connect(sandbox.sandbox_id)+```+++### connect++```python+@class_method_variant("_cls_connect")+def connect(timeout: Optional[int] = None, **opts: Unpack[ApiParams]) -> Self+```++Connect to a sandbox. If the sandbox is paused, it will be automatically resumed.++Sandbox must be either running or be paused.++With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).++**Arguments**:++- `timeout`: Timeout for the sandbox in **seconds**++**Returns**:++A running sandbox instance+@example+```python+sandbox = Sandbox.create()+sandbox.beta_pause()++same_sandbox = sandbox.connect()+```+++### kill++```python+@overload+def kill(**opts: Unpack[ApiParams]) -> bool+```++Kill the sandbox.++**Returns**:++`True` if the sandbox was killed, `False` if the sandbox was not found+++### kill++```python+@overload+@staticmethod+def kill(sandbox_id: str, **opts: Unpack[ApiParams]) -> bool+```++Kill the sandbox specified by sandbox ID.++**Arguments**:++- `sandbox_id`: Sandbox ID++**Returns**:++`True` if the sandbox was killed, `False` if the sandbox was not found+++### kill++```python+@class_method_variant("_cls_kill")+def kill(**opts: Unpack[ApiParams]) -> bool+```++Kill the sandbox specified by sandbox ID.++**Returns**:++`True` if the sandbox was killed, `False` if the sandbox was not found+++### set\_timeout++```python+@overload+def set_timeout(timeout: int, **opts: Unpack[ApiParams]) -> None+```++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`.++The 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**+++### set\_timeout++```python+@overload+@staticmethod+def set_timeout(sandbox_id: str, timeout: int,+ **opts: Unpack[ApiParams]) -> None+```++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`.++The 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**:++- `sandbox_id`: Sandbox ID+- `timeout`: Timeout for the sandbox in **seconds**+++### set\_timeout++```python+@class_method_variant("_cls_set_timeout")+def set_timeout(timeout: int, **opts: Unpack[ApiParams]) -> None+```++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`.++The 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**+++### get\_info++```python+@overload+def get_info(**opts: Unpack[ApiParams]) -> SandboxInfo+```++Get sandbox information like sandbox ID, template, metadata, started at/end at date.++**Returns**:++Sandbox info+++### get\_info++```python+@overload+@staticmethod+def get_info(sandbox_id: str, **opts: Unpack[ApiParams]) -> SandboxInfo+```++Get sandbox information like sandbox ID, template, metadata, started at/end at date.++**Arguments**:++- `sandbox_id`: Sandbox ID++**Returns**:++Sandbox info+++### get\_info++```python+@class_method_variant("_cls_get_info")+def get_info(**opts: Unpack[ApiParams]) -> SandboxInfo+```++Get sandbox information like sandbox ID, template, metadata, started at/end at date.++**Returns**:++Sandbox info+++### get\_metrics++```python+@overload+def get_metrics(start: Optional[datetime.datetime] = None,+ end: Optional[datetime.datetime] = None,+ **opts: Unpack[ApiParams]) -> List[SandboxMetrics]+```++Get the metrics of the current sandbox.++**Arguments**:++- `start`: Start time for the metrics, defaults to the start of the sandbox+- `end`: End time for the metrics, defaults to the current time++**Returns**:++List of sandbox metrics containing CPU, memory and disk usage information+++### get\_metrics++```python+@overload+@staticmethod+def get_metrics(sandbox_id: str,+ start: Optional[datetime.datetime] = None,+ end: Optional[datetime.datetime] = None,+ **opts: Unpack[ApiParams]) -> List[SandboxMetrics]+```++Get the metrics of the sandbox specified by sandbox ID.++**Arguments**:++- `sandbox_id`: Sandbox ID+- `start`: Start time for the metrics, defaults to the start of the sandbox+- `end`: End time for the metrics, defaults to the current time++**Returns**:++List of sandbox metrics containing CPU, memory and disk usage information+++### get\_metrics++```python+@class_method_variant("_cls_get_metrics")+def get_metrics(start: Optional[datetime.datetime] = None,+ end: Optional[datetime.datetime] = None,+ **opts: Unpack[ApiParams]) -> List[SandboxMetrics]+```++Get the metrics of the sandbox specified by sandbox ID.++**Arguments**:++- `start`: Start time for the metrics, defaults to the start of the sandbox+- `end`: End time for the metrics, defaults to the current time++**Returns**:++List of sandbox metrics containing CPU, memory and disk usage information+++### beta\_create++```python+@classmethod+def beta_create(cls,+ template: Optional[str] = None,+ timeout: Optional[int] = None,+ auto_pause: bool = False,+ metadata: Optional[Dict[str, str]] = None,+ envs: Optional[Dict[str, str]] = None,+ secure: bool = True,+ allow_internet_access: bool = True,+ **opts: Unpack[ApiParams]) -> Self+```++[BETA] This feature is in beta and may change in the future.++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. The 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.+- `auto_pause`: Automatically pause the sandbox after the timeout expires. Defaults to `False`.+- `metadata`: Custom metadata for the sandbox+- `envs`: Custom environment variables for the sandbox+- `secure`: Envd is secured with access token and cannot be used without it, defaults to `True`.+- `allow_internet_access`: Allow sandbox to access the internet, defaults to `True`.++**Returns**:++A Sandbox instance for the new sandbox+Use this method instead of using the constructor to create a new sandbox.+++### beta\_pause++```python+@overload+def beta_pause(**opts: Unpack[ApiParams]) -> None+```++[BETA] This feature is in beta and may change in the future.++Pause the sandbox.+++### beta\_pause++```python+@overload+@classmethod+def beta_pause(cls, sandbox_id: str, **opts: Unpack[ApiParams]) -> None+```++[BETA] This feature is in beta and may change in the future.++Pause the sandbox specified by sandbox ID.++**Arguments**:++- `sandbox_id`: Sandbox ID+++### beta\_pause++```python+@class_method_variant("_cls_pause")+def beta_pause(**opts: Unpack[ApiParams]) -> None+```++[BETA] This feature is in beta and may change in the future.++Pause the sandbox.++**Returns**:++Sandbox ID that can be used to resume the sandbox+diff --git a/packages/cli/package.json b/packages/cli/package.jsonindex eb1ec6fd2..305c5747b 100644--- a/packages/cli/package.json+++ b/packages/cli/package.json@@ -1,6 +1,6 @@{"name": "@e2b/cli",- "version": "1.9.2",+ "version": "2.0.0","description": "CLI for managing e2b sandbox templates","homepage": "https://e2b.dev","license": "MIT",@@ -75,7 +75,7 @@"command-exists": "^1.2.9","commander": "^11.1.0","console-table-printer": "^2.11.2",- "e2b": "^1.11.0",+ "e2b": "^2.0.0","inquirer": "^9.2.12","open": "^9.1.0","statuses": "^2.0.1",diff --git a/packages/js-sdk/package.json b/packages/js-sdk/package.jsonindex 381e2cdf7..522cd5770 100644--- a/packages/js-sdk/package.json+++ b/packages/js-sdk/package.json@@ -1,6 +1,6 @@{"name": "e2b",- "version": "1.13.2",+ "version": "2.0.0","description": "E2B SDK that give agents cloud environments","homepage": "https://e2b.dev","license": "MIT",diff --git a/packages/python-sdk/package.json b/packages/python-sdk/package.jsonindex cc0c81479..11e42cd23 100644--- a/packages/python-sdk/package.json+++ b/packages/python-sdk/package.json@@ -1,7 +1,7 @@{"name": "@e2b/python-sdk","private": true,- "version": "1.11.1",+ "version": "2.0.0","scripts": {"example": "poetry run python example.py","test": "poetry run pytest -n 4 --verbose -x",diff --git a/packages/python-sdk/pyproject.toml b/packages/python-sdk/pyproject.tomlindex da73332d7..05cb022ad 100644--- a/packages/python-sdk/pyproject.toml+++ b/packages/python-sdk/pyproject.toml@@ -1,6 +1,6 @@[tool.poetry]name = "e2b"-version = "1.11.1"+version = "2.0.0"description = "E2B SDK that give agents cloud environments"authors = ["e2b <[email protected]>"]license = "MIT"diff --git a/pnpm-lock.yaml b/pnpm-lock.yamlindex edb6ec30c..5a629d7a7 100644--- a/pnpm-lock.yaml+++ b/pnpm-lock.yaml@@ -118,8 +118,8 @@ importers:specifier: ^1.2.1version: 1.2.1e2b:- specifier: ^1.13.2- version: 1.13.2+ specifier: ^2.0.0+ version: 2.0.0fast-glob:specifier: ^3.3.0version: 3.3.1@@ -266,8 +266,8 @@ importers:specifier: ^2.11.2version: 2.11.2e2b:- specifier: ^1.11.0- version: 1.11.0+ specifier: ^2.0.0+ version: 2.0.0inquirer:specifier: ^9.2.12version: 9.2.12@@ -3781,12 +3781,8 @@ packages:resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}engines: {node: '>= 0.4'}- resolution: {integrity: sha512-4kB6cQljSVGbenT/N4VktdJE9PKJ+4i7fqsNGFkyOIrOdBGxPrnc2WHh4E4gVeO+xmL59WYBlQRNpvFoGh/KYA==}- engines: {node: '>=18'}-- resolution: {integrity: sha512-m8acE/MzMAJo1A57DakR2X1Sl5Mt1tcQO2aJfygNaQHLXby/4xsjF0UeJUB70jF7xntiR41pAMbZEHnkzrT9tw==}+ resolution: {integrity: sha512-kC7IC2H/GVoAEgoeMetQjnyhIOTwQUsd7XF1GAl7dD0DmqzwjTr3kFfoilRjyt4ywXu8HROdmIEmEcAFm0slBw==}engines: {node: '>=18'}@@ -11607,16 +11603,7 @@ snapshots:es-errors: 1.3.0gopd: 1.2.0- dependencies:- '@bufbuild/protobuf': 2.6.2- '@connectrpc/connect': 2.0.0-rc.3(@bufbuild/[email protected])- '@connectrpc/connect-web': 2.0.0-rc.3(@bufbuild/[email protected])(@connectrpc/[email protected](@bufbuild/[email protected]))- compare-versions: 6.1.1- openapi-fetch: 0.9.8- platform: 1.3.6-dependencies:'@bufbuild/protobuf': 2.6.2'@connectrpc/connect': 2.0.0-rc.3(@bufbuild/[email protected])