chrome-devtools-mcp 0.10.0 → 0.10.2

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/PartitioningBlobURLIssue.js

@@ -0,0 +1,63 @@
+// Copyright 2025 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 i18n from '../../core/i18n/i18n.js';
+import { Issue } from './Issue.js';
+const UIStrings = {
+    /**
+     * @description Title for Partitioning BlobURL explainer url link.
+     */
+    partitioningBlobURL: 'Partitioning BlobURL',
+    /**
+     * @description Title for Chrome Status Entry url link.
+     */
+    chromeStatusEntry: 'Chrome Status Entry'
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/PartitioningBlobURLIssue.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class PartitioningBlobURLIssue extends Issue {
+    #issueDetails;
+    constructor(issueDetails, issuesModel) {
+        super("PartitioningBlobURLIssue" /* Protocol.Audits.InspectorIssueCode.PartitioningBlobURLIssue */, issuesModel);
+        this.#issueDetails = issueDetails;
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    getDescription() {
+        const fileName = this.#issueDetails.partitioningBlobURLInfo ===
+            "BlockedCrossPartitionFetching" /* Protocol.Audits.PartitioningBlobURLInfo.BlockedCrossPartitionFetching */ ?
+            'fetchingPartitionedBlobURL.md' :
+            'navigatingPartitionedBlobURL.md';
+        return {
+            file: fileName,
+            links: [
+                {
+                    link: 'https://developers.google.com/privacy-sandbox/cookies/storage-partitioning',
+                    linkTitle: i18nString(UIStrings.partitioningBlobURL),
+                },
+                {
+                    link: 'https://chromestatus.com/feature/5130361898795008',
+                    linkTitle: i18nString(UIStrings.chromeStatusEntry),
+                },
+            ],
+        };
+    }
+    details() {
+        return this.#issueDetails;
+    }
+    getKind() {
+        return "BreakingChange" /* IssueKind.BREAKING_CHANGE */;
+    }
+    primaryKey() {
+        return JSON.stringify(this.#issueDetails);
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const details = inspectorIssue.details.partitioningBlobURLIssueDetails;
+        if (!details) {
+            console.warn('Partitioning BlobURL issue without details received.');
+            return [];
+        }
+        return [new PartitioningBlobURLIssue(details, issuesModel)];
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/PropertyRuleIssue.js

@@ -0,0 +1,63 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import { Issue } from './Issue.js';
+export class PropertyRuleIssue extends Issue {
+    #issueDetails;
+    #primaryKey;
+    constructor(issueDetails, issuesModel) {
+        const code = JSON.stringify(issueDetails);
+        super(code, issuesModel);
+        this.#primaryKey = code;
+        this.#issueDetails = issueDetails;
+    }
+    sources() {
+        return [this.#issueDetails.sourceCodeLocation];
+    }
+    details() {
+        return this.#issueDetails;
+    }
+    primaryKey() {
+        return this.#primaryKey;
+    }
+    getPropertyName() {
+        switch (this.#issueDetails.propertyRuleIssueReason) {
+            case "InvalidInherits" /* Protocol.Audits.PropertyRuleIssueReason.InvalidInherits */:
+                return 'inherits';
+            case "InvalidInitialValue" /* Protocol.Audits.PropertyRuleIssueReason.InvalidInitialValue */:
+                return 'initial-value';
+            case "InvalidSyntax" /* Protocol.Audits.PropertyRuleIssueReason.InvalidSyntax */:
+                return 'syntax';
+        }
+        return '';
+    }
+    getDescription() {
+        if (this.#issueDetails.propertyRuleIssueReason === "InvalidName" /* Protocol.Audits.PropertyRuleIssueReason.InvalidName */) {
+            return {
+                file: 'propertyRuleInvalidNameIssue.md',
+                links: [],
+            };
+        }
+        const value = this.#issueDetails.propertyValue ? `: ${this.#issueDetails.propertyValue}` : '';
+        const property = `${this.getPropertyName()}${value}`;
+        return {
+            file: 'propertyRuleIssue.md',
+            substitutions: new Map([['PLACEHOLDER_property', property]]),
+            links: [],
+        };
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    getKind() {
+        return "PageError" /* IssueKind.PAGE_ERROR */;
+    }
+    static fromInspectorIssue(issueModel, inspectorIssue) {
+        const propertyRuleIssueDetails = inspectorIssue.details.propertyRuleIssueDetails;
+        if (!propertyRuleIssueDetails) {
+            console.warn('Property rule issue without details received');
+            return [];
+        }
+        return [new PropertyRuleIssue(propertyRuleIssueDetails, issueModel)];
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/QuirksModeIssue.js

@@ -0,0 +1,53 @@
+// Copyright 2021 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 i18n from '../../core/i18n/i18n.js';
+import { Issue } from './Issue.js';
+const UIStrings = {
+    /**
+     * @description Link title for the Quirks Mode issue in the Issues panel
+     */
+    documentCompatibilityMode: 'Document compatibility mode',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/QuirksModeIssue.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class QuirksModeIssue extends Issue {
+    #issueDetails;
+    constructor(issueDetails, issuesModel) {
+        const mode = issueDetails.isLimitedQuirksMode ? 'LimitedQuirksMode' : 'QuirksMode';
+        const umaCode = ["QuirksModeIssue" /* Protocol.Audits.InspectorIssueCode.QuirksModeIssue */, mode].join('::');
+        super({ code: "QuirksModeIssue" /* Protocol.Audits.InspectorIssueCode.QuirksModeIssue */, umaCode }, issuesModel);
+        this.#issueDetails = issueDetails;
+    }
+    primaryKey() {
+        return `${this.code()}-(${this.#issueDetails.documentNodeId})-(${this.#issueDetails.url})`;
+    }
+    getCategory() {
+        return "QuirksMode" /* IssueCategory.QUIRKS_MODE */;
+    }
+    details() {
+        return this.#issueDetails;
+    }
+    getDescription() {
+        return {
+            file: 'CompatibilityModeQuirks.md',
+            links: [
+                {
+                    link: 'https://web.dev/doctype/',
+                    linkTitle: i18nString(UIStrings.documentCompatibilityMode),
+                },
+            ],
+        };
+    }
+    getKind() {
+        return "Improvement" /* IssueKind.IMPROVEMENT */;
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const quirksModeIssueDetails = inspectorIssue.details.quirksModeIssueDetails;
+        if (!quirksModeIssueDetails) {
+            console.warn('Quirks Mode issue without details received.');
+            return [];
+        }
+        return [new QuirksModeIssue(quirksModeIssueDetails, issuesModel)];
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/RelatedIssue.js

@@ -0,0 +1,70 @@
+// Copyright 2020 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 '../../core/common/common.js';
+import * as SDK from '../../core/sdk/sdk.js';
+import { CookieIssue } from './CookieIssue.js';
+import { IssuesManager } from './IssuesManager.js';
+function issuesAssociatedWithNetworkRequest(issues, request) {
+    return issues.filter(issue => {
+        for (const affectedRequest of issue.requests()) {
+            if (affectedRequest.requestId === request.requestId()) {
+                return true;
+            }
+        }
+        return false;
+    });
+}
+function issuesAssociatedWithCookie(issues, domain, name, path) {
+    return issues.filter(issue => {
+        for (const cookie of issue.cookies()) {
+            if (cookie.domain === domain && cookie.name === name && cookie.path === path) {
+                return true;
+            }
+        }
+        return false;
+    });
+}
+/**
+ * @throws In case obj has an unsupported type (i.e. not part of the IssuesAssociatble union).
+ */
+export function issuesAssociatedWith(issues, obj) {
+    if (obj instanceof SDK.NetworkRequest.NetworkRequest) {
+        return issuesAssociatedWithNetworkRequest(issues, obj);
+    }
+    if (obj instanceof SDK.Cookie.Cookie) {
+        return issuesAssociatedWithCookie(issues, obj.domain(), obj.name(), obj.path());
+    }
+    throw new Error(`issues can not be associated with ${JSON.stringify(obj)}`);
+}
+export function hasIssues(obj) {
+    const issues = Array.from(IssuesManager.instance().issues());
+    return issuesAssociatedWith(issues, obj).length > 0;
+}
+export function hasIssueOfCategory(obj, category) {
+    const issues = Array.from(IssuesManager.instance().issues());
+    return issuesAssociatedWith(issues, obj).some(issue => issue.getCategory() === category);
+}
+export function hasThirdPartyPhaseoutCookieIssue(obj) {
+    const issues = Array.from(IssuesManager.instance().issues());
+    return issuesAssociatedWith(issues, obj)
+        .some(issue => CookieIssue.getSubCategory(issue.code()) === "ThirdPartyPhaseoutCookie" /* CookieIssueSubCategory.THIRD_PARTY_PHASEOUT_COOKIE */);
+}
+export function hasThirdPartyPhaseoutCookieIssueForDomain(domain) {
+    const issues = Array.from(IssuesManager.instance().issues());
+    const issuesForDomain = issues.filter(issue => Array.from(issue.cookies()).some(cookie => cookie.domain === domain));
+    return issuesForDomain.some(issue => CookieIssue.getSubCategory(issue.code()) === "ThirdPartyPhaseoutCookie" /* CookieIssueSubCategory.THIRD_PARTY_PHASEOUT_COOKIE */);
+}
+export async function reveal(obj, category) {
+    if (typeof obj === 'string') {
+        const issue = IssuesManager.instance().getIssueById(obj);
+        if (issue) {
+            return await Common.Revealer.reveal(issue);
+        }
+    }
+    const issues = Array.from(IssuesManager.instance().issues());
+    const candidates = issuesAssociatedWith(issues, obj).filter(issue => !category || issue.getCategory() === category);
+    if (candidates.length > 0) {
+        return await Common.Revealer.reveal(candidates[0]);
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/SRIMessageSignatureIssue.js

@@ -0,0 +1,91 @@
+// Copyright 2025 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 i18n from '../../core/i18n/i18n.js';
+import { Issue } from './Issue.js';
+import { resolveLazyDescription, } from './MarkdownIssueDescription.js';
+const UIStrings = {
+    /**
+     * @description Title for HTTP Message Signatures specification url
+     */
+    httpMessageSignatures: 'HTTP Message Signatures (RFC9421)',
+    /**
+     * @description Title for Signature-based Integrity specification url
+     */
+    signatureBasedIntegrity: 'Signature-based Integrity',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/SRIMessageSignatureIssue.ts', UIStrings);
+const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
+function generateGroupingIssueCode(details) {
+    const issueCode = `${"SRIMessageSignatureIssue" /* Protocol.Audits.InspectorIssueCode.SRIMessageSignatureIssue */}::${details.error}`;
+    if (details.error === "ValidationFailedSignatureMismatch" /* Protocol.Audits.SRIMessageSignatureError.ValidationFailedSignatureMismatch */) {
+        // Signature mismatch errors should be grouped by "signature base".
+        return issueCode + details.signatureBase;
+    }
+    if (details.error === "ValidationFailedIntegrityMismatch" /* Protocol.Audits.SRIMessageSignatureError.ValidationFailedIntegrityMismatch */) {
+        // Integrity mismatch errors should be grouped by integrity assertion.
+        return issueCode + details.integrityAssertions.join();
+    }
+    // Otherwise, simply group by issue type:
+    return issueCode;
+}
+export class SRIMessageSignatureIssue extends Issue {
+    #issueDetails;
+    constructor(issueDetails, issuesModel) {
+        super({
+            code: generateGroupingIssueCode(issueDetails),
+            umaCode: `${"SRIMessageSignatureIssue" /* Protocol.Audits.InspectorIssueCode.SRIMessageSignatureIssue */}::${issueDetails.error}`,
+        }, issuesModel);
+        this.#issueDetails = issueDetails;
+    }
+    details() {
+        return this.#issueDetails;
+    }
+    // Overriding `Issue<String>`:
+    primaryKey() {
+        return JSON.stringify(this.details());
+    }
+    getDescription() {
+        const description = {
+            file: `sri${this.details().error}.md`,
+            links: [
+                {
+                    link: 'https://www.rfc-editor.org/rfc/rfc9421.html',
+                    linkTitle: i18nLazyString(UIStrings.httpMessageSignatures),
+                },
+                {
+                    link: 'https://wicg.github.io/signature-based-sri/',
+                    linkTitle: i18nLazyString(UIStrings.signatureBasedIntegrity),
+                }
+            ],
+            substitutions: new Map()
+        };
+        if (this.#issueDetails.error === "ValidationFailedSignatureMismatch" /* Protocol.Audits.SRIMessageSignatureError.ValidationFailedSignatureMismatch */) {
+            description.substitutions?.set('PLACEHOLDER_signatureBase', () => this.#issueDetails.signatureBase);
+        }
+        if (this.#issueDetails.error === "ValidationFailedIntegrityMismatch" /* Protocol.Audits.SRIMessageSignatureError.ValidationFailedIntegrityMismatch */) {
+            description.substitutions?.set('PLACEHOLDER_integrityAssertions', () => {
+                const prefix = '\n* ';
+                return prefix + this.details().integrityAssertions.join(prefix);
+            });
+        }
+        return resolveLazyDescription(description);
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    getKind() {
+        return "PageError" /* IssueKind.PAGE_ERROR */;
+    }
+    requests() {
+        return this.details().request ? [this.details().request] : [];
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const details = inspectorIssue.details.sriMessageSignatureIssueDetails;
+        if (!details) {
+            console.warn('SRI Message Signature issue without details received.');
+            return [];
+        }
+        return [new SRIMessageSignatureIssue(details, issuesModel)];
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/SharedArrayBufferIssue.js

@@ -0,0 +1,54 @@
+// Copyright 2020 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 i18n from '../../core/i18n/i18n.js';
+import { Issue } from './Issue.js';
+const UIStrings = {
+    /**
+     * @description Label for the link for SharedArrayBuffer Issues. The full text reads "Enabling `SharedArrayBuffer`"
+     * and is the title of an article that describes how to enable a JavaScript feature called SharedArrayBuffer.
+     */
+    enablingSharedArrayBuffer: 'Enabling `SharedArrayBuffer`',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/SharedArrayBufferIssue.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class SharedArrayBufferIssue extends Issue {
+    #issueDetails;
+    constructor(issueDetails, issuesModel) {
+        const umaCode = ["SharedArrayBufferIssue" /* Protocol.Audits.InspectorIssueCode.SharedArrayBufferIssue */, issueDetails.type].join('::');
+        super({ code: "SharedArrayBufferIssue" /* Protocol.Audits.InspectorIssueCode.SharedArrayBufferIssue */, umaCode }, issuesModel);
+        this.#issueDetails = issueDetails;
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    details() {
+        return this.#issueDetails;
+    }
+    getDescription() {
+        return {
+            file: 'sharedArrayBuffer.md',
+            links: [{
+                    link: 'https://developer.chrome.com/blog/enabling-shared-array-buffer/',
+                    linkTitle: i18nString(UIStrings.enablingSharedArrayBuffer),
+                }],
+        };
+    }
+    primaryKey() {
+        return JSON.stringify(this.#issueDetails);
+    }
+    getKind() {
+        if (this.#issueDetails.isWarning) {
+            return "BreakingChange" /* IssueKind.BREAKING_CHANGE */;
+        }
+        return "PageError" /* IssueKind.PAGE_ERROR */;
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const sabIssueDetails = inspectorIssue.details.sharedArrayBufferIssueDetails;
+        if (!sabIssueDetails) {
+            console.warn('SAB transfer issue without details received.');
+            return [];
+        }
+        return [new SharedArrayBufferIssue(sabIssueDetails, issuesModel)];
+    }
+}