From 4c29c6a61e5540e917551ae99e2254cbdfe510f2 Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Sun, 4 Oct 2026 21:33:16 -0400 Subject: [PATCH] Fetch the Steam client again when it never shows up (#225) A client stopped part way through updating itself can be left unable to draw anything. Its files and our install stamp are still on disk, so the installer never looked at it again and every session sat on "Waiting for Steam" with nothing retried. The session now adds a line to package/droiddeck-unconfirmed each time it starts the client, and the app removes the file on the client's first frame. After two starts in a row with nothing shown, the installer: - drops Steam's update manifests, the stamp, .crash and steam.pid - deletes package zips whose sha1 no longer matches their name - downloads the client again over the old one steamapps, config and userdata are left alone. An automatic repair runs once per failure, until a start is seen again. The Steam page's Client settings get a "Repair Steam client" item that queues the same repair for the next start. The request is only cleared once the download completes, so an interrupted repair is retried. --- .../com/droiddeck/launcher/MainActivity.kt | 5 ++ .../com/droiddeck/launcher/SessionActivity.kt | 2 + .../droiddeck/launcher/session/SteamRepair.kt | 21 +++++++ .../launcher/ui/ModeSettingsDialog.kt | 8 +++ app/src/main/res/values/strings.xml | 4 ++ .../overlay/usr/local/bin/droiddeck-session | 4 ++ .../usr/local/bin/droiddeck-steam-install | 28 +++++++++ tools/tests/test_steam_install.py | 63 +++++++++++++++++++ 8 files changed, 135 insertions(+) create mode 100644 app/src/main/java/com/droiddeck/launcher/session/SteamRepair.kt diff --git a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt index 0414ba2b07..e2e82449c7 100644 --- a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt @@ -42,6 +42,7 @@ import com.droiddeck.launcher.ui.ComponentsPage import com.droiddeck.launcher.session.GameSaves import com.droiddeck.launcher.session.SessionLogShare import com.droiddeck.launcher.session.SessionPrefs +import com.droiddeck.launcher.session.SteamRepair import com.droiddeck.launcher.ui.ProtonPage import com.droiddeck.launcher.core.CpuCores import com.droiddeck.launcher.core.PhantomProcessLimit @@ -110,6 +111,7 @@ class MainActivity : ComponentActivity() { private var glThread by mutableStateOf(true) private var noGlError by mutableStateOf(true) private var steamDeckMode by mutableStateOf(false) + private var steamRepairQueued by mutableStateOf(false) private var mangoapp by mutableStateOf(true) private var steamController by mutableStateOf(SessionPrefs.CONTROLLER_DECK) private var showProtons by mutableStateOf(false) @@ -1140,6 +1142,7 @@ class MainActivity : ComponentActivity() { syncBackend = if (mode == SessionService.MODE_STEAM) SessionPrefs.syncBackendOf(fastSync, fsyncFirst, syncFallback) else null, steamChannel = if (mode == SessionService.MODE_STEAM) steamChannel else null, steamDeckMode = mode == SessionService.MODE_STEAM && steamDeckMode, + steamRepairQueued = steamRepairQueued, mangoapp = mangoapp, steamController = if (mode == SessionService.MODE_STEAM) steamController else null, runSteamAtStartup = mode == SessionService.MODE_STEAM && runSteamAtStartup, @@ -1218,6 +1221,7 @@ class MainActivity : ComponentActivity() { syncFallback = SessionPrefs.syncFallback(this) }, onSteamChannel = { id -> SessionPrefs.setSteamChannel(this, id); steamChannel = id }, + onSteamRepair = { steamRepairQueued = SteamRepair.queue(this) }, onSteamDeckMode = { on -> SessionPrefs.setSteamDeckMode(this, on) steamDeckMode = on @@ -1337,6 +1341,7 @@ class MainActivity : ComponentActivity() { syncFallback = SessionPrefs.syncFallback(this) steamChannel = SessionPrefs.steamChannel(this) steamDeckMode = SessionPrefs.steamDeckMode(this) + steamRepairQueued = SteamRepair.queued(this) mangoapp = SessionPrefs.mangoapp(this) steamController = SessionPrefs.steamController(this) runSteamAtStartup = SessionPrefs.runSteamAtStartup(this) diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index 9d7fa640ee..abbe696e93 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -59,6 +59,7 @@ import com.droiddeck.launcher.runtime.LinuxRuntime import com.droiddeck.launcher.session.LoadingState import com.droiddeck.launcher.session.PerfHud import com.droiddeck.launcher.session.PerfMode +import com.droiddeck.launcher.session.SteamRepair import com.droiddeck.launcher.session.GameEnvironmentStore import com.droiddeck.launcher.session.SessionPrefs import com.droiddeck.launcher.session.SessionEvents @@ -1933,6 +1934,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private val endListener: (Int) -> Unit = { status -> onSessionEnded(status) } private val firstFrameListener = Runnable { SessionEvents.firstFrame() + if (SessionState.mode == SessionService.MODE_STEAM) SteamRepair.clientShown(this) runOnUiThread { loading.visible = false hud.start() diff --git a/app/src/main/java/com/droiddeck/launcher/session/SteamRepair.kt b/app/src/main/java/com/droiddeck/launcher/session/SteamRepair.kt new file mode 100644 index 0000000000..38fc9c2352 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/session/SteamRepair.kt @@ -0,0 +1,21 @@ +package com.droiddeck.launcher.session + +import android.content.Context +import com.droiddeck.launcher.runtime.LinuxRuntime +import java.io.File + +object SteamRepair { + private fun home(context: Context) = File(LinuxRuntime.rootDir(context), "root") + private fun request(context: Context) = File(home(context), ".bl-steam-repair") + private fun unconfirmed(context: Context) = File(home(context), ".local/share/Steam/package/droiddeck-unconfirmed") + + fun queued(context: Context): Boolean = request(context).exists() + + fun queue(context: Context): Boolean = runCatching { + request(context).apply { parentFile?.mkdirs() }.writeText("1\n") + }.isSuccess + + fun clientShown(context: Context) { + unconfirmed(context).delete() + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt index 714b6590ef..36997decf3 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt @@ -81,6 +81,7 @@ class ModeSettings( val steamChannel: String? = null, /** Steam only: enable the SteamOS client interface and its performance controls. */ val steamDeckMode: Boolean = false, + val steamRepairQueued: Boolean = false, /** Steam, Deck mode: the QAM's performance overlay (mangoapp) is started. */ val mangoapp: Boolean = true, /** Steam only: what the pad is to the client (SessionPrefs.CONTROLLER_*); null outside Steam. */ @@ -139,6 +140,7 @@ class ModeSettingsActions( val onForceFullscreen: (Boolean) -> Unit = {}, val onStretch16x9: (Boolean) -> Unit = {}, val onSteamChannel: (String) -> Unit = {}, + val onSteamRepair: () -> Unit = {}, val onSteamDeckMode: (Boolean) -> Unit = {}, val onMangoapp: (Boolean) -> Unit = {}, val onSteamController: (String) -> Unit = {}, @@ -368,6 +370,12 @@ fun ModeSettingsPage(s: ModeSettings, a: ModeSettingsActions) { note = stringResource(R.string.mode_branch_note), onPick = a.onSteamChannel, ) + SettingsRow( + stringResource(R.string.mode_steam_repair), + stringResource(if (s.steamRepairQueued) R.string.mode_steam_repair_queued else R.string.mode_steam_repair_hint), + ) { + SecondaryButton(stringResource(R.string.mode_steam_repair_button), enabled = !s.steamRepairQueued, onClick = a.onSteamRepair) + } } if (steam && s.wifiDiscovery != null) SettingsGroup(stringResource(R.string.mode_network)) { val hint = when { diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 11c794fc02..be062ba1b4 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -291,6 +291,10 @@ Public beta Steam Deck public beta Deck mode always uses Steam Deck public beta. + Repair Steam client + Downloads the Steam client again the next time Steam starts. Use it if Steam stays on its loading screen. Games, sign-in and settings are kept. + The Steam client will be downloaded again the next time Steam starts. + Repair Added games no game folders with a .exe found Games folder diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session index 838a58136c..91465d661e 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session @@ -775,6 +775,10 @@ BUSCONF echo "== steam: client branch on disk was '$(cat "$steam_beta" 2>/dev/null)', set to '$steam_channel' to match -clientbeta" echo "$steam_channel" > "$steam_beta" fi + if [ -z "${_bl_counted:-}" ] && [ -z "${BL_DESKTOP:-}" ]; then + echo start >> "$steam_root/package/droiddeck-unconfirmed" + _bl_counted=1 + fi step "starting the Steam client${BL_STEAM_UI:+ ($BL_STEAM_UI UI)}" "$steam_root/steamrtarm64/steam" "${_bl_ui[@]}" "${_bl_cdp[@]}" -clientbeta "$steam_channel" \ -no-cef-sandbox -cef-force-gpu -cef-ozone-platform=x11 \ diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-install b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-install index a5722f7d05..d2f59ed12f 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-install +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-install @@ -12,9 +12,33 @@ manifest=steam_client_${steam_channel}_linuxarm64 steam_root=${XDG_DATA_HOME:-$HOME/.local/share}/Steam stamp=$steam_root/package/droiddeck-installed legacy_stamp=$steam_root/package/bannerlator-installed +unconfirmed=$steam_root/package/droiddeck-unconfirmed +repair_request=$HOME/.bl-steam-repair if [ -f "$legacy_stamp" ] && [ ! -f "$stamp" ]; then mv -f "$legacy_stamp" "$stamp" || true fi +repair="" +if [ -e "$repair_request" ]; then + repair="requested" +elif [ -f "$unconfirmed" ] && ! grep -qx repaired "$unconfirmed" \ + && [ "$(grep -cx start "$unconfirmed")" -ge 2 ]; then + repair="the client was started $(grep -cx start "$unconfirmed") times without showing anything" +fi +if [ -n "$repair" ]; then + echo "== STEP $(date -u +%H:%M:%S) repairing the Steam client ($repair)" + rm -f "$stamp" "$legacy_stamp" "$steam_root/.crash" "$steam_root/steam.pid" \ + "$steam_root"/package/steam_client_*.manifest "$steam_root"/package/steam_client_*.installed + for part in "$steam_root"/package/*.zip.*; do + [ -f "$part" ] || continue + sum=${part##*.} + sum=${sum%%_*} + case $sum in + *[!0-9a-f]*|"") continue ;; + esac + [ ${#sum} -eq 40 ] || continue + [ "$(sha1sum "$part" | cut -d' ' -f1)" = "$sum" ] || rm -f "$part" + done +fi [ -x "$steam_root/steamrtarm64/steam" ] && [ -f "$stamp" ] && exit 0 work=$(mktemp -d) @@ -68,3 +92,7 @@ ln -sfn "$steam_root/linuxarm64" "$HOME/.steam/sdkarm64" ln -sfn "$steam_root/steamrtarm64" "$HOME/.steam/binarm64" ln -sfn "$steam_root/linux32" "$HOME/.steam/sdk32" echo "$version" > "$stamp" +if [ -n "$repair" ]; then + echo repaired > "$unconfirmed" + rm -f "$repair_request" +fi diff --git a/tools/tests/test_steam_install.py b/tools/tests/test_steam_install.py index 0d20529659..e62bba375f 100644 --- a/tools/tests/test_steam_install.py +++ b/tools/tests/test_steam_install.py @@ -38,6 +38,10 @@ cp "$TEST_CDN/${2##*/}" "$4" sha = self.bin / 'sha256sum' sha.write_text('#!/bin/bash\nexec shasum -a 256 "$@"\n') sha.chmod(0o755) + if shutil.which('sha1sum') is None: + sha1 = self.bin / 'sha1sum' + sha1.write_text('#!/bin/bash\nexec shasum -a 1 "$@"\n') + sha1.chmod(0o755) self.env = dict(os.environ, HOME=str(self.home), XDG_DATA_HOME=str(self.data), PATH=str(self.bin) + os.pathsep + os.environ['PATH'], TEST_CDN=str(self.cdn), TEST_REQUESTS=str(self.requests)) @@ -104,6 +108,65 @@ cp "$TEST_CDN/${2##*/}" "$4" self.assertEqual(0, self.install('publicbeta').returncode) self.assertEqual('publicbeta\n', (self.steam / 'package/beta').read_text()) + def break_client(self, starts): + self.assert_installed('steamdeck_publicbeta') + self.requests.unlink() + package = self.steam / 'package' + (self.steam / 'steamrtarm64/steam').write_text('half updated') + (package / 'steam_client_steamdeck_publicbeta_linuxarm64.manifest').write_text('manifest') + (package / 'steam_client_steamdeck_publicbeta_linuxarm64.installed').write_text('installed') + good = b'complete package' + (package / ('bins_linuxarm64.zip.vz.' + hashlib.sha1(good).hexdigest() + '_16')).write_bytes(good) + (package / ('bins_misc_linuxarm64.zip.vz.' + hashlib.sha1(b'whole').hexdigest() + '_5')).write_bytes(b'wh') + (package / ('strings_all.zip.' + hashlib.sha1(b'strings').hexdigest())).write_bytes(b'strings') + (self.steam / '.crash').write_text('') + (package / 'droiddeck-unconfirmed').write_text('start\n' * starts) + return package + + def test_two_starts_with_nothing_shown_fetch_the_client_again(self): + package = self.break_client(2) + self.assert_installed('steamdeck_publicbeta') + self.assertEqual('repaired\n', (package / 'droiddeck-unconfirmed').read_text()) + self.assertFalse((self.steam / '.crash').exists()) + self.assertEqual([], sorted(p.name for p in package.glob('steam_client_*'))) + self.assertEqual(['bins_linuxarm64.zip.vz.', 'strings_all.zip.'], + sorted(p.name[:p.name.rindex('.') + 1] for p in package.glob('*.zip.*'))) + + def test_one_start_with_nothing_shown_is_left_alone(self): + package = self.break_client(1) + self.assertEqual(0, self.install().returncode) + self.assertFalse(self.requests.exists()) + self.assertEqual('half updated', (self.steam / 'steamrtarm64/steam').read_text()) + self.assertTrue((package / 'steam_client_steamdeck_publicbeta_linuxarm64.installed').exists()) + + def test_a_repair_is_not_repeated_until_the_client_has_been_seen(self): + package = self.break_client(2) + self.assertEqual(0, self.install().returncode) + self.requests.unlink() + with (package / 'droiddeck-unconfirmed').open('a') as marker: + marker.write('start\nstart\nstart\n') + self.assertEqual(0, self.install().returncode) + self.assertFalse(self.requests.exists()) + + def test_requested_repair_runs_once_and_is_retried_until_it_completes(self): + package = self.break_client(0) + (package / 'droiddeck-unconfirmed').unlink() + request = self.home / '.bl-steam-repair' + request.write_text('1\n') + archive = self.cdn / 'steamdeck_publicbeta.zip' + original = archive.read_bytes() + archive.write_bytes(b'corrupt download') + self.assertNotEqual(0, self.install().returncode) + self.assertTrue(request.exists()) + self.assertFalse((package / 'droiddeck-installed').exists()) + archive.write_bytes(original) + self.requests.unlink() + self.assert_installed('steamdeck_publicbeta') + self.assertFalse(request.exists()) + self.requests.unlink() + self.assertEqual(0, self.install().returncode) + self.assertFalse(self.requests.exists()) + def test_invalid_channel_fails_before_any_download(self): result = self.install('../unknown') self.assertNotEqual(0, result.returncode)