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

package/src/server/index.ts

@@ -1,13 +1,19 @@
 import cluster from 'cluster';
+import path from 'path';
+import { exec } from 'shelljs';
+import { getUserAgent } from 'package-manager-detector/detect';
+import { resolveCommand } from 'package-manager-detector/commands';
 import { readConfig, defaultBrowser } from './config.js';
 import { Options, Config, BrowserConfigObject, isWorkerMessage } from '../types.js';
 import { logger } from './logger.js';
+import { getStorybookUrl, checkIsStorybookConnected } from './connection.js';
 import { SeleniumWebdriver } from './selenium/webdriver.js';
 import { LOCALHOST_REGEXP } from './webdriver.js';
-import { isInsideDocker } from './utils.js';
-import { sendWorkerMessage } from './messages.js';
-import { playwrightDockerFile } from './playwright/docker-file.js';
+import { isInsideDocker, killTree, resolvePlaywrightBrowserType, shutdownWithError } from './utils.js';
+import { sendWorkerMessage, subscribeOn } from './messages.js';
 import { buildImage } from './docker.js';
+import { mkdir, writeFile } from 'fs/promises';
+import assert from 'assert';
 
 async function startWebdriverServer(browser: string, config: Config, options: Options): Promise<string | undefined> {
   if (config.webdriver === SeleniumWebdriver) {
@@ -25,31 +31,38 @@ async function startWebdriverServer(browser: string, config: Config, options: Op
   } else {
     if (config.gridUrl) return undefined;
 
-    // TODO start standalone playwright server (useDocker == false)
+    if (!config.useDocker) {
+      if (cluster.isPrimary) return undefined;
+
+      const { browserName } = config.browsers[browser] as BrowserConfigObject;
+      return `creevey://${resolvePlaywrightBrowserType(browserName)}`;
+    }
+
     const {
       default: { version },
     } = await import('playwright-core/package.json', { with: { type: 'json' } });
 
     if (cluster.isWorker) {
       // TODO Re-use dockerImage
-
-      // TODO Use https://hub.docker.com/r/playwright/chrome
-      // NOTE It will be possible to use `chrome` browserName
       const { startPlaywrightContainer } = await import('./playwright/docker.js');
       const { browserName } = config.browsers[browser] as BrowserConfigObject;
 
       const imageName = `creevey/${browserName}:v${version}`;
-      const host = await startPlaywrightContainer(imageName, options.debug);
+      const host = await startPlaywrightContainer(imageName, browser, config, options.debug);
 
       return host;
     } else {
+      const { playwrightDockerFile } = await import('./playwright/docker-file.js');
+      const {
+        default: { version: creeveyVersion },
+      } = await import('../../package.json', { with: { type: 'json' } });
       const browsers = [...new Set(Object.values(config.browsers).map((c) => (c as BrowserConfigObject).browserName))];
       await Promise.all(
         browsers.map(async (browserName) => {
           const imageName = `creevey/${browserName}:v${version}`;
-          const dockerfile = playwrightDockerFile(browserName, version);
+          const dockerfile = await playwrightDockerFile(browserName, version);
 
-          await buildImage(imageName, dockerfile);
+          await buildImage(imageName, creeveyVersion, dockerfile);
         }),
       );
 
@@ -79,6 +92,10 @@ export default async function (options: Options): Promise<void> {
   const { browser = defaultBrowser, update, ui, port } = options;
   let gridUrl = cluster.isPrimary ? config.gridUrl : options.gridUrl;
 
+  // TODO Add package.json with `"type": "commonjs"` as workaround for esm packages to load `data.js`
+  await mkdir(config.reportDir, { recursive: true });
+  await writeFile(path.join(config.reportDir, 'package.json'), '{"type": "commonjs"}');
+
   // NOTE: We don't need docker nor selenoid for update option
   if (
     !(gridUrl || (Object.values(config.browsers) as BrowserConfigObject[]).every(({ gridUrl }) => gridUrl)) &&
@@ -87,6 +104,47 @@ export default async function (options: Options): Promise<void> {
     gridUrl = await startWebdriverServer(browser, config, options);
   }
 
+  if (cluster.isPrimary) {
+    const [localUrl, remoteUrl] = getStorybookUrl(config, options);
+
+    if (options.storybookStart) {
+      const pm = getUserAgent();
+      assert(pm, new Error('Failed to detect current package manager'));
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const { command, args } = resolveCommand(pm, 'run', ['storybook', 'dev'])!;
+      const storybookPort = new URL(localUrl).port;
+      const storybookCommand = `${config.storybookAutorunCmd ?? [command, ...args, '--ci'].join(' ')} -p ${storybookPort}`;
+
+      logger().info(`Start Storybook via \`${storybookCommand}\`, it should be accessible at:`);
+      logger().info(`Local - ${localUrl}`);
+      if (remoteUrl && localUrl != remoteUrl) logger().info(`On your network - ${remoteUrl}`);
+      logger().info('Waiting Storybook...');
+
+      const storybook = exec(storybookCommand, { async: true });
+      subscribeOn('shutdown', () => {
+        if (storybook.pid) void killTree(storybook.pid);
+      });
+    } else {
+      logger().info('Storybook should be started and be accessible at:');
+      logger().info(`Local - ${localUrl}`);
+      if (remoteUrl && localUrl != remoteUrl) logger().info(`On your network - ${remoteUrl}`);
+      logger().info(
+        'Tip: Creevey can start Storybook automatically by using `-s` option at the command line. (e.g., yarn/npm run creevey -s)',
+      );
+      logger().info('Waiting Storybook...');
+    }
+
+    if (options.storybookStart || process.env.CI !== 'true') {
+      const isConnected = await checkIsStorybookConnected(localUrl);
+      if (isConnected) {
+        logger().info('Storybook connected!\n');
+      } else {
+        logger().error('Storybook is not responding. Please start Storybook and restart Creevey');
+        shutdownWithError();
+      }
+    }
+  }
+
   switch (true) {
     case Boolean(update): {
       (await import('./update.js')).update(config, typeof update == 'string' ? update : undefined);
@@ -97,25 +155,25 @@ export default async function (options: Options): Promise<void> {
         try {
           await import('selenium-webdriver');
         } catch {
-          logger.error('Failed to start Creevey, missing required dependency: "selenium-webdriver"');
+          logger().error('Failed to start Creevey, missing required dependency: "selenium-webdriver"');
           process.exit(-1);
         }
       } else {
         try {
           await import('playwright-core');
         } catch {
-          logger.error('Failed to start Creevey, missing required dependency: "playwright-core"');
+          logger().error('Failed to start Creevey, missing required dependency: "playwright-core"');
           process.exit(-1);
         }
       }
-      logger.info('Starting Master Process');
+      logger().info('Starting Master Process');
 
       const resolveApi = (await import('./master/server.js')).start(config.reportDir, port, ui);
 
       return (await import('./master/start.js')).start(gridUrl, config, options, resolveApi);
     }
     default: {
-      logger.info(`Starting Worker for ${browser}`);
+      logger().info(`Starting Worker for ${browser}`);
 
       // NOTE: We assume that we pass `gridUrl` to worker CLI options
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion

package/src/server/logger.ts

@@ -10,12 +10,16 @@ export const colors = {
   ERROR: chalk.red,
 };
 
+let rootName = 'Creevey';
+
 prefix.reg(Logger);
 prefix.apply(Logger, {
-  format(level, name = 'Creevey') {
+  format(level, name = rootName) {
     const levelColor = colors[level.toUpperCase() as keyof typeof colors];
     return `[${name}:${chalk.gray(process.pid)}] ${levelColor(level)} =>`;
   },
 });
 
-export const logger = Logger.getLogger('Creevey');
+export const setRootName = (newName: string) => (rootName = newName);
+
+export const logger = () => Logger.getLogger(rootName);

package/src/server/master/api.ts

@@ -26,7 +26,7 @@ export default function creeveyApi(runner: Runner): CreeveyApi {
 
     handleMessage(ws: WebSocket, message: WebSocket.Data) {
       if (typeof message != 'string') {
-        logger.info('unhandled message', message);
+        logger().info('unhandled message', message);
         return;
       }
 

package/src/server/master/pool.ts

@@ -1,18 +1,9 @@
-import cluster, { Worker as ClusterWorker } from 'cluster';
+import { Worker as ClusterWorker } from 'cluster';
 import { EventEmitter } from 'events';
-import {
-  Worker,
-  Config,
-  TestResult,
-  BrowserConfigObject,
-  WorkerMessage,
-  TestStatus,
-  isWorkerMessage,
-} from '../../types.js';
-import { sendTestMessage, sendShutdownMessage, subscribeOnWorker } from '../messages.js';
-import { isShuttingDown } from '../utils.js';
-
-const FORK_RETRIES = 5;
+import { Worker, Config, TestResult, BrowserConfigObject, TestStatus } from '../../types.js';
+import { sendTestMessage, subscribeOnWorker } from '../messages.js';
+import { gracefullyKill, isShuttingDown } from '../utils.js';
+import { WorkerQueue } from './queue.js';
 
 interface WorkerTest {
   id: string;
@@ -28,10 +19,12 @@ export default class Pool extends EventEmitter {
   private forcedStop = false;
   private failFast: boolean;
   private gridUrl?: string;
+  private storybookUrl: string;
   public get isRunning(): boolean {
     return this.workers.length !== this.freeWorkers.length;
   }
   constructor(
+    public scheduler: WorkerQueue,
     config: Config,
     private browser: string,
     gridUrl?: string,
@@ -42,14 +35,18 @@ export default class Pool extends EventEmitter {
     this.maxRetries = config.maxRetries;
     this.config = config.browsers[browser] as BrowserConfigObject;
     this.gridUrl = this.config.gridUrl ?? gridUrl;
+    this.storybookUrl = this.config.storybookUrl ?? config.storybookUrl;
   }
 
   async init(): Promise<void> {
     const poolSize = Math.max(1, this.config.limit ?? 1);
-    // TODO Init queue for workers to smooth browser starting load
-    this.workers = (await Promise.all(Array.from({ length: poolSize }).map(() => this.forkWorker()))).filter(
-      (workerOrError): workerOrError is Worker => workerOrError instanceof ClusterWorker,
-    );
+    this.workers = (
+      await Promise.all(
+        Array.from({ length: poolSize }).map(() =>
+          this.scheduler.forkWorker(this.browser, this.storybookUrl, this.gridUrl),
+        ),
+      )
+    ).filter((workerOrError): workerOrError is Worker => workerOrError instanceof ClusterWorker);
     if (this.workers.length != poolSize)
       throw new Error(`Can't instantiate workers for ${this.browser} due many errors`);
     this.workers.forEach((worker) => {
@@ -66,7 +63,7 @@ export default class Pool extends EventEmitter {
     return true;
   }
 
-  stop(): void {
+  stop() {
     if (!this.isRunning) {
       this.emit('stop');
       return;
@@ -76,7 +73,7 @@ export default class Pool extends EventEmitter {
     this.queue = [];
   }
 
-  process(): void {
+  process() {
     const worker = this.getFreeWorker();
     const test = this.queue.at(0);
 
@@ -99,7 +96,9 @@ export default class Pool extends EventEmitter {
 
     sendTestMessage(worker, { type: 'start', payload: test });
 
-    this.process();
+    setImmediate(() => {
+      this.process();
+    });
   }
 
   private sendStatus(message: { id: string; status: TestStatus; result?: TestResult }): void {
@@ -120,36 +119,12 @@ export default class Pool extends EventEmitter {
     return this.aliveWorkers.filter((worker) => !worker.isRunning);
   }
 
-  private async forkWorker(retry = 0): Promise<Worker | { error: string }> {
-    if (isShuttingDown.current) return { error: 'Master process is shutting down' };
-
-    cluster.setupPrimary({
-      args: ['--browser', this.browser, ...(this.gridUrl ? ['--gridUrl', this.gridUrl] : []), ...process.argv.slice(2)],
-    });
-    const worker = cluster.fork();
-    const message = await new Promise((resolve: (value: WorkerMessage) => void) => {
-      const readyHandler = (message: unknown): void => {
-        if (!isWorkerMessage(message) || message.type == 'port') return;
-        worker.off('message', readyHandler);
-        resolve(message);
-      };
-      worker.on('message', readyHandler);
-    });
-
-    if (message.type != 'error') return worker;
-
-    this.gracefullyKill(worker);
-
-    if (retry == FORK_RETRIES) return message.payload;
-    return this.forkWorker(retry + 1);
-  }
-
   private exitHandler(worker: Worker): void {
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
     worker.once('exit', async () => {
       if (isShuttingDown.current) return;
 
-      const workerOrError = await this.forkWorker();
+      const workerOrError = await this.scheduler.forkWorker(this.browser, this.storybookUrl, this.gridUrl);
 
       if (!(workerOrError instanceof ClusterWorker))
         throw new Error(`Can't instantiate worker for ${this.browser} due many errors`);
@@ -160,17 +135,6 @@ export default class Pool extends EventEmitter {
     });
   }
 
-  private gracefullyKill(worker: Worker): void {
-    worker.isShuttingDown = true;
-    const timeout = setTimeout(() => {
-      worker.kill();
-    }, 10000);
-    worker.on('exit', () => {
-      clearTimeout(timeout);
-    });
-    sendShutdownMessage(worker);
-  }
-
   private shouldRetry(test: WorkerTest): boolean {
     return test.retries < this.maxRetries && !this.forcedStop;
   }
@@ -202,10 +166,10 @@ export default class Pool extends EventEmitter {
         });
 
         if (message.payload.subtype == 'unknown') {
-          this.gracefullyKill(worker);
+          gracefullyKill(worker);
         }
 
-        this.handleTestResult(worker, test, { status: 'failed', error: message.payload.error });
+        this.handleTestResult(worker, test, { status: 'failed', error: message.payload.error, retries: test.retries });
       }),
       subscribeOnWorker(worker, 'test', (message) => {
         if (message.type != 'end') return;

package/src/server/master/queue.ts

@@ -0,0 +1,77 @@
+import cluster from 'cluster';
+import { isWorkerMessage, Worker, WorkerMessage } from '../../types.js';
+import { gracefullyKill, isShuttingDown } from '../utils.js';
+
+const FORK_RETRIES = 5;
+
+type MaybeWorker = Worker | { error: string };
+
+export class WorkerQueue {
+  private isProcessing = false;
+  private queue: {
+    browser: string;
+    storybookUrl: string;
+    gridUrl?: string;
+    retry: number;
+    resolve: (mw: MaybeWorker) => void;
+  }[] = [];
+
+  // TODO Add concurrency
+  constructor(private useQueue: boolean) {}
+
+  async forkWorker(browser: string, storybookUrl: string, gridUrl?: string, retry = 0): Promise<MaybeWorker> {
+    return new Promise<MaybeWorker>((resolve) => {
+      this.queue.push({ browser, storybookUrl, gridUrl, retry, resolve });
+
+      void this.process();
+    });
+  }
+
+  private async process() {
+    if (this.useQueue && this.isProcessing) return;
+
+    const { browser, storybookUrl, gridUrl, retry, resolve } = this.queue.pop() ?? {};
+
+    if (browser == undefined || storybookUrl == undefined || retry == undefined || resolve == undefined) return;
+
+    if (isShuttingDown.current) {
+      resolve({ error: 'Master process is shutting down' });
+      return;
+    }
+
+    this.isProcessing = true;
+
+    cluster.setupPrimary({
+      args: [
+        '--browser',
+        browser,
+        ...(gridUrl ? ['--gridUrl', gridUrl] : []),
+        ...process.argv.slice(2),
+        '--storybookUrl',
+        storybookUrl,
+      ],
+    });
+    const worker = cluster.fork();
+    const message = await new Promise((resolve: (value: WorkerMessage) => void) => {
+      const readyHandler = (message: unknown): void => {
+        if (!isWorkerMessage(message) || message.type == 'port') return;
+        worker.off('message', readyHandler);
+        resolve(message);
+      };
+      worker.on('message', readyHandler);
+    });
+
+    if (message.type == 'error') {
+      gracefullyKill(worker);
+
+      if (retry == FORK_RETRIES) resolve(message.payload);
+      else this.queue.push({ browser, storybookUrl, gridUrl, retry: retry + 1, resolve });
+    } else {
+      resolve(worker);
+    }
+
+    this.isProcessing = false;
+
+    setImmediate(() => void this.process());
+  }
+}

package/src/server/master/runner.ts

@@ -11,15 +11,35 @@ import {
   TestStatus,
   ServerTest,
   TestMeta,
+  TEST_EVENTS,
+  FakeSuite,
+  FakeTest,
 } from '../../types.js';
 import Pool from './pool.js';
+import { WorkerQueue } from './queue.js';
+import { getTestPath } from '../utils.js';
+import { getReporter } from '../reporters/index.js';
+
+// NOTE: This is workaround to fix parallel tests running with mocha-junit-reporter
+let isJUnit = false;
+
+class FakeRunner extends EventEmitter {
+  public stats = {
+    duration: 0,
+    failures: 0,
+    pending: 0,
+  };
+}
 
 export default class Runner extends EventEmitter {
   private failFast: boolean;
   private screenDir: string;
   private reportDir: string;
   private browsers: string[];
+  private scheduler: WorkerQueue;
   private pools: Record<string, Pool> = {};
+  private fakeRunner: FakeRunner;
+  private config: Config;
   tests: Partial<Record<string, ServerTest>> = {};
   public get isRunning(): boolean {
     return Object.values(this.pools).some((pool) => pool.isRunning);
@@ -27,12 +47,25 @@ export default class Runner extends EventEmitter {
   constructor(config: Config, gridUrl?: string) {
     super();
 
+    this.config = config;
     this.failFast = config.failFast;
     this.screenDir = config.screenDir;
     this.reportDir = config.reportDir;
+    this.scheduler = new WorkerQueue(config.useWorkerQueue);
     this.browsers = Object.keys(config.browsers);
+
+    const runner = new FakeRunner();
+    const Reporter = getReporter(config.reporter);
+
+    if (Reporter.name == 'MochaJUnitReporter') {
+      isJUnit = true;
+    }
+
+    new Reporter(runner, { reportDir: this.reportDir, reporterOptions: config.reporterOptions });
+    this.fakeRunner = runner;
+
     this.browsers
-      .map((browser) => (this.pools[browser] = new Pool(config, browser, gridUrl)))
+      .map((browser) => (this.pools[browser] = new Pool(this.scheduler, config, browser, gridUrl)))
       .map((pool) => pool.on('test', this.handlePoolMessage));
   }
 
@@ -42,22 +75,77 @@ export default class Runner extends EventEmitter {
 
     if (!test) return;
     const { browser, testName, storyPath, storyId } = test;
+
+    const fakeSuite: FakeSuite = {
+      title: test.storyPath.slice(0, -1).join('/'),
+      fullTitle: () => fakeSuite.title,
+      titlePath: () => [fakeSuite.title],
+      tests: [],
+    };
+
+    const fakeTest: FakeTest = {
+      parent: fakeSuite,
+      title: [test.story.name, testName, browser].filter(isDefined).join('/'),
+      fullTitle: () => getTestPath(test).join('/'),
+      titlePath: () => getTestPath(test),
+      currentRetry: () => result?.retries,
+      retires: () => this.config.maxRetries,
+      slow: () => 1000,
+      err: result?.error,
+      creevey: {
+        sessionId: result?.sessionId ?? id,
+        browserName: result?.browserName ?? browser,
+        workerId: result?.workerId ?? process.pid,
+        willRetry: (result?.retries ?? 0) < this.config.maxRetries,
+        images: result?.images ?? {},
+      },
+    };
+
+    fakeSuite.tests.push(fakeTest);
+
     // TODO Handle 'retrying' status
     test.status = status == 'retrying' ? 'failed' : status;
     if (!result) {
       // NOTE: Running status
+      this.fakeRunner.emit(TEST_EVENTS.TEST_BEGIN, fakeTest);
       this.sendUpdate({ tests: { [id]: { id, browser, testName, storyPath, status: test.status, storyId } } });
       return;
     }
-    if (!test.results) {
-      test.results = [];
-    }
+    test.results ??= [];
     test.results.push(result);
 
     if (status == 'failed') {
       test.approved = null;
     }
 
+    const { duration, attachments } = result;
+
+    fakeTest.duration = duration;
+    fakeTest.attachments = attachments;
+    fakeTest.state = result.status === 'failed' ? 'failed' : 'passed';
+    if (duration !== undefined) {
+      fakeTest.speed = duration > fakeTest.slow() ? 'slow' : duration / 2 > fakeTest.slow() ? 'medium' : 'fast';
+    }
+
+    if (isJUnit) {
+      this.fakeRunner.emit(TEST_EVENTS.SUITE_BEGIN, fakeSuite);
+    }
+
+    if (result.status === 'failed') {
+      fakeTest.err = result.error;
+      this.fakeRunner.emit(TEST_EVENTS.TEST_FAIL, fakeTest, result.error);
+      this.fakeRunner.stats.failures++;
+    } else {
+      this.fakeRunner.emit(TEST_EVENTS.TEST_PASS, fakeTest);
+      this.fakeRunner.stats.duration += duration ?? 0;
+    }
+
+    if (isJUnit) {
+      this.fakeRunner.emit(TEST_EVENTS.SUITE_END, fakeSuite);
+    }
+
+    this.fakeRunner.emit(TEST_EVENTS.TEST_END, fakeTest);
+
     this.sendUpdate({
       tests: {
         [id]: {
@@ -78,6 +166,7 @@ export default class Runner extends EventEmitter {
 
   private handlePoolStop = (): void => {
     if (!this.isRunning) {
+      this.fakeRunner.emit(TEST_EVENTS.RUN_END);
       this.sendUpdate({ isRunning: false });
       this.emit('stop');
     }
@@ -147,6 +236,7 @@ export default class Runner extends EventEmitter {
       };
     }, {});
 
+    this.fakeRunner.emit(TEST_EVENTS.RUN_BEGIN);
     this.browsers.forEach((browser) => {
       const pool = this.pools[browser];
       const tests = testsByBrowser[browser];
@@ -198,9 +288,7 @@ export default class Runner extends EventEmitter {
         if (!image) continue;
         await this.copyImage(test, name, image.actual);
 
-        if (!test.approved) {
-          test.approved = {};
-        }
+        test.approved ??= {};
         test.approved[name] = retry;
         test.status = 'approved';
 
@@ -224,9 +312,7 @@ export default class Runner extends EventEmitter {
     if (!result.images) return;
     const images = result.images[image];
     if (!images) return;
-    if (!test.approved) {
-      test.approved = {};
-    }
+    test.approved ??= {};
     const { browser, testName, storyPath, storyId } = test;
 
     await this.copyImage(test, image, images.actual);

package/src/server/master/server.ts

@@ -96,7 +96,7 @@ export function start(reportDir: string, port: number, ui: boolean): (api: Creev
   app.use(mount('/report', serve(reportDir)));
 
   wss.on('error', (error) => {
-    logger.error(error);
+    logger().error(error);
   });
 
   server.listen(port);

package/src/server/master/start.ts

@@ -14,13 +14,14 @@ import { sendScreenshotsCount } from '../telemetry.js';
 const importMetaUrl = pathToFileURL(__filename).href;
 
 async function copyStatics(reportDir: string): Promise<void> {
-  const clientDir = path.join(path.dirname(fileURLToPath(importMetaUrl)), '../../client/web');
-  const files = (await readdir(clientDir, { withFileTypes: true }))
-    .filter((dirent) => dirent.isFile() && !dirent.name.endsWith('.d.ts') && !dirent.name.endsWith('.tsx'))
+  const clientDir = path.join(path.dirname(fileURLToPath(importMetaUrl)), '../../../dist/client/web');
+  const assets = (await readdir(path.join(clientDir, 'assets'), { withFileTypes: true }))
+    .filter((dirent) => dirent.isFile())
     .map((dirent) => dirent.name);
-  await mkdir(reportDir, { recursive: true });
-  for (const file of files) {
-    await copyFile(path.join(clientDir, file), path.join(reportDir, file));
+  await mkdir(path.join(reportDir, 'assets'), { recursive: true });
+  await copyFile(path.join(clientDir, 'index.html'), path.join(reportDir, 'index.html'));
+  for (const asset of assets) {
+    await copyFile(path.join(clientDir, 'assets', asset), path.join(reportDir, 'assets', asset));
   }
 }
 
@@ -42,7 +43,10 @@ function outputUnnecessaryImages(imagesDir: string, images: Set<string>): void {
     .map((imagePath) => path.posix.relative(imagesDir, imagePath))
     .filter((imagePath) => !images.has(imagePath));
   if (unnecessaryImages.length > 0) {
-    logger.warn('We found unnecessary screenshot images, those can be safely removed:\n', unnecessaryImages.join('\n'));
+    logger().warn(
+      'We found unnecessary screenshot images, those can be safely removed:\n',
+      unnecessaryImages.join('\n'),
+    );
   }
 }
 
@@ -81,10 +85,10 @@ export async function start(
 
   if (options.ui) {
     resolveApi(creeveyApi(runner));
-    logger.info(`Started on http://localhost:${options.port}`);
+    logger().info(`Started on http://localhost:${options.port}`);
   } else {
     if (Object.values(runner.status.tests).filter((test) => test && !test.skip).length == 0) {
-      logger.warn("Don't have any tests to run");
+      logger().warn("Don't have any tests to run");
 
       void shutdownWorkers().then(() => process.exit());
       return;
@@ -101,10 +105,11 @@ export async function start(
       void sendScreenshotsCount(config, options, runner.status)
         .catch((reason: unknown) => {
           const error = reason instanceof Error ? (reason.stack ?? reason.message) : (reason as string);
-          logger.warn(`Can't send telemetry: ${error}`);
+          logger().warn(`Can't send telemetry: ${error}`);
         })
         .finally(() => {
-          void shutdownWorkers().then(() => process.exit());
+          // NOTE: Take some time to kill processes
+          void shutdownWorkers().then(() => setTimeout(() => process.exit(), 500));
         });
     });
     // TODO grep