feat(host): a window right after a crash says what happened, with a Report button that copies a redacted report and opens the issue form #593
No reviewers
Labels
No labels
area/accessibility
area/audio
area/input
area/install
area/menu
area/renderer
area/saves
area/upscaling
beanstalk: approved @ 1697603
beanstalk: approved @ 2c5a62e
beanstalk: approved @ 4fd82b7
beanstalk: approved @ 64d6d09
beanstalk: approved @ 6f91fae
beanstalk: approved @ 70a78f9
beanstalk: approved @ 8d361dc
beanstalk: approved @ 9d8356e
beanstalk: approved @ abf2227
beanstalk: approved @ d82f202
beanstalk: approved @ e5f1e40
beanstalk: approved @ ee8ab5f
ci: approved
good first issue
gpu/amd
gpu/igpu
gpu/intel
gpu/nvidia
help wanted
kind
bug
kind
chore
kind
docs
kind
feature
kind
performance
kind
question
needs measurements
platform/linux
platform/macos
platform/steam-deck
platform/windows
preview
priority
critical
priority
high
priority
low
regression
status
blocked
status
confirmed
status
duplicate
status
invalid
status
needs-info
status
wontfix
testing wanted
ci: approved
No milestone
No project
No assignees
1 participant
Notifications
Due date
No due date set.
Dependencies
No dependencies set
Reference
MagicBeanDev/Longshot!593
Loading…
Reference in a new issue
No description provided.
Delete branch "HumanBean/Longshot:feat/crash-dialog"
Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?
Type: feat · Risk: medium · Tested on: nothing built or run (game-free checks written, not run here) · Needs: Windows and Linux, any GPU
Why
When Longshot crashes, at the start or in play, the window just disappears: players don't know what happened, whether to update a driver, or where the log is, and a report needs several manual steps. This adds a clear window right after the crash, with a Report button that copies a redacted report and opens the issue form (the owner's request, option 1: a watcher process started with the game, not a window from inside the crash handler).
See #44 (local problem reports; its "the game would still send nothing and open no browser" is relaxed by the owner for this button only: the browser opens only when the player clicks Report, and the game sends nothing).
What changed
The game starts a small helper of itself early (
longshot --crash-watch <pid> <run id> <game folder> <log>), which waits for the game to end and then decides from the crash records and the log whether to show "Longshot closed unexpectedly" (or "Longshot couldn't start"), when, and why where known. Report builds a plain-text report without anything private, puts it on the clipboard, saves it beside the crash records and opens the game-problem form; a crash record no helper showed is shown once at the next start.host/hos_crash_dialog.h(new): the parts that decide, plain C for the checks: the helper's command line (hos_crash_args), which starts get a helper (hos_crash_watch_wanted), Windows argument quoting (hos_crash_quote_arg), the log's facts (hos_crash_log_line,hos_crash_stage,hos_crash_start_failed), the record (hos_crash_record_parse), was it a crash (hos_crash_verdict), the cause (hos_crash_cause) and the window's text, the menu's log redaction and value rule in C (hos_crash_redact_line,hos_crash_value_shown), the issue link (hos_crash_issue_url), and which record a start shows (hos_crash_show_at_start).host/hos_crash_dialog.c(new):hos_crash_helper_main(main's first call: the helper never starts any of the game),hos_crash_watch_start(spawns the helper; WindowsCreateProcessWwithCREATE_NO_WINDOW, no inherited handles, out of the launcher's job where allowed,AllowSetForegroundWindow; Linuxposix_spawnof/proc/self/exewith stdio on/dev/null, and the helper closes any other fd it inherited), the wait (Windows: process handle + exit code; Linux: pidfd, else the parent changing; a Linux restart's new run's marker ends the old helper), the window (SDL3/SDL2'sSDL_ShowMessageBoxloaded by the helper itself,MessageBoxWfallback on Windows), the clipboard (Windows' own; Linuxwl-copyon Wayland, elsexclip/xsel, which keep it after the helper ends, SDL's X11 clipboard only as the last resort; the box after Report says whether it was copied, never claims it when nothing took it, and names the saved report, which Open the report opens), the browser and folders (ShellExecuteW;SDL_OpenURL, elsexdg-open), the report (the newest ten saved reports kept), thebug-reports/shown.txtledger (replaced whole: written beside it, then renamed), no window while Windows signs out or shuts down (it would hold that up; a crash record is then shown at the next start), no helper and no next-start box under gamescope (Steam Deck Game Mode:GAMESCOPE_WAYLAND_DISPLAY, orXDG_CURRENT_DESKTOP=gamescope) until a box there is tested, andHOS_CRASH_TEST. With no log found (the game logged to a terminal or a pipe) the window says nothing about when, instead of "during the start".host/hos_crash_record.c/.h:hos_crash_quit_asked(a "quit" note after the marker's session; recovery copies it into an unclean record asquit_asked: yes; it counts itself busy, andhos_crash_clean_endwaits for it (bounded) before closing the marker, so the note never lands on a closed or reused descriptor),hos_crash_record_run/log/dir,hos_crash_record_recover(a start's recovery for the helper, no marker of its own, sharing a newsetup()withhos_crash_record_start),hos_crash_record_marker. The crash writer's one marker write is now positional on Windows (WriteFilewith anOVERLAPPEDoffset), so it and the quit note never depend on each other's file pointer; nothing else in the handler path changed.host/rx_backend.crx_close_asked: notes the quit first, before the renderer's close that can take seconds (window close, control socket quit, Restart now all go through it).host/hos_main.c: bothmain()s hand a helper's command line over first;game_mainstarts the helper after the crash record and the run id banner (andhos_control_start), before the image, the guest, the renderer, sound and input;hos_crash_test_arm()afterreserve_guest(the crash handlers);HOS_CRASH_TESTadded to the nameslongshot_env.txtmay not set.docs/development.md"The window after a crash" (the flow, the rule table, the causes, what Report holds, the switches, how to test it);docs/common-issues.md"Still stuck?" and the README's troubleshooting paragraph (what players see and the Report button).make_game.pystale_copies: an update no longer ends the windowless crash helper of a game still open (its parent has the visible window).tests/test_crash_dialog.py(new; see Testing);tests/display_startup_failure_test.cppstands in forhos_crash_helper_main(its fixture builds the Linuxmain(), which now calls it).Was it a crash (
hos_crash_verdict, agreeing with #498's rule "a quit never counts, however the process ends after it; a crash, or a kill with no quit asked for, still counts"):cannot reserve the guest window)--prepare-shaders,HOS_HEADLESS,HOS_PGO,HOS_CRASH_WATCH=0, gamescopeCause (first that holds): game files (
cannot open,usage:,lift and image do not match, renderer version mismatch) → "Build the game again with the Longshot Launcher"; Vulkan (did not load ... nothing is drawn,load_global failed,vkCreateInstance failed,no Vulkan 1.3 GPU,create_device failed,the renderer did not start) → "Update your graphics driver: Longshot needs ... Vulkan 1.3"; the window (display: no SDL,SDL_Init,SDL_CreateWindow,... failed (error) ; memory (cannot reserve,Windows is out of memory, commit failed,0xC0000017, or an unclean end afterboot: LOW MEMORY); the graphics driver (device lost,Vulkan fatal, a crash innvoglv64/amdvlk/igvk/libvulkan_*/libnvidia-*...); an unclean end otherwise "closed from outside ... or the system stopped it"; else "An unexpected error". Stage: amap:line → "while you were playing"; preparation lines without "the shaders took" → "while it prepared the shaders"; else "during the start".Report includes: what happened and when, uptime, crash/unclean records of the last day, version and channel (from the version), GPU and driver (log
vk:lines) and the devices listed, CPU (brand string, threads), RAM, OS, what the game was built for (LONGSHOT_NATIVE_CPUor the CPU level), the log's first DLSS and FSR 4 lines,longshot_options.inisettings and switches set (a value only when a number, size or on/off; never for a name with TOKEN/KEY/ROOM/SECRET/PASS/SERVER/USER; controls' bindings left out), the run's crash record, and the last 200 log lines redacted exactly as the Insert menu's Bug report does. Never: saves, game files, the executable or caches, memory dumps, keys, the options file itself, the home folder's path or the user's name. "Crashes in a row" is not tracked by the host; the report gives the records of the last day instead.Screenshots
No real screenshot is possible (nothing built here). A text mock-up of the window (SDL's message box) after a crash in play:
After Report:
Measurements
Verdict: nothing measured yet: nothing was built or run on this PC (the owner's rule for it: its build/GPU queue is busy). What counts for a
feat(it working in the game; no cost when off) needs a tester's run, below. The helper costs one small extra process per start (the same executable, no game started in it) that waits on the game's process; withHOS_CRASH_WATCH=0none is started.Hardware: none
Scene: none
Method: none yet; the game-free checks in
tests/test_crash_dialog.pyare written for CI and testers to runHow to reproduce:
python -I -B tests/test_crash_dialog.py; in the game, the steps under Testing82886e8975d3caf4tests/test_crash_dialog.pyFlags and settings
Two switches added, and a file the game keeps (
bug-reports/shown.txt). Existing switches now also read by the helper, unchanged:HOS_HEADLESSandHOS_PGO(no helper),HOS_SDL_VERSION=2(the helper loads SDL2, as the game would).HOS_CRASH_WATCH=0off=0: no helper and no window after a crash=0only for development runsHOS_CRASH_TESTstartor<seconds>; not read fromlongshot_env.txtTesting
Tested: nothing was built or run here, and no check was run (the owner's rule for this PC). The code was read against the crash record, relaunch, close and log paths it relies on.
Not tested: everything in the game, on both systems; the game-free checks.
tests/test_crash_dialog.pychecks: the helper's command line and its refusals; which starts get a helper; Windows quoting round-tripped through CommandLineToArgvW's rules; record names and times; the log's stage, start failures, memory, device lost, GPU and driver; the verdict and cause tables above; redaction equal togpu/vk/vk_bug_report.cpp'sredactline for line (compiled beside it); the value rule; the issue link (form, its field ids in1-game-problem.yml, ≤ 2000 characters, the same form as the menu'skForm); the source wiring (helper first in both mains, started after the record and before the guest/renderer,HOS_CRASH_TESTafterreserve_guest, the quit noted first inrx_close_asked, no console/inherited handles/game stdio, the helper closing inherited fds, no window at a Windows sign-out or shutdown, the ledger replaced whole, the saved reports pruned, the quit note and the clean end never overlapping on the marker, the display start-up fixture's stand-in for the helper, no process exits in the helper); the window saying nothing about when with no log; no helper under gamescope; Linux's clipboard tools in turn and the box after Report never saying copied when nothing took it (and opening the saved file);make_game.stale_copiessparing a game's waiting helper; and on Linux the real helper (-DHOS_CRASH_DIALOG_TEST: window, clipboard and browser stood in for) against real processes: crash, kill, quit then kill, crash after quit, clean end, Vulkan missing, execve restart, no helper forHOS_HEADLESS/HOS_CRASH_WATCH=0/--prepare-shaders/HOS_PGO, a crash no helper showed shown once at the next start, and Report's text (sections present; no saves, game files, keys, home path, user name, private values; the newest ten saved reports kept). Existing checks reading changed files (tests/test_crash_record.py's exit inventory and banner order,tests/test_startup_progress.py,tests/test_env_on.py,tests/test_env_file.py,tests/test_utf8_paths.py,tests/test_driver_cache_*.py,tests/test_hle_stats.py) were read and should still hold;tests/test_display_startup_failure.pydid not (its fixture had nohos_crash_helper_main) and now has a stand-in. A code review found that and the fixes above (#593 (comment)); the Linux files were only syntax-checked (-fsyntax-only), nothing built or run.Must be tested:
python -I -B tests/run_all.py, by hand (no checks may run on the author's PC), expectingtest_crash_dialog.py,test_crash_record.pyandtest_display_startup_failure.pyto pass.HOS_CRASH_TEST=startin the environment, expecting the window "Longshot closed unexpectedly during the start." right after the game closes, no console window flashing at start; click Open the log folder (Explorer onlogs, the window again), then Report (the browser on the game-problem form with version, GPU, system and title filled in; the clipboard holds the report;bug-reports/pending/report-*.txtsaved), paste into the form and check it holds no home path, user name, saves or keys (by hand).HOS_CRASH_TEST=60, load a save within the minute, expecting "while you were playing"; end the game from Task Manager, expecting "ended without a crash report"; a normal quit and the Insert menu's Restart now, expecting no window (by hand).kill -9 <pid>for the unclean end, expecting the window each time; Report, then paste in the browser, expecting the whole report; a quit, Restart now, and closing the window twice while the shaders are prepared, expecting no window. (Wayland done on KDE with a stand-in game: see the comment with the picture.)Risks
What could break: an extra process per start: a launcher that counts child processes (Steam's reaper on Linux) sees it until the game ends, longer only while the window is open; a false window on an end that is no crash (an unclean end from a logout or a launcher's Stop where the helper survives); on Linux without
wl-copy,xcliporxselinstalled (and, on Wayland, no X11 fallback) nothing takes the text: the box then says so, names the saved report and opens it; on the Steam Deck's Game Mode the window is off (gamescope may not show a child process's box) until a Deck tester shows it works; on Windows the box may come up behind other windows once the game's is gone (a Windows tester wanted);nx2/make_game.pystill ends a windowless helper whose game is gone (as any stray copy) during an update; on Linux, after a Restart now, the old helper is a zombie of the new run until the game exits (one per restart, harmless);SDL_ShowMessageBoxis called before anySDL_Init, as SDL documents, and on Linux the second box runs on a thread while the main thread pumps SDL's events only when SDL's X11 clipboard is the fallback used. The crash writer's change on Windows is one positionalWriteFilein place of a seek and a write.Turning it off:
HOS_CRASH_WATCH=0, or revert the commit.Compatibility: nothing changes for saves,
longshot_options.ini, the shader and pipeline caches, the vk ABI (MkwVkHost/MkwVkRendereruntouched,MKWVK_API_VERSIONnot bumped) or the builder's tools. Unclean records can carry a newquit_asked: yesline. The game folder gainsbug-reports/shown.txtand, after a Report,bug-reports/pending/report-*.txt. The first start with this window lists the records already pending as shown, so no old crash pops up.Issues
See #44
Checklist
Everyone
type(scope): description) of the status line's type.main.python -I -B tests/run_all.pypasses (any failure that also fails onmainis named). (not run: no checks may run on this PC; for CI or a tester)third_party/untouched (a new folder with aPROVENANCE.mdinstead).When it applies
Assisted-by:/Co-Authored-By:trailers.🤖 Generated with Claude Code
Flags and settings: named the existing switches the helper also reads (HOS_HEADLESS, HOS_PGO, HOS_SDL_VERSION). Stays WIP: nothing built or run yet; needs CI and testers on Windows and Linux.
Code review by reading (nothing built or run; the Linux helper's files compiled with
-fsyntax-onlyonly for the fixes).Checked and fine: the crash path is unchanged apart from the Windows marker write, and that write is right: a positional
WriteFilewith anOVERLAPPEDoffset on a synchronous handle writes at that offset whatever the file pointer is,record_complete(insideSession) and the quit note (atsizeof(Session)) never overlap, neither touches the locked byte 0, and recovery reads the note with its own handle. Nothing new runs in a signal or exception handler. Quoting (trailing backslashes, quotes, spaces, UTF-8 to wide), no inherited handles,CREATE_NO_WINDOW, the breakaway retry,/proc/self/exewith stdio on/dev/null, the pidfd and parent fallbacks, the run-id-keyed record and log lookups (two games in one folder, rotated logs, an old record), the quit-during-precompile path (mkwvk_close_askedlets the start finish, so no "could not start" line is logged),--prepare-shaders/HOS_HEADLESS/HOS_PGO, the redaction (the menu's own), the value rule, the link's encoding and length,MKWVK_API_VERSION(vk_api.h untouched),third_party/, noCP_ACP, and the cut-outs intest_crash_record.py,test_env_on.py,test_env_file.py,test_utf8_paths.py,test_startup_progress.py,test_driver_cache_*.pyandtest_hle_stats.py.Found (inline):
tests/test_display_startup_failure.pycuts the Linuxmain()into a C++ fixture that has nohos_crash_helper_main, so it no longer links.hos_crash_clean_endis closing at the same moment (control-socket quit on one thread, window close on another). On Linux a reused fd would getquit\nwritten into another file.--crash-showwhose log has rotated past.1), the window says "during the start" even for a crash in play.bug-reports/pending/report-*.txtfiles are never pruned (prune_pendingonly takescrash-/unclean-).shown.txtis rewritten in place. A start that reads it mid-write sees an empty ledger and shows a crash again.Needs a build or a tester: whether the SDL box comes to the front on Windows once the game's window is gone; whether gamescope (Steam Deck Game Mode) shows a child process's box at all (if not, the helper waits on an invisible box and Steam shows the game as still running); whether the Wayland clipboard takes the text (SDL3 can report success when it doesn't);
nx2/make_game.pyends windowlesslongshot.execopies in the folder during a build, which would end a waiting helper with a "copy left running" message; whether the launcher counts the helper as the game while the window is open.Fixes for 1 to 8 follow on the branch, with checks.
@ -0,0 +306,4 @@Keep k = {&out, all || !old ? NULL : old}; /* (no ledger yet: what was pending is not news) */each_name(pending, keep_listed, &k);if (name && !hos_crash_listed(out.s, name)) put(&out, name), put(&out, "\n");const int ok = write_text(path, out.s ? out.s : "", out.n);nit: the ledger is truncated and rewritten in place. A start reading it in between (two runs, or a helper and a start) gets
"", an existing but empty ledger, and shows a crash of the last day again. Fix: write a temporary file and rename it overshown.txt.@ -0,0 +817,4 @@char pending[PATH_MAX_UTF8], path[PATH_MAX_UTF8], leaf[64], stamp[17];utc_now(stamp);snprintf(leaf, sizeof leaf, "report-%s.txt", stamp);const int saved = pending_of(s->dir, pending, sizeof pending) && join(path, sizeof path, pending, leaf) && write_text(path, text, n);nit:
report-*.txtfiles collect inbug-reports/pendingfor good:prune_pending(hos_crash_record.c) only prunescrash-/unclean-names. Fix: keep the newest 10 after each save.@ -0,0 +832,4 @@"doing, and fill in the rest.");else put(&m, "Open " HOS_CRASH_ISSUES ", choose Game problem, and paste it into the longshot_log.txt box.");if (saved) putf(&m, "\n\nIt is also saved in the game folder as bug-reports/pending/%s.", leaf);if (copied) put(&m, "\n\nKeep this window open until you have pasted it.");nit: on Windows the text stays on the clipboard after the helper exits (
SetClipboardDatahands the memory to the system), so this line only applies to Linux, where the helper serves the X11 selection itself.@ -0,0 +903,4 @@sleep_ms(250);}if (hos_crash_record_marker(a->dir, a->pid, a->run_id) == 3) { /* (restarted: execve, a new run's marker) */if (fd >= 0) close(fd);nit, not fixed: on Linux the helper is a child of the game. After an execve restart this helper returns and stays a zombie of the new run until the game exits: one zombie per restart, harmless. Reaping it from the new run would mean
waitpid(-1, ...)on children the game doesn't own, which is worse than the zombie.@ -0,0 +949,4 @@if (find_run_log(log, a->log, run_id)) read_log(log, &s.who);s.verdict = hos_crash_verdict(&r, &log->facts, have_exit, code, 0);if (a->mode == 2 && r.kind != 1) s.verdict = HOS_CRASH_QUIET;if (s.verdict != HOS_CRASH_QUIET) {risk (Windows): at a logoff or shutdown the session ends the game (often with a non-zero exit code and the marker left), the helper wakes up, and
SDL_ShowMessageBox/MessageBoxWputs up a box that holds the shutdown ("Longshot closed unexpectedly is preventing you from signing out"). Fix: whenGetSystemMetrics(SM_SHUTTINGDOWN)is set, show nothing and don't list the record inshown.txt, so a real crash record is still shown at the next start (unclean ends never are).@ -0,0 +950,4 @@s.verdict = hos_crash_verdict(&r, &log->facts, have_exit, code, 0);if (a->mode == 2 && r.kind != 1) s.verdict = HOS_CRASH_QUIET;if (s.verdict != HOS_CRASH_QUIET) {s.stage = hos_crash_stage(&log->facts);risk: with no log found (stderr to a terminal or a pipe, so
-; or a--crash-showwhose run's log has rotated past.1), the stage isHOS_STAGE_STARTand the window says "closed unexpectedly during the start" even for a crash an hour into play. Fix: an unknown stage when the log wasn't found, and the sentence then says nothing about when.@ -0,0 +1027,4 @@posix_spawn_file_actions_addopen(&fa, 1, "/dev/null", O_WRONLY, 0);posix_spawn_file_actions_addopen(&fa, 2, "/dev/null", O_WRONLY, 0);pid_t pid;const int ok = posix_spawn(&pid, "/proc/self/exe", &fa, NULL, argv, environ) == 0;risk:
posix_spawnpasses on every fd that isn't close-on-exec. The game's own fds are (the marker, maps, the control socket), but whatever a launcher or a shell leaked into the game isn't, and the helper would hold it while it waits and while its window is open. A pipe held like that keeps a reader that waits for EOF waiting. Fix: the helper closes fds 3 and up first thing (close_range, else/proc/self/fd).posix_spawn_file_actions_addclosefrom_npwould raise the glibc minimum to 2.34.@ -823,0 +843,4 @@DWORD n = 0;WriteFile(marker, note, sizeof note, &n, &at);#elseif (pwrite(marker, note, sizeof note, (off_t)sizeof(Session)) != (ssize_t)sizeof note) return;risk: there is a gap between this function's
readycheck and its write.hos_crash_clean_endon another thread (the control socket'sgame_quit, a window close and anatexitcan overlap) can closemarkerin that gap. On Linux, if another thread then opens a file, the write lands on a reused fd, andquit\ngoes into that file at offset ~4.3 KB. On Windows it writes to a closed or reused handle. Thequit_notedexchange doesn't cover this, because the second caller returns at once and goes straight on toclean_end. Fix: count the writers (quit_busy, sequentially consistent), and haveclean_end, after clearingready, wait briefly (bounded) for the count to drop before it closes the marker.@ -2086,1 +2097,4 @@int main(int argc, char **argv) {{ /* (longshot) the crash window's helper of this run (host/hos_crash_dialog.c): first, so it starts nothing of the game */int hos_crash_helper_main(int argc, char **argv);const int helper = hos_crash_helper_main(argc, argv);bug:
tests/test_display_startup_failure.pycuts thismain()out (function(host, "int main(int argc, char **argv)"), the last one), renames itapp_mainand builds it withtests/display_startup_failure_test.cpp, which defines nohos_crash_helper_main. The fixture now fails to link (an undefinedhos_crash_helper_main(int, char**)), so the whole check fails. Fix: add a stub that returns -1 (the game itself) to the fixture.3822fb340d8ad59bc809Code review (#593 (comment)) found, and
8ad59bc8fixes: tests/test_display_startup_failure.py no longer linked (its fixture builds the Linux main(), now calling hos_crash_helper_main: a stand-in added); the quit note could write to a marker hos_crash_clean_end was closing on another thread (now counted busy, and the clean end waits, bounded); the Linux helper kept fds the game inherited without close-on-exec (now closed first); on Windows a sign-out or shutdown would get a window that holds it up (now none, and the record isn't listed so a crash is shown at the next start); with no log found the window said 'during the start' (now nothing about when); saved reports were never pruned (newest ten kept); shown.txt was rewritten in place (now replaced whole); 'Keep this window open' was said on Windows too (Linux only now). Checks added in tests/test_crash_dialog.py for each; docs updated. Not fixed: the Linux zombie after an execve restart (harmless). Still WIP: nothing built or run (the Linux files only -fsyntax-only); needs a build, run_all, and Windows, Linux and Steam Deck testers.8ad59bc80975d3caf4ea75d3caf4, the owner's follow-ups: (1) Linux clipboard: Report now copies through wl-copy on Wayland, else xclip/xsel (they keep the text after the helper ends; reaped, no zombie), SDL's X11 clipboard only as the last resort and never on Wayland (it needs a focused window and claimed success anyway; its video init also put the next box on a thread, which is likely why the 'report ready' box didn't show and the helper exited). The box after Report never says copied when nothing took it, names the saved report's path and opens it (Open the report, or by itself when no box can be shown). (2) No helper and no next-start box under gamescope (GAMESCOPE_WAYLAND_DISPLAY, or XDG_CURRENT_DESKTOP=gamescope; not SteamDeck=1, which Desktop Mode has too) until a Deck tester shows a child's box appears there. (3) nx2/make_game.py: an update no longer ends the windowless crash helper of a game still open (stale_copies: parent has the visible window). Checks for each in tests/test_crash_dialog.py; docs updated. Not run here (helper compiled standalone only). Still WIP.Linux build of the real game with this PR (main
82886e89+ 75d3caf4's changes, dev_packs base on the lab, i7-9700K, clang 23.1.5): compiles and links (BUILD OK; the changed host files, hos_main.c and rx_backend.c's hooks included). On a KDE/Wayland desktop (DISPLAY unset), the helper compiled standalone against a stand-in game killed after writing a crash record: the window shows at once with the right stage, Report writes the report, wl-copy holds the full 77-line report on the clipboard after the helper exits, and the pre-filled issue form opens. Windows: not compiled or run yet.The crash window on a KDE/Wayland desktop (Linux, the helper compiled from this PR against a stand-in game killed after writing a crash record):
Description: the Must be tested items say who runs them and what to expect; the screenshot box ticked with the Wayland picture; the builds box says Linux builds (the lab) and Windows isn't built yet.
WIP: feat(host): a window right after a crash says what happened, with a Report button that copies a redacted report and opens the issue formto feat(host): a window right after a crash says what happened, with a Report button that copies a redacted report and opens the issue form