Rewrite HAOS integration: target-centric architecture with KC color sensors

- Rewrite integration to target-centric model: each picture target becomes
  a HA device under a server hub with switch, FPS, and status sensors
- Replace KC light entities with color sensors (hex state + RGB attributes)
  for better automation support via WebSocket real-time updates
- Add WebSocket manager for Key Colors color streaming
- Add KC per-stage timing metrics (calc_colors, broadcast) with rolling avg
- Fix KC timing fields missing from API by adding them to Pydantic schema
- Make start/stop processing idempotent to prevent intermittent 404 errors
- Add HAOS localization support (en, ru) using translation_key system
- Rename integration from "WLED Screen Controller" to "LED Screen Controller"
- Remove obsolete select.py (display select) and README.md

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

custom_components/wled_screen_controller/config_flow.py

@@ -1,4 +1,4 @@
-"""Config flow for WLED Screen Controller integration."""
+"""Config flow for LED Screen Controller integration."""
 from __future__ import annotations
 
 import logging
@@ -9,19 +9,18 @@ import aiohttp
 import voluptuous as vol
 
 from homeassistant import config_entries
-from homeassistant.const import CONF_NAME
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResult
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
-from .const import DOMAIN, CONF_SERVER_URL, DEFAULT_TIMEOUT
+from .const import DOMAIN, CONF_SERVER_URL, CONF_API_KEY, DEFAULT_TIMEOUT
 
 _LOGGER = logging.getLogger(__name__)
 
 STEP_USER_DATA_SCHEMA = vol.Schema(
     {
-        vol.Required(CONF_NAME, default="WLED Screen Controller"): str,
         vol.Required(CONF_SERVER_URL, default="http://localhost:8080"): str,
+        vol.Required(CONF_API_KEY): str,
     }
 )
 
@@ -30,48 +29,56 @@ def normalize_url(url: str) -> str:
     """Normalize URL to ensure port is an integer."""
     parsed = urlparse(url)
 
-    # If port is specified, ensure it's an integer
     if parsed.port is not None:
-        # Reconstruct URL with integer port
         netloc = parsed.hostname or "localhost"
-        port = int(parsed.port)  # Cast to int to avoid float
+        port = int(parsed.port)
         if port != (443 if parsed.scheme == "https" else 80):
             netloc = f"{netloc}:{port}"
-
         parsed = parsed._replace(netloc=netloc)
 
     return urlunparse(parsed)
 
 
-async def validate_server_connection(
-    hass: HomeAssistant, server_url: str
+async def validate_server(
+    hass: HomeAssistant, server_url: str, api_key: str
 ) -> dict[str, Any]:
-    """Validate the server URL by checking the health endpoint."""
+    """Validate server connectivity and API key."""
     session = async_get_clientsession(hass)
+    timeout = aiohttp.ClientTimeout(total=DEFAULT_TIMEOUT)
 
+    # Step 1: Check connectivity via health endpoint (no auth needed)
+    try:
+        async with session.get(f"{server_url}/health", timeout=timeout) as resp:
+            if resp.status != 200:
+                raise ConnectionError(f"Server returned status {resp.status}")
+            data = await resp.json()
+            version = data.get("version", "unknown")
+    except aiohttp.ClientError as err:
+        raise ConnectionError(f"Cannot connect to server: {err}") from err
+
+    # Step 2: Validate API key via authenticated endpoint
+    headers = {"Authorization": f"Bearer {api_key}"}
     try:
         async with session.get(
-            f"{server_url}/health",
-            timeout=aiohttp.ClientTimeout(total=DEFAULT_TIMEOUT),
-        ) as response:
-            if response.status == 200:
-                data = await response.json()
-                return {
-                    "version": data.get("version", "unknown"),
-                    "status": data.get("status", "unknown"),
-                }
-            raise ConnectionError(f"Server returned status {response.status}")
-
+            f"{server_url}/api/v1/picture-targets",
+            headers=headers,
+            timeout=timeout,
+        ) as resp:
+            if resp.status == 401:
+                raise PermissionError("Invalid API key")
+            resp.raise_for_status()
+    except PermissionError:
+        raise
     except aiohttp.ClientError as err:
-        raise ConnectionError(f"Cannot connect to server: {err}")
-    except Exception as err:
-        raise ConnectionError(f"Unexpected error: {err}")
+        raise ConnectionError(f"API request failed: {err}") from err
+
+    return {"version": version}
 
 
 class WLEDScreenControllerConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for WLED Screen Controller."""
+    """Handle a config flow for LED Screen Controller."""
 
-    VERSION = 1
+    VERSION = 2
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -81,26 +88,28 @@ class WLEDScreenControllerConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
 
         if user_input is not None:
             server_url = normalize_url(user_input[CONF_SERVER_URL].rstrip("/"))
+            api_key = user_input[CONF_API_KEY]
 
             try:
-                info = await validate_server_connection(self.hass, server_url)
+                await validate_server(self.hass, server_url, api_key)
 
-                # Set unique ID based on server URL
                 await self.async_set_unique_id(server_url)
                 self._abort_if_unique_id_configured()
 
                 return self.async_create_entry(
-                    title=user_input[CONF_NAME],
+                    title="LED Screen Controller",
                     data={
                         CONF_SERVER_URL: server_url,
-                        "version": info["version"],
+                        CONF_API_KEY: api_key,
                     },
                 )
 
             except ConnectionError as err:
                 _LOGGER.error("Connection error: %s", err)
                 errors["base"] = "cannot_connect"
-            except Exception as err:  # pylint: disable=broad-except
+            except PermissionError:
+                errors["base"] = "invalid_api_key"
+            except Exception as err:
                 _LOGGER.exception("Unexpected exception: %s", err)
                 errors["base"] = "unknown"