SDK v2 - Add beta submodule and update Sandbox list

.github/workflows/generated_files.yml

@@ -48,7 +48,7 @@ jobs:
           cache-to: type=gha,mode=max
 
       - name: Run codegen
-        run: make codegen
+        run: CODEGEN_IMAGE=codegen-env:latest make codegen
 
       - name: Check for uncommitted changes
         run: |

Makefile

@@ -1,7 +1,10 @@
 .PHONY: codegen
 codegen:
 	@echo "Generating SDK code from openapi and envd spec"
-	@docker run -v "$$(pwd):/workspace" $$(docker build -q -t codegen-env . -f codegen.Dockerfile)
+	@CODEGEN_IMAGE=$${CODEGEN_IMAGE:-$$(docker build -q -t codegen-env . -f codegen.Dockerfile)} ; \
+	echo "Using codegen image: $$CODEGEN_IMAGE" \
+	&& docker run -v $$PWD:/workspace $$CODEGEN_IMAGE make generate
+
 generate: generate-js generate-python
 
 generate-js:

README.md

@@ -64,7 +64,7 @@ Python
 ```py
 from e2b_code_interpreter import Sandbox
 
-with Sandbox() as sandbox:
+with Sandbox.create() as sandbox:
     sandbox.run_code("x = 1")
     execution = sandbox.run_code("x+=1; x")
     print(execution.text)  # outputs 2

codegen.Dockerfile

@@ -32,8 +32,9 @@ COPY --from=0 /go /go
 # Add Go binary to PATH 
 ENV PATH="/go/bin:${PATH}"
 
-# Install Python deps
-RUN pip install black==23.7.0 pyyaml==6.0.2 openapi-python-client==0.24.3
+# Install Python deps (e2b-openapi-python-client is patched version to fix issue with explode)
+# https://github.com/openapi-generators/openapi-python-client/pull/1296
+RUN pip install black==23.7.0 pyyaml==6.0.2 e2b-openapi-python-client==0.26.2
 
 # Install Node.js and npm
 RUN apt-get update && \

packages/cli/src/commands/sandbox/spawn.ts → packages/cli/src/commands/sandbox/create.ts

@@ -10,23 +10,23 @@ import { getConfigPath, loadConfig } from '../../config'
 import fs from 'fs'
 import { configOption, pathOption } from '../../options'
 
-export const spawnCommand = new commander.Command('spawn')
-  .description('spawn sandbox and connect terminal to it')
+export const createCommand = new commander.Command('create')
+  .description('create sandbox and connect terminal to it')
   .argument(
     '[template]',
-    `spawn and connect to sandbox specified by ${asBold('[template]')}`,
+    `create and connect to sandbox specified by ${asBold('[template]')}`
   )
   .addOption(pathOption)
   .addOption(configOption)
-  .alias('sp')
+  .alias('cr')
   .action(
     async (
       template: string | undefined,
       opts: {
         name?: string
         path?: string
         config?: string
-      },
+      }
     ) => {
       try {
         const apiKey = ensureAPIKey()
@@ -49,15 +49,15 @@ export const spawnCommand = new commander.Command('spawn')
                   ? [config.template_name]
                   : undefined,
               },
-              relativeConfigPath,
-            )}`,
+              relativeConfigPath
+            )}`
           )
           templateID = config.template_id
         }
 
         if (!templateID) {
           console.error(
-            'You need to specify sandbox template ID or path to sandbox template config',
+            'You need to specify sandbox template ID or path to sandbox template config'
           )
           process.exit(1)
         }
@@ -68,7 +68,7 @@ export const spawnCommand = new commander.Command('spawn')
         console.error(err)
         process.exit(1)
       }
-    },
+    }
   )
 
 export async function connectSandbox({
@@ -87,8 +87,8 @@ export async function connectSandbox({
 
   console.log(
     `Terminal connecting to template ${asFormattedSandboxTemplate(
-      template,
-    )} with sandbox ID ${asBold(`${sandbox.sandboxId}`)}`,
+      template
+    )} with sandbox ID ${asBold(`${sandbox.sandboxId}`)}`
   )
   try {
     await spawnConnectedTerminal(sandbox)
@@ -97,8 +97,8 @@ export async function connectSandbox({
     await sandbox.kill()
     console.log(
       `Closing terminal connection to template ${asFormattedSandboxTemplate(
-        template,
-      )} with sandbox ID ${asBold(`${sandbox.sandboxId}`)}`,
+        template
+      )} with sandbox ID ${asBold(`${sandbox.sandboxId}`)}`
     )
   }
 }

packages/cli/src/commands/sandbox/index.ts

@@ -3,7 +3,7 @@ import * as commander from 'commander'
 import { connectCommand } from './connect'
 import { listCommand } from './list'
 import { killCommand } from './kill'
-import { spawnCommand } from './spawn'
+import { createCommand } from './create'
 import { logsCommand } from './logs'
 import { metricsCommand } from './metrics'
 
@@ -13,6 +13,6 @@ export const sandboxCommand = new commander.Command('sandbox')
   .addCommand(connectCommand)
   .addCommand(listCommand)
   .addCommand(killCommand)
-  .addCommand(spawnCommand)
+  .addCommand(createCommand)
   .addCommand(logsCommand)
   .addCommand(metricsCommand)

packages/cli/src/commands/sandbox/kill.ts

@@ -3,6 +3,7 @@ import * as commander from 'commander'
 import { ensureAPIKey } from 'src/api'
 import { asBold } from 'src/utils/format'
 import * as e2b from 'e2b'
+import { listSandboxes } from './list'
 
 async function killSandbox(sandboxID: string, apiKey: string) {
   const killed = await e2b.Sandbox.kill(sandboxID, { apiKey })
@@ -17,7 +18,7 @@ export const killCommand = new commander.Command('kill')
   .description('kill sandbox')
   .argument(
     '[sandboxID]',
-    `kill the sandbox specified by ${asBold('[sandboxID]')}`,
+    `kill the sandbox specified by ${asBold('[sandboxID]')}`
   )
   .alias('kl')
   .option('-a, --all', 'kill all running sandboxes')
@@ -28,31 +29,32 @@ export const killCommand = new commander.Command('kill')
       if (!sandboxID && !all) {
         console.error(
           `You need to specify ${asBold('[sandboxID]')} or use ${asBold(
-            '-a/--all',
-          )} flag`,
+            '-a/--all'
+          )} flag`
         )
         process.exit(1)
       }
 
       if (all && sandboxID) {
         console.error(
           `You cannot use ${asBold('-a/--all')} flag while specifying ${asBold(
-            '[sandboxID]',
-          )}`,
+            '[sandboxID]'
+          )}`
         )
         process.exit(1)
       }
 
       if (all) {
-        const sandboxes = await e2b.Sandbox.list({ apiKey })
-
+        const sandboxes = await listSandboxes({
+          state: ['running'],
+        })
         if (sandboxes.length === 0) {
           console.log('No running sandboxes')
           process.exit(0)
         }
 
         await Promise.all(
-          sandboxes.map((sandbox) => killSandbox(sandbox.sandboxId, apiKey)),
+          sandboxes.map((sandbox) => killSandbox(sandbox.sandboxID, apiKey))
         )
       } else {
         await killSandbox(sandboxID, apiKey)

packages/cli/src/commands/sandbox/list.ts

@@ -1,19 +1,38 @@
 import * as tablePrinter from 'console-table-printer'
 import * as commander from 'commander'
-import * as e2b from 'e2b'
+import { components } from 'e2b'
 
 import { client, connectionConfig, ensureAPIKey } from 'src/api'
 import { handleE2BRequestError } from '../../utils/errors'
 
 export const listCommand = new commander.Command('list')
   .description('list all running sandboxes')
   .alias('ls')
-  .action(async () => {
+  .option(
+    '-s, --state <state>',
+    'filter by state, eg. running, stopped',
+    (value) => value.split(',')
+  )
+  .option(
+    '-m, --metadata <metadata>',
+    'filter by metadata, eg. key1=value1',
+    (value) => value.replace(/,/g, '&')
+  )
+  .option(
+    '-l, --limit <limit>',
+    'limit the number of sandboxes returned',
+    (value) => parseInt(value)
+  )
+  .action(async (options) => {
     try {
-      const sandboxes = await listSandboxes()
+      const sandboxes = await listSandboxes({
+        limit: options.limit,
+        state: options.state,
+        metadata: options.metadata,
+      })
 
       if (!sandboxes?.length) {
-        console.log('No running sandboxes.')
+        console.log('No sandboxes found')
       } else {
         const table = new tablePrinter.Table({
           title: 'Running sandboxes',
@@ -28,6 +47,7 @@ export const listCommand = new commander.Command('list')
             { name: 'alias', alignment: 'left', title: 'Alias' },
             { name: 'startedAt', alignment: 'left', title: 'Started at' },
             { name: 'endAt', alignment: 'left', title: 'End at' },
+            { name: 'state', alignment: 'left', title: 'State' },
             { name: 'cpuCount', alignment: 'left', title: 'vCPUs' },
             { name: 'memoryMB', alignment: 'left', title: 'RAM MiB' },
             { name: 'metadata', alignment: 'left', title: 'Metadata' },
@@ -39,6 +59,8 @@ export const listCommand = new commander.Command('list')
               sandboxID: sandbox.sandboxID,
               startedAt: new Date(sandbox.startedAt).toLocaleString(),
               endAt: new Date(sandbox.endAt).toLocaleString(),
+              state:
+                sandbox.state.charAt(0).toUpperCase() + sandbox.state.slice(1), // capitalize
               metadata: JSON.stringify(sandbox.metadata),
             }))
             .sort(
@@ -81,15 +103,51 @@ export const listCommand = new commander.Command('list')
     }
   })
 
-export async function listSandboxes(): Promise<
-  e2b.components['schemas']['ListedSandbox'][]
+type ListSandboxesOptions = {
+  limit?: number
+  state?: components['schemas']['SandboxState'][]
+  metadata?: string
+}
+
+export async function listSandboxes({
+  limit,
+  state,
+  metadata,
+}: ListSandboxesOptions = {}): Promise<
+  components['schemas']['ListedSandbox'][]
 > {
   ensureAPIKey()
 
   const signal = connectionConfig.getSignal()
-  const res = await client.api.GET('/sandboxes', { signal })
 
-  handleE2BRequestError(res,  'Error getting running sandboxes')
+  let hasNext = true
+  let nextToken: string | undefined
+  let remainingLimit: number | undefined = limit
+
+  const sandboxes: components['schemas']['ListedSandbox'][] = []
+
+  while (hasNext && (!limit || (remainingLimit && remainingLimit > 0))) {
+    const res = await client.api.GET('/v2/sandboxes', {
+      params: {
+        query: {
+          state,
+          metadata,
+          nextToken,
+          limit: remainingLimit,
+        },
+      },
+      signal,
+    })
+
+    handleE2BRequestError(res, 'Error getting running sandboxes')
+
+    nextToken = res.response.headers.get('x-next-token') || undefined
+    hasNext = !!nextToken
+    sandboxes.push(...res.data)
+    if (limit && remainingLimit) {
+      remainingLimit -= res.data.length
+    }
+  }
 
-  return res.data
+  return sandboxes
 }

packages/cli/src/commands/sandbox/logs.ts

@@ -104,7 +104,7 @@ export const logsCommand = new commander.Command('logs')
           console.log(`\nLogs for sandbox ${asBold(sandboxID)}:`)
         }
 
-        const isRunningPromise = listSandboxes()
+        const isRunningPromise = listSandboxes({ state: ['running'] })
           .then((r) => r.find((s) => s.sandboxID === getShortID(sandboxID)))
           .then((s) => !!s)
 

packages/js-sdk/src/api/index.ts

@@ -61,6 +61,12 @@ class ApiClient {
         }),
         ...config.headers,
       },
+      querySerializer: {
+        array: {
+          style: 'form',
+          explode: false,
+        },
+      },
     })
 
     if (config.logger) {

packages/js-sdk/src/connectionConfig.ts

@@ -1,7 +1,8 @@
 import { Logger } from './logs'
 import { getEnvVar, version } from './api/metadata'
 
-const REQUEST_TIMEOUT_MS = 60_000 // 60 seconds
+export const REQUEST_TIMEOUT_MS = 60_000 // 60 seconds
+export const DEFAULT_SANDBOX_TIMEOUT_MS = 300_000 // 300 seconds
 export const KEEPALIVE_PING_INTERVAL_SEC = 50 // 50 seconds
 
 export const KEEPALIVE_PING_HEADER = 'Keepalive-Ping-Interval'

packages/js-sdk/src/index.ts

@@ -33,7 +33,18 @@ export type {
   PtyOutput,
   CommandHandle,
 } from './sandbox/commands/commandHandle'
-export type { SandboxApiOpts, SandboxCreateOpts } from './sandbox/sandboxApi'
+export type {
+  SandboxInfo,
+  SandboxMetrics,
+  SandboxOpts,
+  SandboxApiOpts,
+  SandboxConnectOpts,
+  SandboxBetaCreateOpts,
+  SandboxMetricsOpts,
+  SandboxState,
+  SandboxListOpts,
+  SandboxPaginator,
+} from './sandbox/sandboxApi'
 
 export type {
   ProcessInfo,
@@ -44,8 +55,6 @@ export type {
   Pty,
 } from './sandbox/commands'
 
-export type { SandboxOpts } from './sandbox'
-export type { SandboxInfo, SandboxMetrics } from './sandbox/sandboxApi'
 export { Sandbox }
 import { Sandbox } from './sandbox'
 export default Sandbox