steam-backlog-enforcer/steam_backlog_enforcer/game_uninstall.py
Krzysztof kuhy Rudnicki 01d750f36d Remove unneeded Steam tools after an uninstall
Steamworks Common Redistributables, Steam Linux Runtime 4.0 and Proton
Experimental stay in PROTECTED_APP_IDS, so no guard ever calls them an
unauthorized game. uninstall_other_games now ends with a step that
uninstalls them, through uninstall_game, only when all of these hold:

- Steam is not running (pgrep steam.sh, as _ensure_steam_running);
- config.vdf parses and has a CompatToolMapping block;
- every installed non-tool appmanifest maps to proton-cachyos-native;
- that tool's toolmanifest.vdf exists.

Anything else keeps all three and logs "kept Steam tools: <reason>";
a running Steam logs "Steam running, deferring tool removal". No game
installed counts as not needed and says so.

- _tool_need.py decides. Every error keeps the tools.
- _vdf_text.py is a stdlib KeyValues parser. The repo had none, and the
  root daemon's system python has no vdf package.
- _steam_client.steam_client_running() returns None when pgrep cannot
  tell. _ensure_steam_running behaves as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-22 14:53:11 +01:00

237 lines
8.9 KiB
Python

"""Uninstalling games and querying what is installed.
Split out of :mod:`steam_backlog_enforcer.game_install` to keep both files
under the 250-line cap: that module owns getting a game *onto* disk, this one
owns taking it off and reporting what is there.
"""
from __future__ import annotations
import contextlib
import logging
import re
import shutil
from typing import TYPE_CHECKING
from steam_backlog_enforcer import _steam_state
from steam_backlog_enforcer._achievement_skip import zero_achievement_ids
from steam_backlog_enforcer._game_names import _is_protected_name
from steam_backlog_enforcer._progress import tracked
from steam_backlog_enforcer._protected_apps import PROTECTED_APP_IDS
from steam_backlog_enforcer._research_game import kept_ids
from steam_backlog_enforcer._steam_state import STEAMAPPS_PATH, _assert_not_real_steam
from steam_backlog_enforcer._tool_need import STEAM_TOOLS, tool_need
from steam_backlog_enforcer._whitelist_locking import get_approved_exception_ids
if TYPE_CHECKING:
from pathlib import Path
logger = logging.getLogger(__name__)
# ──────────────────────────────────────────────────────────────
# Game uninstall management
# ──────────────────────────────────────────────────────────────
def get_installed_games() -> list[tuple[int, str]]:
"""Parse appmanifest files to find installed games.
Returns: list of (app_id, game_name) tuples.
"""
installed: list[tuple[int, str]] = []
for manifest_file in STEAMAPPS_PATH.glob("appmanifest_*.acf"):
with contextlib.suppress(OSError):
content = manifest_file.read_text(encoding="utf-8")
app_id_match = re.search(r'"appid"\s+"(\d+)"', content)
name_match = re.search(r'"name"\s+"([^"]+)"', content)
if app_id_match:
app_id = int(app_id_match.group(1))
name = name_match.group(1) if name_match else f"Unknown ({app_id})"
installed.append((app_id, name))
installed.sort(key=lambda x: x[1].lower())
return installed
def _read_install_dir(manifest: Path) -> Path | None:
"""Read installdir from a game's appmanifest file."""
if not manifest.exists():
return None
try:
content = manifest.read_text(encoding="utf-8")
match = re.search(r'"installdir"\s+"([^"]+)"', content)
if match:
return STEAMAPPS_PATH / "common" / match.group(1)
except OSError:
pass
return None
def _remove_manifest(manifest: Path, game_name: str, app_id: int) -> bool:
"""Remove a game manifest file.
Args:
manifest: Path to the appmanifest file.
game_name: Human-readable game name for logging.
app_id: Steam application ID.
"""
_assert_not_real_steam(manifest)
try:
if manifest.exists():
manifest.unlink()
logger.info(
"Removed manifest for %s (AppID=%d)", game_name or app_id, app_id
)
except OSError:
logger.exception("Failed to remove manifest for AppID=%d", app_id)
return False
return True
def _remove_game_dirs(install_dir: Path | None, app_id: int) -> bool:
"""Remove game installation directory and cache directories.
Args:
install_dir: Path to the game's install directory, or None.
app_id: Steam application ID.
"""
success = True
if install_dir and install_dir.is_dir():
_assert_not_real_steam(install_dir)
# Folder-name safety net, independent of the app-id gating callers
# already do: it stops deleting the *wrong* directory for an allowed
# game whose name was written inconsistently ("KingdomComeDeliverance2"
# vs "Kingdom Come: Deliverance II"), which caused real data loss once.
if _is_protected_name(install_dir.name):
logger.warning(
"Refusing to remove %s: name matches an allowed game", install_dir
)
return False
try:
shutil.rmtree(install_dir)
logger.info("Removed game files: %s", install_dir)
except OSError:
logger.exception("Failed to remove game dir %s", install_dir)
success = False
for subdir in ("shadercache", "compatdata"):
cache_path = STEAMAPPS_PATH / subdir / str(app_id)
if cache_path.is_dir():
_assert_not_real_steam(cache_path)
with contextlib.suppress(OSError):
shutil.rmtree(cache_path)
logger.debug("Removed %s/%d", subdir, app_id)
return success
def uninstall_game(app_id: int, game_name: str = "") -> bool:
"""Uninstall a single game by removing its manifest and game files.
Uses direct file removal instead of ``steam://uninstall`` URI to avoid
GUI popups and to work when Steam is not running.
"""
# Last line of defence for every caller: the research game's manifest
# and files are never removed while it is on game-research's list.
if app_id in kept_ids():
logger.warning("Refusing to uninstall research game AppID=%d", app_id)
return False
manifest = STEAMAPPS_PATH / f"appmanifest_{app_id}.acf"
install_dir = _read_install_dir(manifest)
success = _remove_manifest(manifest, game_name, app_id)
if not _remove_game_dirs(install_dir, app_id):
success = False
return success
def uninstall_other_games(allowed_app_ids: set[int]) -> int:
"""Uninstall all installed games except the allowed ones and protected IDs.
Args:
allowed_app_ids: Every app id that must survive — the assignment plus
any concurrent manual picks. Empty means "keep nothing".
Returns: number of games uninstalled.
"""
to_remove: list[tuple[int, str]] = []
kept_protected: list[str] = []
keep = allowed_app_ids | kept_ids()
for app_id, name in get_installed_games():
if app_id in keep:
logger.info("KEEPING allowed game: %s (AppID=%d)", name, app_id)
elif is_protected_app(app_id):
kept_protected.append(name)
else:
to_remove.append((app_id, name))
if kept_protected:
logger.info("KEEPING protected: %s", ", ".join(kept_protected))
# Only removals go through the progress bar: it names the item it just
# finished, and naming a kept runtime there reads as "removed it".
count = 0
for app_id, name in tracked(to_remove, "Uninstalling games", lambda g: g[1]):
logger.info("UNINSTALLING: %s (AppID=%d)", name, app_id)
if uninstall_game(app_id, name):
count += 1
# After the games: what is left installed decides whether the tools stay.
remove_unneeded_tools()
return count
def remove_unneeded_tools() -> int:
"""Uninstall :data:`STEAM_TOOLS` when :func:`tool_need` says nothing needs them.
Silent when none of them is installed; otherwise one line says what was
decided and why. Returns how many were removed.
"""
# The canonical binding, read now: the test suite redirects it for every
# test, so no test can reach a live Steam root through this step.
steamapps = _steam_state.STEAMAPPS_PATH
present = [a for a in STEAM_TOOLS if (steamapps / f"appmanifest_{a}.acf").exists()]
if not present:
return 0
need = tool_need(steamapps)
if need.deferred:
logger.info("Steam running, deferring tool removal")
return 0
if need.needed:
logger.info("kept Steam tools: %s", need.reason)
return 0
logger.info("removing Steam tools: %s", need.reason)
return sum(uninstall_game(app_id, STEAM_TOOLS[app_id]) for app_id in present)
def is_infrastructure_app(app_id: int) -> bool:
"""Return True if *app_id* is a Steam runtime or compatibility tool.
The strict subset of :func:`is_protected_app`: no exception, no zero-
achievement game. A research window uses it so that nothing but the one
allowed game survives besides the runtimes that game needs.
"""
return app_id in PROTECTED_APP_IDS
def is_protected_app(app_id: int) -> bool:
"""Return True if *app_id* must never be uninstalled.
Combines the hardcoded Steam infrastructure set with any app IDs that
have been approved via the exception mechanism, and with owned games Steam
confirmed have zero achievements (nothing to complete, so always allowed;
the gaming-time budget still applies to them). Unknown status is not
protected. This one test also gates the unauthorized-game kill.
Args:
app_id: Steam application ID to check.
Returns:
True if the app should be left alone by the enforcer.
"""
return (
is_infrastructure_app(app_id)
or app_id in get_approved_exception_ids()
or app_id in zero_achievement_ids()
)