feat: Start/Stop server buttons, server stays running until manual stop (#53)

- Replace checkbox+auto-run with Start Server / Stop Server / Run Client buttons
- Server stays running after start, user controls when to stop
- SimulationService split into StartServerAsync / StopServerAsync / RunClientAsync
- SimulateConfigModel: remove AutoRun, add ServerRunning flag

Author: JusterZhu

src/Models/SimulateConfigModel.cs

@@ -16,6 +16,6 @@ public partial class SimulateConfigModel : ObservableObject
     [ObservableProperty] private string _appSecretKey = "dfeb5833-975e-4afb-88f1-6278ee9aeff6";
     [ObservableProperty] private string _productId = "2d974e2a-31e6-4887-9bb1-b4689e98c77a";
     [ObservableProperty] private string _outputDirectory = string.Empty;
-    [ObservableProperty] private bool _autoRun = true;
     public int ServerPort { get; set; } = 5000;
+    public bool ServerRunning { get; set; }
 }

src/Services/SimulationService.cs

@@ -10,215 +10,144 @@
 
 namespace GeneralUpdate.Tools.Services;
 
-/// <summary>
-/// Orchestrates the full update simulation: server, client, upgrade, log collection.
-/// </summary>
 public class SimulationService
 {
     private readonly ClientGeneratorService _generator = new();
     private readonly LocalUpdateServer _server = new();
-    private readonly StringBuilder _fullLog = new();
     private int _timeoutSeconds = 120;
 
-    public IReadOnlyList<string> LogLines => _fullLog.ToString().Split('\n').ToList();
+    public string ServerBaseUrl => _server.BaseUrl;
 
-    public async Task<SimulationResult> RunAsync(
-        SimulateConfigModel config,
-        IProgress<string>? progress = null,
-        CancellationToken ct = default)
+    /// <summary>
+    /// Generate scripts and start the local update server. Server stays running until StopServerAsync is called.
+    /// </summary>
+    public async Task StartServerAsync(SimulateConfigModel config, IProgress<string>? progress = null)
+    {
+        Log("STEP 1: Validating inputs", progress);
+        Validate(config);
+
+        Log("STEP 2: Generating client.csx and upgrade.csx", progress);
+        await _generator.GenerateAsync(config, config.OutputDirectory);
+        Log($"  client.csx → {config.OutputDirectory}", progress);
+        Log($"  upgrade.csx → {config.OutputDirectory}", progress);
+
+        Log("STEP 3: Starting local server", progress);
+        var serverPatchDir = Path.Combine(config.OutputDirectory, ".server");
+        Directory.CreateDirectory(serverPatchDir);
+        var patchName = Path.GetFileName(config.PatchFilePath);
+        var patchDest = Path.Combine(serverPatchDir, patchName);
+        File.Copy(config.PatchFilePath, patchDest, true);
+
+        var hash = ComputeQuickHash(patchDest);
+        LocalUpdateServerFiles.Register(patchName, patchDest);
+        _server.Updates.Add((config.CurrentVersion, config.TargetVersion, hash, patchDest, config.AppType));
+
+        await _server.StartAsync(config.ServerPort);
+        config.ServerPort = _server.Port;
+        config.ServerRunning = true;
+        Log($"  Server running on {_server.BaseUrl}", progress);
+    }
+
+    /// <summary>
+    /// Stop the local update server.
+    /// </summary>
+    public async Task StopServerAsync()
+    {
+        await _server.DisposeAsync();
+        LocalUpdateServerFiles.Clear();
+    }
+
+    /// <summary>
+    /// Run the client script and return results. Server must already be running.
+    /// </summary>
+    public async Task<SimulationResult> RunClientAsync(SimulateConfigModel config, IProgress<string>? progress = null, CancellationToken ct = default)
     {
         var result = new SimulationResult();
         var sw = Stopwatch.StartNew();
 
         try
         {
-            // 1. Validate
-            Log("STEP 1: Validating inputs", progress);
-            Validate(config);
-
-            // 2. Prepare output directory
-            Log($"STEP 2: Preparing {config.OutputDirectory}", progress);
-            Directory.CreateDirectory(config.OutputDirectory);
-
-            // 3. Generate scripts first (always, even in manual mode)
-            Log("STEP 3: Generating client.csx and upgrade.csx", progress);
-            await _generator.GenerateAsync(config, config.OutputDirectory);
-            Log($"  client.csx → {config.OutputDirectory}", progress);
-            Log($"  upgrade.csx → {config.OutputDirectory}", progress);
-
-            // Manual mode: skip server + client run
-            if (!config.AutoRun)
-            {
-                Log("  Auto-run disabled — scripts ready for manual execution", progress);
-                Log($"  cd {config.OutputDirectory}", progress);
-                Log("  dotnet script client.csx", progress);
-                result.Success = true;
-                result.Notes.Add("Manual mode: scripts generated, not executed");
-                return result;
-            }
-
-            // 4. Set up server + copy patch
-            Log("STEP 4: Setting up local server", progress);
-            var serverPatchDir = Path.Combine(config.OutputDirectory, ".server");
-            Directory.CreateDirectory(serverPatchDir);
-            var patchName = Path.GetFileName(config.PatchFilePath);
-            var patchDest = Path.Combine(serverPatchDir, patchName);
-            File.Copy(config.PatchFilePath, patchDest, true);
-
-            var hash = ComputeQuickHash(patchDest);
-            LocalUpdateServerFiles.Register(patchName, patchDest);
-            _server.Updates.Add((config.CurrentVersion, config.TargetVersion, hash, patchDest, config.AppType));
-
-            await _server.StartAsync(config.ServerPort);
-            Log($"  Server running on {_server.BaseUrl}", progress);
-            config.ServerPort = _server.Port;
-
-            // 5. Run client
-            Log("STEP 5: Running client (dotnet script client.csx)", progress);
+            Log("Running client (dotnet script client.csx)", progress);
             var clientResult = await RunDotNetScript(config.OutputDirectory, "client.csx", ct);
             Log(clientResult.Output, progress);
 
             if (!clientResult.Success)
             {
-                Log("  Client failed - see output above", progress);
                 result.Success = false;
                 result.ErrorMessage = "Client exited with error";
                 return result;
             }
 
-            Log("  Client completed successfully", progress);
+            Log("Client completed", progress);
+            await Task.Delay(2000, ct);
 
-            // 6. Verify the patch was applied
-            Log("STEP 6: Verifying update result", progress);
-            await Task.Delay(2000, ct); // Give upgrade process time to complete
-            VerifyUpdateResult(config, result);
+            var fileCount = Directory.GetFiles(config.AppDirectory, "*", SearchOption.AllDirectories).Length;
+            result.Notes.Add($"Files in app directory after update: {fileCount}");
 
             result.Success = true;
             result.Elapsed = sw.Elapsed;
-            Log($"✅ Simulation complete ({sw.Elapsed.TotalSeconds:F1}s)", progress);
+            Log($"Simulation complete ({sw.Elapsed.TotalSeconds:F1}s)", progress);
         }
         catch (Exception ex)
         {
             result.Success = false;
             result.ErrorMessage = ex.Message;
-            Log($"❌ Simulation failed: {ex.Message}", progress);
-        }
-        finally
-        {
-            try
-            {
-                await _server.DisposeAsync();
-                LocalUpdateServerFiles.Clear();
-            }
-            catch { }
-
-            result.FullLog = _fullLog.ToString();
+            Log($"Simulation failed: {ex.Message}", progress);
         }
 
+        result.FullLog = "";
         return result;
     }
 
     private void Validate(SimulateConfigModel config)
     {
         if (!Directory.Exists(config.AppDirectory))
             throw new DirectoryNotFoundException($"App directory not found: {config.AppDirectory}");
-
         if (!File.Exists(config.PatchFilePath))
             throw new FileNotFoundException($"Patch file not found: {config.PatchFilePath}");
-
         if (string.IsNullOrWhiteSpace(config.OutputDirectory))
             throw new ArgumentException("Output directory is required");
-
-        // Check dotnet
         try
         {
-            var psi = new ProcessStartInfo("dotnet", "--version")
-            {
-                RedirectStandardOutput = true,
-                UseShellExecute = false,
-                CreateNoWindow = true
-            };
-            using var p = Process.Start(psi);
-            p?.WaitForExit(5000);
+            var psi = new ProcessStartInfo("dotnet", "--version") { RedirectStandardOutput = true, UseShellExecute = false, CreateNoWindow = true };
+            using var p = Process.Start(psi); p?.WaitForExit(5000);
             var ver = p?.StandardOutput.ReadToEnd().Trim();
             if (string.IsNullOrEmpty(ver) || !ver.StartsWith("10.") && !ver.StartsWith("11."))
-                throw new InvalidOperationException(".NET 10.0 SDK is required. Install from https://dotnet.microsoft.com/");
+                throw new InvalidOperationException(".NET 10.0 SDK required");
         }
         catch (InvalidOperationException) { throw; }
-        catch { throw new InvalidOperationException("dotnet CLI not found. Install .NET 10.0 SDK."); }
+        catch { throw new InvalidOperationException("dotnet CLI not found"); }
     }
 
     private async Task<(bool Success, string Output)> RunDotNetScript(string workDir, string script, CancellationToken ct)
     {
         var psi = new ProcessStartInfo("dotnet", $"script {script}")
         {
             WorkingDirectory = workDir,
-            RedirectStandardOutput = true,
-            RedirectStandardError = true,
-            StandardOutputEncoding = System.Text.Encoding.UTF8,
-            StandardErrorEncoding = System.Text.Encoding.UTF8,
-            UseShellExecute = false,
-            CreateNoWindow = true
+            RedirectStandardOutput = true, RedirectStandardError = true,
+            StandardOutputEncoding = Encoding.UTF8, StandardErrorEncoding = Encoding.UTF8,
+            UseShellExecute = false, CreateNoWindow = true
         };
-
         using var p = Process.Start(psi)!;
         var output = new StringBuilder();
-
-        var readTask = Task.Run(async () =>
-        {
-            while (!p.StandardOutput.EndOfStream)
-                output.AppendLine(await p.StandardOutput.ReadLineAsync(ct));
-        }, ct);
-
-        var errorTask = Task.Run(async () =>
-        {
-            while (!p.StandardError.EndOfStream)
-                output.AppendLine(await p.StandardError.ReadLineAsync(ct));
-        }, ct);
-
-        // Wait with timeout
+        var readTask = Task.Run(async () => { while (!p.StandardOutput.EndOfStream) output.AppendLine(await p.StandardOutput.ReadLineAsync(ct)); }, ct);
+        var errorTask = Task.Run(async () => { while (!p.StandardError.EndOfStream) output.AppendLine(await p.StandardError.ReadLineAsync(ct)); }, ct);
         var completed = p.WaitForExit(_timeoutSeconds * 1000);
-        if (!completed)
-        {
-            p.Kill(true);
-            return (false, output + "\n[TIMEOUT] Simulation exceeded time limit");
-        }
-
-        // Also check output for error indicators (GeneralUpdate catches exceptions internally)
+        if (!completed) { p.Kill(true); return (false, output + "\n[TIMEOUT]"); }
         await Task.WhenAll(readTask, errorTask);
         var outputStr = output.ToString();
         var hasError = outputStr.Contains("ERROR:") || outputStr.Contains("FATAL:") || outputStr.Contains("JsonException");
-
         return (!hasError && p.ExitCode == 0, outputStr);
     }
 
-    private void VerifyUpdateResult(SimulateConfigModel config, SimulationResult result)
-    {
-        // Check if delete_files.json was consumed (it should be gone or applied)
-        var deleteFile = Path.Combine(config.AppDirectory, "delete_files.json");
-        if (File.Exists(deleteFile))
-        {
-            result.Notes.Add("delete_files.json still present - HandleDeleteList may not have run");
-        }
-
-        // Count files changed in app directory
-        var fileCount = Directory.GetFiles(config.AppDirectory, "*", SearchOption.AllDirectories).Length;
-        result.Notes.Add($"Files in app directory after update: {fileCount}");
-    }
-
     private static string ComputeQuickHash(string filePath)
     {
         using var sha = System.Security.Cryptography.SHA256.Create();
         using var fs = File.OpenRead(filePath);
         return BitConverter.ToString(sha.ComputeHash(fs)).Replace("-", "").ToLowerInvariant();
     }
 
-    private void Log(string msg, IProgress<string>? progress)
-    {
-        var line = $"[{DateTime.Now:HH:mm:ss}] {msg}";
-        _fullLog.AppendLine(line);
-        progress?.Report(line);
-    }
+    private static void Log(string msg, IProgress<string>? progress) => progress?.Report($"[{DateTime.Now:HH:mm:ss}] {msg}");
 }
 
 public class SimulationResult

src/ViewModels/SimulateViewModel.cs

@@ -84,45 +84,50 @@ public int AppTypeIndex
     [RelayCommand] async Task SelectOutputDir() { var p = await PickFolder(_loc["Sim.SelectOutput"]); if (p != null) Config.OutputDirectory = p; }
 
     [RelayCommand]
-    async Task StartSimulation()
+    async Task StartServer()
     {
         if (string.IsNullOrWhiteSpace(Config.AppDirectory)) { Status = _loc["Sim.ValidateDirs"]; return; }
         if (string.IsNullOrWhiteSpace(Config.PatchFilePath)) { Status = _loc["Sim.ValidateDirs"]; return; }
         if (string.IsNullOrWhiteSpace(Config.OutputDirectory)) { Status = _loc["Sim.ValidateDirs"]; return; }
 
-        IsRunning = true;
-        Log.Clear();
-        Status = _loc["Sim.Starting"];
-
+        IsRunning = true; Log.Clear(); Status = _loc["Sim.Starting"];
         try
         {
-            var progress = new Progress<string>(L);
-            var result = await _sim.RunAsync(Config, progress);
+            await _sim.StartServerAsync(Config, new Progress<string>(L));
+            Status = $"Server: {_sim.ServerBaseUrl}";
+            L($"Server running on {_sim.ServerBaseUrl}");
+            L($"Manual: dotnet script client.csx");
+        }
+        catch (Exception ex) { Status = $"Error: {ex.Message}"; L($"FATAL: {ex}"); }
+        finally { IsRunning = false; }
+    }
 
+    [RelayCommand]
+    async Task StopServer()
+    {
+        await _sim.StopServerAsync();
+        Status = _loc["Patch.Ready"];
+        L("Server stopped");
+    }
+
+    [RelayCommand]
+    async Task RunClient()
+    {
+        if (!Config.ServerRunning) { Status = "Server not running"; return; }
+        IsRunning = true; Status = "Running client...";
+        try
+        {
+            var result = await _sim.RunClientAsync(Config, new Progress<string>(L));
             if (result.Success)
             {
                 Status = _loc.T("Sim.Completed", result.Elapsed.TotalSeconds);
-                L($"Result: {(result.Success ? "PASS" : "FAIL")}");
-                foreach (var note in result.Notes)
-                    L($"  Note: {note}");
-
                 var reportPath = await _report.GenerateAsync(Config, result, Config.OutputDirectory);
                 L(_loc.T("Sim.Report", reportPath));
             }
-            else
-            {
-                Status = _loc.T("Sim.Failed", result.ErrorMessage);
-            }
-        }
-        catch (Exception ex)
-        {
-            Status = $"Error: {ex.Message}";
-            L($"FATAL: {ex}");
-        }
-        finally
-        {
-            IsRunning = false;
+            else { Status = _loc.T("Sim.Failed", result.ErrorMessage ?? "unknown"); }
         }
+        catch (Exception ex) { Status = $"Error: {ex.Message}"; L($"FATAL: {ex}"); }
+        finally { IsRunning = false; }
     }
 
     void L(string msg) => Log.Add($"[{DateTime.Now:HH:mm:ss}] {msg}");

src/Views/SimulateView.axaml

@@ -81,12 +81,24 @@
                 </StackPanel>
             </Border>
 
-            <!-- Run -->
-            <CheckBox Content="{Binding Source={x:Static svc:LocalizationService.Instance}, Path=[Sim.AutoRun]}"
-                      IsChecked="{Binding Config.AutoRun}"/>
-            <Button Content="{Binding Source={x:Static svc:LocalizationService.Instance}, Path=[Sim.Start]}"
-                    Command="{Binding StartSimulationCommand}"
-                    IsEnabled="{Binding !IsRunning}" Height="40" FontSize="14" HorizontalAlignment="Stretch"/>
+            <!-- Server Controls -->
+            <Grid ColumnDefinitions="*,*,Auto" Margin="0,4,0,0">
+                <Button Grid.Column="0" Content="🚀 Start Server"
+                        Command="{Binding StartServerCommand}"
+                        IsEnabled="{Binding !Config.ServerRunning}"
+                        Height="40" FontSize="14"
+                        Margin="0,0,4,0"/>
+                <Button Grid.Column="1" Content="⏹ Stop Server"
+                        Command="{Binding StopServerCommand}"
+                        IsEnabled="{Binding Config.ServerRunning}"
+                        Height="40" FontSize="14"
+                        Margin="4,0"/>
+                <Button Grid.Column="2" Content="▶ Run Client"
+                        Command="{Binding RunClientCommand}"
+                        IsEnabled="{Binding Config.ServerRunning}"
+                        Height="40" FontSize="14" MinWidth="110"
+                        Margin="4,0,0,0"/>
+            </Grid>
             <TextBlock Text="{Binding Status}" FontSize="13"/>
 
             <!-- Log -->