@chrrxs/robloxstudio-mcp 2.15.2 → 2.16.1

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

@@ -7,6 +7,7 @@ import InputHandlers from "./handlers/InputHandlers";
 import EvalRuntimeHandlers from "./handlers/EvalRuntimeHandlers";
 import LuauExec from "./LuauExec";
 import State from "./State";
+import HttpDiagnostics from "./HttpDiagnostics";
 
 interface StudioTestServiceMultiplayer extends StudioTestService {
 	CanLeaveTest(): boolean;
@@ -64,7 +65,8 @@ function resolvePlaceName(): string {
 // is gone: stop now uses StopPlayMonitor with plugin:SetSetting cross-DM
 // signaling, which works regardless of MCP server state.)
 
-const MCP_URL = "http://localhost:58741";
+const DEFAULT_MCP_URL = "http://localhost:58741";
+let mcpUrl = DEFAULT_MCP_URL;
 const BROKER_NAME = "__MCPClientBroker";
 const BROKER_OWNER_ATTRIBUTE = "__MCPBrokerOwner";
 
@@ -152,7 +154,7 @@ function forkRole(): "edit" | "server" | "client" {
 function postJson(endpoint: string, body: Record<string, unknown>) {
 	return pcall(() =>
 		HttpService.RequestAsync({
-			Url: `${MCP_URL}${endpoint}`,
+			Url: `${mcpUrl}${endpoint}`,
 			Method: "POST",
 			Headers: { "Content-Type": "application/json" },
 			Body: HttpService.JSONEncode(body),
@@ -160,6 +162,20 @@ function postJson(endpoint: string, body: Record<string, unknown>) {
 	);
 }
 
+function formatPostJsonFailure(endpoint: string, ok: boolean, res: unknown): string {
+	return HttpDiagnostics.formatRequestFailure(`${mcpUrl}${endpoint}`, ok, res);
+}
+
+function setServerUrl(serverUrl: string | undefined): void {
+	if (serverUrl !== undefined && serverUrl !== "") {
+		mcpUrl = serverUrl;
+	}
+}
+
+function getServerUrl(): string {
+	return mcpUrl;
+}
+
 function handleExecuteLuau(data: Record<string, unknown> | undefined) {
 	const code = data && (data.code as string | undefined);
 	if (typeIs(code, "string") === false || code === "") {
@@ -277,13 +293,14 @@ function setupClientBroker() {
 }
 
 const proxyByPlayer = new Map<Player, ProxyEntry>();
+const proxyRegisterFailuresByPlayer = new Set<Player>();
 let serverBrokerStarted = false;
 
 function pollProxy(proxyId: string, player: Player, rf: RemoteFunction) {
 	while (player.Parent !== undefined && proxyByPlayer.has(player)) {
 		const [ok, res] = pcall(() =>
 			HttpService.RequestAsync({
-				Url: `${MCP_URL}/poll?pluginSessionId=${proxyId}`,
+				Url: `${mcpUrl}/poll?pluginSessionId=${proxyId}`,
 				Method: "GET",
 				Headers: { "Content-Type": "application/json" },
 			}),
@@ -341,18 +358,23 @@ function registerProxy(player: Player, rf: RemoteFunction) {
 		pluginVariant: State.PLUGIN_VARIANT,
 	});
 	if (!ok || !res || !res.Success) {
-		warn(`[robloxstudio-mcp] proxy register failed for ${player.Name}`);
+		proxyRegisterFailuresByPlayer.add(player);
+		warn(`[robloxstudio-mcp] proxy register failed for ${player.Name}: ${formatPostJsonFailure("/ready", ok, res)}`);
 		return;
 	}
 	const body = HttpService.JSONDecode(res.Body) as ReadyResponseBody;
 	const assigned = body.assignedRole ?? "client";
 	proxyByPlayer.set(player, { pluginSessionId: proxyId, role: assigned });
+	if (proxyRegisterFailuresByPlayer.has(player)) {
+		proxyRegisterFailuresByPlayer.delete(player);
+		print(`[robloxstudio-mcp] proxy registered for ${player.Name} as ${assigned} via ${mcpUrl}`);
+	}
 	task.spawn(pollProxy, proxyId, player, rf);
 }
 
 // (Removed: startEditProxyLoop. The play-server DM no longer registers an
 // "edit-proxy" peer with the MCP server. stop_playtest now uses a cross-DM
-// plugin:SetSetting flag consumed by StopPlayMonitor in the play-server DM,
+// plugin:SetSetting request consumed by StopPlayMonitor in the play-server DM,
 // which doesn't depend on MCP server state or peer registration at all.)
 
 function setupServerBroker() {
@@ -377,6 +399,7 @@ function setupServerBroker() {
 		const entry = proxyByPlayer.get(p);
 		if (entry) {
 			proxyByPlayer.delete(p);
+			proxyRegisterFailuresByPlayer.delete(p);
 			postJson("/disconnect", { pluginSessionId: entry.pluginSessionId });
 		}
 	});
@@ -389,7 +412,10 @@ function setupServerBroker() {
 }
 
 export = {
-	MCP_URL,
+	MCP_URL: DEFAULT_MCP_URL,
+	DEFAULT_MCP_URL,
+	getServerUrl,
+	setServerUrl,
 	forkRole,
 	setupClientBroker,
 	setupServerBroker,

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

@@ -2,7 +2,7 @@ import { HttpService, RunService, ServerStorage } from "@rbxts/services";
 import State from "./State";
 import Utils from "./Utils";
 import UI from "./UI";
-import { ensureBridgesInstalled } from "./EvalBridges";
+import { cleanupLegacyEditBridges } from "./EvalBridges";
 import QueryHandlers from "./handlers/QueryHandlers";
 import PropertyHandlers from "./handlers/PropertyHandlers";
 import InstanceHandlers from "./handlers/InstanceHandlers";
@@ -18,6 +18,8 @@ import SerializationHandlers from "./handlers/SerializationHandlers";
 import MemoryHandlers from "./handlers/MemoryHandlers";
 import SceneAnalysisHandlers from "./handlers/SceneAnalysisHandlers";
 import EvalRuntimeHandlers from "./handlers/EvalRuntimeHandlers";
+import ServerUrlSettings from "./ServerUrlSettings";
+import HttpDiagnostics from "./HttpDiagnostics";
 import { Connection, RequestPayload, PollResponse, ReadyResponse } from "../types";
 
 // Per-plugin-load random GUID. Used as the /poll URL param so the server
@@ -50,6 +52,7 @@ let assignedRole: string | undefined;
 let duplicateInstanceRole = false;
 let hasVersionMismatch = false;
 let lastVersionMismatchWarningKey: string | undefined;
+const readyFailureLogKeys = new Set<string>();
 
 // Cache the published place name from MarketplaceService:GetProductInfo so
 // /ready can carry a friendly identifier (e.g. "Natural Disasters") distinct
@@ -249,30 +252,44 @@ function sendReady(conn: Connection): void {
 				}),
 			});
 		});
-		if (!readyOk) return;
-		// 409 = duplicate_instance_role. Surface in UI and stop polling.
-		if (readyResult.StatusCode === 409) {
-			duplicateInstanceRole = true;
-			conn.isActive = false;
-			const ui = UI.getElements();
-			if (State.getActiveTabIndex() === 0) {
-				ui.statusLabel.Text = "Duplicate instance";
-				ui.statusLabel.TextColor3 = Color3.fromRGB(239, 68, 68);
-				ui.detailStatusLabel.Text = "Another Studio is already connected as this place + role";
-				ui.detailStatusLabel.TextColor3 = Color3.fromRGB(239, 68, 68);
-			}
-			warn(
-				`[MCPPlugin] Another Studio is already connected as (${instanceId}, ${detectRole()}). Close the other Studio window or this one.`,
-			);
+		const readyUrl = `${conn.serverUrl}/ready`;
+		const readyRole = detectRole();
+		const readyLogKey = `${conn.serverUrl}|${instanceId}|${readyRole}`;
+		if (!readyOk) {
+			readyFailureLogKeys.add(readyLogKey);
+			warn(`[robloxstudio-mcp] /ready failed for ${instanceId}/${readyRole}: ${HttpDiagnostics.formatRequestFailure(readyUrl, readyOk, readyResult)}`);
 			return;
 		}
-		if (readyResult.Success) {
-			const [parseOk, readyData] = pcall(
-				() => HttpService.JSONDecode(readyResult.Body) as ReadyResponse,
-			);
-			if (parseOk && readyData.assignedRole) {
-				assignedRole = readyData.assignedRole;
+		if (!readyResult.Success) {
+			const reason = HttpDiagnostics.formatRequestFailure(readyUrl, true, readyResult);
+			readyFailureLogKeys.add(readyLogKey);
+			// 409 = duplicate_instance_role. Surface in UI and stop polling.
+			if (readyResult.StatusCode === 409) {
+				duplicateInstanceRole = true;
+				conn.isActive = false;
+				const ui = UI.getElements();
+				if (State.getActiveTabIndex() === 0) {
+					ui.statusLabel.Text = "Duplicate instance";
+					ui.statusLabel.TextColor3 = Color3.fromRGB(239, 68, 68);
+					ui.detailStatusLabel.Text = reason;
+					ui.detailStatusLabel.TextColor3 = Color3.fromRGB(239, 68, 68);
+				}
+				warn(`[robloxstudio-mcp] /ready rejected for ${instanceId}/${readyRole}: ${reason}`);
+				return;
 			}
+			warn(`[robloxstudio-mcp] /ready rejected for ${instanceId}/${readyRole}: ${reason}`);
+			return;
+		}
+		const [parseOk, readyData] = pcall(
+			() => HttpService.JSONDecode(readyResult.Body) as ReadyResponse,
+		);
+		if (parseOk && readyData.assignedRole) {
+			assignedRole = readyData.assignedRole;
+		}
+		const connectedRole = assignedRole ?? detectRole();
+		if (readyFailureLogKeys.has(readyLogKey)) {
+			readyFailureLogKeys.delete(readyLogKey);
+			print(`[robloxstudio-mcp] /ready connected for ${instanceId}/${connectedRole} via ${conn.serverUrl}`);
 		}
 	});
 }
@@ -313,7 +330,7 @@ function pollForRequests(connIndex: number) {
 			const warningKey = `${State.CURRENT_VERSION}:${serverVersion}`;
 			if (lastVersionMismatchWarningKey !== warningKey) {
 				lastVersionMismatchWarningKey = warningKey;
-				warn(`[MCPPlugin] Version mismatch: Studio plugin v${State.CURRENT_VERSION} / MCP v${serverVersion}. Run npx -y @chrrxs/robloxstudio-mcp@latest --auto-install-plugin and restart Studio.`);
+				warn(`[robloxstudio-mcp] Version mismatch: Studio plugin v${State.CURRENT_VERSION} / MCP v${serverVersion}. Run npx -y @chrrxs/robloxstudio-mcp@latest --auto-install-plugin and restart Studio.`);
 			}
 			UI.showBanner("version-mismatch", `Plugin v${State.CURRENT_VERSION} / MCP v${serverVersion} mismatch`);
 		} else if (hasVersionMismatch) {
@@ -470,6 +487,7 @@ function activatePlugin(connIndex?: number) {
 		UI.updateTabLabel(idx);
 		UI.updateUIState();
 	}
+	ServerUrlSettings.rememberServerUrl(conn.serverUrl);
 	UI.updateTabDot(idx);
 
 	if (!conn.heartbeatConnection) {
@@ -487,18 +505,10 @@ function activatePlugin(connIndex?: number) {
 	// later reports knownInstance=false (process restart, etc).
 	sendReady(conn);
 
-	// Keep the eval bridges present in the edit DM so that ANY playtest —
-	// including one the dev starts manually via the Studio Play button —
-	// clones them into the play DMs and eval_*_runtime works with no setup
-	// roundtrip. Only the edit DM installs; play DMs already have the cloned
-	// copies. Idempotent, so reconnects don't re-dirty the place.
+	// Remove legacy edit-mode eval bridge scripts from older plugin builds.
+	// Current bridges are created only in running play DataModels.
 	if (!RunService.IsRunning()) {
-		task.spawn(() => {
-			const result = ensureBridgesInstalled();
-			if (!result.installed) {
-				warn(`[MCPPlugin] Eval bridge install failed: ${result.error}`);
-			}
-		});
+		task.spawn(cleanupLegacyEditBridges);
 	}
 
 	// Watch for game.Name updates so a stale "Place1" captured at first

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

@@ -21,30 +21,13 @@
 // ServerScriptService.LoadStringEnabled, so eval_server_runtime works even
 // when LoadStringEnabled=false (the default in fresh places).
 //
-// Lifecycle: the bridges live PERMANENTLY in the edit DM. Communication
-// installs them (ensureBridgesInstalled) when the plugin connects in edit,
-// and TestHandlers.startPlaytest force-refreshes them right before
-// ExecutePlayModeAsync. ExecutePlayModeAsync clones the DataModel into the
-// play DMs, so the scripts come along and run there. We keep them in the edit
-// DM after a playtest ends (rather than cleaning up) so that a playtest the
-// dev starts MANUALLY via the Studio Play button — not the MCP start_playtest
-// tool — also gets the bridges cloned in. This is intentionally a little
-// intrusive (two helper scripts visible in Explorer) in exchange for a
-// zero-roundtrip eval_*_runtime experience for devs working 1:1 with an agent.
-//
-// Archivable handling: ExecutePlayModeAsync's deep-clone SKIPS instances
-// with Archivable=false (verified empirically in v2.9.0 testing - bridges
-// never reached the play DMs because we'd set them to false). We now keep
-// Archivable=true so the clone works, and rely on cleanupBridges() to
-// remove the scripts from the edit DM when the test ends. The only failure
-// mode is the user saving DURING an active playtest, which would persist
-// the bridges to the .rbxl - that's a no-op next session because
-// installBridges() always calls cleanupBridges() first to clear stale
-// instances. The RemoteFunction/BindableFunction that the bridge scripts
-// CREATE at runtime stay Archivable=false (they're runtime-only and should
-// never appear in a save).
-
-import { ServerScriptService, StarterPlayer } from "@rbxts/services";
+// Lifecycle: bridge scripts are created only in running play DataModels.
+// The server plugin peer creates the Script in runtime ServerScriptService;
+// each client plugin peer creates its LocalScript in that client's
+// PlayerScripts. Nothing is installed into the edit DataModel anymore.
+// Runtime-created scripts disappear naturally when the playtest stops.
+
+import { Players, ReplicatedStorage, RunService, ServerScriptService, StarterPlayer } from "@rbxts/services";
 
 const ScriptEditorService = game.GetService("ScriptEditorService");
 
@@ -122,12 +105,10 @@ end
 `;
 
 // Stamp written onto each installed bridge Script so we can tell whether the
-// bridge currently in the DM was produced by THIS plugin build. It's a djb2
-// hash of the actual bridge source plus the plugin version, so ANY change to
-// the source (or a version bump) yields a new stamp — which makes
-// ensureBridgesInstalled() force a refresh on the next plugin load instead of
-// keeping a stale bridge that happens to still be present (e.g. one saved into
-// the .rbxl from an older build).
+// runtime bridge currently in the play DM was produced by THIS plugin build.
+// It's a djb2 hash of the actual bridge source plus the plugin version, so ANY
+// change to the source (or a version bump) yields a new stamp and triggers a
+// runtime refresh instead of keeping a stale bridge.
 const STAMP_ATTR = "__MCPBridgeStamp";
 
 function computeBridgeStamp(): string {
@@ -155,7 +136,12 @@ function setSource(scriptInst: Script | LocalScript, source: string): void {
 	}
 }
 
-function findBridges(): { server?: Instance; client?: Instance } {
+interface InstallResult {
+	installed: boolean;
+	error?: string;
+}
+
+function findLegacyEditBridges(): { server?: Instance; client?: Instance } {
 	const sps = getStarterPlayerScripts();
 	return {
 		server: ServerScriptService.FindFirstChild(SERVER_SCRIPT_NAME),
@@ -163,8 +149,16 @@ function findBridges(): { server?: Instance; client?: Instance } {
 	};
 }
 
-export function cleanupBridges(): void {
-	const { server, client } = findBridges();
+function destroyIfPresent(parent: Instance, name: string): void {
+	const existing = parent.FindFirstChild(name);
+	if (existing) {
+		pcall(() => existing.Destroy());
+	}
+}
+
+export function cleanupLegacyEditBridges(): void {
+	if (RunService.IsRunning()) return;
+	const { server, client } = findLegacyEditBridges();
 	if (server) {
 		pcall(() => server.Destroy());
 	}
@@ -173,52 +167,75 @@ export function cleanupBridges(): void {
 	}
 }
 
-// Idempotent variant: install only if the bridge scripts aren't already
-// present in the edit DM. Used to keep the bridges always available (so a
-// playtest the dev starts manually — not via the MCP start_playtest tool —
-// still clones them into the play DMs). Cheap no-op when already installed,
-// which avoids re-dirtying the place on every plugin reconnect.
-export function ensureBridgesInstalled(): { installed: boolean; error?: string } {
-	const { server, client } = findBridges();
-	if (server && client) {
-		// Both present — but only skip the reinstall if they were produced by
-		// THIS build. A mismatched/absent stamp means a stale bridge (older
-		// plugin, or one persisted in the saved place), so force a refresh.
-		const sStamp = server.GetAttribute(STAMP_ATTR);
-		const cStamp = client.GetAttribute(STAMP_ATTR);
-		if (sStamp === BRIDGE_STAMP && cStamp === BRIDGE_STAMP) {
-			return { installed: true };
-		}
+function serverRuntimeBridgeReady(): boolean {
+	const scriptInst = ServerScriptService.FindFirstChild(SERVER_SCRIPT_NAME);
+	const bindable = ServerScriptService.FindFirstChild(BRIDGE_NAMES.serverLocal);
+	return scriptInst !== undefined &&
+		scriptInst.GetAttribute(STAMP_ATTR) === BRIDGE_STAMP &&
+		bindable !== undefined &&
+		bindable.IsA("BindableFunction");
+}
+
+function getPlayerScripts(): Instance | undefined {
+	const localPlayer = Players.LocalPlayer;
+	if (!localPlayer) return undefined;
+	let playerScripts = localPlayer.FindFirstChild("PlayerScripts");
+	if (!playerScripts) {
+		playerScripts = localPlayer.WaitForChild("PlayerScripts", 5);
 	}
-	return installBridges();
+	return playerScripts;
+}
+
+function clientRuntimeBridgeReady(): boolean {
+	const playerScripts = getPlayerScripts();
+	if (!playerScripts) return false;
+	const scriptInst = playerScripts.FindFirstChild(CLIENT_SCRIPT_NAME);
+	const bindable = ReplicatedStorage.FindFirstChild(BRIDGE_NAMES.clientLocal);
+	return scriptInst !== undefined &&
+		scriptInst.GetAttribute(STAMP_ATTR) === BRIDGE_STAMP &&
+		bindable !== undefined &&
+		bindable.IsA("BindableFunction");
 }
 
-export function installBridges(): { installed: boolean; error?: string } {
-	// Defensive: clear any stale bridges from a prior unclean exit before
-	// inserting fresh. The injected script also self-cleans its
-	// ReplicatedStorage/ServerScriptService children at startup, but the
-	// containing Script/LocalScript objects themselves we must clear here.
-	cleanupBridges();
+function installServerRuntimeBridge(): InstallResult {
+	if (serverRuntimeBridgeReady()) return { installed: true };
 
 	const [ok, err] = pcall(() => {
+		destroyIfPresent(ServerScriptService, SERVER_SCRIPT_NAME);
+		destroyIfPresent(ServerScriptService, BRIDGE_NAMES.serverLocal);
+
 		const serverScript = new Instance("Script");
 		serverScript.Name = SERVER_SCRIPT_NAME;
-		// Archivable=true so ExecutePlayModeAsync's deep-clone includes the
-		// script. cleanupBridges() removes it from the edit DM when the
-		// playtest ends.
+		serverScript.Archivable = false;
 		setSource(serverScript, SERVER_BRIDGE_SOURCE);
 		serverScript.SetAttribute(STAMP_ATTR, BRIDGE_STAMP);
 		serverScript.Parent = ServerScriptService;
+	});
+
+	if (!ok) {
+		return { installed: false, error: tostring(err) };
+	}
+	return { installed: true };
+}
+
+function installClientRuntimeBridge(): InstallResult {
+	if (clientRuntimeBridgeReady()) return { installed: true };
+
+	const playerScripts = getPlayerScripts();
+	if (!playerScripts) {
+		return { installed: false, error: "Players.LocalPlayer.PlayerScripts not found - cannot install client eval bridge" };
+	}
+
+	const [ok, err] = pcall(() => {
+		destroyIfPresent(playerScripts, CLIENT_SCRIPT_NAME);
+		destroyIfPresent(ReplicatedStorage, BRIDGE_NAMES.clientLocal);
 
-		const sps = getStarterPlayerScripts();
-		if (!sps) {
-			error("StarterPlayer.StarterPlayerScripts not found - cannot install client eval bridge");
-		}
 		const clientScript = new Instance("LocalScript");
 		clientScript.Name = CLIENT_SCRIPT_NAME;
+		clientScript.Archivable = false;
 		setSource(clientScript, CLIENT_BRIDGE_SOURCE);
 		clientScript.SetAttribute(STAMP_ATTR, BRIDGE_STAMP);
-		clientScript.Parent = sps;
+		clientScript.Parent = playerScripts;
 	});
 
 	if (!ok) {
@@ -226,3 +243,13 @@ export function installBridges(): { installed: boolean; error?: string } {
 	}
 	return { installed: true };
 }
+
+export function ensureRuntimeBridgeInstalled(): InstallResult {
+	if (!RunService.IsRunning()) {
+		return { installed: false, error: "Eval bridges are installed only in running play DataModels" };
+	}
+	if (RunService.IsServer()) {
+		return installServerRuntimeBridge();
+	}
+	return installClientRuntimeBridge();
+}

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

@@ -0,0 +1,50 @@
+import { HttpService } from "@rbxts/services";
+
+interface FailureBody {
+	error?: string;
+	message?: string;
+	missingFields?: unknown;
+	request?: unknown;
+	existing?: unknown;
+	details?: unknown;
+}
+
+function encodeForLog(value: unknown): string {
+	const [ok, encoded] = pcall(() => HttpService.JSONEncode(value));
+	return ok ? encoded : tostring(value);
+}
+
+function formatBody(body: string): string {
+	if (body === "") return "";
+	const [ok, decoded] = pcall(() => HttpService.JSONDecode(body));
+	if (ok && typeIs(decoded, "table")) {
+		const data = decoded as FailureBody;
+		const parts: string[] = [];
+		if (typeIs(data.error, "string") && data.error !== "") parts.push(`error=${data.error}`);
+		if (typeIs(data.message, "string") && data.message !== "") parts.push(`message=${data.message}`);
+		if (data.missingFields !== undefined) parts.push(`missingFields=${encodeForLog(data.missingFields)}`);
+		if (data.request !== undefined) parts.push(`request=${encodeForLog(data.request)}`);
+		if (data.existing !== undefined) parts.push(`existing=${encodeForLog(data.existing)}`);
+		if (data.details !== undefined) parts.push(`details=${encodeForLog(data.details)}`);
+		if (parts.size() > 0) return parts.join(" ");
+	}
+	return `body=${body}`;
+}
+
+function formatRequestFailure(url: string, ok: boolean, res: unknown): string {
+	if (!ok) {
+		return `RequestAsync threw for ${url}: ${tostring(res)}`;
+	}
+	if (res === undefined) {
+		return `RequestAsync returned no response for ${url}`;
+	}
+	const response = res as RequestAsyncResponse;
+	const statusMessage = response.StatusMessage !== "" ? ` ${response.StatusMessage}` : "";
+	const body = formatBody(response.Body);
+	const suffix = body !== "" ? `: ${body}` : "";
+	return `HTTP ${response.StatusCode}${statusMessage} from ${url}${suffix}`;
+}
+
+export = {
+	formatRequestFailure,
+};

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

@@ -0,0 +1,48 @@
+import { HttpService, ServerStorage } from "@rbxts/services";
+
+const SETTING_KEY_PREFIX = "MCP_SERVER_URL_";
+
+let pluginRef: Plugin | undefined;
+
+function init(p: Plugin): void {
+	pluginRef = p;
+}
+
+function computeInstanceId(): string {
+	if (game.PlaceId !== 0) {
+		return `place:${tostring(game.PlaceId)}`;
+	}
+	const existing = ServerStorage.GetAttribute("__MCPPlaceId");
+	if (typeIs(existing, "string") && existing !== "") {
+		return `anon:${existing as string}`;
+	}
+	const fresh = HttpService.GenerateGUID(false);
+	pcall(() => ServerStorage.SetAttribute("__MCPPlaceId", fresh));
+	return `anon:${fresh}`;
+}
+
+function settingKey(instanceId: string): string {
+	return SETTING_KEY_PREFIX + instanceId;
+}
+
+function rememberServerUrl(serverUrl: string): void {
+	if (!pluginRef || serverUrl === "") return;
+	const key = settingKey(computeInstanceId());
+	pcall(() => pluginRef!.SetSetting(key, serverUrl));
+}
+
+function readServerUrl(): string | undefined {
+	if (!pluginRef) return undefined;
+	const key = settingKey(computeInstanceId());
+	const [ok, value] = pcall(() => pluginRef!.GetSetting(key));
+	if (ok && typeIs(value, "string") && value !== "") {
+		return value as string;
+	}
+	return undefined;
+}
+
+export = {
+	init,
+	rememberServerUrl,
+	readServerUrl,
+};