Open-source, secure environment with real-world tools for enterprise-grade agents.
Python agentaiai-agentai-agentscode-interpretercopilotdevelopmentdevtoolsgptgpt-4javascriptllmnextjsopenaipythonreactsoftwaretypescript
[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.mdxnew file mode 100644index 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.mdxnew file mode 100644index 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.mdxnew file mode 100644index 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.mdxnew file mode 100644index 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:2diff --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.mdxnew file mode 100644index 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:57diff --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.mdxnew file mode 100644index 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 Ptydiff --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.mdxnew file mode 100644index 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:20diff --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.mdxnew file mode 100644index 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.mdxnew file mode 100644index 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.mdxnew file mode 100644index 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+