desktop: record how the previous run ended, and which webview loaded

Two additions to the Linux startup log, both passive — no behaviour change,
no new UI, nothing the user has to opt into.

A desktop app cannot log its own segfault, so a crash report has no way to say
whether the last session died or was simply quit, and the journal shows the
same thing either way: a process that stopped. A marker file carrying the
running PID closes that gap. Still present at the next start, naming a process
that is gone, means the previous run crashed or was force-quit.

The PID is what makes it trustworthy. A marker naming a live process means a
second instance is open, not that anything crashed, and a shutdown only clears
a marker it owns — otherwise quitting one window would erase another's, and
every second instance would be reported as a crash.

Also log the webview library actually mapped into the process. Which rendering
bugs apply depends on the WebKitGTK build, and the package manager's answer is
not necessarily the library that got loaded. The lookup already exists for the
diagnostics snapshot; this exposes it early enough for the startup log, so it
lands in the journal excerpt users paste into bug reports.

Claude-Session: https://claude.ai/code/session_01KEyZgyPtfpXdbWqPPsTXZe

Author: hisco

cmd/desktop/app.go

@@ -118,6 +118,7 @@ func (a *DesktopApp) beforeClose(ctx context.Context) bool {
 // shutdown is called when the application is shutting down.
 func (a *DesktopApp) shutdown(ctx context.Context) {
 	stopNativeMouseMonitor()
+	markSessionEnd()
 	log.Println("Desktop app shutting down...")
 	app.Shutdown(a.srv)
 }

cmd/desktop/boot_env_linux.go

@@ -18,6 +18,11 @@ import (
 // are also served in the diagnostics snapshot — see internal/desktopenv.
 func logBootEnv() {
 	log.Printf("[desktop] session: %s", joinEnv(desktopenv.SessionKeys, true))
+	// The webview build decides which rendering bugs apply, and the package
+	// manager's answer is not necessarily the library that got loaded.
+	if lib := desktopenv.WebviewLibrary(); lib != "" {
+		log.Printf("[desktop] webview: %s", lib)
+	}
 	if s := joinEnv(desktopenv.OverrideKeys, false); s != "" {
 		log.Printf("[desktop] render overrides: %s", s)
 	}

cmd/desktop/main.go

@@ -87,6 +87,11 @@ func main() {
 	// No-op on macOS/Windows.
 	logBootEnv()
 
+	// Record this run and report how the last one ended. The app cannot log
+	// its own crash, so without this a report cannot say whether the previous
+	// session died or was quit.
+	markSessionStart()
+
 	// Disable WebKit's DMABUF renderer on Linux unless the user opts in —
 	// it produces blank windows on Wayland+KDE/NVIDIA and upstream won't fix.
 	// Must run before Wails initializes WebKit.

cmd/desktop/process_unix.go

@@ -0,0 +1,21 @@
+//go:build !windows
+
+package main
+
+import (
+	"errors"
+	"os"
+	"syscall"
+)
+
+// processAlive reports whether pid names a running process. On Unix
+// os.FindProcess never fails, so liveness has to be probed with signal 0.
+// EPERM means the process exists but belongs to someone else.
+func processAlive(pid int) bool {
+	proc, err := os.FindProcess(pid)
+	if err != nil {
+		return false
+	}
+	err = proc.Signal(syscall.Signal(0))
+	return err == nil || errors.Is(err, syscall.EPERM)
+}

cmd/desktop/process_windows.go

@@ -0,0 +1,15 @@
+package main
+
+import "os"
+
+// processAlive reports whether pid names a running process. On Windows
+// os.FindProcess opens a real handle, so its error already answers the
+// question and signal probing is unavailable.
+func processAlive(pid int) bool {
+	proc, err := os.FindProcess(pid)
+	if err != nil {
+		return false
+	}
+	_ = proc.Release()
+	return true
+}

cmd/desktop/session_marker.go

@@ -0,0 +1,80 @@
+package main
+
+import (
+	"log"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// The desktop app cannot log its own segfault, so a bug report has no way to
+// say whether the last run crashed or the user simply quit. A marker file
+// carrying the running PID closes that gap: still present at the next start,
+// naming a process that is gone, means the previous run died.
+func sessionMarkerPath() string {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return ""
+	}
+	return filepath.Join(home, ".radar", "desktop-session")
+}
+
+func markSessionStart() { claimSession(sessionMarkerPath()) }
+func markSessionEnd()   { releaseSession(sessionMarkerPath()) }
+
+// claimSession reports how the previous run ended and records this one. A
+// marker naming a live process means a second instance is running, which says
+// nothing about how the last one ended — reporting a crash there would be a
+// lie every time someone opens two windows.
+func claimSession(path string) {
+	if path == "" {
+		return
+	}
+
+	if pid, ok := readSessionMarker(path); ok {
+		switch {
+		case pid == os.Getpid():
+			// Same PID reused after an unclean exit; nothing to distinguish.
+		case processAlive(pid):
+			log.Printf("[desktop] another instance is already running (pid %d)", pid)
+		default:
+			log.Printf("[desktop] previous run (pid %d) did not exit cleanly — it crashed or was force-quit", pid)
+		}
+	}
+
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		log.Printf("[desktop] could not record session marker: %v", err)
+		return
+	}
+	if err := os.WriteFile(path, []byte(strconv.Itoa(os.Getpid())), 0o644); err != nil {
+		log.Printf("[desktop] could not record session marker: %v", err)
+	}
+}
+
+// releaseSession clears the marker on a graceful shutdown so the next start
+// does not report a crash that never happened. A marker owned by a different
+// PID belongs to another instance and is left alone.
+func releaseSession(path string) {
+	if path == "" {
+		return
+	}
+	if pid, ok := readSessionMarker(path); ok && pid != os.Getpid() {
+		return
+	}
+	if err := os.Remove(path); err != nil && !os.IsNotExist(err) {
+		log.Printf("[desktop] could not clear session marker: %v", err)
+	}
+}
+
+func readSessionMarker(path string) (int, bool) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return 0, false
+	}
+	pid, err := strconv.Atoi(strings.TrimSpace(string(data)))
+	if err != nil || pid <= 0 {
+		return 0, false
+	}
+	return pid, true
+}

cmd/desktop/session_marker_test.go

@@ -0,0 +1,167 @@
+package main
+
+import (
+	"bytes"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func captureLog(t *testing.T, fn func()) string {
+	t.Helper()
+	var buf bytes.Buffer
+	flags := log.Flags()
+	log.SetOutput(&buf)
+	log.SetFlags(0)
+	t.Cleanup(func() {
+		log.SetOutput(os.Stderr)
+		log.SetFlags(flags)
+	})
+	fn()
+	return buf.String()
+}
+
+func markerPath(t *testing.T) string {
+	t.Helper()
+	return filepath.Join(t.TempDir(), ".radar", "desktop-session")
+}
+
+// deadPID returns a PID that has certainly exited. Picking an arbitrary high
+// number risks colliding with a live process on a busy machine.
+func deadPID(t *testing.T) int {
+	t.Helper()
+	cmd := exec.Command("go", "version")
+	if err := cmd.Start(); err != nil {
+		t.Skipf("cannot spawn a throwaway process: %v", err)
+	}
+	pid := cmd.Process.Pid
+	_ = cmd.Wait()
+	return pid
+}
+
+func writeMarker(t *testing.T, path string, pid int) {
+	t.Helper()
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatalf("prepare marker dir: %v", err)
+	}
+	if err := os.WriteFile(path, []byte(strconv.Itoa(pid)), 0o644); err != nil {
+		t.Fatalf("write marker: %v", err)
+	}
+}
+
+func TestClaimSessionReportsUncleanExit(t *testing.T) {
+	path := markerPath(t)
+	writeMarker(t, path, deadPID(t))
+
+	out := captureLog(t, func() { claimSession(path) })
+
+	if !strings.Contains(out, "did not exit cleanly") {
+		t.Errorf("log = %q, want an unclean-exit report", out)
+	}
+	if pid, ok := readSessionMarker(path); !ok || pid != os.Getpid() {
+		t.Errorf("marker pid = %d (ok=%v), want this process %d", pid, ok, os.Getpid())
+	}
+}
+
+// A live PID means a second window is open, not that anything crashed.
+// Reporting a crash here would fire every time someone runs two instances.
+func TestClaimSessionDoesNotBlameALiveInstance(t *testing.T) {
+	path := markerPath(t)
+	cmd := exec.Command("sleep", "30")
+	if err := cmd.Start(); err != nil {
+		t.Skipf("cannot spawn a helper process: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = cmd.Process.Kill()
+		_ = cmd.Wait()
+	})
+	writeMarker(t, path, cmd.Process.Pid)
+
+	out := captureLog(t, func() { claimSession(path) })
+
+	if strings.Contains(out, "did not exit cleanly") {
+		t.Errorf("log = %q, want no crash claim while another instance runs", out)
+	}
+	if !strings.Contains(out, "another instance") {
+		t.Errorf("log = %q, want the concurrent instance reported", out)
+	}
+}
+
+func TestClaimSessionSilentOnFirstRun(t *testing.T) {
+	path := markerPath(t)
+
+	out := captureLog(t, func() { claimSession(path) })
+
+	if out != "" {
+		t.Errorf("log = %q, want silence when no previous run is recorded", out)
+	}
+	if _, ok := readSessionMarker(path); !ok {
+		t.Error("first run did not record a marker")
+	}
+}
+
+// A graceful shutdown must leave nothing behind, or every clean quit is
+// reported as a crash on the next launch.
+func TestReleaseSessionClearsOwnMarker(t *testing.T) {
+	path := markerPath(t)
+	claimSession(path)
+
+	releaseSession(path)
+
+	if _, err := os.Stat(path); !os.IsNotExist(err) {
+		t.Errorf("marker still present after shutdown (err=%v)", err)
+	}
+	out := captureLog(t, func() { claimSession(path) })
+	if strings.Contains(out, "did not exit cleanly") {
+		t.Errorf("log = %q, want a clean shutdown to leave no crash report", out)
+	}
+}
+
+// Quitting one window must not clear a marker another instance owns.
+func TestReleaseSessionLeavesAnotherInstanceMarker(t *testing.T) {
+	path := markerPath(t)
+	other := deadPID(t)
+	writeMarker(t, path, other)
+
+	releaseSession(path)
+
+	pid, ok := readSessionMarker(path)
+	if !ok || pid != other {
+		t.Errorf("marker pid = %d (ok=%v), want %d left untouched", pid, ok, other)
+	}
+}
+
+func TestReadSessionMarkerRejectsGarbage(t *testing.T) {
+	for _, content := range []string{"", "  ", "not-a-pid", "-1", "0"} {
+		path := markerPath(t)
+		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+			t.Fatalf("prepare marker dir: %v", err)
+		}
+		if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+			t.Fatalf("write marker: %v", err)
+		}
+		if pid, ok := readSessionMarker(path); ok {
+			t.Errorf("readSessionMarker(%q) = %d, true; want not ok", content, pid)
+		}
+	}
+}
+
+func TestSessionHelpersTolerateNoHomeDirectory(t *testing.T) {
+	// sessionMarkerPath returns "" when the home directory is unknown; the
+	// helpers must degrade to doing nothing rather than panicking.
+	claimSession("")
+	releaseSession("")
+}
+
+func TestProcessAliveOnSelf(t *testing.T) {
+	if !processAlive(os.Getpid()) {
+		t.Error("processAlive(self) = false, want true")
+	}
+	if processAlive(deadPID(t)) {
+		t.Error("processAlive(exited process) = true, want false")
+	}
+}

internal/desktopenv/desktopenv.go

@@ -62,3 +62,8 @@ func GPUPolicy() string {
 // Collect returns the current environment, or nil on platforms where none of
 // this applies.
 func Collect() *Snapshot { return collect() }
+
+// WebviewLibrary returns the webview library mapped into this process, or ""
+// where that cannot be determined. Exposed separately from Collect so startup
+// logging can name the build before anything else has run.
+func WebviewLibrary() string { return webviewLibrary() }

internal/desktopenv/desktopenv_linux.go

@@ -16,7 +16,7 @@ func collect() *Snapshot {
 		DisplayServer:      displayServer(),
 		RenderOverrides:    readAll(OverrideKeys),
 		Sandbox:            readSet(SandboxKeys),
-		WebKitLibrary:      webKitLibrary("/proc/self/maps"),
+		WebKitLibrary:      webviewLibrary(),
 		GPUPolicy:          GPUPolicy(),
 	}
 	return s
@@ -56,6 +56,8 @@ func readSet(keys []string) []EnvVar {
 	return out
 }
 
+func webviewLibrary() string { return webKitLibrary("/proc/self/maps") }
+
 // webKitLibrary returns the basename of the webview library mapped into this
 // process. The soname's trailing version identifies the WebKitGTK build, which
 // a bug report otherwise has no way to state. The prefix is matched loosely

internal/desktopenv/desktopenv_other.go

@@ -5,3 +5,5 @@ package desktopenv
 // collect reports nothing off Linux. macOS (WKWebView) and Windows (WebView2)
 // have no equivalent set of host render knobs to surface.
 func collect() *Snapshot { return nil }
+
+func webviewLibrary() string { return "" }