mirror of
https://github.com/kuhyx/steam-backlog-enforcer.git
synced 2026-07-04 13:23:18 +02:00
355 lines
11 KiB
Python
355 lines
11 KiB
Python
"""Hide / unhide games in the Steam library via sharedconfig.vdf.
|
|
|
|
Steam stores per-app settings (including the "hidden" flag) in
|
|
``userdata/<userid>/7/remote/sharedconfig.vdf`` under the path:
|
|
|
|
UserRoamingConfigStore > Software > Valve > Steam > apps > <appid>
|
|
|
|
Setting ``"hidden" "1"`` makes the game invisible in the default
|
|
library view. This module provides functions to bulk-hide every owned
|
|
game *except* the currently assigned one, and to unhide them all when
|
|
enforcement is lifted.
|
|
|
|
Steam must be restarted (or not running) for the changes to take effect,
|
|
because it overwrites the file on exit.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import contextlib
|
|
import logging
|
|
import os
|
|
from pathlib import Path
|
|
import pwd
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
from typing import Any
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# Steam user-data paths.
|
|
_STEAM_DIR = Path.home() / ".local" / "share" / "Steam"
|
|
_USERDATA_DIR = _STEAM_DIR / "userdata"
|
|
_SHARED_CONFIG_REL = Path("7") / "remote" / "sharedconfig.vdf"
|
|
|
|
|
|
# ──────────────────────────────────────────────────────────────
|
|
# Minimal VDF parser / writer
|
|
# ──────────────────────────────────────────────────────────────
|
|
|
|
|
|
def _parse_vdf(text: str) -> dict[str, Any]:
|
|
"""Parse a Valve VDF text file into nested dicts.
|
|
|
|
Only handles the subset used by sharedconfig.vdf (string values and
|
|
nested sections).
|
|
"""
|
|
tokens: list[str] = []
|
|
for m in re.finditer(r'"([^"]*)"|\{|\}', text):
|
|
if m.group(1) is not None:
|
|
tokens.append(m.group(1))
|
|
else:
|
|
tokens.append(m.group(0)) # "{" or "}"
|
|
idx = 0
|
|
|
|
def _parse_obj() -> dict[str, Any]:
|
|
nonlocal idx
|
|
obj: dict[str, Any] = {}
|
|
while idx < len(tokens):
|
|
token = tokens[idx]
|
|
if token == "}": # noqa: S105
|
|
idx += 1
|
|
return obj
|
|
# Key.
|
|
key = token
|
|
idx += 1
|
|
if idx >= len(tokens):
|
|
break
|
|
# Value: either a string or a nested object.
|
|
nxt = tokens[idx]
|
|
if nxt == "{":
|
|
idx += 1
|
|
obj[key] = _parse_obj()
|
|
elif nxt == "}":
|
|
# Key without value right before closing brace — skip.
|
|
obj[key] = ""
|
|
# Don't advance; let the outer loop consume '}'.
|
|
else:
|
|
obj[key] = nxt
|
|
idx += 1
|
|
return obj
|
|
|
|
return _parse_obj()
|
|
|
|
|
|
def _write_vdf(data: dict[str, Any], indent: int = 0) -> str:
|
|
"""Serialize a nested dict back to VDF text."""
|
|
lines: list[str] = []
|
|
prefix = "\t" * indent
|
|
|
|
for key, value in data.items():
|
|
if isinstance(value, dict):
|
|
lines.append(f'{prefix}"{key}"')
|
|
lines.append(f"{prefix}{{")
|
|
lines.append(_write_vdf(value, indent + 1))
|
|
lines.append(f"{prefix}}}")
|
|
else:
|
|
lines.append(f'{prefix}"{key}"\t\t"{value}"')
|
|
|
|
return "\n".join(lines)
|
|
|
|
|
|
# ──────────────────────────────────────────────────────────────
|
|
# Discover Steam user IDs on this machine
|
|
# ──────────────────────────────────────────────────────────────
|
|
|
|
|
|
def _find_user_dirs() -> list[Path]:
|
|
"""Return paths to all numeric userdata directories except '0'."""
|
|
if not _USERDATA_DIR.is_dir():
|
|
return []
|
|
return [p for p in _USERDATA_DIR.iterdir() if p.name.isdigit() and p.name != "0"]
|
|
|
|
|
|
# ──────────────────────────────────────────────────────────────
|
|
# Hide / unhide logic
|
|
# ──────────────────────────────────────────────────────────────
|
|
|
|
|
|
def _get_apps_section(
|
|
vdf_data: dict[str, Any],
|
|
) -> dict[str, Any] | None:
|
|
"""Navigate to the ``apps`` dict inside the VDF tree."""
|
|
try:
|
|
steam_section = vdf_data["UserRoamingConfigStore"]["Software"]["Valve"]["Steam"]
|
|
if "apps" not in steam_section:
|
|
steam_section["apps"] = {}
|
|
except (KeyError, TypeError):
|
|
return None
|
|
else:
|
|
result: dict[str, Any] = steam_section["apps"]
|
|
return result
|
|
|
|
|
|
def _hide_games_in_profile(
|
|
config_path: Path,
|
|
user_dir: Path,
|
|
owned_app_ids: list[int],
|
|
allowed_app_id: int | None,
|
|
) -> int:
|
|
"""Hide games in a single Steam user profile.
|
|
|
|
Args:
|
|
config_path: Path to the sharedconfig.vdf file.
|
|
user_dir: Path to the user's data directory.
|
|
owned_app_ids: List of owned game app IDs.
|
|
allowed_app_id: App ID of the game that should remain visible.
|
|
|
|
Returns:
|
|
Number of games hidden in this profile.
|
|
"""
|
|
# Back up the original.
|
|
backup = config_path.with_suffix(".vdf.bak")
|
|
if not backup.exists():
|
|
shutil.copy2(config_path, backup)
|
|
|
|
text = config_path.read_text(encoding="utf-8")
|
|
vdf_data = _parse_vdf(text)
|
|
apps = _get_apps_section(vdf_data)
|
|
if apps is None:
|
|
logger.warning("Could not find apps section in %s", config_path)
|
|
return 0
|
|
|
|
hidden_count = _apply_hide_flags(apps, owned_app_ids, allowed_app_id)
|
|
|
|
output = _write_vdf(vdf_data) + "\n"
|
|
config_path.write_text(output, encoding="utf-8")
|
|
_fix_ownership(config_path, user_dir)
|
|
|
|
logger.info("Hidden %d games in profile %s", hidden_count, user_dir.name)
|
|
return hidden_count
|
|
|
|
|
|
def _apply_hide_flags(
|
|
apps: dict[str, Any],
|
|
owned_app_ids: list[int],
|
|
allowed_app_id: int | None,
|
|
) -> int:
|
|
"""Set hidden flags on all games except the allowed one.
|
|
|
|
Args:
|
|
apps: The VDF apps section dict.
|
|
owned_app_ids: List of owned app IDs.
|
|
allowed_app_id: App ID to keep visible.
|
|
|
|
Returns:
|
|
Number of games newly hidden.
|
|
"""
|
|
hidden_count = 0
|
|
for app_id in owned_app_ids:
|
|
sid = str(app_id)
|
|
if app_id == allowed_app_id:
|
|
if sid in apps and isinstance(apps[sid], dict):
|
|
apps[sid].pop("hidden", None)
|
|
continue
|
|
|
|
if sid not in apps or not isinstance(apps[sid], dict):
|
|
apps[sid] = {}
|
|
if apps[sid].get("hidden") != "1":
|
|
apps[sid]["hidden"] = "1"
|
|
hidden_count += 1
|
|
return hidden_count
|
|
|
|
|
|
def hide_other_games(
|
|
owned_app_ids: list[int],
|
|
allowed_app_id: int | None,
|
|
) -> int:
|
|
"""Hide every owned game except *allowed_app_id* in the Steam library.
|
|
|
|
Modifies ``sharedconfig.vdf`` for every local Steam user profile.
|
|
Steam must be restarted for changes to take effect.
|
|
|
|
Returns the number of games that were hidden.
|
|
"""
|
|
user_dirs = _find_user_dirs()
|
|
if not user_dirs:
|
|
logger.warning("No Steam userdata directories found.")
|
|
return 0
|
|
|
|
total_hidden = 0
|
|
|
|
for user_dir in user_dirs:
|
|
config_path = user_dir / _SHARED_CONFIG_REL
|
|
if not config_path.exists():
|
|
logger.debug("No sharedconfig.vdf in %s", user_dir.name)
|
|
continue
|
|
|
|
total_hidden += _hide_games_in_profile(
|
|
config_path, user_dir, owned_app_ids, allowed_app_id
|
|
)
|
|
|
|
return total_hidden
|
|
|
|
|
|
def unhide_all_games(owned_app_ids: list[int]) -> int:
|
|
"""Remove the hidden flag from all owned games.
|
|
|
|
Returns the number of games that were unhidden.
|
|
"""
|
|
user_dirs = _find_user_dirs()
|
|
total = 0
|
|
|
|
for user_dir in user_dirs:
|
|
config_path = user_dir / _SHARED_CONFIG_REL
|
|
if not config_path.exists():
|
|
continue
|
|
|
|
text = config_path.read_text(encoding="utf-8")
|
|
vdf_data = _parse_vdf(text)
|
|
apps = _get_apps_section(vdf_data)
|
|
if apps is None:
|
|
continue
|
|
|
|
count = 0
|
|
for app_id in owned_app_ids:
|
|
sid = str(app_id)
|
|
if sid in apps and isinstance(apps[sid], dict):
|
|
if apps[sid].pop("hidden", None) is not None:
|
|
count += 1
|
|
# Remove the entry entirely if it's now empty.
|
|
if not apps[sid]:
|
|
del apps[sid]
|
|
|
|
output = _write_vdf(vdf_data) + "\n"
|
|
config_path.write_text(output, encoding="utf-8")
|
|
_fix_ownership(config_path, user_dir)
|
|
|
|
logger.info("Unhidden %d games in profile %s", count, user_dir.name)
|
|
total += count
|
|
|
|
return total
|
|
|
|
|
|
# ──────────────────────────────────────────────────────────────
|
|
# Steam restart helper
|
|
# ──────────────────────────────────────────────────────────────
|
|
|
|
|
|
def restart_steam() -> None:
|
|
"""Gracefully restart the Steam client.
|
|
|
|
Sends ``steam -shutdown``, waits, then launches again with ``-silent``.
|
|
"""
|
|
real_user = os.environ.get("SUDO_USER") or os.environ.get("USER")
|
|
logger.info("Restarting Steam client...")
|
|
|
|
# Shut down Steam gracefully.
|
|
try:
|
|
_run_as_user(["steam", "-shutdown"], real_user)
|
|
except FileNotFoundError:
|
|
logger.warning("Steam executable not found for restart.")
|
|
return
|
|
|
|
# Wait for Steam to exit.
|
|
import time
|
|
|
|
_pgrep = shutil.which("pgrep") or "/usr/bin/pgrep"
|
|
for _ in range(30):
|
|
result = subprocess.run(
|
|
[_pgrep, "-f", "steam.sh"],
|
|
capture_output=True,
|
|
check=False,
|
|
)
|
|
if result.returncode != 0:
|
|
break
|
|
time.sleep(1)
|
|
|
|
# Relaunch silently.
|
|
with contextlib.suppress(FileNotFoundError):
|
|
_run_as_user(["steam", "-silent"], real_user)
|
|
|
|
|
|
def _run_as_user(cmd: list[str], user: str | None) -> None:
|
|
"""Run a command, dropping to *user* if currently root."""
|
|
if os.geteuid() == 0 and user and user != "root":
|
|
try:
|
|
pw = pwd.getpwnam(user)
|
|
uid = pw.pw_uid
|
|
except KeyError:
|
|
uid = 1000
|
|
|
|
dbus_default = f"unix:path=/run/user/{uid}/bus"
|
|
dbus_addr = os.environ.get("DBUS_SESSION_BUS_ADDRESS", dbus_default)
|
|
xauth = os.environ.get("XAUTHORITY", f"/home/{user}/.Xauthority")
|
|
full_cmd = [
|
|
"sudo",
|
|
"-u",
|
|
user,
|
|
"env",
|
|
f"DISPLAY={os.environ.get('DISPLAY', ':0')}",
|
|
f"XAUTHORITY={xauth}",
|
|
f"DBUS_SESSION_BUS_ADDRESS={dbus_addr}",
|
|
*cmd,
|
|
]
|
|
else:
|
|
full_cmd = cmd
|
|
|
|
subprocess.Popen(
|
|
full_cmd,
|
|
stdout=subprocess.DEVNULL,
|
|
stderr=subprocess.DEVNULL,
|
|
)
|
|
|
|
|
|
def _fix_ownership(path: Path, user_dir: Path) -> None:
|
|
"""If running as root, chown the file to the user who owns user_dir."""
|
|
if os.geteuid() != 0:
|
|
return
|
|
try:
|
|
stat = user_dir.stat()
|
|
os.chown(path, stat.st_uid, stat.st_gid)
|
|
except OSError:
|
|
pass
|