playwright 1.56.0-alpha-2025-08-21 → 1.56.0-alpha-2025-08-23

package/lib/index.js

@@ -222,7 +222,7 @@ const playwrightFixtures = {
     if ((0, import_utils.debugMode)() === "inspector")
       testInfo._setDebugMode();
     playwright._defaultContextOptions = _combinedContextOptions;
-    playwright._defaultContextTimeout = process.env.PLAYWRIGHT_TEST_DEBUGGER_MCP ? 5e3 : actionTimeout || 0;
+    playwright._defaultContextTimeout = process.env.PLAYWRIGHT_DEBUGGER_MCP ? 5e3 : actionTimeout || 0;
     playwright._defaultContextNavigationTimeout = navigationTimeout || 0;
     await use();
     playwright._defaultContextOptions = void 0;

package/lib/mcp/browser/backend.js

@@ -38,11 +38,12 @@ var import_tools = require("./tools");
 var import_exports = require("../sdk/exports");
 var import_mdb = require("../sdk/mdb");
 var import_util = require("../../util");
+const tools = [import_tools.snapshot, import_tools.pickLocator, import_tools.evaluate];
 class BrowserBackend {
   constructor(page) {
     this.name = "Playwright";
     this.version = "0.0.1";
-    this._tools = [import_tools.snapshot, import_tools.pickLocator, import_tools.evaluate];
+    this._tools = tools;
     this._page = page;
   }
   async initialize() {
@@ -72,14 +73,18 @@ const doneToolSchema = (0, import_exports.defineToolSchema)({
   type: "destructive"
 });
 async function runBrowserBackendOnError(page, message) {
-  if (!process.env.PLAYWRIGHT_TEST_DEBUGGER_MCP)
+  if (!process.env.PLAYWRIGHT_DEBUGGER_MCP)
     return;
-  const introMessage = `Paused on error:
-
+  const snapshot2 = await page._snapshotForAI();
+  const introMessage = `### Paused on error:
 ${(0, import_util.stripAnsiEscapes)(message())}
 
-Try recovering from the error prior to continuing.`;
-  await (0, import_mdb.runOnPauseBackendLoop)(process.env.PLAYWRIGHT_TEST_DEBUGGER_MCP, new BrowserBackend(page), introMessage);
+### Current page snapshot:
+${snapshot2}
+
+### Task
+Try recovering from the error prior to continuing, use following tools to recover: ${tools.map((tool) => tool.schema.name).join(", ")}`;
+  await (0, import_mdb.runOnPauseBackendLoop)(process.env.PLAYWRIGHT_DEBUGGER_MCP, new BrowserBackend(page), introMessage);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/mcp/browser/tools.js

@@ -39,9 +39,9 @@ var import_tool = require("./tool.js");
 var mcp = __toESM(require("../sdk/bundle"));
 const snapshot = (0, import_tool.defineTool)({
   schema: {
-    name: "browser_snapshot",
-    title: "Page snapshot",
-    description: "Capture accessibility snapshot of the current page, this is better than screenshot",
+    name: "playwright_test_browser_snapshot",
+    title: "Capture page snapshot",
+    description: "Capture page snapshot for debugging",
     inputSchema: mcp.z.object({}),
     type: "readOnly"
   },
@@ -63,23 +63,21 @@ const elementSchema = mcp.z.object({
 });
 const pickLocator = (0, import_tool.defineTool)({
   schema: {
-    name: "browser_pick_locator",
-    title: "Pick locator",
-    description: "Pick a locator for the given element",
+    name: "playwright_test_generate_locator",
+    title: "Create locator for element",
+    description: "Generate locator for the given element to use in tests",
     inputSchema: elementSchema,
     type: "readOnly"
   },
   handle: async (page, params) => {
     const locator = await refLocator(page, params);
-    const locatorString = await generateLocator(locator);
-    return {
-      content: [
-        {
-          type: "text",
-          text: locatorString
-        }
-      ]
-    };
+    try {
+      const { resolvedSelector } = await locator._resolveSelector();
+      const locatorString = (0, import_utils.asLocator)("javascript", resolvedSelector);
+      return { content: [{ type: "text", text: locatorString }] };
+    } catch (e) {
+      throw new Error(`Ref not found, likely because element was removed. Use ${snapshot.schema.name} to see what elements are currently on the page.`);
+    }
   }
 });
 const evaluateSchema = mcp.z.object({
@@ -89,8 +87,8 @@ const evaluateSchema = mcp.z.object({
 });
 const evaluate = (0, import_tool.defineTool)({
   schema: {
-    name: "browser_evaluate",
-    title: "Evaluate JavaScript",
+    name: "playwright_test_evaluate_on_pause",
+    title: "Evaluate in page",
     description: "Evaluate JavaScript expression on page or element",
     inputSchema: evaluateSchema,
     type: "destructive"
@@ -115,14 +113,6 @@ async function refLocator(page, elementRef) {
     throw new Error(`Ref ${elementRef.ref} not found in the current page snapshot. Try capturing new snapshot.`);
   return page.locator(`aria-ref=${elementRef.ref}`).describe(elementRef.element);
 }
-async function generateLocator(locator) {
-  try {
-    const { resolvedSelector } = await locator._resolveSelector();
-    return (0, import_utils.asLocator)("javascript", resolvedSelector);
-  } catch (e) {
-    throw new Error("Ref not found, likely because element was removed. Use browser_snapshot to see what elements are currently on the page.");
-  }
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   elementSchema,

package/lib/mcp/sdk/mdb.js

@@ -29,8 +29,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var mdb_exports = {};
 __export(mdb_exports, {
   MDBBackend: () => MDBBackend,
-  runOnPauseBackendLoop: () => runOnPauseBackendLoop,
-  runToolsBackend: () => runToolsBackend
+  runMainBackend: () => runMainBackend,
+  runOnPauseBackendLoop: () => runOnPauseBackendLoop
 });
 module.exports = __toCommonJS(mdb_exports);
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
@@ -39,15 +39,23 @@ var import_bundle = require("./bundle.js");
 var import_bundle2 = require("./bundle.js");
 var mcpBundle = __toESM(require("./bundle.js"));
 var import_tool = require("./tool.js");
+var mcpServer = __toESM(require("./server.js"));
 var mcpHttp = __toESM(require("./http.js"));
-var import_call = require("./call.js");
+var import_server = require("./server.js");
+const mdbDebug = (0, import_utilsBundle.debug)("pw:mcp:mdb");
 const errorsDebug = (0, import_utilsBundle.debug)("pw:mcp:errors");
 class MDBBackend {
-  constructor() {
+  constructor(topLevelBackend) {
     this._stack = [];
+    this._initialized = false;
+    this._topLevelBackend = topLevelBackend;
   }
   async initialize(server) {
-    this._server = server;
+    if (this._initialized)
+      return;
+    this._initialized = true;
+    const transport = await (0, import_server.wrapInProcess)(this._topLevelBackend);
+    await this._pushClient(transport);
   }
   async listTools() {
     const response = await this._client().listTools();
@@ -56,9 +64,11 @@ class MDBBackend {
   async callTool(name, args) {
     if (name === pushToolsSchema.name)
       return await this._pushTools(pushToolsSchema.inputSchema.parse(args || {}));
-    this._interruptPromise = new import_utils.ManualPromise();
+    const interruptPromise = new import_utils.ManualPromise();
+    this._interruptPromise = interruptPromise;
     let [entry] = this._stack;
     while (entry && !entry.toolNames.includes(name)) {
+      mdbDebug("popping client from stack for ", name);
       this._stack.shift();
       await entry.client.close();
       entry = this._stack[0];
@@ -68,16 +78,22 @@ class MDBBackend {
     this._client().callTool({
       name,
       arguments: args
-    }).then((result) => {
-      resultPromise.resolve(result);
+    }).then((result2) => {
+      resultPromise.resolve(result2);
     }).catch((e) => {
+      mdbDebug("error in client call", e);
       if (this._stack.length < 2)
         throw e;
       this._stack.shift();
       const prevEntry = this._stack[0];
-      void prevEntry.resultPromise.then((result) => resultPromise.resolve(result));
+      void prevEntry.resultPromise.then((result2) => resultPromise.resolve(result2));
     });
-    return await Promise.race([this._interruptPromise, resultPromise]);
+    const result = await Promise.race([interruptPromise, resultPromise]);
+    if (interruptPromise.isDone())
+      mdbDebug("client call intercepted", result);
+    else
+      mdbDebug("client call result", result);
+    return result;
   }
   _client() {
     const [entry] = this._stack;
@@ -86,22 +102,28 @@ class MDBBackend {
     return entry.client;
   }
   async _pushTools(params) {
+    mdbDebug("pushing tools to the stack", params.mcpUrl);
+    const transport = new import_bundle2.StreamableHTTPClientTransport(new URL(params.mcpUrl));
+    await this._pushClient(transport, params.introMessage);
+    return { content: [{ type: "text", text: "Tools pushed" }] };
+  }
+  async _pushClient(transport, introMessage) {
+    mdbDebug("pushing client to the stack");
     const client = new mcpBundle.Client({ name: "Internal client", version: "0.0.0" });
     client.setRequestHandler(import_bundle.PingRequestSchema, () => ({}));
-    const transport = new import_bundle2.StreamableHTTPClientTransport(new URL(params.mcpUrl));
     await client.connect(transport);
+    mdbDebug("connected to the new client");
+    const { tools } = await client.listTools();
+    this._stack.unshift({ client, toolNames: tools.map((tool) => tool.name), resultPromise: void 0 });
+    mdbDebug("new tools added to the stack:", tools.map((tool) => tool.name));
+    mdbDebug("interrupting current call:", !!this._interruptPromise);
     this._interruptPromise?.resolve({
       content: [{
         type: "text",
-        text: params.introMessage || ""
+        text: introMessage || ""
       }]
     });
     this._interruptPromise = void 0;
-    const { tools } = await client.listTools();
-    this._stack.unshift({ client, toolNames: tools.map((tool) => tool.name), resultPromise: void 0 });
-    await this._server.notification({
-      method: "notifications/tools/list_changed"
-    });
     return { content: [{ type: "text", text: "Tools pushed" }] };
   }
 }
@@ -115,20 +137,17 @@ const pushToolsSchema = (0, import_tool.defineToolSchema)({
   }),
   type: "readOnly"
 });
-async function runToolsBackend(backendFactory, options) {
-  const mdbBackend = new MDBBackend();
-  const mdbBackendFactory = {
-    name: "Playwright MDB",
-    nameInConfig: "playwright-mdb",
-    version: "0.0.0",
+async function runMainBackend(backendFactory, options) {
+  const mdbBackend = new MDBBackend(backendFactory.create());
+  const factory = {
+    ...backendFactory,
     create: () => mdbBackend
   };
-  const mdbUrl = await startAsHttp(mdbBackendFactory, options);
-  const backendUrl = await startAsHttp(backendFactory, { port: 0 });
-  const result = await (0, import_call.callTool)(mdbUrl, pushToolsSchema.name, { mcpUrl: backendUrl });
-  if (result.isError)
-    errorsDebug("Failed to push tools", result.content);
-  return mdbUrl;
+  const url = await startAsHttp(factory, { port: options?.port || 0 });
+  process.env.PLAYWRIGHT_DEBUGGER_MCP = url;
+  if (options?.port !== void 0)
+    return url;
+  await mcpServer.connect(factory, new mcpBundle.StdioServerTransport(), false);
 }
 async function runOnPauseBackendLoop(mdbUrl, backend, introMessage) {
   const wrappedBackend = new OnceTimeServerBackendWrapper(backend);
@@ -179,8 +198,8 @@ class OnceTimeServerBackendWrapper {
   async callTool(name, args) {
     return this._backend.callTool(name, args);
   }
-  serverClosed() {
-    this._backend.serverClosed?.();
+  serverClosed(server) {
+    this._backend.serverClosed?.(server);
     this._selfDestructPromise.resolve();
   }
   async waitForClosed() {
@@ -190,6 +209,6 @@ class OnceTimeServerBackendWrapper {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MDBBackend,
-  runOnPauseBackendLoop,
-  runToolsBackend
+  runMainBackend,
+  runOnPauseBackendLoop
 });

package/lib/mcp/sdk/server.js

@@ -95,7 +95,7 @@ function createServer(name, version, backend, runHeartbeat) {
       errorsDebug(e);
     }
   });
-  addServerListener(server, "close", () => backend.serverClosed?.());
+  addServerListener(server, "close", () => backend.serverClosed?.(server));
   return server;
 }
 const startHeartbeat = (server) => {

package/lib/mcp/test/backend.js

@@ -37,11 +37,11 @@ var import_listTests = require("./listTests");
 var import_runTests = require("./runTests");
 var import_tools = require("../browser/tools");
 class TestServerBackend {
-  constructor(resolvedLocation) {
+  constructor(resolvedLocation, options) {
     this.name = "Playwright";
     this.version = "0.0.1";
     this._tools = [import_listTests.listTests, import_runTests.runTests];
-    this._context = new import_context.Context(resolvedLocation);
+    this._context = new import_context.Context(resolvedLocation, options);
   }
   async listTools() {
     return [
@@ -56,7 +56,11 @@ class TestServerBackend {
     if (!tool)
       throw new Error(`Tool not found: ${name}. Available tools: ${this._tools.map((tool2) => tool2.schema.name).join(", ")}`);
     const parsedArguments = tool.schema.inputSchema.parse(args || {});
-    return await tool.handle(this._context, parsedArguments);
+    const result = await tool.handle(this._context, parsedArguments);
+    const stdio = this._context.takeStdio();
+    if (stdio.trim())
+      result.content.push({ type: "text", text: stdio });
+    return result;
   }
   serverClosed() {
     void this._context.close();

package/lib/mcp/test/context.js

@@ -23,20 +23,42 @@ __export(context_exports, {
 module.exports = __toCommonJS(context_exports);
 var import_testRunner = require("../../runner/testRunner");
 class Context {
-  constructor(configLocation) {
+  constructor(configLocation, options) {
+    this._stdio = [];
     this.configLocation = configLocation;
+    this.options = options;
   }
   async createTestRunner() {
     if (this._testRunner)
       await this._testRunner.stopTests();
     const testRunner = new import_testRunner.TestRunner(this.configLocation, {});
-    await testRunner.initialize({});
+    await testRunner.initialize({
+      sendStdioEvents: true,
+      muteConsole: this.options?.muteConsole
+    });
+    testRunner.on(import_testRunner.TestRunnerEvent.StdioChunk, (chunk, stdio) => {
+      this._stdio.push({ chunk, stdio });
+    });
+    this._testRunner = testRunner;
+    testRunner.on(import_testRunner.TestRunnerEvent.TestFilesChanged, (testFiles) => {
+      this._testRunner?.emit(import_testRunner.TestRunnerEvent.TestFilesChanged, testFiles);
+    });
     this._testRunner = testRunner;
     return testRunner;
   }
+  takeStdio() {
+    const text = this._stdio.map((entry) => chunkToPayload(entry.stdio, entry.chunk)).join("\n");
+    this._stdio = [];
+    return text;
+  }
   async close() {
   }
 }
+function chunkToPayload(type, chunk) {
+  if (chunk instanceof Uint8Array)
+    return "<binary>";
+  return `[${type}] ${chunk}`;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Context

package/lib/mcp/test/runTests.js

@@ -65,7 +65,8 @@ const runTests = (0, import_tool.defineTool)({
     const result = await testRunner.runTests(reporter, {
       testIds: params.tests?.map((test) => test.id),
       // For automatic recovery
-      timeout: 0
+      timeout: 0,
+      workers: 1
     });
     const text = stream.content();
     return {

package/lib/program.js

@@ -46,6 +46,8 @@ var testServer = __toESM(require("./runner/testServer"));
 var import_watchMode = require("./runner/watchMode");
 var import_testRunner = require("./runner/testRunner");
 var import_reporters = require("./runner/reporters");
+var import_backend = require("./mcp/test/backend");
+var import_mdb = require("./mcp/sdk/mdb");
 function addTestCommand(program3) {
   const command = program3.command("test [test-filter...]");
   command.description("run tests with Playwright Test");
@@ -139,6 +141,25 @@ Arguments [dir]:
 Examples:
   $ npx playwright merge-reports playwright-report`);
 }
+function addMCPServerCommand(program3) {
+  const command = program3.command("run-mcp-server", { hidden: true });
+  command.description("Interact with the test runner over MCP");
+  command.option("-c, --config <file>", `Configuration file, or a test directory with optional "playwright.config.{m,c}?{js,ts}"`);
+  command.option("--host <host>", "host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.");
+  command.option("--port <port>", "port to listen on for SSE transport.");
+  command.action(async (options) => {
+    const resolvedLocation = (0, import_configLoader.resolveConfigLocation)(options.config);
+    const backendFactory = {
+      name: "Playwright Test Runner",
+      nameInConfig: "playwright-test-runner",
+      version: "0.0.0",
+      create: () => new import_backend.TestServerBackend(resolvedLocation, { muteConsole: options.port === void 0 })
+    };
+    const mdbUrl = await (0, import_mdb.runMainBackend)(backendFactory, { port: options.port === void 0 ? void 0 : +options.port });
+    if (mdbUrl)
+      console.error("MCP Listening on: ", mdbUrl);
+  });
+}
 async function runTests(args, opts) {
   await (0, import_utils.startProfiling)();
   const cliOverrides = overridesFromOptions(opts);
@@ -336,6 +357,7 @@ addTestCommand(import_program.program);
 addShowReportCommand(import_program.program);
 addMergeReportsCommand(import_program.program);
 addClearCacheCommand(import_program.program);
+addMCPServerCommand(import_program.program);
 addDevServerCommand(import_program.program);
 addTestServerCommand(import_program.program);
 // Annotate the CommonJS export names for ESM import in node:

package/lib/runner/testRunner.js

@@ -36,6 +36,8 @@ module.exports = __toCommonJS(testRunner_exports);
 var import_events = __toESM(require("events"));
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
+var import_util = __toESM(require("util"));
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
 var import_server = require("playwright-core/lib/server");
 var import_utils = require("playwright-core/lib/utils");
 var import_configLoader = require("../common/configLoader");
@@ -46,13 +48,17 @@ var import_webServerPlugin = require("../plugins/webServerPlugin");
 var import_base = require("../reporters/base");
 var import_internalReporter = require("../reporters/internalReporter");
 var import_compilationCache = require("../transform/compilationCache");
-var import_util = require("../util");
+var import_util2 = require("../util");
 var import_reporters = require("./reporters");
 var import_tasks = require("./tasks");
 var import_lastRun = require("./lastRun");
 const TestRunnerEvent = {
-  TestFilesChanged: "testFilesChanged"
+  TestFilesChanged: "testFilesChanged",
+  StdioChunk: "stdioChunk"
 };
+const originalDebugLog = import_utilsBundle.debug.log;
+const originalStdoutWrite = process.stdout.write;
+const originalStderrWrite = process.stderr.write;
 class TestRunner extends import_events.default {
   constructor(configLocation, configCLIOverrides) {
     super();
@@ -73,6 +79,10 @@ class TestRunner extends import_events.default {
   async initialize(params) {
     this._watchTestDirs = !!params.watchTestDirs;
     this._populateDependenciesOnList = !!params.populateDependenciesOnList;
+    this._setInterceptStdio({
+      sendStdioEvents: !!params.sendStdioEvents,
+      muteConsole: !!params.muteConsole
+    });
   }
   resizeTerminal(params) {
     process.stdout.columns = params.cols;
@@ -307,6 +317,10 @@ class TestRunner extends import_events.default {
   async closeGracefully() {
     (0, import_utils.gracefullyProcessExitDoNotHang)(0);
   }
+  async stop() {
+    this._setInterceptStdio({ sendStdioEvents: false, muteConsole: false });
+    await this.runGlobalTeardown();
+  }
   async _loadConfig(overrides) {
     try {
       const config = await (0, import_configLoader.loadConfig)(this.configLocation, overrides);
@@ -319,7 +333,7 @@ class TestRunner extends import_events.default {
       }
       return { config };
     } catch (e) {
-      return { config: null, error: (0, import_util.serializeError)(e) };
+      return { config: null, error: (0, import_util2.serializeError)(e) };
     }
   }
   async _loadConfigOrReportError(reporter, overrides) {
@@ -332,6 +346,38 @@ class TestRunner extends import_events.default {
     await reporter.onExit();
     return null;
   }
+  _setInterceptStdio(options) {
+    if (process.env.PWTEST_DEBUG)
+      return;
+    if (options.sendStdioEvents || options.muteConsole) {
+      if (import_utilsBundle.debug.log === originalDebugLog) {
+        import_utilsBundle.debug.log = (...args) => {
+          const string = import_util.default.format(...args) + "\n";
+          return originalStderrWrite.apply(process.stderr, [string]);
+        };
+      }
+      const stdoutWrite = (chunk) => {
+        if (options.sendStdioEvents)
+          this.emit(TestRunnerEvent.StdioChunk, chunk, "stdout");
+        if (!options.muteConsole)
+          originalStdoutWrite.apply(process.stdout, [chunk]);
+        return true;
+      };
+      const stderrWrite = (chunk) => {
+        if (options.sendStdioEvents)
+          this.emit(TestRunnerEvent.StdioChunk, chunk, "stderr");
+        if (!options.muteConsole)
+          originalStderrWrite.apply(process.stderr, [chunk]);
+        return true;
+      };
+      process.stdout.write = stdoutWrite;
+      process.stderr.write = stderrWrite;
+    } else {
+      import_utilsBundle.debug.log = originalDebugLog;
+      process.stdout.write = originalStdoutWrite;
+      process.stderr.write = originalStderrWrite;
+    }
+  }
 }
 function printInternalError(e) {
   console.error("Internal error:", e);

package/lib/runner/testServer.js

@@ -28,13 +28,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var testServer_exports = {};
 __export(testServer_exports, {
-  TestRunnerEvent: () => TestRunnerEvent,
   TestServerDispatcher: () => TestServerDispatcher,
   runTestServer: () => runTestServer,
   runUIMode: () => runUIMode
 });
 module.exports = __toCommonJS(testServer_exports);
-var import_util = __toESM(require("util"));
 var import_server = require("playwright-core/lib/server");
 var import_utils = require("playwright-core/lib/utils");
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
@@ -43,9 +41,6 @@ var import_list = __toESM(require("../reporters/list"));
 var import_reporters = require("./reporters");
 var import_sigIntWatcher = require("./sigIntWatcher");
 var import_testRunner = require("./testRunner");
-const originalDebugLog = import_utilsBundle.debug.log;
-const originalStdoutWrite = process.stdout.write;
-const originalStderrWrite = process.stderr.write;
 class TestServer {
   constructor(configLocation, configCLIOverrides) {
     this._configLocation = configLocation;
@@ -56,13 +51,9 @@ class TestServer {
     return await (0, import_server.startTraceViewerServer)({ ...options, transport: this._dispatcher.transport });
   }
   async stop() {
-    await this._dispatcher?._setInterceptStdio(false);
-    await this._dispatcher?.runGlobalTeardown();
+    await this._dispatcher?.stop();
   }
 }
-const TestRunnerEvent = {
-  TestFilesChanged: "testFilesChanged"
-};
 class TestServerDispatcher {
   constructor(configLocation, configCLIOverrides) {
     this._serializer = require.resolve("./uiModeReporter");
@@ -78,7 +69,8 @@ class TestServerDispatcher {
       }
     };
     this._dispatchEvent = (method, params) => this.transport.sendEvent?.(method, params);
-    this._testRunner.on(TestRunnerEvent.TestFilesChanged, (testFiles) => this._dispatchEvent("testFilesChanged", { testFiles }));
+    this._testRunner.on(import_testRunner.TestRunnerEvent.TestFilesChanged, (testFiles) => this._dispatchEvent("testFilesChanged", { testFiles }));
+    this._testRunner.on(import_testRunner.TestRunnerEvent.StdioChunk, (chunk, stdio) => this._dispatchEvent("stdio", chunkToPayload(stdio, chunk)));
   }
   async _wireReporter(messageSink) {
     return await (0, import_reporters.createReporterForTestServer)(this._serializer, messageSink);
@@ -93,10 +85,10 @@ class TestServerDispatcher {
   async initialize(params) {
     this._serializer = params.serializer || require.resolve("./uiModeReporter");
     this._closeOnDisconnect = !!params.closeOnDisconnect;
-    await this._setInterceptStdio(!!params.interceptStdio);
     await this._testRunner.initialize({
-      watchTestDirs: !!params.watchTestDirs,
-      populateDependenciesOnList: !!params.populateDependenciesOnList
+      ...params,
+      sendStdioEvents: !!params.interceptStdio,
+      muteConsole: !!params.interceptStdio
     });
   }
   async ping() {
@@ -167,31 +159,8 @@ class TestServerDispatcher {
   async stopTests() {
     await this._testRunner.stopTests();
   }
-  async _setInterceptStdio(intercept) {
-    if (process.env.PWTEST_DEBUG)
-      return;
-    if (intercept) {
-      if (import_utilsBundle.debug.log === originalDebugLog) {
-        import_utilsBundle.debug.log = (...args) => {
-          const string = import_util.default.format(...args) + "\n";
-          return originalStderrWrite.apply(process.stderr, [string]);
-        };
-      }
-      const stdoutWrite = (chunk) => {
-        this._dispatchEvent("stdio", chunkToPayload("stdout", chunk));
-        return true;
-      };
-      const stderrWrite = (chunk) => {
-        this._dispatchEvent("stdio", chunkToPayload("stderr", chunk));
-        return true;
-      };
-      process.stdout.write = stdoutWrite;
-      process.stderr.write = stderrWrite;
-    } else {
-      import_utilsBundle.debug.log = originalDebugLog;
-      process.stdout.write = originalStdoutWrite;
-      process.stderr.write = originalStderrWrite;
-    }
+  async stop() {
+    await this._testRunner.stop();
   }
   async closeGracefully() {
     await this._testRunner.closeGracefully();
@@ -257,7 +226,6 @@ function chunkToPayload(type, chunk) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  TestRunnerEvent,
   TestServerDispatcher,
   runTestServer,
   runUIMode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playwright",
-  "version": "1.56.0-alpha-2025-08-21",
+  "version": "1.56.0-alpha-2025-08-23",
   "description": "A high-level API to automate web browsers",
   "repository": {
     "type": "git",
@@ -60,7 +60,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "playwright-core": "1.56.0-alpha-2025-08-21"
+    "playwright-core": "1.56.0-alpha-2025-08-23"
   },
   "optionalDependencies": {
     "fsevents": "2.3.2"

package/lib/mcp/test/program.js

@@ -1,42 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var import_path = __toESM(require("path"));
-var import_utilsBundle = require("playwright-core/lib/utilsBundle");
-var import_configLoader = require("../../common/configLoader");
-var import_backend = require("./backend.js");
-var import_mdb = require("../sdk/mdb");
-import_utilsBundle.program.version("Version 0.0.1").name("playwright-test-mcp").option("--config <file>", 'Configuration file, or a test directory with optional "playwright.config.{m,c}?{js,ts}"').option("--host <host>", "host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.").option("--port <port>", "port to listen on for SSE transport.").action(async (options) => {
-  const resolvedLocation = (0, import_configLoader.resolveConfigLocation)(options.config);
-  console.error("Test config: ", import_path.default.relative(process.cwd(), resolvedLocation.resolvedConfigFile ?? resolvedLocation.configDir));
-  const backendFactory = {
-    name: "Playwright Test",
-    nameInConfig: "playwright-test-mcp",
-    version: "0.0.0",
-    create: () => new import_backend.TestServerBackend(resolvedLocation)
-  };
-  const mdbUrl = await (0, import_mdb.runToolsBackend)(backendFactory, { port: 9224 });
-  process.env.PLAYWRIGHT_TEST_DEBUGGER_MCP = mdbUrl;
-  console.error("MCP Listening on: ", mdbUrl);
-});
-void import_utilsBundle.program.parseAsync(process.argv);