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

package/build/node_modules/chrome-devtools-frontend/front_end/core/host/GdpClient.js

@@ -0,0 +1,202 @@
+// 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 Root from '../root/root.js';
+import * as DispatchHttpRequestClient from './DispatchHttpRequestClient.js';
+export var SubscriptionStatus;
+(function (SubscriptionStatus) {
+    SubscriptionStatus["ENABLED"] = "SUBSCRIPTION_STATE_ENABLED";
+    SubscriptionStatus["PENDING"] = "SUBSCRIPTION_STATE_PENDING";
+    SubscriptionStatus["CANCELED"] = "SUBSCRIPTION_STATE_CANCELED";
+    SubscriptionStatus["REFUNDED"] = "SUBSCRIPTION_STATE_REFUNDED";
+    SubscriptionStatus["AWAITING_FIX"] = "SUBSCRIPTION_STATE_AWAITING_FIX";
+    SubscriptionStatus["ON_HOLD"] = "SUBSCRIPTION_STATE_ACCOUNT_ON_HOLD";
+})(SubscriptionStatus || (SubscriptionStatus = {}));
+export var SubscriptionTier;
+(function (SubscriptionTier) {
+    SubscriptionTier["PREMIUM_ANNUAL"] = "SUBSCRIPTION_TIER_PREMIUM_ANNUAL";
+    SubscriptionTier["PREMIUM_MONTHLY"] = "SUBSCRIPTION_TIER_PREMIUM_MONTHLY";
+    SubscriptionTier["PRO_ANNUAL"] = "SUBSCRIPTION_TIER_PRO_ANNUAL";
+    SubscriptionTier["PRO_MONTHLY"] = "SUBSCRIPTION_TIER_PRO_MONTHLY";
+})(SubscriptionTier || (SubscriptionTier = {}));
+export var EligibilityStatus;
+(function (EligibilityStatus) {
+    EligibilityStatus["ELIGIBLE"] = "ELIGIBLE";
+    EligibilityStatus["NOT_ELIGIBLE"] = "NOT_ELIGIBLE";
+})(EligibilityStatus || (EligibilityStatus = {}));
+export var EmailPreference;
+(function (EmailPreference) {
+    EmailPreference["ENABLED"] = "ENABLED";
+    EmailPreference["DISABLED"] = "DISABLED";
+})(EmailPreference || (EmailPreference = {}));
+/**
+ * The `batchGet` awards endpoint returns badge names with an
+ * obfuscated user ID (e.g., `profiles/12345/awards/badge-name`).
+ * This function normalizes them to use `me` instead of the ID
+ * (e.g., `profiles/me/awards/badge-path`) to match the format
+ * used for client-side requests.
+ **/
+function normalizeBadgeName(name) {
+    return name.replace(/profiles\/[^/]+\/awards\//, 'profiles/me/awards/');
+}
+export const GOOGLE_DEVELOPER_PROGRAM_PROFILE_LINK = 'https://developers.google.com/profile/u/me';
+const ORIGIN_APPLICATION_NAME = 'APPLICATION_CHROME_DEVTOOLS';
+async function makeHttpRequest(request) {
+    if (!isGdpProfilesAvailable()) {
+        throw new DispatchHttpRequestClient.DispatchHttpRequestError(DispatchHttpRequestClient.ErrorType.HTTP_RESPONSE_UNAVAILABLE);
+    }
+    const response = await DispatchHttpRequestClient.makeHttpRequest(request);
+    return response;
+}
+const SERVICE_NAME = 'gdpService';
+let gdpClientInstance = null;
+export class GdpClient {
+    #cachedProfilePromise;
+    #cachedEligibilityPromise;
+    constructor() {
+    }
+    static instance({ forceNew } = { forceNew: false }) {
+        if (!gdpClientInstance || forceNew) {
+            gdpClientInstance = new GdpClient();
+        }
+        return gdpClientInstance;
+    }
+    /**
+     * Fetches the user's GDP profile and eligibility status.
+     *
+     * It first attempts to fetch the profile. If the profile is not found
+     * (a `NOT_FOUND` error), this is handled gracefully by treating the profile
+     * as `null` and then proceeding to check for eligibility.
+     *
+     * @returns A promise that resolves with an object containing the `profile`
+     * and `isEligible` status, or `null` if an unexpected error occurs.
+     */
+    async getProfile() {
+        try {
+            const profile = await this.#getProfile();
+            return {
+                profile,
+                isEligible: true,
+            };
+        }
+        catch (err) {
+            if (err instanceof DispatchHttpRequestClient.DispatchHttpRequestError &&
+                err.type === DispatchHttpRequestClient.ErrorType.HTTP_RESPONSE_UNAVAILABLE) {
+                return null;
+            }
+        }
+        try {
+            const checkEligibilityResponse = await this.#checkEligibility();
+            return {
+                profile: null,
+                isEligible: checkEligibilityResponse.createProfile === EligibilityStatus.ELIGIBLE,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async #getProfile() {
+        if (this.#cachedProfilePromise) {
+            return await this.#cachedProfilePromise;
+        }
+        this.#cachedProfilePromise = makeHttpRequest({
+            service: SERVICE_NAME,
+            path: '/v1beta1/profile:get',
+            method: 'GET',
+        }).then(profile => {
+            this.#cachedEligibilityPromise = Promise.resolve({ createProfile: EligibilityStatus.ELIGIBLE });
+            return profile;
+        });
+        return await this.#cachedProfilePromise;
+    }
+    async #checkEligibility() {
+        if (this.#cachedEligibilityPromise) {
+            return await this.#cachedEligibilityPromise;
+        }
+        this.#cachedEligibilityPromise =
+            makeHttpRequest({ service: SERVICE_NAME, path: '/v1beta1/eligibility:check', method: 'GET' });
+        return await this.#cachedEligibilityPromise;
+    }
+    /**
+     * @returns null if the request fails, the awarded badge names otherwise.
+     */
+    async getAwardedBadgeNames({ names }) {
+        try {
+            const response = await makeHttpRequest({
+                service: SERVICE_NAME,
+                path: '/v1beta1/profiles/me/awards:batchGet',
+                method: 'GET',
+                queryParams: {
+                    allowMissing: 'true',
+                    names,
+                }
+            });
+            return new Set(response.awards?.map(award => normalizeBadgeName(award.name)) ?? []);
+        }
+        catch {
+            return null;
+        }
+    }
+    async createProfile({ user, emailPreference }) {
+        try {
+            const response = await makeHttpRequest({
+                service: SERVICE_NAME,
+                path: '/v1beta1/profiles',
+                method: 'POST',
+                body: JSON.stringify({
+                    user,
+                    newsletter_email: emailPreference,
+                    creation_origin: {
+                        origin_application: ORIGIN_APPLICATION_NAME,
+                    }
+                }),
+            });
+            this.#clearCache();
+            return response;
+        }
+        catch {
+            return null;
+        }
+    }
+    #clearCache() {
+        this.#cachedProfilePromise = undefined;
+        this.#cachedEligibilityPromise = undefined;
+    }
+    async createAward({ name }) {
+        try {
+            const response = await makeHttpRequest({
+                service: SERVICE_NAME,
+                path: '/v1beta1/profiles/me/awards',
+                method: 'POST',
+                body: JSON.stringify({
+                    awardingUri: 'devtools://devtools',
+                    name,
+                })
+            });
+            return response;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+export function isGdpProfilesAvailable() {
+    const isBaseFeatureEnabled = Boolean(Root.Runtime.hostConfig.devToolsGdpProfiles?.enabled);
+    const isBrandedBuild = Boolean(Root.Runtime.hostConfig.devToolsGdpProfilesAvailability?.enabled);
+    const isOffTheRecordProfile = Root.Runtime.hostConfig.isOffTheRecord;
+    const isDisabledByEnterprisePolicy = getGdpProfilesEnterprisePolicy() === Root.Runtime.GdpProfilesEnterprisePolicyValue.DISABLED;
+    return isBaseFeatureEnabled && isBrandedBuild && !isOffTheRecordProfile && !isDisabledByEnterprisePolicy;
+}
+export function getGdpProfilesEnterprisePolicy() {
+    return (Root.Runtime.hostConfig.devToolsGdpProfilesAvailability?.enterprisePolicyValue ??
+        Root.Runtime.GdpProfilesEnterprisePolicyValue.DISABLED);
+}
+export function isBadgesEnabled() {
+    const isBadgesEnabledByEnterprisePolicy = getGdpProfilesEnterprisePolicy() === Root.Runtime.GdpProfilesEnterprisePolicyValue.ENABLED;
+    const isBadgesEnabledByFeatureFlag = Boolean(Root.Runtime.hostConfig.devToolsGdpProfiles?.badgesEnabled);
+    return isBadgesEnabledByEnterprisePolicy && isBadgesEnabledByFeatureFlag;
+}
+export function isStarterBadgeEnabled() {
+    return Boolean(Root.Runtime.hostConfig.devToolsGdpProfiles?.starterBadgeEnabled);
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/host/InspectorFrontendHost.js

@@ -0,0 +1,92 @@
+// Copyright 2009 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 Root from '../root/root.js';
+import { EventDescriptors, } from './InspectorFrontendHostAPI.js';
+import { InspectorFrontendHostStub } from './InspectorFrontendHostStub.js';
+import { streamWrite as resourceLoaderStreamWrite } from './ResourceLoader.js';
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export let InspectorFrontendHostInstance;
+class InspectorFrontendAPIImpl {
+    constructor() {
+        for (const descriptor of EventDescriptors) {
+            // @ts-expect-error Dispatcher magic
+            this[descriptor[0]] = this.dispatch.bind(this, descriptor[0], descriptor[1], descriptor[2]);
+        }
+    }
+    dispatch(name, signature, _runOnceLoaded, ...params) {
+        // Single argument methods get dispatched with the param.
+        if (signature.length < 2) {
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                InspectorFrontendHostInstance.events.dispatchEventToListeners(name, params[0]);
+            }
+            catch (error) {
+                console.error(error + ' ' + error.stack);
+            }
+            return;
+        }
+        const data = {};
+        for (let i = 0; i < signature.length; ++i) {
+            data[signature[i]] = params[i];
+        }
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            InspectorFrontendHostInstance.events.dispatchEventToListeners(name, data);
+        }
+        catch (error) {
+            console.error(error + ' ' + error.stack);
+        }
+    }
+    streamWrite(id, chunk) {
+        resourceLoaderStreamWrite(id, chunk);
+    }
+}
+/**
+ * Installs the provided host bindings implementation as the globally used one by DevTools.
+ *
+ *   - In non-hosted mode this is provided by `devtools_compatibility.js`.
+ *   - In hosted mode this tends to be the {@link InspectorFrontendHostStub}.
+ *   - For the MCP server this is a custom node.js specific implementation.
+ *
+ * Note that missing methods will be copied over from the stub.
+ */
+export function installInspectorFrontendHost(instance) {
+    globalThis.InspectorFrontendHost = InspectorFrontendHostInstance = instance;
+    if (!(instance instanceof InspectorFrontendHostStub)) {
+        // Add stubs for missing methods.
+        const proto = InspectorFrontendHostStub.prototype;
+        for (const name of Object.getOwnPropertyNames(proto)) {
+            const stub = proto[name];
+            if (typeof stub !== 'function' || InspectorFrontendHostInstance[name]) {
+                continue;
+            }
+            console.error(`Incompatible embedder: method Host.InspectorFrontendHost.${name} is missing. Using stub instead.`);
+            // @ts-expect-error Global injected by devtools_compatibility.js
+            InspectorFrontendHostInstance[name] = stub;
+        }
+    }
+    // Attach the events object.
+    InspectorFrontendHostInstance.events = new Common.ObjectWrapper.ObjectWrapper();
+}
+(function () {
+    // FIXME: This file is included into both apps, since the devtools_app needs the InspectorFrontendHostAPI only,
+    // so the host instance should not be initialized there.
+    installInspectorFrontendHost(globalThis.InspectorFrontendHost ?? new InspectorFrontendHostStub());
+    globalThis.InspectorFrontendAPI = new InspectorFrontendAPIImpl();
+})();
+export function isUnderTest(prefs) {
+    // Integration tests rely on test queryParam.
+    if (Root.Runtime.Runtime.queryParam('test')) {
+        return true;
+    }
+    // Browser tests rely on prefs.
+    if (prefs) {
+        return prefs['isUnderTest'] === 'true';
+    }
+    return Common.Settings.Settings.hasInstance() &&
+        Common.Settings.Settings.instance().createSetting('isUnderTest', false).get();
+}
+// The stub class used to be declared here so for backwards compatibility we re-export it from here.
+export { InspectorFrontendHostStub };

package/build/node_modules/chrome-devtools-frontend/front_end/core/host/InspectorFrontendHostAPI.js

@@ -0,0 +1,69 @@
+// Copyright 2015 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+/**
+ * This values should match the one getting called from Chromium
+ */
+export var Events;
+(function (Events) {
+    /* eslint-disable @typescript-eslint/naming-convention -- Accessed from web_tests */
+    Events["AppendedToURL"] = "appendedToURL";
+    Events["CanceledSaveURL"] = "canceledSaveURL";
+    Events["ColorThemeChanged"] = "colorThemeChanged";
+    Events["ContextMenuCleared"] = "contextMenuCleared";
+    Events["ContextMenuItemSelected"] = "contextMenuItemSelected";
+    Events["DeviceCountUpdated"] = "deviceCountUpdated";
+    Events["DevicesDiscoveryConfigChanged"] = "devicesDiscoveryConfigChanged";
+    Events["DevicesPortForwardingStatusChanged"] = "devicesPortForwardingStatusChanged";
+    Events["DevicesUpdated"] = "devicesUpdated";
+    Events["DispatchMessage"] = "dispatchMessage";
+    Events["DispatchMessageChunk"] = "dispatchMessageChunk";
+    Events["EnterInspectElementMode"] = "enterInspectElementMode";
+    Events["EyeDropperPickedColor"] = "eyeDropperPickedColor";
+    Events["FileSystemsLoaded"] = "fileSystemsLoaded";
+    Events["FileSystemRemoved"] = "fileSystemRemoved";
+    Events["FileSystemAdded"] = "fileSystemAdded";
+    Events["FileSystemFilesChangedAddedRemoved"] = "fileSystemFilesChangedAddedRemoved";
+    Events["IndexingTotalWorkCalculated"] = "indexingTotalWorkCalculated";
+    Events["IndexingWorked"] = "indexingWorked";
+    Events["IndexingDone"] = "indexingDone";
+    Events["KeyEventUnhandled"] = "keyEventUnhandled";
+    Events["ReloadInspectedPage"] = "reloadInspectedPage";
+    Events["RevealSourceLine"] = "revealSourceLine";
+    Events["SavedURL"] = "savedURL";
+    Events["SearchCompleted"] = "searchCompleted";
+    Events["SetInspectedTabId"] = "setInspectedTabId";
+    Events["SetUseSoftMenu"] = "setUseSoftMenu";
+    Events["ShowPanel"] = "showPanel";
+    /* eslint-enable @typescript-eslint/naming-convention */
+})(Events || (Events = {}));
+export const EventDescriptors = [
+    [Events.AppendedToURL, ['url']],
+    [Events.CanceledSaveURL, ['url']],
+    [Events.ColorThemeChanged, []],
+    [Events.ContextMenuCleared, []],
+    [Events.ContextMenuItemSelected, ['id']],
+    [Events.DeviceCountUpdated, ['count']],
+    [Events.DevicesDiscoveryConfigChanged, ['config']],
+    [Events.DevicesPortForwardingStatusChanged, ['status']],
+    [Events.DevicesUpdated, ['devices']],
+    [Events.DispatchMessage, ['messageObject']],
+    [Events.DispatchMessageChunk, ['messageChunk', 'messageSize']],
+    [Events.EnterInspectElementMode, []],
+    [Events.EyeDropperPickedColor, ['color']],
+    [Events.FileSystemsLoaded, ['fileSystems']],
+    [Events.FileSystemRemoved, ['fileSystemPath']],
+    [Events.FileSystemAdded, ['errorMessage', 'fileSystem']],
+    [Events.FileSystemFilesChangedAddedRemoved, ['changed', 'added', 'removed']],
+    [Events.IndexingTotalWorkCalculated, , ['requestId', 'fileSystemPath', 'totalWork']],
+    [Events.IndexingWorked, ['requestId', 'fileSystemPath', 'worked']],
+    [Events.IndexingDone, ['requestId', 'fileSystemPath']],
+    [Events.KeyEventUnhandled, ['event']],
+    [Events.ReloadInspectedPage, ['hard']],
+    [Events.RevealSourceLine, ['url', 'lineNumber', 'columnNumber']],
+    [Events.SavedURL, ['url', 'fileSystemPath']],
+    [Events.SearchCompleted, ['requestId', 'fileSystemPath', 'files']],
+    [Events.SetInspectedTabId, ['tabId']],
+    [Events.SetUseSoftMenu, ['useSoftMenu']],
+    [Events.ShowPanel, ['panelName']],
+];