Migrates Dev Proxy to Kestrel

.github/copilot-instructions.md

@@ -6,7 +6,7 @@ Dev Proxy is a cross-platform .NET API simulator and proxy for testing how appli
 
 ## Critical (Non-Obvious)
 
-- **Proxy engine:** Uses [svrooij/unobtanium-web-proxy](https://github.com/svrooij/unobtanium-web-proxy) (fork of Titanium.Web.Proxy)
+- **Proxy engine:** Built on [ASP.NET Core Kestrel](https://learn.microsoft.com/aspnet/core/fundamentals/servers/kestrel) (a custom forward-proxy + MITM engine; see `DevProxy.Proxy.Kestrel`)
 - **Config tokens:** Paths in config files can use `~appFolder` for resolution
 - **MCP Server:** Use [@devproxy/mcp](https://www.npmjs.com/package/@devproxy/mcp) to programmatically retrieve up-to-date docs and JSON schemas
 

CONTRIBUTING.md

@@ -28,4 +28,4 @@ Typos are embarrassing! Most PRs that fix typos will be accepted immediately. To
 
 ## Our foundation
 
-The Dev Proxy is built with .NET 9 and uses the [Unobtanium Web Proxy](https://github.com/svrooij/unobtanium-web-proxy).
+The Dev Proxy is built with .NET and uses [ASP.NET Core Kestrel](https://learn.microsoft.com/aspnet/core/fundamentals/servers/kestrel) for its forward-proxy engine.

DevProxy.Abstractions.Tests/DevProxy.Abstractions.Tests.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+    <!-- Underscored Method_Scenario_Expectation test names are idiomatic; inline literal
+         arrays in assertions are fine in tests. -->
+    <NoWarn>$(NoWarn);CA1707;CA1861</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DevProxy.Abstractions\DevProxy.Abstractions.csproj" />
+  </ItemGroup>
+
+</Project>

DevProxy.Abstractions.Tests/Proxy/Http/ForwardingInvariantsTests.cs

@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using DevProxy.Abstractions.Proxy.Http;
+using Xunit;
+
+namespace DevProxy.Abstractions.Tests.Proxy.Http;
+
+public class ForwardingInvariantsTests
+{
+    [Theory]
+    [InlineData("Connection")]
+    [InlineData("proxy-connection")]
+    [InlineData("KEEP-ALIVE")]
+    [InlineData("Transfer-Encoding")]
+    [InlineData("te")]
+    [InlineData("Trailer")]
+    [InlineData("Upgrade")]
+    [InlineData("Proxy-Authenticate")]
+    [InlineData("Proxy-Authorization")]
+    public void HopByHopHeaders_ContainsExpected_CaseInsensitive(string name) =>
+        Assert.Contains(name, (IReadOnlySet<string>)ForwardingInvariants.HopByHopHeaders);
+
+    [Theory]
+    [InlineData("Content-Type")]
+    [InlineData("Host")]
+    [InlineData("Set-Cookie")]
+    [InlineData("Authorization")]
+    public void HopByHopHeaders_ExcludesEndToEndHeaders(string name) =>
+        Assert.DoesNotContain(name, (IReadOnlySet<string>)ForwardingInvariants.HopByHopHeaders);
+}

DevProxy.Abstractions.Tests/Proxy/Http/HeaderCollectionTests.cs

@@ -0,0 +1,105 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using DevProxy.Abstractions.Proxy.Http;
+using Xunit;
+
+namespace DevProxy.Abstractions.Tests.Proxy.Http;
+
+public class HeaderCollectionTests
+{
+    [Fact]
+    public void Add_PreservesWireOrderAndDuplicates()
+    {
+        var headers = new HeaderCollection();
+        headers.Add("Set-Cookie", "a=1");
+        headers.Add("Set-Cookie", "b=2");
+
+        var all = headers.GetAll("set-cookie").ToList();
+
+        Assert.Equal(2, all.Count);
+        Assert.Equal("a=1", all[0].Value);
+        Assert.Equal("b=2", all[1].Value);
+    }
+
+    [Fact]
+    public void Contains_And_GetFirst_AreCaseInsensitive()
+    {
+        var headers = new HeaderCollection();
+        headers.Add("Content-Type", "application/json");
+
+        Assert.True(headers.Contains("content-type"));
+        Assert.Equal("application/json", headers.GetFirst("CONTENT-TYPE")!.Value);
+    }
+
+    [Fact]
+    public void GetFirst_ReturnsNull_WhenAbsent()
+    {
+        var headers = new HeaderCollection();
+        Assert.Null(headers.GetFirst("X-Missing"));
+        Assert.Empty(headers.GetAll("X-Missing"));
+    }
+
+    [Fact]
+    public void Replace_CollapsesDuplicatesToSingleValue()
+    {
+        var headers = new HeaderCollection();
+        headers.Add("X-Test", "old1");
+        headers.Add("X-Test", "old2");
+
+        headers.Replace("x-test", "new");
+
+        var all = headers.GetAll("X-Test").ToList();
+        Assert.Single(all);
+        Assert.Equal("new", all[0].Value);
+    }
+
+    [Fact]
+    public void Replace_AddsWhenAbsent()
+    {
+        var headers = new HeaderCollection();
+        headers.Replace("X-New", "value");
+        Assert.Equal("value", headers.GetFirst("X-New")!.Value);
+    }
+
+    [Fact]
+    public void Remove_RemovesAllOccurrences_AndReportsResult()
+    {
+        var headers = new HeaderCollection();
+        headers.Add("X-Dup", "1");
+        headers.Add("X-Dup", "2");
+
+        Assert.True(headers.Remove("x-dup"));
+        Assert.Equal(0, headers.Count);
+        Assert.False(headers.Remove("x-dup"));
+    }
+
+    [Fact]
+    public void AddRange_And_Linq_Work()
+    {
+        var headers = new HeaderCollection(new[]
+        {
+            new HttpHeader("A", "1"),
+            new HttpHeader("B", "2"),
+        });
+        headers.AddRange(new[] { new HttpHeader("C", "3") });
+
+        Assert.Equal(3, headers.Count);
+        Assert.Contains(headers, h => h.Name == "C");
+        Assert.Equal("1", headers.First(h => h.Name == "A").Value);
+    }
+
+    [Fact]
+    public void SeedingConstructor_PreservesOrder()
+    {
+        var headers = new HeaderCollection(new[]
+        {
+            new HttpHeader("First", "1"),
+            new HttpHeader("Second", "2"),
+        });
+
+        var names = headers.Select(h => h.Name).ToList();
+        Assert.Equal(new[] { "First", "Second" }, names);
+    }
+}

DevProxy.Abstractions.Tests/Proxy/RootTrustPolicyTests.cs

@@ -0,0 +1,99 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using DevProxy.Abstractions.Proxy;
+using Xunit;
+
+namespace DevProxy.Abstractions.Tests.Proxy;
+
+public class RootTrustPolicyTests
+{
+    // ── installCert gate ────────────────────────────────────────────────
+    [Theory]
+    [InlineData(true, false)]   // mac
+    [InlineData(false, true)]   // windows
+    [InlineData(false, false)]  // linux
+    public void Decide_InstallCertFalse_AlwaysSkips(bool isMac, bool isWindows)
+    {
+        var action = RootTrustPolicy.Decide(
+            isMac, isWindows, installCert: false, noFirstRun: false, isFirstRun: true, firstRunAnswer: "y");
+
+        Assert.Equal(RootTrustAction.Skip, action);
+    }
+
+    // ── Windows ─────────────────────────────────────────────────────────
+    [Theory]
+    [InlineData(true, false)]   // first run, ignored on Windows
+    [InlineData(false, true)]   // noFirstRun, ignored on Windows
+    public void Decide_Windows_InstallCert_AlwaysTrustsStore(bool isFirstRun, bool noFirstRun)
+    {
+        var action = RootTrustPolicy.Decide(
+            isMac: false, isWindows: true, installCert: true, noFirstRun: noFirstRun, isFirstRun: isFirstRun, firstRunAnswer: null);
+
+        Assert.Equal(RootTrustAction.TrustWindowsStore, action);
+    }
+
+    // ── macOS first-run flow ────────────────────────────────────────────
+    [Fact]
+    public void Decide_Mac_FirstRun_EmptyAnswer_Trusts()
+    {
+        var action = RootTrustPolicy.Decide(
+            isMac: true, isWindows: false, installCert: true, noFirstRun: false, isFirstRun: true, firstRunAnswer: "");
+
+        Assert.Equal(RootTrustAction.TrustMacKeychain, action);
+    }
+
+    [Theory]
+    [InlineData("y")]
+    [InlineData("Y")]
+    [InlineData("yes")]
+    [InlineData("anything")]
+    public void Decide_Mac_FirstRun_NonNoAnswer_Trusts(string answer)
+    {
+        var action = RootTrustPolicy.Decide(
+            isMac: true, isWindows: false, installCert: true, noFirstRun: false, isFirstRun: true, firstRunAnswer: answer);
+
+        Assert.Equal(RootTrustAction.TrustMacKeychain, action);
+    }
+
+    [Theory]
+    [InlineData("n")]
+    [InlineData("N")]
+    [InlineData(" n ")]
+    public void Decide_Mac_FirstRun_AnswerNo_Skips(string answer)
+    {
+        var action = RootTrustPolicy.Decide(
+            isMac: true, isWindows: false, installCert: true, noFirstRun: false, isFirstRun: true, firstRunAnswer: answer);
+
+        Assert.Equal(RootTrustAction.Skip, action);
+    }
+
+    [Fact]
+    public void Decide_Mac_NotFirstRun_Skips()
+    {
+        var action = RootTrustPolicy.Decide(
+            isMac: true, isWindows: false, installCert: true, noFirstRun: false, isFirstRun: false, firstRunAnswer: "y");
+
+        Assert.Equal(RootTrustAction.Skip, action);
+    }
+
+    [Fact]
+    public void Decide_Mac_NoFirstRun_Skips()
+    {
+        var action = RootTrustPolicy.Decide(
+            isMac: true, isWindows: false, installCert: true, noFirstRun: true, isFirstRun: true, firstRunAnswer: "y");
+
+        Assert.Equal(RootTrustAction.Skip, action);
+    }
+
+    // ── Linux ───────────────────────────────────────────────────────────
+    [Fact]
+    public void Decide_Linux_InstallCert_IsManual()
+    {
+        var action = RootTrustPolicy.Decide(
+            isMac: false, isWindows: false, installCert: true, noFirstRun: false, isFirstRun: true, firstRunAnswer: "y");
+
+        Assert.Equal(RootTrustAction.ManualLinux, action);
+    }
+}

DevProxy.Abstractions.Tests/Proxy/SystemProxyAddressTests.cs

@@ -0,0 +1,39 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using DevProxy.Abstractions.Proxy;
+using Xunit;
+
+namespace DevProxy.Abstractions.Tests.Proxy;
+
+public class SystemProxyAddressTests
+{
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData("   ")]
+    [InlineData("0.0.0.0")]
+    [InlineData("::")]
+    public void ResolveHost_WildcardOrEmpty_CollapsesToLoopback(string? ipAddress) =>
+        Assert.Equal("127.0.0.1", SystemProxyAddress.ResolveHost(ipAddress));
+
+    [Theory]
+    [InlineData("127.0.0.1")]
+    [InlineData("10.0.0.5")]
+    [InlineData("192.168.1.10")]
+    public void ResolveHost_ExplicitAddress_PassesThrough(string ipAddress) =>
+        Assert.Equal(ipAddress, SystemProxyAddress.ResolveHost(ipAddress));
+
+    [Fact]
+    public void ToHostPort_ComposesNormalizedHostAndPort() =>
+        Assert.Equal("127.0.0.1:8000", SystemProxyAddress.ToHostPort("0.0.0.0", 8000));
+
+    [Fact]
+    public void ToHostPort_ExplicitAddress() =>
+        Assert.Equal("10.0.0.5:9090", SystemProxyAddress.ToHostPort("10.0.0.5", 9090));
+
+    [Fact]
+    public void ToHostPort_NullAddress_UsesLoopback() =>
+        Assert.Equal("127.0.0.1:8080", SystemProxyAddress.ToHostPort(null, 8080));
+}

DevProxy.Abstractions.Tests/Proxy/WatchedHostExtractorTests.cs

@@ -0,0 +1,61 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Text.RegularExpressions;
+using DevProxy.Abstractions.Proxy;
+using Xunit;
+
+namespace DevProxy.Abstractions.Tests.Proxy;
+
+public class WatchedHostExtractorTests
+{
+    // Mirrors PluginServiceExtensions.ConvertToRegex so tests feed the same
+    // UrlToWatch regex shape both engines receive at runtime.
+    private static Regex ToUrlRegex(string pattern) =>
+        new(
+            $"^{Regex.Escape(pattern).Replace("\\*", ".*", StringComparison.OrdinalIgnoreCase)}$",
+            RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+    private static string HostPattern(string urlPattern) =>
+        WatchedHostExtractor.ToHostRegex(ToUrlRegex(urlPattern)).ToString();
+
+    [Fact]
+    public void ToHostRegex_StripsSchemeAndPath() =>
+        Assert.Equal("^api\\.contoso\\.com$", HostPattern("https://api.contoso.com/v1/users"));
+
+    [Fact]
+    public void ToHostRegex_HostOnlyPattern_NoScheme() =>
+        Assert.Equal("^api\\.contoso\\.com$", HostPattern("api.contoso.com"));
+
+    [Fact]
+    public void ToHostRegex_StripsPort() =>
+        Assert.Equal("^localhost$", HostPattern("https://localhost:3000/*"));
+
+    [Fact]
+    public void ToHostRegex_PreservesWildcardSubdomain() =>
+        Assert.Equal("^.*\\.contoso\\.com$", HostPattern("https://*.contoso.com/*"));
+
+    [Fact]
+    public void ToHostRegex_GlobalWildcard() =>
+        Assert.Equal("^.*$", HostPattern("https://*/*"));
+
+    [Fact]
+    public void ToHostRegex_NoPath_NoTrailingSlash() =>
+        Assert.Equal("^api\\.contoso\\.com$", HostPattern("https://api.contoso.com"));
+
+    [Theory]
+    [InlineData("https://jsonplaceholder.typicode.com/*", "jsonplaceholder.typicode.com", true)]
+    [InlineData("https://jsonplaceholder.typicode.com/*", "example.com", false)]
+    [InlineData("https://*.contoso.com/*", "api.contoso.com", true)]
+    [InlineData("https://*.contoso.com/*", "contoso.net", false)]
+    public void ToHostRegex_MatchesExpectedHosts(string urlPattern, string host, bool expected)
+    {
+        var hostRegex = WatchedHostExtractor.ToHostRegex(ToUrlRegex(urlPattern));
+        Assert.Equal(expected, hostRegex.IsMatch(host));
+    }
+
+    [Fact]
+    public void ToHostRegex_Throws_OnNull() =>
+        Assert.Throws<ArgumentNullException>(() => WatchedHostExtractor.ToHostRegex(null!));
+}