@stablyai/internal-playwright 0.1.0

package/lib/runner/testServer.js

@@ -0,0 +1,264 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var testServer_exports = {};
+__export(testServer_exports, {
+  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");
+var import_configLoader = require("../common/configLoader");
+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;
+    this._configCLIOverrides = configCLIOverrides;
+  }
+  async start(options) {
+    this._dispatcher = new TestServerDispatcher(this._configLocation, this._configCLIOverrides);
+    return await (0, import_server.startTraceViewerServer)({ ...options, transport: this._dispatcher.transport });
+  }
+  async stop() {
+    await this._dispatcher?.stop();
+  }
+}
+class TestServerDispatcher {
+  constructor(configLocation, configCLIOverrides) {
+    this._serializer = require.resolve("./uiModeReporter");
+    this._closeOnDisconnect = false;
+    this._testRunner = new import_testRunner.TestRunner(configLocation, configCLIOverrides);
+    this.transport = {
+      onconnect: () => {
+      },
+      dispatch: (method, params) => this[method](params),
+      onclose: () => {
+        if (this._closeOnDisconnect)
+          (0, import_utils.gracefullyProcessExitDoNotHang)(0);
+      }
+    };
+    this._dispatchEvent = (method, params) => this.transport.sendEvent?.(method, params);
+    this._testRunner.on(import_testRunner.TestRunnerEvent.TestFilesChanged, (testFiles) => this._dispatchEvent("testFilesChanged", { testFiles }));
+  }
+  async _wireReporter(messageSink) {
+    return await (0, import_reporters.createReporterForTestServer)(this._serializer, messageSink);
+  }
+  async _collectingReporter() {
+    const report = [];
+    return {
+      reporter: await (0, import_reporters.createReporterForTestServer)(this._serializer, (e) => report.push(e)),
+      report
+    };
+  }
+  async initialize(params) {
+    this._serializer = params.serializer || require.resolve("./uiModeReporter");
+    this._closeOnDisconnect = !!params.closeOnDisconnect;
+    await this._testRunner.initialize({
+      ...params
+    });
+    this._setInterceptStdio(!!params.interceptStdio);
+  }
+  async ping() {
+  }
+  async open(params) {
+    if ((0, import_utils.isUnderTest)())
+      return;
+    (0, import_utilsBundle.open)("vscode://file/" + params.location.file + ":" + params.location.line).catch((e) => console.error(e));
+  }
+  async resizeTerminal(params) {
+    this._testRunner.resizeTerminal(params);
+  }
+  async checkBrowsers() {
+    return { hasBrowsers: this._testRunner.hasSomeBrowsers() };
+  }
+  async installBrowsers() {
+    await this._testRunner.installBrowsers();
+  }
+  async runGlobalSetup(params) {
+    await this.runGlobalTeardown();
+    const { reporter, report } = await this._collectingReporter();
+    this._globalSetupReport = report;
+    const { status } = await this._testRunner.runGlobalSetup([reporter, new import_list.default()]);
+    return { report, status };
+  }
+  async runGlobalTeardown() {
+    const { status } = await this._testRunner.runGlobalTeardown();
+    const report = this._globalSetupReport || [];
+    this._globalSetupReport = void 0;
+    return { status, report };
+  }
+  async startDevServer(params) {
+    await this.stopDevServer({});
+    const { reporter, report } = await this._collectingReporter();
+    const { status } = await this._testRunner.startDevServer(reporter, "out-of-process");
+    return { report, status };
+  }
+  async stopDevServer(params) {
+    const { status } = await this._testRunner.stopDevServer();
+    const report = this._devServerReport || [];
+    this._devServerReport = void 0;
+    return { status, report };
+  }
+  async clearCache(params) {
+    await this._testRunner.clearCache();
+  }
+  async listFiles(params) {
+    const { reporter, report } = await this._collectingReporter();
+    const { status } = await this._testRunner.listFiles(reporter, params.projects);
+    return { report, status };
+  }
+  async listTests(params) {
+    const { reporter, report } = await this._collectingReporter();
+    const { status } = await this._testRunner.listTests(reporter, params);
+    return { report, status };
+  }
+  async runTests(params) {
+    const wireReporter = await this._wireReporter((e) => this._dispatchEvent("report", e));
+    const { status } = await this._testRunner.runTests(wireReporter, {
+      ...params,
+      doNotRunDepsOutsideProjectFilter: true
+    });
+    return { status };
+  }
+  async watch(params) {
+    await this._testRunner.watch(params.fileNames);
+  }
+  async findRelatedTestFiles(params) {
+    return this._testRunner.findRelatedTestFiles(params.files);
+  }
+  async stopTests() {
+    await this._testRunner.stopTests();
+  }
+  async stop() {
+    this._setInterceptStdio(false);
+    await this._testRunner.stop();
+  }
+  async closeGracefully() {
+    await this._testRunner.closeGracefully();
+  }
+  _setInterceptStdio(interceptStdio) {
+    if (process.env.PWTEST_DEBUG)
+      return;
+    if (interceptStdio) {
+      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 function runUIMode(configFile, configCLIOverrides, options) {
+  const configLocation = (0, import_configLoader.resolveConfigLocation)(configFile);
+  return await innerRunTestServer(configLocation, configCLIOverrides, options, async (server, cancelPromise) => {
+    await (0, import_server.installRootRedirect)(server, void 0, { ...options, webApp: "uiMode.html" });
+    if (options.host !== void 0 || options.port !== void 0) {
+      await (0, import_server.openTraceInBrowser)(server.urlPrefix("human-readable"));
+    } else {
+      const channel = await installedChromiumChannelForUI(configLocation, configCLIOverrides);
+      const page = await (0, import_server.openTraceViewerApp)(server.urlPrefix("precise"), "chromium", {
+        headless: (0, import_utils.isUnderTest)() && process.env.PWTEST_HEADED_FOR_TEST !== "1",
+        persistentContextOptions: {
+          handleSIGINT: false,
+          channel
+        }
+      });
+      page.on("close", () => cancelPromise.resolve());
+    }
+  });
+}
+async function installedChromiumChannelForUI(configLocation, configCLIOverrides) {
+  const config = await (0, import_configLoader.loadConfig)(configLocation, configCLIOverrides).catch((e) => null);
+  if (!config)
+    return void 0;
+  if (config.projects.some((p) => (!p.project.use.browserName || p.project.use.browserName === "chromium") && !p.project.use.channel))
+    return void 0;
+  for (const channel of ["chromium", "chrome", "msedge"]) {
+    if (config.projects.some((p) => p.project.use.channel === channel))
+      return channel;
+  }
+  return void 0;
+}
+async function runTestServer(configFile, configCLIOverrides, options) {
+  const configLocation = (0, import_configLoader.resolveConfigLocation)(configFile);
+  return await innerRunTestServer(configLocation, configCLIOverrides, options, async (server) => {
+    console.log("Listening on " + server.urlPrefix("precise").replace("http:", "ws:") + "/" + server.wsGuid());
+  });
+}
+async function innerRunTestServer(configLocation, configCLIOverrides, options, openUI) {
+  const testServer = new TestServer(configLocation, configCLIOverrides);
+  const cancelPromise = new import_utils.ManualPromise();
+  const sigintWatcher = new import_sigIntWatcher.SigIntWatcher();
+  process.stdin.on("close", () => (0, import_utils.gracefullyProcessExitDoNotHang)(0));
+  void sigintWatcher.promise().then(() => cancelPromise.resolve());
+  try {
+    const server = await testServer.start(options);
+    await openUI(server, cancelPromise);
+    await cancelPromise;
+  } finally {
+    await testServer.stop();
+    sigintWatcher.disarm();
+  }
+  return sigintWatcher.hadSignal() ? "interrupted" : "passed";
+}
+function chunkToPayload(type, chunk) {
+  if (chunk instanceof Uint8Array)
+    return { type, buffer: chunk.toString("base64") };
+  return { type, text: chunk };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TestServerDispatcher,
+  runTestServer,
+  runUIMode
+});

package/lib/runner/testServer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/runner/testServer.ts"],
+  "sourcesContent": ["/**\n * Copyright Microsoft Corporation. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport util from 'util';\n\nimport { installRootRedirect, openTraceInBrowser, openTraceViewerApp, startTraceViewerServer } from 'playwright-core/lib/server';\nimport { ManualPromise, gracefullyProcessExitDoNotHang, isUnderTest } from 'playwright-core/lib/utils';\nimport { debug, open } from 'playwright-core/lib/utilsBundle';\n\nimport { loadConfig, resolveConfigLocation } from '../common/configLoader';\nimport ListReporter from '../reporters/list';\nimport { createReporterForTestServer } from './reporters';\nimport { SigIntWatcher } from './sigIntWatcher';\nimport { TestRunner, TestRunnerEvent } from './testRunner';\n\nimport type { TraceViewerRedirectOptions, TraceViewerServerOptions } from 'playwright-core/lib/server/trace/viewer/traceViewer';\nimport type { HttpServer, Transport } from 'playwright-core/lib/utils';\nimport type * as reporterTypes from '../../types/testReporter';\nimport type { ConfigLocation } from '../common/config';\nimport type { ConfigCLIOverrides } from '../common/ipc';\nimport type { ReportEntry, TestServerInterface, TestServerInterfaceEventEmitters } from '../isomorphic/testServerInterface';\nimport type { ReporterV2 } from '../reporters/reporterV2';\n\nconst originalDebugLog = debug.log;\n// eslint-disable-next-line no-restricted-properties\nconst originalStdoutWrite = process.stdout.write;\n// eslint-disable-next-line no-restricted-properties\nconst originalStderrWrite = process.stderr.write;\n\nclass TestServer {\n  private _configLocation: ConfigLocation;\n  private _configCLIOverrides: ConfigCLIOverrides;\n  private _dispatcher: TestServerDispatcher | undefined;\n\n  constructor(configLocation: ConfigLocation, configCLIOverrides: ConfigCLIOverrides) {\n    this._configLocation = configLocation;\n    this._configCLIOverrides = configCLIOverrides;\n  }\n\n  async start(options: { host?: string, port?: number }): Promise<HttpServer> {\n    this._dispatcher = new TestServerDispatcher(this._configLocation, this._configCLIOverrides);\n    return await startTraceViewerServer({ ...options, transport: this._dispatcher.transport });\n  }\n\n  async stop() {\n    await this._dispatcher?.stop();\n  }\n}\n\nexport type ListTestsParams = {\n  projects?: string[];\n  locations?: string[];\n  grep?: string;\n  grepInvert?: string;\n};\n\nexport type RunTestsParams = {\n  locations?: string[];\n  grep?: string;\n  grepInvert?: string;\n  testIds?: string[];\n  headed?: boolean;\n  workers?: number | string;\n  updateSnapshots?: 'all' | 'changed' | 'missing' | 'none';\n  updateSourceMethod?: 'overwrite' | 'patch' | '3way';\n  reporters?: string[],\n  trace?: 'on' | 'off';\n  video?: 'on' | 'off';\n  projects?: string[];\n  reuseContext?: boolean;\n  connectWsEndpoint?: string;\n};\n\nexport class TestServerDispatcher implements TestServerInterface {\n  readonly transport: Transport;\n  private _serializer = require.resolve('./uiModeReporter');\n  private _closeOnDisconnect = false;\n  private _testRunner: TestRunner;\n  private _globalSetupReport: ReportEntry[] | undefined;\n  private _devServerReport: ReportEntry[] | undefined;\n  readonly _dispatchEvent: TestServerInterfaceEventEmitters['dispatchEvent'];\n\n  constructor(configLocation: ConfigLocation, configCLIOverrides: ConfigCLIOverrides) {\n    this._testRunner = new TestRunner(configLocation, configCLIOverrides);\n    this.transport = {\n      onconnect: () => {},\n      dispatch: (method, params) => (this as any)[method](params),\n      onclose: () => {\n        if (this._closeOnDisconnect)\n          gracefullyProcessExitDoNotHang(0);\n      },\n    };\n\n    this._dispatchEvent = (method, params) => this.transport.sendEvent?.(method, params);\n    this._testRunner.on(TestRunnerEvent.TestFilesChanged, testFiles => this._dispatchEvent('testFilesChanged', { testFiles }));\n  }\n\n  private async _wireReporter(messageSink: (message: any) => void) {\n    return await createReporterForTestServer(this._serializer, messageSink);\n  }\n\n  private async _collectingReporter(): Promise<{ reporter: ReporterV2, report: ReportEntry[] }> {\n    const report: ReportEntry[] = [];\n    return {\n      reporter: await createReporterForTestServer(this._serializer, e => report.push(e)),\n      report,\n    };\n  }\n\n  async initialize(params: Parameters<TestServerInterface['initialize']>[0]): ReturnType<TestServerInterface['initialize']> {\n    // Note: this method can be called multiple times, for example from a new connection after UI mode reload.\n    this._serializer = params.serializer || require.resolve('./uiModeReporter');\n    this._closeOnDisconnect = !!params.closeOnDisconnect;\n    await this._testRunner.initialize({\n      ...params,\n    });\n    this._setInterceptStdio(!!params.interceptStdio);\n  }\n\n  async ping() {}\n\n  async open(params: Parameters<TestServerInterface['open']>[0]): ReturnType<TestServerInterface['open']> {\n    if (isUnderTest())\n      return;\n    // eslint-disable-next-line no-console\n    open('vscode://file/' + params.location.file + ':' + params.location.line).catch(e => console.error(e));\n  }\n\n  async resizeTerminal(params: Parameters<TestServerInterface['resizeTerminal']>[0]): ReturnType<TestServerInterface['resizeTerminal']> {\n    this._testRunner.resizeTerminal(params);\n  }\n\n  async checkBrowsers(): Promise<{ hasBrowsers: boolean; }> {\n    return { hasBrowsers: this._testRunner.hasSomeBrowsers() };\n  }\n\n  async installBrowsers() {\n    await this._testRunner.installBrowsers();\n  }\n\n  async runGlobalSetup(params: Parameters<TestServerInterface['runGlobalSetup']>[0]): ReturnType<TestServerInterface['runGlobalSetup']> {\n    await this.runGlobalTeardown();\n\n    const { reporter, report } = await this._collectingReporter();\n    this._globalSetupReport = report;\n    const { status } = await this._testRunner.runGlobalSetup([reporter, new ListReporter()]);\n    return { report, status };\n  }\n\n  async runGlobalTeardown() {\n    const { status } = await this._testRunner.runGlobalTeardown();\n    const report = this._globalSetupReport || [];\n    this._globalSetupReport = undefined;\n    return { status, report };\n  }\n\n  async startDevServer(params: Parameters<TestServerInterface['startDevServer']>[0]): ReturnType<TestServerInterface['startDevServer']> {\n    await this.stopDevServer({});\n\n    const { reporter, report } = await this._collectingReporter();\n    const { status } = await this._testRunner.startDevServer(reporter, 'out-of-process');\n    return { report, status };\n  }\n\n  async stopDevServer(params: Parameters<TestServerInterface['stopDevServer']>[0]): ReturnType<TestServerInterface['stopDevServer']> {\n    const { status } = await this._testRunner.stopDevServer();\n    const report = this._devServerReport || [];\n    this._devServerReport = undefined;\n    return { status, report };\n  }\n\n  async clearCache(params: Parameters<TestServerInterface['clearCache']>[0]): ReturnType<TestServerInterface['clearCache']> {\n    await this._testRunner.clearCache();\n  }\n\n  async listFiles(params: Parameters<TestServerInterface['listFiles']>[0]): ReturnType<TestServerInterface['listFiles']> {\n    const { reporter, report } = await this._collectingReporter();\n    const { status } = await this._testRunner.listFiles(reporter, params.projects);\n    return { report, status };\n  }\n\n  async listTests(params: Parameters<TestServerInterface['listTests']>[0]): ReturnType<TestServerInterface['listTests']> {\n    const { reporter, report } = await this._collectingReporter();\n    const { status } = await this._testRunner.listTests(reporter, params);\n    return { report, status };\n  }\n\n  async runTests(params: Parameters<TestServerInterface['runTests']>[0]): ReturnType<TestServerInterface['runTests']> {\n    const wireReporter = await this._wireReporter(e => this._dispatchEvent('report', e));\n    const { status } = await this._testRunner.runTests(wireReporter, params);\n    return { status };\n  }\n\n  async watch(params: { fileNames: string[]; }) {\n    await this._testRunner.watch(params.fileNames);\n  }\n\n  async findRelatedTestFiles(params: Parameters<TestServerInterface['findRelatedTestFiles']>[0]): ReturnType<TestServerInterface['findRelatedTestFiles']> {\n    return this._testRunner.findRelatedTestFiles(params.files);\n  }\n\n  async stopTests() {\n    await this._testRunner.stopTests();\n  }\n\n  async stop() {\n    this._setInterceptStdio(false);\n    await this._testRunner.stop();\n  }\n\n  async closeGracefully() {\n    await this._testRunner.closeGracefully();\n  }\n\n  private _setInterceptStdio(interceptStdio: boolean) {\n    /* eslint-disable no-restricted-properties */\n    if (process.env.PWTEST_DEBUG)\n      return;\n    if (interceptStdio) {\n      if (debug.log === originalDebugLog) {\n        // Only if debug.log hasn't already been tampered with, don't intercept any DEBUG=* logging\n        debug.log = (...args) => {\n          const string = util.format(...args) + '\\n';\n          return (originalStderrWrite as any).apply(process.stderr, [string]);\n        };\n      }\n      const stdoutWrite = (chunk: string | Buffer) => {\n        this._dispatchEvent('stdio', chunkToPayload('stdout', chunk));\n        return true;\n      };\n      const stderrWrite = (chunk: string | Buffer) => {\n        this._dispatchEvent('stdio', chunkToPayload('stderr', chunk));\n        return true;\n      };\n      process.stdout.write = stdoutWrite;\n      process.stderr.write = stderrWrite;\n    } else {\n      debug.log = originalDebugLog;\n      process.stdout.write = originalStdoutWrite;\n      process.stderr.write = originalStderrWrite;\n    }\n    /* eslint-enable no-restricted-properties */\n  }\n}\n\nexport async function runUIMode(configFile: string | undefined, configCLIOverrides: ConfigCLIOverrides, options: TraceViewerServerOptions & TraceViewerRedirectOptions): Promise<reporterTypes.FullResult['status']> {\n  const configLocation = resolveConfigLocation(configFile);\n  return await innerRunTestServer(configLocation, configCLIOverrides, options, async (server: HttpServer, cancelPromise: ManualPromise<void>) => {\n    await installRootRedirect(server, [], { ...options, webApp: 'uiMode.html' });\n    if (options.host !== undefined || options.port !== undefined) {\n      await openTraceInBrowser(server.urlPrefix('human-readable'));\n    } else {\n      const channel = await installedChromiumChannelForUI(configLocation, configCLIOverrides);\n      const page = await openTraceViewerApp(server.urlPrefix('precise'), 'chromium', {\n        headless: isUnderTest() && process.env.PWTEST_HEADED_FOR_TEST !== '1',\n        persistentContextOptions: {\n          handleSIGINT: false,\n          channel,\n        },\n      });\n      page.on('close', () => cancelPromise.resolve());\n    }\n  });\n}\n\n// Pick first channel that is used by one of the projects, to ensure it is installed on the machine.\nasync function installedChromiumChannelForUI(configLocation: ConfigLocation, configCLIOverrides: ConfigCLIOverrides) {\n  const config = await loadConfig(configLocation, configCLIOverrides).catch(e => null);\n  if (!config)\n    return undefined;\n  if (config.projects.some(p => (!p.project.use.browserName || p.project.use.browserName === 'chromium') && !p.project.use.channel))\n    return undefined;\n  for (const channel of ['chromium', 'chrome', 'msedge']) {\n    if (config.projects.some(p => p.project.use.channel === channel))\n      return channel;\n  }\n  return undefined;\n}\n\nexport async function runTestServer(configFile: string | undefined, configCLIOverrides: ConfigCLIOverrides, options: { host?: string, port?: number }): Promise<reporterTypes.FullResult['status']> {\n  const configLocation = resolveConfigLocation(configFile);\n  return await innerRunTestServer(configLocation, configCLIOverrides, options, async server => {\n    // eslint-disable-next-line no-console\n    console.log('Listening on ' + server.urlPrefix('precise').replace('http:', 'ws:') + '/' + server.wsGuid());\n  });\n}\n\nasync function innerRunTestServer(configLocation: ConfigLocation, configCLIOverrides: ConfigCLIOverrides, options: { host?: string, port?: number }, openUI: (server: HttpServer, cancelPromise: ManualPromise<void>) => Promise<void>): Promise<reporterTypes.FullResult['status']> {\n  const testServer = new TestServer(configLocation, configCLIOverrides);\n  const cancelPromise = new ManualPromise<void>();\n  const sigintWatcher = new SigIntWatcher();\n  process.stdin.on('close', () => gracefullyProcessExitDoNotHang(0));\n  void sigintWatcher.promise().then(() => cancelPromise.resolve());\n  try {\n    const server = await testServer.start(options);\n    await openUI(server, cancelPromise);\n    await cancelPromise;\n  } finally {\n    await testServer.stop();\n    sigintWatcher.disarm();\n  }\n  return sigintWatcher.hadSignal() ? 'interrupted' : 'passed';\n}\n\ntype StdioPayload = {\n  type: 'stdout' | 'stderr';\n  text?: string;\n  buffer?: string;\n};\n\nfunction chunkToPayload(type: 'stdout' | 'stderr', chunk: Buffer | string): StdioPayload {\n  if (chunk instanceof Uint8Array)\n    return { type, buffer: chunk.toString('base64') };\n  return { type, text: chunk };\n}\n"],
+  "mappings": "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",
+  "names": ["ListReporter", "util"]
+}

package/lib/runner/uiMode.js

@@ -0,0 +1,271 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runUIMode = runUIMode;
+var _server = require("playwright-core/lib/server");
+var _utils = require("playwright-core/lib/utils");
+var _compilationCache = require("../transform/compilationCache");
+var _internalReporter = require("../reporters/internalReporter");
+var _teleEmitter = require("../reporters/teleEmitter");
+var _reporters = require("./reporters");
+var _tasks = require("./tasks");
+var _utilsBundle = require("playwright-core/lib/utilsBundle");
+var _list = _interopRequireDefault(require("../reporters/list"));
+var _multiplexer = require("../reporters/multiplexer");
+var _sigIntWatcher = require("./sigIntWatcher");
+var _fsWatcher = require("../fsWatcher");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright Microsoft Corporation. All rights reserved.
+ *
+ * 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.
+ */
+
+class UIMode {
+  constructor(config) {
+    this._config = void 0;
+    this._transport = void 0;
+    this._testRun = void 0;
+    this.globalCleanup = void 0;
+    this._globalWatcher = void 0;
+    this._testWatcher = void 0;
+    this._originalStdoutWrite = void 0;
+    this._originalStderrWrite = void 0;
+    this._config = config;
+    process.env.PW_LIVE_TRACE_STACKS = '1';
+    config.cliListOnly = false;
+    config.cliPassWithNoTests = true;
+    config.config.preserveOutput = 'always';
+    for (const p of config.projects) {
+      p.project.retries = 0;
+      p.project.repeatEach = 1;
+    }
+    config.configCLIOverrides.use = config.configCLIOverrides.use || {};
+    config.configCLIOverrides.use.trace = {
+      mode: 'on',
+      sources: false,
+      _live: true
+    };
+    this._originalStdoutWrite = process.stdout.write;
+    this._originalStderrWrite = process.stderr.write;
+    this._globalWatcher = new _fsWatcher.Watcher('deep', () => this._dispatchEvent('listChanged', {}));
+    this._testWatcher = new _fsWatcher.Watcher('flat', events => {
+      const collector = new Set();
+      events.forEach(f => (0, _compilationCache.collectAffectedTestFiles)(f.file, collector));
+      this._dispatchEvent('testFilesChanged', {
+        testFileNames: [...collector]
+      });
+    });
+  }
+  async runGlobalSetup() {
+    const reporter = new _internalReporter.InternalReporter(new _list.default());
+    const taskRunner = (0, _tasks.createTaskRunnerForWatchSetup)(this._config, reporter);
+    reporter.onConfigure(this._config.config);
+    const testRun = new _tasks.TestRun(this._config, reporter);
+    const {
+      status,
+      cleanup: globalCleanup
+    } = await taskRunner.runDeferCleanup(testRun, 0);
+    await reporter.onEnd({
+      status
+    });
+    await reporter.onExit();
+    if (status !== 'passed') {
+      await globalCleanup();
+      return status;
+    }
+    this.globalCleanup = globalCleanup;
+    return status;
+  }
+  async showUI(options, cancelPromise) {
+    let queue = Promise.resolve();
+    this._transport = {
+      dispatch: async (method, params) => {
+        if (method === 'ping') return;
+        if (method === 'watch') {
+          this._watchFiles(params.fileNames);
+          return;
+        }
+        if (method === 'open' && params.location) {
+          (0, _utilsBundle.open)('vscode://file/' + params.location).catch(e => this._originalStderrWrite.call(process.stderr, String(e)));
+          return;
+        }
+        if (method === 'resizeTerminal') {
+          process.stdout.columns = params.cols;
+          process.stdout.rows = params.rows;
+          process.stderr.columns = params.cols;
+          process.stderr.columns = params.rows;
+          return;
+        }
+        if (method === 'stop') {
+          void this._stopTests();
+          return;
+        }
+        if (method === 'checkBrowsers') return {
+          hasBrowsers: hasSomeBrowsers()
+        };
+        if (method === 'installBrowsers') {
+          await installBrowsers();
+          return;
+        }
+        queue = queue.then(() => this._queueListOrRun(method, params));
+        await queue;
+      },
+      onclose: () => {}
+    };
+    const openOptions = {
+      app: 'uiMode.html',
+      headless: (0, _utils.isUnderTest)() && process.env.PWTEST_HEADED_FOR_TEST !== '1',
+      transport: this._transport,
+      host: options.host,
+      port: options.port,
+      persistentContextOptions: {
+        handleSIGINT: false
+      }
+    };
+    if (options.host !== undefined || options.port !== undefined) {
+      await (0, _server.openTraceInBrowser)([], openOptions);
+    } else {
+      const page = await (0, _server.openTraceViewerApp)([], 'chromium', openOptions);
+      page.on('close', () => cancelPromise.resolve());
+    }
+    if (!process.env.PWTEST_DEBUG) {
+      process.stdout.write = chunk => {
+        this._dispatchEvent('stdio', chunkToPayload('stdout', chunk));
+        return true;
+      };
+      process.stderr.write = chunk => {
+        this._dispatchEvent('stdio', chunkToPayload('stderr', chunk));
+        return true;
+      };
+    }
+    await cancelPromise;
+    if (!process.env.PWTEST_DEBUG) {
+      process.stdout.write = this._originalStdoutWrite;
+      process.stderr.write = this._originalStderrWrite;
+    }
+  }
+  async _queueListOrRun(method, params) {
+    if (method === 'list') await this._listTests();
+    if (method === 'run') await this._runTests(params.testIds, params.projects);
+  }
+  _dispatchEvent(method, params) {
+    var _this$_transport$send, _this$_transport;
+    (_this$_transport$send = (_this$_transport = this._transport).sendEvent) === null || _this$_transport$send === void 0 || _this$_transport$send.call(_this$_transport, method, params);
+  }
+  async _listTests() {
+    const reporter = new _internalReporter.InternalReporter(new _teleEmitter.TeleReporterEmitter(e => this._dispatchEvent(e.method, e.params), true));
+    this._config.cliListOnly = true;
+    this._config.testIdMatcher = undefined;
+    const taskRunner = (0, _tasks.createTaskRunnerForList)(this._config, reporter, 'out-of-process', {
+      failOnLoadErrors: false
+    });
+    const testRun = new _tasks.TestRun(this._config, reporter);
+    (0, _compilationCache.clearCompilationCache)();
+    reporter.onConfigure(this._config.config);
+    const status = await taskRunner.run(testRun, 0);
+    await reporter.onEnd({
+      status
+    });
+    await reporter.onExit();
+    const projectDirs = new Set();
+    const projectOutputs = new Set();
+    for (const p of this._config.projects) {
+      projectDirs.add(p.project.testDir);
+      projectOutputs.add(p.project.outputDir);
+    }
+    this._globalWatcher.update([...projectDirs], [...projectOutputs], false);
+  }
+  async _runTests(testIds, projects) {
+    await this._stopTests();
+    const testIdSet = testIds ? new Set(testIds) : null;
+    this._config.cliListOnly = false;
+    this._config.cliProjectFilter = projects.length ? projects : undefined;
+    this._config.testIdMatcher = id => !testIdSet || testIdSet.has(id);
+    const reporters = await (0, _reporters.createReporters)(this._config, 'ui');
+    reporters.push(new _teleEmitter.TeleReporterEmitter(e => this._dispatchEvent(e.method, e.params), true));
+    const reporter = new _internalReporter.InternalReporter(new _multiplexer.Multiplexer(reporters));
+    const taskRunner = (0, _tasks.createTaskRunnerForWatch)(this._config, reporter);
+    const testRun = new _tasks.TestRun(this._config, reporter);
+    (0, _compilationCache.clearCompilationCache)();
+    reporter.onConfigure(this._config.config);
+    const stop = new _utils.ManualPromise();
+    const run = taskRunner.run(testRun, 0, stop).then(async status => {
+      await reporter.onEnd({
+        status
+      });
+      await reporter.onExit();
+      this._testRun = undefined;
+      this._config.testIdMatcher = undefined;
+      return status;
+    });
+    this._testRun = {
+      run,
+      stop
+    };
+    await run;
+  }
+  _watchFiles(fileNames) {
+    const files = new Set();
+    for (const fileName of fileNames) {
+      files.add(fileName);
+      (0, _compilationCache.dependenciesForTestFile)(fileName).forEach(file => files.add(file));
+    }
+    this._testWatcher.update([...files], [], true);
+  }
+  async _stopTests() {
+    var _this$_testRun, _this$_testRun2;
+    (_this$_testRun = this._testRun) === null || _this$_testRun === void 0 || (_this$_testRun = _this$_testRun.stop) === null || _this$_testRun === void 0 || _this$_testRun.resolve();
+    await ((_this$_testRun2 = this._testRun) === null || _this$_testRun2 === void 0 ? void 0 : _this$_testRun2.run);
+  }
+}
+async function runUIMode(config, options) {
+  var _uiMode$globalCleanup;
+  const uiMode = new UIMode(config);
+  const globalSetupStatus = await uiMode.runGlobalSetup();
+  if (globalSetupStatus !== 'passed') return globalSetupStatus;
+  const cancelPromise = new _utils.ManualPromise();
+  const sigintWatcher = new _sigIntWatcher.SigIntWatcher();
+  void sigintWatcher.promise().then(() => cancelPromise.resolve());
+  try {
+    await uiMode.showUI(options, cancelPromise);
+  } finally {
+    sigintWatcher.disarm();
+  }
+  return (await ((_uiMode$globalCleanup = uiMode.globalCleanup) === null || _uiMode$globalCleanup === void 0 ? void 0 : _uiMode$globalCleanup.call(uiMode))) || (sigintWatcher.hadSignal() ? 'interrupted' : 'passed');
+}
+function chunkToPayload(type, chunk) {
+  if (chunk instanceof Buffer) return {
+    type,
+    buffer: chunk.toString('base64')
+  };
+  return {
+    type,
+    text: chunk
+  };
+}
+function hasSomeBrowsers() {
+  for (const browserName of ['chromium', 'webkit', 'firefox']) {
+    try {
+      _server.registry.findExecutable(browserName).executablePathOrDie('javascript');
+      return true;
+    } catch {}
+  }
+  return false;
+}
+async function installBrowsers() {
+  const executables = _server.registry.defaultExecutables();
+  await _server.registry.install(executables, false);
+}

package/lib/runner/uiModeReporter.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var uiModeReporter_exports = {};
+__export(uiModeReporter_exports, {
+  default: () => uiModeReporter_default
+});
+module.exports = __toCommonJS(uiModeReporter_exports);
+var import_teleEmitter = require("../reporters/teleEmitter");
+class UIModeReporter extends import_teleEmitter.TeleReporterEmitter {
+  constructor(options) {
+    super(options._send, { omitBuffers: true });
+  }
+}
+var uiModeReporter_default = UIModeReporter;

package/lib/runner/uiModeReporter.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/runner/uiModeReporter.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Microsoft Corporation.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TeleReporterEmitter } from '../reporters/teleEmitter';\n\nclass UIModeReporter extends TeleReporterEmitter {\n  constructor(options: any) {\n    super(options._send, { omitBuffers: true });\n  }\n}\n\nexport default UIModeReporter;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,yBAAoC;AAEpC,MAAM,uBAAuB,uCAAoB;AAAA,EAC/C,YAAY,SAAc;AACxB,UAAM,QAAQ,OAAO,EAAE,aAAa,KAAK,CAAC;AAAA,EAC5C;AACF;AAEA,IAAO,yBAAQ;",
+  "names": []
+}