Add launcher and direct application distribution

Author: gajop

.github/workflows/launcher-release.yml

@@ -15,6 +15,13 @@ env/
 
 # Rust build artifacts
 native/target/
+launcher/target/
+launcher/.dev-runtime/
+
+# Tauri frontend build artifacts
+launcher/tauri/node_modules/
+launcher/tauri/dist/
+launcher/tauri/src-tauri/gen/
 
 # Local E2E run output
 artifacts/

.gitignore

@@ -68,6 +68,19 @@ uv run --project ./build --locked ruff check ./build/sbc_packager
 uv run --project ./build --locked pyright ./build/sbc_packager
 ```
 
+## Standalone launcher bundle
+
+`sbc-packager-standalone` assembles already-built CLI and Tauri launcher
+binaries, a native plugin, a local engine install, and the packaged SBC game
+into one portable directory and a matching ZIP archive. The `just
+bundle-launcher-linux` recipe is the local development entrypoint. Production
+AppImage, NSIS, and CLI release packaging is described in
+[`launcher/docs/distribution.md`](../launcher/docs/distribution.md).
+
+The standalone launch configuration retains the generated-map values from
+`dist_cfg/config.json`; Spring creates `sb_initial_blank_10x8` at launch, so a
+map archive is neither bundled nor downloaded.
+
 ## Linux AppImage sandbox note
 
 `make-package-json` injects `afterPack: build/sbc_after_pack.cjs`.

build/README.md

@@ -9,8 +9,15 @@ dependencies = ["pydantic>=2.12.5", "typer>=0.23.1"]
 sbc-packager = "sbc_packager.cli:main"
 sbc-packager-prepare = "sbc_packager.cli_prepare:main"
 sbc-packager-download-engine = "sbc_packager.cli_download_engine:main"
+sbc-packager-editor = "sbc_packager.cli_editor:main"
+sbc-packager-release-config = "sbc_packager.cli_release_config:main"
+sbc-packager-cli-download = "sbc_packager.cli_download:main"
+sbc-packager-tauri-config = "sbc_packager.cli_tauri_config:main"
+sbc-packager-release-manifests = "sbc_packager.cli_release_manifests:main"
 sbc-packager-make-package-json = "sbc_packager.cli_make_package_json:main"
 sbc-packager-package = "sbc_packager.cli_package:main"
+sbc-packager-standalone = "sbc_packager.cli_standalone:main"
+sbc-packager-application = "sbc_packager.cli_application:main"
 
 [build-system]
 requires = ["hatchling"]

build/pyproject.toml

@@ -1,2 +1 @@
 """Packaging CLI for SpringBoard Core."""
-

build/sbc_packager/__init__.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+
+def create_application_archive(application_dir: Path, platform: str) -> Path:
+    archive_format = "gztar" if platform == "linux" else "zip"
+    suffix = ".tar.gz" if platform == "linux" else ".zip"
+    expected = application_dir.with_name(application_dir.name + suffix)
+    if expected.exists():
+        raise RuntimeError(f"Refusing to overwrite existing application archive: {expected}")
+    return Path(
+        shutil.make_archive(
+            str(application_dir),
+            archive_format,
+            root_dir=application_dir.parent,
+            base_dir=application_dir.name,
+        )
+    )

build/sbc_packager/application_archive.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+PRUNED_ENGINE_DIRECTORIES = ("AI",)
+PRUNED_ENGINE_EXECUTABLES = ("pr-downloader", "spring-dedicated", "spring-headless")
+
+
+def install_engine(*, destination: Path, engine_dir: Path | None, engine_archive: Path | None) -> None:
+    if (engine_dir is None) == (engine_archive is None):
+        raise RuntimeError("Specify exactly one of --engine-dir or --engine-archive")
+
+    if engine_dir is not None:
+        shutil.copytree(engine_dir.resolve(), destination, symlinks=True)
+        return
+
+    if engine_archive is None:
+        raise RuntimeError("Engine archive was not provided")
+    seven_zip = shutil.which("7z")
+    if seven_zip is None:
+        raise RuntimeError("7z is required to extract the engine archive")
+    destination.mkdir(parents=True)
+    subprocess.run(
+        [seven_zip, "x", "-y", f"-o{destination}", str(engine_archive.resolve())],
+        check=True,
+    )
+
+
+def prune_engine(application_dir: Path, platform: str) -> None:
+    executable_suffix = "" if platform == "linux" else ".exe"
+    for executable in PRUNED_ENGINE_EXECUTABLES:
+        (application_dir / f"{executable}{executable_suffix}").unlink(missing_ok=True)
+
+    for directory in PRUNED_ENGINE_DIRECTORIES:
+        path = application_dir / directory
+        if path.is_symlink() or path.is_file():
+            path.unlink()
+        elif path.is_dir():
+            shutil.rmtree(path)
+
+
+def rename_engine(application_dir: Path, platform: str) -> Path:
+    source_name = "spring" if platform == "linux" else "spring.exe"
+    destination_name = "SpringBoard" if platform == "linux" else "SpringBoard.exe"
+    source = application_dir / source_name
+    destination = application_dir / destination_name
+    if not source.is_file():
+        raise RuntimeError(f"Engine executable is missing: {source}")
+    if destination.exists():
+        raise RuntimeError(f"Application executable already exists: {destination}")
+    source.rename(destination)
+    if platform == "linux" and not destination.stat().st_mode & 0o111:
+        raise RuntimeError(f"Engine executable lost its executable mode: {destination}")
+    return destination

build/sbc_packager/application_engine.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import gzip
+import hashlib
+from pathlib import Path
+
+
+def write_file_manifest(application_dir: Path) -> Path:
+    manifest_path = application_dir / "files.md5.gz"
+    entries = []
+    for path in sorted(application_dir.rglob("*")):
+        if path == manifest_path or path.is_symlink() or not path.is_file() or path.suffix == ".dbg":
+            continue
+        relative = path.relative_to(application_dir).as_posix()
+        entries.append(f"{file_md5(path)}  ./{relative}\n")
+
+    with (
+        manifest_path.open("wb") as output,
+        gzip.GzipFile(filename="", mode="wb", fileobj=output, mtime=0) as compressed,
+    ):
+        compressed.write("".join(entries).encode())
+    return manifest_path
+
+
+def file_md5(path: Path) -> str:
+    digest = hashlib.md5(usedforsecurity=False)
+    with path.open("rb") as source:
+        for chunk in iter(lambda: source.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()

build/sbc_packager/application_manifest.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+from urllib.parse import quote
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as artifact:
+        for block in iter(lambda: artifact.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def write_sha256(path: Path) -> Path:
+    checksum = path.with_suffix(path.suffix + ".sha256")
+    checksum.write_text(f"{sha256(path)}  {path.name}\n", encoding="utf-8")
+    return checksum
+
+
+def github_release_url(repository: str, tag: str, asset: str) -> str:
+    repository_path = "/".join(quote(part, safe="") for part in repository.split("/"))
+    return (
+        f"https://github.com/{repository_path}/releases/download/"
+        f"{quote(tag, safe='')}/{quote(asset, safe='')}"
+    )

build/sbc_packager/artifacts.py

@@ -6,10 +6,12 @@
 from .cli_make_package_json import make_package_json_command
 from .cli_package import package_command
 from .cli_prepare import prepare_command
+from .cli_standalone import standalone_command
 
 app = typer.Typer(add_completion=False, no_args_is_help=True)
 
 app.command("prepare")(prepare_command)
+app.command("standalone")(standalone_command)
 app.command("download-engine")(download_engine_command)
 app.command("make-package-json")(make_package_json_command)
 app.command("package")(package_command)