chore: pass daemon session config to the server

Author: pavelfeldman

packages/playwright/src/mcp/browser/config.ts

@@ -26,6 +26,7 @@ import { firstRootPath } from '../sdk/server';
 import type * as playwright from '../../../types/test';
 import type { Config, ToolCapability } from '../config';
 import type { ClientInfo } from '../sdk/server';
+import type { SessionConfig } from '../terminal/program';
 
 type ViewportSize = { width: number; height: number };
 
@@ -42,9 +43,7 @@ export type CLIOptions = {
   codegen?: 'typescript' | 'none';
   config?: string;
   consoleLevel?: 'error' | 'warning' | 'info' | 'debug';
-  daemon?: string;
-  daemonDataDir?: string;
-  daemonHeaded?: boolean;
+  daemonSession?: string;
   device?: string;
   extension?: boolean;
   executablePath?: string;
@@ -107,22 +106,6 @@ export const defaultConfig: FullConfig = {
   },
 };
 
-const defaultDaemonConfig = (cliOptions: CLIOptions) => mergeConfig(defaultConfig, {
-  browser: {
-    userDataDir: '<daemon-data-dir>',
-    launchOptions: {
-      headless: !cliOptions.daemonHeaded,
-    },
-    contextOptions: {
-      viewport: cliOptions.daemonHeaded ? null : { width: 1280, height: 720 },
-    },
-  },
-  outputMode: 'file',
-  snapshot: {
-    mode: 'full',
-  },
-});
-
 type BrowserUserConfig = NonNullable<Config['browser']>;
 
 export type FullConfig = Config & {
@@ -146,32 +129,36 @@ export type FullConfig = Config & {
     navigation: number;
   },
   skillMode?: boolean;
+  configFile?: string;
+  sessionConfig?: SessionConfig;
 };
 
 export async function resolveConfig(config: Config): Promise<FullConfig> {
   return mergeConfig(defaultConfig, config);
 }
 
 export async function resolveCLIConfig(cliOptions: CLIOptions): Promise<FullConfig> {
-  const configInFile = await loadConfig(cliOptions.config);
   const envOverrides = configFromEnv();
+  const daemonOverrides = await configForDaemonSession(cliOptions);
   const cliOverrides = configFromCLIOptions(cliOptions);
-  let result = cliOptions.daemon ? defaultDaemonConfig(cliOptions) : defaultConfig;
+  const configFile = cliOverrides.configFile ?? envOverrides.configFile ?? daemonOverrides.configFile;
+  const configInFile = await loadConfig(configFile);
+
+  let result = defaultConfig;
   result = mergeConfig(result, configInFile);
+  result = mergeConfig(result, daemonOverrides);
   result = mergeConfig(result, envOverrides);
   result = mergeConfig(result, cliOverrides);
 
-  if (cliOptions.daemon)
+  if (daemonOverrides.sessionConfig) {
     result.skillMode = true;
 
-  if (result.browser.userDataDir === '<daemon-data-dir>') {
-    // No custom value provided, use the daemon data dir.
-    const browserToken = result.browser.launchOptions?.channel ?? result.browser?.browserName;
-    const userDataDir = `${cliOptions.daemonDataDir}-${browserToken}`;
-
-    // Use default user profile with extension.
-    if (!result.extension)
+    if (!result.extension && !result.browser.userDataDir && daemonOverrides.sessionConfig.userDataDirPrefix) {
+      // No custom value provided, use the daemon data dir.
+      const browserToken = result.browser.launchOptions?.channel ?? result.browser?.browserName;
+      const userDataDir = `${daemonOverrides.sessionConfig.userDataDirPrefix}-${browserToken}`;
       result.browser.userDataDir = userDataDir;
+    }
   }
 
   if (result.browser.browserName === 'chromium' && result.browser.launchOptions.chromiumSandbox === undefined) {
@@ -181,7 +168,15 @@ export async function resolveCLIConfig(cliOptions: CLIOptions): Promise<FullConf
       result.browser.launchOptions.chromiumSandbox = true;
   }
 
+  result.configFile = configFile;
+  result.sessionConfig = daemonOverrides.sessionConfig;
+
+  // Daemon has different defaults.
+  if (result.sessionConfig && result.browser.launchOptions.headless !== false)
+    result.browser.contextOptions.viewport ??= { width: 1280, height: 720 };
+
   await validateConfig(result);
+
   return result;
 }
 
@@ -202,7 +197,7 @@ async function validateConfig(config: FullConfig): Promise<void> {
     throw new Error('saveVideo is not supported when sharedBrowserContext is true');
 }
 
-export function configFromCLIOptions(cliOptions: CLIOptions): Config {
+export function configFromCLIOptions(cliOptions: CLIOptions): Config & { configFile?: string } {
   let browserName: 'chromium' | 'firefox' | 'webkit' | undefined;
   let channel: string | undefined;
   switch (cliOptions.browser) {
@@ -269,7 +264,7 @@ export function configFromCLIOptions(cliOptions: CLIOptions): Config {
   if (cliOptions.grantPermissions)
     contextOptions.permissions = cliOptions.grantPermissions;
 
-  const result: Config = {
+  const config: Config = {
     browser: {
       browserName,
       isolated: cliOptions.isolated,
@@ -313,10 +308,10 @@ export function configFromCLIOptions(cliOptions: CLIOptions): Config {
     },
   };
 
-  return result;
+  return { ...config, configFile: cliOptions.config };
 }
 
-function configFromEnv(): Config {
+function configFromEnv(): Config & { configFile?: string } {
   const options: CLIOptions = {};
   options.allowedHosts = commaSeparatedList(process.env.PLAYWRIGHT_MCP_ALLOWED_HOSTNAMES);
   options.allowedOrigins = semicolonSeparatedList(process.env.PLAYWRIGHT_MCP_ALLOWED_ORIGINS);
@@ -364,6 +359,23 @@ function configFromEnv(): Config {
   return configFromCLIOptions(options);
 }
 
+async function configForDaemonSession(cliOptions: CLIOptions): Promise<Config & { configFile?: string, sessionConfig?: SessionConfig }> {
+  if (!cliOptions.daemonSession)
+    return {};
+
+  const sessionConfig = await fs.promises.readFile(cliOptions.daemonSession, 'utf-8').then(data => JSON.parse(data) as SessionConfig);
+  const config = configFromCLIOptions({
+    config: sessionConfig.cli.config,
+    browser: sessionConfig.cli.browser,
+    isolated: sessionConfig.cli.isolated,
+    headless: !sessionConfig.cli.headed,
+    extension: sessionConfig.cli.extension,
+    outputMode: 'file',
+    snapshotMode: 'full',
+  });
+  return { ...config, sessionConfig };
+}
+
 async function loadConfig(configFile: string | undefined): Promise<Config> {
   if (!configFile)
     return {};

packages/playwright/src/mcp/browser/response.ts

@@ -142,6 +142,8 @@ export class Response {
 
     const text: string[] = [];
     for (const section of sections) {
+      if (!section.content.length)
+        continue;
       text.push(`### ${section.title}`);
       if (section.codeframe)
         text.push(`\`\`\`${section.codeframe}`);

packages/playwright/src/mcp/program.ts

@@ -77,10 +77,7 @@ export function decorateCommand(command: Command, version: string) {
       .option('--user-data-dir <path>', 'path to the user data directory. If not specified, a temporary directory will be created.')
       .option('--viewport-size <size>', 'specify browser viewport size in pixels, for example "1280x720"', resolutionParser.bind(null, '--viewport-size'))
       .addOption(new ProgramOption('--vision', 'Legacy option, use --caps=vision instead').hideHelp())
-      .addOption(new ProgramOption('--daemon <socket>', 'run as daemon').hideHelp())
-      .addOption(new ProgramOption('--daemon-data-dir <path>', 'path to the daemon data directory.').hideHelp())
-      .addOption(new ProgramOption('--daemon-headed', 'run daemon in headed mode').hideHelp())
-      .addOption(new ProgramOption('--daemon-version <version>', 'version of this daemon').hideHelp())
+      .addOption(new ProgramOption('--daemon-session <path>', 'path to the daemon config.').hideHelp())
       .action(async options => {
 
         // normalize the --no-sandbox option: sandbox = true => nothing was passed, sandbox = false => --no-sandbox was passed.
@@ -110,15 +107,15 @@ export function decorateCommand(command: Command, version: string) {
         const browserContextFactory = contextFactory(config);
         const extensionContextFactory = new ExtensionContextFactory(config.browser.launchOptions.channel || 'chrome', config.browser.userDataDir, config.browser.launchOptions.executablePath);
 
-        if (options.daemon) {
+        if (config.sessionConfig) {
           const contextFactory = config.extension ? extensionContextFactory : browserContextFactory;
           const serverBackendFactory: mcpServer.ServerBackendFactory = {
             name: 'Playwright',
             nameInConfig: 'playwright-daemon',
             version,
             create: () => new BrowserServerBackend(config, contextFactory, { allTools: true })
           };
-          const socketPath = await startMcpDaemonServer(options.daemon, serverBackendFactory, options.daemonVersion);
+          const socketPath = await startMcpDaemonServer(config.sessionConfig, serverBackendFactory);
           console.error(`Daemon server listening on ${socketPath}`);
           return;
         }

packages/playwright/src/mcp/terminal/commands.ts

@@ -26,10 +26,10 @@ const open = declareCommand({
   description: 'Open URL',
   category: 'core',
   args: z.object({
-    url: z.string().describe('The URL to navigate to'),
+    url: z.string().optional().describe('The URL to navigate to'),
   }),
   toolName: 'browser_navigate',
-  toolParams: ({ url }) => ({ url }),
+  toolParams: ({ url }) => ({ url: url || 'about:blank' }),
 });
 
 const close = declareCommand({
@@ -498,6 +498,17 @@ const sessionList = declareCommand({
   toolParams: () => ({}),
 });
 
+const sessionRestart = declareCommand({
+  name: 'session-restart',
+  description: 'Restart session',
+  category: 'session',
+  args: z.object({
+    name: z.string().optional().describe('Name of the session to restart. If omitted, current session is restarted.'),
+  }),
+  toolName: '',
+  toolParams: () => ({}),
+});
+
 const sessionStop = declareCommand({
   name: 'session-stop',
   description: 'Stop session',
@@ -603,6 +614,7 @@ const commandsArray: AnyCommandSchema[] = [
   // session category
   sessionList,
   sessionStop,
+  sessionRestart,
   sessionStopAll,
   sessionDelete,
 ];

packages/playwright/src/mcp/terminal/daemon.ts

@@ -29,6 +29,7 @@ import { parseCommand } from './command';
 
 import type { ServerBackendFactory } from '../sdk/server';
 import type * as mcp from '../sdk/exports';
+import type { SessionConfig } from './program';
 
 const daemonDebug = debug('pw:daemon');
 
@@ -42,14 +43,11 @@ async function socketExists(socketPath: string): Promise<boolean> {
   return false;
 }
 
-/**
- * Start a daemon server listening on Unix domain socket (Unix) or named pipe (Windows).
- */
 export async function startMcpDaemonServer(
-  socketPath: string,
+  sessionConfig: SessionConfig,
   serverBackendFactory: ServerBackendFactory,
-  daemonVersion: string
 ): Promise<string> {
+  const { socketPath, version } = sessionConfig;
   // Clean up existing socket file on Unix
   if (os.platform() !== 'win32' && await socketExists(socketPath)) {
     daemonDebug(`Socket already exists, removing: ${socketPath}`);
@@ -85,26 +83,10 @@ export async function startMcpDaemonServer(
 
   const server = net.createServer(socket => {
     daemonDebug('new client connection');
-    const connection = new SocketConnection(socket, daemonVersion);
+    const connection = new SocketConnection(socket, version);
     connection.onclose = () => {
       daemonDebug('client disconnected');
     };
-    connection.onversionerror = (id, e) => {
-      if (daemonVersion === 'undefined-for-test')
-        return false;
-
-      if (semverGreater(daemonVersion, e.received)) {
-        // eslint-disable-next-line no-console
-        connection.send({ id, error: `Client is too old: daemon is ${daemonVersion}, client is ${e.received}.` }).catch(e => console.error(e));
-      } else {
-        gracefullyProcessExitDoNotHang(0, async () => {
-          // eslint-disable-next-line no-console
-          await connection.send({ id, error: `Daemon is too old: daemon is ${daemonVersion}, client is ${e.received}. Stopping it.` }).catch(e => console.error(e));
-          server.close();
-        });
-      }
-      return true;
-    };
     connection.onmessage = async message => {
       const { id, method, params } = message;
       try {
@@ -170,17 +152,3 @@ function parseCliCommand(args: Record<string, string> & { _: string[] }): { tool
     throw new Error('Command is required');
   return parseCommand(command, args);
 }
-
-function semverGreater(a: string, b: string): boolean {
-  a = a.replace(/-next$/, '');
-  b = b.replace(/-next$/, '');
-  const aParts = a.split('.').map(Number);
-  const bParts = b.split('.').map(Number);
-  for (let i = 0; i < 4; i++) {
-    if (aParts[i] > bParts[i])
-      return true;
-    if (aParts[i] < bParts[i])
-      return false;
-  }
-  return false;
-}