Fail fast when the debug adapter's OnInitialize delegate throws

OmniSharp's `DebugAdapterServer.From()` (0.19.9) awaits an internal
`AsyncSubject` that its `InitializeRequest` handler only signals on the
success path. If an `OnInitialize` delegate throws, the handler faults
before signaling, nothing errors the subject, and `From()` -- and thus
`PsesDebugServer.StartAsync()` -- awaits it forever. So a startup failure
wedges the entire debug server and rides the CI/job timeout instead of
failing fast. This is a library limitation, not our bug: the same code is
present on the library's `master`, so we can't fix it upstream without a
fork or upgrade.

#2328 fixes the specific trigger we hit on in-box Windows PowerShell (the
`Get-ExecutionPolicy -List` type-data conflict), but the wedge mechanism is
generic. Guard against any future `OnInitialize` failure: wrap the delegate
body, log the exception, and signal `_serverStopped` so `WaitForShutdown`
unblocks and the process exits cleanly. `Dispose`'s `_serverStopped`
completion is now idempotent (`TrySetResult`) since the catch may have
already completed it.

This converts a silent multi-hour hang into a clean termination with a
logged error -- the client sees the session end instead of waiting forever.
See #2323.

Drafted by Copilot (Claude Opus 4.8).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: andyleejordan

src/PowerShellEditorServices/Server/PsesDebugServer.cs

@@ -5,7 +5,9 @@
 using System.IO;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using Microsoft.PowerShell.EditorServices.Handlers;
+using Microsoft.PowerShell.EditorServices.Logging;
 using Microsoft.PowerShell.EditorServices.Services;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Host;
 using OmniSharp.Extensions.DebugAdapter.Server;
@@ -89,23 +91,40 @@ public async Task StartAsync()
                     // https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Initialize
                     .OnInitialize(async (server, _, cancellationToken) =>
                     {
-                        // Start the host if not already started, and enable debug mode (required
-                        // for remote debugging).
-                        //
-                        // TODO: We might need to fill in HostStartOptions here.
-                        _startedPses = !await _psesHost.TryStartAsync(new HostStartOptions(), cancellationToken).ConfigureAwait(false);
-                        _psesHost.DebugContext.EnableDebugMode();
-
-                        // We need to give the host a handle to the DAP so it can register
-                        // notifications (specifically for sendKeyPress).
-                        if (_isTemp)
+                        try
                         {
-                            _psesHost.DebugServer = server;
+                            // Start the host if not already started, and enable debug mode (required
+                            // for remote debugging).
+                            //
+                            // TODO: We might need to fill in HostStartOptions here.
+                            _startedPses = !await _psesHost.TryStartAsync(new HostStartOptions(), cancellationToken).ConfigureAwait(false);
+                            _psesHost.DebugContext.EnableDebugMode();
+
+                            // We need to give the host a handle to the DAP so it can register
+                            // notifications (specifically for sendKeyPress).
+                            if (_isTemp)
+                            {
+                                _psesHost.DebugServer = server;
+                            }
+
+                            // Clear any existing breakpoints before proceeding.
+                            BreakpointService breakpointService = server.GetService<BreakpointService>();
+                            await breakpointService.RemoveAllBreakpointsAsync().ConfigureAwait(false);
+                        }
+                        catch (Exception e)
+                        {
+                            // Never let an exception escape this delegate. OmniSharp's
+                            // DebugAdapterServer only signals its internal initialize-complete
+                            // subject on the success path of the InitializeRequest handler, so a
+                            // throw here leaves DebugAdapterServer.From() (and thus StartAsync)
+                            // awaiting that subject forever -- wedging startup and riding the job
+                            // timeout instead of failing fast. Log the failure and signal shutdown
+                            // so WaitForShutdown unblocks and the process can exit cleanly.
+                            ServiceProvider.GetService<ILoggerFactory>()?
+                                .CreateLogger<PsesDebugServer>()
+                                .LogException("Failed to start the debug server; terminating the debug session.", e);
+                            _serverStopped.TrySetResult(true);
                         }
-
-                        // Clear any existing breakpoints before proceeding.
-                        BreakpointService breakpointService = server.GetService<BreakpointService>();
-                        await breakpointService.RemoveAllBreakpointsAsync().ConfigureAwait(false);
                     })
                     // The OnInitialized delegate gets run right before the server responds to the _Initialize_ request:
                     // https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Initialize
@@ -134,7 +153,7 @@ public void Dispose()
             _debugAdapterServer?.Dispose();
             _inputStream.Dispose();
             _outputStream.Dispose();
-            _serverStopped.SetResult(true);
+            _serverStopped.TrySetResult(true);
             // TODO: If the debugger has stopped, should we clear the breakpoints?
         }