@princeofscale/bloxforge-inspector 2.20.2

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

@@ -0,0 +1,149 @@
+import { LogService, ReplicatedStorage, RunService, ServerScriptService } from "@rbxts/services";
+import { BRIDGE_NAMES, ensureRuntimeBridgeInstalled } from "../EvalBridges";
+import LuauExec from "../LuauExec";
+
+const PAYLOAD_INSTANCE_NAME = "__MCPEvalPayload";
+
+interface BridgeInvokeResult {
+	ok?: boolean;
+	value?: unknown;
+}
+
+interface WrapperResult {
+	ok?: boolean;
+	value?: unknown;
+	output?: unknown;
+}
+
+function findBridge(config: { service: Instance; bridgeName: string }): BindableFunction | undefined {
+	const bridge = config.service.FindFirstChild(config.bridgeName);
+	return bridge && bridge.IsA("BindableFunction") ? bridge : undefined;
+}
+
+function waitForBridge(config: { service: Instance; bridgeName: string }, timeoutSec = 2): BindableFunction | undefined {
+	const deadline = tick() + timeoutSec;
+	let bridge = findBridge(config);
+	while (!bridge && tick() < deadline) {
+		task.wait(0.05);
+		bridge = findBridge(config);
+	}
+	return bridge;
+}
+
+function getBridgeConfig() {
+	if (!RunService.IsRunning()) {
+		return {
+			error: "eval_*_runtime requires a running playtest.",
+		};
+	}
+	if (RunService.IsServer()) {
+		return {
+			service: ServerScriptService,
+			bridgeName: BRIDGE_NAMES.serverLocal,
+			missingError: "ServerEvalBridge not found. The bridge runs inside the play DM, so a playtest must be running. The bridge installs automatically in the runtime server peer, including for manually-started playtests.",
+		};
+	}
+	return {
+		service: ReplicatedStorage,
+		bridgeName: BRIDGE_NAMES.clientLocal,
+		missingError: "ClientEvalBridge not found. The bridge runs inside the play DM, so a playtest must be running. The bridge installs automatically in the runtime client peer, including for manually-started playtests.",
+	};
+}
+
+function evalRuntime(requestData: Record<string, unknown>) {
+	const code = requestData.code as string;
+	if (!code || code === "") return { error: "Code is required" };
+
+	const config = getBridgeConfig();
+	if (config.error !== undefined) {
+		return { bridge: "missing", error: config.error };
+	}
+
+	let bridge = findBridge(config);
+	if (!bridge) {
+		const install = ensureRuntimeBridgeInstalled();
+		if (!install.installed) {
+			return {
+				bridge: "missing",
+				error: `${config.missingError} Runtime bridge install failed: ${install.error}`,
+			};
+		}
+		bridge = waitForBridge(config);
+	}
+	if (!bridge) {
+		return {
+			bridge: "missing",
+			error: `${config.missingError} Runtime bridge was installed but did not become ready.`,
+		};
+	}
+
+	const m = new Instance("ModuleScript");
+	m.Name = PAYLOAD_INSTANCE_NAME;
+	const userLines = LuauExec.countLines(code);
+	const wrapped = LuauExec.buildWrapper(code, PAYLOAD_INSTANCE_NAME);
+
+	const [okSet, setErr] = pcall(() => {
+		(m as unknown as { Source: string }).Source = wrapped;
+	});
+	if (!okSet) {
+		m.Destroy();
+		return {
+			bridge: "ok",
+			ok: false,
+			error: `ModuleScript Source set failed: ${tostring(setErr)}`,
+		};
+	}
+
+	m.Parent = game.GetService("Workspace");
+	const historyStart = LogService.GetLogHistory().size();
+	const [invokeOk, invokeResult] = pcall(() => bridge.Invoke(m) as BridgeInvokeResult);
+	m.Destroy();
+
+	if (!invokeOk) {
+		return {
+			bridge: "ok",
+			ok: false,
+			error: tostring(invokeResult),
+		};
+	}
+
+	if (!typeIs(invokeResult, "table")) {
+		return {
+			bridge: "ok",
+			ok: false,
+			error: `Eval bridge returned invalid result: ${tostring(invokeResult)}`,
+		};
+	}
+
+	const bridgeResult = invokeResult as BridgeInvokeResult;
+	if (bridgeResult.ok !== true) {
+		return {
+			bridge: "ok",
+			ok: false,
+			error: LuauExec.recoverPayloadRequireError(bridgeResult.value, userLines, PAYLOAD_INSTANCE_NAME, historyStart),
+		};
+	}
+
+	const inner = bridgeResult.value;
+	if (!typeIs(inner, "table")) {
+		return {
+			bridge: "ok",
+			ok: true,
+			result: inner === undefined ? undefined : LuauExec.formatReturnValue(inner),
+		};
+	}
+
+	const r = inner as WrapperResult;
+	const ok = r.ok === true;
+	return {
+		bridge: "ok",
+		ok,
+		result: ok && r.value !== undefined ? LuauExec.formatReturnValue(r.value) : undefined,
+		error: !ok ? tostring(r.value) : undefined,
+		output: r.output ?? [],
+	};
+}
+
+export = {
+	evalRuntime,
+};

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

@@ -0,0 +1,160 @@
+// Virtual input via UserInputService:CreateVirtualInput().
+//
+// We deliberately do NOT use VirtualInputManager:Send*Event — those methods
+// are gated behind RobloxScriptSecurity ("lacking capability RobloxScript")
+// in every context a plugin can reach (edit DM, play server/client DMs), so
+// they silently never worked. CreateVirtualInput() is callable without that
+// capability and drives the REAL input pipeline: SendKey feeds
+// UserInputService.InputBegan/Ended and the control modules (so WASD walks the
+// character at full WalkSpeed with controls intact, no Humanoid hijack),
+// SendMouseButton feeds UIS and activates GUI buttons (and hit-tests against
+// CoreGui), and SendTextInput types into the focused TextBox.
+//
+// Method set on the VirtualInput object (verified live):
+//   SendKey(isDown: boolean, keyCode: Enum.KeyCode)
+//   SendMouseButton(position: Vector2, inputType: Enum.UserInputType, isDown: boolean)
+//   SendTextInput(text: string)
+// There is NO SendMouseMove / SendMouseWheel / SendKeyEvent — so "move" and
+// "scroll" mouse actions are not supported.
+//
+// Coordinate space: SendMouseButton coordinates are logical viewport pixels
+// (origin at the top-left of the rendered viewport). On OS-scaled displays,
+// CaptureScreenshot may return a larger physical image; the MCP server reports
+// the conversion from image pixels to these logical input coordinates.
+
+import * as RenderMonitor from "../RenderMonitor";
+
+const UserInputService = game.GetService("UserInputService");
+
+interface VirtualInput {
+	SendKey(isDown: boolean, keyCode: Enum.KeyCode): void;
+	SendMouseButton(position: Vector2, inputType: Enum.UserInputType, isDown: boolean): void;
+	SendTextInput(text: string): void;
+}
+
+// One VirtualInput per plugin VM, reused across calls so that a key held down
+// in one call (action="press") and released in a later call (action="release")
+// share the same input source.
+let cachedVI: VirtualInput | undefined;
+
+function getVI(): VirtualInput | undefined {
+	if (cachedVI) return cachedVI;
+	const [ok, vi] = pcall(() => {
+		return (UserInputService as unknown as { CreateVirtualInput(): unknown }).CreateVirtualInput();
+	});
+	if (ok && vi !== undefined) {
+		cachedVI = vi as VirtualInput;
+		return cachedVI;
+	}
+	return undefined;
+}
+
+const MOUSE_TYPE_MAP: Record<string, Enum.UserInputType> = {
+	Left: Enum.UserInputType.MouseButton1,
+	Right: Enum.UserInputType.MouseButton2,
+	Middle: Enum.UserInputType.MouseButton3,
+};
+
+function simulateMouseInput(requestData: Record<string, unknown>) {
+	const action = requestData.action as string;
+	const x = requestData.x as number | undefined;
+	const y = requestData.y as number | undefined;
+	const button = (requestData.button as string) ?? "Left";
+
+	if (!action) return { error: "action is required" };
+	if (x === undefined || y === undefined) {
+		return { error: "x and y are required" };
+	}
+
+	// Input is silently dropped by the engine when the window isn't rendering
+	// (e.g. minimized). Surface that instead of returning a false success.
+	const notRendering = RenderMonitor.notRenderingReason();
+	if (notRendering !== undefined) return { error: notRendering };
+
+	const vi = getVI();
+	if (!vi) {
+		return { error: "UserInputService:CreateVirtualInput() is not available in this context" };
+	}
+
+	const inputType = MOUSE_TYPE_MAP[button] ?? Enum.UserInputType.MouseButton1;
+	const pos = new Vector2(x, y);
+
+	const [success, err] = pcall(() => {
+		if (action === "click") {
+			vi.SendMouseButton(pos, inputType, true);
+			task.wait(0.05);
+			vi.SendMouseButton(pos, inputType, false);
+		} else if (action === "mouseDown") {
+			vi.SendMouseButton(pos, inputType, true);
+		} else if (action === "mouseUp") {
+			vi.SendMouseButton(pos, inputType, false);
+		} else {
+			error(
+				`Unsupported action "${action}". CreateVirtualInput supports click, mouseDown, mouseUp ` +
+					`(no move/scroll — those methods don't exist on VirtualInput).`,
+			);
+		}
+	});
+
+	if (success) {
+		return { success: true, action, x, y, button };
+	}
+	return { error: `Failed to simulate mouse input: ${err}` };
+}
+
+function simulateKeyboardInput(requestData: Record<string, unknown>) {
+	const notRendering = RenderMonitor.notRenderingReason();
+	if (notRendering !== undefined) return { error: notRendering };
+
+	const vi = getVI();
+	if (!vi) {
+		return { error: "UserInputService:CreateVirtualInput() is not available in this context" };
+	}
+
+	// Text mode: type a string into the focused TextBox.
+	const text = requestData.text as string | undefined;
+	if (text !== undefined) {
+		const [ok, err] = pcall(() => vi.SendTextInput(text));
+		if (ok) return { success: true, text };
+		return { error: `Failed to send text input: ${err}` };
+	}
+
+	const keyCodeName = requestData.keyCode as string;
+	if (!keyCodeName) return { error: "keyCode (or text) is required" };
+
+	const action = (requestData.action as string) ?? "tap";
+	const duration = (requestData.duration as number | undefined) ?? (requestData.holdDuration as number | undefined) ?? 0.1;
+
+	const [enumOk, keyCode] = pcall(() => {
+		return (Enum.KeyCode as unknown as Record<string, Enum.KeyCode>)[keyCodeName];
+	});
+	if (!enumOk || !keyCode) {
+		return {
+			error: `Unknown keyCode: ${keyCodeName}. Use Enum.KeyCode names like "W", "Space", "E", "LeftShift", etc.`,
+		};
+	}
+
+	const [success, err] = pcall(() => {
+		if (action === "press") {
+			vi.SendKey(true, keyCode);
+		} else if (action === "release") {
+			vi.SendKey(false, keyCode);
+		} else if (action === "tap") {
+			vi.SendKey(true, keyCode);
+			task.wait(duration);
+			vi.SendKey(false, keyCode);
+		} else {
+			error(`Unknown action: ${action}`);
+		}
+	});
+
+	if (success) {
+		return { success: true, keyCode: keyCodeName, action };
+	}
+	return { error: `Failed to simulate keyboard input: ${err}` };
+}
+
+export = {
+	simulateMouseInput,
+	simulateKeyboardInput,
+};

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

@@ -0,0 +1,380 @@
+import Utils from "../Utils";
+import Recording from "../Recording";
+
+const { getInstancePath, getInstanceByPath, convertPropertyValue } = Utils;
+const { beginRecording, finishRecording } = Recording;
+
+type ProcessedCreateResult =
+	| {
+		instance: Instance;
+		className: string;
+		parentPath: string;
+	}
+	| {
+		error: string;
+		className?: string;
+		parentPath?: string;
+	};
+
+type ProcessedBatchResult = {
+	results: Record<string, unknown>[];
+	successCount: number;
+	failureCount: number;
+};
+
+function processObjectEntries(
+	objects: Record<string, unknown>[],
+	createFn: (objData: Record<string, unknown>) => ProcessedCreateResult,
+): ProcessedBatchResult {
+	const results: Record<string, unknown>[] = [];
+	let successCount = 0;
+	let failureCount = 0;
+
+	const [loopSuccess, loopError] = pcall(() => {
+		for (const entry of objects) {
+			if (!typeIs(entry, "table")) {
+				failureCount++;
+				results.push({ success: false, error: "Each object entry must be a table" });
+				continue;
+			}
+
+			const objData = entry as Record<string, unknown>;
+			const className = objData.className as string;
+			const parentPath = objData.parent as string;
+
+			if (!className || !parentPath) {
+				failureCount++;
+				results.push({ success: false, error: "Class name and parent are required" });
+				continue;
+			}
+
+			const [entrySuccess, entryResult] = pcall(() => createFn(objData));
+			if (!entrySuccess) {
+				failureCount++;
+				results.push({ success: false, className, parent: parentPath, error: tostring(entryResult) });
+				continue;
+			}
+
+			if ("instance" in entryResult) {
+				successCount++;
+				results.push({
+					success: true,
+					className: entryResult.className,
+					parent: entryResult.parentPath,
+					instancePath: getInstancePath(entryResult.instance),
+					name: entryResult.instance.Name,
+				});
+			} else {
+				failureCount++;
+				results.push({
+					success: false,
+					className: entryResult.className ?? className,
+					parent: entryResult.parentPath ?? parentPath,
+					error: entryResult.error,
+				});
+			}
+		}
+	});
+
+	if (!loopSuccess) {
+		failureCount++;
+		results.push({ success: false, error: `Unexpected mass create failure: ${tostring(loopError)}` });
+	}
+
+	return { results, successCount, failureCount };
+}
+
+function createObject(requestData: Record<string, unknown>) {
+	const className = requestData.className as string;
+	const parentPath = requestData.parent as string;
+	const name = requestData.name as string | undefined;
+	const properties = (requestData.properties as Record<string, unknown>) ?? {};
+
+	if (!className || !parentPath) {
+		return { error: "Class name and parent are required" };
+	}
+
+	const parentInstance = getInstanceByPath(parentPath);
+	if (!parentInstance) return { error: `Parent instance not found: ${parentPath}` };
+	const recordingId = beginRecording(`Create ${className}`);
+
+	const [success, newInstance] = pcall(() => {
+		const instance = new Instance(className as keyof CreatableInstances);
+		if (name) instance.Name = name;
+
+		for (const [propertyName, propertyValue] of pairs(properties)) {
+			pcall(() => {
+				const converted = convertPropertyValue(instance, propertyName as string, propertyValue);
+				(instance as unknown as { [key: string]: unknown })[propertyName as string] =
+					converted !== undefined ? converted : propertyValue;
+			});
+		}
+
+		instance.Parent = parentInstance;
+		return instance;
+	});
+
+	if (success && newInstance) {
+		finishRecording(recordingId, true);
+		return {
+			success: true,
+			className,
+			parent: parentPath,
+			instancePath: getInstancePath(newInstance as Instance),
+			name: (newInstance as Instance).Name,
+			message: "Object created successfully",
+		};
+	} else {
+		finishRecording(recordingId, false);
+		return { error: `Failed to create object: ${newInstance}`, className, parent: parentPath };
+	}
+}
+
+function deleteObject(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}` };
+	if (instance === game) return { error: "Cannot delete the game instance" };
+	const recordingId = beginRecording(`Delete ${instance.ClassName} (${instance.Name})`);
+
+	const [success, result] = pcall(() => {
+		instance.Destroy();
+		return true;
+	});
+
+	if (success) {
+		finishRecording(recordingId, true);
+		return { success: true, instancePath, message: "Object deleted successfully" };
+	} else {
+		finishRecording(recordingId, false);
+		return { error: `Failed to delete object: ${result}`, instancePath };
+	}
+}
+
+function massCreateObjects(requestData: Record<string, unknown>) {
+	const objects = requestData.objects as Record<string, unknown>[];
+	if (!objects || !typeIs(objects, "table") || (objects as defined[]).size() === 0) {
+		return { error: "Objects array is required" };
+	}
+
+	const recordingId = beginRecording("Mass create objects");
+
+	const { results, successCount, failureCount } = processObjectEntries(objects, (objData) => {
+		const className = objData.className as string;
+		const parentPath = objData.parent as string;
+		const name = objData.name as string | undefined;
+		const properties = (objData.properties as Record<string, unknown>) ?? {};
+		const parentInstance = getInstanceByPath(parentPath);
+		if (!parentInstance) {
+			return { error: "Parent instance not found", className, parentPath };
+		}
+
+		const [success, newInstance] = pcall(() => {
+			const instance = new Instance(className as keyof CreatableInstances);
+			if (name) instance.Name = name;
+
+			for (const [propertyName, propertyValue] of pairs(properties)) {
+				pcall(() => {
+					const converted = convertPropertyValue(instance, propertyName as string, propertyValue);
+					(instance as unknown as { [key: string]: unknown })[propertyName as string] =
+						converted !== undefined ? converted : propertyValue;
+				});
+			}
+
+			instance.Parent = parentInstance;
+			return instance;
+		});
+
+		if (!success || !newInstance) {
+			return { error: tostring(newInstance), className, parentPath };
+		}
+
+		return { instance: newInstance as Instance, className, parentPath };
+	});
+
+	finishRecording(recordingId, successCount > 0);
+	return { results, summary: { total: (objects as defined[]).size(), succeeded: successCount, failed: failureCount } };
+}
+
+
+
+function performSmartDuplicate(requestData: Record<string, unknown>, useRecording = true) {
+	const instancePath = requestData.instancePath as string;
+	const count = requestData.count as number;
+	const options = (requestData.options as Record<string, unknown>) ?? {};
+
+	if (!instancePath || !count || count < 1) {
+		return { error: "Instance path and count > 0 are required" };
+	}
+
+	const instance = getInstanceByPath(instancePath);
+	if (!instance) return { error: `Instance not found: ${instancePath}` };
+	const recordingId = useRecording ? beginRecording(`Smart duplicate ${instance.Name}`) : undefined;
+
+	const results: Record<string, unknown>[] = [];
+	let successCount = 0;
+	let failureCount = 0;
+
+	for (let i = 1; i <= count; i++) {
+		const [success, newInstance] = pcall(() => {
+			const clone = instance.Clone();
+
+			if (options.namePattern) {
+				clone.Name = (options.namePattern as string).gsub("{n}", tostring(i))[0];
+			} else {
+				clone.Name = instance.Name + i;
+			}
+
+			if (options.positionOffset && clone.IsA("BasePart")) {
+				const offset = options.positionOffset as number[];
+				const currentPos = clone.Position;
+				clone.Position = new Vector3(
+					currentPos.X + ((offset[0] ?? 0) as number) * i,
+					currentPos.Y + ((offset[1] ?? 0) as number) * i,
+					currentPos.Z + ((offset[2] ?? 0) as number) * i,
+				);
+			}
+
+			if (options.rotationOffset && clone.IsA("BasePart")) {
+				const offset = options.rotationOffset as number[];
+				clone.CFrame = clone.CFrame.mul(CFrame.Angles(
+					math.rad(((offset[0] ?? 0) as number) * i),
+					math.rad(((offset[1] ?? 0) as number) * i),
+					math.rad(((offset[2] ?? 0) as number) * i),
+				));
+			}
+
+			if (options.scaleOffset && clone.IsA("BasePart")) {
+				const offset = options.scaleOffset as number[];
+				const currentSize = clone.Size;
+				clone.Size = new Vector3(
+					currentSize.X * (((offset[0] ?? 1) as number) ** i),
+					currentSize.Y * (((offset[1] ?? 1) as number) ** i),
+					currentSize.Z * (((offset[2] ?? 1) as number) ** i),
+				);
+			}
+
+			if (options.propertyVariations) {
+				for (const [propName, values] of pairs(options.propertyVariations as Record<string, unknown[]>)) {
+					if (values && (values as defined[]).size() > 0) {
+						const valueIndex = ((i - 1) % (values as defined[]).size());
+						pcall(() => {
+							(clone as unknown as { [key: string]: unknown })[propName as string] = (values as unknown[])[valueIndex];
+						});
+					}
+				}
+			}
+
+			const targetParents = options.targetParents as string[] | undefined;
+			if (targetParents && targetParents[i - 1]) {
+				const targetParent = getInstanceByPath(targetParents[i - 1]);
+				clone.Parent = targetParent ?? instance.Parent;
+			} else {
+				clone.Parent = instance.Parent;
+			}
+
+			return clone;
+		});
+
+		if (success && newInstance) {
+			successCount++;
+			results.push({
+				success: true,
+				instancePath: getInstancePath(newInstance as Instance),
+				name: (newInstance as Instance).Name,
+				index: i,
+			});
+		} else {
+			failureCount++;
+			results.push({ success: false, index: i, error: tostring(newInstance) });
+		}
+	}
+
+	finishRecording(recordingId, successCount > 0);
+
+	return {
+		results,
+		summary: { total: count, succeeded: successCount, failed: failureCount },
+		sourceInstance: instancePath,
+	};
+}
+
+function smartDuplicate(requestData: Record<string, unknown>) {
+	return performSmartDuplicate(requestData, true);
+}
+
+function massDuplicate(requestData: Record<string, unknown>) {
+	const duplications = requestData.duplications as Record<string, unknown>[];
+	if (!duplications || !typeIs(duplications, "table") || (duplications as defined[]).size() === 0) {
+		return { error: "Duplications array is required" };
+	}
+
+	const allResults: Record<string, unknown>[] = [];
+	let totalSuccess = 0;
+	let totalFailures = 0;
+	const recordingId = beginRecording("Mass duplicate operations");
+
+	for (const duplication of duplications) {
+		const result = performSmartDuplicate(duplication, false) as { summary?: { succeeded: number; failed: number } };
+		allResults.push(result as unknown as Record<string, unknown>);
+		if (result.summary) {
+			totalSuccess += result.summary.succeeded;
+			totalFailures += result.summary.failed;
+		}
+	}
+
+	finishRecording(recordingId, totalSuccess > 0);
+
+	return {
+		results: allResults,
+		summary: { total: totalSuccess + totalFailures, succeeded: totalSuccess, failed: totalFailures },
+	};
+}
+
+function cloneObject(requestData: Record<string, unknown>) {
+	const instancePath = requestData.instancePath as string;
+	const targetParentPath = requestData.targetParentPath as string;
+
+	if (!instancePath || !targetParentPath) {
+		return { error: "Instance path and target parent path are required" };
+	}
+
+	const instance = getInstanceByPath(instancePath);
+	if (!instance) return { error: `Instance not found: ${instancePath}` };
+
+	const targetParent = getInstanceByPath(targetParentPath);
+	if (!targetParent) return { error: `Target parent not found: ${targetParentPath}` };
+
+	const recordingId = beginRecording(`Clone ${instance.Name}`);
+
+	const [success, clone] = pcall(() => {
+		const cloned = instance.Clone();
+		cloned.Parent = targetParent;
+		return cloned;
+	});
+
+	if (success && clone) {
+		finishRecording(recordingId, true);
+		return {
+			success: true,
+			instancePath: getInstancePath(clone as Instance),
+			name: (clone as Instance).Name,
+			className: (clone as Instance).ClassName,
+			parent: targetParentPath,
+			message: "Object cloned successfully",
+		};
+	}
+	finishRecording(recordingId, false);
+	return { error: `Failed to clone object: ${clone}` };
+}
+
+export = {
+	createObject,
+	deleteObject,
+	massCreateObjects,
+	smartDuplicate,
+	massDuplicate,
+	cloneObject,
+};