a2qlinux 0.2.0__py3-none-any.whl

a2qlinux/steam.py

@@ -0,0 +1,101 @@
+"""Steam launch-option wrapper for AION 2: start A2Qlinux, then the game.
+
+Steam > AION 2 > Properties > General > Launch Options:
+    a2qlinux-steam %command%
+Launcher options go before %command%, e.g.
+    a2qlinux-steam --close-with-game %command%
+Where Questlog is, and what happens after the game, come from
+~/.config/a2qlinux/config.toml (a2qlinux.config).
+
+The launcher is started through the user's systemd manager, not as a child of
+this process: it then runs with the desktop session's environment instead of
+Steam's (overlay preload, container variables), and Steam does not count it as
+part of the game. Whatever happens to it, the game is started.
+
+The game starts once Questlog runs, and joins Questlog's Wine session. The
+session then belongs to Questlog's launch, not to the game's, so when the game
+ends, Steam can be told so without touching Questlog (docs/ARCHITECTURE.md
+§5.1, §6.7).
+"""
+
+import os
+import subprocess
+import sys
+import time
+
+from .desktop import LOCK
+from .launcher import APPID, game_processes
+
+# Launcher options accepted in front of %command%.
+OPTIONS = ("--close-with-game", "--no-auto-update")
+QUESTLOG_UP_WAIT = 60   # s for Questlog to be running before the game starts without it
+
+
+def wait_for_questlog(timeout=QUESTLOG_UP_WAIT):
+    """True once Questlog runs in the game's prefix, False if it does not within `timeout` s."""
+    deadline = time.monotonic() + timeout
+    while not game_processes(APPID, ["questlog.exe"])["questlog.exe"]:
+        if time.monotonic() >= deadline:
+            return False
+        time.sleep(0.25)
+    return True
+
+
+def record(text):
+    with open(LOCK.parent / "steam_launch.log", "a") as log:
+        log.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} {text}\n")
+
+
+def switch_proton_verb(command):
+    """Proton's `waitforexitandrun` -> `run`; returns (command, switched).
+
+    Questlog may already run in the game's prefix (started from its icon, e.g.
+    to look through saved fights). Proton's waitforexitandrun would then wait
+    for the prefix to go idle - i.e. until Questlog is closed. With `run`, the
+    game joins the Wine session Questlog runs in, and Questlog sees it at once.
+    Only Proton's own verb is switched: the word right after a `…/proton`
+    argument. Steam's runtime keeps --verb=waitforexitandrun, which marks the
+    game's main container.
+    """
+    command = list(command)
+    for i in range(1, len(command)):
+        if command[i] == "waitforexitandrun" and command[i - 1].endswith("/proton"):
+            command[i] = "run"
+            return command, True
+    return command, False
+
+
+def main():
+    args = sys.argv[1:]
+    options = []
+    while args and args[0] in OPTIONS:
+        options.append(args.pop(0))
+    if not args:
+        print("usage: a2qlinux-steam [--close-with-game] [--no-auto-update] %command%", file=sys.stderr)
+        return 2
+    started = subprocess.run(
+        ["systemd-run", "--user", "--quiet", "--collect", f"--unit=questlog-aion2-{os.getpid()}",
+         sys.executable, "-m", "a2qlinux.desktop", "--for-game", *options],
+        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False)
+    if started.returncode:
+        subprocess.run(["notify-send", "--app-name=Questlog (AION 2)", "Questlog (AION 2)",
+                        "Could not start Questlog from the Steam launch option; start it from its icon."],
+                       stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False)
+
+    # The game waits for Questlog, then joins its Wine session (`run`); the two
+    # never bring up the prefix's Wine at the same moment. Without Questlog the
+    # game starts as Steam asked; a Questlog that comes up later yields to it
+    # (the launcher's steam_launch_pending).
+    # (A Questlog already running is joined even if starting the launcher failed.)
+    if wait_for_questlog(QUESTLOG_UP_WAIT if not started.returncode else 0):
+        args, switched = switch_proton_verb(args)
+        if switched:
+            record("Questlog running: Proton verb waitforexitandrun -> run")
+    elif not started.returncode:
+        record(f"Questlog not running {QUESTLOG_UP_WAIT} s after the launcher was started; "
+               "the game starts on its own")
+    os.execvp(args[0], args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

a2qlinux/tray.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""Questlog's tray icon, drawn by the desktop instead of by Wine.
+
+Questlog's own tray icon is a Windows icon shown through Wine, and under Wine
+its menu opens only once: Electron gives up on the menu when it cannot bring
+its window to the foreground, and Wine's explorer.exe never grants that
+(docs/ARCHITECTURE.md §6.2). the launcher (a2qlinux/launcher.py) hides that icon and runs this one instead, for
+as long as Questlog runs.
+
+This process only reports what was chosen, one word per line on stdout:
+    open    left click, or "Open Questlog"
+    quit    "Quit Questlog"
+the launcher (a2qlinux/launcher.py) does the rest. It ends when its stdin closes, i.e. when
+the launcher (a2qlinux/launcher.py) stops it or ends itself.
+
+With --check it only tells whether it could run here: exit code 0 if Qt
+starts and the desktop has a system tray, otherwise 1 with the reason on
+stderr (Qt's own message when Qt cannot start). a2qlinux-setup runs it.
+"""
+
+from pathlib import Path
+import sys
+
+from PyQt6.QtCore import QSocketNotifier
+from PyQt6.QtGui import QIcon
+from PyQt6.QtWidgets import QApplication, QMenu, QSystemTrayIcon
+
+ICON = Path.home() / ".local" / "share" / "icons" / "questlog-aion2.png"   # written by a2qlinux-setup
+
+
+def report(action):
+    print(action, flush=True)
+
+
+def main():
+    app = QApplication(sys.argv)
+    app.setApplicationName("Questlog (AION 2)")
+    app.setDesktopFileName("questlog-aion2")
+    app.setQuitOnLastWindowClosed(False)
+    if not QSystemTrayIcon.isSystemTrayAvailable():
+        print("a2qlinux tray: the desktop has no system tray", file=sys.stderr)
+        return 1
+    if "--check" in sys.argv[1:]:
+        return 0
+
+    tray = QSystemTrayIcon(QIcon(str(ICON)), app)
+    tray.setToolTip("Questlog (AION 2)")
+    menu = QMenu()
+    menu.addAction("Open Questlog").triggered.connect(lambda: report("open"))
+    menu.addSeparator()
+    menu.addAction("Quit Questlog").triggered.connect(lambda: report("quit"))
+    tray.setContextMenu(menu)
+    tray.activated.connect(lambda reason: reason == QSystemTrayIcon.ActivationReason.Trigger and report("open"))
+    tray.show()
+
+    def parent_gone():
+        if not sys.stdin.buffer.read1(4096):
+            app.quit()
+
+    watcher = QSocketNotifier(sys.stdin.fileno(), QSocketNotifier.Type.Read)
+    watcher.activated.connect(parent_gone)
+    return app.exec()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

a2qlinux/update.py

@@ -0,0 +1,411 @@
+"""Keep Questlog up to date under Proton, where its own installer cannot run.
+
+Questlog updates itself with electron-updater: it downloads the new installer
+in the background and runs it on quit. Under Wine that installer stops with
+code 2 (docs/ARCHITECTURE.md §7.5), so the launcher does the update instead,
+the way docs/UPDATING.md describes doing it by hand:
+
+  while Questlog runs   stage(): read the feed, download the installer, check
+                        size and SHA-512, unpack it, check that the new
+                        version still fits A2Qlinux (compatibility_problems),
+                        and leave it in <state>/update/<version>/app
+  before the next start install_staged(): swap the Questlog folder for the
+                        staged one, keeping the old one as a backup
+  if it then fails      rollback(): put the old folder back
+
+The first installation goes through the same download and checks:
+install_fresh(), run by a2qlinux-setup when the Questlog folder has no
+Questlog.exe, puts the newest version that fits straight into place.
+
+Questlog's own updater is switched off (disable_builtin_updater), so it no
+longer downloads 115 MB that it cannot install, nor offers an install button
+that does nothing. Without resources/app-update.yml it only logs
+"[updater] … ENOENT" every five minutes; nothing else changes (tested).
+
+Nothing here is silent: each step reports through the `log` callback, and
+what the user should know (an update ready, an update that does not fit) goes
+to `notify` as well.
+"""
+
+import base64
+import hashlib
+import json
+from pathlib import Path
+import re
+import shutil
+import struct
+import subprocess
+import tempfile
+import threading
+import urllib.request
+
+FEED = "https://cdn.questlog.gg/desktop/latest.yml"
+DOWNLOADS = "https://cdn.questlog.gg/desktop/"
+# The libpcap calls bridge/wpcap_bridge.c implements.
+PCAP_CALLS = {"pcap_close", "pcap_compile", "pcap_datalink", "pcap_findalldevs", "pcap_freealldevs",
+              "pcap_freecode", "pcap_geterr", "pcap_next_ex", "pcap_open_live", "pcap_setfilter",
+              "pcap_setnonblock"}
+# Electron versions whose tray icon id and WM_ENDSESSION handling were read in
+# their source (questlog_ctl.exe depends on both; docs/ARCHITECTURE.md §10).
+KNOWN_ELECTRON = {"44.5.1"}
+STATE_FILE = "staged.json"
+# The CDN refuses Python's default User-Agent (403); it accepts one that names us.
+USER_AGENT = "A2Qlinux (Questlog updater for Linux)"
+# Held while staging or installing, so an install never meets a half-written stage.
+BUSY = threading.Lock()
+
+
+# ------------------------------------------------------------------ archive
+
+def read_asar_file(asar, name):
+    """One file from an Electron app.asar archive.
+
+    Layout: a 16-byte prefix (pickle sizes; the 4th field is the length of
+    the JSON header), the JSON header describing every file with an offset
+    relative to the end of the header pickle, then the file data. Files kept
+    outside the archive are in app.asar.unpacked.
+    """
+    with open(asar, "rb") as stream:
+        _, header_size, _, json_size = struct.unpack("<4I", stream.read(16))
+        node = json.loads(stream.read(json_size))
+        for part in name.split("/"):
+            node = node["files"][part]
+        if node.get("unpacked"):
+            return (Path(str(asar) + ".unpacked") / name).read_bytes()
+        stream.seek(8 + header_size + int(node["offset"]))
+        return stream.read(node["size"])
+
+
+def version_key(version):
+    return tuple(int(part) for part in re.findall(r"\d+", version))
+
+
+def installed_version(questlog_dir):
+    """Questlog's version from its app.asar; None if it cannot be read."""
+    try:
+        package = read_asar_file(Path(questlog_dir) / "resources" / "app.asar", "package.json")
+        return json.loads(package)["version"]
+    except (OSError, KeyError, ValueError, struct.error):
+        return None
+
+
+def parse_feed(text):
+    """version, installer file name, SHA-512 (base64) and size from latest.yml.
+
+    The file is electron-builder's fixed format; only its top-level scalars
+    and the first entry of `files` are needed, so no YAML library is used.
+    """
+    found = {}
+    for line in text.splitlines():
+        match = re.match(r"^(version|path|sha512):\s*'?([^']+?)'?\s*$", line)
+        if match:
+            found[match.group(1)] = match.group(2)
+        match = re.match(r"^\s+size:\s*(\d+)\s*$", line)
+        if match and "size" not in found:
+            found["size"] = int(match.group(1))
+    missing = {"version", "path", "sha512", "size"} - found.keys()
+    if missing:
+        raise ValueError(f"latest.yml lacks {', '.join(sorted(missing))}")
+    if "/" in found["path"] or not found["path"].endswith(".exe"):
+        raise ValueError(f"latest.yml names an unexpected installer: {found['path']!r}")
+    return found
+
+
+# ------------------------------------------------------------ compatibility
+
+def compatibility_problems(app_dir):
+    """What in an unpacked Questlog would break A2Qlinux; an empty list means it fits.
+
+    The checks listed in docs/ARCHITECTURE.md §10.
+    """
+    app_dir = Path(app_dir)
+    asar = app_dir / "resources" / "app.asar"
+    problems = []
+    try:
+        main = read_asar_file(asar, ".output/electron/main.cjs").decode("utf-8", "replace")
+        worker = read_asar_file(asar, ".output/electron/workers/aion-2/combat.cjs").decode("utf-8", "replace")
+    except (OSError, KeyError, ValueError, struct.error) as error:
+        return [f"its app.asar could not be read ({error!r})"]
+    calls = set(re.findall(r"(pcap_[a-z_]+)\(", worker))
+    if calls - PCAP_CALLS:
+        problems.append(f"it calls libpcap functions the bridge DLL lacks: {', '.join(sorted(calls - PCAP_CALLS))}")
+    if not calls:
+        problems.append("its capture worker calls no libpcap functions any more")
+    electron = re.search(rb"Electron/(\d+\.\d+\.\d+)", (app_dir / "Questlog.exe").read_bytes()) \
+        if (app_dir / "Questlog.exe").is_file() else None
+    if not electron:
+        problems.append("its Electron version could not be read")
+    elif electron.group(1).decode() not in KNOWN_ELECTRON:
+        problems.append(f"it uses Electron {electron.group(1).decode()}, not yet checked "
+                        f"(known: {', '.join(sorted(KNOWN_ELECTRON))}); its tray icon id and session end "
+                        "need reading in that version's source")
+    if not re.search(r'on\("second-instance",[A-Za-z0-9_$]+\.show\)', main):
+        problems.append("a second start no longer simply shows its window (Open Questlog relies on it)")
+    if "focusable:!1" not in main:
+        problems.append("its overlay windows are no longer non-activatable (the window-order guard relies on it)")
+    try:
+        read_asar_file(asar, "resources/icon.png")
+    except (KeyError, OSError):
+        problems.append("its icon resources/icon.png is gone (a2qlinux-setup takes it from there)")
+    return problems
+
+
+# --------------------------------------------------------------- built-in updater
+
+def disable_builtin_updater(questlog_dir, log):
+    """Remove resources/app-update.yml, which is all Questlog's own updater runs on."""
+    config = Path(questlog_dir) / "resources" / "app-update.yml"
+    if config.exists():
+        config.unlink()
+        log("Switched off Questlog's own updater (its installer cannot run under Wine); "
+            "A2Qlinux updates Questlog instead.")
+
+
+# ------------------------------------------------------------------ staging
+
+def _open(url, timeout):
+    return urllib.request.urlopen(urllib.request.Request(url, headers={"User-Agent": USER_AGENT}), timeout=timeout)
+
+
+def _download(url, target, size, sha512_b64, timeout=60):
+    digest = hashlib.sha512()
+    got = 0
+    with _open(url, timeout) as response, open(target, "wb") as out:
+        while chunk := response.read(1 << 20):
+            out.write(chunk)
+            digest.update(chunk)
+            got += len(chunk)
+    if got != size:
+        raise ValueError(f"downloaded {got} bytes, latest.yml says {size}")
+    if base64.b64encode(digest.digest()).decode() != sha512_b64:
+        raise ValueError("the download's SHA-512 does not match latest.yml")
+
+
+def _unpack(installer, work):
+    """installer.exe (NSIS) -> work/app, Questlog's files; needs 7z."""
+    seven = shutil.which("7z")
+    if not seven:
+        raise RuntimeError("7z is missing; run a2qlinux-setup, which names the package to install")
+    nsis, app = work / "nsis", work / "app"
+    for folder in (nsis, app):
+        shutil.rmtree(folder, ignore_errors=True)
+        folder.mkdir(parents=True)
+    for archive, into in ((installer, nsis), (nsis / "$PLUGINSDIR" / "app-64.7z", app)):
+        done = subprocess.run([seven, "x", "-y", f"-o{into}", str(archive)], capture_output=True, text=True)
+        if done.returncode:
+            raise RuntimeError(f"7z could not unpack {archive.name}: {done.stderr.strip() or done.stdout[-300:]}")
+    shutil.rmtree(nsis)
+    if not (app / "Questlog.exe").is_file():
+        raise RuntimeError("the installer did not contain Questlog.exe where expected")
+    return app
+
+
+def read_state(state_dir):
+    try:
+        return json.loads((Path(state_dir) / "update" / STATE_FILE).read_text())
+    except (OSError, ValueError):
+        return {}
+
+
+def write_state(state_dir, state):
+    path = Path(state_dir) / "update" / STATE_FILE
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(state, indent=1))
+
+
+def stage(questlog_dir, state_dir, log, notify, feed_url=FEED, downloads=DOWNLOADS):
+    """Check for a newer Questlog and stage it for the next start. Returns the staged state.
+
+    Network or format errors are logged and end this attempt; the next check
+    tries again. A version already staged or already judged is not fetched again.
+    """
+    with BUSY:
+        return _stage(questlog_dir, state_dir, log, notify, feed_url, downloads)
+
+
+def read_feed(feed_url=FEED):
+    """The newest version as latest.yml describes it (parse_feed); raises OSError or ValueError."""
+    with _open(feed_url, 20) as response:
+        return parse_feed(response.read().decode("utf-8", "replace"))
+
+
+def _fetch(feed, work, downloads):
+    """Download the feed's installer into `work`, verify and unpack it; (app folder, compatibility problems).
+
+    The installer is deleted once unpacked, and Questlog's own updater
+    configuration is removed from the unpacked files (disable_builtin_updater).
+    Raises OSError, ValueError or RuntimeError when a step fails.
+    """
+    installer = work / feed["path"]
+    _download(downloads + feed["path"], installer, feed["size"], feed["sha512"])
+    app = _unpack(installer, work)
+    installer.unlink()
+    problems = compatibility_problems(app)
+    (app / "resources" / "app-update.yml").unlink(missing_ok=True)
+    return app, problems
+
+
+def _stage(questlog_dir, state_dir, log, notify, feed_url, downloads):
+    current = installed_version(questlog_dir)
+    try:
+        feed = read_feed(feed_url)
+    except (OSError, ValueError) as error:
+        log(f"Questlog update check failed ({error}); trying again later.")
+        return None
+    if current and version_key(feed["version"]) <= version_key(current):
+        return None
+    state = read_state(state_dir)
+    if state.get("version") == feed["version"]:
+        return state                                   # already staged or already refused
+    work = Path(state_dir) / "update" / feed["version"]
+    log(f"Questlog {feed['version']} is out (installed: {current or 'unknown'}); downloading it.")
+    try:
+        work.mkdir(parents=True, exist_ok=True)
+        app, problems = _fetch(feed, work, downloads)
+    except (OSError, ValueError, RuntimeError) as error:
+        shutil.rmtree(work, ignore_errors=True)
+        log(f"Questlog {feed['version']} could not be staged: {error}. Trying again later.")
+        return None
+    state = {"version": feed["version"], "app": str(app), "fits": not problems, "problems": problems}
+    # Older staged versions are superseded by this one.
+    for other in (Path(state_dir) / "update").iterdir():
+        if other.is_dir() and other != work:
+            shutil.rmtree(other, ignore_errors=True)
+    write_state(state_dir, state)
+    if problems:
+        shutil.rmtree(app, ignore_errors=True)
+        text = (f"Questlog {feed['version']} does not fit this A2Qlinux yet, so it was not installed; "
+                f"Questlog {current} stays. Why: " + "; ".join(problems) + ".")
+        log(text)
+        notify(text)
+    else:
+        log(f"Questlog {feed['version']} is downloaded and checked; it is installed the next time "
+            "Questlog starts.")
+        notify(f"Questlog {feed['version']} is ready. It is installed the next time Questlog starts.")
+    return state
+
+
+# ------------------------------------------------------------- installation
+
+def install_fresh(questlog_dir, log, feed_url=FEED, downloads=DOWNLOADS):
+    """Install the newest Questlog into a missing or empty folder; returns its version.
+
+    For a2qlinux-setup on a machine without Questlog: the same download,
+    checksum, unpacking and compatibility checks as an update (_fetch), then
+    the unpacked program is moved into place. The work folder is made next
+    to the target, so the move is a rename on one file system.
+
+    Raises RuntimeError with what went wrong and what to do; a folder that
+    holds anything is never written into, and nothing is left behind.
+    """
+    questlog_dir = Path(questlog_dir)
+    if questlog_dir.exists() and (not questlog_dir.is_dir() or any(questlog_dir.iterdir())):
+        raise RuntimeError(f"{questlog_dir} already exists and is not an empty folder, but holds no "
+                           "Questlog.exe; move it away, or pass another folder with --questlog-dir")
+    try:
+        feed = read_feed(feed_url)
+    except (OSError, ValueError) as error:
+        raise RuntimeError(f"Questlog's download information could not be read ({error}); "
+                           "check the internet connection and run a2qlinux-setup again") from error
+    version = feed["version"]
+    log(f"Downloading Questlog {version} from its authors' server ({feed['size'] / 1e6:.0f} MB), "
+        "checking and unpacking it …")
+    try:
+        questlog_dir.parent.mkdir(parents=True, exist_ok=True)
+        work = Path(tempfile.mkdtemp(prefix=".a2qlinux-questlog-", dir=questlog_dir.parent))
+    except OSError as error:
+        raise RuntimeError(f"no folder for Questlog can be made in {questlog_dir.parent}: {error}") from error
+    try:
+        try:
+            app, problems = _fetch(feed, work, downloads)
+        except (OSError, ValueError, RuntimeError) as error:
+            raise RuntimeError(f"Questlog {version} could not be installed: {error}") from error
+        if problems:
+            raise RuntimeError(f"Questlog {version} does not fit this A2Qlinux yet: " + "; ".join(problems)
+                               + ". Update A2Qlinux (pipx upgrade a2qlinux), or install an earlier "
+                               "Questlog by hand (docs/UPDATING.md, 'Installing Questlog by hand')")
+        try:
+            if questlog_dir.exists():
+                questlog_dir.rmdir()
+            app.rename(questlog_dir)
+        except OSError as error:
+            raise RuntimeError(f"Questlog {version} could not be put in {questlog_dir}: {error}") from error
+    finally:
+        shutil.rmtree(work, ignore_errors=True)
+    log(f"Installed Questlog {version} in {questlog_dir}.")
+    return version
+
+
+def install_staged(questlog_dir, state_dir, log):
+    """Swap in a staged version that fits. Returns (old version, backup folder) or None.
+
+    Must run while Questlog does not. The state folder (proton-stream) lives in
+    the Questlog folder, so it moves across with the swap; the launcher's lock
+    stays held, since it is an open file that moves with its folder. Skipped
+    (None) while a download is being staged; the next start installs it.
+    """
+    if not BUSY.acquire(blocking=False):
+        log("A Questlog update is still being downloaded; it is installed at a later start.")
+        return None
+    try:
+        return _install_staged(Path(questlog_dir).resolve(), Path(state_dir).resolve(), log)
+    finally:
+        BUSY.release()
+
+
+def _install_staged(questlog_dir, state_dir, log):
+    state = read_state(state_dir)
+    app = Path(state.get("app", "")).resolve()
+    if not state.get("fits") or not (app / "Questlog.exe").is_file():
+        return None
+    old = installed_version(questlog_dir) or "previous"
+    backup = questlog_dir.with_name(f"{questlog_dir.name}-{old}")
+    if backup.exists():
+        backup = questlog_dir.with_name(f"{questlog_dir.name}-{old}-a2q")
+    if backup.exists():
+        log(f"Questlog {state['version']} is staged, but {backup} is in the way; not installed.")
+        return None
+    staged_rel = app.relative_to(questlog_dir)          # app sits inside the folder being moved
+    questlog_dir.rename(backup)
+    (backup / staged_rel).rename(questlog_dir)
+    (backup / state_dir.name).rename(questlog_dir / state_dir.name)
+    shutil.rmtree(state_dir / "update", ignore_errors=True)
+    previous = read_backup_record(state_dir)
+    write_backup_record(state_dir, {"version": old, "path": str(backup), "installed": state["version"]})
+    # Keep one backup: the one this update made. Older backups made by A2Qlinux go.
+    if previous and Path(previous.get("path", "")).is_dir() and Path(previous["path"]) != backup:
+        shutil.rmtree(previous["path"], ignore_errors=True)
+        log(f"Removed the older backup {previous['path']}.")
+    log(f"Installed Questlog {state['version']}; Questlog {old} is kept in {backup}.")
+    return old, backup
+
+
+def read_backup_record(state_dir):
+    try:
+        return json.loads((Path(state_dir) / "questlog-backup.json").read_text())
+    except (OSError, ValueError):
+        return {}
+
+
+def write_backup_record(state_dir, record):
+    (Path(state_dir) / "questlog-backup.json").write_text(json.dumps(record, indent=1))
+
+
+def rollback(questlog_dir, state_dir, log):
+    """Put the backup made by the last install_staged back. Returns True if done."""
+    questlog_dir, state_dir = Path(questlog_dir), Path(state_dir)
+    record = read_backup_record(state_dir)
+    backup = Path(record.get("path", ""))
+    if not (backup / "Questlog.exe").is_file():
+        log("No Questlog backup to go back to.")
+        return False
+    failed = questlog_dir.with_name(f"{questlog_dir.name}-{record.get('installed', 'failed')}-failed")
+    shutil.rmtree(failed, ignore_errors=True)
+    questlog_dir.rename(failed)
+    backup.rename(questlog_dir)
+    (failed / state_dir.name).rename(questlog_dir / state_dir.name)
+    (state_dir / "questlog-backup.json").unlink(missing_ok=True)
+    write_state(state_dir, {"version": record.get("installed"), "fits": False,
+                            "problems": ["it did not start under Proton after installing"]})
+    log(f"Went back to Questlog {record.get('version')}; the version that failed is in {failed}.")
+    return True