@chrrxs/robloxstudio-mcp 2.23.1 → 3.0.0

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

@@ -5,11 +5,9 @@ import UI from "./UI";
 import { cleanupLegacyEditBridges } from "./EvalBridges";
 import QueryHandlers from "./handlers/QueryHandlers";
 import PropertyHandlers from "./handlers/PropertyHandlers";
-import InstanceHandlers from "./handlers/InstanceHandlers";
 import ScriptHandlers from "./handlers/ScriptHandlers";
 import MetadataHandlers from "./handlers/MetadataHandlers";
 import TestHandlers from "./handlers/TestHandlers";
-import BuildHandlers from "./handlers/BuildHandlers";
 import AssetHandlers from "./handlers/AssetHandlers";
 import CaptureHandlers from "./handlers/CaptureHandlers";
 import InputHandlers from "./handlers/InputHandlers";
@@ -100,32 +98,17 @@ type Handler = (data: Record<string, unknown>) => unknown;
 
 const routeMap: Record<string, Handler> = {
 
-	"/api/file-tree": QueryHandlers.getFileTree,
-	"/api/search-files": QueryHandlers.searchFiles,
-	"/api/place-info": QueryHandlers.getPlaceInfo,
-	"/api/services": QueryHandlers.getServices,
-	"/api/search-objects": QueryHandlers.searchObjects,
-	"/api/instance-properties": QueryHandlers.getInstanceProperties,
-	"/api/instance-children": QueryHandlers.getInstanceChildren,
-	"/api/search-by-property": QueryHandlers.searchByProperty,
-	"/api/class-info": QueryHandlers.getClassInfo,
-	"/api/project-structure": QueryHandlers.getProjectStructure,
-	"/api/grep-scripts": QueryHandlers.grepScripts,
-	"/api/get-descendants": QueryHandlers.getDescendants,
-	"/api/compare-instances": QueryHandlers.compareInstances,
-
-	"/api/set-property": PropertyHandlers.setProperty,
-	"/api/set-properties": PropertyHandlers.setProperties,
-	"/api/mass-set-property": PropertyHandlers.massSetProperty,
-	"/api/mass-get-property": PropertyHandlers.massGetProperty,
-	"/api/create-object": InstanceHandlers.createObject,
-	"/api/mass-create-objects": InstanceHandlers.massCreateObjects,
-	// Back-compat alias: pre-2.7.0 servers split this endpoint when properties were present.
-	"/api/mass-create-objects-with-properties": InstanceHandlers.massCreateObjects,
-	"/api/delete-object": InstanceHandlers.deleteObject,
-	"/api/smart-duplicate": InstanceHandlers.smartDuplicate,
-	"/api/mass-duplicate": InstanceHandlers.massDuplicate,
-	"/api/clone-object": InstanceHandlers.cloneObject,
+    "/api/file-tree": QueryHandlers.getFileTree,
+    "/api/search-files": QueryHandlers.searchFiles,
+    "/api/place-info": QueryHandlers.getPlaceInfo,
+    "/api/search-objects": QueryHandlers.searchObjects,
+    "/api/instance-properties": QueryHandlers.getInstanceProperties,
+    "/api/search-by-property": QueryHandlers.searchByProperty,
+    "/api/class-info": QueryHandlers.getClassInfo,
+    "/api/project-structure": QueryHandlers.getProjectStructure,
+    "/api/grep-scripts": QueryHandlers.grepScripts,
+
+    "/api/set-properties": PropertyHandlers.setProperties,
 
 	"/api/get-script-source": ScriptHandlers.getScriptSource,
 	"/api/set-script-source": ScriptHandlers.setScriptSource,
@@ -133,19 +116,10 @@ const routeMap: Record<string, Handler> = {
 	"/api/insert-script-lines": ScriptHandlers.insertScriptLines,
 	"/api/delete-script-lines": ScriptHandlers.deleteScriptLines,
 
-	"/api/set-attribute": MetadataHandlers.setAttribute,
-	"/api/get-attributes": MetadataHandlers.getAttributes,
-	"/api/delete-attribute": MetadataHandlers.deleteAttribute,
-	"/api/get-tags": MetadataHandlers.getTags,
-	"/api/add-tag": MetadataHandlers.addTag,
-	"/api/remove-tag": MetadataHandlers.removeTag,
-	"/api/get-tagged": MetadataHandlers.getTagged,
-	"/api/get-selection": MetadataHandlers.getSelection,
-	"/api/execute-luau": MetadataHandlers.executeLuau,
-	"/api/eval-runtime": EvalRuntimeHandlers.evalRuntime,
-	"/api/undo": MetadataHandlers.undo,
-	"/api/redo": MetadataHandlers.redo,
-	"/api/bulk-set-attributes": MetadataHandlers.bulkSetAttributes,
+    "/api/get-attributes": MetadataHandlers.getAttributes,
+    "/api/get-selection": MetadataHandlers.getSelection,
+    "/api/execute-luau": MetadataHandlers.executeLuau,
+    "/api/eval-runtime": EvalRuntimeHandlers.evalRuntime,
 
 	"/api/start-playtest": TestHandlers.startPlaytest,
 	"/api/stop-playtest": TestHandlers.stopPlaytest,
@@ -155,12 +129,7 @@ const routeMap: Record<string, Handler> = {
 	"/api/multiplayer-test-leave-client": TestHandlers.multiplayerTestLeaveClient,
 	"/api/multiplayer-test-end": TestHandlers.multiplayerTestEnd,
 
-	"/api/export-build": BuildHandlers.exportBuild,
-	"/api/import-build": BuildHandlers.importBuild,
-	"/api/import-scene": BuildHandlers.importScene,
-	"/api/search-materials": BuildHandlers.searchMaterials,
-
-	"/api/insert-asset": AssetHandlers.insertAsset,
+    "/api/insert-asset": AssetHandlers.insertAsset,
 	"/api/preview-asset": AssetHandlers.previewAsset,
 
 	"/api/capture-screenshot": CaptureHandlers.captureScreenshot,

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

@@ -224,10 +224,67 @@ function readScriptSource(instance: LuaSourceContainer): string {
 		}
 		return undefined;
 	});
-	if (ok && result) {
+	if (ok && result !== undefined) {
 		return result;
 	}
-	return (instance as unknown as { Source: string }).Source;
+	// @rbxts/types does not expose PluginSecurity Source reads.
+	const readableScript = instance as unknown as { Source: string };
+	return readableScript.Source;
+}
+
+interface ApplyScriptSourceResult {
+	success: boolean;
+	method: "UpdateSourceAsync" | "direct";
+	error?: string;
+}
+
+/**
+ * Writes newSource to instance and verifies the live editor text before
+ * reporting success. expectedSource turns line-based edits into a
+ * compare-and-set operation: if the document changes while
+ * UpdateSourceAsync yields or before the direct fallback runs, the write is
+ * rejected instead of overwriting the newer draft.
+ */
+function applyScriptSource(
+	instance: LuaSourceContainer,
+	newSource: string,
+	expectedSource?: string,
+): ApplyScriptSourceResult {
+	const [updateSuccess, updateResult] = pcall(() => {
+		ScriptEditorService.UpdateSourceAsync(instance, (currentSource: string) => {
+			if (expectedSource !== undefined && currentSource !== expectedSource) {
+				error("Script source changed while the edit was being applied; read the script again and retry");
+			}
+			return newSource;
+		});
+		if (readScriptSource(instance) !== newSource) {
+			error("UpdateSourceAsync completed without updating the live script source");
+		}
+	});
+	if (updateSuccess) {
+		return { success: true, method: "UpdateSourceAsync" };
+	}
+
+	const [directSuccess, directResult] = pcall(() => {
+		if (expectedSource !== undefined && readScriptSource(instance) !== expectedSource) {
+			error("Script source changed before direct assignment; read the script again and retry");
+		}
+		// @rbxts/types does not expose PluginSecurity Source writes.
+		const writableScript = instance as unknown as { Source: string };
+		writableScript.Source = newSource;
+		if (readScriptSource(instance) !== newSource) {
+			error("Direct assignment completed without updating the live script source");
+		}
+	});
+	if (directSuccess) {
+		return { success: true, method: "direct" };
+	}
+
+	return {
+		success: false,
+		method: "direct",
+		error: `UpdateSourceAsync failed: ${updateResult}. Direct assignment failed: ${directResult}`,
+	};
 }
 
 function convertPropertyValue(instance: Instance, propertyName: string, propertyValue: unknown): unknown {
@@ -463,6 +520,7 @@ export = {
 	splitLines,
 	joinLines,
 	readScriptSource,
+	applyScriptSource,
 	convertPropertyValue,
 	evaluateFormula,
 	compareVersions,

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

@@ -1,13 +1,9 @@
-import { CollectionService } from "@rbxts/services";
 import Utils from "../Utils";
-import Recording from "../Recording";
 import LuauExec from "../LuauExec";
 
-const ChangeHistoryService = game.GetService("ChangeHistoryService");
 const Selection = game.GetService("Selection");
 
 const { getInstancePath, getInstanceByPath } = Utils;
-const { beginRecording, finishRecording } = Recording;
 
 function serializeValue(value: unknown): unknown {
 	const vType = typeOf(value);
@@ -34,58 +30,6 @@ function serializeValue(value: unknown): unknown {
 	return value;
 }
 
-function deserializeValue(attributeValue: unknown, valueType?: string): unknown {
-	if (!typeIs(attributeValue, "table")) return attributeValue;
-
-	const tbl = attributeValue as Record<string, unknown>;
-	const t = (tbl._type as string) ?? valueType;
-
-	if (t === "Vector3") {
-		return new Vector3((tbl.X as number) ?? 0, (tbl.Y as number) ?? 0, (tbl.Z as number) ?? 0);
-	} else if (t === "Color3") {
-		return new Color3((tbl.R as number) ?? 0, (tbl.G as number) ?? 0, (tbl.B as number) ?? 0);
-	} else if (t === "UDim2") {
-		const x = tbl.X as Record<string, number> | undefined;
-		const y = tbl.Y as Record<string, number> | undefined;
-		return new UDim2(x?.Scale ?? 0, x?.Offset ?? 0, y?.Scale ?? 0, y?.Offset ?? 0);
-	} else if (t === "BrickColor") {
-		return new BrickColor(((tbl.Name as string) ?? "Medium stone grey") as unknown as number);
-	}
-	return attributeValue;
-}
-
-function setAttribute(requestData: Record<string, unknown>) {
-	const instancePath = requestData.instancePath as string;
-	const attributeName = requestData.attributeName as string;
-	const attributeValue = requestData.attributeValue;
-	const valueType = requestData.valueType as string | undefined;
-
-	if (!instancePath || !attributeName) {
-		return { error: "Instance path and attribute name are required" };
-	}
-
-	const instance = getInstanceByPath(instancePath);
-	if (!instance) return { error: `Instance not found: ${instancePath}` };
-	const recordingId = beginRecording(`Set attribute ${attributeName} on ${instance.Name}`);
-
-	const [success, result] = pcall(() => {
-		const value = deserializeValue(attributeValue, valueType);
-		instance.SetAttribute(attributeName, value as AttributeValue);
-
-		return {
-			success: true, instancePath, attributeName,
-			value: attributeValue, message: "Attribute set successfully",
-		};
-	});
-
-	if (success) {
-		finishRecording(recordingId, true);
-		return result;
-	}
-	finishRecording(recordingId, false);
-	return { error: `Failed to set attribute: ${result}` };
-}
-
 function getAttributes(requestData: Record<string, unknown>) {
 	const instancePath = requestData.instancePath as string;
 	if (!instancePath) return { error: "Instance path is required" };
@@ -113,131 +57,6 @@ function getAttributes(requestData: Record<string, unknown>) {
 	return { error: `Failed to get attributes: ${result}` };
 }
 
-function deleteAttribute(requestData: Record<string, unknown>) {
-	const instancePath = requestData.instancePath as string;
-	const attributeName = requestData.attributeName as string;
-
-	if (!instancePath || !attributeName) {
-		return { error: "Instance path and attribute name are required" };
-	}
-
-	const instance = getInstanceByPath(instancePath);
-	if (!instance) return { error: `Instance not found: ${instancePath}` };
-	const recordingId = beginRecording(`Delete attribute ${attributeName} from ${instance.Name}`);
-
-	const [success, result] = pcall(() => {
-		const existed = instance.GetAttribute(attributeName) !== undefined;
-		instance.SetAttribute(attributeName, undefined);
-
-		return {
-			success: true, instancePath, attributeName, existed,
-			message: existed ? "Attribute deleted successfully" : "Attribute did not exist",
-		};
-	});
-
-	if (success) {
-		finishRecording(recordingId, true);
-		return result;
-	}
-	finishRecording(recordingId, false);
-	return { error: `Failed to delete attribute: ${result}` };
-}
-
-function getTags(requestData: Record<string, unknown>) {
-	const instancePath = requestData.instancePath as string;
-	if (!instancePath) return { error: "Instance path is required" };
-
-	const instance = getInstanceByPath(instancePath);
-	if (!instance) return { error: `Instance not found: ${instancePath}` };
-
-	const [success, result] = pcall(() => {
-		const tags = CollectionService.GetTags(instance);
-		return { instancePath, tags, count: tags.size() };
-	});
-
-	if (success) return result;
-	return { error: `Failed to get tags: ${result}` };
-}
-
-function addTag(requestData: Record<string, unknown>) {
-	const instancePath = requestData.instancePath as string;
-	const tagName = requestData.tagName as string;
-
-	if (!instancePath || !tagName) {
-		return { error: "Instance path and tag name are required" };
-	}
-
-	const instance = getInstanceByPath(instancePath);
-	if (!instance) return { error: `Instance not found: ${instancePath}` };
-	const recordingId = beginRecording(`Add tag ${tagName} to ${instance.Name}`);
-
-	const [success, result] = pcall(() => {
-		const alreadyHad = CollectionService.HasTag(instance, tagName);
-		CollectionService.AddTag(instance, tagName);
-
-		return {
-			success: true, instancePath, tagName, alreadyHad,
-			message: alreadyHad ? "Instance already had this tag" : "Tag added successfully",
-		};
-	});
-
-	if (success) {
-		finishRecording(recordingId, true);
-		return result;
-	}
-	finishRecording(recordingId, false);
-	return { error: `Failed to add tag: ${result}` };
-}
-
-function removeTag(requestData: Record<string, unknown>) {
-	const instancePath = requestData.instancePath as string;
-	const tagName = requestData.tagName as string;
-
-	if (!instancePath || !tagName) {
-		return { error: "Instance path and tag name are required" };
-	}
-
-	const instance = getInstanceByPath(instancePath);
-	if (!instance) return { error: `Instance not found: ${instancePath}` };
-	const recordingId = beginRecording(`Remove tag ${tagName} from ${instance.Name}`);
-
-	const [success, result] = pcall(() => {
-		const hadTag = CollectionService.HasTag(instance, tagName);
-		CollectionService.RemoveTag(instance, tagName);
-
-		return {
-			success: true, instancePath, tagName, hadTag,
-			message: hadTag ? "Tag removed successfully" : "Instance did not have this tag",
-		};
-	});
-
-	if (success) {
-		finishRecording(recordingId, true);
-		return result;
-	}
-	finishRecording(recordingId, false);
-	return { error: `Failed to remove tag: ${result}` };
-}
-
-function getTagged(requestData: Record<string, unknown>) {
-	const tagName = requestData.tagName as string;
-	if (!tagName) return { error: "Tag name is required" };
-
-	const [success, result] = pcall(() => {
-		const taggedInstances = CollectionService.GetTagged(tagName);
-		const instances = taggedInstances.map((instance) => ({
-			name: instance.Name,
-			className: instance.ClassName,
-			path: getInstancePath(instance),
-		}));
-
-		return { tagName, instances, count: instances.size() };
-	});
-
-	if (success) return result;
-	return { error: `Failed to get tagged instances: ${result}` };
-}
-
 function getSelection(_requestData: Record<string, unknown>) {
 	const selection = Selection.Get();
 
@@ -270,85 +89,8 @@ function executeLuau(requestData: Record<string, unknown>) {
 	return LuauExec.execute(code);
 }
 
-function undo(_requestData: Record<string, unknown>) {
-	const [success, result] = pcall(() => {
-		ChangeHistoryService.Undo();
-		return {
-			success: true,
-			message: "Undo executed successfully",
-		};
-	});
-
-	if (success) return result;
-	return { error: `Failed to undo: ${result}` };
-}
-
-function redo(_requestData: Record<string, unknown>) {
-	const [success, result] = pcall(() => {
-		ChangeHistoryService.Redo();
-		return {
-			success: true,
-			message: "Redo executed successfully",
-		};
-	});
-
-	if (success) return result;
-	return { error: `Failed to redo: ${result}` };
-}
-
-function bulkSetAttributes(requestData: Record<string, unknown>) {
-	const instancePath = requestData.instancePath as string;
-	const attributes = requestData.attributes as Record<string, unknown>;
-
-	if (!instancePath || !attributes) {
-		return { error: "Instance path and attributes are required" };
-	}
-
-	const instance = getInstanceByPath(instancePath);
-	if (!instance) return { error: `Instance not found: ${instancePath}` };
-
-	const recordingId = beginRecording(`Bulk set attributes on ${instance.Name}`);
-
-	const results: Record<string, unknown>[] = [];
-	let successCount = 0;
-	let failureCount = 0;
-
-	for (const [name, rawValue] of pairs(attributes)) {
-		const attrName = name as string;
-		const [ok, err] = pcall(() => {
-			const value = deserializeValue(rawValue);
-			instance.SetAttribute(attrName, value as AttributeValue);
-		});
-
-		if (ok) {
-			successCount++;
-			results.push({ attributeName: attrName, success: true });
-		} else {
-			failureCount++;
-			results.push({ attributeName: attrName, success: false, error: tostring(err) });
-		}
-	}
-
-	finishRecording(recordingId, successCount > 0);
-
-	return {
-		instancePath,
-		results,
-		summary: { total: successCount + failureCount, succeeded: successCount, failed: failureCount },
-	};
-}
-
 export = {
-	setAttribute,
-	getAttributes,
-	deleteAttribute,
-	getTags,
-	addTag,
-	removeTag,
-	getTagged,
-	getSelection,
-	executeLuau,
-	undo,
-	redo,
-	bulkSetAttributes,
+    getAttributes,
+    getSelection,
+    executeLuau,
 };

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

@@ -4,132 +4,6 @@ import Recording from "../Recording";
 const { getInstanceByPath, convertPropertyValue } = Utils;
 const { beginRecording, finishRecording } = Recording;
 
-function setProperty(requestData: Record<string, unknown>) {
-	const instancePath = requestData.instancePath as string;
-	const propertyName = requestData.propertyName as string;
-	const propertyValue = requestData.propertyValue;
-
-	if (!instancePath || !propertyName) {
-		return { error: "Instance path and property name are required" };
-	}
-
-	const instance = getInstanceByPath(instancePath);
-	if (!instance) return { error: `Instance not found: ${instancePath}` };
-	const recordingId = beginRecording(`Set ${propertyName} property`);
-
-	const inst = instance as unknown as Record<string, unknown>;
-
-	const [success, result] = pcall(() => {
-		if (propertyName === "Parent" || propertyName === "PrimaryPart") {
-			if (typeIs(propertyValue, "string")) {
-				const refInstance = getInstanceByPath(propertyValue);
-				if (refInstance) {
-					inst[propertyName] = refInstance;
-				} else {
-					return { error: `${propertyName} instance not found: ${propertyValue}` };
-				}
-			}
-		} else if (propertyName === "Name") {
-			instance.Name = tostring(propertyValue);
-		} else if (propertyName === "Source" && instance.IsA("LuaSourceContainer")) {
-			(instance as unknown as { Source: string }).Source = tostring(propertyValue);
-		} else {
-			const convertedValue = convertPropertyValue(instance, propertyName, propertyValue);
-			if (convertedValue !== undefined) {
-				inst[propertyName] = convertedValue;
-			} else {
-				inst[propertyName] = propertyValue;
-			}
-		}
-
-		return true;
-	});
-
-	if (success) {
-		finishRecording(recordingId, true);
-		return {
-			success: true,
-			instancePath,
-			propertyName,
-			propertyValue,
-			message: "Property set successfully",
-		};
-	} else {
-		finishRecording(recordingId, false);
-		return { error: `Failed to set property: ${result}`, instancePath, propertyName };
-	}
-}
-
-function massSetProperty(requestData: Record<string, unknown>) {
-	const paths = requestData.paths as string[];
-	const propertyName = requestData.propertyName as string;
-	const propertyValue = requestData.propertyValue;
-
-	if (!paths || !typeIs(paths, "table") || (paths as defined[]).size() === 0 || !propertyName) {
-		return { error: "Paths array and property name are required" };
-	}
-
-	const results: Record<string, unknown>[] = [];
-	let successCount = 0;
-	let failureCount = 0;
-	const recordingId = beginRecording(`Mass set ${propertyName} property`);
-
-	for (const path of paths) {
-		const instance = getInstanceByPath(path);
-		if (instance) {
-			const [success, err] = pcall(() => {
-				const converted = convertPropertyValue(instance, propertyName, propertyValue);
-				(instance as unknown as Record<string, unknown>)[propertyName] =
-					converted !== undefined ? converted : propertyValue;
-			});
-			if (success) {
-				successCount++;
-				results.push({ path, success: true, propertyName, propertyValue });
-			} else {
-				failureCount++;
-				results.push({ path, success: false, error: tostring(err) });
-			}
-		} else {
-			failureCount++;
-			results.push({ path, success: false, error: "Instance not found" });
-		}
-	}
-
-	finishRecording(recordingId, successCount > 0);
-
-	return {
-		results,
-		summary: { total: paths.size(), succeeded: successCount, failed: failureCount },
-	};
-}
-
-function massGetProperty(requestData: Record<string, unknown>) {
-	const paths = requestData.paths as string[];
-	const propertyName = requestData.propertyName as string;
-
-	if (!paths || !typeIs(paths, "table") || (paths as defined[]).size() === 0 || !propertyName) {
-		return { error: "Paths array and property name are required" };
-	}
-
-	const results: Record<string, unknown>[] = [];
-
-	for (const path of paths) {
-		const instance = getInstanceByPath(path);
-		if (instance) {
-			const [success, value] = pcall(() => (instance as unknown as Record<string, unknown>)[propertyName]);
-			if (success) {
-				results.push({ path, success: true, propertyName, propertyValue: value });
-			} else {
-				results.push({ path, success: false, error: tostring(value) });
-			}
-		} else {
-			results.push({ path, success: false, error: "Instance not found" });
-		}
-	}
-
-	return { results, propertyName };
-}
-
 function setProperties(requestData: Record<string, unknown>) {
 	const instancePath = requestData.instancePath as string;
 	const properties = requestData.properties as Record<string, unknown>;
@@ -184,8 +58,5 @@ function setProperties(requestData: Record<string, unknown>) {
 }
 
 export = {
-	setProperty,
-	massSetProperty,
-	massGetProperty,
-	setProperties,
+    setProperties,
 };