playwright-test-explorer 0.0.1

package/dist/api-DuYXKbq5.js

@@ -0,0 +1,965 @@
+import { createRequire } from "node:module";
+import path from "path";
+import { spawn } from "child_process";
+import WebSocket from "ws";
+import fs from "fs/promises";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/upstream/teleReceiver.ts
+var TeleReporterReceiver = class {
+	_rootSuite;
+	_options;
+	_reporter;
+	_tests = /* @__PURE__ */ new Map();
+	_rootDir;
+	_config;
+	constructor(reporter, options) {
+		this._rootSuite = new TeleSuite("", "root");
+		this._options = options;
+		this._reporter = reporter;
+	}
+	reset() {
+		this._rootSuite.suites = [];
+		this._rootSuite.tests = [];
+		this._tests.clear();
+	}
+	dispatch(message) {
+		const { method, params } = message;
+		if (method === "onConfigure") {
+			this._onConfigure(params.config);
+			return;
+		}
+		if (method === "onProject") {
+			this._onProject(params.project);
+			return;
+		}
+		if (method === "onBegin") {
+			this._onBegin();
+			return;
+		}
+		if (method === "onTestBegin") {
+			this._onTestBegin(params.testId, params.result);
+			return;
+		}
+		if (method === "onTestEnd") {
+			this._onTestEnd(params.test, params.result);
+			return;
+		}
+		if (method === "onStepBegin") {
+			this._onStepBegin(params.testId, params.resultId, params.step);
+			return;
+		}
+		if (method === "onStepEnd") {
+			this._onStepEnd(params.testId, params.resultId, params.step);
+			return;
+		}
+		if (method === "onError") {
+			this._onError(params.error);
+			return;
+		}
+		if (method === "onStdIO") {
+			this._onStdIO(params.type, params.testId, params.resultId, params.data, params.isBase64);
+			return;
+		}
+		if (method === "onEnd") return this._onEnd(params.result);
+		if (method === "onExit") return this._onExit();
+	}
+	_onConfigure(config) {
+		this._rootDir = config.rootDir;
+		this._config = this._parseConfig(config);
+		this._reporter.onConfigure?.(this._config);
+	}
+	_onProject(project) {
+		let projectSuite = this._options.mergeProjects ? this._rootSuite.suites.find((suite) => suite.project().name === project.name) : void 0;
+		if (!projectSuite) {
+			projectSuite = new TeleSuite(project.name, "project");
+			this._rootSuite.suites.push(projectSuite);
+			projectSuite.parent = this._rootSuite;
+		}
+		projectSuite._project = this._parseProject(project);
+		this._mergeSuitesInto(project.suites, projectSuite);
+	}
+	_onBegin() {
+		this._reporter.onBegin?.(this._rootSuite);
+	}
+	_onTestBegin(testId, payload) {
+		const test = this._tests.get(testId);
+		if (this._options.clearPreviousResultsWhenTestBegins) test._clearResults();
+		const testResult = test._createTestResult(payload.id);
+		testResult.retry = payload.retry;
+		testResult.workerIndex = payload.workerIndex;
+		testResult.parallelIndex = payload.parallelIndex;
+		testResult.setStartTimeNumber(payload.startTime);
+		this._reporter.onTestBegin?.(test, testResult);
+	}
+	_onTestEnd(testEndPayload, payload) {
+		const test = this._tests.get(testEndPayload.testId);
+		test.timeout = testEndPayload.timeout;
+		test.expectedStatus = testEndPayload.expectedStatus;
+		test.annotations = testEndPayload.annotations;
+		const result = test._resultsMap.get(payload.id);
+		result.duration = payload.duration;
+		result.status = payload.status;
+		result.errors = payload.errors;
+		result.error = result.errors?.[0];
+		result.attachments = this._parseAttachments(payload.attachments);
+		this._reporter.onTestEnd?.(test, result);
+		result._stepMap = /* @__PURE__ */ new Map();
+	}
+	_onStepBegin(testId, resultId, payload) {
+		const test = this._tests.get(testId);
+		const result = test._resultsMap.get(resultId);
+		const parentStep = payload.parentStepId ? result._stepMap.get(payload.parentStepId) : void 0;
+		const step = new TeleTestStep(payload, parentStep, this._absoluteLocation(payload.location));
+		if (parentStep) parentStep.steps.push(step);
+		else result.steps.push(step);
+		result._stepMap.set(payload.id, step);
+		this._reporter.onStepBegin?.(test, result, step);
+	}
+	_onStepEnd(testId, resultId, payload) {
+		const test = this._tests.get(testId);
+		const result = test._resultsMap.get(resultId);
+		const step = result._stepMap.get(payload.id);
+		step.duration = payload.duration;
+		step.error = payload.error;
+		this._reporter.onStepEnd?.(test, result, step);
+	}
+	_onError(error) {
+		this._reporter.onError?.(error);
+	}
+	_onStdIO(type, testId, resultId, data, isBase64) {
+		const chunk = isBase64 ? globalThis.Buffer ? Buffer.from(data, "base64") : atob(data) : data;
+		const test = testId ? this._tests.get(testId) : void 0;
+		const result = test && resultId ? test._resultsMap.get(resultId) : void 0;
+		if (type === "stdout") {
+			result?.stdout.push(chunk);
+			this._reporter.onStdOut?.(chunk, test, result);
+		} else {
+			result?.stderr.push(chunk);
+			this._reporter.onStdErr?.(chunk, test, result);
+		}
+	}
+	async _onEnd(result) {
+		await this._reporter.onEnd?.({
+			status: result.status,
+			startTime: new Date(result.startTime),
+			duration: result.duration
+		});
+	}
+	_onExit() {
+		return this._reporter.onExit?.();
+	}
+	_parseConfig(config) {
+		const result = {
+			...baseFullConfig,
+			...config
+		};
+		if (this._options.configOverrides) {
+			result.configFile = this._options.configOverrides.configFile;
+			result.reportSlowTests = this._options.configOverrides.reportSlowTests;
+			result.quiet = this._options.configOverrides.quiet;
+			result.reporter = [...this._options.configOverrides.reporter];
+		}
+		return result;
+	}
+	_parseProject(project) {
+		return {
+			metadata: project.metadata,
+			name: project.name,
+			outputDir: this._absolutePath(project.outputDir),
+			repeatEach: project.repeatEach,
+			retries: project.retries,
+			testDir: this._absolutePath(project.testDir),
+			testIgnore: parseRegexPatterns(project.testIgnore),
+			testMatch: parseRegexPatterns(project.testMatch),
+			timeout: project.timeout,
+			grep: parseRegexPatterns(project.grep),
+			grepInvert: parseRegexPatterns(project.grepInvert),
+			dependencies: project.dependencies,
+			teardown: project.teardown,
+			snapshotDir: this._absolutePath(project.snapshotDir),
+			use: project.use
+		};
+	}
+	_parseAttachments(attachments) {
+		return attachments.map((a) => {
+			return {
+				...a,
+				body: a.base64 && globalThis.Buffer ? Buffer.from(a.base64, "base64") : void 0
+			};
+		});
+	}
+	_mergeSuitesInto(jsonSuites, parent) {
+		if (!jsonSuites || !Array.isArray(jsonSuites)) return;
+		for (const jsonSuite of jsonSuites) {
+			let targetSuite = parent.suites.find((s) => s.title === jsonSuite.title);
+			if (!targetSuite) {
+				targetSuite = new TeleSuite(jsonSuite.title, parent._type === "project" ? "file" : "describe");
+				targetSuite.parent = parent;
+				parent.suites.push(targetSuite);
+			}
+			targetSuite.location = this._absoluteLocation(jsonSuite.location);
+			this._mergeSuitesInto(jsonSuite.suites, targetSuite);
+			const testsArray = jsonSuite.tests || jsonSuite.entries || [];
+			this._mergeTestsInto(testsArray, targetSuite);
+		}
+	}
+	_mergeTestsInto(jsonTests, parent) {
+		if (!jsonTests || !Array.isArray(jsonTests)) return;
+		for (const jsonTest of jsonTests) {
+			let targetTest = this._options.mergeTestCases ? parent.tests.find((s) => s.title === jsonTest.title && s.repeatEachIndex === jsonTest.repeatEachIndex) : void 0;
+			if (!targetTest) {
+				targetTest = new TeleTestCase(jsonTest.testId, jsonTest.title, this._absoluteLocation(jsonTest.location), jsonTest.repeatEachIndex);
+				targetTest.parent = parent;
+				parent.tests.push(targetTest);
+				this._tests.set(targetTest.id, targetTest);
+			}
+			this._updateTest(jsonTest, targetTest);
+		}
+	}
+	_updateTest(payload, test) {
+		test.id = payload.testId;
+		test.location = this._absoluteLocation(payload.location);
+		test.retries = payload.retries;
+		test.tags = payload.tags ?? [];
+		return test;
+	}
+	_absoluteLocation(location) {
+		if (!location) return location;
+		return {
+			...location,
+			file: this._absolutePath(location.file)
+		};
+	}
+	_absolutePath(relativePath) {
+		if (relativePath === void 0) return;
+		return this._options.resolvePath(this._rootDir, relativePath);
+	}
+};
+var TeleSuite = class TeleSuite {
+	title;
+	location;
+	parent;
+	_requireFile = "";
+	suites = [];
+	tests = [];
+	_timeout;
+	_retries;
+	_project;
+	_parallelMode = "none";
+	_type;
+	constructor(title, type) {
+		this.title = title;
+		this._type = type;
+	}
+	allTests() {
+		const result = [];
+		const visit = (suite) => {
+			for (const entry of [...suite.suites, ...suite.tests]) if (entry instanceof TeleSuite) visit(entry);
+			else result.push(entry);
+		};
+		visit(this);
+		return result;
+	}
+	titlePath() {
+		const titlePath = this.parent ? this.parent.titlePath() : [];
+		if (this.title || this._type !== "describe") titlePath.push(this.title);
+		return titlePath;
+	}
+	project() {
+		return this._project ?? this.parent?.project();
+	}
+};
+var TeleTestCase = class {
+	title;
+	fn = () => {};
+	results = [];
+	location;
+	parent;
+	expectedStatus = "passed";
+	timeout = 0;
+	annotations = [];
+	retries = 0;
+	tags = [];
+	repeatEachIndex = 0;
+	id;
+	_resultsMap = /* @__PURE__ */ new Map();
+	constructor(id, title, location, repeatEachIndex) {
+		this.id = id;
+		this.title = title;
+		this.location = location;
+		this.repeatEachIndex = repeatEachIndex;
+	}
+	titlePath() {
+		const titlePath = this.parent ? this.parent.titlePath() : [];
+		titlePath.push(this.title);
+		return titlePath;
+	}
+	outcome() {
+		const results = [...this.results];
+		while (results[0]?.status === "skipped" || results[0]?.status === "interrupted") results.shift();
+		if (!results.length) return "skipped";
+		const failures = results.filter((result) => result.status !== "skipped" && result.status !== "interrupted" && result.status !== this.expectedStatus);
+		if (!failures.length) return "expected";
+		if (failures.length === results.length) return "unexpected";
+		return "flaky";
+	}
+	ok() {
+		const status = this.outcome();
+		return status === "expected" || status === "flaky" || status === "skipped";
+	}
+	_clearResults() {
+		this.results = [];
+		this._resultsMap.clear();
+	}
+	_createTestResult(id) {
+		const result = new TeleTestResult(this.results.length);
+		this.results.push(result);
+		this._resultsMap.set(id, result);
+		return result;
+	}
+};
+var TeleTestStep = class {
+	title;
+	category;
+	location;
+	parent;
+	duration = -1;
+	steps = [];
+	_startTime = 0;
+	constructor(payload, parentStep, location) {
+		this.title = payload.title;
+		this.category = payload.category;
+		this.location = location;
+		this.parent = parentStep;
+		this._startTime = payload.startTime;
+	}
+	titlePath() {
+		return [...this.parent?.titlePath() || [], this.title];
+	}
+	get startTime() {
+		return new Date(this._startTime);
+	}
+	set startTime(value) {
+		this._startTime = +value;
+	}
+};
+var TeleTestResult = class {
+	retry;
+	parallelIndex = -1;
+	workerIndex = -1;
+	duration = -1;
+	stdout = [];
+	stderr = [];
+	attachments = [];
+	status = "skipped";
+	steps = [];
+	errors = [];
+	error;
+	_stepMap = /* @__PURE__ */ new Map();
+	_startTime = 0;
+	constructor(retry) {
+		this.retry = retry;
+	}
+	setStartTimeNumber(startTime) {
+		this._startTime = startTime;
+	}
+	get startTime() {
+		return new Date(this._startTime);
+	}
+	set startTime(value) {
+		this._startTime = +value;
+	}
+};
+const baseFullConfig = {
+	forbidOnly: false,
+	fullyParallel: false,
+	globalSetup: null,
+	globalTeardown: null,
+	globalTimeout: 0,
+	grep: /.*/,
+	grepInvert: null,
+	maxFailures: 0,
+	metadata: {},
+	preserveOutput: "always",
+	projects: [],
+	reporter: [[process.env.CI ? "dot" : "list"]],
+	reportSlowTests: {
+		max: 5,
+		threshold: 15e3
+	},
+	configFile: "",
+	rootDir: "",
+	quiet: false,
+	shard: null,
+	updateSnapshots: "missing",
+	version: "",
+	workers: 0,
+	webServer: null
+};
+function parseRegexPatterns(patterns) {
+	return patterns.map((p) => {
+		if (p.s !== void 0) return p.s;
+		return new RegExp(p.r.source, p.r.flags);
+	});
+}
+
+//#endregion
+//#region src/upstream/events.ts
+let Disposable;
+(function(_Disposable) {
+	function disposeAll(disposables) {
+		for (const disposable of disposables.splice(0)) disposable.dispose();
+	}
+	_Disposable.disposeAll = disposeAll;
+})(Disposable || (Disposable = {}));
+var EventEmitter = class {
+	event;
+	_deliveryQueue;
+	_listeners = /* @__PURE__ */ new Set();
+	constructor() {
+		this.event = (listener, disposables) => {
+			this._listeners.add(listener);
+			let disposed = false;
+			const self = this;
+			const result = { dispose() {
+				if (!disposed) {
+					disposed = true;
+					self._listeners.delete(listener);
+				}
+			} };
+			if (disposables) disposables.push(result);
+			return result;
+		};
+	}
+	fire(event) {
+		const dispatch = !this._deliveryQueue;
+		if (!this._deliveryQueue) this._deliveryQueue = [];
+		for (const listener of this._listeners) this._deliveryQueue.push({
+			listener,
+			event
+		});
+		if (!dispatch) return;
+		for (let index = 0; index < this._deliveryQueue.length; index++) {
+			const { listener, event: event$1 } = this._deliveryQueue[index];
+			listener.call(null, event$1);
+		}
+		this._deliveryQueue = void 0;
+	}
+	dispose() {
+		this._listeners.clear();
+		if (this._deliveryQueue) this._deliveryQueue = [];
+	}
+};
+
+//#endregion
+//#region src/upstream/testServerConnection.ts
+var WebSocketTestServerTransport = class {
+	_ws;
+	constructor(url) {
+		this._ws = new WebSocket(url);
+	}
+	onmessage(listener) {
+		this._ws.addEventListener("message", (event) => listener(event.data.toString()));
+	}
+	onopen(listener) {
+		this._ws.addEventListener("open", listener);
+	}
+	onerror(listener) {
+		this._ws.addEventListener("error", listener);
+	}
+	onclose(listener) {
+		this._ws.addEventListener("close", listener);
+	}
+	send(data) {
+		this._ws.send(data);
+	}
+	close() {
+		this._ws.close();
+	}
+};
+var TestServerConnection = class {
+	onClose;
+	onReport;
+	onStdio;
+	onTestFilesChanged;
+	onLoadTraceRequested;
+	_onCloseEmitter = new EventEmitter();
+	_onReportEmitter = new EventEmitter();
+	_onStdioEmitter = new EventEmitter();
+	_onTestFilesChangedEmitter = new EventEmitter();
+	_onLoadTraceRequestedEmitter = new EventEmitter();
+	_lastId = 0;
+	_transport;
+	_callbacks = /* @__PURE__ */ new Map();
+	_connectedPromise;
+	_isClosed = false;
+	constructor(transport) {
+		this.onClose = this._onCloseEmitter.event;
+		this.onReport = this._onReportEmitter.event;
+		this.onStdio = this._onStdioEmitter.event;
+		this.onTestFilesChanged = this._onTestFilesChangedEmitter.event;
+		this.onLoadTraceRequested = this._onLoadTraceRequestedEmitter.event;
+		this._transport = transport;
+		this._transport.onmessage((data) => {
+			const { id, result, error, method, params } = JSON.parse(data);
+			if (id) {
+				const callback = this._callbacks.get(id);
+				if (!callback) return;
+				this._callbacks.delete(id);
+				if (error) callback.reject(new Error(error));
+				else callback.resolve(result);
+			} else this._dispatchEvent(method, params);
+		});
+		const pingInterval = setInterval(() => this._sendMessage("ping").catch(() => {}), 3e4);
+		this._connectedPromise = new Promise((f, r) => {
+			this._transport.onopen(f);
+			this._transport.onerror(r);
+		});
+		this._transport.onclose(() => {
+			this._isClosed = true;
+			this._onCloseEmitter.fire();
+			clearInterval(pingInterval);
+			for (const callback of this._callbacks.values()) callback.reject(/* @__PURE__ */ new Error("test server connection closed"));
+			this._callbacks.clear();
+		});
+	}
+	isClosed() {
+		return this._isClosed;
+	}
+	async _sendMessage(method, params) {
+		const logForTest = globalThis.__logForTest;
+		logForTest?.({
+			method,
+			params
+		});
+		await this._connectedPromise;
+		const id = ++this._lastId;
+		const message = {
+			id,
+			method,
+			params
+		};
+		this._transport.send(JSON.stringify(message));
+		return new Promise((resolve, reject) => {
+			this._callbacks.set(id, {
+				resolve,
+				reject
+			});
+		});
+	}
+	_sendMessageNoReply(method, params) {
+		this._sendMessage(method, params).catch(() => {});
+	}
+	_dispatchEvent(method, params) {
+		if (method === "report") this._onReportEmitter.fire(params);
+		else if (method === "stdio") this._onStdioEmitter.fire(params);
+		else if (method === "testFilesChanged") this._onTestFilesChangedEmitter.fire(params);
+		else if (method === "loadTraceRequested") this._onLoadTraceRequestedEmitter.fire(params);
+	}
+	async initialize(params) {
+		await this._sendMessage("initialize", params);
+	}
+	async ping(params) {
+		await this._sendMessage("ping", params);
+	}
+	async pingNoReply(params) {
+		this._sendMessageNoReply("ping", params);
+	}
+	async watch(params) {
+		await this._sendMessage("watch", params);
+	}
+	watchNoReply(params) {
+		this._sendMessageNoReply("watch", params);
+	}
+	async open(params) {
+		await this._sendMessage("open", params);
+	}
+	openNoReply(params) {
+		this._sendMessageNoReply("open", params);
+	}
+	async resizeTerminal(params) {
+		await this._sendMessage("resizeTerminal", params);
+	}
+	resizeTerminalNoReply(params) {
+		this._sendMessageNoReply("resizeTerminal", params);
+	}
+	async checkBrowsers(params) {
+		return await this._sendMessage("checkBrowsers", params);
+	}
+	async installBrowsers(params) {
+		await this._sendMessage("installBrowsers", params);
+	}
+	async runGlobalSetup(params) {
+		return await this._sendMessage("runGlobalSetup", params);
+	}
+	async runGlobalTeardown(params) {
+		return await this._sendMessage("runGlobalTeardown", params);
+	}
+	async startDevServer(params) {
+		return await this._sendMessage("startDevServer", params);
+	}
+	async stopDevServer(params) {
+		return await this._sendMessage("stopDevServer", params);
+	}
+	async clearCache(params) {
+		return await this._sendMessage("clearCache", params);
+	}
+	async listFiles(params) {
+		return await this._sendMessage("listFiles", params);
+	}
+	async listTests(params) {
+		return await this._sendMessage("listTests", params);
+	}
+	async runTests(params) {
+		return await this._sendMessage("runTests", params);
+	}
+	async findRelatedTestFiles(params) {
+		return await this._sendMessage("findRelatedTestFiles", params);
+	}
+	async stopTests(params) {
+		await this._sendMessage("stopTests", params);
+	}
+	stopTestsNoReply(params) {
+		this._sendMessageNoReply("stopTests", params);
+	}
+	async closeGracefully(params) {
+		await this._sendMessage("closeGracefully", params);
+	}
+	close() {
+		try {
+			this._transport.close();
+		} catch {}
+	}
+};
+
+//#endregion
+//#region src/playwrightTestServer.ts
+/**
+* Escape special regex characters in a path
+* From playwright-vscode: src/utils.ts
+*/
+function escapeRegex(text) {
+	if (text.startsWith("/")) text = text.substring(1);
+	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var CancellationToken = class {
+	_isCancelled = false;
+	_onCancelEmitter = new EventEmitter();
+	get isCancellationRequested() {
+		return this._isCancelled;
+	}
+	get onCancellationRequested() {
+		return this._onCancelEmitter.event;
+	}
+	cancel() {
+		this._isCancelled = true;
+		this._onCancelEmitter.fire();
+	}
+};
+var PlaywrightTestServer = class {
+	_config;
+	_options;
+	_testServerPromise;
+	_cli = null;
+	constructor(config = {
+		workspaceFolder: process.cwd(),
+		configFile: "playwright.config.ts"
+	}, options = {}) {
+		this._config = config;
+		this._options = options;
+	}
+	/**
+	* Find Playwright CLI path
+	*/
+	_findPlaywrightCli() {
+		if (this._cli) return this._cli;
+		try {
+			const playwrightPackage = __require.resolve("@playwright/test/package.json", { paths: [this._config.workspaceFolder] });
+			this._cli = path.join(path.dirname(playwrightPackage), "cli.js");
+			return this._cli;
+		} catch {
+			throw new Error("Playwright installation not found. Please install @playwright/test");
+		}
+	}
+	reset() {
+		this._disposeTestServer();
+	}
+	async listFiles() {
+		const testServer = await this._testServer();
+		if (!testServer.connection) {
+			const errors = testServer.errors.length ? ". Test server errors: " + testServer.errors.join("\n") : "";
+			throw new Error("Internal error: unable to connect to the test server." + errors);
+		}
+		const result = { projects: [] };
+		const { report } = await testServer.connection.listFiles({});
+		const teleReceiver = new TeleReporterReceiver({
+			onConfigure: (_config) => {},
+			onBegin(rootSuite) {
+				for (const projectSuite of rootSuite.suites) {
+					const project = projectSuite.project();
+					const files = [];
+					result.projects.push({
+						name: project.name,
+						testDir: project.testDir,
+						use: project.use || {},
+						files
+					});
+					for (const fileSuite of projectSuite.suites) files.push(fileSuite.location.file);
+				}
+			},
+			onError(error) {
+				result.error = error;
+			}
+		}, {
+			mergeProjects: true,
+			mergeTestCases: true,
+			resolvePath: (rootDir, relativePath) => path.join(rootDir, relativePath)
+		});
+		for (const message of report) teleReceiver.dispatch(message);
+		return result;
+	}
+	async listTests(locations, reporter, token) {
+		const { connection } = await this._testServer();
+		if (token?.isCancellationRequested) return;
+		if (!connection) return;
+		const escapedLocations = locations.map(escapeRegex);
+		const { report } = await connection.listTests({ locations: escapedLocations });
+		const teleReceiver = new TeleReporterReceiver(reporter, {
+			mergeProjects: true,
+			mergeTestCases: true,
+			resolvePath: (rootDir, relativePath) => path.join(rootDir, relativePath)
+		});
+		for (const message of report) teleReceiver.dispatch(message);
+	}
+	async findRelatedTestFiles(files) {
+		const testServer = await this._testServer();
+		if (!testServer.connection) return {
+			testFiles: files,
+			errors: [{ message: "Internal error: unable to connect to the test server" }]
+		};
+		return await testServer.connection.findRelatedTestFiles({ files });
+	}
+	_testServer() {
+		if (this._testServerPromise) return this._testServerPromise;
+		this._testServerPromise = this._createTestServer();
+		return this._testServerPromise;
+	}
+	async _createTestServer() {
+		const cwd = this._config.workspaceFolder;
+		const cli = path.relative(cwd, this._findPlaywrightCli());
+		const config = path.relative(cwd, this._config.configFile);
+		const errors = [];
+		const wsEndpoint = await this._startBackend({
+			args: [
+				cli,
+				"test-server",
+				"-c",
+				config
+			],
+			cwd,
+			envProvider: () => {
+				const env = this._options.envProvider?.(this._config.configFile) || {};
+				return {
+					...process.env,
+					...env,
+					FORCE_COLOR: "1"
+				};
+			},
+			errors,
+			onClose: () => {
+				this._testServerPromise = void 0;
+			},
+			onError: () => {
+				this._testServerPromise = void 0;
+			}
+		});
+		if (!wsEndpoint) return {
+			connection: null,
+			errors
+		};
+		const connection = new TestServerConnection(new WebSocketTestServerTransport(wsEndpoint));
+		await connection.initialize({
+			interceptStdio: true,
+			closeOnDisconnect: true
+		});
+		return {
+			connection,
+			errors
+		};
+	}
+	async _startBackend(options) {
+		const node = process.execPath;
+		const env = this._addNpmRunPath({
+			...process.env,
+			...options.envProvider()
+		}, options.cwd);
+		const serverProcess = spawn(node, options.args, {
+			cwd: options.cwd,
+			stdio: "pipe",
+			env
+		});
+		serverProcess.stderr?.on("data", (data) => {
+			const message = data.toString();
+			options.errors.push(message);
+			this._options.onStdErr?.(message);
+		});
+		serverProcess.on("error", options.onError);
+		serverProcess.on("close", options.onClose);
+		return new Promise((fulfill) => {
+			serverProcess.stdout?.on("data", async (data) => {
+				const output = data.toString();
+				this._options.onStdOut?.(output);
+				const match = output.match(/Listening on (.*)/);
+				if (match) fulfill(match[1]);
+			});
+			serverProcess.on("exit", () => fulfill(null));
+		});
+	}
+	_addNpmRunPath(env, cwd) {
+		const pathSeparator = process.platform === "win32" ? ";" : ":";
+		const newPath = [];
+		let currentPath = path.resolve(cwd);
+		let previousPath;
+		while (previousPath !== currentPath) {
+			newPath.push(path.join(currentPath, "node_modules", ".bin"));
+			previousPath = currentPath;
+			currentPath = path.resolve(currentPath, "..");
+		}
+		const defaultPath = process.platform === "win32" ? "Path" : "PATH";
+		const pathKey = Object.keys(env).find((k) => k.toLowerCase() === "path") ?? defaultPath;
+		if (env[pathKey]) newPath.push(env[pathKey]);
+		return {
+			...env,
+			[pathKey]: newPath.join(pathSeparator)
+		};
+	}
+	_disposeTestServer() {
+		const testServer = this._testServerPromise;
+		this._testServerPromise = void 0;
+		if (testServer) testServer.then((server) => server.connection?.close());
+	}
+	close() {
+		this._disposeTestServer();
+	}
+};
+
+//#endregion
+//#region src/api.ts
+async function listTestFile(workspaceFolder = process.cwd(), configFile = "playwright.config.ts", outputFile) {
+	const testServer = new PlaywrightTestServer({
+		workspaceFolder,
+		configFile: path.join(workspaceFolder, configFile)
+	});
+	try {
+		const output = { projects: (await testServer.listFiles()).projects };
+		const jsonString = JSON.stringify(output, null, 2);
+		if (outputFile) {
+			await fs.writeFile(outputFile, jsonString, "utf-8");
+			console.log(`Results saved to: ${outputFile}`);
+		} else console.log(jsonString);
+		testServer.close();
+	} catch (error) {
+		console.error("Error:", error);
+		testServer.close();
+	}
+}
+async function listTestCase(workspaceFolder = process.cwd(), configFile = "playwright.config.ts", relativePaths, outputFile) {
+	const testServer = new PlaywrightTestServer({
+		workspaceFolder,
+		configFile: path.join(workspaceFolder, configFile)
+	});
+	const reporter = { async onBegin(suite) {
+		const tests = [];
+		function walkSuite(s) {
+			if (s.tests) for (const test of s.tests) tests.push({
+				title: test.title,
+				file: test.location.file,
+				line: test.location.line,
+				column: test.location.column,
+				tags: test.tags || [],
+				annotations: test.annotations || [],
+				expectedStatus: test.expectedStatus,
+				timeout: test.timeout,
+				titlePath: test.titlePath()
+			});
+			if (s.suites) for (const child of s.suites) walkSuite(child);
+		}
+		walkSuite(suite);
+		const output = { tests };
+		const jsonString = JSON.stringify(output, null, 2);
+		if (outputFile) {
+			await fs.writeFile(outputFile, jsonString, "utf-8");
+			console.log(`Results saved to: ${outputFile}`);
+		} else console.log(jsonString);
+	} };
+	try {
+		const token = new CancellationToken();
+		if (relativePaths.length > 0) await testServer.listTests(relativePaths, reporter, token);
+		testServer.close();
+	} catch (error) {
+		console.error("Error:", error);
+		testServer.close();
+	}
+}
+async function treeStructure(workspaceFolder = process.cwd(), configFile = "playwright.config.ts", cancellationToken, outputFile) {
+	const testServer = new PlaywrightTestServer({
+		workspaceFolder,
+		configFile: path.join(workspaceFolder, configFile)
+	});
+	const reporter = { async onBegin(suite) {
+		function buildTree(s) {
+			const node = {
+				type: "suite",
+				title: s.title || "Root",
+				file: s.location ? s.location.file : void 0,
+				children: []
+			};
+			if (s.tests) for (const test of s.tests) node.children.push({
+				type: "test",
+				title: test.title,
+				location: {
+					file: test.location.file,
+					line: test.location.line,
+					column: test.location.column
+				},
+				tags: test.tags || [],
+				annotations: test.annotations || [],
+				expectedStatus: test.expectedStatus,
+				timeout: test.timeout
+			});
+			if (s.suites) for (const child of s.suites) node.children.push(buildTree(child));
+			return node;
+		}
+		const tree = buildTree(suite);
+		const jsonString = JSON.stringify(tree, null, 2);
+		if (outputFile) {
+			await fs.writeFile(outputFile, jsonString, "utf-8");
+			console.log(`Results saved to: ${outputFile}`);
+		} else console.log(jsonString);
+	} };
+	try {
+		const token = cancellationToken || new CancellationToken();
+		const files = await testServer.listFiles();
+		if (files.projects.length > 0) {
+			const allRelativePaths = [];
+			for (const project of files.projects) if (project.files.length > 0) {
+				const relativePaths = project.files.map((absolutePath) => {
+					return path.relative(workspaceFolder, absolutePath);
+				});
+				allRelativePaths.push(...relativePaths);
+			}
+			if (allRelativePaths.length > 0) await testServer.listTests(allRelativePaths, reporter, token);
+		}
+		testServer.close();
+	} catch (error) {
+		console.error("Error:", error);
+		testServer.close();
+	}
+}
+
+//#endregion
+export { CancellationToken as i, listTestFile as n, treeStructure as r, listTestCase as t };