Merge Phantom.Agent.Minecraft project into Phantom.Agent.Services

Agent/Phantom.Agent.Services/AgentRegistrationHandler.cs

@@ -79,6 +79,7 @@ public sealed class AgentRegistrationHandler {
 			configureInstanceMessage.Info,
 			configureInstanceMessage.LaunchRecipe,
 			configureInstanceMessage.LaunchNow,
+			configureInstanceMessage.StopRecipe,
 			AlwaysReportStatus: true
 		);
 	}

Agent/Phantom.Agent.Services/Downloads/FileDownloader.cs

@@ -3,7 +3,6 @@ using Phantom.Common.Data.Agent;
 using Phantom.Utils.Cryptography;
 using Phantom.Utils.IO;
 using Phantom.Utils.Logging;
-using Phantom.Utils.Net;
 using Phantom.Utils.Runtime;
 using Serilog;
 
@@ -111,7 +110,7 @@ sealed class FileDownloader {
 			var response = await httpClient.GetAsync(downloadUrl, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
 			response.EnsureSuccessStatusCode();
 			
-			FileSize? fileSize = response.Headers.ContentLength;
+			FileSize? fileSize = response.Content.Headers.ContentLength is {} length and >= 0 ? new FileSize((ulong) length) : null;
 			ulong? fileSizeBytes = fileSize?.Bytes;
 			
 			Logger.Information("Downloading {Url} ({Size})...", downloadUrl, FormatFileSize(fileSize));

Agent/Phantom.Agent.Services/Games/MinecraftCommand.cs

@@ -3,11 +3,6 @@
 static class MinecraftCommand {
 	public const string SaveOn = "save-on";
 	public const string SaveOff = "save-off";
-	public const string Stop = "stop";
-	
-	public static string Say(string message) {
-		return "say " + message;
-	}
 	
 	public static string SaveAll(bool flush) {
 		return flush ? "save-all flush" : "save-all";

Agent/Phantom.Agent.Services/Instances/InstanceActor.cs

@@ -3,9 +3,9 @@ using Phantom.Agent.Services.Instances.Launch;
 using Phantom.Agent.Services.Instances.State;
 using Phantom.Agent.Services.Rpc;
 using Phantom.Common.Data.Agent.Instance;
+using Phantom.Common.Data.Agent.Instance.Stop;
 using Phantom.Common.Data.Backups;
 using Phantom.Common.Data.Instance;
-using Phantom.Common.Data.Minecraft;
 using Phantom.Common.Data.Replies;
 using Phantom.Common.Messages.Agent.ToController;
 using Phantom.Utils.Actor;
@@ -85,7 +85,7 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
 	
 	public sealed record LaunchInstanceCommand(InstanceInfo Info, InstanceLauncher Launcher, InstanceTicketManager.Ticket Ticket, bool IsRestarting) : ICommand;
 	
-	public sealed record StopInstanceCommand(MinecraftStopStrategy StopStrategy) : ICommand;
+	public sealed record StopInstanceCommand(InstanceStopRecipe StopRecipe) : ICommand;
 	
 	public sealed record SendCommandToInstanceCommand(string Command) : ICommand, ICanReply<SendCommandToInstanceResult>;
 	
@@ -93,7 +93,7 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
 	
 	public sealed record HandleProcessEndedCommand(IInstanceStatus Status) : ICommand, IJumpAhead;
 	
-	public sealed record ShutdownCommand : ICommand;
+	public sealed record ShutdownCommand(InstanceStopRecipe StopRecipe) : ICommand;
 	
 	private void ReportInstanceStatus(ReportInstanceStatusCommand command) {
 		ReportCurrentStatus();
@@ -125,7 +125,7 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
 		IInstanceStatus oldStatus = currentStatus;
 		SetAndReportStatus(InstanceStatus.Stopping);
 		
-		if (await InstanceStopProcedure.Run(context, command.StopStrategy, runningState, SetAndReportStatus, shutdownCancellationToken)) {
+		if (await InstanceStopProcedure.Run(context, command.StopRecipe, runningState, SetAndReportStatus, shutdownCancellationToken)) {
 			instanceTicketManager.Release(runningState.Ticket);
 			TransitionState(null);
 		}
@@ -167,7 +167,7 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
 	}
 	
 	private async Task Shutdown(ShutdownCommand command) {
-		await StopInstance(new StopInstanceCommand(MinecraftStopStrategy.Instant));
+		await StopInstance(new StopInstanceCommand(command.StopRecipe));
 		await actorCancellationTokenSource.CancelAsync();
 		
 		await Task.WhenAll(

Agent/Phantom.Agent.Services/Instances/InstanceManagerActor.cs

@@ -6,8 +6,8 @@ using Phantom.Agent.Services.Rpc;
 using Phantom.Common.Data;
 using Phantom.Common.Data.Agent.Instance;
 using Phantom.Common.Data.Agent.Instance.Launch;
+using Phantom.Common.Data.Agent.Instance.Stop;
 using Phantom.Common.Data.Instance;
-using Phantom.Common.Data.Minecraft;
 using Phantom.Common.Data.Replies;
 using Phantom.Utils.Actor;
 using Phantom.Utils.IO;
@@ -52,15 +52,15 @@ sealed class InstanceManagerActor : ReceiveActor<InstanceManagerActor.ICommand>
 		ReceiveAsync<ShutdownCommand>(Shutdown);
 	}
 	
-	private sealed record Instance(ActorRef<InstanceActor.ICommand> Actor, InstanceInfo Info, InstanceProperties Properties, InstanceLaunchRecipe? LaunchRecipe);
+	private sealed record Instance(ActorRef<InstanceActor.ICommand> Actor, InstanceInfo Info, InstanceProperties Properties, InstanceLaunchRecipe? LaunchRecipe, InstanceStopRecipe StopRecipe);
 	
 	public interface ICommand;
 	
-	public sealed record ConfigureInstanceCommand(Guid InstanceGuid, InstanceInfo InstanceInfo, InstanceLaunchRecipe? LaunchRecipe, bool LaunchNow, bool AlwaysReportStatus) : ICommand, ICanReply<Result<ConfigureInstanceResult, InstanceActionFailure>>;
+	public sealed record ConfigureInstanceCommand(Guid InstanceGuid, InstanceInfo InstanceInfo, InstanceLaunchRecipe? LaunchRecipe, bool LaunchNow, InstanceStopRecipe StopRecipe, bool AlwaysReportStatus) : ICommand, ICanReply<Result<ConfigureInstanceResult, InstanceActionFailure>>;
 	
 	public sealed record LaunchInstanceCommand(Guid InstanceGuid) : ICommand, ICanReply<Result<LaunchInstanceResult, InstanceActionFailure>>;
 	
-	public sealed record StopInstanceCommand(Guid InstanceGuid, MinecraftStopStrategy StopStrategy) : ICommand, ICanReply<Result<StopInstanceResult, InstanceActionFailure>>;
+	public sealed record StopInstanceCommand(Guid InstanceGuid, InstanceStopRecipe StopRecipe) : ICommand, ICanReply<Result<StopInstanceResult, InstanceActionFailure>>;
 	
 	public sealed record SendCommandToInstanceCommand(Guid InstanceGuid, string Command) : ICommand, ICanReply<Result<SendCommandToInstanceResult, InstanceActionFailure>>;
 	
@@ -70,11 +70,13 @@ sealed class InstanceManagerActor : ReceiveActor<InstanceManagerActor.ICommand>
 		var instanceGuid = command.InstanceGuid;
 		var instanceInfo = command.InstanceInfo;
 		var launchRecipe = command.LaunchRecipe;
+		var stopRecipe = command.StopRecipe;
 		
 		if (instances.TryGetValue(instanceGuid, out var instance)) {
 			instances[instanceGuid] = instance with {
 				Info = instanceInfo,
 				LaunchRecipe = launchRecipe,
+				StopRecipe = stopRecipe,
 			};
 			
 			Logger.Information("Reconfigured instance \"{Name}\" (GUID {Guid}).", instanceInfo.InstanceName, instanceGuid);
@@ -88,7 +90,7 @@ sealed class InstanceManagerActor : ReceiveActor<InstanceManagerActor.ICommand>
 			var instanceFolder = Path.Combine(agentFolders.InstancesFolderPath, instanceGuid.ToString());
 			var instanceProperties = new InstanceProperties(instanceGuid, instanceFolder);
 			var instanceInit = new InstanceActor.Init(agentState, instanceGuid, instanceLoggerName, instanceServices, instanceTicketManager, shutdownCancellationToken);
-			instances[instanceGuid] = instance = new Instance(Context.ActorOf(InstanceActor.Factory(instanceInit), "Instance-" + instanceGuid), instanceInfo, instanceProperties, launchRecipe);
+			instances[instanceGuid] = instance = new Instance(Context.ActorOf(InstanceActor.Factory(instanceInit), "Instance-" + instanceGuid), instanceInfo, instanceProperties, launchRecipe, stopRecipe);
 			
 			Logger.Information("Created instance \"{Name}\" (GUID {Guid}).", instanceInfo.InstanceName, instanceGuid);
 			
@@ -159,7 +161,7 @@ sealed class InstanceManagerActor : ReceiveActor<InstanceManagerActor.ICommand>
 			}
 		}
 		
-		instanceInfo.Actor.Tell(new InstanceActor.StopInstanceCommand(command.StopStrategy));
+		instanceInfo.Actor.Tell(new InstanceActor.StopInstanceCommand(command.StopRecipe));
 		return StopInstanceResult.StopInitiated;
 	}
 	
@@ -181,7 +183,7 @@ sealed class InstanceManagerActor : ReceiveActor<InstanceManagerActor.ICommand>
 		
 		await shutdownCancellationTokenSource.CancelAsync();
 		
-		await Task.WhenAll(instances.Values.Select(static instance => instance.Actor.Stop(new InstanceActor.ShutdownCommand())));
+		await Task.WhenAll(instances.Values.Select(static instance => instance.Actor.Stop(new InstanceActor.ShutdownCommand(instance.StopRecipe))));
 		instances.Clear();
 		
 		shutdownCancellationTokenSource.Dispose();

Agent/Phantom.Agent.Services/Instances/Launch/InstanceLauncher.cs

@@ -18,6 +18,8 @@ sealed class InstanceLauncher(
 	InstanceProperties instanceProperties,
 	InstanceLaunchRecipe launchRecipe
 ) {
+	public IInstanceValueResolver ValueResolver => valueResolver;
+	
 	public async Task<InstanceLaunchResult> Launch(ILogger logger, Action<IInstanceStatus?> reportStatus, CancellationToken cancellationToken) {
 		string? executablePath = launchRecipe.Executable.Resolve(pathResolver);
 		if (executablePath == null) {
@@ -109,6 +111,8 @@ sealed class InstanceLauncher(
 				}
 			}
 			
+			reportStatus(InstanceStatus.Downloading(null));
+			
 			if (await downloadManager.DownloadAndGetPath(downloadInfo, filePath, OnDownloadProgress, cancellationToken) == null) {
 				logger.Error("Could not download file: {Url}", downloadInfo.Url);
 				return false;

Agent/Phantom.Agent.Services/Instances/State/InstanceProcess.cs

@@ -27,6 +27,15 @@ sealed class InstanceProcess : IDisposable {
 		await process.StandardInput.WriteLineAsync(command.AsMemory(), cancellationToken);
 	}
 	
+	public async Task<bool> TrySendCommand(string command, TimeSpan timeout, CancellationToken cancellationToken) {
+		try {
+			await SendCommand(command, cancellationToken).WaitAsync(timeout, cancellationToken);
+			return true;
+		} catch (TimeoutException) {
+			return false;
+		}
+	}
+	
 	public void AddOutputListener(EventHandler<string> listener, uint maxLinesToReadFromHistory = uint.MaxValue) {
 		OutputEvent += listener;
 		

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

@@ -11,6 +11,7 @@ sealed class InstanceRunningState : IDisposable {
 	public InstanceTicketManager.Ticket Ticket { get; }
 	public InstanceProcess Process { get; }
 	
+	internal IInstanceValueResolver ValueResolver => launcher.ValueResolver;
 	internal bool IsStopping { get; set; }
 	
 	private readonly InstanceContext context;

Agent/Phantom.Agent.Services/Instances/State/InstanceStopProcedure.cs

@@ -1,37 +1,50 @@
 using System.Diagnostics;
-using Phantom.Agent.Services.Games;
+using Phantom.Common.Data.Agent.Instance;
+using Phantom.Common.Data.Agent.Instance.Stop;
 using Phantom.Common.Data.Instance;
-using Phantom.Common.Data.Minecraft;
+using Serilog;
 
 namespace Phantom.Agent.Services.Instances.State;
 
 static class InstanceStopProcedure {
-	private static readonly ushort[] Stops = [60, 30, 10, 5, 4, 3, 2, 1, 0];
+	public static async Task<bool> Run(InstanceContext context, InstanceStopRecipe stopRecipe, InstanceRunningState runningState, Action<IInstanceStatus> reportStatus, CancellationToken cancellationToken) {
+		var logger = context.Logger;
+		
+		var stopCommand = stopRecipe.StopCommand.Resolve(runningState.ValueResolver);
+		if (stopCommand == null) {
+			logger.Error("Could not resolve stop command");
+			return false;
+		}
 		
-	public static async Task<bool> Run(InstanceContext context, MinecraftStopStrategy stopStrategy, InstanceRunningState runningState, Action<IInstanceStatus> reportStatus, CancellationToken cancellationToken) {
-		var process = runningState.Process;
 		runningState.IsStopping = true;
 		
-		var seconds = stopStrategy.Seconds;
-		if (seconds > 0) {
-			try {
-				await CountDownWithAnnouncements(context, process, seconds, cancellationToken);
-			} catch (OperationCanceledException) {
+		bool continueStopping = false;
+		try {
+			var stepExecutor = new StepExecutor(logger, runningState.ValueResolver, runningState.Process, cancellationToken);
+			continueStopping = await RunPreparationSteps(context, stopRecipe, stepExecutor);
+		} finally {
+			if (!continueStopping) {
 				runningState.IsStopping = false;
-				return false;
 			}
 		}
 		
+		if (!continueStopping) {
+			return false;
+		}
+		
 		try {
 			// Too late to cancel the stop procedure now.
 			runningState.OnStopInitiated();
 			
-			if (!process.HasEnded) {
-				context.Logger.Information("Session stopping now.");
-				await DoStop(context, process);
+			if (!runningState.Process.HasEnded) {
+				logger.Information("Sending stop command...");
+				await TrySendStopCommand(context, runningState.Process, stopCommand);
+				
+				logger.Information("Waiting for session to end...");
+				await WaitForSessionToEnd(context, runningState.Process);
 			}
 		} finally {
-			context.Logger.Information("Session stopped.");
+			logger.Information("Session stopped.");
 			reportStatus(InstanceStatus.NotRunning);
 			context.ReportEvent(InstanceEvent.Stopped);
 		}
@@ -39,39 +52,51 @@ static class InstanceStopProcedure {
 		return true;
 	}
 	
-	private static async Task CountDownWithAnnouncements(InstanceContext context, InstanceProcess process, ushort seconds, CancellationToken cancellationToken) {
-		context.Logger.Information("Session stopping in {Seconds} seconds.", seconds);
+	private static async Task<bool> RunPreparationSteps(InstanceContext context, InstanceStopRecipe stopRecipe, StepExecutor executor) {
+		var steps = stopRecipe.Preparation;
 		
-		foreach (var stop in Stops) {
-			// TODO change to event-based cancellation
-			if (process.HasEnded) {
-				return;
+		for (int stepIndex = 0; stepIndex < steps.Length; stepIndex++) {
+			var step = steps[stepIndex];
+			try {
+				if (await step.Run(executor)) {
+					continue;
+				}
+			} catch (OperationCanceledException) {
+				throw;
+			} catch (Exception e) {
+				context.Logger.Error(e, "Failed preparation step {StepIndex} out of {StepCount}: {StepName}", stepIndex, steps.Length, step.GetType().Name);
 			}
 			
-			if (seconds > stop) {
-				await process.SendCommand(GetCountDownAnnouncementCommand(seconds), cancellationToken);
-				await Task.Delay(TimeSpan.FromSeconds(seconds - stop), cancellationToken);
-				seconds = stop;
+			return false;
+		}
+		
+		return true;
+	}
+	
+	private sealed class StepExecutor(ILogger logger, IInstanceValueResolver valueResolver, InstanceProcess process, CancellationToken cancellationToken) : IInstanceStopStepExecutor<bool> {
+		public async Task<bool> Wait(TimeSpan duration) {
+			await Task.Delay(duration, cancellationToken);
+			return true;
+		}
+		
+		public async Task<bool> SendToStandardInput(IInstanceValue line) {
+			string? command = line.Resolve(valueResolver);
+			if (command == null) {
+				logger.Error("Could not resolve standard input line: {Value}", line);
+				return false;
 			}
+			
+			// If the process can't process standard input, wait a bit but don't block or fail the whole stop procedure.
+			await process.TrySendCommand(command, TimeSpan.FromMilliseconds(500), cancellationToken);
+			
+			return true;
 		}
 	}
 	
-	private static string GetCountDownAnnouncementCommand(ushort seconds) {
-		return MinecraftCommand.Say("Server shutting down in " + seconds + (seconds == 1 ? " second." : " seconds."));
-	}
-	
-	private static async Task DoStop(InstanceContext context, InstanceProcess process) {
-		context.Logger.Information("Sending stop command...");
-		await TrySendStopCommand(context, process);
-		
-		context.Logger.Information("Waiting for session to end...");
-		await WaitForSessionToEnd(context, process);
-	}
-	
-	private static async Task TrySendStopCommand(InstanceContext context, InstanceProcess process) {
+	private static async Task TrySendStopCommand(InstanceContext context, InstanceProcess process, string command) {
 		using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
 		try {
-			await process.SendCommand(MinecraftCommand.Stop, timeout.Token);
+			await process.SendCommand(command, timeout.Token);
 		} catch (OperationCanceledException) {
 			// Ignore.
 		} catch (ObjectDisposedException e) when (e.ObjectName == typeof(Process).FullName && process.HasEnded) {

Agent/Phantom.Agent.Services/Rpc/ControllerMessageHandlerActor.cs

@@ -26,7 +26,7 @@ public sealed class ControllerMessageHandlerActor : ReceiveActor<IMessageToAgent
 	}
 	
 	private async Task<Result<ConfigureInstanceResult, InstanceActionFailure>> HandleConfigureInstance(ConfigureInstanceMessage message) {
-		return await agent.InstanceManager.Request(new InstanceManagerActor.ConfigureInstanceCommand(message.InstanceGuid, message.Info, message.LaunchRecipe, message.LaunchNow, AlwaysReportStatus: false));
+		return await agent.InstanceManager.Request(new InstanceManagerActor.ConfigureInstanceCommand(message.InstanceGuid, message.Info, message.LaunchRecipe, message.LaunchNow, message.StopRecipe, AlwaysReportStatus: false));
 	}
 	
 	private async Task<Result<LaunchInstanceResult, InstanceActionFailure>> HandleLaunchInstance(LaunchInstanceMessage message) {
@@ -34,7 +34,7 @@ public sealed class ControllerMessageHandlerActor : ReceiveActor<IMessageToAgent
 	}
 	
 	private async Task<Result<StopInstanceResult, InstanceActionFailure>> HandleStopInstance(StopInstanceMessage message) {
-		return await agent.InstanceManager.Request(new InstanceManagerActor.StopInstanceCommand(message.InstanceGuid, message.StopStrategy));
+		return await agent.InstanceManager.Request(new InstanceManagerActor.StopInstanceCommand(message.InstanceGuid, message.StopRecipe));
 	}
 	
 	private async Task<Result<SendCommandToInstanceResult, InstanceActionFailure>> HandleSendCommandToInstance(SendCommandToInstanceMessage message) {

Common/Phantom.Common.Data.Agent/Instance/Stop/IInstanceLaunchStepExecutor.cs

@@ -0,0 +1,6 @@
+namespace Phantom.Common.Data.Agent.Instance.Stop;
+
+public interface IInstanceStopStepExecutor<TResult> {
+	Task<TResult> Wait(TimeSpan duration);
+	Task<TResult> SendToStandardInput(IInstanceValue line);
+}

Common/Phantom.Common.Data.Agent/Instance/Stop/IInstanceStopStep.cs

@@ -0,0 +1,30 @@
+using MemoryPack;
+
+namespace Phantom.Common.Data.Agent.Instance.Stop;
+
+[MemoryPackable]
+[MemoryPackUnion(tag: 0, typeof(InstanceStopStep.Wait))]
+[MemoryPackUnion(tag: 1, typeof(InstanceStopStep.SendToStandardInput))]
+public partial interface IInstanceStopStep {
+	Task<TResult> Run<TResult>(IInstanceStopStepExecutor<TResult> executor);
+}
+
+public static partial class InstanceStopStep {
+	[MemoryPackable(GenerateType.VersionTolerant)]
+	public sealed partial record Wait(
+		[property: MemoryPackOrder(0)] TimeSpan Duration
+	) : IInstanceStopStep {
+		public Task<TResult> Run<TResult>(IInstanceStopStepExecutor<TResult> executor) {
+			return executor.Wait(Duration);
+		}
+	}
+	
+	[MemoryPackable(GenerateType.VersionTolerant)]
+	public sealed partial record SendToStandardInput(
+		[property: MemoryPackOrder(0)] IInstanceValue Line
+	) : IInstanceStopStep {
+		public Task<TResult> Run<TResult>(IInstanceStopStepExecutor<TResult> executor) {
+			return executor.SendToStandardInput(Line);
+		}
+	}
+}

Common/Phantom.Common.Data.Agent/Instance/Stop/InstanceStopRecipe.cs

@@ -0,0 +1,10 @@
+using System.Collections.Immutable;
+using MemoryPack;
+
+namespace Phantom.Common.Data.Agent.Instance.Stop;
+
+[MemoryPackable(GenerateType.VersionTolerant)]
+public sealed partial record InstanceStopRecipe(
+	[property: MemoryPackOrder(0)] ImmutableArray<IInstanceStopStep> Preparation,
+	[property: MemoryPackOrder(1)] IInstanceValue StopCommand
+);

Common/Phantom.Common.Data.Web/Java/JvmArgumentsHelper.cs

@@ -1,6 +1,6 @@
 using System.Collections.Immutable;
 
-namespace Phantom.Common.Data.Web.Minecraft;
+namespace Phantom.Common.Data.Web.Java;
 
 public static class JvmArgumentsHelper {
 	public static ImmutableArray<string> Split(string arguments) {

Common/Phantom.Common.Data/Minecraft/MinecraftStopStrategy.cs

@@ -1,10 +0,0 @@
-using MemoryPack;
-
-namespace Phantom.Common.Data.Minecraft;
-
-[MemoryPackable(GenerateType.VersionTolerant)]
-public sealed partial record MinecraftStopStrategy(
-	[property: MemoryPackOrder(0)] ushort Seconds
-) {
-	public static MinecraftStopStrategy Instant => new (0);
-}

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

@@ -2,6 +2,7 @@
 using Phantom.Common.Data;
 using Phantom.Common.Data.Agent.Instance;
 using Phantom.Common.Data.Agent.Instance.Launch;
+using Phantom.Common.Data.Agent.Instance.Stop;
 using Phantom.Common.Data.Replies;
 using Phantom.Utils.Actor;
 
@@ -12,5 +13,6 @@ public sealed partial record ConfigureInstanceMessage(
 	[property: MemoryPackOrder(0)] Guid InstanceGuid,
 	[property: MemoryPackOrder(1)] InstanceInfo Info,
 	[property: MemoryPackOrder(2)] InstanceLaunchRecipe? LaunchRecipe,
-	[property: MemoryPackOrder(3)] bool LaunchNow = false
+	[property: MemoryPackOrder(3)] bool LaunchNow,
+	[property: MemoryPackOrder(4)] InstanceStopRecipe StopRecipe
 ) : IMessageToAgent, ICanReply<Result<ConfigureInstanceResult, InstanceActionFailure>>;

Common/Phantom.Common.Messages.Agent/ToAgent/StopInstanceMessage.cs

@@ -1,6 +1,6 @@
 using MemoryPack;
 using Phantom.Common.Data;
-using Phantom.Common.Data.Minecraft;
+using Phantom.Common.Data.Agent.Instance.Stop;
 using Phantom.Common.Data.Replies;
 using Phantom.Utils.Actor;
 
@@ -9,5 +9,5 @@ namespace Phantom.Common.Messages.Agent.ToAgent;
 [MemoryPackable(GenerateType.VersionTolerant)]
 public sealed partial record StopInstanceMessage(
 	[property: MemoryPackOrder(0)] Guid InstanceGuid,
-	[property: MemoryPackOrder(1)] MinecraftStopStrategy StopStrategy
+	[property: MemoryPackOrder(1)] InstanceStopRecipe StopRecipe
 ) : IMessageToAgent, ICanReply<Result<StopInstanceResult, InstanceActionFailure>>;

Common/Phantom.Common.Messages.Web/ToController/StopInstanceMessage.cs

@@ -1,7 +1,6 @@
 using System.Collections.Immutable;
 using MemoryPack;
 using Phantom.Common.Data;
-using Phantom.Common.Data.Minecraft;
 using Phantom.Common.Data.Replies;
 using Phantom.Common.Data.Web.Users;
 using Phantom.Utils.Actor;
@@ -13,5 +12,5 @@ public sealed partial record StopInstanceMessage(
 	[property: MemoryPackOrder(0)] ImmutableArray<byte> AuthToken,
 	[property: MemoryPackOrder(1)] Guid AgentGuid,
 	[property: MemoryPackOrder(2)] Guid InstanceGuid,
-	[property: MemoryPackOrder(3)] MinecraftStopStrategy StopStrategy
+	[property: MemoryPackOrder(3)] ushort AfterSeconds
 ) : IMessageToController, ICanReply<Result<StopInstanceResult, UserInstanceActionFailure>>;

Controller/Phantom.Controller.Database/Repositories/AuditLogRepository.Writer.cs

@@ -87,10 +87,8 @@ sealed partial class AuditLogRepository {
 			});
 		}
 		
-		public void InstanceStopped(Guid instanceGuid, int stopInSeconds) {
-			AddItem(AuditLogEventType.InstanceStopped, instanceGuid.ToString(), new Dictionary<string, object?> {
-				{ "stop_in_seconds", stopInSeconds.ToString() },
-			});
+		public void InstanceStopped(Guid instanceGuid) {
+			AddItem(AuditLogEventType.InstanceStopped, instanceGuid.ToString());
 		}
 	}
 }

Controller/Phantom.Controller.Minecraft/MinecraftInstanceRecipes.Launch.cs

@@ -10,8 +10,8 @@ using Phantom.Utils.Collections;
 
 namespace Phantom.Controller.Minecraft;
 
-public sealed partial class MinecraftLaunchRecipes(MinecraftVersions minecraftVersions) {
-	public async Task<Result<InstanceLaunchRecipe, MinecraftLaunchRecipeCreationFailReason>> Create(InstanceConfiguration configuration, CancellationToken cancellationToken) {
+public sealed partial class MinecraftInstanceRecipes(MinecraftVersions minecraftVersions) {
+	public async Task<Result<InstanceLaunchRecipe, MinecraftLaunchRecipeCreationFailReason>> Launch(InstanceConfiguration configuration, CancellationToken cancellationToken) {
 		string minecraftVersion = configuration.MinecraftVersion;
 		
 		var serverExecutableInfo = await minecraftVersions.GetServerExecutableInfo(minecraftVersion, cancellationToken);

Controller/Phantom.Controller.Minecraft/MinecraftInstanceRecipes.Stop.cs

@@ -0,0 +1,41 @@
+using System.Collections.Immutable;
+using Phantom.Common.Data.Agent.Instance;
+using Phantom.Common.Data.Agent.Instance.Stop;
+
+namespace Phantom.Controller.Minecraft;
+
+public sealed partial class MinecraftInstanceRecipes {
+	private static readonly ushort[] Stops = [60, 30, 10, 5, 4, 3, 2, 1];
+	private static readonly IInstanceValue StopCommand = new InstanceValues.Text("stop");
+	
+	private static InstanceValues.Text SayCommand(string message) {
+		return new InstanceValues.Text($"say {message}");
+	}
+	
+	private static InstanceValues.Text SayCountDownAnnouncementCommand(ushort seconds) {
+		return SayCommand("Server shutting down in " + seconds + (seconds == 1 ? " second." : " seconds."));
+	}
+	
+	public InstanceStopRecipe Stop(ushort afterSeconds) {
+		var steps = ImmutableArray.CreateBuilder<IInstanceStopStep>();
+		
+		if (afterSeconds > 0) {
+			steps.Add(new InstanceStopStep.SendToStandardInput(SayCountDownAnnouncementCommand(afterSeconds)));
+			
+			int remainingSeconds = afterSeconds;
+			
+			for (int stopIndex = Array.FindIndex(Stops, stop => stop < afterSeconds); stopIndex != -1 && stopIndex < Stops.Length; stopIndex++) {
+				ushort currentStop = Stops[stopIndex];
+				
+				steps.Add(new InstanceStopStep.Wait(TimeSpan.FromSeconds(remainingSeconds - currentStop)));
+				steps.Add(new InstanceStopStep.SendToStandardInput(SayCountDownAnnouncementCommand(currentStop)));
+				
+				remainingSeconds = currentStop;
+			}
+			
+			steps.Add(new InstanceStopStep.Wait(TimeSpan.FromSeconds(remainingSeconds)));
+		}
+		
+		return new InstanceStopRecipe(steps.ToImmutable(), StopCommand);
+	}
+}

Controller/Phantom.Controller.Services/Agents/AgentActor.cs

@@ -5,11 +5,10 @@ using Phantom.Common.Data;
 using Phantom.Common.Data.Agent.Instance.Launch;
 using Phantom.Common.Data.Instance;
 using Phantom.Common.Data.Java;
-using Phantom.Common.Data.Minecraft;
 using Phantom.Common.Data.Replies;
 using Phantom.Common.Data.Web.Agent;
 using Phantom.Common.Data.Web.Instance;
-using Phantom.Common.Data.Web.Minecraft;
+using Phantom.Common.Data.Web.Java;
 using Phantom.Common.Messages.Agent;
 using Phantom.Common.Messages.Agent.ToAgent;
 using Phantom.Controller.Database;
@@ -41,7 +40,7 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
 		AgentRuntimeInfo AgentRuntimeInfo,
 		AgentConnectionKeys AgentConnectionKeys,
 		ControllerState ControllerState,
-		MinecraftLaunchRecipes LaunchRecipes,
+		MinecraftInstanceRecipes MinecraftInstanceRecipes,
 		IDbContextProvider DbProvider,
 		CancellationToken CancellationToken
 	);
@@ -54,7 +53,7 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
 	
 	private readonly AgentConnectionKeys agentConnectionKeys;
 	private readonly ControllerState controllerState;
-	private readonly MinecraftLaunchRecipes launchRecipes;
+	private readonly MinecraftInstanceRecipes minecraftInstanceRecipes;
 	private readonly IDbContextProvider dbProvider;
 	private readonly CancellationToken cancellationToken;
 	
@@ -95,7 +94,7 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
 	private AgentActor(Init init) {
 		this.agentConnectionKeys = init.AgentConnectionKeys;
 		this.controllerState = init.ControllerState;
-		this.launchRecipes = init.LaunchRecipes;
+		this.minecraftInstanceRecipes = init.MinecraftInstanceRecipes;
 		this.dbProvider = init.DbProvider;
 		this.cancellationToken = init.CancellationToken;
 		
@@ -190,8 +189,9 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
 		var configurationMessages = ImmutableArray.CreateBuilder<ConfigureInstanceMessage>();
 		
 		foreach (var (instanceGuid, instanceConfiguration, _, _, launchAutomatically) in instanceDataByGuid.Values.ToImmutableArray()) {
-			var launchRecipe = await launchRecipes.Create(instanceConfiguration, cancellationToken);
-			var configurationMessage = new ConfigureInstanceMessage(instanceGuid, instanceConfiguration.AsInfo, launchRecipe.OrElse(null), launchAutomatically);
+			var launchRecipe = await minecraftInstanceRecipes.Launch(instanceConfiguration, cancellationToken);
+			var stopRecipe = minecraftInstanceRecipes.Stop(0);
+			var configurationMessage = new ConfigureInstanceMessage(instanceGuid, instanceConfiguration.AsInfo, launchRecipe.OrElse(null), launchAutomatically, stopRecipe);
 			configurationMessages.Add(configurationMessage);
 		}
 		
@@ -226,7 +226,7 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
 	
 	public sealed record LaunchInstanceCommand(Guid LoggedInUserGuid, Guid InstanceGuid) : ICommand, ICanReply<Result<LaunchInstanceResult, InstanceActionFailure>>;
 	
-	public sealed record StopInstanceCommand(Guid LoggedInUserGuid, Guid InstanceGuid, MinecraftStopStrategy StopStrategy) : ICommand, ICanReply<Result<StopInstanceResult, InstanceActionFailure>>;
+	public sealed record StopInstanceCommand(Guid LoggedInUserGuid, Guid InstanceGuid, ushort AfterSeconds) : ICommand, ICanReply<Result<StopInstanceResult, InstanceActionFailure>>;
 	
 	public sealed record SendCommandToInstanceCommand(Guid LoggedInUserGuid, Guid InstanceGuid, string Command) : ICommand, ICanReply<Result<SendCommandToInstanceResult, InstanceActionFailure>>;
 	
@@ -341,7 +341,7 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
 			return Task.FromResult<Result<CreateOrUpdateInstanceResult, InstanceActionFailure>>(CreateOrUpdateInstanceResult.InstanceMemoryMustNotBeZero);
 		}
 		
-		return launchRecipes.Create(instanceConfiguration, cancellationToken)
+		return minecraftInstanceRecipes.Launch(instanceConfiguration, cancellationToken)
 		                    .ContinueOnActor(CreateOrUpdateInstance1, command)
 		                    .Unwrap();
 	}
@@ -362,7 +362,8 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
 			instanceActorRef = CreateNewInstance(Instance.Offline(instanceGuid, instanceConfiguration));
 		}
 		
-		var configureInstanceCommand = new InstanceActor.ConfigureInstanceCommand(command.LoggedInUserGuid, instanceGuid, instanceConfiguration, launchRecipe.Value, isCreatingInstance);
+		var stopRecipe = minecraftInstanceRecipes.Stop(afterSeconds: 0);
+		var configureInstanceCommand = new InstanceActor.ConfigureInstanceCommand(command.LoggedInUserGuid, instanceGuid, instanceConfiguration, launchRecipe.Value, stopRecipe, isCreatingInstance);
 		
 		return instanceActorRef.Request(configureInstanceCommand, cancellationToken)
 		                       .ContinueOnActor(CreateOrUpdateInstance2, configureInstanceCommand);
@@ -403,7 +404,8 @@ sealed class AgentActor : ReceiveActor<AgentActor.ICommand>, IWithTimers {
 	}
 	
 	private Task<Result<StopInstanceResult, InstanceActionFailure>> StopInstance(StopInstanceCommand command) {
-		return RequestInstance<InstanceActor.StopInstanceCommand, StopInstanceResult>(command.InstanceGuid, new InstanceActor.StopInstanceCommand(command.LoggedInUserGuid, command.StopStrategy));
+		var stopRecipe = minecraftInstanceRecipes.Stop(command.AfterSeconds);
+		return RequestInstance<InstanceActor.StopInstanceCommand, StopInstanceResult>(command.InstanceGuid, new InstanceActor.StopInstanceCommand(command.LoggedInUserGuid, stopRecipe));
 	}
 	
 	private Task<Result<SendCommandToInstanceResult, InstanceActionFailure>> SendMinecraftCommand(SendCommandToInstanceCommand command) {

Controller/Phantom.Controller.Services/Agents/AgentManager.cs

@@ -21,7 +21,7 @@ sealed class AgentManager(
 	IActorRefFactory actorSystem,
 	AgentConnectionKeys agentConnectionKeys,
 	ControllerState controllerState,
-	MinecraftLaunchRecipes launchRecipes,
+	MinecraftInstanceRecipes minecraftInstanceRecipes,
 	IDbContextProvider dbProvider,
 	CancellationToken cancellationToken
 ) {
@@ -42,7 +42,7 @@ sealed class AgentManager(
 	}
 	
 	private bool AddAgent(Guid? loggedInUserGuid, Guid agentGuid, AgentConfiguration configuration, AuthSecret authSecret, AgentRuntimeInfo runtimeInfo) {
-		var init = new AgentActor.Init(loggedInUserGuid, agentGuid, configuration, authSecret, runtimeInfo, agentConnectionKeys, controllerState, launchRecipes, dbProvider, cancellationToken);
+		var init = new AgentActor.Init(loggedInUserGuid, agentGuid, configuration, authSecret, runtimeInfo, agentConnectionKeys, controllerState, minecraftInstanceRecipes, dbProvider, cancellationToken);
 		var name = "Agent:" + agentGuid;
 		return agentsByAgentGuid.TryAdd(agentGuid, actorSystem.ActorOf(AgentActor.Factory(init), name));
 	}

Controller/Phantom.Controller.Services/ControllerServices.cs

@@ -20,7 +20,7 @@ public sealed class ControllerServices : IDisposable {
 	
 	private ControllerState ControllerState { get; }
 	private MinecraftVersions MinecraftVersions { get; }
-	private MinecraftLaunchRecipes LaunchRecipes { get; }
+	private MinecraftInstanceRecipes MinecraftInstanceRecipes { get; }
 	
 	private AuthenticatedUserCache AuthenticatedUserCache { get; }
 	private UserManager UserManager { get; }
@@ -51,7 +51,7 @@ public sealed class ControllerServices : IDisposable {
 		
 		this.ControllerState = new ControllerState();
 		this.MinecraftVersions = new MinecraftVersions();
-		this.LaunchRecipes = new MinecraftLaunchRecipes(MinecraftVersions);
+		this.MinecraftInstanceRecipes = new MinecraftInstanceRecipes(MinecraftVersions);
 		
 		this.AuthenticatedUserCache = new AuthenticatedUserCache();
 		this.UserManager = new UserManager(AuthenticatedUserCache, ControllerState, dbProvider);
@@ -60,7 +60,7 @@ public sealed class ControllerServices : IDisposable {
 		this.UserLoginManager = new UserLoginManager(AuthenticatedUserCache, dbProvider);
 		this.PermissionManager = new PermissionManager(dbProvider);
 		
-		this.AgentManager = new AgentManager(ActorSystem, new AgentConnectionKeys(agentCertificateThumbprint), ControllerState, LaunchRecipes, dbProvider, cancellationToken);
+		this.AgentManager = new AgentManager(ActorSystem, new AgentConnectionKeys(agentCertificateThumbprint), ControllerState, MinecraftInstanceRecipes, dbProvider, cancellationToken);
 		this.InstanceLogManager = new InstanceLogManager();
 		
 		this.AuditLogManager = new AuditLogManager(dbProvider);

Controller/Phantom.Controller.Services/Instances/InstanceActor.cs

@@ -1,7 +1,7 @@
 using Phantom.Common.Data;
 using Phantom.Common.Data.Agent.Instance.Launch;
+using Phantom.Common.Data.Agent.Instance.Stop;
 using Phantom.Common.Data.Instance;
-using Phantom.Common.Data.Minecraft;
 using Phantom.Common.Data.Replies;
 using Phantom.Common.Data.Web.Instance;
 using Phantom.Common.Messages.Agent;
@@ -71,11 +71,11 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
 	
 	public sealed record SetPlayerCountsCommand(InstancePlayerCounts? PlayerCounts) : ICommand;
 	
-	public sealed record ConfigureInstanceCommand(Guid AuditLogUserGuid, Guid InstanceGuid, InstanceConfiguration Configuration, InstanceLaunchRecipe LaunchRecipe, bool IsCreatingInstance) : ICommand, ICanReply<Result<ConfigureInstanceResult, InstanceActionFailure>>;
+	public sealed record ConfigureInstanceCommand(Guid AuditLogUserGuid, Guid InstanceGuid, InstanceConfiguration Configuration, InstanceLaunchRecipe LaunchRecipe, InstanceStopRecipe StopRecipe, bool IsCreatingInstance) : ICommand, ICanReply<Result<ConfigureInstanceResult, InstanceActionFailure>>;
 	
 	public sealed record LaunchInstanceCommand(Guid AuditLogUserGuid) : ICommand, ICanReply<Result<LaunchInstanceResult, InstanceActionFailure>>;
 	
-	public sealed record StopInstanceCommand(Guid AuditLogUserGuid, MinecraftStopStrategy StopStrategy) : ICommand, ICanReply<Result<StopInstanceResult, InstanceActionFailure>>;
+	public sealed record StopInstanceCommand(Guid AuditLogUserGuid, InstanceStopRecipe StopRecipe) : ICommand, ICanReply<Result<StopInstanceResult, InstanceActionFailure>>;
 	
 	public sealed record SendCommandToInstanceCommand(Guid AuditLogUserGuid, string Command) : ICommand, ICanReply<Result<SendCommandToInstanceResult, InstanceActionFailure>>;
 	
@@ -95,7 +95,7 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
 	}
 	
 	private async Task<Result<ConfigureInstanceResult, InstanceActionFailure>> ConfigureInstance(ConfigureInstanceCommand command) {
-		var message = new ConfigureInstanceMessage(command.InstanceGuid, command.Configuration.AsInfo, command.LaunchRecipe);
+		var message = new ConfigureInstanceMessage(command.InstanceGuid, command.Configuration.AsInfo, command.LaunchRecipe, LaunchNow: false, command.StopRecipe);
 		var result = await SendInstanceActionMessage<ConfigureInstanceMessage, ConfigureInstanceResult>(message);
 		
 		if (result.Is(ConfigureInstanceResult.Success)) {
@@ -127,12 +127,12 @@ sealed class InstanceActor : ReceiveActor<InstanceActor.ICommand> {
 	}
 	
 	private async Task<Result<StopInstanceResult, InstanceActionFailure>> StopInstance(StopInstanceCommand command) {
-		var message = new StopInstanceMessage(instanceGuid, command.StopStrategy);
+		var message = new StopInstanceMessage(instanceGuid, command.StopRecipe);
 		var result = await SendInstanceActionMessage<StopInstanceMessage, StopInstanceResult>(message);
 		
 		if (result.Is(StopInstanceResult.StopInitiated)) {
 			SetLaunchAutomatically(false);
-			databaseStorageActor.Tell(new InstanceDatabaseStorageActor.StoreInstanceStoppedCommand(command.AuditLogUserGuid, command.StopStrategy));
+			databaseStorageActor.Tell(new InstanceDatabaseStorageActor.StoreInstanceStoppedCommand(command.AuditLogUserGuid));
 		}
 		
 		return result;

Controller/Phantom.Controller.Services/Instances/InstanceDatabaseStorageActor.cs

@@ -1,6 +1,5 @@
-using Phantom.Common.Data.Minecraft;
-using Phantom.Common.Data.Web.Instance;
-using Phantom.Common.Data.Web.Minecraft;
+using Phantom.Common.Data.Web.Instance;
+using Phantom.Common.Data.Web.Java;
 using Phantom.Controller.Database;
 using Phantom.Controller.Database.Entities;
 using Phantom.Controller.Database.Repositories;
@@ -44,7 +43,7 @@ sealed class InstanceDatabaseStorageActor : ReceiveActor<InstanceDatabaseStorage
 	
 	public sealed record StoreInstanceLaunchedCommand(Guid AuditLogUserGuid) : ICommand;
 	
-	public sealed record StoreInstanceStoppedCommand(Guid AuditLogUserGuid, MinecraftStopStrategy StopStrategy) : ICommand;
+	public sealed record StoreInstanceStoppedCommand(Guid AuditLogUserGuid) : ICommand;
 	
 	public sealed record StoreInstanceCommandSentCommand(Guid AuditLogUserGuid, string Command) : ICommand;
 	
@@ -100,7 +99,7 @@ sealed class InstanceDatabaseStorageActor : ReceiveActor<InstanceDatabaseStorage
 		}
 		
 		var auditLogWriter = new AuditLogRepository(db).Writer(command.AuditLogUserGuid);
-		auditLogWriter.InstanceStopped(instanceGuid, command.StopStrategy.Seconds);
+		auditLogWriter.InstanceStopped(instanceGuid);
 		
 		await db.Ctx.SaveChangesAsync(cancellationToken);
 	}

Controller/Phantom.Controller.Services/Rpc/WebMessageHandlerActor.cs

@@ -156,7 +156,7 @@ sealed class WebMessageHandlerActor : ReceiveActor<IMessageToController> {
 			userLoginManager.GetLoggedInUser(message.AuthToken),
 			Permission.ControlInstances,
 			message.AgentGuid,
-			loggedInUserGuid => new AgentActor.StopInstanceCommand(loggedInUserGuid, message.InstanceGuid, message.StopStrategy)
+			loggedInUserGuid => new AgentActor.StopInstanceCommand(loggedInUserGuid, message.InstanceGuid, message.AfterSeconds)
 		);
 	}
 	

Utils/Phantom.Utils/Net/HttpHeadersExtensions.cs

@@ -1,21 +0,0 @@
-using System.Net.Http.Headers;
-using Phantom.Utils.IO;
-
-namespace Phantom.Utils.Net;
-
-public static class HttpHeadersExtensions {
-	private const string ContentLength = "Content-Length";
-	
-	extension(HttpResponseHeaders headers) {
-		public FileSize? ContentLength {
-			get {
-				if (!headers.TryGetValues(ContentLength, out var values)) {
-					return null;
-				}
-				
-				string? value = values.FirstOrDefault();
-				return value != null && ulong.TryParse(value, out ulong result) ? new FileSize(result) : null;
-			}
-		}
-	}
-}

Web/Phantom.Web.Services/Instances/InstanceManager.cs

@@ -1,6 +1,5 @@
 using System.Collections.Immutable;
 using Phantom.Common.Data;
-using Phantom.Common.Data.Minecraft;
 using Phantom.Common.Data.Replies;
 using Phantom.Common.Data.Web.Instance;
 using Phantom.Common.Data.Web.Users;
@@ -56,9 +55,9 @@ public sealed class InstanceManager(ControllerConnection controllerConnection) {
 		}
 	}
 	
-	public async Task<Result<StopInstanceResult, UserInstanceActionFailure>> StopInstance(AuthenticatedUser? authenticatedUser, Guid agentGuid, Guid instanceGuid, MinecraftStopStrategy stopStrategy, CancellationToken cancellationToken) {
+	public async Task<Result<StopInstanceResult, UserInstanceActionFailure>> StopInstance(AuthenticatedUser? authenticatedUser, Guid agentGuid, Guid instanceGuid, ushort afterSeconds, CancellationToken cancellationToken) {
 		if (authenticatedUser != null && authenticatedUser.Info.CheckPermission(Permission.ControlInstances)) {
-			var message = new StopInstanceMessage(authenticatedUser.Token, agentGuid, instanceGuid, stopStrategy);
+			var message = new StopInstanceMessage(authenticatedUser.Token, agentGuid, instanceGuid, afterSeconds);
 			return await controllerConnection.Send<StopInstanceMessage, Result<StopInstanceResult, UserInstanceActionFailure>>(message, cancellationToken);
 		}
 		else {

Web/Phantom.Web/Shared/InstanceAddOrEditForm.razor

@@ -6,6 +6,7 @@
 @using Phantom.Common.Data.Replies
 @using Phantom.Common.Data.Web.Agent
 @using Phantom.Common.Data.Web.Instance
+@using Phantom.Common.Data.Web.Java
 @using Phantom.Common.Data.Web.Minecraft
 @using Phantom.Common.Data.Web.Users
 @using Phantom.Common.Messages.Web.ToController

Web/Phantom.Web/Shared/InstanceStopDialog.razor

@@ -1,5 +1,4 @@
 @using System.ComponentModel.DataAnnotations
-@using Phantom.Common.Data.Minecraft
 @using Phantom.Common.Data.Replies
 @using Phantom.Common.Data.Web.Users
 @using Phantom.Utils.Result
@@ -54,7 +53,7 @@
   private async Task StopInstance(EditContext context) {
     await form.SubmitModel.StartSubmitting();
 
-    var result = await InstanceManager.StopInstance(await GetAuthenticatedUser(), AgentGuid, InstanceGuid, new MinecraftStopStrategy(form.StopInSeconds), CancellationToken);
+    var result = await InstanceManager.StopInstance(await GetAuthenticatedUser(), AgentGuid, InstanceGuid, form.StopInSeconds, CancellationToken);
 
     switch (result.Variant()) {
       case Ok<StopInstanceResult>(StopInstanceResult.StopInitiated):

Web/Phantom.Web/Utils/Messages.cs

@@ -1,6 +1,6 @@
 using Phantom.Common.Data.Instance;
 using Phantom.Common.Data.Replies;
-using Phantom.Common.Data.Web.Minecraft;
+using Phantom.Common.Data.Web.Java;
 using Phantom.Common.Data.Web.Users;
 
 namespace Phantom.Web.Utils;