dao-modman 0.1.0__py3-none-any.whl

dao_modman/__main__.py

@@ -0,0 +1,252 @@
+"""Command line entry point: the TUI by default, plus `nxm://` link handling."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from .core import console, deploy, ipc, laa, nexus, paths, report, revisions, terminal
+from .core.config import TOKEN_VAR, Config, load_config, load_token
+from .core.library import Library
+from .core.nexus import NexusError
+
+DESKTOP_FILE = "dao-modman-nxm.desktop"
+DESKTOP_ENTRY = """[Desktop Entry]
+Type=Application
+Name=dao-modman (nxm links)
+Exec="{python}" -m dao_modman nxm %u
+Terminal=false
+NoDisplay=true
+MimeType=x-scheme-handler/nxm;
+"""
+
+
+def _report(message: str) -> None:
+    """The handler has no terminal of its own, so errors also go to the desktop."""
+    print(f"error: {message}", file=sys.stderr)
+    if shutil.which("notify-send"):
+        subprocess.run(["notify-send", "--app-name=dao-modman", "dao-modman", message], check=False)
+
+
+def _forward(config: Config, url: str) -> bool:
+    """Hand the link to the running instance, if there is one."""
+    if config.runtime_dir is None or not ipc.is_running(config.runtime_dir):
+        return False
+    ipc.send_link(config.runtime_dir, url)
+    return True
+
+
+def cmd_nxm(url: str) -> int:
+    """Pass a link to the running instance, or start one in a new terminal window."""
+    config = load_config()
+    try:
+        nexus.parse_nxm(url)
+        if not _forward(config, url):
+            argv = [sys.executable, "-m", "dao_modman", "--nxm", url]
+            subprocess.Popen(
+                terminal.command(config.terminal, argv),
+                start_new_session=True,
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+    except (NexusError, ipc.IpcError, terminal.TerminalError, OSError) as exc:
+        _report(str(exc))
+        return 1
+    return 0
+
+
+def cmd_install_nxm_handler() -> int:
+    applications = Path.home() / ".local/share/applications"
+    applications.mkdir(parents=True, exist_ok=True)
+    desktop = applications / DESKTOP_FILE
+    desktop.write_text(DESKTOP_ENTRY.format(python=sys.executable), encoding="utf-8")
+    print(f"wrote {desktop}")
+    if not shutil.which("xdg-mime"):
+        print("xdg-mime not found: register the nxm:// handler manually", file=sys.stderr)
+        return 1
+    # On KDE, xdg-mime calls qtpaths, which some distros keep outside PATH.
+    env = {**os.environ, "PATH": f"{os.environ.get('PATH', '')}:/usr/lib/qt6/bin"}
+    command = ["xdg-mime", "default", DESKTOP_FILE, "x-scheme-handler/nxm"]
+    subprocess.run(command, check=True, env=env)
+    print("registered as handler for nxm:// links")
+    # The browser starts the handler outside the project dir, where ./.env is not found.
+    config_dir = paths.config_dir()
+    if not os.environ.get(TOKEN_VAR) and not load_token(config_dir, cwd=config_dir):
+        print(
+            f"note: the handler will not find your API token: put {TOKEN_VAR}=... "
+            f"into {config_dir / '.env'}"
+        )
+    return 0
+
+
+def _library(config: Config) -> Library:
+    return Library(config.dirs, config.ignore)
+
+
+def cmd_laa(action: str, exe: Path | None) -> int:
+    install_dir = load_config().game_install_dir
+    if not install_dir:
+        print(
+            "error: game install dir not found: set game_install_dir in config.toml",
+            file=sys.stderr,
+        )
+        return 1
+    try:
+        if action == "patch":
+            if exe is None:
+                print(
+                    "error: pass the LAA-patched executable with --exe PATH; how to get one:\n"
+                    f"  {laa.GUIDE_URL}",
+                    file=sys.stderr,
+                )
+                return 1
+            backup = laa.patch(install_dir, exe)
+            print(f"patched {laa.game_exe(install_dir)}\noriginal saved as {backup}")
+        elif action == "restore":
+            print(f"restored {laa.restore(install_dir)}")
+        else:
+            print(f"{laa.game_exe(install_dir)}: {laa.status(install_dir)}")
+    except laa.LaaError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    return 0
+
+
+def cmd_console(action: str) -> int:
+    config = load_config()
+    if not config.game_install_dir:
+        print(
+            "error: game install dir not found: set game_install_dir in config.toml",
+            file=sys.stderr,
+        )
+        return 1
+    try:
+        if action == "enable":
+            console.enable(config.game_install_dir)
+            key = console.ensure_key(config.game_user_dir) if config.game_user_dir else None
+            print(f"console enabled, open it with: {console.key_label(key)}")
+            if not console.fonts_installed(config.game_user_dir, _library(config)):
+                print(f"console text is invisible without fonts.erf: {console.FONTS_MOD_URL}")
+        elif action == "disable":
+            console.disable(config.game_install_dir)
+            print("console disabled")
+        else:
+            state = "enabled" if console.is_enabled(config.game_install_dir) else "disabled"
+            print(f"console: {state}")
+    except console.ConsoleError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    return 0
+
+
+def cmd_conflicts(action: str | None, names: list[str], accept_all: bool) -> int:
+    library = _library(load_config())
+    plan = deploy.build_plan(library)
+    if action is None:
+        print(report.format_conflicts(library, plan) or "no conflicts")
+        return 1 if plan.with_status(deploy.ERROR) else 0
+
+    if bool(names) == accept_all:
+        print("error: give file names or mod ids to accept, or --all (not both)", file=sys.stderr)
+        return 2
+    selected, unmatched = report.select_conflicts(plan, names)
+    if unmatched:
+        print(f"error: no open conflict matches {', '.join(unmatched)}", file=sys.stderr)
+        return 1
+    for conflict in selected:
+        *losers, winner = conflict.mod_ids
+        library.accept_overwrite(winner, losers, conflict.name)
+        print(f"accepted {conflict.name}: {winner} overwrites {', '.join(losers)}")
+    if not selected:
+        print("no open conflicts")
+    for conflict in plan.with_status(deploy.ERROR):
+        print(f"not accepted: {report.file_line(library, conflict)}")
+    return 0
+
+
+def cmd_chargen() -> int:
+    config = load_config()
+    result, text = report.chargen_report(config.game_install_dir, _library(config))
+    print(text)
+    return 1 if result and result.dangling else 0
+
+
+def cmd_revisions() -> int:
+    data_dir = load_config().dirs.data
+    if not revisions.init(data_dir):
+        print("error: could not create a git repository (is git installed?)", file=sys.stderr)
+        return 1
+    print(f"tracking the library's metadata in {data_dir}")
+    print("every change is now committed there; look at it with:")
+    print(f"  git -C '{data_dir}' log --stat")
+    print(f"to stop, delete {data_dir / '.git'}")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="dao-modman", description=__doc__)
+    commands = parser.add_subparsers(dest="command")
+    parser.add_argument("--nxm", metavar="URL", help="start the TUI and download this link")
+    nxm = commands.add_parser("nxm", help="hand a 'Mod Manager Download' link to the TUI")
+    nxm.add_argument("url")
+    commands.add_parser("install-nxm-handler", help="register dao-modman for nxm:// links")
+    laa_cmd = commands.add_parser("laa", help="Large Address Aware patch for the game exe")
+    laa_cmd.add_argument("action", choices=["status", "patch", "restore"])
+    laa_cmd.add_argument("--exe", type=Path, help="LAA-patched executable to install (for patch)")
+    console_cmd = commands.add_parser("console", help="enable the game's developer console")
+    console_cmd.add_argument("action", choices=["status", "enable", "disable"])
+    conflicts = commands.add_parser(
+        "conflicts", help="report files that several mods ship, or accept them as intended"
+    )
+    conflicts.add_argument("action", nargs="?", choices=["accept"])
+    conflicts.add_argument(
+        "names", nargs="*", help="with accept: file names or mod ids of the conflicts to accept"
+    )
+    conflicts.add_argument("--all", action="store_true", help="with accept: every open conflict")
+    revisions_cmd = commands.add_parser(
+        "revisions", help="keep a history of the library's metadata in git (debugging aid)"
+    )
+    revisions_cmd.add_argument("action", choices=["init"])
+    commands.add_parser(
+        "chargen", help="report on the merged character creator list and its broken entries"
+    )
+    args = parser.parse_args(argv)
+
+    if args.command == "nxm":
+        return cmd_nxm(args.url)
+    if args.command == "chargen":
+        return cmd_chargen()
+    if args.command == "revisions":
+        return cmd_revisions()
+    if args.command == "conflicts":
+        return cmd_conflicts(args.action, args.names, args.all)
+    if args.command == "console":
+        return cmd_console(args.action)
+    if args.command == "laa":
+        return cmd_laa(args.action, args.exe)
+    if args.command == "install-nxm-handler":
+        return cmd_install_nxm_handler()
+
+    config = load_config()
+    if args.nxm:
+        # Lost the race against another instance that is starting: let that one handle it.
+        try:
+            if _forward(config, args.nxm):
+                return 0
+        except ipc.IpcError as exc:
+            _report(str(exc))
+            return 1
+
+    from .tui.app import ModManApp
+
+    ModManApp(config, links=[args.nxm] if args.nxm else []).run()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

dao_modman/assets/presets.toml

@@ -0,0 +1,28 @@
+# Predefined path operations for mods that only work when installed at a specific place.
+#
+# An entry is identified by the Nexus mod id and file id. Operations have the same form as
+# in a mod's mod.toml; {mod} stands for the mod's own override folder
+# (packages/core/override/<mod-id>), which differs from one library to the next.
+#
+# The same file in ~/.config/dao-modman/ adds entries, and wins over an entry here for the
+# same mod and file.
+
+[[preset]]
+mod_id = 1825
+file_id = 9280
+description = "The bundled exe has hardcoded paths. For the mod to work, the exe needs to be placed in override/siramods_items"
+
+[[preset.ops]]
+op = "rename"
+from = "{mod}/ADD_ITEM_DELUXE_1_1/siramods_items"
+to = "packages/core/override/siramods_items"
+
+[[preset]]
+mod_id = 1110
+file_id = 5571
+description = "The game only reads fonts.erf from packages/core/data, not from the override folder"
+
+[[preset.ops]]
+op = "rename"
+from = "{mod}/fonts.erf"
+to = "packages/core/data/fonts.erf"

dao_modman/core/addins.py

@@ -0,0 +1,120 @@
+"""Register / unregister dazip AddIns in the game's `Settings/AddIns.xml`."""
+
+from __future__ import annotations
+
+import copy
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+from .dazip import AddIn, addin_from_element
+from .metadata import write_atomic
+from .paths import resolve_case
+
+ADDINS_REL = "Settings/AddIns.xml"
+SHIPPED_REL = "Addins"  # in the game's install dir
+
+MANAGED = "managed"  # registered by one of our mods
+OFFICIAL = "official"  # the game's own DLC
+EXTERNAL = "external"  # installed by hand or by another tool
+
+
+class AddInsError(Exception):
+    pass
+
+
+def list_registered(user_dir: Path) -> list[AddIn]:
+    """Everything registered in the game's `Settings/addins.xml`."""
+    addins_xml = resolve_case(user_dir, ADDINS_REL)
+    if not addins_xml.is_file():
+        return []
+    try:
+        root = _load(addins_xml)
+    except (ET.ParseError, OSError, ValueError) as exc:
+        raise AddInsError(f"cannot read {addins_xml}: {exc}") from exc
+    return [addin for item in root.findall("AddInItem") if (addin := addin_from_element(item))]
+
+
+def shipped_uids(install_dir: Path | None) -> set[str]:
+    """Case-folded UIDs of the AddIns that ship in the game's install dir."""
+    if install_dir is None:
+        return set()
+    shipped = resolve_case(install_dir, SHIPPED_REL)
+    if not shipped.is_dir():
+        return set()
+    return {entry.name.casefold() for entry in shipped.iterdir() if entry.is_dir()}
+
+
+def classify(addin: AddIn, managed: set[str], shipped: set[str]) -> str:
+    """Tell our mods, official DLC and foreign AddIns apart.
+
+    Being shipped in the install dir is the reliable sign of official content. The
+    `BioWare="1"` attribute is only self-declared, but it is all there is for DLC that was
+    downloaded into the user dir (non-Ultimate editions). Our own mods are ruled out first,
+    so a mod claiming to be BioWare content is not mistaken for DLC.
+    """
+    if addin.uid.casefold() in {uid.casefold() for uid in managed}:
+        return MANAGED
+    if addin.uid.casefold() in shipped or addin.bioware:
+        return OFFICIAL
+    return EXTERNAL
+
+
+def _load(path: Path) -> ET.Element:
+    if path.is_file():
+        root = ET.parse(path).getroot()
+        if root.tag != "AddInsList":
+            raise ValueError(f"{path}: unexpected root element <{root.tag}>")
+        return root
+    return ET.Element("AddInsList")
+
+
+def _save(path: Path, root: ET.Element) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    ET.indent(root)
+    write_atomic(path, ET.tostring(root, encoding="utf-8", xml_declaration=True))
+
+
+def absent(addins_xml: Path, addins: list[AddIn]) -> list[str]:
+    """UIDs of `addins` that `register` would add, i.e. that are not registered yet."""
+    present = {(item.get("UID") or "").casefold() for item in _load(addins_xml).iter("AddInItem")}
+    missing: list[str] = []
+    for addin in addins:
+        if addin.uid.casefold() not in present:
+            present.add(addin.uid.casefold())
+            missing.append(addin.uid)
+    return missing
+
+
+def register(addins_xml: Path, addins: list[AddIn]) -> list[str]:
+    """Add missing AddIns; returns the UIDs that were actually added."""
+    if not addins:
+        return []
+    root = _load(addins_xml)
+    # The game treats UIDs case-insensitively: "MyAddIn" and "myaddin" are the same AddIn.
+    present = {(item.get("UID") or "").casefold() for item in root.iter("AddInItem")}
+    added = []
+    for addin in addins:
+        if addin.uid.casefold() in present:
+            continue
+        root.append(copy.deepcopy(addin.element))
+        present.add(addin.uid.casefold())
+        added.append(addin.uid)
+    if added:
+        _save(addins_xml, root)
+    return added
+
+
+def unregister(addins_xml: Path, uids: list[str]) -> list[str]:
+    """Remove AddIns by UID; returns the UIDs that were removed."""
+    if not uids or not addins_xml.is_file():
+        return []
+    root = _load(addins_xml)
+    removed = []
+    wanted = {uid.casefold() for uid in uids}
+    for item in list(root.findall("AddInItem")):
+        if (item.get("UID") or "").casefold() in wanted:
+            root.remove(item)
+            removed.append(item.get("UID"))
+    if removed:
+        _save(addins_xml, root)
+    return removed

dao_modman/core/archive.py

@@ -0,0 +1,129 @@
+"""Hashing and safe extraction of mod archives (zip/dazip/override, 7z, rar)."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import shutil
+import subprocess
+import zipfile
+from pathlib import Path
+
+import py7zr
+
+from .paths import normalize_rel
+
+_CHUNK = 1024 * 1024
+_SEVENZIP_MAGIC = b"7z\xbc\xaf\x27\x1c"
+_RAR_MAGIC = b"Rar!\x1a\x07"
+
+
+class ArchiveError(Exception):
+    pass
+
+
+def file_hashes(path: Path) -> tuple[str, str]:
+    """Return (sha256, md5) of a file."""
+    sha256, md5 = hashlib.sha256(), hashlib.md5(usedforsecurity=False)
+    with path.open("rb") as fh:
+        while chunk := fh.read(_CHUNK):
+            sha256.update(chunk)
+            md5.update(chunk)
+    return sha256.hexdigest(), md5.hexdigest()
+
+
+def sha256_file(path: Path) -> str:
+    return file_hashes(path)[0]
+
+
+def _safe_name(name: str) -> str:
+    try:
+        if name.startswith(("/", "\\")):
+            raise ValueError("absolute path")
+        return normalize_rel(name)
+    except ValueError as exc:
+        raise ArchiveError(f"unsafe path in archive: {name!r}") from exc
+
+
+def _extract_zip(archive: Path, dest: Path) -> None:
+    with zipfile.ZipFile(archive) as zf:
+        for info in zf.infolist():
+            if info.is_dir():
+                continue
+            target = dest / _safe_name(info.filename)
+            target.parent.mkdir(parents=True, exist_ok=True)
+            with zf.open(info) as src, target.open("wb") as out:
+                shutil.copyfileobj(src, out, _CHUNK)
+
+
+def _extract_7z(archive: Path, dest: Path) -> None:
+    with py7zr.SevenZipFile(archive) as sz:
+        for name in sz.getnames():
+            _safe_name(name)
+        sz.extractall(dest)
+
+
+def _extract_rar(archive: Path, dest: Path) -> None:
+    """Extract with whichever tool manages: no pure-Python rar reader exists.
+
+    unrar and 7z come first because bsdtar cannot read solid archives, which are common.
+    All three refuse to write outside the target directory by default.
+    """
+    commands = {
+        "unrar": ["unrar", "x", "-y", "-o+", str(archive), f"{dest}{os.sep}"],
+        "7z": ["7z", "x", "-y", f"-o{dest}", str(archive)],
+        "bsdtar": ["bsdtar", "-xf", str(archive), "-C", str(dest)],
+    }
+    failures = []
+    for tool, command in commands.items():
+        if not shutil.which(tool):
+            continue
+        result = subprocess.run(command, capture_output=True, text=True, stdin=subprocess.DEVNULL)
+        if result.returncode == 0:
+            return
+        detail = (result.stderr or result.stdout).strip().splitlines()
+        failures.append(f"{tool}: {detail[-1] if detail else 'failed'}")
+        shutil.rmtree(dest)  # whatever the failed tool left behind must not be imported
+        dest.mkdir()
+    if not failures:
+        raise ArchiveError("rar archives need one of unrar, 7z or bsdtar on PATH")
+    raise ArchiveError(f"cannot extract {archive.name} ({'; '.join(failures)})")
+
+
+def _drop_links(dest: Path) -> None:
+    """Archives may carry symlinks; they must never be followed when deploying."""
+    for root, dirnames, filenames in os.walk(dest):
+        for name in dirnames + filenames:
+            path = Path(root, name)
+            if path.is_symlink():
+                path.unlink()
+
+
+def extract(archive: Path, dest: Path) -> None:
+    """Extract `archive` into the (new or empty) directory `dest`."""
+    dest.mkdir(parents=True, exist_ok=True)
+    with archive.open("rb") as fh:
+        magic = fh.read(8)
+    try:
+        if magic.startswith(_SEVENZIP_MAGIC):
+            _extract_7z(archive, dest)
+        elif magic.startswith(_RAR_MAGIC):
+            _extract_rar(archive, dest)
+        elif zipfile.is_zipfile(archive):
+            _extract_zip(archive, dest)
+        else:
+            raise ArchiveError(f"unsupported archive format: {archive.name}")
+    except (zipfile.BadZipFile, py7zr.exceptions.ArchiveError, OSError) as exc:
+        raise ArchiveError(f"cannot extract {archive.name}: {exc}") from exc
+    _drop_links(dest)
+
+
+def list_files(root: Path) -> list[str]:
+    """Relative posix paths of all regular files below `root`, sorted."""
+    files = []
+    for dirpath, _dirnames, filenames in os.walk(root):
+        for name in filenames:
+            path = Path(dirpath, name)
+            if path.is_file() and not path.is_symlink():
+                files.append(path.relative_to(root).as_posix())
+    return sorted(files)