add remote bindings support to getPlatformProxy

Author: dario-piotrowicz

.changeset/better-sheep-reply.md

@@ -0,0 +1,5 @@
+---
+"wrangler": patch
+---
+
+add remote bindings support to `getPlatformProxy`

fixtures/get-platform-proxy-remote-bindings-node-test/index.test.js

@@ -0,0 +1,85 @@
+import { execSync } from "child_process";
+import { randomUUID } from "crypto";
+import assert from "node:assert";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import test, { after, before, describe } from "node:test";
+import { getPlatformProxy } from "wrangler";
+
+if (
+	!process.env.TEST_CLOUDFLARE_API_TOKEN ||
+	!process.env.TEST_CLOUDFLARE_ACCOUNT_ID
+) {
+	console.warn("No credentials provided, skipping test...");
+	process.exit(0);
+}
+
+const env = {
+	...process.env,
+	CLOUDFLARE_API_TOKEN: process.env.TEST_CLOUDFLARE_API_TOKEN,
+	CLOUDFLARE_ACCOUNT_ID: process.env.TEST_CLOUDFLARE_ACCOUNT_ID,
+};
+
+describe("getPlatformProxy remote-bindings", () => {
+	const remoteWorkerName = `get-platform-proxy-remote-worker-test-${randomUUID().split("-")[0]}`;
+
+	before(async () => {
+		const deployOut = execSync(
+			`pnpm dlx wrangler deploy remote-worker.js --name ${remoteWorkerName} --compatibility-date 2025-06-19`,
+			{
+				stdio: "pipe",
+				env,
+			}
+		);
+
+		if (
+			!new RegExp(`Deployed\\s+${remoteWorkerName}\\b`).test(`${deployOut}`)
+		) {
+			throw new Error(`Failed to deploy ${remoteWorkerName}`);
+		}
+
+		rmSync("./.tmp", { recursive: true, force: true });
+
+		mkdirSync("./.tmp");
+
+		writeFileSync(
+			"./.tmp/wrangler.json",
+			JSON.stringify(
+				{
+					name: "get-platform-proxy-fixture-test",
+					compatibility_date: "2025-06-01",
+					services: [
+						{
+							binding: "MY_WORKER",
+							service: remoteWorkerName,
+							experimental_remote: true,
+						},
+					],
+				},
+				undefined,
+				2
+			),
+			"utf8"
+		);
+	});
+
+	test("getPlatformProxy works with remote bindings", async () => {
+		const { env, dispose } = await getPlatformProxy({
+			configPath: "./.tmp/wrangler.json",
+			experimental: { remoteBindings: true },
+		});
+
+		try {
+			assert.strictEqual(
+				await (await env.MY_WORKER.fetch("http://example.com")).text(),
+				"Hello from a remote Worker part of the getPlatformProxy remote bindings fixture!"
+			);
+		} finally {
+			await dispose();
+		}
+	});
+
+	after(async () => {
+		execSync(`pnpm dlx wrangler delete --name ${remoteWorkerName}`, { env });
+		rmSync("./.tmp", { recursive: true, force: true });
+	});
+});

fixtures/get-platform-proxy-remote-bindings-node-test/package.json

@@ -0,0 +1,19 @@
+{
+	"name": "@fixture/get-platform-proxy-remote-bindings-node-test",
+	"private": true,
+	"description": "",
+	"license": "ISC",
+	"author": "",
+	"type": "module",
+	"scripts": {
+		"test:ci": "node --test"
+	},
+	"devDependencies": {
+		"@cloudflare/workers-tsconfig": "workspace:*",
+		"@cloudflare/workers-types": "^4.20250617.0",
+		"wrangler": "workspace:*"
+	},
+	"volta": {
+		"extends": "../../package.json"
+	}
+}

fixtures/get-platform-proxy-remote-bindings-node-test/remote-worker.js

@@ -0,0 +1,7 @@
+export default {
+	fetch() {
+		return new Response(
+			"Hello from a remote Worker part of the getPlatformProxy remote bindings fixture!"
+		);
+	},
+};

packages/wrangler/src/api/integrations/platform/index.ts

@@ -11,15 +11,16 @@ import {
 	buildMiniflareBindingOptions,
 	buildSitesOptions,
 } from "../../../dev/miniflare";
-import { run } from "../../../experimental-flags";
 import { logger } from "../../../logger";
 import { getSiteAssetPaths } from "../../../sites";
 import { dedent } from "../../../utils/dedent";
+import { maybeStartOrUpdateRemoteProxySession } from "../../remoteBindings";
 import { CacheStorage } from "./caches";
 import { ExecutionContext } from "./executionContext";
 import { getServiceBindings } from "./services";
 import type { AssetsOptions } from "../../../assets";
 import type { Config, RawConfig, RawEnvironment } from "../../../config";
+import type { RemoteProxySession } from "../../remoteBindings";
 import type { IncomingRequestCfProperties } from "@cloudflare/workers-types/experimental";
 import type {
 	MiniflareOptions,
@@ -58,6 +59,13 @@ export type GetPlatformProxyOptions = {
 	 * If `false` is specified no data is persisted on the filesystem.
 	 */
 	persist?: boolean | { path: string };
+	/**
+	 * Experimental flags (note: these can change at any time and are not version-controlled use at your own risk)
+	 */
+	experimental?: {
+		/** whether access to remove bindings should be enabled */
+		remoteBindings?: boolean;
+	};
 };
 
 /**
@@ -103,27 +111,37 @@ export async function getPlatformProxy<
 >(
 	options: GetPlatformProxyOptions = {}
 ): Promise<PlatformProxy<Env, CfProperties>> {
+	const experimentalRemoteBindings = !!options.experimental?.remoteBindings;
+
 	const env = options.environment;
 
 	const rawConfig = readConfig({
 		config: options.configPath,
 		env,
 	});
 
-	const miniflareOptions = await run(
-		{
-			MULTIWORKER: false,
-			RESOURCES_PROVISION: false,
-			// TODO: when possible remote bindings should be made available for getPlatformProxy
-			REMOTE_BINDINGS: false,
-		},
-		() => getMiniflareOptionsFromConfig(rawConfig, env, options)
+	let remoteProxySession: RemoteProxySession | undefined = undefined;
+	if (experimentalRemoteBindings && rawConfig.configPath) {
+		const a = await maybeStartOrUpdateRemoteProxySession(
+			rawConfig.configPath,
+			null
+		);
+		remoteProxySession = a?.session;
+	}
+
+	const miniflareOptions = await getMiniflareOptionsFromConfig(
+		rawConfig,
+		env,
+		options,
+		remoteProxySession?.remoteProxyConnectionString
 	);
 
 	const mf = new Miniflare({
 		script: "",
+		// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+		// @ts-ignore
 		modules: true,
-		...(miniflareOptions as Record<string, unknown>),
+		...miniflareOptions,
 	});
 
 	const bindings: Env = await mf.getBindings();
@@ -136,15 +154,19 @@ export async function getPlatformProxy<
 		cf: cf as CfProperties,
 		ctx: new ExecutionContext(),
 		caches: new CacheStorage(),
-		dispose: () => mf.dispose(),
+		dispose: async () => {
+			await remoteProxySession?.dispose();
+			await mf.dispose();
+		},
 	};
 }
 
 // this is only used by getPlatformProxy
 async function getMiniflareOptionsFromConfig(
 	rawConfig: Config,
 	env: string | undefined,
-	options: GetPlatformProxyOptions
+	options: GetPlatformProxyOptions,
+	remoteProxyConnectionString?: RemoteProxyConnectionString
 ): Promise<Partial<MiniflareOptions>> {
 	const bindings = getBindings(rawConfig, env, true, {});
 
@@ -183,8 +205,7 @@ async function getMiniflareOptionsFromConfig(
 			containers: undefined,
 			containerBuildId: undefined,
 		},
-		undefined,
-		false
+		remoteProxyConnectionString
 	);
 
 	const defaultPersistRoot = getMiniflarePersistRoot(options.persist);
@@ -320,8 +341,9 @@ export function unstable_getMiniflareWorkerOptions(
 			containers: undefined,
 			containerBuildId: undefined,
 		},
-		options?.remoteProxyConnectionString,
-		options?.remoteBindingsEnabled ?? false
+		options?.remoteBindingsEnabled
+			? options?.remoteProxyConnectionString
+			: undefined
 	);
 
 	// This function is currently only exported for the Workers Vitest pool.

packages/wrangler/src/api/startDevWorker/LocalRuntimeController.ts

@@ -234,8 +234,7 @@ export class LocalRuntimeController extends RuntimeController {
 					this.#log,
 					configBundle,
 					this.#proxyToUserWorkerAuthenticationSecret,
-					this.#remoteProxySessionData?.session?.remoteProxyConnectionString,
-					!!experimentalRemoteBindings
+					this.#remoteProxySessionData?.session?.remoteProxyConnectionString
 				);
 			options.liveReload = false; // TODO: set in buildMiniflareOptions once old code path is removed
 			if (this.#mf === undefined) {

packages/wrangler/src/api/startDevWorker/MultiworkerRuntimeController.ts

@@ -134,8 +134,7 @@ export class MultiworkerRuntimeController extends LocalRuntimeController {
 				await convertToConfigBundle(data),
 				this.#proxyToUserWorkerAuthenticationSecret,
 				this.#remoteProxySessionsData.get(data.config.name)?.session
-					?.remoteProxyConnectionString,
-				!!experimentalRemoteBindings
+					?.remoteProxyConnectionString
 			);
 
 			this.#options.set(data.config.name, {

packages/wrangler/src/dev/miniflare.ts

@@ -535,13 +535,14 @@ type MiniflareBindingsConfig = Pick<
 //  each plugin options schema and use those
 export function buildMiniflareBindingOptions(
 	config: MiniflareBindingsConfig,
-	remoteProxyConnectionString: RemoteProxyConnectionString | undefined,
-	remoteBindingsEnabled: boolean
+	remoteProxyConnectionString: RemoteProxyConnectionString | undefined
 ): {
 	bindingOptions: WorkerOptionsBindings;
 	internalObjects: CfDurableObject[];
 	externalWorkers: WorkerOptions[];
 } {
+	const remoteBindingsEnabled = !!remoteProxyConnectionString;
+
 	const bindings = config.bindings;
 
 	// Setup blob and module bindings
@@ -1289,8 +1290,7 @@ export async function buildMiniflareOptions(
 	log: Log,
 	config: Omit<ConfigBundle, "rules">,
 	proxyToUserWorkerAuthenticationSecret: UUID,
-	remoteProxyConnectionString: RemoteProxyConnectionString | undefined,
-	remoteBindingsEnabled: boolean
+	remoteProxyConnectionString: RemoteProxyConnectionString | undefined
 ): Promise<{
 	options: Options;
 	internalObjects: CfDurableObject[];
@@ -1305,6 +1305,7 @@ export async function buildMiniflareOptions(
 		}
 	}
 
+	const remoteBindingsEnabled = !!remoteProxyConnectionString;
 	if (!remoteBindingsEnabled) {
 		if (config.bindings.ai) {
 			if (!didWarnAiAccountUsage) {
@@ -1339,11 +1340,7 @@ export async function buildMiniflareOptions(
 
 	const { sourceOptions, entrypointNames } = await buildSourceOptions(config);
 	const { bindingOptions, internalObjects, externalWorkers } =
-		buildMiniflareBindingOptions(
-			config,
-			remoteProxyConnectionString,
-			remoteBindingsEnabled
-		);
+		buildMiniflareBindingOptions(config, remoteProxyConnectionString);
 	const sitesOptions = buildSitesOptions(config);
 	const defaultPersistRoot = getDefaultPersistRoot(config.localPersistencePath);
 	const assetOptions = buildAssetOptions(config);