Skip to content

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

chore(mcp): run relay server on 127.0.0.1 only (#38626)

Yury Semikhatskyf0a3affc2127
diff --git a/.github/workflows/tests_mcp.yml b/.github/workflows/tests_mcp.yml
index d068bf9faa..b38e3ad86a 100644
--- a/.github/workflows/tests_mcp.yml
+++ b/.github/workflows/tests_mcp.yml
@@ -23,7 +23,7 @@ env:
# Force terminal colors. @see https://www.npmjs.com/package/colors
FORCE_COLOR: 1
ELECTRON_SKIP_BINARY_DOWNLOAD: 1
- PWDEBUGIMPL=1
+ PWDEBUGIMPL: 1
DEBUG: pw:mcp:error
jobs:
diff --git a/packages/playwright-core/src/server/utils/httpServer.ts b/packages/playwright-core/src/server/utils/httpServer.ts
index 0fd977f3c0..92a46aac17 100644
--- a/packages/playwright-core/src/server/utils/httpServer.ts
+++ b/packages/playwright-core/src/server/utils/httpServer.ts
@@ -20,8 +20,7 @@ import path from 'path';
import { mime, wsServer } from '../../utilsBundle';
import { createGuid } from './crypto';
import { assert } from '../../utils/isomorphic/assert';
-import { ManualPromise } from '../../utils/isomorphic/manualPromise';
-import { createHttpServer } from './network';
+import { createHttpServer, startHttpServer } from './network';
import type http from 'http';
@@ -64,22 +63,6 @@ export class HttpServer {
return this._port;
}
- private async _tryStart(port: number | undefined, host: string) {
- const errorPromise = new ManualPromise();
- const errorListener = (error: Error) => errorPromise.reject(error);
- this._server.on('error', errorListener);
-
- try {
- this._server.listen(port, host);
- await Promise.race([
- new Promise(cb => this._server!.once('listening', cb)),
- errorPromise,
- ]);
- } finally {
- this._server.removeListener('error', errorListener);
- }
- }
-
createWebSocket(transport: Transport, guid?: string) {
assert(!this._wsGuid, 'can only create one main websocket transport per server');
this._wsGuid = guid || createGuid();
@@ -110,17 +93,17 @@ export class HttpServer {
assert(!this._started, 'server already started');
this._started = true;
- const host = options.host || 'localhost';
+ const host = options.host;
if (options.preferredPort) {
try {
- await this._tryStart(options.preferredPort, host);
+ await startHttpServer(this._server, { port: options.preferredPort, host });
} catch (e) {
if (!e || !e.message || !e.message.includes('EADDRINUSE'))
throw e;
- await this._tryStart(undefined, host);
+ await startHttpServer(this._server, { host });
}
} else {
- await this._tryStart(options.port, host);
+ await startHttpServer(this._server, { port: options.port, host });
}
const address = this._server.address();
@@ -158,7 +141,7 @@ export class HttpServer {
}
}
- _serveFile(response: http.ServerResponse, absoluteFilePath: string) {
+ private _serveFile(response: http.ServerResponse, absoluteFilePath: string) {
const content = fs.readFileSync(absoluteFilePath);
response.statusCode = 200;
const contentType = mime.getType(path.extname(absoluteFilePath)) || 'application/octet-stream';
@@ -167,7 +150,7 @@ export class HttpServer {
response.end(content);
}
- _serveRangeFile(request: http.IncomingMessage, response: http.ServerResponse, absoluteFilePath: string) {
+ private _serveRangeFile(request: http.IncomingMessage, response: http.ServerResponse, absoluteFilePath: string) {
const range = request.headers.range;
if (!range || !range.startsWith('bytes=') || range.includes(', ') || [...range].filter(char => char === '-').length !== 1) {
response.statusCode = 400;
diff --git a/packages/playwright-core/src/server/utils/network.ts b/packages/playwright-core/src/server/utils/network.ts
index 27cf4cd7e0..1aea7f6d7b 100644
--- a/packages/playwright-core/src/server/utils/network.ts
+++ b/packages/playwright-core/src/server/utils/network.ts
@@ -193,6 +193,22 @@ export function createHttp2Server(...args: any[]): http2.Http2SecureServer {
return server;
}
+export async function startHttpServer(server: http.Server, options: { host?: string, port?: number }) {
+ const { host = 'localhost', port = 0 } = options;
+ const errorPromise = new ManualPromise();
+ const errorListener = (error: Error) => errorPromise.reject(error);
+ server.on('error', errorListener);
+ try {
+ server.listen(port, host);
+ await Promise.race([
+ new Promise(cb => server.once('listening', cb)),
+ errorPromise,
+ ]);
+ } finally {
+ server.removeListener('error', errorListener);
+ }
+}
+
export async function isURLAvailable(url: URL, ignoreHTTPSErrors: boolean, onLog?: (data: string) => void, onStdErr?: (data: string) => void) {
let statusCode = await httpStatusCode(url, ignoreHTTPSErrors, onLog, onStdErr);
if (statusCode === 404 && url.pathname === '/') {
diff --git a/packages/playwright/src/mcp/extension/cdpRelay.ts b/packages/playwright/src/mcp/extension/cdpRelay.ts
index b2258d70ef..4bcbb8cbcb 100644
--- a/packages/playwright/src/mcp/extension/cdpRelay.ts
+++ b/packages/playwright/src/mcp/extension/cdpRelay.ts
@@ -29,7 +29,7 @@ import { debug, ws, wsServer } from 'playwright-core/lib/utilsBundle';
import { registry } from 'playwright-core/lib/server/registry/index';
import { ManualPromise } from 'playwright-core/lib/utils';
-import { httpAddressToString } from '../sdk/http';
+import { addressToString } from '../sdk/http';
import { logUnhandledError } from '../log';
import * as protocol from './protocol';
@@ -76,7 +76,7 @@ export class CDPRelayServer {
private _extensionConnectionPromise!: ManualPromise<void>;
constructor(server: http.Server, browserChannel: string, userDataDir?: string, executablePath?: string) {
- this._wsHost = httpAddressToString(server.address()).replace(/^http/, 'ws');
+ this._wsHost = addressToString(server.address(), { protocol: 'ws' });
this._browserChannel = browserChannel;
this._userDataDir = userDataDir;
this._executablePath = executablePath;
diff --git a/packages/playwright/src/mcp/extension/extensionContextFactory.ts b/packages/playwright/src/mcp/extension/extensionContextFactory.ts
index a3b9d54e94..c6bc1cb51f 100644
--- a/packages/playwright/src/mcp/extension/extensionContextFactory.ts
+++ b/packages/playwright/src/mcp/extension/extensionContextFactory.ts
@@ -16,8 +16,8 @@
import * as playwright from 'playwright-core';
import { debug } from 'playwright-core/lib/utilsBundle';
+import { createHttpServer, startHttpServer } from 'playwright-core/lib/utils';
-import { startHttpServer } from '../sdk/http';
import { CDPRelayServer } from './cdpRelay';
import type { BrowserContextFactory } from '../browser/browserContextFactory';
@@ -54,7 +54,10 @@ export class ExtensionContextFactory implements BrowserContextFactory {
}
private async _startRelay(abortSignal: AbortSignal) {
- const httpServer = await startHttpServer({});
+ const httpServer = createHttpServer();
+ // Listen to the loopback interface only. The extension will disallow
+ // connections to other hosts anyway.
+ await startHttpServer(httpServer, {});
if (abortSignal.aborted) {
httpServer.close();
throw new Error(abortSignal.reason);
diff --git a/packages/playwright/src/mcp/sdk/http.ts b/packages/playwright/src/mcp/sdk/http.ts
index 72ca99236b..63402c9fdd 100644
--- a/packages/playwright/src/mcp/sdk/http.ts
+++ b/packages/playwright/src/mcp/sdk/http.ts
@@ -21,6 +21,7 @@ import crypto from 'crypto';
import { debug } from 'playwright-core/lib/utilsBundle';
import * as mcpBundle from 'playwright-core/lib/mcpBundle';
+import { createHttpServer, startHttpServer } from 'playwright-core/lib/utils';
import * as mcpServer from './server';
@@ -30,41 +31,34 @@ import type { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/se
const testDebug = debug('pw:mcp:test');
-export async function startHttpServer(config: { host?: string, port?: number }, abortSignal?: AbortSignal): Promise<http.Server> {
- const { host, port } = config;
- const httpServer = http.createServer();
- decorateServer(httpServer);
- await new Promise<void>((resolve, reject) => {
- httpServer.on('error', reject);
- abortSignal?.addEventListener('abort', () => {
- httpServer.close();
- reject(new Error('Aborted'));
- });
- httpServer.listen(port, host, () => {
- resolve();
- httpServer.removeListener('error', reject);
- });
- });
- return httpServer;
+export async function startMcpHttpServer(
+ config: { host?: string, port?: number },
+ serverBackendFactory: ServerBackendFactory,
+ allowedHosts?: string[]
+): Promise<string> {
+ const httpServer = createHttpServer();
+ await startHttpServer(httpServer, config);
+ return await installHttpTransport(httpServer, serverBackendFactory, allowedHosts);
}
-export function httpAddressToString(address: string | net.AddressInfo | null): string {
+export function addressToString(address: string | net.AddressInfo | null, options: {
+ protocol: 'http' | 'ws';
+ normalizeLoopback?: boolean;
+}): string {
assert(address, 'Could not bind server socket');
if (typeof address === 'string')
- return address;
- const resolvedPort = address.port;
- let resolvedHost = address.family === 'IPv4' ? address.address : `[${address.address}]`;
- if (resolvedHost === '0.0.0.0' || resolvedHost === '[::]')
- resolvedHost = 'localhost';
- return `http://${resolvedHost}:${resolvedPort}`;
+ throw new Error('Unexpected address type: ' + address);
+ let host = address.family === 'IPv4' ? address.address : `[${address.address}]`;
+ if (options.normalizeLoopback && (host === '0.0.0.0' || host === '[::]' || host === '[::1]' || host === '127.0.0.1'))
+ host = 'localhost';
+ return `${options.protocol}://${host}:${address.port}`;
}
-export async function installHttpTransport(httpServer: http.Server, serverBackendFactory: ServerBackendFactory, unguessableUrl: boolean, allowedHosts?: string[]) {
- const url = httpAddressToString(httpServer.address());
+async function installHttpTransport(httpServer: http.Server, serverBackendFactory: ServerBackendFactory, allowedHosts?: string[]) {
+ const url = addressToString(httpServer.address(), { protocol: 'http', normalizeLoopback: true });
const host = new URL(url).host;
allowedHosts = (allowedHosts || [host]).map(h => h.toLowerCase());
const allowAnyHost = allowedHosts.includes('*');
- const pathPrefix = unguessableUrl ? `/${crypto.randomUUID()}` : '';
const sseSessions = new Map();
const streamableSessions = new Map();
@@ -84,13 +78,7 @@ export async function installHttpTransport(httpServer: http.Server, serverBacken
}
}
- if (!req.url?.startsWith(pathPrefix)) {
- res.statusCode = 404;
- return res.end('Not found');
- }
-
- const path = req.url?.slice(pathPrefix.length);
- const url = new URL(`http://localhost${path}`);
+ const url = new URL(`http://localhost${req.url}`);
if (url.pathname === '/killkillkill' && req.method === 'GET') {
res.statusCode = 200;
res.end('Killing process');
@@ -104,7 +92,7 @@ export async function installHttpTransport(httpServer: http.Server, serverBacken
await handleStreamable(serverBackendFactory, req, res, streamableSessions);
});
- return `${url}${pathPrefix}`;
+ return url;
}
async function handleSSE(serverBackendFactory: ServerBackendFactory, req: http.IncomingMessage, res: http.ServerResponse, url: URL, sessions: Map<string, SSEServerTransport>) {
@@ -174,19 +162,3 @@ async function handleStreamable(serverBackendFactory: ServerBackendFactory, req:
res.statusCode = 400;
res.end('Invalid request');
}
-
-function decorateServer(server: net.Server) {
- const sockets = new Set<net.Socket>();
- server.on('connection', socket => {
- sockets.add(socket);
- socket.once('close', () => sockets.delete(socket));
- });
-
- const close = server.close;
- server.close = (callback?: (err?: Error) => void) => {
- for (const socket of sockets)
- socket.destroy();
- sockets.clear();
- return close.call(server, callback);
- };
-}
diff --git a/packages/playwright/src/mcp/sdk/server.ts b/packages/playwright/src/mcp/sdk/server.ts
index aeeb652b0b..596edf427e 100644
--- a/packages/playwright/src/mcp/sdk/server.ts
+++ b/packages/playwright/src/mcp/sdk/server.ts
@@ -19,7 +19,7 @@ import { fileURLToPath } from 'url';
import { debug } from 'playwright-core/lib/utilsBundle';
import * as mcpBundle from 'playwright-core/lib/mcpBundle';
-import { installHttpTransport, startHttpServer } from './http';
+import { startMcpHttpServer } from './http';
import { InProcessTransport } from './inProcessTransport';
import type { Tool, CallToolResult, CallToolRequest, Root } from '@modelcontextprotocol/sdk/types.js';
@@ -178,8 +178,7 @@ export async function start(serverBackendFactory: ServerBackendFactory, options:
return;
}
- const httpServer = await startHttpServer(options);
- const url = await installHttpTransport(httpServer, serverBackendFactory, false, options.allowedHosts);
+ const url = await startMcpHttpServer(options, serverBackendFactory, options.allowedHosts);
const mcpConfig: any = { mcpServers: { } };
mcpConfig.mcpServers[serverBackendFactory.nameInConfig] = {
diff --git a/packages/playwright/src/program.ts b/packages/playwright/src/program.ts
index 885668feec..3695c6de15 100644
--- a/packages/playwright/src/program.ts
+++ b/packages/playwright/src/program.ts
@@ -260,8 +260,8 @@ async function runTests(args: string[], opts: { [key: string]: any }) {
}
async function runTestServer(opts: { [key: string]: any }) {
- const host = opts.host || 'localhost';
- const port = opts.port ? +opts.port : 0;
+ const host = opts.host;
+ const port = opts.port ? +opts.port : undefined;
const status = await testServer.runTestServer(opts.config, { }, { host, port });
const exitCode = status === 'interrupted' ? 130 : (status === 'passed' ? 0 : 1);
gracefullyProcessExitDoNotHang(exitCode);
diff --git a/tests/mcp/http.spec.ts b/tests/mcp/http.spec.ts
index f73918bc2c..22e0ce4d33 100644
--- a/tests/mcp/http.spec.ts
+++ b/tests/mcp/http.spec.ts
@@ -16,6 +16,7 @@
import fs from 'fs';
import net from 'net';
+import dns from 'dns';
import { ChildProcess, spawn } from 'child_process';
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
@@ -62,6 +63,19 @@ const test = baseTest.extend<{ serverEndpoint: (options?: { args?: string[], noP
},
});
+async function resolveToIp(address: string) {
+ const resolvedIp = await new Promise<{ address: string, family: number }>((resolve, reject) => {
+ dns.lookup('localhost', (err, address, family) => {
+ if (err)
+ return reject(err);
+ resolve({ address, family }); // ::1 6 OR 127.0.0.1 4
+ });
+ });
+ if (resolvedIp.family === 6)
+ return `[${resolvedIp.address}]`;
+ return resolvedIp.address;
+}
+
test('http transport', async ({ serverEndpoint }) => {
const { url } = await serverEndpoint();
const transport = new StreamableHTTPClientTransport(new URL('/mcp', url));
@@ -351,10 +365,12 @@ test('client should receive list roots request', async ({ serverEndpoint, server
});
test('should not allow rebinding to localhost', async ({ serverEndpoint }) => {
- const { url } = await serverEndpoint();
- const response = await fetch(url.href.replace('localhost', '127.0.0.1'));
- expect(response.status).toBe(403);
- expect(await response.text()).toContain('Access is only allowed at localhost');
+ const { url, stderr } = await serverEndpoint();
+ const ip = await resolveToIp('localhost');
+ const response = await fetch(url.href.replace('localhost', ip));
+ console.log('logs:', stderr());
+ expect.soft(response.status).toBe(403);
+ expect.soft(await response.text()).toContain('Access is only allowed at localhost');
});
test('should respect allowed hosts (negative)', async ({ serverEndpoint }) => {