@quenty/studio-bridge 0.22.1 → 0.24.0

package/templates/studio-bridge-plugin/src/StudioBridgePlugin.server.lua

@@ -1,44 +1,26 @@
 --!strict
 --[[
-	Entry point for the studio-bridge plugin. Wires the modules under Shared/ to
-	Roblox services and boots in one of two modes:
+	Entry point for the studio-bridge plugin. Starts StudioBridgeClient in one of
+	two modes:
 
 	- Ephemeral: the CLI substituted the build constants below, so it connects
 	  straight to that port and session.
 	- Persistent: the constants are left empty, so it scans for a
-	  running bridge with DiscoveryStateMachine and reconnects whenever it drops.
+	  running bridge and reconnects whenever it drops.
 
 	The plugin cannot use the Nevermore loader: rojo builds this template on its
 	own from the published CLI package, without any node_modules.
 ]]
 
-local HttpService = game:GetService("HttpService")
-local LogService = game:GetService("LogService")
-local Players = game:GetService("Players")
 local RunService = game:GetService("RunService")
 
-local ActionRouter = require(script.Parent.Shared.ActionRouter)
-local BuiltInActions = require(script.Parent.Shared.BuiltInActions)
-local DiscoveryStateMachine = require(script.Parent.Shared.DiscoveryStateMachine)
-local MessageBuffer = require(script.Parent.Shared.MessageBuffer)
-local StudioBridgeConnection = require(script.Parent.Shared.StudioBridgeConnection)
-local StudioBridgeLogUtils = require(script.Parent.Shared.StudioBridgeLogUtils)
+local StudioBridgeClient = require(script.Parent.Shared.StudioBridgeClient)
 local StudioBridgeSessionUtils = require(script.Parent.Shared.StudioBridgeSessionUtils)
 
 local PORT = "{{PORT}}"
 local SESSION_ID = "{{SESSION_ID}}"
 local IS_EPHEMERAL = ("{{EPHEMERAL}}" :: string) == "true"
 
-local LOG_BUFFER_CAPACITY = 1000
-local POLL_INTERVAL_SEC = 2
-
-local LOG_LEVELS: { [Enum.MessageType]: string } = {
-	[Enum.MessageType.MessageOutput] = "Print",
-	[Enum.MessageType.MessageInfo] = "Info",
-	[Enum.MessageType.MessageWarning] = "Warning",
-	[Enum.MessageType.MessageError] = "Error",
-}
-
 -- Playtests load a plugin instance into their server and client, but only when
 -- Studio's "load user plugins on playtest" setting is on. Those instances cannot
 -- make the HTTP requests port discovery needs, so they only connect in a
@@ -55,283 +37,25 @@ if not RunService:IsStudio() or (RunService:IsRunning() and not playtestArgs) th
 	return
 end
 
-local function createNonce(): string
-	return string.lower(string.sub(HttpService:GenerateGUID(false), 1, 4))
-end
-
-local context: StudioBridgeSessionUtils.PluginContext = StudioBridgeSessionUtils.getContext()
-local nonceOk, nonce = pcall(StudioBridgeSessionUtils.getOrCreateNonce, game:GetService("CoreGui"), createNonce)
-if not nonceOk then
-	nonce = createNonce()
-end
-
--- Read on every connect: Studio can load plugins before it names the DataModel after the place
-local function getInstanceId(): string
-	if playtestArgs then
-		return playtestArgs.instanceId
+-- A plugin that loads into the playtest's server replaces the bridge planted for it, which can only run code compiled before the playtest
+if playtestArgs and RunService:IsServer() then
+	local planted =
+		StudioBridgeSessionUtils.findPlantedBridge(game:GetService("ServerScriptService"), playtestArgs.playtestId)
+	if planted then
+		planted:Destroy()
 	end
-	return StudioBridgeSessionUtils.getInstanceId(game.Name, nonce)
-end
-local playtestPort = if playtestArgs then playtestArgs.port else nil
-
-local function getPlayerName(): string?
-	local player = if context == "client" then Players.LocalPlayer else nil
-	return if player then player.Name else nil
-end
-
--- The clients of a multiplayer test share an instance id, so their session ids name their player
-local function getSessionId(): string
-	local isMultiplayerClient = playtestArgs and playtestArgs.multiplayer and context == "client"
-	return StudioBridgeSessionUtils.getSessionId(
-		getInstanceId(),
-		context,
-		if isMultiplayerClient then getPlayerName() else nil
-	)
 end
 
-local router = ActionRouter.new()
-local logBuffer = MessageBuffer.new(LOG_BUFFER_CAPACITY)
-local currentConnection: StudioBridgeConnection.StudioBridgeConnection? = nil
-local currentWebSocket: any = nil
-local discovery: DiscoveryStateMachine.DiscoveryStateMachine? = nil
-local pollThread: thread? = nil
-local nameConnection: RBXScriptConnection? = nil
-local isUnloaded = false
-
 local pngOk, png = pcall(function()
 	return (require :: any)(script.Parent.Vendor.png)
 end)
-if pngOk then
-	router:SetVendorPng(png)
-end
-
-BuiltInActions.register(router, function(message)
-	if currentConnection then
-		currentConnection:Send(message)
-	end
-end, logBuffer)
-
--- Hybrid clock: the wall clock at load, then os.clock() deltas, which are cheaper per entry
-local clockBase = os.clock()
-local timeBase = DateTime.now().UnixTimestampMillis / 1000
-
-local logConnection = LogService.MessageOut:Connect(function(message, messageType)
-	if string.sub(message, 1, #StudioBridgeLogUtils.PREFIX) == StudioBridgeLogUtils.PREFIX then
-		return
-	end
-
-	logBuffer:Push({
-		level = LOG_LEVELS[messageType] or "Print",
-		body = message,
-		timestamp = timeBase + (os.clock() - clockBase),
-	})
-end)
 
-local function openConnection(webSocket: any, sessionId: string, label: string)
-	if isUnloaded then
-		return
-	end
-
-	if currentConnection then
-		currentConnection:Destroy()
-	end
-
-	currentConnection = StudioBridgeConnection.new({
-		webSocket = webSocket,
-		router = router,
-		sessionId = sessionId,
-		registerPayload = StudioBridgeSessionUtils.createRegisterPayload(
-			getInstanceId(),
-			context,
-			StudioBridgeSessionUtils.getLaunchId(workspace),
-			getPlayerName()
-		),
-	})
-
-	StudioBridgeLogUtils.logVerbose(`Connected to {label} as {sessionId}`)
-end
-
-local function createWebSocket(url: string): (boolean, any)
-	local ok, webSocket = pcall(function()
-		return HttpService:CreateWebStreamClient(Enum.WebStreamClientType.WebSocket, { Url = url })
-	end)
-	if ok then
-		currentWebSocket = webSocket
-	end
-	return ok, webSocket
-end
+local stop = StudioBridgeClient.start({
+	ephemeral = if IS_EPHEMERAL then { port = PORT, sessionId = SESSION_ID } else nil,
+	playtestArgs = playtestArgs,
+	vendorPng = if pngOk then png else nil,
+})
 
 -- Reloading the plugin destroys this script, but the socket callbacks and the
 -- poll loop outlive it, leaving the old instance connected beside the new one
-plugin.Unloading:Connect(function()
-	isUnloaded = true
-	logConnection:Disconnect()
-	if nameConnection then
-		nameConnection:Disconnect()
-		nameConnection = nil
-	end
-
-	if pollThread then
-		task.cancel(pollThread)
-		pollThread = nil
-	end
-	if discovery then
-		discovery:Stop()
-	end
-	if currentConnection then
-		currentConnection:Destroy()
-		currentConnection = nil
-	end
-	if currentWebSocket then
-		pcall(function()
-			currentWebSocket:Close()
-		end)
-		currentWebSocket = nil
-	end
-
-	router:Destroy()
-end)
-
-local function warnOnError(webSocket: any)
-	webSocket.Error:Connect(function(status, err)
-		StudioBridgeLogUtils.logVerbose(`WebSocket error ({status}): {err}`)
-	end)
-end
-
---[[
-	Probes every port's /health endpoint in parallel and returns the first port
-	to answer, or nil once all fail or the timeout passes. The caller is resumed
-	with task.defer so it has reached coroutine.yield() first.
-]]
-local function scanPortsAsync(ports: { number }, timeoutSec: number): (number?, string?)
-	local callerThread = coroutine.running()
-	local foundPort: number? = nil
-	local foundBody: string? = nil
-	local remaining = #ports
-	local settled = false
-
-	local function settle()
-		if not settled then
-			settled = true
-			task.defer(callerThread)
-		end
-	end
-
-	local threads: { thread } = {}
-	for _, port in ports do
-		table.insert(
-			threads,
-			task.spawn(function()
-				local ok, body = pcall(HttpService.GetAsync, HttpService, `http://localhost:{port}/health`)
-				if ok and not settled then
-					foundPort = port
-					foundBody = body
-					settle()
-					return
-				end
-
-				remaining -= 1
-				if remaining <= 0 then
-					settle()
-				end
-			end)
-		)
-	end
-	table.insert(threads, task.delay(timeoutSec, settle))
-
-	coroutine.yield()
-
-	for _, thread in threads do
-		pcall(task.cancel, thread)
-	end
-
-	return foundPort, foundBody
-end
-
-if IS_EPHEMERAL then
-	-- Every open Studio loads this plugin, but only the one launched for this run
-	-- has the session id stamped on its place, which may load after the plugin
-	local function connectEphemeral()
-		if StudioBridgeSessionUtils.getLaunchId(workspace) ~= SESSION_ID or currentWebSocket then
-			return
-		end
-
-		local ok, webSocket = createWebSocket(`ws://localhost:{PORT}/{SESSION_ID}`)
-		if not (ok and webSocket) then
-			StudioBridgeLogUtils.warn("Failed to create WebSocket client")
-			return
-		end
-
-		webSocket.Opened:Connect(function()
-			openConnection(webSocket, SESSION_ID, `localhost:{PORT} (ephemeral)`)
-		end)
-		warnOnError(webSocket)
-	end
-
-	workspace:GetAttributeChangedSignal("StudioBridgeSessionId"):Connect(connectEphemeral)
-	connectEphemeral()
-	return
-end
-
--- A multiplayer client's session id names its player, so wait for one
-if playtestArgs and playtestArgs.multiplayer and context == "client" then
-	while not Players.LocalPlayer do
-		Players:GetPropertyChangedSignal("LocalPlayer"):Wait()
-	end
-end
-
-local stateMachine: DiscoveryStateMachine.DiscoveryStateMachine
-stateMachine = DiscoveryStateMachine.new(nil, {
-	scanPortsAsync = if playtestPort
-		then function()
-			return playtestPort, nil
-		end
-		else scanPortsAsync,
-	connectWebSocket = createWebSocket,
-	onStateChange = function(oldState, newState)
-		if oldState == "idle" and newState == "searching" then
-			StudioBridgeLogUtils.logVerbose("Searching for host on ports 38741-38744...")
-		end
-	end,
-	onConnected = function(webSocket, port)
-		webSocket.Opened:Connect(function()
-			openConnection(webSocket, getSessionId(), `localhost:{port}`)
-		end)
-		webSocket.Closed:Connect(function()
-			stateMachine:HandleDisconnect("closed")
-		end)
-		warnOnError(webSocket)
-	end,
-	onDisconnected = function(reason)
-		StudioBridgeLogUtils.logVerbose(`Disconnected ({reason}), searching...`)
-	end,
-})
-
-discovery = stateMachine
-
-stateMachine:Start()
-
--- Reconnecting re-registers under the session id for the new name. A
--- playtest's id comes from its test args, so a rename leaves it unchanged.
-nameConnection = game:GetPropertyChangedSignal("Name"):Connect(function()
-	if currentWebSocket and not playtestArgs then
-		pcall(function()
-			currentWebSocket:Close()
-		end)
-	end
-end)
-
--- Each cycle gets a fixed time budget, which PollAsync threads through to the port scan
-pollThread = task.spawn(function()
-	while true do
-		local startTime = os.clock()
-		stateMachine:PollAsync(POLL_INTERVAL_SEC)
-
-		local remaining = POLL_INTERVAL_SEC - (os.clock() - startTime)
-		if remaining > 0 then
-			task.wait(remaining)
-		else
-			task.wait()
-		end
-	end
-end)
+plugin.Unloading:Connect(stop)

package/src/commands/playtest/run/playtest-runner.luau

@@ -1,264 +0,0 @@
---!strict
---[=[
-	Runs a `playtest run` script inside the playtest's server and ends the
-	playtest with the result, so running a script does not depend on Studio
-	loading user plugins into playtests.
-
-	The `run-playtest-script` action plants this source as a Script in the edit
-	DataModel, with the code as a ModuleScript named `Code` under it, and starts a
-	playtest. The playtest copies the edit DataModel, so the runner starts in its
-	server. It only acts in the playtest it was planted for: anywhere else, such
-	as a place saved while it was planted, it does nothing.
-
-	The result crosses back through `StudioTestService:EndTest` in the same shape
-	as an `execute` reply. Instances cannot cross DataModels, so values are
-	marshalled here. Output capture, tracebacks and the marshaller are copies of
-	execute.lua's, since the runner cannot require it.
-
-	@class PlaytestRunner
-]=]
-
-local MAX_DEPTH = 64
-local PLUGIN_PREFIX = "[StudioBridge]"
--- Tracebacks name this module's frames the way its first line does
-local OWN_FRAME_PREFIX = string.match(debug.traceback(), "^([^\n]-):%d+")
-
-local PlaytestRunner = {}
-
-type LogEntry = {
-	level: string,
-	body: string,
-	timestamp: number,
-}
-
-local LOG_LEVELS: { [Enum.MessageType]: string } = {
-	[Enum.MessageType.MessageOutput] = "Print",
-	[Enum.MessageType.MessageInfo] = "Info",
-	[Enum.MessageType.MessageWarning] = "Warning",
-	[Enum.MessageType.MessageError] = "Error",
-}
-
---[=[
-	Runs the `Code` module under `runner` and ends the playtest with the result,
-	when this playtest is the one `runner` was planted for.
-]=]
-function PlaytestRunner.runAsync(runner: Instance, studioTestService: any, players: Players)
-	local argsOk, testArgs = pcall(function()
-		return studioTestService:GetTestArgs()
-	end)
-	if not argsOk or type(testArgs) ~= "table" or testArgs.studioBridgeRunnerId ~= runner:GetAttribute("RunnerId") then
-		return
-	end
-
-	local hasEnded = false
-	local captured: { LogEntry } = {}
-	local function endTest(result: { [string]: any })
-		if hasEnded then
-			return
-		end
-		hasEnded = true
-		studioTestService:EndTest(result)
-	end
-
-	local timeoutSec = testArgs.studioBridgeTimeoutSec
-	if type(timeoutSec) == "number" then
-		task.delay(timeoutSec, function()
-			endTest({
-				success = false,
-				error = `Script timed out after {timeoutSec}s`,
-				code = "SCRIPT_TIMEOUT",
-				output = captured,
-			})
-		end)
-	end
-
-	-- The plugin path waits for the client to connect, so match it in play mode
-	if testArgs.studioBridgeWaitForPlayer and #players:GetPlayers() == 0 then
-		players.PlayerAdded:Wait()
-	end
-
-	local scriptArgs = if type(testArgs.studioBridgeScriptArgs) == "table" then testArgs.studioBridgeScriptArgs else {}
-	endTest(PlaytestRunner.run(runner:FindFirstChild("Code"), captured, scriptArgs))
-end
-
---[=[
-	Runs a code module with `args`, collecting everything logged while it runs
-	into `captured`, and returns the result in the shape of an `execute` reply.
-]=]
-function PlaytestRunner.run(codeModule: Instance?, captured: { LogEntry }, args: { any }?): { [string]: any }
-	if not (codeModule and codeModule:IsA("ModuleScript")) then
-		return { success = false, error = "Runner has no Code module", code = "SCRIPT_LOAD_ERROR", output = captured }
-	end
-
-	local requireOk, fn = pcall(require, codeModule)
-	if not requireOk or type(fn) ~= "function" then
-		return {
-			success = false,
-			error = if requireOk then "Code module did not return a function" else tostring(fn),
-			code = "SCRIPT_LOAD_ERROR",
-			output = captured,
-		}
-	end
-
-	local logConnection = PlaytestRunner._captureOutput(captured)
-	local returned = table.pack(xpcall(fn, function(err)
-		return {
-			message = tostring(err),
-			traceback = PlaytestRunner._dropOwnFrames(debug.traceback(nil, 2)),
-		}
-	end, table.unpack(args or {})))
-
-	-- MessageOut can fire a frame late, after the code's last print
-	task.wait()
-	logConnection:Disconnect()
-
-	if not returned[1] then
-		return {
-			success = false,
-			error = returned[2].message,
-			traceback = returned[2].traceback,
-			code = "SCRIPT_RUNTIME_ERROR",
-			output = captured,
-		}
-	end
-
-	return {
-		success = true,
-		output = captured,
-		returnValues = PlaytestRunner._serializeReturnValues(returned),
-	}
-end
-
---[[
-	Drops the frames of this module's own wrapper from a traceback, leaving only
-	the script's.
-]]
-function PlaytestRunner._dropOwnFrames(traceback: string): string
-	if not OWN_FRAME_PREFIX then
-		return traceback
-	end
-
-	local lines = {}
-	for _, line in string.split(traceback, "\n") do
-		if string.sub(line, 1, #OWN_FRAME_PREFIX + 1) ~= `{OWN_FRAME_PREFIX}:` then
-			table.insert(lines, line)
-		end
-	end
-	return table.concat(lines, "\n")
-end
-
---[[
-	Collects every message logged until the connection is disconnected, other
-	than the plugin's own.
-]]
-function PlaytestRunner._captureOutput(captured: { LogEntry }): RBXScriptConnection
-	return game:GetService("LogService").MessageOut:Connect(function(message: string, messageType: Enum.MessageType)
-		if string.sub(message, 1, #PLUGIN_PREFIX) == PLUGIN_PREFIX then
-			return
-		end
-
-		table.insert(captured, {
-			level = LOG_LEVELS[messageType] or "Print",
-			body = message,
-			timestamp = os.clock(),
-		})
-	end)
-end
-
---[[
-	Marshals what a script returned, in order, skipping the pcall status. A nil
-	becomes an explicit marker, since an array cannot hold a hole.
-]]
-function PlaytestRunner._serializeReturnValues(packed: { n: number, [number]: any }): { any }
-	local returnValues = {}
-	for index = 2, packed.n do
-		local serialized = PlaytestRunner._serializeValue(packed[index], 1, {})
-		if serialized == nil then
-			serialized = { type = "Nil" }
-		end
-		returnValues[index - 1] = serialized
-	end
-	return returnValues
-end
-
---[[
-	Produces the SerializedReturnValue shapes declared in web-socket-protocol.ts.
-	Copied from execute.lua; keep the two in step.
-]]
-function PlaytestRunner._serializeValue(value: any, depth: number, seen: { [any]: boolean }): any
-	local valueType = typeof(value)
-
-	if valueType == "nil" or valueType == "string" or valueType == "boolean" then
-		return value
-	elseif valueType == "number" then
-		if value ~= value or value == math.huge or value == -math.huge then
-			return PlaytestRunner._unsupported("number", tostring(value))
-		end
-		return value
-	elseif valueType == "table" then
-		if depth > MAX_DEPTH then
-			return PlaytestRunner._unsupported("table", "<max depth exceeded>")
-		end
-		if seen[value] then
-			return PlaytestRunner._unsupported("table", "<cycle>")
-		end
-
-		seen[value] = true
-		local serialized = PlaytestRunner._serializeTable(value, depth, seen)
-		seen[value] = nil
-		return serialized
-	elseif valueType == "Vector3" then
-		return { type = "Vector3", value = { value.X, value.Y, value.Z } }
-	elseif valueType == "Vector2" then
-		return { type = "Vector2", value = { value.X, value.Y } }
-	elseif valueType == "CFrame" then
-		return { type = "CFrame", value = { value:GetComponents() } }
-	elseif valueType == "Color3" then
-		return { type = "Color3", value = { value.R, value.G, value.B } }
-	elseif valueType == "UDim2" then
-		return { type = "UDim2", value = { value.X.Scale, value.X.Offset, value.Y.Scale, value.Y.Offset } }
-	elseif valueType == "UDim" then
-		return { type = "UDim", value = { value.Scale, value.Offset } }
-	elseif valueType == "BrickColor" then
-		return { type = "BrickColor", name = value.Name, value = value.Number }
-	elseif valueType == "EnumItem" then
-		return { type = "EnumItem", enum = tostring(value.EnumType), name = value.Name, value = value.Value }
-	elseif valueType == "Instance" then
-		return { type = "Instance", className = value.ClassName, path = value:GetFullName() }
-	else
-		return PlaytestRunner._unsupported(valueType, tostring(value))
-	end
-end
-
-function PlaytestRunner._serializeTable(value: { [any]: any }, depth: number, seen: { [any]: boolean }): any
-	local count = 0
-	for _ in value do
-		count += 1
-	end
-
-	if count == #value then
-		local array = {}
-		for index = 1, count do
-			array[index] = PlaytestRunner._serializeValue(value[index], depth + 1, seen)
-		end
-		return array
-	end
-
-	local map: { [string]: any } = {}
-	for key, item in value do
-		map[if type(key) == "string" then key else tostring(key)] =
-			PlaytestRunner._serializeValue(item, depth + 1, seen)
-	end
-	return map
-end
-
-function PlaytestRunner._unsupported(typeName: string, text: string): { [string]: any }
-	return { type = "Unsupported", typeName = typeName, toString = text }
-end
-
--- Planted as a Script it runs; in the test place it is a ModuleScript specs require
-if script:IsA("Script") then
-	task.spawn(PlaytestRunner.runAsync, script, game:GetService("StudioTestService"), game:GetService("Players"))
-end
-
-return PlaytestRunner

package/src/commands/playtest/run/playtest-runner.spec.lua

@@ -1,71 +0,0 @@
---!strict
---[[
-	@class playtest-runner.spec.lua
-]]
-
-local require = require(script.Parent.loader).load(script)
-
-local Jest = require("Jest")
-local PlaytestRunner = require("playtest-runner")
-
-local describe = Jest.Globals.describe
-local expect = Jest.Globals.expect
-local it = Jest.Globals.it
-
-local function setup(testArgs: any)
-	local ended = {}
-	local runner = Instance.new("Folder")
-	runner:SetAttribute("RunnerId", "runner-1")
-
-	local studioTestService = {
-		GetTestArgs = function()
-			return testArgs
-		end,
-		EndTest = function(_self, value)
-			table.insert(ended, value)
-		end,
-	}
-
-	return {
-		runner = runner,
-		studioTestService = studioTestService,
-		ended = ended,
-		Destroy = function()
-			runner:Destroy()
-		end,
-	}
-end
-
-describe("PlaytestRunner.runAsync()", function()
-	it("should do nothing in a playtest it was not planted for", function()
-		local controller = setup({ studioBridgeRunnerId = "someone-else" })
-
-		PlaytestRunner.runAsync(controller.runner, controller.studioTestService, game:GetService("Players"))
-
-		expect(controller.ended).toEqual({})
-		controller:Destroy()
-	end)
-
-	it("should end the playtest with a load error when the code module is missing", function()
-		local controller = setup({ studioBridgeRunnerId = "runner-1" })
-
-		PlaytestRunner.runAsync(controller.runner, controller.studioTestService, game:GetService("Players"))
-
-		expect(#controller.ended).toEqual(1)
-		expect(controller.ended[1].success).toEqual(false)
-		expect(controller.ended[1].code).toEqual("SCRIPT_LOAD_ERROR")
-		controller:Destroy()
-	end)
-end)
-
-describe("PlaytestRunner._serializeReturnValues()", function()
-	it("should keep a nil in its position", function()
-		local packed = table.pack(true, 1, nil, Vector3.new(1, 2, 3))
-
-		expect(PlaytestRunner._serializeReturnValues(packed)).toEqual({
-			1,
-			{ type = "Nil" },
-			{ type = "Vector3", value = { 1, 2, 3 } },
-		})
-	end)
-end)