fix(cli): add implicit limit to sandbox list (#1164)

<!-- CURSOR_SUMMARY -->
> [!NOTE]
> **Low Risk**
> Low risk: CLI-only behavior change that adds a default cap and minor
output messaging; main risk is surprising users who previously relied on
unlimited listing unless they pass `--limit 0`.
> 
> **Overview**
> Adds an **implicit default limit** to `sandbox list` (now defaults to
`1000`, with `--limit 0` meaning no limit) to avoid unbounded sandbox
listing.
> 
> Updates `listSandboxes` to return `{ sandboxes, hasMore }` and prints
a note in pretty output when results are truncated, while keeping API
pagination capped at `100` per page.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
3a29103. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: jakubno

.changeset/plenty-onions-do.md

@@ -0,0 +1,5 @@
+---
+'@e2b/cli': patch
+---
+
+Add implicit limit for sandbox list query to CLI

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

@@ -5,6 +5,9 @@ import { components, Sandbox, SandboxInfo } from 'e2b'
 import { ensureAPIKey } from 'src/api'
 import { parseMetadata } from './utils'
 
+const DEFAULT_LIMIT = 1000
+const PAGE_LIMIT = 100
+
 function getStateTitle(state?: components['schemas']['SandboxState'][]) {
   if (state?.length === 1) {
     if (state?.includes('running')) return 'Running sandboxes'
@@ -24,22 +27,29 @@ export const listCommand = new commander.Command('list')
   .option('-m, --metadata <metadata>', 'filter by metadata, eg. key1=value1')
   .option(
     '-l, --limit <limit>',
-    'limit the number of sandboxes returned',
+    `limit the number of sandboxes returned (default: ${DEFAULT_LIMIT}, 0 for no limit)`,
     (value) => parseInt(value)
   )
   .option('-f, --format <format>', 'output format, eg. json, pretty')
   .action(async (options) => {
     try {
       const state = options.state || ['running']
       const format = options.format || 'pretty'
-      const sandboxes = await listSandboxes({
-        limit: options.limit,
+      const limit =
+        options.limit === 0 ? undefined : (options.limit ?? DEFAULT_LIMIT)
+      const { sandboxes, hasMore } = await listSandboxes({
+        limit,
         state,
         metadataRaw: options.metadata,
       })
 
       if (format === 'pretty') {
         renderTable(sandboxes, state)
+        if (hasMore) {
+          console.log(
+            `Showing first ${limit} sandboxes. Use --limit to change.`
+          )
+        }
       } else if (format === 'json') {
         console.log(JSON.stringify(sandboxes, null, 2))
       } else {
@@ -130,23 +140,22 @@ type ListSandboxesOptions = {
   metadataRaw?: string
 }
 
+type ListSandboxesResult = {
+  sandboxes: SandboxInfo[]
+  hasMore: boolean
+}
+
 export async function listSandboxes({
   limit,
   state,
   metadataRaw,
-}: ListSandboxesOptions = {}): Promise<SandboxInfo[]> {
+}: ListSandboxesOptions = {}): Promise<ListSandboxesResult> {
   const apiKey = ensureAPIKey()
   const metadata = parseMetadata(metadataRaw)
 
   let pageLimit = limit
-  if (!limit || limit > 100) {
-    pageLimit = 100
-  }
-
-  let remainingLimit = limit
-  //backwards compatibility
-  if (limit === 0) {
-    remainingLimit = undefined
+  if (!limit || limit > PAGE_LIMIT) {
+    pageLimit = PAGE_LIMIT
   }
 
   const sandboxes: SandboxInfo[] = []
@@ -156,17 +165,14 @@ export async function listSandboxes({
     query: { state, metadata },
   })
 
-  while (
-    iterator.hasNext &&
-    (remainingLimit === undefined || remainingLimit > 0)
-  ) {
+  while (iterator.hasNext && (!limit || sandboxes.length < limit)) {
     const batch = await iterator.nextItems()
     sandboxes.push(...batch)
-
-    if (limit && remainingLimit) {
-      remainingLimit -= batch.length
-    }
   }
 
-  return sandboxes
+  return {
+    sandboxes: limit ? sandboxes.slice(0, limit) : sandboxes,
+    // We can't change the page size during iteration, so we may have to check if we have more sandboxes than the limit
+    hasMore: iterator.hasNext || (limit ? sandboxes.length > limit : false),
+  }
 }