Files
DroidDeck/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-shortcuts
T
The412Banner db8d1c9910 feat: optional x86-64 Steam client (Valve's Linux client under FEX) beside the arm64 one (#152)
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.
2026-10-17 23:57:52 -04:00

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())