@mcp-b/chrome-devtools-mcp 2.0.13 → 2.2.0

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

@@ -1,241 +0,0 @@
-// 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/vendor/chrome-devtools-frontend/front_end/core/sdk/CookieModel.js

@@ -1,198 +0,0 @@
-// 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(Root.ExperimentNames.ExperimentName.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/vendor/chrome-devtools-frontend/front_end/core/sdk/CookieParser.js

@@ -1,163 +0,0 @@
-// 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;
-    }
-}