creevey 0.10.0-beta.4 → 0.10.0-beta.41

package/src/server/playwright/docker-file.ts

@@ -1,8 +1,12 @@
+import { readFile } from 'fs/promises';
+import { pathToFileURL } from 'url';
 import semver from 'semver';
 import { exec } from 'shelljs';
 
+const importMetaUrl = pathToFileURL(__filename).href;
+
 // TODO Support custom docker images
-export function playwrightDockerFile(browser: string, version: string): string {
+export async function playwrightDockerFile(browser: string, version: string): Promise<string> {
   const sv = semver.coerce(version);
 
   let npmRegistry;
@@ -12,23 +16,31 @@ export function playwrightDockerFile(browser: string, version: string): string {
     /* noop */
   }
 
-  return `
-FROM mcr.microsoft.com/playwright:v${sv?.format() ?? version}
+  const indexJs = await readFile(new URL('./index-source.mjs', importMetaUrl), 'utf-8');
+
+  const dockerfile = `
+FROM node:lts
 
 WORKDIR /creevey
 
 RUN echo "{ \\"type\\": \\"module\\" }" > package.json && \\
-    echo "import { ${browser} as browser } from 'playwright-core';" >> index.js && \\
-    echo "const ws = await browser.launchServer({ port: 4444, wsPath: 'creevey' })" >> index.js && \\${
+${indexJs
+  .split('\n')
+  .map((line) => `    echo "${line.replace(/"/g, '\\"')}" >> index.js && \\`)
+  .join('\n')}
+    ${
       npmRegistry
         ? `
     echo "registry=${npmRegistry}" > .npmrc && \\`
         : ''
     }
-    npm i playwright-core${sv ? `@${sv.format()}` : ''}
+    npm i playwright-core${sv ? `@${sv.format()}` : ''} && \\
+    npx -y playwright${sv ? `@${sv.format()}` : ''} install --with-deps ${browser}
 
 EXPOSE 4444
 
 ENTRYPOINT [ "node", "./index.js" ]
 `;
+
+  return dockerfile.replace(/\\\n\s*\\?\n/g, '\\\n');
 }

package/src/server/playwright/docker.ts

@@ -1,9 +1,17 @@
+import assert from 'assert';
 import { runImage } from '../docker';
 import { emitWorkerMessage, subscribeOn } from '../messages';
-import { isInsideDocker } from '../utils';
+import { getCreeveyCache, isInsideDocker, resolvePlaywrightBrowserType } from '../utils';
 import { LOCALHOST_REGEXP } from '../webdriver';
+import type { BrowserConfigObject, Config } from '../../types';
 
-export async function startPlaywrightContainer(imageName: string, debug: boolean): Promise<string> {
+export async function startPlaywrightContainer(
+  imageName: string,
+  browser: string,
+  config: Config,
+  debug: boolean,
+): Promise<string> {
+  const { browserName, playwrightOptions } = config.browsers[browser] as BrowserConfigObject;
   const port = await new Promise<number>((resolve) => {
     subscribeOn('worker', (message) => {
       if (message.type == 'port') {
@@ -13,13 +21,18 @@ export async function startPlaywrightContainer(imageName: string, debug: boolean
     emitWorkerMessage({ type: 'port', payload: { port: -1 } });
   });
 
+  const cacheDir = await getCreeveyCache();
+
+  assert(cacheDir, "Couldn't get cache directory");
+
   const host = await runImage(
     imageName,
-    [],
+    [JSON.stringify({ ...playwrightOptions, browser: resolvePlaywrightBrowserType(browserName) })],
     {
       ExposedPorts: { [`${port}/tcp`]: {} },
       HostConfig: {
         PortBindings: { ['4444/tcp']: [{ HostPort: `${port}` }] },
+        Binds: [`${cacheDir}/${process.pid}:/creevey/traces`],
       },
     },
     debug,

package/src/server/playwright/index-source.mjs

@@ -0,0 +1,16 @@
+import { chromium, firefox, webkit } from 'playwright-core';
+
+/** @type import("playwright-core").LaunchOptions & { browser: 'chromium' | 'firefox' | 'webkit' } */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const config = JSON.parse(process.argv.slice(2)[0]);
+
+const browsers = { chromium, firefox, webkit };
+
+const ws = await browsers[config.browser].launchServer({
+  ...config,
+  port: 4444,
+  wsPath: 'creevey',
+  tracesDir: 'traces',
+});
+
+console.log(config.browser, 'browser server launched on:', ws.wsEndpoint());

package/src/server/playwright/internal.ts

@@ -1,8 +1,19 @@
-import { Browser, BrowserType, Page, chromium, firefox, webkit } from 'playwright-core';
-import Logger from 'loglevel';
+import path from 'path';
+import {
+  Browser,
+  BrowserContext,
+  BrowserContextOptions,
+  BrowserType,
+  Page,
+  chromium,
+  firefox,
+  webkit,
+} from 'playwright-core';
 import chalk from 'chalk';
 import { v4 } from 'uuid';
+import Logger from 'loglevel';
 import prefix from 'loglevel-plugin-prefix';
+import type { Args } from '@storybook/types';
 import {
   BrowserConfigObject,
   Config,
@@ -11,13 +22,24 @@ import {
   StoryInput,
   StorybookEvents,
   StorybookGlobals,
-  noop,
 } from '../../types';
-import { subscribeOn } from '../messages';
-import { appendIframePath, getAddresses, LOCALHOST_REGEXP, resolveStorybookUrl, storybookRootID } from '../webdriver';
-import { isShuttingDown, runSequence } from '../utils';
+import {
+  appendIframePath,
+  getAddresses,
+  LOCALHOST_REGEXP,
+  openBrowser,
+  resolveStorybookUrl,
+  storybookRootID,
+} from '../webdriver';
+import { getCreeveyCache, isShuttingDown, resolvePlaywrightBrowserType, runSequence } from '../utils';
 import { colors, logger } from '../logger';
-import { Args } from '@storybook/csf';
+import assert from 'assert';
+
+const browsers = {
+  chromium,
+  firefox,
+  webkit,
+};
 
 async function tryConnect(type: BrowserType, gridUrl: string): Promise<Browser | null> {
   let timeout: NodeJS.Timeout | null = null;
@@ -28,7 +50,7 @@ async function tryConnect(type: BrowserType, gridUrl: string): Promise<Browser |
       (resolve) =>
         (timeout = setTimeout(() => {
           isTimeout = true;
-          logger.error(`Can't connect to ${type.name()} playwright browser`, error);
+          logger().error(`Can't connect to ${type.name()} playwright browser`, error);
           resolve(null);
         }, 10000)),
     ),
@@ -50,25 +72,60 @@ async function tryConnect(type: BrowserType, gridUrl: string): Promise<Browser |
   ]);
 }
 
+async function tryCreateBrowserContext(
+  browser: Browser,
+  options: BrowserContextOptions,
+): Promise<{ context: BrowserContext; page: Page }> {
+  try {
+    const context = await browser.newContext(options);
+    const page = await context.newPage();
+    return { context, page };
+  } catch (error) {
+    if (error instanceof Error && error.message.includes('ffmpeg')) {
+      logger().warn('Failed to create browser context with video recording. Video recording will be disabled.');
+      logger().warn(error);
+      const context = await browser.newContext({
+        ...options,
+        recordVideo: undefined,
+      });
+      const page = await context.newPage();
+      return { context, page };
+    }
+    throw error;
+  }
+}
+
 export class InternalBrowser {
   #isShuttingDown = false;
   #browser: Browser;
+  #context: BrowserContext;
   #page: Page;
+  #traceDir: string;
   #sessionId: string = v4();
   #serverHost: string | null = null;
   #serverPort: number;
-  #logger: Logger.Logger;
-  #unsubscribe: () => void = noop;
-  constructor(browser: Browser, page: Page, port: number) {
+  #debug: boolean;
+  #storybookGlobals?: StorybookGlobals;
+  #closeBrowser = openBrowser();
+  constructor(
+    browser: Browser,
+    context: BrowserContext,
+    page: Page,
+    traceDir: string,
+    port: number,
+    debug: boolean,
+    storybookGlobals?: StorybookGlobals,
+  ) {
     this.#browser = browser;
+    this.#context = context;
     this.#page = page;
+    this.#traceDir = traceDir;
     this.#serverPort = port;
-    this.#logger = Logger.getLogger(this.#sessionId);
-    this.#unsubscribe = subscribeOn('shutdown', () => {
-      void this.closeBrowser();
-    });
+    this.#debug = debug;
+    this.#storybookGlobals = storybookGlobals;
   }
 
+  // TODO Expose #browser and #context in tests
   get browser() {
     return this.#page;
   }
@@ -81,27 +138,36 @@ export class InternalBrowser {
     if (this.#isShuttingDown) return;
 
     this.#isShuttingDown = true;
-    this.#unsubscribe();
 
     try {
+      if (this.#debug) await this.#context.tracing.stop({ path: path.join(this.#traceDir, 'trace.zip') });
       await this.#page.close();
+      if (this.#debug) await this.#page.video()?.saveAs(path.join(this.#traceDir, 'video.webm'));
+      await this.#context.close();
       await this.#browser.close();
-    } catch (_) {
+    } catch {
       /* noop */
+    } finally {
+      this.#closeBrowser();
     }
   }
 
   async takeScreenshot(captureElement?: string | null, ignoreElements?: string | string[] | null): Promise<Buffer> {
-    // TODO Implement features from selenium `takeScreenshot`
-    // TODO Do we need scroll bar hack from selenium?
     const ignore = Array.isArray(ignoreElements) ? ignoreElements : ignoreElements ? [ignoreElements] : [];
     const mask = ignore.map((el) => this.#page.locator(el));
     if (captureElement) {
       const element = await this.#page.$(captureElement);
       if (!element) throw new Error(`Element with selector ${captureElement} not found`);
-      return element.screenshot({ animations: 'disabled', mask });
+
+      logger().debug(`Capturing ${chalk.cyan(captureElement)} element`);
+      return element.screenshot({
+        animations: 'disabled',
+        mask,
+        style: ':root { overflow: hidden !important; }',
+      });
     }
-    return this.#page.screenshot({ animations: 'disabled', mask, fullPage: true });
+    logger().debug('Capturing viewport screenshot');
+    return this.#page.screenshot({ animations: 'disabled', mask });
   }
 
   waitForComplete(callback: (isCompleted: boolean) => void): void {
@@ -110,10 +176,11 @@ export class InternalBrowser {
 
   async selectStory(id: string, waitForReady = false): Promise<boolean> {
     // NOTE: Global variables might be reset after hot reload. I think it's workaround, maybe we need better solution
+    await this.updateStorybookGlobals();
     await this.updateBrowserGlobalVariables();
     await this.resetMousePosition();
 
-    this.#logger.debug(`Triggering 'SetCurrentStory' event with storyId ${chalk.magenta(id)}`);
+    logger().debug(`Triggering 'SetCurrentStory' event with storyId ${chalk.magenta(id)}`);
 
     const result = await this.#page.evaluate<
       [error?: string | null, isCaptureCalled?: boolean] | null,
@@ -152,20 +219,12 @@ export class InternalBrowser {
     );
   }
 
-  async loadStoriesFromBrowser(retry = false): Promise<StoriesRaw> {
-    try {
-      const stories = await this.#page.evaluate<StoriesRaw | undefined>(() => window.__CREEVEY_GET_STORIES__());
+  async loadStoriesFromBrowser(): Promise<StoriesRaw> {
+    const stories = await this.#page.evaluate<StoriesRaw | undefined>(() => window.__CREEVEY_GET_STORIES__());
 
-      if (!stories) throw new Error("Can't get stories, it seems creevey or storybook API isn't available");
+    if (!stories) throw new Error("Can't get stories, it seems creevey or storybook API isn't available");
 
-      return stories;
-    } catch (error) {
-      // TODO Check how other solutions with playwright get stories from storybook
-      if (retry) throw error;
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-      // NOTE: Try one more time because of dynamic nature of vite and storybook
-      return this.loadStoriesFromBrowser(true);
-    }
+    return stories;
   }
 
   static async getBrowser(
@@ -182,56 +241,77 @@ export class InternalBrowser {
       seleniumCapabilities,
       playwrightOptions,
     } = browserConfig;
+    const parsedUrl = new URL(gridUrl);
+    const tracesDir = path.join(
+      playwrightOptions?.tracesDir ?? path.join(config.reportDir, 'traces'),
+      process.pid.toString(),
+    );
+    const cacheDir = await getCreeveyCache();
 
-    let browser: Browser | null = null;
+    assert(cacheDir, "Couldn't get cache directory");
 
-    if (new URL(gridUrl).protocol === 'ws:') {
-      switch (browserConfig.browserName) {
-        case 'chromium':
-          browser = await tryConnect(chromium, gridUrl);
-          break;
-        case 'firefox':
-          browser = await tryConnect(firefox, gridUrl);
-          break;
-        case 'webkit':
-          browser = await tryConnect(webkit, gridUrl);
-          break;
+    let browser: Browser | null = null;
 
-        default:
-          logger.error(
-            `Unknown browser ${browserConfig.browserName}. Playwright supports browsers: chromium, firefox, webkit`,
-          );
-      }
+    if (parsedUrl.protocol === 'ws:') {
+      browser = await tryConnect(browsers[resolvePlaywrightBrowserType(browserConfig.browserName)], gridUrl);
+    } else if (parsedUrl.protocol === 'creevey:') {
+      browser = await browsers[resolvePlaywrightBrowserType(browserConfig.browserName)].launch({
+        ...playwrightOptions,
+        tracesDir: path.join(cacheDir, `${process.pid}`),
+      });
     } else {
-      if (browserConfig.browserName != 'chrome') {
-        logger.error("Playwright's Selenium Grid feature supports only chrome browser");
+      if (browserConfig.browserName !== 'chrome') {
+        logger().error("Playwright's Selenium Grid feature supports only chrome browser");
         return null;
       }
 
       process.env.SELENIUM_REMOTE_URL = gridUrl;
       process.env.SELENIUM_REMOTE_CAPABILITIES = JSON.stringify(seleniumCapabilities);
 
-      browser = await chromium.launch(playwrightOptions);
+      browser = await chromium.launch({ ...playwrightOptions, tracesDir: path.join(cacheDir, `${process.pid}`) });
     }
 
     if (!browser) {
       return null;
     }
 
-    const page = await browser.newPage();
+    const { context, page } = await tryCreateBrowserContext(browser, {
+      recordVideo: options.debug
+        ? {
+            dir: path.join(cacheDir, `${process.pid}`),
+            size: viewport,
+          }
+        : undefined,
+      screen: viewport,
+      viewport,
+    });
+    if (options.debug) {
+      await context.tracing.start(
+        Object.assign({ screenshots: true, snapshots: true, sources: true }, playwrightOptions?.trace),
+      );
+    }
 
-    // TODO Add debug output
+    if (logger().getLevel() <= Logger.levels.DEBUG) {
+      page.on('console', (msg) => {
+        logger().debug(`Console message: ${msg.text()}`);
+      });
+    }
 
-    const internalBrowser = new InternalBrowser(browser, page, options.port);
+    const internalBrowser = new InternalBrowser(
+      browser,
+      context,
+      page,
+      tracesDir,
+      options.port,
+      options.debug,
+      _storybookGlobals,
+    );
 
     try {
       if (isShuttingDown.current) return null;
       const done = await internalBrowser.init({
         browserName,
-        viewport,
         storybookUrl: address,
-        storybookGlobals: _storybookGlobals,
-        resolveStorybookUrl: config.resolveStorybookUrl,
       });
 
       return done ? internalBrowser : null;
@@ -242,90 +322,70 @@ export class InternalBrowser {
       const error = new Error(`Can't load storybook root page: ${message}`);
       if (originalError instanceof Error) error.stack = originalError.stack;
 
-      logger.error(error);
+      logger().error(error);
 
       return null;
     }
   }
 
-  private async init({
-    browserName,
-    viewport,
-    storybookUrl,
-    storybookGlobals,
-    resolveStorybookUrl,
-  }: {
-    browserName: string;
-    viewport?: { width: number; height: number };
-    storybookUrl: string;
-    storybookGlobals?: StorybookGlobals;
-    resolveStorybookUrl?: () => Promise<string>;
-  }) {
+  private async init({ browserName, storybookUrl }: { browserName: string; storybookUrl: string }) {
     const sessionId = this.#sessionId;
 
-    prefix.apply(this.#logger, {
+    prefix.apply(logger(), {
       format(level) {
         const levelColor = colors[level.toUpperCase() as keyof typeof colors];
-        return `[${browserName}:${chalk.gray(sessionId)}] ${levelColor(level)} =>`;
+        return `[${browserName}:${chalk.gray(process.pid)}] ${levelColor(level)} => ${chalk.gray(sessionId)}`;
       },
     });
 
-    this.#page.setDefaultNavigationTimeout(10000);
     this.#page.setDefaultTimeout(60000);
 
     return await runSequence(
       [
-        () => this.openStorybookPage(storybookUrl, resolveStorybookUrl),
+        () => this.openStorybookPage(storybookUrl),
         () => this.waitForStorybook(),
-        () => this.updateStorybookGlobals(storybookGlobals),
+        () => this.triggerViteReload(),
+        () => this.updateStorybookGlobals(),
         () => this.resolveCreeveyHost(),
         () => this.updateBrowserGlobalVariables(),
-        () => this.resizeViewport(viewport),
       ],
       () => !this.#isShuttingDown,
     );
   }
 
-  private async openStorybookPage(storybookUrl: string, resolver?: () => Promise<string>): Promise<void> {
+  private async openStorybookPage(storybookUrl: string): Promise<void> {
     if (!LOCALHOST_REGEXP.test(storybookUrl)) {
       await this.#page.goto(appendIframePath(storybookUrl));
       return;
     }
 
     try {
-      if (resolver) {
-        this.#logger.debug('Resolving storybook url with custom resolver');
-
-        const resolvedUrl = await resolver();
-
-        this.#logger.debug(`Resolver storybook url ${resolvedUrl}`);
-
-        await this.#page.goto(appendIframePath(resolvedUrl));
-      } else {
-        await resolveStorybookUrl(appendIframePath(storybookUrl), (url) => this.checkUrl(url), this.#logger);
-      }
+      const resolvedUrl = await resolveStorybookUrl(appendIframePath(storybookUrl), (url) => this.checkUrl(url));
+      await this.#page.goto(resolvedUrl);
     } catch (error) {
-      this.#logger.error('Failed to resolve storybook URL', error instanceof Error ? error.message : '');
+      logger().error('Failed to resolve storybook URL', error instanceof Error ? error.message : '');
       throw error;
     }
   }
 
   private async checkUrl(url: string): Promise<boolean> {
+    const page = await this.#browser.newPage();
     try {
-      this.#logger.debug(`Opening ${chalk.magenta(url)} and checking the page source`);
-      const response = await this.#page.goto(url, { waitUntil: 'commit' });
+      logger().debug(`Opening ${chalk.magenta(url)} and checking the page source`);
+      const response = await page.goto(url, { waitUntil: 'commit' });
       const source = await response?.text();
 
-      this.#logger.debug(`Checking ${chalk.cyan(`#${storybookRootID}`)} existence on ${chalk.magenta(url)}`);
+      logger().debug(`Checking ${chalk.cyan(`#${storybookRootID}`)} existence on ${chalk.magenta(url)}`);
       return source?.includes(`id="${storybookRootID}"`) ?? false;
     } catch {
       return false;
+    } finally {
+      await page.close();
     }
   }
 
   private async waitForStorybook(): Promise<void> {
-    // TODO Duplicated code with selenium
-    this.#logger.debug('Waiting for `setStories` event to make sure that storybook is initiated');
+    logger().debug('Waiting for Storybook to initiate');
 
     const isTimeout = await Promise.race([
       new Promise<boolean>((resolve) => {
@@ -344,24 +404,38 @@ export class InternalBrowser {
               return false;
             }, StorybookEvents.SET_GLOBALS);
           } catch (e: unknown) {
-            this.#logger.debug('An error has been caught during the script:', e);
+            logger().debug('An error has been caught during the script:', e);
+            if (this.#page.isClosed()) throw e;
           }
+          if (wait) await new Promise((resolve) => setTimeout(resolve, 1000));
         } while (wait);
         return false;
       })(),
     ]);
 
-    // TODO Change the message to describe a reason why it might happen
-    if (isTimeout) throw new Error('Failed to wait `setStories` event');
+    if (isTimeout) throw new Error('Failed to wait Storybook init');
   }
 
-  private async updateStorybookGlobals(globals?: StorybookGlobals): Promise<void> {
-    if (!globals) return;
+  // TODO Doesn't work for some reason, maybe because of race-condition
+  private async triggerViteReload(): Promise<void> {
+    // NOTE: On the first load, Vite might try to optimize some dependencies and reload the page
+    // We need to trigger reload earlier to avoid unnecessary reloads further
+    try {
+      await this.#page.evaluate(async () => {
+        await window.__STORYBOOK_PREVIEW__.extract();
+      });
+    } catch {
+      await this.waitForStorybook();
+    }
+  }
+
+  private async updateStorybookGlobals(): Promise<void> {
+    if (!this.#storybookGlobals) return;
 
-    this.#logger.debug('Applying storybook globals');
+    logger().debug('Applying storybook globals');
     await this.#page.evaluate((globals: StorybookGlobals) => {
       window.__CREEVEY_UPDATE_GLOBALS__(globals);
-    }, globals);
+    }, this.#storybookGlobals);
   }
 
   private async resolveCreeveyHost(): Promise<void> {
@@ -390,8 +464,10 @@ export class InternalBrowser {
   }
 
   private async updateBrowserGlobalVariables() {
+    logger().debug('Updating browser global variables');
     await this.#page.evaluate(
       ([workerId, creeveyHost, creeveyPort]) => {
+        window.__CREEVEY_ENV__ = true;
         window.__CREEVEY_WORKER_ID__ = workerId;
         window.__CREEVEY_SERVER_HOST__ = creeveyHost ?? 'localhost';
         window.__CREEVEY_SERVER_PORT__ = creeveyPort;
@@ -400,13 +476,8 @@ export class InternalBrowser {
     );
   }
 
-  private async resizeViewport(viewport?: { width: number; height: number }): Promise<void> {
-    if (!viewport) return;
-
-    await this.#page.setViewportSize(viewport);
-  }
-
   private async resetMousePosition(): Promise<void> {
+    logger().debug('Resetting mouse position to (0, 0)');
     await this.#page.mouse.move(0, 0);
   }
 }

package/src/server/playwright/webdriver.ts

@@ -1,10 +1,11 @@
 /// <reference types="../../../types/playwright-context" />
-import { Args } from '@storybook/csf';
+import type { Args } from '@storybook/types';
 import { Config, Options, ServerTest, StoriesRaw, StoryInput } from '../../types';
 import { logger } from '../logger';
 import { subscribeOn } from '../messages';
 import { CreeveyWebdriverBase } from '../webdriver';
 import type { InternalBrowser } from './internal';
+import { removeWorkerContainer } from '../worker/context.js'; // Import container context
 
 export class PlaywrightWebdriver extends CreeveyWebdriverBase {
   #browser: InternalBrowser | null = null;
@@ -21,7 +22,9 @@ export class PlaywrightWebdriver extends CreeveyWebdriverBase {
     this.#options = options;
 
     subscribeOn('shutdown', () => {
-      void this.#browser?.closeBrowser().finally(() => process.exit());
+      void this.#browser?.closeBrowser().finally(() => {
+        void removeWorkerContainer().finally(() => process.exit());
+      });
       this.#browser = null;
     });
   }
@@ -32,7 +35,6 @@ export class PlaywrightWebdriver extends CreeveyWebdriverBase {
 
   getSessionId(): Promise<string> {
     if (!this.#browser) {
-      // TODO Describe the error
       throw new Error('Browser is not initialized');
     }
 
@@ -53,7 +55,7 @@ export class PlaywrightWebdriver extends CreeveyWebdriverBase {
       try {
         return await import('./internal.js');
       } catch (error) {
-        logger.error(error);
+        logger().error(error);
         return null;
       }
     })();
@@ -79,7 +81,6 @@ export class PlaywrightWebdriver extends CreeveyWebdriverBase {
 
   async loadStoriesFromBrowser(): Promise<StoriesRaw> {
     if (!this.#browser) {
-      // TODO Describe the error
       throw new Error('Browser is not initialized');
     }
 
@@ -95,7 +96,6 @@ export class PlaywrightWebdriver extends CreeveyWebdriverBase {
     ignoreElements?: string | string[] | null,
   ): Promise<Buffer> {
     if (!this.#browser) {
-      // TODO Describe the error
       throw new Error('Browser is not initialized');
     }
 
@@ -104,7 +104,6 @@ export class PlaywrightWebdriver extends CreeveyWebdriverBase {
 
   protected waitForComplete(callback: (isCompleted: boolean) => void): void {
     if (!this.#browser) {
-      // TODO Describe the error
       throw new Error('Browser is not initialized');
     }
 
@@ -113,7 +112,6 @@ export class PlaywrightWebdriver extends CreeveyWebdriverBase {
 
   protected async selectStory(id: string, waitForReady?: boolean): Promise<boolean> {
     if (!this.#browser) {
-      // TODO Describe the error
       throw new Error('Browser is not initialized');
     }
 
@@ -122,7 +120,6 @@ export class PlaywrightWebdriver extends CreeveyWebdriverBase {
 
   protected async updateStoryArgs(story: StoryInput, updatedArgs: Args): Promise<void> {
     if (!this.#browser) {
-      // TODO Describe the error
       throw new Error('Browser is not initialized');
     }