ros/playwright-mcp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'main' into vscode-client-factory

Browse Source
This commit is contained in:
Simon Knott
2025-08-12 10:19:31 +02:00
parent 0d0783be07 1fb2878271
commit 0741b8bee8
5 changed files with 105 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
src/inProcessClient.ts
View File

@@ -16,14 +16,15 @@
import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { ListRootsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
import { BrowserContextFactory } from './browserContextFactory.js';
import { BrowserServerBackend } from './browserServerBackend.js';
import { InProcessTransport } from './mcp/inProcessTransport.js';
import * as mcpServer from './mcp/server.js';
import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
import type { FullConfig } from './config.js';
import type { ClientFactory } from './mcp/proxyBackend.js';
import type { Implementation } from '@modelcontextprotocol/sdk/types.js';
export class InProcessClientFactory implements ClientFactory {
name: string;
@@ -39,10 +40,20 @@ export class InProcessClientFactory implements ClientFactory {
this._config = config;
}
async create(clientVersion: Implementation): Promise<Client> {
const client = new Client(clientVersion);
const server = mcpServer.createServer(new BrowserServerBackend(this._config, this._contextFactory), false);
await client.connect(new InProcessTransport(server));
async create(server: Server): Promise<Client> {
const client = new Client(server.getClientVersion() ?? { name: 'unknown', version: 'unknown' });
const clientCapabilities = server.getClientCapabilities();
if (clientCapabilities)
client.registerCapabilities(clientCapabilities);
if (clientCapabilities?.roots) {
client.setRequestHandler(ListRootsRequestSchema, async () => {
return await server.listRoots();
});
}
const delegate = mcpServer.createServer(new BrowserServerBackend(this._config, this._contextFactory), false);
await client.connect(new InProcessTransport(delegate));
await client.ping();
return client;
}

7
src/mcp/proxyBackend.ts
View File

@@ -23,14 +23,13 @@ import { packageJSON } from '../package.js';
import { logUnhandledError } from '../log.js';
import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
import type { Implementation } from '@modelcontextprotocol/sdk/types.js';
type NonEmptyArray<T> = [T, ...T[]];
export type ClientFactory = {
name: string;
description: string;
create(clientVersion: Implementation, options: any): Promise<Client>;
create(server: Server, options: any): Promise<Client>;
};
export type ClientFactoryList = NonEmptyArray<ClientFactory>;
@@ -43,7 +42,7 @@ export class ProxyBackend implements ServerBackend {
private _currentClient: Client | undefined;
private _contextSwitchTool: Tool<any>;
private _tools: ToolSchema<any>[] = [];
private _server?: Server;
private _server: Server | undefined;
constructor(clientFactories: ClientFactoryList) {
this._clientFactories = clientFactories;
@@ -123,7 +122,7 @@ export class ProxyBackend implements ServerBackend {
private async _setCurrentClient(factory: ClientFactory, options: any) {
await this._currentClient?.close();
this._currentClient = await factory.create(this._server!.getClientVersion()!, options);
this._currentClient = await factory.create(this._server!, options);
const tools = await this._currentClient.listTools();
this._tools = tools.tools.map(tool => ({
name: tool.name,

4
src/mcp/server.ts
View File

@@ -76,9 +76,7 @@ export function createServer(backend: ServerBackend, runHeartbeat: boolean): Ser
return { tools: tools.map(tool => ({
name: tool.name,
description: tool.description,
// TODO: we expect inputSchema to be a zod schema, but in the out-of-process case it's already a json schema.
// we should move the "zodToJsonSchema" call into defineTool.
inputSchema: tool.inputSchema.$schema ? tool.inputSchema : zodToJsonSchema(tool.inputSchema),
inputSchema: tool.inputSchema instanceof z.ZodType ? zodToJsonSchema(tool.inputSchema) : tool.inputSchema,
annotations: {
title: tool.title,
readOnlyHint: tool.type === 'readOnly',

34
tests/capabilities.spec.ts
View File

@@ -46,6 +46,40 @@ test('test snapshot tool list', async ({ client }) => {
]));
});
test('test tool list proxy mode', async ({ startClient }) => {
const { client } = await startClient({
args: ['--connect-tool'],
});
const { tools } = await client.listTools();
expect(new Set(tools.map(t => t.name))).toEqual(new Set([
'browser_click',
'browser_connect', // the extra tool
'browser_console_messages',
'browser_drag',
'browser_evaluate',
'browser_file_upload',
'browser_handle_dialog',
'browser_hover',
'browser_select_option',
'browser_type',
'browser_close',
'browser_install',
'browser_navigate_back',
'browser_navigate_forward',
'browser_navigate',
'browser_network_requests',
'browser_press_key',
'browser_resize',
'browser_snapshot',
'browser_tab_close',
'browser_tab_list',
'browser_tab_new',
'browser_tab_select',
'browser_take_screenshot',
'browser_wait_for',
]));
});
test('test capabilities (pdf)', async ({ startClient }) => {
const { client } = await startClient({
args: ['--caps=pdf'],

95
tests/roots.spec.ts
View File

@@ -23,48 +23,55 @@ import { createHash } from '../src/utils.js';
const p = process.platform === 'win32' ? 'c:\\non\\existent\\folder' : '/non/existent/folder';
test('should use separate user data by root path', async ({ startClient, server }, testInfo) => {
const { client } = await startClient({
clientName: 'Visual Studio Code', // Simulate VS Code client, roots only work with it
roots: [
{
name: 'test',
uri: 'file://' + p.replace(/\\/g, '/'),
}
],
for (const mode of ['default', 'proxy']) {
const extraArgs = mode === 'proxy' ? ['--connect-tool'] : [];
test.describe(`${mode} mode`, () => {
test('should use separate user data by root path', async ({ startClient, server }, testInfo) => {
const { client } = await startClient({
args: extraArgs,
clientName: 'Visual Studio Code', // Simulate VS Code client, roots only work with it
roots: [
{
name: 'test',
uri: 'file://' + p.replace(/\\/g, '/'),
}
],
});
await client.callTool({
name: 'browser_navigate',
arguments: { url: server.HELLO_WORLD },
});
const hash = createHash(p);
const [file] = await fs.promises.readdir(testInfo.outputPath('ms-playwright'));
expect(file).toContain(hash);
});
test('check that trace is saved in workspace', async ({ startClient, server, mcpMode }, testInfo) => {
const rootPath = testInfo.outputPath('workspace');
const { client } = await startClient({
args: ['--save-trace', ...extraArgs],
clientName: 'Visual Studio Code - Insiders', // Simulate VS Code client, roots only work with it
roots: [
{
name: 'workspace',
uri: pathToFileURL(rootPath).toString(),
},
],
});
expect(await client.callTool({
name: 'browser_navigate',
arguments: { url: server.HELLO_WORLD },
})).toHaveResponse({
code: expect.stringContaining(`page.goto('http://localhost`),
});
const [file] = await fs.promises.readdir(path.join(rootPath, '.playwright-mcp'));
expect(file).toContain('traces');
});
});
await client.callTool({
name: 'browser_navigate',
arguments: { url: server.HELLO_WORLD },
});
const hash = createHash(p);
const [file] = await fs.promises.readdir(testInfo.outputPath('ms-playwright'));
expect(file).toContain(hash);
});
test('check that trace is saved in workspace', async ({ startClient, server, mcpMode }, testInfo) => {
const rootPath = testInfo.outputPath('workspace');
const { client } = await startClient({
args: ['--save-trace'],
clientName: 'Visual Studio Code - Insiders', // Simulate VS Code client, roots only work with it
roots: [
{
name: 'workspace',
uri: pathToFileURL(rootPath).toString(),
},
],
});
expect(await client.callTool({
name: 'browser_navigate',
arguments: { url: server.HELLO_WORLD },
})).toHaveResponse({
code: expect.stringContaining(`page.goto('http://localhost`),
});
const [file] = await fs.promises.readdir(path.join(rootPath, '.playwright-mcp'));
expect(file).toContain('traces');
});
}