@chrrxs/robloxstudio-mcp 2.9.0 → 2.9.1

package/dist/index.js

@@ -1206,6 +1206,17 @@ function luaLongQuote(s) {
 ${s}
 ]${eq}]`;
 }
+function parseBridgeResponse(response) {
+  const r = response;
+  if (r && typeof r.returnValue === "string") {
+    try {
+      const parsed = JSON.parse(r.returnValue);
+      return JSON.stringify(parsed);
+    } catch {
+    }
+  }
+  return JSON.stringify(response);
+}
 var SERVER_LOCAL_NAME, CLIENT_LOCAL_NAME, RobloxStudioTools;
 var init_tools = __esm({
   "../core/dist/tools/index.js"() {
@@ -1755,27 +1766,28 @@ ${code}`
           throw new Error("Code is required for eval_server_runtime");
         }
         const wrapper = `
+local HttpService = game:GetService("HttpService")
 local bf = game:GetService("ServerScriptService"):FindFirstChild("${SERVER_LOCAL_NAME}")
 if not bf then
-	return {
+	return HttpService:JSONEncode({
 		bridge = "missing",
 		error = "ServerEvalBridge not installed. Bridges are auto-installed at start_playtest and removed at stop_playtest. Start a playtest before calling eval_server_runtime.",
-	}
+	})
 end
 local USER_CODE = ${luaLongQuote(code)}
 local ok, result = bf:Invoke(USER_CODE)
-return {
+return HttpService:JSONEncode({
 	bridge = "ok",
 	ok = ok,
 	result = if result == nil then nil else tostring(result),
-}
+})
 `;
         const response = await this.client.request("/api/execute-luau", { code: wrapper }, "server");
         return {
           content: [
             {
               type: "text",
-              text: JSON.stringify(response)
+              text: parseBridgeResponse(response)
             }
           ]
         };
@@ -1789,12 +1801,13 @@ return {
           throw new Error(`eval_client_runtime requires target=client-N (got: ${clientTarget})`);
         }
         const wrapper = `
+local HttpService = game:GetService("HttpService")
 local bf = game:GetService("ReplicatedStorage"):FindFirstChild("${CLIENT_LOCAL_NAME}")
 if not bf then
-	return {
+	return HttpService:JSONEncode({
 		bridge = "missing",
 		error = "ClientEvalBridge not installed. Bridges are auto-installed at start_playtest and removed at stop_playtest. Start a playtest before calling eval_client_runtime.",
-	}
+	})
 end
 local USER_CODE = ${luaLongQuote(code)}
 local m = Instance.new("ModuleScript")
@@ -1802,23 +1815,23 @@ m.Name = "__MCPEvalPayload"
 local okSet, setErr = pcall(function() m.Source = USER_CODE end)
 if not okSet then
 	m:Destroy()
-	return { bridge = "ok", ok = false, result = "ModuleScript Source set failed: " .. tostring(setErr) }
+	return HttpService:JSONEncode({ bridge = "ok", ok = false, result = "ModuleScript Source set failed: " .. tostring(setErr) })
 end
 m.Parent = workspace
 local ok, result = bf:Invoke(m)
 m:Destroy()
-return {
+return HttpService:JSONEncode({
 	bridge = "ok",
 	ok = ok,
 	result = if result == nil then nil else tostring(result),
-}
+})
 `;
         const response = await this.client.request("/api/execute-luau", { code: wrapper }, clientTarget);
         return {
           content: [
             {
               type: "text",
-              text: JSON.stringify(response)
+              text: parseBridgeResponse(response)
             }
           ]
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrrxs/robloxstudio-mcp",
-  "version": "2.9.0",
+  "version": "2.9.1",
   "description": "MCP Server for Roblox Studio Integration (fork of boshyxd/robloxstudio-mcp with per-peer execute_luau + stop_playtest fixes)",
   "main": "dist/index.js",
   "type": "module",

package/studio-plugin/MCPInspectorPlugin.rbxmx

@@ -796,7 +796,18 @@ local TS = require(script.Parent.Parent.include.RuntimeLib)
 -- DataModel into the play DMs, so the scripts come along and run there.
 -- TestHandlers cleans them up from the edit DM when ExecutePlayModeAsync
 -- returns (test ended for any reason: stop_playtest, manual close, EndTest).
--- Both scripts have Archivable=false so a user save doesn't persist them.
+--
+-- 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).
 local _services = TS.import(script, script.Parent.Parent, "node_modules", "@rbxts", "services")
 local ServerScriptService = _services.ServerScriptService
 local StarterPlayer = _services.StarterPlayer
@@ -944,7 +955,9 @@ local function installBridges()
 	local ok, err = pcall(function()
 		local serverScript = Instance.new("Script")
 		serverScript.Name = SERVER_SCRIPT_NAME
-		serverScript.Archivable = false
+		-- Archivable=true so ExecutePlayModeAsync's deep-clone includes the
+		-- script. cleanupBridges() removes it from the edit DM when the
+		-- playtest ends.
 		setSource(serverScript, SERVER_BRIDGE_SOURCE)
 		serverScript.Parent = ServerScriptService
 		local sps = getStarterPlayerScripts()
@@ -953,7 +966,6 @@ local function installBridges()
 		end
 		local clientScript = Instance.new("LocalScript")
 		clientScript.Name = CLIENT_SCRIPT_NAME
-		clientScript.Archivable = false
 		setSource(clientScript, CLIENT_BRIDGE_SOURCE)
 		clientScript.Parent = sps
 	end)
@@ -3127,13 +3139,56 @@ local function executeLuau(requestData)
 		table.insert(output, _arg0)
 		oldWarn(unpack(args))
 	end
+	-- 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.
+	local runViaModuleScript = function()
+		local m = Instance.new("ModuleScript")
+		m.Name = "__MCPExecLuauPayload"
+		local okSet, setErr = pcall(function()
+			m.Source = code
+		end)
+		if not okSet then
+			m:Destroy()
+			error(`ModuleScript Source set failed: {tostring(setErr)}`)
+		end
+		m.Parent = game:GetService("Workspace")
+		local okReq, reqResult = pcall(function()
+			return require(m)
+		end)
+		m:Destroy()
+		if not okReq then
+			error(tostring(reqResult))
+		end
+		return reqResult
+	end
+	local isLoadstringUnavailable = function(err)
+		local errStr = tostring(err)
+		local matchStart = string.find(errStr, "not available", 1, true)
+		return matchStart ~= nil
+	end
 	local success, result = pcall(function()
 		local fn, compileError = loadstring(code)
 		if not fn then
+			if isLoadstringUnavailable(compileError) then
+				return runViaModuleScript()
+			end
 			error(`Compile error: {compileError}`)
 		end
 		return fn()
 	end)
+	-- loadstring throws (not returns nil) in some plugin contexts when
+	-- LoadStringEnabled=false. Catch that here as a second-chance fallback.
+	if not success and isLoadstringUnavailable(result) then
+		success, result = pcall(runViaModuleScript)
+	end
 	env.print = oldPrint
 	env.warn = oldWarn
 	if success then
@@ -5579,7 +5634,7 @@ return {
         <Properties>
           <string name="Name">State</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
-local CURRENT_VERSION = "2.9.0"
+local CURRENT_VERSION = "2.9.1"
 local MAX_CONNECTIONS = 5
 local BASE_PORT = 58741
 local activeTabIndex = 0

package/studio-plugin/MCPPlugin.rbxmx

@@ -796,7 +796,18 @@ local TS = require(script.Parent.Parent.include.RuntimeLib)
 -- DataModel into the play DMs, so the scripts come along and run there.
 -- TestHandlers cleans them up from the edit DM when ExecutePlayModeAsync
 -- returns (test ended for any reason: stop_playtest, manual close, EndTest).
--- Both scripts have Archivable=false so a user save doesn't persist them.
+--
+-- 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).
 local _services = TS.import(script, script.Parent.Parent, "node_modules", "@rbxts", "services")
 local ServerScriptService = _services.ServerScriptService
 local StarterPlayer = _services.StarterPlayer
@@ -944,7 +955,9 @@ local function installBridges()
 	local ok, err = pcall(function()
 		local serverScript = Instance.new("Script")
 		serverScript.Name = SERVER_SCRIPT_NAME
-		serverScript.Archivable = false
+		-- Archivable=true so ExecutePlayModeAsync's deep-clone includes the
+		-- script. cleanupBridges() removes it from the edit DM when the
+		-- playtest ends.
 		setSource(serverScript, SERVER_BRIDGE_SOURCE)
 		serverScript.Parent = ServerScriptService
 		local sps = getStarterPlayerScripts()
@@ -953,7 +966,6 @@ local function installBridges()
 		end
 		local clientScript = Instance.new("LocalScript")
 		clientScript.Name = CLIENT_SCRIPT_NAME
-		clientScript.Archivable = false
 		setSource(clientScript, CLIENT_BRIDGE_SOURCE)
 		clientScript.Parent = sps
 	end)
@@ -3127,13 +3139,56 @@ local function executeLuau(requestData)
 		table.insert(output, _arg0)
 		oldWarn(unpack(args))
 	end
+	-- 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.
+	local runViaModuleScript = function()
+		local m = Instance.new("ModuleScript")
+		m.Name = "__MCPExecLuauPayload"
+		local okSet, setErr = pcall(function()
+			m.Source = code
+		end)
+		if not okSet then
+			m:Destroy()
+			error(`ModuleScript Source set failed: {tostring(setErr)}`)
+		end
+		m.Parent = game:GetService("Workspace")
+		local okReq, reqResult = pcall(function()
+			return require(m)
+		end)
+		m:Destroy()
+		if not okReq then
+			error(tostring(reqResult))
+		end
+		return reqResult
+	end
+	local isLoadstringUnavailable = function(err)
+		local errStr = tostring(err)
+		local matchStart = string.find(errStr, "not available", 1, true)
+		return matchStart ~= nil
+	end
 	local success, result = pcall(function()
 		local fn, compileError = loadstring(code)
 		if not fn then
+			if isLoadstringUnavailable(compileError) then
+				return runViaModuleScript()
+			end
 			error(`Compile error: {compileError}`)
 		end
 		return fn()
 	end)
+	-- loadstring throws (not returns nil) in some plugin contexts when
+	-- LoadStringEnabled=false. Catch that here as a second-chance fallback.
+	if not success and isLoadstringUnavailable(result) then
+		success, result = pcall(runViaModuleScript)
+	end
 	env.print = oldPrint
 	env.warn = oldWarn
 	if success then
@@ -5579,7 +5634,7 @@ return {
         <Properties>
           <string name="Name">State</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
-local CURRENT_VERSION = "2.9.0"
+local CURRENT_VERSION = "2.9.1"
 local MAX_CONNECTIONS = 5
 local BASE_PORT = 58741
 local activeTabIndex = 0

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

@@ -19,7 +19,18 @@
 // DataModel into the play DMs, so the scripts come along and run there.
 // TestHandlers cleans them up from the edit DM when ExecutePlayModeAsync
 // returns (test ended for any reason: stop_playtest, manual close, EndTest).
-// Both scripts have Archivable=false so a user save doesn't persist them.
+//
+// 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";
 
@@ -169,7 +180,9 @@ export function installBridges(): { installed: boolean; error?: string } {
 	const [ok, err] = pcall(() => {
 		const serverScript = new Instance("Script");
 		serverScript.Name = SERVER_SCRIPT_NAME;
-		serverScript.Archivable = false;
+		// Archivable=true so ExecutePlayModeAsync's deep-clone includes the
+		// script. cleanupBridges() removes it from the edit DM when the
+		// playtest ends.
 		setSource(serverScript, SERVER_BRIDGE_SOURCE);
 		serverScript.Parent = ServerScriptService;
 
@@ -179,7 +192,6 @@ export function installBridges(): { installed: boolean; error?: string } {
 		}
 		const clientScript = new Instance("LocalScript");
 		clientScript.Name = CLIENT_SCRIPT_NAME;
-		clientScript.Archivable = false;
 		setSource(clientScript, CLIENT_BRIDGE_SOURCE);
 		clientScript.Parent = sps;
 	});

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

@@ -281,12 +281,56 @@ function executeLuau(requestData: Record<string, unknown>) {
 		oldWarn(...(args as [defined, ...defined[]]));
 	};
 
-	const [success, result] = pcall(() => {
+	// 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 m = new Instance("ModuleScript");
+		m.Name = "__MCPExecLuauPayload";
+		const [okSet, setErr] = pcall(() => {
+			(m as unknown as { Source: string }).Source = code;
+		});
+		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;
+	};
+
+	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(code);
-		if (!fn) error(`Compile error: ${compileError}`);
+		if (!fn) {
+			if (isLoadstringUnavailable(compileError)) {
+				return runViaModuleScript();
+			}
+			error(`Compile error: ${compileError}`);
+		}
 		return fn();
 	});
 
+	// loadstring throws (not returns nil) in some plugin contexts when
+	// LoadStringEnabled=false. Catch that here as a second-chance fallback.
+	if (!success && isLoadstringUnavailable(result)) {
+		[success, result] = pcall(runViaModuleScript);
+	}
+
 	env["print"] = oldPrint;
 	env["warn"] = oldWarn;