@playwright/mcp 0.0.32 → 0.0.33

package/README.md

@@ -61,7 +61,7 @@ Follow the MCP install [guide](https://modelcontextprotocol.io/quickstart/user),
 
 #### Click the button to install:
 
-[![Install MCP Server](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/install-mcp?name=playwright&config=eyJjb21tYW5kIjoibnB4IEBwbGF5d3JpZ2h0L21jcEBsYXRlc3QifQ%3D%3D)
+[![Install MCP Server](https://cursor.com/deeplink/mcp-install-dark.svg)](cursor://anysphere.cursor-deeplink/mcp/install?name=Playwright&config=eyJjb21tYW5kIjoibnB4IEBwbGF5d3JpZ2h0L21jcEBsYXRlc3QifQ%3D%3D)
 
 #### Or install manually:
 
@@ -544,7 +544,7 @@ http.createServer(async (req, res) => {
   - Title: Take a screenshot
   - Description: Take a screenshot of the current page. You can't perform actions based on the screenshot, use browser_snapshot for actions.
   - Parameters:
-    - `raw` (boolean, optional): Whether to return without compression (in PNG format). Default is false, which returns a JPEG image.
+    - `type` (string, optional): Image format for the screenshot. Default is png.
     - `filename` (string, optional): File name to save the screenshot to. Defaults to `page-{timestamp}.{png|jpeg}` if not specified.
     - `element` (string, optional): Human-readable element description used to obtain permission to screenshot the element. If not provided, the screenshot will be taken of viewport. If element is provided, ref must be provided too.
     - `ref` (string, optional): Exact target element reference from the page snapshot. If not provided, the screenshot will be taken of viewport. If ref is provided, element must be provided too.

package/lib/browserContextFactory.js

@@ -13,28 +13,34 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import fs from 'node:fs';
-import net from 'node:net';
-import path from 'node:path';
-import os from 'node:os';
+import fs from 'fs';
+import net from 'net';
+import path from 'path';
 import * as playwright from 'playwright';
+// @ts-ignore
+import { registryDirectory } from 'playwright-core/lib/server/registry/index';
 import { logUnhandledError, testDebug } from './log.js';
-export function contextFactory(browserConfig) {
-    if (browserConfig.remoteEndpoint)
-        return new RemoteContextFactory(browserConfig);
-    if (browserConfig.cdpEndpoint)
-        return new CdpContextFactory(browserConfig);
-    if (browserConfig.isolated)
-        return new IsolatedContextFactory(browserConfig);
-    return new PersistentContextFactory(browserConfig);
+import { createHash } from './utils.js';
+import { outputFile } from './config.js';
+export function contextFactory(config) {
+    if (config.browser.remoteEndpoint)
+        return new RemoteContextFactory(config);
+    if (config.browser.cdpEndpoint)
+        return new CdpContextFactory(config);
+    if (config.browser.isolated)
+        return new IsolatedContextFactory(config);
+    return new PersistentContextFactory(config);
 }
 class BaseContextFactory {
-    browserConfig;
-    _browserPromise;
     name;
-    constructor(name, browserConfig) {
+    description;
+    config;
+    _browserPromise;
+    _tracesDir;
+    constructor(name, description, config) {
         this.name = name;
-        this.browserConfig = browserConfig;
+        this.description = description;
+        this.config = config;
     }
     async _obtainBrowser() {
         if (this._browserPromise)
@@ -53,7 +59,9 @@ class BaseContextFactory {
     async _doObtainBrowser() {
         throw new Error('Not implemented');
     }
-    async createContext() {
+    async createContext(clientInfo) {
+        if (this.config.saveTrace)
+            this._tracesDir = await outputFile(this.config, clientInfo.rootPath, `traces-${Date.now()}`);
         testDebug(`create browser context (${this.name})`);
         const browser = await this._obtainBrowser();
         const browserContext = await this._doCreateContext(browser);
@@ -74,14 +82,15 @@ class BaseContextFactory {
     }
 }
 class IsolatedContextFactory extends BaseContextFactory {
-    constructor(browserConfig) {
-        super('isolated', browserConfig);
+    constructor(config) {
+        super('isolated', 'Create a new isolated browser context', config);
     }
     async _doObtainBrowser() {
-        await injectCdpPort(this.browserConfig);
-        const browserType = playwright[this.browserConfig.browserName];
+        await injectCdpPort(this.config.browser);
+        const browserType = playwright[this.config.browser.browserName];
         return browserType.launch({
-            ...this.browserConfig.launchOptions,
+            tracesDir: this._tracesDir,
+            ...this.config.browser.launchOptions,
             handleSIGINT: false,
             handleSIGTERM: false,
         }).catch(error => {
@@ -91,53 +100,59 @@ class IsolatedContextFactory extends BaseContextFactory {
         });
     }
     async _doCreateContext(browser) {
-        return browser.newContext(this.browserConfig.contextOptions);
+        return browser.newContext(this.config.browser.contextOptions);
     }
 }
 class CdpContextFactory extends BaseContextFactory {
-    constructor(browserConfig) {
-        super('cdp', browserConfig);
+    constructor(config) {
+        super('cdp', 'Connect to a browser over CDP', config);
     }
     async _doObtainBrowser() {
-        return playwright.chromium.connectOverCDP(this.browserConfig.cdpEndpoint);
+        return playwright.chromium.connectOverCDP(this.config.browser.cdpEndpoint);
     }
     async _doCreateContext(browser) {
-        return this.browserConfig.isolated ? await browser.newContext() : browser.contexts()[0];
+        return this.config.browser.isolated ? await browser.newContext() : browser.contexts()[0];
     }
 }
 class RemoteContextFactory extends BaseContextFactory {
-    constructor(browserConfig) {
-        super('remote', browserConfig);
+    constructor(config) {
+        super('remote', 'Connect to a browser using a remote endpoint', config);
     }
     async _doObtainBrowser() {
-        const url = new URL(this.browserConfig.remoteEndpoint);
-        url.searchParams.set('browser', this.browserConfig.browserName);
-        if (this.browserConfig.launchOptions)
-            url.searchParams.set('launch-options', JSON.stringify(this.browserConfig.launchOptions));
-        return playwright[this.browserConfig.browserName].connect(String(url));
+        const url = new URL(this.config.browser.remoteEndpoint);
+        url.searchParams.set('browser', this.config.browser.browserName);
+        if (this.config.browser.launchOptions)
+            url.searchParams.set('launch-options', JSON.stringify(this.config.browser.launchOptions));
+        return playwright[this.config.browser.browserName].connect(String(url));
     }
     async _doCreateContext(browser) {
         return browser.newContext();
     }
 }
 class PersistentContextFactory {
-    browserConfig;
+    config;
+    name = 'persistent';
+    description = 'Create a new persistent browser context';
     _userDataDirs = new Set();
-    constructor(browserConfig) {
-        this.browserConfig = browserConfig;
+    constructor(config) {
+        this.config = config;
     }
-    async createContext() {
-        await injectCdpPort(this.browserConfig);
+    async createContext(clientInfo) {
+        await injectCdpPort(this.config.browser);
         testDebug('create browser context (persistent)');
-        const userDataDir = this.browserConfig.userDataDir ?? await this._createUserDataDir();
+        const userDataDir = this.config.browser.userDataDir ?? await this._createUserDataDir(clientInfo.rootPath);
+        let tracesDir;
+        if (this.config.saveTrace)
+            tracesDir = await outputFile(this.config, clientInfo.rootPath, `traces-${Date.now()}`);
         this._userDataDirs.add(userDataDir);
         testDebug('lock user data dir', userDataDir);
-        const browserType = playwright[this.browserConfig.browserName];
+        const browserType = playwright[this.config.browser.browserName];
         for (let i = 0; i < 5; i++) {
             try {
                 const browserContext = await browserType.launchPersistentContext(userDataDir, {
-                    ...this.browserConfig.launchOptions,
-                    ...this.browserConfig.contextOptions,
+                    tracesDir,
+                    ...this.config.browser.launchOptions,
+                    ...this.config.browser.contextOptions,
                     handleSIGINT: false,
                     handleSIGTERM: false,
                 });
@@ -164,17 +179,12 @@ class PersistentContextFactory {
         this._userDataDirs.delete(userDataDir);
         testDebug('close browser context complete (persistent)');
     }
-    async _createUserDataDir() {
-        let cacheDirectory;
-        if (process.platform === 'linux')
-            cacheDirectory = process.env.XDG_CACHE_HOME || path.join(os.homedir(), '.cache');
-        else if (process.platform === 'darwin')
-            cacheDirectory = path.join(os.homedir(), 'Library', 'Caches');
-        else if (process.platform === 'win32')
-            cacheDirectory = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
-        else
-            throw new Error('Unsupported platform: ' + process.platform);
-        const result = path.join(cacheDirectory, 'ms-playwright', `mcp-${this.browserConfig.launchOptions?.channel ?? this.browserConfig?.browserName}-profile`);
+    async _createUserDataDir(rootPath) {
+        const dir = process.env.PWMCP_PROFILES_DIR_FOR_TEST ?? registryDirectory;
+        const browserToken = this.config.browser.launchOptions?.channel ?? this.config.browser?.browserName;
+        // Hesitant putting hundreds of files into the user's workspace, so using it for hashing instead.
+        const rootPathToken = rootPath ? `-${createHash(rootPath)}` : '';
+        const result = path.join(dir, `mcp-${browserToken}${rootPathToken}`);
         await fs.promises.mkdir(result, { recursive: true });
         return result;
     }

package/lib/browserServerBackend.js

@@ -13,42 +13,109 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { fileURLToPath } from 'url';
+import { z } from 'zod';
 import { Context } from './context.js';
 import { logUnhandledError } from './log.js';
 import { Response } from './response.js';
 import { SessionLog } from './sessionLog.js';
 import { filteredTools } from './tools.js';
 import { packageJSON } from './package.js';
+import { defineTool } from './tools/tool.js';
 export class BrowserServerBackend {
     name = 'Playwright';
     version = packageJSON.version;
-    onclose;
     _tools;
     _context;
     _sessionLog;
-    constructor(config, browserContextFactory) {
+    _config;
+    _browserContextFactory;
+    constructor(config, factories) {
+        this._config = config;
+        this._browserContextFactory = factories[0];
         this._tools = filteredTools(config);
-        this._context = new Context(this._tools, config, browserContextFactory);
+        if (factories.length > 1)
+            this._tools.push(this._defineContextSwitchTool(factories));
     }
-    async initialize() {
-        this._sessionLog = this._context.config.saveSession ? await SessionLog.create(this._context.config) : undefined;
+    async initialize(server) {
+        const capabilities = server.getClientCapabilities();
+        let rootPath;
+        if (capabilities.roots && (server.getClientVersion()?.name === 'Visual Studio Code' ||
+            server.getClientVersion()?.name === 'Visual Studio Code - Insiders')) {
+            const { roots } = await server.listRoots();
+            const firstRootUri = roots[0]?.uri;
+            const url = firstRootUri ? new URL(firstRootUri) : undefined;
+            rootPath = url ? fileURLToPath(url) : undefined;
+        }
+        this._sessionLog = this._config.saveSession ? await SessionLog.create(this._config, rootPath) : undefined;
+        this._context = new Context({
+            tools: this._tools,
+            config: this._config,
+            browserContextFactory: this._browserContextFactory,
+            sessionLog: this._sessionLog,
+            clientInfo: { ...server.getClientVersion(), rootPath },
+        });
     }
     tools() {
         return this._tools.map(tool => tool.schema);
     }
     async callTool(schema, parsedArguments) {
-        const response = new Response(this._context, schema.name, parsedArguments);
+        const context = this._context;
+        const response = new Response(context, schema.name, parsedArguments);
         const tool = this._tools.find(tool => tool.schema.name === schema.name);
-        await tool.handle(this._context, parsedArguments, response);
-        if (this._sessionLog)
-            await this._sessionLog.log(response);
-        return await response.serialize();
-    }
-    serverInitialized(version) {
-        this._context.clientVersion = version;
+        context.setRunningTool(true);
+        try {
+            await tool.handle(context, parsedArguments, response);
+            await response.finish();
+            this._sessionLog?.logResponse(response);
+        }
+        catch (error) {
+            response.addError(String(error));
+        }
+        finally {
+            context.setRunningTool(false);
+        }
+        return response.serialize();
     }
     serverClosed() {
-        this.onclose?.();
         void this._context.dispose().catch(logUnhandledError);
     }
+    _defineContextSwitchTool(factories) {
+        const self = this;
+        return defineTool({
+            capability: 'core',
+            schema: {
+                name: 'browser_connect',
+                title: 'Connect to a browser context',
+                description: [
+                    'Connect to a browser using one of the available methods:',
+                    ...factories.map(factory => `- "${factory.name}": ${factory.description}`),
+                ].join('\n'),
+                inputSchema: z.object({
+                    method: z.enum(factories.map(factory => factory.name)).default(factories[0].name).describe('The method to use to connect to the browser'),
+                }),
+                type: 'readOnly',
+            },
+            async handle(context, params, response) {
+                const factory = factories.find(factory => factory.name === params.method);
+                if (!factory) {
+                    response.addError('Unknown connection method: ' + params.method);
+                    return;
+                }
+                await self._setContextFactory(factory);
+                response.addResult('Successfully changed connection method.');
+            }
+        });
+    }
+    async _setContextFactory(newFactory) {
+        if (this._context) {
+            const options = {
+                ...this._context.options,
+                browserContextFactory: newFactory,
+            };
+            await this._context.dispose();
+            this._context = new Context(options);
+        }
+        this._browserContextFactory = newFactory;
+    }
 }

package/lib/config.js

@@ -17,7 +17,7 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { devices } from 'playwright';
-import { sanitizeForFilePath } from './tools/utils.js';
+import { sanitizeForFilePath } from './utils.js';
 const defaultConfig = {
     browser: {
         browserName: 'chromium',
@@ -35,7 +35,7 @@ const defaultConfig = {
         blockedOrigins: undefined,
     },
     server: {},
-    outputDir: path.join(os.tmpdir(), 'playwright-mcp-output', sanitizeForFilePath(new Date().toISOString())),
+    saveTrace: false,
 };
 export async function resolveConfig(config) {
     return mergeConfig(defaultConfig, config);
@@ -48,9 +48,6 @@ export async function resolveCLIConfig(cliOptions) {
     result = mergeConfig(result, configInFile);
     result = mergeConfig(result, envOverrides);
     result = mergeConfig(result, cliOverrides);
-    // Derive artifact output directory from config.outputDir
-    if (result.saveTrace)
-        result.browser.launchOptions.tracesDir = path.join(result.outputDir, 'traces');
     return result;
 }
 export function configFromCLIOptions(cliOptions) {
@@ -179,10 +176,13 @@ async function loadConfig(configFile) {
         throw new Error(`Failed to load config file: ${configFile}, ${error}`);
     }
 }
-export async function outputFile(config, name) {
-    await fs.promises.mkdir(config.outputDir, { recursive: true });
+export async function outputFile(config, rootPath, name) {
+    const outputDir = config.outputDir
+        ?? (rootPath ? path.join(rootPath, '.playwright-mcp') : undefined)
+        ?? path.join(os.tmpdir(), 'playwright-mcp-output', sanitizeForFilePath(new Date().toISOString()));
+    await fs.promises.mkdir(outputDir, { recursive: true });
     const fileName = sanitizeForFilePath(name);
-    return path.join(config.outputDir, fileName);
+    return path.join(outputDir, fileName);
 }
 function pickDefined(obj) {
     return Object.fromEntries(Object.entries(obj ?? {}).filter(([_, v]) => v !== undefined));

package/lib/context.js

@@ -16,21 +16,29 @@
 import debug from 'debug';
 import { logUnhandledError } from './log.js';
 import { Tab } from './tab.js';
+import { outputFile } from './config.js';
 const testDebug = debug('pw:mcp:test');
 export class Context {
     tools;
     config;
+    sessionLog;
+    options;
     _browserContextPromise;
     _browserContextFactory;
     _tabs = [];
     _currentTab;
-    clientVersion;
+    _clientInfo;
     static _allContexts = new Set();
     _closeBrowserContextPromise;
-    constructor(tools, config, browserContextFactory) {
-        this.tools = tools;
-        this.config = config;
-        this._browserContextFactory = browserContextFactory;
+    _isRunningTool = false;
+    _abortController = new AbortController();
+    constructor(options) {
+        this.tools = options.tools;
+        this.config = options.config;
+        this.sessionLog = options.sessionLog;
+        this.options = options;
+        this._browserContextFactory = options.browserContextFactory;
+        this._clientInfo = options.clientInfo;
         testDebug('create context');
         Context._allContexts.add(this);
     }
@@ -68,27 +76,6 @@ export class Context {
             await browserContext.newPage();
         return this._currentTab;
     }
-    async listTabsMarkdown(force = false) {
-        if (this._tabs.length === 1 && !force)
-            return [];
-        if (!this._tabs.length) {
-            return [
-                '### No open tabs',
-                'Use the "browser_navigate" tool to navigate to a page first.',
-                '',
-            ];
-        }
-        const lines = ['### Open tabs'];
-        for (let i = 0; i < this._tabs.length; i++) {
-            const tab = this._tabs[i];
-            const title = await tab.title();
-            const url = tab.page.url();
-            const current = tab === this._currentTab ? ' (current)' : '';
-            lines.push(`- ${i}:${current} [${title}] (${url})`);
-        }
-        lines.push('');
-        return lines;
-    }
     async closeTab(index) {
         const tab = index === undefined ? this._currentTab : this._tabs[index];
         if (!tab)
@@ -97,6 +84,9 @@ export class Context {
         await tab.page.close();
         return url;
     }
+    async outputFile(name) {
+        return outputFile(this.config, this._clientInfo.rootPath, name);
+    }
     _onPageCreated(page) {
         const tab = new Tab(this, page, tab => this._onPageClosed(tab));
         this._tabs.push(tab);
@@ -119,6 +109,12 @@ export class Context {
         await this._closeBrowserContextPromise;
         this._closeBrowserContextPromise = undefined;
     }
+    isRunningTool() {
+        return this._isRunningTool;
+    }
+    setRunningTool(isRunningTool) {
+        this._isRunningTool = isRunningTool;
+    }
     async _closeBrowserContextImpl() {
         if (!this._browserContextPromise)
             return;
@@ -132,6 +128,7 @@ export class Context {
         });
     }
     async dispose() {
+        this._abortController.abort('MCP context disposed');
         await this.closeBrowserContext();
         Context._allContexts.delete(this);
     }
@@ -159,9 +156,11 @@ export class Context {
         if (this._closeBrowserContextPromise)
             throw new Error('Another browser context is being closed.');
         // TODO: move to the browser context factory to make it based on isolation mode.
-        const result = await this._browserContextFactory.createContext(this.clientVersion);
+        const result = await this._browserContextFactory.createContext(this._clientInfo, this._abortController.signal);
         const { browserContext } = result;
         await this._setupRequestInterception(browserContext);
+        if (this.sessionLog)
+            await InputRecorder.create(this, browserContext);
         for (const page of browserContext.pages())
             this._onPageCreated(page);
         browserContext.on('page', page => this._onPageCreated(page));
@@ -176,3 +175,52 @@ export class Context {
         return result;
     }
 }
+export class InputRecorder {
+    _context;
+    _browserContext;
+    constructor(context, browserContext) {
+        this._context = context;
+        this._browserContext = browserContext;
+    }
+    static async create(context, browserContext) {
+        const recorder = new InputRecorder(context, browserContext);
+        await recorder._initialize();
+        return recorder;
+    }
+    async _initialize() {
+        const sessionLog = this._context.sessionLog;
+        await this._browserContext._enableRecorder({
+            mode: 'recording',
+            recorderMode: 'api',
+        }, {
+            actionAdded: (page, data, code) => {
+                if (this._context.isRunningTool())
+                    return;
+                const tab = Tab.forPage(page);
+                if (tab)
+                    sessionLog.logUserAction(data.action, tab, code, false);
+            },
+            actionUpdated: (page, data, code) => {
+                if (this._context.isRunningTool())
+                    return;
+                const tab = Tab.forPage(page);
+                if (tab)
+                    sessionLog.logUserAction(data.action, tab, code, true);
+            },
+            signalAdded: (page, data) => {
+                if (this._context.isRunningTool())
+                    return;
+                if (data.signal.name !== 'navigation')
+                    return;
+                const tab = Tab.forPage(page);
+                const navigateAction = {
+                    name: 'navigate',
+                    url: data.signal.url,
+                    signals: [],
+                };
+                if (tab)
+                    sessionLog.logUserAction(navigateAction, tab, `await page.goto('${data.signal.url}');`, false);
+            },
+        });
+    }
+}

package/lib/extension/cdpRelay.js

@@ -13,19 +13,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/**
+ * WebSocket server that bridges Playwright MCP and Chrome Extension
+ *
+ * Endpoints:
+ * - /cdp/guid - Full CDP interface for Playwright MCP
+ * - /extension/guid - Extension connection for chrome.debugger forwarding
+ */
 import { spawn } from 'child_process';
-import { WebSocket, WebSocketServer } from 'ws';
 import debug from 'debug';
-import * as playwright from 'playwright';
-// @ts-ignore
-const { registry } = await import('playwright-core/lib/server/registry/index');
-import { httpAddressToString, startHttpServer } from '../httpServer.js';
+import { WebSocket, WebSocketServer } from 'ws';
+import { httpAddressToString } from '../httpServer.js';
 import { logUnhandledError } from '../log.js';
 import { ManualPromise } from '../manualPromise.js';
+// @ts-ignore
+const { registry } = await import('playwright-core/lib/server/registry/index');
 const debugLogger = debug('pw:mcp:relay');
 export class CDPRelayServer {
     _wsHost;
     _browserChannel;
+    _userDataDir;
     _cdpPath;
     _extensionPath;
     _wss;
@@ -34,9 +41,10 @@ export class CDPRelayServer {
     _connectedTabInfo;
     _nextSessionId = 1;
     _extensionConnectionPromise;
-    constructor(server, browserChannel) {
+    constructor(server, browserChannel, userDataDir) {
         this._wsHost = httpAddressToString(server.address()).replace(/^http/, 'ws');
         this._browserChannel = browserChannel;
+        this._userDataDir = userDataDir;
         const uuid = crypto.randomUUID();
         this._cdpPath = `/cdp/${uuid}`;
         this._extensionPath = `/extension/${uuid}`;
@@ -50,16 +58,19 @@ export class CDPRelayServer {
     extensionEndpoint() {
         return `${this._wsHost}${this._extensionPath}`;
     }
-    async ensureExtensionConnectionForMCPContext(clientInfo) {
+    async ensureExtensionConnectionForMCPContext(clientInfo, abortSignal) {
         debugLogger('Ensuring extension connection for MCP context');
         if (this._extensionConnection)
             return;
-        await this._connectBrowser(clientInfo);
+        this._connectBrowser(clientInfo);
         debugLogger('Waiting for incoming extension connection');
-        await this._extensionConnectionPromise;
+        await Promise.race([
+            this._extensionConnectionPromise,
+            new Promise((_, reject) => abortSignal.addEventListener('abort', reject))
+        ]);
         debugLogger('Extension connection established');
     }
-    async _connectBrowser(clientInfo) {
+    _connectBrowser(clientInfo) {
         const mcpRelayEndpoint = `${this._wsHost}${this._extensionPath}`;
         // Need to specify "key" in the manifest.json to make the id stable when loading from file.
         const url = new URL('chrome-extension://jakfalbnbhgkpmoaakfflhflbfpkailf/connect.html');
@@ -72,7 +83,11 @@ export class CDPRelayServer {
         const executablePath = executableInfo.executablePath();
         if (!executablePath)
             throw new Error(`"${this._browserChannel}" executable not found. Make sure it is installed at a standard location.`);
-        spawn(executablePath, [href], {
+        const args = [];
+        if (this._userDataDir)
+            args.push(`--user-data-dir=${this._userDataDir}`);
+        args.push(href);
+        spawn(executablePath, args, {
             windowsHide: true,
             detached: true,
             shell: false,
@@ -248,45 +263,6 @@ export class CDPRelayServer {
         this._playwrightConnection?.send(JSON.stringify(message));
     }
 }
-class ExtensionContextFactory {
-    _relay;
-    _browserPromise;
-    constructor(relay) {
-        this._relay = relay;
-    }
-    async createContext(clientInfo) {
-        // First call will establish the connection to the extension.
-        if (!this._browserPromise)
-            this._browserPromise = this._obtainBrowser(clientInfo);
-        const browser = await this._browserPromise;
-        return {
-            browserContext: browser.contexts()[0],
-            close: async () => {
-                debugLogger('close() called for browser context, ignoring');
-            }
-        };
-    }
-    clientDisconnected() {
-        this._relay.closeConnections('MCP client disconnected');
-        this._browserPromise = undefined;
-    }
-    async _obtainBrowser(clientInfo) {
-        await this._relay.ensureExtensionConnectionForMCPContext(clientInfo);
-        const browser = await playwright.chromium.connectOverCDP(this._relay.cdpEndpoint());
-        browser.on('disconnected', () => {
-            this._browserPromise = undefined;
-            debugLogger('Browser disconnected');
-        });
-        return browser;
-    }
-}
-export async function startCDPRelayServer(browserChannel, abortController) {
-    const httpServer = await startHttpServer({});
-    const cdpRelayServer = new CDPRelayServer(httpServer, browserChannel);
-    abortController.signal.addEventListener('abort', () => cdpRelayServer.stop());
-    debugLogger(`CDP relay server started, extension endpoint: ${cdpRelayServer.extensionEndpoint()}.`);
-    return new ExtensionContextFactory(cdpRelayServer);
-}
 class ExtensionConnection {
     _ws;
     _callbacks = new Map();