Auto-install .NET 8 runtimes if missing

A fresh Windows Server install has neither ASP.NET Core 8 nor .NET
Desktop 8, so the Service refuses to start and the GUI fails to
launch — the symptoms link to aka.ms/dotnet-core-applaunch but it's
not obvious from the GUI itself what's wrong.

Setup now:
- Detects each runtime by looking for an 8.x folder under
  %ProgramFiles%\dotnet\shared\Microsoft.{AspNetCore,WindowsDesktop}.App
- Uses Inno Setup's built-in TDownloadWizardPage to fetch any missing
  runtime from the aka.ms redirect and runs `/install /quiet /norestart`
- Treats Microsoft's 1638 / 3010 / 1641 exit codes as success

If the box has no internet, the prereq install fails with a clear
message and a "continue anyway?" prompt. README + installation docs
list the manual download URLs and `dotnet --list-runtimes` check;
troubleshooting has a section pointing at the same fix when the
service won't start after install.

.gitea/workflows/release.yml

@@ -0,0 +1,102 @@
+name: Release (Gitea)
+
+# Lives in .gitea/workflows/ so it runs on Gitea Actions only. The GitHub-side
+# release lives in .github/workflows/release.yml.
+#
+# Triggered automatically on v* tag pushes; can also be invoked manually via
+# workflow_dispatch with a version override (useful for testing the runner
+# without bumping the project version).
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version to build (e.g. 0.1.4). Defaults to Directory.Build.props.'
+        required: false
+
+jobs:
+  build-installer:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '8.0.x'
+
+      - name: Resolve version
+        id: ver
+        shell: pwsh
+        run: |
+          if ('${{ github.event_name }}' -eq 'push') {
+            $v = '${{ github.ref_name }}'.TrimStart('v')
+          } elseif ('${{ inputs.version }}') {
+            $v = '${{ inputs.version }}'
+          } else {
+            [xml]$p = Get-Content Directory.Build.props
+            $v = $p.Project.PropertyGroup.Version
+          }
+          "version=$v" | Out-File $env:GITHUB_OUTPUT -Append
+          Write-Host "Building version $v"
+
+      - name: Restore + test
+        shell: pwsh
+        run: |
+          dotnet restore WebhookServer.sln
+          dotnet test WebhookServer.sln -c Release
+
+      - name: Ensure Inno Setup is installed
+        shell: pwsh
+        run: |
+          if (-not (Get-Command iscc -ErrorAction SilentlyContinue) -and `
+              -not (Test-Path 'C:\Program Files (x86)\Inno Setup 6\ISCC.exe') -and `
+              -not (Test-Path 'C:\Program Files\Inno Setup 6\ISCC.exe')) {
+            choco install innosetup --no-progress -y
+          }
+
+      - name: Build installer
+        shell: pwsh
+        run: ./scripts/build-installer.ps1 -VersionOverride ${{ steps.ver.outputs.version }}
+
+      - name: Upload installer artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: WebhookServer-Setup-${{ steps.ver.outputs.version }}
+          path: dist/WebhookServer-Setup-*.exe
+
+      - name: Create Gitea release with installer attached
+        if: startsWith(github.ref, 'refs/tags/v')
+        shell: pwsh
+        env:
+          GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          $version   = '${{ steps.ver.outputs.version }}'
+          $tag       = '${{ github.ref_name }}'
+          $repo      = '${{ github.repository }}'
+          $serverUrl = '${{ github.server_url }}'
+          $apiBase   = "$serverUrl/api/v1/repos/$repo"
+          $headers   = @{ Authorization = "token $env:GITEA_TOKEN" }
+
+          # 1. Create the release.
+          $isPre = $version.StartsWith('0.')
+          $createBody = @{
+            tag_name   = $tag
+            name       = "Webhook Server $version"
+            body       = "Automated build via Gitea Actions runner."
+            draft      = $false
+            prerelease = $isPre
+          } | ConvertTo-Json
+          $rel = Invoke-RestMethod -Uri "$apiBase/releases" -Method Post `
+              -Headers $headers -ContentType 'application/json' -Body $createBody
+          Write-Host "Created release id=$($rel.id) tag=$tag"
+
+          # 2. Attach the installer.
+          $file = Get-Item "dist/WebhookServer-Setup-$version.exe"
+          $uploadUri = "$apiBase/releases/$($rel.id)/assets?name=$($file.Name)"
+          Invoke-RestMethod -Uri $uploadUri -Method Post -Headers $headers `
+              -ContentType 'application/octet-stream' -InFile $file.FullName | Out-Null
+          Write-Host "Uploaded $($file.Name) ($([math]::Round($file.Length / 1MB, 2)) MB) to $tag"

.github/workflows/ci.yml

@@ -5,6 +5,7 @@ on:
     branches: [main]
   pull_request:
     branches: [main]
+  workflow_dispatch:
 
 jobs:
   build:

.github/workflows/release.yml

@@ -12,6 +12,9 @@ on:
 
 jobs:
   build-installer:
+    # Gitea reads .github/workflows/ for compatibility, but the create-release
+    # step uses a GitHub-only action. Skip the whole job on non-GitHub runners.
+    if: github.server_url == 'https://github.com'
     runs-on: windows-latest
     permissions:
       contents: write   # needed to create releases / upload assets

.github/workflows/wiki-sync.yml

@@ -11,6 +11,10 @@ on:
 
 jobs:
   sync:
+    # Gitea reads .github/workflows/ for compatibility, but this workflow
+    # pushes to a GitHub-hosted wiki. Skip on non-GitHub runners; the Gitea
+    # wiki is synced separately via scripts/sync-wiki.ps1.
+    if: github.server_url == 'https://github.com'
     runs-on: windows-latest
     permissions:
       contents: write

Directory.Build.props

@@ -1,7 +1,7 @@
 <Project>
 
   <PropertyGroup>
-    <Version>0.1.2</Version>
+    <Version>0.1.4</Version>
     <Authors>Justin Paul</Authors>
     <Company>Justin Paul</Company>
     <Product>Webhook Server</Product>

README.md

@@ -7,7 +7,7 @@ Designed for sysadmins who want to wire up tools like **Zerto pre/post scripts**
 ## Quickstart
 
 1. **Download** the latest installer: <https://github.com/recklessop/webhook-server/releases/latest>
-2. **Run it.** UAC accept → next, next, finish. Adds a Start Menu entry, registers and starts the Windows Service.
+2. **Run it.** UAC accept → next, next, finish. Adds a Start Menu entry, registers and starts the Windows Service. The installer also downloads + installs the **.NET 8 runtimes** (ASP.NET Core + Desktop) if they're missing — fresh Windows Server installs need this.
 3. **Open Webhook Server** from the Start Menu (auto-elevates).
 4. **File → New endpoint**, configure a slug + script, save, hit the URL.
 

docs/installation.md

@@ -6,10 +6,34 @@ This page covers a fresh install. If you already have Webhook Server installed,
 
 - Windows 10, Windows 11, or Windows Server 2019 / 2022 / 2025
 - Administrator rights to install the service and to run the GUI
+- **.NET 8 runtimes** (the installer downloads + installs them automatically if missing — see below)
 - (Optional, only if you publish from source) .NET 8 SDK
 
 The installer is **x64 only**. There is no x86 build.
 
+### .NET 8 runtimes
+
+Webhook Server is published as framework-dependent (so the installer stays small) and needs two .NET 8 runtimes on the target machine:
+
+| Runtime | Used by | Auto-installed by setup |
+|---|---|---|
+| ASP.NET Core 8 Runtime (`Microsoft.AspNetCore.App` 8.x) | the Service / Kestrel | Yes |
+| .NET Desktop Runtime 8 (`Microsoft.WindowsDesktop.App` 8.x) | the WPF GUI | Yes |
+
+A clean Windows Server install has neither. The installer detects what's missing and downloads + installs each one silently before copying our files. If the machine has no internet access, install them manually first:
+
+- ASP.NET Core 8 Runtime — <https://aka.ms/dotnet/8.0/aspnetcore-runtime-win-x64.exe>
+- .NET Desktop Runtime 8 — <https://aka.ms/dotnet/8.0/windowsdesktop-runtime-win-x64.exe>
+
+Run each with `/install /quiet /norestart` for unattended installs, or just double-click. A reboot is rarely required.
+
+To check what's already installed:
+
+```powershell
+dotnet --list-runtimes
+# expect to see Microsoft.AspNetCore.App 8.x.y and Microsoft.WindowsDesktop.App 8.x.y
+```
+
 ## 1. Download
 
 Grab the latest installer from the GitHub Releases page:

docs/troubleshooting.md

@@ -38,6 +38,28 @@ You launched the GUI without elevation. The admin pipe ACL is `SYSTEM` + `Admini
 
 **Fix in v0.1.0**: right-click the Start Menu shortcut → **Run as administrator**, or upgrade.
 
+### Service won't start after install / GUI says "Disconnected" with no obvious error
+
+If `Get-Service WebhookServer` shows it stopped and `Start-Service WebhookServer` fails, or the GUI itself won't even launch, you're probably missing a .NET 8 runtime. The v0.1.4+ installer auto-fetches them, but a clean Windows Server box might still hit this if the install was offline or used an older installer.
+
+Check what's installed:
+
+```powershell
+dotnet --list-runtimes
+```
+
+You need both:
+
+- `Microsoft.AspNetCore.App 8.x.y` — for the Service
+- `Microsoft.WindowsDesktop.App 8.x.y` — for the GUI
+
+If either is missing, install from:
+
+- ASP.NET Core 8 Runtime — <https://aka.ms/dotnet/8.0/aspnetcore-runtime-win-x64.exe>
+- .NET Desktop Runtime 8 — <https://aka.ms/dotnet/8.0/windowsdesktop-runtime-win-x64.exe>
+
+Re-run with `/install /quiet /norestart` for unattended installs. Then `Start-Service WebhookServer`.
+
 ### "Connection refused" hitting the hook URL
 
 Three possibilities, in order of probability:

installer/webhook-server.iss

@@ -86,6 +86,17 @@ Filename: "powershell.exe"; \
     RunOnceId: "RemoveWebhookService"
 
 [Code]
+const
+  // aka.ms redirects to the latest 8.0.x patch. Inno Setup's downloader
+  // follows redirects via the Windows HTTP stack.
+  AspNetCore8Url  = 'https://aka.ms/dotnet/8.0/aspnetcore-runtime-win-x64.exe';
+  WinDesktop8Url  = 'https://aka.ms/dotnet/8.0/windowsdesktop-runtime-win-x64.exe';
+  AspNetCore8File = 'aspnetcore-runtime-8.0-win-x64.exe';
+  WinDesktop8File = 'windowsdesktop-runtime-8.0-win-x64.exe';
+
+var
+  DownloadPage: TDownloadWizardPage;
+
 function ServiceExists(): Boolean;
 var
   ResultCode: Integer;
@@ -96,6 +107,119 @@ begin
   Result := (ResultCode = 0);
 end;
 
+// True if a Microsoft.* shared-framework directory under
+// %ProgramFiles%\dotnet\shared contains at least one 8.x.y subfolder.
+function HasDotNet8(const RuntimeName: String): Boolean;
+var
+  rec: TFindRec;
+  base: String;
+begin
+  Result := False;
+  base := ExpandConstant('{commonpf}\dotnet\shared\') + RuntimeName;
+  if not DirExists(base) then Exit;
+  if FindFirst(base + '\8.*', rec) then
+  try
+    repeat
+      if (rec.Name <> '.') and (rec.Name <> '..') and
+         DirExists(base + '\' + rec.Name) then begin
+        Result := True;
+        Exit;
+      end;
+    until not FindNext(rec);
+  finally
+    FindClose(rec);
+  end;
+end;
+
+function NeedsAspNet8(): Boolean;
+begin
+  Result := not HasDotNet8('Microsoft.AspNetCore.App');
+end;
+
+function NeedsWinDesktop8(): Boolean;
+begin
+  Result := not HasDotNet8('Microsoft.WindowsDesktop.App');
+end;
+
+procedure InitializeWizard;
+begin
+  DownloadPage := CreateDownloadPage(
+    'Downloading prerequisites',
+    'Webhook Server needs the .NET 8 runtimes. Setup is fetching them now.',
+    nil);
+end;
+
+// Runs a downloaded runtime installer silently. Treats Microsoft's
+// "success but reboot pending" / "newer already installed" exit codes
+// as successes so we don't fail the whole install over a benign result.
+function RunRuntimeInstaller(const FileName, DisplayName: String): String;
+var
+  resultCode: Integer;
+  fullPath: String;
+begin
+  Result := '';
+  fullPath := ExpandConstant('{tmp}\') + FileName;
+  if not Exec(fullPath, '/install /quiet /norestart', '', SW_HIDE,
+              ewWaitUntilTerminated, resultCode) then begin
+    Result := 'Could not launch the ' + DisplayName + ' installer.';
+    Exit;
+  end;
+  case resultCode of
+    0, 1638, 3010, 1641: ;
+  else
+    Result := DisplayName + ' installer failed (exit code ' +
+              IntToStr(resultCode) + ').';
+  end;
+end;
+
+function NextButtonClick(CurPageID: Integer): Boolean;
+var
+  errMsg: String;
+begin
+  Result := True;
+  if CurPageID <> wpReady then Exit;
+  if not (NeedsAspNet8 or NeedsWinDesktop8) then Exit;
+
+  DownloadPage.Clear;
+  if NeedsAspNet8 then
+    DownloadPage.Add(AspNetCore8Url, AspNetCore8File, '');
+  if NeedsWinDesktop8 then
+    DownloadPage.Add(WinDesktop8Url, WinDesktop8File, '');
+  DownloadPage.Show;
+  try
+    try
+      DownloadPage.Download;
+    except
+      if MsgBox('Failed to download the .NET 8 runtimes:' + #13#10#13#10 +
+                GetExceptionMessage + #13#10#13#10 +
+                'Continue installing anyway? Webhook Server will not start ' +
+                'until the runtimes are installed manually.',
+                mbError, MB_YESNO) = IDNO then
+        Result := False;
+      Exit;
+    end;
+  finally
+    DownloadPage.Hide;
+  end;
+
+  if NeedsAspNet8 then begin
+    errMsg := RunRuntimeInstaller(AspNetCore8File, 'ASP.NET Core 8 Runtime');
+    if errMsg <> '' then begin
+      MsgBox(errMsg, mbError, MB_OK);
+      Result := False;
+      Exit;
+    end;
+  end;
+  if NeedsWinDesktop8 then begin
+    errMsg := RunRuntimeInstaller(WinDesktop8File, '.NET Desktop Runtime 8');
+    if errMsg <> '' then begin
+      MsgBox(errMsg, mbError, MB_OK);
+      Result := False;
+      Exit;
+    end;
+  end;
+end;
+
 function PrepareToInstall(var NeedsRestart: Boolean): String;
 var
   ResultCode: Integer;

scripts/build-installer.ps1

@@ -53,15 +53,125 @@ if ($LASTEXITCODE -ne 0) { throw 'service publish failed' }
     -c $Configuration -r win-x64 --self-contained false -o $publishGui | Out-Host
 if ($LASTEXITCODE -ne 0) { throw 'GUI publish failed' }
 
-# 2. Compile installer.
+# 2. Pre-flight: confirm every source path the .iss references exists, and
+#    surface the longest path so MAX_PATH issues are obvious in the log.
+function Show-SourcePath($label, $path, [switch]$Recursive) {
+    if (-not (Test-Path $path)) { Write-Warning "MISSING $label : $path"; return }
+    $items = if ($Recursive) {
+        Get-ChildItem $path -Recurse -File -ErrorAction SilentlyContinue
+    } else {
+        Get-ChildItem $path -File -ErrorAction SilentlyContinue
+    }
+    $count   = ($items | Measure-Object).Count
+    $longest = ($items | Measure-Object -Maximum -Property { $_.FullName.Length }).Maximum
+    Write-Host ("  {0,-30} files={1,-5} longestPath={2,-5} root={3}" -f $label, $count, $longest, $path)
+}
+
+Write-Host ""
+Write-Host "--- pre-flight: source paths the .iss will read ---" -ForegroundColor Cyan
+Show-SourcePath 'publish\service'        $publishSvc                              -Recursive
+Show-SourcePath 'publish\gui'            $publishGui                              -Recursive
+Show-SourcePath 'scripts'                (Join-Path $repoRoot 'scripts')
+Show-SourcePath 'scripts\examples'       (Join-Path $repoRoot 'scripts\examples') -Recursive
+Show-SourcePath 'docs'                   (Join-Path $repoRoot 'docs')             -Recursive
+Show-SourcePath 'resources'              (Join-Path $repoRoot 'resources')
+Show-SourcePath 'README.md (file)'       (Join-Path $repoRoot 'README.md')
+
+$lpe = (Get-ItemProperty 'HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem' `
+            -Name LongPathsEnabled -ErrorAction SilentlyContinue).LongPathsEnabled
+Write-Host "  LongPathsEnabled (HKLM): $lpe"
+Write-Host ""
+
+# 3. Compile installer.
 $iscc = Find-InnoCompiler
 $iss = Join-Path $repoRoot 'installer\webhook-server.iss'
 $dist = Join-Path $repoRoot 'dist'
 New-Item -ItemType Directory -Path $dist -Force | Out-Null
 
 Write-Host "Compiling installer with $iscc"
-& $iscc "/DAppVersion=$version" $iss
-if ($LASTEXITCODE -ne 0) { throw 'Inno Setup compile failed' }
+# Run ISCC from the .iss directory with just the bare filename. When invoked
+# with a deeply-nested absolute path on the act-runner host (under
+# %SystemRoot%\System32\config\systemprofile\...), ISCC sometimes prints a
+# generic "The system cannot find the path specified." before it touches any
+# source files. cd-ing first sidesteps it.
+$issDir  = Split-Path $iss -Parent
+$issName = Split-Path $iss -Leaf
+
+# Extra pre-flight: confirm the specific files our .iss references that a
+# trivial test .iss wouldn't (icon, README, scripts) actually exist relative
+# to the .iss directory the way ISCC will resolve them (RepoRoot = ..\).
+Write-Host "--- pre-flight: paths the .iss references via {#RepoRoot} ---" -ForegroundColor Cyan
+$issRefs = @(
+    'resources\webhook-server.ico',
+    'README.md',
+    'scripts\install-service.ps1',
+    'scripts\uninstall-service.ps1',
+    'publish\service',
+    'publish\gui',
+    'docs',
+    'scripts\examples'
+)
+foreach ($ref in $issRefs) {
+    $abs = Join-Path $repoRoot $ref
+    $exists = Test-Path $abs
+    Write-Host ("  {0,-40} exists={1}  ({2})" -f $ref, $exists, $abs)
+}
+Write-Host ""
+
+Write-Host "--- runtime context ---" -ForegroundColor Cyan
+Write-Host "  whoami:        $(whoami)"
+Write-Host "  USERPROFILE:   $env:USERPROFILE"
+Write-Host "  APPDATA:       $env:APPDATA"
+Write-Host "  LOCALAPPDATA:  $env:LOCALAPPDATA"
+Write-Host "  TEMP:          $env:TEMP"
+$isccDir = Split-Path $iscc -Parent
+Write-Host "  ISCC dir:      $isccDir"
+foreach ($f in @('ISCC.exe','ISCmplr.dll','ISPP.dll','Default.isl','Compil32.exe')) {
+    $p = Join-Path $isccDir $f
+    Write-Host ("    {0,-15} exists={1}" -f $f, (Test-Path $p))
+}
+Write-Host ""
+
+Write-Host "  PS  location (pre):  $((Get-Location).Path)"
+Write-Host "  .NET cwd     (pre):  $([System.IO.Directory]::GetCurrentDirectory())"
+
+Push-Location $issDir
+$savedDotNetCwd = [System.IO.Directory]::GetCurrentDirectory()
+[System.IO.Directory]::SetCurrentDirectory($issDir)
+try {
+    Write-Host "  PS  location (post): $((Get-Location).Path)"
+    Write-Host "  .NET cwd     (post): $([System.IO.Directory]::GetCurrentDirectory())"
+
+    # Bake the version into a temp .iss and override OutputDir to an absolute
+    # path so nothing in the build depends on cwd resolution.
+    $tempIss = Join-Path $issDir "webhook-server.gen.iss"
+    $issBody = Get-Content $issName -Raw
+    $pattern = '(?s)#ifndef AppVersion\s+#define AppVersion "[^"]*"\s+#endif'
+    if ($issBody -notmatch $pattern) { throw "Could not find #ifndef AppVersion block in $issName" }
+    $issBody = $issBody -replace $pattern, "#define AppVersion `"$version`""
+    Set-Content -Path $tempIss -Value $issBody -Encoding ascii
+    Write-Host "  using $tempIss"
+
+    # Capture stdout+stderr together so any error line ISCC emits is visible
+    # in the runner log even if the runner's console capture drops one stream.
+    # /O<absolute> overrides OutputDir so ..\dist isn't resolved relative to
+    # whatever cwd ISCC actually inherits.
+    $logPath = Join-Path $env:TEMP "iscc-$version.log"
+    & $iscc "/O$dist" (Split-Path $tempIss -Leaf) *>&1 | Tee-Object -FilePath $logPath | ForEach-Object { Write-Host $_ }
+    $exit = $LASTEXITCODE
+    Write-Host "  ISCC exit code: $exit"
+    Write-Host "  ISCC log path:  $logPath"
+    if (Test-Path $logPath) {
+        Write-Host "  --- iscc log file contents ---"
+        Get-Content $logPath | ForEach-Object { Write-Host "    $_" }
+        Write-Host "  --- end iscc log ---"
+    }
+    Remove-Item $tempIss -ErrorAction SilentlyContinue
+} finally {
+    [System.IO.Directory]::SetCurrentDirectory($savedDotNetCwd)
+    Pop-Location
+}
+if ($exit -ne 0) { throw "Inno Setup compile failed (exit $exit)" }
 
 $out = Get-Item (Join-Path $dist "WebhookServer-Setup-$version.exe")
 Write-Host ""

src/WebhookServer.Gui/MainWindow.xaml

@@ -31,6 +31,11 @@
                 <MenuItem Header="_Export config…" Command="{Binding ExportConfigCommand}"/>
                 <MenuItem Header="Config _Checkpoints…" Command="{Binding ShowConfigCheckpointsCommand}"/>
                 <Separator/>
+                <MenuItem Header="_Minimize to tray"
+                          IsCheckable="True"
+                          IsChecked="{Binding MinimizeToTrayEnabled, Mode=TwoWay}"
+                          ToolTip="When ticked, closing or minimizing the window hides it to the tray and keeps the GUI process alive. Untick to make the X button quit the app."/>
+                <Separator/>
                 <MenuItem Header="E_xit" Command="{Binding ExitCommand}"/>
             </MenuItem>
             <MenuItem Header="_Server">
@@ -63,17 +68,26 @@
                 <DataGrid.RowStyle>
                     <Style TargetType="DataGridRow">
                         <EventSetter Event="MouseDoubleClick" Handler="OnRowDoubleClick"/>
+                        <!-- The ContextMenu lives in its own visual tree (a popup), so
+                             AncestorType=Window doesn't resolve from inside menu items.
+                             Stash MainViewModel on the row's Tag here (still in the
+                             Window's tree), then reach it from the menu via
+                             PlacementTarget.Tag. -->
+                        <Setter Property="Tag" Value="{Binding DataContext, RelativeSource={RelativeSource AncestorType=Window}}"/>
                         <Setter Property="ContextMenu">
                             <Setter.Value>
                                 <ContextMenu>
-                                    <MenuItem Header="_Edit…" Command="{Binding DataContext.EditEndpointCommand, RelativeSource={RelativeSource AncestorType=Window}}"/>
-                                    <MenuItem Header="_Copy URL" Command="{Binding DataContext.CopyEndpointUrlCommand, RelativeSource={RelativeSource AncestorType=Window}}"/>
+                                    <MenuItem Header="_Edit…"
+                                              Command="{Binding PlacementTarget.Tag.EditEndpointCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"/>
+                                    <MenuItem Header="_Copy URL"
+                                              Command="{Binding PlacementTarget.Tag.CopyEndpointUrlCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"/>
                                     <Separator/>
                                     <MenuItem Header="Toggle _enabled"
-                                              Command="{Binding DataContext.ToggleEnabledCommand, RelativeSource={RelativeSource AncestorType=Window}}"
-                                              CommandParameter="{Binding}"/>
+                                              Command="{Binding PlacementTarget.Tag.ToggleEnabledCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"
+                                              CommandParameter="{Binding PlacementTarget.DataContext, RelativeSource={RelativeSource AncestorType=ContextMenu}}"/>
                                     <Separator/>
-                                    <MenuItem Header="_Delete…" Command="{Binding DataContext.DeleteEndpointCommand, RelativeSource={RelativeSource AncestorType=Window}}"/>
+                                    <MenuItem Header="_Delete…"
+                                              Command="{Binding PlacementTarget.Tag.DeleteEndpointCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"/>
                                 </ContextMenu>
                             </Setter.Value>
                         </Setter>

src/WebhookServer.Gui/MainWindow.xaml.cs

@@ -1,3 +1,4 @@
+using System.ComponentModel;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Input;
@@ -11,26 +12,56 @@ public partial class MainWindow : Window
     private readonly TrayIcon _tray;
     private readonly MainViewModel _vm;
 
+    /// <summary>
+    /// Set to true when the user has explicitly asked to quit (File -> Exit or
+    /// Tray -> Exit). The OnClosing handler reads this to decide whether to
+    /// actually let the window close or hide it to the tray.
+    /// </summary>
+    public bool ExitForReal { get; set; }
+
     public MainWindow()
     {
         InitializeComponent();
         _vm = new MainViewModel(new AdminPipeClient());
         DataContext = _vm;
+        _vm.RealExitRequested += OnRealExitRequested;
 
         _tray = new TrayIcon(
             resolveMainWindow: () => Application.Current.MainWindow,
-            restartServiceAsync: async () => await new AdminPipeClient().RestartListenerAsync());
+            restartServiceAsync: async () => await new AdminPipeClient().RestartListenerAsync(),
+            onExit: OnRealExitRequested);
 
         Loaded += async (_, _) => await _vm.RefreshCommand.ExecuteAsync(null);
         StateChanged += OnStateChanged;
-        Closed += (_, _) => _tray.Dispose();
+        Closing += OnClosing;
+    }
+
+    private void OnClosing(object? sender, CancelEventArgs e)
+    {
+        if (ExitForReal || !_vm.MinimizeToTrayEnabled)
+        {
+            _tray.Dispose();
+            return;
+        }
+        // Treat the X button / Alt+F4 like a minimize: hide to tray, keep the
+        // process alive so the tray icon persists.
+        e.Cancel = true;
+        Hide();
+        ShowInTaskbar = false;
+    }
+
+    private void OnRealExitRequested()
+    {
+        ExitForReal = true;
+        Application.Current.Shutdown();
     }
 
     private void OnStateChanged(object? sender, EventArgs e)
     {
-        // Minimize-to-tray: hide the window when the user minimizes; restoring is
-        // via the tray icon's double-click or context menu.
-        if (WindowState == WindowState.Minimized)
+        // Minimize-to-tray: hide the window when the user minimizes IF they've
+        // opted in via File -> Minimize to tray. Otherwise behave like a normal
+        // Windows minimize.
+        if (WindowState == WindowState.Minimized && _vm.MinimizeToTrayEnabled)
         {
             Hide();
             ShowInTaskbar = false;

src/WebhookServer.Gui/Services/GuiSettings.cs

@@ -0,0 +1,50 @@
+using System.IO;
+using System.Text.Json;
+
+namespace WebhookServer.Gui.Services;
+
+/// <summary>
+/// Per-user GUI preferences that don't belong in the service-side ServerConfig.
+/// Persisted to %APPDATA%\WebhookServer\gui.json. Best-effort: failures to read
+/// or write fall back silently to defaults.
+/// </summary>
+public sealed class GuiSettings
+{
+    /// <summary>
+    /// When true, the X / Alt+F4 / minimize buttons hide the window to the tray
+    /// and keep the GUI process alive. When false, X exits the app and minimize
+    /// behaves like a normal Windows minimize.
+    /// </summary>
+    public bool MinimizeToTrayEnabled { get; set; } = true;
+
+    private static string FilePath => Path.Combine(
+        Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+        "WebhookServer",
+        "gui.json");
+
+    public static GuiSettings Load()
+    {
+        try
+        {
+            if (File.Exists(FilePath))
+            {
+                var json = File.ReadAllText(FilePath);
+                if (!string.IsNullOrWhiteSpace(json))
+                    return JsonSerializer.Deserialize<GuiSettings>(json) ?? new GuiSettings();
+            }
+        }
+        catch { /* fall through to defaults */ }
+        return new GuiSettings();
+    }
+
+    public void Save()
+    {
+        try
+        {
+            var dir = Path.GetDirectoryName(FilePath);
+            if (!string.IsNullOrEmpty(dir)) Directory.CreateDirectory(dir);
+            File.WriteAllText(FilePath, JsonSerializer.Serialize(this, new JsonSerializerOptions { WriteIndented = true }));
+        }
+        catch { /* best effort */ }
+    }
+}

src/WebhookServer.Gui/Services/TrayIcon.cs

@@ -16,11 +16,13 @@ public sealed class TrayIcon : IDisposable
     private readonly NotifyIcon _icon;
     private readonly Func<Window?> _resolveMainWindow;
     private readonly Func<Task> _restartServiceAsync;
+    private readonly Action _onExit;
 
-    public TrayIcon(Func<Window?> resolveMainWindow, Func<Task> restartServiceAsync)
+    public TrayIcon(Func<Window?> resolveMainWindow, Func<Task> restartServiceAsync, Action onExit)
     {
         _resolveMainWindow = resolveMainWindow;
         _restartServiceAsync = restartServiceAsync;
+        _onExit = onExit;
 
         _icon = new NotifyIcon
         {
@@ -39,7 +41,7 @@ public sealed class TrayIcon : IDisposable
         menu.Items.Add(new ToolStripSeparator());
         menu.Items.Add("&Restart service", null, async (_, _) => await _restartServiceAsync().ConfigureAwait(false));
         menu.Items.Add(new ToolStripSeparator());
-        menu.Items.Add("E&xit", null, (_, _) => Application.Current.Shutdown());
+        menu.Items.Add("E&xit", null, (_, _) => _onExit());
         return menu;
     }
 

src/WebhookServer.Gui/ViewModels/ConfigCheckpointsViewModel.cs

@@ -82,8 +82,14 @@ public sealed partial class ConfigCheckpointsViewModel : ObservableObject
     {
         if (Selected is null) return;
 
+        // Capture before the refresh; the ObservableCollection.Clear() in
+        // RefreshAsync nulls Selected (the original instance is gone from the
+        // collection so the SelectedItem binding clears).
+        var fileName = Selected.FileName;
+        var savedAt  = Selected.SavedAt;
+
         var ok = MessageBox.Show(
-            $"Roll the configuration back to the checkpoint from {Selected.SavedAt.ToLocalTime():yyyy-MM-dd HH:mm:ss}?\n\nThe current configuration is automatically saved as a new checkpoint first, so you can roll forward again.",
+            $"Roll the configuration back to the checkpoint from {savedAt.ToLocalTime():yyyy-MM-dd HH:mm:ss}?\n\nThe current configuration is automatically saved as a new checkpoint first, so you can roll forward again.",
             "Confirm rollback",
             MessageBoxButton.OKCancel,
             MessageBoxImage.Warning);
@@ -91,10 +97,10 @@ public sealed partial class ConfigCheckpointsViewModel : ObservableObject
 
         try
         {
-            await _client.RestoreBackupAsync(Selected.FileName).ConfigureAwait(false);
+            await _client.RestoreBackupAsync(fileName).ConfigureAwait(false);
             await RefreshAsync().ConfigureAwait(false);
             Application.Current.Dispatcher.Invoke(() =>
-                StatusMessage = $"Rolled back to {Selected!.FileName}.");
+                StatusMessage = $"Rolled back to {fileName}.");
         }
         catch (Exception ex)
         {

src/WebhookServer.Gui/ViewModels/MainViewModel.cs

@@ -29,17 +29,28 @@ public sealed partial class MainViewModel : ObservableObject
     [ObservableProperty] private ServerConfig _serverConfig = new();
     [ObservableProperty] private string _httpBaseUrl = "http://localhost:8080";
     [ObservableProperty] private string? _httpsBaseUrl;
+    [ObservableProperty] private bool _minimizeToTrayEnabled;
 
     private readonly DispatcherTimer _logTimer;
+    private readonly GuiSettings _settings;
 
     public MainViewModel(AdminPipeClient client)
     {
         _client = client;
+        _settings = GuiSettings.Load();
+        _minimizeToTrayEnabled = _settings.MinimizeToTrayEnabled;
+
         _logTimer = new DispatcherTimer(DispatcherPriority.Background) { Interval = TimeSpan.FromSeconds(3) };
         _logTimer.Tick += async (_, _) => await RefreshLogTailAsync();
         _logTimer.Start();
     }
 
+    partial void OnMinimizeToTrayEnabledChanged(bool value)
+    {
+        _settings.MinimizeToTrayEnabled = value;
+        _settings.Save();
+    }
+
     [RelayCommand]
     private async Task RefreshAsync()
     {
@@ -286,10 +297,14 @@ public sealed partial class MainViewModel : ObservableObject
         }
     }
 
+    /// <summary>Raised when the user picks File -> Exit. MainWindow flips its
+    /// ExitForReal flag and shuts down, bypassing the X-hides-to-tray logic.</summary>
+    public event Action? RealExitRequested;
+
     [RelayCommand]
     private void Exit()
     {
-        Application.Current.Shutdown();
+        RealExitRequested?.Invoke();
     }
 
     [RelayCommand]