@scandipwa/magento-scripts 1.16.1 → 2.0.0-alpha.0

package/lib/tasks/magento/install-magento-project.js

@@ -1,32 +1,27 @@
 const path = require('path');
 const fs = require('fs');
-const os = require('os');
+const logger = require('@scandipwa/scandipwa-dev-utils/logger');
 const runComposerCommand = require('../../util/run-composer');
 const matchFilesystem = require('../../util/match-filesystem');
-const moveFile = require('../../util/move-file');
 const pathExists = require('../../util/path-exists');
 const getJsonFileData = require('../../util/get-jsonfile-data');
-const rmdirSafe = require('../../util/rmdir-safe');
 const KnownError = require('../../errors/known-error');
 const UnknownError = require('../../errors/unknown-error');
-const logger = require('@scandipwa/scandipwa-dev-utils/logger');
+const { runPHPContainerCommand } = require('../php/php-container');
 
 const magentoProductEnterpriseEdition = 'magento/product-enterprise-edition';
 const magentoProductCommunityEdition = 'magento/product-community-edition';
 
 /**
- * Adjust composer.json file configuration for magento
+ * @param {import('../../../typings/context').ListrContext} ctx
+ * @param {import('listr2').ListrTaskWrapper<import('../../../typings/context').ListrContext>} task
  */
-const adjustComposerJson = async ({
-    baseConfig,
+const adjustComposerJson = async (ctx, task, {
     magentoEdition,
     magentoProductSelectedEdition,
-    magentoVersion,
-    magentoPackageVersion,
-    task,
-    verbose
+    magentoPackageVersion
 }) => {
-    const composerData = await getJsonFileData(path.join(baseConfig.magentoDir, 'composer.json'));
+    const composerData = await getJsonFileData(path.join(ctx.config.baseConfig.magentoDir, 'composer.json'));
 
     // fix composer magento repository
     if (composerData && (!composerData.repositories
@@ -37,9 +32,8 @@ const adjustComposerJson = async ({
             && !Object.values(composerData.repositories).some((repo) => repo.type === 'composer' && repo.url.includes('repo.magento.com')))
     )) {
         task.output = 'No Magento repository is set in composer.json! Setting up...';
-        await runComposerCommand('config repo.0 composer https://repo.magento.com', {
-            magentoVersion,
-            callback: !verbose ? undefined : (t) => {
+        await runComposerCommand(ctx, 'config repo.0 composer https://repo.magento.com', {
+            callback: !ctx.verbose ? undefined : (t) => {
                 task.output = t;
             }
         });
@@ -48,10 +42,9 @@ const adjustComposerJson = async ({
     // if composer-root-update-plugin is not installed in composer, install it.
     if (composerData && !composerData.require['magento/composer-root-update-plugin']) {
         task.output = 'Installing magento/composer-root-update-plugin!';
-        await runComposerCommand('require magento/composer-root-update-plugin:^1',
+        await runComposerCommand(ctx, 'require magento/composer-root-update-plugin:^1',
             {
-                magentoVersion,
-                callback: !verbose ? undefined : (t) => {
+                callback: !ctx.verbose ? undefined : (t) => {
                     task.output = t;
                 }
             });
@@ -62,7 +55,8 @@ const adjustComposerJson = async ({
         && composerData.require[magentoProductCommunityEdition]
         && composerData.require[magentoProductEnterpriseEdition]
     ) {
-        throw new KnownError('Somehow, both Magento editions are installed!\nPlease choose only one edition an modify your composer.json manually!');
+        throw new KnownError(`Somehow, both Magento editions are installed!
+Please choose only one edition an modify your composer.json manually!`);
     }
 
     const oppositeEdition = [magentoProductCommunityEdition, magentoProductEnterpriseEdition]
@@ -76,13 +70,11 @@ Change magento edition in config file or manually reinstall correct magento edit
     }
 
     // if magento package is not installed in composer, require it.
-
     if (composerData && !composerData.require[magentoProductSelectedEdition]) {
         task.output = `Installing ${magentoProductSelectedEdition}=${magentoPackageVersion}!`;
-        await runComposerCommand(`require ${magentoProductSelectedEdition}:${magentoPackageVersion}`,
+        await runComposerCommand(ctx, `require ${magentoProductSelectedEdition}:${magentoPackageVersion}`,
             {
-                magentoVersion,
-                callback: !verbose ? undefined : (t) => {
+                callback: !ctx.verbose ? undefined : (t) => {
                     task.output = t;
                 }
             });
@@ -90,16 +82,14 @@ Change magento edition in config file or manually reinstall correct magento edit
 };
 
 /**
- * Create Magento Project
+ * @param {import('../../../typings/context').ListrContext} ctx
+ * @param {import('listr2').ListrTaskWrapper<import('../../../typings/context').ListrContext>} task
  */
-const createMagentoProject = async ({
+const createMagentoProject = async (ctx, task, {
     magentoProject,
-    magentoPackageVersion,
-    magentoVersion,
-    task,
-    verbose
+    magentoPackageVersion
 }) => {
-    const tempDir = path.join(os.tmpdir(), `magento-tmpdir-${Date.now()}`);
+    const tempDir = `/tmp/magento-tmpdir-${Date.now()}`;
     const installCommand = [
         'create-project',
         `--repository=https://repo.magento.com/ ${magentoProject}=${magentoPackageVersion}`,
@@ -107,22 +97,8 @@ const createMagentoProject = async ({
         `"${tempDir}"`
     ];
 
-    await runComposerCommand(
-        installCommand.join(' '),
-        {
-            magentoVersion,
-            callback: !verbose ? undefined : (t) => {
-                task.output = t;
-            }
-        }
-    );
-
-    await moveFile({
-        from: path.join(tempDir, 'composer.json'),
-        to: path.join(process.cwd(), 'composer.json')
-    });
-
-    await rmdirSafe(tempDir);
+    await runPHPContainerCommand(ctx, `composer ${installCommand.join(' ')} \n
+&& mv ${tempDir}/composer.json /var/www/html/composer.json`);
 };
 
 /**
@@ -131,7 +107,7 @@ const createMagentoProject = async ({
 const installMagentoProject = () => ({
     title: 'Installing Magento Project',
     task: async (ctx, task) => {
-        const { magentoVersion, config: { baseConfig, overridenConfiguration }, verbose } = ctx;
+        const { config: { baseConfig, overridenConfiguration } } = ctx;
         const {
             magento: { edition: magentoEdition },
             magentoVersion: magentoPackageVersion
@@ -141,15 +117,10 @@ const installMagentoProject = () => ({
         const magentoProject = `magento/project-${magentoEdition}-edition`;
 
         if (await pathExists(path.join(baseConfig.magentoDir, 'composer.json'))) {
-            await adjustComposerJson({
-                baseConfig,
-                isEnterprise,
+            await adjustComposerJson(ctx, task, {
                 magentoEdition,
                 magentoPackageVersion,
-                magentoProductSelectedEdition,
-                magentoVersion,
-                task,
-                verbose
+                magentoProductSelectedEdition
             });
         }
 
@@ -173,12 +144,9 @@ const installMagentoProject = () => ({
         task.output = 'Creating Magento project';
 
         if (!await pathExists(path.join(process.cwd(), 'composer.json'))) {
-            await createMagentoProject({
+            await createMagentoProject(ctx, task, {
                 magentoProject,
-                magentoPackageVersion,
-                magentoVersion,
-                task,
-                verbose
+                magentoPackageVersion
             });
         }
 
@@ -187,18 +155,18 @@ const installMagentoProject = () => ({
                 recursive: true
             });
         }
+
         try {
-            await runComposerCommand('install',
+            await runComposerCommand(ctx, 'install',
                 {
-                    magentoVersion,
-                    callback: !verbose ? undefined : (t) => {
+                    callback: !ctx.verbose ? undefined : (t) => {
                         task.output = t;
                     }
                 });
         } catch (e) {
             if (e.message.includes('man-in-the-middle attack')) {
                 throw new KnownError(`Probably you haven't setup pubkeys in composer.
-Please run ${logger.style.command('composer diagnose')} in cli to get mode.\n\n${e}`);
+        Please run ${logger.style.command('composer diagnose')} in cli to get mode.\n\n${e}`);
             }
 
             throw new UnknownError(`Unexpected error during composer install.\n\n${e}`);

package/lib/tasks/magento/setup-magento/adjust-full-page-cache.js

@@ -6,15 +6,15 @@ const magentoTask = require('../../../util/magento-task');
  */
 const disableFullPageCache = () => ({
     title: 'Adjusting full_page cache setting',
-    task: async ({ magentoVersion, config }, task) => {
-        const { cache_types } = await envPhpToJson(process.cwd(), { magentoVersion });
+    task: async (ctx, task) => {
+        const { cache_types } = await envPhpToJson(ctx);
         if (cache_types && typeof cache_types.full_page === 'number') {
-            if (cache_types.full_page !== 0 && !config.overridenConfiguration.configuration.varnish.enabled) {
+            if (cache_types.full_page !== 0 && !ctx.config.overridenConfiguration.configuration.varnish.enabled) {
                 task.title = 'Disabling full_page cache in Magento';
                 return task.newListr(magentoTask('cache:disable full_page'));
             }
 
-            if (config.overridenConfiguration.configuration.varnish.enabled && cache_types.full_page !== 1) {
+            if (ctx.config.overridenConfiguration.configuration.varnish.enabled && cache_types.full_page !== 1) {
                 task.title = 'Enabling full_page cache in Magento (Varnish is enabled)';
                 return task.newListr(magentoTask('cache:enable full_page'));
             }

package/lib/tasks/magento/setup-magento/configure-elasticsearch.js

@@ -6,10 +6,14 @@ const { updateTableValues, isTableExists } = require('../../../util/database');
 module.exports = () => ({
     title: 'Configuring Elasticsearch',
     skip: async (ctx) => !(await isTableExists('magento', 'core_config_data', ctx)),
-    task: async ({ ports, mysqlConnection }, task) => {
+    task: async (ctx, task) => {
+        const { ports, mysqlConnection } = ctx;
+        const isLinux = ctx.platform === 'linux';
+        const isNativeLinux = isLinux && !ctx.isWsl;
+        const hostMachine = isNativeLinux ? '127.0.0.1' : 'host.docker.internal';
         await updateTableValues('core_config_data', [
             { path: 'catalog/search/engine', value: 'elasticsearch7' },
-            { path: 'catalog/search/elasticsearch7_server_hostname', value: '127.0.0.1' },
+            { path: 'catalog/search/elasticsearch7_server_hostname', value: hostMachine },
             { path: 'catalog/search/elasticsearch7_server_port', value: `${ports.elasticsearch}` }
         ], { mysqlConnection, task });
     }

package/lib/tasks/magento/setup-magento/create-admin.js

@@ -5,8 +5,9 @@ const runMagentoCommand = require('../../../util/run-magento');
  */
 module.exports = () => ({
     title: 'Creating admin user',
-    task: async ({ magentoVersion, mysqlConnection, config: { magentoConfiguration } }, task) => {
-        const [[{ userCount }]] = await mysqlConnection.query(`
+    task: async (ctx, task) => {
+        const { config: { magentoConfiguration } } = ctx;
+        const [[{ userCount }]] = await ctx.mysqlConnection.query(`
             SELECT count(*) AS userCount
             FROM admin_user
             WHERE username = ?;
@@ -17,13 +18,11 @@ module.exports = () => ({
             return;
         }
 
-        await runMagentoCommand(`admin:user:create \
+        await runMagentoCommand(ctx, `admin:user:create \
         --admin-firstname='${ magentoConfiguration.first_name }' \
         --admin-lastname='${ magentoConfiguration.last_name }' \
         --admin-email='${ magentoConfiguration.email }' \
         --admin-user='${ magentoConfiguration.user }' \
-        --admin-password='${ magentoConfiguration.password }'`, {
-            magentoVersion
-        });
+        --admin-password='${ magentoConfiguration.password }'`);
     }
 });

package/lib/tasks/magento/setup-magento/disable-2fa.js

@@ -6,13 +6,11 @@ const runMagentoCommand = require('../../../util/run-magento');
  */
 module.exports = () => ({
     title: 'Disabling 2fa for admin',
-    task: async ({ magentoVersion }, task) => {
-        const { modules } = await configPhpToJson(process.cwd(), { magentoVersion });
+    task: async (ctx, task) => {
+        const { modules } = await configPhpToJson(ctx);
 
         if (modules.Magento_TwoFactorAuth !== undefined && modules.Magento_TwoFactorAuth !== 0) {
-            await runMagentoCommand('module:disable Magento_TwoFactorAuth', {
-                magentoVersion
-            });
+            await runMagentoCommand(ctx, 'module:disable Magento_TwoFactorAuth');
 
             return;
         }

package/lib/tasks/magento/setup-magento/disable-maintenance-mode.js

@@ -5,9 +5,8 @@ const runMagentoCommand = require('../../../util/run-magento');
  */
 const disableMaintenanceMode = () => ({
     title: 'Disabling maintenance mode',
-    task: async ({ magentoVersion }, task) => {
-        const { result } = await runMagentoCommand('maintenance:status', {
-            magentoVersion,
+    task: async (ctx, task) => {
+        const { result } = await runMagentoCommand(ctx, 'maintenance:status', {
             throwNonZeroCode: false
         });
 
@@ -16,7 +15,7 @@ const disableMaintenanceMode = () => ({
             return;
         }
 
-        await runMagentoCommand('maintenance:disable', { magentoVersion });
+        await runMagentoCommand(ctx, 'maintenance:disable');
     }
 });
 

package/lib/tasks/magento/setup-magento/install-magento.js

@@ -27,6 +27,10 @@ const installMagento = ({ isDbEmpty = false } = {}) => ({
             mysqlConnection
         } = ctx;
 
+        const isLinux = ctx.platform === 'linux';
+        const isNativeLinux = isLinux && !ctx.isWsl;
+        const hostMachine = isNativeLinux ? '127.0.0.1' : 'host.docker.internal';
+
         const [tableResponse] = await mysqlConnection.query(
             'SELECT * FROM information_schema.tables WHERE table_schema = \'magento\' AND table_name = \'admin_user\' LIMIT 1;'
         );
@@ -71,9 +75,7 @@ const installMagento = ({ isDbEmpty = false } = {}) => ({
         }
 
         const { mysql: { env } } = docker.getContainers(ports);
-        const envPhpData = await envPhpToJson(process.cwd(), {
-            magentoVersion: ctx.magentoVersion
-        });
+        const envPhpData = await envPhpToJson(ctx);
 
         const envPhpHaveEncryptionKey = envPhpData && envPhpData.crypt && envPhpData.crypt.key && envPhpData.crypt.key;
 
@@ -95,7 +97,7 @@ const installMagento = ({ isDbEmpty = false } = {}) => ({
 
         const elasticsearchConfiguration = ` \
 --search-engine='elasticsearch7' \
---elasticsearch-host='127.0.0.1' \
+--elasticsearch-host='${ hostMachine }' \
 --elasticsearch-port='${ ports.elasticsearch }'`;
 
         /**
@@ -114,25 +116,24 @@ const installMagento = ({ isDbEmpty = false } = {}) => ({
                 ${ !isMagento23 ? elasticsearchConfiguration : '' } \
                 ${encryptionKeyOption || ''} \
                 --session-save=redis \
-                --session-save-redis-host='127.0.0.1' \
+                --session-save-redis-host='${ hostMachine }' \
                 --session-save-redis-port='${ ports.redis }' \
                 --session-save-redis-log-level='3' \
                 --session-save-redis-max-concurrency='30' \
                 --session-save-redis-db='1' \
                 --session-save-redis-disable-locking='1' \
                 --cache-backend='redis' \
-                --cache-backend-redis-server='127.0.0.1' \
+                --cache-backend-redis-server='${ hostMachine }' \
                 --cache-backend-redis-port='${ ports.redis }' \
                 --cache-backend-redis-db='0't \
-                --db-host='127.0.0.1:${ ports.mysql }' \
+                --db-host='${ hostMachine }:${ ports.mysql }' \
                 --db-name='${ env.MYSQL_DATABASE }' \
                 --db-user='${ env.MYSQL_USER }' \
                 --db-password='${ env.MYSQL_PASSWORD }' \
                 --backend-frontname='${ magentoConfiguration.adminuri }' \
                 --no-interaction`;
 
-                await runMagentoCommand(command, {
-                    magentoVersion,
+                await runMagentoCommand(ctx, command, {
                     throwNonZeroCode: true,
                     callback: !ctx.verbose ? undefined : (t) => {
                         task.output = t;

package/lib/tasks/magento/setup-magento/migrate-database.js

@@ -17,10 +17,7 @@ const updateEnvPHP = require('../../php/update-env-php');
 const migrateDatabase = (options = {}) => ({
     title: 'Migrating database',
     task: async (ctx, task) => {
-        const {
-            magentoVersion,
-            mysqlConnection
-        } = ctx;
+        const { mysqlConnection } = ctx;
 
         const [[{ tableCount }]] = await mysqlConnection.query(`
             SELECT count(*) AS tableCount
@@ -35,12 +32,14 @@ const migrateDatabase = (options = {}) => ({
         ) {
             if (options.onlyInstallMagento) {
                 ctx.isSetupUpgradeNeeded = false;
-                return task.newListr(
+                return task.newListr([
+                    updateEnvPHP(),
                     installMagento({ isDbEmpty: true })
-                );
+                ]);
             }
 
             return task.newListr([
+                updateEnvPHP(),
                 installMagento({ isDbEmpty: true }),
                 updateEnvPHP(),
                 varnishConfigSetup(),
@@ -57,8 +56,7 @@ const migrateDatabase = (options = {}) => ({
             });
         }
 
-        const { code } = await runMagentoCommand('setup:db:status', {
-            magentoVersion,
+        const { code } = await runMagentoCommand(ctx, 'setup:db:status', {
             throwNonZeroCode: false
         });
 
@@ -90,6 +88,7 @@ const migrateDatabase = (options = {}) => ({
 
             return task.newListr([
                 installMagentoProject(),
+                updateEnvPHP(),
                 installMagento(),
                 updateEnvPHP(),
                 varnishConfigSetup(),

package/lib/tasks/magento/setup-magento/set-deployment-mode.js

@@ -6,10 +6,10 @@ const runMagentoCommand = require('../../../util/run-magento');
  */
 module.exports = () => ({
     title: 'Switching Magento mode',
-    task: async ({ magentoVersion, config: { magentoConfiguration: { mode } } }, task) => {
-        const { result } = await runMagentoCommand('deploy:mode:show', {
-            throwNonZeroCode: false,
-            magentoVersion
+    task: async (ctx, task) => {
+        const { config: { magentoConfiguration: { mode } } } = ctx;
+        const { result } = await runMagentoCommand(ctx, 'deploy:mode:show', {
+            throwNonZeroCode: false
         });
 
         if (result.includes(mode)) {

package/lib/tasks/magento/setup-magento/varnish-config.js

@@ -19,17 +19,19 @@ const varnishConfigSetup = () => ({
                 }
             },
             mysqlConnection,
-            ports
+            ports,
+            debug
         } = ctx;
 
         const isLinux = os.platform() === 'linux';
         const isWsl = await getIsWsl();
+        const isNativeLinux = isLinux && !isWsl;
 
-        if (varnishEnabled) {
+        if (!debug && varnishEnabled) {
             await updateTableValues('core_config_data', [
                 {
                     path: 'system/full_page_cache/varnish/backend_host',
-                    value: 'localhost'
+                    value: !isNativeLinux ? 'host.docker.internal' : 'localhost'
                 },
                 {
                     path: 'system/full_page_cache/varnish/backend_port',
@@ -37,7 +39,7 @@ const varnishConfigSetup = () => ({
                 },
                 {
                     path: 'system/full_page_cache/varnish/access_list',
-                    value: (!isLinux || isWsl) ? 'host.docker.internal,localhost' : 'localhost'
+                    value: !isNativeLinux ? 'host.docker.internal,localhost' : 'localhost'
                 },
                 {
                     path: 'system/full_page_cache/caching_application',

package/lib/tasks/magento/setup-magento/waiting-for-varnish.js

@@ -1,14 +1,48 @@
+const logger = require('@scandipwa/scandipwa-dev-utils/logger');
+const semver = require('semver');
+const fs = require('fs');
+const path = require('path');
 const { request } = require('smol-request');
 const KnownError = require('../../../errors/known-error');
+const { execAsyncSpawn } = require('../../../util/exec-async-command');
+const { NginxParser } = require('../../../util/nginx-logs-parser');
 const sleep = require('../../../util/sleep');
 
+const pathToWorkingHealthCheckPhp = path.join(__dirname, '..', '..', 'php', 'working_health_check.php');
+const pathToProjectsHealthCheckPhp = path.join(process.cwd(), 'pub', 'health_check.php');
+const pathToHealthCheckBackupPhp = path.join(process.cwd(), 'pub', 'health_check-super-backup-file.php');
+
+/**
+ * @param {import('../../../../typings/context').ListrContext} ctx
+ */
+const getIsHealthCheckRequestBroken = async (ctx) => {
+    const { nginx } = ctx.config.docker.getContainers(ctx.ports);
+
+    const nginxLogs = await execAsyncSpawn(`docker logs ${nginx.name}`);
+
+    const healthCheckRequests = nginxLogs
+        .split('\n')
+        .filter((line) => line.includes('"GET /health_check.php HTTP/1.1"'));
+
+    // eslint-disable-next-line max-len
+    const parser = new NginxParser('$remote_addr - $remote_user [$time_local] "$request" $status $body_bytes_sent "$http_referer" "$http_user_agent"');
+
+    const parsedRequests = healthCheckRequests.map((line) => parser.parseLine(line));
+
+    return parsedRequests.every((parsedRequest) => parsedRequest.status !== '200');
+};
+
 /**
  * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const waitingForVarnish = () => ({
     title: 'Waiting for Varnish to return code 200',
-    skip: (ctx) => !ctx.config.overridenConfiguration.configuration.varnish.enabled,
-    task: async (ctx) => {
+    skip: (ctx) => ctx.debug || !ctx.config.overridenConfiguration.configuration.varnish.enabled,
+    task: async (ctx, task) => {
+        const pureMagentoVersion = ctx.magentoVersion.match(/^([0-9]+\.[0-9]+\.[0-9]+)/)[1];
+
+        const isMagento23 = semver.satisfies(pureMagentoVersion, '<2.4');
+
         let tries = 0;
         while (tries < 10) {
             try {
@@ -28,6 +62,94 @@ const waitingForVarnish = () => ({
             }
         }
 
+        if (tries === 10 && isMagento23) {
+            const isHealthCheckRequestBroken = await getIsHealthCheckRequestBroken(ctx);
+            if (isHealthCheckRequestBroken) {
+                const confirm = await task.prompt({
+                    type: 'Select',
+                    message: `We detected that your Magento instance is experiencing problems with Varnish server.
+Health Check request is returning status 500.
+
+Do you want to try resolving this issue by replacing ${logger.style.file('./pub/health_check.php')} file content with content from newer Magento version (2.4.4)?`,
+                    choices: [
+                        {
+                            name: 'yes',
+                            message: 'Okay, let\'s try that'
+                        },
+                        {
+                            name: 'no',
+                            message: 'I will try to fix this myself, thanks for the info!'
+                        }
+                    ]
+                });
+
+                if (confirm === 'yes') {
+                    await fs.promises.writeFile(
+                        pathToHealthCheckBackupPhp,
+                        await fs.promises.readFile(pathToProjectsHealthCheckPhp, 'utf-8'),
+                        'utf-8'
+                    );
+
+                    task.output = `Backup made! Available at ${logger.style.file(pathToHealthCheckBackupPhp)}`;
+
+                    await fs.promises.writeFile(
+                        pathToProjectsHealthCheckPhp,
+                        await fs.promises.readFile(pathToWorkingHealthCheckPhp, 'utf-8'),
+                        'utf-8'
+                    );
+
+                    task.output = `${logger.style.file('./pub/health_check.php')} content is replaced, waiting for nginx logs...`;
+
+                    let connectionFixed = false;
+
+                    for (let i = 0; i < 10; i++) {
+                        try {
+                            const response = await request(`http://localhost:${ctx.ports.sslTerminator}/`, {
+                                responseType: 'headers'
+                            });
+
+                            if (response.status !== 200) {
+                                await sleep(2000);
+                            } else {
+                                connectionFixed = true;
+                                break;
+                            }
+                        } catch (e) {
+                            await sleep(200);
+                        }
+                    }
+
+                    if (connectionFixed) {
+                        task.output = 'Connection looks good!';
+                        const secondConfirm = await task.prompt({
+                            type: 'Select',
+                            message: `Okay, looks like it helped!
+Do you want to keep backed up ${logger.style.file('health_check.php')} file?`,
+                            choices: [
+                                {
+                                    name: 'no',
+                                    message: 'I don\'t think I will need it anymore, thanks'
+                                },
+                                {
+                                    name: 'yes',
+                                    message: 'I will keep it, maybe it will be useful (X to doubt)'
+                                }
+                            ]
+                        });
+
+                        if (secondConfirm === 'no') {
+                            await fs.promises.rm(pathToHealthCheckBackupPhp);
+                        }
+                    }
+
+                    return;
+                }
+
+                task.skip('User choose to fix issue himself');
+                return;
+            }
+        }
+
         if (tries === 10) {
             throw new KnownError(`After 20 seconds website is still responding with non-200 code, which might indicate issue with setup.
 Or Varnish is still loading...
@@ -35,7 +157,10 @@ Or Varnish is still loading...
 Please check the logs!`);
         }
     },
-    exitOnError: false
+    exitOnError: false,
+    options: {
+        bottomBar: 10
+    }
 });
 
 module.exports = waitingForVarnish;