@chrrxs/robloxstudio-mcp-inspector 2.16.4 → 2.17.1

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

@@ -0,0 +1,386 @@
+const HttpService = game.GetService("HttpService");
+const Players = game.GetService("Players");
+const RunService = game.GetService("RunService");
+
+interface ScriptProfilerServiceLike extends Instance {
+	ServerStart(this: ScriptProfilerServiceLike, frequency?: number): void;
+	ServerStop(this: ScriptProfilerServiceLike): void;
+	ServerRequestData(this: ScriptProfilerServiceLike): void;
+	ClientStart(this: ScriptProfilerServiceLike, player: Player, frequency?: number): void;
+	ClientStop(this: ScriptProfilerServiceLike, player: Player): void;
+	ClientRequestData(this: ScriptProfilerServiceLike, player: Player): void;
+	OnNewData: RBXScriptSignal<(player: Player | undefined, jsonString: string) => void>;
+}
+
+interface CategoryInfo {
+	Name?: string;
+	NodeId?: number;
+}
+
+interface FunctionInfo {
+	Source?: string;
+	Name?: string;
+	Line?: number;
+	TotalDuration?: number;
+	Flags?: number;
+}
+
+interface ProfilingInfo {
+	Version?: number;
+	SessionStartTime?: number;
+	SessionEndTime?: number;
+	Categories?: CategoryInfo[];
+	Nodes?: unknown[];
+	Functions?: FunctionInfo[];
+}
+
+interface FunctionRow {
+	function_index: number;
+	name: string;
+	source?: string;
+	line?: number;
+	total_us: number;
+	is_native?: boolean;
+	is_plugin?: boolean;
+	is_debug_label?: boolean;
+}
+
+const DEFAULT_DURATION_MS = 1000;
+const MIN_DURATION_MS = 100;
+const MAX_DURATION_MS = 15000;
+const DEFAULT_FREQUENCY = 1000;
+const DEFAULT_MAX_FUNCTIONS = 20;
+
+function getProfilerService(): ScriptProfilerServiceLike | Record<string, unknown> {
+	const provider = game as unknown as { GetService(serviceName: string): Instance };
+	const [ok, service] = pcall(() => provider.GetService("ScriptProfilerService") as ScriptProfilerServiceLike);
+	if (!ok || !service) {
+		return {
+			error: "script_profiler_unavailable",
+			message: `ScriptProfilerService is unavailable: ${tostring(service)}`,
+		};
+	}
+	return service;
+}
+
+function normalizeDurationMs(value: unknown): number {
+	if (!typeIs(value, "number")) return DEFAULT_DURATION_MS;
+	return math.clamp(math.floor(value), MIN_DURATION_MS, MAX_DURATION_MS);
+}
+
+function normalizeFrequency(value: unknown): number {
+	if (!typeIs(value, "number")) return DEFAULT_FREQUENCY;
+	return math.clamp(math.floor(value), 1, 10000);
+}
+
+function normalizeMaxFunctions(value: unknown): number {
+	if (!typeIs(value, "number")) return DEFAULT_MAX_FUNCTIONS;
+	return math.clamp(math.floor(value), 1, 100);
+}
+
+function normalizeMinTotalUs(requestData: Record<string, unknown>): number {
+	const value = requestData.min_total_us;
+	if (typeIs(value, "number")) return math.max(0, value);
+	return 0;
+}
+
+function stringContains(haystack: string, needle: string): boolean {
+	return string.find(string.lower(haystack), string.lower(needle), 1, true)[0] !== undefined;
+}
+
+function localPlayer(): Player | undefined {
+	let player = Players.LocalPlayer;
+	const started = tick();
+	while (!player && tick() - started < 5) {
+		task.wait(0.05);
+		player = Players.LocalPlayer;
+	}
+	return player;
+}
+
+function functionDisplayName(func: FunctionInfo): string {
+	if (typeIs(func.Name, "string") && func.Name !== "") return func.Name;
+	if (typeIs(func.Source, "string") && func.Source !== "") {
+		if (typeIs(func.Line, "number") && func.Line > 0) return `${func.Source}:${func.Line}`;
+		return func.Source;
+	}
+	return "<anonymous>";
+}
+
+function flagsOf(func: FunctionInfo): number {
+	return typeIs(func.Flags, "number") ? func.Flags : 0;
+}
+
+function isNativeFunction(func: FunctionInfo): boolean {
+	return bit32.band(flagsOf(func), 1) !== 0;
+}
+
+function isPluginFunction(func: FunctionInfo): boolean {
+	if (bit32.band(flagsOf(func), 2) !== 0) return true;
+	return typeIs(func.Source, "string") && string.find(func.Source, "MCPPlugin", 1, true)[0] !== undefined;
+}
+
+function isDebugLabel(func: FunctionInfo, filter: string | undefined): boolean {
+	if (filter === undefined) return false;
+	if (!typeIs(func.Name, "string") || func.Name === "") return false;
+	if (!typeIs(func.Source, "string") || func.Source === "" || func.Source === "[C]" || func.Source === "GC") return false;
+	if (func.Line !== undefined && func.Line !== 0) return false;
+	if (isNativeFunction(func) || isPluginFunction(func)) return false;
+	return stringContains(func.Name, filter) || stringContains(func.Source, filter);
+}
+
+function pctOfCapture(row: FunctionRow, durationMs: number): number | undefined {
+	const captureUs = durationMs * 1000;
+	if (captureUs <= 0) return undefined;
+	return math.floor((row.total_us / captureUs) * 10000 + 0.5) / 100;
+}
+
+function compactFunction(row: FunctionRow, rank: number, durationMs: number): Record<string, unknown> {
+	const out: Record<string, unknown> = {
+		rank,
+		function_index: row.function_index,
+		name: row.name,
+		total_us: math.floor(row.total_us + 0.5),
+	};
+	const pct = pctOfCapture(row, durationMs);
+	if (pct !== undefined) out.pct_of_capture = pct;
+	if (row.source !== undefined) out.source = row.source;
+	if (row.line !== undefined) out.line = row.line;
+	if (row.is_native === true) out.is_native = true;
+	if (row.is_plugin === true) out.is_plugin = true;
+	if (row.is_debug_label === true) out.is_debug_label = true;
+	return out;
+}
+
+function summarizeProfile(
+	rawJson: string,
+	profile: ProfilingInfo,
+	requestData: Record<string, unknown>,
+	durationMs: number,
+	frequency: number,
+	eventPlayerName: string | undefined,
+): Record<string, unknown> {
+	const funcs = typeIs(profile.Functions, "table") ? profile.Functions : [];
+	const nodes = typeIs(profile.Nodes, "table") ? profile.Nodes : [];
+	const categories = typeIs(profile.Categories, "table") ? profile.Categories : [];
+	const maxFunctions = normalizeMaxFunctions(requestData.max_functions);
+	const minTotalUs = normalizeMinTotalUs(requestData);
+	const includeNative = requestData.include_native === true;
+	const includePlugin = requestData.include_plugin === true;
+	const filter = typeIs(requestData.filter, "string") && requestData.filter !== "" ? requestData.filter as string : undefined;
+
+	const rows: FunctionRow[] = [];
+	const debugRows: FunctionRow[] = [];
+	let omittedNative = 0;
+	let omittedPlugin = 0;
+	let omittedBelowThreshold = 0;
+	let omittedByFilter = 0;
+
+	for (let i = 0; i < funcs.size(); i++) {
+		const func = funcs[i];
+		if (!typeIs(func, "table")) continue;
+		const info = func as FunctionInfo;
+		const totalUs = typeIs(info.TotalDuration, "number") ? info.TotalDuration : 0;
+		const name = functionDisplayName(info);
+		const row: FunctionRow = {
+			function_index: i + 1,
+			name,
+			source: typeIs(info.Source, "string") ? info.Source : undefined,
+			line: typeIs(info.Line, "number") ? info.Line : undefined,
+			total_us: totalUs,
+			is_native: isNativeFunction(info) ? true : undefined,
+			is_plugin: isPluginFunction(info) ? true : undefined,
+			is_debug_label: isDebugLabel(info, filter) ? true : undefined,
+		};
+
+		if (!includeNative && row.is_native === true) {
+			omittedNative += 1;
+			continue;
+		}
+		if (!includePlugin && row.is_plugin === true) {
+			omittedPlugin += 1;
+			continue;
+		}
+		if (totalUs < minTotalUs) {
+			omittedBelowThreshold += 1;
+			continue;
+		}
+		if (filter !== undefined) {
+			const text = `${row.name} ${row.source ?? ""}`;
+			if (!stringContains(text, filter)) {
+				omittedByFilter += 1;
+				continue;
+			}
+		}
+		rows.push(row);
+		if (row.is_debug_label === true) debugRows.push(row);
+	}
+
+	rows.sort((a, b) => a.total_us > b.total_us);
+	debugRows.sort((a, b) => a.total_us > b.total_us);
+
+	const topFunctions: Record<string, unknown>[] = [];
+	for (let i = 0; i < math.min(maxFunctions, rows.size()); i++) {
+		topFunctions.push(compactFunction(rows[i], i + 1, durationMs));
+	}
+
+	const debugLabels: Record<string, unknown>[] = [];
+	for (let i = 0; i < math.min(maxFunctions, debugRows.size()); i++) {
+		debugLabels.push(compactFunction(debugRows[i], i + 1, durationMs));
+	}
+
+	const categoryNames: string[] = [];
+	for (let i = 0; i < categories.size(); i++) {
+		const category = categories[i];
+		if (typeIs(category, "table")) {
+			const name = (category as CategoryInfo).Name;
+			if (typeIs(name, "string")) categoryNames.push(name);
+		}
+	}
+
+	const omitted: Record<string, number> = {};
+	let hasOmitted = false;
+	if (omittedNative > 0) {
+		omitted.native = omittedNative;
+		hasOmitted = true;
+	}
+	if (omittedPlugin > 0) {
+		omitted.plugin = omittedPlugin;
+		hasOmitted = true;
+	}
+	if (omittedBelowThreshold > 0) {
+		omitted.below_min_total_us = omittedBelowThreshold;
+		hasOmitted = true;
+	}
+	if (omittedByFilter > 0) {
+		omitted.filtered_out = omittedByFilter;
+		hasOmitted = true;
+	}
+
+	const result: Record<string, unknown> = {
+		ok: true,
+		duration_ms: durationMs,
+		frequency,
+		applied: {
+			filter: filter ?? undefined,
+			min_total_us: minTotalUs,
+			include_native: includeNative,
+			include_plugin: includePlugin,
+			max_functions: maxFunctions,
+			sort: "total_us_desc",
+		},
+		json_bytes: rawJson.size(),
+		counts: {
+			categories: categories.size(),
+			nodes: nodes.size(),
+			functions: funcs.size(),
+		},
+		top_functions: topFunctions,
+		debug_labels: debugLabels,
+	};
+	if (categoryNames.size() > 0) result.categories = categoryNames;
+	if (hasOmitted) result.omitted = omitted;
+	if (profile.Version !== undefined) result.version = profile.Version;
+	if (profile.SessionStartTime !== undefined || profile.SessionEndTime !== undefined) {
+		result.session = {
+			start_time: profile.SessionStartTime,
+			end_time: profile.SessionEndTime,
+		};
+	}
+	if (eventPlayerName !== undefined) result.player = eventPlayerName;
+	if (requestData.__mcp_include_raw_json === true) result.raw_json = rawJson;
+	return result;
+}
+
+function captureScriptProfiler(requestData: Record<string, unknown>): unknown {
+	if (!RunService.IsRunning()) {
+		return {
+			error: "runtime_target_required",
+			message: "Script profiler capture requires a running playtest target such as target=\"server\" or target=\"client-1\".",
+		};
+	}
+
+	const serviceOrError = getProfilerService();
+	if (!serviceOrError.IsA) return serviceOrError;
+	const service = serviceOrError as ScriptProfilerServiceLike;
+
+	const durationMs = normalizeDurationMs(requestData.duration_ms);
+	const frequency = normalizeFrequency(requestData.frequency);
+	const isServer = RunService.IsServer();
+	const isClient = RunService.IsClient() && !isServer;
+	const player = isClient ? localPlayer() : undefined;
+	if (!isServer && !player) {
+		return {
+			error: "client_player_unavailable",
+			message: "Could not resolve Players.LocalPlayer for client profiling.",
+		};
+	}
+
+	let rawJson: string | undefined;
+	let eventPlayerName: string | undefined;
+	const connection = service.OnNewData.Connect((playerArg: Player | undefined, jsonString: string) => {
+		if (rawJson !== undefined) return;
+		rawJson = jsonString;
+		if (playerArg) eventPlayerName = playerArg.Name;
+	});
+
+	const [startOk, startErr] = pcall(() => {
+		if (isServer) {
+			service.ServerStart(frequency);
+		} else {
+			service.ClientStart(player!, frequency);
+		}
+	});
+	if (!startOk) {
+		connection.Disconnect();
+		return {
+			error: "script_profiler_start_failed",
+			message: tostring(startErr),
+		};
+	}
+
+	task.wait(durationMs / 1000);
+
+	const [stopOk, stopErr] = pcall(() => {
+		if (isServer) {
+			service.ServerStop();
+			service.ServerRequestData();
+		} else {
+			service.ClientStop(player!);
+			service.ClientRequestData(player!);
+		}
+	});
+	if (!stopOk) {
+		connection.Disconnect();
+		return {
+			error: "script_profiler_stop_failed",
+			message: tostring(stopErr),
+		};
+	}
+
+	const requestedAt = tick();
+	while (rawJson === undefined && tick() - requestedAt < 5) {
+		task.wait(0.05);
+	}
+	connection.Disconnect();
+
+	if (rawJson === undefined) {
+		return {
+			error: "script_profiler_data_timeout",
+			message: "ScriptProfilerService did not emit OnNewData after requesting profiler data.",
+		};
+	}
+
+	const [decodeOk, decoded] = pcall(() => HttpService.JSONDecode(rawJson!));
+	if (!decodeOk) {
+		return {
+			error: "script_profiler_decode_failed",
+			message: tostring(decoded),
+			json_bytes: rawJson.size(),
+		};
+	}
+
+	return summarizeProfile(rawJson, decoded as ProfilingInfo, requestData, durationMs, frequency, eventPlayerName);
+}
+
+export = { captureScriptProfiler };

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

@@ -1,4 +1,4 @@
-import { HttpService, LogService, Players, RunService } from "@rbxts/services";
+import { HttpService, Players, RunService } from "@rbxts/services";
 import StopPlayMonitor from "../StopPlayMonitor";
 
 interface StudioTestServiceMultiplayer extends StudioTestService {
@@ -10,29 +10,8 @@ interface StudioTestServiceMultiplayer extends StudioTestService {
 }
 
 const StudioTestService = game.GetService("StudioTestService") as StudioTestServiceMultiplayer;
-const ServerScriptService = game.GetService("ServerScriptService");
-const ScriptEditorService = game.GetService("ScriptEditorService");
-
-// 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__";
-
-interface OutputEntry {
-	message: string;
-	messageType: string;
-	timestamp: number;
-}
 
 let testRunning = false;
-let outputBuffer: OutputEntry[] = [];
-let logConnection: RBXScriptConnection | undefined;
-let testResult: unknown;
-let testError: string | undefined;
-let stopListenerScript: Script | undefined;
-let navResultCallback: ((json: string) => void) | undefined;
 
 type MultiplayerPhase = "idle" | "starting" | "running" | "completed" | "failed";
 
@@ -87,95 +66,6 @@ function normalizeNumPlayers(value: unknown): number | undefined {
 	return n;
 }
 
-function buildCommandListenerSource(): string {
-	return `local LogService = game:GetService("LogService")
-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 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)
-			if not ok or not d then
-				print(NAV_RES .. ':{"success":false,"error":"parse_error"}')
-				return
-			end
-			local ps = Players:GetPlayers()
-			if #ps == 0 then
-				print(NAV_RES .. ':{"success":false,"error":"no_players"}')
-				return
-			end
-			local char = ps[1].Character or ps[1].CharacterAdded:Wait()
-			local hum = char:FindFirstChildOfClass("Humanoid")
-			local root = char:FindFirstChild("HumanoidRootPart")
-			if not hum or not root then
-				print(NAV_RES .. ':{"success":false,"error":"no_humanoid"}')
-				return
-			end
-			local target
-			if d.instancePath then
-				local parts = string.split(d.instancePath, ".")
-				local cur = game
-				for i = 2, #parts do
-					cur = cur:FindFirstChild(parts[i])
-					if not cur then
-						print(NAV_RES .. ':{"success":false,"error":"instance_not_found"}')
-						return
-					end
-				end
-				if cur:IsA("BasePart") then target = cur.Position
-				elseif cur:IsA("Model") and cur.PrimaryPart then target = cur.PrimaryPart.Position
-				else target = cur:GetPivot().Position end
-			else
-				target = Vector3.new(d.x or 0, d.y or 0, d.z or 0)
-			end
-			local path = PathfindingService:CreatePath({AgentRadius=2,AgentHeight=5,AgentCanJump=true})
-			local pok = pcall(function() path:ComputeAsync(root.Position, target) end)
-			local method = "direct"
-			if pok and path.Status == Enum.PathStatus.Success then
-				method = "pathfinding"
-				for _, wp in ipairs(path:GetWaypoints()) do
-					hum:MoveTo(wp.Position)
-					if wp.Action == Enum.PathWaypointAction.Jump then hum.Jump = true end
-					hum.MoveToFinished:Wait()
-				end
-			else
-				hum:MoveTo(target)
-				hum.MoveToFinished:Wait()
-			end
-			local fp = root.Position
-			print(NAV_RES .. ':{"success":true,"method":"' .. method .. '","position":[' .. fp.X .. ',' .. fp.Y .. ',' .. fp.Z .. ']}')
-		end)
-	end
-end)`;
-}
-
-function injectStopListener() {
-	const listener = new Instance("Script");
-	listener.Name = "__MCP_CommandListener";
-	listener.Parent = ServerScriptService;
-
-	const source = buildCommandListenerSource();
-	const [seOk] = pcall(() => {
-		ScriptEditorService.UpdateSourceAsync(listener, () => source);
-	});
-	if (!seOk) {
-		(listener as unknown as { Source: string }).Source = source;
-	}
-
-	stopListenerScript = listener;
-}
-
-function cleanupStopListener() {
-	if (stopListenerScript) {
-		pcall(() => stopListenerScript!.Destroy());
-		stopListenerScript = undefined;
-	}
-}
-
 function startPlaytest(requestData: Record<string, unknown>) {
 	const mode = requestData.mode as string | undefined;
 	const numPlayers = requestData.numPlayers as number | undefined;
@@ -194,11 +84,6 @@ function startPlaytest(requestData: Record<string, unknown>) {
 	// 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();
 		// Runtime eval bridges are created by the play server/client plugin
 		// peers and disappear with the play DataModels.
 	}
@@ -208,31 +93,6 @@ function startPlaytest(requestData: Record<string, unknown>) {
 	}
 
 	testRunning = true;
-	outputBuffer = [];
-	testResult = undefined;
-	testError = undefined;
-
-	cleanupStopListener();
-
-	logConnection = LogService.MessageOut.Connect((message, messageType) => {
-		if (message.sub(1, NAV_SIGNAL.size()) === NAV_SIGNAL) return;
-		if (message.sub(1, NAV_RESULT.size() + 1) === `${NAV_RESULT}:`) {
-			if (navResultCallback) {
-				navResultCallback(message.sub(NAV_RESULT.size() + 2));
-			}
-			return;
-		}
-		outputBuffer.push({
-			message,
-			messageType: messageType.Name,
-			timestamp: tick(),
-		});
-	});
-
-	const [injected, injErr] = pcall(() => injectStopListener());
-	if (!injected) {
-		warn(`[robloxstudio-mcp] Failed to inject stop listener: ${injErr}`);
-	}
 
 	task.spawn(() => {
 		const [ok, result] = pcall(() => {
@@ -242,19 +102,11 @@ function startPlaytest(requestData: Record<string, unknown>) {
 			return StudioTestService.ExecuteRunModeAsync({});
 		});
 
-		if (ok) {
-			testResult = result;
-		} else {
-			testError = tostring(result);
+		if (!ok) {
+			warn(`[robloxstudio-mcp] Playtest ended with error: ${result}`);
 		}
 
-		if (logConnection) {
-			logConnection.Disconnect();
-			logConnection = undefined;
-		}
 		testRunning = false;
-
-		cleanupStopListener();
 	});
 
 	const response: Record<string, unknown> = {
@@ -324,16 +176,6 @@ function stopPlaytest(_requestData: Record<string, unknown>) {
 	return { success: true, message: "Playtest stopped." };
 }
 
-function getPlaytestOutput(_requestData: Record<string, unknown>) {
-	return {
-		isRunning: testRunning,
-		output: [...outputBuffer],
-		outputCount: outputBuffer.size(),
-		testResult: testResult !== undefined ? tostring(testResult) : undefined,
-		testError,
-	};
-}
-
 function multiplayerTestStart(requestData: Record<string, unknown>) {
 	if (RunService.IsRunning()) {
 		return { error: "multiplayer_test_start must be called on the edit DataModel. Route with target=edit." };
@@ -497,60 +339,12 @@ function multiplayerTestEnd(requestData: Record<string, unknown>) {
 	};
 }
 
-function characterNavigation(requestData: Record<string, unknown>) {
-	if (!testRunning) {
-		return { error: "Playtest must be running. Start a playtest in 'play' mode first." };
-	}
-
-	const position = requestData.position as number[] | undefined;
-	const instancePath = requestData.instancePath as string | undefined;
-	const waitForCompletion = (requestData.waitForCompletion as boolean) ?? true;
-	const timeout = (requestData.timeout as number) ?? 25;
-
-	if (!position && !instancePath) {
-		return { error: "Either position [x, y, z] or instancePath is required" };
-	}
-
-	let navData: string;
-	if (position) {
-		navData = HttpService.JSONEncode({ x: position[0], y: position[1], z: position[2] });
-	} else {
-		navData = HttpService.JSONEncode({ instancePath });
-	}
-
-	warn(`${NAV_SIGNAL}:${navData}`);
-
-	if (!waitForCompletion) {
-		return { success: true, message: "Navigation command sent" };
-	}
-
-	let result: string | undefined;
-	navResultCallback = (json: string) => {
-		result = json;
-	};
-
-	const startTime = tick();
-	while (!result && tick() - startTime < timeout) {
-		task.wait(0.2);
-	}
-	navResultCallback = undefined;
-
-	if (result) {
-		const [ok, parsed] = pcall(() => HttpService.JSONDecode(result!));
-		if (ok) return parsed;
-		return { success: true, rawResult: result };
-	}
-	return { error: `Navigation timed out after ${timeout} seconds` };
-}
-
 export = {
 	startPlaytest,
 	stopPlaytest,
-	getPlaytestOutput,
 	multiplayerTestStart,
 	multiplayerTestState,
 	multiplayerTestAddPlayers,
 	multiplayerTestLeaveClient,
 	multiplayerTestEnd,
-	characterNavigation,
 };

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

@@ -6,6 +6,7 @@ import ServerUrlSettings from "../modules/ServerUrlSettings";
 import { cleanupLegacyEditBridges, ensureRuntimeBridgeInstalled } from "../modules/EvalBridges";
 import RuntimeLogBuffer from "../modules/RuntimeLogBuffer";
 import StopPlayMonitor from "../modules/StopPlayMonitor";
+import BreakpointHandlers from "../modules/handlers/BreakpointHandlers";
 import * as RenderMonitor from "../modules/RenderMonitor";
 
 // Track render-loop liveness so input/screenshot tools can report "window
@@ -22,8 +23,22 @@ RuntimeLogBuffer.install();
 // edit DM (write the flag) and the play-server DM (read+act on the flag) can
 // access plugin:SetSetting/GetSetting.
 StopPlayMonitor.init(plugin);
+BreakpointHandlers.init(plugin);
 ServerUrlSettings.init(plugin);
 
+function applyRememberedServerUrl(): void {
+	const rememberedServerUrl = ServerUrlSettings.readServerUrl();
+	if (rememberedServerUrl === undefined) return;
+
+	const conn = State.getActiveConnection();
+	conn.serverUrl = rememberedServerUrl;
+	const port = ServerUrlSettings.extractPort(rememberedServerUrl);
+	if (port !== undefined) conn.port = port;
+	ClientBroker.setServerUrl(rememberedServerUrl);
+}
+
+applyRememberedServerUrl();
+
 UI.init(plugin);
 const elements = UI.getElements();
 
@@ -91,11 +106,11 @@ task.delay(2, () => {
 			if (conn && !conn.isActive) {
 				if (role === "server") {
 					const inheritedServerUrl = ServerUrlSettings.readServerUrl() ?? ClientBroker.DEFAULT_MCP_URL;
-					conn.serverUrl = inheritedServerUrl;
-					elements.urlInput.Text = inheritedServerUrl;
-					const [portStr] = conn.serverUrl.match(":(%d+)$");
-					if (portStr) conn.port = tonumber(portStr) ?? conn.port;
-					ClientBroker.setServerUrl(inheritedServerUrl);
+					conn.serverUrl = ServerUrlSettings.normalizeServerUrl(inheritedServerUrl);
+					elements.urlInput.Text = conn.serverUrl;
+					const port = ServerUrlSettings.extractPort(conn.serverUrl);
+					if (port !== undefined) conn.port = port;
+					ClientBroker.setServerUrl(conn.serverUrl);
 				}
 				// Defensive default: in invisible play-DM UIs, the input field
 				// may not be populated by the time we activate.