trcc-linux 9.8.8__tar.gz → 9.9.0__tar.gz

{trcc_linux-9.8.8 → trcc_linux-9.9.0}/.gitignore

@@ -101,8 +101,8 @@ src/trcc/data/ui_*.json
 /*.sh
 !install.sh
 
-# Dev tooling
-tools/
+# Dev tooling (root-level scratch only — dev/tools/ is tracked source)
+/tools/
 
 # Large binary docs
 doc/*.pdf

{trcc_linux-9.8.8 → trcc_linux-9.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.8.8
+Version: 9.9.0
 Summary: Linux implementation of Thermalright LCD Control Center
 Project-URL: Homepage, https://github.com/Lexonight1/thermalright-trcc-linux
 Project-URL: Documentation, https://github.com/Lexonight1/thermalright-trcc-linux#readme
@@ -152,7 +152,7 @@ Pre-built packages are available for every major distro. No pip, no venv, no PEP
 | macOS 11+ | [macOS](doc/GUIDE_INSTALL.md#macos-experimental) |
 | FreeBSD | [FreeBSD](doc/GUIDE_INSTALL.md#freebsd-experimental) |
 
-Each guide has a one-liner copy-paste command and step-by-step instructions. After installing, unplug and replug the USB cable, then run `trcc gui`.
+Each guide has a one-liner copy-paste command and step-by-step instructions. After installing, run `trcc gui` — TRCC picks the cooler up automatically. (Not detected? Restart your computer and try again.)
 
 ### Verify your download
 
@@ -179,7 +179,7 @@ pipx install trcc-linux
 trcc system setup        # interactive wizard — udev rules, desktop entry
 ```
 
-Then **unplug and replug the USB cable** and run `trcc gui`.
+Then **restart your computer** and run `trcc gui`.
 
 > `pipx` not installed? `sudo apt install pipx` (Debian/Ubuntu), `sudo dnf install pipx` (Fedora), `sudo pacman -S python-pipx` (Arch). See the **[Install Guide](doc/GUIDE_INSTALL.md)** for your distro.
 

{trcc_linux-9.8.8 → trcc_linux-9.9.0}/README.md

@@ -79,7 +79,7 @@ Pre-built packages are available for every major distro. No pip, no venv, no PEP
 | macOS 11+ | [macOS](doc/GUIDE_INSTALL.md#macos-experimental) |
 | FreeBSD | [FreeBSD](doc/GUIDE_INSTALL.md#freebsd-experimental) |
 
-Each guide has a one-liner copy-paste command and step-by-step instructions. After installing, unplug and replug the USB cable, then run `trcc gui`.
+Each guide has a one-liner copy-paste command and step-by-step instructions. After installing, run `trcc gui` — TRCC picks the cooler up automatically. (Not detected? Restart your computer and try again.)
 
 ### Verify your download
 
@@ -106,7 +106,7 @@ pipx install trcc-linux
 trcc system setup        # interactive wizard — udev rules, desktop entry
 ```
 
-Then **unplug and replug the USB cable** and run `trcc gui`.
+Then **restart your computer** and run `trcc gui`.
 
 > `pipx` not installed? `sudo apt install pipx` (Debian/Ubuntu), `sudo dnf install pipx` (Fedora), `sudo pacman -S python-pipx` (Arch). See the **[Install Guide](doc/GUIDE_INSTALL.md)** for your distro.
 

{trcc_linux-9.8.8 → trcc_linux-9.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "9.8.8"
+version = "9.9.0"
 description = "Linux implementation of Thermalright LCD Control Center"
 readme = "README.md"
 license = "GPL-3.0-or-later"

{trcc_linux-9.8.8 → trcc_linux-9.9.0}/src/trcc/__version__.py

@@ -1,4 +1,4 @@
 """TRCC Linux version information. History in doc/CHANGELOG.md."""
 
-__version__ = "9.8.8"
+__version__ = "9.9.0"
 __version_info__ = tuple(int(x) for x in __version__.split("."))

{trcc_linux-9.8.8 → trcc_linux-9.9.0}/src/trcc/adapters/diagnostics/debug_report.py

@@ -35,6 +35,7 @@ from ...core.registry import find_product
 from ..device import DeviceFactory
 from ..infra.logging import tail_log
 from .health import HealthReport, run_health_checks
+from .install import InstallInfo, collect_install_info
 
 log = logging.getLogger(__name__)
 
@@ -50,6 +51,7 @@ class DebugReport:
     timestamp: str
     platform_info: dict[str, str]
     paths: dict[str, str]
+    install: InstallInfo | None = None
     devices: list[dict[str, str]] = field(default_factory=list)
     devices_error: str = ""
     sensors: list[dict[str, str]] = field(default_factory=list)
@@ -66,6 +68,9 @@ class DebugReport:
         log.info("render_text: called")
         sections: list[str] = []
         sections.append(_header(self.timestamp))
+        # Install first: every other section is worthless if this is not the
+        # trcc the reporter thinks they are running.
+        sections.append(_render_install(self.install))
         sections.append(_render_kv("Platform", self.platform_info))
         sections.append(_render_kv("Paths", self.paths))
         sections.append(_render_devices(self.devices, self.devices_error))
@@ -96,6 +101,15 @@ def build_debug_report(
              log_tail_lines)
     timestamp = datetime.now(tz=timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
 
+    # Best-effort like every other collector: a report from a broken install is
+    # exactly when this matters, so it must degrade to "(unavailable)" rather
+    # than abort the report that would have explained the breakage.
+    try:
+        install = collect_install_info()
+    except Exception as e:
+        log.exception("build_debug_report: install info failed: %s", e)
+        install = None
+
     info = _collect_platform_info(platform)
     path_table = _collect_paths(platform)
     devices, devices_err = _collect_devices(platform)
@@ -113,6 +127,7 @@ def build_debug_report(
         timestamp=timestamp,
         platform_info=info,
         paths=path_table,
+        install=install,
         devices=devices,
         devices_error=devices_err,
         sensors=sensors,
@@ -141,11 +156,10 @@ def write_debug_report(report: DebugReport, output_path: Path) -> Path:
 
 def _collect_platform_info(platform: Platform) -> dict[str, str]:
     log.debug("_collect_platform_info: called")
+    # Version / path / installer live in the Install section, which owns the
+    # "which trcc is this?" question in one place — see _render_install.
     return {
         "distro": platform.distro_name(),
-        "install_method": platform.install_method(),
-        "python": f"{sys.version_info.major}.{sys.version_info.minor}."
-                  f"{sys.version_info.micro}",
         "python_impl": py_platform.python_implementation(),
         "machine": py_platform.machine(),
         "system": py_platform.system(),
@@ -375,6 +389,42 @@ def _render_kv(title: str, table: dict[str, str]) -> str:
     return f"## {title}\n{body}" if body else f"## {title}\n  (empty)"
 
 
+def _render_install(info: InstallInfo | None) -> str:
+    """Which trcc is running — and loud warnings when it isn't the expected one.
+
+    The warnings are spelled out in full because the reporter reading them is
+    the person who has to act, and neither of the two failures is guessable
+    from the outside: a stale cache and a duplicate binary both present as
+    "I upgraded and nothing changed".
+    """
+    if info is None:
+        return "## Install\n  (unavailable)"
+    rows = {
+        "version": info.version,
+        "installed_by": info.installer,
+        "module_path": str(info.module_path or "unknown"),
+        "interpreter": info.interpreter,
+        "python": info.python,
+    }
+    lines = [f"  {k:18}  {v}" for k, v in rows.items()]
+    for exe in info.executables:
+        lines.append(f"  {'on PATH':18}  {exe.path}  ->  {exe.interpreter}")
+    if info.bytecode_stale:
+        lines.append("")
+        lines.append(f"  !! STALE BYTECODE — running {info.version} but the source "
+                     f"says {info.source_version}.")
+        lines.append("  !! Python is serving a cached .pyc that no longer matches "
+                     "the code on disk.")
+        lines.append("  !! Fix: delete __pycache__ dirs, or reinstall.")
+    if info.duplicates:
+        lines.append("")
+        lines.append(f"  !! {len(info.executables)} trcc found on PATH — an upgrade "
+                     "may land on one")
+        lines.append("  !! while a different one keeps running. The first listed "
+                     "above is what runs.")
+    return "## Install\n" + "\n".join(lines)
+
+
 def _render_devices(rows: list[dict[str, str]], error: str) -> str:
     if error:
         return f"## Devices\n  Scan failed: {error}"

{trcc_linux-9.8.8 → trcc_linux-9.9.0}/src/trcc/adapters/diagnostics/health.py

@@ -11,9 +11,9 @@ Severity ladder:
   * ``WARN`` — works on this machine but reporter should know.
   * ``FAIL`` — feature won't work until this is fixed.
 
-Adding a check: define a function returning ``HealthCheckResult`` and
-add it to ``ALL_CHECKS``.  The doctor + report bundlers iterate that
-tuple, so registration = inclusion.
+Adding a check: define a function returning ``HealthCheckResult`` and add
+it to the list in ``run_health_checks``.  The doctor + report bundlers both
+go through that function, so registration = inclusion.
 """
 from __future__ import annotations
 
@@ -26,6 +26,7 @@ from pathlib import Path
 from ...core.diagnostics import HealthCheckResult, HealthReport, Severity
 from ...core.ports import Paths, Platform
 from ..sensors.nvml import NVML_RELOAD_HINT, nvml_init_state
+from .install import collect_install_info
 
 log = logging.getLogger(__name__)
 
@@ -48,6 +49,57 @@ __all__ = [
 # =========================================================================
 
 
+def check_install_integrity() -> HealthCheckResult:
+    """Is the running trcc the one the user thinks they installed?
+
+    Two failures both present to the user as "I upgraded and nothing
+    changed", and neither is visible from the outside:
+
+    * stale bytecode — Python serves a cached .pyc whose recorded mtime+size
+      still match a since-edited source (FAIL: every other diagnostic, and
+      the version itself, is then untrustworthy);
+    * duplicate binaries on PATH — the upgrade landed on one, the other keeps
+      running (WARN: legitimate for venv/pipx users, so not fatal).
+    """
+    log.info("check_install_integrity: called")
+    try:
+        info = collect_install_info()
+    except Exception as e:
+        log.exception("check_install_integrity: collection failed: %s", e)
+        return HealthCheckResult(
+            name="install-integrity", severity="WARN",
+            message=f"Could not inspect the install: {e}",
+        )
+    if info.bytecode_stale:
+        return HealthCheckResult(
+            name="install-integrity", severity="FAIL",
+            message=(
+                f"Stale bytecode — running {info.version} but "
+                f"{info.module_path} says {info.source_version}"
+            ),
+            fix_hint=(
+                "Python is serving a cached .pyc that no longer matches the "
+                "source. Delete the __pycache__ directories under "
+                f"{info.module_path}, or reinstall trcc-linux."
+            ),
+        )
+    if info.duplicates:
+        found = ", ".join(str(e.path) for e in info.executables)
+        return HealthCheckResult(
+            name="install-integrity", severity="WARN",
+            message=f"{len(info.executables)} trcc on PATH: {found}",
+            fix_hint=(
+                f"'{info.executables[0].path}' is the one that runs. An "
+                "upgrade applied to the other will appear to do nothing. "
+                "Remove whichever you don't want."
+            ),
+        )
+    return HealthCheckResult(
+        name="install-integrity", severity="OK",
+        message=f"{info.version} via {info.installer} ({info.interpreter})",
+    )
+
+
 def check_python_version(platform: Platform) -> HealthCheckResult:
     """Python ≥ 3.11 is the project minimum (match-statement + slots)."""
     log.info("check_python_version: called")
@@ -301,6 +353,9 @@ def run_health_checks(platform: Platform) -> HealthReport:
     log.info("run_health_checks: starting")
     paths = platform.paths()
     checks: list[HealthCheckResult] = [
+        # First: if this isn't the trcc they think it is, nothing below means
+        # anything.
+        check_install_integrity(),
         check_python_version(platform),
         check_log_writable(paths),
         check_config_writable(paths),

trcc_linux-9.9.0/src/trcc/adapters/diagnostics/install.py

@@ -0,0 +1,206 @@
+"""Install integrity — which trcc is actually running, and is it the one
+the user thinks?
+
+Every field here exists because a real issue was unanswerable without it:
+
+* **version / source_version / bytecode_stale** — a stale ``.pyc`` served
+  ``9.9.9`` from a file that read ``9.8.8``.  Python's timestamp check
+  compares source mtime+size against the values baked into the ``.pyc``;
+  a rewrite that preserves both (same-length version strings do) leaves
+  the cache authoritative and wrong, silently, forever.
+* **executables / duplicates** — ``shutil.which`` returns the FIRST match.
+  Two ``trcc`` on PATH pointing at two interpreters is the commonest cause
+  of "I upgraded and nothing changed" (#175: six weeks on v9.7.0 while
+  installing 9.8.3 repeatedly; #220: three releases behind on "latest").
+* **installer** — the ``INSTALLER`` file pip writes is the only honest
+  answer.  The old per-OS heuristics guessed from PATH and were wrong for
+  rpm / deb / venv / source checkouts alike.
+
+Deliberately dependency-free (stdlib only) and side-effect-free: it is the
+first thing a broken install runs, so it must not need a working App.
+"""
+from __future__ import annotations
+
+import logging
+import os
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+log = logging.getLogger(__name__)
+
+# `__version__ = "9.8.8"` — matched against the SOURCE text, never exec'd.
+_VERSION_RE = re.compile(r"""^__version__\s*=\s*['"]([^'"]+)['"]""", re.MULTILINE)
+
+_UNKNOWN = "unknown"
+
+
+@dataclass(frozen=True, slots=True)
+class Executable:
+    """One ``trcc`` found on PATH, and the interpreter it runs under."""
+
+    path: Path
+    interpreter: str = _UNKNOWN
+
+
+@dataclass(frozen=True, slots=True)
+class InstallInfo:
+    """Everything needed to answer "which trcc is this?"."""
+
+    version: str
+    source_version: str
+    module_path: Path | None
+    interpreter: str
+    python: str
+    installer: str
+    executables: tuple[Executable, ...] = ()
+
+    @property
+    def bytecode_stale(self) -> bool:
+        """Imported version disagrees with its own source file.
+
+        Means Python is serving a cached ``.pyc`` that no longer matches
+        the code on disk — so every claim about "what version is this" is
+        untrustworthy until the cache is cleared.
+        """
+        return (
+            self.source_version != _UNKNOWN
+            and self.version != self.source_version
+        )
+
+    @property
+    def duplicates(self) -> bool:
+        """More than one ``trcc`` on PATH — an upgrade can land on either."""
+        return len(self.executables) > 1
+
+    @property
+    def healthy(self) -> bool:
+        return not self.bytecode_stale and not self.duplicates
+
+
+def _read_source_version(module_path: Path | None) -> str:
+    """Parse ``__version__`` out of the package's own ``__version__.py``.
+
+    Text-parsed rather than imported: importing would hit the very bytecode
+    cache we are trying to check, and would always agree with itself.
+    """
+    if module_path is None:
+        return _UNKNOWN
+    source = module_path / "__version__.py"
+    try:
+        text = source.read_text(encoding="utf-8")
+    except OSError as e:
+        log.debug("_read_source_version: cannot read %s: %s", source, e)
+        return _UNKNOWN
+    m = _VERSION_RE.search(text)
+    if m is None:
+        log.warning("_read_source_version: no __version__ assignment in %s", source)
+        return _UNKNOWN
+    log.debug("_read_source_version: %s → %s", source, m.group(1))
+    return m.group(1)
+
+
+def _shebang_interpreter(path: Path) -> str:
+    """The interpreter a console script runs under, from its shebang."""
+    try:
+        with path.open("rb") as fh:
+            first = fh.readline(256)
+    except OSError as e:
+        log.debug("_shebang_interpreter: cannot read %s: %s", path, e)
+        return _UNKNOWN
+    if not first.startswith(b"#!"):
+        return _UNKNOWN
+    return first[2:].decode("utf-8", "replace").strip()
+
+
+def _find_executables(name: str = "trcc") -> tuple[Executable, ...]:
+    """Every ``name`` on PATH — not just the first.
+
+    ``shutil.which`` stops at the first hit, which is precisely what hides a
+    duplicate install from the person trying to debug one.
+    """
+    exts = [""]
+    if os.name == "nt":
+        exts = [e.lower() for e in os.environ.get("PATHEXT", ".EXE").split(os.pathsep)]
+    found: list[Executable] = []
+    seen: set[Path] = set()
+    for entry in os.environ.get("PATH", "").split(os.pathsep):
+        if not entry:
+            continue
+        for ext in exts:
+            candidate = Path(entry) / f"{name}{ext}"
+            try:
+                resolved = candidate.resolve()
+                usable = candidate.is_file() and os.access(candidate, os.X_OK)
+            except OSError:
+                continue
+            if not usable or resolved in seen:
+                continue
+            seen.add(resolved)
+            found.append(Executable(candidate, _shebang_interpreter(candidate)))
+    log.debug("_find_executables: %d %r on PATH", len(found), name)
+    return tuple(found)
+
+
+def detect_installer() -> str:
+    """How this package got here — ``INSTALLER`` metadata over guesswork.
+
+    Supersedes the per-OS "is trcc on PATH? then pip" heuristics, which
+    answered "pip" for rpm, deb, venv and source checkouts alike.
+    """
+    if getattr(sys, "frozen", False):
+        return "pyinstaller"
+    if "pipx" in sys.prefix:
+        return "pipx"
+    try:
+        from importlib.metadata import PackageNotFoundError, distribution
+        try:
+            installer = (distribution("trcc-linux").read_text("INSTALLER") or "").strip()
+        except PackageNotFoundError:
+            log.debug("detect_installer: trcc-linux has no distribution metadata")
+            return "source"
+    except (OSError, ImportError) as e:
+        log.debug("detect_installer: metadata unavailable: %s", e)
+        return _UNKNOWN
+    if installer:
+        log.debug("detect_installer: INSTALLER=%s", installer)
+        return installer
+    # Installed as a distribution but nobody claimed it — a distro package
+    # manager (rpm/deb/pacman) drops the dist-info without an INSTALLER file.
+    return "package"
+
+
+def collect_install_info() -> InstallInfo:
+    """Gather the running install's identity.  Never raises."""
+    log.info("collect_install_info: called")
+    import trcc
+
+    module_file = getattr(trcc, "__file__", None)
+    module_path = Path(module_file).parent if module_file else None
+    info = InstallInfo(
+        version=trcc.__version__,
+        source_version=_read_source_version(module_path),
+        module_path=module_path,
+        interpreter=sys.executable,
+        python=f"{sys.version_info.major}.{sys.version_info.minor}."
+               f"{sys.version_info.micro}",
+        installer=detect_installer(),
+        executables=_find_executables(),
+    )
+    if info.bytecode_stale:
+        log.warning(
+            "collect_install_info: STALE BYTECODE — imported %s but %s says %s; "
+            "clear __pycache__",
+            info.version, module_path, info.source_version,
+        )
+    if info.duplicates:
+        log.warning(
+            "collect_install_info: %d trcc on PATH (%s) — an upgrade may land "
+            "on one and leave the other running",
+            len(info.executables),
+            ", ".join(str(e.path) for e in info.executables),
+        )
+    log.info("collect_install_info: %s via %s (%s)",
+             info.version, info.installer, info.interpreter)
+    return info

{trcc_linux-9.8.8 → trcc_linux-9.9.0}/src/trcc/adapters/system/bsd.py

@@ -179,11 +179,18 @@ class BSDPlatform(Platform):
         return "FreeBSD" if "freebsd" in sys.platform else "BSD"
 
     def install_method(self) -> str:
-        log.info("install_method: called")
-        import sys
-        if getattr(sys, "frozen", False):
-            return "pyinstaller"
-        return "source"
+        """How this package got here — delegated to the one honest detector.
+
+        Was a per-OS guess: this returned "source" for every pip install
+        (and Linux returned "pip" whenever `trcc` was merely on PATH, so
+        rpm/deb/venv/source checkouts all reported "pip"). The reading of
+        `INSTALLER` metadata is OS-agnostic, so there is nothing per-OS to
+        implement — see adapters/diagnostics/install.detect_installer.
+        """
+        from ..diagnostics.install import detect_installer
+        method = detect_installer()
+        log.info("install_method: %s", method)
+        return method
 
     # ── Per-OS diagnostic hints (pkg) ─────────────────────────────────
 

{trcc_linux-9.8.8 → trcc_linux-9.9.0}/src/trcc/adapters/system/linux.py

@@ -526,20 +526,18 @@ class LinuxPlatform(Platform):
         return "Linux"
 
     def install_method(self) -> str:
-        """Rough heuristic: PyInstaller bundle > pip > source."""
-        import sys
-        if getattr(sys, 'frozen', False):
-            log.info("LinuxPlatform.install_method → pyinstaller (frozen)")
-            return "pyinstaller"
-        try:
-            import shutil
-            if shutil.which("trcc"):
-                log.info("LinuxPlatform.install_method → pip (trcc on PATH)")
-                return "pip"
-        except Exception as e:
-            log.debug("LinuxPlatform.install_method: shutil.which raised %s", e)
-        log.info("LinuxPlatform.install_method → source")
-        return "source"
+        """How this package got here — delegated to the one honest detector.
+
+        Was a per-OS guess: this returned "source" for every pip install
+        (and Linux returned "pip" whenever `trcc` was merely on PATH, so
+        rpm/deb/venv/source checkouts all reported "pip"). The reading of
+        `INSTALLER` metadata is OS-agnostic, so there is nothing per-OS to
+        implement — see adapters/diagnostics/install.detect_installer.
+        """
+        from ..diagnostics.install import detect_installer
+        method = detect_installer()
+        log.info("install_method: %s", method)
+        return method
 
     # ── Per-OS diagnostic hints (distro package manager) ──────────────
 

{trcc_linux-9.8.8 → trcc_linux-9.9.0}/src/trcc/adapters/system/macos.py

@@ -187,11 +187,18 @@ class MacOSPlatform(Platform):
         return "macOS"
 
     def install_method(self) -> str:
-        log.info("install_method: called")
-        import sys
-        if getattr(sys, "frozen", False):
-            return "pyinstaller"
-        return "source"
+        """How this package got here — delegated to the one honest detector.
+
+        Was a per-OS guess: this returned "source" for every pip install
+        (and Linux returned "pip" whenever `trcc` was merely on PATH, so
+        rpm/deb/venv/source checkouts all reported "pip"). The reading of
+        `INSTALLER` metadata is OS-agnostic, so there is nothing per-OS to
+        implement — see adapters/diagnostics/install.detect_installer.
+        """
+        from ..diagnostics.install import detect_installer
+        method = detect_installer()
+        log.info("install_method: %s", method)
+        return method
 
     # ── Per-OS diagnostic hints (Homebrew) ────────────────────────────
 

{trcc_linux-9.8.8 → trcc_linux-9.9.0}/src/trcc/adapters/system/windows.py

@@ -467,11 +467,18 @@ class WindowsPlatform(Platform):
         return "Windows"
 
     def install_method(self) -> str:
-        log.info("install_method: called")
-        import sys
-        if getattr(sys, "frozen", False):
-            return "pyinstaller"
-        return "source"
+        """How this package got here — delegated to the one honest detector.
+
+        Was a per-OS guess: this returned "source" for every pip install
+        (and Linux returned "pip" whenever `trcc` was merely on PATH, so
+        rpm/deb/venv/source checkouts all reported "pip"). The reading of
+        `INSTALLER` metadata is OS-agnostic, so there is nothing per-OS to
+        implement — see adapters/diagnostics/install.detect_installer.
+        """
+        from ..diagnostics.install import detect_installer
+        method = detect_installer()
+        log.info("install_method: %s", method)
+        return method
 
     # ── Per-OS diagnostic hints (winget / WinUSB) ─────────────────────
 

{trcc_linux-9.8.8 → trcc_linux-9.9.0}/src/trcc/app.py

@@ -7,6 +7,7 @@ Holds one Platform (the OS), one dict of live Devices keyed by their
 from __future__ import annotations
 
 import logging
+from collections.abc import Callable
 from contextlib import AbstractContextManager, nullcontext
 from pathlib import Path
 from typing import Any, TypeVar
@@ -608,6 +609,46 @@ class App:
             return nullcontext()
         return sender.exclusive()
 
+    # ── Coldplug ──────────────────────────────────────────────────────
+
+    def discover_and_connect(
+        self, on_progress: Callable[[str], None] | None = None,
+    ) -> None:
+        """Coldplug: discover attached devices and connect each.
+
+        Dispatches ``DiscoverDevices`` (enumerate the registry against live
+        USB), then ``ConnectDevice(key=…)`` per product (attach transport +
+        handshake).  Only the connect step populates ``self.devices``, which
+        every UI's sidebar / device picker reads — without this loop a
+        long-lived UI starts empty and every device-keyed dispatch errors with
+        "Not attached: vid:pid".  Long-lived UIs (gui / qtgui) call this once
+        on startup; ``start_hotplug`` handles live changes afterwards; one-shot
+        CLI scripts skip it.  ``on_progress`` receives a human string per step
+        (splash display); connect *failures* are logged + recorded on the App
+        model (queried via ``DeviceConnectionIssues``), never raised.
+        """
+        from .core.commands import ConnectDevice, DiscoverDevices
+
+        def _say(message: str) -> None:
+            if on_progress is not None:
+                on_progress(message)
+
+        log.info("discover_and_connect: starting coldplug")
+        _say("Discovering devices…")
+        result = self.dispatch(DiscoverDevices())
+        for product in result.products:
+            _say(f"Connecting {product.vendor} {product.product}…")
+            connect = self.dispatch(ConnectDevice(key=product.key))
+            if not connect.ok:
+                log.warning(
+                    "discover_and_connect: connect %s failed: %s",
+                    product.key, connect.message,
+                )
+        log.info(
+            "discover_and_connect: %d product(s) discovered, %d attached",
+            len(result.products), len(self.devices),
+        )
+
     # ── Hotplug ───────────────────────────────────────────────────────
 
     def start_hotplug(self) -> None:

{trcc_linux-9.8.8 → trcc_linux-9.9.0}/src/trcc/core/commands/system.py

@@ -517,9 +517,12 @@ class CheckForUpdate(Command[UpdateCheckResult]):
     """
 
     def execute(self, app: App) -> UpdateCheckResult:
-        from ... import __version__ as next_version_module
-
-        local = getattr(next_version_module, "__version__", "0.0.0")
+        # `trcc/__init__` rebinds the name `__version__` from the submodule to
+        # the version STRING, so this import yields a str, not a module.  The
+        # old `getattr(mod, "__version__", "0.0.0")` therefore always fell
+        # through to "0.0.0" and told every user, on every release, that an
+        # update was available — including users already on the newest one.
+        from ... import __version__ as local
         try:
             latest = app.github_releases.latest()
         except HttpFetchError as e: