fix(presence): update progress dialog + tray reactive while dashboard open

Two UX fixes Dennis pointed out:

1) The auto-update flow had almost no feedback. A single
   "Downloading..." balloon, then silence, then UAC prompted out of
   nowhere when the relaunch happened. Easy to read as "nothing
   happened, the update is broken".

   Now we show a modal customtkinter window with:
     - a real progress bar (Content-Length driven)
     - MB-of-MB counter ("7.4 MB of 19.2 MB")
     - current step ("Downloading...", "Restarting...")
     - an explicit "Approve the Windows UAC prompt when it
       appears" hint before the relaunch

   The download itself now exposes a progress_cb in updater.py so
   the dialog can drive its bar without us guessing.

2) The tray menu stopped responding while the dashboard window was
   open. Both pystray and WebView2 want exclusive ownership of the
   main thread's message loop on Windows, so as long as the
   webview was running pystray was effectively paused — right-click
   on the tray icon did nothing.

   The dashboard now runs on a worker thread. pystray keeps the
   main thread, the webview gets its own. Clicking "Open BusyLight"
   a second time with the window already open is a no-op (we track
   `_webview_open`).

Bumps presence to 0.3.14. Firmware unchanged from 0.3.12.

Author: Dennis Sepede

CHANGELOG.md

@@ -7,7 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.3.13] - 2026-05-25
+## [0.3.14] - 2026-05-25
+
+### Fixed
+- **Tray menu stopped responding while the dashboard was open**: WebView2 and pystray both want the main thread for their message loop on Windows, so opening the dashboard blocked tray right-clicks until the WebView window closed. The dashboard now runs on a worker thread, leaving the tray reactive. Clicking "Open BusyLight" a second time with the window already open is a no-op (Windows brings the existing one to front).
+- **Update flow had almost no feedback**: a single "Downloading…" balloon, then silence, then UAC prompted out of nowhere — easy to read as "nothing happened". Installing now shows a modal progress dialog with a real progress bar, MB-of-MB counter, current step ("Downloading…", "Restarting…"), and an explicit "Approve the Windows UAC prompt when it appears" hint before the relaunch.
+
+
 
 ### Fixed
 - **IN_CALL reverted after ~2s when set manually**: the presence loop unconditionally treated IN_CALL as a mic-driven state. When a user clicked IN_CALL in the web UI and the mic was idle, the next tick pushed `last_manual_state` over the top, reverting the LED. Now the loop distinguishes between "presence-pushed IN_CALL (mic was busy)" and "user-set IN_CALL (anywhere else)" via `last_pushed_state` tracking and only reverts the first kind.

presence_helper/src/busylight_presence/__init__.py

@@ -6,4 +6,4 @@
 previous manual state when the call ends.
 """
 
-__version__ = "0.3.13"
+__version__ = "0.3.14"

presence_helper/src/busylight_presence/tray.py

@@ -31,6 +31,7 @@
 from . import __version__
 from .icons import status_icon
 from .settings_window import SettingsWindow
+from .update_progress_window import UpdateProgressWindow
 from .webui_bridge import WebUiBridge
 from .webview_window import open_device_webui
 from .updater import (
@@ -75,6 +76,8 @@ def __init__(
         self._update_lock = threading.Lock()
         self._pending_firmware_update: Optional[LatestRelease] = None
         self._firmware_update_lock = threading.Lock()
+        self._webview_thread: Optional[threading.Thread] = None
+        self._webview_open = False
 
     # ------------------------------------------------------------------
     # Lifecycle
@@ -207,11 +210,35 @@ def _open_dashboard(self, _icon, _item):
         # The "dashboard" is now the firmware's own web UI, served by
         # the local bridge over USB serial. Same exact look and feel
         # as the device's HTTP UI, but doesn't require Wi-Fi.
+        #
+        # Run the WebView on a worker thread so it doesn't block
+        # pystray's main-thread message loop — otherwise right-click
+        # on the tray icon stops responding while the dashboard is
+        # open (both WebView2 and pystray want exclusive ownership
+        # of the main thread on Windows).
+        if self._webview_open:
+            # Already showing; let the OS bring it to front rather
+            # than spawning a second window.
+            return
         try:
             url = self._bridge.start()
-            open_device_webui(url)
         except Exception as e:  # noqa: BLE001
-            log.exception("web UI failed: %s", e)
+            log.exception("bridge start failed: %s", e)
+            return
+
+        def runner() -> None:
+            self._webview_open = True
+            try:
+                open_device_webui(url)
+            except Exception as e:  # noqa: BLE001
+                log.exception("webview failed: %s", e)
+            finally:
+                self._webview_open = False
+
+        self._webview_thread = threading.Thread(
+            target=runner, daemon=True, name="busylight-webview",
+        )
+        self._webview_thread.start()
 
     def _open_settings_from_dashboard(self) -> None:
         # Dashboard closes itself before calling us, so we can just
@@ -378,17 +405,47 @@ def _on_update_click(self, _icon, _item) -> None:
         ).start()
 
     def _install_update(self, release: LatestRelease) -> None:
+        # Modal progress dialog so the user sees what's going on
+        # instead of just a brief balloon and a silent UAC prompt.
+        progress = UpdateProgressWindow(
+            title=f"Installing BusyLight {release.tag}"
+        )
+        progress.start()
+        progress.set_message(
+            f"Downloading {release.tag} from GitHub…"
+        )
         try:
-            self._notify(
-                "Downloading BusyLight update",
-                f"Fetching {release.tag} from GitHub…",
-            )
-            new_exe = download_exe(release)
+            def cb(written: int, total: int) -> None:
+                if total > 0:
+                    progress.set_progress(written / total)
+                    mb_done = written / (1024 * 1024)
+                    mb_tot = total / (1024 * 1024)
+                    progress.set_message(
+                        f"Downloading {release.tag} from GitHub…"
+                        f"\n{mb_done:.1f} MB of {mb_tot:.1f} MB"
+                    )
+                else:
+                    progress.set_indeterminate()
+            new_exe = download_exe(release, progress_cb=cb)
         except Exception as e:  # noqa: BLE001
             log.exception("update download failed: %s", e)
+            progress.set_message(f"Download failed: {e}")
+            progress.set_progress(0.0)
+            import time
+            time.sleep(3.0)
+            progress.close()
             self._notify("Update failed", str(e))
             return
+
         try:
+            progress.set_progress(1.0)
+            progress.set_message(
+                "Download complete. Restarting BusyLight…\n"
+                "Approve the Windows UAC prompt when it appears."
+            )
+            import time
+            time.sleep(1.5)
+            progress.close()
             self._stop_event.set()  # let worker threads wind down
             install_and_restart(new_exe)
         except SystemExit:

presence_helper/src/busylight_presence/update_progress_window.py

@@ -0,0 +1,162 @@
+"""Progress dialog for the in-app updater.
+
+A small customtkinter window with a header, a description label that
+updates as the install progresses ("Downloading… 7.4 MB / 19 MB",
+"Installing…", "Restarting…"), and an indeterminate-or-determinate
+progress bar.
+
+Lives on its own thread so it doesn't fight pystray's main-thread
+message loop. The caller updates it via `set_progress()` /
+`set_message()` from any thread; we marshall the calls onto the Tk
+thread via `after()`.
+"""
+
+from __future__ import annotations
+
+import logging
+import queue
+import threading
+import tkinter as tk
+from typing import Optional
+
+import customtkinter as ctk
+
+from .bead import render_bead
+
+log = logging.getLogger(__name__)
+
+
+class UpdateProgressWindow:
+    """Thread-safe progress dialog. Construct, call `start()` to show,
+    then `set_progress` / `set_message` from anywhere. Call `close()`
+    when done."""
+
+    def __init__(self, title: str = "BusyLight update") -> None:
+        self._title = title
+        self._thread: Optional[threading.Thread] = None
+        self._root: Optional[ctk.CTk] = None
+        self._cmd_q: queue.Queue[tuple[str, object]] = queue.Queue()
+        self._ready_event = threading.Event()
+
+    def start(self) -> None:
+        if self._thread is not None:
+            return
+        self._thread = threading.Thread(
+            target=self._run, daemon=True, name="update-progress",
+        )
+        self._thread.start()
+        # Wait until Tk root + widgets exist so the first set_*
+        # actually has somewhere to land.
+        self._ready_event.wait(timeout=3.0)
+
+    def set_message(self, text: str) -> None:
+        self._cmd_q.put(("message", text))
+
+    def set_progress(self, fraction: float) -> None:
+        """`fraction` is 0.0 to 1.0. Pass None for indeterminate."""
+        self._cmd_q.put(("progress", max(0.0, min(1.0, fraction))))
+
+    def set_indeterminate(self) -> None:
+        self._cmd_q.put(("indeterminate", None))
+
+    def close(self) -> None:
+        self._cmd_q.put(("close", None))
+        if self._thread is not None:
+            self._thread.join(timeout=2.0)
+            self._thread = None
+
+    # ------------------------------------------------------------------
+    # Tk thread
+    # ------------------------------------------------------------------
+    def _run(self) -> None:
+        try:
+            ctk.set_appearance_mode("light")
+            ctk.set_default_color_theme("blue")
+            root = ctk.CTk()
+            self._root = root
+            root.title(self._title)
+            root.geometry("440x220")
+            root.resizable(False, False)
+            root.attributes("-topmost", True)
+            root.protocol("WM_DELETE_WINDOW", lambda: None)  # disable X
+
+            outer = ctk.CTkFrame(root, fg_color="transparent")
+            outer.pack(fill="both", expand=True, padx=22, pady=18)
+
+            head = ctk.CTkFrame(outer, fg_color="transparent")
+            head.pack(fill="x")
+            bead_img = render_bead("available", 38)
+            ctk_bead = ctk.CTkImage(light_image=bead_img, size=(38, 38))
+            bead_lbl = ctk.CTkLabel(head, text="", image=ctk_bead)
+            bead_lbl.image = ctk_bead
+            bead_lbl.pack(side="left")
+            ctk.CTkLabel(
+                head,
+                text=self._title,
+                font=ctk.CTkFont("Segoe UI Semibold", 15),
+                anchor="w",
+            ).pack(side="left", padx=(10, 0))
+
+            msg_var = tk.StringVar(value="Starting…")
+            ctk.CTkLabel(
+                outer,
+                textvariable=msg_var,
+                font=ctk.CTkFont("Segoe UI", 11),
+                text_color="#3a3d42",
+                wraplength=400,
+                anchor="w",
+                justify="left",
+            ).pack(fill="x", pady=(12, 8))
+
+            bar = ctk.CTkProgressBar(outer, height=14)
+            bar.pack(fill="x", pady=(0, 8))
+            bar.set(0.0)
+
+            pct_var = tk.StringVar(value="")
+            ctk.CTkLabel(
+                outer,
+                textvariable=pct_var,
+                font=ctk.CTkFont("JetBrains Mono", 10),
+                text_color="#5d6066",
+                anchor="e",
+            ).pack(fill="x")
+
+            indeterminate_running = {"on": False}
+
+            def pump() -> None:
+                # Drain any pending commands from the worker thread.
+                while True:
+                    try:
+                        cmd, payload = self._cmd_q.get_nowait()
+                    except queue.Empty:
+                        break
+                    if cmd == "message":
+                        msg_var.set(str(payload))
+                    elif cmd == "progress":
+                        if indeterminate_running["on"]:
+                            bar.stop()
+                            bar.configure(mode="determinate")
+                            indeterminate_running["on"] = False
+                        f = float(payload)  # type: ignore[arg-type]
+                        bar.set(f)
+                        pct_var.set(f"{int(f * 100)} %")
+                    elif cmd == "indeterminate":
+                        if not indeterminate_running["on"]:
+                            bar.configure(mode="indeterminate")
+                            bar.start()
+                            indeterminate_running["on"] = True
+                        pct_var.set("")
+                    elif cmd == "close":
+                        try:
+                            root.destroy()
+                        except tk.TclError:
+                            pass
+                        return
+                root.after(50, pump)
+
+            self._ready_event.set()
+            root.after(50, pump)
+            root.mainloop()
+        except Exception as e:  # noqa: BLE001
+            log.exception("update progress window crashed: %s", e)
+            self._ready_event.set()

presence_helper/src/busylight_presence/updater.py

@@ -150,9 +150,16 @@ def _parse_version(s: str) -> tuple[int, int, int]:
 # Download + self-replace
 # ---------------------------------------------------------------------------
 
-def download_exe(release: LatestRelease, dest_dir: Optional[Path] = None) -> Path:
-    """Download the BusyLightPresence.exe asset to a temp location and
-    return the path. Raises on failure so the tray can show an error.
+def download_exe(
+    release: LatestRelease,
+    dest_dir: Optional[Path] = None,
+    progress_cb=None,
+) -> Path:
+    """Download the BusyLightPresence.exe asset to a temp location.
+
+    `progress_cb(written, total)` is called as bytes arrive, so the
+    caller can drive a progress bar. Total is taken from the
+    Content-Length header (or the asset metadata as a fallback).
     """
     if release.exe_asset is None:
         raise RuntimeError("release has no BusyLightPresence.exe asset")
@@ -166,12 +173,26 @@ def download_exe(release: LatestRelease, dest_dir: Optional[Path] = None) -> Pat
         headers={"User-Agent": f"busylight-presence/{_self_version()}"},
     )
     with urllib.request.urlopen(req, timeout=120) as resp:
+        # Prefer the server-reported Content-Length; fall back to the
+        # asset metadata GitHub provides if it's missing.
+        total = (
+            int(resp.headers.get("Content-Length") or 0)
+            or release.exe_asset.size
+            or 0
+        )
+        written = 0
         with open(target, "wb") as f:
             while True:
                 chunk = resp.read(64 * 1024)
                 if not chunk:
                     break
                 f.write(chunk)
+                written += len(chunk)
+                if progress_cb:
+                    try:
+                        progress_cb(written, total)
+                    except Exception:  # noqa: BLE001
+                        pass
     log.info("downloaded %s (%d bytes)", target, target.stat().st_size)
     return target