Open-source, secure environment with real-world tools for enterprise-grade agents.
Python agentaiai-agentai-agentscode-interpretercopilotdevelopmentdevtoolsgptgpt-4javascriptllmnextjsopenaipythonreactsoftwaretypescript
[skip ci] Release new versions
github-actions[bot]f1afba0d74f3
diff --git a/.changeset/early-bags-relate.md b/.changeset/early-bags-relate.mddeleted file mode 100644index 78e0301d0..000000000--- a/.changeset/early-bags-relate.md+++ /dev/null@@ -1,5 +0,0 @@-----'e2b': patch------adds a new typescript overload to sbx.commands.run to allow options.background to be parameterized as a boolean variablediff --git a/apps/web/package.json b/apps/web/package.jsonindex 9fdf64604..120d36666 100644--- a/apps/web/package.json+++ b/apps/web/package.json@@ -41,7 +41,7 @@"autoprefixer": "^10.4.7","class-variance-authority": "^0.7.0","clsx": "^1.2.1",- "e2b": "^1.5.0",+ "e2b": "^1.5.1","fast-glob": "^3.3.0","fast-xml-parser": "4.4.1","flexsearch": "^0.7.31",diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/code-interpreter-python-sdk/v1.5.0/sandbox/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/code-interpreter-python-sdk/v1.5.0/sandbox/page.mdxindex 2fbc0e205..6bee40031 100644--- a/apps/web/src/app/(docs)/docs/sdk-reference/code-interpreter-python-sdk/v1.5.0/sandbox/page.mdx+++ b/apps/web/src/app/(docs)/docs/sdk-reference/code-interpreter-python-sdk/v1.5.0/sandbox/page.mdx@@ -3,205 +3,6 @@-## Sandbox--```python-class Sandbox(BaseSandbox)-```--E2B cloud sandbox is a secure and isolated cloud environment.--The sandbox allows you to:-- Access Linux OS-- Create, list, and delete files and directories-- Run commands-- Run isolated code-- Access the internet--Check docs [here](https://e2b.dev/docs).--Use the `Sandbox()` to create a new sandbox.--**Example**:--```python-from e2b_code_interpreter import Sandbox--sandbox = Sandbox()-```---### run\_code--```python-@overload-def run_code(code: str,- language: Union[Literal["python"], None] = None,- on_stdout: Optional[OutputHandler[OutputMessage]] = None,- on_stderr: Optional[OutputHandler[OutputMessage]] = None,- on_result: Optional[OutputHandler[Result]] = None,- on_error: Optional[OutputHandler[ExecutionError]] = None,- envs: Optional[Dict[str, str]] = None,- timeout: Optional[float] = None,- request_timeout: Optional[float] = None) -> Execution-```--Runs the code as Python.--Specify the `language` or `context` option to run the code as a different language or in a different `Context`.--You can reference previously defined variables, imports, and functions in the code.--**Arguments**:--- `code`: Code to execute-- `language`: Language to use for code execution. If not defined, the default Python context is used.-- `on_stdout`: Callback for stdout messages-- `on_stderr`: Callback for stderr messages-- `on_result`: Callback for the `Result` object-- `on_error`: Callback for the `ExecutionError` object-- `envs`: Custom environment variables-- `timeout`: Timeout for the code execution in **seconds**-- `request_timeout`: Timeout for the request in **seconds**--**Returns**:--`Execution` result object---### run\_code--```python-@overload-def run_code(code: str,- language: Optional[str] = None,- on_stdout: Optional[OutputHandler[OutputMessage]] = None,- on_stderr: Optional[OutputHandler[OutputMessage]] = None,- on_result: Optional[OutputHandler[Result]] = None,- on_error: Optional[OutputHandler[ExecutionError]] = None,- envs: Optional[Dict[str, str]] = None,- timeout: Optional[float] = None,- request_timeout: Optional[float] = None) -> Execution-```--Runs the code for the specified language.--Specify the `language` or `context` option to run the code as a different language or in a different `Context`.-If no language is specified, Python is used.--You can reference previously defined variables, imports, and functions in the code.--**Arguments**:--- `code`: Code to execute-- `language`: Language to use for code execution. If not defined, the default Python context is used.-- `on_stdout`: Callback for stdout messages-- `on_stderr`: Callback for stderr messages-- `on_result`: Callback for the `Result` object-- `on_error`: Callback for the `ExecutionError` object-- `envs`: Custom environment variables-- `timeout`: Timeout for the code execution in **seconds**-- `request_timeout`: Timeout for the request in **seconds**--**Returns**:--`Execution` result object---### run\_code--```python-@overload-def run_code(code: str,- context: Optional[Context] = None,- on_stdout: Optional[OutputHandler[OutputMessage]] = None,- on_stderr: Optional[OutputHandler[OutputMessage]] = None,- on_result: Optional[OutputHandler[Result]] = None,- on_error: Optional[OutputHandler[ExecutionError]] = None,- envs: Optional[Dict[str, str]] = None,- timeout: Optional[float] = None,- request_timeout: Optional[float] = None) -> Execution-```--Runs the code in the specified context, if not specified, the default context is used.--Specify the `language` or `context` option to run the code as a different language or in a different `Context`.--You can reference previously defined variables, imports, and functions in the code.--**Arguments**:--- `code`: Code to execute-- `context`: Concrete context to run the code in. If not specified, the default context for the language is used. It's mutually exclusive with the language.-- `on_stdout`: Callback for stdout messages-- `on_stderr`: Callback for stderr messages-- `on_result`: Callback for the `Result` object-- `on_error`: Callback for the `ExecutionError` object-- `envs`: Custom environment variables-- `timeout`: Timeout for the code execution in **seconds**-- `request_timeout`: Timeout for the request in **seconds**--**Returns**:--`Execution` result object---### create\_code\_context--```python-def create_code_context(cwd: Optional[str] = None,- language: Optional[str] = None,- request_timeout: Optional[float] = None) -> Context-```--Creates a new context to run code in.--**Arguments**:--- `cwd`: Set the current working directory for the context, defaults to `/home/user`-- `language`: Language of the context. If not specified, defaults to Python-- `request_timeout`: Timeout for the request in **milliseconds**--**Returns**:--Context object-------## ChartType--```python-class ChartType(str, enum.Enum)-```--Chart types---## ScaleType--```python-class ScaleType(str, enum.Enum)-```--Ax scale types---## Chart--```python-class Chart()-```--Extracted data from a chart. It's useful for building an interactive charts or custom visualizations.------## OutputMessage```python@@ -557,6 +358,8 @@ The working directory of the context.++## AsyncSandbox```python@@ -720,3 +523,200 @@ Creates a new context to run code in.Context object++++## ChartType++```python+class ChartType(str, enum.Enum)+```++Chart types+++## ScaleType++```python+class ScaleType(str, enum.Enum)+```++Ax scale types+++## Chart++```python+class Chart()+```++Extracted data from a chart. It's useful for building an interactive charts or custom visualizations.+++++++## Sandbox++```python+class Sandbox(BaseSandbox)+```++E2B cloud sandbox is a secure and isolated cloud environment.++The sandbox allows you to:+- Access Linux OS+- Create, list, and delete files and directories+- Run commands+- Run isolated code+- Access the internet++Check docs [here](https://e2b.dev/docs).++Use the `Sandbox()` to create a new sandbox.++**Example**:++```python+from e2b_code_interpreter import Sandbox++sandbox = Sandbox()+```+++### run\_code++```python+@overload+def run_code(code: str,+ language: Union[Literal["python"], None] = None,+ on_stdout: Optional[OutputHandler[OutputMessage]] = None,+ on_stderr: Optional[OutputHandler[OutputMessage]] = None,+ on_result: Optional[OutputHandler[Result]] = None,+ on_error: Optional[OutputHandler[ExecutionError]] = None,+ envs: Optional[Dict[str, str]] = None,+ timeout: Optional[float] = None,+ request_timeout: Optional[float] = None) -> Execution+```++Runs the code as Python.++Specify the `language` or `context` option to run the code as a different language or in a different `Context`.++You can reference previously defined variables, imports, and functions in the code.++**Arguments**:++- `code`: Code to execute+- `language`: Language to use for code execution. If not defined, the default Python context is used.+- `on_stdout`: Callback for stdout messages+- `on_stderr`: Callback for stderr messages+- `on_result`: Callback for the `Result` object+- `on_error`: Callback for the `ExecutionError` object+- `envs`: Custom environment variables+- `timeout`: Timeout for the code execution in **seconds**+- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++`Execution` result object+++### run\_code++```python+@overload+def run_code(code: str,+ language: Optional[str] = None,+ on_stdout: Optional[OutputHandler[OutputMessage]] = None,+ on_stderr: Optional[OutputHandler[OutputMessage]] = None,+ on_result: Optional[OutputHandler[Result]] = None,+ on_error: Optional[OutputHandler[ExecutionError]] = None,+ envs: Optional[Dict[str, str]] = None,+ timeout: Optional[float] = None,+ request_timeout: Optional[float] = None) -> Execution+```++Runs the code for the specified language.++Specify the `language` or `context` option to run the code as a different language or in a different `Context`.+If no language is specified, Python is used.++You can reference previously defined variables, imports, and functions in the code.++**Arguments**:++- `code`: Code to execute+- `language`: Language to use for code execution. If not defined, the default Python context is used.+- `on_stdout`: Callback for stdout messages+- `on_stderr`: Callback for stderr messages+- `on_result`: Callback for the `Result` object+- `on_error`: Callback for the `ExecutionError` object+- `envs`: Custom environment variables+- `timeout`: Timeout for the code execution in **seconds**+- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++`Execution` result object+++### run\_code++```python+@overload+def run_code(code: str,+ context: Optional[Context] = None,+ on_stdout: Optional[OutputHandler[OutputMessage]] = None,+ on_stderr: Optional[OutputHandler[OutputMessage]] = None,+ on_result: Optional[OutputHandler[Result]] = None,+ on_error: Optional[OutputHandler[ExecutionError]] = None,+ envs: Optional[Dict[str, str]] = None,+ timeout: Optional[float] = None,+ request_timeout: Optional[float] = None) -> Execution+```++Runs the code in the specified context, if not specified, the default context is used.++Specify the `language` or `context` option to run the code as a different language or in a different `Context`.++You can reference previously defined variables, imports, and functions in the code.++**Arguments**:++- `code`: Code to execute+- `context`: Concrete context to run the code in. If not specified, the default context for the language is used. It's mutually exclusive with the language.+- `on_stdout`: Callback for stdout messages+- `on_stderr`: Callback for stderr messages+- `on_result`: Callback for the `Result` object+- `on_error`: Callback for the `ExecutionError` object+- `envs`: Custom environment variables+- `timeout`: Timeout for the code execution in **seconds**+- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++`Execution` result object+++### create\_code\_context++```python+def create_code_context(cwd: Optional[str] = None,+ language: Optional[str] = None,+ request_timeout: Optional[float] = None) -> Context+```++Creates a new context to run code in.++**Arguments**:++- `cwd`: Set the current working directory for the context, defaults to `/home/user`+- `language`: Language of the context. If not specified, defaults to Python+- `request_timeout`: Timeout for the request in **milliseconds**++**Returns**:++Context object+diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/desktop-python-sdk/v1.7.2/sandbox/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/desktop-python-sdk/v1.7.2/sandbox/page.mdxnew file mode 100644index 000000000..b0dccd78d--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/desktop-python-sdk/v1.7.2/sandbox/page.mdx@@ -0,0 +1,302 @@++++++## Sandbox++```python+class Sandbox(SandboxBase)+```+++### \_\_init\_\_++```python+def __init__(resolution: Optional[Tuple[int, int]] = None,+ dpi: Optional[int] = None,+ display: Optional[str] = None,+ 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,+ proxy: Optional[ProxyTypes] = None)+```++Create a new desktop sandbox.++By default, the sandbox is created from the `desktop` template.++**Arguments**:++- `resolution`: Startup the desktop with custom screen resolution. Defaults to (1024, 768)+- `dpi`: Startup the desktop with custom DPI. Defaults to 96+- `display`: Startup the desktop with custom display. Defaults to ":0"+- `template`: Sandbox template name or ID+- `timeout`: Timeout for the sandbox in **seconds**, default to 300 seconds. Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users+- `metadata`: Custom metadata for the sandbox+- `envs`: Custom environment variables for the sandbox+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `domain`: E2B domain to use for authentication, defaults to `E2B_DOMAIN` environment variable+- `debug`: If True, the sandbox will be created in debug mode, defaults to `E2B_DEBUG` environment variable+- `sandbox_id`: Sandbox ID to connect to, defaults to `E2B_SANDBOX_ID` environment variable+- `request_timeout`: Timeout for the request in **seconds**+- `proxy`: Proxy to use for the request and for the requests made to the returned sandbox++**Returns**:++sandbox instance for the new sandbox+++### screenshot++```python+@overload+def screenshot(format: Literal["stream"]) -> Iterator[bytes]+```++Take a screenshot and return it as a stream of bytes.+++### screenshot++```python+@overload+def screenshot(format: Literal["bytes"]) -> bytearray+```++Take a screenshot and return it as a bytearray.+++### screenshot++```python+def screenshot(format: Literal["bytes", "stream"] = "bytes")+```++Take a screenshot and return it in the specified format.++**Arguments**:++- `format`: The format of the screenshot. Can be 'bytes', 'blob', or 'stream'.++**Returns**:++The screenshot in the specified format.+++### left\_click++```python+def left_click(x: Optional[int] = None, y: Optional[int] = None)+```++Left click on the mouse position.+++### double\_click++```python+def double_click(x: Optional[int] = None, y: Optional[int] = None)+```++Double left click on the mouse position.+++### middle\_click++```python+def middle_click(x: Optional[int] = None, y: Optional[int] = None)+```++Middle click on the mouse position.+++### scroll++```python+def scroll(direction: Literal["up", "down"] = "down", amount: int = 1)+```++Scroll the mouse wheel by the given amount.++**Arguments**:++- `direction`: The direction to scroll. Can be "up" or "down".+- `amount`: The amount to scroll.+++### move\_mouse++```python+def move_mouse(x: int, y: int)+```++Move the mouse to the given coordinates.++**Arguments**:++- `x`: The x coordinate.+- `y`: The y coordinate.+++### mouse\_press++```python+def mouse_press(button: Literal["left", "right", "middle"] = "left")+```++Press the mouse button.+++### mouse\_release++```python+def mouse_release(button: Literal["left", "right", "middle"] = "left")+```++Release the mouse button.+++### get\_cursor\_position++```python+def get_cursor_position() -> tuple[int, int]+```++Get the current cursor position.++**Raises**:++- `RuntimeError`: If the cursor position cannot be determined++**Returns**:++A tuple with the x and y coordinates+++### get\_screen\_size++```python+def get_screen_size() -> tuple[int, int]+```++Get the current screen size.++**Raises**:++- `RuntimeError`: If the screen size cannot be determined++**Returns**:++A tuple with the width and height+++### write++```python+def write(text: str, *, chunk_size: int = 25, delay_in_ms: int = 75) -> None+```++Write the given text at the current cursor position.++**Arguments**:++- `text`: The text to write.+- `chunk_size`: The size of each chunk of text to write.+- `delay_in_ms`: The delay between each chunk of text.+++### press++```python+def press(key: Union[str, list[str]])+```++Press a key.++**Arguments**:++- `key`: The key to press (e.g. "enter", "space", "backspace", etc.).+++### drag++```python+def drag(fr: tuple[int, int], to: tuple[int, int])+```++Drag the mouse from the given position to the given position.++**Arguments**:++- `from`: The starting position.+- `to`: The ending position.+++### wait++```python+def wait(ms: int)+```++Wait for the given amount of time.++**Arguments**:++- `ms`: The amount of time to wait in milliseconds.+++### open++```python+def open(file_or_url: str)+```++Open a file or a URL in the default application.++**Arguments**:++- `file_or_url`: The file or URL to open.+++### get\_current\_window\_id++```python+def get_current_window_id() -> str+```++Get the current window ID.+++### get\_application\_windows++```python+def get_application_windows(application: str) -> list[str]+```++Get the window IDs of all windows for the given application.+++### get\_window\_title++```python+def get_window_title(window_id: str) -> str+```++Get the title of the window with the given ID.+++### launch++```python+def launch(application: str, uri: Optional[str] = None)+```++Launch an application.+diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v1.5.1/commands/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v1.5.1/commands/page.mdxnew file mode 100644index 000000000..0bf8ef1d9--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v1.5.1/commands/page.mdx@@ -0,0 +1,504 @@+### Commands++Module for starting and interacting with commands in the sandbox.++#### Constructors++```ts+new Commands(transport: Transport, connectionConfig: ConnectionConfig): Commands+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `transport` | `Transport` |+| `connectionConfig` | `ConnectionConfig` |++###### Returns++`Commands`++#### Methods++### connect()++```ts+connect(pid: number, opts?: CommandConnectOpts): Promise<CommandHandle>+```++Connect to a running command.+You can use CommandHandle.wait to wait for the command to finish and get execution results.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `pid` | `number` | process ID of the command to connect to. You can get the list of running commands using Commands.list. |+| `opts`? | `CommandConnectOpts` | connection options. |++###### Returns++`Promise`\<`CommandHandle`\>++`CommandHandle` handle to interact with the running command.++### kill()++```ts+kill(pid: number, opts?: CommandRequestOpts): Promise<boolean>+```++Kill a running command specified by its process ID.+It uses `SIGKILL` signal to kill the command.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `pid` | `number` | process ID of the command. You can get the list of running commands using Commands.list. |+| `opts`? | `CommandRequestOpts` | connection options. |++###### Returns++`Promise`\<`boolean`\>++`true` if the command was killed, `false` if the command was not found.++### list()++```ts+list(opts?: CommandRequestOpts): Promise<ProcessInfo[]>+```++List all running commands and PTY sessions.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `opts`? | `CommandRequestOpts` | connection options. |++###### Returns++`Promise`\<`ProcessInfo`[]\>++list of running commands and PTY sessions.++### run()++###### run(cmd, opts)++```ts+run(cmd: string, opts?: CommandStartOpts & object): Promise<CommandResult>+```++Start a new command and wait until it finishes executing.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `cmd` | `string` | command to execute. |+| `opts`? | `CommandStartOpts` & `object` | options for starting the command. |++###### Returns++`Promise`\<`CommandResult`\>++`CommandResult` result of the command execution.++###### run(cmd, opts)++```ts+run(cmd: string, opts: CommandStartOpts & object): Promise<CommandHandle>+```++Start a new command in the background.+You can use CommandHandle.wait to wait for the command to finish and get its result.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `cmd` | `string` | command to execute. |+| `opts` | `CommandStartOpts` & `object` | options for starting the command |++###### Returns++`Promise`\<`CommandHandle`\>++`CommandHandle` handle to interact with the running command.++###### run(cmd, opts)++```ts+run(cmd: string, opts?: CommandStartOpts & object): Promise<CommandResult | CommandHandle>+```++Start a new command.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `cmd` | `string` | command to execute. |+| `opts`? | `CommandStartOpts` & `object` | options for starting the command. - `opts.background: true` - runs in background, returns `CommandHandle` - `opts.background: false | undefined` - waits for completion, returns `CommandResult` |++###### Returns++`Promise`\<`CommandResult` \| `CommandHandle`\>++Either a `CommandHandle` or a `CommandResult` (depending on `opts.background`).++### sendStdin()++```ts+sendStdin(+ pid: number,+ data: string,+opts?: CommandRequestOpts): Promise<void>+```++Send data to command stdin.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `pid` | `number` | process ID of the command. You can get the list of running commands using Commands.list. |+| `data` | `string` | data to send to the command. |+| `opts`? | `CommandRequestOpts` | connection options. |++###### Returns++`Promise`\<`void`\>++***++### Pty++Module for interacting with PTYs (pseudo-terminals) in the sandbox.++#### Constructors++```ts+new Pty(transport: Transport, connectionConfig: ConnectionConfig): Pty+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `transport` | `Transport` |+| `connectionConfig` | `ConnectionConfig` |++###### Returns++`Pty`++#### Methods++### create()++```ts+create(opts: PtyCreateOpts): Promise<CommandHandle>+```++Create a new PTY (pseudo-terminal).++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `opts` | `PtyCreateOpts` | options for creating the PTY. |++###### Returns++`Promise`\<`CommandHandle`\>++handle to interact with the PTY.++### kill()++```ts+kill(pid: number, opts?: Pick<ConnectionOpts, "requestTimeoutMs">): Promise<boolean>+```++Kill a running PTY specified by process ID.+It uses `SIGKILL` signal to kill the PTY.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `pid` | `number` | process ID of the PTY. |+| `opts`? | `Pick`\<`ConnectionOpts`, `"requestTimeoutMs"`\> | connection options. |++###### Returns++`Promise`\<`boolean`\>++`true` if the PTY was killed, `false` if the PTY was not found.++### resize()++```ts+resize(+ pid: number,+ size: object,+opts?: Pick<ConnectionOpts, "requestTimeoutMs">): Promise<void>+```++Resize PTY.+Call this when the terminal window is resized and the number of columns and rows has changed.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `pid` | `number` | process ID of the PTY. |+| `size` | `object` | new size of the PTY. |+| `size.cols` | `number` | - |+| `size.rows`? | `number` | - |+| `opts`? | `Pick`\<`ConnectionOpts`, `"requestTimeoutMs"`\> | connection options. |++###### Returns++`Promise`\<`void`\>++### sendInput()++```ts+sendInput(+ pid: number,+ data: Uint8Array,+opts?: Pick<ConnectionOpts, "requestTimeoutMs">): Promise<void>+```++Send input to a PTY.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `pid` | `number` | process ID of the PTY. |+| `data` | `Uint8Array` | input data to send to the PTY. |+| `opts`? | `Pick`\<`ConnectionOpts`, `"requestTimeoutMs"`\> | connection options. |++###### Returns++`Promise`\<`void`\>++## Interfaces++### CommandRequestOpts++Options for sending a command request.++#### Extended by++- `CommandStartOpts`++#### Properties++### requestTimeoutMs?++```ts+optional requestTimeoutMs: number;+```++Timeout for requests to the API in **milliseconds**.++###### Default++```ts+30_000 // 30 seconds+```++***++### CommandStartOpts++Options for starting a new command.++#### Properties++### background?++```ts+optional background: boolean;+```++If true, starts command in the background and the method returns immediately.+You can use CommandHandle.wait to wait for the command to finish.++### cwd?++```ts+optional cwd: string;+```++Working directory for the command.++###### Default++```ts+// home directory of the user used to start the command+```++### envs?++```ts+optional envs: Record<string, string>;+```++Environment variables used for the command.++This overrides the default environment variables from `Sandbox` constructor.++###### Default++`{}`++### onStderr()?++```ts+optional onStderr: (data: string) => void | Promise<void>;+```++Callback for command stderr output.++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `data` | `string` |++###### Returns++`void` \| `Promise`\<`void`\>++### onStdout()?++```ts+optional onStdout: (data: string) => void | Promise<void>;+```++Callback for command stdout output.++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `data` | `string` |++###### Returns++`void` \| `Promise`\<`void`\>++### requestTimeoutMs?++```ts+optional requestTimeoutMs: number;+```++Timeout for requests to the API in **milliseconds**.++###### Default++```ts+30_000 // 30 seconds+```++### timeoutMs?++```ts+optional timeoutMs: number;+```++Timeout for the command in **milliseconds**.++###### Default++```ts+60_000 // 60 seconds+```++### user?++```ts+optional user: Username;+```++User to run the command as.++###### Default++`user`++***++### ProcessInfo++Information about a command, PTY session or start command running in the sandbox as process.++#### Properties++### args++```ts+args: string[];+```++Command arguments.++### cmd++```ts+cmd: string;+```++Command that was executed.++### cwd?++```ts+optional cwd: string;+```++Executed command working directory.++### envs++```ts+envs: Record<string, string>;+```++Environment variables used for the command.++### pid++```ts+pid: number;+```++Process ID.++### tag?++```ts+optional tag: string;+```++Custom tag used for identifying special commands like start command in the custom template.++## Type Aliases++### CommandConnectOpts++```ts+type CommandConnectOpts: Pick<CommandStartOpts, "onStderr" | "onStdout" | "timeoutMs"> & CommandRequestOpts;+```++Options for connecting to a command.diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v1.5.1/errors/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v1.5.1/errors/page.mdxnew file mode 100644index 000000000..c5aa2cc14--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v1.5.1/errors/page.mdx@@ -0,0 +1,211 @@+### AuthenticationError++Thrown when authentication fails.++#### Constructors++```ts+new AuthenticationError(message: any): AuthenticationError+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `any` |++###### Returns++`AuthenticationError`++***++### InvalidArgumentError++Thrown when an invalid argument is provided.++#### Constructors++```ts+new InvalidArgumentError(message: string): InvalidArgumentError+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `string` |++###### Returns++`InvalidArgumentError`++***++### NotEnoughSpaceError++Thrown when there is not enough disk space.++#### Constructors++```ts+new NotEnoughSpaceError(message: string): NotEnoughSpaceError+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `string` |++###### Returns++`NotEnoughSpaceError`++***++### NotFoundError++Thrown when a resource is not found.++#### Constructors++```ts+new NotFoundError(message: string): NotFoundError+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `string` |++###### Returns++`NotFoundError`++***++### RateLimitError++Thrown when the API rate limit is exceeded.++#### Constructors++```ts+new RateLimitError(message: any): RateLimitError+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `any` |++###### Returns++`RateLimitError`++***++### SandboxError++Base class for all sandbox errors.++Thrown when general sandbox errors occur.++#### Extended by++- `TimeoutError`+- `InvalidArgumentError`+- `NotEnoughSpaceError`+- `NotFoundError`+- `AuthenticationError`+- `TemplateError`+- `RateLimitError`++#### Constructors++```ts+new SandboxError(message: any): SandboxError+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `any` |++###### Returns++`SandboxError`++***++### TemplateError++Thrown when the template uses old envd version. It isn't compatible with the new SDK.++#### Constructors++```ts+new TemplateError(message: string): TemplateError+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `string` |++###### Returns++`TemplateError`++***++### TimeoutError++Thrown when a timeout error occurs.++The [unavailable] error type is caused by sandbox timeout.++The [canceled] error type is caused by exceeding request timeout.++The [deadline_exceeded] error type is caused by exceeding the timeout for command execution, watch, etc.++The [unknown] error type is sometimes caused by the sandbox timeout when the request is not processed correctly.++#### Constructors++```ts+new TimeoutError(message: string): TimeoutError+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `string` |++###### Returns++`TimeoutError`++## Functions++### formatSandboxTimeoutError()++```ts+function formatSandboxTimeoutError(message: string): TimeoutError+```++#### Parameters++| Parameter | Type |+| ------ | ------ |+| `message` | `string` |++#### Returns++`TimeoutError`diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v1.5.1/filesystem/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v1.5.1/filesystem/page.mdxnew file mode 100644index 000000000..2b8b614d1--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v1.5.1/filesystem/page.mdx@@ -0,0 +1,509 @@+### FileType++Sandbox filesystem object type.++#### Enumeration Members++| Enumeration Member | Value | Description |+| ------ | ------ | ------ |+| `DIR` | `"dir"` | Filesystem object is a directory. |+| `FILE` | `"file"` | Filesystem object is a file. |++## Classes++### Filesystem++Module for interacting with the sandbox filesystem.++#### Constructors++```ts+new Filesystem(+ transport: Transport,+ envdApi: EnvdApiClient,+ connectionConfig: ConnectionConfig): Filesystem+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `transport` | `Transport` |+| `envdApi` | `EnvdApiClient` |+| `connectionConfig` | `ConnectionConfig` |++###### Returns++`Filesystem`++#### Methods++### exists()++```ts+exists(path: string, opts?: FilesystemRequestOpts): Promise<boolean>+```++Check if a file or a directory exists.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to a file or a directory |+| `opts`? | `FilesystemRequestOpts` | connection options. |++###### Returns++`Promise`\<`boolean`\>++`true` if the file or directory exists, `false` otherwise++### list()++```ts+list(path: string, opts?: FilesystemListOpts): Promise<EntryInfo[]>+```++List entries in a directory.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to the directory. |+| `opts`? | `FilesystemListOpts` | connection options. |++###### Returns++`Promise`\<`EntryInfo`[]\>++list of entries in the sandbox filesystem directory.++### makeDir()++```ts+makeDir(path: string, opts?: FilesystemRequestOpts): Promise<boolean>+```++Create a new directory and all directories along the way if needed on the specified path.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to a new directory. For example '/dirA/dirB' when creating 'dirB'. |+| `opts`? | `FilesystemRequestOpts` | connection options. |++###### Returns++`Promise`\<`boolean`\>++`true` if the directory was created, `false` if it already exists.++### read()++###### read(path, opts)++```ts+read(path: string, opts?: FilesystemRequestOpts & object): Promise<string>+```++Read file content as a `string`.++You can pass `text`, `bytes`, `blob`, or `stream` to `opts.format` to change the return type.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to the file. |+| `opts`? | `FilesystemRequestOpts` & `object` | connection options. |++###### Returns++`Promise`\<`string`\>++file content as string++###### read(path, opts)++```ts+read(path: string, opts?: FilesystemRequestOpts & object): Promise<Uint8Array>+```++Read file content as a `Uint8Array`.++You can pass `text`, `bytes`, `blob`, or `stream` to `opts.format` to change the return type.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to the file. |+| `opts`? | `FilesystemRequestOpts` & `object` | connection options. |++###### Returns++`Promise`\<`Uint8Array`\>++file content as `Uint8Array`++###### read(path, opts)++```ts+read(path: string, opts?: FilesystemRequestOpts & object): Promise<Blob>+```++Read file content as a `Blob`.++You can pass `text`, `bytes`, `blob`, or `stream` to `opts.format` to change the return type.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to the file. |+| `opts`? | `FilesystemRequestOpts` & `object` | connection options. |++###### Returns++`Promise`\<`Blob`\>++file content as `Blob`++###### read(path, opts)++```ts+read(path: string, opts?: FilesystemRequestOpts & object): Promise<ReadableStream<Uint8Array>>+```++Read file content as a `ReadableStream`.++You can pass `text`, `bytes`, `blob`, or `stream` to `opts.format` to change the return type.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to the file. |+| `opts`? | `FilesystemRequestOpts` & `object` | connection options. |++###### Returns++`Promise`\<`ReadableStream`\<`Uint8Array`\>\>++file content as `ReadableStream`++### remove()++```ts+remove(path: string, opts?: FilesystemRequestOpts): Promise<void>+```++Remove a file or directory.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to a file or directory. |+| `opts`? | `FilesystemRequestOpts` | connection options. |++###### Returns++`Promise`\<`void`\>++### rename()++```ts+rename(+ oldPath: string,+ newPath: string,+opts?: FilesystemRequestOpts): Promise<EntryInfo>+```++Rename a file or directory.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `oldPath` | `string` | path to the file or directory to rename. |+| `newPath` | `string` | new path for the file or directory. |+| `opts`? | `FilesystemRequestOpts` | connection options. |++###### Returns++`Promise`\<`EntryInfo`\>++information about renamed file or directory.++### watchDir()++```ts+watchDir(+ path: string,+ onEvent: (event: FilesystemEvent) => void | Promise<void>,+opts?: WatchOpts & object): Promise<WatchHandle>+```++Start watching a directory for filesystem events.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to directory to watch. |+| `onEvent` | (`event`: `FilesystemEvent`) => `void` \| `Promise`\<`void`\> | callback to call when an event in the directory occurs. |+| `opts`? | `WatchOpts` & `object` | connection options. |++###### Returns++`Promise`\<`WatchHandle`\>++`WatchHandle` object for stopping watching directory.++### write()++###### write(path, data, opts)++```ts+write(+ path: string,+ data: string | ArrayBuffer | Blob | ReadableStream<any>,+opts?: FilesystemRequestOpts): Promise<EntryInfo>+```++Write content to a file.++Writing to a file that doesn't exist creates the file.++Writing to a file that already exists overwrites the file.++Writing to a file at path that doesn't exist creates the necessary directories.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to file. |+| `data` | `string` \| `ArrayBuffer` \| `Blob` \| `ReadableStream`\<`any`\> | data to write to the file. Data can be a string, `ArrayBuffer`, `Blob`, or `ReadableStream`. |+| `opts`? | `FilesystemRequestOpts` | connection options. |++###### Returns++`Promise`\<`EntryInfo`\>++information about the written file++###### write(files, opts)++```ts+write(files: WriteEntry[], opts?: FilesystemRequestOpts): Promise<EntryInfo[]>+```++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `files` | `WriteEntry`[] |+| `opts`? | `FilesystemRequestOpts` |++###### Returns++`Promise`\<`EntryInfo`[]\>++## Interfaces++### EntryInfo++Sandbox filesystem object information.++#### Properties++### name++```ts+name: string;+```++Name of the filesystem object.++### path++```ts+path: string;+```++Path to the filesystem object.++### type?++```ts+optional type: FileType;+```++Type of the filesystem object.++***++### FilesystemListOpts++Options for the sandbox filesystem operations.++#### Properties++### depth?++```ts+optional depth: number;+```++Depth of the directory to list.++### requestTimeoutMs?++```ts+optional requestTimeoutMs: number;+```++Timeout for requests to the API in **milliseconds**.++###### Default++```ts+30_000 // 30 seconds+```++### user?++```ts+optional user: Username;+```++User to use for the operation in the sandbox.+This affects the resolution of relative paths and ownership of the created filesystem objects.++***++### FilesystemRequestOpts++Options for the sandbox filesystem operations.++#### Extended by++- `FilesystemListOpts`+- `WatchOpts`++#### Properties++### requestTimeoutMs?++```ts+optional requestTimeoutMs: number;+```++Timeout for requests to the API in **milliseconds**.++###### Default++```ts+30_000 // 30 seconds+```++### user?++```ts+optional user: Username;+```++User to use for the operation in the sandbox.+This affects the resolution of relative paths and ownership of the created filesystem objects.++***++### WatchOpts++Options for watching a directory.++#### Properties++### onExit()?++```ts+optional onExit: (err?: Error) => void | Promise<void>;+```++Callback to call when the watch operation stops.++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `err`? | `Error` |++###### Returns++`void` \| `Promise`\<`void`\>++### recursive?++```ts+optional recursive: boolean;+```++Watch the directory recursively++### requestTimeoutMs?++```ts+optional requestTimeoutMs: number;+```++Timeout for requests to the API in **milliseconds**.++###### Default++```ts+30_000 // 30 seconds+```++### timeoutMs?++```ts+optional timeoutMs: number;+```++Timeout for the watch operation in **milliseconds**.+You can pass `0` to disable the timeout.++###### Default++```ts+60_000 // 60 seconds+```++### user?++```ts+optional user: Username;+```++User to use for the operation in the sandbox.+This affects the resolution of relative paths and ownership of the created filesystem objects.++## Type Aliases++### WriteEntry++```ts+type WriteEntry: object;+```++#### Type declaration++| Name | Type |+| ------ | ------ |+| `data` | `string` \| `ArrayBuffer` \| `Blob` \| `ReadableStream` |+| `path` | `string` |diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v1.5.1/sandbox/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v1.5.1/sandbox/page.mdxnew file mode 100644index 000000000..1caadd048--- /dev/null+++ b/apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v1.5.1/sandbox/page.mdx@@ -0,0 +1,595 @@+### Sandbox++E2B cloud sandbox is a secure and isolated cloud environment.++The sandbox allows you to:+- Access Linux OS+- Create, list, and delete files and directories+- Run commands+- Run isolated code+- Access the internet++Check docs here.++Use Sandbox.create to create a new sandbox.++#### Example++```ts+import { Sandbox } from 'e2b'++const sandbox = await Sandbox.create()+```++#### Properties++| Property | Modifier | Type | Description |+| ------ | ------ | ------ | ------ |+| `commands` | `readonly` | `Commands` | Module for running commands in the sandbox |+| `files` | `readonly` | `Filesystem` | Module for interacting with the sandbox filesystem |+| `pty` | `readonly` | `Pty` | Module for interacting with the sandbox pseudo-terminals |+| `sandboxId` | `readonly` | `string` | Unique identifier of the sandbox. |++#### Methods++### downloadUrl()++```ts+downloadUrl(path: string, opts?: SandboxUrlOpts): string+```++Get the URL to download a file from the sandbox.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path` | `string` | path to the file in the sandbox. |+| `opts`? | `SandboxUrlOpts` | download url options. |++###### Returns++`string`++URL for downloading file.++### getHost()++```ts+getHost(port: number): string+```++Get the host address for the specified sandbox port.+You can then use this address to connect to the sandbox port from outside the sandbox via HTTP or WebSocket.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `port` | `number` | number of the port in the sandbox. |++###### Returns++`string`++host address of the sandbox port.++###### Example++```ts+const sandbox = await Sandbox.create()+// Start an HTTP server+await sandbox.commands.exec('python3 -m http.server 3000')+// Get the hostname of the HTTP server+const serverURL = sandbox.getHost(3000)+```++### getInfo()++```ts+getInfo(opts?: Pick<SandboxOpts, "requestTimeoutMs">): Promise<SandboxInfo>+```++Get sandbox information like sandbox ID, template, metadata, started at/end at date.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `opts`? | `Pick`\<`SandboxOpts`, `"requestTimeoutMs"`\> | connection options. |++###### Returns++`Promise`\<`SandboxInfo`\>++information about the sandbox++### isRunning()++```ts+isRunning(opts?: Pick<ConnectionOpts, "requestTimeoutMs">): Promise<boolean>+```++Check if the sandbox is running.++###### Parameters++| Parameter | Type |+| ------ | ------ |+| `opts`? | `Pick`\<`ConnectionOpts`, `"requestTimeoutMs"`\> |++###### Returns++`Promise`\<`boolean`\>++`true` if the sandbox is running, `false` otherwise.++###### Example++```ts+const sandbox = await Sandbox.create()+await sandbox.isRunning() // Returns true++await sandbox.kill()+await sandbox.isRunning() // Returns false+```++### kill()++```ts+kill(opts?: Pick<SandboxOpts, "requestTimeoutMs">): Promise<void>+```++Kill the sandbox.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `opts`? | `Pick`\<`SandboxOpts`, `"requestTimeoutMs"`\> | connection options. |++###### Returns++`Promise`\<`void`\>++### setTimeout()++```ts+setTimeout(timeoutMs: number, opts?: Pick<SandboxOpts, "requestTimeoutMs">): Promise<void>+```++Set the timeout of the sandbox.+After the timeout expires the sandbox will be automatically killed.++This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.setTimeout`.+Maximum time a sandbox can be kept alive is 24 hours (86_400_000 milliseconds) for Pro users and 1 hour (3_600_000 milliseconds) for Hobby users.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `timeoutMs` | `number` | timeout in **milliseconds**. |+| `opts`? | `Pick`\<`SandboxOpts`, `"requestTimeoutMs"`\> | connection options. |++###### Returns++`Promise`\<`void`\>++### uploadUrl()++```ts+uploadUrl(path?: string, opts?: SandboxUrlOpts): string+```++Get the URL to upload a file to the sandbox.++You have to send a POST request to this URL with the file as multipart/form-data.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `path`? | `string` | path to the file in the sandbox. |+| `opts`? | `SandboxUrlOpts` | download url options. |++###### Returns++`string`++URL for uploading file.++### connect()++```ts+static connect<S>(+ this: S,+ sandboxId: string,+opts?: Omit<SandboxOpts, "timeoutMs" | "metadata" | "envs">): Promise<InstanceType<S>>+```++Connect to an existing sandbox.+With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).++###### Type Parameters++| Type Parameter |+| ------ |+| `S` *extends* *typeof* `Sandbox` |++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `this` | `S` | - |+| `sandboxId` | `string` | sandbox ID. |+| `opts`? | `Omit`\<`SandboxOpts`, `"timeoutMs"` \| `"metadata"` \| `"envs"`\> | connection options. |++###### Returns++`Promise`\<`InstanceType`\<`S`\>\>++sandbox instance for the existing sandbox.++###### Example++```ts+const sandbox = await Sandbox.create()+const sandboxId = sandbox.sandboxId++// Connect to the same sandbox.+const sameSandbox = await Sandbox.connect(sandboxId)+```++### create()++###### create(this, opts)++```ts+static create<S>(this: S, opts?: SandboxOpts): Promise<InstanceType<S>>+```++Create a new sandbox from the default `base` sandbox template.++###### Type Parameters++| Type Parameter |+| ------ |+| `S` *extends* *typeof* `Sandbox` |++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `this` | `S` | - |+| `opts`? | `SandboxOpts` | connection options. |++###### Returns++`Promise`\<`InstanceType`\<`S`\>\>++sandbox instance for the new sandbox.++###### Example++```ts+const sandbox = await Sandbox.create()+```++###### Constructs++Sandbox++###### create(this, template, opts)++```ts+static create<S>(+ this: S,+ template: string,+opts?: SandboxOpts): Promise<InstanceType<S>>+```++Create a new sandbox from the specified sandbox template.++###### Type Parameters++| Type Parameter |+| ------ |+| `S` *extends* *typeof* `Sandbox` |++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `this` | `S` | - |+| `template` | `string` | sandbox template name or ID. |+| `opts`? | `SandboxOpts` | connection options. |++###### Returns++`Promise`\<`InstanceType`\<`S`\>\>++sandbox instance for the new sandbox.++###### Example++```ts+const sandbox = await Sandbox.create('<template-name-or-id>')+```++###### Constructs++Sandbox++### getInfo()++```ts+static getInfo(sandboxId: string, opts?: SandboxApiOpts): Promise<SandboxInfo>+```++Get sandbox information like sandbox ID, template, metadata, started at/end at date.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `sandboxId` | `string` | sandbox ID. |+| `opts`? | `SandboxApiOpts` | connection options. |++###### Returns++`Promise`\<`SandboxInfo`\>++sandbox information.++### kill()++```ts+static kill(sandboxId: string, opts?: SandboxApiOpts): Promise<boolean>+```++Kill the sandbox specified by sandbox ID.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `sandboxId` | `string` | sandbox ID. |+| `opts`? | `SandboxApiOpts` | connection options. |++###### Returns++`Promise`\<`boolean`\>++`true` if the sandbox was found and killed, `false` otherwise.++### list()++```ts+static list(opts?: SandboxListOpts): Promise<ListedSandbox[]>+```++List all running sandboxes.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `opts`? | `SandboxListOpts` | connection options. |++###### Returns++`Promise`\<`ListedSandbox`[]\>++list of running sandboxes.++### setTimeout()++```ts+static setTimeout(+ sandboxId: string,+ timeoutMs: number,+opts?: SandboxApiOpts): Promise<void>+```++Set the timeout of the specified sandbox.+After the timeout expires the sandbox will be automatically killed.++This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to Sandbox.setTimeout.++Maximum time a sandbox can be kept alive is 24 hours (86_400_000 milliseconds) for Pro users and 1 hour (3_600_000 milliseconds) for Hobby users.++###### Parameters++| Parameter | Type | Description |+| ------ | ------ | ------ |+| `sandboxId` | `string` | sandbox ID. |+| `timeoutMs` | `number` | timeout in **milliseconds**. |+| `opts`? | `SandboxApiOpts` | connection options. |++###### Returns++`Promise`\<`void`\>++## Interfaces++### SandboxOpts++Options for creating a new Sandbox.++#### Properties++### accessToken?++```ts+optional accessToken: string;+```++E2B access token to use for authentication.++###### Default++```ts+E2B_ACCESS_TOKEN // environment variable+```++### apiKey?++```ts+optional apiKey: string;+```++E2B API key to use for authentication.++###### Default++```ts+E2B_API_KEY // environment variable+```++### debug?++```ts+optional debug: boolean;+```++**`Internal`**++If true the SDK starts in the debug mode and connects to the local envd API server.++###### Default++E2B_DEBUG // environment variable or `false`++### domain?++```ts+optional domain: string;+```++Domain to use for the API.++###### Default++E2B_DOMAIN // environment variable or `e2b.app`++### envs?++```ts+optional envs: Record<string, string>;+```++Custom environment variables for the sandbox.++Used when executing commands and code in the sandbox.+Can be overridden with the `envs` argument when executing commands or code.++###### Default++```ts+{}+```++### headers?++```ts+optional headers: Record<string, string>;+```++Additional headers to send with the request.++### logger?++```ts+optional logger: Logger;+```++Logger to use for logging messages. It can accept any object that implements `Logger` interface—for example, console.++### metadata?++```ts+optional metadata: Record<string, string>;+```++Custom metadata for the sandbox.++###### Default++```ts+{}+```++### requestTimeoutMs?++```ts+optional requestTimeoutMs: number;+```++Timeout for requests to the API in **milliseconds**.++###### Default++```ts+30_000 // 30 seconds+```++### secure?++```ts+optional secure: boolean;+```++Secure all traffic coming to the sandbox controller with auth token++###### Default++```ts+false+```++### timeoutMs?++```ts+optional timeoutMs: number;+```++Timeout for the sandbox in **milliseconds**.+Maximum time a sandbox can be kept alive is 24 hours (86_400_000 milliseconds) for Pro users and 1 hour (3_600_000 milliseconds) for Hobby users.++###### Default++```ts+300_000 // 5 minutes+```++***++### SandboxUrlOpts++Options for sandbox upload/download URL generation.++#### Properties++### useSignature?++```ts+optional useSignature: true;+```++Use signature for the URL.+This needs to be used in case of using secured envd in sandbox.++###### Default++```ts+false+```++### useSignatureExpiration?++```ts+optional useSignatureExpiration: number;+```++Use signature expiration for the URL.+Optional parameter to set the expiration time for the signature.diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.5.0/sandbox_async/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.5.0/sandbox_async/page.mdxindex 1938a0d7b..37c14af02 100644--- a/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.5.0/sandbox_async/page.mdx+++ b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.5.0/sandbox_async/page.mdx@@ -1,6 +1,364 @@+## SandboxApi++```python+class SandboxApi(SandboxApiBase)+```+++### list++```python+@classmethod+async def list(cls,+ api_key: Optional[str] = None,+ query: Optional[SandboxQuery] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ request_timeout: Optional[float] = None,+ headers: Optional[Dict[str, str]] = None,+ proxy: Optional[ProxyTypes] = None) -> List[ListedSandbox]+```++List all running sandboxes.++**Arguments**:++- `api_key`: API key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `query`: Filter the list of sandboxes, e.g. by metadata `SandboxQuery(metadata={"key": "value"})`, if there are multiple filters they are combined with AND.+- `domain`: Domain to use for the request, only relevant for self-hosted environments+- `debug`: Enable debug mode, all requested are then sent to localhost+- `request_timeout`: Timeout for the request in **seconds**+- `headers`: Additional headers to send with the request+- `proxy`: Proxy to use for the request++**Returns**:++List of running sandboxes+++### get\_info++```python+@classmethod+async def get_info(cls,+ sandbox_id: str,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ request_timeout: Optional[float] = None,+ headers: Optional[Dict[str, str]] = None,+ proxy: Optional[ProxyTypes] = None) -> SandboxInfo+```++Get the sandbox info.++**Arguments**:++- `sandbox_id`: Sandbox ID+- `api_key`: API key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `domain`: Domain to use for the request, defaults to `E2B_DOMAIN` environment variable+- `debug`: Debug mode, defaults to `E2B_DEBUG` environment variable+- `request_timeout`: Timeout for the request in **seconds**+- `headers`: Additional headers to send with the request+- `proxy`: Proxy to use for the request++**Returns**:++Sandbox info+++++## AsyncSandbox++```python+class AsyncSandbox(SandboxSetup, SandboxApi)+```++E2B cloud sandbox is a secure and isolated cloud environment.++The sandbox allows you to:+- Access Linux OS+- Create, list, and delete files and directories+- Run commands+- Run isolated code+- Access the internet++Check docs [here](https://e2b.dev/docs).++Use the `AsyncSandbox.create()` to create a new sandbox.++**Example**:++```python+from e2b import AsyncSandbox++sandbox = await AsyncSandbox.create()+```+++### files++```python+@property+def files() -> Filesystem+```++Module for interacting with the sandbox filesystem.+++### commands++```python+@property+def commands() -> Commands+```++Module for running commands in the sandbox.+++### pty++```python+@property+def pty() -> Pty+```++Module for interacting with the sandbox pseudo-terminal.+++### sandbox\_id++```python+@property+def sandbox_id() -> str+```++Unique identifier of the sandbox.+++### \_\_init\_\_++```python+def __init__(**opts: Unpack[AsyncSandboxOpts])+```++Use `AsyncSandbox.create()` to create a new sandbox instead.+++### is\_running++```python+async def is_running(request_timeout: Optional[float] = None) -> bool+```++Check if the sandbox is running.++**Arguments**:++- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++`True` if the sandbox is running, `False` otherwise+Example+```python+sandbox = await AsyncSandbox.create()+await sandbox.is_running() # Returns True++await sandbox.kill()+await sandbox.is_running() # Returns False+```+++### create++```python+@classmethod+async def create(cls,+ template: Optional[str] = None,+ timeout: Optional[int] = None,+ metadata: Optional[Dict[str, str]] = None,+ envs: Optional[Dict[str, str]] = None,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ request_timeout: Optional[float] = None,+ proxy: Optional[ProxyTypes] = None,+ secure: Optional[bool] = None)+```++Create a new sandbox.++By default, the sandbox is created from the default `base` sandbox template.++**Arguments**:++- `template`: Sandbox template name or ID+- `timeout`: Timeout for the sandbox in **seconds**, default to 300 seconds. Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.+- `metadata`: Custom metadata for the sandbox+- `envs`: Custom environment variables for the sandbox+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `request_timeout`: Timeout for the request in **seconds**+- `proxy`: Proxy to use for the request and for the **requests made to the returned sandbox**+- `secure`: Envd is secured with access token and cannot be used without it++**Returns**:++sandbox instance for the new sandbox+Use this method instead of using the constructor to create a new sandbox.+++### connect++```python+@classmethod+async def connect(cls,+ sandbox_id: str,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ proxy: Optional[ProxyTypes] = None)+```++Connect to an existing sandbox.++With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).++**Arguments**:++- `sandbox_id`: Sandbox ID+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `proxy`: Proxy to use for the request and for the **requests made to the returned sandbox**++**Returns**:++sandbox instance for the existing sandbox+@example+```python+sandbox = await AsyncSandbox.create()+sandbox_id = sandbox.sandbox_id++same_sandbox = await AsyncSandbox.connect(sandbox_id)+++### kill++```python+@overload+async def kill(request_timeout: Optional[float] = None) -> bool+```++Kill the sandbox.++**Arguments**:++- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++`True` if the sandbox was killed, `False` if the sandbox was not found+++### kill++```python+@overload+@staticmethod+async def kill(sandbox_id: str,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ request_timeout: Optional[float] = None,+ proxy: Optional[ProxyTypes] = None) -> bool+```++Kill the sandbox specified by sandbox ID.++**Arguments**:++- `sandbox_id`: Sandbox ID+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `request_timeout`: Timeout for the request in **seconds**+- `proxy`: Proxy to use for the request++**Returns**:++`True` if the sandbox was killed, `False` if the sandbox was not found+++### set\_timeout++```python+@overload+async def set_timeout(timeout: int,+ request_timeout: Optional[float] = None) -> None+```++Set the timeout of the sandbox.++After the timeout expires the sandbox will be automatically killed.+This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.++Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.++**Arguments**:++- `timeout`: Timeout for the sandbox in **seconds**+- `request_timeout`: Timeout for the request in **seconds**+++### set\_timeout++```python+@overload+@staticmethod+async def set_timeout(sandbox_id: str,+ timeout: int,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ request_timeout: Optional[float] = None,+ proxy: Optional[ProxyTypes] = None) -> None+```++Set the timeout of the specified sandbox.++After the timeout expires the sandbox will be automatically killed.+This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.++Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.++**Arguments**:++- `sandbox_id`: Sandbox ID+- `timeout`: Timeout for the sandbox in **seconds**+- `request_timeout`: Timeout for the request in **seconds**+- `proxy`: Proxy to use for the request+++### get\_info++```python+async def get_info(request_timeout: Optional[float] = None) -> SandboxInfo+```++Get sandbox information like sandbox ID, template, metadata, started at/end at date.++**Arguments**:++- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++Sandbox info++++## AsyncWatchHandle@@ -312,290 +670,98 @@ Watch directory for filesystem events.-## AsyncSandbox--```python-class AsyncSandbox(SandboxSetup, SandboxApi)-```--E2B cloud sandbox is a secure and isolated cloud environment.--The sandbox allows you to:-- Access Linux OS-- Create, list, and delete files and directories-- Run commands-- Run isolated code-- Access the internet--Check docs [here](https://e2b.dev/docs).--Use the `AsyncSandbox.create()` to create a new sandbox.--**Example**:--```python-from e2b import AsyncSandbox--sandbox = await AsyncSandbox.create()-```---### files--```python-@property-def files() -> Filesystem-```--Module for interacting with the sandbox filesystem.---### commands--```python-@property-def commands() -> Commands-```--Module for running commands in the sandbox.---### pty--```python-@property-def pty() -> Pty-```--Module for interacting with the sandbox pseudo-terminal.---### sandbox\_id--```python-@property-def sandbox_id() -> str-```--Unique identifier of the sandbox.---### \_\_init\_\_--```python-def __init__(**opts: Unpack[AsyncSandboxOpts])-```--Use `AsyncSandbox.create()` to create a new sandbox instead.---### is\_running--```python-async def is_running(request_timeout: Optional[float] = None) -> bool-```--Check if the sandbox is running.--**Arguments**:--- `request_timeout`: Timeout for the request in **seconds**--**Returns**:--`True` if the sandbox is running, `False` otherwise-Example-```python-sandbox = await AsyncSandbox.create()-await sandbox.is_running() # Returns True--await sandbox.kill()-await sandbox.is_running() # Returns False-```---### create--```python-@classmethod-async def create(cls,- template: Optional[str] = None,- timeout: Optional[int] = None,- metadata: Optional[Dict[str, str]] = None,- envs: Optional[Dict[str, str]] = None,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- request_timeout: Optional[float] = None,- proxy: Optional[ProxyTypes] = None,- secure: Optional[bool] = None)-```--Create a new sandbox.--By default, the sandbox is created from the default `base` sandbox template.--**Arguments**:--- `template`: Sandbox template name or ID-- `timeout`: Timeout for the sandbox in **seconds**, default to 300 seconds. Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.-- `metadata`: Custom metadata for the sandbox-- `envs`: Custom environment variables for the sandbox-- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable-- `request_timeout`: Timeout for the request in **seconds**-- `proxy`: Proxy to use for the request and for the **requests made to the returned sandbox**-- `secure`: Envd is secured with access token and cannot be used without it--**Returns**:--sandbox instance for the new sandbox-Use this method instead of using the constructor to create a new sandbox.---### connect--```python-@classmethod-async def connect(cls,- sandbox_id: str,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- proxy: Optional[ProxyTypes] = None)-```--Connect to an existing sandbox.--With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).--**Arguments**:--- `sandbox_id`: Sandbox ID-- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable-- `proxy`: Proxy to use for the request and for the **requests made to the returned sandbox**--**Returns**:--sandbox instance for the existing sandbox-@example-```python-sandbox = await AsyncSandbox.create()-sandbox_id = sandbox.sandbox_id--same_sandbox = await AsyncSandbox.connect(sandbox_id)---### kill+## Pty```python-@overload-async def kill(request_timeout: Optional[float] = None) -> bool+class Pty()```-Kill the sandbox.--**Arguments**:--- `request_timeout`: Timeout for the request in **seconds**--**Returns**:--`True` if the sandbox was killed, `False` if the sandbox was not found+Module for interacting with PTYs (pseudo-terminals) in the sandbox.### kill```python-@overload-@staticmethod-async def kill(sandbox_id: str,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- request_timeout: Optional[float] = None,- proxy: Optional[ProxyTypes] = None) -> bool+async def kill(pid: int, request_timeout: Optional[float] = None) -> bool```-Kill the sandbox specified by sandbox ID.+Kill PTY.**Arguments**:-- `sandbox_id`: Sandbox ID-- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `pid`: Process ID of the PTY- `request_timeout`: Timeout for the request in **seconds**-- `proxy`: Proxy to use for the request**Returns**:-`True` if the sandbox was killed, `False` if the sandbox was not found+`true` if the PTY was killed, `false` if the PTY was not found-### set\_timeout+### send\_stdin```python-@overload-async def set_timeout(timeout: int,- request_timeout: Optional[float] = None) -> None+async def send_stdin(pid: int,+ data: bytes,+ request_timeout: Optional[float] = None) -> None```-Set the timeout of the sandbox.--After the timeout expires the sandbox will be automatically killed.-This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.--Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.+Send input to a PTY.**Arguments**:-- `timeout`: Timeout for the sandbox in **seconds**+- `pid`: Process ID of the PTY+- `data`: Input data to send- `request_timeout`: Timeout for the request in **seconds**-### set\_timeout+### create```python-@overload-@staticmethod-async def set_timeout(sandbox_id: str,- timeout: int,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- request_timeout: Optional[float] = None,- proxy: Optional[ProxyTypes] = None) -> None+async def create(+ size: PtySize,+ on_data: OutputHandler[PtyOutput],+ user: Username = "user",+ cwd: Optional[str] = None,+ envs: Optional[Dict[str, str]] = None,+ timeout: Optional[float] = 60,+ request_timeout: Optional[float] = None) -> AsyncCommandHandle```-Set the timeout of the specified sandbox.--After the timeout expires the sandbox will be automatically killed.-This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.--Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.+Start a new PTY (pseudo-terminal).**Arguments**:-- `sandbox_id`: Sandbox ID-- `timeout`: Timeout for the sandbox in **seconds**+- `size`: Size of the PTY+- `on_data`: Callback to handle PTY data+- `user`: User to use for the PTY+- `cwd`: Working directory for the PTY+- `envs`: Environment variables for the PTY+- `timeout`: Timeout for the PTY in **seconds**- `request_timeout`: Timeout for the request in **seconds**-- `proxy`: Proxy to use for the request+**Returns**:-### get\_info+Handle to interact with the PTY+++### resize```python-async def get_info(request_timeout: Optional[float] = None) -> SandboxInfo+async def resize(pid: int,+ size: PtySize,+ request_timeout: Optional[float] = None)```-Get sandbox information like sandbox ID, template, metadata, started at/end at date.+Resize PTY.++Call this when the terminal window is resized and the number of columns and rows has changed.**Arguments**:+- `pid`: Process ID of the PTY+- `size`: New size of the PTY- `request_timeout`: Timeout for the request in **seconds**-**Returns**:--Sandbox info-@@ -866,169 +1032,3 @@ It uses `SIGKILL` signal to kill the command`True` if the command was killed successfully, `False` if the command was not found----## Pty--```python-class Pty()-```--Module for interacting with PTYs (pseudo-terminals) in the sandbox.---### kill--```python-async def kill(pid: int, request_timeout: Optional[float] = None) -> bool-```--Kill PTY.--**Arguments**:--- `pid`: Process ID of the PTY-- `request_timeout`: Timeout for the request in **seconds**--**Returns**:--`true` if the PTY was killed, `false` if the PTY was not found---### send\_stdin--```python-async def send_stdin(pid: int,- data: bytes,- request_timeout: Optional[float] = None) -> None-```--Send input to a PTY.--**Arguments**:--- `pid`: Process ID of the PTY-- `data`: Input data to send-- `request_timeout`: Timeout for the request in **seconds**---### create--```python-async def create(- size: PtySize,- on_data: OutputHandler[PtyOutput],- user: Username = "user",- cwd: Optional[str] = None,- envs: Optional[Dict[str, str]] = None,- timeout: Optional[float] = 60,- request_timeout: Optional[float] = None) -> AsyncCommandHandle-```--Start a new PTY (pseudo-terminal).--**Arguments**:--- `size`: Size of the PTY-- `on_data`: Callback to handle PTY data-- `user`: User to use for the PTY-- `cwd`: Working directory for the PTY-- `envs`: Environment variables for the PTY-- `timeout`: Timeout for the PTY in **seconds**-- `request_timeout`: Timeout for the request in **seconds**--**Returns**:--Handle to interact with the PTY---### resize--```python-async def resize(pid: int,- size: PtySize,- request_timeout: Optional[float] = None)-```--Resize PTY.--Call this when the terminal window is resized and the number of columns and rows has changed.--**Arguments**:--- `pid`: Process ID of the PTY-- `size`: New size of the PTY-- `request_timeout`: Timeout for the request in **seconds**-----## SandboxApi--```python-class SandboxApi(SandboxApiBase)-```---### list--```python-@classmethod-async def list(cls,- api_key: Optional[str] = None,- query: Optional[SandboxQuery] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- request_timeout: Optional[float] = None,- headers: Optional[Dict[str, str]] = None,- proxy: Optional[ProxyTypes] = None) -> List[ListedSandbox]-```--List all running sandboxes.--**Arguments**:--- `api_key`: API key to use for authentication, defaults to `E2B_API_KEY` environment variable-- `query`: Filter the list of sandboxes, e.g. by metadata `SandboxQuery(metadata={"key": "value"})`, if there are multiple filters they are combined with AND.-- `domain`: Domain to use for the request, only relevant for self-hosted environments-- `debug`: Enable debug mode, all requested are then sent to localhost-- `request_timeout`: Timeout for the request in **seconds**-- `headers`: Additional headers to send with the request-- `proxy`: Proxy to use for the request--**Returns**:--List of running sandboxes---### get\_info--```python-@classmethod-async def get_info(cls,- sandbox_id: str,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- request_timeout: Optional[float] = None,- headers: Optional[Dict[str, str]] = None,- proxy: Optional[ProxyTypes] = None) -> SandboxInfo-```--Get the sandbox info.--**Arguments**:--- `sandbox_id`: Sandbox ID-- `api_key`: API key to use for authentication, defaults to `E2B_API_KEY` environment variable-- `domain`: Domain to use for the request, defaults to `E2B_DOMAIN` environment variable-- `debug`: Debug mode, defaults to `E2B_DEBUG` environment variable-- `request_timeout`: Timeout for the request in **seconds**-- `headers`: Additional headers to send with the request-- `proxy`: Proxy to use for the request--**Returns**:--Sandbox info-diff --git a/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.5.0/sandbox_sync/page.mdx b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.5.0/sandbox_sync/page.mdxindex b81b70888..9d6dcbdcb 100644--- a/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.5.0/sandbox_sync/page.mdx+++ b/apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.5.0/sandbox_sync/page.mdx@@ -1,6 +1,370 @@+## SandboxApi++```python+class SandboxApi(SandboxApiBase)+```+++### list++```python+@classmethod+def list(cls,+ api_key: Optional[str] = None,+ query: Optional[SandboxQuery] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ request_timeout: Optional[float] = None,+ headers: Optional[Dict[str, str]] = None,+ proxy: Optional[ProxyTypes] = None) -> List[ListedSandbox]+```++List all running sandboxes.++**Arguments**:++- `api_key`: API key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `query`: Filter the list of sandboxes, e.g. by metadata `SandboxQuery(metadata={"key": "value"})`, if there are multiple filters they are combined with AND.+- `domain`: Domain to use for the request, only relevant for self-hosted environments+- `debug`: Enable debug mode, all requested are then sent to localhost+- `request_timeout`: Timeout for the request in **seconds**+- `headers`: Additional headers to send with the request+- `proxy`: Proxy to use for the request++**Returns**:++List of running sandboxes+++### get\_info++```python+@classmethod+def get_info(cls,+ sandbox_id: str,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ request_timeout: Optional[float] = None,+ headers: Optional[Dict[str, str]] = None,+ proxy: Optional[ProxyTypes] = None) -> SandboxInfo+```++Get the sandbox info.++**Arguments**:++- `sandbox_id`: Sandbox ID+- `api_key`: API key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `domain`: Domain to use for the request, defaults to `E2B_DOMAIN` environment variable+- `debug`: Debug mode, defaults to `E2B_DEBUG` environment variable+- `request_timeout`: Timeout for the request in **seconds**+- `headers`: Additional headers to send with the request++**Returns**:++Sandbox info+++++## Sandbox++```python+class Sandbox(SandboxSetup, SandboxApi)+```++E2B cloud sandbox is a secure and isolated cloud environment.++The sandbox allows you to:+- Access Linux OS+- Create, list, and delete files and directories+- Run commands+- Run isolated code+- Access the internet++Check docs [here](https://e2b.dev/docs).++Use the `Sandbox()` to create a new sandbox.++**Example**:++```python+from e2b import Sandbox++sandbox = Sandbox()+```+++### files++```python+@property+def files() -> Filesystem+```++Module for interacting with the sandbox filesystem.+++### commands++```python+@property+def commands() -> Commands+```++Module for running commands in the sandbox.+++### pty++```python+@property+def pty() -> Pty+```++Module for interacting with the sandbox pseudo-terminal.+++### sandbox\_id++```python+@property+def sandbox_id() -> str+```++Unique identifier of the sandbox+++### \_\_init\_\_++```python+def __init__(template: Optional[str] = None,+ timeout: Optional[int] = None,+ metadata: Optional[Dict[str, str]] = None,+ envs: Optional[Dict[str, str]] = None,+ secure: Optional[bool] = None,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ sandbox_id: Optional[str] = None,+ request_timeout: Optional[float] = None,+ proxy: Optional[ProxyTypes] = None)+```++Create a new sandbox.++By default, the sandbox is created from the default `base` sandbox template.++**Arguments**:++- `template`: Sandbox template name or ID+- `timeout`: Timeout for the sandbox in **seconds**, default to 300 seconds. Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users+- `metadata`: Custom metadata for the sandbox+- `envs`: Custom environment variables for the sandbox+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `request_timeout`: Timeout for the request in **seconds**+- `proxy`: Proxy to use for the request and for the **requests made to the returned sandbox**++**Returns**:++sandbox instance for the new sandbox+++### is\_running++```python+def is_running(request_timeout: Optional[float] = None) -> bool+```++Check if the sandbox is running.++**Arguments**:++- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++`True` if the sandbox is running, `False` otherwise+Example+```python+sandbox = Sandbox()+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,+ proxy: Optional[ProxyTypes] = None)+```++Connects to an existing Sandbox.++With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).++**Arguments**:++- `sandbox_id`: Sandbox ID+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `proxy`: Proxy to use for the request and for the **requests made to the returned sandbox**++**Returns**:++sandbox instance for the existing sandbox+@example+```python+sandbox = Sandbox()+sandbox_id = sandbox.sandbox_id++same_sandbox = Sandbox.connect(sandbox_id)+```+++### kill++```python+@overload+def kill(request_timeout: Optional[float] = None) -> bool+```++Kill the sandbox.++**Arguments**:++- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++`True` if the sandbox was killed, `False` if the sandbox was not found+++### kill++```python+@overload+@staticmethod+def kill(sandbox_id: str,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ request_timeout: Optional[float] = None,+ proxy: Optional[ProxyTypes] = None) -> bool+```++Kill the sandbox specified by sandbox ID.++**Arguments**:++- `sandbox_id`: Sandbox ID+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `request_timeout`: Timeout for the request in **seconds**+- `proxy`: Proxy to use for the request++**Returns**:++`True` if the sandbox was killed, `False` if the sandbox was not found+++### 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+@overload+def set_timeout(timeout: int, request_timeout: Optional[float] = None) -> None+```++Set the timeout of the sandbox.++After the timeout expires the sandbox will be automatically killed.+This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.++Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.++**Arguments**:++- `timeout`: Timeout for the sandbox in **seconds**+- `request_timeout`: Timeout for the request in **seconds**+++### set\_timeout++```python+@overload+@staticmethod+def set_timeout(sandbox_id: str,+ timeout: int,+ api_key: Optional[str] = None,+ domain: Optional[str] = None,+ debug: Optional[bool] = None,+ request_timeout: Optional[float] = None,+ proxy: Optional[ProxyTypes] = None) -> None+```++Set the timeout of the sandbox specified by sandbox ID.++After the timeout expires the sandbox will be automatically killed.+This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.++Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.++**Arguments**:++- `sandbox_id`: Sandbox ID+- `timeout`: Timeout for the sandbox in **seconds**+- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `request_timeout`: Timeout for the request in **seconds**+- `proxy`: Proxy to use for the request+++### get\_info++```python+def get_info(request_timeout: Optional[float] = None) -> SandboxInfo+```++Get sandbox information like sandbox ID, template, metadata, started at/end at date.++**Arguments**:++- `request_timeout`: Timeout for the request in **seconds**++**Returns**:++Sandbox info++++## WatchHandle```python@@ -305,296 +669,94 @@ Watch directory for filesystem events.-## Sandbox--```python-class Sandbox(SandboxSetup, SandboxApi)-```--E2B cloud sandbox is a secure and isolated cloud environment.--The sandbox allows you to:-- Access Linux OS-- Create, list, and delete files and directories-- Run commands-- Run isolated code-- Access the internet--Check docs [here](https://e2b.dev/docs).--Use the `Sandbox()` to create a new sandbox.--**Example**:--```python-from e2b import Sandbox--sandbox = Sandbox()-```---### files--```python-@property-def files() -> Filesystem-```--Module for interacting with the sandbox filesystem.---### commands--```python-@property-def commands() -> Commands-```--Module for running commands in the sandbox.---### pty--```python-@property-def pty() -> Pty-```--Module for interacting with the sandbox pseudo-terminal.---### sandbox\_id--```python-@property-def sandbox_id() -> str-```--Unique identifier of the sandbox---### \_\_init\_\_--```python-def __init__(template: Optional[str] = None,- timeout: Optional[int] = None,- metadata: Optional[Dict[str, str]] = None,- envs: Optional[Dict[str, str]] = None,- secure: Optional[bool] = None,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- sandbox_id: Optional[str] = None,- request_timeout: Optional[float] = None,- proxy: Optional[ProxyTypes] = None)-```--Create a new sandbox.--By default, the sandbox is created from the default `base` sandbox template.--**Arguments**:--- `template`: Sandbox template name or ID-- `timeout`: Timeout for the sandbox in **seconds**, default to 300 seconds. Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users-- `metadata`: Custom metadata for the sandbox-- `envs`: Custom environment variables for the sandbox-- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable-- `request_timeout`: Timeout for the request in **seconds**-- `proxy`: Proxy to use for the request and for the **requests made to the returned sandbox**--**Returns**:--sandbox instance for the new sandbox---### is\_running--```python-def is_running(request_timeout: Optional[float] = None) -> bool-```--Check if the sandbox is running.--**Arguments**:--- `request_timeout`: Timeout for the request in **seconds**--**Returns**:--`True` if the sandbox is running, `False` otherwise-Example-```python-sandbox = Sandbox()-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,- proxy: Optional[ProxyTypes] = None)-```--Connects to an existing Sandbox.--With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).--**Arguments**:--- `sandbox_id`: Sandbox ID-- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable-- `proxy`: Proxy to use for the request and for the **requests made to the returned sandbox**--**Returns**:--sandbox instance for the existing sandbox-@example-```python-sandbox = Sandbox()-sandbox_id = sandbox.sandbox_id--same_sandbox = Sandbox.connect(sandbox_id)-```---### kill--```python-@overload-def kill(request_timeout: Optional[float] = None) -> bool-```--Kill the sandbox.--**Arguments**:--- `request_timeout`: Timeout for the request in **seconds**--**Returns**:--`True` if the sandbox was killed, `False` if the sandbox was not found---### kill--```python-@overload-@staticmethod-def kill(sandbox_id: str,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- request_timeout: Optional[float] = None,- proxy: Optional[ProxyTypes] = None) -> bool-```--Kill the sandbox specified by sandbox ID.--**Arguments**:--- `sandbox_id`: Sandbox ID-- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable-- `request_timeout`: Timeout for the request in **seconds**-- `proxy`: Proxy to use for the request+## Pty-**Returns**:+```python+class Pty()+```-`True` if the sandbox was killed, `False` if the sandbox was not found+Module for interacting with PTYs (pseudo-terminals) in the sandbox.### kill```python-@class_method_variant("_cls_kill")-def kill(request_timeout: Optional[float] = None) -> bool+def kill(pid: int, request_timeout: Optional[float] = None) -> bool```-Kill the sandbox.+Kill PTY.**Arguments**:-- `request_timeout`: Timeout for the request+- `pid`: Process ID of the PTY+- `request_timeout`: Timeout for the request in **seconds****Returns**:-`True` if the sandbox was killed, `False` if the sandbox was not found+`true` if the PTY was killed, `false` if the PTY was not found-### set\_timeout+### send\_stdin```python-@overload-def set_timeout(timeout: int, request_timeout: Optional[float] = None) -> None+def send_stdin(pid: int,+ data: bytes,+ request_timeout: Optional[float] = None) -> None```-Set the timeout of the sandbox.--After the timeout expires the sandbox will be automatically killed.-This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.--Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.+Send input to a PTY.**Arguments**:-- `timeout`: Timeout for the sandbox in **seconds**+- `pid`: Process ID of the PTY+- `data`: Input data to send- `request_timeout`: Timeout for the request in **seconds**-### set\_timeout+### create```python-@overload-@staticmethod-def set_timeout(sandbox_id: str,- timeout: int,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- request_timeout: Optional[float] = None,- proxy: Optional[ProxyTypes] = None) -> None+def create(size: PtySize,+ user: Username = "user",+ cwd: Optional[str] = None,+ envs: Optional[Dict[str, str]] = None,+ timeout: Optional[float] = 60,+ request_timeout: Optional[float] = None) -> CommandHandle```-Set the timeout of the sandbox specified by sandbox ID.--After the timeout expires the sandbox will be automatically killed.-This method can extend or reduce the sandbox timeout set when creating the sandbox or from the last call to `.set_timeout`.--Maximum time a sandbox can be kept alive is 24 hours (86_400 seconds) for Pro users and 1 hour (3_600 seconds) for Hobby users.+Start a new PTY (pseudo-terminal).**Arguments**:-- `sandbox_id`: Sandbox ID-- `timeout`: Timeout for the sandbox in **seconds**-- `api_key`: E2B API Key to use for authentication, defaults to `E2B_API_KEY` environment variable+- `size`: Size of the PTY+- `user`: User to use for the PTY+- `cwd`: Working directory for the PTY+- `envs`: Environment variables for the PTY+- `timeout`: Timeout for the PTY in **seconds**- `request_timeout`: Timeout for the request in **seconds**-- `proxy`: Proxy to use for the request+**Returns**:++Handle to interact with the PTY-### get\_info++### resize```python-def get_info(request_timeout: Optional[float] = None) -> SandboxInfo+def resize(pid: int,+ size: PtySize,+ request_timeout: Optional[float] = None) -> None```-Get sandbox information like sandbox ID, template, metadata, started at/end at date.--**Arguments**:+Resize PTY.-- `request_timeout`: Timeout for the request in **seconds**+Call this when the terminal window is resized and the number of columns and rows has changed.-**Returns**:+**Arguments**:-Sandbox info+- `pid`: Process ID of the PTY+- `size`: New size of the PTY+- `request_timeout`: Timeout for the request in **seconds**s@@ -833,165 +995,3 @@ It uses `SIGKILL` signal to kill the command.Whether the command was killed successfully----## Pty--```python-class Pty()-```--Module for interacting with PTYs (pseudo-terminals) in the sandbox.---### kill--```python-def kill(pid: int, request_timeout: Optional[float] = None) -> bool-```--Kill PTY.--**Arguments**:--- `pid`: Process ID of the PTY-- `request_timeout`: Timeout for the request in **seconds**--**Returns**:--`true` if the PTY was killed, `false` if the PTY was not found---### send\_stdin--```python-def send_stdin(pid: int,- data: bytes,- request_timeout: Optional[float] = None) -> None-```--Send input to a PTY.--**Arguments**:--- `pid`: Process ID of the PTY-- `data`: Input data to send-- `request_timeout`: Timeout for the request in **seconds**---### create--```python-def create(size: PtySize,- user: Username = "user",- cwd: Optional[str] = None,- envs: Optional[Dict[str, str]] = None,- timeout: Optional[float] = 60,- request_timeout: Optional[float] = None) -> CommandHandle-```--Start a new PTY (pseudo-terminal).--**Arguments**:--- `size`: Size of the PTY-- `user`: User to use for the PTY-- `cwd`: Working directory for the PTY-- `envs`: Environment variables for the PTY-- `timeout`: Timeout for the PTY in **seconds**-- `request_timeout`: Timeout for the request in **seconds**--**Returns**:--Handle to interact with the PTY---### resize--```python-def resize(pid: int,- size: PtySize,- request_timeout: Optional[float] = None) -> None-```--Resize PTY.--Call this when the terminal window is resized and the number of columns and rows has changed.--**Arguments**:--- `pid`: Process ID of the PTY-- `size`: New size of the PTY-- `request_timeout`: Timeout for the request in **seconds**s-----## SandboxApi--```python-class SandboxApi(SandboxApiBase)-```---### list--```python-@classmethod-def list(cls,- api_key: Optional[str] = None,- query: Optional[SandboxQuery] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- request_timeout: Optional[float] = None,- headers: Optional[Dict[str, str]] = None,- proxy: Optional[ProxyTypes] = None) -> List[ListedSandbox]-```--List all running sandboxes.--**Arguments**:--- `api_key`: API key to use for authentication, defaults to `E2B_API_KEY` environment variable-- `query`: Filter the list of sandboxes, e.g. by metadata `SandboxQuery(metadata={"key": "value"})`, if there are multiple filters they are combined with AND.-- `domain`: Domain to use for the request, only relevant for self-hosted environments-- `debug`: Enable debug mode, all requested are then sent to localhost-- `request_timeout`: Timeout for the request in **seconds**-- `headers`: Additional headers to send with the request-- `proxy`: Proxy to use for the request--**Returns**:--List of running sandboxes---### get\_info--```python-@classmethod-def get_info(cls,- sandbox_id: str,- api_key: Optional[str] = None,- domain: Optional[str] = None,- debug: Optional[bool] = None,- request_timeout: Optional[float] = None,- headers: Optional[Dict[str, str]] = None,- proxy: Optional[ProxyTypes] = None) -> SandboxInfo-```--Get the sandbox info.--**Arguments**:--- `sandbox_id`: Sandbox ID-- `api_key`: API key to use for authentication, defaults to `E2B_API_KEY` environment variable-- `domain`: Domain to use for the request, defaults to `E2B_DOMAIN` environment variable-- `debug`: Debug mode, defaults to `E2B_DEBUG` environment variable-- `request_timeout`: Timeout for the request in **seconds**-- `headers`: Additional headers to send with the request--**Returns**:--Sandbox info-diff --git a/packages/js-sdk/package.json b/packages/js-sdk/package.jsonindex 42a8f6d1f..74da8d992 100644--- a/packages/js-sdk/package.json+++ b/packages/js-sdk/package.json@@ -1,6 +1,6 @@{"name": "e2b",- "version": "1.5.0",+ "version": "1.5.1","description": "E2B SDK that give agents cloud environments","homepage": "https://e2b.dev","license": "MIT",diff --git a/pnpm-lock.yaml b/pnpm-lock.yamlindex 2b802a391..26b69c1d6 100644--- a/pnpm-lock.yaml+++ b/pnpm-lock.yaml@@ -118,8 +118,8 @@ importers:specifier: ^1.2.1version: 1.2.1e2b:- specifier: ^1.5.0- version: 1.5.0+ specifier: ^1.5.1+ version: 1.5.1fast-glob:specifier: ^3.3.0version: 3.3.1@@ -392,7 +392,7 @@ importers:version: 3.1.1(@types/[email protected])(@vitest/[email protected])([email protected])([email protected](@types/[email protected])([email protected]))([email protected])([email protected])vitest-browser-react:specifier: ^0.1.1- version: 0.1.1(@types/[email protected])(@types/[email protected])(@vitest/[email protected])([email protected]([email protected]))([email protected])([email protected])+ version: 0.1.1(@types/[email protected])(@types/[email protected])(@vitest/[email protected]([email protected])([email protected](@types/[email protected])([email protected]))([email protected])([email protected])([email protected](@types/[email protected])([email protected])([email protected])([email protected]))([email protected]))([email protected]([email protected]))([email protected])([email protected](@types/[email protected])(@vitest/[email protected])([email protected])([email protected](@types/[email protected])([email protected]))([email protected])([email protected]))packages/python-sdk: {}@@ -3694,8 +3694,8 @@ packages:resolution: {integrity: sha512-ii/Bw55ecxgORqkArKNbuVTwqLgVZ0rH1X3J/NOe4LMZaVETm3qNpPBjoPkpQAsQjw2ew0Ad2sd54epqm9nLCw==}engines: {node: '>=18'}- resolution: {integrity: sha512-EZWtIigMgQHTFI3o+bH4IzBGMP7RFF61gMefHrtE6wNxot+nDTOqe2EZyDyDyyTLk65ZiXWJiI8vxqldXBb8uw==}+ resolution: {integrity: sha512-TYkIeGMTwBfjxP26nm9QYofPJ5eMM2dr0UFt1q/3QICxozidrRIEeqTO9q0p4pbxzVueqmocwppgoe6yOatlAg==}engines: {node: '>=18'}@@ -11052,7 +11052,7 @@ snapshots:openapi-fetch: 0.9.8platform: 1.3.6dependencies:'@bufbuild/protobuf': 2.2.2'@connectrpc/connect': 2.0.0-rc.3(@bufbuild/[email protected])@@ -11271,7 +11271,7 @@ snapshots:debug: 4.4.0([email protected])enhanced-resolve: 5.18.1eslint: 8.57.1- eslint-module-utils: 2.8.0(@typescript-eslint/[email protected]([email protected])([email protected]))([email protected])([email protected])([email protected])+ eslint-module-utils: 2.8.0(@typescript-eslint/[email protected]([email protected])([email protected]))([email protected])([email protected](@typescript-eslint/[email protected]([email protected])([email protected]))([email protected])([email protected])([email protected]))([email protected])eslint-plugin-import: 2.28.1(@typescript-eslint/[email protected]([email protected])([email protected]))([email protected])([email protected])fast-glob: 3.3.2get-tsconfig: 4.7.0@@ -11283,7 +11283,7 @@ snapshots:- eslint-import-resolver-webpack- supports-color- [email protected](@typescript-eslint/[email protected]([email protected])([email protected]))([email protected])([email protected])([email protected]):+ [email protected](@typescript-eslint/[email protected]([email protected])([email protected]))([email protected])([email protected](@typescript-eslint/[email protected]([email protected])([email protected]))([email protected])([email protected])([email protected]))([email protected]):dependencies:debug: 3.2.7optionalDependencies:@@ -11304,7 +11304,7 @@ snapshots:doctrine: 2.1.0eslint: 8.57.1eslint-import-resolver-node: 0.3.9- eslint-module-utils: 2.8.0(@typescript-eslint/[email protected]([email protected])([email protected]))([email protected])([email protected])([email protected])+ eslint-module-utils: 2.8.0(@typescript-eslint/[email protected]([email protected])([email protected]))([email protected])([email protected](@typescript-eslint/[email protected]([email protected])([email protected]))([email protected])([email protected])([email protected]))([email protected])has: 1.0.3is-core-module: 2.13.0is-glob: 4.0.3@@ -15054,7 +15054,7 @@ snapshots:terser: 5.39.0yaml: 2.5.1- [email protected](@types/[email protected])(@types/[email protected])(@vitest/[email protected])([email protected]([email protected]))([email protected])([email protected]):+ [email protected](@types/[email protected])(@types/[email protected])(@vitest/[email protected]([email protected])([email protected](@types/[email protected])([email protected]))([email protected])([email protected])([email protected](@types/[email protected])([email protected])([email protected])([email protected]))([email protected]))([email protected]([email protected]))([email protected])([email protected](@types/[email protected])(@vitest/[email protected])([email protected])([email protected](@types/[email protected])([email protected]))([email protected])([email protected])):dependencies:'@vitest/browser': 3.1.1([email protected])([email protected](@types/[email protected])([email protected]))([email protected])([email protected])([email protected](@types/[email protected])([email protected])([email protected])([email protected]))([email protected])react: 18.3.1