Add multi-file upload and less flaky metrics test for 1.2.0 beta.1 release

.github/workflows/cli_tests.yml

@@ -2,6 +2,9 @@ name: Test CLI
 
 on:
   workflow_call:
+  pull_request:
+    branches:
+      - main
 
 permissions:
   contents: read

.github/workflows/js_sdk_tests.yml

@@ -5,6 +5,9 @@ on:
     secrets:
       E2B_API_KEY:
         required: true
+  pull_request:
+    branches:
+      - main
 
 permissions:
   contents: read

.github/workflows/python_sdk_tests.yml

@@ -5,6 +5,9 @@ on:
     secrets:
       E2B_API_KEY:
         required: true
+  pull_request:
+    branches:
+      - main
 
 permissions:
   contents: read

apps/web/package.json

@@ -43,7 +43,7 @@
     "autoprefixer": "^10.4.7",
     "class-variance-authority": "^0.7.0",
     "clsx": "^1.2.1",
-    "e2b": "^1.0.7",
+    "e2b": "^1.1.0",
     "fast-glob": "^3.3.0",
     "fast-xml-parser": "4.4.1",
     "flexsearch": "^0.7.31",

apps/web/src/app/(docs)/docs/code-interpreting/analyze-data-with-ai/page.mdx

@@ -6,7 +6,7 @@ import imgChart from '@/images/analyze-data-chart.png'
 You can use E2B Sandbox to run AI-generated code to analyze data. Here's how the AI data analysis workflow usually looks like:
 1. Your user has a dataset in CSV format or other formats.
 2. You prompt the LLM to generate code (usually Python) based on the user's data.
-3. The sandbox runs the AU-generated code and returns the results.
+3. The sandbox runs the AI-generated code and returns the results.
 4. You display the results to the user.
 
 ---

apps/web/src/app/(docs)/docs/filesystem/read-write/page.mdx

@@ -2,7 +2,7 @@
 
 ## Reading files
 
-You can read files from the sandbox filesystem using the `files.reado()` method.
+You can read files from the sandbox filesystem using the `files.read()` method.
 
 <CodeGroup>
 ```js
@@ -18,20 +18,48 @@ file_content = sandbox.files.read('/path/to/file')
 ```
 </CodeGroup>
 
-## Writing files
+## Writing single files
 
-You can write files to the sandbox filesystem using the `files.write()` method.
+You can write single files to the sandbox filesystem using the `files.write()` method.
 
 <CodeGroup>
 ```js
 import { Sandbox } from '@e2b/code-interpreter'
 const sandbox = await Sandbox.create()
+
 await sandbox.files.write('/path/to/file', 'file content')
 ```
 ```python
 from e2b_code_interpreter import Sandbox
 
 sandbox = Sandbox()
+
 await sandbox.files.write('/path/to/file', 'file content')
 ```
 </CodeGroup>
+
+## Writing multiple files
+
+You can also write multiple files to the sandbox filesystem using the `files.write()` method.
+
+<CodeGroup>
+```js
+import { Sandbox } from '@e2b/code-interpreter'
+const sandbox = await Sandbox.create()
+
+await sandbox.files.write([
+    { path: '/path/to/a', data: 'file content' },
+    { path: '/another/path/to/b', data: 'file content' }
+])
+```
+```python
+from e2b_code_interpreter import Sandbox
+
+sandbox = Sandbox()
+
+await sandbox.files.write([
+    { "path": "/path/to/a", "data": "file content" },
+    { "path": "another/path/to/b", "data": "file content" }
+])
+```
+</CodeGroup>

apps/web/src/app/(docs)/docs/filesystem/upload/page.mdx

@@ -2,6 +2,8 @@
 
 You can upload data to the sandbox using the `files.write()` method.
 
+## Upload single file
+
 <CodeGroup>
 ```js
 import fs from 'fs'
@@ -22,6 +24,89 @@ sandbox = Sandbox()
 # Read file from local filesystem
 with open("path/to/local/file", "rb") as file:
   # Upload file to sandbox
-	sandbox.files.write("/path/in/sandbox", file)
+  sandbox.files.write("/path/in/sandbox", file)
 ```
 </CodeGroup>
+
+## Upload directory / multiple files
+
+<CodeGroup>
+```js
+const fs = require('fs');
+const path = require('path');
+
+import { Sandbox } from '@e2b/code-interpreter'
+
+const sandbox = await Sandbox.create()
+
+// Read all files in the directory and store their paths and contents in an array
+const readDirectoryFiles = (directoryPath) => {
+  // Read all files in the local directory
+  const files = fs.readdirSync(directoryPath);
+
+  // Map files to objects with path and data
+  const filesArray = files
+    .filter(file => {
+      const fullPath = path.join(directoryPath, file);
+      // Skip if it's a directory
+      return fs.statSync(fullPath).isFile();
+    })
+    .map(file => {
+      const filePath = path.join(directoryPath, file);
+
+      // Read the content of each file
+      return {
+        path: filePath,
+        data: fs.readFileSync(filePath, 'utf8')
+      };
+    });
+
+  return filesArray;
+};
+
+// Usage example
+const files = readDirectoryContents('/local/dir');
+console.log(files); 
+// [
+//   { path: '/local/dir/file1.txt', data: 'File 1 contents...' },
+//   { path: '/local/dir/file2.txt', data: 'File 2 contents...' },
+//   ...
+// ]
+
+await sandbox.files.write(files)
+```
+```python
+import os
+from e2b_code_interpreter import Sandbox
+
+sandbox = Sandbox()
+
+def read_directory_files(directory_path):
+    files = []
+
+    # Iterate through all files in the directory
+    for filename in os.listdir(directory_path):
+        file_path = os.path.join(directory_path, filename)
+
+        # Skip if it's a directory
+        if os.path.isfile(file_path):
+            # Read file contents in binary mode
+            with open(file_path, "rb") as file:
+                files.append({
+                    'path': file_path,
+                    'data': file.read()
+                })
+
+    return files
+
+files = read_directory_files("/local/dir")
+print(files)
+# [
+#  {"'path": "/local/dir/file1.txt", "data": "File 1 contents..." },
+#   { "path": "/local/dir/file2.txt", "data": "File 2 contents..." },
+#   ...
+# ]
+
+sandbox.files.write(files)
+```
+</CodeGroup>

apps/web/src/app/(docs)/docs/quickstart/connect-llms/page.mdx

@@ -497,13 +497,14 @@ console.log(text)
 
 <CodeGroup>
 ```python
-# pip install crewai crewai[tools] e2b-code-interpreter
-from crewai_tools import tool
+# pip install crewai e2b-code-interpreter
+from crewai.tools import tool
 from crewai import Agent, Task, Crew, LLM
 from e2b_code_interpreter import Sandbox
 
-@tool("Python interpreter tool")
-def execute_python(code: str):
+# Update tool definition using the decorator
+@tool("Python Interpreter")  
+def execute_python(code: str) -> str:
     """
     Execute Python code and return the results.
     """

apps/web/src/app/(docs)/docs/sandbox/internet-access/page.mdx

@@ -8,7 +8,7 @@ Every sandbox has a public URL that can be used to access running services insid
 
 <CodeGroup>
 ```js
-import { Sandbox } from '@e2b/code-interpeter'
+import { Sandbox } from '@e2b/code-interpreter'
 
 const sandbox = await Sandbox.create()
 
@@ -31,10 +31,10 @@ The code above will print something like this:
 
 <CodeGroup>
 ```bash {{ language: 'js' }}
-http://3000-i62mff4ahtrdfdkyn2esc-b0b684e9.e2b.dev
+https://3000-i62mff4ahtrdfdkyn2esc-b0b684e9.e2b.dev
 ```
 ```bash {{ language: 'python' }}
-http://3000-i62mff4ahtrdfdkyn2esc-b0b684e9.e2b.dev
+https://3000-i62mff4ahtrdfdkyn2esc-b0b684e9.e2b.dev
 ```
 </CodeGroup>
 
@@ -47,7 +47,7 @@ In this example we will start a simple HTTP server that listens on port 3000 and
 
 <CodeGroup>
 ```js
-import { Sandbox } from '@e2b/code-interpeter'
+import { Sandbox } from '@e2b/code-interpreter'
 
 const sandbox = await Sandbox.create()
 

apps/web/src/app/(docs)/docs/sdk-reference/cli/v1.2.3/auth/page.mdx

@@ -0,0 +1,58 @@
+## e2b auth
+
+
+authentication commands
+
+### Usage
+
+```bash
+e2b auth [options] [command]
+```
+## e2b auth login
+
+
+log in to CLI
+
+### Usage
+
+```bash
+e2b auth login [options]
+```
+
+
+## e2b auth logout
+
+
+log out of CLI
+
+### Usage
+
+```bash
+e2b auth logout [options]
+```
+
+
+## e2b auth info
+
+
+get information about the current user
+
+### Usage
+
+```bash
+e2b auth info [options]
+```
+
+
+## e2b auth configure
+
+
+configure user
+
+### Usage
+
+```bash
+e2b auth configure [options]
+```
+
+

apps/web/src/app/(docs)/docs/sdk-reference/cli/v1.2.3/sandbox/page.mdx

@@ -0,0 +1,89 @@
+## e2b sandbox
+
+
+work with sandboxes
+
+### Usage
+
+```bash
+e2b sandbox [options] [command]
+```
+## e2b sandbox connect
+
+
+connect terminal to already running sandbox
+
+### Usage
+
+```bash
+e2b sandbox connect [options] <sandboxID>
+```
+
+
+## e2b sandbox list
+
+
+list all running sandboxes
+
+### Usage
+
+```bash
+e2b sandbox list [options]
+```
+
+
+## e2b sandbox kill
+
+
+kill sandbox
+
+### Usage
+
+```bash
+e2b sandbox kill [options] [sandboxID]
+```
+
+### Options
+
+
+ - `-a, --all: kill all running sandboxes `
+
+
+## e2b sandbox spawn
+
+
+spawn sandbox and connect terminal to it
+
+### Usage
+
+```bash
+e2b sandbox spawn [options] [template]
+```
+
+### Options
+
+
+ - `-p, --path <path>: change root directory where command is executed to <path> directory `
+ - `--config <e2b-toml>: specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+
+
+## e2b sandbox logs
+
+
+show logs for sandbox
+
+### Usage
+
+```bash
+e2b sandbox logs [options] <sandboxID>
+```
+
+### Options
+
+
+ - `--level <level>: filter logs by level (DEBUG, INFO, WARN, ERROR). The logs with the higher levels will be also shown. [default: INFO]`
+ - `-f, --follow: keep streaming logs until the sandbox is closed `
+ - `--format <format>: specify format for printing logs (json, pretty) [default: pretty]`
+ - `--loggers [loggers]: filter logs by loggers. Specify multiple loggers by separating them with a comma. `
+
+

apps/web/src/app/(docs)/docs/sdk-reference/cli/v1.2.3/template/page.mdx

@@ -0,0 +1,132 @@
+## e2b template
+
+
+manage sandbox templates
+
+### Usage
+
+```bash
+e2b template [options] [command]
+```
+## e2b template build
+
+
+build sandbox template defined by ./e2b.Dockerfile or ./Dockerfile in root directory. By default the root directory is the current working directory. This command also creates e2b.toml config.
+
+### Usage
+
+```bash
+e2b template build [options] [template]
+```
+
+### Options
+
+
+ - `-p, --path <path>: change root directory where command is executed to <path> directory `
+ - `-d, --dockerfile <file>: specify path to Dockerfile. By default E2B tries to find e2b.Dockerfile or Dockerfile in root directory. `
+ - `-n, --name <template-name>: specify sandbox template name. You can use the template name to start the sandbox with SDK. The template name must be lowercase and contain only letters, numbers, dashes and underscores. `
+ - `-c, --cmd <start-command>: specify command that will be executed when the sandbox is started. `
+ - `-t, --team <team-id>: specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `--config <e2b-toml>: specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `--cpu-count <cpu-count>: specify the number of CPUs that will be used to run the sandbox. The default value is 2. `
+ - `--memory-mb <memory-mb>: specify the amount of memory in megabytes that will be used to run the sandbox. Must be an even number. The default value is 512. `
+ - `--build-arg <args...>: specify additional build arguments for the build command. The format should be <varname>=<value>. `
+
+
+## e2b template list
+
+
+list sandbox templates
+
+### Usage
+
+```bash
+e2b template list [options]
+```
+
+### Options
+
+
+ - `-t, --team <team-id>: specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+
+
+## e2b template init
+
+
+create basic E2B Dockerfile (./e2b.Dockerfile) in root directory. You can then run e2b template build to build sandbox template from this Dockerfile
+
+### Usage
+
+```bash
+e2b template init [options]
+```
+
+### Options
+
+
+ - `-p, --path <path>: change root directory where command is executed to <path> directory `
+
+
+## e2b template delete
+
+
+delete sandbox template and e2b.toml config
+
+### Usage
+
+```bash
+e2b template delete [options] [template]
+```
+
+### Options
+
+
+ - `-p, --path <path>: change root directory where command is executed to <path> directory `
+ - `--config <e2b-toml>: specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `-s, --select: select sandbox template from interactive list `
+ - `-t, --team <team-id>: specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `-y, --yes: skip manual delete confirmation `
+
+
+## e2b template publish
+
+
+publish sandbox template
+
+### Usage
+
+```bash
+e2b template publish [options] [template]
+```
+
+### Options
+
+
+ - `-p, --path <path>: change root directory where command is executed to <path> directory `
+ - `--config <e2b-toml>: specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `-s, --select: select sandbox template from interactive list `
+ - `-t, --team <team-id>: specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `-y, --yes: skip manual publish confirmation `
+
+
+## e2b template unpublish
+
+
+unpublish sandbox template
+
+### Usage
+
+```bash
+e2b template unpublish [options] [template]
+```
+
+### Options
+
+
+ - `-p, --path <path>: change root directory where command is executed to <path> directory `
+ - `--config <e2b-toml>: specify path to the E2B config toml. By default E2B tries to find ./e2b.toml in root directory. `
+ - `-s, --select: select sandbox template from interactive list `
+ - `-t, --team <team-id>: specify the team ID that the operation will be associated with. You can find team ID in the team settings in the E2B dashboard (https://e2b.dev/dashboard?tab=team). `
+ - `-y, --yes: skip manual unpublish confirmation `
+
+

apps/web/src/app/(docs)/docs/sdk-reference/js-sdk/v1.1.0/errors/page.mdx

@@ -0,0 +1,211 @@
+### AuthenticationError
+
+Thrown when authentication fails.
+
+#### Constructors
+
+```ts
+new AuthenticationError(message: any): AuthenticationError
+```
+
+###### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `message` | `any` |
+
+###### Returns
+
+`AuthenticationError`
+
+***
+
+### InvalidArgumentError
+
+Thrown when an invalid argument is provided.
+
+#### Constructors
+
+```ts
+new InvalidArgumentError(message: string): InvalidArgumentError
+```
+
+###### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `message` | `string` |
+
+###### Returns
+
+`InvalidArgumentError`
+
+***
+
+### NotEnoughSpaceError
+
+Thrown when there is not enough disk space.
+
+#### Constructors
+
+```ts
+new NotEnoughSpaceError(message: string): NotEnoughSpaceError
+```
+
+###### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `message` | `string` |
+
+###### Returns
+
+`NotEnoughSpaceError`
+
+***
+
+### NotFoundError
+
+Thrown when a resource is not found.
+
+#### Constructors
+
+```ts
+new NotFoundError(message: string): NotFoundError
+```
+
+###### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `message` | `string` |
+
+###### Returns
+
+`NotFoundError`
+
+***
+
+### RateLimitError
+
+Thrown when the API rate limit is exceeded.
+
+#### Constructors
+
+```ts
+new RateLimitError(message: any): RateLimitError
+```
+
+###### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `message` | `any` |
+
+###### Returns
+
+`RateLimitError`
+
+***
+
+### SandboxError
+
+Base class for all sandbox errors.
+
+Thrown when general sandbox errors occur.
+
+#### Extended by
+
+- `TimeoutError`
+- `InvalidArgumentError`
+- `NotEnoughSpaceError`
+- `NotFoundError`
+- `AuthenticationError`
+- `TemplateError`
+- `RateLimitError`
+
+#### Constructors
+
+```ts
+new SandboxError(message: any): SandboxError
+```
+
+###### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `message` | `any` |
+
+###### Returns
+
+`SandboxError`
+
+***
+
+### TemplateError
+
+Thrown when the template uses old envd version. It isn't compatible with the new SDK.
+
+#### Constructors
+
+```ts
+new TemplateError(message: string): TemplateError
+```
+
+###### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `message` | `string` |
+
+###### Returns
+
+`TemplateError`
+
+***
+
+### TimeoutError
+
+Thrown when a timeout error occurs.
+
+The [unavailable] error type is caused by sandbox timeout.
+
+The [canceled] error type is caused by exceeding request timeout.
+
+The [deadline_exceeded] error type is caused by exceeding the timeout for command execution, watch, etc.
+
+The [unknown] error type is sometimes caused by the sandbox timeout when the request is not processed correctly.
+
+#### Constructors
+
+```ts
+new TimeoutError(message: string): TimeoutError
+```
+
+###### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `message` | `string` |
+
+###### Returns
+
+`TimeoutError`
+
+## Functions
+
+### formatSandboxTimeoutError()
+
+```ts
+function formatSandboxTimeoutError(message: string): TimeoutError
+```
+
+#### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `message` | `string` |
+
+#### Returns
+
+`TimeoutError`

apps/web/src/app/(docs)/docs/sdk-reference/python-sdk/v1.2.0/exceptions/page.mdx

@@ -0,0 +1,84 @@
+
+
+
+## SandboxException
+
+```python
+class SandboxException(Exception)
+```
+
+Base class for all sandbox errors.
+
+Raised when a general sandbox exception occurs.
+
+
+## TimeoutException
+
+```python
+class TimeoutException(SandboxException)
+```
+
+Raised when a timeout occurs.
+
+The `unavailable` exception type is caused by sandbox timeout.
+
+The `canceled` exception type is caused by exceeding request timeout.
+
+The `deadline_exceeded` exception type is caused by exceeding the timeout for process, watch, etc.
+
+The `unknown` exception type is sometimes caused by the sandbox timeout when the request is not processed correctly.
+
+
+## InvalidArgumentException
+
+```python
+class InvalidArgumentException(SandboxException)
+```
+
+Raised when an invalid argument is provided.
+
+
+## NotEnoughSpaceException
+
+```python
+class NotEnoughSpaceException(SandboxException)
+```
+
+Raised when there is not enough disk space.
+
+
+## NotFoundException
+
+```python
+class NotFoundException(SandboxException)
+```
+
+Raised when a resource is not found.
+
+
+## AuthenticationException
+
+```python
+class AuthenticationException(SandboxException)
+```
+
+Raised when authentication fails.
+
+
+## TemplateException
+
+```python
+class TemplateException(SandboxException)
+```
+
+Exception raised when the template uses old envd version. It isn't compatible with the new SDK.
+
+
+## RateLimitException
+
+```python
+class RateLimitException(SandboxException)
+```
+
+Raised when the API rate limit is exceeded.
+

packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e2b/cli",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "CLI for managing e2b sandbox templates",
   "homepage": "https://e2b.dev",
   "license": "MIT",
@@ -73,7 +73,7 @@
     "command-exists": "^1.2.9",
     "commander": "^11.1.0",
     "console-table-printer": "^2.11.2",
-    "e2b": "^1.0.7",
+    "e2b": "^1.1.0",
     "inquirer": "^9.2.12",
     "open": "^9.1.0",
     "strip-ansi": "^7.1.0",

packages/cli/src/commands/template/build.ts

@@ -397,7 +397,7 @@ export const buildCommand = new commander.Command('build')
         console.log(
           `> Triggered build for the sandbox template ${asFormattedSandboxTemplate(
             template
-          )} `
+          )} with build ID: ${template.buildID}`
         )
 
         console.log('Waiting for build to finish...')

packages/js-sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "e2b",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "description": "E2B SDK that give agents cloud environments",
   "homepage": "https://e2b.dev",
   "license": "MIT",

packages/js-sdk/src/index.ts

@@ -1,26 +1,23 @@
 export { ApiClient } from './api'
 export type { components, paths } from './api'
 
+export { ConnectionConfig } from './connectionConfig'
+export type { ConnectionOpts, Username } from './connectionConfig'
 export {
   AuthenticationError,
-  SandboxError,
-  TimeoutError,
-  NotFoundError,
-  NotEnoughSpaceError,
   InvalidArgumentError,
+  NotEnoughSpaceError,
+  NotFoundError,
+  SandboxError,
   TemplateError,
+  TimeoutError,
 } from './errors'
-export { ConnectionConfig } from './connectionConfig'
 export type { Logger } from './logs'
-export type { ConnectionOpts, Username } from './connectionConfig'
 
-export { FilesystemEventType } from './sandbox/filesystem/watchHandle'
-export type {
-  FilesystemEvent,
-  WatchHandle,
-} from './sandbox/filesystem/watchHandle'
-export type { EntryInfo, Filesystem, WatchOpts } from './sandbox/filesystem'
 export { FileType } from './sandbox/filesystem'
+export type { EntryInfo, Filesystem } from './sandbox/filesystem'
+export { FilesystemEventType } from './sandbox/filesystem/watchHandle'
+export type { FilesystemEvent, WatchHandle } from './sandbox/filesystem/watchHandle'
 
 export { CommandExitError } from './sandbox/commands/commandHandle'
 export type {
@@ -41,8 +38,8 @@ export type {
   Pty,
 } from './sandbox/commands'
 
-export type { SandboxInfo } from './sandbox/sandboxApi'
 export type { SandboxOpts } from './sandbox'
-import { Sandbox } from './sandbox'
+export type { SandboxInfo } from './sandbox/sandboxApi'
 export { Sandbox }
+import { Sandbox } from './sandbox'
 export default Sandbox

packages/js-sdk/src/sandbox/filesystem/index.ts

@@ -7,20 +7,23 @@ import {
 } from '@connectrpc/connect'
 import {
   ConnectionConfig,
-  defaultUsername,
-  Username,
   ConnectionOpts,
-  KEEPALIVE_PING_INTERVAL_SEC,
+  defaultUsername,
   KEEPALIVE_PING_HEADER,
+  KEEPALIVE_PING_INTERVAL_SEC,
+  Username,
 } from '../../connectionConfig'
 
 import { handleEnvdApiError, handleWatchDirStartEvent } from '../../envd/api'
 import { authenticationHeader, handleRpcError } from '../../envd/rpc'
 
 import { EnvdApiClient } from '../../envd/api'
-import { FileType as FsFileType, Filesystem as FilesystemService } from '../../envd/filesystem/filesystem_pb'
+import {
+  FileType as FsFileType,
+  Filesystem as FilesystemService,
+} from '../../envd/filesystem/filesystem_pb'
 
-import { WatchHandle, FilesystemEvent } from './watchHandle'
+import { FilesystemEvent, WatchHandle } from './watchHandle'
 
 import { compareVersions } from 'compare-versions'
 import { TemplateError } from '../../errors'
@@ -58,6 +61,11 @@ export const enum FileType {
   DIR = 'dir',
 }
 
+export type WriteEntry = {
+  path: string
+  data: string | ArrayBuffer | Blob | ReadableStream
+}
+
 function mapFileType(fileType: FsFileType) {
   switch (fileType) {
     case FsFileType.DIRECTORY:
@@ -233,22 +241,75 @@ export class Filesystem {
     path: string,
     data: string | ArrayBuffer | Blob | ReadableStream,
     opts?: FilesystemRequestOpts
-  ): Promise<EntryInfo> {
-    const blob = await new Response(data).blob()
+  ): Promise<EntryInfo>
+  async write(
+    files: WriteEntry[],
+    opts?: FilesystemRequestOpts
+  ): Promise<EntryInfo[]>
+  async write(
+    pathOrFiles: string | WriteEntry[],
+    dataOrOpts?:
+      | string
+      | ArrayBuffer
+      | Blob
+      | ReadableStream
+      | FilesystemRequestOpts,
+    opts?: FilesystemRequestOpts
+  ): Promise<EntryInfo | EntryInfo[]> {
+    if (typeof pathOrFiles !== 'string' && !Array.isArray(pathOrFiles)) {
+      throw new Error('Path or files are required')
+    }
+
+    if (typeof pathOrFiles === 'string' && Array.isArray(dataOrOpts)) {
+      throw new Error(
+        'Cannot specify both path and array of files. You have to specify either path and data for a single file or an array for multiple files.'
+      )
+    }
+
+    const { path, writeOpts, writeFiles } =
+      typeof pathOrFiles === 'string'
+        ? {
+            path: pathOrFiles,
+            writeOpts: opts as FilesystemRequestOpts,
+            writeFiles: [
+              {
+                data: dataOrOpts as
+                  | string
+                  | ArrayBuffer
+                  | Blob
+                  | ReadableStream,
+              },
+            ],
+          }
+        : {
+            path: undefined,
+            writeOpts: dataOrOpts as FilesystemRequestOpts,
+            writeFiles: pathOrFiles as WriteEntry[],
+          }
+
+    if (writeFiles.length === 0) return [] as EntryInfo[]
+
+    const blobs = await Promise.all(
+      writeFiles.map((f) => new Response(f.data).blob())
+    )
 
     const res = await this.envdApi.api.POST('/files', {
       params: {
         query: {
           path,
-          username: opts?.user || defaultUsername,
+          username: writeOpts?.user || defaultUsername,
         },
       },
       bodySerializer() {
-        const fd = new FormData()
-
-        fd.append('file', blob)
-
-        return fd
+        return blobs.reduce((fd, blob, i) => {
+          // Important: RFC 7578, Section 4.2 requires that if a filename is provided,
+          // the directory path information must not be used.
+          // BUT in our case we need to use the directory path information with a custom
+          // muktipart part name getter in envd.
+          fd.append('file', blob, writeFiles[i].path)
+
+          return fd
+        }, new FormData())
       },
       body: {},
       headers: {
@@ -262,12 +323,12 @@ export class Filesystem {
       throw err
     }
 
-    const files = res.data
-    if (!files || files.length === 0) {
+    const files = res.data as EntryInfo[]
+    if (!files) {
       throw new Error('Expected to receive information about written file')
     }
 
-    return files[0] as EntryInfo
+    return files.length === 1 && path ? files[0] : files
   }
 
   /**
@@ -441,12 +502,19 @@ export class Filesystem {
   async watchDir(
     path: string,
     onEvent: (event: FilesystemEvent) => void | Promise<void>,
-    opts?: WatchOpts
+    opts?: WatchOpts & {
+      timeout?: number
+      onExit?: (err?: Error) => void | Promise<void>
+    }
   ): Promise<WatchHandle> {
-    if (opts?.recursive && this.envdApi.version && compareVersions(this.envdApi.version, ENVD_VERSION_RECURSIVE_WATCH) < 0) {
+    if (
+      opts?.recursive &&
+      this.envdApi.version &&
+      compareVersions(this.envdApi.version, ENVD_VERSION_RECURSIVE_WATCH) < 0
+    ) {
       throw new TemplateError(
         'You need to update the template to use recursive watching. ' +
-        'You can do this by running `e2b template build` in the directory with the template.'
+          'You can do this by running `e2b template build` in the directory with the template.'
       )
     }
 
@@ -457,8 +525,8 @@ export class Filesystem {
 
     const reqTimeout = requestTimeoutMs
       ? setTimeout(() => {
-        controller.abort()
-      }, requestTimeoutMs)
+          controller.abort()
+        }, requestTimeoutMs)
       : undefined
 
     const events = this.rpc.watchDir(

packages/js-sdk/tests/sandbox/closed_port.test.ts

@@ -19,7 +19,7 @@ test.skipIf(isDebug)('closed port in SDK', async () => {
 
   let res2 = await fetch(`${isDebug ? 'http' : 'https'}://${goodHost}`)
 
-  for (let i = 0; i < 10; i++) {
+  for (let i = 0; i < 20; i++) {
     if (res2.status === 200) {
       break
     }
@@ -62,7 +62,7 @@ test.skipIf(isDebug)('closed port in browser  ', async () => {
 
   let res2 = await fetch(`${isDebug ? 'http' : 'https'}://${goodHost}`)
 
-  for (let i = 0; i < 10; i++) {
+  for (let i = 0; i < 20; i++) {
     if (res2.status === 200) {
       break
     }

packages/js-sdk/tests/sandbox/files/write.test.ts

@@ -1,12 +1,125 @@
-import { assert } from 'vitest'
+import path from 'path'
+import { assert, onTestFinished } from 'vitest'
 
-import { sandboxTest } from '../../setup.js'
+import { WriteEntry } from '../../../src/sandbox/filesystem'
+import { isDebug, sandboxTest } from '../../setup.js'
+
+sandboxTest('write file', async ({ sandbox }) => {
+  const filename = 'test_write.txt'
+  const content = 'This is a test file.'
+
+  // Attempt to write with undefined path and content
+  await sandbox.files
+    // @ts-ignore
+    .write(undefined, content)
+    .then((e) => {
+      assert.isUndefined(e)
+    })
+    .catch((err) => {
+      assert.instanceOf(err, Error)
+      assert.include(err.message, 'Path or files are required')
+    })
+
+  const info = await sandbox.files.write(filename, content)
+  assert.isFalse(Array.isArray(info))
+  assert.equal(info.name, filename)
+  assert.equal(info.type, 'file')
+  assert.equal(info.path, `/home/user/${filename}`)
+
+  const exists = await sandbox.files.exists(filename)
+  assert.isTrue(exists)
+  const readContent = await sandbox.files.read(filename)
+  assert.equal(readContent, content)
+})
+
+sandboxTest('write multiple files', async ({ sandbox }) => {
+  // Attempt to write with empty files array
+  const emptyInfo = await sandbox.files.write([])
+  assert.isTrue(Array.isArray(emptyInfo))
+  assert.equal(emptyInfo.length, 0)
+
+  // Attempt to write with undefined path and file array
+  await sandbox.files
+    // @ts-ignore
+    .write(undefined, [{ path: 'one_test_file.txt', data: 'This is a test file.' }])
+    .then((e) => {
+      assert.isUndefined(e)
+    })
+    .catch((err) => {
+      assert.instanceOf(err, Error)
+      assert.include(err.message, 'Path or files are required')
+    })
+
+  // Attempt to write with path and file array
+  await sandbox.files
+    // @ts-ignore
+    .write('/path/to/file', [{ path: 'one_test_file.txt', data: 'This is a test file.' }])
+    .then((e) => {
+      assert.isUndefined(e)
+    })
+    .catch((err) => {
+      assert.instanceOf(err, Error)
+      assert.include(
+        err.message,
+        'Cannot specify both path and array of files. You have to specify either path and data for a single file or an array for multiple files.'
+      )
+    })
+
+  // Attempt to write with one file in array
+  const info = await sandbox.files.write([{ path: 'one_test_file.txt', data: 'This is a test file.' }])
+  assert.isTrue(Array.isArray(info))
+  assert.equal(info[0].name, 'one_test_file.txt')
+  assert.equal(info[0].type, 'file')
+  assert.equal(info[0].path, '/home/user/one_test_file.txt')
+
+  // Attempt to write with multiple files in array
+  const files: WriteEntry[] = []
+
+  for (let i = 0; i < 10; i++) {
+    let path = ''
+    if (i % 2 == 0) {
+      path = `/${i}/multi_test_file${i}.txt`
+    } else {
+      path = `/home/user/multi_test_file${i}.txt`
+    }
+
+    if (isDebug) {
+      onTestFinished(async () => await sandbox.files.remove(path))
+    }
+
+    files.push({
+      path: path,
+      data: `This is a test file ${i}.`,
+    })
+  }
+
+  const infos = await sandbox.files.write(files)
+
+  assert.isTrue(Array.isArray(infos))
+  assert.equal(infos.length, files.length)
+
+  // Attempt to write with multiple files in array
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i]
+    const info = infos[i]
+
+    assert.equal(info.name, path.basename(file.path))
+    assert.equal(info.path, file.path)
+    assert.equal(info.type, 'file')
+
+    const exists = await sandbox.files.exists(file.path)
+    assert.isTrue(exists)
+    const readContent = await sandbox.files.read(file.path)
+    assert.equal(readContent, file.data)
+  }
+})
 
 sandboxTest('write file', async ({ sandbox }) => {
   const filename = 'test_write.txt'
   const content = 'This is a test file.'
 
   const info = await sandbox.files.write(filename, content)
+  assert.isFalse(Array.isArray(info))
   assert.equal(info.name, filename)
   assert.equal(info.type, 'file')
   assert.equal(info.path, `/home/user/${filename}`)

packages/js-sdk/tests/sandbox/host.test.ts

@@ -12,7 +12,7 @@ sandboxTest('ping server in sandbox', async ({ sandbox }) => {
 
     let res = await fetch(`${isDebug ? 'http' : 'https'}://${host}`)
 
-    for (let i = 0; i < 10; i++) {
+    for (let i = 0; i < 20; i++) {
       if (res.status === 200) {
         break
       }

packages/python-sdk/e2b/exceptions.py

@@ -30,10 +30,10 @@ class TimeoutException(SandboxException):
     """
     Raised when a timeout occurs.
 
-    The [unavailable] exception type is caused by sandbox timeout.\n
-    The [canceled] exception type is caused by exceeding request timeout.\n
-    The [deadline_exceeded] exception type is caused by exceeding the timeout for process, watch, etc.\n
-    The [unknown] exception type is sometimes caused by the sandbox timeout when the request is not processed correctly.\n
+    The `unavailable` exception type is caused by sandbox timeout.\n
+    The `canceled` exception type is caused by exceeding request timeout.\n
+    The `deadline_exceeded` exception type is caused by exceeding the timeout for process, watch, etc.\n
+    The `unknown` exception type is sometimes caused by the sandbox timeout when the request is not processed correctly.\n
     """
 
     pass

packages/python-sdk/e2b/sandbox/filesystem/filesystem.py

@@ -1,6 +1,6 @@
-from enum import Enum
 from dataclasses import dataclass
-from typing import Optional
+from enum import Enum
+from typing import IO, Optional, Union
 
 from e2b.envd.filesystem import filesystem_pb2
 
@@ -45,3 +45,13 @@ class EntryInfo:
     """
     Path to the filesystem object.
     """
+
+
+dataclass
+class WriteEntry:
+    """
+    Contains path and data of the file to be written to the filesystem.
+    """
+
+    path: str
+    data: Union[str, bytes, IO]

packages/python-sdk/e2b/sandbox_async/filesystem/filesystem.py

@@ -2,7 +2,8 @@
 import httpx
 from io import TextIOBase
 from packaging.version import Version
-from typing import IO, AsyncIterator, List, Literal, Optional, Union, overload
+from typing import AsyncIterator, IO, List, Literal, Optional, overload, Union
+from e2b.sandbox.filesystem.filesystem import WriteEntry
 
 import e2b_connect as connect
 from e2b.connection_config import (
@@ -133,6 +134,7 @@ async def read(
         elif format == "stream":
             return r.aiter_bytes()
 
+    @overload
     async def write(
         self,
         path: str,
@@ -156,27 +158,87 @@ async def write(
 
         :return: Information about the written file
         """
-        if isinstance(data, TextIOBase):
-            data = data.read().encode()
+
+    @overload
+    async def write(
+        self,
+        files: List[WriteEntry],
+        user: Optional[Username] = "user",
+        request_timeout: Optional[float] = None,
+    ) -> List[EntryInfo]:
+        """
+        Writes multiple files.
+
+        :param files: list of files to write 
+        :param user: Run the operation as this user
+        :param request_timeout: Timeout for the request
+        :return: Information about the written files
+        """
+
+    async def write(
+        self,
+        path_or_files: Union[str, List[WriteEntry]],
+        data_or_user: Union[str, bytes, IO, Username] = "user",
+        user_or_request_timeout: Optional[Union[float, Username]] = None,
+        request_timeout_or_none: Optional[float] = None
+    ) -> Union[EntryInfo, List[EntryInfo]]:
+        """
+        Writes content to a file on the path.
+        When writing to a file that doesn't exist, the file will get created.
+        When writing to a file that already exists, the file will get overwritten.
+        When writing to a file that's in a directory that doesn't exist, you'll get an error.
+        """
+        path, write_files, user, request_timeout = None, [], "user", None
+        if isinstance(path_or_files, str):
+            if isinstance(data_or_user, list):
+                raise Exception("Cannot specify both path and array of files. You have to specify either path and data for a single file or an array for multiple files.")
+            path, write_files, user, request_timeout = \
+                path_or_files, [{"path": path_or_files, "data": data_or_user}], user_or_request_timeout or "user", request_timeout_or_none
+        else:
+            if path_or_files is None:
+                raise Exception("Path or files are required")
+            path, write_files, user, request_timeout = \
+                None, path_or_files, data_or_user, user_or_request_timeout
+
+        # Prepare the files for the multipart/form-data request
+        httpx_files = []
+        for file in write_files:
+            file_path, file_data = file['path'], file['data']
+            if isinstance(file_data, str) or isinstance(file_data, bytes):
+                httpx_files.append(('file', (file_path, file_data)))
+            elif isinstance(file_data, TextIOBase):
+                httpx_files.append(('file', (file_path, file_data.read())))
+            else:
+                raise ValueError(f"Unsupported data type for file {file_path}")
+
+        # Allow passing empty list of files
+        if len(httpx_files) == 0: return []
+
+        params = {"username": user}
+        if path is not None: params["path"] = path
 
         r = await self._envd_api.post(
             ENVD_API_FILES_ROUTE,
-            files={"file": data},
-            params={"path": path, "username": user},
+            files=httpx_files,
+            params=params,
             timeout=self._connection_config.get_request_timeout(request_timeout),
         )
 
         err = await ahandle_envd_api_exception(r)
         if err:
             raise err
 
-        files = r.json()
+        write_files = r.json()
 
-        if not isinstance(files, list) or len(files) == 0:
+        if not isinstance(write_files, list) or len(write_files) == 0:
             raise Exception("Expected to receive information about written file")
 
-        file = files[0]
-        return EntryInfo(**file)
+        if len(write_files) == 1 and path:
+            file = write_files[0]
+            return EntryInfo(**file)
+        else:
+            return [EntryInfo(**file) for file in write_files]
+
 
     async def list(
         self,

packages/python-sdk/e2b/sandbox_sync/filesystem/filesystem.py

@@ -1,5 +1,6 @@
 from io import TextIOBase
-from typing import IO, Iterator, List, Literal, Optional, Union, overload
+from typing import IO, Iterator, List, Literal, Optional, overload, Union
+from e2b.sandbox.filesystem.filesystem import WriteEntry
 
 import e2b_connect
 import httpcore
@@ -132,6 +133,7 @@ def read(
         elif format == "stream":
             return r.iter_bytes()
 
+    @overload
     def write(
         self,
         path: str,
@@ -155,27 +157,83 @@ def write(
 
         :return: Information about the written file
         """
-        if isinstance(data, TextIOBase):
-            data = data.read().encode()
+
+    @overload
+    def write(
+        self,
+        files: List[WriteEntry],
+        user: Optional[Username] = "user",
+        request_timeout: Optional[float] = None,
+    ) -> List[EntryInfo]:
+        """
+        Writes a list of files to the filesystem.
+        When writing to a file that doesn't exist, the file will get created.
+        When writing to a file that already exists, the file will get overwritten.
+        When writing to a file that's in a directory that doesn't exist, you'll get an error.
+
+        :param files: list of files to write 
+        :param user: Run the operation as this user
+        :param request_timeout: Timeout for the request
+        :return: Information about the written files
+        """
+
+    def write(
+        self,
+        path_or_files: Union[str, List[WriteEntry]],
+        data_or_user: Union[str, bytes, IO, Username] = "user",
+        user_or_request_timeout: Optional[Union[float, Username]] = None,
+        request_timeout_or_none: Optional[float] = None
+    ) -> Union[EntryInfo, List[EntryInfo]]:
+        path, write_files, user, request_timeout  = None, [], "user", None
+        if isinstance(path_or_files, str):
+            if isinstance(data_or_user, list):
+                raise Exception("Cannot specify both path and array of files. You have to specify either path and data for a single file or an array for multiple files.")
+            path, write_files, user, request_timeout = \
+                path_or_files, [{"path": path_or_files, "data": data_or_user}], user_or_request_timeout or "user", request_timeout_or_none
+        else:
+            if path_or_files is None:
+                raise Exception("Path or files are required")
+            path, write_files, user, request_timeout = \
+                None, path_or_files, data_or_user, user_or_request_timeout
+
+        # Prepare the files for the multipart/form-data request
+        httpx_files = []
+        for file in write_files:
+            file_path, file_data = file['path'], file['data']
+            if isinstance(file_data, str) or isinstance(file_data, bytes):
+                httpx_files.append(('file', (file_path, file_data)))
+            elif isinstance(file_data, TextIOBase):
+                httpx_files.append(('file', (file_path, file_data.read())))
+            else:
+                raise ValueError(f"Unsupported data type for file {file_path}")
+
+        # Allow passing empty list of files
+        if len(httpx_files) == 0: return []
+
+        params = {"username": user}
+        if path is not None: params["path"] = path
 
         r = self._envd_api.post(
             ENVD_API_FILES_ROUTE,
-            files={"file": data},
-            params={"path": path, "username": user},
+            files=httpx_files,
+            params=params,
             timeout=self._connection_config.get_request_timeout(request_timeout),
         )
 
         err = handle_envd_api_exception(r)
         if err:
             raise err
 
-        files = r.json()
+        write_files = r.json()
 
-        if not isinstance(files, list) or len(files) == 0:
+        if not isinstance(write_files, list) or len(write_files) == 0:
             raise Exception("Expected to receive information about written file")
 
-        file = files[0]
-        return EntryInfo(**file)
+        if len(write_files) == 1 and path:
+            file = write_files[0]
+            return EntryInfo(**file)
+        else:
+            return [EntryInfo(**file) for file in write_files]
 
     def list(
         self,

packages/python-sdk/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@e2b/python-sdk",
   "private": true,
-  "version": "1.1.0",
+  "version": "1.2.0",
   "scripts": {
     "example": "poetry run python example.py",
     "test": "poetry run pytest -n 4 --verbose -x",

packages/python-sdk/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "e2b"
-version = "1.1.0"
+version = "1.2.0"
 description = "E2B SDK that give agents cloud environments"
 authors = ["e2b <hello@e2b.dev>"]
 license = "MIT"

packages/python-sdk/tests/async/sandbox_async/files/test_write.py

@@ -1,10 +1,16 @@
 from e2b import AsyncSandbox
-
+from e2b.sandbox_async.filesystem.filesystem import EntryInfo
 
 async def test_write_file(async_sandbox: AsyncSandbox):
     filename = "test_write.txt"
     content = "This is a test file."
 
+    # Attempt to write without path
+    try:
+        await async_sandbox.files.write(None, content)
+    except Exception as e:
+        assert "Path or files are required" in str(e)
+
     info = await async_sandbox.files.write(filename, content)
     assert info.path == f"/home/user/{filename}"
 
@@ -14,6 +20,55 @@ async def test_write_file(async_sandbox: AsyncSandbox):
     read_content = await async_sandbox.files.read(filename)
     assert read_content == content
 
+async def test_write_multiple_files(async_sandbox: AsyncSandbox):
+    # Attempt to write with empty files array
+    empty_info = await async_sandbox.files.write([])
+    assert isinstance(empty_info, list)
+    assert len(empty_info) == 0
+
+    # Attempt to write with None path and empty files array
+    try:
+        await async_sandbox.files.write(None, [])
+    except Exception as e:
+        assert "Path or files are required" in str(e)
+
+    # Attempt to write with path and file array
+    try:
+        await async_sandbox.files.write("/path/to/file", [{ "path": "one_test_file.txt", "data": "This is a test file." }])
+    except Exception as e:
+        assert "Cannot specify both path and array of files. You have to specify either path and data for a single file or an array for multiple files." in str(e)
+
+    # Attempt to write with one file in array
+    info = await async_sandbox.files.write([{ "path": "one_test_file.txt", "data": "This is a test file." }])
+    assert isinstance(info, list)
+    assert len(info) == 1
+    info = info[0]
+    assert isinstance(info, EntryInfo)
+    assert info.path == "/home/user/one_test_file.txt"
+    exists = await async_sandbox.files.exists(info.path)
+    assert exists
+
+    read_content = await async_sandbox.files.read(info.path)
+    assert read_content == "This is a test file."
+
+    # Attempt to write with multiple files in array
+    files = []
+    for i in range(10):
+        path = f"test_write_{i}.txt"
+        content = f"This is a test file {i}."
+        files.append({"path": path, "data": content})
+
+    infos = await async_sandbox.files.write(files)
+    assert isinstance(infos, list)
+    assert len(infos) == len(files)
+    for i, info in enumerate(infos):
+        assert isinstance(info, EntryInfo)
+        assert info.path == f"/home/user/test_write_{i}.txt"
+        exists = await async_sandbox.files.exists(path)
+        assert exists
+
+        read_content = await async_sandbox.files.read(info.path)
+        assert read_content == files[i]["data"]
 
 async def test_overwrite_file(async_sandbox: AsyncSandbox):
     filename = "test_overwrite.txt"

packages/python-sdk/tests/async/sandbox_async/test_host.py

@@ -16,7 +16,7 @@ async def test_ping_server(async_sandbox: AsyncSandbox, debug):
 
         status_code = None
         async with httpx.AsyncClient() as client:
-            for _ in range(5):
+            for _ in range(20):
                 res = await client.get(f"{'http' if debug else 'https'}://{host}")
                 status_code = res.status_code
                 if res.status_code == 200:

packages/python-sdk/tests/async/sandbox_async/test_port_closed.py

@@ -9,19 +9,19 @@ async def test_port_closed(template):
     sbx = await AsyncSandbox.create(template, timeout=60)
     try:
         assert await sbx.is_running()
-        
-        good_port = 8000
-        # Start a Python HTTP server on port 8000
+
+        good_port = 8002
+        # Start a Python HTTP server on port 8002
         await sbx.commands.run(
             f"python -m http.server {good_port}",
             background=True,
         )
         await asyncio.sleep(1)  # Wait for server to start
-        
-        # Test good port (8000)
+
+        # Test good port (8002)
         good_host = sbx.get_host(good_port)
         async with httpx.AsyncClient() as client:
-            for _ in range(10):
+            for _ in range(20):
                 try:
                     response = await client.get(f"https://{good_host}")
                     if response.status_code == 200:
@@ -35,7 +35,7 @@ async def test_port_closed(template):
         bad_port = 3000
         bad_host = sbx.get_host(bad_port)
         async with httpx.AsyncClient() as client:
-            for _ in range(10):
+            for _ in range(20):
                 try:
                     response = await client.get(f"https://{bad_host}")
                     if response.status_code == 502:

packages/python-sdk/tests/sync/sandbox_sync/files/test_watch.py

@@ -8,20 +8,15 @@ def test_watch_directory_changes(sandbox: Sandbox):
     filename = "test_watch.txt"
     content = "This file will be watched."
 
-    sandbox.files.remove(dirname)
     sandbox.files.make_dir(dirname)
+    sandbox.files.write(f"{dirname}/{filename}", content)
 
     handle = sandbox.files.watch_dir(dirname)
     sandbox.files.write(f"{dirname}/{filename}", content)
 
     events = handle.get_new_events()
-    assert len(events) == 3
-    assert events[0].type == FilesystemEventType.CREATE
+    assert events[0].type == FilesystemEventType.WRITE
     assert events[0].name == filename
-    assert events[1].type == FilesystemEventType.CHMOD
-    assert events[1].name == filename
-    assert events[2].type == FilesystemEventType.WRITE
-    assert events[2].name == filename
 
     handle.stop()
 

packages/python-sdk/tests/sync/sandbox_sync/files/test_write.py

@@ -1,7 +1,15 @@
+from e2b.sandbox.filesystem.filesystem import EntryInfo
+
 def test_write_file(sandbox):
     filename = "test_write.txt"
     content = "This is a test file."
 
+    # Attempt to write without path
+    try:
+        sandbox.files.write(None, content)
+    except Exception as e:
+        assert "Path or files are required" in str(e)
+
     info = sandbox.files.write(filename, content)
     assert info.path == f"/home/user/{filename}"
 
@@ -11,6 +19,55 @@ def test_write_file(sandbox):
     read_content = sandbox.files.read(filename)
     assert read_content == content
 
+def test_write_multiple_files(sandbox):
+    # Attempt to write with empty files array
+    empty_info = sandbox.files.write([])
+    assert isinstance(empty_info, list)
+    assert len(empty_info) == 0
+
+    # Attempt to write with None path and empty files array
+    try:
+        sandbox.files.write(None, [])
+    except Exception as e:
+        assert "Path or files are required" in str(e)
+
+    # Attempt to write with path and file array
+    try:
+        sandbox.files.write("/path/to/file", [{ "path": "one_test_file.txt", "data": "This is a test file." }])
+    except Exception as e:
+        assert "Cannot specify both path and array of files. You have to specify either path and data for a single file or an array for multiple files." in str(e)
+
+    # Attempt to write with one file in array
+    info = sandbox.files.write([{ "path": "one_test_file.txt", "data": "This is a test file." }])
+    assert isinstance(info, list)
+    assert len(info) == 1
+    info = info[0]
+    assert isinstance(info, EntryInfo)
+    assert info.path == "/home/user/one_test_file.txt"
+    exists = sandbox.files.exists(info.path)
+    assert exists
+
+    read_content = sandbox.files.read(info.path)
+    assert read_content == "This is a test file."
+
+    # Attempt to write with multiple files in array
+    files = []
+    for i in range(10):
+        path = f"test_write_{i}.txt"
+        content = f"This is a test file {i}."
+        files.append({"path": path, "data": content})
+
+    infos = sandbox.files.write(files)
+    assert isinstance(infos, list)
+    assert len(infos) == len(files)
+    for i, info in enumerate(infos):
+        assert isinstance(info, EntryInfo)
+        assert info.path == f"/home/user/test_write_{i}.txt"
+        exists = sandbox.files.exists(path)
+        assert exists
+
+        read_content = sandbox.files.read(info.path)
+        assert read_content == files[i]["data"]
 
 def test_overwrite_file(sandbox):
     filename = "test_overwrite.txt"

packages/python-sdk/tests/sync/sandbox_sync/test_host.py

@@ -9,7 +9,7 @@ def test_ping_server(sandbox, debug):
     try:
         host = sandbox.get_host(8001)
         status_code = None
-        for _ in range(5):
+        for _ in range(20):
             res = httpx.get(f"{'http' if debug else 'https'}://{host}")
             status_code = res.status_code
             if res.status_code == 200:

packages/python-sdk/tests/sync/sandbox_sync/test_port_closed.py

@@ -9,16 +9,16 @@ def test_port_closed(template):
     sbx = Sandbox(template, timeout=60)
     try:
         assert sbx.is_running()
-        
-        good_port = 8000
-        # Start a Python HTTP server on port 8000
+
+        good_port = 8004
+        # Start a Python HTTP server on port 8004
         sbx.commands.run(
             f"python -m http.server {good_port}",
             background=True,
         )
         time.sleep(1)  # Wait for server to start
-        
-        # Test good port (8000)
+
+        # Test good port (8004)
         good_host = sbx.get_host(good_port)
         with httpx.Client() as client:
             for _ in range(10):