@cloudflare/sandbox 0.8.5 → 0.8.6

package/dist/index.js

@@ -773,6 +773,44 @@ var BaseTransport = class {
 		}
 	}
 	/**
+	* Build a URL targeting the container's HTTP server.
+	*/
+	buildContainerUrl(path$1) {
+		if (this.config.stub) return `http://localhost:${this.config.port || 3e3}${path$1}`;
+		return `${this.config.baseUrl ?? `http://localhost:${this.config.port || 3e3}`}${path$1}`;
+	}
+	/**
+	* Single HTTP request to the container — no WebSocket, no 503 retry.
+	*/
+	httpFetch(path$1, options) {
+		const url = this.buildContainerUrl(path$1);
+		if (this.config.stub) return this.config.stub.containerFetch(url, options || {}, this.config.port);
+		return globalThis.fetch(url, options);
+	}
+	/**
+	* Streaming HTTP request to the container — no WebSocket, no 503 retry.
+	*/
+	async httpFetchStream(path$1, body, method = "POST", headers) {
+		const url = this.buildContainerUrl(path$1);
+		const init = {
+			method,
+			headers: body && method === "POST" ? {
+				...headers,
+				"Content-Type": "application/json"
+			} : headers,
+			body: body && method === "POST" ? JSON.stringify(body) : void 0
+		};
+		let response;
+		if (this.config.stub) response = await this.config.stub.containerFetch(url, init, this.config.port);
+		else response = await globalThis.fetch(url, init);
+		if (!response.ok) {
+			const errorBody = await response.text();
+			throw new Error(`HTTP error! status: ${response.status} - ${errorBody}`);
+		}
+		if (!response.body) throw new Error("No response body for streaming");
+		return response.body;
+	}
+	/**
 	* Sleep utility for retry delays
 	*/
 	sleep(ms) {
@@ -787,13 +825,12 @@ var BaseTransport = class {
 *
 * Uses standard fetch API for communication with the container.
 * HTTP is stateless, so connect/disconnect are no-ops.
+*
+* All HTTP request logic lives in {@link BaseTransport.httpFetch} and
+* {@link BaseTransport.httpFetchStream}; this subclass simply wires
+* the abstract `doFetch` / `fetchStream` hooks to those shared helpers.
 */
 var HttpTransport = class extends BaseTransport {
-	baseUrl;
-	constructor(config) {
-		super(config);
-		this.baseUrl = config.baseUrl ?? "http://localhost:3000";
-	}
 	getMode() {
 		return "http";
 	}
@@ -803,36 +840,10 @@ var HttpTransport = class extends BaseTransport {
 		return true;
 	}
 	async doFetch(path$1, options) {
-		const url = this.buildUrl(path$1);
-		if (this.config.stub) return this.config.stub.containerFetch(url, options || {}, this.config.port);
-		return globalThis.fetch(url, options);
+		return this.httpFetch(path$1, options);
 	}
 	async fetchStream(path$1, body, method = "POST", headers) {
-		const url = this.buildUrl(path$1);
-		const options = this.buildStreamOptions(body, method, headers);
-		let response;
-		if (this.config.stub) response = await this.config.stub.containerFetch(url, options, this.config.port);
-		else response = await globalThis.fetch(url, options);
-		if (!response.ok) {
-			const errorBody = await response.text();
-			throw new Error(`HTTP error! status: ${response.status} - ${errorBody}`);
-		}
-		if (!response.body) throw new Error("No response body for streaming");
-		return response.body;
-	}
-	buildUrl(path$1) {
-		if (this.config.stub) return `http://localhost:${this.config.port}${path$1}`;
-		return `${this.baseUrl}${path$1}`;
-	}
-	buildStreamOptions(body, method, headers) {
-		return {
-			method,
-			headers: body && method === "POST" ? {
-				...headers,
-				"Content-Type": "application/json"
-			} : headers,
-			body: body && method === "POST" ? JSON.stringify(body) : void 0
-		};
+		return this.httpFetchStream(path$1, body, method, headers);
 	}
 };
 
@@ -899,10 +910,30 @@ var WebSocketTransport = class extends BaseTransport {
 		this.cleanup();
 	}
 	/**
-	* Transport-specific fetch implementation
+	* Whether a WebSocket connection is currently being established.
+	*
+	* When true, awaiting `connectPromise` from a nested call would deadlock:
+	* the outer `connectViaFetch → stub.fetch → containerFetch →
+	* startAndWaitForPorts → blockConcurrencyWhile(onStart)` chain may call
+	* back into the SDK (e.g. `exec()`), which would await the same
+	* `connectPromise` that cannot resolve until `onStart` returns.
+	*
+	* Callers use this to fall back to a direct HTTP request, which is safe
+	* because `startAndWaitForPorts()` calls `setHealthy()` before invoking
+	* `onStart()`, so `containerFetch()` routes directly to the container.
+	*/
+	isWebSocketConnecting() {
+		return this.state === "connecting";
+	}
+	/**
+	* Transport-specific fetch implementation.
 	* Converts WebSocket response to standard Response object.
+	*
+	* Falls back to HTTP while a WebSocket connection is being established
+	* to avoid the re-entrant deadlock described in `isWebSocketConnecting()`.
 	*/
 	async doFetch(path$1, options) {
+		if (this.isWebSocketConnecting()) return this.httpFetch(path$1, options);
 		await this.connect();
 		const method = options?.method || "GET";
 		const body = this.parseBody(options?.body);
@@ -914,7 +945,9 @@ var WebSocketTransport = class extends BaseTransport {
 		});
 	}
 	/**
-	* Streaming fetch implementation
+	* Streaming fetch implementation.
+	*
+	* Delegates to `requestStream()`, which applies the re-entrancy guard.
 	*/
 	async fetchStream(path$1, body, method = "POST", headers) {
 		return this.requestStream(method, path$1, body, headers);
@@ -1054,7 +1087,12 @@ var WebSocketTransport = class extends BaseTransport {
 		});
 	}
 	/**
-	* Send a request and wait for response
+	* Send a request and wait for response.
+	*
+	* Only reachable from `doFetch()`, which already applies the re-entrancy
+	* guard via `isWebSocketConnecting()`. The `connect()` call here handles
+	* the case where the WebSocket was closed between `doFetch` and `request`
+	* (idle disconnect).
 	*/
 	async request(method, path$1, body, headers) {
 		await this.connect();
@@ -1105,7 +1143,7 @@ var WebSocketTransport = class extends BaseTransport {
 		});
 	}
 	/**
-	* Send a streaming request and return a ReadableStream
+	* Send a streaming request and return a ReadableStream.
 	*
 	* The stream will receive data chunks as they arrive over the WebSocket.
 	* Format matches SSE for compatibility with existing streaming code.
@@ -1117,8 +1155,12 @@ var WebSocketTransport = class extends BaseTransport {
 	* Uses an inactivity timeout instead of a total-duration timeout so that
 	* long-running streams (e.g. execStream from an agent) stay alive as long
 	* as data is flowing. The timer resets on every chunk or response message.
+	*
+	* Falls back to HTTP while a WebSocket connection is being established
+	* to avoid the re-entrant deadlock described in `isWebSocketConnecting()`.
 	*/
 	async requestStream(method, path$1, body, headers) {
+		if (this.isWebSocketConnecting()) return this.httpFetchStream(path$1, body, method, headers);
 		await this.connect();
 		this.clearIdleDisconnectTimer();
 		const id = generateRequestId();
@@ -3645,7 +3687,7 @@ function buildS3fsSource(bucket, prefix) {
 * This file is auto-updated by .github/changeset-version.ts during releases
 * DO NOT EDIT MANUALLY - Changes will be overwritten on the next version bump
 */
-const SDK_VERSION = "0.8.5";
+const SDK_VERSION = "0.8.6";
 
 //#endregion
 //#region src/sandbox.ts