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): reconnect to the browser after disconnect (#41966)

Yury Semikhatsky2cc9f3ee7fdd
diff --git a/packages/playwright-core/src/tools/backend/browserBackend.ts b/packages/playwright-core/src/tools/backend/browserBackend.ts
index 2fc6d82944..ac23adda87 100644
--- a/packages/playwright-core/src/tools/backend/browserBackend.ts
+++ b/packages/playwright-core/src/tools/backend/browserBackend.ts
@@ -27,7 +27,9 @@ import type { Tool } from './tool';
import type * as mcpServer from '../utils/mcp/server';
import type { ClientInfo, ServerBackend } from '../utils/mcp/server';
-export class BrowserBackend extends EventEmitter<{ disconnected: [], disposed: [] }> implements ServerBackend {
+const backendDebug = debug('pw:mcp:backend');
+
+export class BrowserBackend extends EventEmitter<{ disconnected: [] }> implements ServerBackend {
private _tools: Tool[];
private _context: Context | undefined;
private _sessionLog: SessionLog | undefined;
@@ -46,6 +48,7 @@ export class BrowserBackend extends EventEmitter<{ disconnected: [], disposed: [
const markDisconnected = () => {
if (this._disconnected)
return;
+ backendDebug('browser disconnected');
this._disconnected = true;
this.emit('disconnected');
};
@@ -68,7 +71,6 @@ export class BrowserBackend extends EventEmitter<{ disconnected: [], disposed: [
this._disposed = true;
await this._context?.dispose().catch(e => debug('pw:tools:error')(e));
await this._disposeCallback?.().catch(e => debug('pw:tools:error')(e));
- this.emit('disposed');
}
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/cdpRelay.ts b/packages/playwright-core/src/tools/mcp/cdpRelay.ts
index b1a654131a..2de9348bf6 100644
--- a/packages/playwright-core/src/tools/mcp/cdpRelay.ts
+++ b/packages/playwright-core/src/tools/mcp/cdpRelay.ts
@@ -58,6 +58,7 @@ type CDPCommand = {
type CDPResponse = CDPMessage;
export class CDPRelayServer {
+ private _httpServer: http.Server;
private _wsHost: string;
private _browserChannel: string;
private _executablePath?: string;
@@ -72,6 +73,7 @@ export class CDPRelayServer {
private _extensionConnectionPromise = new ManualPromise<void>();
constructor(server: http.Server, browserChannel: string, executablePath?: string, userDataDir?: string) {
+ this._httpServer = server;
this._wsHost = addressToString(server.address(), { protocol: 'ws' });
this._browserChannel = browserChannel;
this._executablePath = executablePath;
@@ -160,6 +162,7 @@ export class CDPRelayServer {
stop(): void {
this._closeConnections('Server stopped');
this._wss.close();
+ this._httpServer.close();
}
private _closeConnections(reason: string) {
diff --git a/packages/playwright-core/src/tools/mcp/extensionContextFactory.ts b/packages/playwright-core/src/tools/mcp/extensionContextFactory.ts
index 16d8a6ae6c..8c3f6f3e8b 100644
--- a/packages/playwright-core/src/tools/mcp/extensionContextFactory.ts
+++ b/packages/playwright-core/src/tools/mcp/extensionContextFactory.ts
@@ -41,10 +41,11 @@ export async function createExtensionBrowser(channel: string, executablePath: st
try {
await relay.establishExtensionConnection(clientName);
- return await playwright.chromium.connectOverCDP(relay.cdpEndpoint(), { isLocal: true, timeout: 0 });
+ const browser = await playwright.chromium.connectOverCDP(relay.cdpEndpoint(), { isLocal: true, timeout: 0 });
+ browser.on('disconnected', () => relay.stop());
+ return browser;
} catch (error) {
relay.stop();
- httpServer.close();
throw error;
}
}
diff --git a/packages/playwright-core/src/tools/mcp/program.ts b/packages/playwright-core/src/tools/mcp/program.ts
index 2c748848b3..9db1980820 100644
--- a/packages/playwright-core/src/tools/mcp/program.ts
+++ b/packages/playwright-core/src/tools/mcp/program.ts
@@ -110,41 +110,55 @@ export function decorateMCPCommand(command: Command) {
toolSchemas: tools.map(tool => tool.schema),
create: async (clientInfo: ClientInfo) => {
if (useSharedBrowser && !sharedBrowserPromise) {
- sharedBrowserPromise = (async () => {
+ const promise = (async () => {
const { browser, canBind } = await createBrowserWithInfo(config, clientInfo, options);
if (canBind)
await browser.bind(clientInfo.clientName, { workspaceDir: clientInfo.cwd });
+ browser.once('disconnected', () => {
+ if (sharedBrowserPromise === promise)
+ sharedBrowserPromise = undefined;
+ });
return browser;
})().catch(error => {
- sharedBrowserPromise = undefined;
+ if (sharedBrowserPromise === promise)
+ sharedBrowserPromise = undefined;
throw error;
});
+ sharedBrowserPromise = promise;
}
clientCount++;
- const { browser, canBind } = sharedBrowserPromise ? { browser: await sharedBrowserPromise, canBind: false } : await createBrowserWithInfo(config, clientInfo, options);
- if (canBind) {
- const count = (clientNameCounters.get(clientInfo.clientName) ?? 0) + 1;
- clientNameCounters.set(clientInfo.clientName, count);
- const sessionName = count > 1 ? `${clientInfo.clientName} (${count})` : clientInfo.clientName;
- await browser.bind(sessionName, { workspaceDir: clientInfo.cwd });
- }
- const browserContext = config.browser.isolated ? await browser.newContext(config.browser.contextOptions) : browser.contexts()[0];
- return new BrowserBackend(config, browserContext, tools, async () => {
- clientCount--;
+ try {
+ const promise = sharedBrowserPromise;
+ const { browser, canBind } = promise ? { browser: await promise, canBind: false } : await createBrowserWithInfo(config, clientInfo, options);
+ if (canBind) {
+ const count = (clientNameCounters.get(clientInfo.clientName) ?? 0) + 1;
+ clientNameCounters.set(clientInfo.clientName, count);
+ const sessionName = count > 1 ? `${clientInfo.clientName} (${count})` : clientInfo.clientName;
+ await browser.bind(sessionName, { workspaceDir: clientInfo.cwd });
+ }
+ const browserContext = config.browser.isolated ? await browser.newContext(config.browser.contextOptions) : browser.contexts()[0];
+ return new BrowserBackend(config, browserContext, tools, async () => {
+ clientCount--;
- if (sharedBrowserPromise && clientCount > 0) {
- if (config.browser.isolated) {
- testDebug('close context');
- await browserContext.close().catch(() => { });
+ if (sharedBrowserPromise && clientCount > 0) {
+ if (config.browser.isolated) {
+ testDebug('close context');
+ await browserContext.close().catch(() => { });
+ }
+ return;
}
- return;
- }
- testDebug('close browser');
- sharedBrowserPromise = undefined;
- await browserContext.close().catch(() => { });
- await browserContext.browser()?.close().catch(() => { });
- });
+ testDebug('close browser');
+ if (sharedBrowserPromise === promise)
+ sharedBrowserPromise = undefined;
+ await browserContext.close().catch(() => { });
+ await browser.close().catch(() => { });
+ });
+ } catch (error) {
+ // The dispose callback never runs for a failed create.
+ clientCount--;
+ throw error;
+ }
},
};
await mcpServer.start(factory, config.server);
diff --git a/packages/playwright-core/src/tools/utils/mcp/server.ts b/packages/playwright-core/src/tools/utils/mcp/server.ts
index ecdd1ae6ca..252e7ccb5a 100644
--- a/packages/playwright-core/src/tools/utils/mcp/server.ts
+++ b/packages/playwright-core/src/tools/utils/mcp/server.ts
@@ -42,7 +42,7 @@ export interface ServerBackend {
initialize?(clientInfo: ClientInfo): Promise<void>;
callTool(name: string, args: CallToolRequest['params']['arguments'], signal: AbortSignal): Promise<CallToolResult>;
dispose?(): Promise<void>;
- once(event: 'disposed', listener: () => void): void;
+ once(event: 'disconnected', listener: () => void): void;
}
export type ServerBackendFactory = {
@@ -80,13 +80,19 @@ export function createServer(name: string, version: string, factory: ServerBacke
try {
if (!backendPromise) {
- backendPromise = initializeServer(server, factory, transportInitialized, runHeartbeat).then(backend => {
- backend.once('disposed', () => { backendPromise = undefined; });
+ const promise = initializeServer(server, factory, transportInitialized, runHeartbeat).then(backend => {
+ backend.once('disconnected', () => {
+ if (backendPromise === promise)
+ backendPromise = undefined;
+ void backend.dispose?.().catch(serverDebug);
+ });
return backend;
}).catch(e => {
- backendPromise = undefined;
+ if (backendPromise === promise)
+ backendPromise = undefined;
throw e;
});
+ backendPromise = promise;
}
const backend = await backendPromise;
diff --git a/tests/extension/extension-fixtures.ts b/tests/extension/extension-fixtures.ts
index b7e8e0420c..8594364908 100644
--- a/tests/extension/extension-fixtures.ts
+++ b/tests/extension/extension-fixtures.ts
@@ -197,6 +197,15 @@ export async function startWithExtensionFlag(browserWithExtension: BrowserWithEx
return client;
}
+export async function readExtensionToken(browserContext: BrowserContext): Promise<string> {
+ const page = await browserContext.newPage();
+ await page.goto(`chrome-extension://${extensionId}/status.html`);
+ const token = await page.locator('.auth-token-code').textContent();
+ await page.close();
+ const [, value] = token?.split('=') || [];
+ return value;
+}
+
// The connect page closes itself once a different tab is selected, which races
// with the click — the request reaches the background while the page is being
// torn down. Swallow the resulting "Target closed" error.
diff --git a/tests/extension/extension.spec.ts b/tests/extension/extension.spec.ts
index 1f3c7b4b88..1757434607 100644
--- a/tests/extension/extension.spec.ts
+++ b/tests/extension/extension.spec.ts
@@ -17,7 +17,7 @@
import fs from 'fs/promises';
import path from 'path';
-import { test, testWithOldExtensionVersion, expect, extensionId, clickAllowAndSelect, connectAndNavigate, startWithExtensionFlag } from './extension-fixtures';
+import { test, testWithOldExtensionVersion, expect, extensionId, clickAllowAndSelect, connectAndNavigate, readExtensionToken, startWithExtensionFlag } from './extension-fixtures';
import { utils } from '../../packages/playwright-core/lib/coreBundle';
const { defaultUserDataDirForChannel } = utils;
@@ -342,18 +342,14 @@ test(`browser_cookie_list and browser_cookie_set work in extension mode`, {
test(`bypass connection dialog with token`, async ({ browserWithExtension, startClient, server }) => {
const browserContext = await browserWithExtension.launch();
-
- const page = await browserContext.newPage();
- await page.goto(`chrome-extension://${extensionId}/status.html`);
- const token = await page.locator('.auth-token-code').textContent();
- const [, value] = token?.split('=') || [];
+ const token = await readExtensionToken(browserContext);
const clientName = 'token-bypass-client';
const { client } = await startClient({
clientName,
args: [`--extension`],
env: {
- PLAYWRIGHT_MCP_EXTENSION_TOKEN: value,
+ PLAYWRIGHT_MCP_EXTENSION_TOKEN: token,
PWTEST_EXTENSION_USER_DATA_DIR: browserWithExtension.userDataDir,
},
});
@@ -367,6 +363,45 @@ test(`bypass connection dialog with token`, async ({ browserWithExtension, start
snapshot: expect.stringContaining(`- generic [active] [ref=f1e1]: Hello, world!`),
});
+ const page = await browserContext.newPage();
await page.goto(`chrome-extension://${extensionId}/status.html`);
await expect(page.locator('.client-info')).toContainText(`Connected to "${clientName}"`);
});
+
+test(`reconnects after the extension connection drops`, {
+ annotation: { type: 'issue', description: 'https://github.com/microsoft/playwright/issues/41874' },
+}, async ({ browserWithExtension, startClient, server }) => {
+ const browserContext = await browserWithExtension.launch();
+ const token = await readExtensionToken(browserContext);
+
+ const { client, stderr } = await startClient({
+ args: [`--extension`],
+ env: {
+ DEBUG: 'pw:mcp:backend',
+ PLAYWRIGHT_MCP_EXTENSION_TOKEN: token,
+ PWTEST_EXTENSION_USER_DATA_DIR: browserWithExtension.userDataDir,
+ },
+ });
+
+ expect(await client.callTool({
+ name: 'browser_navigate',
+ arguments: { url: server.HELLO_WORLD },
+ })).toHaveResponse({
+ snapshot: expect.stringContaining(`Hello, world!`),
+ });
+
+ // Closing the last controlled tab drops the relay WebSocket, like the MV3
+ // service worker idle timeout would.
+ await browserContext.pages().find(page => page.url() === server.HELLO_WORLD)!.close();
+
+ // Wait for the MCP server to observe the disconnect.
+ await expect.poll(() => stderr()).toContain('browser disconnected');
+
+ // The next tool call reconnects transparently; the token bypasses the dialog.
+ expect(await client.callTool({
+ name: 'browser_navigate',
+ arguments: { url: server.HELLO_WORLD },
+ })).toHaveResponse({
+ snapshot: expect.stringContaining(`Hello, world!`),
+ });
+});
diff --git a/tests/mcp/cdp.spec.ts b/tests/mcp/cdp.spec.ts
index db0b513af0..0dcafed0e7 100644
--- a/tests/mcp/cdp.spec.ts
+++ b/tests/mcp/cdp.spec.ts
@@ -130,6 +130,33 @@ test('auto-recover when remote browser disconnects mid-session', async ({ cdpSer
});
});
+test('transparently reconnects when the remote browser is restarted', async ({ cdpServer, startClient, server }) => {
+ const browserContext = await cdpServer.start();
+ const { client, stderr } = await startClient({
+ args: [`--cdp-endpoint=${cdpServer.endpoint}`],
+ env: { DEBUG: 'pw:mcp:backend' },
+ });
+
+ expect(await client.callTool({
+ name: 'browser_navigate',
+ arguments: { url: server.HELLO_WORLD },
+ })).toHaveResponse({
+ snapshot: expect.stringContaining(`Hello, world!`),
+ });
+
+ await browserContext.close();
+ await expect.poll(() => stderr()).toContain('browser disconnected');
+ await cdpServer.start();
+
+ // The very next tool call must reconnect, with no failed call in between.
+ expect(await client.callTool({
+ name: 'browser_navigate',
+ arguments: { url: server.HELLO_WORLD },
+ })).toHaveResponse({
+ snapshot: expect.stringContaining(`Hello, world!`),
+ });
+});
+
test('does not support --device', async () => {
const result = spawnSync('node', [
...mcpServerPath, '--device=Pixel 5', '--cdp-endpoint=http://localhost:1234',
diff --git a/tests/mcp/http.spec.ts b/tests/mcp/http.spec.ts
index 85dca4f877..a63fec5927 100644
--- a/tests/mcp/http.spec.ts
+++ b/tests/mcp/http.spec.ts
@@ -18,6 +18,7 @@ import fs from 'fs';
import dns from 'dns';
import { ChildProcess, spawn } from 'child_process';
+import { chromium } from 'playwright';
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { test as baseTest, expect, mcpServerPath, formatLog } from './fixtures';
@@ -158,6 +159,7 @@ test('http transport browser sigint', async ({ serverEndpoint, server }) => {
'create context': 1,
'create http session': 1,
'gracefully closing 1': 1,
+ 'close browser': 1,
});
});
@@ -235,6 +237,103 @@ test('http transport browser lifecycle (isolated, concurrent clients)', { annota
});
});
+test('http transport isolated multiclient relaunches a crashed shared browser', async ({ serverEndpoint, server }, testInfo) => {
+ // The CDP port lets the test kill the browser from the outside.
+ const port = 9400 + testInfo.workerIndex;
+ const configFile = testInfo.outputPath('config.json');
+ await fs.promises.writeFile(configFile, JSON.stringify({
+ browser: { launchOptions: { args: [`--remote-debugging-port=${port}`] } },
+ }));
+ const { url, stderr } = await serverEndpoint({
+ args: ['--isolated', `--config=${configFile}`],
+ env: { DEBUG: 'pw:mcp:test,pw:mcp:backend' },
+ });
+
+ const transport1 = new StreamableHTTPClientTransport(new URL('/mcp', url));
+ const client1 = new Client({ name: 'test', 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: 'test', version: '1.0.0' });
+ await client2.connect(transport2);
+ await client2.callTool({
+ name: 'browser_navigate',
+ arguments: { url: server.HELLO_WORLD },
+ });
+
+ // Kill the shared browser, as if it crashed, and wait for both backends
+ // to observe the disconnect.
+ const cdpBrowser = await chromium.connectOverCDP(`http://localhost:${port}`);
+ const session = await cdpBrowser.newBrowserCDPSession();
+ await session.send('Browser.close').catch(() => {});
+ await expect.poll(() => stderr().match(/browser disconnected/g)?.length).toBe(2);
+
+ // Each client transparently migrates to a fresh shared browser on its
+ // next tool call.
+ for (const client of [client1, client2]) {
+ expect(await client.callTool({
+ name: 'browser_navigate',
+ arguments: { url: server.HELLO_WORLD },
+ })).toHaveResponse({
+ snapshot: expect.stringContaining(`Hello, world!`),
+ });
+ }
+
+ await transport1.terminateSession();
+ await client1.close();
+ await transport2.terminateSession();
+ await client2.close();
+
+ await expect.poll(() => formatLog(stderr())).toEqual(({
+ 'create http session': 2,
+ 'delete http session': 2,
+ 'create browser (isolated)': 2,
+ 'create context': 4,
+ 'close browser': 2,
+ 'close context': 2,
+ }));
+});
+
+test('http transport isolated closes the browser despite an earlier failed backend creation', async ({ serverEndpoint, server }, testInfo) => {
+ // A failed backend creation must not leak the client count, otherwise the
+ // browser is never closed once the last client disconnects.
+ const storageStatePath = testInfo.outputPath('storage-state.json');
+ const { url, stderr } = await serverEndpoint({ args: ['--isolated', `--storage-state=${storageStatePath}`] });
+
+ const transport = new StreamableHTTPClientTransport(new URL('/mcp', url));
+ const client = new Client({ name: 'test', version: '1.0.0' });
+ await client.connect(transport);
+
+ // The browser launches, but context creation fails on the missing file.
+ expect((await client.callTool({
+ name: 'browser_navigate',
+ arguments: { url: server.HELLO_WORLD },
+ })).isError).toBe(true);
+
+ await fs.promises.writeFile(storageStatePath, JSON.stringify({ origins: [] }));
+ expect(await client.callTool({
+ name: 'browser_navigate',
+ arguments: { url: server.HELLO_WORLD },
+ })).toHaveResponse({
+ snapshot: expect.stringContaining(`Hello, world!`),
+ });
+
+ await transport.terminateSession();
+ await client.close();
+
+ await expect.poll(() => formatLog(stderr())).toEqual({
+ 'create http session': 1,
+ 'delete http session': 1,
+ 'create browser (isolated)': 1,
+ 'create context': 1,
+ 'close browser': 1,
+ });
+});
+
test('http transport browser lifecycle (persistent)', async ({ serverEndpoint, server }) => {
const { url, stderr } = await serverEndpoint();
diff --git a/tests/mcp/launch.spec.ts b/tests/mcp/launch.spec.ts
index c501934648..9e410e3c79 100644
--- a/tests/mcp/launch.spec.ts
+++ b/tests/mcp/launch.spec.ts
@@ -16,6 +16,8 @@
import fs from 'fs';
+import { chromium } from 'playwright';
+
import { test, expect, formatLog } from './fixtures';
test('test reopen browser', async ({ startClient, server }) => {
@@ -159,6 +161,40 @@ test('isolated context', async ({ startClient, server }) => {
});
});
+test('isolated context relaunches the browser after it dies', async ({ startClient, server, mcpBrowser }, testInfo) => {
+ test.skip(!['chrome', 'msedge', 'chromium'].includes(mcpBrowser!), 'The test kills the browser over CDP');
+
+ // The CDP port lets the test kill the browser from the outside.
+ const port = 9300 + testInfo.workerIndex;
+ const { client, stderr } = await startClient({
+ args: [`--isolated`],
+ config: { browser: { launchOptions: { args: [`--remote-debugging-port=${port}`] } } },
+ env: { DEBUG: 'pw:mcp:backend' },
+ });
+
+ expect(await client.callTool({
+ name: 'browser_navigate',
+ arguments: { url: server.HELLO_WORLD },
+ })).toHaveResponse({
+ snapshot: expect.stringContaining(`Hello, world!`),
+ });
+
+ // Kill the browser, as if it crashed.
+ const cdpBrowser = await chromium.connectOverCDP(`http://localhost:${port}`);
+ const session = await cdpBrowser.newBrowserCDPSession();
+ await session.send('Browser.close').catch(() => {});
+ await expect.poll(() => stderr()).toContain('browser disconnected');
+
+ // The very next tool call must relaunch the browser, with no failed call
+ // in between.
+ expect(await client.callTool({
+ name: 'browser_navigate',
+ arguments: { url: server.HELLO_WORLD },
+ })).toHaveResponse({
+ snapshot: expect.stringContaining(`Hello, world!`),
+ });
+});
+
test('isolated context with storage state', async ({ startClient, server }, testInfo) => {
const storageStatePath = testInfo.outputPath('storage-state.json');
await fs.promises.writeFile(storageStatePath, JSON.stringify({