@chrrxs/robloxstudio-mcp 2.16.4 → 2.17.1

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

@@ -5,6 +5,8 @@ import SceneAnalysisHandlers from "./handlers/SceneAnalysisHandlers";
 import CaptureHandlers from "./handlers/CaptureHandlers";
 import InputHandlers from "./handlers/InputHandlers";
 import EvalRuntimeHandlers from "./handlers/EvalRuntimeHandlers";
+import BreakpointHandlers from "./handlers/BreakpointHandlers";
+import ScriptProfilerHandlers from "./handlers/ScriptProfilerHandlers";
 import LuauExec from "./LuauExec";
 import State from "./State";
 import HttpDiagnostics from "./HttpDiagnostics";
@@ -94,6 +96,8 @@ const CLIENT_BROKER_ALLOWED_ENDPOINTS = new Set<string>([
 	"/api/get-runtime-logs",
 	"/api/get-memory-breakdown",
 	"/api/get-scene-analysis",
+	"/api/breakpoints",
+	"/api/capture-script-profiler",
 	"/api/multiplayer-test-state",
 	"/api/multiplayer-test-leave-client",
 	// Screenshot capture must run in the client peer (CaptureService captures
@@ -266,6 +270,12 @@ function setupClientBroker() {
 		if (payload && payload.endpoint === "/api/get-scene-analysis") {
 			return SceneAnalysisHandlers.getSceneAnalysis(payload.data ?? {});
 		}
+		if (payload && payload.endpoint === "/api/breakpoints") {
+			return BreakpointHandlers.breakpoints(payload.data ?? {});
+		}
+		if (payload && payload.endpoint === "/api/capture-script-profiler") {
+			return ScriptProfilerHandlers.captureScriptProfiler(payload.data ?? {});
+		}
 		if (payload && payload.endpoint === "/api/multiplayer-test-state") {
 			return handleMultiplayerTestState();
 		}

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

@@ -17,6 +17,8 @@ import LogHandlers from "./handlers/LogHandlers";
 import SerializationHandlers from "./handlers/SerializationHandlers";
 import MemoryHandlers from "./handlers/MemoryHandlers";
 import SceneAnalysisHandlers from "./handlers/SceneAnalysisHandlers";
+import BreakpointHandlers from "./handlers/BreakpointHandlers";
+import ScriptProfilerHandlers from "./handlers/ScriptProfilerHandlers";
 import EvalRuntimeHandlers from "./handlers/EvalRuntimeHandlers";
 import ClientBroker from "./ClientBroker";
 import ServerUrlSettings from "./ServerUrlSettings";
@@ -109,7 +111,6 @@ const routeMap: Record<string, Handler> = {
 	"/api/grep-scripts": QueryHandlers.grepScripts,
 	"/api/get-descendants": QueryHandlers.getDescendants,
 	"/api/compare-instances": QueryHandlers.compareInstances,
-	"/api/get-output-log": QueryHandlers.getOutputLog,
 
 	"/api/set-property": PropertyHandlers.setProperty,
 	"/api/set-properties": PropertyHandlers.setProperties,
@@ -146,13 +147,11 @@ const routeMap: Record<string, Handler> = {
 
 	"/api/start-playtest": TestHandlers.startPlaytest,
 	"/api/stop-playtest": TestHandlers.stopPlaytest,
-	"/api/get-playtest-output": TestHandlers.getPlaytestOutput,
 	"/api/multiplayer-test-start": TestHandlers.multiplayerTestStart,
 	"/api/multiplayer-test-state": TestHandlers.multiplayerTestState,
 	"/api/multiplayer-test-add-players": TestHandlers.multiplayerTestAddPlayers,
 	"/api/multiplayer-test-leave-client": TestHandlers.multiplayerTestLeaveClient,
 	"/api/multiplayer-test-end": TestHandlers.multiplayerTestEnd,
-	"/api/character-navigation": TestHandlers.characterNavigation,
 
 	"/api/export-build": BuildHandlers.exportBuild,
 	"/api/import-build": BuildHandlers.importBuild,
@@ -171,6 +170,8 @@ const routeMap: Record<string, Handler> = {
 	"/api/find-and-replace-in-scripts": ScriptHandlers.findAndReplaceInScripts,
 
 	"/api/get-runtime-logs": LogHandlers.getRuntimeLogs,
+	"/api/breakpoints": BreakpointHandlers.breakpoints,
+	"/api/capture-script-profiler": ScriptProfilerHandlers.captureScriptProfiler,
 
 	"/api/export-rbxm": SerializationHandlers.exportRbxm,
 	"/api/import-rbxm": SerializationHandlers.importRbxm,
@@ -306,6 +307,7 @@ function sendReady(conn: Connection): void {
 		lastReadyInstanceId = parseOk && typeIs(readyData.instanceId, "string") && readyData.instanceId !== ""
 			? readyData.instanceId
 			: instanceId;
+		ServerUrlSettings.rememberServerUrl(conn.serverUrl);
 		const connectedRole = assignedRole ?? detectRole();
 		if (readyFailureLogKeys.has(readyLogKey)) {
 			readyFailureLogKeys.delete(readyLogKey);
@@ -501,13 +503,15 @@ function activatePlugin(connIndex?: number) {
 	conn.currentRetryDelay = 0.5;
 
 	if (idx === State.getActiveTabIndex()) {
-		conn.serverUrl = ui.urlInput.Text;
-		const [portStr] = conn.serverUrl.match(":(%d+)$");
-		if (portStr) conn.port = tonumber(portStr) ?? conn.port;
+		const normalizedUrl = ServerUrlSettings.normalizeServerUrl(ui.urlInput.Text);
+		conn.serverUrl = normalizedUrl !== "" ? normalizedUrl : conn.serverUrl;
+		if (conn.serverUrl === "") conn.serverUrl = ClientBroker.DEFAULT_MCP_URL;
+		ui.urlInput.Text = conn.serverUrl;
+		const port = ServerUrlSettings.extractPort(conn.serverUrl);
+		if (port !== undefined) conn.port = port;
 		UI.updateTabLabel(idx);
 		UI.updateUIState();
 	}
-	ServerUrlSettings.rememberServerUrl(conn.serverUrl);
 	UI.updateTabDot(idx);
 
 	if (!conn.heartbeatConnection) {

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

@@ -57,21 +57,47 @@ function dropOldestUntilFits(incomingBytes: number): void {
 	}
 }
 
+function pushEntry(msg: string, t: Enum.MessageType, ts = nowSec()): void {
+	const bytes = msg.size();
+	dropOldestUntilFits(bytes);
+	entries.push({
+		seq: nextSeq,
+		ts,
+		level: levelTag(t),
+		message: msg,
+	});
+	nextSeq += 1;
+	totalBytes += bytes;
+}
+
+interface LogHistoryEntry {
+	message: string;
+	messageType: Enum.MessageType;
+	timestamp: number;
+}
+
+function seedRuntimeHistory(): void {
+	if (!RunService.IsRunning()) return;
+
+	const [ok, history] = pcall(() => LogService.GetLogHistory() as LogHistoryEntry[]);
+	if (!ok) return;
+
+	for (const entry of history) {
+		if (!typeIs(entry.message, "string")) continue;
+		pushEntry(entry.message, entry.messageType, typeIs(entry.timestamp, "number") ? entry.timestamp : undefined);
+	}
+}
+
 function install(): void {
 	if (installed) return;
 	if (!RunService.IsStudio()) return;
 	installed = true;
+	// Play peers can emit startup logs before the plugin finishes loading.
+	// Seed from per-DataModel LogHistory so get_runtime_logs can still see
+	// those early messages; skip edit mode to avoid stale prior-session logs.
+	seedRuntimeHistory();
 	LogService.MessageOut.Connect((msg, t) => {
-		const bytes = msg.size();
-		dropOldestUntilFits(bytes);
-		entries.push({
-			seq: nextSeq,
-			ts: nowSec(),
-			level: levelTag(t),
-			message: msg,
-		});
-		nextSeq += 1;
-		totalBytes += bytes;
+		pushEntry(msg, t);
 	});
 }
 

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

@@ -1,6 +1,8 @@
 import { HttpService, ServerStorage } from "@rbxts/services";
 
-const SETTING_KEY_PREFIX = "MCP_SERVER_URL_";
+const LEGACY_SETTING_KEY_PREFIX = "MCP_SERVER_URL_";
+const SETTING_KEY_PREFIX = "MCP_LAST_SUCCESSFUL_SERVER_URL_";
+const GLOBAL_SETTING_KEY = "MCP_LAST_SUCCESSFUL_SERVER_URL_GLOBAL_V1";
 
 let pluginRef: Plugin | undefined;
 
@@ -8,6 +10,31 @@ function init(p: Plugin): void {
 	pluginRef = p;
 }
 
+function normalizeServerUrl(serverUrl: string | undefined): string {
+	let normalized = (serverUrl ?? "").gsub("^%s+", "")[0].gsub("%s+$", "")[0];
+	if (normalized === "") return "";
+
+	if (normalized.match("^%a[%w+.-]*://")[0] === undefined) {
+		normalized = `http://${normalized}`;
+	}
+
+	while (
+		normalized.size() > 0 &&
+		normalized.sub(-1) === "/" &&
+		normalized.match("^%a[%w+.-]*://$")[0] === undefined
+	) {
+		normalized = normalized.sub(1, -2);
+	}
+
+	return normalized;
+}
+
+function extractPort(serverUrl: string): number | undefined {
+	const [portStr] = serverUrl.match(":(%d+)$");
+	if (portStr === undefined) return undefined;
+	return tonumber(portStr);
+}
+
 function addUnique(values: string[], value: string): void {
 	if (!values.includes(value)) {
 		values.push(value);
@@ -34,28 +61,54 @@ function settingKey(instanceId: string): string {
 	return SETTING_KEY_PREFIX + instanceId;
 }
 
+function legacySettingKey(instanceId: string): string {
+	return LEGACY_SETTING_KEY_PREFIX + instanceId;
+}
+
+function readSettingString(key: string): string | undefined {
+	if (!pluginRef) return undefined;
+	const [ok, value] = pcall(() => pluginRef!.GetSetting(key));
+	if (!ok || !typeIs(value, "string")) return undefined;
+
+	const normalized = normalizeServerUrl(value as string);
+	return normalized !== "" ? normalized : undefined;
+}
+
+function writeSettingString(key: string, serverUrl: string): void {
+	if (!pluginRef) return;
+	pcall(() => pluginRef!.SetSetting(key, serverUrl));
+}
+
 function rememberServerUrl(serverUrl: string): void {
-	if (!pluginRef || serverUrl === "") return;
+	const normalized = normalizeServerUrl(serverUrl);
+	if (!pluginRef || normalized === "") return;
+	writeSettingString(GLOBAL_SETTING_KEY, normalized);
 	for (const instanceId of computeInstanceIds()) {
-		const key = settingKey(instanceId);
-		pcall(() => pluginRef!.SetSetting(key, serverUrl));
+		writeSettingString(settingKey(instanceId), normalized);
+		writeSettingString(legacySettingKey(instanceId), normalized);
 	}
 }
 
 function readServerUrl(): string | undefined {
 	if (!pluginRef) return undefined;
 	for (const instanceId of computeInstanceIds()) {
-		const key = settingKey(instanceId);
-		const [ok, value] = pcall(() => pluginRef!.GetSetting(key));
-		if (ok && typeIs(value, "string") && value !== "") {
-			return value as string;
-		}
+		const remembered = readSettingString(settingKey(instanceId));
+		if (remembered !== undefined) return remembered;
 	}
+	const globalRemembered = readSettingString(GLOBAL_SETTING_KEY);
+	if (globalRemembered !== undefined) return globalRemembered;
+	for (const instanceId of computeInstanceIds()) {
+		const legacyRemembered = readSettingString(legacySettingKey(instanceId));
+		if (legacyRemembered !== undefined) return legacyRemembered;
+	}
+
 	return undefined;
 }
 
 export = {
 	init,
+	normalizeServerUrl,
+	extractPort,
 	rememberServerUrl,
 	readServerUrl,
 };

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

@@ -1,5 +1,6 @@
 import { TweenService } from "@rbxts/services";
 import State from "./State";
+import ServerUrlSettings from "./ServerUrlSettings";
 import { Connection } from "../types";
 
 interface UIElements {
@@ -473,7 +474,7 @@ function init(pluginRef: Plugin) {
 	urlInput.Size = new UDim2(1, 0, 0, 26);
 	urlInput.BackgroundColor3 = C.bg;
 	urlInput.BorderSizePixel = 0;
-	urlInput.Text = "http://localhost:58741";
+	urlInput.Text = State.getActiveConnection().serverUrl;
 	urlInput.TextColor3 = C.label;
 	urlInput.TextSize = 11;
 	urlInput.Font = Enum.Font.GothamMedium;
@@ -495,9 +496,15 @@ function init(pluginRef: Plugin) {
 	urlInput.FocusLost.Connect(() => {
 		const conn = State.getActiveConnection();
 		if (!conn || conn.isActive) return;
-		conn.serverUrl = urlInput.Text;
-		const [portStr] = conn.serverUrl.match(":(%d+)$");
-		if (portStr) conn.port = tonumber(portStr) ?? conn.port;
+		const normalizedUrl = ServerUrlSettings.normalizeServerUrl(urlInput.Text);
+		if (normalizedUrl === "") {
+			urlInput.Text = conn.serverUrl;
+			return;
+		}
+		conn.serverUrl = normalizedUrl;
+		urlInput.Text = normalizedUrl;
+		const port = ServerUrlSettings.extractPort(conn.serverUrl);
+		if (port !== undefined) conn.port = port;
 		updateTabLabel(State.getActiveTabIndex());
 	});
 

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

@@ -1,5 +1,11 @@
 const ScriptEditorService = game.GetService("ScriptEditorService");
 
+const LUAU_KEYWORDS = new Set<string>([
+	"and", "break", "continue", "do", "else", "elseif", "end", "export",
+	"false", "for", "function", "if", "in", "local", "nil", "not", "or",
+	"repeat", "return", "then", "true", "type", "until", "while",
+]);
+
 function safeCall<T>(func: (...args: never[]) => T, ...args: never[]): T | undefined {
 	const [success, result] = pcall(func, ...args);
 	if (success) {
@@ -10,6 +16,125 @@ function safeCall<T>(func: (...args: never[]) => T, ...args: never[]): T | undef
 	}
 }
 
+function isSimplePathSegment(segment: string): boolean {
+	return segment.match("^[%a_][%w_]*$")[0] !== undefined && !LUAU_KEYWORDS.has(segment);
+}
+
+function quotePathSegment(segment: string): string {
+	let escaped = segment.gsub("\\", "\\\\")[0];
+	escaped = escaped.gsub("\n", "\\n")[0];
+	escaped = escaped.gsub("\r", "\\r")[0];
+	escaped = escaped.gsub("\t", "\\t")[0];
+	escaped = escaped.gsub('"', '\\"')[0];
+	return `"${escaped}"`;
+}
+
+function unescapePathSegment(segment: string): string {
+	const chars: string[] = [];
+	let i = 1;
+	while (i <= segment.size()) {
+		const ch = segment.sub(i, i);
+		if (ch === "\\" && i < segment.size()) {
+			const nextChar = segment.sub(i + 1, i + 1);
+			if (nextChar === "n") {
+				chars.push("\n");
+			} else if (nextChar === "r") {
+				chars.push("\r");
+			} else if (nextChar === "t") {
+				chars.push("\t");
+			} else {
+				chars.push(nextChar);
+			}
+			i += 2;
+		} else {
+			chars.push(ch);
+			i += 1;
+		}
+	}
+	return chars.join("");
+}
+
+function isCanonicalBracketStart(path: string, index: number): boolean {
+	const quote = path.sub(index + 1, index + 1);
+	return (quote === '"' || quote === "'") && path.sub(index - 1, index - 1) !== ".";
+}
+
+function parseInstancePath(path: string): string[] | undefined {
+	let i = 1;
+	const len = path.size();
+	const parts: string[] = [];
+	let current = "";
+
+	if (path === "" || path === "game") return parts;
+	if (path.sub(1, 5) === "game.") {
+		i = 6;
+	} else if (path.sub(1, 5) === "game[") {
+		i = 5;
+	}
+
+	while (i <= len) {
+		const ch = path.sub(i, i);
+
+		if (ch === ".") {
+			if (current !== "") {
+				parts.push(current);
+				current = "";
+				i += 1;
+			} else if (i > 1 && path.sub(i - 1, i - 1) === "." && i < len && path.sub(i + 1, i + 1) !== "[") {
+				// Back-compat for previously emitted paths such as
+				// game.ServerScriptService..dir.ReproScript, where ".dir"
+				// was an actual instance name.
+				current = ".";
+				i += 1;
+			} else {
+				i += 1;
+			}
+		} else if (ch === "[" && i < len && isCanonicalBracketStart(path, i)) {
+			if (current !== "") {
+				parts.push(current);
+				current = "";
+			}
+
+			const quote = path.sub(i + 1, i + 1);
+			if (quote !== '"' && quote !== "'") return undefined;
+			let j = i + 2;
+			let raw = "";
+			while (j <= len) {
+				const c = path.sub(j, j);
+				if (c === "\\") {
+					if (j >= len) return undefined;
+					raw += c + path.sub(j + 1, j + 1);
+					j += 2;
+				} else if (c === quote) {
+					break;
+				} else {
+					raw += c;
+					j += 1;
+				}
+			}
+			if (j > len || path.sub(j, j) !== quote || path.sub(j + 1, j + 1) !== "]") return undefined;
+			parts.push(unescapePathSegment(raw));
+			i = j + 2;
+		} else {
+			current += ch;
+			i += 1;
+		}
+	}
+
+	if (current !== "") parts.push(current);
+	return parts;
+}
+
+function getRootSegment(instance: Instance): string {
+	if (instance.Parent === game) {
+		const [ok, service] = pcall(() => game.GetService(instance.ClassName as keyof Services));
+		if (ok && service === instance) {
+			return instance.ClassName;
+		}
+	}
+	return instance.Name;
+}
+
 function getInstancePath(instance: Instance): string {
 	if (!instance || instance === game) {
 		return "game";
@@ -19,26 +144,35 @@ function getInstancePath(instance: Instance): string {
 	let current: Instance | undefined = instance;
 
 	while (current && current !== game) {
-		pathParts.unshift(current.Name);
+		pathParts.unshift(getRootSegment(current));
 		current = current.Parent as Instance | undefined;
 	}
 
-	return `game.${pathParts.join(".")}`;
+	let path = "game";
+	for (const part of pathParts) {
+		if (isSimplePathSegment(part)) {
+			path += `.${part}`;
+		} else {
+			path += `[${quotePathSegment(part)}]`;
+		}
+	}
+	return path;
 }
 
-function getInstanceByPath(path: string): Instance | undefined {
-	if (path === "game" || path === "") {
-		return game;
-	}
+function getRootInstance(segment: string): Instance | undefined {
+	const [ok, service] = pcall(() => game.GetService(segment as keyof Services));
+	if (ok && service) return service as Instance;
+	return game.FindFirstChild(segment);
+}
 
-	const cleaned = path.gsub("^game%.", "")[0];
-	const parts: string[] = [];
-	for (const [part] of cleaned.gmatch("[^%.]+")) {
-		parts.push(part as string);
-	}
+function getInstanceByPath(path: string): Instance | undefined {
+	const parts = parseInstancePath(path);
+	if (parts === undefined) return undefined;
+	if (parts.size() === 0) return game;
 
-	let current: Instance | undefined = game;
-	for (const part of parts) {
+	let current: Instance | undefined = getRootInstance(parts[0]);
+	for (let i = 1; i < parts.size(); i++) {
+		const part = parts[i];
 		if (!current) return undefined;
 		current = current.FindFirstChild(part);
 	}