Skip to content

Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.

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.ts
index 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: [] }> implement
private _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: [] }> implement
this._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: [] }> implement
if (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.ts
index 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.ts
index 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.ts
index 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;
+}