@chrrxs/robloxstudio-mcp 2.10.0 → 2.11.0

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

@@ -1,5 +1,6 @@
 import { HttpService, Players, ReplicatedStorage, RunService } from "@rbxts/services";
 import RuntimeLogBuffer from "./RuntimeLogBuffer";
+import MemoryHandlers from "./handlers/MemoryHandlers";
 
 // The client peer cannot reach the MCP HTTP server - Roblox forbids
 // HttpService:RequestAsync from the client DM even under PluginSecurity, and
@@ -45,6 +46,7 @@ interface ExecuteResult {
 const CLIENT_BROKER_ALLOWED_ENDPOINTS = new Set<string>([
 	"/api/execute-luau",
 	"/api/get-runtime-logs",
+	"/api/get-memory-breakdown",
 ]);
 
 interface ReadyResponseBody {
@@ -145,6 +147,9 @@ function setupClientBroker() {
 		if (payload && payload.endpoint === "/api/get-runtime-logs") {
 			return handleGetRuntimeLogs(payload.data);
 		}
+		if (payload && payload.endpoint === "/api/get-memory-breakdown") {
+			return MemoryHandlers.getMemoryBreakdown(payload.data ?? {});
+		}
 		if (payload && payload.endpoint === "/api/execute-luau") {
 			return handleExecuteLuau(payload.data);
 		}

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

@@ -13,6 +13,8 @@ import AssetHandlers from "./handlers/AssetHandlers";
 import CaptureHandlers from "./handlers/CaptureHandlers";
 import InputHandlers from "./handlers/InputHandlers";
 import LogHandlers from "./handlers/LogHandlers";
+import SerializationHandlers from "./handlers/SerializationHandlers";
+import MemoryHandlers from "./handlers/MemoryHandlers";
 import { Connection, RequestPayload, PollResponse, ReadyResponse } from "../types";
 
 const instanceId = HttpService.GenerateGUID(false);
@@ -95,6 +97,11 @@ const routeMap: Record<string, Handler> = {
 	"/api/find-and-replace-in-scripts": ScriptHandlers.findAndReplaceInScripts,
 
 	"/api/get-runtime-logs": LogHandlers.getRuntimeLogs,
+
+	"/api/export-rbxm": SerializationHandlers.exportRbxm,
+	"/api/import-rbxm": SerializationHandlers.importRbxm,
+
+	"/api/get-memory-breakdown": MemoryHandlers.getMemoryBreakdown,
 };
 
 function processRequest(request: RequestPayload): unknown {
@@ -181,6 +188,7 @@ function pollForRequests(connIndex: number) {
 
 	const ui = UI.getElements();
 	UI.updateTabDot(connIndex);
+	if (connIndex === State.getActiveTabIndex()) UI.updateToolbarIcon();
 
 	if (success && (result.Success || result.StatusCode === 503)) {
 		conn.consecutiveFailures = 0;
@@ -333,7 +341,6 @@ function activatePlugin(connIndex?: number) {
 	conn.isActive = true;
 	conn.consecutiveFailures = 0;
 	conn.currentRetryDelay = 0.5;
-	ui.screenGui.Enabled = true;
 
 	if (idx === State.getActiveTabIndex()) {
 		conn.serverUrl = ui.urlInput.Text;

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

@@ -5,15 +5,22 @@
 // `require(SomeModule)` returns a fresh copy, not the one the running game
 // scripts hold. So runtime-mutated module state is invisible to probes.
 //
-// These bridges fix that by living inside the user's game scripts:
-//   - Server: a Script in ServerScriptService that creates a BindableFunction
-//     (for our server-peer plugin to invoke directly) plus a RemoteFunction
-//     (kept for parity with the upstream primitive's client-callable shape).
+// These bridges fix that by living inside the user's game scripts. Both
+// peers use the same symmetric shape:
+//   - Server: a Script in ServerScriptService that creates a BindableFunction.
+//     Plugin (server peer) invokes it with a fresh ModuleScript payload;
+//     require() runs inside the Script VM so it shares the running server's
+//     require cache.
 //   - Client: a LocalScript in StarterPlayer.StarterPlayerScripts that
 //     creates a BindableFunction. Plugin invokes it with a fresh ModuleScript
 //     payload; require() runs inside the LocalScript VM so it shares the
 //     game's require cache.
 //
+// Why ModuleScript+require on both sides (no loadstring): require'd modules
+// run with the security level they were created at and don't need
+// ServerScriptService.LoadStringEnabled, so eval_server_runtime works even
+// when LoadStringEnabled=false (the default in fresh places).
+//
 // Lifecycle: TestHandlers.startPlaytest inserts both scripts into the EDIT
 // DM right before ExecutePlayModeAsync. ExecutePlayModeAsync clones the
 // DataModel into the play DMs, so the scripts come along and run there.
@@ -47,7 +54,6 @@ const CLIENT_SCRIPT_NAME = "__MCP_ClientEvalBridge";
 export const BRIDGE_NAMES = {
 	serverScript: SERVER_SCRIPT_NAME,
 	clientScript: CLIENT_SCRIPT_NAME,
-	serverRemote: "__MCP_ServerEvalRemote",
 	serverLocal: "__MCP_ServerEvalLocal",
 	clientLocal: "__MCP_ClientEvalBridge",
 } as const;
@@ -59,7 +65,6 @@ const SERVER_BRIDGE_SOURCE = `
 -- stop_playtest. Provides shared-require-cache eval on the server peer for
 -- the eval_server_runtime MCP tool.
 
-local ReplicatedStorage = game:GetService("ReplicatedStorage")
 local ServerScriptService = game:GetService("ServerScriptService")
 local RunService = game:GetService("RunService")
 
@@ -67,49 +72,18 @@ if not RunService:IsStudio() then
 	return
 end
 
-local function evalCode(source)
-	if type(source) ~= "string" then
-		return false, "source must be a string"
-	end
-	local fn, compileErr = loadstring(source, "MCPServerEval")
-	if not fn then
-		local errStr = tostring(compileErr or "loadstring returned nil")
-		-- Roblox returns nil from loadstring when LoadStringEnabled=false.
-		-- Surface a clear, actionable error.
-		if string.find(errStr, "not enabled", 1, true)
-			or string.find(errStr, "disabled", 1, true)
-			or errStr == "loadstring returned nil"
-		then
-			return false,
-				"ServerScriptService.LoadStringEnabled is false. eval_server_runtime requires it. "
-				.. "Enable it in Studio (ServerScriptService > Properties > LoadStringEnabled = true) "
-				.. "and restart the playtest."
-		end
-		return false, errStr
-	end
-	return pcall(fn)
-end
-
--- Defensive cleanup of stale instances from a prior session.
-local prevRf = ReplicatedStorage:FindFirstChild("${BRIDGE_NAMES.serverRemote}")
-if prevRf then prevRf:Destroy() end
 local prevBf = ServerScriptService:FindFirstChild("${BRIDGE_NAMES.serverLocal}")
 if prevBf then prevBf:Destroy() end
 
-local rf = Instance.new("RemoteFunction")
-rf.Name = "${BRIDGE_NAMES.serverRemote}"
-rf.Archivable = false
-rf.Parent = ReplicatedStorage
-rf.OnServerInvoke = function(_player, source)
-	return evalCode(source)
-end
-
 local bf = Instance.new("BindableFunction")
 bf.Name = "${BRIDGE_NAMES.serverLocal}"
 bf.Archivable = false
 bf.Parent = ServerScriptService
-bf.OnInvoke = function(source)
-	return evalCode(source)
+bf.OnInvoke = function(payload)
+	if typeof(payload) ~= "Instance" or not payload:IsA("ModuleScript") then
+		return false, "payload must be a ModuleScript instance"
+	end
+	return pcall(require, payload)
 end
 `;
 
@@ -202,14 +176,3 @@ export function installBridges(): { installed: boolean; error?: string } {
 	return { installed: true };
 }
 
-// Heuristic check so start_playtest can surface a warning when
-// LoadStringEnabled is false (eval_server_runtime won't work in that mode).
-// We can't import the runtime LoadStringEnabled value cleanly without
-// pulling in the type — read defensively.
-export function loadStringEnabled(): boolean {
-	const [ok, value] = pcall(
-		() => (ServerScriptService as unknown as { LoadStringEnabled: boolean }).LoadStringEnabled,
-	);
-	return ok && value === true;
-}
-

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

@@ -30,6 +30,39 @@ let elements: UIElements = undefined!;
 let pulseAnimation: Tween | undefined;
 let buttonHover = false;
 
+interface ToolbarIcons {
+	disconnected: string;
+	connecting: string;
+	connected: string;
+}
+let toolbarButton: PluginToolbarButton | undefined;
+let toolbarIcons: ToolbarIcons | undefined;
+let lastToolbarIcon: string | undefined;
+
+function setToolbarButton(btn: PluginToolbarButton, icons: ToolbarIcons) {
+	toolbarButton = btn;
+	toolbarIcons = icons;
+	lastToolbarIcon = undefined;
+	updateToolbarIcon();
+}
+
+function updateToolbarIcon() {
+	if (!toolbarButton || !toolbarIcons) return;
+	const conn = State.getActiveConnection();
+	let nextIcon: string;
+	if (!conn || !conn.isActive) {
+		nextIcon = toolbarIcons.disconnected;
+	} else if (conn.lastHttpOk && conn.lastMcpOk) {
+		nextIcon = toolbarIcons.connected;
+	} else {
+		nextIcon = toolbarIcons.connecting;
+	}
+	if (nextIcon !== lastToolbarIcon) {
+		(toolbarButton as unknown as { Icon: string }).Icon = nextIcon;
+		lastToolbarIcon = nextIcon;
+	}
+}
+
 interface TabButton {
 	frame: Frame;
 	label: TextLabel;
@@ -596,6 +629,7 @@ function init(pluginRef: Plugin) {
 }
 
 function updateUIState() {
+	updateToolbarIcon();
 	const conn = State.getActiveConnection();
 	if (!conn) return;
 	const el = elements;
@@ -723,5 +757,7 @@ export = {
 	updateTabLabel,
 	stopPulseAnimation,
 	startPulseAnimation,
+	setToolbarButton,
+	updateToolbarIcon,
 	getElements: () => elements,
 };

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

@@ -0,0 +1,44 @@
+const Stats = game.GetService("Stats");
+
+// GetMemoryUsageMbAllCategories is gated by capability "InternalTest" and not
+// callable from plugin context. GetMemoryUsageMbForTag is not - so we iterate
+// Enum.DeveloperMemoryTag and ask per-tag.
+function getMemoryBreakdown(requestData: Record<string, unknown>): unknown {
+	if (!Stats.MemoryTrackingEnabled) {
+		return { error: "MemoryTrackingEnabled is false on this peer" };
+	}
+
+	const requested = requestData.tags as string[] | undefined;
+	const requestedSet = requested && requested.size() > 0 ? new Set(requested) : undefined;
+
+	const categories: Record<string, number> = {};
+	for (const item of Enum.DeveloperMemoryTag.GetEnumItems()) {
+		const name = item.Name;
+		if (requestedSet && !requestedSet.has(name)) continue;
+		const [ok, mb] = pcall(() => Stats.GetMemoryUsageMbForTag(item));
+		categories[name] = ok ? (mb as number) : 0;
+	}
+
+	const unknownTags: string[] = [];
+	if (requestedSet) {
+		const known = new Set<string>();
+		for (const i of Enum.DeveloperMemoryTag.GetEnumItems()) known.add(i.Name);
+		for (const t of requestedSet) {
+			if (!known.has(t)) {
+				unknownTags.push(t);
+				categories[t] = 0;
+			}
+		}
+	}
+
+	const result: Record<string, unknown> = {
+		total_mb: Stats.GetTotalMemoryUsageMb(),
+		categories,
+		memory_tracking_enabled: true,
+		timestamp: DateTime.now().UnixTimestampMillis,
+	};
+	if (unknownTags.size() > 0) result.unknown_tags = unknownTags;
+	return result;
+}
+
+export = { getMemoryBreakdown };

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

@@ -96,8 +96,23 @@ function searchFiles(requestData: Record<string, unknown>) {
 }
 
 function getPlaceInfo(_requestData: Record<string, unknown>) {
+	const dataModelName = game.Name;
+	let placeName = dataModelName;
+
+	if (game.PlaceId > 0) {
+		const MarketplaceService = game.GetService("MarketplaceService");
+		const [ok, info] = pcall(() => MarketplaceService.GetProductInfo(game.PlaceId));
+		if (ok && info !== undefined) {
+			const name = (info as { Name?: string }).Name;
+			if (typeIs(name, "string") && name !== "") {
+				placeName = name;
+			}
+		}
+	}
+
 	return {
-		placeName: game.Name,
+		placeName,
+		dataModelName,
 		placeId: game.PlaceId,
 		gameId: game.GameId,
 		jobId: game.JobId,

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

@@ -0,0 +1,172 @@
+import { RunService } from "@rbxts/services";
+import Utils from "../Utils";
+import Recording from "../Recording";
+
+// SerializationService:SerializeInstancesAsync / DeserializeInstancesAsync were
+// added in engine v668 and are PluginSecurity. They are not in @rbxts/types yet,
+// so we resolve the service through an untyped GetService cast and treat the
+// methods as opaque (buffer in / buffer out).
+type SerializationServiceShape = {
+	SerializeInstancesAsync(this: SerializationServiceShape, instances: Instance[]): buffer;
+	DeserializeInstancesAsync(this: SerializationServiceShape, b: buffer): Instance[];
+};
+
+const SerializationService = (game as unknown as {
+	GetService(name: string): SerializationServiceShape;
+}).GetService("SerializationService");
+
+// EncodingService:Base64Encode / Base64Decode take and return `buffer` (not
+// `string`). The signature is in @rbxts/types under None.d.ts so a normal
+// GetService("EncodingService") would already give correct types, but @rbxts
+// generates a per-service nominal interface and roblox.d.ts doesn't re-export
+// EncodingService from the services barrel module - so the typed cast below
+// matches what GetService would give us if it did.
+type EncodingServiceShape = {
+	Base64Encode(this: EncodingServiceShape, input: buffer): buffer;
+	Base64Decode(this: EncodingServiceShape, input: buffer): buffer;
+};
+
+const EncodingService = (game as unknown as {
+	GetService(name: string): EncodingServiceShape;
+}).GetService("EncodingService");
+
+const { getInstanceByPath, getInstancePath } = Utils;
+const { beginRecording, finishRecording } = Recording;
+
+function exportRbxm(requestData: Record<string, unknown>): unknown {
+	const instancePaths = requestData.instance_paths as string[] | undefined;
+	if (!instancePaths || !typeIs(instancePaths, "table") || instancePaths.size() === 0) {
+		return { error: "instance_paths must be a non-empty array" };
+	}
+
+	const instances: Instance[] = [];
+	for (const p of instancePaths) {
+		const inst = getInstanceByPath(p);
+		if (!inst) {
+			return { error: `instance not found: ${p}` };
+		}
+		instances.push(inst);
+	}
+
+	const [serializeOk, serializeResult] = pcall(() => {
+		return SerializationService.SerializeInstancesAsync(instances);
+	});
+	if (!serializeOk) {
+		return { error: `SerializeInstancesAsync failed: ${tostring(serializeResult)}` };
+	}
+
+	const buf = serializeResult as buffer;
+	const [encodeOk, encodeResult] = pcall(() => EncodingService.Base64Encode(buf));
+	if (!encodeOk) {
+		return { error: `EncodingService:Base64Encode failed: ${tostring(encodeResult)}` };
+	}
+	// Base64Encode returns a buffer of ASCII bytes; convert to a Lua string so
+	// HttpService:JSONEncode (called by the harness in Communication.ts) accepts
+	// it. Base64 is by definition pure ASCII so this round-trips cleanly.
+	const base64Str = buffer.tostring(encodeResult as buffer);
+
+	return {
+		base64: base64Str,
+		instance_count: instances.size(),
+	};
+}
+
+function importRbxm(requestData: Record<string, unknown>): unknown {
+	const b64 = requestData.base64 as string | undefined;
+	const parentPath = requestData.parent_path as string | undefined;
+	const sourceLabel = (requestData.source_label as string | undefined) ?? "unknown";
+
+	if (!b64 || !typeIs(b64, "string")) {
+		return { error: "base64 payload is required" };
+	}
+	if (!parentPath || !typeIs(parentPath, "string")) {
+		return { error: "parent_path is required" };
+	}
+
+	const parentInstance = getInstanceByPath(parentPath);
+	if (!parentInstance) {
+		return { error: `parent instance not found: ${parentPath}` };
+	}
+
+	// b64 is an ASCII-only Lua string from the wire; lift it into a buffer for
+	// EncodingService:Base64Decode, which returns a buffer of raw rbxm bytes
+	// ready for DeserializeInstancesAsync.
+	const [b64BufOk, b64BufResult] = pcall(() => buffer.fromstring(b64));
+	if (!b64BufOk) {
+		return { error: `buffer.fromstring(base64) failed: ${tostring(b64BufResult)}` };
+	}
+	const [decodeOk, decodeResult] = pcall(() => EncodingService.Base64Decode(b64BufResult as buffer));
+	if (!decodeOk) {
+		return { error: `EncodingService:Base64Decode failed: ${tostring(decodeResult)}` };
+	}
+	const buf = decodeResult as buffer;
+
+	const [deserOk, deserResult] = pcall(() => {
+		return SerializationService.DeserializeInstancesAsync(buf);
+	});
+	if (!deserOk) {
+		return { error: `DeserializeInstancesAsync failed: ${tostring(deserResult)}` };
+	}
+	const deserialized = deserResult as Instance[];
+
+	// All-or-nothing parenting. Track every instance we've attached and roll back
+	// (unparent + Destroy) if any later one fails - partial imports leave the DM
+	// in a worse state than failing cleanly.
+	const isEdit = !RunService.IsRunning();
+	const recordingId = isEdit ? beginRecording(`Import rbxm`) : undefined;
+
+	const attached: Instance[] = [];
+	let failureMessage: string | undefined;
+	for (const inst of deserialized) {
+		const [parentOk, parentErr] = pcall(() => {
+			inst.Parent = parentInstance;
+		});
+		if (!parentOk) {
+			failureMessage = `failed to parent ${inst.Name} (${inst.ClassName}) under ${parentPath}: ${tostring(parentErr)}`;
+			break;
+		}
+		attached.push(inst);
+	}
+
+	if (failureMessage !== undefined) {
+		for (const inst of attached) {
+			pcall(() => {
+				inst.Parent = undefined;
+				inst.Destroy();
+			});
+		}
+		// Also destroy any unparented deserialized instances so they don't leak.
+		for (const inst of deserialized) {
+			if (inst.Parent === undefined) {
+				pcall(() => inst.Destroy());
+			}
+		}
+		finishRecording(recordingId, false);
+		return { error: failureMessage };
+	}
+
+	const names: string[] = [];
+	const paths: string[] = [];
+	for (const inst of attached) {
+		names.push(inst.Name);
+		paths.push(getInstancePath(inst));
+	}
+
+	// The recording shows "MCP: Import rbxm" in Studio's undo stack -
+	// ChangeHistoryService doesn't expose a way to set a richer displayName
+	// after TryBeginRecording, so the count/source only land in the JSON response.
+	finishRecording(recordingId, true);
+
+	return {
+		instance_count: attached.size(),
+		instance_names: names,
+		instance_paths: paths,
+		parent_path: parentPath,
+		source: sourceLabel,
+	};
+}
+
+export = {
+	exportRbxm,
+	importRbxm,
+};

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

@@ -1,5 +1,5 @@
 import { HttpService, LogService } from "@rbxts/services";
-import { installBridges, cleanupBridges, loadStringEnabled } from "../EvalBridges";
+import { installBridges, cleanupBridges } from "../EvalBridges";
 
 const StudioTestService = game.GetService("StudioTestService");
 const ServerScriptService = game.GetService("ServerScriptService");
@@ -159,7 +159,6 @@ function startPlaytest(requestData: Record<string, unknown>) {
 	// so eval_server_runtime / eval_client_runtime work without manual setup.
 	// Bridges are cleaned up from the edit DM after the play DMs tear down.
 	const bridgeInstall = installBridges();
-	const hasLoadString = loadStringEnabled();
 	if (!bridgeInstall.installed) {
 		warn(`[MCP] Eval bridge install failed: ${bridgeInstall.error}`);
 	}
@@ -203,17 +202,6 @@ function startPlaytest(requestData: Record<string, unknown>) {
 		evalBridges: bridgeInstall.installed ? "installed" : `failed: ${bridgeInstall.error}`,
 	};
 
-	// Surface loadstring availability up-front so callers know whether
-	// eval_server_runtime will work before they try it. eval_client_runtime
-	// doesn't need loadstring (it uses ModuleScript+require), so this only
-	// affects the server bridge.
-	if (!hasLoadString) {
-		response.serverEvalNote =
-			"ServerScriptService.LoadStringEnabled is false. eval_server_runtime will not work " +
-			"until you enable it (ServerScriptService > Properties > LoadStringEnabled = true) " +
-			"and restart the playtest. eval_client_runtime is unaffected.";
-	}
-
 	return response;
 }
 

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

@@ -13,8 +13,13 @@ UI.init(plugin);
 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 = plugin.CreateToolbar("__TOOLBAR_NAME__");
-const button = toolbar.CreateButton("__BUTTON_TITLE__", "__BUTTON_TOOLTIP__", "rbxassetid://__BUTTON_ICON_ID__");
+const button = toolbar.CreateButton("__BUTTON_TITLE__", "__BUTTON_TOOLTIP__", ICON_DISCONNECTED);
+UI.setToolbarButton(button, { disconnected: ICON_DISCONNECTED, connecting: ICON_CONNECTING, connected: ICON_CONNECTED });
 
 
 elements.connectButton.Activated.Connect(() => {