mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 21:06:09 +00:00
An opt-in second Steam client (Steam settings, Steam client: x86-64): Valve's x86-64 Linux client, unchanged, runs under FEX in its own home with its own game library and the same sign-in. Linux builds run directly, so titles such as Team Fortress 2 and Half-Life use their Linux versions; Windows games use DroidDeck-Proton as on arm64. The arm64 client stays the default. - droiddeck-steam-x64: FEX and the x86-64 rootfs from DroidDeck-Components (sha256-pinned), client install and sync from Valve's CDN, sign-in shared with the arm64 client, its web helper on the GPU (ANGLE GL over FEX's GL thunk, zink, Turnip), Proton wrappers for the arm64 client's tools, DroidDeck direct for Linux builds, SD-card library (x86-64/ beside the arm64 one), repair. - FEX 2610 built by build-fex.yml with thunks and three patches: an openat2 fallback without openat2 (proot), newer-clang thunkgen, MAP_32BIT exhaustion returning ENOMEM. libblsession resolves RESOLVE_IN_ROOT paths inside the root. - Session: x86-64 gating, shortcuts and compatibility tools per client, logs from the client that ran. - App: client setting with the FEX version, an x86-64 chip on the Games header, the active client's library, art, storage, downloads, repair, Offline Mode, Decky, desktop mode, optional VAC diagnostics; per-client state for art, the content log, repair and leftovers. - Strings in every locale. - Review fixes: the library cache is saved only by the newest scan; an abandoned session's Steam logs come from the client it recorded; distinct VAC console names; FEXInterpreter in CPU pinning; clearer VAC hint in pl, ru, uk, cs and bg.
369 lines
14 KiB
Python
Executable File
369 lines
14 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""Import added games while Steam is closed, preserving user-created shortcuts.
|
|
|
|
Usage: droiddeck-steam-shortcuts <steam_root> <added-games.json>
|
|
"""
|
|
import importlib.machinery
|
|
import importlib.util
|
|
import json
|
|
import os
|
|
import re
|
|
import shutil
|
|
import struct
|
|
import sys
|
|
|
|
TAG = "droiddeck-app"
|
|
|
|
|
|
def account_dir(steam_root):
|
|
"""The most recent account's userdata folder, else the only one that is not 0."""
|
|
users = os.path.join(steam_root, "config", "loginusers.vdf")
|
|
recent = None
|
|
try:
|
|
with open(users, encoding="utf-8", errors="replace") as f:
|
|
text = f.read()
|
|
for block in re.finditer(r'"(\d{5,})"\s*\{([^}]*)\}', text):
|
|
if re.search(r'"MostRecent"\s*"1"', block.group(2)):
|
|
recent = int(block.group(1))
|
|
except OSError:
|
|
pass
|
|
userdata = os.path.join(steam_root, "userdata")
|
|
if recent is not None:
|
|
acct = recent - 76561197960265728
|
|
return os.path.join(userdata, str(acct))
|
|
try:
|
|
dirs = [d for d in os.listdir(userdata) if d.isdigit() and d != "0"]
|
|
except OSError:
|
|
dirs = []
|
|
return os.path.join(userdata, dirs[0]) if len(dirs) == 1 else None
|
|
|
|
|
|
|
|
def parse(data):
|
|
pos = [0]
|
|
|
|
def cstr():
|
|
end = data.index(b"\x00", pos[0])
|
|
s = data[pos[0]:end].decode("utf-8", "replace")
|
|
pos[0] = end + 1
|
|
return s
|
|
|
|
def node():
|
|
out = {}
|
|
while True:
|
|
t = data[pos[0]]
|
|
pos[0] += 1
|
|
if t == 0x08:
|
|
return out
|
|
key = cstr()
|
|
if t == 0x00:
|
|
out[key] = node()
|
|
elif t == 0x01:
|
|
out[key] = cstr()
|
|
elif t == 0x02:
|
|
out[key] = struct.unpack_from("<i", data, pos[0])[0]
|
|
pos[0] += 4
|
|
else:
|
|
raise ValueError("unknown vdf type 0x%02x" % t)
|
|
|
|
t = data[pos[0]]
|
|
pos[0] += 1
|
|
key = cstr()
|
|
return {key: node()}
|
|
|
|
|
|
def write(obj):
|
|
out = bytearray()
|
|
|
|
def emit(key, value):
|
|
if isinstance(value, dict):
|
|
out.append(0x00)
|
|
out.extend(key.encode() + b"\x00")
|
|
for k, v in value.items():
|
|
emit(k, v)
|
|
out.append(0x08)
|
|
elif isinstance(value, int):
|
|
out.append(0x02)
|
|
out.extend(key.encode() + b"\x00" + struct.pack("<i", value))
|
|
else:
|
|
out.append(0x01)
|
|
out.extend(key.encode() + b"\x00" + str(value).encode() + b"\x00")
|
|
|
|
for k, v in obj.items():
|
|
emit(k, v)
|
|
out.append(0x08)
|
|
return bytes(out)
|
|
|
|
|
|
def shortcut(game, launch_options=None):
|
|
appid = int(game["appid"]) & 0xFFFFFFFF
|
|
return {
|
|
"appid": struct.unpack("<i", struct.pack("<I", appid))[0],
|
|
"AppName": game["name"],
|
|
"Exe": '"%s"' % game["exe"],
|
|
"StartDir": '"%s"' % game["dir"],
|
|
"icon": (game.get("art") or {}).get("icon", "") or "",
|
|
"ShortcutPath": "",
|
|
"LaunchOptions": launch_options if launch_options is not None else (game.get("launch") or ""),
|
|
"IsHidden": 0,
|
|
"AllowDesktopConfig": 1,
|
|
"AllowOverlay": 1,
|
|
"OpenVR": 0,
|
|
"Devkit": 0,
|
|
"DevkitGameID": "",
|
|
"DevkitOverrideAppID": 0,
|
|
"LastPlayTime": 0,
|
|
"FlatpakAppID": "",
|
|
"tags": {"0": TAG},
|
|
}
|
|
|
|
|
|
RECORD = ".droiddeck-shortcuts.json"
|
|
AWAY_LIMIT = 256
|
|
FIELDS = ("AppName", "Exe", "StartDir", "icon", "LaunchOptions")
|
|
FOLLOWED = ("StartDir", "LaunchOptions")
|
|
|
|
|
|
def unquoted(value):
|
|
return value.strip().strip('"') if isinstance(value, str) else ""
|
|
|
|
|
|
def read_record(path):
|
|
try:
|
|
with open(path, encoding="utf-8") as f:
|
|
record = json.load(f)
|
|
except (OSError, ValueError):
|
|
record = {}
|
|
if not isinstance(record, dict):
|
|
record = {}
|
|
games, away = record.get("games"), record.get("away")
|
|
return {
|
|
"games": {k: v for k, v in games.items() if isinstance(v, dict)} if isinstance(games, dict) else {},
|
|
"away": {k: v for k, v in away.items() if isinstance(v, dict) and isinstance(v.get("entry"), dict)} if isinstance(away, dict) else {},
|
|
}
|
|
|
|
|
|
def merge(fresh, current, state, seen):
|
|
state = state if isinstance(state, dict) else {}
|
|
rev = state.get("rev") if isinstance(state.get("rev"), int) else 0
|
|
if current is None:
|
|
return fresh, rev
|
|
base = state.get("app") if isinstance(state.get("app"), dict) else {field: current.get(field) for field in FIELDS}
|
|
before = state.get("steam") if isinstance(state.get("steam"), dict) else {"Exe": current.get("Exe")}
|
|
if unquoted(current.get("Exe")) != unquoted(before.get("Exe")):
|
|
rev += 1
|
|
entry = dict(current)
|
|
entry["appid"] = fresh["appid"]
|
|
exe = unquoted(fresh["Exe"])
|
|
if exe != unquoted(current.get("Exe")) and (exe != unquoted(base.get("Exe")) or seen == rev):
|
|
entry["Exe"], entry["StartDir"] = fresh["Exe"], fresh["StartDir"]
|
|
for field in ("AppName", "icon"):
|
|
if current.get(field) == base.get(field):
|
|
entry[field] = fresh[field]
|
|
if isinstance(state.get("app"), dict):
|
|
for field in FOLLOWED:
|
|
was = base.get(field, "" if field == "LaunchOptions" else current.get(field))
|
|
if fresh[field] != was and current.get(field) == was:
|
|
entry[field] = fresh[field]
|
|
tags = dict(current["tags"]) if isinstance(current.get("tags"), dict) else {}
|
|
if TAG not in tags.values():
|
|
slot = 0
|
|
while str(slot) in tags:
|
|
slot += 1
|
|
tags[str(slot)] = TAG
|
|
entry["tags"] = tags
|
|
for key, value in fresh.items():
|
|
entry.setdefault(key, value)
|
|
return entry, rev
|
|
|
|
|
|
def reconcile(existing, wanted, seen, record):
|
|
games, away = record["games"], dict(record["away"])
|
|
kept, ours, placed = [], [], {}
|
|
claimed = {(unquoted(fresh["Exe"]), fresh["AppName"]) for fresh in wanted.values()}
|
|
for value in existing.values():
|
|
if not isinstance(value, dict):
|
|
continue
|
|
tags = value.get("tags")
|
|
if not isinstance(tags, dict) or TAG not in tags.values():
|
|
if (unquoted(value.get("Exe")), value.get("AppName")) not in claimed:
|
|
kept.append(value)
|
|
continue
|
|
appid = value.get("appid")
|
|
if not isinstance(appid, int) or appid in placed:
|
|
continue
|
|
key = str(appid & 0xFFFFFFFF)
|
|
fresh = wanted.get(appid)
|
|
if fresh is None:
|
|
away.pop(key, None)
|
|
away[key] = {"entry": value, "state": games.get(key)}
|
|
continue
|
|
entry, rev = merge(fresh, value, games.get(key), seen.get(appid, 0))
|
|
placed[appid] = (len(ours), rev)
|
|
ours.append(entry)
|
|
for appid, fresh in wanted.items():
|
|
if appid in placed:
|
|
continue
|
|
key = str(appid & 0xFFFFFFFF)
|
|
stashed = away.get(key)
|
|
if stashed:
|
|
entry, rev = merge(fresh, stashed["entry"], stashed.get("state"), seen.get(appid, 0))
|
|
else:
|
|
entry, rev = merge(fresh, None, games.get(key), seen.get(appid, 0))
|
|
placed[appid] = (len(ours), rev)
|
|
ours.append(entry)
|
|
for appid in placed:
|
|
away.pop(str(appid & 0xFFFFFFFF), None)
|
|
while len(away) > AWAY_LIMIT:
|
|
away.pop(next(iter(away)))
|
|
state = {}
|
|
for appid, (index, rev) in placed.items():
|
|
entry = ours[index]
|
|
state[str(appid & 0xFFFFFFFF)] = {
|
|
"app": {field: wanted[appid][field] for field in FIELDS},
|
|
"steam": {field: entry.get(field, "") for field in ("AppName", "Exe", "StartDir", "LaunchOptions")},
|
|
"rev": rev,
|
|
}
|
|
return kept, ours, {"games": state, "away": away}
|
|
|
|
|
|
def save_record(path, record):
|
|
tmp = path + ".droiddeck"
|
|
with open(tmp, "w", encoding="utf-8") as f:
|
|
json.dump(record, f)
|
|
os.replace(tmp, path)
|
|
|
|
|
|
ART_MANIFEST = ".droiddeck-art.json"
|
|
ART_SLOTS = (("p", "p"), ("header", ""), ("hero", "_hero"), ("logo", "_logo"))
|
|
|
|
|
|
def install_art(acct, games):
|
|
"""Copies each game's art into the client's grid folder under the names it looks for. A file
|
|
the client already has that this script did not write (art the user set in the client) is
|
|
left alone; ours are replaced when the source changed and removed when the game lost its art."""
|
|
grid = os.path.join(acct, "config", "grid")
|
|
os.makedirs(grid, exist_ok=True)
|
|
manifest_path = os.path.join(grid, ART_MANIFEST)
|
|
try:
|
|
with open(manifest_path, encoding="utf-8") as f:
|
|
manifest = json.load(f)
|
|
except (OSError, ValueError):
|
|
manifest = {}
|
|
wanted = {}
|
|
copied = 0
|
|
for game in games:
|
|
art = game.get("art") or {}
|
|
appid = str(int(game["appid"]) & 0xFFFFFFFF)
|
|
for key, suffix in ART_SLOTS:
|
|
src = art.get(key)
|
|
if not src or not os.path.isfile(src):
|
|
continue
|
|
ext = os.path.splitext(src)[1].lower() or ".png"
|
|
if ext == ".jpeg":
|
|
ext = ".jpg"
|
|
name = appid + suffix + ext
|
|
dst = os.path.join(grid, name)
|
|
size = os.path.getsize(src)
|
|
if os.path.exists(dst) and name not in manifest:
|
|
continue
|
|
wanted[name] = size
|
|
if os.path.exists(dst) and manifest.get(name) == size:
|
|
continue
|
|
try:
|
|
shutil.copyfile(src, dst + ".tmp")
|
|
os.replace(dst + ".tmp", dst)
|
|
copied += 1
|
|
except OSError as e:
|
|
print("droiddeck-steam-shortcuts: could not copy art %s (%s)" % (name, e))
|
|
for name in list(manifest):
|
|
if name not in wanted:
|
|
try:
|
|
os.remove(os.path.join(grid, name))
|
|
except OSError:
|
|
pass
|
|
with open(manifest_path, "w", encoding="utf-8") as f:
|
|
json.dump(wanted, f)
|
|
if copied:
|
|
print("droiddeck-steam-shortcuts: %d piece(s) of art placed" % copied)
|
|
|
|
|
|
def main():
|
|
if len(sys.argv) < 3:
|
|
print(__doc__)
|
|
return 2
|
|
steam_root, listing = sys.argv[1], sys.argv[2]
|
|
try:
|
|
with open(listing, encoding="utf-8") as f:
|
|
games = json.load(f)
|
|
except (OSError, ValueError) as e:
|
|
print("droiddeck-steam-shortcuts: no list (%s)" % e)
|
|
return 0
|
|
acct = account_dir(steam_root)
|
|
if not acct:
|
|
print("droiddeck-steam-shortcuts: no signed-in account yet; nothing written")
|
|
return 0
|
|
config = os.path.join(acct, "config")
|
|
os.makedirs(config, exist_ok=True)
|
|
path = os.path.join(config, "shortcuts.vdf")
|
|
existing = {}
|
|
if os.path.isfile(path):
|
|
try:
|
|
with open(path, "rb") as f:
|
|
existing = parse(f.read()).get("shortcuts", {})
|
|
except (ValueError, IndexError, struct.error) as e:
|
|
print("droiddeck-steam-shortcuts: could not read the existing file (%s); keeping it unchanged" % e)
|
|
return 1
|
|
helper = os.path.join(os.path.dirname(os.path.abspath(__file__)), "droiddeck-steam-games")
|
|
loader = importlib.machinery.SourceFileLoader("steam_games", helper)
|
|
spec = importlib.util.spec_from_loader(loader.name, loader)
|
|
routing = importlib.util.module_from_spec(spec)
|
|
loader.exec_module(routing)
|
|
games, routes = routing.route(steam_root, acct, games)
|
|
wanted, seen = {}, {}
|
|
for game in games:
|
|
if game.get("exe") and game.get("name"):
|
|
entry = shortcut(game)
|
|
if entry["appid"] not in wanted:
|
|
wanted[entry["appid"]] = entry
|
|
seen[entry["appid"]] = game["seen"] if isinstance(game.get("seen"), int) else 0
|
|
record_path = os.path.join(config, RECORD)
|
|
kept, ours, record = reconcile(existing, wanted, seen, read_record(record_path))
|
|
entries = {str(i): v for i, v in enumerate(kept + ours)}
|
|
tmp = path + ".droiddeck"
|
|
with open(tmp, "wb") as f:
|
|
f.write(write({"shortcuts": entries}))
|
|
os.replace(tmp, path)
|
|
save_record(record_path, record)
|
|
print("droiddeck-steam-shortcuts: %d added game(s) written, %d of the client's own kept" % (len(ours), len(kept)))
|
|
install_art(acct, [g for g in games if g.get("exe") and g.get("name")])
|
|
try:
|
|
compat_path = "/usr/local/bin/steam-compatibility"
|
|
spec = importlib.util.spec_from_file_location("compat", compat_path, loader=importlib.machinery.SourceFileLoader("compat", compat_path))
|
|
compat = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(compat)
|
|
cfg = os.path.join(steam_root, "config", "config.vdf")
|
|
if os.path.isfile(cfg) and (ours or routes):
|
|
tools = os.path.join(steam_root, "compatibilitytools.d")
|
|
x64_tool = os.environ.get("BL_COMPAT_TOOL")
|
|
own = {}
|
|
if x64_tool:
|
|
protect = {compat.first_key(os.path.join(tools, e, "compatibilitytool.vdf"), ["compatibilitytools", "compat_tools"]) or e: e
|
|
for e in (os.listdir(tools) if os.path.isdir(tools) else [])}
|
|
# Its own state: the arm64 client's state.json lists which of that client's titles follow its default.
|
|
own = {"default": x64_tool,
|
|
"directory": os.path.join(os.path.dirname(os.path.abspath(steam_root)), "droiddeck-compat"),
|
|
"linux_tool": "droiddeck-direct"}
|
|
else:
|
|
protect = compat.adopt_extras(tools)
|
|
used = compat.register_default(cfg, apps=[str(int(g["appid"]) & 0xFFFFFFFF) for g in games if g.get("exe") and not g.get("native")] + [str(appid) for appid in set(routes.values())],
|
|
protect=protect, **own)
|
|
print("droiddeck-steam-shortcuts: mapped them to %s" % used)
|
|
except Exception as e:
|
|
print("droiddeck-steam-shortcuts: compat mapping skipped (%s)" % e)
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|