Files
DroidDeck/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-shortcuts
T

373 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, best = None, 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):
stamp = re.search(r'"timestamp"\s*"(\d+)"', block.group(2))
rank = (bool(re.search(r'"MostRecent"\s*"1"', block.group(2))),
bool(re.search(r'"AutoLogin"\s*"1"', block.group(2))),
int(stamp.group(1)) if stamp else 0)
if any(rank) and (best is None or rank >= best):
recent, best = int(block.group(1)), rank
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())