dominus-cli 2.0.0 → 2.1.1

package/plugin/src/Protocol.lua

@@ -1,30 +1,30 @@
---[[
-	Message protocol: JSON encoding/decoding with unique ID generation
-]]
-
-local HttpService = game:GetService("HttpService")
-
-local Protocol = {}
-
-function Protocol.encode(data)
-	return HttpService:JSONEncode(data)
-end
-
-function Protocol.decode(json)
-	return HttpService:JSONDecode(json)
-end
-
-function Protocol.generateId()
-	return HttpService:GenerateGUID(false)
-end
-
-function Protocol.createMessage(msgType, payload)
-	return {
-		id = Protocol.generateId(),
-		type = msgType,
-		payload = payload,
-		ts = os.clock(),
-	}
-end
-
-return Protocol
+--[[
+	Message protocol: JSON encoding/decoding with unique ID generation
+]]
+
+local HttpService = game:GetService("HttpService")
+
+local Protocol = {}
+
+function Protocol.encode(data)
+	return HttpService:JSONEncode(data)
+end
+
+function Protocol.decode(json)
+	return HttpService:JSONDecode(json)
+end
+
+function Protocol.generateId()
+	return HttpService:GenerateGUID(false)
+end
+
+function Protocol.createMessage(msgType, payload)
+	return {
+		id = Protocol.generateId(),
+		type = msgType,
+		payload = payload,
+		ts = os.clock(),
+	}
+end
+
+return Protocol

package/plugin/src/Reflection.lua

@@ -1,22 +1,39 @@
---[[
-	Reflection module: query Roblox class/property/method/event information
-	Uses the new ReflectionService API (2025+):
-	  - GetClass(className, filter?)
-	  - GetClasses(filter?)
-	  - GetPropertiesOfClass(className, filter?)
-	  - GetMethodsOfClass(className, filter?)
-	  - GetEventsOfClass(className, filter?)
-]]
-
 local ReflectionService = game:GetService("ReflectionService")
+
 local Reflection = {}
 
-local function safeCall(fn, ...)
-	local ok, result = pcall(fn, ...)
-	if ok then return result end
+local function safeCall(callback)
+	local ok, result = pcall(callback)
+	if ok then
+		return result
+	end
 	return nil, result
 end
 
+local function typeName(reflectionType)
+	if reflectionType == nil then
+		return "unknown"
+	end
+	if type(reflectionType) == "table" then
+		return reflectionType.Name or reflectionType.name or reflectionType.Type or tostring(reflectionType)
+	end
+	return tostring(reflectionType)
+end
+
+local function displayCategory(member)
+	if member.Display and member.Display.Category then
+		return member.Display.Category
+	end
+	return "Other"
+end
+
+local function permitString(permits, key)
+	if not permits or permits[key] == nil then
+		return nil
+	end
+	return tostring(permits[key])
+end
+
 function Reflection.getClassInfo(className)
 	local classData, classErr = safeCall(function()
 		return ReflectionService:GetClass(className)
@@ -27,13 +44,15 @@ function Reflection.getClassInfo(className)
 		return ReflectionService:GetPropertiesOfClass(className)
 	end)
 	if propData then
-		for _, prop in propData do
+		for _, property in propData do
 			table.insert(properties, {
-				name = prop.Name,
-				type = prop.ValueType and tostring(prop.ValueType) or "unknown",
-				category = prop.Category or "Other",
-				serialized = prop.Serialized,
-				owner = prop.Owner,
+				name = property.Name,
+				type = typeName(property.Type),
+				category = displayCategory(property),
+				owner = property.Owner,
+				serialized = property.Serialized,
+				readPermission = permitString(property.Permits, "Read"),
+				writePermission = permitString(property.Permits, "Write"),
 			})
 		end
 	end
@@ -44,18 +63,19 @@ function Reflection.getClassInfo(className)
 	end)
 	if methodData then
 		for _, method in methodData do
-			local params = {}
-			if method.Parameters then
-				for _, param in method.Parameters do
-					table.insert(params, {
-						name = param.Name,
-						type = param.Type and tostring(param.Type) or "unknown",
-					})
-				end
+			local parameters = {}
+			for _, parameter in method.Parameters or {} do
+				table.insert(parameters, {
+					name = parameter.Name,
+					type = typeName(parameter.Type),
+					defaultValue = parameter.DefaultValue,
+				})
 			end
 			table.insert(methods, {
 				name = method.Name,
-				parameters = params,
+				parameters = parameters,
+				returnType = typeName(method.ReturnType),
+				canYield = method.CanYield,
 				owner = method.Owner,
 			})
 		end
@@ -67,70 +87,82 @@ function Reflection.getClassInfo(className)
 	end)
 	if eventData then
 		for _, event in eventData do
-			local params = {}
-			if event.Parameters then
-				for _, param in event.Parameters do
-					table.insert(params, {
-						name = param.Name,
-						type = param.Type and tostring(param.Type) or "unknown",
-					})
-				end
+			local parameters = {}
+			for _, parameter in event.Parameters or {} do
+				table.insert(parameters, { name = parameter.Name, type = typeName(parameter.Type) })
 			end
-			table.insert(events, {
-				name = event.Name,
-				parameters = params,
-				owner = event.Owner,
-			})
+			table.insert(events, { name = event.Name, parameters = parameters, owner = event.Owner })
 		end
 	end
 
 	local result = {
+		success = classData ~= nil or #properties > 0,
 		className = className,
 		properties = properties,
 		methods = methods,
 		events = events,
 	}
-
 	if classData then
-		result.superclass = classData.Superclass
-		result.creatable = classData.Creatable
-		result.serialized = classData.Serialized
+		result.superclass = classData.Superclass and tostring(classData.Superclass) or nil
+		result.newPermission = permitString(classData.Permits, "New")
+		result.creatable = classData.Permits ~= nil and classData.Permits.New ~= nil
 	end
-
 	if classErr and #properties == 0 then
 		result.error = "Could not reflect class: " .. tostring(classErr)
 	end
-
 	return result
 end
 
 function Reflection.getPropertyTypes(className)
-	local propData = safeCall(function()
+	local properties = safeCall(function()
 		return ReflectionService:GetPropertiesOfClass(className)
 	end)
-	if not propData then return {} end
+	if not properties then
+		return {}
+	end
+	local result = {}
+	for _, property in properties do
+		result[property.Name] = typeName(property.Type)
+	end
+	return result
+end
 
-	local typeMap = {}
-	for _, prop in propData do
-		typeMap[prop.Name] = prop.ValueType and tostring(prop.ValueType) or "unknown"
+function Reflection.getPropertyMetadata(className)
+	local properties = safeCall(function()
+		return ReflectionService:GetPropertiesOfClass(className)
+	end)
+	if not properties then
+		return {}
+	end
+	local result = {}
+	for _, property in properties do
+		result[property.Name] = {
+			type = typeName(property.Type),
+			category = displayCategory(property),
+			writable = property.Permits == nil or property.Permits.Write ~= nil,
+		}
 	end
-	return typeMap
+	return result
 end
 
 function Reflection.listClasses()
 	local classes = safeCall(function()
 		return ReflectionService:GetClasses()
 	end)
-	if not classes then return {} end
-
+	if not classes then
+		return {}
+	end
 	local result = {}
-	for _, cls in classes do
+	for _, classData in classes do
 		table.insert(result, {
-			name = cls.Name,
-			superclass = cls.Superclass,
-			creatable = cls.Creatable,
+			name = classData.Name,
+			superclass = classData.Superclass and tostring(classData.Superclass) or nil,
+			creatable = classData.Permits ~= nil and classData.Permits.New ~= nil,
 		})
 	end
+	table.sort(result, function(a, b)
+		return a.name < b.name
+	end)
 	return result
 end
 

package/plugin/src/TestRunner.lua

@@ -1,141 +1,69 @@
---[[
-	TestRunner: interface with StudioTestService for automated testing
-	https://create.roblox.com/docs/reference/engine/classes/StudioTestService
-
-	StudioTestService allows plugins to:
-	- ExecuteRunModeAsync(args) → start Run mode, yield until EndTest
-	- ExecutePlayModeAsync(args) → start Play/Solo mode, yield until EndTest
-	- GetTestArgs() → retrieve args from inside the running session
-	- EndTest(value) → end the session and return a value
-]]
-
-local TestRunner = {}
-
-local StudioTestService = game:GetService("StudioTestService")
-
-function TestRunner.executeRunMode(args)
-	local startTime = os.clock()
-	local ok, result = pcall(function()
-		return StudioTestService:ExecuteRunModeAsync(args)
-	end)
-	local duration = os.clock() - startTime
-
-	if not ok then
-		return {
-			success = false,
-			error = tostring(result),
-			duration = duration,
-		}
-	end
-
-	return {
-		success = true,
-		result = result,
-		duration = duration,
-	}
-end
-
-function TestRunner.executePlayMode(args)
-	local startTime = os.clock()
-	local ok, result = pcall(function()
-		return StudioTestService:ExecutePlayModeAsync(args)
-	end)
-	local duration = os.clock() - startTime
-
-	if not ok then
-		return {
-			success = false,
-			error = tostring(result),
-			duration = duration,
-		}
-	end
-
-	return {
-		success = true,
-		result = result,
-		duration = duration,
-	}
-end
-
-function TestRunner.endTest(value)
-	local ok, err = pcall(function()
-		StudioTestService:EndTest(value)
-	end)
-
-	if not ok then
-		return { success = false, error = tostring(err) }
-	end
-
-	return { success = true }
-end
-
-function TestRunner.run(testName)
-	local results = {}
-
-	local ok, err = pcall(function()
-		local TestService = game:GetService("TestService")
-
-		if testName then
-			local testScript = nil
-			for _, desc in game:GetDescendants() do
-				if desc:IsA("ModuleScript") and desc.Name == testName then
-					testScript = desc
-					break
-				end
-			end
-
-			if not testScript then
-				table.insert(results, {
-					name = testName,
-					passed = false,
-					duration = 0,
-					error = "Test not found: " .. testName,
-				})
-				return
-			end
-
-			local startTime = os.clock()
-			local testOk, testErr = pcall(function()
-				require(testScript)
-			end)
-			local duration = os.clock() - startTime
-
-			table.insert(results, {
-				name = testName,
-				passed = testOk,
-				duration = duration,
-				error = not testOk and tostring(testErr) or nil,
-			})
-		else
-			for _, desc in game:GetDescendants() do
-				if desc:IsA("ModuleScript") then
-					local name = desc.Name
-					if string.match(name, "%.test$") or string.match(name, "%.spec$")
-						or string.match(name, "Test$") or string.match(name, "Spec$") then
-
-						local startTime = os.clock()
-						local testOk, testErr = pcall(function()
-							require(desc)
-						end)
-						local duration = os.clock() - startTime
-
-						table.insert(results, {
-							name = name,
-							passed = testOk,
-							duration = duration,
-							error = not testOk and tostring(testErr) or nil,
-						})
-					end
-				end
-			end
-		end
-	end)
-
-	if not ok then
-		return { results = {{ name = "TestRunner", passed = false, duration = 0, error = tostring(err) }} }
-	end
-
-	return { results = results }
-end
-
-return TestRunner
+local StudioTestService = game:GetService("StudioTestService")
+
+local TestRunner = {}
+local activeRunId = nil
+
+function TestRunner.executeV2(spec)
+	if activeRunId then
+		return { success = false, error = "A Dominus Studio test is already running" }
+	end
+
+	local mode = spec.mode or "run"
+	if mode ~= "run" and mode ~= "play" and mode ~= "multiplayer" then
+		return { success = false, error = "mode must be run, play, or multiplayer" }
+	end
+	local timeoutSeconds = math.clamp((spec.timeoutMs or 120000) / 1000, 5, 600)
+	local players = math.clamp(spec.players or 1, 1, 8)
+	local runId = tostring(os.clock()) .. ":" .. mode
+	activeRunId = runId
+	local timedOut = false
+
+	task.delay(timeoutSeconds, function()
+		if activeRunId ~= runId then
+			return
+		end
+		timedOut = true
+		pcall(function()
+			if StudioTestService:CanLeaveTest() then
+				StudioTestService:LeaveTest()
+			end
+		end)
+	end)
+
+	local startedAt = os.clock()
+	local ok, result = pcall(function()
+		if mode == "run" then
+			return StudioTestService:ExecuteRunModeAsync(spec.args)
+		elseif mode == "play" then
+			return StudioTestService:ExecutePlayModeAsync(spec.args)
+		end
+		return StudioTestService:ExecuteMultiplayerTestAsync(players, spec.args)
+	end)
+	local duration = os.clock() - startedAt
+	if activeRunId == runId then
+		activeRunId = nil
+	end
+
+	if timedOut then
+		return { success = false, timedOut = true, error = "Studio test exceeded its timeout", duration = duration }
+	end
+	if not ok then
+		return { success = false, error = tostring(result), duration = duration }
+	end
+	return {
+		success = true,
+		mode = mode,
+		players = mode == "multiplayer" and players or nil,
+		result = result,
+		duration = duration,
+	}
+end
+
+function TestRunner.endTest(value)
+	local ok, err = pcall(function()
+		StudioTestService:EndTest(value)
+	end)
+	return ok and { success = true } or { success = false, error = tostring(err) }
+end
+
+return TestRunner