@chrrxs/robloxstudio-mcp 2.11.3 → 2.12.0

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

@@ -1,32 +1,40 @@
-// Cross-DM stop_playtest signaling via plugin:SetSetting.
+// Cross-DM stop_playtest signaling via plugin:SetSetting, scoped by
+// per-instance setting key so the same Studio process can host playtests
+// for multiple places without one place's stop_playtest yanking another's.
 //
 // `plugin:SetSetting` / `plugin:GetSetting` is a per-plugin persistent store
-// that's shared across every DataModel the plugin runs in (edit, play-server,
-// play-clients). We use it as a one-bit flag for "please call EndTest in the
-// play-server DM":
+// shared across every DataModel the plugin runs in (edit DMs, play-server
+// DMs, play-client DMs). For each connected place we use a dedicated key
+// "MCP_STOP_PLAY_<instanceId>" as a single-bit mailbox:
 //
-//   * The edit DM's stopPlaytest handler writes the flag (requestStop).
-//   * A monitor loop running inside the play-server DM polls the flag at 1Hz
-//     and calls StudioTestService:EndTest when it flips true, then resets it.
-//   * The edit DM then waits up to ~2.5s for the flag to be reset, which
-//     tells us a play-server actually consumed the request (no false-positive
-//     success when nothing was running).
+//   * The edit DM's stopPlaytest handler writes `true` into its own key
+//     (computed from its placeId / ServerStorage anon UUID).
+//   * Each play-server DM's monitor loop polls the key matching its own
+//     instanceId at 0.1Hz; on `true` it clears the key and calls
+//     StudioTestService:EndTest. Play-server DMs for other places never
+//     touch this key.
+//   * The edit DM waits up to ~8s for its key to be cleared, confirming a
+//     matching play-server actually consumed the request.
 //
-// Why this is simpler than the previous edit-proxy registration:
-//   * Doesn't depend on the MCP server tracking peer roles at all.
-//   * Survives MCP server restarts: monitor loop is local to the play-server
-//     plugin lifetime, not to any HTTP/registration state.
-//   * No need for cross-DM LogService.MessageOut reflection (which we verified
-//     does not work edit -> play-server anyway).
-//
-// Pattern mirrors the official Roblox Studio MCP
-// (Roblox/studio-rust-mcp-server, plugin/src/Utils/GameStopUtil.luau).
+// Earlier versions used a single shared boolean flag, which let any
+// play-server DM in the same Studio process consume any place's stop
+// request — silently yanking teammates' playtests. The per-key scoping
+// below is the fix.
+
+import { HttpService, ServerStorage } from "@rbxts/services";
 
 const StudioTestService = game.GetService("StudioTestService");
 
-const SETTING_KEY = "MCP_STOP_PLAY_SIGNAL";
-const POLL_INTERVAL_SEC = 1;
-const WAIT_FOR_CONSUMPTION_TIMEOUT_SEC = 2.5;
+const SETTING_KEY_PREFIX = "MCP_STOP_PLAY_";
+// Monitor checks the key at this cadence. 0.1s keeps worst-case detection
+// lag tight so the consumption-confirmation window doesn't have to absorb
+// polling jitter on top of EndTest's teardown time.
+const POLL_INTERVAL_SEC = 0.1;
+// Total time we wait for the matching play-server DM to consume the
+// signal. Must cover: monitor detection (<= POLL_INTERVAL_SEC) +
+// StudioTestService:EndTest teardown (several seconds on heavier places).
+// 8s is comfortable; the tighter poll above keeps real cases well under.
+const WAIT_FOR_CONSUMPTION_TIMEOUT_SEC = 8.0;
 const WAIT_POLL_SEC = 0.1;
 
 let pluginRef: Plugin | undefined;
@@ -35,20 +43,45 @@ function init(p: Plugin): void {
 	pluginRef = p;
 }
 
+// Mirror of Communication.computeInstanceId(). Duplicated here because
+// StopPlayMonitor runs in both edit and play-server DMs, and both must
+// agree on the place identifier (published places: placeId; unpublished:
+// UUID on ServerStorage's __MCPPlaceId attribute, travels with the .rbxl
+// into the play DM).
+function computeInstanceId(): string {
+	if (game.PlaceId !== 0) {
+		return `place:${tostring(game.PlaceId)}`;
+	}
+	const existing = ServerStorage.GetAttribute("__MCPPlaceId");
+	if (typeIs(existing, "string") && existing !== "") {
+		return `anon:${existing as string}`;
+	}
+	const fresh = HttpService.GenerateGUID(false);
+	pcall(() => ServerStorage.SetAttribute("__MCPPlaceId", fresh));
+	return `anon:${fresh}`;
+}
+
+function settingKey(instanceId: string): string {
+	return SETTING_KEY_PREFIX + instanceId;
+}
+
 function startMonitor(): void {
 	if (!pluginRef) {
 		warn("[MCP] StopPlayMonitor.startMonitor called before init; skipping");
 		return;
 	}
-	// Clear any stale value left from a prior session. If a real stop request
-	// is in-flight when this runs, the requesting edit DM will set it again
-	// within its 2.5s wait window.
-	pcall(() => pluginRef!.SetSetting(SETTING_KEY, false));
+	const myKey = settingKey(computeInstanceId());
+	// Clear any stale value left from a prior session. If a real stop
+	// request is in-flight when this runs, the requesting edit DM will
+	// write again within its consumption-confirmation window.
+	pcall(() => pluginRef!.SetSetting(myKey, false));
 	task.spawn(() => {
 		while (true) {
-			const [okGet, val] = pcall(() => pluginRef!.GetSetting(SETTING_KEY));
+			const [okGet, val] = pcall(() => pluginRef!.GetSetting(myKey));
 			if (okGet && val === true) {
-				pcall(() => pluginRef!.SetSetting(SETTING_KEY, false));
+				// Consume the flag first so requestStop's
+				// waitForConsumption returns success, then end the test.
+				pcall(() => pluginRef!.SetSetting(myKey, false));
 				pcall(() => StudioTestService.EndTest("stopped_by_mcp"));
 			}
 			task.wait(POLL_INTERVAL_SEC);
@@ -58,15 +91,17 @@ function startMonitor(): void {
 
 function requestStop(): boolean {
 	if (!pluginRef) return false;
-	const [ok] = pcall(() => pluginRef!.SetSetting(SETTING_KEY, true));
+	const myKey = settingKey(computeInstanceId());
+	const [ok] = pcall(() => pluginRef!.SetSetting(myKey, true));
 	return ok;
 }
 
 function waitForConsumption(): boolean {
 	if (!pluginRef) return false;
+	const myKey = settingKey(computeInstanceId());
 	const start = tick();
 	while (tick() - start < WAIT_FOR_CONSUMPTION_TIMEOUT_SEC) {
-		const [okGet, val] = pcall(() => pluginRef!.GetSetting(SETTING_KEY));
+		const [okGet, val] = pcall(() => pluginRef!.GetSetting(myKey));
 		if (okGet && val !== true) return true;
 		task.wait(WAIT_POLL_SEC);
 	}
@@ -75,7 +110,8 @@ function waitForConsumption(): boolean {
 
 function clearPending(): void {
 	if (!pluginRef) return;
-	pcall(() => pluginRef!.SetSetting(SETTING_KEY, false));
+	const myKey = settingKey(computeInstanceId());
+	pcall(() => pluginRef!.SetSetting(myKey, false));
 }
 
 export = {

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

@@ -1,6 +1,7 @@
 import { CollectionService } from "@rbxts/services";
 import Utils from "../Utils";
 import Recording from "../Recording";
+import LuauExec from "../LuauExec";
 
 const ChangeHistoryService = game.GetService("ChangeHistoryService");
 const Selection = game.GetService("Selection");
@@ -262,127 +263,11 @@ function getSelection(_requestData: Record<string, unknown>) {
 function executeLuau(requestData: Record<string, unknown>) {
 	const code = requestData.code as string;
 	if (!code || code === "") return { error: "Code is required" };
-
-	// Both execution paths (loadstring + ModuleScript-require fallback) run
-	// the SAME wrapped source so they return a uniform { ok, value, output }
-	// shape. Two problems the wrapper solves at once:
-	//
-	//   1. pcall(require, m) swallows the real error and returns Roblox's
-	//      generic "Requested module experienced an error while loading"
-	//      message. Wrapping user code in xpcall INSIDE the IIFE keeps the
-	//      ModuleScript itself returning successfully — the real error +
-	//      traceback live in the returned table.
-	//
-	//   2. The ModuleScript path runs in its own environment, so a plugin-
-	//      side getfenv print/warn override never reached user prints. A
-	//      lexical local print/warn inside the IIFE captures user prints
-	//      regardless of which path executes. We also call the real global
-	//      print/warn so messages still flow to Studio's output and
-	//      LogService.MessageOut (which powers get_runtime_logs).
-	//
-	// Prints from required sub-modules don't reach this capture (they have
-	// their own env) — those go through the runtime log buffer.
-	const wrapped = `return ((function()
-\tlocal __mcp_output = {}
-\tlocal __mcp_real_print = print
-\tlocal __mcp_real_warn = warn
-\tlocal print = function(...)
-\t\t__mcp_real_print(...)
-\t\tlocal args = {...}
-\t\tlocal parts = table.create(#args)
-\t\tfor i, a in ipairs(args) do parts[i] = tostring(a) end
-\t\ttable.insert(__mcp_output, table.concat(parts, "\\t"))
-\tend
-\tlocal warn = function(...)
-\t\t__mcp_real_warn(...)
-\t\tlocal args = {...}
-\t\tlocal parts = table.create(#args)
-\t\tfor i, a in ipairs(args) do parts[i] = tostring(a) end
-\t\ttable.insert(__mcp_output, "[warn] " .. table.concat(parts, "\\t"))
-\tend
-\tlocal function __mcp_run()
-${code}
-\tend
-\tlocal ok, errOrValue = xpcall(__mcp_run, debug.traceback)
-\treturn { ok = ok, value = errOrValue, output = __mcp_output }
-end)())`;
-
-	interface WrapperResult {
-		ok?: boolean;
-		value?: unknown;
-		output?: defined;
-	}
-
-	const runViaModuleScript = (): WrapperResult => {
-		const m = new Instance("ModuleScript");
-		m.Name = "__MCPExecLuauPayload";
-		const [okSet, setErr] = pcall(() => {
-			(m as unknown as { Source: string }).Source = wrapped;
-		});
-		if (!okSet) {
-			m.Destroy();
-			error(`ModuleScript Source set failed: ${tostring(setErr)}`);
-		}
-		m.Parent = game.GetService("Workspace");
-		const [okReq, reqResult] = pcall(() => require(m));
-		m.Destroy();
-		if (!okReq) error(tostring(reqResult));
-		return reqResult as unknown as WrapperResult;
-	};
-
-	const isLoadstringUnavailable = (err: unknown): boolean => {
-		const errStr = tostring(err);
-		const [matchStart] = string.find(errStr, "not available", 1, true);
-		return matchStart !== undefined;
-	};
-
-	let [success, result] = pcall(() => {
-		const [fn, compileError] = loadstring(wrapped);
-		if (!fn) {
-			if (isLoadstringUnavailable(compileError)) {
-				return runViaModuleScript();
-			}
-			error(`Compile error: ${compileError}`);
-		}
-		return fn() as unknown as WrapperResult;
-	});
-
-	// loadstring throws (not returns nil) in some plugin contexts when
-	// LoadStringEnabled=false. Catch that as a second-chance fallback.
-	if (!success && isLoadstringUnavailable(result)) {
-		[success, result] = pcall(runViaModuleScript);
-	}
-
-	if (!success) {
-		// Outer pcall failed - the wrapper itself didn't even run (e.g. compile
-		// error in the user code, or ModuleScript setup error). 'result' is the
-		// raw error string from pcall.
-		return {
-			success: false,
-			error: tostring(result),
-			output: [],
-			message: "Code execution failed",
-		};
-	}
-
-	// Wrapper executed - unpack { ok, value, output }.
-	const r = result as unknown as WrapperResult;
-	const capturedOutput = r.output as unknown as string[] | undefined;
-	const output = capturedOutput !== undefined ? capturedOutput : ([] as string[]);
-	if (r.ok === true) {
-		return {
-			success: true,
-			returnValue: r.value !== undefined ? tostring(r.value) : undefined,
-			output,
-			message: "Code executed successfully",
-		};
-	}
-	return {
-		success: false,
-		error: r.value !== undefined ? tostring(r.value) : "(unknown error)",
-		output,
-		message: "Code execution failed",
-	};
+	// All wrapping, print/warn capture, loadstring fallback, JSON-encoding
+	// of table returns, and parse-error recovery live in LuauExec so the
+	// edit/server (this handler) and the play-client (ClientBroker) take
+	// the same code path and produce identical output shapes.
+	return LuauExec.execute(code);
 }
 
 function undo(_requestData: Record<string, unknown>) {

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

@@ -235,9 +235,27 @@ function stopPlaytest(_requestData: Record<string, unknown>) {
 		return { error: "Plugin not ready. Try again in a moment." };
 	}
 	if (!StopPlayMonitor.waitForConsumption()) {
-		// Clean up the pending flag so a future playtest's monitor doesn't fire
-		// EndTest on its own startup against a stale signal.
+		// Two distinct failure modes collapse here, distinguished by whether
+		// THIS edit DM has a playtest tracked:
+		//
+		// - testRunning=false: no playtest was running from this edit DM
+		//   (true negative). Return "no active playtest" — fine to retry only
+		//   after actually starting a playtest.
+		// - testRunning=true: a playtest IS running but the cross-DM signal
+		//   didn't propagate within the consumption timeout (false negative
+		//   from the caller's perspective — playtest may actually have ended).
+		//   Tell the caller it's a timing issue and they can retry.
+		//
+		// Either way clean up the pending flag so a future playtest's monitor
+		// doesn't fire EndTest on startup against a stale signal.
 		StopPlayMonitor.clearPending();
+		if (testRunning) {
+			return {
+				error:
+					"Playtest stop signal sent but consumption confirmation timed out. " +
+					"The playtest may have ended anyway; check get_connected_instances.",
+			};
+		}
 		return { error: "No active playtest to stop." };
 	}
 	// Flag was consumed (EndTest called). ExecutePlayModeAsync in our

package/studio-plugin/src/types/index.d.ts

@@ -33,14 +33,17 @@ export interface PollResponse {
 	request?: RequestPayload;
 	requestId?: string;
 	// Server signals knownInstance=false when its in-memory instances map
-	// doesn't contain our instanceId (typically after an MCP process restart).
-	// The plugin re-issues /ready when it sees this.
+	// doesn't contain our pluginSessionId (typically after an MCP process
+	// restart). The plugin re-issues /ready when it sees this.
 	knownInstance?: boolean;
 }
 
 export interface ReadyResponse {
 	success: boolean;
 	assignedRole?: string;
+	instanceId?: string;
+	error?: string;
+	message?: string;
 }
 
 declare global {