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

package/src/client/web/CreeveyView/SideBar/SideBarFooter.tsx

@@ -1,4 +1,4 @@
-import React, { JSX } from 'react';
+import React, { JSX, useCallback, useEffect, useState } from 'react';
 import { styled, withTheme } from '@storybook/theming';
 import { Button } from '@storybook/components';
 import { ChevronRightIcon } from '@storybook/icons';
@@ -21,15 +21,46 @@ const Container = styled.div({
 });
 
 export function SideBarFooter(): JSX.Element {
-  const { onApproveAll, onImageApprove } = useCreeveyContext();
+  const { onApproveAll, onImageApprove, onImageNext } = useCreeveyContext();
+  const [isAlt, setIsAlt] = useState(false);
+
+  const handleKeyDown = useCallback((e: KeyboardEvent) => {
+    if (e.code === 'AltLeft') {
+      e.preventDefault();
+      setIsAlt(true);
+    }
+  }, []);
+  const handleKeyUp = useCallback((e: KeyboardEvent) => {
+    if (e.code === 'AltLeft') {
+      e.preventDefault();
+      setIsAlt(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    document.addEventListener('keydown', handleKeyDown, false);
+    document.addEventListener('keyup', handleKeyUp, false);
+
+    return () => {
+      document.removeEventListener('keydown', handleKeyDown, false);
+      document.removeEventListener('keyup', handleKeyUp, false);
+    };
+  }, [handleKeyDown, handleKeyUp]);
 
   return (
     <Sticky>
       <Container>
-        <Button variant="solid" size="medium" onClick={onImageApprove} disabled={!onImageApprove}>
-          Approve
-          <ChevronRightIcon />
-        </Button>
+        {isAlt ? (
+          <Button variant="outline" size="medium" onClick={onImageNext} disabled={!onImageApprove}>
+            Next
+            <ChevronRightIcon />
+          </Button>
+        ) : (
+          <Button variant="solid" size="medium" onClick={onImageApprove} disabled={!onImageApprove}>
+            Approve
+            <ChevronRightIcon />
+          </Button>
+        )}
         <Button variant="outline" size="medium" onClick={onApproveAll}>
           Approve all
         </Button>

package/src/client/web/CreeveyView/SideBar/SuiteLink.tsx

@@ -1,11 +1,10 @@
-import React, { JSX, useRef, useContext, useEffect, useMemo } from 'react';
+import React, { JSX, useRef, useEffect, useMemo } from 'react';
 import { ChevronDownIcon, ChevronRightIcon } from '@storybook/icons';
 import { styled, withTheme, Theme } from '@storybook/theming';
 import { Checkbox, CheckboxContainer } from './Checkbox.js';
 import { TestStatusIcon } from './TestStatusIcon.js';
 import { CreeveySuite, isTest } from '../../../../types.js';
-import { CreeveyContext } from '../../CreeveyContext.js';
-import { KeyboardEventsContext } from '../../KeyboardEventsContext.js';
+import { useCreeveyContext } from '../../CreeveyContext.js';
 
 export interface SuiteLinkProps {
   title: string;
@@ -79,8 +78,7 @@ export const SuiteTitle = styled.span({
 });
 
 export function SuiteLink({ title, suite, 'data-testid': dataTid }: SuiteLinkProps): JSX.Element {
-  const { onSuiteOpen, onSuiteToggle } = useContext(CreeveyContext);
-  const { sidebarFocusedItem, setSidebarFocusedItem } = useContext(KeyboardEventsContext);
+  const { onSuiteOpen, onSuiteToggle, sidebarFocusedItem, setSidebarFocusedItem } = useCreeveyContext();
   const checkboxRef = useRef<Checkbox>(null);
   const buttonRef = useRef<HTMLButtonElement | null>(null);
 

package/src/client/web/CreeveyView/SideBar/TestLink.tsx

@@ -1,9 +1,8 @@
 import React, { JSX, useEffect, useCallback, useContext, useMemo, useRef } from 'react';
 import { CreeveyTest } from '../../../../types.js';
 import { TestStatusIcon } from './TestStatusIcon.js';
-import { CreeveyContext } from '../../CreeveyContext.js';
+import { useCreeveyContext } from '../../CreeveyContext.js';
 import { SideBarContext } from './SideBar.js';
-import { KeyboardEventsContext } from '../../KeyboardEventsContext.js';
 import { Button, Container, SuiteContainer, SuiteTitle } from './SuiteLink.js';
 import { Checkbox, CheckboxContainer } from './Checkbox.js';
 import { getTestPath } from '../../../shared/helpers.js';
@@ -20,9 +19,8 @@ const TestContainer = styled(SuiteContainer)({
 });
 
 export function TestLink({ title, opened, test }: TestLinkProps): JSX.Element {
-  const { onSuiteToggle } = useContext(CreeveyContext);
+  const { onSuiteToggle, sidebarFocusedItem, setSidebarFocusedItem } = useCreeveyContext();
   const { onOpenTest } = useContext(SideBarContext);
-  const { sidebarFocusedItem, setSidebarFocusedItem } = useContext(KeyboardEventsContext);
   const buttonRef = useRef<HTMLButtonElement | null>(null);
 
   const emptyResults = (test.results?.length ?? 0) == 0;

package/src/client/web/KeyboardEventsContext.tsx

@@ -1,20 +1,7 @@
-import React, { JSX, useState, useEffect, useCallback, useContext, PropsWithChildren } from 'react';
-import { CreeveySuite, isTest, noop } from '../../types.js';
+import React, { JSX, useEffect, useCallback, PropsWithChildren } from 'react';
+import { CreeveySuite, isTest } from '../../types.js';
 import { CreeveyViewFilter, filterTests, flattenSuite, getSuiteByPath, getTestPath } from '../shared/helpers.js';
-import { CreeveyContext } from './CreeveyContext.js';
-
-export type SuitePath = string[];
-export type FocusableItem = null | SuitePath;
-
-export interface KeyboardEventsContextType {
-  sidebarFocusedItem: FocusableItem;
-  setSidebarFocusedItem: (item: FocusableItem) => void;
-}
-
-export const KeyboardEventsContext = React.createContext<KeyboardEventsContextType>({
-  sidebarFocusedItem: [],
-  setSidebarFocusedItem: noop,
-});
+import { useCreeveyContext } from './CreeveyContext.js';
 
 export const KeyboardEvents = ({
   children,
@@ -24,9 +11,7 @@ export const KeyboardEvents = ({
   rootSuite: CreeveySuite;
   filter: CreeveyViewFilter;
 }>): JSX.Element => {
-  const [sidebarFocusedItem, setSidebarFocusedItem] = useState<FocusableItem>([]);
-
-  const { onSuiteOpen, onSuiteToggle } = useContext(CreeveyContext);
+  const { onSuiteOpen, onSuiteToggle, sidebarFocusedItem, setSidebarFocusedItem } = useCreeveyContext();
 
   const suiteList = flattenSuite(filterTests(rootSuite, filter));
 
@@ -45,63 +30,70 @@ export const KeyboardEvents = ({
     (e: KeyboardEvent) => {
       if (sidebarFocusedItem === null) return;
 
-      if (e.code === 'Enter') {
-        if (sidebarFocusedItem.length === 0) return;
-
-        const focusedSuite = getSuiteByPath(rootSuite, sidebarFocusedItem);
-        if (!focusedSuite) return;
-        if (!isTest(focusedSuite)) {
-          e.preventDefault();
-          onSuiteOpen(focusedSuite.path, !focusedSuite.opened);
+      switch (e.code) {
+        case 'Enter': {
+          if (sidebarFocusedItem.length === 0) return;
+
+          const focusedSuite = getSuiteByPath(rootSuite, sidebarFocusedItem);
+          if (!focusedSuite) return;
+          if (!isTest(focusedSuite)) {
+            e.preventDefault();
+            onSuiteOpen(focusedSuite.path, !focusedSuite.opened);
+          }
+          if (isTest(focusedSuite) && focusedSuite.results?.length == 0) {
+            e.preventDefault();
+          }
+          return;
         }
-        if (isTest(focusedSuite) && focusedSuite.results?.length == 0) {
+        case 'Space': {
           e.preventDefault();
+          // TODO handle keys in one place
+          if (e.altKey) return;
+          const focusedSuite = getSuiteByPath(rootSuite, sidebarFocusedItem);
+          if (!focusedSuite) return;
+          const path = isTest(focusedSuite) ? getTestPath(focusedSuite) : focusedSuite.path;
+          onSuiteToggle(path, !focusedSuite.checked);
+          return;
         }
-        return;
-      }
-      if (e.code === 'Space') {
-        e.preventDefault();
-        const focusedSuite = getSuiteByPath(rootSuite, sidebarFocusedItem);
-        if (!focusedSuite) return;
-        const path = isTest(focusedSuite) ? getTestPath(focusedSuite) : focusedSuite.path;
-        onSuiteToggle(path, !focusedSuite.checked);
-      }
-      if (e.code === 'ArrowDown') {
-        const currentIndex = sidebarFocusedItem.length === 0 ? -1 : getFocusedItemIndex(sidebarFocusedItem);
-        if (currentIndex === suiteList.length - 1) return;
-        const nextSuite = suiteList[currentIndex + 1];
-        const nextPath = isTest(nextSuite.suite) ? getTestPath(nextSuite.suite) : nextSuite.suite.path;
-        setSidebarFocusedItem(nextPath);
-      }
-      if (e.code === 'ArrowUp') {
-        const currentIndex = sidebarFocusedItem.length === 0 ? 0 : getFocusedItemIndex(sidebarFocusedItem);
-        const nextSuite = currentIndex > 0 ? suiteList[currentIndex - 1].suite : rootSuite;
-        const nextPath = isTest(nextSuite) ? getTestPath(nextSuite) : nextSuite.path;
-        setSidebarFocusedItem(nextPath);
-      }
-
-      if (e.code === 'ArrowRight') {
-        if (sidebarFocusedItem.length === 0) return;
-        const focusedSuite = getSuiteByPath(rootSuite, sidebarFocusedItem);
-
-        if (!focusedSuite || isTest(focusedSuite)) return;
-        onSuiteOpen(focusedSuite.path, true);
-      }
-
-      if (e.code === 'ArrowLeft') {
-        if (sidebarFocusedItem.length === 0) return;
-        const focusedSuite = getSuiteByPath(rootSuite, sidebarFocusedItem);
-        if (!focusedSuite) return;
-        if (!isTest(focusedSuite) && focusedSuite.opened) {
-          onSuiteOpen(focusedSuite.path, false);
+        case 'ArrowDown': {
+          const currentIndex = sidebarFocusedItem.length === 0 ? -1 : getFocusedItemIndex(sidebarFocusedItem);
+          if (currentIndex === suiteList.length - 1) return;
+          const nextSuite = suiteList[currentIndex + 1];
+          const nextPath = isTest(nextSuite.suite) ? getTestPath(nextSuite.suite) : nextSuite.suite.path;
+          setSidebarFocusedItem(nextPath);
+          return;
+        }
+        case 'ArrowUp': {
+          const currentIndex = sidebarFocusedItem.length === 0 ? 0 : getFocusedItemIndex(sidebarFocusedItem);
+          const nextSuite = currentIndex > 0 ? suiteList[currentIndex - 1].suite : rootSuite;
+          const nextPath = isTest(nextSuite) ? getTestPath(nextSuite) : nextSuite.path;
+          setSidebarFocusedItem(nextPath);
           return;
         }
+        case 'ArrowRight': {
+          if (sidebarFocusedItem.length === 0) return;
+          const focusedSuite = getSuiteByPath(rootSuite, sidebarFocusedItem);
 
-        const path = isTest(focusedSuite) ? getTestPath(focusedSuite) : focusedSuite.path;
-        setSidebarFocusedItem(path.slice(0, -1));
+          if (!focusedSuite || isTest(focusedSuite)) return;
+          onSuiteOpen(focusedSuite.path, true);
+          return;
+        }
+        case 'ArrowLeft': {
+          if (sidebarFocusedItem.length === 0) return;
+          const focusedSuite = getSuiteByPath(rootSuite, sidebarFocusedItem);
+          if (!focusedSuite) return;
+          if (!isTest(focusedSuite) && focusedSuite.opened) {
+            onSuiteOpen(focusedSuite.path, false);
+            return;
+          }
+
+          const path = isTest(focusedSuite) ? getTestPath(focusedSuite) : focusedSuite.path;
+          setSidebarFocusedItem(path.slice(0, -1));
+          return;
+        }
       }
     },
-    [onSuiteOpen, onSuiteToggle, rootSuite, suiteList, getFocusedItemIndex, sidebarFocusedItem],
+    [onSuiteOpen, onSuiteToggle, rootSuite, suiteList, getFocusedItemIndex, sidebarFocusedItem, setSidebarFocusedItem],
   );
 
   useEffect(() => {
@@ -112,9 +104,5 @@ export const KeyboardEvents = ({
     };
   }, [handleKeyDown]);
 
-  return (
-    <KeyboardEventsContext.Provider value={{ sidebarFocusedItem, setSidebarFocusedItem }}>
-      {children}
-    </KeyboardEventsContext.Provider>
-  );
+  return <>{children}</>;
 };

package/src/client/web/themes.ts

@@ -0,0 +1,24 @@
+import { useEffect, useState } from 'react';
+import { themes, ThemeVars } from '@storybook/theming';
+import { isDefined } from '../../types.js';
+
+const CREEVEY_THEME = 'Creevey_theme';
+
+function isTheme(theme?: string | null): theme is ThemeVars['base'] {
+  return isDefined(theme) && Object.prototype.hasOwnProperty.call(themes, theme);
+}
+
+function initialTheme(): ThemeVars['base'] {
+  const theme = localStorage.getItem(CREEVEY_THEME);
+  return isTheme(theme) ? theme : 'light';
+}
+
+export function useTheme(): [ThemeVars['base'], (theme: ThemeVars['base']) => void] {
+  const [theme, setTheme] = useState<ThemeVars['base']>(initialTheme());
+
+  useEffect(() => {
+    localStorage.setItem(CREEVEY_THEME, theme);
+  }, [theme]);
+
+  return [theme, setTheme];
+}

package/src/creevey.ts

@@ -5,14 +5,14 @@ import { Options } from './types.js';
 import { emitWorkerMessage } from './server/messages.js';
 import { isShuttingDown, shutdownWorkers } from './server/utils.js';
 import Logger from 'loglevel';
-import { logger } from './server/logger.js';
+import { logger, setRootName } from './server/logger.js';
 
 function shutdownOnException(reason: unknown): void {
   if (isShuttingDown.current) return;
 
   const error = reason instanceof Error ? (reason.stack ?? reason.message) : (reason as string);
 
-  logger.error(error);
+  logger().error(error);
 
   process.exitCode = -1;
   if (cluster.isWorker) emitWorkerMessage({ type: 'error', payload: { subtype: 'unknown', error } });
@@ -23,19 +23,25 @@ process.on('uncaughtException', shutdownOnException);
 process.on('unhandledRejection', shutdownOnException);
 // TODO SIGINT Stuck with selenium
 process.on('SIGINT', () => {
+  if (isShuttingDown.current) {
+    process.exit(-1);
+  }
   isShuttingDown.current = true;
 });
 
 const argv = minimist<Options>(process.argv.slice(2), {
-  string: ['browser', 'config', 'reporter', 'reportDir', 'screenDir', 'gridUrl', 'storybookUrl'],
-  boolean: ['debug', 'trace', 'ui', 'odiff'],
-  default: { port: 3000 },
-  alias: { port: 'p', config: 'c', debug: 'd', update: 'u' },
+  string: ['browser', 'config', 'reporter', 'reportDir', 'screenDir', 'gridUrl', 'storybookUrl', 'storybookPort'],
+  boolean: ['debug', 'trace', 'ui', 'odiff', 'noDocker'],
+  default: { port: '3000' },
+  alias: { port: 'p', config: 'c', debug: 'd', update: 'u', storybookStart: 's' },
 });
 
+if ('port' in argv && !isNaN(argv.port)) argv.port = Number(argv.port);
+if ('browser' in argv && argv.browser) setRootName(argv.browser);
+
 // eslint-disable-next-line @typescript-eslint/no-deprecated
 if (cluster.isPrimary && argv.reporter) {
-  logger.warn(`--reporter option has been removed please describe reporter in config file:
+  logger().warn(`--reporter option has been removed please describe reporter in config file:
     import { reporters } from 'mocha';
 
     const config = {
@@ -52,13 +58,13 @@ if (cluster.isPrimary && argv.reporter) {
 // @ts-expect-error: define log level for storybook
 global.LOGLEVEL = argv.trace ? 'trace' : argv.debug ? 'debug' : 'warn';
 if (argv.trace) {
-  logger.setDefaultLevel(Logger.levels.TRACE);
+  logger().setDefaultLevel(Logger.levels.TRACE);
   Logger.setDefaultLevel(Logger.levels.TRACE);
 } else if (argv.debug) {
-  logger.setDefaultLevel(Logger.levels.DEBUG);
+  logger().setDefaultLevel(Logger.levels.DEBUG);
   Logger.setDefaultLevel(Logger.levels.DEBUG);
 } else {
-  logger.setDefaultLevel(Logger.levels.INFO);
+  logger().setDefaultLevel(Logger.levels.INFO);
   Logger.setDefaultLevel(Logger.levels.INFO);
 }
 

package/src/server/config.ts

@@ -1,33 +1,37 @@
 import fs from 'fs';
 import path from 'path';
+import cluster from 'cluster';
 import { pathToFileURL } from 'url';
-import { loadStories as browserStoriesProvider } from './providers/browser.js';
+import { loadStories as hybridStoriesProvider } from './providers/hybrid.js';
 import { Config, BrowserConfig, BrowserConfigObject, Options, isDefined } from '../types.js';
 import { configExt, loadThroughTSX } from './utils.js';
-import { CreeveyReporter, TeamcityReporter } from './reporter.js';
+import { CreeveyReporter } from './reporters/creevey.js';
+import { TeamcityReporter } from './reporters/teamcity.js';
 import { logger } from './logger.js';
 
 export const defaultBrowser = 'chrome';
 
-export const defaultConfig: Omit<Config, 'gridUrl' | 'testsDir' | 'tsConfig' | 'webdriver'> = {
+export const defaultConfig: Omit<Config, 'gridUrl' | 'tsConfig' | 'webdriver'> = {
   disableTelemetry: false,
+  useWorkerQueue: false,
   useDocker: true,
-  dockerImage: 'aerokube/selenoid:latest-release',
+  dockerImage: 'aerokube/selenoid:latest-release', // TODO What about playwright?
   dockerImagePlatform: '',
   pullImages: true,
   failFast: false,
   storybookUrl: 'http://localhost:6006',
   screenDir: path.resolve('images'),
   reportDir: path.resolve('report'),
+  testsDir: path.resolve('src'),
   reporter: process.env.TEAMCITY_VERSION ? TeamcityReporter : CreeveyReporter,
-  storiesProvider: browserStoriesProvider,
+  storiesProvider: hybridStoriesProvider,
   maxRetries: 0,
   testTimeout: 30000,
   diffOptions: { threshold: 0.1, includeAA: false },
   odiffOptions: { threshold: 0.1, antialiasing: true },
   browsers: { [defaultBrowser]: true },
   hooks: {},
-  testsRegex: /\.creevey\.(t|j)s$/,
+  testsRegex: /\.creevey\.(m|c)?(t|j)s$/,
 };
 
 function normalizeBrowserConfig(name: string, config: BrowserConfig): BrowserConfigObject {
@@ -73,7 +77,7 @@ export async function readConfig(options: Options): Promise<Config> {
 
     if (!configData.webdriver) {
       const { SeleniumWebdriver } = await import('./selenium/webdriver.js');
-      logger.warn(
+      logger().warn(
         "Creevey supports `Selenium` and `Playwright` webdrivers. For backward compatibility `Selenium` is used by default, but it might changed in the future. Please explicitly specify one of webdrivers in your Creevey's config",
       );
       configData.webdriver = SeleniumWebdriver;
@@ -82,10 +86,29 @@ export async function readConfig(options: Options): Promise<Config> {
     Object.assign(userConfig, configData);
   }
 
+  if (userConfig.resolveStorybookUrl && !options.storybookUrl) {
+    userConfig.storybookUrl = await userConfig.resolveStorybookUrl();
+  }
+
+  if (options.noDocker) userConfig.useDocker = false;
   if (options.failFast != undefined) userConfig.failFast = Boolean(options.failFast);
   if (options.reportDir) userConfig.reportDir = path.resolve(options.reportDir);
   if (options.screenDir) userConfig.screenDir = path.resolve(options.screenDir);
   if (options.storybookUrl) userConfig.storybookUrl = options.storybookUrl;
+  if (options.storybookPort && cluster.isPrimary) {
+    const url = new URL(userConfig.storybookUrl);
+    url.port = options.storybookPort;
+    userConfig.storybookUrl = url.toString();
+  }
+  if (typeof options.storybookStart === 'string') userConfig.storybookAutorunCmd = options.storybookStart;
+
+  if (options.storybookStart && cluster.isPrimary) {
+    const { default: getPort } = await import('get-port');
+    const url = new URL(userConfig.storybookUrl);
+    const port = await getPort({ port: Number(url.port) });
+    url.port = `${port}`;
+    userConfig.storybookUrl = url.toString();
+  }
 
   // NOTE: Hack to pass typescript checking
   const config = userConfig as Config;

package/src/server/connection.ts

@@ -0,0 +1,26 @@
+import type { Config, Options } from '../types';
+import { waitOnUrl } from './utils.js';
+import { logger } from './logger.js';
+
+const RESPONSE_CHECK_TIMEOUT_MS = 10000;
+const RESPONSE_CHECK_INTERVAL_MS = 200;
+
+export function getStorybookUrl({ storybookUrl }: Config, { storybookStart }: Options): [string, string | undefined] {
+  if (storybookStart) {
+    const url = new URL(storybookUrl);
+    url.hostname = 'localhost';
+    return [url.toString(), storybookUrl];
+  }
+  return [storybookUrl, undefined];
+}
+
+export async function checkIsStorybookConnected(url: string) {
+  try {
+    await waitOnUrl(url, RESPONSE_CHECK_TIMEOUT_MS, RESPONSE_CHECK_INTERVAL_MS);
+    return true;
+  } catch (reason: unknown) {
+    const error = reason instanceof Error ? (reason.stack ?? reason.message) : (reason as string);
+    logger().error(error);
+    return false;
+  }
+}

package/src/server/docker.ts

@@ -1,9 +1,10 @@
 import tar from 'tar-stream';
+import Logger from 'loglevel';
 import { Writable } from 'stream';
 import Dockerode, { Container } from 'dockerode';
 import { DockerAuth } from '../types.js';
-import { subscribeOn } from './messages.js';
 import { logger } from './logger.js';
+import { setWorkerContainer } from './worker/context.js';
 
 const docker = new Dockerode();
 
@@ -21,7 +22,7 @@ export async function pullImages(
   if (auth) args.authconfig = auth;
   if (platform) args.platform = platform;
 
-  logger.info('Pull docker images');
+  logger().info('Pull docker images');
   // TODO Replace with `import from`
   const { default: yoctoSpinner } = await import('yocto-spinner');
   for (const image of images) {
@@ -50,18 +51,46 @@ export async function pullImages(
         function onProgress(event: { id: string; status: string; progress?: string }): void {
           if (!/^[a-z0-9]{12}$/i.test(event.id)) return;
 
-          spinner.text = `${image}: [${event.id}] ${event.status} ${event.progress ? event.progress : ''}`;
+          spinner.text = `${image}: [${event.id}] ${event.status} ${event.progress ?? ''}`;
         }
       });
     });
   }
 }
 
-export async function buildImage(imageName: string, dockerfile: string): Promise<void> {
+export async function buildImage(imageName: string, version: string, dockerfile: string): Promise<void> {
   const images = await docker.listImages({ filters: { label: [`creevey=${imageName}`] } });
 
-  if (images.at(0)) {
-    logger.info(`Image ${imageName} already exists`);
+  const containers = await docker.listContainers({ all: true, filters: { label: [`creevey=${imageName}`] } });
+  if (containers.length > 0) {
+    await Promise.all(
+      containers.map(async (info) => {
+        const container = docker.getContainer(info.Id);
+        try {
+          await container.remove({ force: true });
+        } catch {
+          /* noop */
+        }
+      }),
+    );
+  }
+
+  const oldImages = images.filter((info) => info.Labels.version !== version);
+  if (oldImages.length > 0) {
+    await Promise.all(
+      oldImages.map(async (info) => {
+        const image = docker.getImage(info.Id);
+        try {
+          await image.remove({ force: true });
+        } catch {
+          /* noop */
+        }
+      }),
+    );
+  }
+
+  if (oldImages.length !== images.length) {
+    logger().info(`Image ${imageName} already exists`);
     return;
   }
 
@@ -70,15 +99,20 @@ export async function buildImage(imageName: string, dockerfile: string): Promise
   pack.finalize();
 
   const { default: yoctoSpinner } = await import('yocto-spinner');
-  const spinner = yoctoSpinner({ text: `${imageName}: Build start` }).start();
+  const spinner = yoctoSpinner({ text: `${imageName}: Build start` });
+  if (logger().getLevel() > Logger.levels.DEBUG) {
+    spinner.start();
+  }
+  let isFailed = false;
   await new Promise<void>((resolve, reject) => {
     void docker.buildImage(
       // @ts-expect-error Type incompatibility AsyncIterator and AsyncIterableIterator
       pack,
-      { t: imageName, labels: { creevey: imageName } },
+      // TODO Support buildkit decode grpc (version: '2')
+      { t: imageName, labels: { creevey: imageName, version }, version: '1' },
       (buildError: Error | null, stream) => {
         if (buildError || !stream) {
-          spinner.error(buildError?.message);
+          // spinner.error(buildError?.message);
           reject(buildError ?? new Error('Unknown error'));
           return;
         }
@@ -86,6 +120,8 @@ export async function buildImage(imageName: string, dockerfile: string): Promise
         docker.modem.followProgress(stream, onFinished, onProgress);
 
         function onFinished(error: Error | null): void {
+          if (isFailed) return;
+
           if (error) {
             spinner.error(error.message);
             reject(error);
@@ -95,10 +131,23 @@ export async function buildImage(imageName: string, dockerfile: string): Promise
           resolve();
         }
 
-        function onProgress(event: { id: string; status: string; progress?: string }): void {
-          if (!/^[a-z0-9]{12}$/i.test(event.id)) return;
-
-          spinner.text = `${imageName}: [${event.id}] ${event.status} ${event.progress ? event.progress : ''}`;
+        function onProgress(
+          event:
+            | { stream: string }
+            | { errorDetail: { code: number; message: string }; error: string }
+            | { id: string; aux: string }, // NOTE: Only with `version: '2'`
+        ): void {
+          if ('stream' in event) {
+            if (logger().getLevel() <= Logger.levels.DEBUG) {
+              logger().debug(event.stream.trim());
+            } else {
+              spinner.text = `${imageName}: [Build] - ${event.stream}`;
+            }
+          } else if ('errorDetail' in event) {
+            isFailed = true;
+            spinner.error(event.error);
+            reject(new Error(event.error));
+          }
         }
       },
     );
@@ -111,33 +160,13 @@ export async function runImage(
   options: Record<string, unknown>,
   debug: boolean,
 ): Promise<string> {
-  await Promise.all(
-    (await docker.listContainers({ all: true, filters: { ancestor: [image] } })).map(async (info) => {
-      const container = docker.getContainer(info.Id);
-      try {
-        await container.stop();
-      } catch {
-        /* noop */
-      }
-      await container.remove();
-    }),
-  );
-
   const hub = docker.run(image, args, debug ? process.stdout : new DevNull(), options, (error) => {
     if (error) throw error;
   });
 
   return new Promise((resolve) => {
     hub.once('container', (container: Container) => {
-      // eslint-disable-next-line @typescript-eslint/no-misused-promises
-      subscribeOn('shutdown', async () => {
-        try {
-          await container.stop();
-          await container.remove();
-        } catch {
-          /* noop */
-        }
-      });
+      setWorkerContainer(container);
     });
     hub.once(
       'start',