session logging, build-only mode, park splash, boot logo spinner

- Per-process stderr logging to /data/log2/{session}/ with time-safe
  directory naming (boot-xxx renamed once GPS/NTP sets clock)
- Aggregate session.log with major events (start/stop, transitions)
- 30-day log rotation cleanup on manager startup
- build_only.sh: compile without starting manager, non-blocking error
  display, kills stale processes
- build.py: copies updated spinner binary after successful build
- Onroad park mode: show splash screen when car is on but in park,
  switch to camera view when shifted to drive, honor screen on/off
- Spinner: full-screen boot logo background from /usr/comma/bg.jpg
  with white progress bar overlay
- Boot logo: auto-regenerate when boot_logo.png changes, 140% scale
- launch_openpilot.sh: cd to /data/openpilot for reliable execution
- launch_chffrplus.sh: kill stale text error displays on startup
- spinner shell wrapper: prefer freshly built _spinner over prebuilt

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

selfdrive/manager/build.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 import os
+import sys
 import subprocess
 from pathlib import Path
 
@@ -54,6 +55,14 @@ def build(spinner: Spinner, dirty: bool = False, minimal: bool = False) -> None:
 
     if scons.returncode == 0:
       Path('/data/openpilot/prebuilt').touch()
+
+      # CLEARPILOT: update prebuilt spinner if the new build is newer
+      new_spinner = Path(BASEDIR) / "selfdrive/ui/_spinner"
+      old_spinner = Path(BASEDIR) / "selfdrive/ui/qt/spinner"
+      if new_spinner.exists() and (not old_spinner.exists() or new_spinner.stat().st_mtime > old_spinner.stat().st_mtime):
+        import shutil
+        shutil.copy2(str(new_spinner), str(old_spinner))
+
       break
 
   if scons.returncode != 0:
@@ -69,8 +78,13 @@ def build(spinner: Spinner, dirty: bool = False, minimal: bool = False) -> None:
     # Show TextWindow
     spinner.close()
     if not os.getenv("CI"):
-      with TextWindow("openpilot failed to build\n \n" + error_s) as t:
+      # CLEARPILOT: BUILD_ONLY mode shows error on screen but doesn't block
+      t = TextWindow("openpilot failed to build\n \n" + error_s)
+      if os.getenv("BUILD_ONLY"):
+        print(error_s, file=sys.stderr)
+      else:
         t.wait_for_exit()
+        t.close()
     exit(1)
 
   # enforce max cache size

selfdrive/manager/manager.py

@@ -16,7 +16,7 @@ from openpilot.common.text_window import TextWindow
 from openpilot.common.time import system_time_valid
 from openpilot.system.hardware import HARDWARE, PC
 from openpilot.selfdrive.manager.helpers import unblock_stdout, write_onroad_params, save_bootlog
-from openpilot.selfdrive.manager.process import ensure_running
+from openpilot.selfdrive.manager.process import ensure_running, update_log_dir_timestamp, session_log
 from openpilot.selfdrive.manager.process_config import managed_processes
 from openpilot.selfdrive.athena.registration import register, UNREGISTERED_DONGLE_ID
 from openpilot.common.swaglog import cloudlog, add_file_handler
@@ -51,7 +51,26 @@ def frogpilot_boot_functions(frogpilot_functions):
   except Exception as e:
     print(f"An unexpected error occurred: {e}")
 
+def cleanup_old_logs(max_age_days=30):
+  """CLEARPILOT: delete session log directories older than max_age_days."""
+  import shutil
+  log_base = "/data/log2"
+  if not os.path.exists(log_base):
+    return
+  cutoff = time.time() - (max_age_days * 86400)
+  for entry in os.listdir(log_base):
+    path = os.path.join(log_base, entry)
+    if os.path.isdir(path):
+      if os.path.getmtime(path) < cutoff:
+        try:
+          shutil.rmtree(path)
+        except OSError:
+          pass
+
+
 def manager_init(frogpilot_functions) -> None:
+  cleanup_old_logs()
+
   frogpilot_boot = threading.Thread(target=frogpilot_boot_functions, args=(frogpilot_functions,))
   frogpilot_boot.start()
 
@@ -367,6 +386,7 @@ def manager_thread(frogpilot_functions) -> None:
   cloudlog.bind(daemon="manager")
   cloudlog.info("manager start")
   cloudlog.info({"environ": os.environ})
+  session_log.info("manager starting")
 
   params = Params()
   params_memory = Params("/dev/shm/params")
@@ -397,6 +417,7 @@ def manager_thread(frogpilot_functions) -> None:
 
     if started and not started_prev:
       params.clear_all(ParamKeyType.CLEAR_ON_ONROAD_TRANSITION)
+      session_log.info("onroad transition")
 
       if openpilot_crashed:
         os.remove(os.path.join(sentry.CRASHES_DIR, 'error.txt'))
@@ -404,6 +425,7 @@ def manager_thread(frogpilot_functions) -> None:
     elif not started and started_prev:
       params.clear_all(ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION)
       params_memory.clear_all(ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION)
+      session_log.info("offroad transition")
 
     # update onroad params, which drives boardd's safety setter thread
     if started != started_prev:
@@ -413,6 +435,9 @@ def manager_thread(frogpilot_functions) -> None:
 
     ensure_running(managed_processes.values(), started, params=params, CP=sm['carParams'], not_run=ignore)
 
+    # CLEARPILOT: rename log directory once system time is valid
+    update_log_dir_timestamp()
+
     running = ' '.join("{}{}\u001b[0m".format("\u001b[32m" if p.proc.is_alive() else "\u001b[31m", p.name)
                        for p in managed_processes.values() if p.proc)
     print(running)
@@ -430,6 +455,7 @@ def manager_thread(frogpilot_functions) -> None:
         shutdown = True
         params.put("LastManagerExitReason", f"{param} {datetime.datetime.now()}")
         cloudlog.warning(f"Shutting down manager - {param} set")
+        session_log.info("manager shutting down: %s", param)
 
     if shutdown:
       break
@@ -481,6 +507,7 @@ if __name__ == "__main__":
   except Exception:
     add_file_handler(cloudlog)
     cloudlog.exception("Manager failed to start")
+    session_log.critical("manager failed to start: %s", traceback.format_exc())
 
     try:
       managed_processes['ui'].stop()

selfdrive/manager/process.py

@@ -2,6 +2,7 @@ import importlib
 import os
 import signal
 import struct
+import sys
 import datetime
 import time
 import subprocess
@@ -17,17 +18,62 @@ import openpilot.selfdrive.sentry as sentry
 from openpilot.common.basedir import BASEDIR
 from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
+from openpilot.common.time import system_time_valid
 
 WATCHDOG_FN = "/dev/shm/wd_"
 ENABLE_WATCHDOG = os.getenv("NO_WATCHDOG") is None
 
-timestamp = datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
-_log_dir = f"/data/log2/{timestamp}"
+# CLEARPILOT: time-safe log directory — use temporary name if clock is invalid (1970),
+# rename to real timestamp once GPS/NTP resolves the time
+if system_time_valid():
+  _log_dir = f"/data/log2/{datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S')}"
+  _time_resolved = True
+else:
+  _log_dir = f"/data/log2/boot-{int(time.monotonic())}"
+  _time_resolved = False
 os.makedirs(_log_dir, exist_ok=True)
 
+# CLEARPILOT: aggregate session log for major events
+import logging
+session_log = logging.getLogger("clearpilot.session")
+session_log.setLevel(logging.DEBUG)
+_session_handler = logging.FileHandler(os.path.join(_log_dir, "session.log"))
+_session_handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
+session_log.addHandler(_session_handler)
 
 
-def launcher(proc: str, name: str) -> None:
+def update_log_dir_timestamp():
+  """Rename boot-xxx log dir to real timestamp once system time is valid."""
+  global _log_dir, _time_resolved, _session_handler
+  if _time_resolved:
+    return
+  if not system_time_valid():
+    return
+  new_dir = f"/data/log2/{datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S')}"
+  try:
+    os.rename(_log_dir, new_dir)
+    _log_dir = new_dir
+    _time_resolved = True
+    # Re-point session log handler to renamed directory
+    session_log.removeHandler(_session_handler)
+    _session_handler.close()
+    _session_handler = logging.FileHandler(os.path.join(_log_dir, "session.log"))
+    _session_handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
+    session_log.addHandler(_session_handler)
+    session_log.info("log directory renamed to %s", _log_dir)
+  except OSError:
+    pass
+
+
+
+def launcher(proc: str, name: str, log_path: str) -> None:
+  # CLEARPILOT: redirect stderr to per-process log file
+  try:
+    log_file = open(log_path, 'a')
+    os.dup2(log_file.fileno(), sys.stderr.fileno())
+  except Exception:
+    pass
+
   try:
     # import the process
     mod = importlib.import_module(proc)
@@ -53,9 +99,16 @@ def launcher(proc: str, name: str) -> None:
     raise
 
 
-def nativelauncher(pargs: list[str], cwd: str, name: str) -> None:
+def nativelauncher(pargs: list[str], cwd: str, name: str, log_path: str) -> None:
   os.environ['MANAGER_DAEMON'] = name
 
+  # CLEARPILOT: redirect stderr to per-process log file
+  try:
+    log_file = open(log_path, 'a')
+    os.dup2(log_file.fileno(), sys.stderr.fileno())
+  except Exception:
+    pass
+
   # exec the process
   os.chdir(cwd)
   os.execvp(pargs[0], pargs)
@@ -110,6 +163,7 @@ class ManagerProcess(ABC):
     if dt > self.watchdog_max_dt:
       if (self.watchdog_seen or self.always_watchdog and self.proc.exitcode is not None) and ENABLE_WATCHDOG:
         cloudlog.error(f"Watchdog timeout for {self.name} (exitcode {self.proc.exitcode}) restarting ({started=})")
+        session_log.warning("watchdog timeout for %s (exitcode %s), restarting", self.name, self.proc.exitcode)
         self.restart()
     else:
       self.watchdog_seen = True
@@ -139,6 +193,10 @@ class ManagerProcess(ABC):
 
     ret = self.proc.exitcode
     cloudlog.info(f"{self.name} is dead with {ret}")
+    if ret is not None and ret != 0:
+      session_log.error("process %s died with exit code %s", self.name, ret)
+    elif ret == 0:
+      session_log.info("process %s stopped (exit 0)", self.name)
 
     if self.proc.exitcode is not None:
       self.shutting_down = False
@@ -200,7 +258,8 @@ class NativeProcess(ManagerProcess):
 
     cwd = os.path.join(BASEDIR, self.cwd)
     cloudlog.info(f"starting process {self.name}")
-    self.proc = Process(name=self.name, target=self.launcher, args=(self.cmdline, cwd, self.name))
+    session_log.info("starting %s", self.name)
+    self.proc = Process(name=self.name, target=self.launcher, args=(self.cmdline, cwd, self.name, log_path))
     self.proc.start()
     self.watchdog_seen = False
     self.shutting_down = False
@@ -232,7 +291,8 @@ class PythonProcess(ManagerProcess):
     global _log_dir
     log_path = _log_dir+"/"+self.name+".log"
     cloudlog.info(f"starting python {self.module}")
-    self.proc = Process(name=self.name, target=self.launcher, args=(self.module, self.name))
+    session_log.info("starting %s", self.name)
+    self.proc = Process(name=self.name, target=self.launcher, args=(self.module, self.name, log_path))
     self.proc.start()
     self.watchdog_seen = False
     self.shutting_down = False
@@ -276,6 +336,7 @@ class DaemonProcess(ManagerProcess):
         pass
 
     cloudlog.info(f"starting daemon {self.name}")
+    session_log.info("starting daemon %s", self.name)
     proc = subprocess.Popen(['python', '-m', self.module],
                                stdin=open('/dev/null'),
                                stdout=open(log_path, 'a'),

selfdrive/ui/qt/home.cc

@@ -61,19 +61,42 @@ void HomeWindow::showSidebar(bool show) {
 }
 
 void HomeWindow::updateState(const UIState &s) {
-  // const SubMaster &sm = *(s.sm);
   if (s.scene.started) {
     showDriverView(s.scene.driver_camera_timer >= 10, true);
+
+    // CLEARPILOT: show splash screen when onroad but in park
+    bool parked = s.scene.parked;
+    if (parked && !was_parked_onroad) {
+      // just shifted into park — show splash
+      slayout->setCurrentWidget(ready);
+    } else if (!parked && was_parked_onroad) {
+      // just shifted out of park — show onroad camera
+      slayout->setCurrentWidget(onroad);
+    }
+    was_parked_onroad = parked;
+
+    // CLEARPILOT: honor display on/off while showing splash in park
+    if (parked && ready->isVisible()) {
+      int screenMode = paramsMemory.getInt("ScreenDisaplayMode");
+      if (screenMode == 1) {
+        Hardware::set_display_power(false);
+      } else {
+        Hardware::set_display_power(true);
+      }
+    }
   }
 }
 
 void HomeWindow::offroadTransition(bool offroad) {
+  sidebar->setVisible(false);
   if (offroad) {
-    sidebar->setVisible(false);
+    was_parked_onroad = false;
     slayout->setCurrentWidget(ready);
   } else {
-    sidebar->setVisible(false);
-    slayout->setCurrentWidget(onroad);
+    // CLEARPILOT: start onroad in splash — updateState will switch to
+    // camera view once the car shifts out of park
+    was_parked_onroad = true;
+    slayout->setCurrentWidget(ready);
   }
 }
 

selfdrive/ui/qt/home.h

@@ -56,10 +56,11 @@ private:
 
   // FrogPilot variables
   Params params;
+  Params paramsMemory{"/dev/shm/params"};
 
   // CLEARPILOT
-  // bool show_ready;
   ReadyWindow *ready;
+  bool was_parked_onroad = false;
 
 private slots:
   void updateState(const UIState &s);

selfdrive/ui/qt/spinner.cc

@@ -15,48 +15,24 @@
 #include "selfdrive/ui/qt/qt_window.h"
 #include "selfdrive/ui/qt/util.h"
 
-TrackWidget::TrackWidget(QWidget *parent) : QWidget(parent) {
-  setAttribute(Qt::WA_OpaquePaintEvent);
-  setFixedSize(spinner_size);
-
-  // pre-compute all the track imgs. make this a gif instead?
-  QPixmap comma_img = loadPixmap("../assets/img_spinner_comma.png", spinner_size);
-  QPixmap track_img = loadPixmap("../assets/img_spinner_track.png", spinner_size);
-
-  QTransform transform(1, 0, 0, 1, width() / 2, height() / 2);
-  QPixmap pm(spinner_size);
-  QPainter p(&pm);
-  p.setRenderHint(QPainter::SmoothPixmapTransform);
-  for (int i = 0; i < track_imgs.size(); ++i) {
-    p.resetTransform();
-    p.fillRect(0, 0, spinner_size.width(), spinner_size.height(), Qt::black);
-    p.drawPixmap(0, 0, comma_img);
-    p.setTransform(transform.rotate(360 / spinner_fps));
-    p.drawPixmap(-width() / 2, -height() / 2, track_img);
-    track_imgs[i] = pm.copy();
-  }
-
-  m_anim.setDuration(1000);
-  m_anim.setStartValue(0);
-  m_anim.setEndValue(int(track_imgs.size() -1));
-  m_anim.setLoopCount(-1);
-  m_anim.start();
-  connect(&m_anim, SIGNAL(valueChanged(QVariant)), SLOT(update()));
-}
-
-void TrackWidget::paintEvent(QPaintEvent *event) {
-  QPainter painter(this);
-  painter.drawPixmap(0, 0, track_imgs[m_anim.currentValue().toInt()]);
-}
-
-// Spinner
+// CLEARPILOT: full-screen boot logo background with progress bar overlay
 
 Spinner::Spinner(QWidget *parent) : QWidget(parent) {
+  // Load boot logo as full-screen background, rotated 90° CCW
+  // (bg.jpg is pre-rotated 90° CW for the raw framebuffer)
+  QPixmap boot_logo("/usr/comma/bg.jpg");
+  if (!boot_logo.isNull()) {
+    QTransform rot;
+    rot.rotate(-90);
+    bg_img = boot_logo.transformed(rot);
+  }
+
   QGridLayout *main_layout = new QGridLayout(this);
   main_layout->setSpacing(0);
-  main_layout->setMargin(200);
+  main_layout->setMargin(0);
 
-  main_layout->addWidget(new TrackWidget(this), 0, 0, Qt::AlignHCenter | Qt::AlignVCenter);
+  // Spacer to push progress bar toward bottom
+  main_layout->setRowStretch(0, 1);
 
   text = new QLabel();
   text->setWordWrap(true);
@@ -69,7 +45,10 @@ Spinner::Spinner(QWidget *parent) : QWidget(parent) {
   progress_bar->setTextVisible(false);
   progress_bar->setVisible(false);
   progress_bar->setFixedHeight(20);
-  main_layout->addWidget(progress_bar, 1, 0, Qt::AlignHCenter);
+  main_layout->addWidget(progress_bar, 2, 0, Qt::AlignHCenter | Qt::AlignBottom);
+
+  // Bottom margin for progress bar
+  main_layout->setContentsMargins(0, 0, 0, 80);
 
   setStyleSheet(R"(
     Spinner {
@@ -88,7 +67,7 @@ Spinner::Spinner(QWidget *parent) : QWidget(parent) {
     }
     QProgressBar::chunk {
       border-radius: 10px;
-      background-color: rgba(23, 134, 68, 255);
+      background-color: white;
     }
   )");
 
@@ -96,6 +75,17 @@ Spinner::Spinner(QWidget *parent) : QWidget(parent) {
   QObject::connect(notifier, &QSocketNotifier::activated, this, &Spinner::update);
 }
 
+void Spinner::paintEvent(QPaintEvent *event) {
+  QPainter p(this);
+  p.fillRect(rect(), Qt::black);
+  if (!bg_img.isNull()) {
+    QPixmap scaled = bg_img.scaled(size(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
+    int x = (width() - scaled.width()) / 2;
+    int y = (height() - scaled.height()) / 2;
+    p.drawPixmap(x, y, scaled);
+  }
+}
+
 void Spinner::update(int n) {
   std::string line;
   std::getline(std::cin, line);

selfdrive/ui/qt/spinner.h

@@ -1,36 +1,23 @@
-#include <array>
-
 #include <QLabel>
 #include <QPixmap>
 #include <QProgressBar>
 #include <QSocketNotifier>
-#include <QVariantAnimation>
 #include <QWidget>
 
-constexpr int spinner_fps = 30;
-constexpr QSize spinner_size = QSize(360, 360);
-
-class TrackWidget : public QWidget  {
-  Q_OBJECT
-public:
-  TrackWidget(QWidget *parent = nullptr);
-
-private:
-  void paintEvent(QPaintEvent *event) override;
-  std::array<QPixmap, spinner_fps> track_imgs;
-  QVariantAnimation m_anim;
-};
-
 class Spinner : public QWidget {
   Q_OBJECT
 
 public:
   explicit Spinner(QWidget *parent = 0);
 
+protected:
+  void paintEvent(QPaintEvent *event) override;
+
 private:
   QLabel *text;
   QProgressBar *progress_bar;
   QSocketNotifier *notifier;
+  QPixmap bg_img;
 
 public slots:
   void update(int n);

selfdrive/ui/spinner

@@ -1,5 +1,10 @@
 #!/bin/sh
 
+# CLEARPILOT: prefer freshly built _spinner over prebuilt qt/spinner
+if [ -f ./_spinner ]; then
+  exec ./_spinner "$1"
+fi
+
 if [ -f /TICI ] && [ ! -f qt/spinner ]; then
   cp qt/spinner_larch64 qt/spinner
 fi