Fixes forwarding https URLs on mac (#1768)

Author: waldekmastykarz

DevProxy.Proxy.Kestrel/Internal/ProxyConnectionHandler.cs

@@ -278,7 +278,8 @@ private async Task BlindTunnelAsync(Stream clientStream, string host, int port,
     private async Task<bool> ExchangeAsync(
         Http1ConnectionReader reader, Stream clientStream, ParsedRequestHead head, string absoluteUrl, CancellationToken ct)
     {
-        if (!Uri.TryCreate(absoluteUrl, UriKind.Absolute, out var requestUri))
+        if (!Uri.TryCreate(absoluteUrl, UriKind.Absolute, out var requestUri)
+            || (requestUri.Scheme != "http" && requestUri.Scheme != "https"))
         {
             await WriteErrorAsync(clientStream, HttpStatusCode.BadRequest, "Malformed request target", ct).ConfigureAwait(false);
             return false;

DevProxy/Commands/StopCommand.cs

@@ -36,18 +36,16 @@ private async Task<int> RunAsync(ParseResult parseResult, CancellationToken canc
 
         if (pid is not null)
         {
-            var state = await StateManager.LoadStateByPidAsync(pid.Value, cancellationToken);
-            if (state is null)
-            {
-                Console.WriteLine($"No running Dev Proxy instance with PID {pid.Value}.");
-                return 1;
-            }
-
-            return await StopInstanceAsync(state, force, cancellationToken);
+            return await StopByPidAsync(pid.Value, force, cancellationToken);
         }
 
+        // Reconcile any system-proxy registrations left behind by crashed
+        // instances first — this must run before LoadAllStatesAsync, which prunes
+        // (deletes) the stale state files it depends on.
+        var reconciliation = await SystemProxyManager.ReconcileOrphanedSystemProxiesAsync(cancellationToken);
+
         var states = await StateManager.LoadAllStatesAsync(cancellationToken);
-        if (states.Count == 0)
+        if (states.Count == 0 && reconciliation.Orphans.Count == 0)
         {
             Console.WriteLine("Dev Proxy is not running.");
             return 1;
@@ -63,9 +61,55 @@ private async Task<int> RunAsync(ParseResult parseResult, CancellationToken canc
             }
         }
 
+        ReportReconciledOrphans(reconciliation);
+
         return exitCode;
     }
 
+    private static async Task<int> StopByPidAsync(int pid, bool force, CancellationToken cancellationToken)
+    {
+        // Capture a potential orphaned system-proxy record before LoadStateByPidAsync
+        // prunes (deletes) the stale state file for a dead PID.
+        var orphan = (await StateManager.GetOrphanedSystemProxyStatesAsync(cancellationToken))
+            .Find(o => o.Pid == pid);
+
+        var state = await StateManager.LoadStateByPidAsync(pid, cancellationToken);
+        if (state is not null)
+        {
+            return await StopInstanceAsync(state, force, cancellationToken);
+        }
+
+        if (orphan is not null)
+        {
+            var liveOwner = await StateManager.FindSystemProxyInstanceAsync(cancellationToken);
+            if (liveOwner is null)
+            {
+                new SystemProxyManager(NullLogger<SystemProxyManager>.Instance).Disable();
+                Console.WriteLine($"Restored system proxy left by crashed Dev Proxy (PID: {pid}).");
+            }
+            else
+            {
+                Console.WriteLine($"Removed stale record for crashed Dev Proxy (PID: {pid}); system proxy is owned by a running instance (PID: {liveOwner.Pid}).");
+            }
+
+            await StateManager.DeleteStateAsync(pid, cancellationToken);
+            return 0;
+        }
+
+        Console.WriteLine($"No running Dev Proxy instance with PID {pid}.");
+        return 1;
+    }
+
+    private static void ReportReconciledOrphans(SystemProxyManager.OrphanReconciliation reconciliation)
+    {
+        foreach (var orphan in reconciliation.Orphans)
+        {
+            Console.WriteLine(reconciliation.SystemProxyDisabled
+                ? $"Restored system proxy left by crashed Dev Proxy (PID: {orphan.Pid})."
+                : $"Removed stale record for crashed Dev Proxy (PID: {orphan.Pid}); system proxy is owned by a running instance.");
+        }
+    }
+
     private static async Task<int> StopInstanceAsync(ProxyInstanceState state, bool force, CancellationToken cancellationToken)
     {
         if (force)
@@ -148,10 +192,12 @@ private static async Task<int> StopInstanceAsync(ProxyInstanceState state, bool
 
     private static async Task<int> ForceStopAsync(ProxyInstanceState state, CancellationToken cancellationToken)
     {
-        // Best-effort: restore the OS proxy in case the daemon is killed before it can
-        // deregister itself (SIGKILL can't be caught; a crashed daemon never cleans up).
-        // Engine-agnostic and cross-platform (Windows WinINET + macOS toggle-proxy.sh).
-        new SystemProxyManager(NullLogger<SystemProxyManager>.Instance).Disable();
+        // A killed process can't run its own cleanup, so restore the system proxy
+        // on its behalf before terminating it.
+        if (state.AsSystemProxy)
+        {
+            new SystemProxyManager(NullLogger<SystemProxyManager>.Instance).Disable();
+        }
 
         try
         {

DevProxy/Proxy/SystemProxyManager.cs

@@ -6,6 +6,8 @@
 using System.Runtime.InteropServices;
 using System.Runtime.Versioning;
 using DevProxy.Abstractions.Proxy;
+using DevProxy.State;
+using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Win32;
 
 namespace DevProxy.Proxy;
@@ -160,4 +162,44 @@ private void RunToggleScript(string arguments)
             logger.LogError(ex, "Failed to toggle the system proxy via toggle-proxy.sh.");
         }
     }
+
+    // ------------------------------------------------------------------
+    // Static helpers for orphan reconciliation (crash-cleanup path).
+    // ------------------------------------------------------------------
+
+    /// <summary>
+    /// The outcome of reconciling orphaned system-proxy registrations.
+    /// </summary>
+    internal readonly record struct OrphanReconciliation(
+        IReadOnlyList<ProxyInstanceState> Orphans,
+        bool SystemProxyDisabled);
+
+    /// <summary>
+    /// Reconciles system-proxy registrations left behind by crashed instances.
+    /// Restores the OS proxy (unless a live instance still owns it) and removes
+    /// the stale state records. Safe to call when there are no orphans.
+    /// </summary>
+    public static async Task<OrphanReconciliation> ReconcileOrphanedSystemProxiesAsync(CancellationToken cancellationToken = default)
+    {
+        var orphans = await StateManager.GetOrphanedSystemProxyStatesAsync(cancellationToken);
+        if (orphans.Count == 0)
+        {
+            return new([], false);
+        }
+
+        var liveOwner = await StateManager.FindSystemProxyInstanceAsync(cancellationToken);
+        var disabled = false;
+        if (liveOwner is null)
+        {
+            new SystemProxyManager(NullLogger<SystemProxyManager>.Instance).Disable();
+            disabled = true;
+        }
+
+        foreach (var orphan in orphans)
+        {
+            await StateManager.DeleteStateAsync(orphan.Pid, cancellationToken);
+        }
+
+        return new(orphans, disabled);
+    }
 }