remoteRF-server 1.4.2__tar.gz → 1.4.4__tar.gz

{remoterf_server-1.4.2 → remoterf_server-1.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 1.4.2
+Version: 1.4.4
 Summary: RemoteRF server-side control package
 License: GPL-3.0-or-later
 Classifier: Programming Language :: Python :: 3

{remoterf_server-1.4.2 → remoterf_server-1.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoteRF-server"
-version = "1.4.2"
+version = "1.4.4"
 description = "RemoteRF server-side control package"
 license = { text = "GPL-3.0-or-later" }
 requires-python = ">=3.10"

{remoterf_server-1.4.2 → remoterf_server-1.4.4}/src/remoteRF_server/server/device_manager.py

@@ -1294,23 +1294,24 @@ def device_inventory_snapshot() -> Dict[int, Dict[str, object]]:
 
 # Optional: reload device definitions (atomic swap)
 
-def reload_devices() -> None:
+def reload_devices(on_device=None) -> None:
     """
     Open the local devices in devices.yml: once at server startup
     (start_server_runtime), and again after `devices add/remove/rename/wipe`.
     Preserves existing salt/hash for devices that remain (same gid),
     and preserves host virtual devices + their auth state.
+    on_device(gid, name) is called as each local device starts opening.
     """
     # The console and the control socket can both reload; two at once would
     # each make every device and leave one set open.
     with _reload_lock:
-        _reload_devices_locked()
+        _reload_devices_locked(on_device)
 
 
 _reload_lock = threading.Lock()
 
 
-def _reload_devices_locked() -> None:
+def _reload_devices_locked(on_device=None) -> None:
     # ponytail: reconnects every local device, not just the changed one;
     # diff against the current table if a reload mid-session ever hurts.
     records = _load_device_records()
@@ -1343,6 +1344,8 @@ def _reload_devices_locked() -> None:
         name = (rec.get("NAME") or f"device-{gid}").strip()
         ident = (rec.get("IDENT") or "").strip()
 
+        if on_device is not None:
+            on_device(int(gid), name)
         dev, ident2, dtype2 = _connect_from_record(rec)
 
         tmp_info[int(gid)] = name

{remoterf_server-1.4.2 → remoterf_server-1.4.4}/src/remoteRF_server/server/grpc_server.py

@@ -405,8 +405,15 @@ def start_server_runtime(
             ca_path=cert_dir / "ca.crt",
         )
         # The one place local hardware is opened: importing device_manager does not.
-        reload_devices()
-        reservation_handler.update_devices()
+        # The startup check runs before server.start(): no call reaches a
+        # Pluto it is power-cycling.
+        def open_devices(on_device):
+            reload_devices(on_device=on_device)
+            reservation_handler.update_devices()
+
+        from . import startup_check
+
+        startup_check.run(open_devices)
         server.start()
         if direct_path is not None:
             direct_path.start_listener()
@@ -424,7 +431,7 @@ def start_server_runtime(
             start_usergroup_cleanup_loop(interval_sec=60)
         if publish_status:
             start_status_publisher()
-    except Exception:
+    except BaseException:  # Ctrl-C during the startup check too: close_local_devices powers Plutos down
         stop_event.set()
         server.stop(0)
         session_manager.close_all()
@@ -500,6 +507,9 @@ def welcome():
     try:
         from . import global_onboarding as g
 
+        lan = g.lan_endpoint()
+        if lan and lan != f"{local_ip}:{local_port}":
+            rows.append(f"lan     {lan}")
         if g.participating() and g.state() == "active" and g.hostname():
             rows.append(f"global  {g.hostname()}")
     except Exception:  # noqa: BLE001 - the banner never fails on Global state

remoterf_server-1.4.4/src/remoteRF_server/server/startup_check.py

@@ -0,0 +1,308 @@
+# Copyright (C) 2026 RemoteRF
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""Startup device check: open every local device quietly, test each one, and
+show one line per device plus a summary. Everything the drivers print,
+C libraries writing straight to fd 1/2 included, goes to
+<config>/logs/startup-<UTC>.log instead of the console."""
+
+from __future__ import annotations
+
+import ctypes
+import os
+import shutil
+import sys
+import threading
+import time
+import traceback
+from concurrent.futures import Future, TimeoutError as FutureTimeout
+from datetime import datetime, timezone
+from pathlib import Path
+
+from prompt_toolkit import print_formatted_text
+
+from ..common.utils import Sty, stylize
+from ..common.utils.ansi_codes import style
+from ..common.utils.panel import supports_unicode
+from ..drivers.adalm_pluto.poe import PoePluto
+from . import device_manager as dm
+
+DEADLINE_S = 120  # all device checks, counted from when opening finishes (opening is unbounded, as before)
+POE_TIMEOUT_S = 90  # power off, OFF_S, boot (BOOT_TIMEOUT_S), IIO context
+CHECK_TIMEOUT_S = 15
+GPS_WAIT_S = 5
+KEEP_LOGS = 10
+MIN_FREE_BYTES = 16 << 20  # less than this: open the devices without capture
+FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+
+def enabled() -> bool:
+    return os.getenv("REMOTERF_STARTUP_TEST", "1").strip().lower() not in ("0", "false", "no", "off")
+
+
+def _start(fn, *args) -> Future:
+    """fn(*args) on a daemon thread: one that never returns cannot hold up exit."""
+    fut: Future = Future()
+
+    def run():
+        try:
+            fut.set_result(fn(*args))
+        except BaseException as exc:  # noqa: BLE001 - handed to the waiter
+            fut.set_exception(exc)
+
+    threading.Thread(target=run, daemon=True, name="remoterf-startup-check").start()
+    return fut
+
+
+def _short(text: str, limit: int = 72) -> str:
+    text = " ".join(str(text).split())
+    return text if len(text) <= limit else text[: limit - 1] + "…"
+
+
+def _log(fd: int, text: str) -> None:
+    try:
+        os.write(fd, text.encode())
+    except OSError:  # a full disk must not fail opening or the check
+        pass
+
+
+def _restore_power(st) -> None:
+    """A tested PoE Pluto goes back to standby unless a reservation holds it (pre-warm keeps it on)."""
+    with dm._state_lock:
+        reserved = bool(st.salt and st.hsh)
+    if not reserved:
+        st.dev.call_power_down()
+
+
+def _check(st) -> None:
+    """Raise unless the device answers. Holds io_lock, so a call cannot reach it mid-check."""
+    with st.io_lock:
+        dev = st.dev
+        native = getattr(dev, "device", None)
+        if isinstance(native, PoePluto):
+            # Its own RLock across cycle, read and restore: a close() (quit) runs after the restore.
+            with native._lock:
+                try:
+                    if native.power_state != "on":  # already on: its reservation pre-warm booted it
+                        native.power_cycle()
+                    int(native.sample_rate)
+                finally:
+                    try:
+                        _restore_power(st)
+                    except Exception as exc:  # noqa: BLE001 - the check's own result matters more
+                        print(f"could not return {st.name} to standby: {exc}")
+        elif st.dtype == "rtl_sdr":
+            dev.call_read_bytes(512)
+        elif st.dtype == "gps":
+            end = time.monotonic() + GPS_WAIT_S
+            while not dev.call_read_raw(1):
+                if time.monotonic() > end:
+                    raise RuntimeError(f"no NMEA sentence in {GPS_WAIT_S} s")
+                time.sleep(0.2)
+        elif st.dtype == "bluetooth":
+            if not dev.get_powered():
+                raise RuntimeError("adapter is not powered")
+        # ponytail: USRPs and other drivers count as operational once they open;
+        # add a dtype branch here when one gets a cheap probe.
+
+
+def _timeout_for(st) -> float:
+    return POE_TIMEOUT_S if isinstance(getattr(st.dev, "device", None), PoePluto) else CHECK_TIMEOUT_S
+
+
+class _Display:
+    def __init__(self, out):
+        self.out = out
+        self.tty = out.isatty()
+        self.uni = supports_unicode(getattr(out, "encoding", None))
+        self.frame = 0
+
+    def _print(self, *pairs, end="\n") -> None:
+        if self.tty:
+            self.out.write("\r\x1b[2K")
+        print_formatted_text(stylize(*pairs), style=style, file=self.out, end=end)
+
+    def spin(self, text: str) -> None:
+        """Gray spinner line, redrawn in place; nothing at all off a TTY."""
+        if not self.tty:
+            return
+        frames = FRAMES if self.uni else "|/-\\"
+        self.frame += 1
+        self._print(f"{frames[self.frame % len(frames)]} {text}", Sty.GRAY, end="")
+
+    def clear(self) -> None:
+        if self.tty:
+            self.out.write("\r\x1b[2K")
+            self.out.flush()
+
+    def result(self, ok: bool, label: str, detail: str) -> None:
+        mark = ("✓" if ok else "✗") if self.uni else ("ok" if ok else "x")
+        self._print(mark, Sty.BRIGHT_GREEN if ok else Sty.BRIGHT_RED, f" {label} · {detail}", Sty.GRAY)
+
+    def summary(self, results, word: str) -> None:
+        n = len(results)
+        ok = sum(1 for r in results if r[1])
+        noun = "device" if n == 1 else "devices"
+        if ok == n:
+            self._print(f"All {n} {noun} {word}", Sty.BRIGHT_GREEN)
+            return
+        issues = ", ".join(r[0] for r in results if not r[1])
+        self._print(f"{ok} of {n} {noun} {word}", Sty.YELLOW if ok else Sty.BRIGHT_RED,
+                    f" · issues: {issues}", Sty.GRAY)
+
+
+def _wait(display: _Display, fut: Future, until: float, text):
+    """fut's result while a spinner shows `text` (a str or a callable); FutureTimeout once `until` passes."""
+    while True:
+        try:
+            return fut.result(timeout=max(0.0, min(0.1, until - time.monotonic())))
+        except FutureTimeout:
+            if time.monotonic() >= until:
+                raise
+            display.spin(text() if callable(text) else text)
+
+
+def _new_log(cfg_dir: Path) -> Path:
+    logs = cfg_dir / "logs"
+    logs.mkdir(parents=True, exist_ok=True)
+    for old in sorted(logs.glob("startup-*.log"))[: -(KEEP_LOGS - 1)]:
+        old.unlink(missing_ok=True)
+    return logs / f"startup-{datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%SZ')}.log"
+
+
+def _flush_all() -> None:
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.flush()
+        except Exception:  # noqa: BLE001
+            pass
+    try:
+        ctypes.CDLL(None).fflush(None)  # C stdio buffers (librtlsdr, UHD) before fd 1/2 move
+    except Exception:  # noqa: BLE001
+        pass
+
+
+def run(open_devices, *, cfg_dir: Path | None = None) -> None:
+    """open_devices(on_device) opens the hardware (device_manager.reload_devices);
+    its errors propagate as before. A failure of the check itself never does."""
+    log_fd = -1
+    try:
+        log_path = _new_log(Path(cfg_dir or dm._cfg_dir()))
+        if shutil.disk_usage(log_path.parent).free < MIN_FREE_BYTES:
+            raise OSError("low disk space")
+        log_fd = os.open(log_path, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o644)
+        os.write(log_fd, b"remoterf startup check\n")
+    except Exception as exc:  # noqa: BLE001 - no log: open the devices the old way
+        if log_fd >= 0:
+            os.close(log_fd)
+        print(f"Warning: startup check log unavailable ({exc}); opening devices without it")
+        open_devices(None)
+        return
+
+    _flush_all()
+    saved = (os.dup(1), os.dup(2))
+    out = os.fdopen(os.dup(saved[0]), "w", encoding=getattr(sys.stdout, "encoding", None) or "utf-8",
+                    errors="replace")
+    display = _Display(out)
+    results = None
+    try:
+        os.dup2(log_fd, 1)
+        os.dup2(log_fd, 2)
+        try:
+            results = _run_captured(open_devices, display, log_fd, log_path)
+        finally:
+            _flush_all()
+            os.dup2(saved[0], 1)
+            os.dup2(saved[1], 2)
+            display.clear()
+            if results:
+                display.summary(results, "operational" if enabled() else "opened")
+            elif results == []:
+                display._print("No local devices opened", Sty.YELLOW)
+            display._print(f"log: {log_path}", Sty.GRAY)
+    finally:
+        out.close()
+        for fd in (*saved, log_fd):
+            os.close(fd)
+
+
+def _run_captured(open_devices, display: _Display, log_fd: int, log_path: Path):
+    marks: dict[int, int] = {}  # gid -> where its open output starts in the log
+    breaks: list[int] = []  # where each device's "--- open" line starts
+    current = {"name": "devices"}
+
+    def on_device(gid: int, name: str) -> None:
+        _flush_all()  # the previous device's buffered prints land in its own slice
+        current["name"] = name
+        breaks.append(os.fstat(log_fd).st_size)
+        _log(log_fd, f"\n--- [{gid}] {name} · open\n")
+        marks[gid] = os.fstat(log_fd).st_size
+
+    # Opening has no deadline: no device is served before it finishes, as before.
+    _wait(display, _start(open_devices, on_device), float("inf"), lambda: f"opening {current['name']}…")
+    _flush_all()
+    opened_end = os.fstat(log_fd).st_size
+
+    try:
+        with dm._state_lock:
+            states = sorted((gid, st) for gid, st in dm._devices.items() if st.origin == "local")
+        if not states:
+            return []
+        captured = log_path.read_bytes()
+
+        def open_error(gid: int) -> str:
+            """The last line its driver printed while opening it."""
+            start = marks.get(gid)
+            if start is None:
+                return "not opened"
+            end = min([b for b in breaks if b >= start] + [opened_end])
+            lines = [l for l in captured[start:end].decode("utf-8", "replace").splitlines() if l.strip()]
+            return _short(lines[-1]) if lines else "not found"
+
+        test = enabled()
+        checks = {}
+        launched = time.monotonic()
+        deadline = launched + DEADLINE_S
+        for gid, st in states:
+            if st.dev is not None and test:
+                _log(log_fd, f"\n--- [{gid}] {st.name} · test\n")
+                checks[gid] = _start(_check, st)
+
+        results = []
+        for gid, st in states:
+            label = f"[{gid}] {st.name}"
+            if st.dev is None:
+                ok, detail = False, open_error(gid)
+            elif gid not in checks:
+                ok, detail = True, "operational" if test else "opened"
+            else:
+                until = min(launched + _timeout_for(st), deadline)
+                try:
+                    _wait(display, checks[gid], until, f"{label} · testing…")
+                    ok, detail = True, "operational"
+                except FutureTimeout:
+                    ok, detail = False, f"no answer after {int(time.monotonic() - launched)} s"
+                except Exception as exc:  # noqa: BLE001 - the device's failure, shown on its line
+                    ok, detail = False, _short(exc) or type(exc).__name__
+                    _log(log_fd, "".join(traceback.format_exception(type(exc), exc, exc.__traceback__)))
+            _flush_all()
+            display.result(ok, label, detail)
+            results.append((st.name, ok))
+            _log(log_fd, f"[{gid}] {st.name}: {'ok' if ok else 'ISSUE'} {detail}\n")
+        return results
+    except Exception as exc:  # noqa: BLE001 - never stops the server
+        _log(log_fd, f"startup check failed: {type(exc).__name__}: {exc}\n")
+        display.result(False, "startup check", _short(f"failed: {exc}"))
+        return None

{remoterf_server-1.4.2 → remoterf_server-1.4.4}/src/remoteRF_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 1.4.2
+Version: 1.4.4
 Summary: RemoteRF server-side control package
 License: GPL-3.0-or-later
 Classifier: Programming Language :: Python :: 3

{remoterf_server-1.4.2 → remoterf_server-1.4.4}/src/remoteRF_server.egg-info/SOURCES.txt

@@ -76,6 +76,7 @@ src/remoteRF_server/server/grpc_server.py
 src/remoteRF_server/server/host_dynamic_v2.py
 src/remoteRF_server/server/reservation.py
 src/remoteRF_server/server/rpc_manager.py
+src/remoteRF_server/server/startup_check.py
 src/remoteRF_server/server/user_group_cli.py
 src/remoteRF_server/server/user_group_handler.py
 src/remoteRF_server/server/v2_errors.py
@@ -161,6 +162,7 @@ tests/test_rpc_manager_calln.py
 tests/test_rpc_manager_rx_n.py
 tests/test_rtl_sdr_schema.py
 tests/test_soak_federation.py
+tests/test_startup_check.py
 tests/test_status_push.py
 tests/test_ti_mmwave_hardware.py
 tests/test_ti_mmwave_schema.py

remoterf_server-1.4.4/tests/test_startup_check.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+import ctypes
+import io
+import os
+import pty
+import sys
+import threading
+import time
+import types
+from unittest.mock import MagicMock
+
+import pytest
+
+from remoteRF_server.drivers.adalm_pluto.poe import PoePluto
+from remoteRF_server.server import device_manager as dm
+from remoteRF_server.server import startup_check as sc
+
+
+def state(name, dev, dtype="custom", reserved=False):
+    return dm._DeviceState(dev=dev, origin="local", online=dev is not None,
+                           salt="s" if reserved else "", hsh="h" if reserved else "",
+                           name=name, ident="", dtype=dtype)
+
+
+class Rtl:
+    def __init__(self, block=None, delay=0):
+        self.block = block
+        self.delay = delay
+        self.reads = []
+
+    def call_read_bytes(self, n):
+        self.reads.append(n)
+        time.sleep(self.delay)
+        if self.block is not None:
+            self.block.wait()
+
+
+def opener(devices, noise=None):
+    def open_devices(on_device):
+        for gid, st in devices.items():
+            on_device(gid, st.name)
+            for line in (noise or {}).get(gid, []):
+                os.write(2 if "error" in line else 1, line.encode() + b"\n")
+            dm._devices[gid] = st
+    return open_devices
+
+
+@pytest.fixture(autouse=True)
+def clean(monkeypatch):
+    monkeypatch.setattr(dm, "_devices", {})
+    monkeypatch.delenv("REMOTERF_STARTUP_TEST", raising=False)
+
+
+def test_quiet_lines_summary_and_log(tmp_path, capfd):
+    devices = {100: state("Pluto 00", object()), 101: state("RTL 01", None, "rtl_sdr"),
+               102: state("RTL 02", Rtl(), "rtl_sdr")}
+
+    def open_devices(on_device):
+        opener(devices, {101: ["Found Rafael Micro R828D tuner", "usb_open error -3"]})(on_device)
+        ctypes.CDLL(None).printf(b"RTL-SDR Blog V4 Detected\n")  # C stdio, buffered
+
+    sc.run(open_devices, cfg_dir=tmp_path)
+    out = capfd.readouterr().out
+    assert out.splitlines() == [
+        "✓ [100] Pluto 00 · operational",
+        "✗ [101] RTL 01 · usb_open error -3",
+        "✓ [102] RTL 02 · operational",
+        "2 of 3 devices operational · issues: RTL 01",
+        f"log: {next((tmp_path / 'logs').glob('startup-*.log'))}",
+    ]
+    assert devices[102].dev.reads == [512]
+    log = next((tmp_path / "logs").glob("startup-*.log")).read_text()
+    for text in ("Found Rafael Micro", "RTL-SDR Blog V4 Detected", "[101] RTL 01: ISSUE usb_open error -3"):
+        assert text in log
+
+
+def test_all_operational_and_test_off(tmp_path, capfd, monkeypatch):
+    rtl = Rtl()
+    sc.run(opener({7: state("RTL", rtl, "rtl_sdr")}), cfg_dir=tmp_path)
+    assert capfd.readouterr().out.splitlines()[:2] == ["✓ [7] RTL · operational", "All 1 device operational"]
+
+    monkeypatch.setenv("REMOTERF_STARTUP_TEST", "0")
+    sc.run(opener({7: state("RTL", rtl, "rtl_sdr")}), cfg_dir=tmp_path)
+    assert capfd.readouterr().out.splitlines()[:2] == ["✓ [7] RTL · opened", "All 1 device opened"]
+    assert rtl.reads == [512]  # the second run did not test it
+
+
+def test_timeout_and_deadline(tmp_path, capfd, monkeypatch):
+    block = threading.Event()
+    monkeypatch.setattr(sc, "CHECK_TIMEOUT_S", 0.3)
+    t = time.monotonic()
+    sc.run(opener({1: state("Hung", Rtl(block), "rtl_sdr")}), cfg_dir=tmp_path)
+    assert time.monotonic() - t < 2
+    out = capfd.readouterr().out
+    assert "✗ [1] Hung · no answer after 0 s" in out
+    assert "\x1b" not in out and not set(sc.FRAMES) & set(out)  # no spinner off a TTY
+
+    monkeypatch.setattr(sc, "CHECK_TIMEOUT_S", 30)
+    monkeypatch.setattr(sc, "DEADLINE_S", 0.4)
+    t = time.monotonic()
+    sc.run(opener({1: state("A", Rtl(block), "rtl_sdr"), 2: state("B", Rtl(block), "rtl_sdr")}), cfg_dir=tmp_path)
+    assert time.monotonic() - t < 2
+    assert capfd.readouterr().out.count("no answer after") == 2
+    block.set()
+
+
+def test_log_unavailable_still_opens_devices(tmp_path, monkeypatch):
+    (tmp_path / "logs").write_text("not a directory")
+    calls = []
+    sc.run(calls.append, cfg_dir=tmp_path)
+    assert calls == [None]
+
+    (tmp_path / "logs").unlink()
+    monkeypatch.setattr(sc.shutil, "disk_usage", lambda p: types.SimpleNamespace(free=0))
+    sc.run(calls.append, cfg_dir=tmp_path)
+    assert calls == [None, None]
+
+
+def test_silent_failure_does_not_borrow_next_devices_output(tmp_path, capfd):
+    devices = {20: state("GPS", None, "gps"), 30: state("RTL 01", Rtl(), "rtl_sdr")}
+    sc.run(opener(devices, {30: ["RTL-SDR Blog V4 Detected"]}), cfg_dir=tmp_path)
+    assert "✗ [20] GPS · not found" in capfd.readouterr().out
+
+
+def test_buffered_print_is_the_failure_reason(tmp_path, capfd, monkeypatch):
+    monkeypatch.setattr(sys, "stdout", io.TextIOWrapper(open(1, "wb", closefd=False), line_buffering=False))
+    devices = {10: state("BT", None, "bluetooth"), 20: state("GPS", Rtl(), "rtl_sdr")}
+
+    def open_devices(on_device):
+        for gid, st in devices.items():
+            on_device(gid, st.name)
+            if st.dev is None:
+                print("make_device() failed for bluetooth: No adapter found")
+            dm._devices[gid] = st
+
+    sc.run(open_devices, cfg_dir=tmp_path)
+    assert "✗ [10] BT · make_device() failed for bluetooth: No adapter found" in capfd.readouterr().out
+    log = next((tmp_path / "logs").glob("startup-*.log")).read_text()
+    assert log.index("No adapter found") < log.index("[10] BT: ISSUE")
+
+
+def test_checks_run_concurrently(tmp_path, capfd, monkeypatch):
+    monkeypatch.setattr(sc, "CHECK_TIMEOUT_S", 0.5)
+    sc.run(opener({1: state("A", Rtl(delay=0.3), "rtl_sdr"), 2: state("B", Rtl(delay=0.3), "rtl_sdr")}),
+           cfg_dir=tmp_path)
+    assert "All 2 devices operational" in capfd.readouterr().out
+
+
+def test_no_devices_and_machinery_failure_never_raise(tmp_path, capfd, monkeypatch):
+    sc.run(opener({}), cfg_dir=tmp_path)
+    out = capfd.readouterr().out.splitlines()
+    assert out[0] == "No local devices opened" and out[1].startswith("log: ")
+
+    monkeypatch.setattr(dm, "_state_lock", None)  # `with None:` raises inside the check
+    sc.run(opener({1: state("A", Rtl(), "rtl_sdr")}), cfg_dir=tmp_path)
+    assert "✗ startup check · failed" in capfd.readouterr().out
+    logs = sorted((tmp_path / "logs").glob("startup-*.log"))
+    assert any("startup check failed" in p.read_text() for p in logs)
+
+
+def test_log_rotation(tmp_path):
+    logs = tmp_path / "logs"
+    logs.mkdir()
+    for i in range(15):
+        (logs / f"startup-2026010{i:02d}.log").write_text("")
+    sc.run(opener({}), cfg_dir=tmp_path)
+    assert len(list(logs.glob("startup-*.log"))) == sc.KEEP_LOGS
+
+
+@pytest.mark.parametrize("reserved,power_state,cycled,powered_down", [
+    (False, "standby", True, True),
+    (True, "standby", True, False),
+    (True, "on", False, False),  # its reservation pre-warm already booted it
+])
+def test_poe_restore_rule(reserved, power_state, cycled, powered_down):
+    native = MagicMock(spec=PoePluto)
+    native._lock = threading.RLock()
+    native.power_state = power_state
+    native.sample_rate = 30_720_000
+    schema = types.SimpleNamespace(device=native, call_power_down=MagicMock())
+    sc._check(state("Pluto 00", schema, "adalm_pluto", reserved=reserved))
+    assert native.power_cycle.called is cycled
+    assert schema.call_power_down.called is powered_down
+
+
+def test_poe_failure_still_returns_to_standby():
+    native = MagicMock(spec=PoePluto)
+    native._lock = threading.RLock()
+    native.power_state = "standby"
+    native.power_cycle.side_effect = RuntimeError("did not boot within 45 s")
+    schema = types.SimpleNamespace(device=native, call_power_down=MagicMock())
+    with pytest.raises(RuntimeError, match="45 s"):
+        sc._check(state("Pluto 04", schema, "adalm_pluto"))
+    schema.call_power_down.assert_called_once()
+
+
+def test_tty_spinner_redraws_in_place():
+    master, slave = pty.openpty()
+    out = os.fdopen(slave, "w", encoding="utf-8")
+    display = sc._Display(out)
+    display.spin("[100] Pluto 00 · testing…")
+    display.result(True, "[100] Pluto 00", "operational")
+    out.flush()
+    text = os.read(master, 4096).decode()
+    out.close()
+    os.close(master)
+    assert "\r\x1b[2K" in text and "testing…" in text and "operational" in text
+    assert text.index("testing…") < text.rindex("\r\x1b[2K") < text.index("✓")