How to use WebApiConfig class of PupppeterSharpAspNetFrameworkSample package

So, after many tries and a lot of searched, I ended up switching to Selenium, which seems to have better documentation and a lot of examples here. This is the code, that worked for me:

string locator1 = "td:Contains(\'41818397111\')";
string locator2 = "td[id = \'InvoiceDetails\']";
IWebElement webElement = driver.FindElement(Selenium.WebDriver.Extensions.By.JQuerySelector(locator1).Parent().Find(locator2));
webElement.Click();

If you want to get an element from the browser you should get an ElementHandle, which is a pointer to an element in the browser, using EvaluateExpressionHandleAsync:

var element = await page.EvaluateExpressionHandleAsync($"document.querySelectorAll('[{attributeName}=\"{attributeValue}\"]')[0];");

Change your Window_Loaded event method to async and do an await on the Init method, Event Handler methods are an exception. using async void instead of async Task is ok in this scenario. - Reference (Should I avoid 'async void' event handlers?):

private async void Window_Loaded(object sender, RoutedEventArgs e) 
{  
   await Handler.Init(Handler);
}

Set the Headless to true nad try

var options = new LaunchOptions
{
    Headless = true,
    ExecutablePath = @"C:\Program Files\Mozilla Firefox\firefox.exe",
    Args = argumentsWithoutExtension
};

First thing, you need to launch Chrome with remote debugging enabled. If you launch Chrome, for instance, with the flag --remote-debugging-port=2122, you know that you will be able to connect to the browser using the http://127.0.0.1:2122 URL.

Second, if you want to connect to an existing browser you need to call ConnectAsync instead of LaunchAsync.

Having all that. If would be a matter of doing something like this:

var browser = await Puppeteer.ConnectAsync(new ConnectOptions
{
    BrowserURL = "http://127.0.0.1:2122"
}));

This is how you can use System.Net.WebSockets.Managed on Puppeteer-Sharp

var browserOptions = new LaunchOptions
{
    Headless = true,
    WebSocketFactory = (uri, socketOptions, cancellationToken)
        => System.Net.WebSockets.SystemClientWebSocket.ConnectAsync(uri, cancellationToken)
};
using (var browser = await Puppeteer.LaunchAsync(browserOptions))
using (var page = await browser.NewPageAsync())
{

}

You can use the LaunchOptions.ExecutablePath property. If you use ExecutablePath you don't even need to call BrowserFetcher. It would look something like this:

var options = new LaunchOptions
{
    Headless = true,
    ExecutablePath = "<CHROME.EXE FULL PATH>"
};

using (var browser = await Puppeteer.LaunchAsync(options))
{
}

If anyone needs it, here is the code I used below :

        Base64Image img = new Base64Image();            
        using (Page page = await parentPage.Browser.NewPageAsync())
        {                
            var tcs = new TaskCompletionSource();
            page.Response += async (sender, e) =>
            {
                string contentType = null;
                string[] imageMimeTypes = { "image/jpeg", "image/png", "image/webp", "image/gif" };

                if (e.Response.Headers.ContainsKey("content-type"))
                    contentType = (string)e.Response.Headers["content-type"].ToLower();

                if (e.Response.Headers.ContainsKey("Content-Type"))
                    contentType = (string)e.Response.Headers["Content-Type"].ToLower();

                if (imageMimeTypes.Any(t => t == contentType))
                {
                    img.ContentType = contentType;
                    

                    await e.Response.BufferAsync().AsTask().ContinueWith(async (data) => img.Bytes = await data);   
                    tcs.TrySetResult();
                }
            };
            await Task.WhenAll(page.GoToAsync(uri.AbsoluteUri), tcs.Task);
            await page.CloseAsync();
        }
        return img;

Yarp Reverse proxy with Direct Forwarding is the answer:

Server code: (ASP.NET core minimal API):

Dictionary<string, string> routes = new();

app.UseRouting();
app.UseEndpoints(endpoints =>
{
    endpoints.Map("/connect/{**catch-all}", async httpContext =>
    {
        var route = httpContext.Request.GetDisplayUrl();

        await app.Services.GetRequiredService<IHttpForwarder>().SendAsync(
            httpContext,
            routes.TryGetValue(Path.GetFileName(new Uri(route).AbsolutePath), out string targetRoute) ? targetRoute : route,
            new HttpMessageInvoker(new SocketsHttpHandler()
            {
                UseProxy = false,
                AllowAutoRedirect = false,
                AutomaticDecompression = DecompressionMethods.None,
                UseCookies = false,
                ActivityHeadersPropagator = new ReverseProxyPropagator(DistributedContextPropagator.Current)
            })
        );
    });
});

app.MapGet("/", async () =>
{
    var b = await Puppeteer.LaunchAsync(new()
    {
        ExecutablePath = browserPath // set your chrome directory
    });

    var id = Path.GetFileName(b.WebSocketEndpoint);

    routes.Add(id, b.WebSocketEndpoint);

    return $"ws://your-server-ip-address/connect/{id}";
});

app.Run();

Client code:

await Puppeteer.ConnectAsync(new() { BrowserWSEndpoint = await httpClient.GetStringAsync("http://your-server-ip-address") })