mirror of
https://github.com/kuhyx/steam-backlog-enforcer.git
synced 2026-11-22 23:02:19 +01:00
Map safe games to a FOSS Proton
Install the pinned proton-cachyos-native build (signature and sha256 checked, .INSTALL never run), decide per game whether it is safe, write the CompatToolMapping as text, add --map-installed and --valve-proton, and drop steamcmd from install.sh. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
parent
e2fc518624
commit
c1b6fdd16f
@ -51,7 +51,9 @@ repos:
|
||||
types: [text]
|
||||
|
||||
# Every dependency on its ecosystem's newest STABLE release, exact-pinned
|
||||
# so the question is mechanically answerable at all.
|
||||
# so the question is mechanically answerable at all. That includes the
|
||||
# native Proton build, pinned in proton-native.lock and checked against
|
||||
# cachyos.db by the shared gate's pacman-repo adapter.
|
||||
#
|
||||
# `files:` is what keeps this cheap: a commit touching only source makes
|
||||
# ZERO network requests, and manifest commits mostly hit a 6h disk cache.
|
||||
@ -71,7 +73,8 @@ repos:
|
||||
|package\.json|package-lock\.json|pnpm-lock\.yaml
|
||||
|Cargo\.(toml|lock)|go\.(mod|sum)
|
||||
|\.fvmrc|\.nvmrc|\.python-version
|
||||
|\.github/workflows/.*\.ya?ml)$
|
||||
|\.github/workflows/.*\.ya?ml
|
||||
|steam_installer/data/proton-native\.lock)$
|
||||
|
||||
- id: repo-contract
|
||||
name: repo contract (CLAUDE.md Commands + test_changed)
|
||||
|
||||
@ -8,9 +8,11 @@ a real install so **Play** works.
|
||||
./run.sh BeamNG.drive
|
||||
```
|
||||
|
||||
That is the whole thing. `run.sh` installs its own dependencies (steamcmd via
|
||||
`yay`, DepotDownloader from the SteamRE release, and a local `.venv`) on first
|
||||
use, then works out what you meant. All four of these install the same game:
|
||||
That is the whole thing. `run.sh` installs its own dependencies (`libibus` via
|
||||
pacman, DepotDownloader from the SteamRE release, a local `.venv` and the native
|
||||
Proton described below) on first use, then works out what you meant. It never
|
||||
runs `steamcmd`: app info comes from Steam's own cache and the tool writes the
|
||||
manifest itself. All four of these install the same game:
|
||||
|
||||
```bash
|
||||
./run.sh 284160 # an AppID
|
||||
@ -25,8 +27,49 @@ name shows a numbered picker, and in a non-interactive run it lists the
|
||||
candidates and exits 2 rather than guessing.
|
||||
|
||||
Useful flags: `--dry-run` (resolve and report, change nothing), `--yes`
|
||||
(no prompts), `--repair-ghosts` (see below), `--username` (remembered after the
|
||||
first run, in `~/.config/steam-game-installer/config`; never a password).
|
||||
(no prompts), `--repair-ghosts` (see below), `--valve-proton` (keep this game on
|
||||
Valve's Proton for this run), `--map-installed` (see below), `--username`
|
||||
(remembered after the first run, in `~/.config/steam-game-installer/config`;
|
||||
never a password).
|
||||
|
||||
## Games run on a FOSS Proton
|
||||
|
||||
A plain Windows game is mapped to `proton-cachyos-native`, a Proton that
|
||||
CachyOS builds from source against the host's own libraries. Steam then runs
|
||||
it with no Steam Linux Runtime container, and Proton Experimental, Steam Linux
|
||||
Runtime 4.0 and the Steamworks Redistributables are not needed while only such
|
||||
games are installed (steam-backlog-enforcer removes them then).
|
||||
|
||||
- **The tool.** `install.sh` downloads the exact build pinned in
|
||||
`steam_installer/data/proton-native.lock` from the CachyOS mirror. It checks
|
||||
the package's `.sig` against the CachyOS key pinned in
|
||||
`steam_installer/data/cachyos_signing_key.asc` (fingerprint and sources in
|
||||
`proton_pkg.py`), and its sha256 against the lock. Then it extracts only the
|
||||
tool folder into `compatibilitytools.d/` and writes a `VERSION` stamp; the
|
||||
package's `.INSTALL` is never run. A copy already on disk is adopted when
|
||||
every file matches the package's `.MTREE`. An update is swapped in by rename,
|
||||
only while Steam and every game are closed. The dependency-freshness gate
|
||||
checks the lock against `cachyos.db`.
|
||||
- **Which games.** Only a game proven safe: Windows-only (the app, every depot,
|
||||
every launch option), no shared depots, no owned DLC depot, not in
|
||||
AreWeAntiCheatYet's `games.json` (fetched every run, last good copy cached;
|
||||
no list means nothing is mapped), and not in
|
||||
`steam_installer/data/compat_overrides.json` (`{"<appid>": "<reason>"}` for a
|
||||
game that breaks on the native build). Anything else keeps Valve's default,
|
||||
so it runs exactly as before. The run prints every reason.
|
||||
- **The mapping.** With Steam closed, the game gets a `CompatToolMapping`
|
||||
entry in `config/config.vdf` (`"name" "proton-cachyos-native"`, priority
|
||||
250). The file is edited as text, and none of its other lines is ever logged.
|
||||
An entry Valve chose (priority 100) is replaced; one you picked is kept.
|
||||
- **Games already installed.** `./run.sh --map-installed` prints the decision
|
||||
for every installed game and writes nothing; add `--apply` to close Steam and
|
||||
write the safe ones. `--appids 730,1201270` decides any cached app instead.
|
||||
|
||||
Proven live on 2026-11-22 with A Space for the Unbound (1201270). Not tested
|
||||
yet, so they stay on Valve's default or are fixture-tested only: a game with
|
||||
shared depots (its from-scratch manifest records `SharedDepots`), an owned DLC
|
||||
depot, a native Linux game, an anti-cheat game, a global default mapping and a
|
||||
package update.
|
||||
|
||||
**Steam gets closed for you.** Steam owns `appmanifest_<appid>.acf` while it
|
||||
runs and rewrites it from its own in-memory state, so anything written
|
||||
@ -76,7 +119,8 @@ password nobody was there to type.
|
||||
|
||||
## Ghost installs
|
||||
|
||||
`steamcmd +login anonymous +app_update <paid appid>` has no licence for the app.
|
||||
Older versions of this tool ran steamcmd. `steamcmd +login anonymous +app_update
|
||||
<paid appid>` has no licence for the app.
|
||||
It does not say so. It transfers nothing, prints `Success! App '...' fully
|
||||
installed.`, exits 0, and writes a manifest claiming `StateFlags=4` with
|
||||
`SizeOnDisk=0` and an empty `InstalledDepots`.
|
||||
@ -111,17 +155,21 @@ manifest verbatim before and after every write, the depot cache listing,
|
||||
expected-vs-actual depots, and whether Steam was running. Send `latest.log` when
|
||||
something goes wrong. `--verbose` mirrors all of it to the console.
|
||||
|
||||
Subprocess output is teed through a pty rather than captured, because steamcmd
|
||||
only prompts for a password / Steam Guard code when it believes it is on a
|
||||
terminal — with a plain pipe the prompt never appears and the run looks hung.
|
||||
Subprocess output is teed through a pty rather than captured, because
|
||||
depotdownloader only prompts for a password / Steam Guard code when it believes
|
||||
it is on a terminal — with a plain pipe the prompt never appears and the run looks hung.
|
||||
|
||||
## How it works
|
||||
|
||||
1. `depotdownloader` pulls the content (fast path).
|
||||
1. App info (name, installdir, depots, build) is read from Steam's own cache,
|
||||
`appcache/appinfo.vdf`. An app missing from it fails with the fix: start
|
||||
Steam once, let it sync, rerun. A DLC missing from it counts as not owned.
|
||||
2. `depotdownloader` pulls the content (fast path).
|
||||
Then each owned DLC with depots of its own gets a run of its own.
|
||||
2. `steamcmd app_update <id> validate` reconciles Steam's own bookkeeping.
|
||||
3. If that fails or leaves the manifest incomplete, the manifest is finished by
|
||||
hand — but only when every precondition below holds.
|
||||
3. The manifest is finished by hand, or written from scratch with the 15 keys
|
||||
Steam accepted when none exists, but only when every precondition below
|
||||
holds. Steam adds `LastOwner`, `UserConfig` and the rest itself.
|
||||
4. The game is mapped to the native Proton when it is safe (see above).
|
||||
|
||||
## Fail-closed preconditions
|
||||
|
||||
@ -132,25 +180,23 @@ The tool refuses to mark an app installed, and exits non-zero, unless:
|
||||
(required = this app's depots for the chosen language and OS, excluding DLC,
|
||||
optional and shared depots — KCD2 lists 12 depots but an english/windows
|
||||
install only ever fetches 3);
|
||||
- the manifest carries a real `buildid` matching the current public build;
|
||||
- every required depot holds the public gid from Steam's cache, which proves
|
||||
the build (a differing gid means the cache is stale: start Steam, let it
|
||||
sync, rerun), or else the manifest carries a matching real `buildid`;
|
||||
- no Steam client is running (it is closed first, and restarted afterwards);
|
||||
- the manifest reads back as a real install *after* being written.
|
||||
|
||||
This matters: an earlier version wrote `StateFlags=4` and reported success after
|
||||
a steamcmd run that had done nothing at all.
|
||||
a steamcmd run that had done nothing at all. A from-scratch manifest is built in
|
||||
memory and only written once every check has passed.
|
||||
|
||||
## Failure modes this encodes
|
||||
|
||||
Each of these cost a real debugging session; the tests pin them.
|
||||
|
||||
**`force_install_dir` is a library root, not an install directory.** Pointing it
|
||||
at the game folder made steamcmd look for manifests in `<game>/steamapps/`, find
|
||||
none (`Loaded 0 apps from install folder`), create that stray directory, and then
|
||||
fail the app with `Invalid platform` — it had no depot context for the app.
|
||||
Dropped entirely: the app already lives in a registered library.
|
||||
|
||||
**A Linux steamcmd needs `+@sSteamCmdForcePlatformType windows`** (before
|
||||
`+login`) for a Windows-only game, or it resolves depots against the host OS.
|
||||
**A wrong `installdir` makes Steam wipe the game.** Steam treated the correctly
|
||||
downloaded folder as orphaned, deleted it and started a fresh download into the
|
||||
folder its manifest named. The field is fixed first, as soon as Steam is closed.
|
||||
|
||||
**Steam rejects an internally inconsistent manifest.** A file that says
|
||||
`StateFlags=4` while `BytesDownloaded` (22 GB) still differs from
|
||||
|
||||
@ -3,13 +3,20 @@
|
||||
# ============================================================================
|
||||
# Install everything this tool shells out to, then set up the dev environment.
|
||||
#
|
||||
# steamcmd AUR package, via yay
|
||||
# libibus the one runtime library of proton-cachyos-native's 63
|
||||
# package dependencies a plain Arch desktop may lack (pacman)
|
||||
# depotdownloader official self-contained release from SteamRE/DepotDownloader
|
||||
# .venv local virtualenv with the package installed editable
|
||||
# native Proton proton-cachyos-native, pinned in
|
||||
# steam_installer/data/proton-native.lock, signature- and
|
||||
# sha256-checked, into Steam's compatibilitytools.d
|
||||
#
|
||||
# steamcmd is not needed any more: app info comes from Steam's own cache and
|
||||
# the manifest is written by the tool itself.
|
||||
#
|
||||
# Idempotent: every step no-ops when its target is already in place, so run.sh
|
||||
# can call it on every run. `yay` shells out to `sudo pacman`, so installing
|
||||
# steamcmd may prompt for a password -- that is the one interactive step.
|
||||
# can call it on every run. Installing libibus runs `sudo -n pacman`; when sudo
|
||||
# would prompt, it stops and prints the one command to type.
|
||||
# ============================================================================
|
||||
|
||||
set -euo pipefail
|
||||
@ -45,19 +52,29 @@ die() {
|
||||
exit 1
|
||||
}
|
||||
|
||||
ensure_steamcmd() {
|
||||
if command -v steamcmd >/dev/null 2>&1; then
|
||||
ensure_libibus() {
|
||||
if pacman -Q libibus >/dev/null 2>&1; then
|
||||
return 0
|
||||
fi
|
||||
if [[ "$CHECK_ONLY" -eq 1 ]]; then
|
||||
echo "missing: steamcmd -- run: yay -S steamcmd" >&2
|
||||
echo "missing: libibus -- run: sudo pacman -S --needed libibus" >&2
|
||||
return 1
|
||||
fi
|
||||
command -v yay >/dev/null 2>&1 ||
|
||||
die "steamcmd is missing and yay is not installed. Install it, then: yay -S steamcmd"
|
||||
echo "Installing steamcmd (yay may ask for your sudo password)..."
|
||||
yay -S --needed --noconfirm --answerdiff None --answeredit None steamcmd
|
||||
command -v steamcmd >/dev/null 2>&1 || die "steamcmd still not on PATH after install"
|
||||
sudo -n pacman -S --needed --noconfirm libibus ||
|
||||
die "libibus is missing and sudo needs a password. Run: sudo pacman -S --needed libibus"
|
||||
}
|
||||
|
||||
# Never runs the package's .INSTALL; see steam_installer/proton_native.py.
|
||||
ensure_native_proton() {
|
||||
local python="${VENV}/bin/python"
|
||||
if [[ "$CHECK_ONLY" -eq 1 ]]; then
|
||||
if [[ -x "$python" ]] && ! "$python" -m steam_installer.proton_native --check; then
|
||||
echo "missing: proton-cachyos-native at the pinned version -- run ./install.sh" >&2
|
||||
return 1
|
||||
fi
|
||||
return 0
|
||||
fi
|
||||
"$python" -m steam_installer.proton_native || die "native Proton install failed"
|
||||
}
|
||||
|
||||
# Build from source only if the published binary can't be fetched. The upstream
|
||||
@ -137,15 +154,17 @@ setup_dev_env() {
|
||||
|
||||
main() {
|
||||
local missing=0
|
||||
ensure_steamcmd || missing=1
|
||||
ensure_libibus || missing=1
|
||||
ensure_depotdownloader || missing=1
|
||||
|
||||
if [[ "$CHECK_ONLY" -eq 1 ]]; then
|
||||
ensure_native_proton || missing=1
|
||||
[[ "$missing" -eq 0 ]] && echo "All dependencies present."
|
||||
exit "$missing"
|
||||
fi
|
||||
|
||||
setup_dev_env
|
||||
ensure_native_proton
|
||||
echo "All dependencies present."
|
||||
: >"$STAMP"
|
||||
}
|
||||
|
||||
@ -1,11 +1,11 @@
|
||||
[project]
|
||||
name = "steam-game-installer"
|
||||
version = "0.1.0"
|
||||
description = "Fast Steam game installs: depotdownloader for speed, steamcmd for recognition."
|
||||
description = "Fast Steam game installs: depotdownloader for speed, a hand-written manifest for recognition, a FOSS Proton to run them."
|
||||
requires-python = ">=3.14"
|
||||
# kuhy's shared "Created by kuhy" credit, shown at the end of --help.
|
||||
dependencies = [
|
||||
"kuhy-credit @ git+https://github.com/kuhyx/utils@kuhy-credit-v0.3.0#subdirectory=kuhy_credit",
|
||||
"kuhy-credit @ git+https://github.com/kuhyx/utils@kuhy-credit-v0.3.2#subdirectory=kuhy_credit",
|
||||
]
|
||||
|
||||
[project.scripts]
|
||||
|
||||
@ -20,6 +20,7 @@ readonly SCRIPT_DIR
|
||||
readonly VENV_PY="${SCRIPT_DIR}/.venv/bin/python"
|
||||
readonly STAMP="${SCRIPT_DIR}/.venv/.deps-ok"
|
||||
readonly INSTALLER="${SCRIPT_DIR}/install.sh"
|
||||
readonly PROTON_LOCK="${SCRIPT_DIR}/steam_installer/data/proton-native.lock"
|
||||
|
||||
SKIP_DEPS="${SGI_SKIP_DEPS:-0}"
|
||||
DEPS_ONLY=0
|
||||
@ -52,7 +53,9 @@ deps_are_current() {
|
||||
[[ -f "$STAMP" ]] || return 1
|
||||
[[ "$STAMP" -nt "$INSTALLER" ]] || return 1
|
||||
[[ "$STAMP" -nt "${SCRIPT_DIR}/pyproject.toml" ]] || return 1
|
||||
"$VENV_PY" -c 'import steam_installer' >/dev/null 2>&1
|
||||
[[ "$STAMP" -nt "$PROTON_LOCK" ]] || return 1
|
||||
# A bumped pin or a deleted tool folder: the stamp alone would miss both.
|
||||
"$VENV_PY" -m steam_installer.proton_native --check >/dev/null 2>&1
|
||||
}
|
||||
|
||||
main() {
|
||||
|
||||
@ -3,7 +3,7 @@
|
||||
# ============================================================================
|
||||
# Deploy origin/main to where this tool runs: kuhy's checkout
|
||||
# (~/src/steam-game-installer, used through ./run.sh). Refuses a dirty tree,
|
||||
# fast-forwards it, reruns ./run.sh --deps-only (steamcmd, depotdownloader,
|
||||
# fast-forwards it, reruns ./run.sh --deps-only (libibus, depotdownloader, the native Proton,
|
||||
# editable .venv), then starts the CLI as the health check. Nothing is
|
||||
# published elsewhere: no package, no service, no release.
|
||||
# Idempotent; non-zero unless the checkout is at origin/main and the CLI starts.
|
||||
|
||||
57
_installer_import/steam_installer/anticheat.py
Normal file
57
_installer_import/steam_installer/anticheat.py
Normal file
@ -0,0 +1,57 @@
|
||||
"""Steam app ids that use anti-cheat, from AreWeAntiCheatYet's `games.json`.
|
||||
|
||||
Fetched on every run; the last good copy is kept so a flaky network does not
|
||||
change any decision. With neither a fetch nor a copy the answer is "unknown",
|
||||
and an unknown list maps nothing. Every listed game counts, whatever its
|
||||
status: kuhy's library has 54 such games (CS2, Garry's Mod, TF2, ...), and VAC
|
||||
runs inside Valve's client, so those stay on Valve's own setup.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import urllib.request
|
||||
from pathlib import Path
|
||||
|
||||
URL = (
|
||||
"https://raw.githubusercontent.com/AreWeAntiCheatYet/AreWeAntiCheatYet/"
|
||||
"HEAD/games.json"
|
||||
)
|
||||
CACHE = Path.home() / ".cache" / "steam-game-installer" / "anticheat-games.json"
|
||||
|
||||
|
||||
def _download() -> bytes:
|
||||
with urllib.request.urlopen(URL, timeout=20) as response:
|
||||
return response.read()
|
||||
|
||||
|
||||
def _ids(raw: bytes | str) -> set[int]:
|
||||
"""Steam ids in a games.json; ValueError/TypeError when it is not one."""
|
||||
games = json.loads(raw)
|
||||
if not isinstance(games, list):
|
||||
raise TypeError("games.json is not a list")
|
||||
ids: set[int] = set()
|
||||
for game in games:
|
||||
stores = game.get("storeIds") if isinstance(game, dict) else None
|
||||
steam = stores.get("steam") if isinstance(stores, dict) else None
|
||||
if isinstance(steam, str) and steam.isdigit():
|
||||
ids.add(int(steam))
|
||||
return ids
|
||||
|
||||
|
||||
def steam_ids(cache: Path = CACHE) -> set[int] | None:
|
||||
"""Anti-cheat Steam app ids, or None when no list can be had."""
|
||||
try:
|
||||
raw = _download()
|
||||
ids = _ids(raw)
|
||||
except (OSError, ValueError, TypeError):
|
||||
try:
|
||||
return _ids(cache.read_bytes())
|
||||
except (OSError, ValueError, TypeError):
|
||||
return None
|
||||
cache.parent.mkdir(parents=True, exist_ok=True)
|
||||
tmp = cache.with_name(f"{cache.name}.tmp{os.getpid()}")
|
||||
tmp.write_bytes(raw)
|
||||
os.replace(tmp, cache)
|
||||
return ids
|
||||
@ -6,7 +6,6 @@ from dataclasses import dataclass, field
|
||||
|
||||
from steam_installer import appinfo_cache
|
||||
|
||||
|
||||
# depotdownloader is never given -branch, so it always fetches this one.
|
||||
PUBLIC_BRANCH = "public"
|
||||
|
||||
|
||||
@ -13,6 +13,7 @@ from steam_installer import (
|
||||
deps,
|
||||
flow,
|
||||
ghost,
|
||||
map_installed,
|
||||
resolve,
|
||||
runlog,
|
||||
takeover,
|
||||
@ -70,6 +71,7 @@ def _build_parser() -> argparse.ArgumentParser:
|
||||
"steamcmd leaves behind, and clear them away."
|
||||
),
|
||||
)
|
||||
map_installed.add_arguments(parser)
|
||||
parser.add_argument(
|
||||
"--verbose",
|
||||
action="store_true",
|
||||
@ -82,8 +84,11 @@ def main(argv: list[str] | None = None) -> int:
|
||||
parser = _build_parser()
|
||||
args = parser.parse_args(argv)
|
||||
|
||||
if not args.repair_ghosts and args.appid is None and args.target is None:
|
||||
parser.error("provide an AppID, a Steam URL, a game name, or --repair-ghosts")
|
||||
if not (args.repair_ghosts or args.map_installed) and not (args.appid or args.target):
|
||||
parser.error(
|
||||
"provide an AppID, a Steam URL, a game name, --repair-ghosts or --map-installed"
|
||||
)
|
||||
map_installed.check_arguments(parser, args)
|
||||
|
||||
literal = target.parse_literal(args.target) if args.target else None
|
||||
log = runlog.setup(args.appid or (literal[0] if literal else None), args.verbose)
|
||||
@ -163,6 +168,8 @@ def _run(args: argparse.Namespace, log: runlog.RunLog) -> int:
|
||||
|
||||
if args.repair_ghosts:
|
||||
return _repair_ghosts(log)
|
||||
if args.map_installed:
|
||||
return map_installed.run(args, log, find_steam_root())
|
||||
|
||||
try:
|
||||
deps.require()
|
||||
@ -184,7 +191,8 @@ def _run(args: argparse.Namespace, log: runlog.RunLog) -> int:
|
||||
resolved.source,
|
||||
)
|
||||
|
||||
libraries = list_libraries(find_steam_root())
|
||||
steam_root = find_steam_root()
|
||||
libraries = list_libraries(steam_root)
|
||||
install_target = pick_install_target(libraries, metadata.installdir)
|
||||
library = next(lib for lib in libraries if lib.common == install_target.parent)
|
||||
report = ghost.inspect(library, metadata.appid)
|
||||
@ -223,6 +231,7 @@ def _run(args: argparse.Namespace, log: runlog.RunLog) -> int:
|
||||
return flow.install(
|
||||
args=args,
|
||||
log=log,
|
||||
steam_root=steam_root,
|
||||
library=library,
|
||||
metadata=metadata,
|
||||
install_target=install_target,
|
||||
|
||||
74
_installer_import/steam_installer/compat_apply.py
Normal file
74
_installer_import/steam_installer/compat_apply.py
Normal file
@ -0,0 +1,74 @@
|
||||
"""Run the per-game decision and, when it says so, write the mapping.
|
||||
|
||||
Shared by the install flow (right after the manifest is finished, while Steam
|
||||
is still closed) and by `--map-installed`. The decision rules live in
|
||||
:mod:`compat_decide`, the config.vdf edit in :mod:`compat_map`.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from pathlib import Path
|
||||
|
||||
from steam_installer import anticheat, appinfo, compat_decide, compat_map, proton_pkg
|
||||
|
||||
VALVE_PROTON = "--valve-proton"
|
||||
TOOL_DIR = "compatibilitytools.d/proton-cachyos-native"
|
||||
|
||||
|
||||
class Context:
|
||||
"""What every decision in one run shares: fetched once, not per game."""
|
||||
|
||||
def __init__(self, steam_root: Path, extra_overrides: dict[str, str] | None = None):
|
||||
self.steam_root = steam_root
|
||||
self.config = compat_map.config_path(steam_root)
|
||||
self.anticheat = anticheat.steam_ids()
|
||||
self.overrides = {**compat_decide.load_overrides(), **(extra_overrides or {})}
|
||||
self.tool_ready = compat_decide.tool_ready(
|
||||
steam_root / TOOL_DIR, proton_pkg.read_lock().version
|
||||
)
|
||||
|
||||
def decide(self, appid: int, block: dict, owned_dlc: bool) -> compat_decide.Decision:
|
||||
return compat_decide.decide(
|
||||
appid,
|
||||
block,
|
||||
anticheat=self.anticheat,
|
||||
overrides=self.overrides,
|
||||
owned_dlc=owned_dlc,
|
||||
tool_ready=self.tool_ready,
|
||||
)
|
||||
|
||||
|
||||
def after_install(
|
||||
steam_root: Path,
|
||||
appid: int,
|
||||
owned_dlc: bool,
|
||||
valve_proton: bool,
|
||||
logger: logging.Logger,
|
||||
) -> None:
|
||||
"""Map a freshly installed game, or say why it keeps Valve's default.
|
||||
|
||||
Never fails the install: a game left unmapped still runs on Valve's
|
||||
Proton, exactly as before this tool knew about compat tools.
|
||||
"""
|
||||
extra = {str(appid): VALVE_PROTON} if valve_proton else {}
|
||||
try:
|
||||
context = Context(steam_root, extra)
|
||||
decision = context.decide(appid, appinfo._fetch_app_block(appid), owned_dlc)
|
||||
if not decision.map:
|
||||
logger.info("Compat tool: %s", decision.describe())
|
||||
return
|
||||
outcome = compat_map.map_app(context.config, appid)
|
||||
except (appinfo.AppInfoError, compat_map.CompatMapError, OSError, ValueError) as exc:
|
||||
logger.warning("Compat tool not set (%s); the game stays on Valve's default.", exc)
|
||||
return
|
||||
report(logger, appid, outcome)
|
||||
|
||||
|
||||
def report(logger: logging.Logger, appid: int, outcome: compat_map.Outcome) -> None:
|
||||
if outcome.action == "kept":
|
||||
logger.info("Compat tool for %s kept: %s", appid, outcome.detail)
|
||||
elif outcome.action == "already":
|
||||
logger.info("Compat tool for %s: already mapped to %s.", appid, compat_map.TOOL)
|
||||
else:
|
||||
logger.info("Compat tool for %s: mapped to %s.", appid, compat_map.TOOL)
|
||||
108
_installer_import/steam_installer/compat_decide.py
Normal file
108
_installer_import/steam_installer/compat_decide.py
Normal file
@ -0,0 +1,108 @@
|
||||
"""Decide per game whether Steam may run it on the native Proton.
|
||||
|
||||
Only a game this can prove safe is mapped: Windows-only (the app, every depot
|
||||
and every launch option), no shared depots, no owned DLC depot, not in the
|
||||
anti-cheat list, not overridden. Anything else keeps Valve's default, so
|
||||
Valve's tools come back while that game is installed -- every game stays
|
||||
playable. When unsure, the answer is no.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from dataclasses import dataclass, field
|
||||
from pathlib import Path
|
||||
|
||||
OVERRIDES = Path(__file__).parent / "data" / "compat_overrides.json"
|
||||
|
||||
|
||||
@dataclass
|
||||
class Decision:
|
||||
appid: int
|
||||
reasons: list[str] = field(default_factory=list)
|
||||
|
||||
@property
|
||||
def map(self) -> bool:
|
||||
return not self.reasons
|
||||
|
||||
def describe(self) -> str:
|
||||
return "map" if self.map else f"Valve default: {', '.join(self.reasons)}"
|
||||
|
||||
|
||||
def load_overrides(path: Path = OVERRIDES) -> dict[str, str]:
|
||||
"""`{appid: reason}` for games that break on the native build."""
|
||||
data = json.loads(path.read_text())
|
||||
if not isinstance(data, dict) or not all(
|
||||
key.isdigit() and isinstance(reason, str) for key, reason in data.items()
|
||||
):
|
||||
raise ValueError(f"{path.name}: compat_overrides must map app ids to reasons")
|
||||
return data
|
||||
|
||||
|
||||
def tool_ready(tool_dir: Path, pinned_version: str) -> bool:
|
||||
"""The tool is there and is the exact pinned, verified build."""
|
||||
stamp = tool_dir / "VERSION"
|
||||
return (
|
||||
(tool_dir / "toolmanifest.vdf").is_file()
|
||||
and stamp.is_file()
|
||||
and stamp.read_text().strip() == pinned_version
|
||||
)
|
||||
|
||||
|
||||
def _oses(value: object) -> set[str]:
|
||||
return {os for os in value.split(",") if os} if isinstance(value, str) else set()
|
||||
|
||||
|
||||
def _dicts(section: object) -> list[dict]:
|
||||
if not isinstance(section, dict):
|
||||
return []
|
||||
return [entry for entry in section.values() if isinstance(entry, dict)]
|
||||
|
||||
|
||||
def _config_oslist(entry: dict) -> set[str]:
|
||||
config = entry.get("config")
|
||||
return _oses(config.get("oslist")) if isinstance(config, dict) else set()
|
||||
|
||||
|
||||
def _platform_reasons(block: dict) -> list[str]:
|
||||
common = block.get("common")
|
||||
app_oses = _oses(common.get("oslist")) if isinstance(common, dict) else set()
|
||||
depots = _dicts(block.get("depots"))
|
||||
config = block.get("config")
|
||||
launches = _dicts(config.get("launch")) if isinstance(config, dict) else []
|
||||
oses = app_oses.union(*(_config_oslist(e) for e in depots + launches))
|
||||
reasons = []
|
||||
if not app_oses:
|
||||
reasons.append("no OS list")
|
||||
if "linux" in oses:
|
||||
reasons.append("native")
|
||||
if oses - {"windows", "linux"}:
|
||||
reasons.append("not Windows-only")
|
||||
if any("depotfromapp" in d or "sharedinstall" in d for d in depots):
|
||||
reasons.append("shared depots")
|
||||
return reasons
|
||||
|
||||
|
||||
def decide(
|
||||
appid: int,
|
||||
block: dict,
|
||||
*,
|
||||
anticheat: set[int] | None,
|
||||
overrides: dict[str, str],
|
||||
owned_dlc: bool,
|
||||
tool_ready: bool,
|
||||
) -> Decision:
|
||||
"""Every reason `appid` must keep Valve's default; none means map it."""
|
||||
reasons: list[str] = []
|
||||
if anticheat is None:
|
||||
reasons.append("anti-cheat list unavailable")
|
||||
elif appid in anticheat:
|
||||
reasons.append("anti-cheat")
|
||||
reasons += _platform_reasons(block)
|
||||
if owned_dlc:
|
||||
reasons.append("owned DLC")
|
||||
if str(appid) in overrides:
|
||||
reasons.append(f"override: {overrides[str(appid)]}")
|
||||
if not tool_ready:
|
||||
reasons.append("native Proton not installed")
|
||||
return Decision(appid, reasons)
|
||||
208
_installer_import/steam_installer/compat_map.py
Normal file
208
_installer_import/steam_installer/compat_map.py
Normal file
@ -0,0 +1,208 @@
|
||||
"""Map one game to the native Proton in Steam's `config/config.vdf`.
|
||||
|
||||
The entry goes under InstallConfigStore/Software/Valve/Steam/CompatToolMapping,
|
||||
the same shape Steam writes for a per-game choice in its own UI:
|
||||
|
||||
"<appid>" { "name" "proton-cachyos-native" "config" "" "priority" "250" }
|
||||
|
||||
Steam itself records Valve's per-game defaults at priority 100. On 2026-11-22
|
||||
Steam honoured a 250 entry: `compat_log.txt` named the native tool as the only
|
||||
tool. A global default was never tested, so only per-game entries are written.
|
||||
|
||||
The file is edited as text, never round-tripped through a parser: every other
|
||||
byte stays as Steam wrote it. It also holds private values (tokens, account
|
||||
ids), so no line of it is ever logged or put in an error message -- errors
|
||||
carry line numbers only. Steam rewrites the file from memory on exit, so a
|
||||
write while it runs would be lost; it is refused.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import re
|
||||
import tempfile
|
||||
from dataclasses import dataclass, field
|
||||
from pathlib import Path
|
||||
|
||||
from steam_installer import recognize
|
||||
|
||||
TOOL = "proton-cachyos-native"
|
||||
PRIORITY = "250"
|
||||
VALVE_PRIORITY = "100"
|
||||
_STEAM = ("installconfigstore", "software", "valve", "steam")
|
||||
_MAPPING = (*_STEAM, "compattoolmapping")
|
||||
# A quoted string (escapes allowed, newlines too), a brace, or anything else.
|
||||
_TOKEN = re.compile(r'"(?:[^"\\]|\\.)*"|[{}]|[^\s"{}]+')
|
||||
|
||||
|
||||
class CompatMapError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
@dataclass
|
||||
class Outcome:
|
||||
action: str # "mapped", "already" or "kept"
|
||||
detail: str = ""
|
||||
|
||||
|
||||
@dataclass
|
||||
class _Entry:
|
||||
open_line: int # the `{` after the appid key
|
||||
close_line: int = -1
|
||||
values: dict[str, str] = field(default_factory=dict)
|
||||
|
||||
|
||||
@dataclass
|
||||
class _Layout:
|
||||
lines: list[str]
|
||||
steam_open: int = -1
|
||||
mapping_open: int = -1
|
||||
entry: _Entry | None = None
|
||||
|
||||
|
||||
def config_path(steam_root: Path) -> Path:
|
||||
return steam_root / "config" / "config.vdf"
|
||||
|
||||
|
||||
def current(config: Path, appid: int) -> tuple[str, str] | None:
|
||||
"""The (name, priority) the game is mapped to, or None when unmapped."""
|
||||
entry = _scan(_read(config), str(appid)).entry
|
||||
if entry is None:
|
||||
return None
|
||||
return entry.values.get("name", ""), entry.values.get("priority", "")
|
||||
|
||||
|
||||
def map_app(config: Path, appid: int) -> Outcome:
|
||||
"""Point `appid` at the native Proton unless kuhy chose another tool."""
|
||||
pids = recognize.steam_client_pids()
|
||||
if pids:
|
||||
raise CompatMapError(
|
||||
"Steam is running and would overwrite config.vdf on exit -- close it first"
|
||||
)
|
||||
layout = _scan(_read(config), str(appid))
|
||||
lines = layout.lines
|
||||
entry = layout.entry
|
||||
if entry is not None:
|
||||
name = entry.values.get("name", "")
|
||||
priority = entry.values.get("priority", "")
|
||||
if name == TOOL:
|
||||
return Outcome("already")
|
||||
if name and priority != VALVE_PRIORITY:
|
||||
return Outcome("kept", f"already mapped to {name} (priority {priority})")
|
||||
key_line = entry.open_line - 1
|
||||
if lines[key_line].strip() != f'"{appid}"' or lines[entry.close_line].strip() != "}":
|
||||
raise CompatMapError(f"config.vdf line {key_line + 1}: unexpected layout")
|
||||
indent = _indent(lines[entry.open_line])
|
||||
lines[key_line : entry.close_line + 1] = _entry(appid, indent)
|
||||
_write(config, lines)
|
||||
return Outcome("mapped", f"replaced Valve's choice {name or '(empty)'}")
|
||||
if layout.mapping_open >= 0:
|
||||
indent = _indent(lines[layout.mapping_open]) + "\t"
|
||||
lines[layout.mapping_open + 1 : layout.mapping_open + 1] = _entry(appid, indent)
|
||||
else:
|
||||
one = _indent(lines[layout.steam_open]) + "\t"
|
||||
block = [f'{one}"CompatToolMapping"\n', f"{one}{{\n"]
|
||||
block += [*_entry(appid, one + "\t"), f"{one}}}\n"]
|
||||
lines[layout.steam_open + 1 : layout.steam_open + 1] = block
|
||||
_write(config, lines)
|
||||
return Outcome("mapped")
|
||||
|
||||
|
||||
def _read(config: Path) -> list[str]:
|
||||
try:
|
||||
return config.read_text(encoding="utf-8").splitlines(keepends=True)
|
||||
except OSError as exc:
|
||||
raise CompatMapError(f"cannot read {config}") from exc
|
||||
|
||||
|
||||
def _tokens(lines: list[str]) -> list[tuple[str, int, bool]]:
|
||||
"""(text, line index, is_quoted) for every token; quoted values may span lines."""
|
||||
text = "".join(lines)
|
||||
starts = [0]
|
||||
for line in lines:
|
||||
starts.append(starts[-1] + len(line))
|
||||
out: list[tuple[str, int, bool]] = []
|
||||
line_no = 0
|
||||
for match in _TOKEN.finditer(text):
|
||||
while starts[line_no + 1] <= match.start():
|
||||
line_no += 1
|
||||
token = match.group(0)
|
||||
if token[0] == '"':
|
||||
out.append((token[1:-1], line_no, True))
|
||||
elif token in "{}":
|
||||
out.append((token, line_no, False))
|
||||
else:
|
||||
raise CompatMapError(f"config.vdf line {line_no + 1}: unexpected layout")
|
||||
return out
|
||||
|
||||
|
||||
def _scan(lines: list[str], appid: str) -> _Layout:
|
||||
"""Find the Steam block, its mapping block and the app's entry."""
|
||||
layout = _Layout(lines)
|
||||
stack: list[str] = []
|
||||
pending: str | None = None
|
||||
for text, index, quoted in _tokens(lines):
|
||||
in_entry = layout.entry is not None and tuple(stack) == (*_MAPPING, appid)
|
||||
if quoted:
|
||||
if pending is None:
|
||||
pending = text
|
||||
continue
|
||||
if in_entry:
|
||||
layout.entry.values[pending.lower()] = text
|
||||
pending = None
|
||||
elif text == "{":
|
||||
if pending is None:
|
||||
raise CompatMapError(f"config.vdf line {index + 1}: block without a key")
|
||||
stack.append(pending.lower())
|
||||
pending = None
|
||||
_note_open(layout, tuple(stack), appid, index)
|
||||
else:
|
||||
if not stack or pending is not None:
|
||||
raise CompatMapError(f"config.vdf line {index + 1}: unbalanced brace")
|
||||
if in_entry:
|
||||
layout.entry.close_line = index
|
||||
stack.pop()
|
||||
if layout.steam_open < 0:
|
||||
raise CompatMapError("config.vdf has no InstallConfigStore/Software/Valve/Steam")
|
||||
return layout
|
||||
|
||||
|
||||
def _note_open(layout: _Layout, path: tuple[str, ...], appid: str, index: int) -> None:
|
||||
if path in (_STEAM, _MAPPING, (*_MAPPING, appid)) and layout.lines[index].strip() != "{":
|
||||
raise CompatMapError(f"config.vdf line {index + 1}: unexpected layout")
|
||||
if path == _STEAM:
|
||||
layout.steam_open = index
|
||||
elif path == _MAPPING:
|
||||
layout.mapping_open = index
|
||||
elif path == (*_MAPPING, appid):
|
||||
layout.entry = _Entry(open_line=index)
|
||||
|
||||
|
||||
def _indent(line: str) -> str:
|
||||
return line[: len(line) - len(line.lstrip())]
|
||||
|
||||
|
||||
def _entry(appid: int, indent: str) -> list[str]:
|
||||
inner = indent + "\t"
|
||||
return [
|
||||
f'{indent}"{appid}"\n',
|
||||
f"{indent}{{\n",
|
||||
f'{inner}"name"\t\t"{TOOL}"\n',
|
||||
f'{inner}"config"\t\t""\n',
|
||||
f'{inner}"priority"\t\t"{PRIORITY}"\n',
|
||||
f"{indent}}}\n",
|
||||
]
|
||||
|
||||
|
||||
def _write(config: Path, lines: list[str]) -> None:
|
||||
"""Replace the file atomically, keeping its permissions."""
|
||||
mode = config.stat().st_mode & 0o777
|
||||
fd, tmp = tempfile.mkstemp(dir=config.parent, prefix=".config.vdf.")
|
||||
try:
|
||||
with os.fdopen(fd, "w", encoding="utf-8") as handle:
|
||||
handle.write("".join(lines))
|
||||
os.chmod(tmp, mode)
|
||||
os.replace(tmp, config)
|
||||
except BaseException:
|
||||
Path(tmp).unlink(missing_ok=True)
|
||||
raise
|
||||
@ -1,9 +1,8 @@
|
||||
"""Remember the Steam username so every run doesn't ask for it again.
|
||||
|
||||
Only the username is ever persisted. Passwords and Steam Guard codes stay
|
||||
where they belong: with steamcmd's own cached login token (prompted through
|
||||
the pty in `runlog.run_logged`) and depotdownloader's `-remember-password`.
|
||||
Writing either of those to a dotfile would be a downgrade in security over
|
||||
where they belong: with depotdownloader's `-remember-password` login token
|
||||
(prompted through the pty in `runlog.run_logged`). Writing them to a dotfile would be a downgrade in security over
|
||||
what Steam's own tooling already does.
|
||||
"""
|
||||
|
||||
|
||||
@ -0,0 +1,53 @@
|
||||
-----BEGIN PGP PUBLIC KEY BLOCK-----
|
||||
Comment: Hostname:
|
||||
Version: Hockeypuck 2.2
|
||||
|
||||
xsDNBGERxNwBDAD1aEVN8rdWBlV2sOwkiW1ddO44xKjdumwuGhoXP1pUzK4SkNUb
|
||||
IrQ1cenckdxzZsS8cbXTvEteC4K8tTYxobZpgzAPhKZNECsyCyDf2DEYv7bS75gy
|
||||
sdl0bh+mOXPjvOe9IK3eFPQWWFd0erYyf9SHjlZ0utOg3qZ2JuVupGOH8W3taKth
|
||||
ijR98RzUqP5rPoMPKcrOdBUiIREHx0y6SwdyX0c2XKm52T3cP8O0MPsvZLbRwGU0
|
||||
DTyr7knzuGhR9tLxsy4PqKz3tSUEGM7PhFcpEoRFvV/4Al8/OpRaPj3zRn6RbL1D
|
||||
9ZAH9OblgHkQlK6MPnLOygoaAvjreMHK3ykjlRugUtnRBmQHhH+o3iXb8Ep5GXjZ
|
||||
XJZazy5ZSTbuJ8+DcjuC/G459ePnQ658od2Sxz5OBRmK3a1taAtgszHio1EHb8Db
|
||||
OZ+Za5E46VOHM/8sl8toGbK4JOqpgdQ3YqIH4R915WqCYnMvfTQbCiHLYzWHrgAA
|
||||
awBu3kaV2MagPnkAEQEAAc0bQ2FjaHlPUyA8YWRtaW5AY2FjaHlvcy5vcmc+wsEO
|
||||
BBMBCAA4AhsDBQsJCAcCBhUKCQgLAgQWAgMBAh4BAheAFiEEiC3P5I4gUdSOJWKr
|
||||
87YHSI2zWkcFAmTUdqcACgkQ87YHSI2zWkc2ygwAknD+O2LQeHp1tEYwplF9Rthq
|
||||
uPN64IxC/8nAc+L92fSOkVJKUfRh0PJcCCZgpTBAa7UV++GsT9SZ8jRtUPDfAy/R
|
||||
0TSwKkEC6b1291xNdV3O83CtkSJRTP39nVCefXrBUpIwmkQJuytBF1qypTuw4jom
|
||||
orcbmE40O7uNDe0FpZOJkUxT1sVJqj+y2h4mJsDuEAYKVQa4809yDwlQOYlLg6i3
|
||||
wEBut7PPh8bEFWycNElKseh3dpQfvFVWMcUBafpQq7Q9zVFDW3nCUkFBMErcLb0y
|
||||
VARQizrO3GqmWSU0zmgs8ruc3HnYjIfLIU68JRDsLdFgzIstEasnOskdUYywdvYw
|
||||
BeGpCQX2ZFcTosLrZc1SRAk/XKioVXeHA92dcQacBClzKCmbat0CcNng5phu9fom
|
||||
xGbNijvV5NWmQITw7j2sco0nLtfx2MiyRlR8s6pgrZ/VgfGq5K2gM306MgshgyMW
|
||||
oIELm7aUTkbY+QH4v0y+U/KUNeHetDZhsMLwZq1DwsEUBBMBCAA+FiEEiC3P5I4g
|
||||
UdSOJWKr87YHSI2zWkcFAmERxNwCGwMFCQPCZwAFCwkIBwIGFQoJCAsCBBYCAwEC
|
||||
HgECF4AACgkQ87YHSI2zWkcB8QwA5+lumQa7SItzfd5v7HJhDU9IEE6gvxhs9wPC
|
||||
UxcZmbCVj4AoP0yLXshbKpbwfpXQN+CmlnNr+U9TmUe0q6f6L7qdqIAfDGOy2BOX
|
||||
Xn/x1h5u7jeppUYpSiB4oZW2A6zHuWp1RyGSiPFO0W+k5awA8nBNnZpnCdZIjT2R
|
||||
OWCpSOpGgR8V35joq/tUxje/A1W7oaHuWnuSIz8nEqHQc9xTXbU4tFab24cxRxV+
|
||||
3U1wJ10jC0VoBPX2B7KhutgEIqwq9V2XOfRUAKO2u5IcKKwYFhjHa4O951rm+YoV
|
||||
L2fj3BNeQwwwufofEHat4GhVXhvw+oZli3PMZ/9PZBf40/T5I4m+t+4nkpyyl3ng
|
||||
Z8iW55gGKkcjgEmGBurmB+KuRbSBG6gQrYIfVvil+QFRVFh9yQJNKX7lzZpBv6M2
|
||||
tc1kC8N0jV2pTjlTwjDhn5xm3qC00FHLuvp6kNNDpnkYxYhVYR5PVLE1TOyPqL4L
|
||||
J3I93lNfpef8p6jjBEJXi6C8PL+mzsDNBGERxNwBDAC1RE2JFOjAMzqg3f5JsTa5
|
||||
1WgApe2zlS/QjD+qr2LbC0CvQK3WO/MseqnEBfnXlUrL+tCzQXG79+kJk5xHsdaI
|
||||
bblTqdX3xNbT0/+sJkLsUWbfLh1lTgs+NnltsCtg1cIKm/eOBEWyVfnrkKI+uTlQ
|
||||
DDGcHW9XGaxLaIMi8FgaitMtrvH3AdajEpvpvdAAUbeIUL/hFs6VTSs74xJRxy0J
|
||||
1eZYlZXo2YQ8EuZCAtyaQuvoDKijybxqj+FKPRiL920UI2emBYL0cwMRq1XylZST
|
||||
7xXEzrEVgQ+xEUTBOUgmbRmIJVsSE/pDy7127dwPVpTglWiwfqntgdujrl6HM2b0
|
||||
a6lV5/ZoeYL5ucu6bku0ewbkoEKhqTe1JSVYWbStW5hwGFBxCFxGpKQMMsDltmst
|
||||
8Z0Ic1Bhes00gd7LAC0AK8OkWFs4sIbHinNBVXQH/5MINF2ngm9tP9kym17Nr5Jt
|
||||
erbxOOyNYl+ZOq6HFsrMXMZ1Cx+d4diqK2GnSeCZIvMAEQEAAcLA/AQYAQgAJhYh
|
||||
BIgtz+SOIFHUjiViq/O2B0iNs1pHBQJhEcTcAhsMBQkDwmcAAAoJEPO2B0iNs1pH
|
||||
mFMMAOuyEJ93J4X5H+Jnf8/pXg2PFVvp0se7weCFha1d9umGSTrQEjivm55z1X4R
|
||||
+Jt6D/cL3wN1WnayyNEtVzTD1CiuMDNO4a+qyBmE3/tJRWyIXoZ/wdNu38rRNO/S
|
||||
dNbDWj0dCl6HCokLKSlfpP7996zymNeVX7yCw7T56jb2mTILTszyE0xYPVAKb8cR
|
||||
Zt9gUTivxQ3SPw5xVe1OXcF0Dkwx2EAAm7Alo6DMCZlqTii8Xc6KYcaSRHNdlmkk
|
||||
W3RcTMkNja5mRFhzygklh9ViXqQs+9gZB+VHDqB2iNKbHJwO40aLRo/bta1h9P0H
|
||||
DD8q8mZWkZpGBlzul0x5UMedCeYudk9tOMwFCKRrhZeAyzMRn/+FXUw7oFiWX6RX
|
||||
9ujq0O+Yna6WsWe+YN/vmT0KloTzRb0yqeDc37zc850+woYy+mNpV2+Tq6hBDajk
|
||||
+BohvFyI7T4vvs45e+GwN2fTS6oqVsc9TfO7Q8JTi5y9UqByEbNCbqY/IeIwaapR
|
||||
IqDYsg==
|
||||
=N+41
|
||||
-----END PGP PUBLIC KEY BLOCK-----
|
||||
@ -0,0 +1 @@
|
||||
{}
|
||||
@ -0,0 +1,7 @@
|
||||
# pacman-repo lock: the exact proton-cachyos-native build steam-game-installer
|
||||
# installs. The dependency-freshness gate (kuhyx/utils, pacman-repo adapter)
|
||||
# compares it with cachyos.db; bump version and sha256 together.
|
||||
name=proton-cachyos-native
|
||||
repo=https://mirror.cachyos.org/repo/x86_64/cachyos/cachyos.db
|
||||
version=1:11.0.20261015-1
|
||||
sha256=25bf302f90e8e01118555b997b873c3cd06a33b5647e79d049a59e29794b43e0
|
||||
@ -87,7 +87,7 @@ def check_ready_to_finish(
|
||||
if not (buildid and buildid != "0") and not (target and target != "0"):
|
||||
problems.append(
|
||||
"manifest has no usable buildid (both buildid and TargetBuildID are 0) "
|
||||
"-- steamcmd never recorded a real build"
|
||||
"-- no real build was ever recorded"
|
||||
)
|
||||
resolved = buildid if buildid and buildid != "0" else target
|
||||
if expected_build_id is None:
|
||||
|
||||
@ -10,6 +10,7 @@ from pathlib import Path
|
||||
|
||||
from steam_installer import (
|
||||
appinfo,
|
||||
compat_apply,
|
||||
depotdl,
|
||||
dlc,
|
||||
manifest_write,
|
||||
@ -50,6 +51,7 @@ def install(
|
||||
*,
|
||||
args,
|
||||
log: runlog.RunLog,
|
||||
steam_root: Path,
|
||||
library: SteamLibrary,
|
||||
metadata: appinfo.AppMetadata,
|
||||
install_target: Path,
|
||||
@ -64,9 +66,22 @@ def install(
|
||||
if steam_was_running is None:
|
||||
return 1
|
||||
try:
|
||||
return _download_and_recognize(
|
||||
returncode = _download_and_recognize(
|
||||
args, log, library, metadata, install_target, staged, username, language
|
||||
)
|
||||
if returncode == 0:
|
||||
# Still inside the window where Steam is closed: config.vdf written
|
||||
# under a running client is lost when it exits.
|
||||
cached = recognize.discover_cached_depot_manifests(install_target)
|
||||
dlc_depots = appinfo.get_depot_plan(metadata.appid, language).dlc
|
||||
compat_apply.after_install(
|
||||
steam_root,
|
||||
metadata.appid,
|
||||
owned_dlc=bool(set(dlc_depots) & set(cached)),
|
||||
valve_proton=args.valve_proton,
|
||||
logger=logger,
|
||||
)
|
||||
return returncode
|
||||
finally:
|
||||
if steam_was_running:
|
||||
steamctl.start(logger)
|
||||
|
||||
125
_installer_import/steam_installer/map_installed.py
Normal file
125
_installer_import/steam_installer/map_installed.py
Normal file
@ -0,0 +1,125 @@
|
||||
"""`--map-installed`: run the compat decision over every installed game.
|
||||
|
||||
./run.sh --map-installed # dry run: print, write nothing
|
||||
./run.sh --map-installed --apply # close Steam, map the safe ones
|
||||
./run.sh --map-installed --appids 730,10 # decide any cached app (read-only)
|
||||
|
||||
The dry run only reads, so it works with Steam open. `--apply` closes Steam
|
||||
first (it rewrites config.vdf on exit) and restarts it afterwards.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
from pathlib import Path
|
||||
|
||||
from steam_installer import (
|
||||
appinfo,
|
||||
compat_apply,
|
||||
compat_map,
|
||||
flow,
|
||||
recognize,
|
||||
runlog,
|
||||
steamctl,
|
||||
)
|
||||
from steam_installer.library import SteamLibrary, list_libraries
|
||||
|
||||
# Steam's own compat tools and runtimes are apps too, but not games.
|
||||
TOOL_TYPES = {"tool", "config"}
|
||||
|
||||
|
||||
def add_arguments(parser: argparse.ArgumentParser) -> None:
|
||||
parser.add_argument(
|
||||
"--valve-proton",
|
||||
action="store_true",
|
||||
help="Keep this game on Valve's default Proton for this run.",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--map-installed",
|
||||
action="store_true",
|
||||
help="Decide every installed game's compat tool. Dry run unless --apply.",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--apply", action="store_true", help="With --map-installed: write the mappings."
|
||||
)
|
||||
parser.add_argument(
|
||||
"--appids",
|
||||
default=None,
|
||||
help="With --map-installed: comma-separated app ids to decide instead.",
|
||||
)
|
||||
|
||||
|
||||
def check_arguments(parser: argparse.ArgumentParser, args: argparse.Namespace) -> None:
|
||||
if args.map_installed and args.valve_proton:
|
||||
parser.error("--valve-proton goes with an install, not --map-installed")
|
||||
|
||||
|
||||
def _installed(libraries: list[SteamLibrary]) -> dict[int, dict]:
|
||||
"""appid -> AppState for every manifest in every library."""
|
||||
found: dict[int, dict] = {}
|
||||
for library in libraries:
|
||||
for manifest in sorted(library.steamapps.glob("appmanifest_*.acf")):
|
||||
appid = manifest.stem.removeprefix("appmanifest_")
|
||||
if appid.isdigit():
|
||||
found[int(appid)] = recognize.read_app_state(manifest)
|
||||
return found
|
||||
|
||||
|
||||
def _owned_dlc(app_state: dict) -> bool:
|
||||
depots = app_state.get("InstalledDepots")
|
||||
entries = depots.values() if isinstance(depots, dict) else []
|
||||
return any(isinstance(entry, dict) and "dlcappid" in entry for entry in entries)
|
||||
|
||||
|
||||
def _is_tool(block: dict) -> bool:
|
||||
common = block.get("common")
|
||||
kind = common.get("type", "") if isinstance(common, dict) else ""
|
||||
return isinstance(kind, str) and kind.lower() in TOOL_TYPES
|
||||
|
||||
|
||||
def run(args: argparse.Namespace, log: runlog.RunLog, steam_root: Path) -> int:
|
||||
logger = log.logger
|
||||
installed = _installed(list_libraries(steam_root))
|
||||
if args.appids:
|
||||
appids = [int(x) for x in args.appids.split(",") if x.strip().isdigit()]
|
||||
else:
|
||||
appids = sorted(installed)
|
||||
context = compat_apply.Context(steam_root)
|
||||
blocks = appinfo._cached_blocks(appids)
|
||||
to_map: list[int] = []
|
||||
for appid in appids:
|
||||
block = blocks.get(appid)
|
||||
if block is None:
|
||||
logger.info("%s: not in Steam's app cache -- skipped", appid)
|
||||
continue
|
||||
if _is_tool(block) and not args.appids:
|
||||
continue
|
||||
name = block.get("common", {}).get("name", "?")
|
||||
decision = context.decide(appid, block, _owned_dlc(installed.get(appid, {})))
|
||||
line = f"{appid} {name}: {decision.describe()}"
|
||||
if decision.map:
|
||||
to_map.append(appid)
|
||||
current = compat_map.current(context.config, appid)
|
||||
if current and current[0] == compat_map.TOOL:
|
||||
line += " -- already mapped"
|
||||
logger.info("%s", line)
|
||||
if not args.apply:
|
||||
logger.info("Dry run: nothing written. Rerun with --apply to write.")
|
||||
return 0
|
||||
return _apply(args, logger, context.config, to_map)
|
||||
|
||||
|
||||
def _apply(args, logger, config, to_map: list[int]) -> int:
|
||||
was_running = flow._prepare_steam(args, logger)
|
||||
if was_running is None:
|
||||
return 1
|
||||
try:
|
||||
for appid in to_map:
|
||||
compat_apply.report(logger, appid, compat_map.map_app(config, appid))
|
||||
except compat_map.CompatMapError as exc:
|
||||
logger.error("Mapping stopped: %s", exc)
|
||||
return 1
|
||||
finally:
|
||||
if was_running:
|
||||
steamctl.start(logger)
|
||||
return 0
|
||||
173
_installer_import/steam_installer/proton_native.py
Normal file
173
_installer_import/steam_installer/proton_native.py
Normal file
@ -0,0 +1,173 @@
|
||||
"""Install the pinned proton-cachyos-native build into Steam's compatibilitytools.d.
|
||||
|
||||
python -m steam_installer.proton_native # what install.sh runs
|
||||
python -m steam_installer.proton_native --check # exit 0 when in place
|
||||
|
||||
The package comes straight from the CachyOS mirror: the `proton-cachyos-native`
|
||||
entry of `cachyos.db`, its signature and sha256 checked (see :mod:`proton_pkg`),
|
||||
and only `usr/share/steam/compatibilitytools.d/proton-cachyos-native/` taken
|
||||
out of it. Its `.INSTALL` is never run. It is a WoW64 build that needs no
|
||||
lib32 packages, and unlike the `-slr` variant its toolmanifest requires no
|
||||
Steam Linux Runtime -- which is the point.
|
||||
|
||||
A `VERSION` stamp equal to the lock means there is nothing to do and no
|
||||
network is touched. Otherwise the new build is extracted next to the old one
|
||||
and swapped in by rename -- never while Steam or a game from the tool runs,
|
||||
since a game would lose its files mid-run. A copy already on disk with no
|
||||
stamp is adopted as is when every file matches the package's `.MTREE`.
|
||||
|
||||
`SGI_PROTON_REPO` points the fetch at another copy of the repo db (a local
|
||||
test mirror); the pinned key and sha256 still decide what is accepted.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import dataclasses
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import urllib.request
|
||||
from pathlib import Path
|
||||
|
||||
from steam_installer import proton_pkg, recognize
|
||||
from steam_installer.library import find_steam_root
|
||||
from steam_installer.proton_pkg import FINGERPRINT, KEY, Lock, PkgError
|
||||
|
||||
TOOL_NAME = "proton-cachyos-native"
|
||||
|
||||
|
||||
def in_use(tool: Path) -> list[int]:
|
||||
"""Steam client pids plus every process running from the tool folder."""
|
||||
pids = list(recognize.steam_client_pids())
|
||||
root = tool.resolve()
|
||||
for entry in recognize.PROC_DIR.iterdir():
|
||||
if not entry.name.isdigit():
|
||||
continue
|
||||
try:
|
||||
exe = (entry / "exe").resolve(strict=True)
|
||||
except OSError:
|
||||
continue
|
||||
if exe.is_relative_to(root):
|
||||
pids.append(int(entry.name))
|
||||
return pids
|
||||
|
||||
|
||||
def _download(url: str, dest: Path) -> None:
|
||||
with urllib.request.urlopen(url, timeout=60) as response, dest.open("wb") as out:
|
||||
shutil.copyfileobj(response, out, 1 << 20)
|
||||
|
||||
|
||||
def _fetch_verified(lock: Lock, work: Path, key: Path, fingerprint: str) -> Path:
|
||||
"""Download the pinned package and prove it, or raise PkgError."""
|
||||
db = work / "repo.db"
|
||||
_download(lock.repo, db)
|
||||
entry = proton_pkg.find_in_db(db, lock.name)
|
||||
if entry.version != lock.version:
|
||||
raise PkgError(
|
||||
f"the repo serves {lock.name} {entry.version} but the lock pins "
|
||||
f"{lock.version}: bump steam_installer/data/proton-native.lock "
|
||||
"(version and sha256)"
|
||||
)
|
||||
if entry.sha256 != lock.sha256:
|
||||
raise PkgError("the repo's sha256 for the pinned version differs from the lock")
|
||||
package = work / entry.filename
|
||||
url = proton_pkg.package_url(lock, entry.filename)
|
||||
_download(url, package)
|
||||
sig = work / f"{entry.filename}.sig"
|
||||
_download(f"{url}.sig", sig)
|
||||
home = work / "gnupg"
|
||||
home.mkdir(mode=0o700)
|
||||
try:
|
||||
proton_pkg.verify_signature(package, sig, key, fingerprint, home)
|
||||
finally:
|
||||
subprocess.run(
|
||||
["gpgconf", "--homedir", str(home), "--kill", "all"],
|
||||
check=False, capture_output=True,
|
||||
)
|
||||
if proton_pkg.sha256_file(package) != lock.sha256:
|
||||
raise PkgError("the downloaded package's sha256 differs from the pinned sha256")
|
||||
return package
|
||||
|
||||
|
||||
def _stamp(tool: Path, version: str) -> None:
|
||||
(tool / "VERSION").write_text(version + "\n")
|
||||
|
||||
|
||||
def _swap(package: Path, tools_dir: Path, tool: Path, version: str) -> None:
|
||||
new = tools_dir / f".{TOOL_NAME}.new"
|
||||
old = tools_dir / f".{TOOL_NAME}.old"
|
||||
for leftover in (new, old):
|
||||
shutil.rmtree(leftover, ignore_errors=True)
|
||||
new.mkdir()
|
||||
proton_pkg.extract(package, new)
|
||||
if tool.exists():
|
||||
tool.rename(old)
|
||||
new.rename(tool)
|
||||
shutil.rmtree(old, ignore_errors=True)
|
||||
_stamp(tool, version)
|
||||
|
||||
|
||||
def ensure(
|
||||
tools_dir: Path, lock: Lock, *, key: Path = KEY, fingerprint: str = FINGERPRINT
|
||||
) -> str:
|
||||
"""Make `tools_dir/proton-cachyos-native` the pinned build; return what happened."""
|
||||
tool = tools_dir / TOOL_NAME
|
||||
stamp = tool / "VERSION"
|
||||
current = stamp.read_text().strip() if stamp.is_file() else None
|
||||
if current == lock.version:
|
||||
return f"current: {lock.version}"
|
||||
tools_dir.mkdir(parents=True, exist_ok=True)
|
||||
work = Path(tempfile.mkdtemp(dir=tools_dir, prefix=".proton-download."))
|
||||
try:
|
||||
package = _fetch_verified(lock, work, key, fingerprint)
|
||||
checks = f"signature by {fingerprint} and sha256 both passed"
|
||||
if not tool.exists():
|
||||
verb = f"installed: {lock.version}"
|
||||
elif current is not None:
|
||||
verb = f"updated: {current} -> {lock.version}"
|
||||
else:
|
||||
entries = proton_pkg.read_mtree(package)
|
||||
mismatch = proton_pkg.first_mismatch(tool, entries)
|
||||
if mismatch is None:
|
||||
_stamp(tool, lock.version)
|
||||
count = sum(entry.kind != "dir" for entry in entries.values())
|
||||
return f"adopted: all {count} files match .MTREE ({checks})"
|
||||
verb = f"replaced: mismatch in {mismatch}"
|
||||
busy = in_use(tool) if tool.exists() else []
|
||||
if busy:
|
||||
return (
|
||||
f"deferred: Steam or a game is running (pid {', '.join(map(str, busy))}); "
|
||||
"rerun with Steam closed"
|
||||
)
|
||||
_swap(package, tools_dir, tool, lock.version)
|
||||
return f"{verb} ({checks})"
|
||||
finally:
|
||||
shutil.rmtree(work, ignore_errors=True)
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> int:
|
||||
"""Install the pinned build; with `--check`, only say whether it is in place."""
|
||||
lock = proton_pkg.read_lock()
|
||||
if os.environ.get("SGI_PROTON_REPO"):
|
||||
lock = dataclasses.replace(lock, repo=os.environ["SGI_PROTON_REPO"])
|
||||
try:
|
||||
tools_dir = find_steam_root() / "compatibilitytools.d"
|
||||
except FileNotFoundError:
|
||||
print("native Proton skipped: no Steam installation")
|
||||
return 0
|
||||
if argv and argv[0] == "--check":
|
||||
stamp = tools_dir / TOOL_NAME / "VERSION"
|
||||
return 0 if stamp.is_file() and stamp.read_text().strip() == lock.version else 1
|
||||
try:
|
||||
status = ensure(tools_dir, lock)
|
||||
except (PkgError, OSError) as exc:
|
||||
print(f"error: native Proton: {exc}", file=sys.stderr)
|
||||
return 1
|
||||
print(f"native Proton {status}")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main(sys.argv[1:]))
|
||||
208
_installer_import/steam_installer/proton_pkg.py
Normal file
208
_installer_import/steam_installer/proton_pkg.py
Normal file
@ -0,0 +1,208 @@
|
||||
"""The CachyOS package formats and the two checks every download must pass.
|
||||
|
||||
The repo database is not signed, so nothing in it is trusted on its own:
|
||||
- the package's detached `.sig` must verify against the CachyOS key pinned in
|
||||
`data/cachyos_signing_key.asc`, by primary-key fingerprint, in a throwaway
|
||||
gpg home that holds that key and nothing else;
|
||||
- the package's sha256 must equal both the db entry and the pinned lock.
|
||||
Either failing stops the install before anything is extracted.
|
||||
|
||||
Pinned key: 882DCFE48E2051D48E2562ABF3B607488DB35A47 ("CachyOS
|
||||
<admin@cachyos.org>"). The .sig names its own issuer, so it could not vouch
|
||||
for the pin. Taken on 2026-11-22 from two other sources instead:
|
||||
https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x882DCFE48E2051D48E2562ABF3B607488DB35A47
|
||||
(the key file) and the long id F3B607488DB35A47 that CachyOS's own installer
|
||||
imports, https://github.com/CachyOS/cachyos-repo-add-script/blob/5b27dc1eff276e104077cfaf75798b4c290eaef4/cachyos-repo.sh#L156
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import gzip
|
||||
import hashlib
|
||||
import re
|
||||
import subprocess
|
||||
import tarfile
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
from urllib.parse import quote
|
||||
|
||||
DATA = Path(__file__).parent / "data"
|
||||
LOCK = DATA / "proton-native.lock"
|
||||
KEY = DATA / "cachyos_signing_key.asc"
|
||||
FINGERPRINT = "882DCFE48E2051D48E2562ABF3B607488DB35A47"
|
||||
PREFIX = "usr/share/steam/compatibilitytools.d/proton-cachyos-native/"
|
||||
|
||||
|
||||
class PkgError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Lock:
|
||||
name: str
|
||||
repo: str # URL of the <repo>.db
|
||||
version: str
|
||||
sha256: str
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class DbEntry:
|
||||
filename: str
|
||||
version: str
|
||||
sha256: str
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class MtreeEntry:
|
||||
kind: str # "file", "link" or "dir"
|
||||
sha256: str = ""
|
||||
link: str = ""
|
||||
|
||||
|
||||
def read_lock(path: Path = LOCK) -> Lock:
|
||||
fields = {}
|
||||
for line in path.read_text().splitlines():
|
||||
if line.strip() and not line.lstrip().startswith("#"):
|
||||
key, _, value = line.partition("=")
|
||||
fields[key.strip()] = value.strip()
|
||||
try:
|
||||
return Lock(fields["name"], fields["repo"], fields["version"], fields["sha256"])
|
||||
except KeyError as exc:
|
||||
raise PkgError(f"{path.name} has no {exc.args[0]}=") from exc
|
||||
|
||||
|
||||
def package_url(lock: Lock, filename: str) -> str:
|
||||
"""The package sits next to the db; the epoch colon must be escaped."""
|
||||
return f"{lock.repo.rsplit('/', 1)[0]}/{quote(filename)}"
|
||||
|
||||
|
||||
def find_in_db(db: Path, name: str) -> DbEntry:
|
||||
"""The db entry whose %NAME% is exactly `name` (not `<name>-v3`)."""
|
||||
with tarfile.open(db, "r:*") as tar:
|
||||
for member in tar:
|
||||
if not member.name.endswith("/desc"):
|
||||
continue
|
||||
fields = _desc(tar.extractfile(member).read().decode())
|
||||
if fields.get("NAME") == name:
|
||||
return DbEntry(fields["FILENAME"], fields["VERSION"], fields["SHA256SUM"])
|
||||
raise PkgError(f"the repo database lists no {name}")
|
||||
|
||||
|
||||
def _desc(text: str) -> dict[str, str]:
|
||||
fields: dict[str, str] = {}
|
||||
for block in text.strip().split("\n\n"):
|
||||
head, _, value = block.partition("\n")
|
||||
fields[head.strip("%")] = value.strip()
|
||||
return fields
|
||||
|
||||
|
||||
def sha256_file(path: Path) -> str:
|
||||
digest = hashlib.sha256()
|
||||
with path.open("rb") as handle:
|
||||
for chunk in iter(lambda: handle.read(1 << 20), b""):
|
||||
digest.update(chunk)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
def _gpg(home: Path, *args: str) -> subprocess.CompletedProcess:
|
||||
return subprocess.run(
|
||||
["gpg", "--homedir", str(home), "--batch", "--no-tty", *args],
|
||||
capture_output=True, text=True, check=False, timeout=60,
|
||||
)
|
||||
|
||||
|
||||
def key_fingerprints(key: Path, home: Path) -> list[str]:
|
||||
"""Primary-key fingerprints in `key`, imported into the empty `home`."""
|
||||
_gpg(home, "--import", str(key))
|
||||
listing = _gpg(home, "--with-colons", "--fingerprint").stdout.splitlines()
|
||||
out, after_pub = [], False
|
||||
for line in listing:
|
||||
if line.startswith("pub"):
|
||||
after_pub = True
|
||||
elif line.startswith("fpr") and after_pub:
|
||||
out.append(line.split(":")[9])
|
||||
after_pub = False
|
||||
return out
|
||||
|
||||
|
||||
def verify_signature(package: Path, sig: Path, key: Path, fingerprint: str, home: Path) -> None:
|
||||
"""Fail unless `sig` is a good signature by the pinned primary key."""
|
||||
if fingerprint not in key_fingerprints(key, home):
|
||||
raise PkgError("the pinned key file does not hold the pinned fingerprint")
|
||||
result = _gpg(home, "--status-fd", "1", "--verify", str(sig), str(package))
|
||||
signers = [
|
||||
line.split()[-1]
|
||||
for line in result.stdout.splitlines()
|
||||
if line.startswith("[GNUPG:] VALIDSIG ")
|
||||
]
|
||||
if result.returncode != 0 or signers != [fingerprint]:
|
||||
raise PkgError(f"package signature does not verify against {fingerprint}")
|
||||
|
||||
|
||||
def _unescape(path: str) -> str:
|
||||
return re.sub(r"\\([0-7]{3})", lambda m: chr(int(m.group(1), 8)), path)
|
||||
|
||||
|
||||
def read_mtree(package: Path) -> dict[str, MtreeEntry]:
|
||||
"""The package's own file list for the tool folder, relative to it."""
|
||||
with tarfile.open(package, "r:zst") as tar:
|
||||
for member in tar:
|
||||
if member.name == ".MTREE":
|
||||
text = gzip.decompress(tar.extractfile(member).read()).decode()
|
||||
break
|
||||
else:
|
||||
raise PkgError("package has no .MTREE")
|
||||
entries: dict[str, MtreeEntry] = {}
|
||||
defaults: dict[str, str] = {}
|
||||
for line in text.splitlines():
|
||||
if not line or line.startswith("#"):
|
||||
continue
|
||||
path, *pairs = line.split(" ")
|
||||
values = dict(pair.partition("=")[::2] for pair in pairs)
|
||||
if path == "/set":
|
||||
defaults.update(values)
|
||||
continue
|
||||
path = _unescape(path.removeprefix("./"))
|
||||
if not path.startswith(PREFIX) or path == PREFIX:
|
||||
continue
|
||||
values = {**defaults, **values}
|
||||
entries[path[len(PREFIX):]] = MtreeEntry(
|
||||
values.get("type", "file"), values.get("sha256digest", ""), values.get("link", "")
|
||||
)
|
||||
return entries
|
||||
|
||||
|
||||
def first_mismatch(folder: Path, entries: dict[str, MtreeEntry]) -> str | None:
|
||||
"""The first path where `folder` differs from the package, or None.
|
||||
|
||||
Files the package does not list count as a difference (a stray
|
||||
user_settings.py changes how Proton runs), except Python's own
|
||||
`__pycache__`, which running protonfixes creates.
|
||||
"""
|
||||
for rel, entry in sorted(entries.items()):
|
||||
path = folder / rel
|
||||
if entry.kind == "link":
|
||||
if not path.is_symlink() or str(path.readlink()) != entry.link:
|
||||
return rel
|
||||
elif entry.kind == "file" and (
|
||||
path.is_symlink() or not path.is_file() or sha256_file(path) != entry.sha256
|
||||
):
|
||||
return rel
|
||||
for path in sorted(folder.rglob("*")):
|
||||
if path.is_dir() and not path.is_symlink():
|
||||
continue
|
||||
rel = str(path.relative_to(folder))
|
||||
if rel not in entries and "__pycache__" not in path.parts and rel != "VERSION":
|
||||
return rel
|
||||
return None
|
||||
|
||||
|
||||
def extract(package: Path, dest: Path) -> None:
|
||||
"""Unpack only the tool folder into `dest`; scripts are never run."""
|
||||
with tarfile.open(package, "r:zst") as tar:
|
||||
members = []
|
||||
for member in tar.getmembers():
|
||||
if member.name.startswith(PREFIX) and member.name != PREFIX:
|
||||
member.name = member.name[len(PREFIX):]
|
||||
members.append(member)
|
||||
tar.extractall(dest, members=members, filter="data")
|
||||
@ -1,7 +1,7 @@
|
||||
"""Read-only questions about whether Steam will see an install as real.
|
||||
|
||||
Split on 2026-09-25 (250-line cap): steamcmd's validate run now lives in
|
||||
:mod:`steamcmd_validate`, every manifest write in :mod:`manifest_write`, and
|
||||
Split on 2026-09-25 (250-line cap): every manifest write lives in
|
||||
:mod:`manifest_write`, and
|
||||
the preconditions for writing in :mod:`finish_check`. What stays here is the
|
||||
shared vocabulary they all read: depotdownloader's cache, Steam's staging tree
|
||||
and client process, and whether a manifest's bookkeeping says "done".
|
||||
|
||||
@ -8,10 +8,10 @@ log records the manifest *verbatim, before and after* every write, alongside the
|
||||
full output of every subprocess.
|
||||
|
||||
Subprocess output is teed through a pty rather than captured with
|
||||
`capture_output=True`. steamcmd prompts for a password (and possibly a Steam
|
||||
Guard code) on stdin; prompt text written to a captured/buffered pipe never
|
||||
`capture_output=True`. depotdownloader prompts for a password (and possibly a
|
||||
Steam Guard code) on stdin; prompt text written to a captured/buffered pipe never
|
||||
reaches the terminal, so the process looks hung with no visible request for
|
||||
input. A pty keeps steamcmd in line-buffered interactive mode and lets us
|
||||
input. A pty keeps it in line-buffered interactive mode and lets us
|
||||
mirror every byte to both the terminal and the log.
|
||||
"""
|
||||
|
||||
@ -110,7 +110,7 @@ def run_logged(
|
||||
"""Run `cmd` on a pty, mirroring output to both the terminal and the log.
|
||||
|
||||
Returns (returncode, combined_output). stdin stays attached to the real
|
||||
terminal so interactive prompts (steamcmd's password / Steam Guard) work
|
||||
terminal so interactive prompts (depotdownloader's password / Steam Guard) work
|
||||
exactly as they do without logging.
|
||||
"""
|
||||
logger.debug("$ %s", shlex.join(cmd))
|
||||
@ -139,7 +139,7 @@ def run_logged(
|
||||
except subprocess.TimeoutExpired as exc:
|
||||
# Record what the child managed to say before it hung, then re-raise.
|
||||
# Losing it here defeats the whole point of the log in precisely the
|
||||
# case where it matters most -- a steamcmd hang at the 3600s timeout.
|
||||
# case where it matters most -- a download hung until its timeout.
|
||||
output = _log_output(logger, chunks, started, returncode=None)
|
||||
process.wait()
|
||||
exc.output = output.encode()
|
||||
@ -177,7 +177,7 @@ def _read_pty(fd: int, size: int) -> bytes:
|
||||
def _stdin_for_child(slave_fd: int) -> int:
|
||||
"""The child's stdin: the real terminal when there is one, else the pty.
|
||||
|
||||
steamcmd needs a readable stdin to prompt for a password, but `sys.stdin`
|
||||
depotdownloader needs a readable stdin to prompt for a password, but `sys.stdin`
|
||||
is not always a real file descriptor -- under pytest's capture, systemd, or
|
||||
a piped invocation it has no fileno(). Falling back to the pty's slave end
|
||||
keeps the child on a terminal-like stdin instead of crashing.
|
||||
|
||||
@ -8,8 +8,8 @@ Four accepted forms, all resolving to the same app:
|
||||
BeamNG.drive
|
||||
BeamNG
|
||||
|
||||
Whatever the input, the appid is always confirmed through steamcmd's own
|
||||
`app_info_print` before anything acts on it, so the name and installdir used
|
||||
Whatever the input, the appid is always confirmed against Steam's own app
|
||||
cache (`appcache/appinfo.vdf`) before anything acts on it, so the name and installdir used
|
||||
downstream come from Steam rather than from a search index that ranks
|
||||
"Portal 2" above "Portal".
|
||||
"""
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
"""Minimal reader/writer for Valve's KeyValues (VDF) text format.
|
||||
|
||||
Steam uses this format for appmanifest_*.acf, libraryfolders.vdf, and
|
||||
steamcmd's `app_info_print` output. Only the plain-text variant is
|
||||
Steam uses this format for appmanifest_*.acf and libraryfolders.vdf.
|
||||
(Its binary cousin, appcache/appinfo.vdf, is read by :mod:`appinfo_cache`.) Only the plain-text variant is
|
||||
supported (no binary VDF) -- that covers every file this project touches.
|
||||
"""
|
||||
|
||||
|
||||
121
_installer_import/tests/_proton_fixture.py
Normal file
121
_installer_import/tests/_proton_fixture.py
Normal file
@ -0,0 +1,121 @@
|
||||
"""A tiny fake CachyOS repo: a signed proton package, its db and the signing key.
|
||||
|
||||
Built for real (zstd tars, a gzip .MTREE, a gpg detached signature from a
|
||||
throwaway ed25519 key) so the fetcher's checks run against the same formats
|
||||
the real mirror serves.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import gzip
|
||||
import hashlib
|
||||
import io
|
||||
import subprocess
|
||||
import tarfile
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
|
||||
PREFIX = "usr/share/steam/compatibilitytools.d/proton-cachyos-native/"
|
||||
VERSION = "1:11.0.20261015-1"
|
||||
FILENAME = f"proton-cachyos-native-{VERSION}-x86_64.pkg.tar.zst"
|
||||
FILES = {
|
||||
"toolmanifest.vdf": b'"manifest"\n{\n "commandline" "/proton %verb%"\n}\n',
|
||||
"proton": b"#!/usr/bin/env python3\n",
|
||||
"files/bin/wine": b"\x7fELF wine",
|
||||
"user settings.py": b"# a name with a space\n",
|
||||
}
|
||||
LINKS = {"files/bin/msidb": "wine"}
|
||||
|
||||
|
||||
@dataclass
|
||||
class Repo:
|
||||
root: Path # served as the mirror: holds cachyos.db, the package, the .sig
|
||||
key: Path
|
||||
fingerprint: str
|
||||
sha256: str
|
||||
gpg_home: Path
|
||||
|
||||
@property
|
||||
def db_url(self) -> str:
|
||||
return (self.root / "cachyos.db").as_uri()
|
||||
|
||||
@property
|
||||
def package(self) -> Path:
|
||||
return self.root / FILENAME
|
||||
|
||||
|
||||
def _mtree() -> bytes:
|
||||
lines = ["#mtree", "/set type=file uid=0 gid=0 mode=644"]
|
||||
lines.append("./.INSTALL time=1.0 size=3 sha256digest=00")
|
||||
lines.append(f"./{PREFIX.rstrip('/')} time=1.0 mode=755 type=dir")
|
||||
for name, data in FILES.items():
|
||||
digest = hashlib.sha256(data).hexdigest()
|
||||
path = (PREFIX + name).replace(" ", "\\040")
|
||||
lines.append(f"./{path} time=1.0 size={len(data)} sha256digest={digest}")
|
||||
for name, target in LINKS.items():
|
||||
lines.append(f"./{PREFIX}{name} time=1.0 mode=777 type=link link={target}")
|
||||
return gzip.compress(("\n".join(lines) + "\n").encode())
|
||||
|
||||
|
||||
def _add(tar: tarfile.TarFile, name: str, data: bytes) -> None:
|
||||
info = tarfile.TarInfo(name)
|
||||
info.size = len(data)
|
||||
tar.addfile(info, io.BytesIO(data))
|
||||
|
||||
|
||||
def build_package(path: Path, files: dict[str, bytes] = FILES) -> None:
|
||||
with tarfile.open(path, "w:zst") as tar:
|
||||
_add(tar, ".INSTALL", b"rm -rf /\n") # never run, never extracted
|
||||
_add(tar, ".MTREE", _mtree())
|
||||
_add(tar, "usr/bin/stray", b"outside the tool folder")
|
||||
for name, data in files.items():
|
||||
_add(tar, PREFIX + name, data)
|
||||
for name, target in LINKS.items():
|
||||
info = tarfile.TarInfo(PREFIX + name)
|
||||
info.type = tarfile.SYMTYPE
|
||||
info.linkname = target
|
||||
tar.addfile(info)
|
||||
|
||||
|
||||
def build_db(path: Path, version: str, sha256: str, name: str = "proton-cachyos-native") -> None:
|
||||
desc = (
|
||||
f"%FILENAME%\n{name}-{version}-x86_64.pkg.tar.zst\n\n%NAME%\n{name}\n\n"
|
||||
f"%VERSION%\n{version}\n\n%SHA256SUM%\n{sha256}\n\n"
|
||||
).encode()
|
||||
other = b"%NAME%\nproton-cachyos-native-v3\n\n%VERSION%\n9:9-9\n\n"
|
||||
with tarfile.open(path, "w:zst") as tar:
|
||||
_add(tar, "proton-cachyos-native-v3-9:9-9/desc", other)
|
||||
_add(tar, f"{name}-{version}/desc", desc)
|
||||
|
||||
|
||||
def gpg(home: Path, *args: str) -> None:
|
||||
subprocess.run(
|
||||
["gpg", "--homedir", str(home), "--batch", "--passphrase", "", *args],
|
||||
check=True,
|
||||
capture_output=True,
|
||||
)
|
||||
|
||||
|
||||
def build_repo(tmp: Path) -> Repo:
|
||||
root = tmp / "mirror"
|
||||
root.mkdir()
|
||||
home = tmp / "signer"
|
||||
home.mkdir(mode=0o700)
|
||||
gpg(home, "--quick-gen-key", "Fake CachyOS <fake@example.invalid>", "ed25519", "sign", "never")
|
||||
listing = subprocess.run(
|
||||
["gpg", "--homedir", str(home), "--with-colons", "--fingerprint"],
|
||||
check=True, capture_output=True, text=True,
|
||||
).stdout
|
||||
fingerprint = next(line.split(":")[9] for line in listing.splitlines() if line.startswith("fpr"))
|
||||
key = tmp / "key.asc"
|
||||
gpg(home, "--armor", "--output", str(key), "--export", fingerprint)
|
||||
package = root / FILENAME
|
||||
build_package(package)
|
||||
gpg(home, "--output", f"{package}.sig", "--detach-sign", str(package))
|
||||
sha256 = hashlib.sha256(package.read_bytes()).hexdigest()
|
||||
build_db(root / "cachyos.db", VERSION, sha256)
|
||||
return Repo(root, key, fingerprint, sha256, home)
|
||||
|
||||
|
||||
def stop_agent(home: Path) -> None:
|
||||
subprocess.run(["gpgconf", "--homedir", str(home), "--kill", "all"], check=False)
|
||||
@ -194,3 +194,34 @@ def steam(tmp_path, monkeypatch):
|
||||
# Prompting is tty-gated now, and pytest's stdin is not a tty.
|
||||
monkeypatch.setattr(cli, "_is_interactive", lambda args: True)
|
||||
return library, install_dir
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def _no_live_compat_side_effects(request, tmp_path, monkeypatch):
|
||||
"""No test may fetch the anti-cheat list or read the real app cache.
|
||||
|
||||
The modules that test those seams themselves (with their own fakes) are
|
||||
exempt from the part they cover.
|
||||
"""
|
||||
from steam_installer import anticheat, appinfo_cache
|
||||
|
||||
def offline():
|
||||
raise OSError("tests are offline")
|
||||
|
||||
module = request.node.module.__name__
|
||||
if not request.node.name.startswith("test_anticheat_download"):
|
||||
monkeypatch.setattr(anticheat, "_download", offline)
|
||||
monkeypatch.setattr(anticheat, "CACHE", tmp_path / "no-anticheat-cache.json")
|
||||
if module != "test_appinfo_cache":
|
||||
monkeypatch.setattr(
|
||||
appinfo_cache, "default_path", lambda: tmp_path / "no-appinfo.vdf"
|
||||
)
|
||||
# The live Steam client is never seen, stopped or started by a test: an
|
||||
# unstubbed --apply run once shut down and relaunched kuhy's real Steam.
|
||||
from steam_installer import steamctl
|
||||
|
||||
if module in ("test_steamctl", "test_recognize"):
|
||||
return # these fake subprocess and /proc themselves
|
||||
monkeypatch.setattr(recognize, "steam_client_pids", list)
|
||||
monkeypatch.setattr(steamctl, "stop", lambda *a, **k: pytest.fail("real steam stop"))
|
||||
monkeypatch.setattr(steamctl, "start", lambda *a, **k: pytest.fail("real steam start"))
|
||||
|
||||
@ -202,3 +202,10 @@ def test_get_build_id_handles_non_dict_sections(monkeypatch):
|
||||
def test_get_build_id_returns_none_when_buildid_not_a_string(monkeypatch):
|
||||
_app_block(monkeypatch, {"depots": {"branches": {"public": {"buildid": {}}}}})
|
||||
assert appinfo.get_build_id(1) is None
|
||||
|
||||
|
||||
def test_a_shared_install_without_an_owner_is_still_shared(monkeypatch):
|
||||
_app_block(monkeypatch, {"depots": {"5": {"sharedinstall": "1"}, "6": {"depotfromapp": "228980"}}})
|
||||
plan = appinfo.get_depot_plan(1)
|
||||
assert plan.shared == {"5", "6"}
|
||||
assert plan.shared_owner == {"6": "228980"}
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
"""Steam's local binary app-info cache, read without steamcmd."""
|
||||
|
||||
import pytest
|
||||
from steam_installer import appinfo_cache
|
||||
|
||||
from _appinfo_blob import encode
|
||||
|
||||
from steam_installer import appinfo_cache
|
||||
|
||||
|
||||
def _write(tmp_path, apps):
|
||||
path = tmp_path / "appinfo.vdf"
|
||||
|
||||
@ -4,6 +4,8 @@ import subprocess
|
||||
import sys
|
||||
|
||||
import pytest
|
||||
from _cli_helpers import ARGV, _stub_download
|
||||
|
||||
from steam_installer import (
|
||||
appinfo,
|
||||
cli,
|
||||
@ -11,8 +13,6 @@ from steam_installer import (
|
||||
vdf,
|
||||
)
|
||||
|
||||
from _cli_helpers import ARGV, _stub_download
|
||||
|
||||
pytestmark = pytest.mark.usefixtures("cli_logs")
|
||||
|
||||
|
||||
|
||||
164
_installer_import/tests/test_compat_decide.py
Normal file
164
_installer_import/tests/test_compat_decide.py
Normal file
@ -0,0 +1,164 @@
|
||||
"""Which games get the native Proton, and why the others keep Valve's default."""
|
||||
|
||||
import json
|
||||
|
||||
import pytest
|
||||
|
||||
from steam_installer import anticheat, compat_decide
|
||||
|
||||
WINDOWS_ONLY = {
|
||||
"common": {"oslist": "windows"},
|
||||
"depots": {"11": {"config": {"oslist": "windows"}}, "12": {}},
|
||||
"config": {"launch": {"0": {"config": {"oslist": "windows"}}}},
|
||||
}
|
||||
|
||||
|
||||
def _decide(block=WINDOWS_ONLY, **kw):
|
||||
args = {"anticheat": set(), "overrides": {}, "owned_dlc": False, "tool_ready": True}
|
||||
args.update(kw)
|
||||
return compat_decide.decide(10, block, **args)
|
||||
|
||||
|
||||
def test_a_plain_windows_game_is_mapped():
|
||||
decision = _decide()
|
||||
assert decision.map
|
||||
assert decision.describe() == "map"
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("block", "reason"),
|
||||
[
|
||||
({**WINDOWS_ONLY, "common": {"oslist": "windows,linux"}}, "native"),
|
||||
({**WINDOWS_ONLY, "depots": {"11": {"config": {"oslist": "linux"}}}}, "native"),
|
||||
(
|
||||
{**WINDOWS_ONLY, "config": {"launch": {"0": {"config": {"oslist": "linux"}}}}},
|
||||
"native",
|
||||
),
|
||||
({**WINDOWS_ONLY, "common": {"oslist": "windows,macos"}}, "not Windows-only"),
|
||||
({**WINDOWS_ONLY, "common": {}}, "no OS list"),
|
||||
({"common": "x"}, "no OS list"),
|
||||
({**WINDOWS_ONLY, "depots": {"11": {"depotfromapp": "228980"}}}, "shared depots"),
|
||||
({**WINDOWS_ONLY, "depots": {"11": {"sharedinstall": "1"}}}, "shared depots"),
|
||||
],
|
||||
)
|
||||
def test_unsafe_games_keep_valves_default(block, reason):
|
||||
decision = _decide(block)
|
||||
assert not decision.map
|
||||
assert reason in decision.reasons
|
||||
|
||||
|
||||
def test_odd_shapes_are_ignored_not_crashed_on():
|
||||
block = {
|
||||
"common": {"oslist": "windows"},
|
||||
"depots": {"branches": {"public": {}}, "11": "scalar", "12": {"config": "x"}},
|
||||
"config": {"launch": "scalar"},
|
||||
}
|
||||
assert _decide(block).map
|
||||
assert _decide({**block, "config": {"launch": {"0": "x", "1": {"config": "y"}}}}).map
|
||||
assert _decide({**block, "depots": "scalar", "config": "scalar"}).map
|
||||
|
||||
|
||||
def test_anti_cheat_whatever_its_status():
|
||||
assert _decide(anticheat={10}).reasons == ["anti-cheat"]
|
||||
|
||||
|
||||
def test_no_anti_cheat_list_means_no_mapping():
|
||||
assert _decide(anticheat=None).reasons == ["anti-cheat list unavailable"]
|
||||
|
||||
|
||||
def test_owned_dlc_is_left_on_valves_default_until_tested_live():
|
||||
assert _decide(owned_dlc=True).reasons == ["owned DLC"]
|
||||
|
||||
|
||||
def test_override_and_missing_tool():
|
||||
assert _decide(overrides={"10": "crashes at intro"}).reasons == [
|
||||
"override: crashes at intro"
|
||||
]
|
||||
assert _decide(tool_ready=False).reasons == ["native Proton not installed"]
|
||||
|
||||
|
||||
def test_every_reason_is_reported():
|
||||
block = {**WINDOWS_ONLY, "common": {"oslist": "windows,linux"}}
|
||||
decision = _decide(block, anticheat={10})
|
||||
assert decision.describe() == "Valve default: anti-cheat, native"
|
||||
|
||||
|
||||
def test_overrides_file_is_tracked_and_valid():
|
||||
assert compat_decide.load_overrides() == {}
|
||||
|
||||
|
||||
def test_overrides_file_must_map_ids_to_reasons(tmp_path):
|
||||
path = tmp_path / "o.json"
|
||||
path.write_text(json.dumps({"10": "why"}))
|
||||
assert compat_decide.load_overrides(path) == {"10": "why"}
|
||||
for bad in ([1], {"x": "why"}, {"10": 3}):
|
||||
path.write_text(json.dumps(bad))
|
||||
with pytest.raises(ValueError, match="compat_overrides"):
|
||||
compat_decide.load_overrides(path)
|
||||
|
||||
|
||||
def test_tool_ready_needs_the_manifest_and_the_pinned_stamp(tmp_path):
|
||||
tool = tmp_path / "proton-cachyos-native"
|
||||
assert not compat_decide.tool_ready(tool, "1:2-3")
|
||||
tool.mkdir()
|
||||
(tool / "toolmanifest.vdf").write_text("x")
|
||||
assert not compat_decide.tool_ready(tool, "1:2-3")
|
||||
(tool / "VERSION").write_text("1:2-2\n")
|
||||
assert not compat_decide.tool_ready(tool, "1:2-3")
|
||||
(tool / "VERSION").write_text("1:2-3\n")
|
||||
assert compat_decide.tool_ready(tool, "1:2-3")
|
||||
|
||||
|
||||
GAMES = [
|
||||
{"name": "CS", "storeIds": {"steam": "730"}, "status": "Supported"},
|
||||
{"name": "Epic only", "storeIds": {"epic": "x"}},
|
||||
{"name": "Broken", "storeIds": "x"},
|
||||
"not a game",
|
||||
]
|
||||
|
||||
|
||||
def test_anticheat_list_is_fetched_and_cached(tmp_path, monkeypatch):
|
||||
cache = tmp_path / "ac.json"
|
||||
monkeypatch.setattr(anticheat, "_download", lambda: json.dumps(GAMES).encode())
|
||||
assert anticheat.steam_ids(cache) == {730}
|
||||
assert json.loads(cache.read_text()) == GAMES
|
||||
|
||||
|
||||
def test_anticheat_falls_back_to_the_last_good_copy(tmp_path, monkeypatch):
|
||||
cache = tmp_path / "ac.json"
|
||||
cache.write_text(json.dumps(GAMES))
|
||||
|
||||
def offline():
|
||||
raise OSError("no network")
|
||||
|
||||
monkeypatch.setattr(anticheat, "_download", offline)
|
||||
assert anticheat.steam_ids(cache) == {730}
|
||||
|
||||
|
||||
def test_anticheat_with_no_fetch_and_no_cache_is_unknown(tmp_path, monkeypatch):
|
||||
monkeypatch.setattr(anticheat, "_download", lambda: b"{not json")
|
||||
assert anticheat.steam_ids(tmp_path / "ac.json") is None
|
||||
(tmp_path / "ac.json").write_text('{"a": 1}')
|
||||
assert anticheat.steam_ids(tmp_path / "ac.json") is None
|
||||
|
||||
|
||||
def test_anticheat_download_reads_the_upstream_url(monkeypatch):
|
||||
seen = {}
|
||||
|
||||
class _Response:
|
||||
def __enter__(self):
|
||||
return self
|
||||
|
||||
def __exit__(self, *a):
|
||||
return False
|
||||
|
||||
def read(self):
|
||||
return b"[]"
|
||||
|
||||
def fake_urlopen(url, timeout):
|
||||
seen["url"] = url
|
||||
return _Response()
|
||||
|
||||
monkeypatch.setattr(anticheat.urllib.request, "urlopen", fake_urlopen)
|
||||
assert anticheat._download() == b"[]"
|
||||
assert "AreWeAntiCheatYet" in seen["url"]
|
||||
198
_installer_import/tests/test_compat_map.py
Normal file
198
_installer_import/tests/test_compat_map.py
Normal file
@ -0,0 +1,198 @@
|
||||
"""Per-game CompatToolMapping entries, inserted into config.vdf as text."""
|
||||
|
||||
import pytest
|
||||
|
||||
from steam_installer import compat_map
|
||||
|
||||
HEAD = '''"InstallConfigStore"
|
||||
{
|
||||
\t"Software"
|
||||
\t{
|
||||
\t\t"Valve"
|
||||
\t\t{
|
||||
\t\t\t"Steam"
|
||||
\t\t\t{
|
||||
\t\t\t\t"SecretToken"\t\t"do-not-print-me"
|
||||
'''
|
||||
TAIL = '''\t\t\t}
|
||||
\t\t}
|
||||
\t}
|
||||
\t"Music"
|
||||
\t{
|
||||
\t\t"CompatToolMapping"\t\t"decoy outside the Steam block"
|
||||
\t}
|
||||
}
|
||||
'''
|
||||
|
||||
|
||||
def _entry(appid, name, priority, indent="\t\t\t\t\t"):
|
||||
return (
|
||||
f'{indent}"{appid}"\n{indent}{{\n'
|
||||
f'{indent}\t"name"\t\t"{name}"\n{indent}\t"config"\t\t""\n'
|
||||
f'{indent}\t"priority"\t\t"{priority}"\n{indent}}}\n'
|
||||
)
|
||||
|
||||
|
||||
def _config(tmp_path, mapping=None):
|
||||
body = HEAD
|
||||
if mapping is not None:
|
||||
body += '\t\t\t\t"CompatToolMapping"\n\t\t\t\t{\n' + mapping + "\t\t\t\t}\n"
|
||||
path = tmp_path / "config.vdf"
|
||||
path.write_text(body + TAIL)
|
||||
path.chmod(0o600)
|
||||
return path
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def _steam_closed(monkeypatch):
|
||||
monkeypatch.setattr(compat_map.recognize, "steam_client_pids", list)
|
||||
|
||||
|
||||
def test_adds_the_block_when_there_is_none(tmp_path):
|
||||
path = _config(tmp_path)
|
||||
before = path.read_text()
|
||||
|
||||
outcome = compat_map.map_app(path, 1201270)
|
||||
|
||||
assert outcome.action == "mapped"
|
||||
text = path.read_text()
|
||||
assert compat_map.current(path, 1201270) == ("proton-cachyos-native", "250")
|
||||
# Everything Steam wrote is still there byte for byte.
|
||||
assert text.replace(_mapping_block(1201270), "") == before
|
||||
assert path.stat().st_mode & 0o777 == 0o600
|
||||
|
||||
|
||||
def _mapping_block(appid):
|
||||
return (
|
||||
'\t\t\t\t"CompatToolMapping"\n\t\t\t\t{\n'
|
||||
+ _entry(appid, "proton-cachyos-native", "250")
|
||||
+ "\t\t\t\t}\n"
|
||||
)
|
||||
|
||||
|
||||
def test_adds_an_entry_to_an_existing_block(tmp_path):
|
||||
path = _config(tmp_path, _entry(10, "proton_9", "250"))
|
||||
assert compat_map.map_app(path, 20).action == "mapped"
|
||||
assert compat_map.current(path, 10) == ("proton_9", "250")
|
||||
assert compat_map.current(path, 20) == ("proton-cachyos-native", "250")
|
||||
|
||||
|
||||
def test_replaces_valves_own_choice(tmp_path):
|
||||
path = _config(tmp_path, _entry(20, "proton_experimental", "100"))
|
||||
outcome = compat_map.map_app(path, 20)
|
||||
assert outcome.action == "mapped"
|
||||
assert "proton_experimental" in outcome.detail
|
||||
assert compat_map.current(path, 20) == ("proton-cachyos-native", "250")
|
||||
assert path.read_text().count('"20"') == 1
|
||||
|
||||
|
||||
def test_replaces_an_empty_entry(tmp_path):
|
||||
path = _config(tmp_path, _entry(20, "", "250"))
|
||||
assert compat_map.map_app(path, 20).action == "mapped"
|
||||
assert compat_map.current(path, 20) == ("proton-cachyos-native", "250")
|
||||
|
||||
|
||||
def test_keeps_a_tool_kuhy_picked_himself(tmp_path):
|
||||
path = _config(tmp_path, _entry(20, "GE-Proton10", "250"))
|
||||
before = path.read_text()
|
||||
outcome = compat_map.map_app(path, 20)
|
||||
assert outcome.action == "kept"
|
||||
assert "GE-Proton10" in outcome.detail
|
||||
assert path.read_text() == before
|
||||
|
||||
|
||||
def test_a_second_run_changes_nothing(tmp_path):
|
||||
path = _config(tmp_path)
|
||||
compat_map.map_app(path, 20)
|
||||
once = path.read_text()
|
||||
assert compat_map.map_app(path, 20).action == "already"
|
||||
assert path.read_text() == once
|
||||
|
||||
|
||||
def test_refuses_while_steam_runs(tmp_path, monkeypatch):
|
||||
path = _config(tmp_path)
|
||||
before = path.read_text()
|
||||
monkeypatch.setattr(compat_map.recognize, "steam_client_pids", lambda: [7])
|
||||
with pytest.raises(compat_map.CompatMapError, match="Steam is running"):
|
||||
compat_map.map_app(path, 20)
|
||||
assert path.read_text() == before
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"text",
|
||||
[
|
||||
'"InstallConfigStore"\n{\n}\n',
|
||||
'"InstallConfigStore"\n{\n\t"Software" { }\n}\n',
|
||||
'"InstallConfigStore"\n{\n\t}\n\t}\n',
|
||||
'{\n}\n',
|
||||
],
|
||||
)
|
||||
def test_an_unexpected_layout_is_refused_without_echoing_lines(tmp_path, text):
|
||||
path = tmp_path / "config.vdf"
|
||||
path.write_text(text + '"x"\t"do-not-print-me"\n')
|
||||
with pytest.raises(compat_map.CompatMapError) as excinfo:
|
||||
compat_map.map_app(path, 20)
|
||||
assert "do-not-print-me" not in str(excinfo.value)
|
||||
|
||||
|
||||
def test_missing_config_is_an_error(tmp_path):
|
||||
with pytest.raises(compat_map.CompatMapError, match="cannot read"):
|
||||
compat_map.current(tmp_path / "nope.vdf", 1)
|
||||
|
||||
|
||||
def test_current_is_none_for_an_unmapped_app(tmp_path):
|
||||
assert compat_map.current(_config(tmp_path), 20) is None
|
||||
assert compat_map.current(_config(tmp_path, _entry(10, "x", "1")), 20) is None
|
||||
|
||||
|
||||
def test_keys_match_case_insensitively(tmp_path):
|
||||
path = _config(tmp_path)
|
||||
path.write_text(path.read_text().replace('"Steam"', '"steam"'))
|
||||
assert compat_map.map_app(path, 20).action == "mapped"
|
||||
assert compat_map.current(path, 20) == ("proton-cachyos-native", "250")
|
||||
|
||||
|
||||
def test_config_path_is_under_the_steam_root(tmp_path):
|
||||
assert compat_map.config_path(tmp_path) == tmp_path / "config" / "config.vdf"
|
||||
|
||||
|
||||
def test_a_value_spanning_lines_is_read_as_one_value(tmp_path):
|
||||
"""Steam stores some values with embedded newlines (seen in the real file)."""
|
||||
path = _config(tmp_path)
|
||||
path.write_text(path.read_text().replace(
|
||||
'"SecretToken"\t\t"do-not-print-me"', '"SecretToken"\t\t"line one\nline {two}"'))
|
||||
assert compat_map.map_app(path, 20).action == "mapped"
|
||||
assert compat_map.current(path, 20) == ("proton-cachyos-native", "250")
|
||||
|
||||
|
||||
def test_an_entry_sharing_a_line_with_its_key_is_refused(tmp_path):
|
||||
path = _config(tmp_path, '\t\t\t\t\t"20" {\n\t\t\t\t\t\t"name" "x"\n\t\t\t\t\t}\n')
|
||||
with pytest.raises(compat_map.CompatMapError, match="unexpected layout"):
|
||||
compat_map.map_app(path, 20)
|
||||
|
||||
|
||||
def test_an_entry_closing_on_a_shared_line_is_refused(tmp_path):
|
||||
path = _config(tmp_path, '\t\t\t\t\t"20"\n\t\t\t\t\t{\n\t\t\t\t\t\t"name" "" }\n')
|
||||
with pytest.raises(compat_map.CompatMapError, match="unexpected layout"):
|
||||
compat_map.map_app(path, 20)
|
||||
|
||||
|
||||
def test_unquoted_tokens_are_refused(tmp_path):
|
||||
path = _config(tmp_path)
|
||||
path.write_text(path.read_text().replace('"SecretToken"', "SecretToken"))
|
||||
with pytest.raises(compat_map.CompatMapError, match="line 9: unexpected layout"):
|
||||
compat_map.current(path, 20)
|
||||
|
||||
|
||||
def test_a_failed_replace_leaves_the_file_and_no_temp(tmp_path, monkeypatch):
|
||||
path = _config(tmp_path)
|
||||
before = path.read_text()
|
||||
|
||||
def fail(src, dst):
|
||||
raise OSError("disk full")
|
||||
|
||||
monkeypatch.setattr(compat_map.os, "replace", fail)
|
||||
with pytest.raises(OSError, match="disk full"):
|
||||
compat_map.map_app(path, 20)
|
||||
assert path.read_text() == before
|
||||
assert sorted(p.name for p in tmp_path.iterdir()) == ["config.vdf"]
|
||||
45
_installer_import/tests/test_install_sh.py
Normal file
45
_installer_import/tests/test_install_sh.py
Normal file
@ -0,0 +1,45 @@
|
||||
"""install.sh --check-only: what a run needs, with steamcmd no longer on the list."""
|
||||
|
||||
import os
|
||||
import subprocess
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parent.parent
|
||||
|
||||
|
||||
def _stub(bin_dir: Path, name: str, script: str) -> None:
|
||||
path = bin_dir / name
|
||||
path.write_text(f"#!/bin/bash\n{script}\n")
|
||||
path.chmod(0o755)
|
||||
|
||||
|
||||
def _check_only(tmp_path, libibus_installed: bool):
|
||||
bin_dir = tmp_path / "bin"
|
||||
bin_dir.mkdir()
|
||||
_stub(bin_dir, "depotdownloader", "exit 0")
|
||||
_stub(bin_dir, "pacman", f'[[ "$*" == "-Q libibus" ]] && exit {0 if libibus_installed else 1}; exit 0')
|
||||
env = {**os.environ, "PATH": f"{bin_dir}:/usr/bin:/bin", "HOME": str(tmp_path)}
|
||||
return subprocess.run(
|
||||
["bash", str(ROOT / "install.sh"), "--check-only"],
|
||||
capture_output=True, text=True, env=env, timeout=30, check=False,
|
||||
)
|
||||
|
||||
|
||||
def test_missing_libibus_is_reported_and_steamcmd_is_not_needed(tmp_path):
|
||||
result = _check_only(tmp_path, libibus_installed=False)
|
||||
assert result.returncode == 1
|
||||
assert "missing: libibus" in result.stderr
|
||||
assert "steamcmd" not in result.stdout + result.stderr
|
||||
|
||||
|
||||
def test_all_present_without_steamcmd(tmp_path):
|
||||
result = _check_only(tmp_path, libibus_installed=True)
|
||||
assert result.returncode == 0, result.stderr
|
||||
assert "All dependencies present." in result.stdout
|
||||
|
||||
|
||||
def test_run_sh_rechecks_when_the_proton_pin_changes():
|
||||
"""A stale stamp must not hide a lock bump or a deleted tool folder."""
|
||||
text = (ROOT / "run.sh").read_text()
|
||||
assert "proton-native.lock" in text
|
||||
assert "steam_installer.proton_native --check" in text
|
||||
197
_installer_import/tests/test_map_installed.py
Normal file
197
_installer_import/tests/test_map_installed.py
Normal file
@ -0,0 +1,197 @@
|
||||
"""Mapping games to the native Proton: after an install, and for the whole library."""
|
||||
|
||||
import pytest
|
||||
from _appinfo_blob import encode
|
||||
from _cli_helpers import ARGV, _stub_download
|
||||
|
||||
from steam_installer import (
|
||||
anticheat,
|
||||
cli,
|
||||
compat_apply,
|
||||
compat_map,
|
||||
proton_pkg,
|
||||
recognize,
|
||||
steamctl,
|
||||
vdf,
|
||||
)
|
||||
|
||||
pytestmark = pytest.mark.usefixtures("cli_logs")
|
||||
|
||||
LOCKED = proton_pkg.read_lock().version
|
||||
CONFIG = '"InstallConfigStore"\n{\n\t"Software"\n\t{\n\t\t"Valve"\n\t\t{\n\t\t\t"Steam"\n\t\t\t{\n\t\t\t}\n\t\t}\n\t}\n}\n'
|
||||
PLAIN = {"common": {"name": "Plain", "oslist": "windows", "type": "Game"},
|
||||
"depots": {"11": {"config": {"oslist": "windows"}}}}
|
||||
NATIVE = {"common": {"name": "Native", "oslist": "windows,linux", "type": "Game"}}
|
||||
SHARED = {"common": {"name": "Shared", "oslist": "windows", "type": "Game"},
|
||||
"depots": {"31": {"depotfromapp": "228980"}}}
|
||||
CS = {"common": {"name": "CS", "oslist": "windows,linux", "type": "Game"}}
|
||||
TOOL = {"common": {"name": "Proton Experimental", "type": "Tool"}}
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def home(tmp_path, monkeypatch):
|
||||
"""A Steam root with config.vdf, the stamped tool, an app cache and anti-cheat list."""
|
||||
root = tmp_path / "Steam"
|
||||
(root / "config").mkdir(parents=True)
|
||||
(root / "config" / "config.vdf").write_text(CONFIG)
|
||||
tool = root / "compatibilitytools.d" / "proton-cachyos-native"
|
||||
tool.mkdir(parents=True)
|
||||
(tool / "toolmanifest.vdf").write_text("x")
|
||||
(tool / "VERSION").write_text(LOCKED + "\n")
|
||||
cache = tmp_path / "appinfo.vdf"
|
||||
cache.write_bytes(encode({10: PLAIN, 20: NATIVE, 30: SHARED, 730: CS, 1493710: TOOL}))
|
||||
monkeypatch.setattr(compat_apply.appinfo.appinfo_cache, "default_path", lambda: cache)
|
||||
monkeypatch.setattr(anticheat, "_download", lambda: b'[{"storeIds": {"steam": "730"}}]')
|
||||
steamapps = root / "steamapps"
|
||||
steamapps.mkdir()
|
||||
for appid in (10, 20, 1493710):
|
||||
(steamapps / f"appmanifest_{appid}.acf").write_text(
|
||||
vdf.dumps("AppState", {"appid": str(appid), "InstalledDepots": {}}))
|
||||
monkeypatch.setattr(cli, "find_steam_root", lambda: root)
|
||||
return root
|
||||
|
||||
|
||||
def _mapped(root, appid):
|
||||
return compat_map.current(root / "config" / "config.vdf", appid)
|
||||
|
||||
|
||||
def test_dry_run_lists_decisions_and_writes_nothing(home, capsys):
|
||||
before = (home / "config" / "config.vdf").read_bytes()
|
||||
assert cli.main(["--map-installed"]) == 0
|
||||
out = capsys.readouterr().out
|
||||
assert "10 Plain: map" in out
|
||||
assert "20 Native: Valve default: native" in out
|
||||
assert "1493710" not in out # a tool, not a game
|
||||
assert "Dry run" in out
|
||||
assert (home / "config" / "config.vdf").read_bytes() == before
|
||||
|
||||
|
||||
def test_appids_decides_any_cached_app(home, capsys):
|
||||
assert cli.main(["--map-installed", "--appids", "730,20,30,10,999"]) == 0
|
||||
out = capsys.readouterr().out
|
||||
assert "730 CS: Valve default: anti-cheat, native" in out
|
||||
assert "30 Shared: Valve default: shared depots" in out
|
||||
assert "10 Plain: map" in out
|
||||
assert "999: not in Steam's app cache" in out
|
||||
|
||||
|
||||
def test_apply_maps_the_safe_ones_and_a_rerun_changes_nothing(home, capsys):
|
||||
assert cli.main(["--map-installed", "--apply", "--yes"]) == 0
|
||||
assert _mapped(home, 10) == ("proton-cachyos-native", "250")
|
||||
assert _mapped(home, 20) is None
|
||||
once = (home / "config" / "config.vdf").read_bytes()
|
||||
capsys.readouterr()
|
||||
assert cli.main(["--map-installed", "--apply", "--yes"]) == 0
|
||||
assert "10 Plain: map -- already mapped" in capsys.readouterr().out
|
||||
assert (home / "config" / "config.vdf").read_bytes() == once
|
||||
|
||||
|
||||
def test_apply_closes_steam_first_and_restarts_it(home, monkeypatch):
|
||||
events = []
|
||||
monkeypatch.setattr(recognize, "steam_client_pids", lambda: [] if events else [5])
|
||||
monkeypatch.setattr(steamctl, "stop", lambda logger: events.append("stop") or True)
|
||||
monkeypatch.setattr(steamctl, "start", lambda logger: events.append("start"))
|
||||
assert cli.main(["--map-installed", "--apply", "--yes"]) == 0
|
||||
assert events == ["stop", "start"]
|
||||
assert _mapped(home, 10) is not None
|
||||
|
||||
|
||||
def test_apply_declined_writes_nothing(home, monkeypatch):
|
||||
monkeypatch.setattr(recognize, "steam_client_pids", lambda: [5])
|
||||
monkeypatch.setattr("builtins.input", lambda *a: "n")
|
||||
assert cli.main(["--map-installed", "--apply"]) == 1
|
||||
assert _mapped(home, 10) is None
|
||||
|
||||
|
||||
def test_a_kept_choice_and_a_write_error_are_reported(home, monkeypatch, capsys):
|
||||
config = home / "config" / "config.vdf"
|
||||
compat_map.map_app(config, 10)
|
||||
config.write_text(config.read_text().replace("proton-cachyos-native", "GE-Proton10"))
|
||||
assert cli.main(["--map-installed", "--apply", "--yes"]) == 0
|
||||
assert "kept: already mapped to GE-Proton10" in capsys.readouterr().out
|
||||
config.write_text("garbage {")
|
||||
assert cli.main(["--map-installed", "--apply", "--yes"]) == 1
|
||||
|
||||
|
||||
def test_owned_dlc_in_the_manifest_keeps_valves_default(home, capsys):
|
||||
manifest = home / "steamapps" / "appmanifest_10.acf"
|
||||
manifest.write_text(vdf.dumps("AppState", {"appid": "10", "InstalledDepots": {
|
||||
"11": {"manifest": "1"}, "12": {"manifest": "2", "dlcappid": "13"}}}))
|
||||
assert cli.main(["--map-installed"]) == 0
|
||||
assert "10 Plain: Valve default: owned DLC" in capsys.readouterr().out
|
||||
|
||||
|
||||
def test_valve_proton_only_goes_with_an_install(home):
|
||||
with pytest.raises(SystemExit):
|
||||
cli.main(["--map-installed", "--valve-proton"])
|
||||
|
||||
|
||||
def test_an_install_maps_the_game_while_steam_is_closed(steam, monkeypatch, capsys, tmp_path):
|
||||
library, install_dir = steam
|
||||
_with_compat_home(library.path, monkeypatch, tmp_path)
|
||||
_stub_download(monkeypatch)
|
||||
monkeypatch.setattr(compat_apply.appinfo, "_fetch_app_block", lambda appid: PLAIN)
|
||||
_proven(monkeypatch, install_dir)
|
||||
assert cli.main(ARGV) == 0
|
||||
assert _mapped(library.path, 1771300) == ("proton-cachyos-native", "250")
|
||||
assert "mapped to proton-cachyos-native" in capsys.readouterr().out
|
||||
|
||||
|
||||
def test_valve_proton_keeps_valves_default_for_one_run(steam, monkeypatch, capsys, tmp_path):
|
||||
library, install_dir = steam
|
||||
_with_compat_home(library.path, monkeypatch, tmp_path)
|
||||
_stub_download(monkeypatch)
|
||||
monkeypatch.setattr(compat_apply.appinfo, "_fetch_app_block", lambda appid: PLAIN)
|
||||
_proven(monkeypatch, install_dir)
|
||||
assert cli.main([*ARGV, "--valve-proton"]) == 0
|
||||
assert _mapped(library.path, 1771300) is None
|
||||
assert "Valve default: override: --valve-proton" in capsys.readouterr().out
|
||||
|
||||
|
||||
def test_a_mapping_failure_leaves_the_install_on_valves_default(steam, monkeypatch, capsys, tmp_path):
|
||||
"""The install itself succeeded; the game still runs on Valve's Proton."""
|
||||
library, install_dir = steam
|
||||
_with_compat_home(library.path, monkeypatch, tmp_path)
|
||||
(library.path / "config" / "config.vdf").write_text("broken {")
|
||||
_stub_download(monkeypatch)
|
||||
monkeypatch.setattr(compat_apply.appinfo, "_fetch_app_block", lambda appid: PLAIN)
|
||||
_proven(monkeypatch, install_dir)
|
||||
assert cli.main(ARGV) == 0
|
||||
assert "stays on Valve's default" in capsys.readouterr().out
|
||||
|
||||
|
||||
def test_an_owned_dlc_download_keeps_valves_default(steam, monkeypatch, capsys, tmp_path):
|
||||
library, install_dir = steam
|
||||
_with_compat_home(library.path, monkeypatch, tmp_path)
|
||||
_stub_download(monkeypatch)
|
||||
monkeypatch.setattr(compat_apply.appinfo, "_fetch_app_block", lambda appid: PLAIN)
|
||||
_proven(monkeypatch, install_dir, dlc={"1771303": "9"})
|
||||
assert cli.main(ARGV) == 0
|
||||
assert "Valve default: owned DLC" in capsys.readouterr().out
|
||||
|
||||
|
||||
def _with_compat_home(root, monkeypatch, tmp_path):
|
||||
(root / "config").mkdir(parents=True, exist_ok=True)
|
||||
(root / "config" / "config.vdf").write_text(CONFIG)
|
||||
tool = root / "compatibilitytools.d" / "proton-cachyos-native"
|
||||
tool.mkdir(parents=True)
|
||||
(tool / "toolmanifest.vdf").write_text("x")
|
||||
(tool / "VERSION").write_text(LOCKED + "\n")
|
||||
monkeypatch.setattr(anticheat, "_download", lambda: b"[]")
|
||||
|
||||
|
||||
def _proven(monkeypatch, install_dir, dlc=None):
|
||||
(gid,) = recognize.discover_cached_depot_manifests(install_dir).values()
|
||||
plan = compat_apply.appinfo.DepotPlan({"1771303"}, set(), manifests={"1771303": gid},
|
||||
dlc=dict(dlc or {}))
|
||||
monkeypatch.setattr(compat_apply.appinfo, "get_depot_plan", lambda appid, language: plan)
|
||||
|
||||
|
||||
def test_a_failed_write_stops_the_run(home, monkeypatch, capsys):
|
||||
def boom(config, appid):
|
||||
raise compat_map.CompatMapError("config.vdf line 3: unexpected layout")
|
||||
|
||||
monkeypatch.setattr(compat_map, "map_app", boom)
|
||||
(home / "steamapps" / "appmanifest_notanid.acf").write_text("x")
|
||||
assert cli.main(["--map-installed", "--apply", "--yes"]) == 1
|
||||
assert "Mapping stopped: config.vdf line 3" in capsys.readouterr().out
|
||||
211
_installer_import/tests/test_proton_native.py
Normal file
211
_installer_import/tests/test_proton_native.py
Normal file
@ -0,0 +1,211 @@
|
||||
"""Fetch, verify and install the native Proton, never running its .INSTALL."""
|
||||
|
||||
import os
|
||||
import shutil
|
||||
|
||||
import pytest
|
||||
from _proton_fixture import (
|
||||
FILES,
|
||||
VERSION,
|
||||
build_db,
|
||||
build_package,
|
||||
build_repo,
|
||||
gpg,
|
||||
stop_agent,
|
||||
)
|
||||
|
||||
from steam_installer import proton_native, proton_pkg
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def repo(tmp_path_factory):
|
||||
built = build_repo(tmp_path_factory.mktemp("repo"))
|
||||
yield built
|
||||
stop_agent(built.gpg_home)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mirror(repo, tmp_path):
|
||||
"""A private copy of the fake mirror a test may tamper with."""
|
||||
root = tmp_path / "mirror"
|
||||
shutil.copytree(repo.root, root)
|
||||
return root
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def setup(repo, mirror, tmp_path, monkeypatch):
|
||||
tools = tmp_path / "compatibilitytools.d"
|
||||
tools.mkdir()
|
||||
lock = proton_pkg.Lock(
|
||||
"proton-cachyos-native", (mirror / "cachyos.db").as_uri(), VERSION, repo.sha256
|
||||
)
|
||||
monkeypatch.setattr(proton_native, "in_use", lambda tool: [])
|
||||
|
||||
def run(**kw):
|
||||
return proton_native.ensure(
|
||||
tools, lock, key=repo.key, fingerprint=repo.fingerprint, **kw
|
||||
)
|
||||
|
||||
return tools, lock, run
|
||||
|
||||
|
||||
def _tree(tool):
|
||||
return sorted(str(p.relative_to(tool)) for p in tool.rglob("*"))
|
||||
|
||||
|
||||
def test_a_fresh_install_extracts_only_the_tool_and_stamps_it(setup):
|
||||
tools, _, run = setup
|
||||
status = run()
|
||||
tool = tools / "proton-cachyos-native"
|
||||
assert status.startswith("installed")
|
||||
assert "signature" in status and "sha256" in status
|
||||
assert (tool / "VERSION").read_text() == VERSION + "\n"
|
||||
assert (tool / "files/bin/wine").read_bytes() == FILES["files/bin/wine"]
|
||||
assert os.readlink(tool / "files/bin/msidb") == "wine"
|
||||
assert not (tools / ".INSTALL").exists()
|
||||
assert not any(".INSTALL" in p or "stray" in p for p in _tree(tools))
|
||||
assert sorted(os.listdir(tools)) == ["proton-cachyos-native"]
|
||||
|
||||
|
||||
def test_a_current_stamp_needs_no_network(setup, monkeypatch):
|
||||
_, _, run = setup
|
||||
run()
|
||||
monkeypatch.setattr(proton_native, "_download", lambda url, dest: pytest.fail())
|
||||
assert run() == f"current: {VERSION}"
|
||||
|
||||
|
||||
def _assert_fails_untouched(run, tools, match):
|
||||
old = tools / "proton-cachyos-native"
|
||||
old.mkdir(exist_ok=True)
|
||||
(old / "keep").write_text("old build")
|
||||
with pytest.raises(proton_pkg.PkgError, match=match):
|
||||
run()
|
||||
assert (old / "keep").read_text() == "old build"
|
||||
assert sorted(os.listdir(tools)) == ["proton-cachyos-native"]
|
||||
|
||||
|
||||
def test_a_tampered_signature_fails_closed(setup, mirror):
|
||||
tools, _, run = setup
|
||||
sig = next(mirror.glob("*.sig"))
|
||||
data = bytearray(sig.read_bytes())
|
||||
data[-5] ^= 0xFF
|
||||
sig.write_bytes(bytes(data))
|
||||
_assert_fails_untouched(run, tools, "signature")
|
||||
|
||||
|
||||
def test_a_signature_from_another_key_fails_closed(setup, mirror, tmp_path):
|
||||
tools, _, run = setup
|
||||
other = tmp_path / "other"
|
||||
other.mkdir(mode=0o700)
|
||||
gpg(other, "--quick-gen-key", "Mallory <m@example.invalid>", "ed25519", "sign", "never")
|
||||
package = next(mirror.glob("*.pkg.tar.zst"))
|
||||
(mirror / f"{package.name}.sig").unlink()
|
||||
gpg(other, "--output", f"{package}.sig", "--detach-sign", str(package))
|
||||
stop_agent(other)
|
||||
_assert_fails_untouched(run, tools, "signature")
|
||||
|
||||
|
||||
def test_a_package_that_differs_from_the_pinned_sha256_fails_closed(setup, mirror, repo):
|
||||
tools, _, run = setup
|
||||
package = next(mirror.glob("*.pkg.tar.zst"))
|
||||
build_package(package, {**FILES, "proton": b"evil"})
|
||||
gpg(repo.gpg_home, "--yes", "--output", f"{package}.sig", "--detach-sign", str(package))
|
||||
_assert_fails_untouched(run, tools, "sha256")
|
||||
|
||||
|
||||
def test_a_db_sha256_that_disagrees_with_the_lock_fails_closed(setup, mirror):
|
||||
tools, _, run = setup
|
||||
build_db(mirror / "cachyos.db", VERSION, "0" * 64)
|
||||
_assert_fails_untouched(run, tools, "sha256")
|
||||
|
||||
|
||||
def test_a_newer_package_in_the_repo_asks_for_a_lock_bump(setup, mirror, repo):
|
||||
tools, _, run = setup
|
||||
build_db(mirror / "cachyos.db", "1:11.0.20261101-1", repo.sha256)
|
||||
_assert_fails_untouched(run, tools, "bump")
|
||||
|
||||
|
||||
def test_a_repo_without_the_package_fails(setup, mirror, repo):
|
||||
tools, _, run = setup
|
||||
build_db(mirror / "cachyos.db", VERSION, repo.sha256, name="something-else")
|
||||
_assert_fails_untouched(run, tools, "no proton-cachyos-native")
|
||||
|
||||
|
||||
def _existing_copy(tools):
|
||||
tool = tools / "proton-cachyos-native"
|
||||
for name, data in FILES.items():
|
||||
(tool / name).parent.mkdir(parents=True, exist_ok=True)
|
||||
(tool / name).write_bytes(data)
|
||||
os.symlink("wine", tool / "files/bin/msidb")
|
||||
(tool / "__pycache__").mkdir()
|
||||
(tool / "__pycache__" / "x.pyc").write_bytes(b"made by running it")
|
||||
return tool
|
||||
|
||||
|
||||
def test_an_identical_copy_is_adopted_without_extracting(setup, monkeypatch):
|
||||
tools, _, run = setup
|
||||
tool = _existing_copy(tools)
|
||||
monkeypatch.setattr(proton_pkg, "extract", lambda *a: pytest.fail("extracted"))
|
||||
status = run()
|
||||
assert status.startswith(f"adopted: all {len(FILES) + 1} files match .MTREE (signature")
|
||||
assert (tool / "VERSION").read_text() == VERSION + "\n"
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("change", "where"),
|
||||
[
|
||||
(lambda t: (t / "files/bin/wine").write_bytes(b"patched"), "files/bin/wine"),
|
||||
(lambda t: (t / "user_settings.py").write_text("x"), "user_settings.py"),
|
||||
(lambda t: (t / "proton").unlink(), "proton"),
|
||||
(lambda t: (t / "files/bin/msidb").unlink() or os.symlink("x", t / "files/bin/msidb"), "msidb"),
|
||||
(lambda t: (t / "files/bin/msidb").unlink(), "msidb"),
|
||||
],
|
||||
)
|
||||
def test_a_differing_copy_is_replaced(setup, change, where):
|
||||
tools, _, run = setup
|
||||
tool = _existing_copy(tools)
|
||||
change(tool)
|
||||
status = run()
|
||||
assert status.startswith("replaced: mismatch in") and where in status
|
||||
assert (tool / "files/bin/wine").read_bytes() == FILES["files/bin/wine"]
|
||||
assert not (tool / "user_settings.py").exists()
|
||||
assert sorted(os.listdir(tools)) == ["proton-cachyos-native"]
|
||||
|
||||
|
||||
def test_replacing_is_deferred_while_steam_or_a_game_runs(setup, monkeypatch):
|
||||
tools, _, run = setup
|
||||
tool = _existing_copy(tools)
|
||||
(tool / "proton").write_text("old")
|
||||
monkeypatch.setattr(proton_native, "in_use", lambda t: [4242])
|
||||
status = run()
|
||||
assert status.startswith("deferred")
|
||||
assert (tool / "proton").read_text() == "old"
|
||||
assert not (tool / "VERSION").exists()
|
||||
|
||||
|
||||
def test_an_older_stamp_is_updated(setup):
|
||||
tools, _, run = setup
|
||||
tool = _existing_copy(tools)
|
||||
(tool / "VERSION").write_text("1:10.0-1\n")
|
||||
assert run().startswith("updated: 1:10.0-1 ->")
|
||||
assert (tool / "VERSION").read_text() == VERSION + "\n"
|
||||
|
||||
|
||||
def test_in_use_sees_steam_and_processes_running_from_the_tool(tmp_path, monkeypatch):
|
||||
proc = tmp_path / "proc"
|
||||
tool = tmp_path / "tool"
|
||||
(tool / "files/bin").mkdir(parents=True)
|
||||
(tool / "files/bin/wine").write_text("")
|
||||
(tmp_path / "other").write_text("")
|
||||
for pid, target in (
|
||||
("10", tool / "files/bin/wine"),
|
||||
("11", tmp_path / "other"),
|
||||
("13", tmp_path / "gone"),
|
||||
):
|
||||
(proc / pid).mkdir(parents=True)
|
||||
os.symlink(target, proc / pid / "exe")
|
||||
(proc / "self").mkdir()
|
||||
(proc / "12").mkdir()
|
||||
monkeypatch.setattr(proton_native.recognize, "PROC_DIR", proc)
|
||||
monkeypatch.setattr(proton_native.recognize, "steam_client_pids", lambda: [99])
|
||||
assert proton_native.in_use(tool) == [99, 10]
|
||||
58
_installer_import/tests/test_proton_native_cli.py
Normal file
58
_installer_import/tests/test_proton_native_cli.py
Normal file
@ -0,0 +1,58 @@
|
||||
"""The proton_native entry point: what install.sh and run.sh call."""
|
||||
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
from steam_installer import proton_native, proton_pkg
|
||||
|
||||
|
||||
def test_main_reports_and_exits(monkeypatch, capsys, tmp_path):
|
||||
monkeypatch.setattr(proton_native, "ensure", lambda *a, **kw: "current: x")
|
||||
monkeypatch.setattr(proton_native, "find_steam_root", lambda: tmp_path)
|
||||
assert proton_native.main([]) == 0
|
||||
assert "current: x" in capsys.readouterr().out
|
||||
|
||||
def boom(*a, **kw):
|
||||
raise proton_pkg.PkgError("bad signature")
|
||||
|
||||
monkeypatch.setattr(proton_native, "ensure", boom)
|
||||
assert proton_native.main([]) == 1
|
||||
assert "bad signature" in capsys.readouterr().err
|
||||
|
||||
|
||||
def test_check_reports_whether_the_stamp_matches_the_lock(tmp_path, monkeypatch):
|
||||
monkeypatch.setattr(proton_native, "find_steam_root", lambda: tmp_path)
|
||||
assert proton_native.main(["--check"]) == 1
|
||||
tool = tmp_path / "compatibilitytools.d" / "proton-cachyos-native"
|
||||
tool.mkdir(parents=True)
|
||||
(tool / "VERSION").write_text(proton_pkg.read_lock().version + "\n")
|
||||
assert proton_native.main(["--check"]) == 0
|
||||
|
||||
|
||||
def test_no_steam_installation_means_nothing_to_install(monkeypatch, capsys):
|
||||
def absent():
|
||||
raise FileNotFoundError("No Steam installation found")
|
||||
|
||||
monkeypatch.setattr(proton_native, "find_steam_root", absent)
|
||||
assert proton_native.main([]) == 0
|
||||
assert proton_native.main(["--check"]) == 0
|
||||
assert "skipped" in capsys.readouterr().out
|
||||
|
||||
|
||||
def test_the_repo_can_be_pointed_at_a_test_mirror(monkeypatch, tmp_path, capsys):
|
||||
seen = {}
|
||||
monkeypatch.setattr(proton_native, "find_steam_root", lambda: tmp_path)
|
||||
monkeypatch.setenv("SGI_PROTON_REPO", "file:///mirror/cachyos.db")
|
||||
monkeypatch.setattr(proton_native, "ensure", lambda d, lock: seen.setdefault("repo", lock.repo))
|
||||
assert proton_native.main([]) == 0
|
||||
assert seen["repo"] == "file:///mirror/cachyos.db"
|
||||
|
||||
|
||||
def test_module_runs_as_a_script(tmp_path, coverage_subprocess_env):
|
||||
env = {**coverage_subprocess_env, "HOME": str(tmp_path)}
|
||||
result = subprocess.run(
|
||||
[sys.executable, "-m", "steam_installer.proton_native", "--check"],
|
||||
capture_output=True, text=True, env=env, timeout=30, check=False,
|
||||
)
|
||||
assert result.returncode == 0
|
||||
assert "skipped" in result.stdout
|
||||
98
_installer_import/tests/test_proton_pkg.py
Normal file
98
_installer_import/tests/test_proton_pkg.py
Normal file
@ -0,0 +1,98 @@
|
||||
"""The package formats and checks behind the native Proton fetcher."""
|
||||
|
||||
import hashlib
|
||||
import tarfile
|
||||
|
||||
import pytest
|
||||
from _proton_fixture import PREFIX, build_repo, stop_agent
|
||||
|
||||
from steam_installer import proton_pkg
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def repo(tmp_path_factory):
|
||||
built = build_repo(tmp_path_factory.mktemp("repo"))
|
||||
yield built
|
||||
stop_agent(built.gpg_home)
|
||||
|
||||
|
||||
def test_the_real_lock_pins_the_proven_build():
|
||||
lock = proton_pkg.read_lock()
|
||||
assert lock.name == "proton-cachyos-native"
|
||||
assert lock.version == "1:11.0.20261015-1"
|
||||
assert lock.sha256 == "25bf302f90e8e01118555b997b873c3cd06a33b5647e79d049a59e29794b43e0"
|
||||
assert lock.repo == "https://mirror.cachyos.org/repo/x86_64/cachyos/cachyos.db"
|
||||
|
||||
|
||||
def test_a_lock_missing_a_key_is_refused(tmp_path):
|
||||
path = tmp_path / "x.lock"
|
||||
path.write_text("# c\nname=a\nrepo=b.db\n")
|
||||
with pytest.raises(proton_pkg.PkgError, match="version"):
|
||||
proton_pkg.read_lock(path)
|
||||
|
||||
|
||||
def test_the_pinned_key_file_holds_the_pinned_fingerprint(tmp_path):
|
||||
home = tmp_path / "g"
|
||||
home.mkdir(mode=0o700)
|
||||
try:
|
||||
assert proton_pkg.key_fingerprints(proton_pkg.KEY, home) == [proton_pkg.FINGERPRINT]
|
||||
finally:
|
||||
stop_agent(home)
|
||||
|
||||
|
||||
def test_package_urls_quote_the_epoch_colon():
|
||||
lock = proton_pkg.Lock("p", "https://m/repo/cachyos.db", "1:2-3", "x")
|
||||
assert proton_pkg.package_url(lock, "p-1:2-3-x86_64.pkg.tar.zst") == (
|
||||
"https://m/repo/p-1%3A2-3-x86_64.pkg.tar.zst"
|
||||
)
|
||||
|
||||
|
||||
def test_sha256_file_streams(tmp_path):
|
||||
path = tmp_path / "f"
|
||||
path.write_bytes(b"abc" * 100000)
|
||||
assert proton_pkg.sha256_file(path) == hashlib.sha256(b"abc" * 100000).hexdigest()
|
||||
|
||||
|
||||
def test_mtree_unescapes_octal_names(repo):
|
||||
entries = proton_pkg.read_mtree(repo.package)
|
||||
assert entries["user settings.py"].kind == "file"
|
||||
assert entries["files/bin/msidb"].link == "wine"
|
||||
assert ".INSTALL" not in entries and "" not in entries
|
||||
assert PREFIX not in entries
|
||||
|
||||
|
||||
|
||||
|
||||
def test_db_entries_other_than_desc_are_ignored(tmp_path):
|
||||
db = tmp_path / "x.db"
|
||||
with tarfile.open(db, "w:zst") as tar:
|
||||
info = tarfile.TarInfo("p-1/files")
|
||||
tar.addfile(info)
|
||||
with pytest.raises(proton_pkg.PkgError, match="lists no p"):
|
||||
proton_pkg.find_in_db(db, "p")
|
||||
|
||||
|
||||
def test_a_key_file_without_the_pinned_fingerprint_is_refused(repo, tmp_path):
|
||||
home = tmp_path / "g"
|
||||
home.mkdir(mode=0o700)
|
||||
try:
|
||||
with pytest.raises(proton_pkg.PkgError, match="pinned key file"):
|
||||
proton_pkg.verify_signature(
|
||||
repo.package, repo.package, repo.key, "0" * 40, home
|
||||
)
|
||||
finally:
|
||||
stop_agent(home)
|
||||
|
||||
|
||||
def test_a_package_without_mtree_is_refused(tmp_path):
|
||||
package = tmp_path / "p.pkg.tar.zst"
|
||||
with tarfile.open(package, "w:zst") as tar:
|
||||
tar.addfile(tarfile.TarInfo("usr/x"))
|
||||
with pytest.raises(proton_pkg.PkgError, match="no .MTREE"):
|
||||
proton_pkg.read_mtree(package)
|
||||
|
||||
|
||||
def test_directories_listed_in_mtree_need_no_content_check(tmp_path):
|
||||
entries = {"files": proton_pkg.MtreeEntry("dir")}
|
||||
(tmp_path / "files").mkdir()
|
||||
assert proton_pkg.first_mismatch(tmp_path, entries) is None
|
||||
Loading…
Reference in New Issue
Block a user