rbxstudio-mcp 1.14.3 → 2.1.0

package/studio-plugin/plugin.luau

@@ -111,7 +111,7 @@ local screenGui = plugin:CreateDockWidgetPluginGuiAsync(
 	"MCPServerInterface",
 	DockWidgetPluginGuiInfo.new(Enum.InitialDockState.Float, false, false, 400, 500, 350, 450)
 )
-screenGui.Title = "MCP Server v1.14.0"
+screenGui.Title = "MCP Server v2.0.0"
 
 local mainFrame = Instance.new("Frame")
 mainFrame.Size = UDim2.new(1, 0, 1, 0)
@@ -164,7 +164,7 @@ local versionLabel = Instance.new("TextLabel")
 versionLabel.Size = UDim2.new(1, 0, 0, 16)
 versionLabel.Position = UDim2.new(0, 0, 0, 32)
 versionLabel.BackgroundTransparency = 1
-versionLabel.Text = "AI Integration • v1.14.0"
+versionLabel.Text = "AI Integration • v2.0.0"
 versionLabel.TextColor3 = Color3.fromRGB(191, 219, 254)
 versionLabel.TextScaled = false
 versionLabel.TextSize = 12
@@ -4015,6 +4015,223 @@ handlers.redo = function(requestData)
 	end
 end
 
+-- ============================================
+-- EXECUTE LUA HANDLER (Run arbitrary Lua code)
+-- ============================================
+
+handlers.executeLua = function(requestData)
+	local code = requestData.code
+
+	if not code or type(code) ~= "string" then
+		return {
+			success = false,
+			error = "code parameter is required and must be a string"
+		}
+	end
+
+	-- Create a sandboxed environment with access to game services and Roblox types
+	local env = setmetatable({
+		-- Core globals
+		game = game,
+		workspace = workspace,
+		script = nil, -- No script context
+
+		-- Services (commonly used)
+		Players = game:GetService("Players"),
+		Workspace = workspace,
+		ReplicatedStorage = game:GetService("ReplicatedStorage"),
+		ServerStorage = game:GetService("ServerStorage"),
+		ServerScriptService = game:GetService("ServerScriptService"),
+		StarterGui = game:GetService("StarterGui"),
+		StarterPack = game:GetService("StarterPack"),
+		StarterPlayer = game:GetService("StarterPlayer"),
+		Lighting = game:GetService("Lighting"),
+		SoundService = game:GetService("SoundService"),
+		TweenService = game:GetService("TweenService"),
+		RunService = game:GetService("RunService"),
+		UserInputService = game:GetService("UserInputService"),
+		HttpService = game:GetService("HttpService"),
+		CollectionService = game:GetService("CollectionService"),
+		PhysicsService = game:GetService("PhysicsService"),
+		PathfindingService = game:GetService("PathfindingService"),
+		TextService = game:GetService("TextService"),
+		MarketplaceService = game:GetService("MarketplaceService"),
+		TeleportService = game:GetService("TeleportService"),
+		GroupService = game:GetService("GroupService"),
+		BadgeService = game:GetService("BadgeService"),
+		DataStoreService = game:GetService("DataStoreService"),
+		MemoryStoreService = game:GetService("MemoryStoreService"),
+		MessagingService = game:GetService("MessagingService"),
+		PolicyService = game:GetService("PolicyService"),
+		LocalizationService = game:GetService("LocalizationService"),
+		Selection = game:GetService("Selection"),
+		ChangeHistoryService = game:GetService("ChangeHistoryService"),
+		ScriptEditorService = game:GetService("ScriptEditorService"),
+
+		-- Roblox constructors
+		Instance = Instance,
+		Vector3 = Vector3,
+		Vector2 = Vector2,
+		CFrame = CFrame,
+		Color3 = Color3,
+		BrickColor = BrickColor,
+		UDim = UDim,
+		UDim2 = UDim2,
+		Rect = Rect,
+		Ray = Ray,
+		Region3 = Region3,
+		NumberSequence = NumberSequence,
+		NumberSequenceKeypoint = NumberSequenceKeypoint,
+		ColorSequence = ColorSequence,
+		ColorSequenceKeypoint = ColorSequenceKeypoint,
+		NumberRange = NumberRange,
+		TweenInfo = TweenInfo,
+		Font = Font,
+
+		-- Enums
+		Enum = Enum,
+
+		-- Lua globals
+		print = print,
+		warn = warn,
+		error = error,
+		assert = assert,
+		type = type,
+		typeof = typeof,
+		tostring = tostring,
+		tonumber = tonumber,
+		pairs = pairs,
+		ipairs = ipairs,
+		next = next,
+		select = select,
+		unpack = unpack,
+		pcall = pcall,
+		xpcall = xpcall,
+		rawget = rawget,
+		rawset = rawset,
+		rawequal = rawequal,
+		setmetatable = setmetatable,
+		getmetatable = getmetatable,
+		newproxy = newproxy,
+
+		-- Tables
+		table = table,
+		string = string,
+		math = math,
+		os = { time = os.time, date = os.date, difftime = os.difftime, clock = os.clock },
+		coroutine = coroutine,
+		bit32 = bit32,
+		utf8 = utf8,
+		buffer = buffer,
+
+		-- Task library
+		task = task,
+		wait = task.wait,
+		delay = task.delay,
+		spawn = task.spawn,
+		defer = task.defer,
+
+		-- Instance helper from plugin
+		getInstanceByPath = getInstanceByPath,
+
+		-- Allow loadstring for dynamic code (we're already in a plugin context)
+		loadstring = loadstring,
+	}, { __index = _G })
+
+	local success, compileResult = pcall(function()
+		return loadstring(code)
+	end)
+
+	if not success then
+		return {
+			success = false,
+			error = "Failed to compile code: " .. tostring(compileResult)
+		}
+	end
+
+	local fn = compileResult
+	if not fn then
+		return {
+			success = false,
+			error = "Failed to compile code (loadstring returned nil)"
+		}
+	end
+
+	-- Set the environment
+	setfenv(fn, env)
+
+	-- Execute the code
+	local execSuccess, execResult = pcall(fn)
+
+	if not execSuccess then
+		return {
+			success = false,
+			error = "Runtime error: " .. tostring(execResult)
+		}
+	end
+
+	-- Serialize the result
+	local function serializeResult(value, depth)
+		depth = depth or 0
+		if depth > 5 then return "<max depth>" end
+
+		local t = typeof(value)
+
+		if value == nil then
+			return nil
+		elseif t == "string" then
+			return value
+		elseif t == "number" or t == "boolean" then
+			return value
+		elseif t == "Vector3" then
+			return { type = "Vector3", X = value.X, Y = value.Y, Z = value.Z }
+		elseif t == "Vector2" then
+			return { type = "Vector2", X = value.X, Y = value.Y }
+		elseif t == "CFrame" then
+			local components = { value:GetComponents() }
+			return { type = "CFrame", components = components }
+		elseif t == "Color3" then
+			return { type = "Color3", R = value.R, G = value.G, B = value.B }
+		elseif t == "BrickColor" then
+			return { type = "BrickColor", Name = value.Name }
+		elseif t == "UDim2" then
+			return { type = "UDim2", X = { Scale = value.X.Scale, Offset = value.X.Offset }, Y = { Scale = value.Y.Scale, Offset = value.Y.Offset } }
+		elseif t == "UDim" then
+			return { type = "UDim", Scale = value.Scale, Offset = value.Offset }
+		elseif t == "Instance" then
+			return { type = "Instance", ClassName = value.ClassName, Name = value.Name, Path = value:GetFullName() }
+		elseif t == "EnumItem" then
+			return { type = "EnumItem", Name = tostring(value) }
+		elseif t == "table" then
+			local result = {}
+			local count = 0
+			for k, v in pairs(value) do
+				count = count + 1
+				if count > 100 then
+					result["__truncated__"] = true
+					break
+				end
+				local keyStr = type(k) == "string" and k or tostring(k)
+				result[keyStr] = serializeResult(v, depth + 1)
+			end
+			return result
+		elseif t == "function" then
+			return "<function>"
+		elseif t == "thread" then
+			return "<thread>"
+		else
+			return "<" .. t .. ">"
+		end
+	end
+
+	return {
+		success = true,
+		result = serializeResult(execResult),
+		resultType = typeof(execResult),
+		message = "Code executed successfully"
+	}
+end
+
 -- ============================================
 -- INSERT ASSET HANDLER (Creator Store)
 -- ============================================
@@ -4382,6 +4599,295 @@ handlers.captureScreenshot = function(requestData)
 	return resultData
 end
 
+-- ============================================
+-- VIEWPORTFRAME RENDERING SYSTEM
+-- ============================================
+
+-- Camera angle presets
+local CameraPresets = {
+	-- Standard orthographic views
+	front = CFrame.new(0, 0, 10) * CFrame.Angles(0, 0, 0),
+	back = CFrame.new(0, 0, -10) * CFrame.Angles(0, math.pi, 0),
+	left = CFrame.new(-10, 0, 0) * CFrame.Angles(0, math.pi/2, 0),
+	right = CFrame.new(10, 0, 0) * CFrame.Angles(0, -math.pi/2, 0),
+	top = CFrame.new(0, 10, 0) * CFrame.Angles(-math.pi/2, 0, 0),
+	bottom = CFrame.new(0, -10, 0) * CFrame.Angles(math.pi/2, 0, 0),
+
+	-- Isometric views (popular for thumbnails)
+	iso = CFrame.new(7, 7, 7) * CFrame.Angles(-math.pi/6, math.pi/4, 0),
+	iso_front = CFrame.new(5, 5, 10) * CFrame.Angles(-math.pi/6, 0, 0),
+	iso_back = CFrame.new(-5, 5, -10) * CFrame.Angles(-math.pi/6, math.pi, 0),
+
+	-- Dramatic angles
+	low_angle = CFrame.new(0, -5, 10) * CFrame.Angles(math.pi/6, 0, 0),
+	high_angle = CFrame.new(0, 15, 8) * CFrame.Angles(-math.pi/3, 0, 0),
+}
+
+-- Apply lighting preset to WorldModel
+local function applyLightingPreset(worldModel, preset)
+	-- Remove existing lighting
+	for _, child in ipairs(worldModel:GetChildren()) do
+		if child:IsA("Light") or child:IsA("Sky") or child:IsA("Atmosphere") then
+			child:Destroy()
+		end
+	end
+
+	if preset == "bright" or preset == "showcase" then
+		-- Three-point lighting setup
+		local keyLight = Instance.new("PointLight")
+		keyLight.Brightness = 2
+		keyLight.Range = 60
+		keyLight.Color = Color3.fromRGB(255, 255, 255)
+		keyLight.Parent = worldModel
+
+		local fillLight = Instance.new("PointLight")
+		fillLight.Brightness = 1
+		fillLight.Range = 40
+		fillLight.Color = Color3.fromRGB(200, 220, 255)
+		fillLight.Parent = worldModel
+
+		local rimLight = Instance.new("PointLight")
+		rimLight.Brightness = 1.5
+		rimLight.Range = 50
+		rimLight.Color = Color3.fromRGB(255, 240, 200)
+		rimLight.Parent = worldModel
+
+	elseif preset == "studio" or preset == "flat" then
+		-- Flat, even lighting like in Studio
+		local ambientLight = Instance.new("PointLight")
+		ambientLight.Brightness = 1
+		ambientLight.Range = 100
+		ambientLight.Color = Color3.fromRGB(255, 255, 255)
+		ambientLight.Parent = worldModel
+
+	elseif preset == "dark" or preset == "dramatic" then
+		-- Single directional light
+		local light = Instance.new("PointLight")
+		light.Brightness = 1.5
+		light.Range = 40
+		light.Color = Color3.fromRGB(255, 200, 150)
+		light.Parent = worldModel
+	end
+	-- default: no lights added (ambient only)
+end
+
+-- Calculate bounding box of a model
+local function getModelBoundingBox(model)
+	local parts = {}
+
+	-- Collect all BaseParts
+	for _, child in ipairs(model:GetDescendants()) do
+		if child:IsA("BasePart") then
+			table.insert(parts, child)
+		end
+	end
+
+	if #parts == 0 then
+		-- No parts found, return default
+		return Vector3.new(1, 1, 1), Vector3.new(0, 0, 0)
+	end
+
+	-- Calculate bounding box
+	local minPos = parts[1].Position - parts[1].Size/2
+	local maxPos = parts[1].Position + parts[1].Size/2
+
+	for _, part in ipairs(parts) do
+		local partMin = part.Position - part.Size/2
+		local partMax = part.Position + part.Size/2
+
+		minPos = Vector3.new(
+			math.min(minPos.X, partMin.X),
+			math.min(minPos.Y, partMin.Y),
+			math.min(minPos.Z, partMin.Z)
+		)
+		maxPos = Vector3.new(
+			math.max(maxPos.X, partMax.X),
+			math.max(maxPos.Y, partMax.Y),
+			math.max(maxPos.Z, partMax.Z)
+		)
+	end
+
+	local size = maxPos - minPos
+	local center = (minPos + maxPos) / 2
+
+	return size, center
+end
+
+-- Main handler: Render Object View
+handlers.renderObjectView = function(requestData)
+	local success, result = pcall(function()
+		local instancePath = requestData.instancePath
+		if not instancePath then
+			return {
+				success = false,
+				error = "instancePath is required"
+			}
+		end
+
+		-- Parse resolution
+		local resolution = requestData.resolution or {width = 512, height = 512}
+		local width = resolution.width or 512
+		local height = resolution.height or 512
+
+		-- Clamp resolution for performance
+		width = math.clamp(width, 64, 2048)
+		height = math.clamp(height, 64, 2048)
+
+		local anglePreset = requestData.angle or "iso"
+		local lighting = requestData.lighting or "bright"
+		local background = requestData.background or "transparent"
+		local autoDistance = requestData.autoDistance ~= false
+
+		-- Get target instance
+		local targetInstance = getInstanceByPath(instancePath)
+		if not targetInstance then
+			return {
+				success = false,
+				error = "Instance not found: " .. instancePath
+			}
+		end
+
+		-- Create ViewportFrame (no parent = no GUI overhead)
+		local viewportFrame = Instance.new("ViewportFrame")
+		viewportFrame.Size = UDim2.fromOffset(width, height)
+		viewportFrame.BackgroundTransparency = background == "transparent" and 1 or 0
+		viewportFrame.BackgroundColor3 = background == "grid" and Color3.fromRGB(128, 128, 128) or Color3.fromRGB(255, 255, 255)
+
+		-- Create WorldModel for viewport
+		local worldModel = Instance.new("WorldModel")
+		worldModel.Parent = viewportFrame
+
+		local camera = Instance.new("Camera")
+		camera.Parent = viewportFrame
+		viewportFrame.CurrentCamera = camera
+
+		-- Clone target into WorldModel
+		local clonedInstance = targetInstance:Clone()
+		clonedInstance.Parent = worldModel
+
+		-- Calculate bounding box and center
+		local boundingSize, boundingCenter = getModelBoundingBox(clonedInstance)
+		local maxDimension = math.max(boundingSize.X, boundingSize.Y, boundingSize.Z)
+
+		-- Position camera
+		local cameraOffset
+		if type(anglePreset) == "string" and CameraPresets[anglePreset] then
+			cameraOffset = CameraPresets[anglePreset]
+		elseif type(anglePreset) == "table" then
+			-- Custom angle {pitch, yaw, roll, distance}
+			local pitch = math.rad(anglePreset.pitch or 0)
+			local yaw = math.rad(anglePreset.yaw or 0)
+			local roll = math.rad(anglePreset.roll or 0)
+			local distance = anglePreset.distance or 10
+			cameraOffset = CFrame.new(0, 0, distance) * CFrame.Angles(pitch, yaw, roll)
+		else
+			cameraOffset = CameraPresets.iso
+		end
+
+		-- Auto-calculate distance to fit object
+		local cameraDistance = 10
+		if autoDistance then
+			local fov = 70
+			cameraDistance = maxDimension / (2 * math.tan(math.rad(fov / 2))) * 1.3
+			cameraDistance = math.max(cameraDistance, 1) -- Minimum distance
+		elseif type(anglePreset) == "table" and anglePreset.distance then
+			cameraDistance = anglePreset.distance
+		end
+
+		-- Apply distance to camera offset
+		local offsetDirection = cameraOffset.Position.Unit
+		local finalCameraPos = boundingCenter + (offsetDirection * cameraDistance)
+
+		camera.CFrame = CFrame.new(finalCameraPos, boundingCenter) * cameraOffset.Rotation
+		camera.FieldOfView = 70
+
+		-- Apply lighting
+		applyLightingPreset(worldModel, lighting)
+
+		-- Add grid background if requested
+		if background == "grid" then
+			local gridPart = Instance.new("Part")
+			gridPart.Size = Vector3.new(maxDimension * 5, 0.1, maxDimension * 5)
+			gridPart.Position = boundingCenter - Vector3.new(0, boundingSize.Y/2 + 0.1, 0)
+			gridPart.Anchored = true
+			gridPart.Material = Enum.Material.SmoothPlastic
+			gridPart.Color = Color3.fromRGB(200, 200, 200)
+			gridPart.Parent = worldModel
+		end
+
+		-- Wait for viewport to render
+		task.wait(0.1)
+		RunService.Heartbeat:Wait()
+
+		-- Capture to EditableImage using AssetService
+		local AssetService = game:GetService("AssetService")
+		local editableImage = AssetService:CreateEditableImage({
+			Size = Vector2.new(width, height)
+		})
+
+		-- Read pixels from viewport
+		local pixelSuccess, pixelBuffer = pcall(function()
+			return viewportFrame:ReadPixelsBuffer(Vector2.new(0, 0), Vector2.new(width, height))
+		end)
+
+		if not pixelSuccess or not pixelBuffer then
+			viewportFrame:Destroy()
+			editableImage:Destroy()
+			return {
+				success = false,
+				error = "Failed to capture viewport pixels: " .. tostring(pixelBuffer)
+			}
+		end
+
+		-- Write pixels to EditableImage
+		editableImage:WritePixelsBuffer(Vector2.new(0, 0), Vector2.new(width, height), pixelBuffer)
+
+		-- Convert to base64 RGBA
+		local rgbaBuffer = editableImage:ReadPixelsBuffer(Vector2.new(0, 0), editableImage.Size)
+		local rgbaString = buffer.tostring(rgbaBuffer)
+		local base64Data = base64encode(rgbaString)
+
+		-- Cleanup
+		viewportFrame:Destroy()
+		editableImage:Destroy()
+
+		return {
+			success = true,
+			base64 = base64Data,
+			width = width,
+			height = height,
+			viewInfo = {
+				objectName = targetInstance.Name,
+				objectClass = targetInstance.ClassName,
+				boundingBox = {
+					size = {x = boundingSize.X, y = boundingSize.Y, z = boundingSize.Z},
+					center = {x = boundingCenter.X, y = boundingCenter.Y, z = boundingCenter.Z}
+				},
+				camera = {
+					distance = cameraDistance,
+					position = {x = finalCameraPos.X, y = finalCameraPos.Y, z = finalCameraPos.Z}
+				},
+				settings = {
+					angle = anglePreset,
+					lighting = lighting,
+					background = background,
+					resolution = {width = width, height = height}
+				}
+			},
+			message = "Rendered " .. targetInstance.Name .. " at " .. width .. "x" .. height
+		}
+	end)
+
+	if success then
+		return result
+	else
+		return {
+			success = false,
+			error = "Failed to render object: " .. tostring(result)
+		}
+	end
+end
+
 -- Now that all handlers are defined, populate the endpoint mapping table
 endpointHandlers = {
 	["/api/file-tree"] = handlers.getFileTree,
@@ -4431,11 +4937,15 @@ endpointHandlers = {
 	["/api/insert-asset"] = handlers.insertAsset,
 	["/api/undo"] = handlers.undo,
 	["/api/redo"] = handlers.redo,
+	-- Execute Lua
+	["/api/execute-lua"] = handlers.executeLua,
 	-- Playtest control
 	["/api/play-solo"] = handlers.playSolo,
 	["/api/stop-play"] = handlers.stopPlay,
 	-- Screenshot
 	["/api/capture-screenshot"] = handlers.captureScreenshot,
+	-- ViewportFrame rendering
+	["/api/render-object-view"] = handlers.renderObjectView,
 }
 
 local function updateUIState()