From 6b110581ac167b1476d945db6b38327c63cd399e Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Sun, 8 Nov 2026 18:45:53 -0500 Subject: [PATCH] fix(gog): install scripts' support files reach the prefix (#2294) * fix(gog): install scripts' support files reach the prefix A goggame-.script can copy files into the prefix with supportData actions: default INI files, Plugins.txt and other settings that mods such as one-click editions need. Only setRegistry actions were applied, so those games started without their configuration and ran as the base game. droiddeck-store-launch now applies supportData after the registry, once per script revision: copies from {app} and {supportDir} into {userdocs} and {localappdata}, matching paths without regard to case. Links are copied as links, paths outside those folders are refused, and existing files are replaced only when the action asks for it. * Keep GOG support data copies inside the game and prefix folders * Copy linked GOG support sources as links and keep a player's own links --- docs/development/stores.md | 9 + .../usr/local/bin/droiddeck-store-launch | 117 +++++++++++ tools/tests/test_store_launch.py | 191 +++++++++++++++++- 3 files changed, 316 insertions(+), 1 deletion(-) diff --git a/docs/development/stores.md b/docs/development/stores.md index 78855ea749..278c0cbd8d 100644 --- a/docs/development/stores.md +++ b/docs/development/stores.md @@ -244,6 +244,15 @@ self-extractor stops at "Path not found", so the values it installs are applied `witcher.exe` exits during startup. The language comes from the installed product's `goggame-.info`, and a script's own `setRegistry` entries always win over the built-in table. +The script's `supportData` actions run right after: files and folders from the game folder +(`{app}`) or its support files (`{supportDir}`, `support//`) are copied to `{userdocs}` and +`{localappdata}` in the prefix, and `type: folder` without a source creates the folder. Mods such +as one-click editions ship their `Plugins.txt` and INI files this way. Paths match without regard +to case, links are copied as links, and a path outside those folders is refused. A file the +player already has is replaced only when the action says `overwrite`. `.droiddeck-gog-support` in +the prefix holds the actions' hash, so they run once per script revision and a player's later +edits stay. + A GOG game's exe comes from its own manifest first: `goggame-.info`'s play task in category `game` (`isPrimary` first), or a primary `launcher` task for launcher games, whose `path` stays inside the folder; any other `goggame-*.info` in the folder supplies the task only when the diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch b/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch index 131c049062..b2e2b870e0 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch @@ -5,6 +5,7 @@ import binascii import json import os import re +import shutil import sys import time import subprocess @@ -352,6 +353,7 @@ def prepare_gog(sidecar, compat_data, launch_dir): GOG_SCRIPTS = "goggame-*.script" GOG_REGISTRY_MARK = ".droiddeck-gog-registry" +GOG_SUPPORT_MARK = ".droiddeck-gog-support" GOG_ROOTS = {"HKEY_LOCAL_MACHINE": "HKEY_LOCAL_MACHINE", "HKLM": "HKEY_LOCAL_MACHINE", "HKEY_CURRENT_USER": "HKEY_CURRENT_USER", "HKCU": "HKEY_CURRENT_USER", "HKEY_CLASSES_ROOT": "HKEY_CLASSES_ROOT", "HKCR": "HKEY_CLASSES_ROOT"} @@ -611,6 +613,120 @@ def apply_gog_registry(folder, compat_data, proton, timeout=90, installation=Non return "import-failed" + note +def gog_support_actions(folder): + found = [] + for script in sorted(Path(folder).glob(GOG_SCRIPTS)): + product = script.name[len("goggame-"):-len(".script")] + try: + actions = json.loads(script.read_text(encoding="utf-8-sig")).get("actions") + except (OSError, ValueError, AttributeError): + continue + for action in actions if isinstance(actions, list) else []: + install = action.get("install") if isinstance(action, dict) else None + if isinstance(install, dict) and install.get("action") == "supportData" \ + and isinstance(install.get("arguments"), dict): + found.append((product, install["arguments"])) + return found + + +def gog_support_bases(folder, product, pfx): + user = Path(pfx) / "drive_c" / "users" / "steamuser" + support = Path(folder) / "support" / product + return {"app": Path(folder), "supportdir": support, "support": support, + "userdocs": user / "Documents", "localappdata": user / "AppData" / "Local"} + + +def gog_inside(path, base): + root = os.path.realpath(base) + real = os.path.realpath(path) + return real == root or real.startswith(root + os.sep) + + +def gog_support_path(text, bases): + match = re.fullmatch(r"\{(\w+)\}(.*)", text) if isinstance(text, str) else None + if not match or match.group(1).lower() not in bases: + return None + parts = [part for part in re.split(r"[\\/]+", match.group(2)) if part] + if any(part in (".", "..") for part in parts): + return None + base = bases[match.group(1).lower()] + path = base + for part in parts: + exact = path / part + if not exact.exists() and path.is_dir(): + exact = next((child for child in path.iterdir() if child.name.lower() == part.lower()), exact) + path = exact + if path != base and not gog_inside(path.parent, base): + return None + return path, base + + +def gog_copy_file(source, target, root): + if not gog_inside(target.parent, root): + raise OSError("outside " + str(root)) + target.parent.mkdir(parents=True, exist_ok=True) + if target.is_symlink(): + target.unlink() + shutil.copy2(source, target, follow_symlinks=False) + + +def gog_support_data(folder, compat_data, proton): + actions = gog_support_actions(folder) + if not actions: + return "none" + pfx = Path(compat_data) / "pfx" if compat_data else None + if not pfx or not (pfx / "drive_c" / "users" / "steamuser").is_dir(): + made = create_prefix(compat_data, proton) + if made not in ("present", "created") or not (pfx / "drive_c" / "users" / "steamuser").is_dir(): + return "no-prefix" + stamp = hashlib.sha256(json.dumps(actions, sort_keys=True).encode("utf-8")).hexdigest() + marker = pfx / GOG_SUPPORT_MARK + try: + if marker.is_file() and marker.read_text() == stamp: + return "ready" + except OSError: + pass + copied = skipped = missing = 0 + for product, arguments in actions: + bases = gog_support_bases(folder, product, pfx) + found = gog_support_path(arguments.get("target"), bases) + origin = gog_support_path(arguments["source"], bases) if "source" in arguments else None + if found is None or ("source" in arguments and origin is None): + skipped += 1 + continue + target, root = found + source = origin[0] if origin else None + try: + if source is None: + target.mkdir(parents=True, exist_ok=True) + elif not source.exists(): + missing += 1 + elif source.is_dir() and not source.is_symlink(): + for top, dirs, files in os.walk(source): + for name in sorted(files + [d for d in dirs if (Path(top) / d).is_symlink()]): + item = Path(top) / name + destination = target / item.relative_to(source) + if (destination.exists() or destination.is_symlink()) and not arguments.get("overwrite"): + continue + gog_copy_file(item, destination, root) + copied += 1 + target.mkdir(parents=True, exist_ok=True) + elif (target.exists() or target.is_symlink()) and not arguments.get("overwrite"): + continue + else: + gog_copy_file(source, target, root) + copied += 1 + except OSError: + skipped += 1 + note = "".join(" %s=%d" % (name, count) for name, count in (("skipped", skipped), ("missing", missing)) if count) + if not skipped: + try: + marker.write_text(stamp) + except OSError: + pass + return "copied=%d%s" % (copied, note) + + def main(argv): if os.environ.get("DROIDDECK_GOG_MAINTENANCE") == "1": return 0 @@ -654,6 +770,7 @@ def main(argv): if store == "gog": prepare_gog(sidecar, compat_data, launch_dir) log("gog registry: " + apply_gog_registry(folder, compat_data, os.environ.get("BL_STORE_PROTON", ""))) + log("gog support data: " + gog_support_data(folder, compat_data, os.environ.get("BL_STORE_PROTON", ""))) if store == "epic": handled = os.environ.get(EPIC_HANDLED) == "1" and (folder / EPIC_ARGS).is_file() if not handled: diff --git a/tools/tests/test_store_launch.py b/tools/tests/test_store_launch.py index 7ea5a1ae79..863eb679a9 100644 --- a/tools/tests/test_store_launch.py +++ b/tools/tests/test_store_launch.py @@ -387,6 +387,193 @@ def set_registry(**arguments): return {'install': {'action': 'setRegistry', 'arguments': arguments}, 'name': 'setRegistry'} +def support_data(**arguments): + return {'install': {'action': 'supportData', 'arguments': arguments}, 'name': 'supportData'} + + +class GogSupportData(unittest.TestCase): + def prefix(self, root): + user = Path(root) / 'compat/pfx/drive_c/users/steamuser' + user.mkdir(parents=True) + return user + + def test_support_files_reach_the_prefix_once(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + user = self.prefix(root) + support = folder / 'support/9' + (support / 'Docs').mkdir(parents=True) + (support / 'Docs/Fallout4.ini').write_text('[Archive]\n') + (support / 'Plugins.txt').write_text('*LondonWorldSpace.esm\n') + (folder / '__AppData/Saves').mkdir(parents=True) + (folder / '__AppData/Saves/a.txt').write_text('a') + gog_script(folder, '9', [ + set_registry(root='HKLM', subkey='Software\\Game', valueName='a', valueData='b', valueType='string'), + support_data(type='folder', target='{userdocs}/My Games/Fallout4'), + support_data(type='file', overwrite=True, source='{supportDir}/docs/Fallout4.ini', + target='{userdocs}/My Games/Fallout4/Fallout4.ini'), + support_data(type='file', overwrite=True, source='{supportDir}/Plugins.txt', + target='{localappdata}/Fallout4/Plugins.txt'), + support_data(type='folder', overwrite=True, source='{app}/__AppData', target='{localappdata}/Fallout4'), + ]) + with patch.object(store, 'create_prefix') as create: + self.assertEqual('copied=3', store.gog_support_data(folder, root + '/compat', '/proton')) + create.assert_not_called() + self.assertTrue((user / 'Documents/My Games/Fallout4').is_dir()) + self.assertEqual('[Archive]\n', (user / 'Documents/My Games/Fallout4/Fallout4.ini').read_text()) + self.assertEqual('*LondonWorldSpace.esm\n', (user / 'AppData/Local/Fallout4/Plugins.txt').read_text()) + self.assertEqual('a', (user / 'AppData/Local/Fallout4/Saves/a.txt').read_text()) + (user / 'AppData/Local/Fallout4/Plugins.txt').write_text('player order') + self.assertEqual('ready', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertEqual('player order', (user / 'AppData/Local/Fallout4/Plugins.txt').read_text()) + + def test_a_source_the_build_lacks_does_not_recopy_the_rest_every_launch(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + user = self.prefix(root) + (folder / 'support/9').mkdir(parents=True) + (folder / 'support/9/Plugins.txt').write_text('x') + gog_script(folder, '9', [ + support_data(type='file', overwrite=True, source='{supportDir}/Plugins.txt', target='{localappdata}/G/Plugins.txt'), + support_data(type='folder', overwrite=True, source='{app}/__AppData', target='{localappdata}/G'), + ]) + self.assertEqual('copied=1 missing=1', store.gog_support_data(folder, root + '/compat', '/proton')) + (user / 'AppData/Local/G/Plugins.txt').write_text('player order') + self.assertEqual('ready', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertEqual('player order', (user / 'AppData/Local/G/Plugins.txt').read_text()) + + def test_a_link_never_carries_a_copy_outside(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + user = self.prefix(root) + outside = Path(root) / 'outside' + outside.mkdir() + (outside / 'secret.ini').write_text('s') + (folder / '__AppData').mkdir() + (folder / '__AppData/linked').symlink_to(outside) + (folder / 'support/9').mkdir(parents=True) + (folder / 'support/9/a.ini').write_text('a') + gog_script(folder, '9', [ + support_data(type='folder', overwrite=True, source='{app}/__AppData', target='{localappdata}/G'), + support_data(type='file', overwrite=True, source='{supportDir}/a.ini', target='{localappdata}/G/linked/a.ini'), + support_data(type='file', overwrite=True, source='{app}/__AppData/linked/secret.ini', target='{userdocs}/secret.ini'), + ]) + self.assertEqual('copied=1 skipped=2', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertTrue((user / 'AppData/Local/G/linked').is_symlink()) + self.assertEqual(['secret.ini'], sorted(p.name for p in outside.iterdir())) + self.assertFalse((user / 'Documents/secret.ini').exists()) + + def test_a_linked_source_folder_is_copied_as_a_link(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + user = self.prefix(root) + outside = Path(root) / 'outside' + outside.mkdir() + (outside / 'secret.ini').write_text('s') + (folder / 'linked').symlink_to(outside) + gog_script(folder, '9', [support_data(type='folder', overwrite=True, source='{app}/linked', target='{userdocs}/G')]) + store.gog_support_data(folder, root + '/compat', '/proton') + self.assertTrue((user / 'Documents/G').is_symlink()) + self.assertEqual(outside, Path(os.readlink(user / 'Documents/G'))) + + def test_a_players_own_links_stay_without_overwrite(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + user = self.prefix(root) + (folder / 'support/9/Saves').mkdir(parents=True) + (folder / 'support/9/a.ini').write_text('a') + (folder / 'support/9/Saves/b.ini').write_text('b') + (user / 'Documents/G').mkdir(parents=True) + (user / 'Documents/a.ini').symlink_to(user / 'mine.ini') + (user / 'Documents/G/b.ini').symlink_to(user / 'gone.ini') + gog_script(folder, '9', [ + support_data(type='file', source='{supportDir}/a.ini', target='{userdocs}/a.ini'), + support_data(type='folder', source='{supportDir}/Saves', target='{userdocs}/G'), + ]) + self.assertEqual('copied=0', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertEqual(user / 'mine.ini', Path(os.readlink(user / 'Documents/a.ini'))) + self.assertEqual(user / 'gone.ini', Path(os.readlink(user / 'Documents/G/b.ini'))) + + def test_a_changed_script_applies_again(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + user = self.prefix(root) + (folder / 'support/9').mkdir(parents=True) + (folder / 'support/9/a.ini').write_text('1') + action = support_data(type='file', overwrite=True, source='{supportDir}/a.ini', target='{userdocs}/a.ini') + gog_script(folder, '9', [action]) + self.assertEqual('copied=1', store.gog_support_data(folder, root + '/compat', '/proton')) + (folder / 'support/9/b.ini').write_text('2') + gog_script(folder, '9', [action, support_data(type='file', overwrite=True, source='{supportDir}/b.ini', + target='{userdocs}/b.ini')]) + self.assertEqual('copied=2', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertEqual('2', (user / 'Documents/b.ini').read_text()) + + def test_a_players_file_is_kept_unless_the_script_overwrites_it(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + user = self.prefix(root) + (folder / 'support/9').mkdir(parents=True) + (folder / 'support/9/a.ini').write_text('default') + (user / 'Documents').mkdir() + (user / 'Documents/a.ini').write_text('mine') + gog_script(folder, '9', [support_data(type='file', source='{supportDir}/a.ini', target='{userdocs}/a.ini')]) + self.assertEqual('copied=0', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertEqual('mine', (user / 'Documents/a.ini').read_text()) + + def test_paths_outside_the_known_folders_are_refused(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + self.prefix(root) + (folder / 'support/9').mkdir(parents=True) + (folder / 'support/9/a.ini').write_text('x') + gog_script(folder, '9', [ + support_data(type='file', overwrite=True, source='{supportDir}/a.ini', target='{userdocs}/../../../../escape.ini'), + support_data(type='file', overwrite=True, source='{supportDir}/a.ini', target='C:/escape.ini'), + support_data(type='folder', target='{windir}/x'), + ]) + self.assertEqual('copied=0 skipped=3', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertEqual([], list(Path(root).rglob('escape.ini'))) + self.assertFalse((Path(root) / 'compat/pfx' / store.GOG_SUPPORT_MARK).exists()) + + def test_links_in_a_support_folder_are_copied_as_links(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + user = self.prefix(root) + outside = Path(root) / 'outside' + outside.mkdir() + (outside / 'secret.txt').write_text('s') + (folder / '__AppData').mkdir() + (folder / '__AppData/linked').symlink_to(outside, target_is_directory=True) + gog_script(folder, '9', [support_data(type='folder', overwrite=True, source='{app}/__AppData', target='{localappdata}/G')]) + self.assertEqual('copied=1', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertTrue((user / 'AppData/Local/G/linked').is_symlink()) + self.assertEqual('s', (outside / 'secret.txt').read_text()) + + def test_without_support_data_no_prefix_is_made(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + gog_script(folder, '9', [set_registry(root='HKLM', subkey='Software\\Game', valueName='a', valueData='b', valueType='string')]) + with patch.object(store, 'create_prefix') as create: + self.assertEqual('none', store.gog_support_data(folder, root + '/compat', '/proton')) + create.assert_not_called() + + def test_a_missing_prefix_is_made_first(self): + with tempfile.TemporaryDirectory() as root: + folder = game(root, store_id='gog', ident='9') + gog_script(folder, '9', [support_data(type='folder', target='{userdocs}/My Games/G')]) + with patch.object(store, 'create_prefix', return_value='failed') as create: + self.assertEqual('no-prefix', store.gog_support_data(folder, root + '/compat', '/proton')) + create.assert_called_once_with(root + '/compat', '/proton') + + def made(compat_data, proton): + self.prefix(root) + return 'created' + with patch.object(store, 'create_prefix', side_effect=made): + self.assertEqual('copied=0', store.gog_support_data(folder, root + '/compat', '/proton')) + self.assertTrue((Path(root) / 'compat/pfx/drive_c/users/steamuser/Documents/My Games/G').is_dir()) + + class GogRegistry(unittest.TestCase): def test_patch_registration_uses_authentic_build_and_the_prefix_registry_executable(self): with tempfile.TemporaryDirectory() as root: @@ -605,6 +792,8 @@ class GogRegistry(unittest.TestCase): folder = game(root, store_id='gog') with patch.dict(os.environ, {'BL_LAUNCH_DIR': root, 'STEAM_COMPAT_DATA_PATH': root + '/compat/', 'BL_STORE_PROTON': '/chosen/proton'}), \ patch.object(store, 'prepare_gog', return_value=False), patch.object(store, 'ask', return_value=None), \ - patch.object(store, 'apply_gog_registry', return_value='ready') as apply: + patch.object(store, 'apply_gog_registry', return_value='ready') as apply, \ + patch.object(store, 'gog_support_data', return_value='ready') as support: store.main([str(folder / store.LAUNCHER)]) apply.assert_called_once_with(folder, root + '/compat', '/chosen/proton') + support.assert_called_once_with(folder, root + '/compat', '/chosen/proton')