dominus-cli 2.0.0 → 2.1.1

package/plugin/src/ValueCodec.lua

@@ -0,0 +1,231 @@
+local InstanceRegistry = require(script.Parent.InstanceRegistry)
+
+local ValueCodec = {}
+
+local function number(value, label)
+	if type(value) ~= "number" then
+		error(label .. " must be a number")
+	end
+	return value
+end
+
+local function component(value, names, index, default)
+	for _, name in names do
+		if value[name] ~= nil then
+			return number(value[name], name)
+		end
+	end
+	if value[index] ~= nil then
+		return number(value[index], tostring(index))
+	end
+	return default
+end
+
+local function decodeColor3(value)
+	if type(value) == "string" then
+		if value:sub(1, 1) == "#" then
+			return Color3.fromHex(value)
+		end
+		local r, g, b = value:match("rgb%s*%((%d+)%D+(%d+)%D+(%d+)%)")
+		if r then
+			return Color3.fromRGB(tonumber(r), tonumber(g), tonumber(b))
+		end
+		error("Color3 strings must be #RRGGBB or rgb(r,g,b)")
+	end
+	if type(value) ~= "table" then
+		error("Color3 must be a string or array")
+	end
+	local r = component(value, { "R", "r", "red" }, 1, 0)
+	local g = component(value, { "G", "g", "green" }, 2, 0)
+	local b = component(value, { "B", "b", "blue" }, 3, 0)
+	if r > 1 or g > 1 or b > 1 then
+		return Color3.fromRGB(r, g, b)
+	end
+	return Color3.new(r, g, b)
+end
+
+local function decodeEnum(current, value)
+	if typeof(value) == "EnumItem" then
+		return value
+	end
+	if type(value) ~= "string" then
+		error("Enum value must be a string")
+	end
+	local itemName = value:match("Enum%.[^.]+%.(.+)") or value
+	for _, item in current.EnumType:GetEnumItems() do
+		if item.Name == itemName then
+			return item
+		end
+	end
+	error("Invalid enum value " .. value .. " for " .. tostring(current.EnumType))
+end
+
+function ValueCodec.decodeForCurrent(current, value)
+	local expectedType = typeof(current)
+	if expectedType == "UDim2" then
+		assert(type(value) == "table", "UDim2 must be an array or object")
+		return UDim2.new(
+			component(value, { "XScale", "xScale" }, 1, 0),
+			component(value, { "XOffset", "xOffset" }, 2, 0),
+			component(value, { "YScale", "yScale" }, 3, 0),
+			component(value, { "YOffset", "yOffset" }, 4, 0)
+		)
+	elseif expectedType == "UDim" then
+		assert(type(value) == "table", "UDim must be an array or object")
+		return UDim.new(component(value, { "Scale", "scale" }, 1, 0), component(value, { "Offset", "offset" }, 2, 0))
+	elseif expectedType == "Vector2" then
+		assert(type(value) == "table", "Vector2 must be an array or object")
+		return Vector2.new(component(value, { "X", "x" }, 1, 0), component(value, { "Y", "y" }, 2, 0))
+	elseif expectedType == "Vector3" then
+		assert(type(value) == "table", "Vector3 must be an array or object")
+		return Vector3.new(
+			component(value, { "X", "x" }, 1, 0),
+			component(value, { "Y", "y" }, 2, 0),
+			component(value, { "Z", "z" }, 3, 0)
+		)
+	elseif expectedType == "Color3" then
+		return decodeColor3(value)
+	elseif expectedType == "BrickColor" then
+		return BrickColor.new(value)
+	elseif expectedType == "EnumItem" then
+		return decodeEnum(current, value)
+	elseif expectedType == "Rect" then
+		assert(type(value) == "table", "Rect must be a four-number array")
+		return Rect.new(number(value[1], "1"), number(value[2], "2"), number(value[3], "3"), number(value[4], "4"))
+	elseif expectedType == "NumberRange" then
+		if type(value) == "number" then
+			return NumberRange.new(value)
+		end
+		assert(type(value) == "table", "NumberRange must be a number or two-number array")
+		return NumberRange.new(number(value[1], "1"), number(value[2] or value[1], "2"))
+	elseif expectedType == "CFrame" then
+		assert(type(value) == "table", "CFrame must be an array")
+		if #value == 3 then
+			return CFrame.new(value[1], value[2], value[3])
+		elseif #value == 12 then
+			return CFrame.new(table.unpack(value))
+		end
+		error("CFrame requires 3 or 12 numbers")
+	elseif expectedType == "NumberSequence" then
+		if type(value) == "number" then
+			return NumberSequence.new(value)
+		end
+		assert(type(value) == "table", "NumberSequence must be a number or keypoint array")
+		local keypoints = {}
+		for _, keypoint in value do
+			table.insert(keypoints, NumberSequenceKeypoint.new(keypoint[1], keypoint[2], keypoint[3] or 0))
+		end
+		return NumberSequence.new(keypoints)
+	elseif expectedType == "ColorSequence" then
+		if type(value) == "string" then
+			return ColorSequence.new(decodeColor3(value))
+		end
+		assert(type(value) == "table", "ColorSequence must be a color or keypoint array")
+		local keypoints = {}
+		for _, keypoint in value do
+			table.insert(keypoints, ColorSequenceKeypoint.new(keypoint[1], decodeColor3(keypoint[2])))
+		end
+		return ColorSequence.new(keypoints)
+	elseif expectedType == "Font" then
+		assert(type(value) == "table", "Font must be an object")
+		local weight = Enum.FontWeight[value.Weight or value.weight or "Regular"]
+		local style = Enum.FontStyle[value.Style or value.style or "Normal"]
+		assert(weight and style, "Invalid Font weight or style")
+		return Font.new(value.Family or value.family, weight, style)
+	elseif expectedType == "Instance" then
+		local resolved, err = InstanceRegistry.resolve(value)
+		if not resolved then
+			error(err)
+		end
+		return resolved
+	elseif expectedType == "number" then
+		return number(value, "Property")
+	elseif expectedType == "boolean" then
+		assert(type(value) == "boolean", "Property must be a boolean")
+		return value
+	elseif expectedType == "string" then
+		assert(type(value) == "string", "Property must be a string")
+		return value
+	end
+	return value
+end
+
+function ValueCodec.encode(value)
+	local valueType = typeof(value)
+	if valueType == "UDim2" then
+		return { value.X.Scale, value.X.Offset, value.Y.Scale, value.Y.Offset }
+	end
+	if valueType == "UDim" then
+		return { value.Scale, value.Offset }
+	end
+	if valueType == "Vector2" then
+		return { value.X, value.Y }
+	end
+	if valueType == "Vector3" then
+		return { value.X, value.Y, value.Z }
+	end
+	if valueType == "Color3" then
+		return "#" .. value:ToHex()
+	end
+	if valueType == "BrickColor" then
+		return value.Name
+	end
+	if valueType == "EnumItem" then
+		return tostring(value)
+	end
+	if valueType == "Rect" then
+		return { value.Min.X, value.Min.Y, value.Max.X, value.Max.Y }
+	end
+	if valueType == "NumberRange" then
+		return { value.Min, value.Max }
+	end
+	if valueType == "CFrame" then
+		return { value:GetComponents() }
+	end
+	if valueType == "NumberSequence" then
+		local result = {}
+		for _, keypoint in value.Keypoints do
+			table.insert(result, { keypoint.Time, keypoint.Value, keypoint.Envelope })
+		end
+		return result
+	end
+	if valueType == "ColorSequence" then
+		local result = {}
+		for _, keypoint in value.Keypoints do
+			table.insert(result, { keypoint.Time, "#" .. keypoint.Value:ToHex() })
+		end
+		return result
+	end
+	if valueType == "Font" then
+		return { Family = value.Family, Weight = value.Weight.Name, Style = value.Style.Name }
+	end
+	if valueType == "Instance" then
+		return InstanceRegistry.toRef(value)
+	end
+	if valueType == "boolean" or valueType == "number" or valueType == "string" then
+		return value
+	end
+	return tostring(value)
+end
+
+function ValueCodec.setProperty(instance, propertyName, value)
+	if propertyName == "Parent" or propertyName == "ClassName" then
+		error("Property cannot be changed through setProperties: " .. propertyName)
+	end
+	local readOk, current = pcall(function()
+		return instance[propertyName]
+	end)
+	if not readOk then
+		error("Unknown or unreadable property: " .. propertyName)
+	end
+	local decoded = ValueCodec.decodeForCurrent(current, value)
+	local writeOk, writeErr = pcall(function()
+		instance[propertyName] = decoded
+	end)
+	if not writeOk then
+		error("Failed to set " .. propertyName .. ": " .. tostring(writeErr))
+	end
+	return ValueCodec.encode(instance[propertyName])
+end
+
+return ValueCodec

package/plugin/src/Watcher.lua

@@ -1,85 +1,85 @@
---[[
-	Watcher: monitors LogService output and forwards to CLI
-]]
-
-local LogService = game:GetService("LogService")
-
-local Watcher = {}
-
-local outputBuffer = {}
-local MAX_BUFFER = 500
-local connection = nil
-local outputCallback = nil
-
-local function classifyLevel(messageType)
-	if messageType == Enum.MessageType.MessageOutput then
-		return "info"
-	elseif messageType == Enum.MessageType.MessageWarning then
-		return "warn"
-	elseif messageType == Enum.MessageType.MessageError then
-		return "error"
-	end
-	return "info"
-end
-
-function Watcher.start(callback)
-	outputCallback = callback
-
-	if connection then
-		connection:Disconnect()
-	end
-
-	connection = LogService.MessageOut:Connect(function(message, messageType)
-		-- Skip Dominus's own messages
-		if string.find(message, "[Dominus]", 1, true) then
-			return
-		end
-
-		local entry = {
-			message = message,
-			level = classifyLevel(messageType),
-			timestamp = os.clock(),
-		}
-
-		-- Buffer for get_output requests
-		table.insert(outputBuffer, entry)
-		if #outputBuffer > MAX_BUFFER then
-			table.remove(outputBuffer, 1)
-		end
-
-		-- Forward to CLI
-		if outputCallback then
-			outputCallback(entry)
-		end
-	end)
-end
-
-function Watcher.stop()
-	if connection then
-		connection:Disconnect()
-		connection = nil
-	end
-	outputCallback = nil
-end
-
-function Watcher.getRecentOutput(limit, levelFilter)
-	limit = limit or 50
-	local result = {}
-
-	for i = math.max(1, #outputBuffer - limit + 1), #outputBuffer do
-		local entry = outputBuffer[i]
-		if entry then
-			if not levelFilter or entry.level == levelFilter then
-				table.insert(result, entry)
-			end
-		end
-	end
-
-	return { entries = result }
-end
-
-function Watcher.clearBuffer()
-	outputBuffer = {}
-end
-
-return Watcher
+--[[
+	Watcher: monitors LogService output and forwards to CLI
+]]
+
+local LogService = game:GetService("LogService")
+
+local Watcher = {}
+
+local outputBuffer = {}
+local MAX_BUFFER = 500
+local connection = nil
+local outputCallback = nil
+
+local function classifyLevel(messageType)
+	if messageType == Enum.MessageType.MessageOutput then
+		return "info"
+	elseif messageType == Enum.MessageType.MessageWarning then
+		return "warn"
+	elseif messageType == Enum.MessageType.MessageError then
+		return "error"
+	end
+	return "info"
+end
+
+function Watcher.start(callback)
+	outputCallback = callback
+
+	if connection then
+		connection:Disconnect()
+	end
+
+	connection = LogService.MessageOut:Connect(function(message, messageType)
+		-- Skip every Dominus-prefixed message, including transport errors.
+		if string.find(message, "[Dominus", 1, true) then
+			return
+		end
+
+		local entry = {
+			message = message,
+			level = classifyLevel(messageType),
+			timestamp = os.clock(),
+		}
+
+		-- Buffer for get_output requests
+		table.insert(outputBuffer, entry)
+		if #outputBuffer > MAX_BUFFER then
+			table.remove(outputBuffer, 1)
+		end
+
+		-- Forward to CLI
+		if outputCallback then
+			outputCallback(entry)
+		end
+	end)
+end
+
+function Watcher.stop()
+	if connection then
+		connection:Disconnect()
+		connection = nil
+	end
+	outputCallback = nil
+end
+
+function Watcher.getRecentOutput(limit, levelFilter)
+	limit = limit or 50
+	local result = {}
+
+	for i = math.max(1, #outputBuffer - limit + 1), #outputBuffer do
+		local entry = outputBuffer[i]
+		if entry then
+			if not levelFilter or entry.level == levelFilter then
+				table.insert(result, entry)
+			end
+		end
+	end
+
+	return { entries = result }
+end
+
+function Watcher.clearBuffer()
+	outputBuffer = {}
+end
+
+return Watcher

package/plugin/src/WsClient.lua

@@ -1,81 +1,166 @@
---[[
-	WebSocket client wrapper using HttpService:CreateWebStreamClient
-	Uses the new WebSocket API available in Studio plugins (Oct 2025+)
-]]
-
-local HttpService = game:GetService("HttpService")
-
-local WsClient = {}
-WsClient.__index = WsClient
-
-local currentConnection = nil
-local messageCallback = nil
-local closeCallback = nil
-local errorCallback = nil
-
-function WsClient.connect(url, callbacks)
-	local ok, wsOrErr = pcall(function()
-		return HttpService:CreateWebStreamClient(Enum.WebStreamClientType.WebSocket, {
-			Url = url,
-		})
-	end)
-
-	if not ok then
-		warn("[Dominus WS] Failed to create WebSocket:", wsOrErr)
-		if callbacks.onError then
-			callbacks.onError(tostring(wsOrErr))
-		end
-		return false
-	end
-
-	local wsClient = wsOrErr
-	currentConnection = wsClient
-
-	-- Handle incoming messages
-	wsClient.MessageReceived:Connect(function(message)
-		if callbacks.onMessage then
-			callbacks.onMessage(message)
-		end
-	end)
-
-	-- Handle disconnection
-	wsClient.Closed:Connect(function()
-		currentConnection = nil
-		if callbacks.onClose then
-			callbacks.onClose()
-		end
-	end)
-
-	-- Notify connected
-	if callbacks.onOpen then
-		callbacks.onOpen()
-	end
-
-	return true
-end
-
-function WsClient.send(message)
-	if currentConnection then
-		local ok, err = pcall(function()
-			currentConnection:Send(message)
-		end)
-		if not ok then
-			warn("[Dominus WS] Send error:", err)
-		end
-	end
-end
-
-function WsClient.disconnect()
-	if currentConnection then
-		pcall(function()
-			currentConnection:Close()
-		end)
-		currentConnection = nil
-	end
-end
-
-function WsClient.isConnected()
-	return currentConnection ~= nil
-end
-
-return WsClient
+local HttpService = game:GetService("HttpService")
+
+local WsClient = {}
+
+local currentConnection = nil
+local currentSignals = {}
+local currentCancel = nil
+local generation = 0
+
+local function disconnectSignals()
+	for _, signal in currentSignals do
+		signal:Disconnect()
+	end
+	currentSignals = {}
+end
+
+local function closeCandidate(candidate)
+	pcall(function()
+		candidate:Close()
+	end)
+end
+
+function WsClient.connect(url, callbacks, timeoutSeconds)
+	WsClient.disconnect()
+	generation += 1
+	local attempt = generation
+	local completion = Instance.new("BindableEvent")
+	local completed = false
+	local opened = false
+
+	local ok, candidateOrError = pcall(function()
+		return HttpService:CreateWebStreamClient(Enum.WebStreamClientType.WebSocket, { Url = url })
+	end)
+	if not ok then
+		completion:Destroy()
+		if callbacks.onError then
+			callbacks.onError(0, tostring(candidateOrError))
+		end
+		return false, tostring(candidateOrError)
+	end
+	local candidate = candidateOrError
+
+	local function finish(success, reason)
+		if completed then
+			return
+		end
+		completed = true
+		completion:Fire(success, reason)
+	end
+	local function cancelPending()
+		finish(false, "Connection cancelled")
+	end
+	currentCancel = cancelPending
+
+	table.insert(
+		currentSignals,
+		candidate.Opened:Connect(function(statusCode, headers)
+			if attempt ~= generation then
+				return
+			end
+			opened = true
+			currentConnection = candidate
+			if callbacks.onOpen then
+				callbacks.onOpen(statusCode, headers)
+			end
+			finish(true)
+		end)
+	)
+
+	table.insert(
+		currentSignals,
+		candidate.MessageReceived:Connect(function(message)
+			if attempt == generation and opened and callbacks.onMessage then
+				callbacks.onMessage(message)
+			end
+		end)
+	)
+
+	table.insert(
+		currentSignals,
+		candidate.Error:Connect(function(statusCode, errorMessage)
+			if attempt ~= generation then
+				return
+			end
+			if callbacks.onError then
+				callbacks.onError(statusCode, errorMessage)
+			end
+			if not opened then
+				finish(false, errorMessage)
+			end
+		end)
+	)
+
+	table.insert(
+		currentSignals,
+		candidate.Closed:Connect(function()
+			if attempt ~= generation then
+				return
+			end
+			local wasOpened = opened
+			currentConnection = nil
+			opened = false
+			if callbacks.onClose then
+				callbacks.onClose()
+			end
+			if not wasOpened then
+				finish(false, "Connection closed before opening")
+			end
+		end)
+	)
+
+	task.delay(timeoutSeconds or 4, function()
+		if attempt == generation and not completed then
+			closeCandidate(candidate)
+			finish(false, "Connection timed out")
+		end
+	end)
+
+	local success, reason = completion.Event:Wait()
+	if currentCancel == cancelPending then
+		currentCancel = nil
+	end
+	completion:Destroy()
+	if not success then
+		closeCandidate(candidate)
+		if attempt == generation then
+			currentConnection = nil
+			disconnectSignals()
+		end
+	end
+	return success, reason
+end
+
+function WsClient.send(message)
+	if not currentConnection then
+		return false, "WebSocket is not open"
+	end
+	local ok, err = pcall(function()
+		currentConnection:Send(message)
+	end)
+	if not ok then
+		return false, tostring(err)
+	end
+	return true
+end
+
+function WsClient.disconnect()
+	generation += 1
+	local cancelPending = currentCancel
+	currentCancel = nil
+	if cancelPending then
+		cancelPending()
+	end
+	local connection = currentConnection
+	currentConnection = nil
+	disconnectSignals()
+	if connection then
+		closeCandidate(connection)
+	end
+end
+
+function WsClient.isConnected()
+	return currentConnection ~= nil
+end
+
+return WsClient