Game Server Manager

Game Server Manager is a Tauri desktop application for installing and operating private game servers. The React interface is action-oriented: it displays available operations, status, progress, and results without exposing the shell commands used by the privileged Rust runner.

Game Server Manager is Linux-only. Native Windows and WSL2 are not supported build or runtime targets.

Supported server modules:

• Aura Kingdom: preserved V7/V15 legacy profiles, native operator actions, and a hash-pinned Windows AK-Tools v1.0 workflow
  • X-Legend legacy collection: Astral Realm/Astral Tale (assembled v1249 and exact TW 012.1.01.49_8 profiles), Grand Fantasia (paired 0.74/0.751/0.761 server and client archives plus the earlier incomplete artifact), Dream Journey Mobile, Dragon Slayer, Fantasy Frontier/Aura Kingdom V15, Fantasy Frontier 2, If Only: Once Again, Seventh Dark, and the decoded LaPlace 2024 AutoInstaller release; the complete Grand Fantasia ZoneServer command reference is preserved with its upstream history
• FFXI: LandSandBoat
• FFXIV: Meteor
• FFXIV: Sapphire
• WoW: TrinityCore 3.3.5
• WoW: TrinityCore master

Architecture

The workspace is split into a small Tauri boundary and reusable Rust crates:

gui/
  crates/gsm-core/                 manifests, typed operations, runner
  crates/gsm-helper/               privileged helper operations
  crates/gsm-mod-*/                game-specific manifests and actions
  crates/gsm-twin-saga-oracle/     loopback preservation protocol service
  tauri/src/                       React application
  tauri/src-tauri/                 Tauri commands, services, and stores

See docs/architecture.md for the dependency rules used by the frontend, Tauri boundary, persistence layer, and game modules.

The WebView receives narrow presentation DTOs. Programs, arguments, environment variables, and stored secret values stay in Rust. Operations requiring elevation use the platform runner (pkexec/sudo on Linux) rather than rendering executable commands in the interface.

RustClient integration for FFXIV

Applying the Sapphire configuration writes build/bin/web/.well-known/mmo-preservation.json, which Sapphire serves beside /login.html. Publishing Meteor's web files writes the same discovery contract below its configured web root. The document contains the selected server's public lobby host/port, complete login page and API URLs, and optional patch-mirror base URL.

RustClient can therefore connect using only the server host or profile URL. Typical discovery URLs are:

http://SAPPHIRE_ADDRESS/.well-known/mmo-preservation.json
http://METEOR_ADDRESS:8080/.well-known/mmo-preservation.json

RustClient downloads and verifies the retail patch chains locally, builds the managed client, and publishes both %LOCALAPPDATA%\SapphireLauncher\server-assets.json and a portable copy in the managed library root. For a selected Sapphire or Meteor instance, run the manifest-declared client asset synchronization from Controller. On a shared controller filesystem, leave Source SqPack path or staticactors.bin source path blank for automatic detection. If RustClient runs on a separate Windows machine, expose its managed library to the Linux manager through a mounted share and set the source field to the portable server-assets.json or its containing library folder. Relative paths in the handoff keep this cross-machine mapping valid. The manager uploads only the server-required derived asset through its existing host-key-pinned, resumable SSH path:

• Sapphire: the prepared game/sqpack snapshot and ffxivgame.ver;
• Meteor: staticactors.bin or the preserved rq9q1797qvs.san equivalent.

Patch archives remain in RustClient's verified shared cache; they are not copied to the game server unless an operator intentionally builds a separate HTTP mirror and advertises its base URL.

RustClient integration for Twin Saga preservation

gsm-twin-saga-oracle provides the fail-closed protocol boundary used while the official client is being recovered. It binds only to loopback, inventories a selected patch directory without following symlinks, and publishes absolute discovery/login URLs plus SHA-256-and-size-pinned patch, world, and zone contracts. RustClient streams and verifies every advertised patch before accepting the transcript.

The service and client oracle never execute the preserved game client or server binaries and never contact historical endpoints. See gui/crates/gsm-twin-saga-oracle/README.md for the local smoke-test commands.

Packaged X-Legend preservation repositories

The legacy source drops are normalized into one repository per game family. main contains the preservation index and safe installer; immutable payloads live on release/<version> branches through Git LFS. The installer verifies SHA-256, rejects unsafe archive paths, stages extraction atomically, and never executes bundled root installers or game binaries.

Repository	Release branches
server-aura-kingdom	v15-xlegend, eternal-hxsy
server-twin-saga	v1249, tw-012.1.01.49_8
server-grand-fantasia	v0.74, v0.751, v0.761, v761-incomplete
server-dream-journey-mobile	v959
server-dragon-slayer	1512021530
server-fantasy-frontier-2	v32005
server-if-only-once-again	unknown
server-seventh-dark	v45110, laplace-2024-09
client-aura-kingdom	eternal-v15-private, luna-private, official-de-2023-08-31
client-twin-saga	astral-realm-reborn, eternal-private, official-tw-2018-05-25 (legacy alias: installer-fragments-2018)
client-grand-fantasia	v0.74, v0.751, v0.761

Website and engine material are separated into web-aura-kingdom, xlegend-engine-tools, and xlegend-pkg-tools. Binary-only tools carry a decompilation queue marker. The canonical SHA-256 catalog and reproducible importer are maintained in preservation-packager.

Prerequisites

• A Linux desktop with WebKitGTK 4.1 and the other system libraries required by Tauri 2 on Linux
• Rust stable
• Node.js 22 or newer

Development

Install frontend dependencies once:

cd gui/tauri
npm ci

Run the desktop application:

cd gui/tauri
npm run tauri dev

Run the web frontend by itself:

cd gui/tauri
npm run dev

The browser-only development view cannot execute Tauri operations, but it is useful for layout and component work.

Verification

cd gui/tauri
npm run check

cd ../
cargo fmt --all --check
cargo clippy --workspace --all-targets -- -D warnings
cargo test --workspace

Browser smoke tests are available with npm run test:e2e after installing a Playwright browser using npx playwright install chromium.

Release build

Release builds target Linux only. The Tauri configuration permits Debian packages and AppImages when bundling is enabled.

cd gui
target_triple="$(rustc -vV | sed -n 's/^host: //p')"
cargo build -p gsm-helper --release --locked
install -Dm755 target/release/gsm-helper "tauri/src-tauri/binaries/gsm-helper-${target_triple}"

cd tauri
npm run tauri build

The Tauri CLI builds the frontend once before Cargo runs; Cargo's build script never installs packages, accesses the network, or rebuilds frontend assets. Tauri writes Linux bundles beneath gui/target/release/bundle. Tagged releases also publish checksums and signed GitHub build-provenance attestations.

Security model

• The production WebView does not enable a remote-debugging port.
• A restrictive content security policy limits executable frontend sources.
• Action-list endpoints return metadata rather than executable task payloads.
• Secret settings are write-only from the frontend: reads report whether a value is configured, not its stored value.
• Persistent JSON stores use atomic replacement so interrupted writes do not leave partial configuration files.

Treat changes to Tauri capabilities, IPC DTOs, privileged operations, or content security policy as security-sensitive changes and cover them with tests.