Namespace McServerLauncher.Services

Classes

Advice: One suggestion.

AdviceInputs: What the advice depends on.

AgentStatus: What the agent says about the JVM it runs in. Read from status.json.

AnsiEscapes: Removes the colour codes some servers write into their console output.

AppHttp: The one place an HttpClient of this app is made.

AppLinks: The places this app points people at, in one list.

AppPaths: Where the app keeps what it writes about itself: settings, logs, caches, the Java runtimes it downloads, the Playit agent. One place, so a change to where that is (a portable mode, a test folder) is a change to one line instead of to nineteen.

AppSettingsService: Loads and saves the global settings in %APPDATA%\McServerLauncher\settings.json.

AppUpdateCoordinator: Gets an update's package onto disk and proves it is the one the publisher made, in the order that makes a refusal cheap: everything that can say "no" is asked for before the download.

AppUpdateCoordinator.VerifiedPackage: A package that passed both checks: where it is, and the SHA-256 it was verified as.

AppWindows: The windows the app has, for whatever needs one to own a dialog or reach the clipboard.

AtomicDownload

Downloads a file so that a failure can never damage what was already on disk.

Writing straight to the destination truncates it the moment the stream opens, long before the download is known to be good. A connection dropped halfway then leaves a valid path holding a half a file — and for the Fabric server jar it was worse than that: the structural check that runs afterwards deletes what it rejects, so an interrupted loader change turned a working server into one with no jar to start at all.

So the bytes go to "<dest>.part", verification runs against that, and only a file that arrived complete and passed its check replaces the real one — in a single filesystem move. This is the same guarantee AtomicJsonFile gives the app's JSON, applied to binaries.

AtomicJsonFile: Atomic load/save for the app's JSON files (servers.json, settings.json), so a crash or power loss mid-write can never truncate them. Writes go to a ".tmp" file that atomically replaces the target, keeping the previous version as ".bak". A corrupt file is quarantined as ".bad" and the ".bak" copy is restored when possible, instead of silently starting from scratch.

AtomicTextFile: Writing a config file the app owns: only when it actually changed, and never half-written.

BackupSchedule: Decides when a running server is due for an automatic backup.

BrowserLauncher

Opens a link in the user's browser.

Everywhere else in the app the URL is a constant we wrote. In the store it comes from Modrinth — an author fills in "source", "wiki" or "discord", and the long description is full of links — so it is untrusted input. UseShellExecute hands whatever it is given to the shell, which would happily run a local executable or a registered custom scheme, so only absolute http/https URLs are ever passed through.

BukkitPathRule: The two characters a Paper or Purpur server refuses to run from.

ByteSize: A size on disk as a person reads it: "812 KB", "3.4 MB", "1.2 GB".

Changelog: Per-version "what's new" notes. When the user updates across several versions at once, the notes for every version they hadn't seen yet are shown together (newest first), so nothing is missed. Add a new entry (newest first) plus its Whatsnew_x_y_z resx keys on each release.

ClientPack: The jars a server's players need and the server must not load: Sodium, MaLiLib, a minimap.

ColorPalette: The colours offered in the colour chooser, and how readable a colour is on the app's dark surfaces.

ConnectionProbe: The measurements behind the connection test: a Minecraft status ping, a Bedrock (RakNet) ping, a bare TCP round trip, and a download and an upload to time the line.

ConsoleColors: The colour each kind of console line is drawn in, as data.

ConsoleLineClassifier: What a console line is about: its severity, and whether it is chat, a player event, or the app.

ConsoleLogService: Persists every server's console output to a shared, dated log file (%APPDATA%/McServerLauncher/logs/launcher-yyyy-MM-dd.log) so the history survives the app being closed or crashing, not just the in-memory console shown in the UI. A new file starts each day; files older than McServerLauncher.Services.ConsoleLogService.RetentionDays are pruned so the folder doesn't grow forever.

ConsolePreferences: The two console colours the user can change, app-wide.

ContentDependencyCheck: Whether every installed mod and plugin has what it needs, answered from the jars alone.

ContentDependencyCheck.Missing: Something needed that nothing installed provides.

ContentLedger: What the app has to remember about a server's mods that the folder itself cannot say.

ContentLedgerStore: Loads and saves one server's ContentLedger.

ContentManifest: What a mod or plugin jar says about itself: the names it provides, and the ones it needs.

ContentManifest.Entry: One jar in a content folder, switched on or off.

ContentManifest.Manifest: One jar: what it offers under what names, and what it needs to be there.

ContentManifestCache: What a jar says about itself, remembered for as long as the jar has not changed.

ContentMigrationService: What happens to the mods or plugins already installed when a server changes family.

CrashLog: Writes down what went wrong when something escapes every handler, so a crash leaves a trace.

CrashReportService: Looks for a Minecraft server crash report relevant to the server's most recent run, to show a short human-readable reason alongside "the server exited unexpectedly" instead of just an exit code. Vanilla/Fabric/Forge/Paper all write crash reports to "<folder>/crash-reports/" with a stable, decade-old format: a "---- Minecraft Crash Report ----" header followed by a "Description: ..." line summarizing what went wrong.

CreateAgentResult: Result of /v1/partner/create_agent: the per-user self-managed agent minted for the user from their setup code. AgentSecretKey is what the app stores (encrypted) and uses as the agent-key for all subsequent tunnel management.

CrossplayService: Setting a server up so people can join from Bedrock as well as Java.

DeathMessageDetector: Detects Minecraft death/kill messages in a server console line, for the "deaths" notification. Best-effort and English/vanilla-oriented: the server's locale or plugins may word some deaths differently. Pairing a death-phrase match with a "subject is a valid player name" check keeps it from firing on chat lines (which start with a "<name>" tag) or other log output.

DesktopShortcutService

Puts a shortcut to the app on the user's desktop.

Each desktop means something different by "shortcut": Windows wants a .lnk, Linux a .desktop entry that has to be executable and, on GNOME, explicitly trusted, and macOS a symlink to the bundle. What they share is that the target must be whatever this copy is really running from — an AppImage the user dropped in Downloads, a bundle in /Applications — and not a guessed install path.

DownloadVerifier: Verifies a downloaded file's hash against the checksum an official API (Mojang, Adoptium, Paper) already returns alongside the download URL. On mismatch the file is deleted and an exception is thrown, so a corrupted or tampered download is never silently trusted.

ErrorMessages: What to tell a person about a failure, instead of what the exception says.

ExistingServer: Turns a folder that already holds a server into one the app manages, without touching it.

ExistingServerForm: What the user settled on in the create dialog for a folder that already holds a server.

ExportSelection: Which of a server's jars belong in the pack its players are handed.

ExportSelection.Candidate: One jar up for inclusion: what it says about itself, and what the store says.

ExportSelection.Plan: What an export decided, by jar file name.

FileHashCache: The SHA-1 of a file, remembered for as long as the file has not changed.

GcLogLine: Reads one line of the unified GC log (-Xlog:gc) the app asks the JVM to write.

GcLogTail: Reads the lines a file gains, between one call and the next: the GC log the JVM keeps writing.

GcLogging: Asks the JVM for a GC log, which is how the app learns how much heap a server really keeps alive.

GeyserConfigService: Geyser's config.yml: where it lives, and the two ports the launcher has to set in it.

GeyserDownloadsApi: GeyserMC's downloads API, which the app reads for Floodgate and for Hydraulic.

GeyserDownloadsApi.Artifact: One published artifact: which build it came from, and how to verify it.

HydraulicService: Hydraulic: what lets Bedrock players actually see the blocks and items that mods add.

IdlePolicy: The rules for stopping an empty server and for leaving it alone after it was woken, as plain functions of their inputs.

ImageCache

Remote images (project icons and gallery screenshots) with a memory + disk cache in front.

The URLs come from Modrinth's API, but they are still remote input, so every download is guarded: the response has to declare an image content-type and stay under a byte cap that is enforced while streaming, so a missing or lying Content-Length can't balloon memory either. Anything odd yields null and the caller keeps its placeholder.

Decoding happens on the calling (background) thread, never on the UI thread. Bitmaps are cached and handed to several views at once, so they are deliberately never disposed here — a disposed bitmap still bound to an Image would throw when it is drawn.

InlineProgress<T>: Reports on the thread that called it, at once. Progress<T> posts to the thread's synchronization context instead, so a late message can land after the line that was written to say the work finished.

InstalledContentIndex: What the store says each jar on disk is: one answer per file, asked once a session.

JavaService: Detects the machine's Java installations and, if needed, downloads the right version (Adoptium Temurin) for a specific Minecraft version. Works on Windows and Linux.

JavaService.JavaInstall: A Java runtime found on the machine: where its executable is, and its major version.

JavaService.JavaRuntime: What a Java executable is, as far as the command line the app builds cares.

JvmArgs: Reads a server's extra JVM arguments for the decisions the automatic memory profile must leave to their owner.

LatencyStats: Round trips to one place: what came back, out of how many were sent.

LearnedCeiling: A ceiling worked out from how a server was really used, and why.

LiveWorldBackup: Backs up the world of a server that is running, by asking Minecraft to let go of it first.

LoaderChange: What the Loader page asks for: change this server's type, keeping its world.

LoaderChangeResult: The fields of the server's config that an install changes.

LoaderChangeService: Changes a server from one type to another — Vanilla into a loader, a loader into another, or back to Vanilla — without touching the world.

LoaderPaths: Where each mod loader leaves the files the launcher has to find again afterwards.

MarkdownBlock: One block of the description: a paragraph, a heading, a list item…

MarkdownParser

A small Markdown reader for the long descriptions Modrinth returns.

It is deliberately partial. Those descriptions are Markdown with raw HTML mixed in, written to be rendered by a web page, and pulling in a full Markdown engine (and an HTML sanitiser behind it) to show them in a desktop panel would be a large dependency for a read-only view. What is supported is what those pages actually use: headings, lists, quotes, code, emphasis, links and rules. Everything else — HTML tags, images, scripts — is dropped rather than shown raw, so a project page can never inject markup into the app.

Images are dropped on purpose: the gallery already shows them, and a description with thirty remote images would mean thirty downloads for a page the user may only skim.

MarkdownSpan: A run of text inside a block, with the formatting that applies to it.

MemoryAgent: The agent that holds a server's heap tighter while the machine is short of memory: getting it into the server's folder, onto the command line, and out again when it must not run.

MemoryAgentPolicy: Decides, from how much memory the machine has free, whether the agent should hold a server's heap tighter. Pure: the app decides, the agent only carries it out.

MemoryBudget: The memory ceilings of the servers running right now, so the next one to start knows what is left.

MemoryHistory: The memory side of a server's history: its latest runs, oldest first.

MemoryHistoryStore: Loads and saves one server's MemoryHistory.

MemoryInputs: Everything the memory decision depends on, gathered before a server starts.

MemoryLearner: Works out a server's next heap ceiling from the runs the app has seen of it. Pure.

MemoryPlan: What a server starts with.

MemoryPreferences: The app-wide memory settings the start path reads. Set at startup from the saved settings and again when they change, like WindowBehavior.

MemoryPressure: Decides from the GC log whether a server is short of memory. Pure, with the time given by the caller.

MemoryProfile: Decides how much memory a server may use and the JVM flags that make it use no more than it needs.

MemoryReadout: Which of a sample's numbers the RAM card shows.

MemorySession: What the app learned about memory during one run of a server.

MemorySessionStart: What is known about a run when it starts.

MemorySessionTracker: Gathers a run's memory measurements as they arrive, and turns them into one MemorySession when it ends.

MinecraftIds: Turns a Minecraft id into something readable: minecraft:deepslate_diamond_ore becomes "Deepslate diamond ore".

MinecraftRange: Does this Minecraft version satisfy the range a mod declares?

MinecraftVersionService: Gets the list of Minecraft versions from Mojang's official manifest and downloads the server.jar of the chosen version.

MinecraftVersionService.VersionDetails: server.jar URL, required Java version and its official SHA-1 (for integrity checking).

ModDependencyInstaller: Finds the library mods a server's content needs and puts them on disk.

ModDependencyService: The library mods almost every mod needs, and that nobody remembers to install by hand.

ModDependencyService.Needed: One dependency that has to be downloaded, already resolved to a concrete file.

ModDependencyService.Plan: What is missing, and what could not be worked out.

ModLoaderService: Installs a mod loader — Fabric, Forge or NeoForge — into a server folder.

ModLoaderService.ForgeInstallResult: Outcome of a Forge server install: a runnable jar (old Forge) or an args id (modern Forge).

ModrinthService: The app's whole conversation with Modrinth: searching the store, reading a project, resolving a version for this server, identifying installed jars by hash, and downloading a file.

MotdDocument: A server's MOTD as the two lines the game's server list shows, with a style per character.

MultiVersionService: Letting people join from a Minecraft version other than the one the server runs.

NameIssue: The problem found, and whatever detail the message needs.

NbtReader: Reads one number out of a gzipped NBT file, the format Minecraft saves its world data in.

NeoForgeVersions: Turning "which Minecraft version?" into "which NeoForge build?".

NeoForgeVersions.Choice: A chosen build, and whether the user is about to install a pre-release.

NewServerPlan: What the new-server form asks for, once it has been checked and is safe to act on.

NotificationCatalog: What each kind of notification looks like: its level, and the icon that identifies it.

NotificationCatalog.Entry: One kind of notification: how serious it is, and how it is marked.

NotificationPalette: The default colour of each notification level, and what counts as a valid one.

NotificationPreferences: Decides whether a given notification should be shown for a given server, combining the global settings with an optional per-server override. Global is app-wide state (like ToastService.Shared): set once at startup from AppSettings and updated when the user edits the global notification settings.

PaperDistanceOverride: Whether Spigot's own configuration overrides the distances in server.properties.

PaperService: Downloads the Paper server jar from PaperMC's "fill" API (v3). Paper is a runnable jar, so it launches like vanilla (-jar). Plugins go in the server's plugins/ folder.

PaperService.PaperBuild: One Paper build, resolved to something downloadable.

PerformanceAdvice: Turns a verdict into the settings changes worth offering. Pure.

PerformanceMonitor: Decides from several signals whether a server is coping, and says which one convinced it.

PerformanceParsers: Reads the lines that tell how fast a server is running: its own lag warnings and the answers of spark tps, vanilla's tick query and Paper's tps.

PerformancePick: One mod or plugin the Performance page may suggest.

PerformancePicks: The short list of mods and plugins that make a server faster without changing how the game plays, from Resources/performance-picks.json.

PerformanceProbe: Asks a running server how fast it is, with the best command it understands, and keeps the answer out of the console.

PerformanceStatus: The monitor's verdict at one moment.

PlayerEvent: One thing a player did, read from a console line.

PlayerEventParser: Turns a server log line into something a player did.

PlayerHistoryPreferences: The app-wide history settings, set from AppSettings at startup and by the settings dialog.

PlayerHistoryStore: One server's player history: who came, when, for how long, and what they did and said.

PlayerLogImporter: Fills a new player history from the logs the server already kept, once.

PlayerNames: What a Minecraft Java player name looks like, in one place.

PlayerRecord: What the history knows about one player, all in one place.

PlayerStats: A player's statistics as the server itself counts them.

PlayerStatsReader: Reads the statistics the server keeps per player, for the player's profile.

PlayersService: Reads the player lists the server stores in JSON files: ops.json (operators), banned-players.json (banned) and usercache.json (known).

PlayitAgentRunner: Runs Playit's official agent (playitd) as a child process so the user's tunnels actually forward traffic — without them installing anything. The binary is downloaded once (pinned to the same version the app registers, McServerLauncher.Services.PlayitAgentRunner.AgentVersion) and launched with --secret-path (see McServerLauncher.Services.PlayitAgentRunner.SecretPath) pointing at the per-user agent key from the setup-code flow. One agent serves all of the user's tunnels; it runs while the app is open and connected, and is stopped on shutdown. App-wide singleton.

PlayitApiException: Error returned by the Playit API (status != success).

PlayitApiService

Playit.gg API client.

Preferred: a per-user self-managed agent secret key from the partner setup-code flow (PlayitPartnerService), set app-wide via SetAgentKey(string?) and used as agent-key for both reads AND writes.
Fallback (legacy): the agent's secret_key from playit.toml (reads) and a user-pasted write key (writes, sent as Api-Key/Agent-Key). Auth is resolved by trying the schemes in order, so a caller doesn't need to know which kind of key it holds.

PlayitApiService.PlayitTunnel: One tunnel as the agent reports it.

PlayitManager

Playit.gg integration that relies on the background Playit agent already keeping the tunnels up 24/7. The app does not launch its own playit binary: it only queries and, when possible, starts/stops the agent.

On Windows the agent is a Windows service ("playitd"), managed via ServiceController.
On Linux it is typically a systemd unit, managed via systemctl (start/stop may need privileges).

PlayitPartnerService: Third-party "Integration"-tier onboarding: exchanges a Playit account_setup_code (that the user obtained from playit.gg) for a per-user self-managed agent secret key. The request goes through a small proxy (a Cloudflare Worker, see playit-proxy/) that injects the partner Api-Key server-side — so NO secret ships inside this (public, open-source) app. Everything after uses the returned per-user secret via PlayitApiService.

PlayitStatus: What the tunnel panel says about Playit, worked out from the two things that can carry the tunnel: the app's embedded agent, and the system's own Playit service.

PortService: Checks which ports are in use on the machine (by any application) and helps find the next free one. TCP and UDP are asked separately because they are separate namespaces.

ProcessMemory: The memory a process holds that belongs to it alone, as the system reports it.

ProcessRunner: Runs a short external command and collects what it printed, within a deadline that holds.

ProcessStatsService: Computes CPU usage (%) and RAM (MB) of a process, sampling the CPU time between consecutive calls.

ProcessStatsService.Stats: One sample of a running server's cost, as the status cards show it.

PropertiesSavedWhileRunning: The server.properties values saved while the server was running, to be written again when the server overwrites them.

PurpurService: Downloads the Purpur server jar. Purpur is a Paper fork: a runnable jar, plugins in plugins/, and every Bukkit plugin works on it unchanged.

PurpurService.PurpurBuild: A build of Purpur, and the hash their API publishes for it.

Safe: For the failures the app decides to carry on after: they are not shown to the user, but they are not thrown away either.

SaveConfirmation: Recognises the server saying it has finished writing the world to disk.

SecretProtector

Protects small secrets (like the Playit API key) at rest, on every platform:

Windows: DPAPI scoped to the current user, stored as "dpapi:" + base64. Only the same Windows user on the same machine can decrypt it.
Linux/macOS: AES-256-GCM with a random per-user key kept in a file only the user can read (0600), stored as "aes:" + base64(nonce | tag | ciphertext). Both protect the settings file against other users and accidental leaks (backups, sharing the file); neither protects against malware already running as the same user — DPAPI can't either.

SeedInfo: A world's seed, and where the app found it.

SeedMapLink: The link to a seed on Chunkbase's seed map, for the version the server runs.

SelfUpdater

Replaces the running application with an already downloaded and verified package, then restarts it — the same "press Update and it just happens" behaviour on every platform.

Each platform ships differently, so each is applied differently: Windows runs the silent installer, Linux swaps the AppImage file the app is running from, and macOS mounts the .dmg and replaces the .app bundle. What they share is the shape: nothing is touched until a complete, package, verified by checksum and by the publisher's signature, exists on disk, and any failure leaves the current install working.

ServerAccessCatalog: One row per permission and per role: what it is called on the wire, how dangerous it is, and what a role starts with.

ServerAccessCatalog.PermissionEntry: Everything the app knows about one permission.

ServerAccessRules: Who can do what on a shared server, and who may change whose access.

ServerCreationService: Generates the initial files of a new server: eula.txt, run.bat and a minimal server.properties with the chosen port (Minecraft fills in the rest on the first launch).

ServerDetection: What a server folder turned out to contain.

ServerDetectionService: Works out what kind of server a folder holds: the type, the Minecraft version, the loader, what to launch, and the port, memory and world it was set up with.

ServerIconService: Generates a server's server-icon.png (64x64 PNG) from any image, cropping it to a centered square and scaling. This is the icon players see in the server list. Uses SkiaSharp so it works on Windows and Linux.

ServerJarInstaller: Puts the right server files on disk for a server type, whichever way that type is obtained.

ServerJarInstaller.InstallResult: What the install left behind, in the shape the caller needs for its config.

ServerNameRule: Checking a server's folder name before it becomes a server that will not start.

ServerPorts: What a server needs from the account's tunnels: its name and the ports it listens on. JavaPort is null when server.properties cannot be read; BedrockPort is null when crossplay is off (a server without Bedrock owns no UDP tunnel); PlayitEnabled says whether the server is meant to be reached through Playit at all.

ServerProcessManager: Manages the lifecycle of a Minecraft server's java process: startup, clean shutdown (sending "stop" over stdin), command sending and re-emitting the console output in real time.

ServerPropertiesService: Reads and writes the server.properties file (key=value format, one per line). Used to read values (e.g. the port) and to update them from the visual configuration screen.

ServerProvisioningService: Makes a server on disk, or takes over a folder that already holds one: everything the new-server panel does once the form has been accepted.

ServerStorageService: Loads and saves the list of registered servers in %APPDATA%\McServerLauncher\servers.json.

ServerTypeCatalog: One row per server type: what it is called, what it takes, and whether Bedrock can reach it.

ServerTypeCatalog.Entry: Everything the app knows about one server type.

SingleInstance: Keeps the app to one running copy per user, and lets a second launch bring the first one back to the front instead of opening a window of its own.

SlpReply: What a Minecraft server said to a status ping.

StatEntry: One id and how many times it was counted: minecraft:stone, 1420.

StoreCache

Two-level cache (memory, then disk, then the network) for the store's API responses. It exists so that opening a mod — and going back and opening it again — costs one request, not one per visit, and so that a project already seen still opens with no connection.

Concurrent callers asking for the same key share a single fetch: opening a details page kicks off the project, its versions and its dependencies at once, and the related-mods strip may ask for a project that is already in flight.

Entries are kept on disk beyond their freshness window on purpose: when the network fails, a stale entry is a much better answer than an empty page. Anything older than McServerLauncher.Services.StoreCache.MaxDiskAge is pruned once per run.

StoreCatalogEntry: What the catalogue knows about one project.

StoreCatalogService: The store catalogue: what each popular project is about and what it does, decided outside the app.

StoreSummaryService

Answers "what does this actually do to my server?" in the user's own language.

Modrinth's own one-line description is written by the author, in English, and often for other modders ("An intermediary api aimed to ease developing multiplatform mods"). So the store ships a hand-written catalogue for the projects a server owner is most likely to meet, in the five languages the app speaks. It is looked up locally: no request, no key, no cost, and it works offline.

Anything outside the catalogue falls back to a sentence built from what Modrinth does tell us — the kind of project, its main tag and, above all, whether players have to install it too, which is the one thing that decides whether a mod is usable on a public server.

The catalogue can be replaced without rebuilding by dropping a store-summaries.json in the user's data folder.

StoreTagService

Turns a store item into the app's own tags.

Modrinth's categories are a good start but they are coarse — nearly half of the top server mods are filed under "utility" — and they don't say the one thing a server owner cares most about: whether players have to install the mod as well. So the categories are combined with keyword rules and with the client/server side, all of which live in Resources/store-tags.json.

Every rule adds to a score and a tag applies from McServerLauncher.Services.StoreTagService.Threshold. That is what replaced "any rule matching is enough", which tagged a password manager as combat (the keyword "sword" inside "password") and a backpack mod as combat too (Modrinth files armour, tools and backpacks under "equipment"). Keywords are whole words, and a project whose author ticked most of the topics gets little from them: those authors tick everything, so the ticks say little. When nothing reaches the threshold the project has no tags, and the card says so by showing none rather than a guess.

Where the downloaded StoreCatalogService has an answer for a project, that answer is used instead: it comes from reading the whole description with a model, which is what these rules can only approximate. The rules remain what runs for every project the catalogue has never seen, and what runs offline on a first launch.

The catalogue is read from the embedded copy, unless %APPDATA%\McServerLauncher\store-tags.json exists, in which case that file is used instead. Tags can therefore be added, translated, recoloured or re-mapped without a new build.

StoredEvent: One event as it is stored and shown.

SystemMemory: The machine's memory, as the memory budget and the performance advice need it.

Throughput: How fast bytes went one way.

TickReading: One answer from a server about its speed.

ToastLifetime: How long a toast stays, how much of that is left, and how opaque it is right now.

TunnelAddressSync: What a server card should say about its addresses, given what the Playit account answered.

TunnelInventory: Reading the account's tunnels against the servers on this machine: which ones lead nowhere, which ones two servers are fighting over, which are there twice, and what is missing.

TunnelReport

TunnelRow: One tunnel of the account, with what is known about it. Owners are the servers that listen where it points; SuggestedName is the name it would carry if named after its server, null when nothing sensible exists (no owner, or several).

TunnelSuggestion: One thing the screen can offer to put right. TunnelId and ServerId name what it concerns, when it concerns one; Subject is the name to show (the tunnel's or the server's); Other is a second name where one is needed (the other server sharing a port); Udp and Port say which local port it is about — a shared Bedrock port is fixed differently from a shared Java one, and "create a tunnel" is only actionable on playit.gg with the port in hand.

UpdateCheck: Turning the update service's answer into one of the three outcomes a person can be told about.

UpdateService: Checks the GitHub Releases for a version newer than the installed one.

UpdateService.UpdateInfo: Update data. PackageUrl/PackageName are the package for the platform this app is running on — the Windows installer, the Linux AppImage or the macOS .dmg for this architecture — and are null when the release ships nothing usable here. ChecksumUrl is the asset that carries its SHA-256, used to verify the download before it is installed; null on releases published before that existed. SignatureUrl is the asset with the publisher's signature of the package (see UpdateSignature); null when the release has not been signed (yet).

UpdateSignature: Checks that an update package was signed by whoever publishes this project, with a key that does not live on GitHub — and that the signature is for this version of this package.

UserFacingException: A failure whose message was written for the user — translated, complete, ready to show.

VerifiedJarDownload: Fetching a server jar: announce the size, download atomically, verify, say it is done.

WakeOnDemandListener

Answers Minecraft clients on the server's port while the real server is stopped, so a stopped server can say "I'm asleep, come in and I'll wake up" instead of just refusing the connection.

It speaks the small, stable part of the protocol needed for that: the handshake, the server-list status, and the login disconnect. Pressing Join is what wakes the server — the client re-pings every few seconds while the multiplayer screen is open, so waking on a status request would start the server over and over for people who are not even playing.

With a Playit tunnel this socket is reachable from the internet, so everything it reads is treated as hostile: lengths are bounded before anything is allocated, every connection has a deadline, and the number of them at once is capped.

WakePolicy: Who may wake a sleeping server by trying to join it.

WakeStatus: What a client is told about a server that is currently asleep.

WhitelistService: Manages a server's whitelist.json file (list of allowed players). Each entry has uuid + name. It resolves the UUID from Mojang (online mode) or computes it offline when the server does not use official accounts.

WindowBehavior: What the window's minimize and close buttons do, as chosen in the settings. App-wide state (like Global): set at startup from the saved settings and updated when the user edits them, so the change takes effect without restarting the app.

WorldBackupService: Creates and restores zip backups of a server's world folder — the "level-name" directory from server.properties ("world" by default) — together with the Nether and the End when the server keeps them beside it. Backups live in "<server folder>/backups/"; old ones beyond the configured retention are pruned after each new one.

WorldBackupService.BackupInfo: One backup zip already on disk, as the backups list shows it.

WorldCommand: Whether a command typed into the console can change the world's files.

WorldSeed: Finds the seed of a server's world.

Structs

Changelog.Section: A version and its localized notes.

GcEvent: One collection read from the GC log.

MotdStyle: How one character looks. Color is a Minecraft code (0-9, a-f), 'x' for the RGB colour in Rgb, or '\0' for the list's default grey.

PerfLine: A console line read for speed, with the numbers it carries.

ProcessRunner.Result: What a command left behind. ExitCode is -1 when it could not run or ran out of time.

ReachabilitySignal: What the signal shows: its kind, the hint to explain it, and whether to warn.

Interfaces

IUpdateSource: Where an update's files come from: the checksum list, the signature and the package itself.

Enums

AdviceKind: A change to the server's settings that lightens its load.

AgentRunState: State of the embedded Playit agent process.

AppUpdateCoordinator.Phase: A step the user can be told about while it runs.

AtomicJsonFile.LoadOutcome: What happened when loading a JSON file.

BackupDue: What the clock says about the next automatic backup.

ContentManifest.ContentSide: Where a jar declares it runs, read out of its own manifest.

CrossplayLevel: How well Bedrock players can actually play on a server type.

ExportSelection.StoreSide: How well a project supports one side, in the store's vocabulary.

GcCollector: The collector a JVM reports it is using.

GcKind: What a collection was, as far as the memory history cares.

GrantDenial: Why a change to somebody's access is refused. None means it is allowed.

HeapMargins: How tight the agent keeps a server's heap.

MarkdownBlockKind: What a parsed block of a project's long description is.

MemoryCeilingReason: Why a server got the memory ceiling it got.

MemoryPressureReason: Why a server counts as short of memory.

MotdFormat: The formatting a Minecraft MOTD can carry besides its colour.

NameIssueKind: What is wrong with a server's folder name, when something is.

PerfLineKind: What a console line says about the server's speed.

PerformanceCause: What the judgement rests on, most serious first.

PerformanceLevel: How a server is coping, in the three words the card shows.

PermissionRisk: How much damage a permission can do if it falls into the wrong hands.

PlayerEventKind: What a player did, as far as the history is concerned.

PlayitApiService.TunnelEdition: Which edition a tunnel carries: they are different protocols, not a preference.

ProbeKind: The command the app asks a server for its speed with.

SeedSource: Where a seed the app shows came from, which decides how it is described.

ServerFamily: What a server type accepts: plugins, mods, or neither.

SessionEnd: How a run ended, for the history.

SignalKind: How reachable a server is, for the coloured dot beside its name.

TickSource: Where a tick reading came from.

TunnelHealth: How a tunnel stands against the servers on this machine.

TunnelSuggestionKind

UpdateCheckState: Where the "is there a newer version" question stands.

Table of Contents

Namespace McServerLauncher.Services

Classes

Structs

Interfaces

Enums