@wordbricks/playwright-mcp 0.1.19 → 0.1.22

package/README.md

@@ -142,49 +142,58 @@ Playwright MCP server supports following arguments. They can be provided in the
 
 ```
 > npx @wordbricks/playwright-mcp@latest --help
-  --allowed-origins <origins>  semicolon-separated list of origins to allow the
-                               browser to request. Default is to allow all.
-  --blocked-origins <origins>  semicolon-separated list of origins to block the
-                               browser from requesting. Blocklist is evaluated
-                               before allowlist. If used without the allowlist,
-                               requests not matching the blocklist are still
-                               allowed.
-  --block-service-workers      block service workers
-  --browser <browser>          browser or chrome channel to use, possible
-                               values: chrome, firefox, webkit, msedge.
-  --caps <caps>                comma-separated list of additional capabilities
-                               to enable, possible values: vision, pdf.
-  --cdp-endpoint <endpoint>    CDP endpoint to connect to.
-  --config <path>              path to the configuration file.
-  --device <device>            device to emulate, for example: "iPhone 15"
-  --executable-path <path>     path to the browser executable.
-  --headless                   run browser in headless mode, headed by default
-  --host <host>                host to bind server to. Default is localhost. Use
-                               0.0.0.0 to bind to all interfaces.
-  --ignore-https-errors        ignore https errors
-  --isolated                   keep the browser profile in memory, do not save
-                               it to disk.
-  --image-responses <mode>     whether to send image responses to the client.
-                               Can be "allow" or "omit", Defaults to "allow".
-  --no-sandbox                 disable the sandbox for all process types that
-                               are normally sandboxed.
-  --output-dir <path>          path to the directory for output files.
-  --port <port>                port to listen on for SSE transport.
-  --proxy-bypass <bypass>      comma-separated domains to bypass proxy, for
-                               example ".com,chromium.org,.domain.com"
-  --proxy-server <proxy>       specify proxy server, for example
-                               "http://myproxy:3128" or "socks5://myproxy:8080"
-  --save-session               Whether to save the Playwright MCP session into
-                               the output directory.
-  --save-trace                 Whether to save the Playwright Trace of the
-                               session into the output directory.
-  --storage-state <path>       path to the storage state file for isolated
-                               sessions.
-  --user-agent <ua string>     specify user agent string
-  --user-data-dir <path>       path to the user data directory. If not
-                               specified, a temporary directory will be created.
-  --viewport-size <size>       specify browser viewport size in pixels, for
-                               example "1280, 720"
+  --allowed-origins <origins>   semicolon-separated list of origins to allow the
+                                browser to request. Default is to allow all.
+  --blocked-origins <origins>   semicolon-separated list of origins to block the
+                                browser from requesting. Blocklist is evaluated
+                                before allowlist. If used without the allowlist,
+                                requests not matching the blocklist are still
+                                allowed.
+  --block-service-workers       block service workers
+  --browser <browser>           browser or chrome channel to use, possible
+                                values: chrome, firefox, webkit, msedge.
+  --caps <caps>                 comma-separated list of additional capabilities
+                                to enable, possible values: vision, pdf.
+  --cdp-endpoint <endpoint>     CDP endpoint to connect to.
+  --config <path>               path to the configuration file.
+  --device <device>             device to emulate, for example: "iPhone 15"
+  --executable-path <path>      path to the browser executable.
+  --headless                    run browser in headless mode, headed by default
+  --host <host>                 host to bind server to. Default is localhost.
+                                Use 0.0.0.0 to bind to all interfaces.
+  --ignore-https-errors         ignore https errors
+  --init-script <path>          path to a JavaScript file to inject into all
+                                pages using addInitScript.
+  --isolated                    keep the browser profile in memory, do not save
+                                it to disk.
+  --image-responses <mode>      whether to send image responses to the client.
+                                Can be "allow" or "omit", Defaults to "allow".
+  --no-sandbox                  disable the sandbox for all process types that
+                                are normally sandboxed.
+  --output-dir <path>           path to the directory for output files.
+  --port <port>                 port to listen on for SSE transport.
+  --proxy-bypass <bypass>       comma-separated domains to bypass proxy, for
+                                example ".com,chromium.org,.domain.com"
+  --proxy-server <proxy>        specify proxy server, for example
+                                "http://myproxy:3128" or "socks5://myproxy:8080"
+  --save-session                Whether to save the Playwright MCP session into
+                                the output directory.
+  --save-trace                  Whether to save the Playwright Trace of the
+                                session into the output directory.
+  --storage-state <path>        path to the storage state file for isolated
+                                sessions.
+  --user-agent <ua string>      specify user agent string
+  --user-data-dir <path>        path to the user data directory. If not
+                                specified, a temporary directory will be
+                                created.
+  --viewport-size <size>        specify browser viewport size in pixels, for
+                                example "1280, 720"
+  --window-position <x,y>       specify Chrome window position in pixels, for
+                                example "100,200"
+  --window-size <width,height>  specify Chrome window size in pixels, for
+                                example "1280,720"
+  --app <url>                   launch browser in app mode with the specified
+                                URL
 ```
 
 <!--- End of options generated section -->
@@ -397,6 +406,7 @@ http.createServer(async (req, res) => {
     - `ref` (string): Exact target element reference from the page snapshot
     - `doubleClick` (boolean, optional): Whether to perform a double click instead of a single click
     - `button` (string, optional): Button to click, defaults to left
+    - `modifiers` (array, optional): Modifier keys to press
   - Read-only: **false**
 
 <!-- NOTE: This has been generated via update-readme.js -->
@@ -564,7 +574,7 @@ http.createServer(async (req, res) => {
   - Description: Scroll the page using mouse wheel with human-like behavior
   - Parameters:
     - `amount` (number): Vertical scroll amount in pixels (positive scrolls down, negative up)
-  - Read-only: **false**
+  - Read-only: **true**
 
 <!-- NOTE: This has been generated via update-readme.js -->
 

package/cli-wrapper.js

@@ -15,33 +15,34 @@
  * limitations under the License.
  */
 
-import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
+import { spawn } from "child_process";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-const isBunRuntime = 'bun' in process.versions;
-const isRunViaBundle = process.env.npm_execpath && process.env.npm_execpath.includes('bunx');
+const isBunRuntime = "bun" in process.versions;
+const isRunViaBundle =
+  process.env.npm_execpath && process.env.npm_execpath.includes("bunx");
 
 if (!isBunRuntime && isRunViaBundle) {
-  const cliPath = join(__dirname, 'cli.js');
+  const cliPath = join(__dirname, "cli.js");
   const args = process.argv.slice(2);
 
-  const bunProcess = spawn('bun', [cliPath, ...args], {
-    stdio: 'inherit',
-    env: { ...process.env, FORCE_BUN_RUNTIME: '1' }
+  const bunProcess = spawn("bun", [cliPath, ...args], {
+    stdio: "inherit",
+    env: { ...process.env, FORCE_BUN_RUNTIME: "1" },
   });
 
-  bunProcess.on('exit', (code) => {
+  bunProcess.on("exit", (code) => {
     process.exit(code || 0);
   });
 
-  bunProcess.on('error', (err) => {
-    console.error('Failed to run with bun:', err.message);
-    import('./lib/program.js');
+  bunProcess.on("error", (err) => {
+    console.error("Failed to run with bun:", err.message);
+    import("./lib/program.js");
   });
 } else {
-  import('./lib/program.js');
+  import("./lib/program.js");
 }

package/cli.js

@@ -15,4 +15,4 @@
  * limitations under the License.
  */
 
-import './lib/program.js';
+import "./lib/program.js";

package/config.d.ts

@@ -14,9 +14,14 @@
  * limitations under the License.
  */
 
-import type * as playwright from 'playwright-core';
+import type * as playwright from "playwright-core";
 
-export type ToolCapability = 'core' | 'core-tabs' | 'core-install' | 'vision' | 'pdf';
+export type ToolCapability =
+  | "core"
+  | "core-tabs"
+  | "core-install"
+  | "vision"
+  | "pdf";
 
 export type Config = {
   /**
@@ -26,7 +31,7 @@ export type Config = {
     /**
      * The type of browser to use.
      */
-    browserName?: 'chromium' | 'firefox' | 'webkit';
+    browserName?: "chromium" | "firefox" | "webkit";
 
     /**
      * Keep the browser profile in memory, do not save it to disk.
@@ -73,7 +78,7 @@ export type Config = {
      * URL to launch in Chrome app mode.
      */
     app?: string;
-  },
+  };
 
   server?: {
     /**
@@ -85,7 +90,7 @@ export type Config = {
      * The host to bind the server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.
      */
     host?: string;
-  },
+  };
 
   /**
    * List of enabled tool capabilities. Possible values:
@@ -125,5 +130,5 @@ export type Config = {
   /**
    * Whether to send image responses to the client. Can be "allow", "omit", or "auto". Defaults to "auto", which sends images if the client can display them.
    */
-  imageResponses?: 'allow' | 'omit';
+  imageResponses?: "allow" | "omit";
 };

package/index.d.ts

@@ -15,9 +15,11 @@
  * limitations under the License.
  */
 
-import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import type { Config } from './config.js';
-import type { BrowserContext } from 'playwright-core';
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import type { Config } from "./config.js";
+import type { BrowserContext } from "playwright-core";
 
-export declare function createConnection(config?: Config, contextGetter?: () => Promise<BrowserContext>): Promise<Server>;
-export {};
+export declare function createConnection(
+  config?: Config,
+  contextGetter?: () => Promise<BrowserContext>,
+): Promise<Server>;

package/index.js

@@ -15,5 +15,5 @@
  * limitations under the License.
  */
 
-import { createConnection } from './lib/index.js';
+import { createConnection } from "./lib/index.js";
 export { createConnection };

package/lib/browserContextFactory.js

@@ -13,22 +13,75 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import fs from 'fs';
-import net from 'net';
-import path from 'path';
-import * as playwright from 'playwright-core';
-import ms from 'ms';
-// @ts-ignore
-import { registryDirectory } from 'playwright-core/lib/server/registry/index';
-// @ts-ignore
-import { startTraceViewerServer } from 'playwright-core/lib/server';
-import { logUnhandledError, testDebug } from './utils/log.js';
-import { createHash } from './utils/guid.js';
-import { outputFile } from './config.js';
-const TIMEOUT_STR = '30m';
+import fs from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import ms from "ms";
+import * as playwright from "playwright-core";
+// @ts-expect-error
+import { startTraceViewerServer } from "playwright-core/lib/server";
+// @ts-expect-error
+import { registryDirectory } from "playwright-core/lib/server/registry/index";
+import { outputFile } from "./config.js";
+import { createHash } from "./utils/guid.js";
+import { logUnhandledError, testDebug } from "./utils/log.js";
+const TIMEOUT_STR = "30m";
+// Disable password manager in Chrome Preferences file
+async function disablePasswordManagerInPrefs(userDataDir) {
+    const prefsPath = path.join(userDataDir, "Default", "Preferences");
+    const defaultDir = path.join(userDataDir, "Default");
+    // Ensure Default directory exists
+    await fs.promises.mkdir(defaultDir, { recursive: true });
+    let prefs = {};
+    try {
+        const existing = await fs.promises.readFile(prefsPath, "utf8");
+        prefs = JSON.parse(existing);
+    }
+    catch {
+        // File doesn't exist or is invalid, start fresh
+    }
+    // Disable password manager settings
+    prefs.credentials_enable_service = false;
+    prefs.credentials_enable_autosignin = false;
+    prefs.password_manager_enabled = false;
+    // Nested profile preferences
+    prefs.profile = prefs.profile || {};
+    prefs.profile.password_manager_enabled = false;
+    // Password manager specific settings
+    prefs.password_manager =
+        prefs.password_manager || {};
+    prefs.password_manager.saving_enabled = false;
+    prefs.password_manager.autofilling_enabled =
+        false;
+    await fs.promises.writeFile(prefsPath, JSON.stringify(prefs, null, 2));
+}
 async function applyInitScript(browserContext, config) {
+    // Clear stale auth mode from previous sessions on first page load
+    // Uses a session marker to avoid clearing during active auth navigation
+    const sessionId = Date.now().toString();
+    await browserContext.addInitScript((sid) => {
+        try {
+            const currentSession = sessionStorage.getItem("__nr_session__");
+            const authMode = localStorage.getItem("__nr_auth_mode__");
+            console.log("[NextRows:Init] Session check", {
+                currentSession,
+                newSessionId: sid,
+                authModeBefore: authMode,
+            });
+            if (currentSession !== sid) {
+                // New session - clear any stale auth state
+                localStorage.removeItem("__nr_auth_mode__");
+                localStorage.removeItem("__nr_auth_continue__");
+                sessionStorage.setItem("__nr_session__", sid);
+                console.log("[NextRows:Init] Cleared stale auth state for new session");
+            }
+        }
+        catch (e) {
+            console.log("[NextRows:Init] Error in session check", e);
+        }
+    }, sessionId);
     if (config.browser.initScript) {
-        const scriptContent = await fs.promises.readFile(config.browser.initScript, 'utf8');
+        const scriptContent = await fs.promises.readFile(config.browser.initScript, "utf8");
         await browserContext.addInitScript(scriptContent);
     }
 }
@@ -40,23 +93,23 @@ async function hidePlaywrightMarkers(browserContext) {
         const originalGetOwnPropertyNames = Object.getOwnPropertyNames;
         Object.getOwnPropertyNames = (obj) => {
             const props = originalGetOwnPropertyNames(obj);
-            return props.filter((prop) => prop !== '__pwInitScripts');
+            return props.filter((prop) => prop !== "__pwInitScripts");
         };
         // Use a Proxy to handle access to `window`
         const windowHandler = {
             get(target, prop) {
-                if (prop === '__pwInitScripts')
+                if (prop === "__pwInitScripts")
                     return undefined; // Hide the property
                 return Reflect.get(target, prop);
             },
             has(target, prop) {
-                if (prop === '__pwInitScripts')
+                if (prop === "__pwInitScripts")
                     return false; // Prevent detection via "in" operator
                 return Reflect.has(target, prop);
             },
         };
         const proxiedWindow = new Proxy(window, windowHandler);
-        Object.defineProperty(globalThis, 'window', {
+        Object.defineProperty(globalThis, "window", {
             value: proxiedWindow,
             configurable: false,
             writable: false,
@@ -88,14 +141,16 @@ class BaseContextFactory {
             return this._browserPromise;
         testDebug(`obtain browser (${this.name})`);
         this._browserPromise = this._doObtainBrowser(clientInfo);
-        void this._browserPromise.then(browser => {
-            browser.on('disconnected', () => {
+        void this._browserPromise
+            .then((browser) => {
+            browser.on("disconnected", () => {
                 this._browserPromise = undefined;
                 this._clearAutoCloseTimer();
             });
             // Start auto-close timer
             this._startAutoCloseTimer(browser);
-        }).catch(() => {
+        })
+            .catch(() => {
             this._browserPromise = undefined;
             this._clearAutoCloseTimer();
         });
@@ -124,16 +179,19 @@ class BaseContextFactory {
         }
     }
     async _doObtainBrowser(clientInfo) {
-        throw new Error('Not implemented');
+        throw new Error("Not implemented");
     }
     async createContext(clientInfo) {
         testDebug(`create browser context (${this.name})`);
         const browser = await this._obtainBrowser(clientInfo);
         const browserContext = await this._doCreateContext(browser);
-        return { browserContext, close: () => this._closeBrowserContext(browserContext, browser) };
+        return {
+            browserContext,
+            close: () => this._closeBrowserContext(browserContext, browser),
+        };
     }
     async _doCreateContext(browser) {
-        throw new Error('Not implemented');
+        throw new Error("Not implemented");
     }
     async _closeBrowserContext(browserContext, browser) {
         testDebug(`close browser context (${this.name})`);
@@ -151,25 +209,29 @@ class BaseContextFactory {
 }
 class IsolatedContextFactory extends BaseContextFactory {
     constructor(config) {
-        super('isolated', 'Create a new isolated browser context', config);
+        super("isolated", "Create a new isolated browser context", config);
     }
     async _doObtainBrowser(clientInfo) {
         await injectCdpPort(this.config.browser);
         const browserType = playwright[this.config.browser.browserName];
-        return browserType.launch({
+        return browserType
+            .launch({
             tracesDir: await startTraceServer(this.config, clientInfo.rootPath),
             ...this.config.browser.launchOptions,
             handleSIGINT: false,
             handleSIGTERM: false,
-            args: this.config.browser.launchOptions?.args || [],
-        }).catch(error => {
-            if (error.message.includes('Executable doesn\'t exist'))
+        })
+            .catch((error) => {
+            if (error.message.includes("Executable doesn't exist"))
                 throw new Error(`Browser specified in your config is not installed. Either install it (likely) or change the config.`);
             throw error;
         });
     }
     async _doCreateContext(browser) {
-        const browserContext = await browser.newContext(this.config.browser.contextOptions);
+        const browserContext = await browser.newContext({
+            ...this.config.browser.contextOptions,
+            bypassCSP: true,
+        });
         await applyInitScript(browserContext, this.config);
         await hidePlaywrightMarkers(browserContext);
         return browserContext;
@@ -177,13 +239,15 @@ class IsolatedContextFactory extends BaseContextFactory {
 }
 class CdpContextFactory extends BaseContextFactory {
     constructor(config) {
-        super('cdp', 'Connect to a browser over CDP', config);
+        super("cdp", "Connect to a browser over CDP", config);
     }
     async _doObtainBrowser() {
         return playwright.chromium.connectOverCDP(this.config.browser.cdpEndpoint);
     }
     async _doCreateContext(browser) {
-        const browserContext = this.config.browser.isolated ? await browser.newContext() : browser.contexts()[0];
+        const browserContext = this.config.browser.isolated
+            ? await browser.newContext({ bypassCSP: true })
+            : browser.contexts()[0];
         await applyInitScript(browserContext, this.config);
         await hidePlaywrightMarkers(browserContext);
         return browserContext;
@@ -191,17 +255,17 @@ class CdpContextFactory extends BaseContextFactory {
 }
 class RemoteContextFactory extends BaseContextFactory {
     constructor(config) {
-        super('remote', 'Connect to a browser using a remote endpoint', config);
+        super("remote", "Connect to a browser using a remote endpoint", config);
     }
     async _doObtainBrowser() {
         const url = new URL(this.config.browser.remoteEndpoint);
-        url.searchParams.set('browser', this.config.browser.browserName);
+        url.searchParams.set("browser", this.config.browser.browserName);
         if (this.config.browser.launchOptions)
-            url.searchParams.set('launch-options', JSON.stringify(this.config.browser.launchOptions));
+            url.searchParams.set("launch-options", JSON.stringify(this.config.browser.launchOptions));
         return playwright[this.config.browser.browserName].connect(String(url));
     }
     async _doCreateContext(browser) {
-        const browserContext = await browser.newContext();
+        const browserContext = await browser.newContext({ bypassCSP: true });
         await applyInitScript(browserContext, this.config);
         await hidePlaywrightMarkers(browserContext);
         return browserContext;
@@ -209,8 +273,8 @@ class RemoteContextFactory extends BaseContextFactory {
 }
 class PersistentContextFactory {
     config;
-    name = 'persistent';
-    description = 'Create a new persistent browser context';
+    name = "persistent";
+    description = "Create a new persistent browser context";
     _userDataDirs = new Set();
     _autoCloseTimer;
     constructor(config) {
@@ -218,11 +282,14 @@ class PersistentContextFactory {
     }
     async createContext(clientInfo) {
         await injectCdpPort(this.config.browser);
-        testDebug('create browser context (persistent)');
-        const userDataDir = this.config.browser.userDataDir ?? await this._createUserDataDir(clientInfo.rootPath);
+        testDebug("create browser context (persistent)");
+        const userDataDir = this.config.browser.userDataDir ??
+            (await this._createUserDataDir(clientInfo.rootPath));
         const tracesDir = await startTraceServer(this.config, clientInfo.rootPath);
         this._userDataDirs.add(userDataDir);
-        testDebug('lock user data dir', userDataDir);
+        testDebug("lock user data dir", userDataDir);
+        // Disable password manager in Chrome preferences before launch
+        await disablePasswordManagerInPrefs(userDataDir);
         const browserType = playwright[this.config.browser.browserName];
         for (let i = 0; i < 5; i++) {
             try {
@@ -230,9 +297,9 @@ class PersistentContextFactory {
                     tracesDir,
                     ...this.config.browser.launchOptions,
                     ...this.config.browser.contextOptions,
+                    bypassCSP: true,
                     handleSIGINT: false,
                     handleSIGTERM: false,
-                    args: this.config.browser.launchOptions?.args || [],
                 });
                 await applyInitScript(browserContext, this.config);
                 await hidePlaywrightMarkers(browserContext);
@@ -242,11 +309,12 @@ class PersistentContextFactory {
                 return { browserContext, close };
             }
             catch (error) {
-                if (error.message.includes('Executable doesn\'t exist'))
+                if (error.message.includes("Executable doesn't exist"))
                     throw new Error(`Browser specified in your config is not installed. Either install it (likely) or change the config.`);
-                if (error.message.includes('ProcessSingleton') || error.message.includes('Invalid URL')) {
+                if (error.message.includes("ProcessSingleton") ||
+                    error.message.includes("Invalid URL")) {
                     // User data directory is already in use, try again.
-                    await new Promise(resolve => setTimeout(resolve, 1000));
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
                     continue;
                 }
                 throw error;
@@ -276,31 +344,36 @@ class PersistentContextFactory {
         }
     }
     async _closeBrowserContext(browserContext, userDataDir) {
-        testDebug('close browser context (persistent)');
-        testDebug('release user data dir', userDataDir);
+        testDebug("close browser context (persistent)");
+        testDebug("release user data dir", userDataDir);
         this._clearAutoCloseTimer();
         await browserContext.close().catch(() => { });
         this._userDataDirs.delete(userDataDir);
-        testDebug('close browser context complete (persistent)');
+        testDebug("close browser context complete (persistent)");
     }
     async _createUserDataDir(rootPath) {
         const dir = process.env.PWMCP_PROFILES_DIR_FOR_TEST ?? registryDirectory;
-        const browserToken = this.config.browser.launchOptions?.channel ?? this.config.browser?.browserName;
+        const browserToken = this.config.browser.launchOptions?.channel ??
+            this.config.browser?.browserName;
         // Hesitant putting hundreds of files into the user's workspace, so using it for hashing instead.
-        const rootPathToken = rootPath ? `-${createHash(rootPath)}` : '';
+        const rootPathToken = rootPath ? `-${createHash(rootPath)}` : "";
         const result = path.join(dir, `mcp-${browserToken}${rootPathToken}`);
         await fs.promises.mkdir(result, { recursive: true });
         return result;
     }
 }
 async function injectCdpPort(browserConfig) {
-    const isBunRuntime = 'bun' in process.versions;
-    if (isBunRuntime)
+    const isBunRuntime = "bun" in process.versions;
+    const isWindows = process.platform === "win32";
+    // On Windows, always use CDP port because Bun has issues with --remote-debugging-pipe
+    // On other platforms, Bun handles pipes correctly
+    if (!isWindows && isBunRuntime)
         return;
-    if (browserConfig.browserName !== 'chromium')
+    if (browserConfig.browserName !== "chromium")
         return;
     const launchOptions = browserConfig.launchOptions || {};
-    launchOptions.cdpPort = await findFreePort();
+    const cdpPort = await findFreePort();
+    launchOptions.cdpPort = cdpPort;
     browserConfig.launchOptions = launchOptions;
 }
 async function findFreePort() {
@@ -310,7 +383,7 @@ async function findFreePort() {
             const { port } = server.address();
             server.close(() => resolve(port));
         });
-        server.on('error', reject);
+        server.on("error", reject);
     });
 }
 async function startTraceServer(config, rootPath) {
@@ -318,9 +391,9 @@ async function startTraceServer(config, rootPath) {
         return undefined;
     const tracesDir = await outputFile(config, rootPath, `traces-${Date.now()}`);
     const server = await startTraceViewerServer();
-    const urlPrefix = server.urlPrefix('human-readable');
-    const url = urlPrefix + '/trace/index.html?trace=' + tracesDir + '/trace.json';
+    const urlPrefix = server.urlPrefix("human-readable");
+    const url = urlPrefix + "/trace/index.html?trace=" + tracesDir + "/trace.json";
     // eslint-disable-next-line no-console
-    console.error('\nTrace viewer listening on ' + url);
+    console.error("\nTrace viewer listening on " + url);
     return tracesDir;
 }