Skip to content

armgit / E2B

Public Imported from GitHub
0

Open-source, secure environment with real-world tools for enterprise-grade agents.

enable http2 for js sdk envd rpc/api traffic (#1311)

Matt Brockmanf7a97e698ea4
diff --git a/.changeset/empty-fans-wave.md b/.changeset/empty-fans-wave.md
new file mode 100644
index 000000000..e71bfd79c
--- /dev/null
+++ b/.changeset/empty-fans-wave.md
@@ -0,0 +1,5 @@
+---
+'e2b': patch
+---
+
+Use HTTP/2 for JS SDK envd/api requests and require Node.js 20.18.1 or newer.
diff --git a/packages/js-sdk/package.json b/packages/js-sdk/package.json
index 96a903812..ed3e45812 100644
--- a/packages/js-sdk/package.json
+++ b/packages/js-sdk/package.json
@@ -96,10 +96,11 @@
"glob": "^11.1.0",
"openapi-fetch": "^0.14.1",
"platform": "^1.3.6",
- "tar": "^7.5.11"
+ "tar": "^7.5.11",
+ "undici": "^7.25.0"
},
"engines": {
- "node": ">=20"
+ "node": ">=20.18.1"
},
"browserslist": [
"defaults"
diff --git a/packages/js-sdk/src/envd/http2.ts b/packages/js-sdk/src/envd/http2.ts
new file mode 100644
index 000000000..ff5816e2c
--- /dev/null
+++ b/packages/js-sdk/src/envd/http2.ts
@@ -0,0 +1,103 @@
+import { dynamicRequire, runtime } from '../utils'
+
+type Undici = typeof import('undici')
+type UndiciDispatcher = InstanceType<Undici['Agent']>
+type UndiciRequestInit = RequestInit & {
+ dispatcher: UndiciDispatcher
+ duplex?: 'half'
+}
+type EnvdFetchOptions = {
+ connectionLimit?: number
+}
+
+let envdFetch: typeof fetch | undefined
+let envdRpcFetch: typeof fetch | undefined
+
+export function createEnvdFetchForRuntime(
+ currentRuntime = runtime,
+ options: EnvdFetchOptions = { connectionLimit: 1 }
+): typeof fetch {
+ if (currentRuntime !== 'node') {
+ return fetch
+ }
+
+ const { Agent, fetch: undiciFetch } = dynamicRequire<Undici>('undici')
+ const dispatcherOptions: { allowH2: true; connections?: number } = {
+ allowH2: true,
+ }
+ if (options.connectionLimit !== undefined) {
+ dispatcherOptions.connections = options.connectionLimit
+ }
+ const dispatcher = new Agent(dispatcherOptions)
+ const fetchWithDispatcher = undiciFetch as unknown as (
+ input: RequestInfo | URL,
+ init?: UndiciRequestInit
+ ) => Promise<Response>
+
+ return ((input, init) => {
+ const request = toRequestInput(input, init)
+
+ return fetchWithDispatcher(request.input, {
+ ...request.init,
+ dispatcher,
+ })
+ }) as typeof fetch
+}
+
+export function createEnvdFetch(): typeof fetch {
+ if (envdFetch) {
+ return envdFetch
+ }
+
+ // Keep one origin connection for short envd REST calls. If ALPN falls back
+ // to h1, this favors connection pressure over per-sandbox throughput.
+ envdFetch = createEnvdFetchForRuntime(runtime)
+
+ return envdFetch
+}
+
+export function createEnvdRpcFetch(): typeof fetch {
+ if (envdRpcFetch) {
+ return envdRpcFetch
+ }
+
+ // RPC streams can stay open while follow-up RPCs run against the same
+ // sandbox, so they cannot share the REST client's single-connection cap.
+ envdRpcFetch = createEnvdFetchForRuntime(runtime, {})
+
+ return envdRpcFetch
+}
+
+function toRequestInput(
+ input: RequestInfo | URL,
+ init?: RequestInit
+): { input: RequestInfo | URL; init?: RequestInit & { duplex?: 'half' } } {
+ if (!(input instanceof Request)) {
+ return { input, init }
+ }
+
+ const requestInit: RequestInit & { duplex?: 'half' } = {
+ body: input.body,
+ cache: input.cache,
+ credentials: input.credentials,
+ headers: input.headers,
+ integrity: input.integrity,
+ keepalive: input.keepalive,
+ method: input.method,
+ mode: input.mode,
+ redirect: input.redirect,
+ referrer: input.referrer,
+ referrerPolicy: input.referrerPolicy,
+ signal: input.signal,
+ ...init,
+ }
+
+ if (requestInit.body) {
+ requestInit.duplex = 'half'
+ }
+
+ return {
+ input: input.url,
+ init: requestInit,
+ }
+}
diff --git a/packages/js-sdk/src/sandbox/index.ts b/packages/js-sdk/src/sandbox/index.ts
index c223c6b6f..0b2115dec 100644
--- a/packages/js-sdk/src/sandbox/index.ts
+++ b/packages/js-sdk/src/sandbox/index.ts
@@ -8,6 +8,7 @@ import {
Username,
} from '../connectionConfig'
import { EnvdApiClient, handleEnvdApiError } from '../envd/api'
+import { createEnvdFetch, createEnvdRpcFetch } from '../envd/http2'
import { createRpcLogger } from '../logs'
import { Commands, Pty } from './commands'
import { Filesystem } from './filesystem'
@@ -150,6 +151,8 @@ export class Sandbox extends SandboxApi {
'E2b-Sandbox-Id': this.sandboxId,
'E2b-Sandbox-Port': this.envdPort.toString(),
}
+ const envdFetch = createEnvdFetch()
+ const envdRpcFetch = createEnvdRpcFetch()
const rpcTransport = createConnectTransport({
baseUrl: this.envdApiUrl,
@@ -179,7 +182,7 @@ export class Sandbox extends SandboxApi {
redirect: 'follow',
}
- return fetch(url, options)
+ return envdRpcFetch(url, options)
},
})
@@ -195,6 +198,7 @@ export class Sandbox extends SandboxApi {
? { 'X-Access-Token': this.envdAccessToken }
: {}),
},
+ fetch: (request) => envdFetch(request),
},
{
version: opts.envdVersion,
diff --git a/packages/js-sdk/tests/envd/http2.test.ts b/packages/js-sdk/tests/envd/http2.test.ts
new file mode 100644
index 000000000..b550f9e18
--- /dev/null
+++ b/packages/js-sdk/tests/envd/http2.test.ts
@@ -0,0 +1,101 @@
+import { afterEach, expect, test, vi } from 'vitest'
+
+afterEach(() => {
+ vi.restoreAllMocks()
+ vi.resetModules()
+ vi.doUnmock('../../src/utils')
+})
+
+test('uses undici with HTTP/2 enabled in Node', async () => {
+ const agents: Array<{ allowH2?: boolean; connections?: number }> = []
+ const requests: Array<{ init?: RequestInit & { dispatcher?: unknown } }> = []
+
+ class Agent {
+ constructor(options: { allowH2?: boolean; connections?: number }) {
+ agents.push(options)
+ }
+ }
+
+ const undiciFetch = vi.fn((input, init) => {
+ requests.push({ init })
+ return Promise.resolve(new Response('ok'))
+ })
+
+ vi.doMock('../../src/utils', () => ({
+ dynamicRequire: () => ({ Agent, fetch: undiciFetch }),
+ runtime: 'node',
+ }))
+ const { createEnvdFetchForRuntime } = await import('../../src/envd/http2')
+
+ const fetcher = createEnvdFetchForRuntime('node')
+ const res = await fetcher('https://example.com/status')
+
+ expect(await res.text()).toBe('ok')
+ expect(agents).toEqual([{ allowH2: true, connections: 1 }])
+ expect(requests[0].init?.dispatcher).toBeInstanceOf(Agent)
+})
+
+test('passes Request objects to undici as URL plus init', async () => {
+ const requests: Array<{ input: RequestInfo | URL; init?: RequestInit }> = []
+
+ class Agent {}
+
+ const undiciFetch = vi.fn((input, init) => {
+ requests.push({ input, init })
+ return Promise.resolve(new Response('ok'))
+ })
+
+ vi.doMock('../../src/utils', () => ({
+ dynamicRequire: () => ({ Agent, fetch: undiciFetch }),
+ runtime: 'node',
+ }))
+ const { createEnvdFetchForRuntime } = await import('../../src/envd/http2')
+
+ const fetcher = createEnvdFetchForRuntime('node')
+ const body = JSON.stringify({ ok: true })
+ await fetcher(
+ new Request('https://example.com/rpc', {
+ body,
+ headers: { 'content-type': 'application/json' },
+ method: 'POST',
+ })
+ )
+
+ expect(requests[0].input).toBe('https://example.com/rpc')
+ expect(requests[0].init?.method).toBe('POST')
+ expect(requests[0].init?.headers).toBeInstanceOf(Headers)
+ expect(requests[0].init?.body).toBeInstanceOf(ReadableStream)
+})
+
+test('can create an uncapped dispatcher for RPC streams', async () => {
+ const agents: Array<{ allowH2?: boolean; connections?: number }> = []
+
+ class Agent {
+ constructor(options: { allowH2?: boolean; connections?: number }) {
+ agents.push(options)
+ }
+ }
+
+ const undiciFetch = vi.fn(() => Promise.resolve(new Response('ok')))
+
+ vi.doMock('../../src/utils', () => ({
+ dynamicRequire: () => ({ Agent, fetch: undiciFetch }),
+ runtime: 'node',
+ }))
+ const { createEnvdFetchForRuntime } = await import('../../src/envd/http2')
+
+ const fetcher = createEnvdFetchForRuntime('node', {})
+ await fetcher('https://example.com/rpc')
+
+ expect(agents).toEqual([{ allowH2: true }])
+})
+
+test('uses global fetch outside Node', async () => {
+ const fallbackFetch = vi.fn() as unknown as typeof fetch
+ vi.stubGlobal('fetch', fallbackFetch)
+
+ const { createEnvdFetchForRuntime } = await import('../../src/envd/http2')
+
+ expect(createEnvdFetchForRuntime('browser')).toBe(fallbackFetch)
+ expect(createEnvdFetchForRuntime('vercel-edge')).toBe(fallbackFetch)
+})
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index e3485c7a4..bab886b33 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -178,6 +178,9 @@ importers:
tar:
specifier: ^7.5.11
version: 7.5.12
+ undici:
+ specifier: ^7.25.0
+ version: 7.25.0
devDependencies:
'@testing-library/react':
specifier: ^16.2.0
@@ -3437,6 +3440,10 @@ packages:
resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==}
+ resolution: {integrity: sha512-xXnp4kTyor2Zq+J1FfPI6Eq3ew5h6Vl0F/8d9XU5zZQf1tX9s2Su1/3PiMmUANFULpmksxkClamIZcaUqryHsQ==}
+ engines: {node: '>=20.18.1'}
+
resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==}
engines: {node: '>= 4.0.0'}
@@ -7130,6 +7137,8 @@ snapshots:
+