fix(updater): print-aware unattended updates, reliable boot provisioning and self-heal, gapless restart splash

BlocksScreen/BlocksScreen.py

@@ -68,11 +68,7 @@ def notify(self, a0: QtCore.QObject, a1: QtCore.QEvent) -> bool:  # type: ignore
 
 
 def _write_splash_to_fb0() -> None:
-    """Write precomputed splash to fb0 while KD_GRAPHICS is still active.
-
-    Called from SIGTERM handler so fb0 already shows the splash before X exits,
-    eliminating the brief black frame between X shutdown and ExecStopPost.
-    """
+    """Write the precomputed splash to fb0 on SIGTERM, before window teardown."""
     try:
         if _SPLASH_CACHE.exists():
             _FB0.write_bytes(_SPLASH_CACHE.read_bytes())

BlocksScreen/lib/panels/mainWindow.py

@@ -283,6 +283,10 @@ def __init__(self):
         self.controlPanel.disable_popups.connect(self.popup_toggle)
         self.updater_worker.status_ready.connect(self.update_page.handle_status_ready)
         self.updater_worker.busy_changed.connect(self.update_page.handle_busy_changed)
+        self.updater_worker.provisioning_changed.connect(
+            self.update_page.handle_provisioning_changed
+        )
+        self.updater_worker.replay_busy()
         self.updater_worker.daemon_unavailable.connect(self.on_updater_unavailable)
         self.updater_worker.daemon_unavailable.connect(
             self.update_page.handle_daemon_unavailable

BlocksScreen/lib/panels/widgets/MainWindow/updatePage.py

@@ -2,6 +2,7 @@
 
 import json
 import logging
+import re
 import typing
 from types import MappingProxyType
 
@@ -15,6 +16,12 @@
 from updater.models import ComponentStatus
 
 _log = logging.getLogger(__name__)
+_DESCRIBE_SUFFIX = re.compile(r"-(\d+)-g[0-9a-f]+$")
+
+
+def _compact_version(describe: str) -> str:
+    """`v1.0.0-12-gabc1234` -> `v1.0.0+12`, so commits past one tag stay distinguishable."""
+    return _DESCRIBE_SUFFIX.sub(r"+\1", describe)
 
 
 class UpdatePage(QtWidgets.QWidget):
@@ -46,6 +53,12 @@ class UpdatePage(QtWidgets.QWidget):
         }
     )
 
+    _PROVISION_STEP_LABELS: typing.ClassVar[MappingProxyType[int, str]] = (
+        MappingProxyType(
+            {1: "cloning", 2: "installing deps", 3: "setting up", 4: "starting"}
+        )
+    )
+
     _APT_STEP_LABELS: typing.ClassVar[MappingProxyType[int, str]] = MappingProxyType(
         {1: "updating packages", 2: "upgrading packages"}
     )
@@ -72,6 +85,8 @@ def __init__(self) -> None:
         self._update_avail: bool = False
         self._post_update_status_pending: bool = False
         self._overlay_shown: bool = False
+        self._restart_pending: bool = False
+        self._provisioning: bool = False
         self._elapsed_time_seconds: int = 0
         self._elapsed_timer: QtCore.QTimer = QtCore.QTimer(self)
         self._elapsed_timer.setSingleShot(False)
@@ -81,6 +96,15 @@ def __init__(self) -> None:
         self._busy_timeout_timer.setSingleShot(True)
         self._busy_timeout_timer.setInterval(400_000)  # 400s > 360s watchdog
         self._busy_timeout_timer.timeout.connect(self._on_busy_timeout)
+        # Reusable: a stale singleShot from update N would close update N+1's overlay.
+        self._restart_grace_timer: QtCore.QTimer = QtCore.QTimer(self)
+        self._restart_grace_timer.setSingleShot(True)
+        self._restart_grace_timer.setInterval(15000)
+        self._restart_grace_timer.timeout.connect(self._dismiss_after_restart_grace)
+        self._stale_overlay_timer: QtCore.QTimer = QtCore.QTimer(self)
+        self._stale_overlay_timer.setSingleShot(True)
+        self._stale_overlay_timer.setInterval(60000)
+        self._stale_overlay_timer.timeout.connect(self._dismiss_stale_overlay)
         self._update_confirm_popup: BasePopup | None = None
         self.show_loading(True)
 
@@ -113,7 +137,7 @@ def _on_busy_timeout(self) -> None:
             self.show_loading(False)
             self.call_load_panel.emit(False, "", False)
             self._show_toast(
-                "Update is taking longer than expected - tap refresh to check status"
+                "Still working in the background - tap refresh to check status"
             )
 
     def showEvent(self, a0: QtGui.QShowEvent | None) -> None:
@@ -140,7 +164,7 @@ def resizeEvent(self, a0: QtGui.QResizeEvent | None) -> None:
         return super().resizeEvent(a0)
 
     def _needs_update(self, status: ComponentStatus) -> bool:
-        # Mirrors daemon dirty-set: errored git repos self-heal; apt errors don't.
+        """Mirror the daemon's dirty set: errored git repos count, apt errors don't."""
         return bool(
             status.commits_behind
             or status.packages_upgradable > 0
@@ -155,8 +179,8 @@ def _version_string(self, status: ComponentStatus) -> str:
             return "status error"
         if status.kind in ("system", "apt"):
             return "updates available"
-        current = status.current_version or status.current_hash[:8]
-        return f"{current} → {status.remote_version or 'unknown'}"
+        current = _compact_version(status.current_version) or status.current_hash[:8]
+        return f"{current} → {_compact_version(status.remote_version) or 'unknown'}"
 
     def _make_white_label(
         self,
@@ -310,18 +334,16 @@ def _toggle_details(self) -> None:
         )
 
     def handle_status_ready(self, json_str: str) -> None:
-        """Update component statuses from a JSON payload and refresh the list."""
+        """Parse statuses per entry so one bad entry can't blank the list; refresh."""
         self.update_all_btn.setEnabled(True)
         _log.debug("handle_status_ready: busy=%s", self._busy)
         try:
             data: dict[str, dict] = json.loads(json_str)
         except (json.JSONDecodeError, TypeError) as exc:
             _log.error("handle_status_ready: bad payload '%s'", exc)
             _log.debug(json_str)
-            # Keep the last good list but tell the user it may be stale.
             self._show_toast("Status update failed - tap refresh to retry")
             return
-        # Build per-component so one malformed entry can't blank the whole list.
         self._statuses = {}
         for name, fields in data.items():
             try:
@@ -335,10 +357,11 @@ def handle_status_ready(self, json_str: str) -> None:
         self._update_avail = _update_avail
         if not self._busy:
             self.show_loading(False)
-            if self._post_update_status_pending:
+            if self._post_update_status_pending and not self._restart_pending:
                 _log.debug("status_ready: emitting call_load_panel(False)")
                 self.call_load_panel.emit(False, "", False)
                 self._post_update_status_pending = False
+                self._overlay_shown = False
         else:
             _log.debug("status_ready: skipping loadscreen dismiss (busy=True)")
         self.build_cards()
@@ -350,25 +373,61 @@ def handle_busy_changed(self, busy: bool) -> None:
         self._busy = busy
         self.show_loading(busy)
         if busy:
+            if self._provisioning:
+                self._show_provisioning_overlay()
+            self._restart_pending = False
+            self._restart_grace_timer.stop()
+            self._stale_overlay_timer.stop()
             self._elapsed_time_seconds = 0
             self._elapsed_timer.start()
             self._busy_timeout_timer.start()
             self._elapsed_time_label.show()
             self._progress_label.setText("")
             self._progress_label.show()
-            self._cancel_btn.show()
+            # The daemon ignores cancel() while installing a component.
+            self._cancel_btn.setVisible(not self._provisioning)
         else:
+            self._provisioning = False
             self._elapsed_timer.stop()
             self._busy_timeout_timer.stop()
             self._elapsed_time_label.hide()
             self._progress_label.hide()
             self._cancel_btn.hide()
             self.update_all_btn.setEnabled(True)
-            if self._overlay_shown:
-                self._overlay_shown = False
-                self.call_load_panel.emit(False, "", False)
+            if self._restart_pending:
+                # Keep the overlay up: SIGTERM is imminent, MainWindow would flash.
+                self._restart_grace_timer.start()
+            elif self._overlay_shown:
+                # Hold the overlay until fresh status lands, else stale cards flash.
+                self._post_update_status_pending = True
+                self._stale_overlay_timer.start()
             self._request_status_debounced()
 
+    def handle_provisioning_changed(self, provisioning: bool) -> None:
+        """Daemon-declared: the current busy period installs a missing component."""
+        self._provisioning = provisioning
+        if provisioning and self._busy:
+            self._cancel_btn.hide()
+            self._show_provisioning_overlay()
+
+    def _show_provisioning_overlay(self) -> None:
+        self._overlay_shown = True
+        self.call_load_panel.emit(True, "Missing component, installing ...", False)
+
+    def _dismiss_stale_overlay(self) -> None:
+        """Drop the overlay if the post-update status never arrived."""
+        if self._overlay_shown and not self._busy:
+            self._overlay_shown = False
+            self._post_update_status_pending = False
+            self.call_load_panel.emit(False, "", False)
+
+    def _dismiss_after_restart_grace(self) -> None:
+        """Drop the overlay if the expected UI restart never came."""
+        if self._restart_pending and not self._busy:
+            self._restart_pending = False
+            self._overlay_shown = False
+            self.call_load_panel.emit(False, "", False)
+
     @QtCore.pyqtSlot(name="on-update-all-clicked")
     def on_update_all_clicked(self) -> None:
         """Guard against updates during a print or with hot heaters; otherwise show confirm dialog."""
@@ -385,7 +444,7 @@ def on_update_all_clicked(self) -> None:
         self._show_update_confirm()
 
     def _show_update_confirm(self) -> None:
-        # Dialogs parented to the page outlive close(); drop the previous one.
+        """Show the confirm dialog; delete the previous one, which outlives close()."""
         if self._update_confirm_popup is not None:
             self._update_confirm_popup.deleteLater()
         popup = BasePopup(self, floating=True)
@@ -418,14 +477,20 @@ def handle_step_complete(self, name: str, step: int, total: int) -> None:
         status = self._statuses.get(name)
         if status and status.kind == "apt":
             label = self._APT_STEP_LABELS.get(step, "working")
+        elif self._provisioning:
+            label = self._PROVISION_STEP_LABELS.get(step, "working")
         else:
             label = self._STEP_LABELS.get(step, "working")
         _log.info("step_complete: %s %d/%d (%s)", name, step, total, label)
         # Progress = daemon liveness; push the force-dismiss deadline out.
         if self._busy_timeout_timer.isActive():
             self._busy_timeout_timer.start()
         self._overlay_shown = True
-        overlay_msg = f"{name}: {label}"
+        # Latched: a later step of another component must not clear it.
+        self._restart_pending |= name == "BlocksScreen" and step == total
+        overlay_msg = (
+            f"Installing {name}: {label}" if self._provisioning else f"{name}: {label}"
+        )
         self._progress_label.setText(f"Step {step}/{total}")
         self.call_load_panel.emit(True, overlay_msg, False)
 
@@ -476,7 +541,7 @@ def handle_daemon_unavailable(self) -> None:
         self._cancel_btn.hide()
         self.show_loading(False)
         self._show_toast(
-            "Updater unavailable. Check system logs or restart BlocksScreen.",
+            "Updater unavailable, retrying ...",
             success=False,
         )
         self.update_all_btn.setEnabled(False)
@@ -598,7 +663,6 @@ def _setup_ui(self) -> None:
         self._progress_label.setWordWrap(True)
         self._progress_label.hide()
 
-        # Touch target size: minimum 44×44 px per WCAG; set to 60px tall for comfort
         self._cancel_btn = BlocksCustomButton(self._loadwidget)
         self._cancel_btn.setMinimumSize(QtCore.QSize(240, 60))
         self._cancel_btn.setMaximumSize(QtCore.QSize(320, 60))