Skip to content

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

chore: remove ai slops from dashboard app (#40302)

Pavel Feldman42c2478602bc
diff --git a/packages/playwright-core/src/tools/cli-client/program.ts b/packages/playwright-core/src/tools/cli-client/program.ts
index 2e27bb5a32..606ab7b98c 100644
--- a/packages/playwright-core/src/tools/cli-client/program.ts
+++ b/packages/playwright-core/src/tools/cli-client/program.ts
@@ -180,13 +180,19 @@ export async function program(options?: { embedderVersion?: string}) {
const daemonScript = libPath('entry', 'dashboardApp.js');
const daemonArgs = [
daemonScript,
- `--session=${sessionName}`,
- `--workspace=${clientInfo.workspaceDir ?? ''}`,
+ `--sessionName=${sessionName}`,
+ `--workspaceDir=${clientInfo.workspaceDir ?? ''}`,
];
if (args.port !== undefined)
daemonArgs.push(`--port=${args.port}`);
if (args.host !== undefined)
daemonArgs.push(`--host=${args.host as string}`);
+ if (args.kill) {
+ daemonArgs.push(`--kill`);
+ const child = spawn(process.execPath, daemonArgs, { stdio: 'ignore' });
+ await new Promise<void>(resolve => child.on('exit', () => resolve()));
+ return;
+ }
if (args.annotate) {
const dashboard = spawn(process.execPath, daemonArgs, { detached: true, stdio: 'ignore' });
dashboard.unref();
diff --git a/packages/playwright-core/src/tools/cli-daemon/commands.ts b/packages/playwright-core/src/tools/cli-daemon/commands.ts
index 3863c30dd6..34dd5da7ec 100644
--- a/packages/playwright-core/src/tools/cli-daemon/commands.ts
+++ b/packages/playwright-core/src/tools/cli-daemon/commands.ts
@@ -858,6 +858,7 @@ const devtoolsShow = declareCommand({
port: numberArg.optional().describe('Start as a blocking HTTP server on this port (use 0 for a random port)'),
host: z.string().optional().describe('Host to bind to when using --port (defaults to localhost)'),
annotate: z.boolean().optional().describe('Switch the dashboard into annotation mode.'),
+ kill: z.boolean().optional().describe('Kill the dashboard daemon.'),
}),
toolName: '',
toolParams: () => ({}),
diff --git a/packages/playwright-core/src/tools/dashboard/dashboardApp.ts b/packages/playwright-core/src/tools/dashboard/dashboardApp.ts
index 6639cba552..84aafe5e38 100644
--- a/packages/playwright-core/src/tools/dashboard/dashboardApp.ts
+++ b/packages/playwright-core/src/tools/dashboard/dashboardApp.ts
@@ -32,23 +32,19 @@ import { DashboardConnection } from './dashboardController';
import type * as api from '../../..';
import type { AnnotationData } from '@dashboard/dashboardChannel';
-type RevealOptions = { sessionName?: string; workspaceDir?: string };
-
-type DashboardCommand = RevealOptions & { command: 'bringToFront' | 'annotate' };
-
type DashboardServer = {
url: string;
- reveal: (options: RevealOptions) => void;
+ reveal: (options: DashboardOptions) => void;
triggerAnnotate: () => void;
registerAnnotateWaiter: (socket: net.Socket) => void;
};
-async function startDashboardServer(options: { port?: number; host?: string; reveal?: RevealOptions } = {}): Promise<DashboardServer> {
+async function startDashboardServer(options: DashboardOptions): Promise<DashboardServer> {
const httpServer = new HttpServer();
const dashboardDir = libPath('vite', 'dashboard');
const connections = new Set<DashboardConnection>();
- let currentReveal: RevealOptions = options.reveal ?? {};
+ let currentReveal: DashboardOptions = options;
let pendingAnnotate = false;
const waitingSockets = new Set<net.Socket>();
@@ -88,7 +84,7 @@ async function startDashboardServer(options: { port?: number; host?: string; rev
});
await httpServer.start({ port: options.port, host: options.host });
- const reveal = (next: RevealOptions) => {
+ const reveal = (next: DashboardOptions) => {
currentReveal = next;
if (!next.sessionName)
return;
@@ -115,8 +111,8 @@ async function startDashboardServer(options: { port?: number; host?: string; rev
return { url: httpServer.urlPrefix('human-readable'), reveal, triggerAnnotate, registerAnnotateWaiter };
}
-async function innerOpenDashboardApp(initialReveal: RevealOptions): Promise<{ page: api.Page; server: DashboardServer }> {
- const server = await startDashboardServer({ reveal: initialReveal });
+async function innerOpenDashboardApp(options: DashboardOptions): Promise<{ page: api.Page; server: DashboardServer }> {
+ const server = await startDashboardServer(options);
const { page } = await launchApp('dashboard');
await page.goto(server.url);
return { page, server };
@@ -193,23 +189,29 @@ function dashboardSocketPath() {
return makeSocketPath('dashboard', 'app');
}
-type OpenArgs = { reveal: RevealOptions; port?: number; host?: string; annotate: boolean };
+type DashboardOptions = {
+ sessionName: string;
+ workspaceDir: string;
+ kill?: boolean;
+ annotate?: boolean;
+ port?: number;
+ host?: string;
+};
-function parseOpenArgs(): OpenArgs {
- const args = minimist(process.argv.slice(2), { string: ['session', 'workspace', 'host'], boolean: ['annotate'] });
+function parseOpenArgs(): DashboardOptions {
+ const args = minimist(process.argv.slice(2), { string: ['sessionName', 'workspaceDir', 'host'], boolean: ['annotate', 'kill'] });
const portStr = args.port as string | undefined;
return {
- reveal: {
- sessionName: (args.session as string) || undefined,
- workspaceDir: (args.workspace as string) || undefined,
- },
+ sessionName: args.sessionName as string,
+ workspaceDir: args.workspaceDir as string,
port: portStr !== undefined ? Number(portStr) : undefined,
- host: (args.host as string) || undefined,
+ host: args.host as string | undefined,
annotate: !!args.annotate,
+ kill: !!args.kill,
};
}
-async function acquireSingleton(reveal: RevealOptions): Promise<net.Server> {
+async function acquireSingleton(options: DashboardOptions): Promise<net.Server> {
const socketPath = dashboardSocketPath();
if (process.platform !== 'win32')
await fs.promises.mkdir(path.dirname(socketPath), { recursive: true });
@@ -221,8 +223,7 @@ async function acquireSingleton(reveal: RevealOptions): Promise<net.Server> {
if (err.code !== 'EADDRINUSE')
return reject(err);
const client = net.connect(socketPath, () => {
- const message: DashboardCommand = { command: 'bringToFront', ...reveal };
- client.write(JSON.stringify(message) + '\n');
+ client.write(JSON.stringify(options) + '\n');
reject(new Error('already running'));
});
client.on('error', () => {
@@ -235,17 +236,21 @@ async function acquireSingleton(reveal: RevealOptions): Promise<net.Server> {
}
export async function openDashboardApp() {
- const args = parseOpenArgs();
- if (args.annotate) {
- await runAnnotateClient(args);
+ const options = parseOpenArgs();
+ if (options.kill) {
+ await runKillClient();
+ return;
+ }
+ if (options.annotate) {
+ await runAnnotateClient(options);
return;
}
process.on('unhandledRejection', error => {
// eslint-disable-next-line no-console
console.error('Unhandled promise rejection:', error);
});
- if (args.port !== undefined) {
- const { url } = await startDashboardServer({ port: args.port, host: args.host, reveal: args.reveal });
+ if (options.port !== undefined) {
+ const { url } = await startDashboardServer(options);
// eslint-disable-next-line no-console
console.log(`Listening on ${url}`);
selfDestructOnParentGone();
@@ -254,11 +259,11 @@ export async function openDashboardApp() {
let server: net.Server | undefined;
process.on('exit', () => server?.close());
try {
- server = await acquireSingleton(args.reveal);
+ server = await acquireSingleton(options);
} catch {
return;
}
- const statePromise = innerOpenDashboardApp(args.reveal);
+ const statePromise = innerOpenDashboardApp(options);
server?.on('connection', socket => {
let buffer = '';
socket.on('data', data => {
@@ -268,27 +273,29 @@ export async function openDashboardApp() {
return;
const line = buffer.slice(0, newlineIndex);
buffer = buffer.slice(newlineIndex + 1);
- let parsed: DashboardCommand | undefined;
+ let parsed: DashboardOptions | undefined;
try {
parsed = JSON.parse(line);
} catch {
// no-op
}
- if (!parsed?.command) {
+ if (!parsed) {
socket.end();
return;
}
void statePromise.then(({ page, server: dashboard }) => {
- const revealTo = { sessionName: parsed.sessionName, workspaceDir: parsed.workspaceDir };
- if (parsed.command === 'bringToFront') {
- page?.bringToFront().catch(() => {});
- dashboard.reveal(revealTo);
- socket.end();
- } else if (parsed.command === 'annotate') {
+ if (parsed.annotate) {
page?.bringToFront().catch(() => {});
- dashboard.reveal(revealTo);
+ dashboard.reveal(parsed);
dashboard.triggerAnnotate();
dashboard.registerAnnotateWaiter(socket);
+ } else if (parsed.kill) {
+ socket.end();
+ gracefullyProcessExitDoNotHang(0);
+ } else {
+ page?.bringToFront().catch(() => {});
+ dashboard.reveal(parsed);
+ socket.end();
}
});
});
@@ -296,7 +303,19 @@ export async function openDashboardApp() {
await statePromise;
}
-async function runAnnotateClient(args: OpenArgs): Promise<void> {
+async function runKillClient(): Promise<void> {
+ const socketPath = dashboardSocketPath();
+ await new Promise<void>(resolve => {
+ const client = net.connect(socketPath);
+ client.once('connect', () => {
+ client.write(JSON.stringify({ kill: true }) + '\n');
+ });
+ client.once('end', () => resolve());
+ client.once('error', () => resolve());
+ });
+}
+
+async function runAnnotateClient(options: DashboardOptions): Promise<void> {
selfDestructOnParentGone();
const socketPath = dashboardSocketPath();
@@ -320,8 +339,7 @@ async function runAnnotateClient(args: OpenArgs): Promise<void> {
gracefullyProcessExitDoNotHang(1);
return;
}
- const message: DashboardCommand = { command: 'annotate', ...args.reveal };
- socket.write(JSON.stringify(message) + '\n');
+ socket.write(JSON.stringify(options) + '\n');
const chunks: Buffer[] = [];
await new Promise<void>((resolve, reject) => {
socket!.on('data', chunk => chunks.push(chunk));
diff --git a/tests/mcp/cli-fixtures.ts b/tests/mcp/cli-fixtures.ts
index 0758f4ab73..e8703fe0e5 100644
--- a/tests/mcp/cli-fixtures.ts
+++ b/tests/mcp/cli-fixtures.ts
@@ -68,6 +68,7 @@ export const test = baseTest.extend<{
}).toPass();
return await playwright.chromium.connect(endpoint);
});
+ await cli('show', '--kill');
},
cli: async ({ mcpBrowser, mcpHeadless, childProcess }, use) => {
const sessions: { name: string, pid: number }[] = [];