Bidi: Unlock cookies support

kblok · kblok · commit 2b695b80e1b6 · 2025-10-20T14:18:00.000-04:00
diff --git a/lib/PuppeteerSharp.Nunit/TestExpectations/TestExpectations.local.json b/lib/PuppeteerSharp.Nunit/TestExpectations/TestExpectations.local.json
@@ -315,21 +315,6 @@
       "FAIL"
     ]
   },
-  {
-    "comment": "This is part of organizing the webdriver bidi implementation, We will remove it one by one",
-    "testIdPattern": "[cookies.spec] *",
-    "platforms": [
-      "darwin",
-      "linux",
-      "win32"
-    ],
-    "parameters": [
-      "webDriverBiDi"
-    ],
-    "expectations": [
-      "FAIL"
-    ]
-  },
   {
     "comment": "This is part of organizing the webdriver bidi implementation, We will remove it one by one",
     "testIdPattern": "[crash] *",
@@ -1769,5 +1754,20 @@
     "expectations": [
       "FAIL"
     ]
+  },
+  {
+    "comment": "BidiBrowserContext.CloseAsync() is not implemented - fails with NotImplementedException",
+    "testIdPattern": "[cookies.spec] Cookie specs Page.setCookie should isolate cookies in browser contexts",
+    "platforms": [
+      "darwin",
+      "linux",
+      "win32"
+    ],
+    "parameters": [
+      "webDriverBiDi"
+    ],
+    "expectations": [
+      "SKIP"
+    ]
   }
 ]
diff --git a/lib/PuppeteerSharp/Bidi/BidiCookieHelper.cs b/lib/PuppeteerSharp/Bidi/BidiCookieHelper.cs
@@ -0,0 +1,210 @@
+// * MIT License
+//  *
+//  * Copyright (c) Darío Kondratiuk
+//  *
+//  * Permission is hereby granted, free of charge, to any person obtaining a copy
+//  * of this software and associated documentation files (the "Software"), to deal
+//  * in the Software without restriction, including without limitation the rights
+//  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  * copies of the Software, and to permit persons to whom the Software is
+//  * furnished to do so, subject to the following conditions:
+//  *
+//  * The above copyright notice and this permission notice shall be included in all
+//  * copies or substantial portions of the Software.
+//  *
+//  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  * SOFTWARE.
+
+using System;
+using WebDriverBiDi.Network;
+using WebDriverBiDi.Storage;
+using BidiCookie = WebDriverBiDi.Network.Cookie;
+
+namespace PuppeteerSharp.Bidi;
+
+internal static class BidiCookieHelper
+{
+    /// <summary>
+    /// Converts a BiDi cookie to a PuppeteerSharp cookie.
+    /// </summary>
+    public static CookieParam BidiToPuppeteerCookie(BidiCookie bidiCookie)
+        => new()
+        {
+            Name = bidiCookie.Name,
+            Value = bidiCookie.Value.Value,
+            Domain = bidiCookie.Domain,
+            Path = bidiCookie.Path,
+            Size = (int)bidiCookie.Size,
+            HttpOnly = bidiCookie.HttpOnly,
+            Secure = bidiCookie.Secure,
+            SameSite = ConvertSameSiteBidiToPuppeteer(bidiCookie.SameSite),
+            Expires = bidiCookie.EpochExpires.HasValue ? (double)bidiCookie.EpochExpires.Value / 1000 : -1,
+            Session = !bidiCookie.EpochExpires.HasValue || bidiCookie.EpochExpires.Value == 0,
+        };
+
+    /// <summary>
+    /// Converts a PuppeteerSharp cookie to a BiDi partial cookie.
+    /// </summary>
+    public static PartialCookie PuppeteerToBidiCookie(CookieParam cookie, string domain)
+    {
+        var bidiCookie = new PartialCookie(
+            cookie.Name,
+            BytesValue.FromString(cookie.Value),
+            domain)
+        {
+            Path = cookie.Path,
+            SameSite = ConvertSameSitePuppeteerToBidi(cookie.SameSite),
+        };
+
+        // Only set HttpOnly and Secure if explicitly provided
+        if (cookie.HttpOnly.HasValue)
+        {
+            bidiCookie.HttpOnly = cookie.HttpOnly.Value;
+        }
+
+        if (cookie.Secure.HasValue)
+        {
+            bidiCookie.Secure = cookie.Secure.Value;
+        }
+
+        // Convert expiration
+        if (cookie.Expires.HasValue && cookie.Expires.Value != -1)
+        {
+            bidiCookie.Expires = DateTimeOffset.FromUnixTimeSeconds((long)cookie.Expires.Value).DateTime;
+        }
+
+        // Add CDP-specific properties if needed
+        if (cookie.SameParty.HasValue)
+        {
+            bidiCookie.AdditionalData["goog:sameParty"] = cookie.SameParty.Value;
+        }
+
+        if (cookie.SourceScheme.HasValue)
+        {
+            bidiCookie.AdditionalData["goog:sourceScheme"] = ConvertSourceSchemeEnumToString(cookie.SourceScheme.Value);
+        }
+
+        if (cookie.Priority.HasValue)
+        {
+            bidiCookie.AdditionalData["goog:priority"] = ConvertPriorityEnumToString(cookie.Priority.Value);
+        }
+
+        if (!string.IsNullOrEmpty(cookie.Url))
+        {
+            bidiCookie.AdditionalData["goog:url"] = cookie.Url;
+        }
+
+        return bidiCookie;
+    }
+
+    /// <summary>
+    /// Checks if a cookie matches a URL according to the spec.
+    /// </summary>
+    public static bool TestUrlMatchCookie(CookieParam cookie, Uri url)
+    {
+        return TestUrlMatchCookieHostname(cookie, url) && TestUrlMatchCookiePath(cookie, url);
+    }
+
+    /// <summary>
+    /// Checks if cookie domain matches URL hostname.
+    /// </summary>
+    private static bool TestUrlMatchCookieHostname(CookieParam cookie, Uri url)
+    {
+        var cookieDomain = cookie.Domain.ToLowerInvariant();
+        var urlHostname = url.Host.ToLowerInvariant();
+
+        if (cookieDomain == urlHostname)
+        {
+            return true;
+        }
+
+        // TODO: does not consider additional restrictions w.r.t to IP
+        // addresses which is fine as it is for representation and does not
+        // mean that cookies actually apply that way in the browser.
+        // https://datatracker.ietf.org/doc/html/rfc6265#section-5.1.3
+        return cookieDomain.StartsWith(".", StringComparison.Ordinal) && urlHostname.EndsWith(cookieDomain, StringComparison.Ordinal);
+    }
+
+    /// <summary>
+    /// Checks if cookie path matches URL path.
+    /// Spec: https://datatracker.ietf.org/doc/html/rfc6265#section-5.1.4.
+    /// </summary>
+    private static bool TestUrlMatchCookiePath(CookieParam cookie, Uri url)
+    {
+        var uriPath = url.AbsolutePath;
+        var cookiePath = cookie.Path;
+
+        if (uriPath == cookiePath)
+        {
+            // The cookie-path and the request-path are identical.
+            return true;
+        }
+
+        if (uriPath.StartsWith(cookiePath, StringComparison.Ordinal))
+        {
+            // The cookie-path is a prefix of the request-path.
+            if (cookiePath.EndsWith("/", StringComparison.Ordinal))
+            {
+                // The last character of the cookie-path is %x2F ("/").
+                return true;
+            }
+
+            if (uriPath.Length > cookiePath.Length && uriPath[cookiePath.Length] == '/')
+            {
+                // The first character of the request-path that is not included in the cookie-path
+                // is a %x2F ("/") character.
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static SameSite ConvertSameSiteBidiToPuppeteer(CookieSameSiteValue sameSite)
+    {
+        return sameSite switch
+        {
+            CookieSameSiteValue.Strict => SameSite.Strict,
+            CookieSameSiteValue.Lax => SameSite.Lax,
+            _ => SameSite.None,
+        };
+    }
+
+    private static CookieSameSiteValue? ConvertSameSitePuppeteerToBidi(SameSite? sameSite)
+    {
+        return sameSite switch
+        {
+            SameSite.Strict => CookieSameSiteValue.Strict,
+            SameSite.Lax => CookieSameSiteValue.Lax,
+            SameSite.None => CookieSameSiteValue.None,
+            _ => null,
+        };
+    }
+
+    private static string ConvertSourceSchemeEnumToString(CookieSourceScheme sourceScheme)
+    {
+        return sourceScheme switch
+        {
+            CookieSourceScheme.Unset => "Unset",
+            CookieSourceScheme.NonSecure => "NonSecure",
+            CookieSourceScheme.Secure => "Secure",
+            _ => "Unset",
+        };
+    }
+
+    private static string ConvertPriorityEnumToString(CookiePriority priority)
+    {
+        return priority switch
+        {
+            CookiePriority.Low => "Low",
+            CookiePriority.Medium => "Medium",
+            CookiePriority.High => "High",
+            _ => "Medium",
+        };
+    }
+}
diff --git a/lib/PuppeteerSharp/Bidi/BidiPage.cs b/lib/PuppeteerSharp/Bidi/BidiPage.cs
@@ -205,7 +205,66 @@ await BidiMainFrame.BrowsingContext.SetViewportAsync(
     }
 
     /// <inheritdoc />
-    public override Task SetCookieAsync(params CookieParam[] cookies) => throw new NotImplementedException();
+    public override async Task SetCookieAsync(params CookieParam[] cookies)
+    {
+        if (cookies == null)
+        {
+            throw new ArgumentNullException(nameof(cookies));
+        }
+
+        var pageUrl = Url;
+        var pageUrlStartsWithHttp = pageUrl.StartsWith("http", StringComparison.Ordinal);
+
+        foreach (var cookie in cookies)
+        {
+            var cookieUrl = cookie.Url ?? string.Empty;
+            if (string.IsNullOrEmpty(cookieUrl) && pageUrlStartsWithHttp)
+            {
+                cookieUrl = pageUrl;
+            }
+
+            if (cookieUrl == "about:blank")
+            {
+                throw new PuppeteerException($"Blank page can not have cookie \"{cookie.Name}\"");
+            }
+
+            if (cookieUrl.StartsWith("data:", StringComparison.Ordinal))
+            {
+                throw new PuppeteerException($"Data URL page can not have cookie \"{cookie.Name}\"");
+            }
+
+            // TODO: Support Chrome cookie partition keys
+            if (!string.IsNullOrEmpty(cookie.PartitionKey))
+            {
+                throw new PuppeteerException("BiDi only allows domain partition keys");
+            }
+
+            Uri normalizedUrl = null;
+            if (Uri.TryCreate(cookieUrl, UriKind.Absolute, out var parsedUrl))
+            {
+                normalizedUrl = parsedUrl;
+            }
+
+            var domain = cookie.Domain ?? normalizedUrl?.Host;
+            if (string.IsNullOrEmpty(domain))
+            {
+                throw new MessageException("At least one of the url and domain needs to be specified");
+            }
+
+            // Automatically set secure flag for HTTPS URLs if not explicitly provided
+            if (!cookie.Secure.HasValue && normalizedUrl?.Scheme == "https")
+            {
+                cookie.Secure = true;
+            }
+
+            var bidiCookie = BidiCookieHelper.PuppeteerToBidiCookie(cookie, domain);
+
+            await BidiBrowser.Driver.Storage.SetCookieAsync(new WebDriverBiDi.Storage.SetCookieCommandParameters(bidiCookie)
+            {
+                Partition = new WebDriverBiDi.Storage.BrowsingContextPartitionDescriptor(BidiMainFrame.BrowsingContext.Id),
+            }).ConfigureAwait(false);
+        }
+    }
 
     /// <inheritdoc />
     public override async Task CloseAsync(PageCloseOptions options = null)
@@ -221,7 +280,41 @@ public override async Task CloseAsync(PageCloseOptions options = null)
     }
 
     /// <inheritdoc />
-    public override Task DeleteCookieAsync(params CookieParam[] cookies) => throw new NotImplementedException();
+    public override async Task DeleteCookieAsync(params CookieParam[] cookies)
+    {
+        await Task.WhenAll(cookies.Select(async cookie =>
+        {
+            var cookieUrl = cookie.Url ?? Url;
+            Uri normalizedUrl = null;
+            if (Uri.TryCreate(cookieUrl, UriKind.Absolute, out var parsedUrl))
+            {
+                normalizedUrl = parsedUrl;
+            }
+
+            var domain = cookie.Domain ?? normalizedUrl?.Host;
+            if (string.IsNullOrEmpty(domain))
+            {
+                throw new MessageException("At least one of the url and domain needs to be specified");
+            }
+
+            var filter = new WebDriverBiDi.Storage.CookieFilter
+            {
+                Domain = domain,
+                Name = cookie.Name,
+            };
+
+            if (!string.IsNullOrEmpty(cookie.Path))
+            {
+                filter.Path = cookie.Path;
+            }
+
+            await BidiBrowser.Driver.Storage.DeleteCookiesAsync(new WebDriverBiDi.Storage.DeleteCookiesCommandParameters
+            {
+                Filter = filter,
+                Partition = new WebDriverBiDi.Storage.BrowsingContextPartitionDescriptor(BidiMainFrame.BrowsingContext.Id),
+            }).ConfigureAwait(false);
+        })).ConfigureAwait(false);
+    }
 
     /// <inheritdoc />
     public override Task SetDragInterceptionAsync(bool enabled) => throw new NotImplementedException();
@@ -257,7 +350,25 @@ public override async Task CloseAsync(PageCloseOptions options = null)
     public override Task EmulateNetworkConditionsAsync(NetworkConditions networkConditions) => throw new NotImplementedException();
 
     /// <inheritdoc />
-    public override Task<CookieParam[]> GetCookiesAsync(params string[] urls) => throw new NotImplementedException();
+    public override async Task<CookieParam[]> GetCookiesAsync(params string[] urls)
+    {
+        if (urls == null)
+        {
+            throw new ArgumentNullException(nameof(urls));
+        }
+
+        var normalizedUrls = (urls.Length > 0 ? urls : [Url]).Select(url => new Uri(url)).ToArray();
+
+        var result = await BidiBrowser.Driver.Storage.GetCookiesAsync(new WebDriverBiDi.Storage.GetCookiesCommandParameters
+        {
+            Partition = new WebDriverBiDi.Storage.BrowsingContextPartitionDescriptor(BidiMainFrame.BrowsingContext.Id),
+        }).ConfigureAwait(false);
+
+        return result.Cookies
+            .Select(BidiCookieHelper.BidiToPuppeteerCookie)
+            .Where(cookie => normalizedUrls.Any(url => BidiCookieHelper.TestUrlMatchCookie(cookie, url)))
+            .ToArray();
+    }
 
     internal static BidiPage From(BidiBrowserContext browserContext, BrowsingContext browsingContext)
     {
