Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.
TypeScript automationchromechromiume2e-testingelectronend-to-end-testingfirefoxjavascriptplaywrighttesttest-automationtestingtesting-toolswebwebkit
fix(mcp): drop the backend after browser_close with a shared browser (#42365)
om singhale65229f19f4c
diff --git a/packages/playwright-core/src/tools/backend/browserBackend.ts b/packages/playwright-core/src/tools/backend/browserBackend.tsindex ac23adda87..1c4dd4d634 100644--- a/packages/playwright-core/src/tools/backend/browserBackend.ts+++ b/packages/playwright-core/src/tools/backend/browserBackend.ts@@ -38,6 +38,7 @@ export class BrowserBackend extends EventEmitter<{ disconnected: [] }> implementprivate _disposed = false;private _browserContext: playwright.BrowserContext;private _disposeCallback: (() => Promise<void>) | undefined;+ private _markDisconnected: () => void;constructor(config: ContextConfig, browserContext: playwright.BrowserContext, tools: Tool[], disposeCallback?: () => Promise<void>) {super();@@ -45,15 +46,15 @@ export class BrowserBackend extends EventEmitter<{ disconnected: [] }> implementthis._tools = tools;this._browserContext = browserContext;this._disposeCallback = disposeCallback;- const markDisconnected = () => {+ this._markDisconnected = () => {if (this._disconnected)return;backendDebug('browser disconnected');this._disconnected = true;this.emit('disconnected');};- this._browserContext.once('close', markDisconnected);- this._browserContext.browser()?.once('disconnected', markDisconnected);+ this._browserContext.once('close', this._markDisconnected);+ this._browserContext.browser()?.once('disconnected', this._markDisconnected);}async initialize(clientInfo: ClientInfo): Promise<void> {@@ -69,8 +70,18 @@ export class BrowserBackend extends EventEmitter<{ disconnected: [] }> implementif (this._disposed)return;this._disposed = true;+ // These listeners would otherwise keep every disposed backend reachable for+ // as long as the context and the browser live.+ this._browserContext.off('close', this._markDisconnected);+ this._browserContext.browser()?.off('disconnected', this._markDisconnected);await this._context?.dispose().catch(e => debug('pw:tools:error')(e));await this._disposeCallback?.().catch(e => debug('pw:tools:error')(e));+ // The browser may outlive this backend, e.g. when other clients share it,+ // so tell the server to stop handing out the disposed backend.+ if (!this._disconnected) {+ this._disconnected = true;+ this.emit('disconnected');+ }}async callTool(name: string, rawArguments: mcpServer.CallToolRequest['params']['arguments'] & { _meta?: Record<string, any> } = {}, signal?: AbortSignal): Promise<mcpServer.CallToolResult> {diff --git a/packages/playwright-core/src/tools/mcp/index.ts b/packages/playwright-core/src/tools/mcp/index.tsindex d720e1c938..5f259b3fe3 100644--- a/packages/playwright-core/src/tools/mcp/index.ts+++ b/packages/playwright-core/src/tools/mcp/index.ts@@ -35,11 +35,24 @@ export async function createConnection(userConfig: Config = {}, contextGetter?:version: packageJSON.version,toolSchemas: tools.map(tool => tool.schema),create: async (clientInfo: ClientInfo) => {- const browser = contextGetter- ? new SimpleBrowser(await contextGetter())- : (await createBrowserWithInfo(config, clientInfo, {})).browser;+ if (contextGetter) {+ const browser = new SimpleBrowser(await contextGetter());+ const context = config.browser.isolated ? await browser.newContext() : browser.contexts()[0];+ // The caller owns the context it handed us, so it closes it too.+ return new BrowserBackend(config, context, tools);+ }++ const { browser } = await createBrowserWithInfo(config, clientInfo, {});const context = config.browser.isolated ? await browser.newContext(config.browser.contextOptions) : browser.contexts()[0];- return new BrowserBackend(config, context, tools);+ // Close the browser in both ownership modes. A browser this factory+ // launched shuts down here. For an attached one (a CDP or remote+ // endpoint, or the extension) close() only drops the connection this+ // factory made while the external browser keeps running, so skipping it+ // would leak that connection. The next call attaches again.+ return new BrowserBackend(config, context, tools, async () => {+ await context.close().catch(() => {});+ await browser.close().catch(() => {});+ });},};return createServer('api', packageJSON.version, backendFactory, Promise.resolve(), false);diff --git a/tests/mcp/http.spec.ts b/tests/mcp/http.spec.tsindex f24b65e28f..6952eef2e8 100644--- a/tests/mcp/http.spec.ts+++ b/tests/mcp/http.spec.ts@@ -438,6 +438,62 @@ test('http transport shared context', async ({ serverEndpoint, server }) => {});});+test('http transport shared context survives browser_close', { annotation: { type: 'issue', description: 'https://github.com/microsoft/playwright/issues/42363' } }, async ({ serverEndpoint, server }) => {+ const { url, stderr } = await serverEndpoint({ args: ['--shared-browser-context'] });++ const transport1 = new StreamableHTTPClientTransport(new URL('/mcp', url));+ const client1 = new Client({ name: 'test1', version: '1.0.0' });+ await client1.connect(transport1);+ await client1.callTool({+ name: 'browser_navigate',+ arguments: { url: server.HELLO_WORLD },+ });++ const transport2 = new StreamableHTTPClientTransport(new URL('/mcp', url));+ const client2 = new Client({ name: 'test2', version: '1.0.0' });+ await client2.connect(transport2);+ await client2.callTool({+ name: 'browser_navigate',+ arguments: { url: server.HELLO_WORLD },+ });++ // The second client keeps the shared browser alive, so closing only+ // disposes the first client's backend.+ await client1.callTool({+ name: 'browser_close',+ arguments: {},+ });++ // The next call from the first client must get a fresh backend.+ expect(await client1.callTool({+ name: 'browser_tabs',+ arguments: { action: 'new', url: server.HELLO_WORLD },+ })).toHaveResponse({+ snapshot: expect.stringContaining(`Hello, world!`),+ });++ // The second client is unaffected.+ expect(await client2.callTool({+ name: 'browser_snapshot',+ arguments: {},+ })).toHaveResponse({+ inlineSnapshot: expect.stringContaining(`Hello, world!`),+ });++ await transport1.terminateSession();+ await client1.close();+ await transport2.terminateSession();+ await client2.close();++ await expect.poll(() => formatLog(stderr())).toEqual({+ 'create browser (persistent)': 1,+ 'create http session': 2,+ 'delete http session': 2,+ 'create context': 3,+ 'close browser': 1,+ });+});+test('http transport (default)', async ({ serverEndpoint }) => {const { url } = await serverEndpoint();const transport = new StreamableHTTPClientTransport(url);diff --git a/tests/mcp/library.spec.ts b/tests/mcp/library.spec.tsindex c853b53097..176493f5ea 100644--- a/tests/mcp/library.spec.ts+++ b/tests/mcp/library.spec.ts@@ -15,7 +15,17 @@*/import child_process from 'child_process';import fs from 'fs/promises';+import net from 'net';++import * as playwright from 'playwright';+import { Client } from '@modelcontextprotocol/sdk/client/index.js';+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';import { test, expect } from './fixtures';+import { tools } from '../../packages/playwright-core/lib/coreBundle';++import type { Server } from '@modelcontextprotocol/sdk/server/index.js';++const { createConnection } = tools;test('library can be used from CommonJS', { annotation: { type: 'issue', description: 'https://github.com/microsoft/playwright-mcp/issues/456' } }, async ({}, testInfo) => {const file = testInfo.outputPath('main.cjs');@@ -26,3 +36,146 @@ test('library can be used from CommonJS', { annotation: { type: 'issue', descrip`);expect(child_process.execSync(`node ${file}`, { encoding: 'utf-8' })).toContain('OK');});++test('createConnection detaches backend listeners from a caller owned context', async ({ mcpBrowser, mcpHeadless, server }, testInfo) => {+ const { browserName, channel } = browserForProject(mcpBrowser);+ const browser = await playwright[browserName].launch({ channel, headless: mcpHeadless });+ const browserContext = await browser.newContext();++ const client = await connectClient(await createConnection({+ outputDir: testInfo.outputPath('output'),+ }, async () => browserContext));++ const contextListeners = listenerCount(browserContext, 'close');+ const browserListeners = listenerCount(browser, 'disconnected');++ // browser_close disposes the backend while the caller keeps the context, so+ // the next tool call builds another backend over the same two objects.+ for (let i = 0; i < 3; i++) {+ await client.callTool({ name: 'browser_navigate', arguments: { url: server.HELLO_WORLD } });+ // A live backend listens on both objects.+ expect(listenerCount(browserContext, 'close')).toBe(contextListeners + 1);+ expect(listenerCount(browser, 'disconnected')).toBe(browserListeners + 1);++ await client.callTool({ name: 'browser_close', arguments: {} });+ // A disposed one gives both back, so they do not pile up.+ expect(listenerCount(browserContext, 'close')).toBe(contextListeners);+ expect(listenerCount(browser, 'disconnected')).toBe(browserListeners);+ }++ await client.close();+ await browser.close();+});++test('createConnection closes the browser it launched when the backend is disposed', async ({ mcpBrowser, mcpHeadless, server }, testInfo) => {+ test.skip(!['chrome', 'msedge', 'chromium'].includes(mcpBrowser!), 'Profile locking is a Chromium behavior');++ const { browserName, channel } = browserForProject(mcpBrowser);+ const userDataDir = testInfo.outputPath('user-data-dir');++ const client = await connectClient(await createConnection({+ // Match what BrowserType.launch does by default. Resolving this config+ // turns the sandbox on for a chromium without a channel, and the bundled+ // build cannot sandbox on a linux runner.+ browser: { browserName, userDataDir, launchOptions: { channel, chromiumSandbox: false, headless: mcpHeadless } },+ outputDir: testInfo.outputPath('output'),+ }));++ expect(await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.HELLO_WORLD },+ })).toHaveResponse({+ page: expect.stringContaining(`Page URL: ${server.HELLO_WORLD}`),+ });++ // Nothing else holds this browser, so disposing the backend has to close it.+ // A leaked browser keeps the profile, and nothing else can open it. Claiming+ // the profile from the test rather than through another tool call keeps this+ // about the browser process and not about how the server rebuilds a backend.+ await client.callTool({ name: 'browser_close', arguments: {} });+ await client.close();++ await expect.poll(async () => {+ try {+ const context = await playwright[browserName].launchPersistentContext(userDataDir, { channel, headless: mcpHeadless });+ await context.close();+ return 'free';+ } catch (e: any) {+ return String(e.message);+ }+ }, { timeout: 15000 }).toBe('free');+});++test('createConnection drops its connection to an attached browser when the backend is disposed', async ({ mcpBrowser, mcpHeadless, server }, testInfo) => {+ const { browserName, channel } = browserForProject(mcpBrowser);+ const browserServer = await playwright[browserName].launchServer({ channel, headless: mcpHeadless });+ const wsUrl = new URL(browserServer.wsEndpoint());+ // URL keeps the brackets around an IPv6 host, net.connect does not take them.+ const wsHost = wsUrl.hostname.replace(/^\[|\]$/g, '');++ // A counting TCP proxy in front of the browser server makes the connection+ // the factory holds observable from the outside.+ let openConnections = 0;+ const proxy = net.createServer(socket => {+ openConnections++;+ const upstream = net.connect(Number(wsUrl.port), wsHost);+ socket.pipe(upstream);+ upstream.pipe(socket);+ socket.once('close', () => {+ openConnections--;+ upstream.destroy();+ });+ upstream.once('close', () => socket.destroy());+ socket.on('error', () => socket.destroy());+ upstream.on('error', () => upstream.destroy());+ });+ await new Promise<void>(resolve => proxy.listen(0, '127.0.0.1', resolve));+ const proxyPort = (proxy.address() as net.AddressInfo).port;++ const client = await connectClient(await createConnection({+ browser: { remoteEndpoint: `ws://127.0.0.1:${proxyPort}${wsUrl.pathname}` },+ outputDir: testInfo.outputPath('output'),+ }));++ expect(await client.callTool({+ name: 'browser_navigate',+ arguments: { url: server.HELLO_WORLD },+ })).toHaveResponse({+ page: expect.stringContaining(`Page URL: ${server.HELLO_WORLD}`),+ });+ expect(openConnections).toBe(1);++ // The factory attached to this browser instead of launching it, so closing+ // the browser on dispose only drops the connection the factory made while+ // the browser server keeps running. Skipping the close would leak that+ // connection for as long as the server stays up.+ await client.callTool({ name: 'browser_close', arguments: {} });+ await expect.poll(() => openConnections).toBe(0);++ // The external browser survived the disconnect.+ const probe = await playwright[browserName].connect(browserServer.wsEndpoint());+ expect(probe.isConnected()).toBe(true);+ await probe.close();++ await client.close();+ await new Promise<void>(resolve => proxy.close(() => resolve()));+ await browserServer.close();+});++function browserForProject(mcpBrowser: string | undefined): { browserName: 'chromium' | 'firefox' | 'webkit', channel: string | undefined } {+ const channel = mcpBrowser === 'chrome' || mcpBrowser === 'msedge' ? mcpBrowser : undefined;+ const browserName = channel || mcpBrowser === 'chromium' ? 'chromium' : mcpBrowser as 'firefox' | 'webkit';+ return { browserName, channel };+}++function listenerCount(emitter: object, event: string): number {+ return (emitter as unknown as { listenerCount(event: string): number }).listenerCount(event);+}++async function connectClient(server: Server): Promise<Client> {+ const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();+ await server.connect(serverTransport);+ const client = new Client({ name: 'test', version: '1.0.0' });+ await client.connect(clientTransport);+ return client;+}