chrome-devtools-mcp 0.17.2 → 0.18.0

package/build/src/McpContext.js

@@ -0,0 +1,703 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { extractUrlLikeFromDevToolsTitle, UniverseManager, urlsEqual, } from './DevtoolsUtils.js';
+import { NetworkCollector, ConsoleCollector } from './PageCollector.js';
+import { Locator } from './third_party/index.js';
+import { PredefinedNetworkConditions } from './third_party/index.js';
+import { listPages } from './tools/pages.js';
+import { takeSnapshot } from './tools/snapshot.js';
+import { CLOSE_PAGE_ERROR } from './tools/ToolDefinition.js';
+import { ExtensionRegistry, } from './utils/ExtensionRegistry.js';
+import { WaitForHelper } from './WaitForHelper.js';
+const DEFAULT_TIMEOUT = 5_000;
+const NAVIGATION_TIMEOUT = 10_000;
+function getNetworkMultiplierFromString(condition) {
+    const puppeteerCondition = condition;
+    switch (puppeteerCondition) {
+        case 'Fast 4G':
+            return 1;
+        case 'Slow 4G':
+            return 2.5;
+        case 'Fast 3G':
+            return 5;
+        case 'Slow 3G':
+            return 10;
+    }
+    return 1;
+}
+function getExtensionFromMimeType(mimeType) {
+    switch (mimeType) {
+        case 'image/png':
+            return 'png';
+        case 'image/jpeg':
+            return 'jpeg';
+        case 'image/webp':
+            return 'webp';
+    }
+    throw new Error(`No mapping for Mime type ${mimeType}.`);
+}
+export class McpContext {
+    browser;
+    logger;
+    // Maps LLM-provided isolatedContext name → Puppeteer BrowserContext.
+    #isolatedContexts = new Map();
+    // Reverse lookup: Page → isolatedContext name (for snapshot labeling).
+    // WeakMap so closed pages are garbage-collected automatically.
+    #pageToIsolatedContextName = new WeakMap();
+    // Auto-generated name counter for when no name is provided.
+    #nextIsolatedContextId = 1;
+    #pages = [];
+    #pageToDevToolsPage = new Map();
+    #selectedPage;
+    #textSnapshot = null;
+    #networkCollector;
+    #consoleCollector;
+    #devtoolsUniverseManager;
+    #extensionRegistry = new ExtensionRegistry();
+    #isRunningTrace = false;
+    #screenRecorderData = null;
+    #emulationSettingsMap = new WeakMap();
+    #dialog;
+    #pageIdMap = new WeakMap();
+    #nextPageId = 1;
+    #nextSnapshotId = 1;
+    #traceResults = [];
+    #locatorClass;
+    #options;
+    #uniqueBackendNodeIdToMcpId = new Map();
+    constructor(browser, logger, options, locatorClass) {
+        this.browser = browser;
+        this.logger = logger;
+        this.#locatorClass = locatorClass;
+        this.#options = options;
+        this.#networkCollector = new NetworkCollector(this.browser);
+        this.#consoleCollector = new ConsoleCollector(this.browser, collect => {
+            return {
+                console: event => {
+                    collect(event);
+                },
+                uncaughtError: event => {
+                    collect(event);
+                },
+                issue: event => {
+                    collect(event);
+                },
+            };
+        });
+        this.#devtoolsUniverseManager = new UniverseManager(this.browser);
+    }
+    async #init() {
+        const pages = await this.createPagesSnapshot();
+        await this.#networkCollector.init(pages);
+        await this.#consoleCollector.init(pages);
+        await this.#devtoolsUniverseManager.init(pages);
+    }
+    dispose() {
+        this.#networkCollector.dispose();
+        this.#consoleCollector.dispose();
+        this.#devtoolsUniverseManager.dispose();
+        // Isolated contexts are intentionally not closed here.
+        // Either the entire browser will be closed or we disconnect
+        // without destroying browser state.
+        this.#isolatedContexts.clear();
+    }
+    static async from(browser, logger, opts, 
+    /* Let tests use unbundled Locator class to avoid overly strict checks within puppeteer that fail when mixing bundled and unbundled class instances */
+    locatorClass = Locator) {
+        const context = new McpContext(browser, logger, opts, locatorClass);
+        await context.#init();
+        return context;
+    }
+    resolveCdpRequestId(cdpRequestId) {
+        const selectedPage = this.getSelectedPage();
+        if (!cdpRequestId) {
+            this.logger('no network request');
+            return;
+        }
+        const request = this.#networkCollector.find(selectedPage, request => {
+            // @ts-expect-error id is internal.
+            return request.id === cdpRequestId;
+        });
+        if (!request) {
+            this.logger('no network request for ' + cdpRequestId);
+            return;
+        }
+        return this.#networkCollector.getIdForResource(request);
+    }
+    resolveCdpElementId(cdpBackendNodeId) {
+        if (!cdpBackendNodeId) {
+            this.logger('no cdpBackendNodeId');
+            return;
+        }
+        if (this.#textSnapshot === null) {
+            this.logger('no text snapshot');
+            return;
+        }
+        // TODO: index by backendNodeId instead.
+        const queue = [this.#textSnapshot.root];
+        while (queue.length) {
+            const current = queue.pop();
+            if (current.backendNodeId === cdpBackendNodeId) {
+                return current.id;
+            }
+            for (const child of current.children) {
+                queue.push(child);
+            }
+        }
+        return;
+    }
+    getNetworkRequests(includePreservedRequests) {
+        const page = this.getSelectedPage();
+        return this.#networkCollector.getData(page, includePreservedRequests);
+    }
+    getConsoleData(includePreservedMessages) {
+        const page = this.getSelectedPage();
+        return this.#consoleCollector.getData(page, includePreservedMessages);
+    }
+    getDevToolsUniverse() {
+        return this.#devtoolsUniverseManager.get(this.getSelectedPage());
+    }
+    getConsoleMessageStableId(message) {
+        return this.#consoleCollector.getIdForResource(message);
+    }
+    getConsoleMessageById(id) {
+        return this.#consoleCollector.getById(this.getSelectedPage(), id);
+    }
+    async newPage(background, isolatedContextName) {
+        let page;
+        if (isolatedContextName !== undefined) {
+            let ctx = this.#isolatedContexts.get(isolatedContextName);
+            if (!ctx) {
+                ctx = await this.browser.createBrowserContext();
+                this.#isolatedContexts.set(isolatedContextName, ctx);
+            }
+            page = await ctx.newPage();
+            this.#pageToIsolatedContextName.set(page, isolatedContextName);
+        }
+        else {
+            page = await this.browser.newPage({ background });
+        }
+        await this.createPagesSnapshot();
+        this.selectPage(page);
+        this.#networkCollector.addPage(page);
+        this.#consoleCollector.addPage(page);
+        return page;
+    }
+    async closePage(pageId) {
+        if (this.#pages.length === 1) {
+            throw new Error(CLOSE_PAGE_ERROR);
+        }
+        const page = this.getPageById(pageId);
+        await page.close({ runBeforeUnload: false });
+        this.#pageToIsolatedContextName.delete(page);
+    }
+    getNetworkRequestById(reqid) {
+        return this.#networkCollector.getById(this.getSelectedPage(), reqid);
+    }
+    async emulate(options) {
+        const page = this.getSelectedPage();
+        const currentSettings = this.#emulationSettingsMap.get(page) ?? {};
+        const newSettings = { ...currentSettings };
+        let timeoutsNeedUpdate = false;
+        if (options.networkConditions !== undefined) {
+            timeoutsNeedUpdate = true;
+            if (options.networkConditions === null ||
+                options.networkConditions === 'No emulation') {
+                await page.emulateNetworkConditions(null);
+                delete newSettings.networkConditions;
+            }
+            else if (options.networkConditions === 'Offline') {
+                await page.emulateNetworkConditions({
+                    offline: true,
+                    download: 0,
+                    upload: 0,
+                    latency: 0,
+                });
+                newSettings.networkConditions = 'Offline';
+            }
+            else if (options.networkConditions in PredefinedNetworkConditions) {
+                const networkCondition = PredefinedNetworkConditions[options.networkConditions];
+                await page.emulateNetworkConditions(networkCondition);
+                newSettings.networkConditions = options.networkConditions;
+            }
+        }
+        if (options.cpuThrottlingRate !== undefined) {
+            timeoutsNeedUpdate = true;
+            if (options.cpuThrottlingRate === null) {
+                await page.emulateCPUThrottling(1);
+                delete newSettings.cpuThrottlingRate;
+            }
+            else {
+                await page.emulateCPUThrottling(options.cpuThrottlingRate);
+                newSettings.cpuThrottlingRate = options.cpuThrottlingRate;
+            }
+        }
+        if (options.geolocation !== undefined) {
+            if (options.geolocation === null) {
+                await page.setGeolocation({ latitude: 0, longitude: 0 });
+                delete newSettings.geolocation;
+            }
+            else {
+                await page.setGeolocation(options.geolocation);
+                newSettings.geolocation = options.geolocation;
+            }
+        }
+        if (options.userAgent !== undefined) {
+            if (options.userAgent === null) {
+                await page.setUserAgent({ userAgent: undefined });
+                delete newSettings.userAgent;
+            }
+            else {
+                await page.setUserAgent({ userAgent: options.userAgent });
+                newSettings.userAgent = options.userAgent;
+            }
+        }
+        if (options.colorScheme !== undefined) {
+            if (options.colorScheme === null || options.colorScheme === 'auto') {
+                await page.emulateMediaFeatures([
+                    { name: 'prefers-color-scheme', value: '' },
+                ]);
+                delete newSettings.colorScheme;
+            }
+            else {
+                await page.emulateMediaFeatures([
+                    { name: 'prefers-color-scheme', value: options.colorScheme },
+                ]);
+                newSettings.colorScheme = options.colorScheme;
+            }
+        }
+        if (options.viewport !== undefined) {
+            if (options.viewport === null) {
+                await page.setViewport(null);
+                delete newSettings.viewport;
+            }
+            else {
+                const defaults = {
+                    deviceScaleFactor: 1,
+                    isMobile: false,
+                    hasTouch: false,
+                    isLandscape: false,
+                };
+                const viewport = { ...defaults, ...options.viewport };
+                await page.setViewport(viewport);
+                newSettings.viewport = viewport;
+            }
+        }
+        if (Object.keys(newSettings).length) {
+            this.#emulationSettingsMap.set(page, newSettings);
+        }
+        else {
+            this.#emulationSettingsMap.delete(page);
+        }
+        if (timeoutsNeedUpdate) {
+            this.#updateSelectedPageTimeouts();
+        }
+    }
+    getNetworkConditions() {
+        const page = this.getSelectedPage();
+        return this.#emulationSettingsMap.get(page)?.networkConditions ?? null;
+    }
+    getCpuThrottlingRate() {
+        const page = this.getSelectedPage();
+        return this.#emulationSettingsMap.get(page)?.cpuThrottlingRate ?? 1;
+    }
+    getGeolocation() {
+        const page = this.getSelectedPage();
+        return this.#emulationSettingsMap.get(page)?.geolocation ?? null;
+    }
+    getViewport() {
+        const page = this.getSelectedPage();
+        return this.#emulationSettingsMap.get(page)?.viewport ?? null;
+    }
+    getUserAgent() {
+        const page = this.getSelectedPage();
+        return this.#emulationSettingsMap.get(page)?.userAgent ?? null;
+    }
+    getColorScheme() {
+        const page = this.getSelectedPage();
+        return this.#emulationSettingsMap.get(page)?.colorScheme ?? null;
+    }
+    setIsRunningPerformanceTrace(x) {
+        this.#isRunningTrace = x;
+    }
+    isRunningPerformanceTrace() {
+        return this.#isRunningTrace;
+    }
+    getScreenRecorder() {
+        return this.#screenRecorderData;
+    }
+    setScreenRecorder(data) {
+        this.#screenRecorderData = data;
+    }
+    isCruxEnabled() {
+        return this.#options.performanceCrux;
+    }
+    getDialog() {
+        return this.#dialog;
+    }
+    clearDialog() {
+        this.#dialog = undefined;
+    }
+    getSelectedPage() {
+        const page = this.#selectedPage;
+        if (!page) {
+            throw new Error('No page selected');
+        }
+        if (page.isClosed()) {
+            throw new Error(`The selected page has been closed. Call ${listPages.name} to see open pages.`);
+        }
+        return page;
+    }
+    getPageById(pageId) {
+        const page = this.#pages.find(p => this.#pageIdMap.get(p) === pageId);
+        if (!page) {
+            throw new Error('No page found');
+        }
+        return page;
+    }
+    getPageId(page) {
+        return this.#pageIdMap.get(page);
+    }
+    #dialogHandler = (dialog) => {
+        this.#dialog = dialog;
+    };
+    isPageSelected(page) {
+        return this.#selectedPage === page;
+    }
+    selectPage(newPage) {
+        const oldPage = this.#selectedPage;
+        if (oldPage) {
+            oldPage.off('dialog', this.#dialogHandler);
+            void oldPage.emulateFocusedPage(false).catch(error => {
+                this.logger('Error turning off focused page emulation', error);
+            });
+        }
+        this.#selectedPage = newPage;
+        newPage.on('dialog', this.#dialogHandler);
+        this.#updateSelectedPageTimeouts();
+        void newPage.emulateFocusedPage(true).catch(error => {
+            this.logger('Error turning on focused page emulation', error);
+        });
+    }
+    #updateSelectedPageTimeouts() {
+        const page = this.getSelectedPage();
+        // For waiters 5sec timeout should be sufficient.
+        // Increased in case we throttle the CPU
+        const cpuMultiplier = this.getCpuThrottlingRate();
+        page.setDefaultTimeout(DEFAULT_TIMEOUT * cpuMultiplier);
+        // 10sec should be enough for the load event to be emitted during
+        // navigations.
+        // Increased in case we throttle the network requests
+        const networkMultiplier = getNetworkMultiplierFromString(this.getNetworkConditions());
+        page.setDefaultNavigationTimeout(NAVIGATION_TIMEOUT * networkMultiplier);
+    }
+    getNavigationTimeout() {
+        const page = this.getSelectedPage();
+        return page.getDefaultNavigationTimeout();
+    }
+    getAXNodeByUid(uid) {
+        return this.#textSnapshot?.idToNode.get(uid);
+    }
+    async getElementByUid(uid) {
+        if (!this.#textSnapshot?.idToNode.size) {
+            throw new Error(`No snapshot found. Use ${takeSnapshot.name} to capture one.`);
+        }
+        const node = this.#textSnapshot?.idToNode.get(uid);
+        if (!node) {
+            throw new Error('No such element found in the snapshot.');
+        }
+        const message = `Element with uid ${uid} no longer exists on the page.`;
+        try {
+            const handle = await node.elementHandle();
+            if (!handle) {
+                throw new Error(message);
+            }
+            return handle;
+        }
+        catch (error) {
+            throw new Error(message, {
+                cause: error,
+            });
+        }
+    }
+    async createPagesSnapshot() {
+        const allPages = await this.#getAllPages();
+        for (const page of allPages) {
+            if (!this.#pageIdMap.has(page)) {
+                this.#pageIdMap.set(page, this.#nextPageId++);
+            }
+        }
+        this.#pages = allPages.filter(page => {
+            return (this.#options.experimentalDevToolsDebugging ||
+                !page.url().startsWith('devtools://'));
+        });
+        if ((!this.#selectedPage || this.#pages.indexOf(this.#selectedPage) === -1) &&
+            this.#pages[0]) {
+            this.selectPage(this.#pages[0]);
+        }
+        await this.detectOpenDevToolsWindows();
+        return this.#pages;
+    }
+    async #getAllPages() {
+        const defaultCtx = this.browser.defaultBrowserContext();
+        const allPages = await this.browser.pages(this.#options.experimentalIncludeAllPages);
+        // Build a reverse lookup from BrowserContext instance → name.
+        const contextToName = new Map();
+        for (const [name, ctx] of this.#isolatedContexts) {
+            contextToName.set(ctx, name);
+        }
+        // Auto-discover BrowserContexts not in our mapping (e.g., externally
+        // created incognito contexts) and assign generated names.
+        const knownContexts = new Set(this.#isolatedContexts.values());
+        for (const ctx of this.browser.browserContexts()) {
+            if (ctx !== defaultCtx && !ctx.closed && !knownContexts.has(ctx)) {
+                const name = `isolated-context-${this.#nextIsolatedContextId++}`;
+                this.#isolatedContexts.set(name, ctx);
+                contextToName.set(ctx, name);
+            }
+        }
+        // Use page.browserContext() to determine each page's context membership.
+        for (const page of allPages) {
+            const ctx = page.browserContext();
+            const name = contextToName.get(ctx);
+            if (name) {
+                this.#pageToIsolatedContextName.set(page, name);
+            }
+        }
+        return allPages;
+    }
+    async detectOpenDevToolsWindows() {
+        this.logger('Detecting open DevTools windows');
+        const pages = await this.#getAllPages();
+        this.#pageToDevToolsPage = new Map();
+        for (const devToolsPage of pages) {
+            if (devToolsPage.url().startsWith('devtools://')) {
+                try {
+                    this.logger('Calling getTargetInfo for ' + devToolsPage.url());
+                    const data = await devToolsPage
+                        // @ts-expect-error no types for _client().
+                        ._client()
+                        .send('Target.getTargetInfo');
+                    const devtoolsPageTitle = data.targetInfo.title;
+                    const urlLike = extractUrlLikeFromDevToolsTitle(devtoolsPageTitle);
+                    if (!urlLike) {
+                        continue;
+                    }
+                    // TODO: lookup without a loop.
+                    for (const page of this.#pages) {
+                        if (urlsEqual(page.url(), urlLike)) {
+                            this.#pageToDevToolsPage.set(page, devToolsPage);
+                        }
+                    }
+                }
+                catch (error) {
+                    this.logger('Issue occurred while trying to find DevTools', error);
+                }
+            }
+        }
+    }
+    getPages() {
+        return this.#pages;
+    }
+    getIsolatedContextName(page) {
+        return this.#pageToIsolatedContextName.get(page);
+    }
+    getDevToolsPage(page) {
+        return this.#pageToDevToolsPage.get(page);
+    }
+    async getDevToolsData() {
+        try {
+            this.logger('Getting DevTools UI data');
+            const selectedPage = this.getSelectedPage();
+            const devtoolsPage = this.getDevToolsPage(selectedPage);
+            if (!devtoolsPage) {
+                this.logger('No DevTools page detected');
+                return {};
+            }
+            const { cdpRequestId, cdpBackendNodeId } = await devtoolsPage.evaluate(async () => {
+                // @ts-expect-error no types
+                const UI = await import('/bundled/ui/legacy/legacy.js');
+                // @ts-expect-error no types
+                const SDK = await import('/bundled/core/sdk/sdk.js');
+                const request = UI.Context.Context.instance().flavor(SDK.NetworkRequest.NetworkRequest);
+                const node = UI.Context.Context.instance().flavor(SDK.DOMModel.DOMNode);
+                return {
+                    cdpRequestId: request?.requestId(),
+                    cdpBackendNodeId: node?.backendNodeId(),
+                };
+            });
+            return { cdpBackendNodeId, cdpRequestId };
+        }
+        catch (err) {
+            this.logger('error getting devtools data', err);
+        }
+        return {};
+    }
+    /**
+     * Creates a text snapshot of a page.
+     */
+    async createTextSnapshot(verbose = false, devtoolsData = undefined) {
+        const page = this.getSelectedPage();
+        const rootNode = await page.accessibility.snapshot({
+            includeIframes: true,
+            interestingOnly: !verbose,
+        });
+        if (!rootNode) {
+            return;
+        }
+        const snapshotId = this.#nextSnapshotId++;
+        // Iterate through the whole accessibility node tree and assign node ids that
+        // will be used for the tree serialization and mapping ids back to nodes.
+        let idCounter = 0;
+        const idToNode = new Map();
+        const seenUniqueIds = new Set();
+        const assignIds = (node) => {
+            let id = '';
+            // @ts-expect-error untyped loaderId & backendNodeId.
+            const uniqueBackendId = `${node.loaderId}_${node.backendNodeId}`;
+            if (this.#uniqueBackendNodeIdToMcpId.has(uniqueBackendId)) {
+                // Re-use MCP exposed ID if the uniqueId is the same.
+                id = this.#uniqueBackendNodeIdToMcpId.get(uniqueBackendId);
+            }
+            else {
+                // Only generate a new ID if we have not seen the node before.
+                id = `${snapshotId}_${idCounter++}`;
+                this.#uniqueBackendNodeIdToMcpId.set(uniqueBackendId, id);
+            }
+            seenUniqueIds.add(uniqueBackendId);
+            const nodeWithId = {
+                ...node,
+                id,
+                children: node.children
+                    ? node.children.map(child => assignIds(child))
+                    : [],
+            };
+            // The AXNode for an option doesn't contain its `value`.
+            // Therefore, set text content of the option as value.
+            if (node.role === 'option') {
+                const optionText = node.name;
+                if (optionText) {
+                    nodeWithId.value = optionText.toString();
+                }
+            }
+            idToNode.set(nodeWithId.id, nodeWithId);
+            return nodeWithId;
+        };
+        const rootNodeWithId = assignIds(rootNode);
+        this.#textSnapshot = {
+            root: rootNodeWithId,
+            snapshotId: String(snapshotId),
+            idToNode,
+            hasSelectedElement: false,
+            verbose,
+        };
+        const data = devtoolsData ?? (await this.getDevToolsData());
+        if (data?.cdpBackendNodeId) {
+            this.#textSnapshot.hasSelectedElement = true;
+            this.#textSnapshot.selectedElementUid = this.resolveCdpElementId(data?.cdpBackendNodeId);
+        }
+        // Clean up unique IDs that we did not see anymore.
+        for (const key of this.#uniqueBackendNodeIdToMcpId.keys()) {
+            if (!seenUniqueIds.has(key)) {
+                this.#uniqueBackendNodeIdToMcpId.delete(key);
+            }
+        }
+    }
+    getTextSnapshot() {
+        return this.#textSnapshot;
+    }
+    async saveTemporaryFile(data, mimeType) {
+        try {
+            const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'chrome-devtools-mcp-'));
+            const filename = path.join(dir, `screenshot.${getExtensionFromMimeType(mimeType)}`);
+            await fs.writeFile(filename, data);
+            return { filename };
+        }
+        catch (err) {
+            this.logger(err);
+            throw new Error('Could not save a screenshot to a file', { cause: err });
+        }
+    }
+    async saveFile(data, filename) {
+        try {
+            const filePath = path.resolve(filename);
+            await fs.writeFile(filePath, data);
+            return { filename };
+        }
+        catch (err) {
+            this.logger(err);
+            throw new Error('Could not save a screenshot to a file', { cause: err });
+        }
+    }
+    storeTraceRecording(result) {
+        // Clear the trace results because we only consume the latest trace currently.
+        this.#traceResults = [];
+        this.#traceResults.push(result);
+    }
+    recordedTraces() {
+        return this.#traceResults;
+    }
+    getWaitForHelper(page, cpuMultiplier, networkMultiplier) {
+        return new WaitForHelper(page, cpuMultiplier, networkMultiplier);
+    }
+    waitForEventsAfterAction(action, options) {
+        const page = this.getSelectedPage();
+        const cpuMultiplier = this.getCpuThrottlingRate();
+        const networkMultiplier = getNetworkMultiplierFromString(this.getNetworkConditions());
+        const waitForHelper = this.getWaitForHelper(page, cpuMultiplier, networkMultiplier);
+        return waitForHelper.waitForEventsAfterAction(action, options);
+    }
+    getNetworkRequestStableId(request) {
+        return this.#networkCollector.getIdForResource(request);
+    }
+    waitForTextOnPage(text, timeout) {
+        const page = this.getSelectedPage();
+        const frames = page.frames();
+        let locator = this.#locatorClass.race(frames.flatMap(frame => text.flatMap(value => [
+            frame.locator(`aria/${value}`),
+            frame.locator(`text/${value}`),
+        ])));
+        if (timeout) {
+            locator = locator.setTimeout(timeout);
+        }
+        return locator.wait();
+    }
+    /**
+     * We need to ignore favicon request as they make our test flaky
+     */
+    async setUpNetworkCollectorForTesting() {
+        this.#networkCollector = new NetworkCollector(this.browser, collect => {
+            return {
+                request: req => {
+                    if (req.url().includes('favicon.ico')) {
+                        return;
+                    }
+                    collect(req);
+                },
+            };
+        });
+        const pages = await this.#getAllPages();
+        await this.#networkCollector.init(pages);
+    }
+    async installExtension(extensionPath) {
+        const id = await this.browser.installExtension(extensionPath);
+        await this.#extensionRegistry.registerExtension(id, extensionPath);
+        return id;
+    }
+    async uninstallExtension(id) {
+        await this.browser.uninstallExtension(id);
+        this.#extensionRegistry.remove(id);
+    }
+    listExtensions() {
+        return this.#extensionRegistry.list();
+    }
+    getExtension(id) {
+        return this.#extensionRegistry.getById(id);
+    }
+}