@chrrxs/robloxstudio-mcp-inspector 2.8.0

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

@@ -0,0 +1,391 @@
+import { CollectionService } from "@rbxts/services";
+import Utils from "../Utils";
+import Recording from "../Recording";
+
+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);
+	if (vType === "Vector3") {
+		const v = value as Vector3;
+		return { X: v.X, Y: v.Y, Z: v.Z, _type: "Vector3" };
+	} else if (vType === "Color3") {
+		const v = value as Color3;
+		return { R: v.R, G: v.G, B: v.B, _type: "Color3" };
+	} else if (vType === "CFrame") {
+		const v = value as CFrame;
+		return { Position: { X: v.Position.X, Y: v.Position.Y, Z: v.Position.Z }, _type: "CFrame" };
+	} else if (vType === "UDim2") {
+		const v = value as UDim2;
+		return {
+			X: { Scale: v.X.Scale, Offset: v.X.Offset },
+			Y: { Scale: v.Y.Scale, Offset: v.Y.Offset },
+			_type: "UDim2",
+		};
+	} else if (vType === "BrickColor") {
+		const v = value as BrickColor;
+		return { Name: v.Name, _type: "BrickColor" };
+	}
+	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" };
+
+	const instance = getInstanceByPath(instancePath);
+	if (!instance) return { error: `Instance not found: ${instancePath}` };
+
+	const [success, result] = pcall(() => {
+		const attributes = instance.GetAttributes();
+		const serializedAttributes: Record<string, { value: unknown; type: string }> = {};
+		let count = 0;
+
+		for (const [name, value] of pairs(attributes)) {
+			serializedAttributes[name as string] = {
+				value: serializeValue(value),
+				type: typeOf(value),
+			};
+			count++;
+		}
+
+		return { instancePath, attributes: serializedAttributes, count };
+	});
+
+	if (success) return result;
+	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();
+
+	if (selection.size() === 0) {
+		return { success: true, selection: [], count: 0, message: "No objects selected" };
+	}
+
+	const selectedObjects = selection.map((instance: Instance) => ({
+		name: instance.Name,
+		className: instance.ClassName,
+		path: getInstancePath(instance),
+		parent: instance.Parent ? getInstancePath(instance.Parent) : undefined,
+	}));
+
+	return {
+		success: true,
+		selection: selectedObjects,
+		count: selection.size(),
+		message: `${selection.size()} object(s) selected`,
+	};
+}
+
+function executeLuau(requestData: Record<string, unknown>) {
+	const code = requestData.code as string;
+	if (!code || code === "") return { error: "Code is required" };
+
+	const output: string[] = [];
+	const oldPrint = print;
+	const oldWarn = warn;
+
+	const env = getfenv(0) as unknown as Record<string, unknown>;
+	env["print"] = (...args: defined[]) => {
+		const parts: string[] = [];
+		for (const a of args) parts.push(tostring(a));
+		output.push(parts.join("\t"));
+		oldPrint(...(args as [defined, ...defined[]]));
+	};
+	env["warn"] = (...args: defined[]) => {
+		const parts: string[] = [];
+		for (const a of args) parts.push(tostring(a));
+		output.push(`[warn] ${parts.join("\t")}`);
+		oldWarn(...(args as [defined, ...defined[]]));
+	};
+
+	const [success, result] = pcall(() => {
+		const [fn, compileError] = loadstring(code);
+		if (!fn) error(`Compile error: ${compileError}`);
+		return fn();
+	});
+
+	env["print"] = oldPrint;
+	env["warn"] = oldWarn;
+
+	if (success) {
+		return {
+			success: true,
+			returnValue: result !== undefined ? tostring(result) : undefined,
+			output,
+			message: "Code executed successfully",
+		};
+	} else {
+		return {
+			success: false,
+			error: tostring(result),
+			output,
+			message: "Code execution failed",
+		};
+	}
+}
+
+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,
+};

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

@@ -0,0 +1,191 @@
+import Utils from "../Utils";
+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>;
+
+	if (!instancePath || !properties || !typeIs(properties, "table")) {
+		return { error: "Instance path and properties object are required" };
+	}
+
+	const instance = getInstanceByPath(instancePath);
+	if (!instance) return { error: `Instance not found: ${instancePath}` };
+
+	const recordingId = beginRecording("Set multiple properties");
+	const inst = instance as unknown as Record<string, unknown>;
+	const results: Record<string, unknown>[] = [];
+	let successCount = 0;
+	let failureCount = 0;
+
+	for (const [propName, propValue] of pairs(properties)) {
+		const [success, err] = pcall(() => {
+			if (propName === "Parent" || propName === "PrimaryPart") {
+				if (typeIs(propValue, "string")) {
+					const refInstance = getInstanceByPath(propValue as string);
+					if (!refInstance) error(`${propName} reference not found: ${propValue}`);
+					inst[propName as string] = refInstance;
+				}
+			} else if (propName === "Name") {
+				instance.Name = tostring(propValue);
+			} else if (propName === "Source" && instance.IsA("LuaSourceContainer")) {
+				(instance as unknown as { Source: string }).Source = tostring(propValue);
+			} else {
+				const converted = convertPropertyValue(instance, propName as string, propValue);
+				inst[propName as string] = converted !== undefined ? converted : propValue;
+			}
+		});
+
+		if (success) {
+			successCount++;
+			results.push({ property: propName, success: true });
+		} else {
+			failureCount++;
+			results.push({ property: propName, success: false, error: tostring(err) });
+		}
+	}
+
+	finishRecording(recordingId, successCount > 0);
+
+	return {
+		instancePath,
+		summary: { total: successCount + failureCount, succeeded: successCount, failed: failureCount },
+		results,
+	};
+}
+
+export = {
+	setProperty,
+	massSetProperty,
+	massGetProperty,
+	setProperties,
+};