Skip to content

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

chore: extract session registry (#39216)

Pavel Feldmana65b44d104d8
diff --git a/packages/playwright/package.json b/packages/playwright/package.json
index 2c60bd0b99..1bc3d12b4f 100644
--- a/packages/playwright/package.json
+++ b/packages/playwright/package.json
@@ -27,6 +27,7 @@
"./lib/mcp/sdk/bundle": "./lib/mcp/sdk/bundle.js",
"./lib/mcp/sdk/exports": "./lib/mcp/sdk/exports.js",
"./lib/mcp/terminal/program": "./lib/mcp/terminal/program.js",
+ "./lib/mcp/terminal/registry": "./lib/mcp/terminal/registry.js",
"./lib/program": "./lib/program.js",
"./lib/reporters/base": "./lib/reporters/base.js",
"./lib/reporters/list": "./lib/reporters/list.js",
diff --git a/packages/playwright/src/mcp/browser/config.ts b/packages/playwright/src/mcp/browser/config.ts
index 042e84853c..47cb5c98d3 100644
--- a/packages/playwright/src/mcp/browser/config.ts
+++ b/packages/playwright/src/mcp/browser/config.ts
@@ -26,7 +26,7 @@ import { firstRootPath } from '../sdk/server';
import type * as playwright from '../../../types/test';
import type { Config, ToolCapability } from '../config';
import type { ClientInfo } from '../sdk/server';
-import type { SessionConfig } from '../terminal/program';
+import type { SessionConfig } from '../terminal/registry';
type ViewportSize = { width: number; height: number };
diff --git a/packages/playwright/src/mcp/terminal/DEPS.list b/packages/playwright/src/mcp/terminal/DEPS.list
index e67b7fc131..9189f792d0 100644
--- a/packages/playwright/src/mcp/terminal/DEPS.list
+++ b/packages/playwright/src/mcp/terminal/DEPS.list
@@ -10,6 +10,10 @@
[program.ts]
"strict"
./socketConnection.ts
+./registry.ts
[socketConnection.ts]
"strict"
+
+[registry.ts]
+"strict"
diff --git a/packages/playwright/src/mcp/terminal/program.ts b/packages/playwright/src/mcp/terminal/program.ts
index 84e2a1c956..e94d418cf3 100644
--- a/packages/playwright/src/mcp/terminal/program.ts
+++ b/packages/playwright/src/mcp/terminal/program.ts
@@ -25,38 +25,17 @@ import net from 'net';
import os from 'os';
import path from 'path';
import { SocketConnection } from './socketConnection';
-import type { FullConfig } from '../browser/config';
+import { baseDaemonDir, Registry } from './registry';
+import type { FullConfig } from '../browser/config';
import type { Config } from '../config';
+import type { SessionConfig, ClientInfo } from './registry';
type MinimistArgs = {
_: string[];
[key: string]: any;
};
-export type SessionConfig = {
- version: string;
- socketPath: string;
- cli: {
- headed?: boolean;
- extension?: boolean;
- browser?: string;
- persistent?: boolean;
- profile?: string;
- config?: string;
- };
- userDataDirPrefix?: string;
- workspaceDir?: string;
- resolvedConfig?: FullConfig
-};
-
-type ClientInfo = {
- version: string;
- workspaceDirHash: string;
- daemonProfilesDir: string;
- workspaceDir: string | undefined;
-};
-
class Session {
readonly name: string;
private _connection: SocketConnection | undefined;
@@ -65,10 +44,10 @@ class Session {
private _config: SessionConfig;
private _clientInfo: ClientInfo;
- constructor(clientInfo: ClientInfo, name: string, options: SessionConfig) {
- this.name = name;
+ constructor(clientInfo: ClientInfo, options: SessionConfig) {
this._clientInfo = clientInfo;
this._config = options;
+ this.name = options.name;
}
config(): SessionConfig {
@@ -91,7 +70,9 @@ to restart the browser session.`);
async run(args: MinimistArgs): Promise<{ text: string }> {
this.checkCompatible();
- return await this._send('run', { args, cwd: process.cwd() });
+ const result = await this._send('run', { args, cwd: process.cwd() });
+ this.disconnect();
+ return result;
}
async stop(quiet: boolean = false): Promise<void> {
@@ -320,89 +301,12 @@ to restart the browser session.`);
}
}
-class SessionManager {
- readonly clientInfo: ClientInfo;
- readonly sessions: Map<string, Session>;
-
- private constructor(clientInfo: ClientInfo, sessions: Map<string, Session>) {
- this.clientInfo = clientInfo;
- this.sessions = sessions;
- }
-
- static async create(clientInfo: ClientInfo): Promise<SessionManager> {
- const dir = clientInfo.daemonProfilesDir;
- const sessions = new Map<string, Session>();
- const files = await fs.promises.readdir(dir).catch(() => []);
- for (const file of files) {
- if (!file.endsWith('.session'))
- continue;
- try {
- const sessionName = path.basename(file, '.session');
- const sessionConfig = await fs.promises.readFile(path.join(dir, file), 'utf-8').then(data => JSON.parse(data)) as SessionConfig;
- sessions.set(sessionName, new Session(clientInfo, sessionName, sessionConfig));
- } catch {
- }
- }
- return new SessionManager(clientInfo, sessions);
- }
-
- async open(args: MinimistArgs): Promise<void> {
- const sessionName = this._resolveSessionName(args.session);
- let session = this.sessions.get(sessionName);
- if (session)
- await session.stop(true);
-
- session = new Session(this.clientInfo, sessionName, sessionConfigFromArgs(this.clientInfo, sessionName, args));
- this.sessions.set(sessionName, session);
- await this.run(args);
- }
-
- async run(args: MinimistArgs): Promise<void> {
- const sessionName = this._resolveSessionName(args.session);
- const session = this.sessions.get(sessionName);
- if (!session) {
- console.log(`The browser '${sessionName}' is not open, please run open first`);
- console.log('');
- console.log(` playwright-cli${sessionName !== 'default' ? ` -s=${sessionName}` : ''} open [params]`);
- process.exit(1);
- }
-
- for (const globalOption of globalOptions)
- delete args[globalOption];
- const result = await session.run(args);
- console.log(result.text);
- session.disconnect();
- }
-
- async close(options: GlobalOptions): Promise<void> {
- const sessionName = this._resolveSessionName(options.session);
- const session = this.sessions.get(sessionName);
- if (!session || !await session.canConnect()) {
- console.log(`Browser '${sessionName}' is not open.`);
- return;
- }
-
- await session.stop();
- }
-
- async deleteData(options: GlobalOptions): Promise<void> {
- const sessionName = this._resolveSessionName(options.session);
- const session = this.sessions.get(sessionName);
- if (!session) {
- console.log(`No user data found for browser '${sessionName}'.`);
- return;
- }
- await session.deleteData();
- this.sessions.delete(sessionName);
- }
-
- private _resolveSessionName(sessionName?: string): string {
- if (sessionName)
- return sessionName;
- if (process.env.PLAYWRIGHT_CLI_SESSION)
- return process.env.PLAYWRIGHT_CLI_SESSION;
- return 'default';
- }
+function resolveSessionName(sessionName?: string): string {
+ if (sessionName)
+ return sessionName;
+ if (process.env.PLAYWRIGHT_CLI_SESSION)
+ return process.env.PLAYWRIGHT_CLI_SESSION;
+ return 'default';
}
function createClientInfo(packageLocation: string): ClientInfo {
@@ -435,22 +339,6 @@ function findWorkspaceDir(startDir: string): string | undefined {
return undefined;
}
-const baseDaemonDir = (() => {
- if (process.env.PLAYWRIGHT_DAEMON_SESSION_DIR)
- return process.env.PLAYWRIGHT_DAEMON_SESSION_DIR;
-
- let localCacheDir: string | undefined;
- if (process.platform === 'linux')
- localCacheDir = process.env.XDG_CACHE_HOME || path.join(os.homedir(), '.cache');
- if (process.platform === 'darwin')
- localCacheDir = path.join(os.homedir(), 'Library', 'Caches');
- if (process.platform === 'win32')
- localCacheDir = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
- if (!localCacheDir)
- throw new Error('Unsupported platform: ' + process.platform);
- return path.join(localCacheDir, 'ms-playwright', 'daemon');
-})();
-
const daemonProfilesDir = (workspaceDirHash: string) => {
return path.join(baseDaemonDir, workspaceDirHash);
};
@@ -539,39 +427,71 @@ export async function program(packageLocation: string) {
process.exit(1);
}
- const sessionManager = await SessionManager.create(clientInfo);
+ const registry = await Registry.load();
+ const sessionName = resolveSessionName(args.session);
switch (commandName) {
case 'list': {
- if (args.all)
- await listAllSessions(clientInfo);
- else
- await listSessions(sessionManager);
+ await listSessions(registry, clientInfo, args.all);
return;
}
case 'close-all': {
- const sessions = sessionManager.sessions;
- for (const session of sessions.values())
- await session.stop(true);
+ const configs = registry.configs(clientInfo);
+ for (const config of configs)
+ await new Session(clientInfo, config).stop(true);
return;
}
- case 'delete-data':
- await sessionManager.deleteData(args as GlobalOptions);
+ case 'delete-data': {
+ const config = registry.config(clientInfo, sessionName);
+ if (!config) {
+ console.log(`No user data found for browser '${sessionName}'.`);
+ return;
+ }
+ await new Session(clientInfo, config).deleteData();
return;
- case 'kill-all':
+ }
+ case 'kill-all': {
await killAllDaemons();
return;
- case 'open':
- await sessionManager.open(args);
+ }
+ case 'open': {
+ const config = registry.config(clientInfo, sessionName);
+ if (config)
+ await new Session(clientInfo, config).stop(true);
+ const session = new Session(clientInfo, sessionConfigFromArgs(clientInfo, sessionName, args));
+ for (const globalOption of globalOptions)
+ delete args[globalOption];
+ const result = await session.run(args);
+ console.log(result.text);
return;
+ }
+
case 'close':
- await sessionManager.close(args as GlobalOptions);
+ const config = registry.config(clientInfo, sessionName);
+ const session = config ? new Session(clientInfo, config) : undefined;
+ if (!session || !await session.canConnect()) {
+ console.log(`Browser '${sessionName}' is not open.`);
+ return;
+ }
+ await session.stop();
return;
case 'install':
await install(args);
return;
- default:
- await sessionManager.run(args);
+ default: {
+ const config = registry.config(clientInfo, sessionName);
+ if (!config) {
+ console.log(`The browser '${sessionName}' is not open, please run open first`);
+ console.log('');
+ console.log(` playwright-cli${sessionName !== 'default' ? ` -s=${sessionName}` : ''} open [params]`);
+ process.exit(1);
+ }
+
+ for (const globalOption of globalOptions)
+ delete args[globalOption];
+ const result = await new Session(clientInfo, config).run(args);
+ console.log(result.text);
+ }
}
}
@@ -674,6 +594,7 @@ function sessionConfigFromArgs(clientInfo: ClientInfo, sessionName: string, args
args.persistent = true;
return {
+ name: sessionName,
version: clientInfo.version,
socketPath: daemonSocketPath(clientInfo, sessionName),
cli: {
@@ -737,51 +658,23 @@ async function killAllDaemons(): Promise<void> {
console.log(`Killed ${killed} daemon process${killed === 1 ? '' : 'es'}.`);
}
-async function listSessions(sessionManager: SessionManager): Promise<void> {
- const sessions = sessionManager.sessions;
- console.log('### Browsers');
- await gcAndPrintSessions([...sessions.values()]);
-}
-
-async function listAllSessions(clientInfo: ClientInfo): Promise<void> {
- const hashes = await fs.promises.readdir(baseDaemonDir).catch(() => []);
-
- // Group sessions by workspace folder
- const sessionsByWorkspace = new Map<string, Session[]>();
- for (const hash of hashes) {
- const hashDir = path.join(baseDaemonDir, hash);
- const stat = await fs.promises.stat(hashDir).catch(() => null);
- if (!stat?.isDirectory())
- continue;
-
- const files = await fs.promises.readdir(hashDir).catch(() => []);
- for (const file of files) {
- if (!file.endsWith('.session'))
+async function listSessions(registry: Registry, clientInfo: ClientInfo, all: boolean): Promise<void> {
+ if (all) {
+ const configs = registry.configMap();
+ if (configs.size === 0) {
+ console.log('No browsers found.');
+ return;
+ }
+ for (const [workspace, list] of configs) {
+ if (!list.length)
continue;
- try {
- const sessionName = path.basename(file, '.session');
- const sessionConfig = await fs.promises.readFile(path.join(hashDir, file), 'utf-8').then(data => JSON.parse(data)) as SessionConfig;
- const session = new Session(clientInfo, sessionName, sessionConfig);
- const workspaceKey = sessionConfig.workspaceDir || '<global>';
- if (!sessionsByWorkspace.has(workspaceKey))
- sessionsByWorkspace.set(workspaceKey, []);
- sessionsByWorkspace.get(workspaceKey)!.push(session);
- } catch {
- }
+ console.log(`${workspace}:`);
+ await gcAndPrintSessions(list.map(config => new Session(clientInfo, config)));
}
- }
-
- if (sessionsByWorkspace.size === 0) {
- console.log('No browsers found.');
- return;
- }
-
- const sortedWorkspaces = [...sessionsByWorkspace.keys()].sort();
-
- for (const workspace of sortedWorkspaces) {
- const sessions = sessionsByWorkspace.get(workspace)!;
- console.log(`${workspace}:`);
- await gcAndPrintSessions(sessions);
+ } else {
+ console.log('### Browsers');
+ const configs = registry.configs(clientInfo);
+ await gcAndPrintSessions(configs.map(config => new Session(clientInfo, config)));
}
}
@@ -789,7 +682,7 @@ async function gcAndPrintSessions(sessions: Session[]) {
const running: Session[] = [];
const stopped: Session[] = [];
- for (const session of sessions.values()) {
+ for (const session of sessions) {
const canConnect = await session.canConnect();
if (canConnect) {
running.push(session);
diff --git a/packages/playwright/src/mcp/terminal/registry.ts b/packages/playwright/src/mcp/terminal/registry.ts
new file mode 100644
index 0000000000..6be8b57957
--- /dev/null
+++ b/packages/playwright/src/mcp/terminal/registry.ts
@@ -0,0 +1,115 @@
+/**
+ * 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 fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import type { FullConfig } from '../browser/config';
+
+export type ClientInfo = {
+ version: string;
+ workspaceDirHash: string;
+ daemonProfilesDir: string;
+ workspaceDir: string | undefined;
+};
+
+export type SessionConfig = {
+ name: string;
+ version: string;
+ socketPath: string;
+ cli: {
+ headed?: boolean;
+ extension?: boolean;
+ browser?: string;
+ persistent?: boolean;
+ profile?: string;
+ config?: string;
+ };
+ userDataDirPrefix?: string;
+ workspaceDir?: string;
+ resolvedConfig?: FullConfig
+};
+
+export class Registry {
+ private _configs: Map<string, SessionConfig[]>;
+
+ private constructor(configs: Map<string, SessionConfig[]>) {
+ this._configs = configs;
+ }
+
+ config(clientInfo: ClientInfo, sessionName: string): SessionConfig | undefined {
+ const key = clientInfo.workspaceDir || clientInfo.workspaceDirHash;
+ const configs = this._configs.get(key) || [];
+ return configs.find(config => config.name === sessionName);
+ }
+
+ configs(clientInfo: ClientInfo): SessionConfig[] {
+ const key = clientInfo.workspaceDir || clientInfo.workspaceDirHash;
+ return this._configs.get(key) || [];
+ }
+
+ configMap(): Map<string, SessionConfig[]> {
+ return this._configs;
+ }
+
+ static async load(): Promise<Registry> {
+ const sessions = new Map<string, SessionConfig[]>();
+ const hashDirs = await fs.promises.readdir(baseDaemonDir).catch(() => []);
+ for (const workspaceDirHash of hashDirs) {
+ const hashDir = path.join(baseDaemonDir, workspaceDirHash);
+ const stat = await fs.promises.stat(hashDir);
+ if (!stat.isDirectory())
+ continue;
+
+ const files = await fs.promises.readdir(hashDir).catch(() => []);
+ for (const file of files) {
+ if (!file.endsWith('.session'))
+ continue;
+ const fileName = path.join(hashDir, file);
+ const sessionName = path.basename(file, '.session');
+ const sessionConfig = await fs.promises.readFile(fileName, 'utf-8').then(data => JSON.parse(data)) as SessionConfig;
+ // Support for 0.1.0 where session name was not stored in the file.
+ if (!sessionConfig.name)
+ sessionConfig.name = sessionName;
+ const key = sessionConfig.workspaceDir || workspaceDirHash;
+ let list = sessions.get(key);
+ if (!list) {
+ list = [];
+ sessions.set(key, list);
+ }
+ list.push(sessionConfig);
+ }
+ }
+ return new Registry(sessions);
+ }
+}
+
+export const baseDaemonDir = (() => {
+ if (process.env.PLAYWRIGHT_DAEMON_SESSION_DIR)
+ return process.env.PLAYWRIGHT_DAEMON_SESSION_DIR;
+
+ let localCacheDir: string | undefined;
+ if (process.platform === 'linux')
+ localCacheDir = process.env.XDG_CACHE_HOME || path.join(os.homedir(), '.cache');
+ if (process.platform === 'darwin')
+ localCacheDir = path.join(os.homedir(), 'Library', 'Caches');
+ if (process.platform === 'win32')
+ localCacheDir = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+ if (!localCacheDir)
+ throw new Error('Unsupported platform: ' + process.platform);
+ return path.join(localCacheDir, 'ms-playwright', 'daemon');
+})();
diff --git a/tests/mcp/cli-isolated.spec.ts b/tests/mcp/cli-isolated.spec.ts
index 236f1e6e34..368e5d02b8 100644
--- a/tests/mcp/cli-isolated.spec.ts
+++ b/tests/mcp/cli-isolated.spec.ts
@@ -24,6 +24,7 @@ test('should not save user data by default (in-memory mode)', async ({ cli, serv
const dataDir = path.resolve(await daemonFolder(), 'ud-default-' + mcpBrowser);
expect(fs.existsSync(dataDir)).toBe(false);
expect(sessionOptions).toEqual({
+ name: 'default',
cli: {},
socketPath: expect.any(String),
userDataDirPrefix: expect.any(String),
@@ -47,6 +48,7 @@ test('should save user data with --persistent flag', async ({ cli, server, mcpBr
const dataDir = path.resolve(await daemonFolder(), 'ud-default-' + mcpBrowser);
expect(fs.existsSync(dataDir)).toBe(true);
expect(sessionOptions).toEqual({
+ name: 'default',
cli: {
persistent: true,
},
@@ -64,6 +66,7 @@ test('should use custom user data dir with --profile=<dir>', async ({ cli, serve
expect(fs.existsSync(customDir)).toBe(true);
const sessionOptions = await findDefaultSession();
expect(sessionOptions).toEqual({
+ name: 'default',
cli: {
persistent: true,
profile: customDir,