Skip to content

armgit / E2B

Public Imported from GitHub
0

Open-source, secure environment with real-world tools for enterprise-grade agents.

[skip ci] Release new SDK API reference doc versions

github-actions[bot]f2de8cb89f28
diff --git a/apps/web/src/app/(docs)/docs/api-reference/cli/v0.5.10/auth/page.mdx b/apps/web/src/app/(docs)/docs/api-reference/cli/v0.5.10/auth/page.mdx
new file mode 100644
index 000000000..5e547262c
--- /dev/null
+++ b/apps/web/src/app/(docs)/docs/api-reference/cli/v0.5.10/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/api-reference/cli/v0.5.10/sandbox/page.mdx b/apps/web/src/app/(docs)/docs/api-reference/cli/v0.5.10/sandbox/page.mdx
new file mode 100644
index 000000000..060e6969c
--- /dev/null
+++ b/apps/web/src/app/(docs)/docs/api-reference/cli/v0.5.10/sandbox/page.mdx
@@ -0,0 +1,84 @@
+# e2b sandbox
+
+
+work with sandboxes
+
+## Usage
+
+```bash
+e2b sandbox [options] [command]
+```
+# e2b sandbox connect
+
+
+connect terminal to already running sandbox
+
+## Usage
+
+```bash
+e2b sandbox connect [options] <sandboxID>
+```
+
+
+# e2b sandbox list
+
+
+list all running sandboxes
+
+## Usage
+
+```bash
+e2b sandbox list [options]
+```
+
+
+# e2b sandbox kill
+
+
+kill sandbox
+
+## Usage
+
+```bash
+e2b sandbox kill [options] <sandboxID>
+```
+
+
+# e2b sandbox spawn
+
+
+spawn sandbox and connect terminal to it
+
+## Usage
+
+```bash
+e2b sandbox spawn [options] [template]
+```
+
+## Options
+
+
+ - `-p, --path <path>: change root directory where command is executed to <path> directory `
+ - `--config <e2b-toml>: specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+
+
+# e2b sandbox logs
+
+
+show logs for sandbox
+
+## Usage
+
+```bash
+e2b sandbox logs [options] <sandboxID>
+```
+
+## Options
+
+
+ - `--level <level>: filter logs by level (DEBUG, INFO, WARN, ERROR). The logs with the higher levels will be also shown. [default: INFO]`
+ - `-f, --follow: keep streaming logs until the sandbox is closed `
+ - `--format <format>: specify format for printing logs (json, pretty) [default: pretty]`
+ - `--loggers [loggers]: filter logs by loggers. The available loggers are process, filesystem, terminal, network, file. Specify multiple loggers by separating them with a comma. [default: process,filesystem]`
+
+
diff --git a/apps/web/src/app/(docs)/docs/api-reference/cli/v0.5.10/template/page.mdx b/apps/web/src/app/(docs)/docs/api-reference/cli/v0.5.10/template/page.mdx
new file mode 100644
index 000000000..48d3dcb2e
--- /dev/null
+++ b/apps/web/src/app/(docs)/docs/api-reference/cli/v0.5.10/template/page.mdx
@@ -0,0 +1,90 @@
+# e2b template
+
+
+manage sandbox templates
+
+## Usage
+
+```bash
+e2b template [options] [command]
+```
+# e2b template build
+
+
+build sandbox template defined by ./e2b.Dockerfile or ./Dockerfile in root directory. By default the root directory is the current working directory. This command also creates e2b.toml config.
+
+## Usage
+
+```bash
+e2b template build [options] [template]
+```
+
+## Options
+
+
+ - `-p, --path <path>: change root directory where command is executed to <path> directory `
+ - `-d, --dockerfile <file>: specify path to Dockerfile. By default E2B tries to find e2b.Dockerfile or Dockerfile in root directory. `
+ - `-n, --name <template-name>: specify sandbox template name. You can use the template name to start the sandbox with SDK. The template name must be lowercase and contain only letters, numbers, dashes and underscores. `
+ - `-c, --cmd <start-command>: specify command that will be executed when the sandbox is started. `
+ - `-t, --team <team-id>: specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `--config <e2b-toml>: specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `--cpu-count <cpu-count>: specify the number of CPUs that will be used to run the sandbox. The default value is 2. `
+ - `--memory-mb <memory-mb>: specify the amount of memory in megabytes that will be used to run the sandbox. Must be an even number. The default value is 512. `
+ - `--build-arg <args...>: specify additional build arguments for the build command. The format should be <varname>=<value>. `
+
+
+# e2b template list
+
+
+list sandbox templates
+
+## Usage
+
+```bash
+e2b template list [options]
+```
+
+## Options
+
+
+ - `-t, --team <team-id>: specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+
+
+# e2b template init
+
+
+create basic E2B Dockerfile (./e2b.Dockerfile) in root directory. You can then run e2b template build to build sandbox template from this Dockerfile
+
+## Usage
+
+```bash
+e2b template init [options]
+```
+
+## Options
+
+
+ - `-p, --path <path>: change root directory where command is executed to <path> directory `
+
+
+# e2b template delete
+
+
+delete sandbox template and e2b.toml config
+
+## Usage
+
+```bash
+e2b template delete [options] [template]
+```
+
+## Options
+
+
+ - `-p, --path <path>: change root directory where command is executed to <path> directory `
+ - `--config <e2b-toml>: specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `-s, --select: select sandbox template from interactive list `
+ - `-t, --team <team-id>: specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `-y, --yes: skip manual delete confirmation `
+
+
diff --git a/apps/web/src/app/(docs)/docs/api-reference/js-sdk/v0.16.2-beta.52/errors/page.mdx b/apps/web/src/app/(docs)/docs/api-reference/js-sdk/v0.16.2-beta.52/errors/page.mdx
new file mode 100644
index 000000000..5f2546641
--- /dev/null
+++ b/apps/web/src/app/(docs)/docs/api-reference/js-sdk/v0.16.2-beta.52/errors/page.mdx
@@ -0,0 +1,206 @@
+# errors
+
+## Classes
+
+### AuthenticationError
+
+Thrown when authentication fails.
+
+#### Constructors
+
+##### new AuthenticationError()
+
+> **new AuthenticationError**(`message`): `AuthenticationError`
+
+###### Parameters
+
+• **message**: `any`
+
+###### Returns
+
+`AuthenticationError`
+
+###### Defined in
+
+errors.ts:72
+
+***
+
+### InvalidArgumentError
+
+Thrown when an invalid argument is provided.
+
+#### Constructors
+
+##### new InvalidArgumentError()
+
+> **new InvalidArgumentError**(`message`): `InvalidArgumentError`
+
+###### Parameters
+
+• **message**: `string`
+
+###### Returns
+
+`InvalidArgumentError`
+
+###### Defined in
+
+errors.ts:42
+
+***
+
+### NotEnoughSpaceError
+
+Thrown when there is not enough disk space.
+
+#### Constructors
+
+##### new NotEnoughSpaceError()
+
+> **new NotEnoughSpaceError**(`message`): `NotEnoughSpaceError`
+
+###### Parameters
+
+• **message**: `string`
+
+###### Returns
+
+`NotEnoughSpaceError`
+
+###### Defined in
+
+errors.ts:52
+
+***
+
+### NotFoundError
+
+Thrown when a resource is not found.
+
+#### Constructors
+
+##### new NotFoundError()
+
+> **new NotFoundError**(`message`): `NotFoundError`
+
+###### Parameters
+
+• **message**: `string`
+
+###### Returns
+
+`NotFoundError`
+
+###### Defined in
+
+errors.ts:62
+
+***
+
+### SandboxError
+
+Thrown when a sandbox error occurs.
+
+Base class for all sandbox errors.
+
+#### Extended by
+
+- `TimeoutError`
+- `InvalidArgumentError`
+- `NotEnoughSpaceError`
+- `NotFoundError`
+- `AuthenticationError`
+- `TemplateError`
+
+#### Constructors
+
+##### new SandboxError()
+
+> **new SandboxError**(`message`): `SandboxError`
+
+###### Parameters
+
+• **message**: `any`
+
+###### Returns
+
+`SandboxError`
+
+###### Defined in
+
+errors.ts:14
+
+***
+
+### TemplateError
+
+Thrown when the template uses old envd version. It isn't compatible with the new SDK.
+
+#### Constructors
+
+##### new TemplateError()
+
+> **new TemplateError**(`message`): `TemplateError`
+
+###### Parameters
+
+• **message**: `string`
+
+###### Returns
+
+`TemplateError`
+
+###### Defined in
+
+errors.ts:82
+
+***
+
+### 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 process, watch, etc.
+
+The [unknown] error type is sometimes caused by the sandbox timeout when the request is not processed correctly.
+
+#### Constructors
+
+##### new TimeoutError()
+
+> **new TimeoutError**(`message`): `TimeoutError`
+
+###### Parameters
+
+• **message**: `string`
+
+###### Returns
+
+`TimeoutError`
+
+###### Defined in
+
+errors.ts:32
+
+## Functions
+
+### formatSandboxTimeoutError()
+
+> **formatSandboxTimeoutError**(`message`): `TimeoutError`
+
+#### Parameters
+
+• **message**: `string`
+
+#### Returns
+
+`TimeoutError`
+
+#### Defined in
+
+errors.ts:2
diff --git a/apps/web/src/app/(docs)/docs/api-reference/js-sdk/v0.16.2-beta.52/filesystem/page.mdx b/apps/web/src/app/(docs)/docs/api-reference/js-sdk/v0.16.2-beta.52/filesystem/page.mdx
new file mode 100644
index 000000000..6b20d4b01
--- /dev/null
+++ b/apps/web/src/app/(docs)/docs/api-reference/js-sdk/v0.16.2-beta.52/filesystem/page.mdx
@@ -0,0 +1,440 @@
+# sandbox/filesystem
+
+## Enumerations
+
+### FileType
+
+Type of filesystem object.
+
+#### Enumeration Members
+
+##### DIR
+
+> **DIR**: `"dir"`
+
+###### Defined in
+
+sandbox/filesystem/index.ts:40
+
+##### FILE
+
+> **FILE**: `"file"`
+
+###### Defined in
+
+sandbox/filesystem/index.ts:39
+
+## Classes
+
+### Filesystem
+
+Manager for interacting with the filesystem in the sandbox.
+
+#### Constructors
+
+##### new Filesystem()
+
+> **new Filesystem**(`transport`, `envdApi`, `connectionConfig`): `Filesystem`
+
+###### Parameters
+
+• **transport**: `Transport`
+
+• **envdApi**: `EnvdApiClient`
+
+• **connectionConfig**: `ConnectionConfig`
+
+###### Returns
+
+`Filesystem`
+
+###### Defined in
+
+sandbox/filesystem/index.ts:76
+
+#### Methods
+
+##### exists()
+
+> **exists**(`path`, `opts`?): `Promise`\<`boolean`\>
+
+Checks if a file or a directory exists.
+
+###### Parameters
+
+• **path**: `string`
+
+Path to a file or a directory
+
+• **opts?**: `FilesystemRequestOpts`
+
+Options for the request
+
+###### Returns
+
+`Promise`\<`boolean`\>
+
+True if the file or directory exists, false otherwise
+
+###### Defined in
+
+sandbox/filesystem/index.ts:325
+
+##### list()
+
+> **list**(`path`, `opts`?): `Promise`\<`EntryInfo`[]\>
+
+Lists entries in a directory.
+
+###### Parameters
+
+• **path**: `string`
+
+Path to the directory
+
+• **opts?**: `FilesystemRequestOpts`
+
+Options for the request
+
+###### Returns
+
+`Promise`\<`EntryInfo`[]\>
+
+List of entries in the directory
+
+###### Defined in
+
+sandbox/filesystem/index.ts:200
+
+##### makeDir()
+
+> **makeDir**(`path`, `opts`?): `Promise`\<`boolean`\>
+
+Creates a new directory and all directories along the way if needed on the specified pth.
+
+###### Parameters
+
+• **path**: `string`
+
+Path to a new directory. For example '/dirA/dirB' when creating 'dirB'.
+
+• **opts?**: `FilesystemRequestOpts`
+
+Options for the request
+
+###### Returns
+
+`Promise`\<`boolean`\>
+
+True if the directory was created, false if it already exists
+
+###### Defined in
+
+sandbox/filesystem/index.ts:237
+
+##### read()
+
+###### read(path, opts)
+
+> **read**(`path`, `opts`?): `Promise`\<`string`\>
+
+Reads a whole file content and returns it in requested format (text by default).
+
+###### Parameters
+
+• **path**: `string`
+
+Path to the file
+
+• **opts?**: `FilesystemRequestOpts` & `object`
+
+Options for the request
+
+###### Returns
+
+`Promise`\<`string`\>
+
+File content in requested format
+
+###### Defined in
+
+sandbox/filesystem/index.ts:92
+
+###### read(path, opts)
+
+> **read**(`path`, `opts`?): `Promise`\<`Uint8Array`\>
+
+###### Parameters
+
+• **path**: `string`
+
+• **opts?**: `FilesystemRequestOpts` & `object`
+
+###### Returns
+
+`Promise`\<`Uint8Array`\>
+
+###### Defined in
+
+sandbox/filesystem/index.ts:96
+
+###### read(path, opts)
+
+> **read**(`path`, `opts`?): `Promise`\<`Blob`\>
+
+###### Parameters
+
+• **path**: `string`
+
+• **opts?**: `FilesystemRequestOpts` & `object`
+
+###### Returns
+
+`Promise`\<`Blob`\>
+
+###### Defined in
+
+sandbox/filesystem/index.ts:100
+
+###### read(path, opts)
+
+> **read**(`path`, `opts`?): `Promise`\<`ReadableStream`\<`Uint8Array`\>\>
+
+###### Parameters
+
+• **path**: `string`
+
+• **opts?**: `FilesystemRequestOpts` & `object`
+
+###### Returns
+
+`Promise`\<`ReadableStream`\<`Uint8Array`\>\>
+
+###### Defined in
+
+sandbox/filesystem/index.ts:104
+
+##### remove()
+
+> **remove**(`path`, `opts`?): `Promise`\<`void`\>
+
+Removes a file or a directory.
+
+###### Parameters
+
+• **path**: `string`
+
+Path to a file or a directory
+
+• **opts?**: `FilesystemRequestOpts`
+
+Options for the request
+
+###### Returns
+
+`Promise`\<`void`\>
+
+###### Defined in
+
+sandbox/filesystem/index.ts:304
+
+##### rename()
+
+> **rename**(`oldPath`, `newPath`, `opts`?): `Promise`\<`EntryInfo`\>
+
+Renames a file or directory from one path to another.
+
+###### Parameters
+
+• **oldPath**: `string`
+
+Path to the file or directory to move
+
+• **newPath**: `string`
+
+Path to move the file or directory to
+
+• **opts?**: `FilesystemRequestOpts`
+
+Options for the request
+
+###### Returns
+
+`Promise`\<`EntryInfo`\>
+
+Information about the moved object
+
+###### Defined in
+
+sandbox/filesystem/index.ts:267
+
+##### watch()
+
+> **watch**(`path`, `onEvent`, `opts`?): `Promise`\<`WatchHandle`\>
+
+Watches directory for filesystem events.
+
+###### Parameters
+
+• **path**: `string`
+
+Path to a directory that will be watched
+
+• **onEvent**
+
+Callback that will be called when an event in the directory occurs
+
+• **opts?**: `FilesystemRequestOpts` & `object`
+
+Options for the request
+
+###### Returns
+
+`Promise`\<`WatchHandle`\>
+
+New watcher
+
+###### Defined in
+
+sandbox/filesystem/index.ts:355
+
+##### write()
+
+> **write**(`path`, `data`, `opts`?): `Promise`\<`EntryInfo`\>
+
+Writes content to a file on the path.
+ 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, the directory will get created.
+
+###### Parameters
+
+• **path**: `string`
+
+Path to a new file. For example '/dirA/dirB/newFile.txt' when creating 'newFile.txt'
+
+• **data**: `string` \| `ArrayBuffer` \| `Blob` \| `ReadableStream`\<`any`\>
+
+Data to write to a new file
+
+• **opts?**: `FilesystemRequestOpts`
+
+Options for the request
+
+###### Returns
+
+`Promise`\<`EntryInfo`\>
+
+Information about the written file
+
+###### Defined in
+
+sandbox/filesystem/index.ts:155
+
+## Interfaces
+
+### EntryInfo
+
+Information about a filesystem object.
+
+#### Properties
+
+##### name
+
+> **name**: `string`
+
+###### Defined in
+
+sandbox/filesystem/index.ts:30
+
+##### path
+
+> **path**: `string`
+
+###### Defined in
+
+sandbox/filesystem/index.ts:32
+
+##### type?
+
+> `optional` **type**: `FileType`
+
+###### Defined in
+
+sandbox/filesystem/index.ts:31
+
+***
+
+### FilesystemRequestOpts
+
+Options for sending a request to the filesystem.
+
+#### Extended by
+
+- `WatchOpts`
+
+#### Properties
+
+##### requestTimeoutMs?
+
+> `optional` **requestTimeoutMs**: `number`
+
+###### Defined in
+
+connectionConfig.ts:17
+
+##### user?
+
+> `optional` **user**: `Username`
+
+###### Defined in
+
+sandbox/filesystem/index.ts:57
+
+***
+
+### WatchOpts
+
+Options for watching a directory.
+
+#### Properties
+
+##### onExit()?
+
+> `optional` **onExit**: (`err`) => `void`
+
+###### Parameters
+
+• **err**: `Error`
+
+###### Returns
+
+`void`
+
+###### Defined in
+
+sandbox/filesystem/index.ts:65
+
+##### requestTimeoutMs?
+
+> `optional` **requestTimeoutMs**: `number`
+
+###### Defined in
+
+connectionConfig.ts:17
+
+##### timeout?
+
+> `optional` **timeout**: `number`
+
+###### Defined in
+
+sandbox/filesystem/index.ts:64
+
+##### user?
+
+> `optional` **user**: `Username`
+
+###### Defined in
+
+sandbox/filesystem/index.ts:57
diff --git a/apps/web/src/app/(docs)/docs/api-reference/js-sdk/v0.16.2-beta.52/process/page.mdx b/apps/web/src/app/(docs)/docs/api-reference/js-sdk/v0.16.2-beta.52/process/page.mdx
new file mode 100644
index 000000000..2adf95f20
--- /dev/null
+++ b/apps/web/src/app/(docs)/docs/api-reference/js-sdk/v0.16.2-beta.52/process/page.mdx
@@ -0,0 +1,27 @@
+# sandbox/process
+
+## References
+
+### Process
+
+Re-exports Process
+
+### ProcessConnectOpts
+
+Re-exports ProcessConnectOpts
+
+### ProcessInfo
+
+Re-exports ProcessInfo
+
+### ProcessRequestOpts
+
+Re-exports ProcessRequestOpts
+
+### ProcessStartOpts
+
+Re-exports ProcessStartOpts
+
+### Pty
+
+Re-exports Pty
diff --git a/apps/web/src/app/(docs)/docs/api-reference/js-sdk/v0.16.2-beta.52/sandbox/page.mdx b/apps/web/src/app/(docs)/docs/api-reference/js-sdk/v0.16.2-beta.52/sandbox/page.mdx
new file mode 100644
index 000000000..3e32d22a1
--- /dev/null
+++ b/apps/web/src/app/(docs)/docs/api-reference/js-sdk/v0.16.2-beta.52/sandbox/page.mdx
@@ -0,0 +1,476 @@
+# sandbox
+
+## Classes
+
+### Sandbox
+
+E2B cloud sandbox gives your agent a full cloud development environment that's sandboxed.
+
+That means:
+- Access to Linux OS
+- Using filesystem (create, list, and delete files and dirs)
+- Run commands
+- Sandboxed - you can run any code
+- Access to the internet
+
+Check usage docs - https://e2b.dev/docs/sandbox/overview
+
+These cloud sandboxes are meant to be used for agents. Like a sandboxed playgrounds, where the agent can do whatever it wants.
+
+Use the Sandbox.create method to create a new sandbox.
+
+#### Example
+
+```ts
+import { Sandbox } from '@e2b/sdk'
+
+const sandbox = await Sandbox.create()
+```
+
+#### Properties
+
+##### commands
+
+> `readonly` **commands**: `Process`
+
+Commands module for interacting with the sandbox's processes
+
+###### Defined in
+
+sandbox/index.ts:57
+
+##### files
+
+> `readonly` **files**: `Filesystem`
+
+Filesystem module for interacting with the sandbox's filesystem
+
+###### Defined in
+
+sandbox/index.ts:53
+
+##### pty
+
+> `readonly` **pty**: `Pty`
+
+PTY module for interacting with the sandbox's pseudo-terminal
+
+###### Defined in
+
+sandbox/index.ts:61
+
+##### sandboxId
+
+> `readonly` **sandboxId**: `string`
+
+Unique identifier of the sandbox.
+
+###### Defined in
+
+sandbox/index.ts:66
+
+#### Methods
+
+##### downloadUrl()
+
+> **downloadUrl**(`path`): `string`
+
+Get the URL to download a file from the sandbox.
+
+###### Parameters
+
+• **path**: `string`
+
+Path to the file
+
+###### Returns
+
+`string`
+
+URL to download the file
+
+###### Defined in
+
+sandbox/index.ts:297
+
+##### getHost()
+
+> **getHost**(`port`): `string`
+
+Get the hostname for the specified sandbox's port.
+
+###### Parameters
+
+• **port**: `number`
+
+Port number of a specific port in the sandbox
+
+###### Returns
+
+`string`
+
+Hostname of the sandbox's 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)
+``
+
+###### Defined in
+
+sandbox/index.ts:198
+
+##### isRunning()
+
+> **isRunning**(`opts`?): `Promise`\<`boolean`\>
+
+Check if the sandbox is running.
+
+###### Parameters
+
+• **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
+```
+
+###### Defined in
+
+sandbox/index.ts:219
+
+##### kill()
+
+> **kill**(`opts`?): `Promise`\<`void`\>
+
+Kill the sandbox.
+
+###### Parameters
+
+• **opts?**: `Pick`\<`SandboxOpts`, `"requestTimeoutMs"`\>
+
+Connection options
+
+###### Returns
+
+`Promise`\<`void`\>
+
+Promise that resolves when the sandbox is killed
+
+###### Defined in
+
+sandbox/index.ts:270
+
+##### setTimeout()
+
+> **setTimeout**(`timeoutMs`, `opts`?): `Promise`\<`void`\>
+
+Set the sandbox's timeout, after which the sandbox will be automatically killed.
+The sandbox can be kept alive for a maximum of 24 hours from the time of creation.
+If you try to set the timeout to a period, which exceeds the maximum limit, the timeout will be set to the maximum limit.
+
+###### Parameters
+
+• **timeoutMs**: `number`
+
+Duration in milliseconds. Must be between 0 and 86400000 milliseconds (24 hours).
+
+• **opts?**: `Pick`\<`SandboxOpts`, `"requestTimeoutMs"`\>
+
+Connection options
+
+###### Returns
+
+`Promise`\<`void`\>
+
+Promise that resolves when the sandbox is kept alive
+
+###### Defined in
+
+sandbox/index.ts:249
+
+##### uploadUrl()
+
+> **uploadUrl**(`path`?): `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 the field in the form data.
+You can find the specification for this API at https://github.com/e2b-dev/E2B/blob/main/spec/envd/envd.yaml.
+
+###### Parameters
+
+• **path?**: `string`
+
+Path to the directory where the file will be uploaded, defaults to user's home directory
+
+###### Returns
+
+`string`
+
+URL to upload the file
+
+###### Defined in
+
+sandbox/index.ts:287
+
+##### connect()
+
+> `static` **connect**\<`S`\>(`this`, `sandboxId`, `opts`?): `Promise`\<`InstanceType`\<`S`\>\>
+
+Connects to an existing Sandbox.
+
+###### Type Parameters
+
+• **S** *extends* *typeof* `Sandbox`
+
+###### Parameters
+
+• **this**: `S`
+
+• **sandboxId**: `string`
+
+Sandbox ID
+
+• **opts?**: `Omit`\<`SandboxOpts`, `"metadata"` \| `"envs"` \| `"timeoutMs"`\>
+
+Connection options
+
+###### Returns
+
+`Promise`\<`InstanceType`\<`S`\>\>
+
+Existing Sandbox
+
+###### Example
+
+```ts
+const sandbox = await Sandbox.create()
+const sandboxId = sandbox.sandboxId
+
+// Another code block
+const sameSandbox = await Sandbox.connect(sandboxId)
+```
+
+###### Defined in
+
+sandbox/index.ts:173
+
+##### create()
+
+###### create(this, opts)
+
+> `static` **create**\<`S`\>(`this`, `opts`?): `Promise`\<`InstanceType`\<`S`\>\>
+
+Creates a new Sandbox from the default `base` sandbox template.
+
+###### Type Parameters
+
+• **S** *extends* *typeof* `Sandbox`
+
+###### Parameters
+
+• **this**: `S`
+
+• **opts?**: `SandboxOpts`
+
+Connection options
+
+###### Returns
+
+`Promise`\<`InstanceType`\<`S`\>\>
+
+New Sandbox
+
+###### Example
+
+```ts
+const sandbox = await Sandbox.create()
+```
+
+###### Constructs
+
+Sandbox
+
+###### Defined in
+
+sandbox/index.ts:125
+
+###### create(this, template, opts)
+
+> `static` **create**\<`S`\>(`this`, `template`, `opts`?): `Promise`\<`InstanceType`\<`S`\>\>
+
+###### Type Parameters
+
+• **S** *extends* *typeof* `Sandbox`
+
+###### Parameters
+
+• **this**: `S`
+
+• **template**: `string`
+
+• **opts?**: `SandboxOpts`
+
+###### Returns
+
+`Promise`\<`InstanceType`\<`S`\>\>
+
+###### Defined in
+
+sandbox/index.ts:129
+
+##### kill()
+
+> `static` **kill**(`sandboxId`, `opts`?): `Promise`\<`boolean`\>
+
+Kills sandbox specified by sandbox ID.
+
+###### Parameters
+
+• **sandboxId**: `string`
+
+Sandbox ID.
+
+• **opts?**: `SandboxApiOpts`
+
+Connection options.
+
+###### Returns
+
+`Promise`\<`boolean`\>
+
+###### Defined in
+
+sandbox/sandboxApi.ts:53
+
+##### list()
+
+> `static` **list**(`opts`?): `Promise`\<`SandboxInfo`[]\>
+
+###### Parameters
+
+• **opts?**: `SandboxApiOpts`
+
+###### Returns
+
+`Promise`\<`SandboxInfo`[]\>
+
+###### Defined in
+
+sandbox/sandboxApi.ts:81
+
+##### setTimeout()
+
+> `static` **setTimeout**(`sandboxId`, `timeoutMs`, `opts`?): `Promise`\<`void`\>
+
+###### Parameters
+
+• **sandboxId**: `string`
+
+• **timeoutMs**: `number`
+
+• **opts?**: `SandboxApiOpts`
+
+###### Returns
+
+`Promise`\<`void`\>
+
+###### Defined in
+
+sandbox/sandboxApi.ts:108
+
+## Interfaces
+
+### SandboxOpts
+
+Options for creating a new Sandbox.
+
+#### Properties
+
+##### accessToken?
+
+> `optional` **accessToken**: `string`
+
+###### Defined in
+
+connectionConfig.ts:14
+
+##### apiKey?
+
+> `optional` **apiKey**: `string`
+
+###### Defined in
+
+connectionConfig.ts:13
+
+##### debug?
+
+> `optional` **debug**: `boolean`
+
+###### Defined in
+
+connectionConfig.ts:16
+
+##### domain?
+
+> `optional` **domain**: `string`
+
+###### Defined in
+
+connectionConfig.ts:15
+
+##### envs?
+
+> `optional` **envs**: `Record`\<`string`, `string`\>
+
+###### Defined in
+
+sandbox/index.ts:19
+
+##### logger?
+
+> `optional` **logger**: `Logger`
+
+###### Defined in
+
+connectionConfig.ts:18
+
+##### metadata?
+
+> `optional` **metadata**: `Record`\<`string`, `string`\>
+
+###### Defined in
+
+sandbox/index.ts:18
+
+##### requestTimeoutMs?
+
+> `optional` **requestTimeoutMs**: `number`
+
+###### Defined in
+
+connectionConfig.ts:17
+
+##### timeoutMs?
+
+> `optional` **timeoutMs**: `number`
+
+###### Defined in
+
+sandbox/index.ts:20
diff --git a/apps/web/src/app/(docs)/docs/api-reference/python-sdk/v0.17.1/exceptions/page.mdx b/apps/web/src/app/(docs)/docs/api-reference/python-sdk/v0.17.1/exceptions/page.mdx
new file mode 100644
index 000000000..256bf8a08
--- /dev/null
+++ b/apps/web/src/app/(docs)/docs/api-reference/python-sdk/v0.17.1/exceptions/page.mdx
@@ -0,0 +1,75 @@
+
+
+
+## SandboxException
+
+```python
+class SandboxException(Exception)
+```
+
+Raised when a sandbox exception occurs.
+
+Base class for all sandbox errors.
+
+
+## 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.
+
+
+## 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.
+
+
+## InvalidArgumentException
+
+```python
+class InvalidArgumentException(SandboxException)
+```
+
+Raised when an invalid argument is provided.
+
+
+## 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.
+
diff --git a/apps/web/src/app/(docs)/docs/api-reference/python-sdk/v0.17.1/sandbox_async/page.mdx b/apps/web/src/app/(docs)/docs/api-reference/python-sdk/v0.17.1/sandbox_async/page.mdx
new file mode 100644
index 000000000..a7511b576
--- /dev/null
+++ b/apps/web/src/app/(docs)/docs/api-reference/python-sdk/v0.17.1/sandbox_async/page.mdx
@@ -0,0 +1,719 @@
+
+
+
+
+
+## AsyncSandbox
+
+```python
+class AsyncSandbox(SandboxSetup, SandboxApi)
+```
+
+E2B cloud sandbox gives your agent a full cloud development environment that's sandboxed.
+
+That means:
+- Access to Linux OS
+- Using filesystem (create, list, and delete files and dirs)
+- Run commands
+- Sandboxed - you can run any code
+- Access to the internet
+
+Check usage docs - https://e2b.dev/docs/sandbox/overview
+
+These cloud sandboxes are meant to be used for agents. Like a sandboxed playgrounds, where the agent can do whatever it wants.
+
+Use the `AsyncSandbox.create()` to create a new sandbox.
+
+**Example**:
+
+```python
+sandbox = await AsyncSandbox.create()
+```
+
+
+#### files
+
+```python
+@property
+def files() -> Filesystem
+```
+
+Filesystem module for interacting with the sandbox's filesystem
+
+
+#### commands
+
+```python
+@property
+def commands() -> Process
+```
+
+Commands module for interacting with the sandbox's processes
+
+
+#### pty
+
+```python
+@property
+def pty() -> Pty
+```
+
+PTY module for interacting with the sandbox's pseudo-terminal.
+
+
+#### sandbox\_id
+
+```python
+@property
+def sandbox_id() -> str
+```
+
+Get the sandbox ID
+
+
+#### envd\_api\_url
+
+```python
+@property
+def envd_api_url() -> str
+```
+
+Get the sandbox API URL
+
+
+#### connection\_config
+
+```python
+@property
+def connection_config() -> ConnectionConfig
+```
+
+Get the ConnectionConfig object
+
+
+#### \_\_init\_\_
+
+```python
+def __init__(**opts: Unpack[AsyncSandboxOpts])
+```
+
+Use `Sandbox.create()` instead.
+
+
+#### is\_running
+
+```python
+async def is_running(request_timeout: Optional[float] = None) -> bool
+```
+
+Check if the sandbox is running.
+
+**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,
+ api_key: Optional[str] = None,
+ domain: Optional[str] = None,
+ debug: Optional[bool] = None,
+ request_timeout: Optional[float] = None)
+```
+
+Creates a new sandbox.
+
+This method creates a new sandbox in the async version,
+you have to use this method instead of using the constructor.
+
+
+#### connect
+
+```python
+@classmethod
+async def connect(cls,
+ sandbox_id: str,
+ api_key: Optional[str] = None,
+ domain: Optional[str] = None,
+ debug: Optional[bool] = None)
+```
+
+Connects to an existing Sandbox.
+
+**Arguments**:
+
+- `sandbox_id`: Sandbox ID
+- `api_key`: E2B API Key
+- `domain`: E2B Domain (use only if you self-host E2B)
+- `debug`: For developing purposes, uses a local sandbox
+
+**Returns**:
+
+Sandbox object
+@example
+```python
+sandbox = await AsyncSandbox.create()
+sandbox_id = sandbox.sandbox_id
+
+same_sandbox = await AsyncSandbox.connect(sandbox_id)
+
+
+#### kill
+
+```python
+@class_method_variant("_cls_kill")
+async def kill(request_timeout: Optional[float] = None) -> bool
+```
+
+Kill the sandbox.
+
+**Arguments**:
+
+- `request_timeout`: Timeout for the request
+
+**Returns**:
+
+`True` if the sandbox was killed, `False` if the sandbox was not found
+
+
+#### set\_timeout
+
+```python
+@class_method_variant("_cls_set_timeout")
+async def set_timeout(timeout: int,
+ request_timeout: Optional[float] = None) -> None
+```
+
+Set the sandbox's timeout, after which the sandbox will be automatically killed.
+
+The sandbox can be kept alive for a maximum of 24 hours from the time of creation.
+If you try to set the timeout to a period, which exceeds the maximum limit, the timeout will be set to the maximum limit.
+
+**Arguments**:
+
+- `timeout`: Duration in milliseconds. Must be between 0 and 86400000 milliseconds (24 hours).
+- `request_timeout`: Timeout for the request
+
+
+
+
+## Process
+
+```python
+class Process()
+```
+
+Manager for starting and interacting with processes in the sandbox.
+
+
+#### list
+
+```python
+async def list(request_timeout: Optional[float] = None) -> List[ProcessInfo]
+```
+
+Lists all running processes.
+
+**Arguments**:
+
+- `request_timeout`: Request timeout
+
+**Returns**:
+
+List of running processes
+
+
+#### kill
+
+```python
+async def kill(pid: int, request_timeout: Optional[float] = None) -> bool
+```
+
+Kills a process.
+
+**Arguments**:
+
+- `pid`: Process ID to connect to. You can get the list of processes using `sandbox.commands.list()`.
+- `request_timeout`: Request timeout
+
+**Returns**:
+
+`True` if the process was killed, `False` if the process was not found
+
+
+#### send\_stdin
+
+```python
+async def send_stdin(pid: int,
+ data: str,
+ request_timeout: Optional[float] = None) -> None
+```
+
+Sends data to the stdin of a process.
+
+:param pid Process ID to send data to. You can get the list of processes using `sandbox.commands.list()`.
+:param data: Data to send to the process
+:param request_timeout: Request timeout
+
+
+
+#### run
+
+```python
+async def run(cmd: str,
+ background: Union[bool, 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)
+```
+
+Starts a new process and depending on the `background` parameter, waits for the process to finish or not.
+
+:param cmd Command to execute
+:param background:
+ If `True`, the function will return a `ProcessHandle` object that can be used to interact with the process.
+ If `False`, the function will wait for the process to finish and return a `ProcessResult` object.
+:param envs: Environment variables
+:param user: User to run the process as
+:param cwd: Working directory
+:param on_stdout: Callback for stdout
+:param on_stderr: Callback for stderr
+:param timeout: Timeout for the maximum time the process is allowed to run
+:param request_timeout: Timeout for the request
+:return: `ProcessHandle` if `background` is `True`, `ProcessResult` if `background` is `False`
+
+
+
+#### 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
+) -> AsyncProcessHandle
+```
+
+Connects to an existing process.
+
+**Arguments**:
+
+- `pid`: Process ID to connect to. You can get the list of processes using `sandbox.commands.list()`.
+- `timeout`: Timeout for the connection
+- `request_timeout`: Request timeout
+- `on_stdout`: Callback for stdout
+- `on_stderr`: Callback for stderr
+
+
+
+
+## Pty
+
+```python
+class Pty()
+```
+
+Manager for starting and interacting with PTY (pseudo-terminal) processes in the sandbox.
+
+
+#### kill
+
+```python
+async def kill(pid: int, request_timeout: Optional[float] = None) -> bool
+```
+
+Kills a process.
+
+**Arguments**:
+
+- `pid`: Process ID to kill. You can get the list of processes using `sandbox.commands.list()`.
+- `request_timeout`: Timeout for the request
+
+**Returns**:
+
+`true` if the process was killed, `false` if the process was not found
+
+
+#### send\_stdin
+
+```python
+async def send_stdin(pid: int,
+ data: bytes,
+ request_timeout: Optional[float] = None) -> None
+```
+
+Sends input to a PTY process.
+
+**Arguments**:
+
+- `pid`: Process ID of the PTY process
+- `data`: Input data to send
+- `request_timeout`: Timeout for the request
+
+
+#### 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) -> AsyncProcessHandle
+```
+
+Starts a new process with a PTY (pseudo-terminal).
+
+**Arguments**:
+
+- `size`: Size of the PTY
+- `on_data`: Callback for handling PTY output
+- `user`: User to start the process as
+- `cwd`: Current working directory
+- `envs`: Environment variables
+- `timeout`: Timeout for the request
+- `request_timeout`: Timeout for the request
+
+**Returns**:
+
+New process
+
+
+#### resize
+
+```python
+async def resize(pid: int,
+ size: PtySize,
+ request_timeout: Optional[float] = None)
+```
+
+Resizes a PTY process (changes the number of columns and rows in the terminal).
+
+**Arguments**:
+
+- `pid`: Process ID of the PTY process
+- `size`: New size of the PTY
+- `request_timeout`: Timeout for the request
+
+
+
+
+## AsyncProcessHandle
+
+```python
+class AsyncProcessHandle()
+```
+
+Class representing a process. It provides methods for waiting and killing the process.
+
+
+#### pid
+
+```python
+@property
+def pid()
+```
+
+Get the process ID.
+
+
+#### stdout
+
+```python
+@property
+def stdout()
+```
+
+Stdout of the process.
+
+
+#### stderr
+
+```python
+@property
+def stderr()
+```
+
+Stderr of the process.
+
+
+#### error
+
+```python
+@property
+def error()
+```
+
+Error message of the process. It is `None` if the process is still running.
+
+
+#### exit\_code
+
+```python
+@property
+def exit_code()
+```
+
+Exit code of the process. It is `None` if the process is still running.
+
+
+#### disconnect
+
+```python
+async def disconnect() -> None
+```
+
+Disconnects from the process. It does not kill the process. It only stops receiving events from the process.
+
+
+#### wait
+
+```python
+async def wait() -> ProcessResult
+```
+
+Waits for the process to finish and returns the result.
+
+If the process exits with a non-zero exit code, it throws a `ProcessExitException`.
+
+**Returns**:
+
+Process result
+
+
+#### kill
+
+```python
+async def kill() -> bool
+```
+
+Kills the process.
+
+**Returns**:
+
+Whether the process was killed successfully
+
+
+
+
+
+
+## AsyncWatchHandle
+
+```python
+class AsyncWatchHandle()
+```
+
+Class representing the watch operation. It provides method to stop the watch operation.
+
+
+#### close
+
+```python
+async def close()
+```
+
+Stop watching the directory.
+
+
+
+
+## Filesystem
+
+```python
+class Filesystem()
+```
+
+Manager for interacting with the filesystem in the sandbox.
+
+
+#### read
+
+```python
+async def read(path: str,
+ format: Literal["text", "bytes", "stream"] = "text",
+ user: Username = "user",
+ request_timeout: Optional[float] = None)
+```
+
+Reads a whole file content and returns it in requested format (text by default).
+
+:param path: Path to the file
+:param format: Format of the file content
+:param user: Run the operation as this user
+:param request_timeout: Timeout for the request
+:return File content in requested format
+
+
+
+#### write
+
+```python
+async def write(path: str,
+ data: Union[str, bytes, IO],
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> EntryInfo
+```
+
+Writes content to a file on the path.
+
+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, the directory will get created.
+
+**Arguments**:
+
+- `path`: Path to the file
+- `data`: Data to write to the file
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request
+
+**Returns**:
+
+Information about the written file
+
+
+#### list
+
+```python
+async def list(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> List[EntryInfo]
+```
+
+Lists entries in a directory.
+
+**Arguments**:
+
+- `path`: Path to the directory
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request
+
+**Returns**:
+
+List of entries in the directory
+
+
+#### exists
+
+```python
+async def exists(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> bool
+```
+
+Checks if a file or a directory exists.
+
+:param path: Path to a file or a directory
+:param user Run the operation as this user
+:param request_timeout Timeout for the request
+
+
+
+#### remove
+
+```python
+async def remove(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> None
+```
+
+Removes 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
+
+
+#### rename
+
+```python
+async def rename(old_path: str,
+ new_path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> EntryInfo
+```
+
+Renames a file or directory from one path to another.
+
+:param old_path Path to the file or directory to move
+:param new_path Path to move the file or directory to
+:param user Run the operation as this user
+:param request_timeout Timeout for the request
+
+:return: 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
+```
+
+Creates 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
+
+**Returns**:
+
+True if the directory was created, False if the directory already exists
+
+
+#### watch
+
+```python
+async def watch(path: str,
+ on_event: OutputHandler[FilesystemEvent],
+ on_exit: Optional[OutputHandler[Exception]] = None,
+ user: Username = "user",
+ request_timeout: Optional[float] = None,
+ timeout: Optional[float] = 60) -> AsyncWatchHandle
+```
+
+Watches directory for filesystem events.
+
+**Arguments**:
+
+- `path`: Path to a directory that will be watched
+- `on_event`: Callback that will be called on each event
+- `on_exit`: Callback that will be called when the watch is closed
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request
+- `timeout`: Timeout for the watch, after which the watch will be closed
+
+**Returns**:
+
+Watcher handle
+
diff --git a/apps/web/src/app/(docs)/docs/api-reference/python-sdk/v0.17.1/sandbox_sync/page.mdx b/apps/web/src/app/(docs)/docs/api-reference/python-sdk/v0.17.1/sandbox_sync/page.mdx
new file mode 100644
index 000000000..9813b6714
--- /dev/null
+++ b/apps/web/src/app/(docs)/docs/api-reference/python-sdk/v0.17.1/sandbox_sync/page.mdx
@@ -0,0 +1,661 @@
+
+
+
+
+
+## Sandbox
+
+```python
+class Sandbox(SandboxSetup, SandboxApi)
+```
+
+E2B cloud sandbox gives your agent a full cloud development environment that's sandboxed.
+
+That means:
+- Access to Linux OS
+- Using filesystem (create, list, and delete files and dirs)
+- Run commands
+- Sandboxed - you can run any code
+- Access to the internet
+
+Check usage docs - https://e2b.dev/docs/sandbox/overview
+
+These cloud sandboxes are meant to be used for agents. Like a sandboxed playgrounds, where the agent can do whatever it wants.
+
+Use the `Sandbox()` to create a new sandbox.
+
+**Example**:
+
+```python
+sandbox = Sandbox()
+```
+
+
+#### files
+
+```python
+@property
+def files() -> Filesystem
+```
+
+Filesystem module for interacting with the sandbox's filesystem
+
+
+#### commands
+
+```python
+@property
+def commands() -> Process
+```
+
+Commands module for interacting with the sandbox's processes
+
+
+#### pty
+
+```python
+@property
+def pty() -> Pty
+```
+
+PTY module for interacting with the sandbox's pseudo-terminal
+
+
+#### sandbox\_id
+
+```python
+@property
+def sandbox_id() -> str
+```
+
+Unique identifier of the sandbox
+
+
+#### envd\_api\_url
+
+```python
+@property
+def envd_api_url() -> str
+```
+
+Get the sandbox API URL
+
+
+#### connection\_config
+
+```python
+@property
+def connection_config() -> ConnectionConfig
+```
+
+Get the ConnectionConfig object
+
+
+#### \_\_init\_\_
+
+```python
+def __init__(template: Optional[str] = None,
+ timeout: Optional[int] = None,
+ metadata: Optional[Dict[str, str]] = None,
+ envs: Optional[Dict[str, str]] = None,
+ api_key: Optional[str] = None,
+ domain: Optional[str] = None,
+ debug: Optional[bool] = None,
+ sandbox_id: Optional[str] = None,
+ request_timeout: Optional[float] = None)
+```
+
+Instantiate sandbox
+
+
+#### is\_running
+
+```python
+def is_running(request_timeout: Optional[float] = None) -> bool
+```
+
+Check if the sandbox is running.
+
+**Returns**:
+
+`True` if the sandbox is running, `False` otherwise
+Example
+```python
+sandbox = Sandbox()
+sandbox.is_running() # Returns True
+
+sandbox.kill()
+sandbox.is_running() # Returns False
+```
+
+
+#### connect
+
+```python
+@classmethod
+def connect(cls,
+ sandbox_id: str,
+ api_key: Optional[str] = None,
+ domain: Optional[str] = None,
+ debug: Optional[bool] = None)
+```
+
+Connects to an existing Sandbox.
+
+**Arguments**:
+
+- `sandbox_id`: Sandbox ID
+- `api_key`: E2B API Key
+- `domain`: E2B Domain (use only if you self-host E2B)
+- `debug`: For developing purposes, uses a local sandbox
+
+**Returns**:
+
+Sandbox object
+@example
+```python
+sandbox = Sandbox()
+sandbox_id = sandbox.sandbox_id
+
+same_sandbox = Sandbox.connect(sandbox_id)
+
+
+#### kill
+
+```python
+@class_method_variant("_cls_kill")
+def kill(request_timeout: Optional[float] = None) -> bool
+```
+
+Kill the sandbox.
+
+**Arguments**:
+
+- `request_timeout`: Timeout for the request
+
+**Returns**:
+
+`True` if the sandbox was killed, `False` if the sandbox was not found
+
+
+#### set\_timeout
+
+```python
+@class_method_variant("_cls_set_timeout")
+def set_timeout(timeout: int, request_timeout: Optional[float] = None) -> None
+```
+
+Set the sandbox's timeout, after which the sandbox will be automatically killed.
+
+The sandbox can be kept alive for a maximum of 24 hours from the time of creation.
+If you try to set the timeout to a period, which exceeds the maximum limit, the timeout will be set to the maximum limit.
+
+**Arguments**:
+
+- `timeout`: Duration in milliseconds. Must be between 0 and 86400000 milliseconds (24 hours).
+- `request_timeout`: Timeout for the request
+
+
+
+
+## Process
+
+```python
+class Process()
+```
+
+
+#### list
+
+```python
+def list(request_timeout: Optional[float] = None) -> List[ProcessInfo]
+```
+
+Lists all running processes.
+
+**Arguments**:
+
+- `request_timeout`: Request timeout
+
+**Returns**:
+
+List of running processes
+
+
+#### kill
+
+```python
+def kill(pid: int, request_timeout: Optional[float] = None) -> bool
+```
+
+Kills a process.
+
+**Arguments**:
+
+- `pid`: Process ID to connect to. You can get the list of processes using `sandbox.commands.list()`.
+- `request_timeout`: Request timeout
+
+**Returns**:
+
+`True` if the process was killed, `False` if the process was not found
+
+
+#### send\_stdin
+
+```python
+def send_stdin(pid: int, data: str, request_timeout: Optional[float] = None)
+```
+
+Sends data to the stdin of a process.
+
+:param pid Process ID to send data to. You can get the list of processes using `sandbox.commands.list()`.
+:param data: Data to send to the process
+:param request_timeout: Request timeout
+
+
+
+#### run
+
+```python
+def run(cmd: str,
+ background: Union[bool, 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)
+```
+
+Starts a new process and depending on the `background` parameter, waits for the process to finish or not.
+
+:param cmd Command to execute
+:param background:
+ If `True`, the function will return a `ProcessHandle` object that can be used to interact with the process.
+ If `False`, the function will wait for the process to finish and return a `ProcessResult` object.
+:param envs: Environment variables
+:param user: User to run the process as
+:param cwd: Working directory
+:param on_stdout: Callback for stdout
+:param on_stderr: Callback for stderr
+:param timeout: Timeout for the maximum time the process is allowed to run
+:param request_timeout: Timeout for the request
+:return: `ProcessHandle` if `background` is `True`, `ProcessResult` if `background` is `False`
+
+
+
+#### connect
+
+```python
+def connect(pid: int,
+ timeout: Optional[float] = 60,
+ request_timeout: Optional[float] = None)
+```
+
+Connects to an existing process.
+
+**Arguments**:
+
+- `pid`: Process ID to connect to. You can get the list of processes using `sandbox.commands.list()`.
+- `timeout`: Timeout for the connection
+- `request_timeout`: Request timeout
+
+
+
+
+## Pty
+
+```python
+class Pty()
+```
+
+Manager for starting and interacting with PTY (pseudo-terminal) processes in the sandbox.
+
+
+#### kill
+
+```python
+def kill(pid: int, request_timeout: Optional[float] = None) -> bool
+```
+
+Kills a process.
+
+**Arguments**:
+
+- `pid`: Process ID to kill. You can get the list of processes using `sandbox.commands.list()`.
+- `request_timeout`: Timeout for the request
+
+**Returns**:
+
+`true` if the process was killed, `false` if the process was not found
+
+
+#### send\_stdin
+
+```python
+def send_stdin(pid: int,
+ data: bytes,
+ request_timeout: Optional[float] = None) -> None
+```
+
+Sends input to a PTY process.
+
+**Arguments**:
+
+- `pid`: Process ID of the PTY process
+- `data`: Input data to send
+- `request_timeout`: Timeout for the request
+
+
+#### 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) -> ProcessHandle
+```
+
+Starts a new process with a PTY (pseudo-terminal).
+
+**Arguments**:
+
+- `size`: Size of the PTY
+- `user`: User to start the process as
+- `cwd`: Current working directory
+- `envs`: Environment variables
+- `timeout`: Timeout for the request
+- `request_timeout`: Timeout for the request
+
+**Returns**:
+
+New process
+
+
+#### resize
+
+```python
+def resize(pid: int,
+ size: PtySize,
+ request_timeout: Optional[float] = None) -> None
+```
+
+Resizes a PTY process (changes the number of columns and rows in the terminal).
+
+**Arguments**:
+
+- `pid`: Process ID of the PTY process
+- `size`: New size of the PTY
+- `request_timeout`: Timeout for the request
+
+
+
+
+## ProcessHandle
+
+```python
+class ProcessHandle()
+```
+
+Class representing a process. It provides methods for waiting and killing the process.
+It is also used to iterate over the process output.
+
+
+#### pid
+
+```python
+@property
+def pid()
+```
+
+Get the process ID.
+
+
+#### disconnect
+
+```python
+def disconnect() -> None
+```
+
+Disconnect from the process. It does not kill the process. It only stops receiving events from the process.
+
+
+#### 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) -> ProcessResult
+```
+
+Waits for the process to finish and returns the result.
+
+If the process exits with a non-zero exit code, it throws a `ProcessExitException`.
+
+**Arguments**:
+
+- `on_pty`: Callback for pty output
+- `on_stdout`: Callback for stdout output
+- `on_stderr`: Callback for stderr output
+
+**Returns**:
+
+Process result
+
+
+#### kill
+
+```python
+def kill() -> bool
+```
+
+Kills the process.
+
+**Returns**:
+
+Whether the process was killed successfully
+
+
+
+
+## WatchHandle
+
+```python
+class WatchHandle()
+```
+
+Handle for watching filesystem events. It is used to iterate over the events in the watched directory.
+
+
+#### close
+
+```python
+def close()
+```
+
+Stop watching the directory.
+
+**Warnings**:
+
+ You won't get any event if you don't iterate over the handle before closing it.
+
+
+
+
+## Filesystem
+
+```python
+class Filesystem()
+```
+
+Manager for interacting with the filesystem in the sandbox.
+
+
+#### read
+
+```python
+def read(path: str,
+ format: Literal["text", "bytes", "stream"] = "text",
+ user: Username = "user",
+ request_timeout: Optional[float] = None)
+```
+
+Reads a whole file content and returns it in requested format (text by default).
+
+:param path: Path to the file
+:param format: Format of the file content
+:param user: Run the operation as this user
+:param request_timeout: Timeout for the request
+:return File content in requested format
+
+
+
+#### write
+
+```python
+def write(path: str,
+ data: Union[str, bytes, IO],
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> EntryInfo
+```
+
+Writes content to a file on the path.
+
+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, the directory will get created.
+
+**Arguments**:
+
+- `path`: Path to the file
+- `data`: Data to write to the file
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request
+
+**Returns**:
+
+Information about the written file
+
+
+#### list
+
+```python
+def list(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> List[EntryInfo]
+```
+
+Lists entries in a directory.
+
+**Arguments**:
+
+- `path`: Path to the directory
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request
+
+**Returns**:
+
+List of entries in the directory
+
+
+#### exists
+
+```python
+def exists(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> bool
+```
+
+Checks if a file or a directory exists.
+
+:param path: Path to a file or a directory
+:param user Run the operation as this user
+:param request_timeout Timeout for the request
+
+
+
+#### remove
+
+```python
+def remove(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> None
+```
+
+Removes 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
+
+
+#### rename
+
+```python
+def rename(old_path: str,
+ new_path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> EntryInfo
+```
+
+Renames a file or directory from one path to another.
+
+:param old_path Path to the file or directory to move
+:param new_path Path to move the file or directory to
+:param user Run the operation as this user
+:param request_timeout Timeout for the request
+
+:return: Information about the renamed file or directory
+
+
+
+#### make\_dir
+
+```python
+def make_dir(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None) -> bool
+```
+
+Creates 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
+
+**Returns**:
+
+True if the directory was created, False if the directory already exists
+
+
+#### watch
+
+```python
+def watch(path: str,
+ user: Username = "user",
+ request_timeout: Optional[float] = None,
+ timeout: Optional[float] = 60) -> WatchHandle
+```
+
+Watches directory for filesystem events. The watch will be closed after the timeout.
+
+To get the events, you need to iterate over the returned WatchHandle.
+
+**Arguments**:
+
+- `path`: Path to a directory that will be watched
+- `user`: Run the operation as this user
+- `request_timeout`: Timeout for the request
+- `timeout`: Timeout for the watch, after which the watch will be closed
+
+**Returns**:
+
+Watcher handle
+