@mcp-b/chrome-devtools-mcp 1.1.0 → 1.1.1

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/Cookie.js

@@ -0,0 +1,241 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+const OPAQUE_PARTITION_KEY = '<opaque>';
+export class Cookie {
+    #name;
+    #value;
+    #type;
+    #attributes = new Map();
+    #size = 0;
+    #priority;
+    #cookieLine = null;
+    #partitionKey;
+    constructor(name, value, type, priority, partitionKey) {
+        this.#name = name;
+        this.#value = value;
+        this.#type = type;
+        this.#priority = (priority || 'Medium');
+        this.#partitionKey = partitionKey;
+    }
+    static fromProtocolCookie(protocolCookie) {
+        const cookie = new Cookie(protocolCookie.name, protocolCookie.value, null, protocolCookie.priority);
+        cookie.addAttribute("domain" /* Attribute.DOMAIN */, protocolCookie['domain']);
+        cookie.addAttribute("path" /* Attribute.PATH */, protocolCookie['path']);
+        if (protocolCookie['expires']) {
+            cookie.addAttribute("expires" /* Attribute.EXPIRES */, protocolCookie['expires'] * 1000);
+        }
+        if (protocolCookie['httpOnly']) {
+            cookie.addAttribute("http-only" /* Attribute.HTTP_ONLY */);
+        }
+        if (protocolCookie['secure']) {
+            cookie.addAttribute("secure" /* Attribute.SECURE */);
+        }
+        if (protocolCookie['sameSite']) {
+            cookie.addAttribute("same-site" /* Attribute.SAME_SITE */, protocolCookie['sameSite']);
+        }
+        if ('sourcePort' in protocolCookie) {
+            cookie.addAttribute("source-port" /* Attribute.SOURCE_PORT */, protocolCookie.sourcePort);
+        }
+        if ('sourceScheme' in protocolCookie) {
+            cookie.addAttribute("source-scheme" /* Attribute.SOURCE_SCHEME */, protocolCookie.sourceScheme);
+        }
+        if ('partitionKey' in protocolCookie) {
+            if (protocolCookie.partitionKey) {
+                cookie.setPartitionKey(protocolCookie.partitionKey.topLevelSite, protocolCookie.partitionKey.hasCrossSiteAncestor);
+            }
+        }
+        if ('partitionKeyOpaque' in protocolCookie && protocolCookie.partitionKeyOpaque) {
+            cookie.addAttribute("partition-key" /* Attribute.PARTITION_KEY */, OPAQUE_PARTITION_KEY);
+        }
+        cookie.setSize(protocolCookie['size']);
+        return cookie;
+    }
+    key() {
+        return (this.domain() || '-') + ' ' + this.name() + ' ' + (this.path() || '-') + ' ' +
+            (this.partitionKey() ?
+                (this.topLevelSite() + ' ' + (this.hasCrossSiteAncestor() ? 'cross_site' : 'same_site')) :
+                '-');
+    }
+    name() {
+        return this.#name;
+    }
+    value() {
+        return this.#value;
+    }
+    type() {
+        return this.#type;
+    }
+    httpOnly() {
+        return this.#attributes.has("http-only" /* Attribute.HTTP_ONLY */);
+    }
+    secure() {
+        return this.#attributes.has("secure" /* Attribute.SECURE */);
+    }
+    partitioned() {
+        return this.#attributes.has("partitioned" /* Attribute.PARTITIONED */) || Boolean(this.partitionKey()) || this.partitionKeyOpaque();
+    }
+    sameSite() {
+        // TODO(allada) This should not rely on #attributes and instead store them individually.
+        // when #attributes get added via addAttribute() they are lowercased, hence the lowercasing of samesite here
+        return this.#attributes.get("same-site" /* Attribute.SAME_SITE */);
+    }
+    partitionKey() {
+        return this.#partitionKey;
+    }
+    setPartitionKey(topLevelSite, hasCrossSiteAncestor) {
+        this.#partitionKey = { topLevelSite, hasCrossSiteAncestor };
+        if (!this.#attributes.has("partitioned" /* Attribute.PARTITIONED */)) {
+            this.addAttribute("partitioned" /* Attribute.PARTITIONED */);
+        }
+    }
+    topLevelSite() {
+        if (!this.#partitionKey) {
+            return '';
+        }
+        return this.#partitionKey?.topLevelSite;
+    }
+    setTopLevelSite(topLevelSite, hasCrossSiteAncestor) {
+        this.setPartitionKey(topLevelSite, hasCrossSiteAncestor);
+    }
+    hasCrossSiteAncestor() {
+        if (!this.#partitionKey) {
+            return false;
+        }
+        return this.#partitionKey?.hasCrossSiteAncestor;
+    }
+    setHasCrossSiteAncestor(hasCrossSiteAncestor) {
+        if (!this.partitionKey() || !Boolean(this.topLevelSite())) {
+            return;
+        }
+        this.setPartitionKey(this.topLevelSite(), hasCrossSiteAncestor);
+    }
+    partitionKeyOpaque() {
+        if (!this.#partitionKey) {
+            return false;
+        }
+        return (this.topLevelSite() === OPAQUE_PARTITION_KEY);
+    }
+    setPartitionKeyOpaque() {
+        this.addAttribute("partition-key" /* Attribute.PARTITION_KEY */, OPAQUE_PARTITION_KEY);
+        this.setPartitionKey(OPAQUE_PARTITION_KEY, false);
+    }
+    priority() {
+        return this.#priority;
+    }
+    session() {
+        // RFC 2965 suggests using Discard attribute to mark session cookies, but this does not seem to be widely used.
+        // Check for absence of explicitly max-age or expiry date instead.
+        return !(this.#attributes.has("expires" /* Attribute.EXPIRES */) || this.#attributes.has("max-age" /* Attribute.MAX_AGE */));
+    }
+    path() {
+        return this.#attributes.get("path" /* Attribute.PATH */);
+    }
+    domain() {
+        return this.#attributes.get("domain" /* Attribute.DOMAIN */);
+    }
+    expires() {
+        return this.#attributes.get("expires" /* Attribute.EXPIRES */);
+    }
+    maxAge() {
+        return this.#attributes.get("max-age" /* Attribute.MAX_AGE */);
+    }
+    sourcePort() {
+        return this.#attributes.get("source-port" /* Attribute.SOURCE_PORT */);
+    }
+    sourceScheme() {
+        return this.#attributes.get("source-scheme" /* Attribute.SOURCE_SCHEME */);
+    }
+    size() {
+        return this.#size;
+    }
+    /**
+     * @deprecated
+     */
+    url() {
+        if (!this.domain() || !this.path()) {
+            return null;
+        }
+        let port = '';
+        const sourcePort = this.sourcePort();
+        // Do not include standard ports to ensure the back-end will change standard ports according to the scheme.
+        if (sourcePort && sourcePort !== 80 && sourcePort !== 443) {
+            port = `:${this.sourcePort()}`;
+        }
+        // We must not consider the this.sourceScheme() here, otherwise it will be impossible to set a cookie without
+        // the Secure attribute from a secure origin.
+        return (this.secure() ? 'https://' : 'http://') + this.domain() + port + this.path();
+    }
+    setSize(size) {
+        this.#size = size;
+    }
+    expiresDate(requestDate) {
+        // RFC 6265 indicates that the max-age attribute takes precedence over the expires attribute
+        if (this.maxAge()) {
+            return new Date(requestDate.getTime() + 1000 * this.maxAge());
+        }
+        if (this.expires()) {
+            return new Date(this.expires());
+        }
+        return null;
+    }
+    addAttribute(key, value) {
+        if (!key) {
+            return;
+        }
+        switch (key) {
+            case "priority" /* Attribute.PRIORITY */:
+                this.#priority = value;
+                break;
+            default:
+                this.#attributes.set(key, value);
+        }
+    }
+    hasAttribute(key) {
+        return this.#attributes.has(key);
+    }
+    getAttribute(key) {
+        return this.#attributes.get(key);
+    }
+    setCookieLine(cookieLine) {
+        this.#cookieLine = cookieLine;
+    }
+    getCookieLine() {
+        return this.#cookieLine;
+    }
+    matchesSecurityOrigin(securityOrigin) {
+        const hostname = new URL(securityOrigin).hostname;
+        return Cookie.isDomainMatch(this.domain(), hostname);
+    }
+    static isDomainMatch(domain, hostname) {
+        // This implementation mirrors
+        // https://source.chromium.org/search?q=net::cookie_util::IsDomainMatch()
+        //
+        // Can domain match in two ways; as a domain cookie (where the cookie
+        // domain begins with ".") or as a host cookie (where it doesn't).
+        // Some consumers of the CookieMonster expect to set cookies on
+        // URLs like http://.strange.url.  To retrieve cookies in this instance,
+        // we allow matching as a host cookie even when the domain_ starts with
+        // a period.
+        if (hostname === domain) {
+            return true;
+        }
+        // Domain cookie must have an initial ".".  To match, it must be
+        // equal to url's host with initial period removed, or a suffix of
+        // it.
+        // Arguably this should only apply to "http" or "https" cookies, but
+        // extension cookie tests currently use the funtionality, and if we
+        // ever decide to implement that it should be done by preventing
+        // such cookies from being set.
+        if (domain?.[0] !== '.') {
+            return false;
+        }
+        // The host with a "." prefixed.
+        if (domain.substr(1) === hostname) {
+            return true;
+        }
+        // A pure suffix of the host (ok since we know the domain already
+        // starts with a ".")
+        return hostname.length > domain.length && hostname.endsWith(domain);
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/CookieModel.js

@@ -0,0 +1,198 @@
+// Copyright 2017 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as Common from '../common/common.js';
+import * as Platform from '../platform/platform.js';
+import * as Root from '../root/root.js';
+import { Cookie } from './Cookie.js';
+import { Events as NetworkManagerEvents, NetworkManager } from './NetworkManager.js';
+import { Events as ResourceTreeModelEvents, ResourceTreeModel } from './ResourceTreeModel.js';
+import { SDKModel } from './SDKModel.js';
+export class CookieModel extends SDKModel {
+    #blockedCookies = new Map();
+    #cookieToBlockedReasons = new Map();
+    #refreshThrottler = new Common.Throttler.Throttler(300);
+    #cookies = new Map();
+    constructor(target) {
+        super(target);
+        target.model(ResourceTreeModel)
+            ?.addEventListener(ResourceTreeModelEvents.PrimaryPageChanged, this.#onPrimaryPageChanged, this);
+        target.model(NetworkManager)
+            ?.addEventListener(NetworkManagerEvents.ResponseReceived, this.#onResponseReceived, this);
+        target.model(NetworkManager)?.addEventListener(NetworkManagerEvents.LoadingFinished, this.#onLoadingFinished, this);
+    }
+    addBlockedCookie(cookie, blockedReasons) {
+        const key = cookie.key();
+        const previousCookie = this.#blockedCookies.get(key);
+        this.#blockedCookies.set(key, cookie);
+        if (blockedReasons) {
+            this.#cookieToBlockedReasons.set(cookie, blockedReasons);
+        }
+        else {
+            this.#cookieToBlockedReasons.delete(cookie);
+        }
+        if (previousCookie) {
+            this.#cookieToBlockedReasons.delete(previousCookie);
+        }
+    }
+    removeBlockedCookie(cookie) {
+        this.#blockedCookies.delete(cookie.key());
+    }
+    async #onPrimaryPageChanged() {
+        this.#blockedCookies.clear();
+        this.#cookieToBlockedReasons.clear();
+        await this.#refresh();
+    }
+    getCookieToBlockedReasonsMap() {
+        return this.#cookieToBlockedReasons;
+    }
+    async #getCookies(urls) {
+        const networkAgent = this.target().networkAgent();
+        const newCookies = new Map(await Promise.all(urls.keysArray().map(domain => networkAgent.invoke_getCookies({ urls: [...urls.get(domain).values()] })
+            .then(({ cookies }) => [domain, cookies.map(Cookie.fromProtocolCookie)]))));
+        const updated = this.#isUpdated(newCookies);
+        this.#cookies = newCookies;
+        if (updated) {
+            this.dispatchEventToListeners("CookieListUpdated" /* Events.COOKIE_LIST_UPDATED */);
+        }
+    }
+    async deleteCookie(cookie) {
+        await this.deleteCookies([cookie]);
+    }
+    async clear(domain, securityOrigin) {
+        if (!this.#isRefreshing()) {
+            await this.#refreshThrottled();
+        }
+        const cookies = domain ? (this.#cookies.get(domain) || []) : [...this.#cookies.values()].flat();
+        cookies.push(...this.#blockedCookies.values());
+        if (securityOrigin) {
+            const cookiesToDelete = cookies.filter(cookie => {
+                return cookie.matchesSecurityOrigin(securityOrigin);
+            });
+            await this.deleteCookies(cookiesToDelete);
+        }
+        else {
+            await this.deleteCookies(cookies);
+        }
+    }
+    async saveCookie(cookie) {
+        let domain = cookie.domain();
+        if (!domain.startsWith('.')) {
+            domain = '';
+        }
+        let expires = undefined;
+        if (cookie.expires()) {
+            expires = Math.floor(Date.parse(`${cookie.expires()}`) / 1000);
+        }
+        const enabled = Root.Runtime.experiments.isEnabled('experimental-cookie-features');
+        const preserveUnset = (scheme) => scheme === "Unset" /* Protocol.Network.CookieSourceScheme.Unset */ ? scheme : undefined;
+        const protocolCookie = {
+            name: cookie.name(),
+            value: cookie.value(),
+            url: cookie.url() || undefined,
+            domain,
+            path: cookie.path(),
+            secure: cookie.secure(),
+            httpOnly: cookie.httpOnly(),
+            sameSite: cookie.sameSite(),
+            expires,
+            priority: cookie.priority(),
+            partitionKey: cookie.partitionKey(),
+            sourceScheme: enabled ? cookie.sourceScheme() : preserveUnset(cookie.sourceScheme()),
+            sourcePort: enabled ? cookie.sourcePort() : undefined,
+        };
+        const response = await this.target().networkAgent().invoke_setCookie(protocolCookie);
+        const error = response.getError();
+        if (error || !response.success) {
+            return false;
+        }
+        await this.#refreshThrottled();
+        return response.success;
+    }
+    /**
+     * Returns cookies needed by current page's frames whose security origins are |domain|.
+     */
+    async getCookiesForDomain(domain, forceUpdate) {
+        if (!this.#isRefreshing() || forceUpdate) {
+            await this.#refreshThrottled();
+        }
+        const normalCookies = this.#cookies.get(domain) || [];
+        return normalCookies.concat(Array.from(this.#blockedCookies.values()));
+    }
+    async deleteCookies(cookies) {
+        const networkAgent = this.target().networkAgent();
+        this.#blockedCookies.clear();
+        this.#cookieToBlockedReasons.clear();
+        await Promise.all(cookies.map(cookie => networkAgent.invoke_deleteCookies({
+            name: cookie.name(),
+            url: undefined,
+            domain: cookie.domain(),
+            path: cookie.path(),
+            partitionKey: cookie.partitionKey(),
+        })));
+        await this.#refreshThrottled();
+    }
+    #isRefreshing() {
+        return Boolean(this.listeners?.size);
+    }
+    #isUpdated(newCookies) {
+        if (newCookies.size !== this.#cookies.size) {
+            return true;
+        }
+        for (const [domain, newDomainCookies] of newCookies) {
+            if (!this.#cookies.has(domain)) {
+                return true;
+            }
+            const oldDomainCookies = this.#cookies.get(domain) || [];
+            if (newDomainCookies.length !== oldDomainCookies.length) {
+                return true;
+            }
+            const comparisonKey = (c) => c.key() + ' ' + c.value();
+            const oldDomainCookieKeys = new Set(oldDomainCookies.map(comparisonKey));
+            for (const newCookie of newDomainCookies) {
+                if (!oldDomainCookieKeys.has(comparisonKey(newCookie))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    #refreshThrottled() {
+        return this.#refreshThrottler.schedule(() => this.#refresh());
+    }
+    #refresh() {
+        const resourceURLs = new Platform.MapUtilities.Multimap();
+        function populateResourceURLs(resource) {
+            const documentURL = Common.ParsedURL.ParsedURL.fromString(resource.documentURL);
+            if (documentURL) {
+                resourceURLs.set(documentURL.securityOrigin(), resource.url);
+            }
+            return false;
+        }
+        const resourceTreeModel = this.target().model(ResourceTreeModel);
+        if (resourceTreeModel) {
+            // In case the current frame was unreachable, add its cookies
+            // because they might help to debug why the frame was unreachable.
+            const unreachableUrl = resourceTreeModel.mainFrame?.unreachableUrl();
+            if (unreachableUrl) {
+                const documentURL = Common.ParsedURL.ParsedURL.fromString(unreachableUrl);
+                if (documentURL) {
+                    resourceURLs.set(documentURL.securityOrigin(), unreachableUrl);
+                }
+            }
+            resourceTreeModel.forAllResources(populateResourceURLs);
+        }
+        return this.#getCookies(resourceURLs);
+    }
+    #onResponseReceived() {
+        if (this.#isRefreshing()) {
+            void this.#refreshThrottled();
+        }
+    }
+    #onLoadingFinished() {
+        if (this.#isRefreshing()) {
+            void this.#refreshThrottled();
+        }
+    }
+}
+SDKModel.register(CookieModel, { capabilities: 16 /* Capability.NETWORK */, autostart: false });

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/CookieParser.js

@@ -0,0 +1,163 @@
+// Copyright 2010 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+// Ideally, we would rely on platform support for parsing a cookie, since
+// this would save us from any potential inconsistency. However, exposing
+// platform cookie parsing logic would require quite a bit of additional
+// plumbing, and at least some platforms lack support for parsing Cookie,
+// which is in a format slightly different from Set-Cookie and is normally
+// only required on the server side.
+import { Cookie } from './Cookie.js';
+export class CookieParser {
+    #domain;
+    #cookies;
+    #input;
+    #originalInputLength;
+    #lastCookie;
+    #lastCookieLine;
+    #lastCookiePosition;
+    constructor(domain) {
+        if (domain) {
+            // Handle #domain according to
+            // https://tools.ietf.org/html/draft-ietf-httpbis-rfc6265bis-03#section-5.3.3
+            this.#domain = domain.toLowerCase().replace(/^\./, '');
+        }
+        this.#cookies = [];
+        this.#originalInputLength = 0;
+    }
+    static parseSetCookie(header, domain) {
+        return (new CookieParser(domain)).parseSetCookie(header);
+    }
+    getCookieAttribute(header) {
+        if (!header) {
+            return null;
+        }
+        switch (header.toLowerCase()) {
+            case 'domain':
+                return "domain" /* Attribute.DOMAIN */;
+            case 'expires':
+                return "expires" /* Attribute.EXPIRES */;
+            case 'max-age':
+                return "max-age" /* Attribute.MAX_AGE */;
+            case 'httponly':
+                return "http-only" /* Attribute.HTTP_ONLY */;
+            case 'name':
+                return "name" /* Attribute.NAME */;
+            case 'path':
+                return "path" /* Attribute.PATH */;
+            case 'samesite':
+                return "same-site" /* Attribute.SAME_SITE */;
+            case 'secure':
+                return "secure" /* Attribute.SECURE */;
+            case 'value':
+                return "value" /* Attribute.VALUE */;
+            case 'priority':
+                return "priority" /* Attribute.PRIORITY */;
+            case 'sourceport':
+                return "source-port" /* Attribute.SOURCE_PORT */;
+            case 'sourcescheme':
+                return "source-scheme" /* Attribute.SOURCE_SCHEME */;
+            case 'partitioned':
+                return "partitioned" /* Attribute.PARTITIONED */;
+            default:
+                console.error('Failed getting cookie attribute: ' + header);
+                return null;
+        }
+    }
+    cookies() {
+        return this.#cookies;
+    }
+    parseSetCookie(setCookieHeader) {
+        if (!this.initialize(setCookieHeader)) {
+            return null;
+        }
+        for (let kv = this.extractKeyValue(); kv; kv = this.extractKeyValue()) {
+            if (this.#lastCookie) {
+                this.#lastCookie.addAttribute(this.getCookieAttribute(kv.key), kv.value);
+            }
+            else {
+                this.addCookie(kv, 1 /* Type.RESPONSE */);
+            }
+            if (this.advanceAndCheckCookieDelimiter()) {
+                this.flushCookie();
+            }
+        }
+        this.flushCookie();
+        return this.#cookies;
+    }
+    initialize(headerValue) {
+        this.#input = headerValue;
+        if (typeof headerValue !== 'string') {
+            return false;
+        }
+        this.#cookies = [];
+        this.#lastCookie = null;
+        this.#lastCookieLine = '';
+        this.#originalInputLength = this.#input.length;
+        return true;
+    }
+    flushCookie() {
+        if (this.#lastCookie) {
+            // if we have a last cookie we know that these valeus all exist, hence the typecasts
+            this.#lastCookie.setSize(this.#originalInputLength - this.#input.length - this.#lastCookiePosition);
+            this.#lastCookie.setCookieLine(this.#lastCookieLine.replace('\n', ''));
+        }
+        this.#lastCookie = null;
+        this.#lastCookieLine = '';
+    }
+    extractKeyValue() {
+        if (!this.#input || !this.#input.length) {
+            return null;
+        }
+        // Note: RFCs offer an option for quoted values that may contain commas and semicolons.
+        // Many browsers/platforms do not support this, however (see http://webkit.org/b/16699
+        // and http://crbug.com/12361). The logic below matches latest versions of IE, Firefox,
+        // Chrome and Safari on some old platforms. The latest version of Safari supports quoted
+        // cookie values, though.
+        const keyValueMatch = /^[ \t]*([^=;\n]+)[ \t]*(?:=[ \t]*([^;\n]*))?/.exec(this.#input);
+        if (!keyValueMatch) {
+            console.error('Failed parsing cookie header before: ' + this.#input);
+            return null;
+        }
+        const result = new KeyValue(keyValueMatch[1]?.trim(), keyValueMatch[2]?.trim(), (this.#originalInputLength) - this.#input.length);
+        this.#lastCookieLine += keyValueMatch[0];
+        this.#input = this.#input.slice(keyValueMatch[0].length);
+        return result;
+    }
+    advanceAndCheckCookieDelimiter() {
+        if (!this.#input) {
+            return false;
+        }
+        const match = /^\s*[\n;]\s*/.exec(this.#input);
+        if (!match) {
+            return false;
+        }
+        this.#lastCookieLine += match[0];
+        this.#input = this.#input.slice(match[0].length);
+        return match[0].match('\n') !== null;
+    }
+    addCookie(keyValue, type) {
+        if (this.#lastCookie) {
+            this.#lastCookie.setSize(keyValue.position - this.#lastCookiePosition);
+        }
+        // Mozilla bug 169091: Mozilla, IE and Chrome treat single token (w/o "=") as
+        // specifying a value for a cookie with empty name.
+        this.#lastCookie = typeof keyValue.value === 'string' ? new Cookie(keyValue.key, keyValue.value, type) :
+            new Cookie('', keyValue.key, type);
+        if (this.#domain) {
+            this.#lastCookie.addAttribute("domain" /* Attribute.DOMAIN */, this.#domain);
+        }
+        this.#lastCookiePosition = keyValue.position;
+        this.#cookies.push(this.#lastCookie);
+    }
+}
+class KeyValue {
+    key;
+    value;
+    position;
+    constructor(key, value, position) {
+        this.key = key;
+        this.value = value;
+        this.position = position;
+    }
+}