Remove remote bindings flag (#10741)

* Remove remote bindings flag

* Fix tests

* fix tests

* fix tests

* fix getPlatformProxy() tests

* no more deletion

* Remove obsolete '--x-remote-bindings' flag

Updated the changeset to reflect the removal of the obsolete remote bindings flag.

* finalise removal

* Address comments

* fix rebase

* Throw 'remoteProxyConnectionString is missing' errors from the actual bindings API at runtime rather than at startup. This means that empty stubs of bindings like AI & Vectorize are available in Vitest to be mocked with vi.spyOn

* fix lint

Author: penalosa

.changeset/wicked-chairs-clean.md

@@ -0,0 +1,7 @@
+---
+"wrangler": minor
+"@cloudflare/vite-plugin": minor
+"@cloudflare/vitest-pool-workers": minor
+---
+
+Remove obsolete `--x-remote-bindings` flag

fixtures/get-platform-proxy-remote-bindings/tests/index.test.ts

@@ -14,50 +14,51 @@ const execOptions = {
 	encoding: "utf8",
 	env: { ...process.env, ...auth },
 } as const;
-const remoteWorkerName = `tmp-e2e-worker-test-remote-bindings-${randomUUID().split("-")[0]}`;
-const remoteStagingWorkerName = `tmp-e2e-staging-worker-test-remote-bindings-${randomUUID().split("-")[0]}`;
+const remoteWorkerName = `preserve-e2e-get-platform-proxy-remote`;
+const remoteStagingWorkerName = `preserve-e2e-get-platform-proxy-remote-staging`;
 const remoteKvName = `tmp-e2e-kv${Date.now()}-test-remote-bindings-${randomUUID().split("-")[0]}`;
 
 if (auth) {
 	describe("getPlatformProxy - remote bindings", { timeout: 50_000 }, () => {
 		let remoteKvId: string;
 
 		beforeAll(async () => {
-			const deployOut = execSync(
-				`pnpm wrangler deploy remote-worker.js --name ${remoteWorkerName} --compatibility-date 2025-06-19`,
-				execOptions
-			);
-			const deployedUrl = deployOut.match(
-				/(?<url>https:\/\/tmp-e2e-.+?\..+?\.workers\.dev)/
-			)?.groups?.url;
-			assert(deployedUrl, "Failed to find deployed worker URL");
+			const deployedUrl =
+				"https://preserve-e2e-get-platform-proxy-remote.devprod-testing7928.workers.dev/";
 
-			const stagingDeployOut = execSync(
-				`pnpm wrangler deploy remote-worker.staging.js --name ${remoteStagingWorkerName} --compatibility-date 2025-06-19`,
-				execOptions
-			);
-			const stagingDeployedUrl = stagingDeployOut.match(
-				/(?<url>https:\/\/tmp-e2e-.+?\..+?\.workers\.dev)/
-			)?.groups?.url;
-			assert(stagingDeployedUrl, "Failed to find deployed staging worker URL");
-
-			// Wait for the deployed workers to be available
-			await Promise.all([
-				vi.waitFor(
+			try {
+				assert((await fetch(deployedUrl)).status !== 404);
+			} catch (e) {
+				execSync(
+					`pnpm wrangler deploy remote-worker.js --name ${remoteWorkerName} --compatibility-date 2025-06-19`,
+					execOptions
+				);
+				await vi.waitFor(
 					async () => {
 						const response = await fetch(deployedUrl);
 						expect(response.status).toBe(200);
 					},
 					{ timeout: 5000, interval: 500 }
-				),
-				vi.waitFor(
+				);
+			}
+
+			const stagingDeployedUrl =
+				"https://preserve-e2e-get-platform-proxy-remote-staging.devprod-testing7928.workers.dev/";
+			try {
+				assert((await fetch(stagingDeployedUrl)).status !== 404);
+			} catch {
+				execSync(
+					`pnpm wrangler deploy remote-worker.staging.js --name ${remoteStagingWorkerName} --compatibility-date 2025-06-19`,
+					execOptions
+				);
+				await vi.waitFor(
 					async () => {
 						const response = await fetch(stagingDeployedUrl);
 						expect(response.status).toBe(200);
 					},
 					{ timeout: 5000, interval: 500 }
-				),
-			]);
+				);
+			}
 
 			const kvAddOut = execSync(
 				`pnpm wrangler kv namespace create ${remoteKvName}`,
@@ -79,31 +80,21 @@ if (auth) {
 		}, 35_000);
 
 		afterAll(() => {
-			try {
-				execSync(
-					`pnpm wrangler delete --name ${remoteWorkerName}`,
-					execOptions
-				);
-			} catch {}
-			try {
-				execSync(
-					`pnpm wrangler delete --name ${remoteStagingWorkerName}`,
-					execOptions
-				);
-			} catch {}
 			try {
 				execSync(
 					`pnpm wrangler kv namespace delete --namespace-id=${remoteKvId}`,
 					execOptions
 				);
 			} catch {}
 
-			rmSync("./.tmp", {
-				recursive: true,
-				force: true,
-				maxRetries: 10,
-				retryDelay: 100,
-			});
+			try {
+				rmSync("./.tmp", {
+					recursive: true,
+					force: true,
+					maxRetries: 10,
+					retryDelay: 100,
+				});
+			} catch {}
 		}, 35_000);
 
 		describe("normal usage", () => {
@@ -202,32 +193,6 @@ if (auth) {
 
 				await dispose();
 			});
-
-			test("getPlatformProxy does not work with remote bindings if the experimental remoteBindings flag is not turned on", async () => {
-				const { env, dispose } = await getPlatformProxy<{
-					MY_WORKER: Fetcher;
-					MY_KV: KVNamespace;
-				}>({
-					configPath: "./.tmp/normal-usage/wrangler.json",
-					experimental: {
-						remoteBindings: false,
-					},
-				});
-
-				const response = await fetchFromWorker(
-					env.MY_WORKER,
-					"Service Unavailable"
-				);
-				const workerText = await response?.text();
-				expect(workerText).toEqual(
-					`Couldn't find a local dev session for the "default" entrypoint of service "${remoteWorkerName}" to proxy to`
-				);
-
-				const kvValue = await env.MY_KV.get("test-key");
-				expect(kvValue).toEqual(null);
-
-				await dispose();
-			});
 		});
 
 		describe("account id taken from the wrangler config", () => {

fixtures/vitest-pool-workers-examples/ai-vectorize/test/index.spec.ts

@@ -19,7 +19,7 @@ describe("Tests that do hit the AI binding", () => {
 			const ctx = createExecutionContext();
 
 			// mock the AI run function by directly modifying `env`
-			env.AI.run = vi.fn().mockResolvedValue({
+			vi.spyOn(env.AI, "run").mockResolvedValue({
 				shape: [1, 2],
 				data: [[0, 0]],
 			});
@@ -37,16 +37,21 @@ describe("Tests that do hit the AI binding", () => {
 
 			// mock the vectorize upsert function by directly modifying `env`
 			const mockVectorizeStore: VectorizeVector[] = [];
-			env.VECTORIZE.upsert = vi.fn().mockImplementation(async (vectors) => {
+
+			vi.spyOn(env.VECTORIZE, "upsert").mockImplementation(async (vectors) => {
 				mockVectorizeStore.push(...vectors);
-				return { mutationId: "123" };
+				return {
+					mutationId: "123",
+					count: vectors.length,
+					ids: vectors.map((v) => v.id),
+				};
 			});
 
 			const response = await worker.fetch(request, env, ctx);
 
 			await waitOnExecutionContext(ctx);
 			expect(await response.text()).toMatchInlineSnapshot(
-				`"{"mutationId":"123"}"`
+				`"{"mutationId":"123","count":2,"ids":["123","456"]}"`
 			);
 			expect(mockVectorizeStore.map((v) => v.id)).toMatchInlineSnapshot(`
 				[

packages/miniflare/src/plugins/ai/index.ts

@@ -1,4 +1,3 @@
-import assert from "node:assert";
 import { z } from "zod";
 import {
 	getUserBindingServiceName,
@@ -10,7 +9,9 @@ import {
 
 const AISchema = z.object({
 	binding: z.string(),
-	remoteProxyConnectionString: z.custom<RemoteProxyConnectionString>(),
+	remoteProxyConnectionString: z
+		.custom<RemoteProxyConnectionString>()
+		.optional(),
 });
 
 export const AIOptionsSchema = z.object({
@@ -26,11 +27,6 @@ export const AI_PLUGIN: Plugin<typeof AIOptionsSchema> = {
 			return [];
 		}
 
-		assert(
-			options.ai.remoteProxyConnectionString,
-			"Workers AI only supports running remotely"
-		);
-
 		return [
 			{
 				name: options.ai.binding,

packages/miniflare/src/plugins/dispatch-namespace/index.ts

@@ -1,4 +1,3 @@
-import assert from "node:assert";
 import LOCAL_DISPATCH_NAMESPACE from "worker:dispatch-namespace/dispatch-namespace";
 import { z } from "zod";
 import { Worker_Binding } from "../../runtime";
@@ -13,7 +12,9 @@ export const DispatchNamespaceOptionsSchema = z.object({
 		.record(
 			z.object({
 				namespace: z.string(),
-				remoteProxyConnectionString: z.custom<RemoteProxyConnectionString>(),
+				remoteProxyConnectionString: z
+					.custom<RemoteProxyConnectionString>()
+					.optional(),
 			})
 		)
 		.optional(),
@@ -33,20 +34,19 @@ export const DISPATCH_NAMESPACE_PLUGIN: Plugin<
 		const bindings = Object.entries(
 			options.dispatchNamespaces
 		).map<Worker_Binding>(([name, config]) => {
-			assert(
-				config.remoteProxyConnectionString,
-				"Dispatch Namespace bindings only support running remotely"
-			);
-
 			return {
 				name,
 				wrapped: {
 					moduleName: `${DISPATCH_NAMESPACE_PLUGIN_NAME}:local-dispatch-namespace`,
 					innerBindings: [
-						{
-							name: "remoteProxyConnectionString",
-							text: config.remoteProxyConnectionString.href,
-						},
+						...(config.remoteProxyConnectionString?.href
+							? [
+									{
+										name: "remoteProxyConnectionString",
+										text: config.remoteProxyConnectionString.href,
+									},
+								]
+							: []),
 						{
 							name: "binding",
 							text: name,

packages/miniflare/src/plugins/media/index.ts

@@ -1,4 +1,3 @@
-import assert from "node:assert";
 import BINDING from "worker:media/binding";
 import { z } from "zod";
 import {
@@ -13,7 +12,9 @@ export const MEDIA_PLUGIN_NAME = "media";
 
 const MediaSchema = z.object({
 	binding: z.string(),
-	remoteProxyConnectionString: z.custom<RemoteProxyConnectionString>(),
+	remoteProxyConnectionString: z
+		.custom<RemoteProxyConnectionString>()
+		.optional(),
 });
 
 export const MediaOptionsSchema = z.object({
@@ -27,11 +28,6 @@ export const MEDIA_PLUGIN: Plugin<typeof MediaOptionsSchema> = {
 			return [];
 		}
 
-		assert(
-			options.media.remoteProxyConnectionString,
-			"Media only supports running remotely"
-		);
-
 		return [
 			{
 				name: options.media.binding,

packages/miniflare/src/plugins/mtls/index.ts

@@ -1,4 +1,3 @@
-import assert from "node:assert";
 import { z } from "zod";
 import {
 	getUserBindingServiceName,
@@ -10,7 +9,9 @@ import {
 
 const MtlsSchema = z.object({
 	certificate_id: z.string(),
-	remoteProxyConnectionString: z.custom<RemoteProxyConnectionString>(),
+	remoteProxyConnectionString: z
+		.custom<RemoteProxyConnectionString>()
+		.optional(),
 });
 
 export const MtlsOptionsSchema = z.object({
@@ -28,11 +29,6 @@ export const MTLS_PLUGIN: Plugin<typeof MtlsOptionsSchema> = {
 
 		return Object.entries(options.mtlsCertificates).map(
 			([name, { certificate_id, remoteProxyConnectionString }]) => {
-				assert(
-					remoteProxyConnectionString,
-					"MTLS only supports running remotely"
-				);
-
 				return {
 					name,
 
@@ -65,11 +61,6 @@ export const MTLS_PLUGIN: Plugin<typeof MtlsOptionsSchema> = {
 
 		return Object.entries(options.mtlsCertificates).map(
 			([name, { certificate_id, remoteProxyConnectionString }]) => {
-				assert(
-					remoteProxyConnectionString,
-					"MTLS only supports running remotely"
-				);
-
 				return {
 					name: getUserBindingServiceName(
 						MTLS_PLUGIN_NAME,

packages/miniflare/src/plugins/shared/constants.ts

@@ -74,7 +74,7 @@ export function objectEntryWorker(
 }
 
 export function remoteProxyClientWorker(
-	remoteProxyConnectionString: RemoteProxyConnectionString,
+	remoteProxyConnectionString: RemoteProxyConnectionString | undefined,
 	binding: string
 ) {
 	return {
@@ -86,10 +86,14 @@ export function remoteProxyClientWorker(
 			},
 		],
 		bindings: [
-			{
-				name: "remoteProxyConnectionString",
-				text: remoteProxyConnectionString.href,
-			},
+			...(remoteProxyConnectionString?.href
+				? [
+						{
+							name: "remoteProxyConnectionString",
+							text: remoteProxyConnectionString.href,
+						},
+					]
+				: []),
 			{
 				name: "binding",
 				text: binding,