fix: startup card showed Unraid System/Array red while running — yield before snapshot (v0.14.4)

Author: dervish666

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 All notable changes to UnraidMonitor will be documented in this file.
 
+## [0.14.4] - 2026-06-05
+
+### Fixed
+- **Startup card no longer shows Unraid System/Array as red when they're actually running** — a timing race in the startup notification. Each monitor sets `is_running` synchronously at the top of its `start()` coroutine, but `asyncio.create_task()` only *schedules* that coroutine. The Unraid system/array monitors are created *after* `await client.connect()` with nothing yielding before the card is built, so their tasks hadn't run yet and rendered 🔴 (they were running fine moments later — `/health` always showed green). Also fixed the latent case where, with Unraid not configured, there's no `connect()` await at all and *every* monitor could show red. `_start_background_monitors` now yields one event-loop turn (`await asyncio.sleep(0)`) before returning, so all monitors report their real state when the card snapshots them.
+
 ## [0.14.3] - 2026-06-05
 
 ### Changed

CLAUDE.md

@@ -92,7 +92,7 @@ src/utils/version_store.py - read/write data/announced_version.json for startup
 
 ## Project Overview
 
-Unraid Server Monitor Bot (v0.14.3) - A Docker-based Telegram bot for monitoring Unraid servers. Monitors Docker containers (events, logs, resources) and Unraid server health (CPU, memory, disks, array, UPS). Uses multi-provider LLM support (Anthropic, OpenAI, Ollama) for AI-powered diagnostics and natural language interaction. Sends alerts via Telegram with quick-action buttons.
+Unraid Server Monitor Bot (v0.14.4) - A Docker-based Telegram bot for monitoring Unraid servers. Monitors Docker containers (events, logs, resources) and Unraid server health (CPU, memory, disks, array, UPS). Uses multi-provider LLM support (Anthropic, OpenAI, Ollama) for AI-powered diagnostics and natural language interaction. Sends alerts via Telegram with quick-action buttons.
 
 **Version string lives in TWO places** — `pyproject.toml` (`version`) and `src/__init__.py` (`__version__`). Both must be bumped together on release; `tests/test_version.py` guards against drift. `BOT_VERSION` (in `src/bot/health_command.py`) resolves from installed package metadata when available, else falls back to `src.__version__` — the package is not installed in the Docker image, so the `__version__` fallback is what runs in production.
 

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unraid-monitor-bot"
-version = "0.14.3"
+version = "0.14.4"
 requires-python = ">=3.11"
 dependencies = [
     "docker>=7.0.0,<8.0.0",

src/__init__.py

@@ -1 +1 @@
-__version__ = "0.14.3"
+__version__ = "0.14.4"

src/startup.py

@@ -335,6 +335,15 @@ async def _start_background_monitors(
                 except Exception as send_err:
                     logger.error(f"Failed to send Unraid error to {cid}: {send_err}")
 
+    # Yield once so every task created above runs its synchronous prefix and
+    # flips is_running=True before the startup card snapshots monitor state.
+    # Each monitor's start() sets the flag before its first await, so a single
+    # event-loop turn is enough. Without this the Unraid system/array monitors
+    # (created after the connect() await, with nothing yielding afterwards) — and
+    # all monitors when Unraid is not configured (no connect() await at all) —
+    # would render red on the startup card despite running fine moments later.
+    await asyncio.sleep(0)
+
 
 async def start_monitoring(
     config: AppConfig,

tests/test_background_monitors_startup.py

@@ -0,0 +1,80 @@
+"""Regression test: monitors report is_running before the startup card snapshots them.
+
+The startup card is built immediately after `_start_background_monitors` returns,
+with no further yield. Each monitor sets `_running=True` synchronously at the top
+of its `start()` coroutine, but `create_task` only schedules that coroutine — it
+doesn't run it. So `_start_background_monitors` must yield once before returning,
+or freshly-created monitors render red on the card despite running fine.
+"""
+
+import asyncio
+from unittest.mock import MagicMock
+
+import src.startup as startup_mod
+from src.background import _BackgroundTasks
+
+
+class _FakeMonitor:
+    """Mimics a real monitor: flips _running before its first await, then loops."""
+
+    def __init__(self) -> None:
+        self._running = False
+
+    @property
+    def is_running(self) -> bool:
+        return self._running
+
+    async def start(self) -> None:
+        self._running = True
+        while self._running:
+            await asyncio.sleep(3600)
+
+
+class _FakeClient:
+    async def connect(self) -> None:
+        return None
+
+
+class _FakeUnraid:
+    def __init__(self, client, system_monitor, array_monitor) -> None:
+        self.client = client
+        self.system_monitor = system_monitor
+        self.array_monitor = array_monitor
+
+
+async def _cancel(bg: _BackgroundTasks) -> None:
+    for task in bg._tasks:
+        task.cancel()
+    await asyncio.gather(*bg._tasks, return_exceptions=True)
+
+
+async def test_unraid_monitors_running_when_card_is_built():
+    """The reported bug: Unraid system/array created after connect() showed red."""
+    bg = _BackgroundTasks()
+    bg.monitor = _FakeMonitor()
+    bg.log_watcher = _FakeMonitor()
+    uc = _FakeUnraid(_FakeClient(), _FakeMonitor(), _FakeMonitor())
+
+    await startup_mod._start_background_monitors(bg, None, uc, MagicMock(), MagicMock())
+    try:
+        assert bg.monitor.is_running
+        assert bg.log_watcher.is_running
+        assert uc.system_monitor.is_running
+        assert uc.array_monitor.is_running
+    finally:
+        await _cancel(bg)
+
+
+async def test_core_monitors_running_when_unraid_not_configured():
+    """The latent case: with no Unraid client there's no connect() await at all."""
+    bg = _BackgroundTasks()
+    bg.monitor = _FakeMonitor()
+    bg.log_watcher = _FakeMonitor()
+    uc = _FakeUnraid(None, None, None)
+
+    await startup_mod._start_background_monitors(bg, None, uc, MagicMock(), MagicMock())
+    try:
+        assert bg.monitor.is_running
+        assert bg.log_watcher.is_running
+    finally:
+        await _cancel(bg)