@chrrxs/robloxstudio-mcp 2.15.2 → 2.16.0

package/studio-plugin/src/modules/EvalBridges.ts

@@ -21,30 +21,13 @@
 // ServerScriptService.LoadStringEnabled, so eval_server_runtime works even
 // when LoadStringEnabled=false (the default in fresh places).
 //
-// Lifecycle: the bridges live PERMANENTLY in the edit DM. Communication
-// installs them (ensureBridgesInstalled) when the plugin connects in edit,
-// and TestHandlers.startPlaytest force-refreshes them right before
-// ExecutePlayModeAsync. ExecutePlayModeAsync clones the DataModel into the
-// play DMs, so the scripts come along and run there. We keep them in the edit
-// DM after a playtest ends (rather than cleaning up) so that a playtest the
-// dev starts MANUALLY via the Studio Play button — not the MCP start_playtest
-// tool — also gets the bridges cloned in. This is intentionally a little
-// intrusive (two helper scripts visible in Explorer) in exchange for a
-// zero-roundtrip eval_*_runtime experience for devs working 1:1 with an agent.
-//
-// Archivable handling: ExecutePlayModeAsync's deep-clone SKIPS instances
-// with Archivable=false (verified empirically in v2.9.0 testing - bridges
-// never reached the play DMs because we'd set them to false). We now keep
-// Archivable=true so the clone works, and rely on cleanupBridges() to
-// remove the scripts from the edit DM when the test ends. The only failure
-// mode is the user saving DURING an active playtest, which would persist
-// the bridges to the .rbxl - that's a no-op next session because
-// installBridges() always calls cleanupBridges() first to clear stale
-// instances. The RemoteFunction/BindableFunction that the bridge scripts
-// CREATE at runtime stay Archivable=false (they're runtime-only and should
-// never appear in a save).
-
-import { ServerScriptService, StarterPlayer } from "@rbxts/services";
+// Lifecycle: bridge scripts are created only in running play DataModels.
+// The server plugin peer creates the Script in runtime ServerScriptService;
+// each client plugin peer creates its LocalScript in that client's
+// PlayerScripts. Nothing is installed into the edit DataModel anymore.
+// Runtime-created scripts disappear naturally when the playtest stops.
+
+import { Players, ReplicatedStorage, RunService, ServerScriptService, StarterPlayer } from "@rbxts/services";
 
 const ScriptEditorService = game.GetService("ScriptEditorService");
 
@@ -122,12 +105,10 @@ end
 `;
 
 // Stamp written onto each installed bridge Script so we can tell whether the
-// bridge currently in the DM was produced by THIS plugin build. It's a djb2
-// hash of the actual bridge source plus the plugin version, so ANY change to
-// the source (or a version bump) yields a new stamp — which makes
-// ensureBridgesInstalled() force a refresh on the next plugin load instead of
-// keeping a stale bridge that happens to still be present (e.g. one saved into
-// the .rbxl from an older build).
+// runtime bridge currently in the play DM was produced by THIS plugin build.
+// It's a djb2 hash of the actual bridge source plus the plugin version, so ANY
+// change to the source (or a version bump) yields a new stamp and triggers a
+// runtime refresh instead of keeping a stale bridge.
 const STAMP_ATTR = "__MCPBridgeStamp";
 
 function computeBridgeStamp(): string {
@@ -155,7 +136,12 @@ function setSource(scriptInst: Script | LocalScript, source: string): void {
 	}
 }
 
-function findBridges(): { server?: Instance; client?: Instance } {
+interface InstallResult {
+	installed: boolean;
+	error?: string;
+}
+
+function findLegacyEditBridges(): { server?: Instance; client?: Instance } {
 	const sps = getStarterPlayerScripts();
 	return {
 		server: ServerScriptService.FindFirstChild(SERVER_SCRIPT_NAME),
@@ -163,8 +149,16 @@ function findBridges(): { server?: Instance; client?: Instance } {
 	};
 }
 
-export function cleanupBridges(): void {
-	const { server, client } = findBridges();
+function destroyIfPresent(parent: Instance, name: string): void {
+	const existing = parent.FindFirstChild(name);
+	if (existing) {
+		pcall(() => existing.Destroy());
+	}
+}
+
+export function cleanupLegacyEditBridges(): void {
+	if (RunService.IsRunning()) return;
+	const { server, client } = findLegacyEditBridges();
 	if (server) {
 		pcall(() => server.Destroy());
 	}
@@ -173,52 +167,75 @@ export function cleanupBridges(): void {
 	}
 }
 
-// Idempotent variant: install only if the bridge scripts aren't already
-// present in the edit DM. Used to keep the bridges always available (so a
-// playtest the dev starts manually — not via the MCP start_playtest tool —
-// still clones them into the play DMs). Cheap no-op when already installed,
-// which avoids re-dirtying the place on every plugin reconnect.
-export function ensureBridgesInstalled(): { installed: boolean; error?: string } {
-	const { server, client } = findBridges();
-	if (server && client) {
-		// Both present — but only skip the reinstall if they were produced by
-		// THIS build. A mismatched/absent stamp means a stale bridge (older
-		// plugin, or one persisted in the saved place), so force a refresh.
-		const sStamp = server.GetAttribute(STAMP_ATTR);
-		const cStamp = client.GetAttribute(STAMP_ATTR);
-		if (sStamp === BRIDGE_STAMP && cStamp === BRIDGE_STAMP) {
-			return { installed: true };
-		}
+function serverRuntimeBridgeReady(): boolean {
+	const scriptInst = ServerScriptService.FindFirstChild(SERVER_SCRIPT_NAME);
+	const bindable = ServerScriptService.FindFirstChild(BRIDGE_NAMES.serverLocal);
+	return scriptInst !== undefined &&
+		scriptInst.GetAttribute(STAMP_ATTR) === BRIDGE_STAMP &&
+		bindable !== undefined &&
+		bindable.IsA("BindableFunction");
+}
+
+function getPlayerScripts(): Instance | undefined {
+	const localPlayer = Players.LocalPlayer;
+	if (!localPlayer) return undefined;
+	let playerScripts = localPlayer.FindFirstChild("PlayerScripts");
+	if (!playerScripts) {
+		playerScripts = localPlayer.WaitForChild("PlayerScripts", 5);
 	}
-	return installBridges();
+	return playerScripts;
+}
+
+function clientRuntimeBridgeReady(): boolean {
+	const playerScripts = getPlayerScripts();
+	if (!playerScripts) return false;
+	const scriptInst = playerScripts.FindFirstChild(CLIENT_SCRIPT_NAME);
+	const bindable = ReplicatedStorage.FindFirstChild(BRIDGE_NAMES.clientLocal);
+	return scriptInst !== undefined &&
+		scriptInst.GetAttribute(STAMP_ATTR) === BRIDGE_STAMP &&
+		bindable !== undefined &&
+		bindable.IsA("BindableFunction");
 }
 
-export function installBridges(): { installed: boolean; error?: string } {
-	// Defensive: clear any stale bridges from a prior unclean exit before
-	// inserting fresh. The injected script also self-cleans its
-	// ReplicatedStorage/ServerScriptService children at startup, but the
-	// containing Script/LocalScript objects themselves we must clear here.
-	cleanupBridges();
+function installServerRuntimeBridge(): InstallResult {
+	if (serverRuntimeBridgeReady()) return { installed: true };
 
 	const [ok, err] = pcall(() => {
+		destroyIfPresent(ServerScriptService, SERVER_SCRIPT_NAME);
+		destroyIfPresent(ServerScriptService, BRIDGE_NAMES.serverLocal);
+
 		const serverScript = new Instance("Script");
 		serverScript.Name = SERVER_SCRIPT_NAME;
-		// Archivable=true so ExecutePlayModeAsync's deep-clone includes the
-		// script. cleanupBridges() removes it from the edit DM when the
-		// playtest ends.
+		serverScript.Archivable = false;
 		setSource(serverScript, SERVER_BRIDGE_SOURCE);
 		serverScript.SetAttribute(STAMP_ATTR, BRIDGE_STAMP);
 		serverScript.Parent = ServerScriptService;
+	});
+
+	if (!ok) {
+		return { installed: false, error: tostring(err) };
+	}
+	return { installed: true };
+}
+
+function installClientRuntimeBridge(): InstallResult {
+	if (clientRuntimeBridgeReady()) return { installed: true };
+
+	const playerScripts = getPlayerScripts();
+	if (!playerScripts) {
+		return { installed: false, error: "Players.LocalPlayer.PlayerScripts not found - cannot install client eval bridge" };
+	}
+
+	const [ok, err] = pcall(() => {
+		destroyIfPresent(playerScripts, CLIENT_SCRIPT_NAME);
+		destroyIfPresent(ReplicatedStorage, BRIDGE_NAMES.clientLocal);
 
-		const sps = getStarterPlayerScripts();
-		if (!sps) {
-			error("StarterPlayer.StarterPlayerScripts not found - cannot install client eval bridge");
-		}
 		const clientScript = new Instance("LocalScript");
 		clientScript.Name = CLIENT_SCRIPT_NAME;
+		clientScript.Archivable = false;
 		setSource(clientScript, CLIENT_BRIDGE_SOURCE);
 		clientScript.SetAttribute(STAMP_ATTR, BRIDGE_STAMP);
-		clientScript.Parent = sps;
+		clientScript.Parent = playerScripts;
 	});
 
 	if (!ok) {
@@ -226,3 +243,13 @@ export function installBridges(): { installed: boolean; error?: string } {
 	}
 	return { installed: true };
 }
+
+export function ensureRuntimeBridgeInstalled(): InstallResult {
+	if (!RunService.IsRunning()) {
+		return { installed: false, error: "Eval bridges are installed only in running play DataModels" };
+	}
+	if (RunService.IsServer()) {
+		return installServerRuntimeBridge();
+	}
+	return installClientRuntimeBridge();
+}

package/studio-plugin/src/modules/handlers/EvalRuntimeHandlers.ts

@@ -1,5 +1,5 @@
 import { LogService, ReplicatedStorage, RunService, ServerScriptService } from "@rbxts/services";
-import { BRIDGE_NAMES } from "../EvalBridges";
+import { BRIDGE_NAMES, ensureRuntimeBridgeInstalled } from "../EvalBridges";
 import LuauExec from "../LuauExec";
 
 const PAYLOAD_INSTANCE_NAME = "__MCPEvalPayload";
@@ -15,6 +15,21 @@ interface WrapperResult {
 	output?: unknown;
 }
 
+function findBridge(config: { service: Instance; bridgeName: string }): BindableFunction | undefined {
+	const bridge = config.service.FindFirstChild(config.bridgeName);
+	return bridge && bridge.IsA("BindableFunction") ? bridge : undefined;
+}
+
+function waitForBridge(config: { service: Instance; bridgeName: string }, timeoutSec = 2): BindableFunction | undefined {
+	const deadline = tick() + timeoutSec;
+	let bridge = findBridge(config);
+	while (!bridge && tick() < deadline) {
+		task.wait(0.05);
+		bridge = findBridge(config);
+	}
+	return bridge;
+}
+
 function getBridgeConfig() {
 	if (!RunService.IsRunning()) {
 		return {
@@ -25,13 +40,13 @@ function getBridgeConfig() {
 		return {
 			service: ServerScriptService,
 			bridgeName: BRIDGE_NAMES.serverLocal,
-			missingError: "ServerEvalBridge not found. The bridge runs inside the play DM, so a playtest must be running. The bridge installs automatically (including for manually-started playtests); if a playtest is running and you still see this, reconnect the plugin in the edit window so the bridge reinstalls, then start the playtest again.",
+			missingError: "ServerEvalBridge not found. The bridge runs inside the play DM, so a playtest must be running. The bridge installs automatically in the runtime server peer, including for manually-started playtests.",
 		};
 	}
 	return {
 		service: ReplicatedStorage,
 		bridgeName: BRIDGE_NAMES.clientLocal,
-		missingError: "ClientEvalBridge not found. The bridge runs inside the play DM, so a playtest must be running. The bridge installs automatically (including for manually-started playtests); if a playtest is running and you still see this, reconnect the plugin in the edit window so the bridge reinstalls, then start the playtest again.",
+		missingError: "ClientEvalBridge not found. The bridge runs inside the play DM, so a playtest must be running. The bridge installs automatically in the runtime client peer, including for manually-started playtests.",
 	};
 }
 
@@ -44,9 +59,22 @@ function evalRuntime(requestData: Record<string, unknown>) {
 		return { bridge: "missing", error: config.error };
 	}
 
-	const bridge = config.service.FindFirstChild(config.bridgeName);
-	if (!bridge || !bridge.IsA("BindableFunction")) {
-		return { bridge: "missing", error: config.missingError };
+	let bridge = findBridge(config);
+	if (!bridge) {
+		const install = ensureRuntimeBridgeInstalled();
+		if (!install.installed) {
+			return {
+				bridge: "missing",
+				error: `${config.missingError} Runtime bridge install failed: ${install.error}`,
+			};
+		}
+		bridge = waitForBridge(config);
+	}
+	if (!bridge) {
+		return {
+			bridge: "missing",
+			error: `${config.missingError} Runtime bridge was installed but did not become ready.`,
+		};
 	}
 
 	const m = new Instance("ModuleScript");

package/studio-plugin/src/modules/handlers/TestHandlers.ts

@@ -1,5 +1,4 @@
 import { HttpService, LogService, Players, RunService } from "@rbxts/services";
-import { installBridges, ensureBridgesInstalled } from "../EvalBridges";
 import StopPlayMonitor from "../StopPlayMonitor";
 
 interface StudioTestServiceMultiplayer extends StudioTestService {
@@ -200,9 +199,8 @@ function startPlaytest(requestData: Record<string, unknown>) {
 			logConnection = undefined;
 		}
 		cleanupStopListener();
-		// Note: eval bridges are intentionally NOT cleaned up — they live
-		// permanently in the edit DM so manual playtests also get them. See
-		// EvalBridges.ts lifecycle comment.
+		// Runtime eval bridges are created by the play server/client plugin
+		// peers and disappear with the play DataModels.
 	}
 
 	if (testRunning) {
@@ -236,15 +234,6 @@ function startPlaytest(requestData: Record<string, unknown>) {
 		warn(`[MCP] Failed to inject stop listener: ${injErr}`);
 	}
 
-	// Force-refresh the game-VM eval bridges (ServerEvalBridge + ClientEvalBridge)
-	// right before cloning so the play DMs get the current source. They also
-	// live permanently in the edit DM (installed on connect) so manually-started
-	// playtests get them too; here we just ensure they're fresh.
-	const bridgeInstall = installBridges();
-	if (!bridgeInstall.installed) {
-		warn(`[MCP] Eval bridge install failed: ${bridgeInstall.error}`);
-	}
-
 	task.spawn(() => {
 		const [ok, result] = pcall(() => {
 			if (mode === "play") {
@@ -266,22 +255,12 @@ function startPlaytest(requestData: Record<string, unknown>) {
 		testRunning = false;
 
 		cleanupStopListener();
-		// Eval bridges persist in the edit DM (see EvalBridges.ts) — do not
-		// clean up here, so the next manual playtest still gets them.
-		ensureBridgesInstalled();
 	});
 
 	const response: Record<string, unknown> = {
 		success: true,
 		message: `Playtest started in ${mode} mode.`,
 	};
-	// Only mention eval bridges when they failed — when they're fine, the
-	// detail is noise. eval_server_runtime / eval_client_runtime will surface
-	// their own clear errors if the caller tries to use them after a failed
-	// install.
-	if (!bridgeInstall.installed) {
-		response.evalBridgesError = bridgeInstall.error;
-	}
 
 	return response;
 }
@@ -370,11 +349,6 @@ function multiplayerTestStart(requestData: Record<string, unknown>) {
 	const testArgs = requestData.testArgs !== undefined ? requestData.testArgs : {};
 	const testId = HttpService.GenerateGUID(false);
 
-	const bridgeInstall = installBridges();
-	if (!bridgeInstall.installed) {
-		warn(`[MCP] Eval bridge install failed: ${bridgeInstall.error}`);
-	}
-
 	multiplayerState = {
 		phase: "starting",
 		testId,
@@ -400,8 +374,6 @@ function multiplayerTestStart(requestData: Record<string, unknown>) {
 			multiplayerState.result = undefined;
 			multiplayerState.error = tostring(result);
 		}
-
-		ensureBridgesInstalled();
 	});
 
 	const response: Record<string, unknown> = {
@@ -412,9 +384,6 @@ function multiplayerTestStart(requestData: Record<string, unknown>) {
 		numPlayers,
 		testArgs,
 	};
-	if (!bridgeInstall.installed) {
-		response.evalBridgesError = bridgeInstall.error;
-	}
 	return response;
 }
 

package/studio-plugin/src/server/index.server.ts

@@ -2,6 +2,7 @@ import State from "../modules/State";
 import UI from "../modules/UI";
 import Communication from "../modules/Communication";
 import ClientBroker from "../modules/ClientBroker";
+import { cleanupLegacyEditBridges, ensureRuntimeBridgeInstalled } from "../modules/EvalBridges";
 import RuntimeLogBuffer from "../modules/RuntimeLogBuffer";
 import StopPlayMonitor from "../modules/StopPlayMonitor";
 import * as RenderMonitor from "../modules/RenderMonitor";
@@ -28,10 +29,24 @@ const elements = UI.getElements();
 const ICON_DISCONNECTED = "rbxassetid://__BUTTON_ICON_DISCONNECTED__";
 const ICON_CONNECTING = "rbxassetid://__BUTTON_ICON_CONNECTING__";
 const ICON_CONNECTED = "rbxassetid://__BUTTON_ICON_CONNECTED__";
+const TOOLBAR_REGISTRATION_DELAY_SECONDS = 1;
 
-const toolbar = plugin.CreateToolbar("__TOOLBAR_NAME__");
-const button = toolbar.CreateButton("__BUTTON_TITLE__", "__BUTTON_TOOLTIP__", ICON_DISCONNECTED);
-UI.setToolbarButton(button, { disconnected: ICON_DISCONNECTED, connecting: ICON_CONNECTING, connected: ICON_CONNECTED });
+let toolbarButtonRegistered = false;
+
+function registerToolbarButton() {
+	if (toolbarButtonRegistered) {
+		return;
+	}
+	toolbarButtonRegistered = true;
+
+	const toolbar = plugin.CreateToolbar("__TOOLBAR_NAME__");
+	const button = toolbar.CreateButton("__BUTTON_TITLE__", "__BUTTON_TOOLTIP__", ICON_DISCONNECTED);
+	UI.setToolbarButton(button, { disconnected: ICON_DISCONNECTED, connecting: ICON_CONNECTING, connected: ICON_CONNECTED });
+
+	button.Click.Connect(() => {
+		elements.screenGui.Enabled = !elements.screenGui.Enabled;
+	});
+}
 
 
 elements.connectButton.Activated.Connect(() => {
@@ -44,11 +59,6 @@ elements.connectButton.Activated.Connect(() => {
 });
 
 
-button.Click.Connect(() => {
-	elements.screenGui.Enabled = !elements.screenGui.Enabled;
-});
-
-
 plugin.Unloading.Connect(() => {
 	Communication.deactivateAll();
 });
@@ -56,6 +66,7 @@ plugin.Unloading.Connect(() => {
 
 UI.updateUIState();
 Communication.checkForUpdates();
+task.delay(TOOLBAR_REGISTRATION_DELAY_SECONDS, registerToolbarButton);
 
 // Auto-activate per peer. The boshyxd plugin only registers with MCP when the
 // user clicks Connect in its UI, but that UI is invisible in play DMs - so
@@ -63,6 +74,14 @@ Communication.checkForUpdates();
 // short delay so the UI/State have a chance to initialize first.
 task.delay(2, () => {
 	const role = ClientBroker.forkRole();
+	if (role === "edit") {
+		cleanupLegacyEditBridges();
+	} else {
+		const result = ensureRuntimeBridgeInstalled();
+		if (!result.installed) {
+			warn(`[MCPPlugin] Runtime eval bridge install failed: ${result.error}`);
+		}
+	}
 	if (role === "edit" || role === "server") {
 		pcall(() => {
 			const idx = State.getActiveTabIndex();