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

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

@@ -1,535 +0,0 @@
-// Copyright 2012 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 Host from '../host/host.js';
-import { DebuggerModel } from './DebuggerModel.js';
-import { HeapProfilerModel } from './HeapProfilerModel.js';
-import { RemoteFunction, RemoteObject, RemoteObjectImpl, RemoteObjectProperty, ScopeRemoteObject, } from './RemoteObject.js';
-import { SDKModel } from './SDKModel.js';
-import { Type } from './Target.js';
-export class RuntimeModel extends SDKModel {
-    agent;
-    #executionContextById = new Map();
-    #executionContextComparator = ExecutionContext.comparator;
-    constructor(target) {
-        super(target);
-        this.agent = target.runtimeAgent();
-        this.target().registerRuntimeDispatcher(new RuntimeDispatcher(this));
-        void this.agent.invoke_enable();
-        if (Common.Settings.Settings.instance().moduleSetting('custom-formatters').get()) {
-            void this.agent.invoke_setCustomObjectFormatterEnabled({ enabled: true });
-        }
-        Common.Settings.Settings.instance()
-            .moduleSetting('custom-formatters')
-            .addChangeListener(this.customFormattersStateChanged.bind(this));
-    }
-    static isSideEffectFailure(response) {
-        const exceptionDetails = 'exceptionDetails' in response && response.exceptionDetails;
-        return Boolean(exceptionDetails &&
-            exceptionDetails.exception?.description?.startsWith('EvalError: Possible side-effect in debug-evaluate'));
-    }
-    debuggerModel() {
-        return this.target().model(DebuggerModel);
-    }
-    heapProfilerModel() {
-        return this.target().model(HeapProfilerModel);
-    }
-    executionContexts() {
-        return [...this.#executionContextById.values()].sort(this.executionContextComparator());
-    }
-    setExecutionContextComparator(comparator) {
-        this.#executionContextComparator = comparator;
-    }
-    /**
-     * comparator
-     */
-    executionContextComparator() {
-        return this.#executionContextComparator;
-    }
-    defaultExecutionContext() {
-        for (const context of this.executionContexts()) {
-            if (context.isDefault) {
-                return context;
-            }
-        }
-        return null;
-    }
-    executionContext(id) {
-        return this.#executionContextById.get(id) || null;
-    }
-    executionContextCreated(context) {
-        const data = context.auxData || { isDefault: true };
-        const executionContext = new ExecutionContext(this, context.id, context.uniqueId, context.name, context.origin, data['isDefault'], data['frameId']);
-        this.#executionContextById.set(executionContext.id, executionContext);
-        this.dispatchEventToListeners(Events.ExecutionContextCreated, executionContext);
-    }
-    executionContextDestroyed(executionContextId) {
-        const executionContext = this.#executionContextById.get(executionContextId);
-        if (!executionContext) {
-            return;
-        }
-        this.debuggerModel().executionContextDestroyed(executionContext);
-        this.#executionContextById.delete(executionContextId);
-        this.dispatchEventToListeners(Events.ExecutionContextDestroyed, executionContext);
-    }
-    fireExecutionContextOrderChanged() {
-        this.dispatchEventToListeners(Events.ExecutionContextOrderChanged, this);
-    }
-    executionContextsCleared() {
-        this.debuggerModel().globalObjectCleared();
-        const contexts = this.executionContexts();
-        this.#executionContextById.clear();
-        for (let i = 0; i < contexts.length; ++i) {
-            this.dispatchEventToListeners(Events.ExecutionContextDestroyed, contexts[i]);
-        }
-    }
-    createRemoteObject(payload) {
-        console.assert(typeof payload === 'object', 'Remote object payload should only be an object');
-        return new RemoteObjectImpl(this, payload.objectId, payload.type, payload.subtype, payload.value, payload.unserializableValue, payload.description, payload.preview, payload.customPreview, payload.className);
-    }
-    createScopeRemoteObject(payload, scopeRef) {
-        return new ScopeRemoteObject(this, payload.objectId, scopeRef, payload.type, payload.subtype, payload.value, payload.unserializableValue, payload.description, payload.preview);
-    }
-    createRemoteObjectFromPrimitiveValue(value) {
-        const type = typeof value;
-        let unserializableValue = undefined;
-        const unserializableDescription = RemoteObject.unserializableDescription(value);
-        if (unserializableDescription !== null) {
-            unserializableValue = (unserializableDescription);
-        }
-        if (typeof unserializableValue !== 'undefined') {
-            value = undefined;
-        }
-        return new RemoteObjectImpl(this, undefined, type, undefined, value, unserializableValue);
-    }
-    createRemotePropertyFromPrimitiveValue(name, value) {
-        return new RemoteObjectProperty(name, this.createRemoteObjectFromPrimitiveValue(value));
-    }
-    discardConsoleEntries() {
-        void this.agent.invoke_discardConsoleEntries();
-    }
-    releaseObjectGroup(objectGroup) {
-        void this.agent.invoke_releaseObjectGroup({ objectGroup });
-    }
-    releaseEvaluationResult(result) {
-        if ('object' in result && result.object) {
-            result.object.release();
-        }
-        if ('exceptionDetails' in result && result.exceptionDetails?.exception) {
-            const exception = result.exceptionDetails.exception;
-            const exceptionObject = this.createRemoteObject({ type: exception.type, objectId: exception.objectId });
-            exceptionObject.release();
-        }
-    }
-    runIfWaitingForDebugger() {
-        void this.agent.invoke_runIfWaitingForDebugger();
-    }
-    customFormattersStateChanged({ data: enabled }) {
-        void this.agent.invoke_setCustomObjectFormatterEnabled({ enabled });
-    }
-    async compileScript(expression, sourceURL, persistScript, executionContextId) {
-        const response = await this.agent.invoke_compileScript({
-            expression,
-            sourceURL,
-            persistScript,
-            executionContextId,
-        });
-        if (response.getError()) {
-            console.error(response.getError());
-            return null;
-        }
-        return { scriptId: response.scriptId, exceptionDetails: response.exceptionDetails };
-    }
-    async runScript(scriptId, executionContextId, objectGroup, silent, includeCommandLineAPI, returnByValue, generatePreview, awaitPromise) {
-        const response = await this.agent.invoke_runScript({
-            scriptId,
-            executionContextId,
-            objectGroup,
-            silent,
-            includeCommandLineAPI,
-            returnByValue,
-            generatePreview,
-            awaitPromise,
-        });
-        const error = response.getError();
-        if (error) {
-            console.error(error);
-            return { error };
-        }
-        return { object: this.createRemoteObject(response.result), exceptionDetails: response.exceptionDetails };
-    }
-    async queryObjects(prototype) {
-        if (!prototype.objectId) {
-            return { error: 'Prototype should be an Object.' };
-        }
-        const response = await this.agent.invoke_queryObjects({ prototypeObjectId: prototype.objectId, objectGroup: 'console' });
-        const error = response.getError();
-        if (error) {
-            console.error(error);
-            return { error };
-        }
-        return { objects: this.createRemoteObject(response.objects) };
-    }
-    async isolateId() {
-        const response = await this.agent.invoke_getIsolateId();
-        if (response.getError() || !response.id) {
-            return this.target().id();
-        }
-        return response.id;
-    }
-    async heapUsage() {
-        const result = await this.agent.invoke_getHeapUsage();
-        return result.getError() ? null : result;
-    }
-    inspectRequested(payload, hints, executionContextId) {
-        const object = this.createRemoteObject(payload);
-        if (hints !== null && typeof hints === 'object') {
-            if ('copyToClipboard' in hints && Boolean(hints.copyToClipboard)) {
-                this.copyRequested(object);
-                return;
-            }
-            if ('queryObjects' in hints && hints.queryObjects) {
-                void this.queryObjectsRequested(object, executionContextId);
-                return;
-            }
-        }
-        if (object.isNode()) {
-            void Common.Revealer.reveal(object).then(object.release.bind(object));
-            return;
-        }
-        if (object.type === 'function') {
-            void RemoteFunction.objectAsFunction(object).targetFunctionDetails().then(didGetDetails);
-            return;
-        }
-        function didGetDetails(response) {
-            object.release();
-            if (!response?.location) {
-                return;
-            }
-            void Common.Revealer.reveal(response.location);
-        }
-        object.release();
-    }
-    async addBinding(event) {
-        return await this.agent.invoke_addBinding(event);
-    }
-    async removeBinding(request) {
-        return await this.agent.invoke_removeBinding(request);
-    }
-    bindingCalled(event) {
-        this.dispatchEventToListeners(Events.BindingCalled, event);
-    }
-    copyRequested(object) {
-        if (!object.objectId) {
-            Host.InspectorFrontendHost.InspectorFrontendHostInstance.copyText(object.unserializableValue() || object.value);
-            return;
-        }
-        const indent = Common.Settings.Settings.instance().moduleSetting('text-editor-indent').get();
-        void object
-            .callFunctionJSON(toStringForClipboard, [{
-                value: {
-                    subtype: object.subtype,
-                    indent,
-                },
-            }])
-            .then(Host.InspectorFrontendHost.InspectorFrontendHostInstance.copyText.bind(Host.InspectorFrontendHost.InspectorFrontendHostInstance));
-        function toStringForClipboard(data) {
-            const subtype = data.subtype;
-            const indent = data.indent;
-            if (subtype === 'node') {
-                return this instanceof Element ? this.outerHTML : undefined;
-            }
-            if (subtype && typeof this === 'undefined') {
-                return String(subtype);
-            }
-            try {
-                return JSON.stringify(this, null, indent);
-            }
-            catch {
-                return String(this);
-            }
-        }
-    }
-    async queryObjectsRequested(object, executionContextId) {
-        const result = await this.queryObjects(object);
-        object.release();
-        if ('error' in result) {
-            Common.Console.Console.instance().error(result.error);
-            return;
-        }
-        this.dispatchEventToListeners(Events.QueryObjectRequested, { objects: result.objects, executionContextId });
-    }
-    static simpleTextFromException(exceptionDetails) {
-        let text = exceptionDetails.text;
-        if (exceptionDetails.exception?.description) {
-            let description = exceptionDetails.exception.description;
-            if (description.indexOf('\n') !== -1) {
-                description = description.substring(0, description.indexOf('\n'));
-            }
-            text += ' ' + description;
-        }
-        return text;
-    }
-    exceptionThrown(timestamp, exceptionDetails) {
-        const exceptionWithTimestamp = { timestamp, details: exceptionDetails };
-        this.dispatchEventToListeners(Events.ExceptionThrown, exceptionWithTimestamp);
-    }
-    exceptionRevoked(exceptionId) {
-        this.dispatchEventToListeners(Events.ExceptionRevoked, exceptionId);
-    }
-    consoleAPICalled(type, args, executionContextId, timestamp, stackTrace, context) {
-        const consoleAPICall = {
-            type,
-            args,
-            executionContextId,
-            timestamp,
-            stackTrace,
-            context,
-        };
-        this.dispatchEventToListeners(Events.ConsoleAPICalled, consoleAPICall);
-    }
-    executionContextIdForScriptId(scriptId) {
-        const script = this.debuggerModel().scriptForId(scriptId);
-        return script ? script.executionContextId : 0;
-    }
-    executionContextForStackTrace(stackTrace) {
-        let currentStackTrace = stackTrace;
-        while (currentStackTrace && !currentStackTrace.callFrames.length) {
-            currentStackTrace = currentStackTrace.parent || null;
-        }
-        if (!currentStackTrace?.callFrames.length) {
-            return 0;
-        }
-        return this.executionContextIdForScriptId(currentStackTrace.callFrames[0].scriptId);
-    }
-    terminateExecution() {
-        return this.agent.invoke_terminateExecution();
-    }
-    async getExceptionDetails(errorObjectId) {
-        const response = await this.agent.invoke_getExceptionDetails({ errorObjectId });
-        if (response.getError()) {
-            // This CDP method errors if called with non-Error object ids. Swallow that.
-            return undefined;
-        }
-        return response.exceptionDetails;
-    }
-}
-export var Events;
-(function (Events) {
-    /* eslint-disable @typescript-eslint/naming-convention -- Used by web_tests. */
-    Events["BindingCalled"] = "BindingCalled";
-    Events["ExecutionContextCreated"] = "ExecutionContextCreated";
-    Events["ExecutionContextDestroyed"] = "ExecutionContextDestroyed";
-    Events["ExecutionContextChanged"] = "ExecutionContextChanged";
-    Events["ExecutionContextOrderChanged"] = "ExecutionContextOrderChanged";
-    Events["ExceptionThrown"] = "ExceptionThrown";
-    Events["ExceptionRevoked"] = "ExceptionRevoked";
-    Events["ConsoleAPICalled"] = "ConsoleAPICalled";
-    Events["QueryObjectRequested"] = "QueryObjectRequested";
-    /* eslint-enable @typescript-eslint/naming-convention */
-})(Events || (Events = {}));
-class RuntimeDispatcher {
-    #runtimeModel;
-    constructor(runtimeModel) {
-        this.#runtimeModel = runtimeModel;
-    }
-    executionContextCreated({ context }) {
-        this.#runtimeModel.executionContextCreated(context);
-    }
-    executionContextDestroyed({ executionContextId }) {
-        this.#runtimeModel.executionContextDestroyed(executionContextId);
-    }
-    executionContextsCleared() {
-        this.#runtimeModel.executionContextsCleared();
-    }
-    exceptionThrown({ timestamp, exceptionDetails }) {
-        this.#runtimeModel.exceptionThrown(timestamp, exceptionDetails);
-    }
-    exceptionRevoked({ exceptionId }) {
-        this.#runtimeModel.exceptionRevoked(exceptionId);
-    }
-    consoleAPICalled({ type, args, executionContextId, timestamp, stackTrace, context }) {
-        this.#runtimeModel.consoleAPICalled(type, args, executionContextId, timestamp, stackTrace, context);
-    }
-    inspectRequested({ object, hints, executionContextId }) {
-        this.#runtimeModel.inspectRequested(object, hints, executionContextId);
-    }
-    bindingCalled(event) {
-        this.#runtimeModel.bindingCalled(event);
-    }
-}
-export class ExecutionContext {
-    id;
-    uniqueId;
-    name;
-    #label;
-    origin;
-    isDefault;
-    runtimeModel;
-    debuggerModel;
-    frameId;
-    constructor(runtimeModel, id, uniqueId, name, origin, isDefault, frameId) {
-        this.id = id;
-        this.uniqueId = uniqueId;
-        this.name = name;
-        this.#label = null;
-        this.origin = origin;
-        this.isDefault = isDefault;
-        this.runtimeModel = runtimeModel;
-        this.debuggerModel = runtimeModel.debuggerModel();
-        this.frameId = frameId;
-        this.#setLabel('');
-    }
-    target() {
-        return this.runtimeModel.target();
-    }
-    static comparator(a, b) {
-        function targetWeight(target) {
-            if (target.parentTarget()?.type() !== Type.FRAME) {
-                return 5;
-            }
-            if (target.type() === Type.FRAME) {
-                return 4;
-            }
-            if (target.type() === Type.ServiceWorker) {
-                return 3;
-            }
-            if (target.type() === Type.Worker || target.type() === Type.SHARED_WORKER) {
-                return 2;
-            }
-            return 1;
-        }
-        function targetPath(target) {
-            let currentTarget = target;
-            const parents = [];
-            while (currentTarget) {
-                parents.push(currentTarget);
-                currentTarget = currentTarget.parentTarget();
-            }
-            return parents.reverse();
-        }
-        const tagetsA = targetPath(a.target());
-        const targetsB = targetPath(b.target());
-        let targetA;
-        let targetB;
-        for (let i = 0;; i++) {
-            if (!tagetsA[i] || !targetsB[i] || (tagetsA[i] !== targetsB[i])) {
-                targetA = tagetsA[i];
-                targetB = targetsB[i];
-                break;
-            }
-        }
-        if (!targetA && targetB) {
-            return -1;
-        }
-        if (!targetB && targetA) {
-            return 1;
-        }
-        if (targetA && targetB) {
-            const weightDiff = targetWeight(targetA) - targetWeight(targetB);
-            if (weightDiff) {
-                return -weightDiff;
-            }
-            return targetA.id().localeCompare(targetB.id());
-        }
-        // Main world context should always go first.
-        if (a.isDefault) {
-            return -1;
-        }
-        if (b.isDefault) {
-            return +1;
-        }
-        return a.name.localeCompare(b.name);
-    }
-    async evaluate(options, userGesture, awaitPromise) {
-        // FIXME: It will be moved to separate ExecutionContext.
-        if (this.debuggerModel.selectedCallFrame()) {
-            return await this.debuggerModel.evaluateOnSelectedCallFrame(options);
-        }
-        return await this.evaluateGlobal(options, userGesture, awaitPromise);
-    }
-    globalObject(objectGroup, generatePreview) {
-        const evaluationOptions = {
-            expression: 'this',
-            objectGroup,
-            includeCommandLineAPI: false,
-            silent: true,
-            returnByValue: false,
-            generatePreview,
-        };
-        return this.evaluateGlobal(evaluationOptions, false, false);
-    }
-    async callFunctionOn(options) {
-        const response = await this.runtimeModel.agent.invoke_callFunctionOn({
-            functionDeclaration: options.functionDeclaration,
-            returnByValue: options.returnByValue,
-            userGesture: options.userGesture,
-            awaitPromise: options.awaitPromise,
-            throwOnSideEffect: options.throwOnSideEffect,
-            arguments: options.arguments,
-            // Old back-ends don't know about uniqueContextId (and also don't generate
-            // one), so fall back to contextId in that case (https://crbug.com/1192621).
-            ...(this.uniqueId ? { uniqueContextId: this.uniqueId } : { contextId: this.id }),
-        });
-        const error = response.getError();
-        if (error) {
-            return { error };
-        }
-        return { object: this.runtimeModel.createRemoteObject(response.result), exceptionDetails: response.exceptionDetails };
-    }
-    async evaluateGlobal(options, userGesture, awaitPromise) {
-        if (!options.expression) {
-            // There is no expression, so the completion should happen against global properties.
-            options.expression = 'this';
-        }
-        const response = await this.runtimeModel.agent.invoke_evaluate({
-            expression: options.expression,
-            objectGroup: options.objectGroup,
-            includeCommandLineAPI: options.includeCommandLineAPI,
-            silent: options.silent,
-            returnByValue: options.returnByValue,
-            generatePreview: options.generatePreview,
-            userGesture,
-            awaitPromise,
-            throwOnSideEffect: options.throwOnSideEffect,
-            timeout: options.timeout,
-            disableBreaks: options.disableBreaks,
-            replMode: options.replMode,
-            allowUnsafeEvalBlockedByCSP: options.allowUnsafeEvalBlockedByCSP,
-            // Old back-ends don't know about uniqueContextId (and also don't generate
-            // one), so fall back to contextId in that case (https://crbug.com/1192621).
-            ...(this.uniqueId ? { uniqueContextId: this.uniqueId } : { contextId: this.id }),
-        });
-        const error = response.getError();
-        if (error) {
-            console.error(error);
-            return { error };
-        }
-        return { object: this.runtimeModel.createRemoteObject(response.result), exceptionDetails: response.exceptionDetails };
-    }
-    async globalLexicalScopeNames() {
-        const response = await this.runtimeModel.agent.invoke_globalLexicalScopeNames({ executionContextId: this.id });
-        return response.getError() ? [] : response.names;
-    }
-    label() {
-        return this.#label;
-    }
-    setLabel(label) {
-        this.#setLabel(label);
-        this.runtimeModel.dispatchEventToListeners(Events.ExecutionContextChanged, this);
-    }
-    #setLabel(label) {
-        if (label) {
-            this.#label = label;
-            return;
-        }
-        if (this.name) {
-            this.#label = this.name;
-            return;
-        }
-        const parsedUrl = Common.ParsedURL.ParsedURL.fromString(this.origin);
-        this.#label = parsedUrl ? parsedUrl.lastPathComponentWithFragment() : '';
-    }
-}
-SDKModel.register(RuntimeModel, { capabilities: 4 /* Capability.JS */, autostart: true });

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

@@ -1,45 +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.
-import * as Common from '../common/common.js';
-const registeredModels = new Map();
-// TODO(crbug.com/1228674) Remove defaults for generic type parameters once
-//                         all event emitters and sinks have been migrated.
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export class SDKModel extends Common.ObjectWrapper.ObjectWrapper {
-    #target;
-    constructor(target) {
-        super();
-        this.#target = target;
-    }
-    target() {
-        return this.#target;
-    }
-    /**
-     * Override this method to perform tasks that are required to suspend the
-     * model and that still need other models in an unsuspended state.
-     */
-    async preSuspendModel(_reason) {
-    }
-    async suspendModel(_reason) {
-    }
-    async resumeModel() {
-    }
-    /**
-     * Override this method to perform tasks that are required to after resuming
-     * the model and that require all models already in an unsuspended state.
-     */
-    async postResumeModel() {
-    }
-    dispose() {
-    }
-    static register(modelClass, registrationInfo) {
-        if (registrationInfo.early && !registrationInfo.autostart) {
-            throw new Error(`Error registering model ${modelClass.name}: early models must be autostarted.`);
-        }
-        registeredModels.set(modelClass, registrationInfo);
-    }
-    static get registeredModels() {
-        return registeredModels;
-    }
-}

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

@@ -1,36 +0,0 @@
-// 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 * as Formatter from '../../models/formatter/formatter.js';
-import * as TextUtils from '../../models/text_utils/text_utils.js';
-/** If a script failed to parse, we stash null in order to prevent unnecessary re-parsing */
-const scopeTrees = new WeakMap();
-/**
- * Computes and caches the scope tree for `script`.
- *
- * We use {@link Script} as a key to uniquely identify scripts.
- * {@link Script} boils down to "target" + "script ID". This
- * duplicates work in case of identical script running on multiple targets
- * (e.g. workers).
- *
- * We also return a {@link TextUtils.Text.Text} instance. The scope tree uses offsets
- * and the text allows conversion from/to line/column numbers.
- */
-export function scopeTreeForScript(script) {
-    let promise = scopeTrees.get(script);
-    if (promise === undefined) {
-        promise = script.requestContentData().then(content => {
-            if (TextUtils.ContentData.ContentData.isError(content)) {
-                return null;
-            }
-            const sourceType = script.isModule ? 'module' : 'script';
-            return Formatter.FormatterWorkerPool.formatterWorkerPool()
-                .javaScriptScopeTree(content.text, sourceType)
-                .then(scopeTree => scopeTree ? ({ scopeTree, text: content.textObj }) : null)
-                .catch(() => null);
-        });
-        scopeTrees.set(script, promise);
-    }
-    // We intentionally return `null` here if the script already failed to parse once.
-    return promise;
-}