@chrrxs/robloxstudio-mcp-inspector 2.11.2 → 2.11.3

package/dist/index.js

@@ -1217,7 +1217,28 @@ ${s}
 }
 function buildModuleScriptInvokeWrapper(opts) {
   const wrapped = `return ((function()
+	local __mcp_output = {}
+	local __mcp_real_print = print
+	local __mcp_real_warn = warn
+	local print = function(...)
+		__mcp_real_print(...)
+		local args = {...}
+		local parts = table.create(#args)
+		for i, a in ipairs(args) do parts[i] = tostring(a) end
+		table.insert(__mcp_output, table.concat(parts, "\\t"))
+	end
+	local warn = function(...)
+		__mcp_real_warn(...)
+		local args = {...}
+		local parts = table.create(#args)
+		for i, a in ipairs(args) do parts[i] = tostring(a) end
+		table.insert(__mcp_output, "[warn] " .. table.concat(parts, "\\t"))
+	end
+	local function __mcp_run()
 ${opts.userCode}
+	end
+	local ok, errOrValue = xpcall(__mcp_run, debug.traceback)
+	return { ok = ok, value = errOrValue, output = __mcp_output }
 end)())`;
   return `
 local HttpService = game:GetService("HttpService")
@@ -1234,15 +1255,29 @@ m.Name = "__MCPEvalPayload"
 local okSet, setErr = pcall(function() m.Source = USER_CODE end)
 if not okSet then
 	m:Destroy()
-	return HttpService:JSONEncode({ bridge = "ok", ok = false, result = "ModuleScript Source set failed: " .. tostring(setErr) })
+	return HttpService:JSONEncode({ bridge = "ok", ok = false, error = "ModuleScript Source set failed: " .. tostring(setErr) })
 end
 m.Parent = workspace
-local ok, result = bf:Invoke(m)
+local bridgeOk, inner = bf:Invoke(m)
 m:Destroy()
+if not bridgeOk then
+	return HttpService:JSONEncode({ bridge = "ok", ok = false, error = tostring(inner) })
+end
+-- inner is the {ok, value, output} table from our IIFE. Defensive: if it's
+-- somehow not a table (caller bypassed the wrapper), fall back to old shape.
+if typeof(inner) ~= "table" then
+	return HttpService:JSONEncode({
+		bridge = "ok",
+		ok = true,
+		result = if inner == nil then nil else tostring(inner),
+	})
+end
 return HttpService:JSONEncode({
 	bridge = "ok",
-	ok = ok,
-	result = if result == nil then nil else tostring(result),
+	ok = inner.ok == true,
+	result = if inner.ok and inner.value ~= nil then tostring(inner.value) else nil,
+	error = if not inner.ok then tostring(inner.value) else nil,
+	output = inner.output or {},
 })
 `;
 }
@@ -3073,14 +3108,42 @@ var init_proxy_bridge_service = __esm({
   "../core/dist/proxy-bridge-service.js"() {
     "use strict";
     init_bridge_service();
-    ProxyBridgeService = class extends BridgeService {
+    ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
       primaryBaseUrl;
       proxyInstanceId;
       proxyRequestTimeout = 3e4;
+      cachedInstances = [];
+      refreshTimer;
+      static REFRESH_INTERVAL_MS = 1e3;
       constructor(primaryBaseUrl) {
         super();
         this.primaryBaseUrl = primaryBaseUrl;
         this.proxyInstanceId = uuidv42();
+        this.refreshInstances();
+        this.refreshTimer = setInterval(() => this.refreshInstances(), _ProxyBridgeService.REFRESH_INTERVAL_MS);
+      }
+      async refreshInstances() {
+        try {
+          const res = await fetch(`${this.primaryBaseUrl}/instances`);
+          if (!res.ok)
+            return;
+          const body = await res.json();
+          if (Array.isArray(body.instances)) {
+            this.cachedInstances = body.instances;
+          }
+        } catch {
+        }
+      }
+      getInstances() {
+        return this.cachedInstances;
+      }
+      /** Called when this proxy is being discarded (e.g. promotion to primary
+          replaced it). Stops the background refresh so it doesn't leak. */
+      stop() {
+        if (this.refreshTimer) {
+          clearInterval(this.refreshTimer);
+          this.refreshTimer = void 0;
+        }
       }
       async sendRequest(endpoint, data, target = "edit") {
         const controller = new AbortController();
@@ -3208,8 +3271,12 @@ var init_server = __esm({
             const candidateApp = createHttpServer(candidateTools, candidateBridge, this.allowedToolNames, this.config);
             try {
               const result = await listenWithRetry(candidateApp, host, basePort, 1);
+              const oldBridge = this.bridge;
               this.bridge = candidateBridge;
               this.tools = candidateTools;
+              if (oldBridge instanceof ProxyBridgeService) {
+                oldBridge.stop();
+              }
               httpHandle = result.server;
               boundPort = result.port;
               primaryApp = candidateApp;
@@ -3272,6 +3339,9 @@ var init_server = __esm({
           clearInterval(cleanupInterval);
           if (promotionInterval)
             clearInterval(promotionInterval);
+          if (this.bridge instanceof ProxyBridgeService) {
+            this.bridge.stop();
+          }
           await this.server.close().catch(() => {
           });
           if (httpHandle)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrrxs/robloxstudio-mcp-inspector",
-  "version": "2.11.2",
+  "version": "2.11.3",
   "description": "Read-only MCP Server for Roblox Studio (fork of boshyxd/robloxstudio-mcp-inspector with per-peer execute_luau fixes baked in)",
   "main": "dist/index.js",
   "type": "module",

package/studio-plugin/MCPInspectorPlugin.rbxmx

@@ -3255,56 +3255,52 @@ local function executeLuau(requestData)
 			error = "Code is required",
 		}
 	end
-	local output = {}
-	local oldPrint = print
-	local oldWarn = warn
-	local env = getfenv(0)
-	env.print = function(...)
-		local args = { ... }
-		local parts = {}
-		for _, a in args do
-			local _arg0 = tostring(a)
-			table.insert(parts, _arg0)
-		end
-		local _arg0 = table.concat(parts, "\t")
-		table.insert(output, _arg0)
-		oldPrint(unpack(args))
-	end
-	env.warn = function(...)
-		local args = { ... }
-		local parts = {}
-		for _, a in args do
-			local _arg0 = tostring(a)
-			table.insert(parts, _arg0)
-		end
-		local _arg0 = `[warn] {table.concat(parts, "\t")}`
-		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.
+	-- 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.
+	local 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)())`
 	local runViaModuleScript = function()
 		local m = Instance.new("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.
-		local wrapped = `return ((function()\n{code}\nend)())`
 		local okSet, setErr = pcall(function()
 			m.Source = wrapped
 		end)
@@ -3328,7 +3324,7 @@ local function executeLuau(requestData)
 		return matchStart ~= nil
 	end
 	local success, result = pcall(function()
-		local fn, compileError = loadstring(code)
+		local fn, compileError = loadstring(wrapped)
 		if not fn then
 			if isLoadstringUnavailable(compileError) then
 				return runViaModuleScript()
@@ -3338,27 +3334,39 @@ local function executeLuau(requestData)
 		return fn()
 	end)
 	-- 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 not success and isLoadstringUnavailable(result) then
 		success, result = pcall(runViaModuleScript)
 	end
-	env.print = oldPrint
-	env.warn = oldWarn
-	if success then
-		return {
-			success = true,
-			returnValue = if result ~= nil then tostring(result) else nil,
-			output = output,
-			message = "Code executed successfully",
-		}
-	else
+	if not success then
+		-- 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 = output,
+			output = {},
 			message = "Code execution failed",
 		}
 	end
+	-- Wrapper executed - unpack { ok, value, output }.
+	local r = result
+	local capturedOutput = r.output
+	local output = if capturedOutput ~= nil then capturedOutput else ({})
+	if r.ok == true then
+		return {
+			success = true,
+			returnValue = if r.value ~= nil then tostring(r.value) else nil,
+			output = output,
+			message = "Code executed successfully",
+		}
+	end
+	return {
+		success = false,
+		error = if r.value ~= nil then tostring(r.value) else "(unknown error)",
+		output = output,
+		message = "Code execution failed",
+	}
 end
 local function undo(_requestData)
 	local success, result = pcall(function()
@@ -5643,6 +5651,7 @@ local TS = require(script.Parent.Parent.Parent.include.RuntimeLib)
 local _services = TS.import(script, script.Parent.Parent.Parent, "node_modules", "@rbxts", "services")
 local HttpService = _services.HttpService
 local LogService = _services.LogService
+local RunService = _services.RunService
 local _EvalBridges = TS.import(script, script.Parent.Parent, "EvalBridges")
 local installBridges = _EvalBridges.installBridges
 local cleanupBridges = _EvalBridges.cleanupBridges
@@ -5759,6 +5768,19 @@ local function startPlaytest(requestData)
 			error = 'mode must be "play" or "run"',
 		}
 	end
+	-- 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 and not RunService:IsRunning() then
+		testRunning = false
+		if logConnection then
+			logConnection:Disconnect()
+			logConnection = nil
+		end
+		cleanupStopListener()
+		cleanupBridges()
+	end
 	if testRunning then
 		return {
 			error = "A test is already running",
@@ -5856,17 +5878,35 @@ local function stopPlaytest(_requestData)
 			error = "Plugin not ready. Try again in a moment.",
 		}
 	end
-	if StopPlayMonitor.waitForConsumption() then
+	if not StopPlayMonitor.waitForConsumption() then
+		-- 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.",
+		}
+	end
+	-- 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.
+	local deadline = tick() + 10
+	while testRunning and tick() < deadline do
+		task.wait(0.1)
+	end
+	if testRunning then
 		return {
 			success = true,
-			message = "Playtest stopped.",
+			message = "Playtest stop signal sent; teardown still in progress.",
 		}
 	end
-	-- 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.",
+		success = true,
+		message = "Playtest stopped.",
 	}
 end
 local function getPlaytestOutput(_requestData)
@@ -6175,7 +6215,7 @@ return {
         <Properties>
           <string name="Name">State</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
-local CURRENT_VERSION = "2.11.2"
+local CURRENT_VERSION = "2.11.3"
 local MAX_CONNECTIONS = 5
 local BASE_PORT = 58741
 local activeTabIndex = 0

package/studio-plugin/MCPPlugin.rbxmx

@@ -3255,56 +3255,52 @@ local function executeLuau(requestData)
 			error = "Code is required",
 		}
 	end
-	local output = {}
-	local oldPrint = print
-	local oldWarn = warn
-	local env = getfenv(0)
-	env.print = function(...)
-		local args = { ... }
-		local parts = {}
-		for _, a in args do
-			local _arg0 = tostring(a)
-			table.insert(parts, _arg0)
-		end
-		local _arg0 = table.concat(parts, "\t")
-		table.insert(output, _arg0)
-		oldPrint(unpack(args))
-	end
-	env.warn = function(...)
-		local args = { ... }
-		local parts = {}
-		for _, a in args do
-			local _arg0 = tostring(a)
-			table.insert(parts, _arg0)
-		end
-		local _arg0 = `[warn] {table.concat(parts, "\t")}`
-		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.
+	-- 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.
+	local 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)())`
 	local runViaModuleScript = function()
 		local m = Instance.new("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.
-		local wrapped = `return ((function()\n{code}\nend)())`
 		local okSet, setErr = pcall(function()
 			m.Source = wrapped
 		end)
@@ -3328,7 +3324,7 @@ local function executeLuau(requestData)
 		return matchStart ~= nil
 	end
 	local success, result = pcall(function()
-		local fn, compileError = loadstring(code)
+		local fn, compileError = loadstring(wrapped)
 		if not fn then
 			if isLoadstringUnavailable(compileError) then
 				return runViaModuleScript()
@@ -3338,27 +3334,39 @@ local function executeLuau(requestData)
 		return fn()
 	end)
 	-- 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 not success and isLoadstringUnavailable(result) then
 		success, result = pcall(runViaModuleScript)
 	end
-	env.print = oldPrint
-	env.warn = oldWarn
-	if success then
-		return {
-			success = true,
-			returnValue = if result ~= nil then tostring(result) else nil,
-			output = output,
-			message = "Code executed successfully",
-		}
-	else
+	if not success then
+		-- 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 = output,
+			output = {},
 			message = "Code execution failed",
 		}
 	end
+	-- Wrapper executed - unpack { ok, value, output }.
+	local r = result
+	local capturedOutput = r.output
+	local output = if capturedOutput ~= nil then capturedOutput else ({})
+	if r.ok == true then
+		return {
+			success = true,
+			returnValue = if r.value ~= nil then tostring(r.value) else nil,
+			output = output,
+			message = "Code executed successfully",
+		}
+	end
+	return {
+		success = false,
+		error = if r.value ~= nil then tostring(r.value) else "(unknown error)",
+		output = output,
+		message = "Code execution failed",
+	}
 end
 local function undo(_requestData)
 	local success, result = pcall(function()
@@ -5643,6 +5651,7 @@ local TS = require(script.Parent.Parent.Parent.include.RuntimeLib)
 local _services = TS.import(script, script.Parent.Parent.Parent, "node_modules", "@rbxts", "services")
 local HttpService = _services.HttpService
 local LogService = _services.LogService
+local RunService = _services.RunService
 local _EvalBridges = TS.import(script, script.Parent.Parent, "EvalBridges")
 local installBridges = _EvalBridges.installBridges
 local cleanupBridges = _EvalBridges.cleanupBridges
@@ -5759,6 +5768,19 @@ local function startPlaytest(requestData)
 			error = 'mode must be "play" or "run"',
 		}
 	end
+	-- 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 and not RunService:IsRunning() then
+		testRunning = false
+		if logConnection then
+			logConnection:Disconnect()
+			logConnection = nil
+		end
+		cleanupStopListener()
+		cleanupBridges()
+	end
 	if testRunning then
 		return {
 			error = "A test is already running",
@@ -5856,17 +5878,35 @@ local function stopPlaytest(_requestData)
 			error = "Plugin not ready. Try again in a moment.",
 		}
 	end
-	if StopPlayMonitor.waitForConsumption() then
+	if not StopPlayMonitor.waitForConsumption() then
+		-- 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.",
+		}
+	end
+	-- 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.
+	local deadline = tick() + 10
+	while testRunning and tick() < deadline do
+		task.wait(0.1)
+	end
+	if testRunning then
 		return {
 			success = true,
-			message = "Playtest stopped.",
+			message = "Playtest stop signal sent; teardown still in progress.",
 		}
 	end
-	-- 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.",
+		success = true,
+		message = "Playtest stopped.",
 	}
 end
 local function getPlaytestOutput(_requestData)
@@ -6175,7 +6215,7 @@ return {
         <Properties>
           <string name="Name">State</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
-local CURRENT_VERSION = "2.11.2"
+local CURRENT_VERSION = "2.11.3"
 local MAX_CONNECTIONS = 5
 local BASE_PORT = 58741
 local activeTabIndex = 0

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,4 +1,4 @@
-import { HttpService, LogService } from "@rbxts/services";
+import { HttpService, LogService, RunService } from "@rbxts/services";
 import { installBridges, cleanupBridges } from "../EvalBridges";
 import StopPlayMonitor from "../StopPlayMonitor";
 
@@ -124,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" };
 	}
@@ -220,13 +234,31 @@ function stopPlaytest(_requestData: Record<string, unknown>) {
 	if (!StopPlayMonitor.requestStop()) {
 		return { error: "Plugin not ready. Try again in a moment." };
 	}
-	if (StopPlayMonitor.waitForConsumption()) {
-		return { success: true, message: "Playtest stopped." };
+	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.",
+		};
 	}
-	// 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." };
+	return { success: true, message: "Playtest stopped." };
 }
 
 function getPlaytestOutput(_requestData: Record<string, unknown>) {