WIP

Agent/Phantom.Agent.Minecraft/Instance/InstanceProcess.cs

@@ -1,28 +1,25 @@
-using System.Diagnostics;
-using Phantom.Utils.Collections;
+using Phantom.Utils.Collections;
 using Phantom.Utils.Runtime;
 
 namespace Phantom.Agent.Minecraft.Instance; 
 
-public sealed class InstanceSession : IDisposable {
+public sealed class InstanceProcess : IDisposable {
 	public InstanceProperties InstanceProperties { get; }
 	public CancellableSemaphore BackupSemaphore { get; } = new (1, 1);
 	
 	private readonly RingBuffer<string> outputBuffer = new (10000);
 	private event EventHandler<string>? OutputEvent;
 
-	public event EventHandler? SessionEnded;
+	public event EventHandler? Ended;
 	public bool HasEnded { get; private set; }
 
 	private readonly Process process;
 
-	internal InstanceSession(InstanceProperties instanceProperties, Process process) {
+	internal InstanceProcess(InstanceProperties instanceProperties, Process process) {
 		this.InstanceProperties = instanceProperties;
 		this.process = process;
-		this.process.EnableRaisingEvents = true;
 		this.process.Exited += ProcessOnExited;
-		this.process.OutputDataReceived += HandleOutputLine;
-		this.process.ErrorDataReceived += HandleOutputLine;
+		this.process.OutputReceived += ProcessOutputReceived;
 	}
 
 	public async Task SendCommand(string command, CancellationToken cancellationToken) {
@@ -41,17 +38,15 @@ public sealed class InstanceSession : IDisposable {
 		OutputEvent -= listener;
 	}
 
-	private void HandleOutputLine(object sender, DataReceivedEventArgs args) {
-		if (args.Data is {} line) {
-			outputBuffer.Add(line);
-			OutputEvent?.Invoke(this, line);
-		}
+	private void ProcessOutputReceived(object? sender, Process.Output output) {
+		outputBuffer.Add(output.Line);
+		OutputEvent?.Invoke(this, output.Line);
 	}
 
 	private void ProcessOnExited(object? sender, EventArgs e) {
 		OutputEvent = null;
 		HasEnded = true;
-		SessionEnded?.Invoke(this, EventArgs.Empty);
+		Ended?.Invoke(this, EventArgs.Empty);
 	}
 
 	public void Kill() {
@@ -68,6 +63,6 @@ public sealed class InstanceSession : IDisposable {
 		process.Dispose();
 		BackupSemaphore.Dispose();
 		OutputEvent = null;
-		SessionEnded = null;
+		Ended = null;
 	}
 }

Agent/Phantom.Agent.Minecraft/Instance/InstanceProperties.cs

@@ -1,6 +1,7 @@
 using System.Collections.Immutable;
 using Phantom.Agent.Minecraft.Java;
 using Phantom.Agent.Minecraft.Properties;
+using Phantom.Common.Data.Instance;
 
 namespace Phantom.Agent.Minecraft.Instance;
 
@@ -11,5 +12,6 @@ public sealed record InstanceProperties(
 	ImmutableArray<string> JvmArguments,
 	string InstanceFolder,
 	string ServerVersion,
-	ServerProperties ServerProperties
+	ServerProperties ServerProperties,
+	InstanceLaunchProperties LaunchProperties
 );

Agent/Phantom.Agent.Minecraft/Launcher/BaseLauncher.cs

@@ -1,17 +1,19 @@
-using System.Diagnostics;
-using System.Text;
+using System.Text;
 using Kajabity.Tools.Java;
 using Phantom.Agent.Minecraft.Instance;
 using Phantom.Agent.Minecraft.Java;
 using Phantom.Agent.Minecraft.Server;
 using Phantom.Common.Minecraft;
+using Phantom.Utils.Runtime;
 using Serilog;
 
 namespace Phantom.Agent.Minecraft.Launcher;
 
-public abstract class BaseLauncher {
+public abstract class BaseLauncher : IServerLauncher {
 	private readonly InstanceProperties instanceProperties;
 
+	protected string MinecraftVersion => instanceProperties.ServerVersion;
+
 	private protected BaseLauncher(InstanceProperties instanceProperties) {
 		this.instanceProperties = instanceProperties;
 	}
@@ -25,33 +27,25 @@ public abstract class BaseLauncher {
 			return new LaunchResult.InvalidJvmArguments();
 		}
 
-		var vanillaServerJarPath = await services.ServerExecutables.DownloadAndGetPath(instanceProperties.ServerVersion, downloadProgressEventHandler, cancellationToken);
+		var vanillaServerJarPath = await services.ServerExecutables.DownloadAndGetPath(instanceProperties.LaunchProperties.ServerDownloadInfo, MinecraftVersion, downloadProgressEventHandler, cancellationToken);
 		if (vanillaServerJarPath == null) {
 			return new LaunchResult.CouldNotDownloadMinecraftServer();
 		}
 
-		var startInfo = new ProcessStartInfo {
-			FileName = javaRuntimeExecutable.ExecutablePath,
-			WorkingDirectory = instanceProperties.InstanceFolder,
-			RedirectStandardInput = true,
-			RedirectStandardOutput = true,
-			RedirectStandardError = true,
-			UseShellExecute = false,
-			CreateNoWindow = false
-		};
+		ServerJarInfo? serverJar;
+		try {
+			serverJar = await PrepareServerJar(logger, vanillaServerJarPath, cancellationToken);
+		} catch (OperationCanceledException) {
+			throw;
+		} catch (Exception e) {
+			logger.Error(e, "Caught exception while preparing the server jar.");
+			return new LaunchResult.CouldNotPrepareMinecraftServerLauncher();
+		}
 
-		var jvmArguments = new JvmArgumentBuilder(instanceProperties.JvmProperties, instanceProperties.JvmArguments);
-		CustomizeJvmArguments(jvmArguments);
-
-		var serverJarPath = await PrepareServerJar(vanillaServerJarPath, instanceProperties.InstanceFolder, cancellationToken);
-		var processArguments = startInfo.ArgumentList;
-		jvmArguments.Build(processArguments);
-		processArguments.Add("-jar");
-		processArguments.Add(serverJarPath);
-		processArguments.Add("nogui");
-
-		var process = new Process { StartInfo = startInfo };
-		var session = new InstanceSession(instanceProperties, process);
+		if (!File.Exists(serverJar.FilePath)) {
+			logger.Error("Missing prepared server or launcher jar: {FilePath}", serverJar.FilePath);
+			return new LaunchResult.CouldNotPrepareMinecraftServerLauncher();
+		}
 
 		try {
 			await AcceptEula(instanceProperties);
@@ -61,10 +55,32 @@ public abstract class BaseLauncher {
 			return new LaunchResult.CouldNotConfigureMinecraftServer();
 		}
 		
+		var processConfigurator = new ProcessConfigurator {
+			FileName = javaRuntimeExecutable.ExecutablePath,
+			WorkingDirectory = instanceProperties.InstanceFolder,
+			RedirectInput = true,
+			UseShellExecute = false
+		};
+		
+		var jvmArguments = new JvmArgumentBuilder(instanceProperties.JvmProperties, instanceProperties.JvmArguments);
+		CustomizeJvmArguments(jvmArguments);
+
+		var processArguments = processConfigurator.ArgumentList;
+		jvmArguments.Build(processArguments);
+		
+		foreach (var extraArgument in serverJar.ExtraArgs) {
+			processArguments.Add(extraArgument);
+		}
+		
+		processArguments.Add("-jar");
+		processArguments.Add(serverJar.FilePath);
+		processArguments.Add("nogui");
+
+		var process = processConfigurator.CreateProcess();
+		var instanceProcess = new InstanceProcess(instanceProperties, process);
+
 		try {
 			process.Start();
-			process.BeginOutputReadLine();
-			process.BeginErrorReadLine();
 		} catch (Exception launchException) {
 			logger.Error(launchException, "Caught exception launching the server process.");
 			
@@ -77,13 +93,13 @@ public abstract class BaseLauncher {
 			return new LaunchResult.CouldNotStartMinecraftServer();
 		}
 
-		return new LaunchResult.Success(session);
+		return new LaunchResult.Success(instanceProcess);
 	}
 
 	private protected virtual void CustomizeJvmArguments(JvmArgumentBuilder arguments) {}
 
-	private protected virtual Task<string> PrepareServerJar(string serverJarPath, string instanceFolderPath, CancellationToken cancellationToken) {
-		return Task.FromResult(serverJarPath);
+	private protected virtual Task<ServerJarInfo> PrepareServerJar(ILogger logger, string serverJarPath, CancellationToken cancellationToken) {
+		return Task.FromResult(new ServerJarInfo(serverJarPath));
 	}
 
 	private static async Task AcceptEula(InstanceProperties instanceProperties) {

Agent/Phantom.Agent.Minecraft/Launcher/IServerLauncher.cs

@@ -0,0 +1,8 @@
+using Phantom.Agent.Minecraft.Server;
+using Serilog;
+
+namespace Phantom.Agent.Minecraft.Launcher;
+
+public interface IServerLauncher {
+	Task<LaunchResult> Launch(ILogger logger, LaunchServices services, EventHandler<DownloadProgressEventArgs> downloadProgressEventHandler, CancellationToken cancellationToken);
+}

Agent/Phantom.Agent.Minecraft/Launcher/LaunchResult.cs

@@ -5,7 +5,7 @@ namespace Phantom.Agent.Minecraft.Launcher;
 public abstract record LaunchResult {
 	private LaunchResult() {}
 
-	public sealed record Success(InstanceSession Session) : LaunchResult;
+	public sealed record Success(InstanceProcess Process) : LaunchResult;
 
 	public sealed record InvalidJavaRuntime : LaunchResult;
 	
@@ -13,6 +13,8 @@ public abstract record LaunchResult {
 
 	public sealed record CouldNotDownloadMinecraftServer : LaunchResult;
 	
+	public sealed record CouldNotPrepareMinecraftServerLauncher : LaunchResult;
+	
 	public sealed record CouldNotConfigureMinecraftServer : LaunchResult;
 	
 	public sealed record CouldNotStartMinecraftServer : LaunchResult;

Agent/Phantom.Agent.Minecraft/Launcher/ServerJarInfo.cs

@@ -0,0 +1,7 @@
+using System.Collections.Immutable;
+
+namespace Phantom.Agent.Minecraft.Launcher;
+
+sealed record ServerJarInfo(string FilePath, ImmutableArray<string> ExtraArgs) {
+	public ServerJarInfo(string filePath) : this(filePath, ImmutableArray<string>.Empty) {}
+}

Agent/Phantom.Agent.Minecraft/Launcher/Types/FabricLauncher.cs

@@ -0,0 +1,55 @@
+using System.Collections.Immutable;
+using Phantom.Agent.Minecraft.Instance;
+using Phantom.Utils.IO;
+using Serilog;
+
+namespace Phantom.Agent.Minecraft.Launcher.Types; 
+
+public sealed class FabricLauncher : BaseLauncher {
+	public FabricLauncher(InstanceProperties instanceProperties) : base(instanceProperties) {}
+	
+	private protected override async Task<ServerJarInfo> PrepareServerJar(ILogger logger, string serverJarPath, CancellationToken cancellationToken) {
+		var serverJarParentFolderPath = Directory.GetParent(serverJarPath);
+		if (serverJarParentFolderPath == null) {
+			throw new ArgumentException("Could not get parent folder from: " + serverJarPath, nameof(serverJarPath));
+		}
+		
+		var launcherJarPath = Path.Combine(serverJarParentFolderPath.FullName, "fabric.jar");
+		
+		if (!File.Exists(launcherJarPath)) {
+			await DownloadLauncher(logger, launcherJarPath, cancellationToken);
+		}
+
+		return new ServerJarInfo(launcherJarPath, ImmutableArray.Create("-Dfabric.installer.server.gameJar=" + Paths.NormalizeSlashes(serverJarPath)));
+	}
+
+	private async Task DownloadLauncher(ILogger logger, string targetFilePath, CancellationToken cancellationToken) {
+		// TODO customizable loader version, probably with a dedicated temporary folder
+		string installerUrl = $"https://meta.fabricmc.net/v2/versions/loader/{MinecraftVersion}/stable/stable/server/jar";
+		logger.Information("Downloading Fabric launcher from: {Url}", installerUrl);
+		
+		using var http = new HttpClient();
+		
+		var response = await http.GetAsync(installerUrl, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
+		response.EnsureSuccessStatusCode();
+		
+		try {
+			await using var fileStream = new FileStream(targetFilePath, FileMode.CreateNew, FileAccess.Write, FileShare.Read);
+			await using var responseStream = await response.Content.ReadAsStreamAsync(cancellationToken);
+			await responseStream.CopyToAsync(fileStream, cancellationToken);
+		} catch (Exception) {
+			TryDeleteLauncherAfterFailure(logger, targetFilePath);
+			throw;
+		}
+	}
+
+	private static void TryDeleteLauncherAfterFailure(ILogger logger, string filePath) {
+		if (File.Exists(filePath)) {
+			try {
+				File.Delete(filePath);
+			} catch (Exception e) {
+				logger.Warning(e, "Could not clean up partially downloaded Fabric launcher: {FilePath}", filePath);
+			}
+		}
+	}
+}

Agent/Phantom.Agent.Minecraft/Launcher/Types/ForgeLauncher.cs

@@ -0,0 +1,12 @@
+using Phantom.Agent.Minecraft.Instance;
+using Phantom.Agent.Minecraft.Java;
+
+namespace Phantom.Agent.Minecraft.Launcher.Types; 
+
+public class ForgeLauncher : BaseLauncher {
+	public ForgeLauncher(InstanceProperties instanceProperties) : base(instanceProperties) {}
+	
+	private protected override void CustomizeJvmArguments(JvmArgumentBuilder arguments) {
+		arguments.AddProperty("terminal.ansi", "true"); // TODO
+	}
+}

Agent/Phantom.Agent.Minecraft/Launcher/Types/InvalidLauncher.cs

@@ -0,0 +1,14 @@
+using Phantom.Agent.Minecraft.Server;
+using Serilog;
+
+namespace Phantom.Agent.Minecraft.Launcher.Types; 
+
+public sealed class InvalidLauncher : IServerLauncher {
+	public static InvalidLauncher Instance { get; } = new ();
+	
+	private InvalidLauncher() {}
+	
+	public Task<LaunchResult> Launch(ILogger logger, LaunchServices services, EventHandler<DownloadProgressEventArgs> downloadProgressEventHandler, CancellationToken cancellationToken) {
+		return Task.FromResult<LaunchResult>(new LaunchResult.CouldNotPrepareMinecraftServerLauncher());
+	}
+}

Agent/Phantom.Agent.Minecraft/Phantom.Agent.Minecraft.csproj

@@ -17,6 +17,7 @@
     <ProjectReference Include="..\..\Utils\Phantom.Utils.Collections\Phantom.Utils.Collections.csproj" />
     <ProjectReference Include="..\..\Utils\Phantom.Utils.Cryptography\Phantom.Utils.Cryptography.csproj" />
     <ProjectReference Include="..\..\Utils\Phantom.Utils.IO\Phantom.Utils.IO.csproj" />
+    <ProjectReference Include="..\..\Utils\Phantom.Utils.Runtime\Phantom.Utils.Runtime.csproj" />
   </ItemGroup>
 
 </Project>

Agent/Phantom.Agent.Minecraft/Server/MinecraftServerExecutableDownloader.cs

@@ -1,6 +1,6 @@
 using System.Security.Cryptography;
+using Phantom.Common.Data.Minecraft;
 using Phantom.Common.Logging;
-using Phantom.Common.Minecraft;
 using Phantom.Utils.Cryptography;
 using Phantom.Utils.IO;
 using Phantom.Utils.Runtime;
@@ -11,8 +11,6 @@ namespace Phantom.Agent.Minecraft.Server;
 sealed class MinecraftServerExecutableDownloader {
 	private static readonly ILogger Logger = PhantomLogger.Create<MinecraftServerExecutableDownloader>();
 
-	private readonly MinecraftVersions minecraftVersions;
-	
 	public Task<string?> Task { get; }
 	public event EventHandler<DownloadProgressEventArgs>? DownloadProgress;
 	public event EventHandler? Completed;
@@ -20,17 +18,15 @@ sealed class MinecraftServerExecutableDownloader {
 	private readonly CancellationTokenSource cancellationTokenSource = new ();
 	private int listeners = 0;
 
-	public MinecraftServerExecutableDownloader(MinecraftVersions minecraftVersions, string version, string filePath, MinecraftServerExecutableDownloadListener listener) {
-		this.minecraftVersions = minecraftVersions;
-		
+	public MinecraftServerExecutableDownloader(FileDownloadInfo fileDownloadInfo, string minecraftVersion, string filePath, MinecraftServerExecutableDownloadListener listener) {
 		Register(listener);
-		Task = DownloadAndGetPath(version, filePath);
+		Task = DownloadAndGetPath(fileDownloadInfo, minecraftVersion, filePath);
 		Task.ContinueWith(OnCompleted, TaskScheduler.Default);
 	}
 
 	public void Register(MinecraftServerExecutableDownloadListener listener) {
 		++listeners;
-		Logger.Verbose("Registered download listener, current listener count: {Listeners}", listeners);
+		Logger.Debug("Registered download listener, current listener count: {Listeners}", listeners);
 		
 		DownloadProgress += listener.DownloadProgressEventHandler;
 		listener.CancellationToken.Register(Unregister, listener);
@@ -41,11 +37,11 @@ sealed class MinecraftServerExecutableDownloader {
 		DownloadProgress -= listener.DownloadProgressEventHandler;
 
 		if (--listeners <= 0) {
-			Logger.Verbose("Unregistered last download listener, cancelling download.");
+			Logger.Debug("Unregistered last download listener, cancelling download.");
 			cancellationTokenSource.Cancel();
 		}
 		else {
-			Logger.Verbose("Unregistered download listener, current listener count: {Listeners}", listeners);
+			Logger.Debug("Unregistered download listener, current listener count: {Listeners}", listeners);
 		}
 	}
 
@@ -54,7 +50,7 @@ sealed class MinecraftServerExecutableDownloader {
 	}
 
 	private void OnCompleted(Task task) {
-		Logger.Verbose("Download task completed.");
+		Logger.Debug("Download task completed.");
 		Completed?.Invoke(this, EventArgs.Empty);
 		Completed = null;
 		DownloadProgress = null;
@@ -72,33 +68,26 @@ sealed class MinecraftServerExecutableDownloader {
 		}
 	}
 
-	private async Task<string?> DownloadAndGetPath(string version, string filePath) {
-		Logger.Information("Downloading server version {Version}...", version);
-
+	private async Task<string?> DownloadAndGetPath(FileDownloadInfo fileDownloadInfo, string minecraftVersion, string filePath) {
 		string tmpFilePath = filePath + ".tmp";
 
 		var cancellationToken = cancellationTokenSource.Token;
 		try {
-			var serverExecutableInfo = await minecraftVersions.GetServerExecutableInfo(version, cancellationToken);
-			if (serverExecutableInfo == null) {
-				return null;
-			}
-
-			Logger.Information("Downloading server executable from: {Url} ({Size})", serverExecutableInfo.DownloadUrl, serverExecutableInfo.Size.ToHumanReadable(decimalPlaces: 1));
+			Logger.Information("Downloading server version {Version} from: {Url} ({Size})", minecraftVersion, fileDownloadInfo.DownloadUrl, fileDownloadInfo.Size.ToHumanReadable(decimalPlaces: 1));
 			try {
 				using var http = new HttpClient();
-				await FetchServerExecutableFile(http, new DownloadProgressCallback(this), serverExecutableInfo, tmpFilePath, cancellationToken);
+				await FetchServerExecutableFile(http, new DownloadProgressCallback(this), fileDownloadInfo, tmpFilePath, cancellationToken);
 			} catch (Exception) {
 				TryDeleteExecutableAfterFailure(tmpFilePath);
 				throw;
 			}
 
 			File.Move(tmpFilePath, filePath, true);
-			Logger.Information("Server version {Version} downloaded.", version);
+			Logger.Information("Server version {Version} downloaded.", minecraftVersion);
 
 			return filePath;
 		} catch (OperationCanceledException) {
-			Logger.Information("Download for server version {Version} was cancelled.", version);
+			Logger.Information("Download for server version {Version} was cancelled.", minecraftVersion);
 			throw;
 		} catch (StopProcedureException) {
 			return null;
@@ -110,17 +99,17 @@ sealed class MinecraftServerExecutableDownloader {
 		}
 	}
 
-	private static async Task FetchServerExecutableFile(HttpClient http, DownloadProgressCallback progressCallback, MinecraftServerExecutableInfo info, string filePath, CancellationToken cancellationToken) {
+	private static async Task FetchServerExecutableFile(HttpClient http, DownloadProgressCallback progressCallback, FileDownloadInfo fileDownloadInfo, string filePath, CancellationToken cancellationToken) {
 		Sha1String downloadedFileHash;
 
 		try {
-			var response = await http.GetAsync(info.DownloadUrl, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
+			var response = await http.GetAsync(fileDownloadInfo.DownloadUrl, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
 			response.EnsureSuccessStatusCode();
 
 			await using var fileStream = new FileStream(filePath, FileMode.CreateNew, FileAccess.Write, FileShare.Read);
 			await using var responseStream = await response.Content.ReadAsStreamAsync(cancellationToken);
 
-			using var streamCopier = new MinecraftServerDownloadStreamCopier(progressCallback, info.Size.Bytes);
+			using var streamCopier = new MinecraftServerDownloadStreamCopier(progressCallback, fileDownloadInfo.Size.Bytes);
 			downloadedFileHash = await streamCopier.Copy(responseStream, fileStream, cancellationToken);
 		} catch (OperationCanceledException) {
 			throw;
@@ -129,8 +118,8 @@ sealed class MinecraftServerExecutableDownloader {
 			throw StopProcedureException.Instance;
 		}
 
-		if (!downloadedFileHash.Equals(info.Hash)) {
-			Logger.Error("Downloaded server executable has mismatched SHA1 hash. Expected {Expected}, got {Actual}.", info.Hash, downloadedFileHash);
+		if (!downloadedFileHash.Equals(fileDownloadInfo.Hash)) {
+			Logger.Error("Downloaded server executable has mismatched SHA1 hash. Expected {Expected}, got {Actual}.", fileDownloadInfo.Hash, downloadedFileHash);
 			throw StopProcedureException.Instance;
 		}
 	}

Agent/Phantom.Agent.Minecraft/Server/MinecraftServerExecutables.cs

@@ -1,33 +1,37 @@
 using System.Text.RegularExpressions;
+using Phantom.Common.Data.Minecraft;
 using Phantom.Common.Logging;
-using Phantom.Common.Minecraft;
 using Phantom.Utils.IO;
 using Serilog;
 
 namespace Phantom.Agent.Minecraft.Server;
 
-public sealed partial class MinecraftServerExecutables : IDisposable {
+public sealed partial class MinecraftServerExecutables {
 	private static readonly ILogger Logger = PhantomLogger.Create<MinecraftServerExecutables>();
 
 	[GeneratedRegex(@"[^a-zA-Z0-9_\-\.]", RegexOptions.Compiled)]
 	private static partial Regex VersionFolderSanitizeRegex();
 
 	private readonly string basePath;
-	private readonly MinecraftVersions minecraftVersions = new ();
 	private readonly Dictionary<string, MinecraftServerExecutableDownloader> runningDownloadersByVersion = new ();
 
 	public MinecraftServerExecutables(string basePath) {
 		this.basePath = basePath;
 	}
 
-	internal async Task<string?> DownloadAndGetPath(string version, EventHandler<DownloadProgressEventArgs> progressEventHandler, CancellationToken cancellationToken) {
-		string serverExecutableFolderPath = Path.Combine(basePath, VersionFolderSanitizeRegex().Replace(version, "_"));
+	internal async Task<string?> DownloadAndGetPath(FileDownloadInfo? fileDownloadInfo, string minecraftVersion, EventHandler<DownloadProgressEventArgs> progressEventHandler, CancellationToken cancellationToken) {
+		string serverExecutableFolderPath = Path.Combine(basePath, VersionFolderSanitizeRegex().Replace(minecraftVersion, "_"));
 		string serverExecutableFilePath = Path.Combine(serverExecutableFolderPath, "server.jar");
 
 		if (File.Exists(serverExecutableFilePath)) {
 			return serverExecutableFilePath;
 		}
 
+		if (fileDownloadInfo == null) {
+			Logger.Error("Unable to download server executable for version {Version} because no download info was provided.", minecraftVersion);
+			return null;
+		}
+
 		try {
 			Directories.Create(serverExecutableFolderPath, Chmod.URWX_GRX);
 		} catch (Exception e) {
@@ -39,26 +43,22 @@ public sealed partial class MinecraftServerExecutables : IDisposable {
 		MinecraftServerExecutableDownloadListener listener = new (progressEventHandler, cancellationToken);
 
 		lock (this) {
-			if (runningDownloadersByVersion.TryGetValue(version, out downloader)) {
-				Logger.Information("A download for server version {Version} is already running, waiting for it to finish...", version);
+			if (runningDownloadersByVersion.TryGetValue(minecraftVersion, out downloader)) {
+				Logger.Information("A download for server version {Version} is already running, waiting for it to finish...", minecraftVersion);
 				downloader.Register(listener);
 			}
 			else {
-				downloader = new MinecraftServerExecutableDownloader(minecraftVersions, version, serverExecutableFilePath, listener);
+				downloader = new MinecraftServerExecutableDownloader(fileDownloadInfo, minecraftVersion, serverExecutableFilePath, listener);
 				downloader.Completed += (_, _) => {
 					lock (this) {
-						runningDownloadersByVersion.Remove(version);
+						runningDownloadersByVersion.Remove(minecraftVersion);
 					}
 				};
 
-				runningDownloadersByVersion[version] = downloader;
+				runningDownloadersByVersion[minecraftVersion] = downloader;
 			}
 		}
 
 		return await downloader.Task.WaitAsync(cancellationToken);
 	}
-
-	public void Dispose() {
-		minecraftVersions.Dispose();
-	}
 }

Agent/Phantom.Agent.Minecraft/Server/ServerStatusProtocol.cs

@@ -84,7 +84,7 @@ public sealed class ServerStatusProtocol {
 				return null;
 			}
 			
-			logger.Verbose("Detected {OnlinePlayerCount} online player(s).", onlinePlayerCount);
+			logger.Debug("Detected {OnlinePlayerCount} online player(s).", onlinePlayerCount);
 			return onlinePlayerCount;
 		} finally {
 			ArrayPool<byte>.Shared.Return(messageBuffer);

Agent/Phantom.Agent.Rpc/RpcLauncher.cs

@@ -69,7 +69,7 @@ public sealed class RpcLauncher : RpcRuntime<ClientSocket> {
 		} catch (OperationCanceledException) {
 			// Ignore.
 		} finally {
-			logger.Verbose("ZeroMQ client stopped receiving messages.");
+			logger.Debug("ZeroMQ client stopped receiving messages.");
 
 			disconnectSemaphore.Wait(CancellationToken.None);
 			keepAliveLoop.Cancel();

Agent/Phantom.Agent.Services/Backups/BackupArchiver.cs

@@ -44,7 +44,7 @@ sealed class BackupArchiver {
 		return false;
 	}
 
-	public async Task ArchiveWorld(BackupCreationResult.Builder resultBuilder) {
+	public async Task<string?> ArchiveWorld(BackupCreationResult.Builder resultBuilder) {
 		string guid = instanceProperties.InstanceGuid.ToString();
 		string currentDateTime = DateTime.Now.ToString("yyyyMMdd-HHmmss");
 		string backupFolderPath = Path.Combine(destinationBasePath, guid);
@@ -53,7 +53,7 @@ sealed class BackupArchiver {
 		if (File.Exists(backupFilePath)) {
 			resultBuilder.Kind = BackupCreationResultKind.BackupFileAlreadyExists;
 			logger.Warning("Skipping backup, file already exists: {File}", backupFilePath);
-			return;
+			return null;
 		}
 		
 		try {
@@ -61,18 +61,16 @@ sealed class BackupArchiver {
 		} catch (Exception e) {
 			resultBuilder.Kind = BackupCreationResultKind.CouldNotCreateBackupFolder;
 			logger.Error(e, "Could not create backup folder: {Folder}", backupFolderPath);
-			return;
+			return null;
 		}
 
 		string temporaryFolderPath = Path.Combine(temporaryBasePath, guid + "_" + currentDateTime);
 		if (!await CopyWorldAndCreateTarArchive(temporaryFolderPath, backupFilePath, resultBuilder)) {
-			return;
+			return null;
 		}
 		
-		var compressedFilePath = await BackupCompressor.Compress(backupFilePath, cancellationToken);
-		if (compressedFilePath == null) {
-			resultBuilder.Warnings |= BackupCreationWarnings.CouldNotCompressWorldArchive;
-		}
+		logger.Debug("Created world backup: {FilePath}", backupFilePath);
+		return backupFilePath;
 	}
 
 	private async Task<bool> CopyWorldAndCreateTarArchive(string temporaryFolderPath, string backupFilePath, BackupCreationResult.Builder resultBuilder) {
@@ -137,7 +135,7 @@ sealed class BackupArchiver {
 		foreach (FileInfo file in sourceFolder.EnumerateFiles()) {
 			var filePath = relativePath.Add(file.Name);
 			if (IsFileSkipped(filePath)) {
-				logger.Verbose("Skipping file: {File}", string.Join('/', filePath));
+				logger.Debug("Skipping file: {File}", string.Join('/', filePath));
 				continue;
 			}
 
@@ -152,7 +150,7 @@ sealed class BackupArchiver {
 		foreach (DirectoryInfo directory in sourceFolder.EnumerateDirectories()) {
 			var folderPath = relativePath.Add(directory.Name);
 			if (IsFolderSkipped(folderPath)) {
-				logger.Verbose("Skipping folder: {Folder}", string.Join('/', folderPath));
+				logger.Debug("Skipping folder: {Folder}", string.Join('/', folderPath));
 				continue;
 			}
 			

Agent/Phantom.Agent.Services/Backups/BackupCompressor.cs

@@ -1,15 +1,16 @@
-using System.Diagnostics;
-using Phantom.Common.Logging;
+using Phantom.Common.Logging;
+using Phantom.Utils.Runtime;
 using Serilog;
 
 namespace Phantom.Agent.Services.Backups; 
 
 static class BackupCompressor {
 	private static ILogger Logger { get; } = PhantomLogger.Create(nameof(BackupCompressor));
+	private static ILogger ZstdLogger { get; } = PhantomLogger.Create(nameof(BackupCompressor), "Zstd");
 	
-	private const int Quality = 10;
-	private const int Memory = 26;
-	private const int Threads = 3;
+	private const string Quality = "-10";
+	private const string Memory = "--long=26";
+	private const string Threads = "-T3";
 	
 	public static async Task<string?> Compress(string sourceFilePath, CancellationToken cancellationToken) {
 		if (sourceFilePath.Contains('"')) {
@@ -39,65 +40,30 @@ static class BackupCompressor {
 			return false;
 		}
 
-		var startInfo = new ProcessStartInfo {
+		var launcher = new ProcessConfigurator {
 			FileName = "zstd",
 			WorkingDirectory = workingDirectory,
-			Arguments = $"-{Quality} --long={Memory} -T{Threads} -c --rm --no-progress -c -o \"{destinationFilePath}\" -- \"{sourceFilePath}\"",
-			RedirectStandardOutput = true,
-			RedirectStandardError = true
+			ArgumentList = {
+				Quality,
+				Memory,
+				Threads,
+				"-c",
+				"--rm",
+				"--no-progress",
+				"-c",
+				"-o", destinationFilePath,
+				"--", sourceFilePath
+			}
 		};
 
-		using var process = new Process { StartInfo = startInfo };
-		process.OutputDataReceived += OnZstdProcessOutput;
-		process.ErrorDataReceived += OnZstdProcessOutput;
-
-		try {
-			process.Start();
-			process.BeginOutputReadLine();
-			process.BeginErrorReadLine();
-		} catch (Exception e) {
-			Logger.Error(e, "Caught exception launching zstd process.");
+		static void OnZstdOutput(object? sender, Process.Output output) {
+			if (!string.IsNullOrWhiteSpace(output.Line)) {
+				ZstdLogger.Debug("[Output] {Line}", output.Line);
+			}
 		}
 
-		try {
-			await process.WaitForExitAsync(cancellationToken);
-		} catch (OperationCanceledException) {
-			await TryKillProcess(process);
-			return false;
-		} catch (Exception e) {
-			Logger.Error(e, "Caught exception waiting for zstd process to exit.");
-			return false;
-		}
-
-		if (!process.HasExited) {
-			await TryKillProcess(process);
-			return false;
-		}
-
-		if (process.ExitCode != 0) {
-			Logger.Error("Zstd process exited with code {ExitCode}.", process.ExitCode);
-			return false;
-		}
-
-		return true;
-	}
-
-	private static void OnZstdProcessOutput(object sender, DataReceivedEventArgs e) {
-		if (!string.IsNullOrWhiteSpace(e.Data)) {
-			Logger.Verbose("[Zstd] {Line}", e.Data);
-		}
-	}
-
-	private static async Task TryKillProcess(Process process) {
-		CancellationTokenSource timeout = new CancellationTokenSource(TimeSpan.FromSeconds(1));
-
-		try {
-			process.Kill();
-			await process.WaitForExitAsync(timeout.Token);
-		} catch (OperationCanceledException) {
-			Logger.Error("Timed out waiting for killed zstd process to exit.");
-		} catch (Exception e) {
-			Logger.Error(e, "Caught exception killing zstd process.");
-		}
+		var process = new OneShotProcess(ZstdLogger, launcher);
+		process.OutputReceived += OnZstdOutput;
+		return await process.Run(cancellationToken);
 	}
 }

Agent/Phantom.Agent.Services/Backups/BackupManager.cs

@@ -1,13 +1,11 @@
-using System.Text.RegularExpressions;
-using Phantom.Agent.Minecraft.Command;
-using Phantom.Agent.Minecraft.Instance;
+using Phantom.Agent.Minecraft.Instance;
 using Phantom.Common.Data.Backups;
 using Phantom.Common.Logging;
 using Serilog;
 
 namespace Phantom.Agent.Services.Backups;
 
-sealed partial class BackupManager {
+sealed class BackupManager {
 	private readonly string destinationBasePath;
 	private readonly string temporaryBasePath;
 
@@ -16,9 +14,9 @@ sealed partial class BackupManager {
 		this.temporaryBasePath = Path.Combine(agentFolders.TemporaryFolderPath, "backups");
 	}
 
-	public async Task<BackupCreationResult> CreateBackup(string loggerName, InstanceSession session, CancellationToken cancellationToken) {
+	public async Task<BackupCreationResult> CreateBackup(string loggerName, InstanceProcess process, CancellationToken cancellationToken) {
 		try {
-			if (!await session.BackupSemaphore.Wait(TimeSpan.FromSeconds(1), cancellationToken)) {
+			if (!await process.BackupSemaphore.Wait(TimeSpan.FromSeconds(1), cancellationToken)) {
 				return new BackupCreationResult(BackupCreationResultKind.BackupAlreadyRunning);
 			}
 		} catch (ObjectDisposedException) {
@@ -28,9 +26,9 @@ sealed partial class BackupManager {
 		}
 
 		try {
-			return await new BackupCreator(destinationBasePath, temporaryBasePath, loggerName, session, cancellationToken).CreateBackup();
+			return await new BackupCreator(destinationBasePath, temporaryBasePath, loggerName, process, cancellationToken).CreateBackup();
 		} finally {
-			session.BackupSemaphore.Release();
+			process.BackupSemaphore.Release();
 		}
 	}
 
@@ -39,62 +37,53 @@ sealed partial class BackupManager {
 		private readonly string temporaryBasePath;
 		private readonly string loggerName;
 		private readonly ILogger logger;
-		private readonly InstanceSession session;
-		private readonly BackupCommandListener listener;
+		private readonly InstanceProcess process;
 		private readonly CancellationToken cancellationToken;
 
-		public BackupCreator(string destinationBasePath, string temporaryBasePath, string loggerName, InstanceSession session, CancellationToken cancellationToken) {
+		public BackupCreator(string destinationBasePath, string temporaryBasePath, string loggerName, InstanceProcess process, CancellationToken cancellationToken) {
 			this.destinationBasePath = destinationBasePath;
 			this.temporaryBasePath = temporaryBasePath;
 			this.loggerName = loggerName;
 			this.logger = PhantomLogger.Create<BackupManager>(loggerName);
-			this.session = session;
-			this.listener = new BackupCommandListener(logger);
+			this.process = process;
 			this.cancellationToken = cancellationToken;
 		}
 
 		public async Task<BackupCreationResult> CreateBackup() {
 			logger.Information("Backup started.");
-			session.AddOutputListener(listener.OnOutput, maxLinesToReadFromHistory: 0);
-			try {
-				var resultBuilder = new BackupCreationResult.Builder();
 			
-				await RunBackupProcedure(resultBuilder);
+			var resultBuilder = new BackupCreationResult.Builder();
+			string? backupFilePath;
 			
-				var result = resultBuilder.Build();
-				if (result.Kind == BackupCreationResultKind.Success) {
-					var warningCount = result.Warnings.Count();
-					if (warningCount == 0) {
-						logger.Information("Backup finished successfully.");
-					}
-					else {
-						logger.Warning("Backup finished with {Warnings} warning(s).", warningCount);
-					}
-				}
-				else {
-					logger.Warning("Backup failed: {Reason}", result.Kind.ToSentence());
-				}
-				
-				return result;
-			} finally {
-				session.RemoveOutputListener(listener.OnOutput);
+			using (var dispatcher = new BackupServerCommandDispatcher(logger, process, cancellationToken)) {
+				backupFilePath = await CreateWorldArchive(dispatcher, resultBuilder);
 			}
+			
+			if (backupFilePath != null) {
+				await CompressWorldArchive(backupFilePath, resultBuilder);
+			}
+			
+			var result = resultBuilder.Build();
+			LogBackupResult(result);
+			return result;
 		}
 
-		private async Task RunBackupProcedure(BackupCreationResult.Builder resultBuilder) {
+		private async Task<string?> CreateWorldArchive(BackupServerCommandDispatcher dispatcher, BackupCreationResult.Builder resultBuilder) {
 			try {
-				await DisableAutomaticSaving();
-				await SaveAllChunks();
-				await new BackupArchiver(destinationBasePath, temporaryBasePath, loggerName, session.InstanceProperties, cancellationToken).ArchiveWorld(resultBuilder);
+				await dispatcher.DisableAutomaticSaving();
+				await dispatcher.SaveAllChunks();
+				return await new BackupArchiver(destinationBasePath, temporaryBasePath, loggerName, process.InstanceProperties, cancellationToken).ArchiveWorld(resultBuilder);
 			} catch (OperationCanceledException) {
 				resultBuilder.Kind = BackupCreationResultKind.BackupCancelled;
 				logger.Warning("Backup creation was cancelled.");
+				return null;
 			} catch (Exception e) {
 				resultBuilder.Kind = BackupCreationResultKind.UnknownError;
 				logger.Error(e, "Caught exception while creating an instance backup.");
+				return null;
 			} finally {
 				try {
-					await EnableAutomaticSaving();
+					await dispatcher.EnableAutomaticSaving();
 				} catch (OperationCanceledException) {
 					// ignore
 				} catch (Exception e) {
@@ -104,66 +93,25 @@ sealed partial class BackupManager {
 			}
 		}
 
-		private async Task DisableAutomaticSaving() {
-			await session.SendCommand(MinecraftCommand.SaveOff, cancellationToken);
-			await listener.AutomaticSavingDisabled.Task.WaitAsync(cancellationToken);
+		private async Task CompressWorldArchive(string filePath, BackupCreationResult.Builder resultBuilder) {
+			var compressedFilePath = await BackupCompressor.Compress(filePath, cancellationToken);
+			if (compressedFilePath == null) {
+				resultBuilder.Warnings |= BackupCreationWarnings.CouldNotCompressWorldArchive;
+			}
 		}
 
-		private async Task SaveAllChunks() {
-			// TODO Try if not flushing and waiting a few seconds before flushing reduces lag.
-			await session.SendCommand(MinecraftCommand.SaveAll(flush: true), cancellationToken);
-			await listener.SavedTheGame.Task.WaitAsync(cancellationToken);
-		}
-
-		private async Task EnableAutomaticSaving() {
-			await session.SendCommand(MinecraftCommand.SaveOn, cancellationToken);
-			await listener.AutomaticSavingEnabled.Task.WaitAsync(cancellationToken);
-		}
-	}
-	
-	private sealed partial class BackupCommandListener {
-		[GeneratedRegex(@"^\[(?:.*?)\] \[Server thread/INFO\]: (.*?)$", RegexOptions.NonBacktracking)]
-		private static partial Regex ServerThreadInfoRegex();
-
-		private readonly ILogger logger;
-
-		public BackupCommandListener(ILogger logger) {
-			this.logger = logger;
-		}
-
-		public TaskCompletionSource AutomaticSavingDisabled { get; } = new ();
-		public TaskCompletionSource SavedTheGame { get; } = new ();
-		public TaskCompletionSource AutomaticSavingEnabled { get; } = new ();
-
-		public void OnOutput(object? sender, string? line) {
-			if (line == null) {
+		private void LogBackupResult(BackupCreationResult result) {
+			if (result.Kind != BackupCreationResultKind.Success) {
+				logger.Warning("Backup failed: {Reason}", result.Kind.ToSentence());
 				return;
 			}
 			
-			var match = ServerThreadInfoRegex().Match(line);
-			if (!match.Success) {
-				return;
+			var warningCount = result.Warnings.Count();
+			if (warningCount > 0) {
+				logger.Warning("Backup finished with {Warnings} warning(s).", warningCount);
 			}
-
-			string info = match.Groups[1].Value;
-
-			if (!AutomaticSavingDisabled.Task.IsCompleted) {
-				if (info == "Automatic saving is now disabled") {
-					logger.Verbose("Detected that automatic saving is disabled.");
-					AutomaticSavingDisabled.SetResult();
-				}
-			}
-			else if (!SavedTheGame.Task.IsCompleted) {
-				if (info == "Saved the game") {
-					logger.Verbose("Detected that the game is saved.");
-					SavedTheGame.SetResult();
-				}
-			}
-			else if (!AutomaticSavingEnabled.Task.IsCompleted) {
-				if (info == "Automatic saving is now enabled") {
-					logger.Verbose("Detected that automatic saving is enabled.");
-					AutomaticSavingEnabled.SetResult();
-				}
+			else {
+				logger.Information("Backup finished successfully.");
 			}
 		}
 	}

Agent/Phantom.Agent.Services/Backups/BackupScheduler.cs

@@ -14,17 +14,17 @@ sealed class BackupScheduler : CancellableBackgroundTask {
 
 	private readonly string loggerName;
 	private readonly BackupManager backupManager;
-	private readonly InstanceSession session;
+	private readonly InstanceProcess process;
 	private readonly int serverPort;
 	private readonly ServerStatusProtocol serverStatusProtocol;
 	private readonly ManualResetEventSlim serverOutputWhileWaitingForOnlinePlayers = new ();
 	
 	public event EventHandler<BackupCreationResult>? BackupCompleted; 
 
-	public BackupScheduler(TaskManager taskManager, BackupManager backupManager, InstanceSession session, int serverPort, string loggerName) : base(PhantomLogger.Create<BackupScheduler>(loggerName), taskManager, "Backup scheduler for " + loggerName) {
+	public BackupScheduler(TaskManager taskManager, BackupManager backupManager, InstanceProcess process, int serverPort, string loggerName) : base(PhantomLogger.Create<BackupScheduler>(loggerName), taskManager, "Backup scheduler for " + loggerName) {
 		this.loggerName = loggerName;
 		this.backupManager = backupManager;
-		this.session = session;
+		this.process = process;
 		this.serverPort = serverPort;
 		this.serverStatusProtocol = new ServerStatusProtocol(loggerName);
 	}
@@ -50,13 +50,13 @@ sealed class BackupScheduler : CancellableBackgroundTask {
 	}
 
 	private async Task<BackupCreationResult> CreateBackup() {
-		return await backupManager.CreateBackup(loggerName, session, CancellationToken.None);
+		return await backupManager.CreateBackup(loggerName, process, CancellationToken.None);
 	}
 
 	private async Task WaitForOnlinePlayers() {
 		bool needsToLogOfflinePlayersMessage = true;
 		
-		session.AddOutputListener(ServerOutputListener, maxLinesToReadFromHistory: 0);
+		process.AddOutputListener(ServerOutputListener, maxLinesToReadFromHistory: 0);
 		try {
 			while (!CancellationToken.IsCancellationRequested) {
 				serverOutputWhileWaitingForOnlinePlayers.Reset();
@@ -79,18 +79,18 @@ sealed class BackupScheduler : CancellableBackgroundTask {
 
 				await Task.Delay(TimeSpan.FromSeconds(10), CancellationToken);
 				
-				Logger.Verbose("Waiting for server output before checking for online players again...");
+				Logger.Debug("Waiting for server output before checking for online players again...");
 				await serverOutputWhileWaitingForOnlinePlayers.WaitHandle.WaitOneAsync(CancellationToken);
 			}
 		} finally {
-			session.RemoveOutputListener(ServerOutputListener);
+			process.RemoveOutputListener(ServerOutputListener);
 		}
 	}
 
 	private void ServerOutputListener(object? sender, string line) {
 		if (!serverOutputWhileWaitingForOnlinePlayers.IsSet) {
 			serverOutputWhileWaitingForOnlinePlayers.Set();
-			Logger.Verbose("Detected server output, signalling to check for online players again.");
+			Logger.Debug("Detected server output, signalling to check for online players again.");
 		}
 	}
 }

Agent/Phantom.Agent.Services/Backups/BackupServerCommandDispatcher.cs

@@ -0,0 +1,80 @@
+using System.Text.RegularExpressions;
+using Phantom.Agent.Minecraft.Command;
+using Phantom.Agent.Minecraft.Instance;
+using Phantom.Utils.Runtime;
+using Serilog;
+
+namespace Phantom.Agent.Services.Backups;
+
+sealed partial class BackupServerCommandDispatcher : IDisposable {
+	[GeneratedRegex(@"^\[(?:.*?)\] \[Server thread/INFO\]: (.*?)$", RegexOptions.NonBacktracking)]
+	private static partial Regex ServerThreadInfoRegex();
+
+	private readonly ILogger logger;
+	private readonly InstanceProcess process;
+	private readonly CancellationToken cancellationToken;
+
+	private readonly TaskCompletionSource automaticSavingDisabled = Tasks.CreateCompletionSource();
+	private readonly TaskCompletionSource savedTheGame = Tasks.CreateCompletionSource();
+	private readonly TaskCompletionSource automaticSavingEnabled = Tasks.CreateCompletionSource();
+
+	public BackupServerCommandDispatcher(ILogger logger, InstanceProcess process, CancellationToken cancellationToken) {
+		this.logger = logger;
+		this.process = process;
+		this.cancellationToken = cancellationToken;
+
+		this.process.AddOutputListener(OnOutput, maxLinesToReadFromHistory: 0);
+	}
+
+	void IDisposable.Dispose() {
+		process.RemoveOutputListener(OnOutput);
+	}
+
+	public async Task DisableAutomaticSaving() {
+		await process.SendCommand(MinecraftCommand.SaveOff, cancellationToken);
+		await automaticSavingDisabled.Task.WaitAsync(cancellationToken);
+	}
+
+	public async Task SaveAllChunks() {
+		// TODO Try if not flushing and waiting a few seconds before flushing reduces lag.
+		await process.SendCommand(MinecraftCommand.SaveAll(flush: true), cancellationToken);
+		await savedTheGame.Task.WaitAsync(cancellationToken);
+	}
+
+	public async Task EnableAutomaticSaving() {
+		await process.SendCommand(MinecraftCommand.SaveOn, cancellationToken);
+		await automaticSavingEnabled.Task.WaitAsync(cancellationToken);
+	}
+
+	private void OnOutput(object? sender, string? line) {
+		if (line == null) {
+			return;
+		}
+
+		var match = ServerThreadInfoRegex().Match(line);
+		if (!match.Success) {
+			return;
+		}
+
+		string info = match.Groups[1].Value;
+
+		if (!automaticSavingDisabled.Task.IsCompleted) {
+			if (info == "Automatic saving is now disabled") {
+				logger.Debug("Detected that automatic saving is disabled.");
+				automaticSavingDisabled.SetResult();
+			}
+		}
+		else if (!savedTheGame.Task.IsCompleted) {
+			if (info == "Saved the game") {
+				logger.Debug("Detected that the game is saved.");
+				savedTheGame.SetResult();
+			}
+		}
+		else if (!automaticSavingEnabled.Task.IsCompleted) {
+			if (info == "Automatic saving is now enabled") {
+				logger.Debug("Detected that automatic saving is enabled.");
+				automaticSavingEnabled.SetResult();
+			}
+		}
+	}
+}

Agent/Phantom.Agent.Services/Instances/Instance.cs

@@ -18,15 +18,10 @@ sealed class Instance : IDisposable {
 		return prefix[..prefix.IndexOf('-')] + "/" + Interlocked.Increment(ref loggerSequenceId);
 	}
 
-	public static Instance Create(InstanceConfiguration configuration, InstanceServices services, BaseLauncher launcher) {
-		var instance = new Instance(configuration, services, launcher);
-		instance.SetStatus(instance.currentStatus);
-		return instance;
-	}
+	private InstanceServices Services { get; }
 	
 	public InstanceConfiguration Configuration { get; private set; }
-	private InstanceServices Services { get; }
-	private BaseLauncher Launcher { get; set; }
+	private IServerLauncher Launcher { get; set; }
 
 	private readonly string shortName;
 	private readonly ILogger logger;
@@ -41,29 +36,41 @@ sealed class Instance : IDisposable {
 	
 	public event EventHandler? IsRunningChanged; 
 
-	private Instance(InstanceConfiguration configuration, InstanceServices services, BaseLauncher launcher) {
+	public Instance(InstanceServices services, InstanceConfiguration configuration, IServerLauncher launcher) {
 		this.shortName = GetLoggerName(configuration.InstanceGuid);
 		this.logger = PhantomLogger.Create<Instance>(shortName);
 
-		this.Configuration = configuration;
 		this.Services = services;
+		this.Configuration = configuration;
 		this.Launcher = launcher;
 		
 		this.currentState = new InstanceNotRunningState();
 		this.currentStatus = InstanceStatus.NotRunning;
 	}
 
-	private void SetStatus(IInstanceStatus status) {
+	private void TryUpdateStatus(string taskName, Func<Task> getUpdateTask) {
 		int myStatusUpdateCounter = Interlocked.Increment(ref statusUpdateCounter);
 		
-		Services.TaskManager.Run("Report status of instance " + shortName + " as " + status.GetType().Name, async () => {
+		Services.TaskManager.Run(taskName, async () => {
 			if (myStatusUpdateCounter == statusUpdateCounter) {
-				currentStatus = status;
-				await ServerMessaging.Send(new ReportInstanceStatusMessage(Configuration.InstanceGuid, status));
+				await getUpdateTask();
 			}
 		});
 	}
 
+	public void ReportLastStatus() {
+		TryUpdateStatus("Report last status of instance " + shortName, async () => {
+			await ServerMessaging.Send(new ReportInstanceStatusMessage(Configuration.InstanceGuid, currentStatus));
+		});
+	}
+
+	private void ReportAndSetStatus(IInstanceStatus status) {
+		TryUpdateStatus("Report status of instance " + shortName + " as " + status.GetType().Name, async () => {
+			currentStatus = status;
+			await ServerMessaging.Send(new ReportInstanceStatusMessage(Configuration.InstanceGuid, status));
+		});
+	}
+
 	private void ReportEvent(IInstanceEvent instanceEvent) {
 		var message = new ReportInstanceEventMessage(Guid.NewGuid(), DateTime.UtcNow, Configuration.InstanceGuid, instanceEvent);
 		Services.TaskManager.Run("Report event for instance " + shortName, async () => await ServerMessaging.Send(message));
@@ -78,7 +85,7 @@ sealed class Instance : IDisposable {
 			disposable.Dispose();
 		}
 
-		logger.Verbose("Transitioning instance state to: {NewState}", newState.GetType().Name);
+		logger.Debug("Transitioning instance state to: {NewState}", newState.GetType().Name);
 		
 		var wasRunning = IsRunning;
 		currentState = newState;
@@ -94,7 +101,7 @@ sealed class Instance : IDisposable {
 		return newStateAndResult.Result;
 	}
 
-	public async Task Reconfigure(InstanceConfiguration configuration, BaseLauncher launcher, CancellationToken cancellationToken) {
+	public async Task Reconfigure(InstanceConfiguration configuration, IServerLauncher launcher, CancellationToken cancellationToken) {
 		await stateTransitioningActionSemaphore.WaitAsync(cancellationToken);
 		try {
 			Configuration = configuration;
@@ -147,7 +154,7 @@ sealed class Instance : IDisposable {
 		private readonly Instance instance;
 		private readonly CancellationToken shutdownCancellationToken;
 		
-		public InstanceContextImpl(Instance instance, CancellationToken shutdownCancellationToken) : base(instance.Configuration, instance.Launcher, instance.Services) {
+		public InstanceContextImpl(Instance instance, CancellationToken shutdownCancellationToken) : base(instance.Services, instance.Configuration, instance.Launcher) {
 			this.instance = instance;
 			this.shutdownCancellationToken = shutdownCancellationToken;
 		}
@@ -156,7 +163,7 @@ sealed class Instance : IDisposable {
 		public override string ShortName => instance.shortName;
 
 		public override void SetStatus(IInstanceStatus newStatus) {
-			instance.SetStatus(newStatus);
+			instance.ReportAndSetStatus(newStatus);
 		}
 
 		public override void ReportEvent(IInstanceEvent instanceEvent) {
@@ -170,12 +177,12 @@ sealed class Instance : IDisposable {
 				
 				if (!instance.IsRunning) {
 					// Only InstanceSessionManager is allowed to transition an instance out of a non-running state.
-					instance.logger.Verbose("Cancelled state transition to {State} because instance is not running.", state.GetType().Name);
+					instance.logger.Debug("Cancelled state transition to {State} because instance is not running.", state.GetType().Name);
 					return;
 				}
 				
 				if (state is not InstanceNotRunningState && shutdownCancellationToken.IsCancellationRequested) {
-					instance.logger.Verbose("Cancelled state transition to {State} due to Agent shutdown.", state.GetType().Name);
+					instance.logger.Debug("Cancelled state transition to {State} due to Agent shutdown.", state.GetType().Name);
 					return;
 				}
 

Agent/Phantom.Agent.Services/Instances/InstanceContext.cs

@@ -6,17 +6,17 @@ using Serilog;
 namespace Phantom.Agent.Services.Instances;
 
 abstract class InstanceContext {
-	public InstanceConfiguration Configuration { get; }
-	public BaseLauncher Launcher { get; }
 	public InstanceServices Services { get; }
+	public InstanceConfiguration Configuration { get; }
+	public IServerLauncher Launcher { get; }
 	
 	public abstract ILogger Logger { get; }
 	public abstract string ShortName { get; }
 
-	protected InstanceContext(InstanceConfiguration configuration, BaseLauncher launcher, InstanceServices services) {
+	protected InstanceContext(InstanceServices services, InstanceConfiguration configuration, IServerLauncher launcher) {
+		Services = services;
 		Configuration = configuration;
 		Launcher = launcher;
-		Services = services;
 	}
 
 	public abstract void SetStatus(IInstanceStatus newStatus);

Agent/Phantom.Agent.Services/Instances/InstanceSessionManager.cs

@@ -27,7 +27,6 @@ sealed class InstanceSessionManager : IDisposable {
 	private readonly AgentInfo agentInfo;
 	private readonly string basePath;
 
-	private readonly MinecraftServerExecutables minecraftServerExecutables;
 	private readonly InstanceServices instanceServices;
 	private readonly Dictionary<Guid, Instance> instances = new ();
 
@@ -38,11 +37,12 @@ sealed class InstanceSessionManager : IDisposable {
 	public InstanceSessionManager(AgentInfo agentInfo, AgentFolders agentFolders, JavaRuntimeRepository javaRuntimeRepository, TaskManager taskManager, BackupManager backupManager) {
 		this.agentInfo = agentInfo;
 		this.basePath = agentFolders.InstancesFolderPath;
-		this.minecraftServerExecutables = new MinecraftServerExecutables(agentFolders.ServerExecutableFolderPath);
 		this.shutdownCancellationToken = shutdownCancellationTokenSource.Token;
 		
+		var minecraftServerExecutables = new MinecraftServerExecutables(agentFolders.ServerExecutableFolderPath);
 		var launchServices = new LaunchServices(minecraftServerExecutables, javaRuntimeRepository);
 		var portManager = new PortManager(agentInfo.AllowedServerPorts, agentInfo.AllowedRconPorts);
+		
 		this.instanceServices = new InstanceServices(taskManager, portManager, backupManager, launchServices);
 	}
 
@@ -71,7 +71,7 @@ sealed class InstanceSessionManager : IDisposable {
 		});
 	}
 
-	public async Task<InstanceActionResult<ConfigureInstanceResult>> Configure(InstanceConfiguration configuration) {
+	public async Task<InstanceActionResult<ConfigureInstanceResult>> Configure(InstanceConfiguration configuration, InstanceLaunchProperties launchProperties, bool launchNow, bool alwaysReportStatus) {
 		return await AcquireSemaphoreAndRun(async () => {
 			var instanceGuid = configuration.InstanceGuid;
 			var instanceFolder = Path.Combine(basePath, instanceGuid.ToString());
@@ -90,22 +90,33 @@ sealed class InstanceSessionManager : IDisposable {
 				configuration.JvmArguments,
 				instanceFolder,
 				configuration.MinecraftVersion,
-				new ServerProperties(configuration.ServerPort, configuration.RconPort)
+				new ServerProperties(configuration.ServerPort, configuration.RconPort),
+				launchProperties
 			);
 
-			BaseLauncher launcher = new VanillaLauncher(properties);
+			IServerLauncher launcher = configuration.MinecraftServerKind switch {
+				MinecraftServerKind.Vanilla => new VanillaLauncher(properties),
+				MinecraftServerKind.Fabric  => new FabricLauncher(properties),
+				_                           => InvalidLauncher.Instance
+			};
 
 			if (instances.TryGetValue(instanceGuid, out var instance)) {
 				await instance.Reconfigure(configuration, launcher, shutdownCancellationToken);
 				Logger.Information("Reconfigured instance \"{Name}\" (GUID {Guid}).", configuration.InstanceName, configuration.InstanceGuid);
+				
+				if (alwaysReportStatus) {
+					instance.ReportLastStatus();
+				}
 			}
 			else {
-				instances[instanceGuid] = instance = Instance.Create(configuration, instanceServices, launcher);
-				instance.IsRunningChanged += OnInstanceIsRunningChanged;
+				instances[instanceGuid] = instance = new Instance(instanceServices, configuration, launcher);
 				Logger.Information("Created instance \"{Name}\" (GUID {Guid}).", configuration.InstanceName, configuration.InstanceGuid);
+				
+				instance.ReportLastStatus();
+				instance.IsRunningChanged += OnInstanceIsRunningChanged;
 			}
 
-			if (configuration.LaunchAutomatically) {
+			if (launchNow) {
 				await LaunchInternal(instance);
 			}
 
@@ -179,7 +190,6 @@ sealed class InstanceSessionManager : IDisposable {
 
 	public void Dispose() {
 		DisposeAllInstances();
-		minecraftServerExecutables.Dispose();
 		shutdownCancellationTokenSource.Dispose();
 		semaphore.Dispose();
 	}

Agent/Phantom.Agent.Services/Instances/Sessions/InstanceSession.cs

@@ -0,0 +1,28 @@
+using Phantom.Agent.Minecraft.Instance;
+
+namespace Phantom.Agent.Services.Instances.Sessions; 
+
+sealed class InstanceSession : IDisposable {
+	private readonly InstanceProcess process;
+	private readonly InstanceContext context;
+	private readonly InstanceLogSender logSender;
+
+	public InstanceSession(InstanceProcess process, InstanceContext context) {
+		this.process = process;
+		this.context = context;
+		this.logSender = new InstanceLogSender(context.Services.TaskManager, context.Configuration.InstanceGuid, context.ShortName);
+		
+		this.process.AddOutputListener(SessionOutput);
+	}
+	
+	private void SessionOutput(object? sender, string line) {
+		context.Logger.Debug("[Server] {Line}", line);
+		logSender.Enqueue(line);
+	}
+	
+	public void Dispose() {
+		logSender.Stop();
+		process.Dispose();
+		context.Services.PortManager.Release(context.Configuration);
+	}
+}

Agent/Phantom.Agent.Services/Instances/States/InstanceLaunchingState.cs

@@ -1,6 +1,7 @@
 using Phantom.Agent.Minecraft.Instance;
 using Phantom.Agent.Minecraft.Launcher;
 using Phantom.Agent.Minecraft.Server;
+using Phantom.Agent.Services.Instances.Sessions;
 using Phantom.Common.Data.Instance;
 using Phantom.Common.Data.Minecraft;
 using Phantom.Common.Data.Replies;
@@ -24,7 +25,7 @@ sealed class InstanceLaunchingState : IInstanceState, IDisposable {
 		launchTask.ContinueWith(OnLaunchFailure, CancellationToken.None, TaskContinuationOptions.NotOnRanToCompletion, TaskScheduler.Default);
 	}
 
-	private async Task<InstanceSession> DoLaunch() {
+	private async Task<InstanceProcess> DoLaunch() {
 		var cancellationToken = cancellationTokenSource.Token;
 		cancellationToken.ThrowIfCancellationRequested();
 
@@ -47,6 +48,9 @@ sealed class InstanceLaunchingState : IInstanceState, IDisposable {
 		else if (launchResult is LaunchResult.CouldNotDownloadMinecraftServer) {
 			throw new LaunchFailureException(InstanceLaunchFailReason.CouldNotDownloadMinecraftServer, "Session failed to launch, could not download Minecraft server.");
 		}
+		else if (launchResult is LaunchResult.CouldNotPrepareMinecraftServerLauncher) {
+			throw new LaunchFailureException(InstanceLaunchFailReason.CouldNotPrepareMinecraftServerLauncher, "Session failed to launch, could not prepare Minecraft server launcher.");
+		}
 		else if (launchResult is LaunchResult.CouldNotConfigureMinecraftServer) {
 			throw new LaunchFailureException(InstanceLaunchFailReason.CouldNotConfigureMinecraftServer, "Session failed to launch, could not configure Minecraft server.");
 		}
@@ -59,29 +63,35 @@ sealed class InstanceLaunchingState : IInstanceState, IDisposable {
 		}
 
 		context.SetStatus(InstanceStatus.Launching);
-		return launchSuccess.Session;
+		return launchSuccess.Process;
 	}
 
-	private void OnLaunchSuccess(Task<InstanceSession> task) {
+	private void OnLaunchSuccess(Task<InstanceProcess> task) {
 		context.TransitionState(() => {
+			context.ReportEvent(InstanceEvent.LaunchSucceded);
+			
+			var process = task.Result;
+			var session = new InstanceSession(process, context);
+			
 			if (cancellationTokenSource.IsCancellationRequested) {
-				context.Services.PortManager.Release(context.Configuration);
-				return (new InstanceNotRunningState(), InstanceStatus.NotRunning);
+				return (new InstanceStoppingState(context, process, session), InstanceStatus.Stopping);
 			}
 			else {
-				context.ReportEvent(InstanceEvent.LaunchSucceded);
-				return (new InstanceRunningState(context, task.Result), null);
+				return (new InstanceRunningState(context, process, session), null);
 			}
 		});
 	}
 
 	private void OnLaunchFailure(Task task) {
-		if (task.Exception is { InnerException: LaunchFailureException e }) {
-			context.Logger.Error(e.LogMessage);
-			context.SetLaunchFailedStatusAndReportEvent(e.Reason);
-		}
-		else {
-			context.SetLaunchFailedStatusAndReportEvent(InstanceLaunchFailReason.UnknownError);
+		if (task.IsFaulted) {
+			if (task.Exception is { InnerException: LaunchFailureException e }) {
+				context.Logger.Error(e.LogMessage);
+				context.SetLaunchFailedStatusAndReportEvent(e.Reason);
+			}
+			else {
+				context.Logger.Error(task.Exception, "Caught exception while launching instance.");
+				context.SetLaunchFailedStatusAndReportEvent(InstanceLaunchFailReason.UnknownError);
+			}
 		}
 
 		context.Services.PortManager.Release(context.Configuration);

Agent/Phantom.Agent.Services/Instances/States/InstanceRunningState.cs

@@ -1,6 +1,7 @@
 using Phantom.Agent.Minecraft.Command;
 using Phantom.Agent.Minecraft.Instance;
 using Phantom.Agent.Services.Backups;
+using Phantom.Agent.Services.Instances.Sessions;
 using Phantom.Common.Data.Backups;
 using Phantom.Common.Data.Instance;
 using Phantom.Common.Data.Minecraft;
@@ -10,30 +11,27 @@ namespace Phantom.Agent.Services.Instances.States;
 
 sealed class InstanceRunningState : IInstanceState {
 	private readonly InstanceContext context;
-	private readonly InstanceSession session;
-	private readonly InstanceLogSender logSender;
+	private readonly InstanceProcess process;
 	private readonly BackupScheduler backupScheduler;
-	private readonly SessionObjects sessionObjects;
+	private readonly RunningSessionDisposer runningSessionDisposer;
 	
 	private readonly CancellationTokenSource delayedStopCancellationTokenSource = new ();
 	private bool stateOwnsDelayedStopCancellationTokenSource = true;
 	private bool isStopping;
 
-	public InstanceRunningState(InstanceContext context, InstanceSession session) {
+	public InstanceRunningState(InstanceContext context, InstanceProcess process, InstanceSession session) {
 		this.context = context;
-		this.session = session;
-		this.logSender = new InstanceLogSender(context.Services.TaskManager, context.Configuration.InstanceGuid, context.ShortName);
-		this.backupScheduler = new BackupScheduler(context.Services.TaskManager, context.Services.BackupManager, session, context.Configuration.ServerPort, context.ShortName);
+		this.process = process;
+		this.backupScheduler = new BackupScheduler(context.Services.TaskManager, context.Services.BackupManager, process, context.Configuration.ServerPort, context.ShortName);
 		this.backupScheduler.BackupCompleted += OnScheduledBackupCompleted;
-		this.sessionObjects = new SessionObjects(this);
+		this.runningSessionDisposer = new RunningSessionDisposer(this, session);
 	}
 
 	public void Initialize() {
-		session.AddOutputListener(SessionOutput);
-		session.SessionEnded += SessionEnded;
+		process.Ended += ProcessEnded;
 		
-		if (session.HasEnded) {
-			if (sessionObjects.Dispose()) {
+		if (process.HasEnded) {
+			if (runningSessionDisposer.Dispose()) {
 				context.Logger.Warning("Session ended immediately after it was started.");
 				context.ReportEvent(InstanceEvent.Stopped);
 				context.Services.TaskManager.Run("Transition state of instance " + context.ShortName + " to not running", () => context.TransitionState(new InstanceNotRunningState(), InstanceStatus.Failed(InstanceLaunchFailReason.UnknownError)));
@@ -45,13 +43,8 @@ sealed class InstanceRunningState : IInstanceState {
 		}
 	}
 
-	private void SessionOutput(object? sender, string line) {
-		context.Logger.Verbose("[Server] {Line}", line);
-		logSender.Enqueue(line);
-	}
-
-	private void SessionEnded(object? sender, EventArgs e) {
-		if (!sessionObjects.Dispose()) {
+	private void ProcessEnded(object? sender, EventArgs e) {
+		if (!runningSessionDisposer.Dispose()) {
 			return;
 		}
 
@@ -88,9 +81,9 @@ sealed class InstanceRunningState : IInstanceState {
 	}
 
 	private IInstanceState PrepareStoppedState() {
-		session.SessionEnded -= SessionEnded;
+		process.Ended -= ProcessEnded;
 		backupScheduler.Stop();
-		return new InstanceStoppingState(context, session, sessionObjects);
+		return new InstanceStoppingState(context, process, runningSessionDisposer);
 	}
 
 	private void CancelDelayedStop() {
@@ -117,7 +110,7 @@ sealed class InstanceRunningState : IInstanceState {
 				}
 			}
 		} catch (OperationCanceledException) {
-			context.Logger.Verbose("Cancelled delayed stop.");
+			context.Logger.Debug("Cancelled delayed stop.");
 			return;
 		} catch (ObjectDisposedException) {
 			return;
@@ -134,7 +127,7 @@ sealed class InstanceRunningState : IInstanceState {
 	public async Task<bool> SendCommand(string command, CancellationToken cancellationToken) {
 		try {
 			context.Logger.Information("Sending command: {Command}", command);
-			await session.SendCommand(command, cancellationToken);
+			await process.SendCommand(command, cancellationToken);
 			return true;
 		} catch (OperationCanceledException) {
 			return false;
@@ -148,12 +141,14 @@ sealed class InstanceRunningState : IInstanceState {
 		context.ReportEvent(new InstanceBackupCompletedEvent(e.Kind, e.Warnings));
 	}
 
-	public sealed class SessionObjects {
+	private sealed class RunningSessionDisposer : IDisposable {
 		private readonly InstanceRunningState state;
+		private readonly InstanceSession session;
 		private bool isDisposed;
 
-		public SessionObjects(InstanceRunningState state) {
+		public RunningSessionDisposer(InstanceRunningState state, InstanceSession session) {
 			this.state = state;
+			this.session = session;
 		}
 
 		public bool Dispose() {
@@ -172,10 +167,12 @@ sealed class InstanceRunningState : IInstanceState {
 				state.CancelDelayedStop();
 			}
 			
-			state.logSender.Stop();
-			state.session.Dispose();
-			state.context.Services.PortManager.Release(state.context.Configuration);
+			session.Dispose();
 			return true;
 		}
+
+		void IDisposable.Dispose() {
+			Dispose();
+		}
 	}
 }

Agent/Phantom.Agent.Services/Instances/States/InstanceStoppingState.cs

@@ -9,13 +9,13 @@ namespace Phantom.Agent.Services.Instances.States;
 
 sealed class InstanceStoppingState : IInstanceState, IDisposable {
 	private readonly InstanceContext context;
-	private readonly InstanceSession session;
-	private readonly InstanceRunningState.SessionObjects sessionObjects;
+	private readonly InstanceProcess process;
+	private readonly IDisposable sessionDisposer;
 
-	public InstanceStoppingState(InstanceContext context, InstanceSession session, InstanceRunningState.SessionObjects sessionObjects) {
-		this.sessionObjects = sessionObjects;
-		this.session = session;
+	public InstanceStoppingState(InstanceContext context, InstanceProcess process, IDisposable sessionDisposer) {
 		this.context = context;
+		this.process = process;
+		this.sessionDisposer = sessionDisposer;
 	}
 
 	public void Initialize() {
@@ -27,9 +27,9 @@ sealed class InstanceStoppingState : IInstanceState, IDisposable {
 	private async Task DoStop() {
 		try {
 			// Do not release the semaphore after this point.
-			if (!await session.BackupSemaphore.CancelAndWait(TimeSpan.FromSeconds(1))) {
+			if (!await process.BackupSemaphore.CancelAndWait(TimeSpan.FromSeconds(1))) {
 				context.Logger.Information("Waiting for backup to finish...");
-				await session.BackupSemaphore.CancelAndWait(Timeout.InfiniteTimeSpan);
+				await process.BackupSemaphore.CancelAndWait(Timeout.InfiniteTimeSpan);
 			}
 			
 			context.Logger.Information("Sending stop command...");
@@ -47,10 +47,10 @@ sealed class InstanceStoppingState : IInstanceState, IDisposable {
 	private async Task DoSendStopCommand() {
 		using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
 		try {
-			await session.SendCommand(MinecraftCommand.Stop, timeout.Token);
+			await process.SendCommand(MinecraftCommand.Stop, timeout.Token);
 		} catch (OperationCanceledException) {
 			// ignore
-		} catch (ObjectDisposedException e) when (e.ObjectName == typeof(Process).FullName && session.HasEnded) {
+		} catch (ObjectDisposedException e) when (e.ObjectName == typeof(Process).FullName && process.HasEnded) {
 			// ignore
 		} catch (Exception e) {
 			context.Logger.Warning(e, "Caught exception while sending stop command.");
@@ -60,11 +60,11 @@ sealed class InstanceStoppingState : IInstanceState, IDisposable {
 	private async Task DoWaitForSessionToEnd() {
 		using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(55));
 		try {
-			await session.WaitForExit(timeout.Token);
+			await process.WaitForExit(timeout.Token);
 		} catch (OperationCanceledException) {
 			try {
 				context.Logger.Warning("Waiting timed out, killing session...");
-				session.Kill();
+				process.Kill();
 			} catch (Exception e) {
 				context.Logger.Error(e, "Caught exception while killing session.");
 			}
@@ -84,6 +84,6 @@ sealed class InstanceStoppingState : IInstanceState, IDisposable {
 	}
 
 	public void Dispose() {
-		sessionObjects.Dispose();
+		sessionDisposer.Dispose();
 	}
 }

Agent/Phantom.Agent.Services/Rpc/MessageListener.cs

@@ -1,4 +1,5 @@
 using Phantom.Agent.Rpc;
+using Phantom.Common.Data.Instance;
 using Phantom.Common.Data.Replies;
 using Phantom.Common.Logging;
 using Phantom.Common.Messages;
@@ -26,12 +27,15 @@ public sealed class MessageListener : IMessageToAgentListener {
 	public async Task<NoReply> HandleRegisterAgentSuccess(RegisterAgentSuccessMessage message) {
 		Logger.Information("Agent authentication successful.");
 
-		foreach (var instanceInfo in message.InitialInstances) {
-			var result = await agent.InstanceSessionManager.Configure(instanceInfo);
-			if (!result.Is(ConfigureInstanceResult.Success)) {
-				Logger.Fatal("Unable to configure instance \"{Name}\" (GUID {Guid}), shutting down.", instanceInfo.InstanceName, instanceInfo.InstanceGuid);
+		void ShutdownAfterConfigurationFailed(InstanceConfiguration configuration) {
+			Logger.Fatal("Unable to configure instance \"{Name}\" (GUID {Guid}), shutting down.", configuration.InstanceName, configuration.InstanceGuid);
+			shutdownTokenSource.Cancel();
+		}
 		
-				shutdownTokenSource.Cancel();
+		foreach (var configureInstanceMessage in message.InitialInstanceConfigurations) {
+			var result = await HandleConfigureInstance(configureInstanceMessage, alwaysReportStatus: true);
+			if (!result.Is(ConfigureInstanceResult.Success)) {
+				ShutdownAfterConfigurationFailed(configureInstanceMessage.Configuration);
 				return NoReply.Instance;
 			}
 		}
@@ -55,8 +59,12 @@ public sealed class MessageListener : IMessageToAgentListener {
 		return Task.FromResult(NoReply.Instance);
 	}
 	
+	private Task<InstanceActionResult<ConfigureInstanceResult>> HandleConfigureInstance(ConfigureInstanceMessage message, bool alwaysReportStatus) {
+		return agent.InstanceSessionManager.Configure(message.Configuration, message.LaunchProperties, message.LaunchNow, alwaysReportStatus);
+	}
+	
 	public async Task<InstanceActionResult<ConfigureInstanceResult>> HandleConfigureInstance(ConfigureInstanceMessage message) {
-		return await agent.InstanceSessionManager.Configure(message.Configuration);
+		return await HandleConfigureInstance(message, alwaysReportStatus: false);
 	}
 
 	public async Task<InstanceActionResult<LaunchInstanceResult>> HandleLaunchInstance(LaunchInstanceMessage message) {

Common/Phantom.Common.Data/Instance/InstanceConfiguration.cs

@@ -15,6 +15,5 @@ public sealed partial record InstanceConfiguration(
 	[property: MemoryPackOrder(6)] MinecraftServerKind MinecraftServerKind,
 	[property: MemoryPackOrder(7)] RamAllocationUnits MemoryAllocation,
 	[property: MemoryPackOrder(8)] Guid JavaRuntimeGuid,
-	[property: MemoryPackOrder(9)] ImmutableArray<string> JvmArguments,
-	[property: MemoryPackOrder(10)] bool LaunchAutomatically
+	[property: MemoryPackOrder(9)] ImmutableArray<string> JvmArguments
 );

Common/Phantom.Common.Data/Instance/InstanceLaunchFailReason.cs

@@ -10,22 +10,24 @@ public enum InstanceLaunchFailReason : byte {
 	InvalidJvmArguments,
 	CouldNotDownloadMinecraftServer,
 	CouldNotConfigureMinecraftServer,
+	CouldNotPrepareMinecraftServerLauncher,
 	CouldNotStartMinecraftServer
 }
 
 public static class InstanceLaunchFailReasonExtensions {
 	public static string ToSentence(this InstanceLaunchFailReason reason) {
 		return reason switch {
-			InstanceLaunchFailReason.ServerPortNotAllowed             => "Server port not allowed.",
-			InstanceLaunchFailReason.ServerPortAlreadyInUse           => "Server port already in use.",
-			InstanceLaunchFailReason.RconPortNotAllowed               => "Rcon port not allowed.",
-			InstanceLaunchFailReason.RconPortAlreadyInUse             => "Rcon port already in use.",
-			InstanceLaunchFailReason.JavaRuntimeNotFound              => "Java runtime not found.",
-			InstanceLaunchFailReason.InvalidJvmArguments              => "Invalid JVM arguments.",
-			InstanceLaunchFailReason.CouldNotDownloadMinecraftServer  => "Could not download Minecraft server.",
-			InstanceLaunchFailReason.CouldNotConfigureMinecraftServer => "Could not configure Minecraft server.",
-			InstanceLaunchFailReason.CouldNotStartMinecraftServer     => "Could not start Minecraft server.",
-			_                                                         => "Unknown error."
+			InstanceLaunchFailReason.ServerPortNotAllowed                   => "Server port not allowed.",
+			InstanceLaunchFailReason.ServerPortAlreadyInUse                 => "Server port already in use.",
+			InstanceLaunchFailReason.RconPortNotAllowed                     => "Rcon port not allowed.",
+			InstanceLaunchFailReason.RconPortAlreadyInUse                   => "Rcon port already in use.",
+			InstanceLaunchFailReason.JavaRuntimeNotFound                    => "Java runtime not found.",
+			InstanceLaunchFailReason.InvalidJvmArguments                    => "Invalid JVM arguments.",
+			InstanceLaunchFailReason.CouldNotDownloadMinecraftServer        => "Could not download Minecraft server.",
+			InstanceLaunchFailReason.CouldNotConfigureMinecraftServer       => "Could not configure Minecraft server.",
+			InstanceLaunchFailReason.CouldNotPrepareMinecraftServerLauncher => "Could not prepare Minecraft server launcher.",
+			InstanceLaunchFailReason.CouldNotStartMinecraftServer           => "Could not start Minecraft server.",
+			_                                                               => "Unknown error."
 		};
 	}
 }

Common/Phantom.Common.Data/Instance/InstanceLaunchProperties.cs

@@ -0,0 +1,9 @@
+using MemoryPack;
+using Phantom.Common.Data.Minecraft;
+
+namespace Phantom.Common.Data.Instance; 
+
+[MemoryPackable]
+public sealed partial record InstanceLaunchProperties(
+	[property: MemoryPackOrder(0)] FileDownloadInfo? ServerDownloadInfo
+);

Common/Phantom.Common.Data/Minecraft/FileDownloadInfo.cs

@@ -0,0 +1,30 @@
+using MemoryPack;
+using Phantom.Utils.Cryptography;
+using Phantom.Utils.IO;
+
+namespace Phantom.Common.Data.Minecraft; 
+
+[MemoryPackable]
+public sealed partial class FileDownloadInfo {
+	[MemoryPackOrder(0)]
+	public string DownloadUrl { get; }
+	
+	[MemoryPackOrder(1)]
+	[MemoryPackInclude]
+	private readonly string hash;
+	
+	[MemoryPackIgnore]
+	public Sha1String Hash => Sha1String.FromString(hash);
+	
+	[MemoryPackOrder(2)]
+	public FileSize Size { get; }
+	
+	public FileDownloadInfo(string downloadUrl, Sha1String hash, FileSize size) : this(downloadUrl, hash.ToString(), size) {}
+
+	[MemoryPackConstructor]
+	private FileDownloadInfo(string downloadUrl, string hash, FileSize size) {
+		this.DownloadUrl = downloadUrl;
+		this.hash = hash;
+		this.Size = size;
+	}
+}

Common/Phantom.Common.Data/Minecraft/MinecraftServerKind.cs

@@ -1,5 +1,6 @@
 namespace Phantom.Common.Data.Minecraft; 
 
 public enum MinecraftServerKind : ushort {
-	Vanilla = 1
+	Vanilla = 1,
+	Fabric = 2
 }

Common/Phantom.Common.Logging/Phantom.Common.Logging.csproj

@@ -8,6 +8,7 @@
   
   <ItemGroup>
     <PackageReference Include="Serilog" />
+    <PackageReference Include="Serilog.Sinks.Async" />
     <PackageReference Include="Serilog.Sinks.Console" />
   </ItemGroup>
 

Common/Phantom.Common.Logging/PhantomLogger.cs

@@ -18,7 +18,7 @@ public static class PhantomLogger {
 		       .MinimumLevel.Override("Microsoft.EntityFrameworkCore.Database.Command", DefaultLogLevel.Coerce(LogEventLevel.Warning))
 		       .Filter.ByExcluding(static e => e.Exception is OperationCanceledException)
 		       .Enrich.FromLogContext()
-		       .WriteTo.Console(outputTemplate: template, formatProvider: CultureInfo.InvariantCulture, theme: AnsiConsoleTheme.Literate)
+		       .WriteTo.Async(c => c.Console(outputTemplate: template, formatProvider: CultureInfo.InvariantCulture, theme: AnsiConsoleTheme.Literate))
 		       .CreateLogger();
 	}
 

Common/Phantom.Common.Messages/ToAgent/ConfigureInstanceMessage.cs

@@ -6,7 +6,9 @@ namespace Phantom.Common.Messages.ToAgent;
 
 [MemoryPackable]
 public sealed partial record ConfigureInstanceMessage(
-	[property: MemoryPackOrder(0)] InstanceConfiguration Configuration
+	[property: MemoryPackOrder(0)] InstanceConfiguration Configuration,
+	[property: MemoryPackOrder(1)] InstanceLaunchProperties LaunchProperties,
+	[property: MemoryPackOrder(2)] bool LaunchNow = false
 ) : IMessageToAgent<InstanceActionResult<ConfigureInstanceResult>> {
 	public Task<InstanceActionResult<ConfigureInstanceResult>> Accept(IMessageToAgentListener listener) {
 		return listener.HandleConfigureInstance(this);

Common/Phantom.Common.Messages/ToAgent/RegisterAgentSuccessMessage.cs

@@ -1,13 +1,12 @@
 using System.Collections.Immutable;
 using MemoryPack;
-using Phantom.Common.Data.Instance;
 using Phantom.Utils.Rpc.Message;
 
 namespace Phantom.Common.Messages.ToAgent;
 
 [MemoryPackable]
 public sealed partial record RegisterAgentSuccessMessage(
-	[property: MemoryPackOrder(0)] ImmutableArray<InstanceConfiguration> InitialInstances
+	[property: MemoryPackOrder(0)] ImmutableArray<ConfigureInstanceMessage> InitialInstanceConfigurations
 ) : IMessageToAgent {
 	public Task<NoReply> Accept(IMessageToAgentListener listener) {
 		return listener.HandleRegisterAgentSuccess(this);

Common/Phantom.Common.Minecraft/MinecraftServerExecutableInfo.cs

@@ -1,10 +0,0 @@
-using Phantom.Utils.Cryptography;
-using Phantom.Utils.IO;
-
-namespace Phantom.Common.Minecraft; 
-
-public sealed record MinecraftServerExecutableInfo(
-	string DownloadUrl,
-	Sha1String Hash,
-	FileSize Size
-);

Common/Phantom.Common.Minecraft/Phantom.Common.Minecraft.csproj

@@ -6,11 +6,4 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
   
-  <ItemGroup>
-    <ProjectReference Include="..\..\Utils\Phantom.Utils.IO\Phantom.Utils.IO.csproj" />
-    <ProjectReference Include="..\..\Utils\Phantom.Utils.Runtime\Phantom.Utils.Runtime.csproj" />
-    <ProjectReference Include="..\Phantom.Common.Data\Phantom.Common.Data.csproj" />
-    <ProjectReference Include="..\Phantom.Common.Logging\Phantom.Common.Logging.csproj" />
-  </ItemGroup>
-  
 </Project>

Packages.props

@@ -20,6 +20,7 @@
   <ItemGroup>
     <PackageReference Update="Serilog"               Version="2.12.0" />
     <PackageReference Update="Serilog.AspNetCore"    Version="6.1.0" />
+    <PackageReference Update="Serilog.Sinks.Async"   Version="1.5.0" />
     <PackageReference Update="Serilog.Sinks.Console" Version="4.1.0" />
   </ItemGroup>
   

PhantomPanel.sln

@@ -36,6 +36,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Phantom.Server.Database", "
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Phantom.Server.Database.Postgres", "Server\Phantom.Server.Database.Postgres\Phantom.Server.Database.Postgres.csproj", "{81625B4A-3DB6-48BD-A739-D23DA02107D1}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Phantom.Server.Minecraft", "Server\Phantom.Server.Minecraft\Phantom.Server.Minecraft.csproj", "{4B3B73E6-48DD-4846-87FD-DFB86619B67C}"
+EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Phantom.Server.Rpc", "Server\Phantom.Server.Rpc\Phantom.Server.Rpc.csproj", "{79312D72-44E0-431D-96A4-4C0A066B9671}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Phantom.Server.Services", "Server\Phantom.Server.Services\Phantom.Server.Services.csproj", "{90F0F1B1-EB0A-49C9-8DF0-1153A87F77C9}"
@@ -118,6 +120,10 @@ Global
 		{81625B4A-3DB6-48BD-A739-D23DA02107D1}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{81625B4A-3DB6-48BD-A739-D23DA02107D1}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{81625B4A-3DB6-48BD-A739-D23DA02107D1}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4B3B73E6-48DD-4846-87FD-DFB86619B67C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4B3B73E6-48DD-4846-87FD-DFB86619B67C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4B3B73E6-48DD-4846-87FD-DFB86619B67C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4B3B73E6-48DD-4846-87FD-DFB86619B67C}.Release|Any CPU.Build.0 = Release|Any CPU
 		{79312D72-44E0-431D-96A4-4C0A066B9671}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{79312D72-44E0-431D-96A4-4C0A066B9671}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{79312D72-44E0-431D-96A4-4C0A066B9671}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -184,6 +190,7 @@ Global
 		{A0F1C595-96B6-4DBF-8C16-6B99223F8F35} = {8AC8FB6C-033A-4626-820F-ED0F908756B2}
 		{E3AD566F-384A-489A-A3BB-EA3BA400C18C} = {8AC8FB6C-033A-4626-820F-ED0F908756B2}
 		{81625B4A-3DB6-48BD-A739-D23DA02107D1} = {8AC8FB6C-033A-4626-820F-ED0F908756B2}
+		{4B3B73E6-48DD-4846-87FD-DFB86619B67C} = {8AC8FB6C-033A-4626-820F-ED0F908756B2}
 		{79312D72-44E0-431D-96A4-4C0A066B9671} = {8AC8FB6C-033A-4626-820F-ED0F908756B2}
 		{90F0F1B1-EB0A-49C9-8DF0-1153A87F77C9} = {8AC8FB6C-033A-4626-820F-ED0F908756B2}
 		{7CA2E5FE-E507-4DC6-930C-E18711A9F856} = {8AC8FB6C-033A-4626-820F-ED0F908756B2}

Server/Phantom.Server.Minecraft/MinecraftVersionApi.cs

@@ -1,5 +1,4 @@
 using System.Collections.Immutable;
-using System.Diagnostics;
 using System.Net.Http.Json;
 using System.Text.Json;
 using Phantom.Common.Data.Minecraft;
@@ -9,71 +8,39 @@ using Phantom.Utils.IO;
 using Phantom.Utils.Runtime;
 using Serilog;
 
-namespace Phantom.Common.Minecraft;
+namespace Phantom.Server.Minecraft;
 
-public sealed class MinecraftVersions : IDisposable {
-	private static readonly ILogger Logger = PhantomLogger.Create<MinecraftVersions>();
-	private static readonly TimeSpan CacheRetentionTime = TimeSpan.FromMinutes(10);
+sealed class MinecraftVersionApi : IDisposable {
+	private static readonly ILogger Logger = PhantomLogger.Create<MinecraftVersionApi>();
 	
 	private const string VersionManifestUrl = "https://launchermeta.mojang.com/mc/game/version_manifest.json";
 	
 	private readonly HttpClient http = new ();
 
-	private readonly Stopwatch cacheTimer = new ();
-	private readonly SemaphoreSlim cachedVersionsSemaphore = new (1, 1);
-
-	private ImmutableArray<MinecraftVersion>? cachedVersions;
-	private ImmutableArray<MinecraftVersion>? CachedVersionsUnlessExpired => cacheTimer.IsRunning && cacheTimer.Elapsed < CacheRetentionTime ? cachedVersions : null;
-
 	public void Dispose() {
 		http.Dispose();
-		cachedVersionsSemaphore.Dispose();
 	}
 
 	public async Task<ImmutableArray<MinecraftVersion>> GetVersions(CancellationToken cancellationToken) {
-		if (CachedVersionsUnlessExpired is {} earlyResult) {
-			return earlyResult;
-		}
-
-		try {
-			await cachedVersionsSemaphore.WaitAsync(cancellationToken);
-		} catch (OperationCanceledException) {
-			return ImmutableArray<MinecraftVersion>.Empty;
-		}
-
-		try {
-			if (CachedVersionsUnlessExpired is {} racedResult) {
-				return racedResult;
-			}
-
-			ImmutableArray<MinecraftVersion> versions = await FetchVersions(cancellationToken) ?? ImmutableArray<MinecraftVersion>.Empty;
-			Logger.Information("Refreshed Minecraft version cache, {Versions} version(s) found.", versions.Length);
-			
-			cachedVersions = versions;
-			cacheTimer.Restart();
-			return versions;
-		} finally {
-			cachedVersionsSemaphore.Release();
-		}
+		return await FetchVersions(cancellationToken) ?? ImmutableArray<MinecraftVersion>.Empty;
 	}
 	
 	private async Task<ImmutableArray<MinecraftVersion>?> FetchVersions(CancellationToken cancellationToken) {
 		return await FetchOrFailSilently(async () => {
-			var versionManifest = await FetchJson(http, VersionManifestUrl, "version manifest", cancellationToken);
+			var versionManifest = await FetchJson(VersionManifestUrl, "version manifest", cancellationToken);
 			return GetVersionsFromManifest(versionManifest);
 		});
 	}
 	
-	public async Task<MinecraftServerExecutableInfo?> GetServerExecutableInfo(string version, CancellationToken cancellationToken) {
-		return await FetchOrFailSilently(async () => {
-			var versions = await GetVersions(cancellationToken);
-			var versionObject = versions.FirstOrDefault(v => v.Id == version);
-			if (versionObject == null) {
-				Logger.Error("Version {Version} was not found in version manifest.", version);
-				return null;
-			}
+	public async Task<FileDownloadInfo?> GetServerExecutableInfo(ImmutableArray<MinecraftVersion> versions, string version, CancellationToken cancellationToken) {
+		var versionObject = versions.FirstOrDefault(v => v.Id == version);
+		if (versionObject == null) {
+			Logger.Error("Version {Version} was not found in version manifest.", version);
+			return null;
+		}
 		
-			var versionMetadata = await FetchJson(http, versionObject.MetadataUrl, "version metadata", cancellationToken);
+		return await FetchOrFailSilently(async () => {
+			var versionMetadata = await FetchJson(versionObject.MetadataUrl, "version metadata", cancellationToken);
 			return GetServerExecutableInfoFromMetadata(versionMetadata);
 		});
 	}
@@ -81,8 +48,6 @@ public sealed class MinecraftVersions : IDisposable {
 	private static async Task<T?> FetchOrFailSilently<T>(Func<Task<T?>> task) {
 		try {
 			return await task();
-		} catch (OperationCanceledException) {
-			return default;
 		} catch (StopProcedureException) {
 			return default;
 		} catch (Exception e) {
@@ -91,14 +56,12 @@ public sealed class MinecraftVersions : IDisposable {
 		}
 	}
 
-	private static async Task<JsonElement> FetchJson(HttpClient http, string url, string description, CancellationToken cancellationToken) {
-		Logger.Information("Fetching {Description} JSON from: {Url}", description, url);
+	private async Task<JsonElement> FetchJson(string url, string description, CancellationToken cancellationToken) {
+		Logger.Debug("Fetching {Description} JSON from: {Url}", description, url);
 
 		try {
 			return await http.GetFromJsonAsync<JsonElement>(url, cancellationToken);
-		} catch (OperationCanceledException) {
-			throw StopProcedureException.Instance;
-		}  catch (HttpRequestException e) {
+		} catch (HttpRequestException e) {
 			Logger.Error(e, "Unable to download {Description}.", description);
 			throw StopProcedureException.Instance;
 		} catch (Exception e) {
@@ -117,7 +80,7 @@ public sealed class MinecraftVersions : IDisposable {
 			} catch (StopProcedureException) {}
 		}
 
-		return foundVersions.ToImmutable();
+		return foundVersions.MoveToImmutable();
 	}
 
 	private static MinecraftVersion GetVersionFromManifestEntry(JsonElement versionElement) {
@@ -129,7 +92,7 @@ public sealed class MinecraftVersions : IDisposable {
 
 		var type = MinecraftVersionTypes.FromString(typeString);
 		if (type == MinecraftVersionType.Other) {
-			Logger.Verbose("Unknown version type: {Type} ({Version})", typeString, id);
+			Logger.Warning("Unknown version type: {Type} ({Version})", typeString, id);
 		}
 
 		JsonElement urlElement = GetJsonPropertyOrThrow(versionElement, "url", JsonValueKind.String, "version entry in version manifest");
@@ -148,7 +111,7 @@ public sealed class MinecraftVersions : IDisposable {
 		return new MinecraftVersion(id, type, url);
 	}
 
-	private static MinecraftServerExecutableInfo GetServerExecutableInfoFromMetadata(JsonElement versionMetadata) {
+	private static FileDownloadInfo GetServerExecutableInfoFromMetadata(JsonElement versionMetadata) {
 		JsonElement downloadsElement = GetJsonPropertyOrThrow(versionMetadata, "downloads", JsonValueKind.Object, "version metadata");
 		JsonElement serverElement = GetJsonPropertyOrThrow(downloadsElement, "server", JsonValueKind.Object, "downloads object in version metadata");
 		JsonElement urlElement = GetJsonPropertyOrThrow(serverElement, "url", JsonValueKind.String, "downloads.server object in version metadata");
@@ -182,7 +145,7 @@ public sealed class MinecraftVersions : IDisposable {
 			throw StopProcedureException.Instance;
 		}
 
-		return new MinecraftServerExecutableInfo(url, hash, new FileSize(size));
+		return new FileDownloadInfo(url, hash, new FileSize(size));
 	}
 
 	private static JsonElement GetJsonPropertyOrThrow(JsonElement parentElement, string propertyKey, JsonValueKind expectedKind, string location) {

Server/Phantom.Server.Minecraft/MinecraftVersions.cs

@@ -0,0 +1,75 @@
+using System.Collections.Immutable;
+using System.Diagnostics;
+using Phantom.Common.Data.Minecraft;
+using Phantom.Common.Logging;
+using Serilog;
+
+namespace Phantom.Server.Minecraft;
+
+public sealed class MinecraftVersions : IDisposable {
+	private static readonly ILogger Logger = PhantomLogger.Create<MinecraftVersions>();
+	private static readonly TimeSpan CacheRetentionTime = TimeSpan.FromMinutes(10);
+
+	private readonly MinecraftVersionApi api = new ();
+	private readonly Stopwatch cacheTimer = new ();
+	private readonly SemaphoreSlim cacheSemaphore = new (1, 1);
+
+	private bool IsCacheNotExpired => cacheTimer.IsRunning && cacheTimer.Elapsed < CacheRetentionTime;
+	
+	private ImmutableArray<MinecraftVersion>? cachedVersions;
+	private readonly Dictionary<string, FileDownloadInfo?> cachedServerExecutables = new ();
+
+	public void Dispose() {
+		api.Dispose();
+		cacheSemaphore.Dispose();
+	}
+
+	public async Task<ImmutableArray<MinecraftVersion>> GetVersions(CancellationToken cancellationToken) {
+		return await GetCachedObject(() => cachedVersions != null, () => cachedVersions.GetValueOrDefault(), v => cachedVersions = v, LoadVersions, cancellationToken);
+	}
+
+	private async Task<ImmutableArray<MinecraftVersion>> LoadVersions(CancellationToken cancellationToken) {
+		ImmutableArray<MinecraftVersion> versions = await api.GetVersions(cancellationToken);
+		Logger.Information("Refreshed Minecraft version cache, {Versions} version(s) found.", versions.Length);
+		return versions;
+	}
+
+	public async Task<FileDownloadInfo?> GetServerExecutableInfo(string version, CancellationToken cancellationToken) {
+		var versions = await GetVersions(cancellationToken);
+		return await GetCachedObject(() => cachedServerExecutables.ContainsKey(version), () => cachedServerExecutables[version], v => cachedServerExecutables[version] = v, ct => LoadServerExecutableInfo(versions, version, ct), cancellationToken);
+	}
+
+	private async Task<FileDownloadInfo?> LoadServerExecutableInfo(ImmutableArray<MinecraftVersion> versions, string version, CancellationToken cancellationToken) {
+		var info = await api.GetServerExecutableInfo(versions, version, cancellationToken);
+			
+		if (info == null) {
+			Logger.Information("Refreshed Minecraft {Version} server executable cache, no file found.", version);
+		}
+		else {
+			Logger.Information("Refreshed Minecraft {Version} server executable cache, found file: {Url}.", version, info.DownloadUrl);
+		}
+
+		return info;
+	}
+
+	private async Task<T> GetCachedObject<T>(Func<bool> isLoaded, Func<T> fieldGetter, Action<T> fieldSetter, Func<CancellationToken, Task<T>> fieldLoader, CancellationToken cancellationToken) {
+		if (IsCacheNotExpired && isLoaded()) {
+			return fieldGetter();
+		}
+
+		await cacheSemaphore.WaitAsync(cancellationToken);
+		try {
+			if (IsCacheNotExpired && isLoaded()) {
+				return fieldGetter();
+			}
+
+			T result = await fieldLoader(cancellationToken);
+			fieldSetter(result);
+			
+			cacheTimer.Restart();
+			return result;
+		} finally {
+			cacheSemaphore.Release();
+		}
+	}
+}

Server/Phantom.Server.Minecraft/Phantom.Server.Minecraft.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <ProjectReference Include="..\..\Common\Phantom.Common.Data\Phantom.Common.Data.csproj" />
+    <ProjectReference Include="..\..\Common\Phantom.Common.Logging\Phantom.Common.Logging.csproj" />
+    <ProjectReference Include="..\..\Utils\Phantom.Utils.Runtime\Phantom.Utils.Runtime.csproj" />
+  </ItemGroup>
+
+</Project>

Server/Phantom.Server.Rpc/RpcLauncher.cs

@@ -46,7 +46,7 @@ public sealed class RpcLauncher : RpcRuntime<ServerSocket> {
 
 		void OnConnectionClosed(object? sender, RpcClientConnectionClosedEventArgs e) {
 			clients.Remove(e.RoutingId);
-			logger.Verbose("Closed connection to {RoutingId}.", e.RoutingId);
+			logger.Debug("Closed connection to {RoutingId}.", e.RoutingId);
 		}
 
 		while (!cancellationToken.IsCancellationRequested) {

Server/Phantom.Server.Services/Agents/AgentManager.cs

@@ -82,7 +82,9 @@ public sealed class AgentManager {
 
 		Logger.Information("Registered agent \"{Name}\" (GUID {Guid}).", agent.Name, agent.Guid);
 
-		await connection.Send(new RegisterAgentSuccessMessage(instanceManager.GetInstanceConfigurationsForAgent(agent.Guid)));
+		var instanceConfigurations = await instanceManager.GetInstanceConfigurationsForAgent(agent.Guid);
+		await connection.Send(new RegisterAgentSuccessMessage(instanceConfigurations));
+		
 		return true;
 	}
 

Server/Phantom.Server.Services/Instances/AddOrEditInstanceResult.cs

@@ -5,17 +5,19 @@ public enum AddOrEditInstanceResult : byte {
 	Success,
 	InstanceNameMustNotBeEmpty,
 	InstanceMemoryMustNotBeZero,
+	MinecraftVersionDownloadInfoNotFound,
 	AgentNotFound
 }
 
 public static class AddOrEditInstanceResultExtensions {
 	public static string ToSentence(this AddOrEditInstanceResult reason) {
 		return reason switch {
-			AddOrEditInstanceResult.Success                     => "Success.",
-			AddOrEditInstanceResult.InstanceNameMustNotBeEmpty  => "Instance name must not be empty.",
-			AddOrEditInstanceResult.InstanceMemoryMustNotBeZero => "Memory must not be 0 MB.",
-			AddOrEditInstanceResult.AgentNotFound               => "Agent not found.",
-			_                                                   => "Unknown error."
+			AddOrEditInstanceResult.Success                              => "Success.",
+			AddOrEditInstanceResult.InstanceNameMustNotBeEmpty           => "Instance name must not be empty.",
+			AddOrEditInstanceResult.InstanceMemoryMustNotBeZero          => "Memory must not be 0 MB.",
+			AddOrEditInstanceResult.MinecraftVersionDownloadInfoNotFound => "Could not find download information for the selected Minecraft version.",
+			AddOrEditInstanceResult.AgentNotFound                        => "Agent not found.",
+			_                                                            => "Unknown error."
 		};
 	}
 }

Server/Phantom.Server.Services/Instances/Instance.cs

@@ -4,7 +4,8 @@ namespace Phantom.Server.Services.Instances;
 
 public sealed record Instance(
 	InstanceConfiguration Configuration,
-	IInstanceStatus Status
+	IInstanceStatus Status,
+	bool LaunchAutomatically
 ) {
-	internal Instance(InstanceConfiguration configuration) : this(configuration, InstanceStatus.Offline) {}
+	internal Instance(InstanceConfiguration configuration, bool launchAutomatically = false) : this(configuration, InstanceStatus.Offline, launchAutomatically) {}
 }

Server/Phantom.Server.Services/Instances/InstanceManager.cs

@@ -10,6 +10,7 @@ using Phantom.Common.Messages.ToAgent;
 using Phantom.Common.Minecraft;
 using Phantom.Server.Database;
 using Phantom.Server.Database.Entities;
+using Phantom.Server.Minecraft;
 using Phantom.Server.Services.Agents;
 using Phantom.Utils.Collections;
 using Phantom.Utils.Events;
@@ -26,12 +27,14 @@ public sealed class InstanceManager {
 
 	private readonly CancellationToken cancellationToken;
 	private readonly AgentManager agentManager;
+	private readonly MinecraftVersions minecraftVersions;
 	private readonly DatabaseProvider databaseProvider;
 	private readonly SemaphoreSlim modifyInstancesSemaphore = new (1, 1);
 
-	public InstanceManager(ServiceConfiguration configuration, AgentManager agentManager, DatabaseProvider databaseProvider) {
+	public InstanceManager(ServiceConfiguration configuration, AgentManager agentManager, MinecraftVersions minecraftVersions, DatabaseProvider databaseProvider) {
 		this.cancellationToken = configuration.CancellationToken;
 		this.agentManager = agentManager;
+		this.minecraftVersions = minecraftVersions;
 		this.databaseProvider = databaseProvider;
 	}
 
@@ -49,11 +52,10 @@ public sealed class InstanceManager {
 				entity.MinecraftServerKind,
 				entity.MemoryAllocation,
 				entity.JavaRuntimeGuid,
-				JvmArgumentsHelper.Split(entity.JvmArguments),
-				entity.LaunchAutomatically
+				JvmArgumentsHelper.Split(entity.JvmArguments)
 			);
 
-			var instance = new Instance(configuration);
+			var instance = new Instance(configuration, entity.LaunchAutomatically);
 			instances.ByGuid[instance.Configuration.InstanceGuid] = instance;
 		}
 	}
@@ -73,23 +75,29 @@ public sealed class InstanceManager {
 			return InstanceActionResult.Concrete(AddOrEditInstanceResult.InstanceMemoryMustNotBeZero);
 		}
 		
+		var serverExecutableInfo = await minecraftVersions.GetServerExecutableInfo(configuration.MinecraftVersion, cancellationToken);
+		if (serverExecutableInfo == null) {
+			return InstanceActionResult.Concrete(AddOrEditInstanceResult.MinecraftVersionDownloadInfoNotFound);
+		}
+
 		InstanceActionResult<AddOrEditInstanceResult> result;
 		bool isNewInstance;
 
 		await modifyInstancesSemaphore.WaitAsync(cancellationToken);
 		try {
-			var instance = new Instance(configuration);
-			instances.ByGuid.AddOrReplace(instance.Configuration.InstanceGuid, instance, out var oldInstance);
+			isNewInstance = !instances.ByGuid.TryReplace(configuration.InstanceGuid, instance => instance with { Configuration = configuration });
+			if (isNewInstance) {
+				instances.ByGuid.TryAdd(configuration.InstanceGuid, new Instance(configuration));
+			}
 
-			var reply = await agentManager.SendMessage<ConfigureInstanceMessage, InstanceActionResult<ConfigureInstanceResult>>(configuration.AgentGuid, new ConfigureInstanceMessage(configuration), TimeSpan.FromSeconds(10));
+			var message = new ConfigureInstanceMessage(configuration, new InstanceLaunchProperties(serverExecutableInfo));
+			var reply = await agentManager.SendMessage<ConfigureInstanceMessage, InstanceActionResult<ConfigureInstanceResult>>(configuration.AgentGuid, message, TimeSpan.FromSeconds(10));
 			
 			result = reply.DidNotReplyIfNull().Map(static result => result switch {
 				ConfigureInstanceResult.Success => AddOrEditInstanceResult.Success,
 				_                               => AddOrEditInstanceResult.UnknownError
 			});
 			
-			isNewInstance = oldInstance == null;
-			
 			if (result.Is(AddOrEditInstanceResult.Success)) {
 				using var scope = databaseProvider.CreateScope();
 				InstanceEntity entity = scope.Ctx.InstanceUpsert.Fetch(configuration.InstanceGuid);
@@ -103,7 +111,6 @@ public sealed class InstanceManager {
 				entity.MemoryAllocation = configuration.MemoryAllocation;
 				entity.JavaRuntimeGuid = configuration.JavaRuntimeGuid;
 				entity.JvmArguments = JvmArgumentsHelper.Join(configuration.JvmArguments);
-				entity.LaunchAutomatically = configuration.LaunchAutomatically;
 
 				await scope.Ctx.SaveChangesAsync(cancellationToken);
 			}
@@ -180,9 +187,7 @@ public sealed class InstanceManager {
 	private async Task SetInstanceShouldLaunchAutomatically(Guid instanceGuid, bool shouldLaunchAutomatically) {
 		await modifyInstancesSemaphore.WaitAsync(cancellationToken);
 		try {
-			instances.ByGuid.TryReplace(instanceGuid, instance => instance with {
-				Configuration = instance.Configuration with { LaunchAutomatically = shouldLaunchAutomatically }
-			});
+			instances.ByGuid.TryReplace(instanceGuid, instance => instance with { LaunchAutomatically = shouldLaunchAutomatically });
 
 			using var scope = databaseProvider.CreateScope();
 			var entity = await scope.Ctx.Instances.FindAsync(instanceGuid, cancellationToken);
@@ -199,8 +204,15 @@ public sealed class InstanceManager {
 		return await SendInstanceActionMessage<SendCommandToInstanceMessage, SendCommandToInstanceResult>(instanceGuid, new SendCommandToInstanceMessage(instanceGuid, command));
 	}
 
-	internal ImmutableArray<InstanceConfiguration> GetInstanceConfigurationsForAgent(Guid agentGuid) {
-		return instances.ByGuid.ValuesCopy.Select(static instance => instance.Configuration).Where(configuration => configuration.AgentGuid == agentGuid).ToImmutableArray();
+	internal async Task<ImmutableArray<ConfigureInstanceMessage>> GetInstanceConfigurationsForAgent(Guid agentGuid) {
+		var configurationMessages = ImmutableArray.CreateBuilder<ConfigureInstanceMessage>();
+		
+		foreach (var (configuration, _, launchAutomatically) in instances.ByGuid.ValuesCopy.Where(instance => instance.Configuration.AgentGuid == agentGuid)) {
+			var serverExecutableInfo = await minecraftVersions.GetServerExecutableInfo(configuration.MinecraftVersion, cancellationToken);
+			configurationMessages.Add(new ConfigureInstanceMessage(configuration, new InstanceLaunchProperties(serverExecutableInfo), launchAutomatically));
+		}
+
+		return configurationMessages.ToImmutable();
 	}
 
 	private sealed class ObservableInstances : ObservableState<ImmutableDictionary<Guid, Instance>> {

Server/Phantom.Server.Services/Phantom.Server.Services.csproj

@@ -16,6 +16,7 @@
     <ProjectReference Include="..\..\Utils\Phantom.Utils.Collections\Phantom.Utils.Collections.csproj" />
     <ProjectReference Include="..\..\Utils\Phantom.Utils.Events\Phantom.Utils.Events.csproj" />
     <ProjectReference Include="..\Phantom.Server.Database\Phantom.Server.Database.csproj" />
+    <ProjectReference Include="..\Phantom.Server.Minecraft\Phantom.Server.Minecraft.csproj" />
     <ProjectReference Include="..\Phantom.Server.Rpc\Phantom.Server.Rpc.csproj" />
   </ItemGroup>
 

Server/Phantom.Server.Services/Rpc/MessageToServerListener.cs

@@ -9,6 +9,7 @@ using Phantom.Server.Services.Agents;
 using Phantom.Server.Services.Events;
 using Phantom.Server.Services.Instances;
 using Phantom.Utils.Rpc.Message;
+using Phantom.Utils.Runtime;
 
 namespace Phantom.Server.Services.Rpc;
 
@@ -21,7 +22,7 @@ public sealed class MessageToServerListener : IMessageToServerListener {
 	private readonly InstanceLogManager instanceLogManager;
 	private readonly EventLog eventLog;
 
-	private readonly TaskCompletionSource<Guid> agentGuidWaiter = new ();
+	private readonly TaskCompletionSource<Guid> agentGuidWaiter = Tasks.CreateCompletionSource<Guid>();
 
 	public bool IsDisposed { get; private set; }
 

Server/Phantom.Server.Web.Identity/Authentication/PhantomLoginManager.cs

@@ -40,7 +40,7 @@ public sealed class PhantomLoginManager {
 		
 		var result = await signInManager.CheckPasswordSignInAsync(user, password, lockoutOnFailure: true);
 		if (result == SignInResult.Success) {
-			Logger.Verbose("Created login token for {Username}.", username);
+			Logger.Debug("Created login token for {Username}.", username);
 			
 			string token = TokenGenerator.Create(60);
 			loginStore.Add(token, user, password, returnUrl ?? string.Empty);

Server/Phantom.Server.Web.Identity/Authentication/PhantomLoginStore.cs

@@ -30,7 +30,7 @@ public sealed class PhantomLoginStore {
 
 				foreach (var (token, entry) in loginEntries) {
 					if (entry.IsExpired) {
-						Logger.Verbose("Expired login entry for {Username}.", entry.User.UserName);
+						Logger.Debug("Expired login entry for {Username}.", entry.User.UserName);
 						loginEntries.TryRemove(token, out _);
 					}
 				}
@@ -50,7 +50,7 @@ public sealed class PhantomLoginStore {
 		}
 
 		if (entry.IsExpired) {
-			Logger.Verbose("Expired login entry for {Username}.", entry.User.UserName);
+			Logger.Debug("Expired login entry for {Username}.", entry.User.UserName);
 			return null;
 		}
 		

Server/Phantom.Server.Web/Pages/Events.razor

@@ -4,15 +4,13 @@
 @using Phantom.Server.Services.Agents
 @using Phantom.Server.Services.Events
 @using Phantom.Server.Services.Instances
-@using Microsoft.AspNetCore.Identity
 @using Phantom.Server.Database.Enums
 @implements IDisposable
 @inject AgentManager AgentManager
 @inject EventLog EventLog
 @inject InstanceManager InstanceManager
-@inject UserManager<IdentityUser> UserManager
 
-<h1>Audit Log</h1>
+<h1>Event Log</h1>
 
 <table class="table">
   <thead>

Server/Phantom.Server.Web/Pages/Instances.razor

@@ -29,7 +29,7 @@
   </thead>
   @if (!instances.IsEmpty) {
     <tbody>
-      @foreach (var (configuration, status) in instances) {
+      @foreach (var (configuration, status, _) in instances) {
         var agentName = agentNames.TryGetValue(configuration.AgentGuid, out var name) ? name : string.Empty;
         var instanceGuid = configuration.InstanceGuid.ToString();
         <tr>

Server/Phantom.Server.Web/Shared/InstanceAddOrEditForm.razor

@@ -1,5 +1,6 @@
 @using Phantom.Common.Data.Minecraft
 @using Phantom.Common.Minecraft
+@using Phantom.Server.Minecraft
 @using Phantom.Server.Services.Agents
 @using Phantom.Server.Services.Audit
 @using Phantom.Server.Services.Instances
@@ -324,8 +325,7 @@
       form.MinecraftServerKind,
       form.MemoryAllocation ?? RamAllocationUnits.Zero,
       form.JavaRuntimeGuid.GetValueOrDefault(),
-      JvmArgumentsHelper.Split(form.JvmArguments),
-      EditedInstanceConfiguration?.LaunchAutomatically ?? false
+      JvmArgumentsHelper.Split(form.JvmArguments)
     );
 
     var result = await InstanceManager.AddOrEditInstance(instance);

Server/Phantom.Server/Phantom.Server.csproj

@@ -14,10 +14,10 @@
   <ItemGroup>
     <ProjectReference Include="..\..\Common\Phantom.Common.Data\Phantom.Common.Data.csproj" />
     <ProjectReference Include="..\..\Common\Phantom.Common.Logging\Phantom.Common.Logging.csproj" />
-    <ProjectReference Include="..\..\Common\Phantom.Common.Minecraft\Phantom.Common.Minecraft.csproj" />
     <ProjectReference Include="..\..\Utils\Phantom.Utils.IO\Phantom.Utils.IO.csproj" />
     <ProjectReference Include="..\..\Utils\Phantom.Utils.Runtime\Phantom.Utils.Runtime.csproj" />
     <ProjectReference Include="..\Phantom.Server.Database.Postgres\Phantom.Server.Database.Postgres.csproj" />
+    <ProjectReference Include="..\Phantom.Server.Minecraft\Phantom.Server.Minecraft.csproj" />
     <ProjectReference Include="..\Phantom.Server.Rpc\Phantom.Server.Rpc.csproj" />
     <ProjectReference Include="..\Phantom.Server.Services\Phantom.Server.Services.csproj" />
     <ProjectReference Include="..\Phantom.Server.Web\Phantom.Server.Web.csproj" />

Server/Phantom.Server/WebConfigurator.cs

@@ -1,6 +1,6 @@
 using Microsoft.Extensions.DependencyInjection;
 using Phantom.Common.Data.Agent;
-using Phantom.Common.Minecraft;
+using Phantom.Server.Minecraft;
 using Phantom.Server.Services;
 using Phantom.Server.Services.Agents;
 using Phantom.Server.Services.Audit;

Utils/Phantom.Utils.Rpc/Message/MessageReplyTracker.cs

@@ -1,4 +1,5 @@
 using System.Collections.Concurrent;
+using Phantom.Utils.Runtime;
 using Serilog;
 
 namespace Phantom.Utils.Rpc.Message;
@@ -15,7 +16,7 @@ public sealed class MessageReplyTracker {
 
 	public uint RegisterReply() {
 		var sequenceId = Interlocked.Increment(ref lastSequenceId);
-		replyTasks[sequenceId] = new TaskCompletionSource<byte[]>(TaskCreationOptions.None);
+		replyTasks[sequenceId] = Tasks.CreateCompletionSource<byte[]>();
 		return sequenceId;
 	}
 

Utils/Phantom.Utils.Rpc/RpcRuntime.cs

@@ -43,7 +43,11 @@ public abstract class RpcRuntime<TSocket> where TSocket : ThreadSafeSocket, new(
 		Connect(socket);
 
 		void RunTask() {
-			Run(socket, replyTracker, taskManager);
+			try {
+				Run(socket, replyTracker, taskManager);
+			} catch (Exception e) {
+				runtimeLogger.Error(e, "Caught exception in RPC thread.");
+			}
 		}
 		
 		try {

Utils/Phantom.Utils.Runtime/CancellableBackgroundTask.cs

@@ -15,7 +15,7 @@ public abstract class CancellableBackgroundTask {
 	}
 
 	private async Task Run() {
-		Logger.Verbose("Task started.");
+		Logger.Debug("Task started.");
 
 		try {
 			await RunTask();
@@ -25,7 +25,7 @@ public abstract class CancellableBackgroundTask {
 			Logger.Fatal(e, "Caught exception in task.");
 		} finally {
 			cancellationTokenSource.Dispose();
-			Logger.Verbose("Task stopped.");
+			Logger.Debug("Task stopped.");
 		}
 	}
 	

Utils/Phantom.Utils.Runtime/OneShotProcess.cs

@@ -0,0 +1,63 @@
+using Serilog;
+
+namespace Phantom.Utils.Runtime;
+
+public sealed class OneShotProcess {
+	private readonly ILogger logger;
+	private readonly ProcessConfigurator configurator;
+	
+	public event EventHandler<Process.Output>? OutputReceived;
+	
+	public OneShotProcess(ILogger logger, ProcessConfigurator configurator) {
+		this.logger = logger;
+		this.configurator = configurator;
+	}
+
+	public async Task<bool> Run(CancellationToken cancellationToken) {
+		using var process = configurator.CreateProcess();
+		process.OutputReceived += OutputReceived;
+
+		try {
+			process.Start();
+		} catch (Exception e) {
+			logger.Error(e, "Caught exception launching process.");
+			return false;
+		}
+
+		try {
+			await process.WaitForExitAsync(cancellationToken);
+		} catch (OperationCanceledException) {
+			await TryKillProcess(process);
+			return false;
+		} catch (Exception e) {
+			logger.Error(e, "Caught exception waiting for process to exit.");
+			return false;
+		}
+
+		if (!process.HasExited) {
+			await TryKillProcess(process);
+			return false;
+		}
+
+		if (process.ExitCode != 0) {
+			logger.Error("Process exited with code {ExitCode}.", process.ExitCode);
+			return false;
+		}
+
+		logger.Debug("Process finished successfully.");
+		return true;
+	}
+
+	private async Task TryKillProcess(Process process) {
+		using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(2));
+
+		try {
+			process.Kill();
+			await process.WaitForExitAsync(timeout.Token);
+		} catch (OperationCanceledException) {
+			logger.Error("Timed out waiting for killed process to exit.");
+		} catch (Exception e) {
+			logger.Error(e, "Caught exception killing process.");
+		}
+	}
+}

Utils/Phantom.Utils.Runtime/Process.cs

@@ -0,0 +1,92 @@
+using System.Diagnostics;
+
+namespace Phantom.Utils.Runtime;
+
+public sealed class Process : IDisposable {
+	public readonly record struct Output(string Line, bool IsError);
+	
+	public event EventHandler<Output>? OutputReceived;
+	
+	public event EventHandler Exited {
+		add {
+			wrapped.EnableRaisingEvents = true;
+			wrapped.Exited += value;
+		}
+		remove {
+			wrapped.Exited -= value;
+		}
+	}
+
+	public bool HasExited => wrapped.HasExited;
+	public int ExitCode => wrapped.ExitCode;
+	public StreamWriter StandardInput => wrapped.StandardInput;
+
+	private readonly System.Diagnostics.Process wrapped;
+
+	internal Process(System.Diagnostics.Process wrapped) {
+		this.wrapped = wrapped;
+	}
+
+	public void Start() {
+		if (!OperatingSystem.IsWindows()) {
+			this.wrapped.OutputDataReceived += OnStandardOutputDataReceived;
+			this.wrapped.ErrorDataReceived += OnStandardErrorDataReceived;
+		}
+			
+		this.wrapped.Start();
+
+		// https://github.com/dotnet/runtime/issues/81896
+		if (OperatingSystem.IsWindows()) {
+			Task.Factory.StartNew(ReadStandardOutputSynchronously, TaskCreationOptions.LongRunning);
+			Task.Factory.StartNew(ReadStandardErrorSynchronously, TaskCreationOptions.LongRunning);
+		}
+		else {
+			this.wrapped.BeginOutputReadLine();
+			this.wrapped.BeginErrorReadLine();
+		}
+	}
+
+	private void OnStandardOutputDataReceived(object sender, DataReceivedEventArgs e) {
+		OnStandardStreamDataReceived(e.Data, isError: false);
+	}
+
+	private void OnStandardErrorDataReceived(object sender, DataReceivedEventArgs e) {
+		OnStandardStreamDataReceived(e.Data, isError: true);
+	}
+
+	private void OnStandardStreamDataReceived(string? line, bool isError) {
+		if (line != null) {
+			OutputReceived?.Invoke(this, new Output(line, isError));
+		}
+	}
+
+	private void ReadStandardOutputSynchronously() {
+		ReadStandardStreamSynchronously(wrapped.StandardOutput, isError: false);
+	}
+
+	private void ReadStandardErrorSynchronously() {
+		ReadStandardStreamSynchronously(wrapped.StandardError, isError: true);
+	}
+
+	private void ReadStandardStreamSynchronously(StreamReader reader, bool isError) {
+		try {
+			while (reader.ReadLine() is {} line) {
+				OutputReceived?.Invoke(this, new Output(line, isError));
+			}
+		} catch (ObjectDisposedException) {
+			// Ignore.
+		}
+	}
+
+	public Task WaitForExitAsync(CancellationToken cancellationToken) {
+		return wrapped.WaitForExitAsync(cancellationToken);
+	}
+
+	public void Kill(bool entireProcessTree = false) {
+		wrapped.Kill(entireProcessTree);
+	}
+
+	public void Dispose() {
+		wrapped.Dispose();
+	}
+}

Utils/Phantom.Utils.Runtime/ProcessConfigurator.cs

@@ -0,0 +1,37 @@
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+
+namespace Phantom.Utils.Runtime; 
+
+public sealed class ProcessConfigurator {
+	private readonly ProcessStartInfo startInfo = new () {
+		RedirectStandardOutput = true,
+		RedirectStandardError = true
+	};
+	
+	public string FileName {
+		get => startInfo.FileName;
+		set => startInfo.FileName = value;
+	}
+
+	public Collection<string> ArgumentList => startInfo.ArgumentList;
+
+	public string WorkingDirectory {
+		get => startInfo.WorkingDirectory;
+		set => startInfo.WorkingDirectory = value;
+	}
+
+	public bool RedirectInput {
+		get => startInfo.RedirectStandardInput;
+		set => startInfo.RedirectStandardInput = value;
+	}
+	
+	public bool UseShellExecute {
+		get => startInfo.UseShellExecute;
+		set => startInfo.UseShellExecute = value;
+	}
+
+	public Process CreateProcess() {
+		return new Process(new System.Diagnostics.Process { StartInfo = startInfo });
+	}
+}

Utils/Phantom.Utils.Runtime/Tasks.cs

@@ -0,0 +1,11 @@
+namespace Phantom.Utils.Runtime; 
+
+public static class Tasks {
+	public static TaskCompletionSource CreateCompletionSource() {
+		return new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+	}
+
+	public static TaskCompletionSource<T> CreateCompletionSource<T>() {
+		return new TaskCompletionSource<T>(TaskCreationOptions.RunContinuationsAsynchronously);
+	}
+}