Skip to content

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

Revert debug controller UI additions (#37661)

Simon Knott52766b2bcba6
diff --git a/.github/workflows/tests_primary.yml b/.github/workflows/tests_primary.yml
index 07c5b40867..2cb96d9ad6 100644
--- a/.github/workflows/tests_primary.yml
+++ b/.github/workflows/tests_primary.yml
@@ -187,7 +187,7 @@ jobs:
env:
DEBUG: pw:install
- run: npm run build
- - run: npx playwright install chromium firefox
+ - run: npx playwright install chromium
- name: Checkout extension
run: git clone https://github.com/microsoft/playwright-vscode.git
- name: Print extension revision
diff --git a/packages/playwright-core/src/browserServerImpl.ts b/packages/playwright-core/src/browserServerImpl.ts
index a9b1e97ae9..0057d26ac9 100644
--- a/packages/playwright-core/src/browserServerImpl.ts
+++ b/packages/playwright-core/src/browserServerImpl.ts
@@ -26,7 +26,7 @@ import * as validatorPrimitives from './protocol/validatorPrimitives';
import { ProgressController } from './server/progress';
import type { BrowserServer, BrowserServerLauncher } from './client/browserType';
-import type { LaunchOptions, LaunchServerOptions, Logger } from './client/types';
+import type { LaunchServerOptions, Logger } from './client/types';
import type { ProtocolLogger } from './server/types';
import type { WebSocketEventEmitter } from './utilsBundle';
import type { Browser } from './server/browser';
@@ -38,7 +38,7 @@ export class BrowserServerLauncherImpl implements BrowserServerLauncher {
this._browserName = browserName;
}
- async launchServer(options: LaunchOptions & LaunchServerOptions & { _userDataDir?: string } = {}): Promise<BrowserServer> {
+ async launchServer(options: LaunchServerOptions & { _sharedBrowser?: boolean, _userDataDir?: string } = {}): Promise<BrowserServer> {
const playwright = createPlaywright({ sdkLanguage: 'javascript', isServer: true });
// 1. Pre-launch the browser
const metadata = { id: '', startTime: 0, endTime: 0, type: 'Internal', method: '', params: {}, log: [], internal: true };
@@ -78,14 +78,10 @@ export class BrowserServerLauncherImpl implements BrowserServerLauncher {
throw e;
}
- return this.launchServerOnExistingBrowser(browser, options);
- }
-
- async launchServerOnExistingBrowser(browser: Browser, options: LaunchServerOptions): Promise<BrowserServer> {
const path = options.wsPath ? (options.wsPath.startsWith('/') ? options.wsPath : `/${options.wsPath}`) : `/${createGuid()}`;
// 2. Start the server
- const server = new PlaywrightServer({ mode: options._sharedBrowser ? 'launchServerShared' : 'launchServer', path, maxConnections: Infinity, preLaunchedBrowser: browser, debugController: options._debugController });
+ const server = new PlaywrightServer({ mode: options._sharedBrowser ? 'launchServerShared' : 'launchServer', path, maxConnections: Infinity, preLaunchedBrowser: browser });
const wsEndpoint = await server.listen(options.port, options.host);
// 3. Return the BrowserServer interface
diff --git a/packages/playwright-core/src/client/browser.ts b/packages/playwright-core/src/client/browser.ts
index d112e88443..80d2ff2fb9 100644
--- a/packages/playwright-core/src/client/browser.ts
+++ b/packages/playwright-core/src/client/browser.ts
@@ -24,7 +24,7 @@ import { mkdirIfNeeded } from './fileUtils';
import type { BrowserType } from './browserType';
import type { Page } from './page';
-import type { BrowserContextOptions, LaunchOptions, LaunchServerOptions, Logger } from './types';
+import type { BrowserContextOptions, LaunchOptions, Logger } from './types';
import type * as api from '../../types/types';
import type * as channels from '@protocol/channels';
@@ -146,17 +146,6 @@ export class Browser extends ChannelOwner<channels.BrowserChannel> implements ap
return CDPSession.from((await this._channel.newBrowserCDPSession()).session);
}
- async _launchServer(options: LaunchServerOptions = {}) {
- const serverLauncher = this._browserType._serverLauncher;
- const browserImpl = this._connection.toImpl?.(this);
- if (!serverLauncher || !browserImpl)
- throw new Error('Launching server is not supported');
- return await serverLauncher.launchServerOnExistingBrowser(browserImpl, {
- _sharedBrowser: true,
- ...options,
- });
- }
-
async startTracing(page?: Page, options: { path?: string; screenshots?: boolean; categories?: string[]; } = {}) {
this._path = options.path;
await this._channel.startTracing({ ...options, page: page ? page._channel : undefined });
diff --git a/packages/playwright-core/src/client/browserType.ts b/packages/playwright-core/src/client/browserType.ts
index c0491a0715..af99f15dc7 100644
--- a/packages/playwright-core/src/client/browserType.ts
+++ b/packages/playwright-core/src/client/browserType.ts
@@ -31,11 +31,9 @@ import type { ConnectOptions, LaunchOptions, LaunchPersistentContextOptions, Lau
import type * as api from '../../types/types';
import type * as channels from '@protocol/channels';
import type { ChildProcess } from 'child_process';
-import type { Browser as BrowserImpl } from '../server/browser';
export interface BrowserServerLauncher {
- launchServer(options?: LaunchOptions & LaunchServerOptions): Promise<api.BrowserServer>;
- launchServerOnExistingBrowser(browser: BrowserImpl, options?: LaunchServerOptions): Promise<api.BrowserServer>;
+ launchServer(options?: LaunchServerOptions): Promise<api.BrowserServer>;
}
// This is here just for api generation and checking.
diff --git a/packages/playwright-core/src/client/types.ts b/packages/playwright-core/src/client/types.ts
index 5b0b10b594..48a2d71cf8 100644
--- a/packages/playwright-core/src/client/types.ts
+++ b/packages/playwright-core/src/client/types.ts
@@ -104,12 +104,10 @@ export type ConnectOptions = {
timeout?: number,
logger?: Logger,
};
-export type LaunchServerOptions = {
+export type LaunchServerOptions = LaunchOptions & {
host?: string,
port?: number,
wsPath?: string,
- _debugController?: boolean;
- _sharedBrowser?: boolean;
};
export type LaunchAndroidServerOptions = {
diff --git a/packages/playwright-core/src/protocol/validator.ts b/packages/playwright-core/src/protocol/validator.ts
index 595694d8f7..3913c0545a 100644
--- a/packages/playwright-core/src/protocol/validator.ts
+++ b/packages/playwright-core/src/protocol/validator.ts
@@ -445,16 +445,6 @@ scheme.DebugControllerSetModeRequestedEvent = tObject({
});
scheme.DebugControllerStateChangedEvent = tObject({
pageCount: tInt,
- browsers: tArray(tObject({
- id: tString,
- name: tString,
- channel: tOptional(tString),
- contexts: tArray(tObject({
- pages: tArray(tObject({
- url: tString,
- })),
- })),
- })),
});
scheme.DebugControllerSourceChangedEvent = tObject({
text: tString,
@@ -475,7 +465,6 @@ scheme.DebugControllerSetReportStateChangedParams = tObject({
});
scheme.DebugControllerSetReportStateChangedResult = tOptional(tObject({}));
scheme.DebugControllerSetRecorderModeParams = tObject({
- browserId: tOptional(tString),
mode: tEnum(['inspecting', 'recording', 'none']),
testIdAttributeName: tOptional(tString),
generateAutoExpect: tOptional(tBoolean),
@@ -490,11 +479,6 @@ scheme.DebugControllerHideHighlightParams = tOptional(tObject({}));
scheme.DebugControllerHideHighlightResult = tOptional(tObject({}));
scheme.DebugControllerResumeParams = tOptional(tObject({}));
scheme.DebugControllerResumeResult = tOptional(tObject({}));
-scheme.DebugControllerCloseBrowserParams = tObject({
- id: tString,
- reason: tOptional(tString),
-});
-scheme.DebugControllerCloseBrowserResult = tOptional(tObject({}));
scheme.DebugControllerKillParams = tOptional(tObject({}));
scheme.DebugControllerKillResult = tOptional(tObject({}));
scheme.SocksSupportInitializer = tOptional(tObject({}));
diff --git a/packages/playwright-core/src/remote/playwrightServer.ts b/packages/playwright-core/src/remote/playwrightServer.ts
index 0f5629d7d6..a22ec51bd3 100644
--- a/packages/playwright-core/src/remote/playwrightServer.ts
+++ b/packages/playwright-core/src/remote/playwrightServer.ts
@@ -39,7 +39,6 @@ type ServerOptions = {
preLaunchedBrowser?: Browser;
preLaunchedAndroidDevice?: AndroidDevice;
preLaunchedSocksProxy?: SocksProxy;
- debugController?: boolean;
};
export class PlaywrightServer {
@@ -107,19 +106,6 @@ export class PlaywrightServer {
const allowFSPaths = isExtension;
launchOptions = filterLaunchOptions(launchOptions, allowFSPaths);
- if (url.searchParams.has('debug-controller')) {
- if (!(this._options.debugController || isExtension))
- throw new Error('Debug controller is not enabled');
- return new PlaywrightConnection(
- controllerSemaphore,
- ws,
- true,
- this._playwright,
- async () => { throw new Error('shouldnt be used'); },
- id,
- );
- }
-
if (isExtension) {
const connectFilter = url.searchParams.get('connect');
if (connectFilter) {
@@ -135,6 +121,16 @@ export class PlaywrightServer {
);
}
+ if (url.searchParams.has('debug-controller')) {
+ return new PlaywrightConnection(
+ controllerSemaphore,
+ ws,
+ true,
+ this._playwright,
+ async () => { throw new Error('shouldnt be used'); },
+ id,
+ );
+ }
return new PlaywrightConnection(
reuseBrowserSemaphore,
ws,
diff --git a/packages/playwright-core/src/server/debugController.ts b/packages/playwright-core/src/server/debugController.ts
index 850ddaeed2..a9c4aafc7d 100644
--- a/packages/playwright-core/src/server/debugController.ts
+++ b/packages/playwright-core/src/server/debugController.ts
@@ -24,8 +24,6 @@ import { unsafeLocatorOrSelectorAsSelector } from '../utils/isomorphic/locatorPa
import { generateCode } from './codegen/language';
import { collapseActions } from './recorder/recorderUtils';
import { JavaScriptLanguageGenerator } from './codegen/javascript';
-import { Frame } from './frames';
-import { Page } from './page';
import type { Language } from '../utils';
import type { BrowserContext } from './browserContext';
@@ -44,8 +42,7 @@ export class DebugController extends SdkObject {
SetModeRequested: 'setModeRequested',
};
- private _reportState = false;
- private _disposeListeners = new Set<() => void>();
+ private _trackHierarchyListener: InstrumentationListener | undefined;
private _playwright: Playwright;
_sdkLanguage: Language = 'javascript';
_generateAutoExpect = false;
@@ -64,40 +61,25 @@ export class DebugController extends SdkObject {
}
setReportStateChanged(enabled: boolean) {
- if (this._reportState === enabled)
- return;
- this._reportState = enabled;
- if (enabled) {
- const listener: InstrumentationListener = {
- onPageOpen: page => {
- this._emitSnapshot(false);
- const handleNavigation = () => this._emitSnapshot(false);
- page.mainFrame().on(Frame.Events.InternalNavigation, handleNavigation);
- const dispose = () => page.mainFrame().off(Frame.Events.InternalNavigation, handleNavigation);
- this._disposeListeners.add(dispose);
- page.on(Page.Events.Close, () => this._disposeListeners.delete(dispose));
- },
+ if (enabled && !this._trackHierarchyListener) {
+ this._trackHierarchyListener = {
+ onPageOpen: () => this._emitSnapshot(false),
onPageClose: () => this._emitSnapshot(false),
- onBrowserClose: () => {
- this._emitSnapshot(false);
- },
};
- this._playwright.instrumentation.addListener(listener, null);
- this._disposeListeners.add(() => this._playwright.instrumentation.removeListener(listener));
+ this._playwright.instrumentation.addListener(this._trackHierarchyListener, null);
this._emitSnapshot(true);
- } else {
- for (const dispose of this._disposeListeners)
- dispose();
- this._disposeListeners.clear();
+ } else if (!enabled && this._trackHierarchyListener) {
+ this._playwright.instrumentation.removeListener(this._trackHierarchyListener);
+ this._trackHierarchyListener = undefined;
}
}
- async setRecorderMode(progress: Progress, params: { mode: Mode, testIdAttributeName?: string, generateAutoExpect?: boolean, browserId?: string }) {
+ async setRecorderMode(progress: Progress, params: { mode: Mode, testIdAttributeName?: string, generateAutoExpect?: boolean }) {
await progress.race(this._closeBrowsersWithoutPages());
this._generateAutoExpect = !!params.generateAutoExpect;
if (params.mode === 'none') {
- for (const recorder of await progress.race(this._allRecorders(params.browserId))) {
+ for (const recorder of await progress.race(this._allRecorders())) {
recorder.hideHighlightedSelector();
recorder.setMode('none');
}
@@ -115,14 +97,11 @@ export class DebugController extends SdkObject {
}
// Update test id attribute.
if (params.testIdAttributeName) {
- for (const page of this._playwright.allPages()) {
- if (params.browserId && page.browserContext._browser.guid !== params.browserId)
- continue;
+ for (const page of this._playwright.allPages())
page.browserContext.selectors().setTestIdAttributeName(params.testIdAttributeName);
- }
}
// Toggle the mode.
- for (const recorder of await progress.race(this._allRecorders(params.browserId))) {
+ for (const recorder of await progress.race(this._allRecorders())) {
recorder.hideHighlightedSelector();
recorder.setMode(params.mode);
}
@@ -154,13 +133,6 @@ export class DebugController extends SdkObject {
recorder.resume();
}
- async closeBrowser(progress: Progress, id: string, reason?: string) {
- const browser = this._playwright.allBrowsers().find(b => b.guid === id);
- if (!browser)
- return;
- await progress.race(browser.close({ reason }));
- }
-
kill() {
gracefullyProcessExitDoNotHang(0);
}
@@ -169,28 +141,13 @@ export class DebugController extends SdkObject {
const pageCount = this._playwright.allPages().length;
if (initial && !pageCount)
return;
- this.emit(DebugController.Events.StateChanged, {
- pageCount,
- browsers: this._playwright.allBrowsers().map(browser => ({
- id: browser.guid,
- name: browser.options.name,
- channel: browser.options.channel,
- contexts: browser.contexts().map(context => ({
- pages: context.pages().map(page => ({
- url: page.mainFrame().url(),
- }))
- }))
- }))
- });
+ this.emit(DebugController.Events.StateChanged, { pageCount });
}
- private async _allRecorders(browserId?: string): Promise<Recorder[]> {
+ private async _allRecorders(): Promise<Recorder[]> {
const contexts = new Set<BrowserContext>();
- for (const page of this._playwright.allPages()) {
- if (browserId && page.browserContext._browser.guid !== browserId)
- continue;
+ for (const page of this._playwright.allPages())
contexts.add(page.browserContext);
- }
const recorders = await Promise.all([...contexts].map(c => Recorder.forContext(c, { omitCallTracking: true })));
const nonNullRecorders = recorders.filter(Boolean) as Recorder[];
for (const recorder of recorders)
diff --git a/packages/playwright-core/src/server/dispatchers/debugControllerDispatcher.ts b/packages/playwright-core/src/server/dispatchers/debugControllerDispatcher.ts
index 28e4e93a2f..5955359257 100644
--- a/packages/playwright-core/src/server/dispatchers/debugControllerDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/debugControllerDispatcher.ts
@@ -78,10 +78,6 @@ export class DebugControllerDispatcher extends Dispatcher<DebugController, chann
this._object.kill();
}
- async closeBrowser(params: channels.DebugControllerCloseBrowserParams, progress: Progress) {
- await this._object.closeBrowser(progress, params.id, params.reason);
- }
-
override _onDispose() {
eventsHelper.removeEventListeners(this._listeners);
this._object.dispose();
diff --git a/packages/playwright-core/src/server/utils/wsServer.ts b/packages/playwright-core/src/server/utils/wsServer.ts
index 16878bdaf9..95fdd2f72c 100644
--- a/packages/playwright-core/src/server/utils/wsServer.ts
+++ b/packages/playwright-core/src/server/utils/wsServer.ts
@@ -106,13 +106,8 @@ export class WSServer {
const url = new URL('http://localhost' + (request.url || ''));
const id = String(++lastConnectionId);
debugLogger.log('server', `[${id}] serving connection: ${request.url}`);
- try {
- const connection = this._delegate.onConnection(request, url, ws, id);
- (ws as any)[kConnectionSymbol] = connection;
- } catch (error) {
- debugLogger.log('server', `[${id}] connection error: ${error}`);
- ws.close(1011, String(error));
- }
+ const connection = this._delegate.onConnection(request, url, ws, id);
+ (ws as any)[kConnectionSymbol] = connection;
});
return wsEndpoint;
diff --git a/packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts b/packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts
index b66cf30a5a..01c64d1b3b 100644
--- a/packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts
+++ b/packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts
@@ -41,7 +41,6 @@ export const methodMetainfo = new Map<string, { internal?: boolean, title?: stri
['DebugController.highlight', { internal: true, }],
['DebugController.hideHighlight', { internal: true, }],
['DebugController.resume', { internal: true, }],
- ['DebugController.closeBrowser', { internal: true, }],
['DebugController.kill', { internal: true, }],
['SocksSupport.socksConnected', { internal: true, }],
['SocksSupport.socksFailed', { internal: true, }],
diff --git a/packages/playwright/src/mcp/DEPS.list b/packages/playwright/src/mcp/DEPS.list
index 7634f18222..37011f7172 100644
--- a/packages/playwright/src/mcp/DEPS.list
+++ b/packages/playwright/src/mcp/DEPS.list
@@ -2,7 +2,6 @@
./sdk/
./browser/
./extension/
-./vscode/
[index.ts]
./sdk/
diff --git a/packages/playwright/src/mcp/program.ts b/packages/playwright/src/mcp/program.ts
index d9fad59b1a..7f7c2cf06a 100644
--- a/packages/playwright/src/mcp/program.ts
+++ b/packages/playwright/src/mcp/program.ts
@@ -22,7 +22,6 @@ import { contextFactory } from './browser/browserContextFactory';
import { ProxyBackend } from './sdk/proxyBackend';
import { BrowserServerBackend } from './browser/browserServerBackend';
import { ExtensionContextFactory } from './extension/extensionContextFactory';
-import { runVSCodeTools } from './vscode/host';
import type { Command } from 'playwright-core/lib/utilsBundle';
import type { MCPProvider } from './sdk/proxyBackend';
@@ -65,7 +64,6 @@ export function decorateCommand(command: Command, version: string) {
.option('--user-data-dir <path>', 'path to the user data directory. If not specified, a temporary directory will be created.')
.option('--viewport-size <size>', 'specify browser viewport size in pixels, for example "1280x720"', resolutionParser.bind(null, '--viewport-size'))
.addOption(new ProgramOption('--connect-tool', 'Allow to switch between different browser connection methods.').hideHelp())
- .addOption(new ProgramOption('--vscode', 'VS Code tools.').hideHelp())
.addOption(new ProgramOption('--vision', 'Legacy option, use --caps=vision instead').hideHelp())
.action(async options => {
setupExitWatchdog();
@@ -91,11 +89,6 @@ export function decorateCommand(command: Command, version: string) {
return;
}
- if (options.vscode) {
- await runVSCodeTools(config);
- return;
- }
-
if (options.connectTool) {
const providers: MCPProvider[] = [
{
diff --git a/packages/playwright/src/mcp/vscode/DEPS.list b/packages/playwright/src/mcp/vscode/DEPS.list
deleted file mode 100644
index 6e7a1c9a22..0000000000
--- a/packages/playwright/src/mcp/vscode/DEPS.list
+++ /dev/null
@@ -1,6 +0,0 @@
-[*]
-../sdk/
-../browser/config.ts
-../browser/browserServerBackend.ts
-../browser/browserContextFactory.ts
-../log.ts
diff --git a/packages/playwright/src/mcp/vscode/host.ts b/packages/playwright/src/mcp/vscode/host.ts
deleted file mode 100644
index e3c0a8916d..0000000000
--- a/packages/playwright/src/mcp/vscode/host.ts
+++ /dev/null
@@ -1,203 +0,0 @@
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import path from 'path';
-
-import * as mcpBundle from '../sdk/bundle';
-import * as mcpServer from '../sdk/server';
-import { logUnhandledError } from '../log';
-
-import { FullConfig } from '../browser/config';
-import { BrowserServerBackend } from '../browser/browserServerBackend';
-import { contextFactory } from '../browser/browserContextFactory';
-
-import type { z as zod } from 'zod';
-import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
-import type { ClientInfo, ServerBackend } from '../sdk/server';
-import type { Tool, CallToolResult, CallToolRequest } from '@modelcontextprotocol/sdk/types.js';
-import type { Browser, BrowserContext, BrowserServer } from 'playwright';
-import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
-
-const packageJSON = require('../../../package.json');
-
-const { z, zodToJsonSchema } = mcpBundle;
-
-const contextSwitchOptions = z.object({
- connectionString: z.string().optional().describe('The connection string to use to connect to the browser'),
- lib: z.string().optional().describe('The library to use for the connection'),
- debugController: z.boolean().optional().describe('Enable the debug controller')
-});
-
-class VSCodeProxyBackend implements ServerBackend {
- name = 'Playwright MCP Client Switcher';
- version = packageJSON.version;
-
- private _currentClient: Client | undefined;
- private _contextSwitchTool: Tool;
- private _clientInfo?: ClientInfo;
- private _context?: BrowserContext;
- private _browser?: Browser;
- private _browserServer?: BrowserServer;
-
- constructor(private readonly _config: FullConfig, private readonly _defaultTransportFactory: (delegate: VSCodeProxyBackend) => Promise<Transport>) {
- this._contextSwitchTool = this._defineContextSwitchTool();
- }
-
- async initialize(server: mcpServer.Server, clientInfo: ClientInfo): Promise<void> {
- this._clientInfo = clientInfo;
- const transport = await this._defaultTransportFactory(this);
- await this._setCurrentClient(transport);
- }
-
- async listTools(): Promise<Tool[]> {
- const response = await this._currentClient!.listTools();
- return [
- ...response.tools,
- this._contextSwitchTool,
- ];
- }
-
- async callTool(name: string, args: CallToolRequest['params']['arguments']): Promise<CallToolResult> {
- if (name === this._contextSwitchTool.name)
- return this._callContextSwitchTool(args as any);
- return await this._currentClient!.callTool({
- name,
- arguments: args,
- }) as CallToolResult;
- }
-
- serverClosed?(server: mcpServer.Server): void {
- void this._currentClient?.close().catch(logUnhandledError);
- }
-
- onContext(context: BrowserContext) {
- this._context = context;
- context.on('close', () => {
- this._context = undefined;
- });
- }
-
- private async _getDebugControllerURL() {
- if (!this._context)
- return;
-
- const browser = this._context.browser() as any;
- if (!browser || !browser._launchServer)
- return;
-
- if (this._browser !== browser)
- this._browserServer = undefined;
-
- if (!this._browserServer)
- this._browserServer = await browser._launchServer({ _debugController: true }) as BrowserServer;
-
- const url = new URL(this._browserServer.wsEndpoint());
- url.searchParams.set('debug-controller', '1');
- return url.toString();
- }
-
- private async _callContextSwitchTool(params: zod.infer<typeof contextSwitchOptions>): Promise<CallToolResult> {
- if (params.debugController) {
- const url = await this._getDebugControllerURL();
- const lines = [`### Result`];
- if (url) {
- lines.push(`URL: ${url}`);
- lines.push(`Version: ${packageJSON.version}`);
- } else {
- lines.push(`No open browsers.`);
- }
- return { content: [{ type: 'text', text: lines.join('\n') }] };
- }
-
- if (!params.connectionString || !params.lib) {
- const transport = await this._defaultTransportFactory(this);
- await this._setCurrentClient(transport);
- return {
- content: [{ type: 'text', text: '### Result\nSuccessfully disconnected.\n' }],
- };
- }
-
- await this._setCurrentClient(
- new mcpBundle.StdioClientTransport({
- command: process.execPath,
- cwd: process.cwd(),
- args: [
- path.join(__dirname, 'main.js'),
- JSON.stringify(this._config),
- params.connectionString,
- params.lib,
- ],
- })
- );
- return {
- content: [{ type: 'text', text: '### Result\nSuccessfully connected.\n' }],
- };
- }
-
- private _defineContextSwitchTool(): Tool {
- return {
- name: 'browser_connect',
- description: 'Do not call, this tool is used in the integration with the Playwright VS Code Extension and meant for programmatic usage only.',
- inputSchema: zodToJsonSchema(contextSwitchOptions, { strictUnions: true }) as Tool['inputSchema'],
- annotations: {
- title: 'Connect to a browser running in VS Code.',
- readOnlyHint: true,
- openWorldHint: false,
- },
- };
- }
-
- private async _setCurrentClient(transport: Transport) {
- await this._currentClient?.close();
- this._currentClient = undefined;
-
- const client = new mcpBundle.Client({ name: this._clientInfo!.name, version: this._clientInfo!.version });
- client.registerCapabilities({
- roots: {
- listRoots: true,
- },
- });
- client.setRequestHandler(mcpBundle.ListRootsRequestSchema, () => ({ roots: this._clientInfo!.roots }));
- client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));
-
- await client.connect(transport);
- this._currentClient = client;
- }
-}
-
-export async function runVSCodeTools(config: FullConfig) {
- const serverBackendFactory: mcpServer.ServerBackendFactory = {
- name: 'Playwright w/ vscode',
- nameInConfig: 'playwright-vscode',
- version: packageJSON.version,
- create: () => new VSCodeProxyBackend(
- config,
- delegate => mcpServer.wrapInProcess(
- new BrowserServerBackend(config,
- {
- async createContext(clientInfo, abortSignal, toolName) {
- const context = await contextFactory(config).createContext(clientInfo, abortSignal, toolName);
- delegate.onContext(context.browserContext);
- return context;
- },
- }
- )
- )
- )
- };
- await mcpServer.start(serverBackendFactory, config.server);
- return;
-}
diff --git a/packages/playwright/src/mcp/vscode/main.ts b/packages/playwright/src/mcp/vscode/main.ts
deleted file mode 100644
index 67ca6a3ac8..0000000000
--- a/packages/playwright/src/mcp/vscode/main.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import * as mcpBundle from '../sdk/bundle';
-import * as mcpServer from '../sdk/server';
-import { BrowserServerBackend } from '../browser/browserServerBackend';
-import { BrowserContextFactory } from '../browser/browserContextFactory';
-
-import type { FullConfig } from '../browser/config';
-import type { BrowserContext } from 'playwright-core';
-import type { ClientInfo } from '../sdk/server';
-
-class VSCodeBrowserContextFactory implements BrowserContextFactory {
- name = 'vscode';
- description = 'Connect to a browser running in the Playwright VS Code extension';
-
- constructor(private _config: FullConfig, private _playwright: typeof import('playwright'), private _connectionString: string) {}
-
- async createContext(clientInfo: ClientInfo, abortSignal: AbortSignal): Promise<{ browserContext: BrowserContext; close: () => Promise<void>; }> {
- let launchOptions: any = this._config.browser.launchOptions;
- if (this._config.browser.userDataDir) {
- launchOptions = {
- ...launchOptions,
- ...this._config.browser.contextOptions,
- userDataDir: this._config.browser.userDataDir,
- };
- }
- const connectionString = new URL(this._connectionString);
- connectionString.searchParams.set('launch-options', JSON.stringify(launchOptions));
-
- const browserType = this._playwright.chromium; // it could also be firefox or webkit, we just need some browser type to call `connect` on
- const browser = await browserType.connect(connectionString.toString());
-
- const context = browser.contexts()[0] ?? await browser.newContext(this._config.browser.contextOptions);
-
- return {
- browserContext: context,
- close: async () => {
- await browser.close();
- }
- };
- }
-}
-
-async function main(config: FullConfig, connectionString: string, lib: string) {
- const playwright = await import(lib).then(mod => mod.default ?? mod);
- const factory = new VSCodeBrowserContextFactory(config, playwright, connectionString);
- await mcpServer.connect(
- {
- name: 'Playwright MCP',
- nameInConfig: 'playwright-vscode',
- create: () => new BrowserServerBackend(config, factory),
- version: 'unused'
- },
- new mcpBundle.StdioServerTransport(),
- false
- );
-}
-
-void (async () => {
- await main(
- JSON.parse(process.argv[2]),
- process.argv[3],
- process.argv[4]
- );
-})();
diff --git a/packages/protocol/src/channels.d.ts b/packages/protocol/src/channels.d.ts
index a025e267d9..a3bcb262fa 100644
--- a/packages/protocol/src/channels.d.ts
+++ b/packages/protocol/src/channels.d.ts
@@ -743,7 +743,6 @@ export interface DebugControllerChannel extends DebugControllerEventTarget, Chan
highlight(params: DebugControllerHighlightParams, progress?: Progress): Promise<DebugControllerHighlightResult>;
hideHighlight(params?: DebugControllerHideHighlightParams, progress?: Progress): Promise<DebugControllerHideHighlightResult>;
resume(params?: DebugControllerResumeParams, progress?: Progress): Promise<DebugControllerResumeResult>;
- closeBrowser(params: DebugControllerCloseBrowserParams, progress?: Progress): Promise<DebugControllerCloseBrowserResult>;
kill(params?: DebugControllerKillParams, progress?: Progress): Promise<DebugControllerKillResult>;
}
export type DebugControllerInspectRequestedEvent = {
@@ -756,16 +755,6 @@ export type DebugControllerSetModeRequestedEvent = {
};
export type DebugControllerStateChangedEvent = {
pageCount: number,
- browsers: {
- id: string,
- name: string,
- channel?: string,
- contexts: {
- pages: {
- url: string,
- }[],
- }[],
- }[],
};
export type DebugControllerSourceChangedEvent = {
text: string,
@@ -792,13 +781,11 @@ export type DebugControllerSetReportStateChangedOptions = {
};
export type DebugControllerSetReportStateChangedResult = void;
export type DebugControllerSetRecorderModeParams = {
- browserId?: string,
mode: 'inspecting' | 'recording' | 'none',
testIdAttributeName?: string,
generateAutoExpect?: boolean,
};
export type DebugControllerSetRecorderModeOptions = {
- browserId?: string,
testIdAttributeName?: string,
generateAutoExpect?: boolean,
};
@@ -818,14 +805,6 @@ export type DebugControllerHideHighlightResult = void;
export type DebugControllerResumeParams = {};
export type DebugControllerResumeOptions = {};
export type DebugControllerResumeResult = void;
-export type DebugControllerCloseBrowserParams = {
- id: string,
- reason?: string,
-};
-export type DebugControllerCloseBrowserOptions = {
- reason?: string,
-};
-export type DebugControllerCloseBrowserResult = void;
export type DebugControllerKillParams = {};
export type DebugControllerKillOptions = {};
export type DebugControllerKillResult = void;
diff --git a/packages/protocol/src/protocol.yml b/packages/protocol/src/protocol.yml
index 1eee2e08f1..d0b79ba72a 100644
--- a/packages/protocol/src/protocol.yml
+++ b/packages/protocol/src/protocol.yml
@@ -896,7 +896,6 @@ DebugController:
setRecorderMode:
internal: true
parameters:
- browserId: string?
mode:
type: enum
literals:
@@ -918,12 +917,6 @@ DebugController:
resume:
internal: true
- closeBrowser:
- internal: true
- parameters:
- id: string
- reason: string?
-
kill:
internal: true
@@ -941,25 +934,6 @@ DebugController:
stateChanged:
parameters:
pageCount: int
- browsers:
- type: array
- items:
- type: object
- properties:
- id: string
- name: string
- channel: string?
- contexts:
- type: array
- items:
- type: object
- properties:
- pages:
- type: array
- items:
- type: object
- properties:
- url: string
sourceChanged:
parameters:
diff --git a/tests/config/debugControllerBackend.ts b/tests/config/debugControllerBackend.ts
index 5b927e53ca..9f67d44e50 100644
--- a/tests/config/debugControllerBackend.ts
+++ b/tests/config/debugControllerBackend.ts
@@ -153,8 +153,6 @@ export class Backend extends EventEmitter {
}
private _send(method: string, params: any = {}): Promise<any> {
- if (this._transport.isClosed())
- throw new Error('Transport is closed');
return new Promise((fulfill, reject) => {
const id = ++Backend._lastId;
const command = { id, guid: 'DebugController', method, params, metadata: {} };
diff --git a/tests/config/remote-server-impl.js b/tests/config/remote-server-impl.js
index e77ed89395..baf6d946b9 100644
--- a/tests/config/remote-server-impl.js
+++ b/tests/config/remote-server-impl.js
@@ -2,8 +2,7 @@ const fs = require('fs');
const cluster = require('cluster');
async function start() {
- /** @type {import("./remoteServer").RemoteServerOptions} */
- const { browserTypeName, launchOptions, stallOnClose, disconnectOnSIGHUP, exitOnFile, exitOnWarning, startStopAndRunHttp, existingBrowser } = JSON.parse(process.argv[2]);
+ const { browserTypeName, launchOptions, stallOnClose, disconnectOnSIGHUP, exitOnFile, exitOnWarning, startStopAndRunHttp } = JSON.parse(process.argv[2]);
if (stallOnClose) {
launchOptions.__testHookGracefullyClose = () => {
console.log(`(stalled=>true)`);
@@ -26,15 +25,7 @@ async function start() {
return;
}
- let browserServer;
- if (existingBrowser) {
- const browser = await playwright[browserTypeName].launch(launchOptions);
- const page = await browser.newPage();
- await page.setContent(existingBrowser.content);
- browserServer = await browser._launchServer();
- } else {
- browserServer = await playwright[browserTypeName].launchServer(launchOptions);
- }
+ const browserServer = await playwright[browserTypeName].launchServer(launchOptions);
if (disconnectOnSIGHUP)
process.on('SIGHUP', () => browserServer._disconnectForTest());
diff --git a/tests/config/remoteServer.ts b/tests/config/remoteServer.ts
index 2e9ec35d2a..4c25934581 100644
--- a/tests/config/remoteServer.ts
+++ b/tests/config/remoteServer.ts
@@ -69,7 +69,6 @@ export type RemoteServerOptions = {
url?: string;
startStopAndRunHttp?: boolean;
sharedBrowser?: boolean;
- existingBrowser?: { content: string };
};
export class RemoteServer implements PlaywrightServer {
diff --git a/tests/library/browsertype-connect.spec.ts b/tests/library/browsertype-connect.spec.ts
index a94786753a..31ac7171a4 100644
--- a/tests/library/browsertype-connect.spec.ts
+++ b/tests/library/browsertype-connect.spec.ts
@@ -1048,14 +1048,6 @@ test.describe('launchServer only', () => {
const browser = await connect(remoteServer.wsEndpoint()) as any;
await expect(browser._parent.launch({ timeout: 0 })).rejects.toThrowError('Launching more browsers is not allowed.');
});
-
- test('should work with existing browser', async ({ connect, startRemoteServer, mode }) => {
- test.skip(mode === 'driver', 'Driver mode does not support browserType.launchServer');
- const remoteServer = await startRemoteServer('launchServer', { existingBrowser: { content: 'hello world' } });
- const browser = await connect(remoteServer.wsEndpoint());
- const page = browser.contexts()[0].pages()[0];
- expect(await page.content()).toContain('hello world');
- });
});
test('should refuse connecting when versions do not match', async ({ connect, childProcess }) => {
diff --git a/tests/library/debug-controller.spec.ts b/tests/library/debug-controller.spec.ts
index 8109e4171a..9159eaad66 100644
--- a/tests/library/debug-controller.spec.ts
+++ b/tests/library/debug-controller.spec.ts
@@ -34,7 +34,7 @@ const test = baseTest.extend<Fixtures>({
wsEndpoint: async ({ headless }, use) => {
if (headless)
process.env.PW_DEBUG_CONTROLLER_HEADLESS = '1';
- const server = new PlaywrightServer({ mode: 'default', path: '/' + createGuid(), maxConnections: Number.MAX_VALUE, enableSocksProxy: false, debugController: true });
+ const server = new PlaywrightServer({ mode: 'extension', path: '/' + createGuid(), maxConnections: Number.MAX_VALUE, enableSocksProxy: false });
const wsEndpoint = await server.listen();
await use(wsEndpoint);
await server.close();
@@ -111,31 +111,7 @@ test('should pick element', async ({ backend, connectedBrowser }) => {
expect(events).toHaveLength(2);
});
-test('should allow setting recorder mode only for specific browser', async ({ backend, connectedBrowserFactory }) => {
- const events = [];
- backend.on('inspectRequested', event => events.push(event));
-
- const browser1 = await connectedBrowserFactory();
- const browser2 = await connectedBrowserFactory();
- expect((browser1 as any)._guid).not.toBe((browser2 as any)._guid);
- const page1 = await browser1.newPage();
- await page1.setContent('<button>Submit</button>');
- const page2 = await browser2.newPage();
- await page2.setContent('<button>Submit</button>');
-
- await backend.setRecorderMode({ mode: 'inspecting', browserId: (browser1 as any)._guid });
- await page1.getByRole('button').click();
- expect(events).toHaveLength(1);
-
- await page2.getByRole('button').click();
- expect(events).toHaveLength(1);
-
- await backend.setRecorderMode({ mode: 'inspecting', browserId: (browser2 as any)._guid });
- await page2.getByRole('button').click();
- expect(events).toHaveLength(2);
-});
-
-test('should report pages', async ({ backend, connectedBrowser, browserName, channel }) => {
+test('should report pages', async ({ backend, connectedBrowser }) => {
const events = [];
backend.on('stateChanged', event => events.push(event));
await backend.setReportStateChanged({ enabled: true });
@@ -144,7 +120,6 @@ test('should report pages', async ({ backend, connectedBrowser, browserName, cha
const page1 = await context.newPage();
const page2 = await context.newPage();
await page1.close();
- await page2.goto('data:text/html,Foo');
await page2.close();
await backend.setReportStateChanged({ enabled: false });
@@ -154,63 +129,12 @@ test('should report pages', async ({ backend, connectedBrowser, browserName, cha
expect(events).toEqual([
{
pageCount: 1,
- browsers: [{
- id: (connectedBrowser as any)._guid,
- name: browserName,
- channel,
- contexts: [{
- pages: [
- { url: 'about:blank' }
- ]
- }]
- }]
}, {
pageCount: 2,
- browsers: [{
- id: (connectedBrowser as any)._guid,
- name: browserName,
- channel,
- contexts: [{
- pages: [
- { url: 'about:blank' },
- { url: 'about:blank' }
- ]
- }]
- }]
- }, {
- pageCount: 1,
- browsers: [{
- id: (connectedBrowser as any)._guid,
- name: browserName,
- channel,
- contexts: [{
- pages: [
- { url: 'about:blank' }
- ]
- }]
- }]
}, {
pageCount: 1,
- browsers: [{
- id: (connectedBrowser as any)._guid,
- name: browserName,
- channel,
- contexts: [{
- pages: [
- { url: 'data:text/html,Foo' }
- ]
- }]
- }]
}, {
pageCount: 0,
- browsers: [{
- id: (connectedBrowser as any)._guid,
- name: browserName,
- channel,
- contexts: [{
- pages: []
- }]
- }]
}
]);
});
@@ -388,53 +312,3 @@ test('should report error in aria template', async ({ backend }) => {
const error = await backend.highlight({ ariaTemplate: `- button "Submit` }).catch(e => e);
expect(error.message).toContain('Unterminated string:');
});
-
-test('should work with browser._launchServer', async ({ browserType }) => {
- const browser = await browserType.launch();
- const server = await (browser as any)._launchServer({ _debugController: true });
-
- const backend = new Backend();
- const connectionString = new URL(server.wsEndpoint());
- connectionString.searchParams.set('debug-controller', '');
- await backend.connect(connectionString.toString());
- await backend.initialize();
- await backend.channel.setReportStateChanged({ enabled: true });
- const pageCounts: number[] = [];
- backend.channel.on('stateChanged', event => pageCounts.push(event.pageCount));
-
- const page = await browser.newPage();
- await page.close();
- // this test shares an instance of Playwright with other tests, so we can't assert on the precise number of pages
- expect(pageCounts.length).toBeGreaterThanOrEqual(2);
-
- await server.close();
- await browser.close();
-});
-
-test('should not work with browser._launchServer(_debugController: false)', async ({ browserType }) => {
- const browser = await browserType.launch();
- const server = await (browser as any)._launchServer({ _debugController: false });
-
- const backend = new Backend();
- const connectionString = new URL(server.wsEndpoint());
- connectionString.searchParams.set('debug-controller', '');
- await expect(async () => {
- await backend.connect(connectionString.toString());
- await backend.initialize();
- }).rejects.toThrow();
-
- await server.close();
- await browser.close();
-});
-
-test('should support closing browsers', async ({ backend, connectedBrowser }) => {
- const events: channels.DebugControllerStateChangedEvent[] = [];
- backend.on('stateChanged', event => events.push(event));
- await backend.setReportStateChanged({ enabled: true });
- await connectedBrowser.newPage();
-
- await backend.closeBrowser({ id: (connectedBrowser as any)._guid, reason: 'some reason' });
- await expect.poll(() => connectedBrowser.isConnected()).toBe(false);
-
- await expect.poll(() => events[events.length - 1]?.browsers).toEqual([]);
-});
diff --git a/tests/mcp/vscode.spec.ts b/tests/mcp/vscode.spec.ts
deleted file mode 100644
index fc0b8187e8..0000000000
--- a/tests/mcp/vscode.spec.ts
+++ /dev/null
@@ -1,120 +0,0 @@
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { test, expect } from './fixtures';
-import { pathToFileURL } from 'node:url';
-
-test('browser_connect(vscode) works', async ({ startClient, playwright, browserName }) => {
- const { client } = await startClient({
- args: ['--vscode'],
- });
-
- const server = await playwright[browserName].launchServer();
-
- expect(await client.callTool({
- name: 'browser_connect',
- arguments: {
- connectionString: server.wsEndpoint(),
- lib: pathToFileURL(require.resolve('playwright')),
- }
- })).toHaveResponse({
- result: 'Successfully connected.'
- });
-
- expect(await client.callTool({
- name: 'browser_navigate',
- arguments: {
- url: 'data:text/html,foo'
- }
- })).toHaveResponse({
- pageState: expect.stringContaining('foo'),
- });
-
- await server.close();
-
- expect(await client.callTool({
- name: 'browser_snapshot',
- arguments: {}
- }), 'it actually used the server').toHaveResponse({
- isError: true,
- result: expect.stringContaining('ECONNREFUSED')
- });
-});
-
-test('browser_connect(debugController) works', async ({ startClient }) => {
- test.skip(!globalThis.WebSocket, 'WebSocket is not supported in this environment');
-
- const { client } = await startClient({
- args: ['--vscode'],
- });
-
- expect(await client.callTool({
- name: 'browser_connect',
- arguments: {
- debugController: true,
- }
- })).toHaveResponse({
- result: 'No open browsers.'
- });
-
- expect(await client.callTool({
- name: 'browser_navigate',
- arguments: {
- url: 'data:text/html,foo'
- }
- })).toHaveResponse({
- pageState: expect.stringContaining('foo'),
- });
-
- const response = await client.callTool({
- name: 'browser_connect',
- arguments: {
- debugController: true,
- }
- });
- expect(response.content?.[0].text).toMatch(/Version: \d+\.\d+\.\d+/);
- const url = new URL(response.content?.[0].text.match(/URL: (.*)/)?.[1]);
- const messages: unknown[] = [];
- const socket = new WebSocket(url);
- socket.onmessage = event => {
- messages.push(JSON.parse(event.data));
- };
- await new Promise((resolve, reject) => {
- socket.onopen = resolve;
- socket.onerror = reject;
- });
-
- socket.send(JSON.stringify({
- id: '1',
- guid: 'DebugController',
- method: 'setReportStateChanged',
- params: {
- enabled: true,
- },
- metadata: {},
- }));
-
- expect(await client.callTool({
- name: 'browser_navigate',
- arguments: {
- url: 'data:text/html,bar'
- }
- })).toHaveResponse({
- pageState: expect.stringContaining('bar'),
- });
-
- await expect.poll(() => messages).toContainEqual(expect.objectContaining({ method: 'stateChanged' }));
-});