@el4cteo/rbx-studio-mcp 0.7.2 → 0.7.5

package/plugin/src/handlers/Exec.luau

@@ -12,99 +12,16 @@
 	the reason for running it at all.
 ]]
 
-local LogService = game:GetService("LogService")
 local RunService = game:GetService("RunService")
 
 local Dispatch = require(script.Parent.Parent.Dispatch)
-local Serialize = require(script.Parent.Parent.Serialize)
-
--- A chunk that prints in a loop would otherwise return a response no context
--- window can hold.
-local MAX_OUTPUT_LINES = 200
-local MAX_RETURN_VALUES = 10
-
--- Returned tables are walked rather than counted, but not without limit: a
--- chunk that returns a whole config tree, or one with a cycle in it, must not be
--- able to produce a response nothing can read.
-local MAX_TABLE_ENTRIES = 50
-local MAX_TABLE_DEPTH = 4
+local Runtime = require(script.Parent.Parent.ExecRuntime)
+local ClientRelay = require(script.Parent.Parent.ClientRelay)
 
 local CHUNK_NAME = "StudioMCP.execute_luau"
 
 local Exec = {}
 
---[[
-	Describes a returned value.
-
-	Tables used to come back as "<table with 5 entries>", which threw away the
-	answer whenever the answer was a table -- and returning a table is the natural
-	way to report several things at once, so this hit constantly. They are walked
-	now, bounded by breadth and depth. Everything else goes through the same
-	serializer the rest of the server uses, so a Vector3 reads the way it does
-	everywhere else.
-]]
-local function describe(value: any, depth: number?, seen: { [any]: boolean }?): any
-	local level = depth or 0
-	local visited = seen or {}
-	local kind = typeof(value)
-
-	if kind == "function" or kind == "thread" then
-		return string.format("<%s>", kind)
-	end
-	if kind ~= "table" then
-		return Serialize.value(value)
-	end
-
-	local source = value :: { [any]: any }
-	-- Named separately from the depth cap, because they mean opposite things to
-	-- a reader. The depth cap says "there is more below this"; a cycle says
-	-- "this is the table you are already inside". Reporting the second as the
-	-- first printed `t.self.self.self` as three distinct nested tables, which
-	-- reads as real structure that does not exist.
-	if visited[source] then
-		return "<circular reference>"
-	end
-	if level >= MAX_TABLE_DEPTH then
-		return "<nested table>"
-	end
-	visited[source] = true
-
-	local count = 0
-	for _ in source do
-		count += 1
-	end
-
-	-- Arrays keep their shape so they read as lists on the other side; anything
-	-- with non-sequential keys becomes a map with stringified keys.
-	if count == #source then
-		local list: { any } = {}
-		for index, item in ipairs(source) do
-			if index > MAX_TABLE_ENTRIES then
-				table.insert(list, string.format("<%d more>", count - MAX_TABLE_ENTRIES))
-				break
-			end
-			table.insert(list, describe(item, level + 1, visited))
-		end
-		-- Cleared on the way out so the same table appearing twice side by side
-		-- still renders twice; only a table containing itself is a cycle.
-		visited[source] = nil
-		return list
-	end
-
-	local map: { [string]: any } = {}
-	local shown = 0
-	for key, item in source do
-		shown += 1
-		if shown > MAX_TABLE_ENTRIES then
-			map["..."] = string.format("<%d more>", count - MAX_TABLE_ENTRIES)
-			break
-		end
-		map[tostring(key)] = describe(item, level + 1, visited)
-	end
-	visited[source] = nil
-	return map
-end
-
 --[[
 	Compiles the chunk by whichever route this session actually allows.
 
@@ -225,6 +142,36 @@ function Exec.run(params: { [string]: any }): { [string]: any }
 		)
 	end
 
+	if params.target == "client" then
+		local player = ClientRelay.playerFor(params.player)
+		local timeout = math.clamp(tonumber(params.timeoutSeconds) or 30, 1, 300)
+		local result = ClientRelay.run(player, "MCPExecRelay", [==[
+local report = script:WaitForChild("Report", 10)
+if not report then return end
+local ok, result = pcall(function()
+	assert(game:GetService("RunService"):IsClient(), "Client VM required")
+	local runtime = require(script:WaitForChild("ExecRuntime"))
+	local compiled, chunk = pcall(require, script:WaitForChild("Chunk"))
+	if not compiled then
+		return { ok = false, error = tostring(chunk), output = {}, milliseconds = 0 }
+	end
+	return runtime.run(chunk, script:GetAttribute("Timeout"))
+end)
+report:FireServer(if ok then result else { ok = false, error = tostring(result), output = {}, milliseconds = 0 })
+]==], { Timeout = timeout }, timeout + 5, function(relay)
+			-- These modules are required ONLY by the LocalScript, sharing the game's client VM.
+			for _, name in { "ExecRuntime", "Serialize", "Paths", "Dispatch" } do
+				local copy = script.Parent.Parent[name]:Clone()
+				copy.Parent = relay
+			end
+			local chunk = Instance.new("ModuleScript")
+			chunk.Name = "Chunk"
+			chunk.Parent = relay
+			chunk.Source = "return function(...) " .. source .. "\nend"
+		end)
+		return result
+	end
+
 	local chunk, compileError, route, module = compile(source)
 	if chunk == nil then
 		if route == "none" then
@@ -243,82 +190,10 @@ function Exec.run(params: { [string]: any }): { [string]: any }
 		)
 	end
 
-	-- Captured rather than inferred: a chunk's prints are usually the point, and
-	-- reading them back from the log afterwards would also pick up whatever else
-	-- the place logged in the meantime.
-	local output: { { [string]: any } } = {}
-	local connection = LogService.MessageOut:Connect(function(message, messageType)
-		if #output < MAX_OUTPUT_LINES then
-			table.insert(output, {
-				message = message,
-				level = if messageType == Enum.MessageType.MessageError
-					then "error"
-					elseif messageType == Enum.MessageType.MessageWarning then "warning"
-					else "print",
-			})
-		end
-	end)
-
-	local started = os.clock()
-	local results = table.pack(pcall(chunk :: () -> ...any))
-	local elapsed = os.clock() - started
-
-	--[[
-		MessageOut is deferred: `print` returns before the event fires, so
-		disconnecting straight after the chunk finished captured nothing at all.
-		A short settle picks the lines up.
-
-		It is bounded and stops as soon as the flow stops, rather than waiting a
-		fixed period, so a chunk that logged nothing costs almost no time and one
-		that logged plenty is not truncated.
-	]]
-	local settleDeadline = os.clock() + 0.5
-	local seen = #output
-	local quietFrames = 0
-	while os.clock() < settleDeadline and quietFrames < 3 do
-		task.wait()
-		if #output == seen then
-			quietFrames += 1
-		else
-			seen = #output
-			quietFrames = 0
-		end
-	end
-
-	connection:Disconnect()
-
-	if module then
-		module:Destroy()
-	end
-
-	local identity = notes(route, source)
-
-	if not results[1] then
-		return {
-			ok = false,
-			error = tostring(results[2]),
-			output = output,
-			note = identity,
-			milliseconds = math.floor(elapsed * 1000 + 0.5),
-		}
-	end
-
-	local returned: { any } = {}
-	for index = 2, math.min(results.n, MAX_RETURN_VALUES + 1) do
-		-- A nil return is written out rather than dropped. `table.insert` of nil
-		-- does nothing, so `return a, nil, b` came back as two values and every
-		-- one after the nil shifted into the wrong position.
-		local value = results[index]
-		table.insert(returned, if value == nil then "nil" else describe(value))
-	end
-
-	return {
-		ok = true,
-		returned = returned,
-		output = output,
-		note = identity,
-		milliseconds = math.floor(elapsed * 1000 + 0.5),
-	}
+	local result = Runtime.run(chunk :: any)
+	if module then module:Destroy() end
+	result.note = notes(route, source)
+	return result
 end
 
 function Exec.register()

package/plugin/src/handlers/Input.luau

@@ -24,8 +24,7 @@
 ]]
 
 local HttpService = game:GetService("HttpService")
-local Players = game:GetService("Players")
-local ReplicatedStorage = game:GetService("ReplicatedStorage")
+local ClientRelay = require(script.Parent.Parent.ClientRelay)
 local RunService = game:GetService("RunService")
 
 local Dispatch = require(script.Parent.Parent.Dispatch)
@@ -111,7 +110,7 @@ local performed = {}
 local landed = nil
 local aimed = nil
 local seenAt = nil
-UserInputService.InputBegan:Connect(function(input)
+local inputConnection = UserInputService.InputBegan:Connect(function(input)
 	local kind = input.UserInputType
 	if aimed ~= nil and (kind == Enum.UserInputType.MouseButton1 or kind == Enum.UserInputType.Touch) then
 		seenAt = { x = input.Position.X, y = input.Position.Y }
@@ -192,6 +191,16 @@ local HOTSPOT_FALLBACK = Vector2.new(0.484, 0.5)
 
 local cursor = nil
 local cursorGui = nil
+local function cleanup()
+	inputConnection:Disconnect()
+	if cursorGui then cursorGui:Destroy() end
+end
+relay.Destroying:Connect(cleanup)
+local mainThread = coroutine.running()
+local watchdog = task.delay(relay:GetAttribute("Budget") or 20, function()
+	cleanup()
+	task.cancel(mainThread)
+end)
 
 local function makeCursor()
 	if relay:GetAttribute("Cursor") ~= true then
@@ -322,7 +331,29 @@ local function refusedKey(key, err)
 	return string.format("%s was not sent: %s", key, message)
 end
 
+local function guiTarget(path)
+	local object = Players.LocalPlayer
+	for segment in string.gmatch(path, "[^%.]+") do
+		object = object:FindFirstChild(segment)
+		if object == nil then error("GUI target not found: " .. path) end
+	end
+	if not object:IsA("GuiObject") then error("Target is not a GuiObject: " .. path) end
+	return object
+end
+
 local function runStep(step): boolean
+	local target = if step.target then guiTarget(step.target) else nil
+	if target then
+		local centre = target.AbsolutePosition + target.AbsoluteSize / 2
+		local inset = game:GetService("GuiService"):GetGuiInset()
+		step.x, step.y = centre.X + inset.X, centre.Y + inset.Y
+		if target:IsA("TextBox") then
+			target:CaptureFocus()
+			task.wait(0.05)
+		elseif step.kind == "text" then
+			error("Text target must be a TextBox: " .. step.target)
+		end
+	end
 	local kind = step.kind
 	if kind == "key" then
 		local code = Enum.KeyCode[step.key]
@@ -410,6 +441,8 @@ if cursorGui ~= nil then
 	cursorGui:Destroy()
 end
 
+task.cancel(watchdog)
+inputConnection:Disconnect()
 report:FireServer({
 	ok = true,
 	performed = performed,
@@ -420,35 +453,6 @@ report:FireServer({
 })
 ]==]
 
-local function playerFor(name: string?): Player
-	local players = Players:GetPlayers()
-	if #players == 0 then
-		Dispatch.fail(
-			"NO_PLAYER",
-			"No player is in this session.",
-			"Input needs a running playtest with a character. Use `playtest op=\"play\"`, "
-				.. "then address this at the playtest's studioId."
-		)
-	end
-	if name == nil or name == "" then
-		if #players > 1 then
-			Dispatch.fail(
-				"AMBIGUOUS_PLAYER",
-				string.format("%d players are in this session.", #players),
-				"Name one with `player`."
-			)
-		end
-		return players[1]
-	end
-	for _, player in players do
-		if player.Name == name then
-			return player
-		end
-	end
-	Dispatch.fail("NO_PLAYER", string.format("No player named %q is in this session.", name))
-	return players[1]
-end
-
 --[[
 	Turns the request into steps the relay understands, validating names here
 	rather than on the client where a bad one would silently do nothing.
@@ -469,6 +473,12 @@ local function planFrom(params: { [string]: any }): { { [string]: any } }
 	for index, raw in steps :: { { [string]: any } } do
 		local kind = tostring(raw.kind or "key")
 		local step: { [string]: any } = { kind = kind }
+		if raw.target ~= nil then
+			if (kind ~= "click" and kind ~= "text") or typeof(raw.target) ~= "string" or raw.target == "" then
+				Dispatch.fail("BAD_PARAMS", "target must be a GUI path on a click or text step.")
+			end
+			step.target = raw.target
+		end
 
 		if raw.after ~= nil then
 			step.after = math.clamp(tonumber(raw.after) or 0, 0, MAX_HOLD)
@@ -539,52 +549,21 @@ function Input.send(params: { [string]: any }): { [string]: any }
 	end
 
 	local plan = planFrom(params)
-	local player = playerFor(if typeof(params.player) == "string" then params.player else nil)
-	local playerGui = player:FindFirstChildOfClass("PlayerGui")
-	if playerGui == nil then
-		Dispatch.fail("NO_PLAYER", string.format("%s has no PlayerGui yet.", player.Name))
-	end
-
-	local remote = Instance.new("RemoteEvent")
-	remote.Name = "Report"
-
-	local relay = Instance.new("LocalScript")
-	relay.Name = "MCPInputRelay"
-	relay.Source = RELAY_SOURCE
-	relay:SetAttribute("Plan", HttpService:JSONEncode(plan))
-	relay:SetAttribute("Cursor", params.cursor ~= false)
-
-	remote.Parent = relay
-
-	local answer: { [string]: any }? = nil
-	local connection = remote.OnServerEvent:Connect(function(_from, payload)
-		if typeof(payload) == "table" then
-			answer = payload :: { [string]: any }
-		end
-	end)
-
-	-- Parenting last: the script starts the moment it lands, and it waits for
-	-- the RemoteEvent, so both must already be in place.
-	relay.Parent = playerGui
-
-	local deadline = os.clock() + ACK_TIMEOUT
-	while answer == nil and os.clock() < deadline do
-		task.wait(0.05)
-	end
-
-	connection:Disconnect()
-	relay:Destroy()
+	local player = ClientRelay.playerFor(params.player)
 
-	if answer == nil then
-		Dispatch.fail(
-			"NO_ACK",
-			string.format("The client did not confirm the input within %ds.", ACK_TIMEOUT),
-			"Nothing here can tell whether some of it was delivered. Read `character op=\"state\"` "
-				.. "to see where things actually are."
-		)
+	--[[
+		The deadline grows with the plan. A flat 20s refused plans the schema
+		allows -- two 10s holds and a tap came back NO_ACK while the client was
+		still pressing keys. Each step also gets a little for cursor travel.
+	]]
+	local budget = ACK_TIMEOUT
+	for _, step in plan do
+		budget += (step.hold or 0) + (step.after or 0) + 0.5
 	end
+	local result = ClientRelay.run(player, "MCPInputRelay", RELAY_SOURCE, {
+		Plan = HttpService:JSONEncode(plan), Cursor = params.cursor ~= false, Budget = budget,
+	}, budget + 2)
 
-	local result = answer :: { [string]: any }
 	if result.ok ~= true then
 		Dispatch.fail("INPUT_FAILED", tostring(result.reason or "the client refused the plan"))
 	end