Add multi-file write support to the js and python sdks

.changeset/new-berries-heal.md

@@ -0,0 +1,6 @@
+---
+'@e2b/python-sdk': minor
+'e2b': minor
+---
+
+the Filesytem write method is overloaded to also allow passing in an array of files

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 signle 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'
@@ -25,3 +27,86 @@ with open("path/to/local/file", "rb") as 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>

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, WriteData } 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,10 @@ export type {
   Pty,
 } from './sandbox/commands'
 
-export type { SandboxInfo } from './sandbox/sandboxApi'
+export type { Pty } from './sandbox/pty'
+
 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,11 +7,11 @@ 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'
@@ -20,7 +20,7 @@ import { authenticationHeader, handleRpcError } from '../../envd/rpc'
 import { EnvdApiClient } from '../../envd/api'
 import { FileType as FsFileType, Filesystem as FilesystemService } from '../../envd/filesystem/filesystem_pb'
 
-import { WatchHandle, FilesystemEvent } from './watchHandle'
+import { FilesystemEvent, WatchHandle } from './watchHandle'
 
 /**
  * Sandbox filesystem object information.
@@ -54,6 +54,13 @@ export const enum FileType {
   DIR = 'dir',
 }
 
+export type WriteData = string | ArrayBuffer | Blob | ReadableStream
+
+export type WriteEntry = {
+  path: string
+  data: WriteData
+}
+
 function mapFileType(fileType: FsFileType) {
   switch (fileType) {
     case FsFileType.DIRECTORY:
@@ -220,26 +227,53 @@ export class Filesystem {
    *
    * @returns information about the written file
    */
+  async write(path: string, data: WriteData, opts?: FilesystemRequestOpts): Promise<EntryInfo>
+  async write(files: WriteEntry[], opts?: FilesystemRequestOpts): Promise<EntryInfo[]>
   async write(
-    path: string,
-    data: string | ArrayBuffer | Blob | ReadableStream,
+    pathOrFiles: string | WriteEntry[],
+    dataOrOpts?: WriteData | FilesystemRequestOpts,
     opts?: FilesystemRequestOpts
-  ): Promise<EntryInfo> {
-    const blob = await new Response(data).blob()
+  ): 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 WriteData }],
+          }
+        : { 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: {
@@ -253,12 +287,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
   }
 
   /**
@@ -338,11 +372,7 @@ export class Filesystem {
    *
    * @returns information about renamed file or directory.
    */
-  async rename(
-    oldPath: string,
-    newPath: string,
-    opts?: FilesystemRequestOpts
-  ): Promise<EntryInfo> {
+  async rename(oldPath: string, newPath: string, opts?: FilesystemRequestOpts): Promise<EntryInfo> {
     try {
       const res = await this.rpc.move(
         {
@@ -434,8 +464,7 @@ export class Filesystem {
     onEvent: (event: FilesystemEvent) => void | Promise<void>,
     opts?: WatchOpts
   ): Promise<WatchHandle> {
-    const requestTimeoutMs =
-      opts?.requestTimeoutMs ?? this.connectionConfig.requestTimeoutMs
+    const requestTimeoutMs = opts?.requestTimeoutMs ?? this.connectionConfig.requestTimeoutMs
 
     const controller = new AbortController()
 
@@ -462,12 +491,7 @@ export class Filesystem {
 
       clearTimeout(reqTimeout)
 
-      return new WatchHandle(
-        () => controller.abort(),
-        events,
-        onEvent,
-        opts?.onExit
-      )
+      return new WatchHandle(() => controller.abort(), events, onEvent, opts?.onExit)
     } catch (err) {
       throw handleRpcError(err)
     }