Add radio now-playing metadata polling and readonly props

server/app/items/types/radio_station/definition.py

@@ -29,6 +29,8 @@ DEFAULT_PARAMS: dict = {
     "mediaChannel": "stereo",
     "mediaEffect": "off",
     "mediaEffectValue": 50,
+    "stationName": "",
+    "nowPlaying": "",
     "facing": 0,
     "emitRange": 10,
 }
@@ -39,6 +41,8 @@ PARAM_KEYS: tuple[str, ...] = (
     "mediaChannel",
     "mediaEffect",
     "mediaEffectValue",
+    "stationName",
+    "nowPlaying",
     "facing",
     "emitRange",
 )
@@ -61,7 +65,10 @@ PROPERTY_METADATA: dict[str, dict[str, object]] = {
         "valueType": "number",
         "tooltip": "Amount for the selected effect.",
         "range": {"min": 0, "max": 100, "step": 0.1},
+        "visibleWhen": {"mediaEffect": "!off"},
     },
+    "stationName": {"valueType": "text", "tooltip": "Detected station name from stream metadata."},
+    "nowPlaying": {"valueType": "text", "tooltip": "Detected current track/title from stream metadata."},
     "facing": {
         "valueType": "number",
         "tooltip": "Facing direction in degrees used for directional emit.",

server/app/items/types/radio_station/validator.py

@@ -59,6 +59,9 @@ def validate_update(item: WorldItem, next_params: dict) -> dict:
     if not (0 <= effect_value <= 100):
         raise ValueError("mediaEffectValue must be between 0 and 100.")
     next_params["mediaEffectValue"] = round(effect_value, 1)
+    # Read-only metadata fields are server-managed and cannot be client-edited.
+    next_params["stationName"] = str(item.params.get("stationName", "")).strip()[:160]
+    next_params["nowPlaying"] = str(item.params.get("nowPlaying", "")).strip()[:200]
 
     try:
         facing = float(next_params.get("facing", item.params.get("facing", 0)))

server/app/server.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import argparse
 import asyncio
 from collections import deque
+from contextlib import suppress
 from datetime import datetime
 from getpass import getpass
 from importlib.metadata import PackageNotFoundError, version as package_version
@@ -18,6 +19,8 @@ import time
 import uuid
 from pathlib import Path
 from typing import Literal
+from urllib.error import URLError
+from urllib.request import Request, urlopen
 from zoneinfo import ZoneInfo
 
 from pydantic import ValidationError, TypeAdapter
@@ -96,6 +99,8 @@ AUTH_RATE_LIMIT_PER_IP = 20
 AUTH_RATE_LIMIT_PER_IDENTITY = 8
 AUTH_FAILURE_JITTER_MIN_MS = 0.02
 AUTH_FAILURE_JITTER_MAX_MS = 0.08
+RADIO_METADATA_POLL_INTERVAL_S = 10.0
+RADIO_METADATA_TIMEOUT_S = 6.0
 
 
 class SignalingServer:
@@ -153,6 +158,7 @@ class SignalingServer:
         self._auth_hash_semaphore = asyncio.Semaphore(AUTH_HASH_MAX_CONCURRENCY)
         self._auth_failures_by_ip: dict[str, deque[float]] = {}
         self._auth_failures_by_identity: dict[str, deque[float]] = {}
+        self._radio_metadata_task: asyncio.Task[None] | None = None
 
     @staticmethod
     def _resolve_server_version() -> str:
@@ -344,6 +350,95 @@ class SignalingServer:
             return item.useSound.strip()
         return None
 
+    def _get_item_emit_range(self, item: WorldItem) -> int:
+        """Return effective emit range for one item with sane bounds."""
+
+        value = item.params.get("emitRange")
+        if isinstance(value, (int, float)):
+            emit_range = int(value)
+            if emit_range > 0:
+                return emit_range
+        definition = get_item_definition(item.type)
+        if isinstance(definition.emit_range, int) and definition.emit_range > 0:
+            return definition.emit_range
+        return 15
+
+    def _has_listener_in_range(self, item: WorldItem) -> bool:
+        """Return whether any connected user is currently inside item hear range."""
+
+        emit_range = self._get_item_emit_range(item)
+        for client in self.clients.values():
+            if max(abs(client.x - item.x), abs(client.y - item.y)) <= emit_range:
+                return True
+        return False
+
+    @staticmethod
+    def _fetch_stream_metadata(stream_url: str) -> tuple[str, str]:
+        """Read ICY headers/metadata from a stream URL and return station/title."""
+
+        if not stream_url:
+            return "", ""
+        try:
+            request = Request(
+                stream_url,
+                headers={"Icy-MetaData": "1", "User-Agent": "ChatGrid"},
+            )
+            with urlopen(request, timeout=RADIO_METADATA_TIMEOUT_S) as response:
+                station = str(response.headers.get("icy-name") or response.headers.get("ice-name") or "").strip()
+                title = ""
+                metaint_raw = response.headers.get("icy-metaint")
+                if metaint_raw:
+                    metaint = int(metaint_raw)
+                    if metaint > 0:
+                        response.read(metaint)
+                        meta_len_byte = response.read(1)
+                        if meta_len_byte:
+                            meta_length = meta_len_byte[0] * 16
+                            if meta_length > 0:
+                                meta = response.read(meta_length).decode(errors="ignore")
+                                match = re.search(r"StreamTitle='(.*?)';", meta)
+                                if match:
+                                    title = match.group(1).strip()
+                return station[:160], title[:200]
+        except (OSError, URLError, ValueError):
+            return "", ""
+
+    async def _refresh_radio_metadata_once(self) -> None:
+        """Refresh station/title metadata for active radios near at least one listener."""
+
+        radios = [
+            item
+            for item in self.items.values()
+            if item.type == "radio_station"
+            and bool(item.params.get("enabled", True))
+            and isinstance(item.params.get("streamUrl"), str)
+            and str(item.params.get("streamUrl", "")).strip()
+            and self._has_listener_in_range(item)
+        ]
+        for item in radios:
+            stream_url = str(item.params.get("streamUrl", "")).strip()
+            station_name, now_playing = await asyncio.to_thread(self._fetch_stream_metadata, stream_url)
+            current_station = str(item.params.get("stationName", "")).strip()
+            current_playing = str(item.params.get("nowPlaying", "")).strip()
+            if station_name == current_station and now_playing == current_playing:
+                continue
+            item.params["stationName"] = station_name
+            item.params["nowPlaying"] = now_playing
+            item.updatedAt = self.item_service.now_ms()
+            item.version += 1
+            self._request_state_save()
+            await self._broadcast_item(item)
+
+    async def _run_radio_metadata_loop(self) -> None:
+        """Background polling loop that refreshes radio now-playing metadata."""
+
+        try:
+            while True:
+                await self._refresh_radio_metadata_once()
+                await asyncio.sleep(RADIO_METADATA_POLL_INTERVAL_S)
+        except asyncio.CancelledError:
+            return
+
     def _get_item_sound_source_position(self, item: WorldItem) -> tuple[int, int]:
         """Resolve source position for item-emitted one-shot sounds."""
 
@@ -836,6 +931,7 @@ class SignalingServer:
 
         protocol = "wss" if self._ssl_context else "ws"
         LOGGER.info("starting signaling server on %s://%s:%d", protocol, self.host, self.port)
+        self._radio_metadata_task = asyncio.create_task(self._run_radio_metadata_loop())
         try:
             async with serve(
                 self._handle_client,
@@ -846,6 +942,11 @@ class SignalingServer:
             ):
                 await asyncio.Future()
         finally:
+            if self._radio_metadata_task is not None:
+                self._radio_metadata_task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await self._radio_metadata_task
+                self._radio_metadata_task = None
             self._flush_state_save()
             self.auth_service.close()