@chrrxs/robloxstudio-mcp 2.11.1 → 2.11.3

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

@@ -0,0 +1,87 @@
+// Cross-DM stop_playtest signaling via plugin:SetSetting.
+//
+// `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":
+//
+//   * 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).
+//
+// 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).
+
+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 WAIT_POLL_SEC = 0.1;
+
+let pluginRef: Plugin | undefined;
+
+function init(p: Plugin): void {
+	pluginRef = p;
+}
+
+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));
+	task.spawn(() => {
+		while (true) {
+			const [okGet, val] = pcall(() => pluginRef!.GetSetting(SETTING_KEY));
+			if (okGet && val === true) {
+				pcall(() => pluginRef!.SetSetting(SETTING_KEY, false));
+				pcall(() => StudioTestService.EndTest("stopped_by_mcp"));
+			}
+			task.wait(POLL_INTERVAL_SEC);
+		}
+	});
+}
+
+function requestStop(): boolean {
+	if (!pluginRef) return false;
+	const [ok] = pcall(() => pluginRef!.SetSetting(SETTING_KEY, true));
+	return ok;
+}
+
+function waitForConsumption(): boolean {
+	if (!pluginRef) return false;
+	const start = tick();
+	while (tick() - start < WAIT_FOR_CONSUMPTION_TIMEOUT_SEC) {
+		const [okGet, val] = pcall(() => pluginRef!.GetSetting(SETTING_KEY));
+		if (okGet && val !== true) return true;
+		task.wait(WAIT_POLL_SEC);
+	}
+	return false;
+}
+
+function clearPending(): void {
+	if (!pluginRef) return;
+	pcall(() => pluginRef!.SetSetting(SETTING_KEY, false));
+}
+
+export = {
+	init,
+	startMonitor,
+	requestStop,
+	waitForConsumption,
+	clearPending,
+};

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

@@ -263,48 +263,59 @@ function executeLuau(requestData: Record<string, unknown>) {
 	const code = requestData.code as string;
 	if (!code || code === "") return { error: "Code is required" };
 
-	const output: string[] = [];
-	const oldPrint = print;
-	const oldWarn = warn;
-
-	const env = getfenv(0) as unknown as Record<string, unknown>;
-	env["print"] = (...args: defined[]) => {
-		const parts: string[] = [];
-		for (const a of args) parts.push(tostring(a));
-		output.push(parts.join("\t"));
-		oldPrint(...(args as [defined, ...defined[]]));
-	};
-	env["warn"] = (...args: defined[]) => {
-		const parts: string[] = [];
-		for (const a of args) parts.push(tostring(a));
-		output.push(`[warn] ${parts.join("\t")}`);
-		oldWarn(...(args as [defined, ...defined[]]));
-	};
+	// 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;
+	}
 
-	// Try loadstring first (preserves print/warn interception). When
-	// ServerScriptService.LoadStringEnabled=false AND the plugin runs in a
-	// peer where the engine respects that gate (notably the play-server DM
-	// in some Studio configurations), loadstring either returns nil with a
-	// "loadstring() is not available" message OR throws that same message
-	// directly. Both paths must trigger the ModuleScript + require
-	// fallback. The fallback can't intercept print/warn since the
-	// ModuleScript runs in its own environment, so the output array stays
-	// empty in that branch - the playtest log buffer already captures
-	// prints separately via LogService.MessageOut.
-	const runViaModuleScript = () => {
+	const runViaModuleScript = (): WrapperResult => {
 		const m = new Instance("ModuleScript");
 		m.Name = "__MCPExecLuauPayload";
-		// Wrap user code in an IIFE so require() always gets exactly one
-		// return value. Without this, code like `print("x")` errors with
-		// "Module code did not return exactly one value" because top-level
-		// ModuleScripts must return exactly one value.
-		//
-		// The DOUBLE parens around the call are load-bearing: in Luau,
-		// `return f()` propagates whatever multi-value tuple f returns,
-		// including zero values. Outer parens adjust the call to exactly
-		// one value (the first, or nil). So `return ((f)())` always
-		// returns exactly one value, regardless of what f does.
-		const wrapped = `return ((function()\n${code}\nend)())`;
 		const [okSet, setErr] = pcall(() => {
 			(m as unknown as { Source: string }).Source = wrapped;
 		});
@@ -316,7 +327,7 @@ function executeLuau(requestData: Record<string, unknown>) {
 		const [okReq, reqResult] = pcall(() => require(m));
 		m.Destroy();
 		if (!okReq) error(tostring(reqResult));
-		return reqResult;
+		return reqResult as unknown as WrapperResult;
 	};
 
 	const isLoadstringUnavailable = (err: unknown): boolean => {
@@ -326,40 +337,52 @@ function executeLuau(requestData: Record<string, unknown>) {
 	};
 
 	let [success, result] = pcall(() => {
-		const [fn, compileError] = loadstring(code);
+		const [fn, compileError] = loadstring(wrapped);
 		if (!fn) {
 			if (isLoadstringUnavailable(compileError)) {
 				return runViaModuleScript();
 			}
 			error(`Compile error: ${compileError}`);
 		}
-		return fn();
+		return fn() as unknown as WrapperResult;
 	});
 
 	// loadstring throws (not returns nil) in some plugin contexts when
-	// LoadStringEnabled=false. Catch that here as a second-chance fallback.
+	// LoadStringEnabled=false. Catch that as a second-chance fallback.
 	if (!success && isLoadstringUnavailable(result)) {
 		[success, result] = pcall(runViaModuleScript);
 	}
 
-	env["print"] = oldPrint;
-	env["warn"] = oldWarn;
+	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",
+		};
+	}
 
-	if (success) {
+	// 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: result !== undefined ? tostring(result) : undefined,
+			returnValue: r.value !== undefined ? tostring(r.value) : undefined,
 			output,
 			message: "Code executed successfully",
 		};
-	} else {
-		return {
-			success: false,
-			error: tostring(result),
-			output,
-			message: "Code execution failed",
-		};
 	}
+	return {
+		success: false,
+		error: r.value !== undefined ? tostring(r.value) : "(unknown error)",
+		output,
+		message: "Code execution failed",
+	};
 }
 
 function undo(_requestData: Record<string, unknown>) {

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

@@ -1,11 +1,15 @@
-import { HttpService, LogService } from "@rbxts/services";
+import { HttpService, LogService, RunService } from "@rbxts/services";
 import { installBridges, cleanupBridges } from "../EvalBridges";
+import StopPlayMonitor from "../StopPlayMonitor";
 
 const StudioTestService = game.GetService("StudioTestService");
 const ServerScriptService = game.GetService("ServerScriptService");
 const ScriptEditorService = game.GetService("ScriptEditorService");
 
-const STOP_SIGNAL = "__MCP_STOP__";
+// NAV_SIGNAL flows from the edit DM to the play-server DM via the injected
+// __MCP_CommandListener Script + LogService.MessageOut. Stop signaling moved
+// off this path entirely (see StopPlayMonitor) because cross-DM MessageOut
+// reflection from edit -> play-server does not work in practice.
 const NAV_SIGNAL = "__MCP_NAV__";
 const NAV_RESULT = "__MCP_NAV_RESULT__";
 
@@ -25,16 +29,13 @@ let navResultCallback: ((json: string) => void) | undefined;
 
 function buildCommandListenerSource(): string {
 	return `local LogService = game:GetService("LogService")
-local StudioTestService = game:GetService("StudioTestService")
 local PathfindingService = game:GetService("PathfindingService")
 local Players = game:GetService("Players")
 local HttpService = game:GetService("HttpService")
 local NAV_SIG = "${NAV_SIGNAL}"
 local NAV_RES = "${NAV_RESULT}"
 LogService.MessageOut:Connect(function(msg)
-	if msg == "${STOP_SIGNAL}" then
-		pcall(function() StudioTestService:EndTest("stopped_by_mcp") end)
-	elseif string.sub(msg, 1, #NAV_SIG + 1) == NAV_SIG .. ":" then
+	if string.sub(msg, 1, #NAV_SIG + 1) == NAV_SIG .. ":" then
 		local json = string.sub(msg, #NAV_SIG + 2)
 		task.spawn(function()
 			local ok, d = pcall(function() return HttpService:JSONDecode(json) end)
@@ -123,6 +124,20 @@ function startPlaytest(requestData: Record<string, unknown>) {
 		return { error: 'mode must be "play" or "run"' };
 	}
 
+	// Self-heal: if testRunning is stuck true but Studio reports no active
+	// playtest, the previous start_playtest's task.spawn was orphaned
+	// (plugin reload mid-test, Studio entered some inconsistent state, etc).
+	// Reset it so subsequent starts don't hit a false "already running".
+	if (testRunning && !RunService.IsRunning()) {
+		testRunning = false;
+		if (logConnection) {
+			logConnection.Disconnect();
+			logConnection = undefined;
+		}
+		cleanupStopListener();
+		cleanupBridges();
+	}
+
 	if (testRunning) {
 		return { error: "A test is already running" };
 	}
@@ -135,7 +150,6 @@ function startPlaytest(requestData: Record<string, unknown>) {
 	cleanupStopListener();
 
 	logConnection = LogService.MessageOut.Connect((message, messageType) => {
-		if (message === STOP_SIGNAL) return;
 		if (message.sub(1, NAV_SIGNAL.size()) === NAV_SIGNAL) return;
 		if (message.sub(1, NAV_RESULT.size() + 1) === `${NAV_RESULT}:`) {
 			if (navResultCallback) {
@@ -193,32 +207,58 @@ function startPlaytest(requestData: Record<string, unknown>) {
 	});
 
 	const msg = numPlayers !== undefined
-		? `Playtest started in ${mode} mode with ${numPlayers} player(s)`
-		: `Playtest started in ${mode} mode`;
+		? `Playtest started in ${mode} mode with ${numPlayers} player(s).`
+		: `Playtest started in ${mode} mode.`;
 
 	const response: Record<string, unknown> = {
 		success: true,
 		message: msg,
-		evalBridges: bridgeInstall.installed ? "installed" : `failed: ${bridgeInstall.error}`,
 	};
+	// 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;
 }
 
 function stopPlaytest(_requestData: Record<string, unknown>) {
-	// Server-side routing (tools/index.ts:stopPlaytest) sends /api/stop-playtest
-	// to the role="edit-proxy" instance whenever one is registered. This handler
-	// is only reached when there's no edit-proxy - i.e. no active playtest, or
-	// the play DMs haven't completed plugin auto-activation yet. Calling
-	// StudioTestService:EndTest from the edit DM is illegal ("can only be
-	// called from the server DataModel of a running Studio play session"), so
-	// don't try - return a clean "no active playtest" response instead.
-	return {
-		error: "No active playtest to stop (edit-proxy not registered).",
-		hint:
-			"If a playtest is running, the play-server DM may not have completed plugin auto-activation yet. " +
-			"Wait a moment and retry, or call execute_luau target=server with StudioTestService:EndTest as a manual fallback.",
-	};
+	// Signal the play-server DM's StopPlayMonitor via plugin:SetSetting (a
+	// cross-DM persistent store). The monitor polls at 1Hz, sees the flag,
+	// calls StudioTestService:EndTest, then resets the flag. We wait up to
+	// 2.5s for the reset to confirm a play DM actually consumed the request,
+	// which avoids returning success when nothing is running.
+	if (!StopPlayMonitor.requestStop()) {
+		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.
+		StopPlayMonitor.clearPending();
+		return { error: "No active playtest to stop." };
+	}
+	// Flag was consumed (EndTest called). ExecutePlayModeAsync in our
+	// startPlaytest task.spawn is still unwinding though — testRunning stays
+	// true until that yield completes and the post-block runs. Wait so
+	// back-to-back stop -> start sequences don't race against the prior
+	// teardown and get "A test is already running". 10s covers play-DM
+	// teardown on heavier places; if it still hasn't cleared we return
+	// anyway so users aren't stuck — but note that in the response so the
+	// caller knows a subsequent start may need a moment.
+	const deadline = tick() + 10;
+	while (testRunning && tick() < deadline) {
+		task.wait(0.1);
+	}
+	if (testRunning) {
+		return {
+			success: true,
+			message: "Playtest stop signal sent; teardown still in progress.",
+		};
+	}
+	return { success: true, message: "Playtest stopped." };
 }
 
 function getPlaytestOutput(_requestData: Record<string, unknown>) {

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

@@ -3,12 +3,18 @@ import UI from "../modules/UI";
 import Communication from "../modules/Communication";
 import ClientBroker from "../modules/ClientBroker";
 import RuntimeLogBuffer from "../modules/RuntimeLogBuffer";
+import StopPlayMonitor from "../modules/StopPlayMonitor";
 
 // Attach the per-peer LogService.MessageOut listener as early as possible so
 // boot-time prints from the user's place scripts are captured. Powers the
 // get_runtime_logs MCP tool. Idempotent; safe to call before UI.init().
 RuntimeLogBuffer.install();
 
+// Share the plugin reference with the stop-play signaling module so both the
+// edit DM (write the flag) and the play-server DM (read+act on the flag) can
+// access plugin:SetSetting/GetSetting.
+StopPlayMonitor.init(plugin);
+
 UI.init(plugin);
 const elements = UI.getElements();
 
@@ -67,6 +73,10 @@ task.delay(2, () => {
 	}
 	if (role === "server") {
 		ClientBroker.setupServerBroker();
+		// The play-server DM is the only one where StudioTestService:EndTest is
+		// legal, so the stop-play monitor lives here. Reads MCP_STOP_PLAY_SIGNAL
+		// at 1Hz and calls EndTest when the edit DM sets it.
+		StopPlayMonitor.startMonitor();
 	} else if (role === "client") {
 		ClientBroker.setupClientBroker();
 	}