Add static color support, HAOS light entity, and real-time profile updates

- Add static_color capability to WLED and serial providers with native
  set_color() dispatch (WLED uses JSON API, serial uses idle client)
- Encapsulate device-specific logic in providers instead of device_type
  checks in ProcessorManager and API routes
- Add HAOS light entity for devices with brightness_control + static_color
  (Adalight/AmbiLED get light entity, WLED keeps number entity)
- Fix serial device brightness and turn-off: pass software_brightness
  through provider chain, clear device on color=null, re-send static
  color after brightness change
- Add global events WebSocket (events-ws.js) replacing per-tab WS,
  enabling real-time profile state updates on both dashboard and profiles tabs
- Fix profile activation: mark active when all targets already running,
  add asyncio.Lock to prevent concurrent evaluation races, skip process
  enumeration when no profile has conditions, trigger immediate evaluation
  on enable/create/update for instant target startup
- Add reliable server restart script (restart.ps1)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

custom_components/wled_screen_controller/light.py

@@ -0,0 +1,151 @@
+"""Light platform for LED Screen Controller (static color + brightness)."""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from homeassistant.components.light import (
+    ATTR_BRIGHTNESS,
+    ATTR_RGB_COLOR,
+    ColorMode,
+    LightEntity,
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN, DATA_COORDINATOR, TARGET_TYPE_KEY_COLORS
+from .coordinator import WLEDScreenControllerCoordinator
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up LED Screen Controller light entities."""
+    data = hass.data[DOMAIN][entry.entry_id]
+    coordinator: WLEDScreenControllerCoordinator = data[DATA_COORDINATOR]
+
+    entities = []
+    if coordinator.data and "targets" in coordinator.data:
+        devices = coordinator.data.get("devices") or {}
+
+        for target_id, target_data in coordinator.data["targets"].items():
+            info = target_data["info"]
+
+            # Only LED targets (skip KC targets)
+            if info.get("target_type") == TARGET_TYPE_KEY_COLORS:
+                continue
+
+            device_id = info.get("device_id", "")
+            if not device_id:
+                continue
+
+            device_data = devices.get(device_id)
+            if not device_data:
+                continue
+
+            capabilities = device_data.get("info", {}).get("capabilities") or []
+
+            # Light entity requires BOTH brightness_control AND static_color
+            if "brightness_control" in capabilities and "static_color" in capabilities:
+                entities.append(
+                    WLEDScreenControllerLight(
+                        coordinator, target_id, device_id, entry.entry_id,
+                    )
+                )
+
+    async_add_entities(entities)
+
+
+class WLEDScreenControllerLight(CoordinatorEntity, LightEntity):
+    """Light entity for an LED device with brightness and static color."""
+
+    _attr_has_entity_name = True
+    _attr_color_mode = ColorMode.RGB
+    _attr_supported_color_modes = {ColorMode.RGB}
+
+    def __init__(
+        self,
+        coordinator: WLEDScreenControllerCoordinator,
+        target_id: str,
+        device_id: str,
+        entry_id: str,
+    ) -> None:
+        """Initialize the light entity."""
+        super().__init__(coordinator)
+        self._target_id = target_id
+        self._device_id = device_id
+        self._entry_id = entry_id
+        self._attr_unique_id = f"{target_id}_light"
+        self._attr_translation_key = "light"
+
+    @property
+    def device_info(self) -> dict[str, Any]:
+        """Return device information."""
+        return {"identifiers": {(DOMAIN, self._target_id)}}
+
+    @property
+    def is_on(self) -> bool | None:
+        """Return True if static_color is set (not null)."""
+        device_data = self._get_device_data()
+        if not device_data:
+            return None
+        static_color = device_data.get("info", {}).get("static_color")
+        return static_color is not None
+
+    @property
+    def brightness(self) -> int | None:
+        """Return the brightness (0-255)."""
+        device_data = self._get_device_data()
+        if not device_data:
+            return None
+        return device_data.get("brightness")
+
+    @property
+    def rgb_color(self) -> tuple[int, int, int] | None:
+        """Return the RGB color tuple."""
+        device_data = self._get_device_data()
+        if not device_data:
+            return None
+        static_color = device_data.get("info", {}).get("static_color")
+        if static_color is not None and len(static_color) == 3:
+            return tuple(static_color)
+        return None
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        if not self.coordinator.data:
+            return False
+        targets = self.coordinator.data.get("targets", {})
+        devices = self.coordinator.data.get("devices", {})
+        return self._target_id in targets and self._device_id in devices
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn the light on (set static color and/or brightness)."""
+        if ATTR_BRIGHTNESS in kwargs:
+            await self.coordinator.set_brightness(
+                self._device_id, int(kwargs[ATTR_BRIGHTNESS])
+            )
+
+        if ATTR_RGB_COLOR in kwargs:
+            r, g, b = kwargs[ATTR_RGB_COLOR]
+            await self.coordinator.set_color(self._device_id, [r, g, b])
+        elif not self.is_on:
+            # Turning on without specifying color: default to white
+            await self.coordinator.set_color(self._device_id, [255, 255, 255])
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn the light off (clear static color)."""
+        await self.coordinator.set_color(self._device_id, None)
+
+    def _get_device_data(self) -> dict[str, Any] | None:
+        """Get device data from coordinator."""
+        if not self.coordinator.data:
+            return None
+        return self.coordinator.data.get("devices", {}).get(self._device_id)