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

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/mess-detector-project-configuration-config.js

@@ -0,0 +1,50 @@
+const { nameKey, valueKey } = require('../keys');
+
+const MESS_DETECTOR_PROJECT_CONFIGURATION_COMPONENT_NAME = 'MessDetectorProjectConfiguration';
+
+const selectedConfigurationIdName = 'selectedConfigurationId';
+const value = 'DEFAULT_INTERPRETER';
+
+const defaultOption = {
+    [nameKey]: selectedConfigurationIdName,
+    [valueKey]: value
+};
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupMessDetectorProjectConfiguration = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const messDetectorProjectConfigurationComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === MESS_DETECTOR_PROJECT_CONFIGURATION_COMPONENT_NAME
+    );
+
+    if (messDetectorProjectConfigurationComponent) {
+        if (messDetectorProjectConfigurationComponent.option && !Array.isArray(messDetectorProjectConfigurationComponent.option)) {
+            hasChanges = true;
+            messDetectorProjectConfigurationComponent.option = [messDetectorProjectConfigurationComponent.option];
+        } else if (!messDetectorProjectConfigurationComponent.option) {
+            hasChanges = true;
+            messDetectorProjectConfigurationComponent.option = [];
+        }
+
+        if (
+            messDetectorProjectConfigurationComponent.option.length > 0
+            && !messDetectorProjectConfigurationComponent.option.some((option) => option[nameKey] === selectedConfigurationIdName)
+        ) {
+            messDetectorProjectConfigurationComponent.option = [defaultOption];
+            hasChanges = true;
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: MESS_DETECTOR_PROJECT_CONFIGURATION_COMPONENT_NAME,
+            option: [defaultOption]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupMessDetectorProjectConfiguration;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/php-code-sniffer-project-configuration-config.js

@@ -0,0 +1,50 @@
+const { nameKey, valueKey } = require('../keys');
+
+const PHP_CODE_SNIFFER_PROJECT_CONFIGURATION_COMPONENT_NAME = 'PHPCodeSnifferProjectConfiguration';
+
+const selectedConfigurationIdName = 'selectedConfigurationId';
+const value = 'DEFAULT_INTERPRETER';
+
+const defaultOption = {
+    [nameKey]: selectedConfigurationIdName,
+    [valueKey]: value
+};
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPCodeSnifferProjectConfiguration = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const phpCodeSnifferProjectConfigurationComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PHP_CODE_SNIFFER_PROJECT_CONFIGURATION_COMPONENT_NAME
+    );
+
+    if (phpCodeSnifferProjectConfigurationComponent) {
+        if (phpCodeSnifferProjectConfigurationComponent.option && !Array.isArray(phpCodeSnifferProjectConfigurationComponent.option)) {
+            hasChanges = true;
+            phpCodeSnifferProjectConfigurationComponent.option = [phpCodeSnifferProjectConfigurationComponent.option];
+        } else if (!phpCodeSnifferProjectConfigurationComponent.option) {
+            hasChanges = true;
+            phpCodeSnifferProjectConfigurationComponent.option = [];
+        }
+
+        if (
+            phpCodeSnifferProjectConfigurationComponent.option.length > 0
+            && !phpCodeSnifferProjectConfigurationComponent.option.some((option) => option[nameKey] === selectedConfigurationIdName)
+        ) {
+            phpCodeSnifferProjectConfigurationComponent.option = [defaultOption];
+            hasChanges = true;
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: PHP_CODE_SNIFFER_PROJECT_CONFIGURATION_COMPONENT_NAME,
+            option: [defaultOption]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPCodeSnifferProjectConfiguration;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/php-cs-fixer-project-configuration-config.js

@@ -0,0 +1,50 @@
+const { nameKey, valueKey } = require('../keys');
+
+const PHP_CS_FIXER_PROJECT_CONFIGURATION_COMPONENT_NAME = 'PHPCSFixerProjectConfiguration';
+
+const selectedConfigurationIdName = 'selectedConfigurationId';
+const value = 'DEFAULT_INTERPRETER';
+
+const defaultOption = {
+    [nameKey]: selectedConfigurationIdName,
+    [valueKey]: value
+};
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPCSFixerProjectConfiguration = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const phpCSFixeProjectConfigurationComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PHP_CS_FIXER_PROJECT_CONFIGURATION_COMPONENT_NAME
+    );
+
+    if (phpCSFixeProjectConfigurationComponent) {
+        if (phpCSFixeProjectConfigurationComponent.option && !Array.isArray(phpCSFixeProjectConfigurationComponent.option)) {
+            hasChanges = true;
+            phpCSFixeProjectConfigurationComponent.option = [phpCSFixeProjectConfigurationComponent.option];
+        } else if (!phpCSFixeProjectConfigurationComponent.option) {
+            hasChanges = true;
+            phpCSFixeProjectConfigurationComponent.option = [];
+        }
+
+        if (
+            phpCSFixeProjectConfigurationComponent.option.length > 0
+            && !phpCSFixeProjectConfigurationComponent.option.some((option) => option[nameKey] === selectedConfigurationIdName)
+        ) {
+            phpCSFixeProjectConfigurationComponent.option = [defaultOption];
+            hasChanges = true;
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: PHP_CS_FIXER_PROJECT_CONFIGURATION_COMPONENT_NAME,
+            option: [defaultOption]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPCSFixerProjectConfiguration;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/php-debug-general-config.js

@@ -8,12 +8,13 @@ const portKey = '@_port';
 const xdebugDebugPortKey = '@_xdebug_debug_port';
 const ignoreConnectionsThroughUnregisteredServersKey = '@_ignore_connections_through_unregistered_servers';
 
+const xdebugPort = '9003';
+
 /**
  * @param {Array} workspaceConfigs
- * @param {ReturnType<typeof import('./workspace-config').getWorkspaceConfig>} workspaceConfig
  * @returns {Promise<Boolean>}
  */
-const setupPHPDebugGeneral = async (workspaceConfigs, workspaceConfig) => {
+const setupPHPDebugGeneral = async (workspaceConfigs) => {
     let hasChanges = false;
     const phpDebugGeneralComponent = workspaceConfigs.find(
         (workspaceConfig) => workspaceConfig[nameKey] === PHP_DEBUG_GENERAL_COMPONENT_NAME
@@ -30,30 +31,29 @@ const setupPHPDebugGeneral = async (workspaceConfigs, workspaceConfig) => {
 
         if (!(xdebugDebugPortKey in phpDebugGeneralComponent)) {
             hasChanges = true;
-            phpDebugGeneralComponent[xdebugDebugPortKey] = workspaceConfig.v3Port;
+            phpDebugGeneralComponent[xdebugDebugPortKey] = xdebugPort;
         }
 
-        const missingXDebugPorts = [workspaceConfig.v3Port, workspaceConfig.v2Port].filter(
-            (port) => !phpDebugGeneralComponent.xdebug_debug_ports.some((xPort) => xPort[portKey] === port)
-        );
+        if (phpDebugGeneralComponent[xdebugDebugPortKey] !== xdebugPort) {
+            hasChanges = true;
+            phpDebugGeneralComponent[xdebugDebugPortKey] = xdebugPort;
+        }
 
-        if (missingXDebugPorts.length > 0) {
+        if (!phpDebugGeneralComponent.xdebug_debug_ports.some((xPort) => xPort[portKey] === xdebugPort)) {
             hasChanges = true;
-            missingXDebugPorts.forEach((port) => {
-                phpDebugGeneralComponent.xdebug_debug_ports.push({
-                    [portKey]: port
-                });
+            phpDebugGeneralComponent.xdebug_debug_ports.push({
+                [portKey]: xdebugPort
             });
         }
     } else {
         hasChanges = true;
         workspaceConfigs.push({
             [nameKey]: PHP_DEBUG_GENERAL_COMPONENT_NAME,
-            [xdebugDebugPortKey]: workspaceConfig.v3Port,
+            [xdebugDebugPortKey]: xdebugPort,
             [ignoreConnectionsThroughUnregisteredServersKey]: 'true',
-            xdebug_debug_ports: [workspaceConfig.v3Port, workspaceConfig.v2Port].map((port) => ({
-                [portKey]: port
-            }))
+            xdebug_debug_ports: [{
+                [portKey]: xdebugPort
+            }]
         });
     }
 

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/php-server-config.js

@@ -3,13 +3,17 @@ const { nameKey } = require('../keys');
 const PHP_SERVERS_COMPONENT_NAME = 'PhpServers';
 
 const hostKey = '@_host';
+const usePathMappingsKey = '@_use_path_mappings';
+const localRootKey = '@_local-root';
+const remoteRootKey = '@_remote-root';
 
 /**
  * @param {Array} workspaceConfigs
  * @param {ReturnType<typeof import('./workspace-config').getWorkspaceConfig>} workspaceConfig
+ * @param {import('../../../../../typings/context').ListrContext} ctx
  * @returns {Promise<Boolean>}
  */
-const setupPHPServers = async (workspaceConfigs, workspaceConfig) => {
+const setupPHPServers = async (workspaceConfigs, workspaceConfig, ctx) => {
     let hasChanges = false;
     const phpServersComponent = workspaceConfigs.find(
         (workspaceConfig) => workspaceConfig[nameKey] === PHP_SERVERS_COMPONENT_NAME
@@ -18,7 +22,14 @@ const setupPHPServers = async (workspaceConfigs, workspaceConfig) => {
     const defaultServerConfig = {
         [hostKey]: workspaceConfig.debugServerAddress,
         id: '7e16e907-9ce3-4559-9d26-a30a5650d11f',
-        [nameKey]: workspaceConfig.serverName
+        [nameKey]: workspaceConfig.serverName,
+        [usePathMappingsKey]: true,
+        path_mappings: {
+            mapping: {
+                [localRootKey]: '$PROJECT_DIR$',
+                [remoteRootKey]: ctx.config.baseConfig.containerMagentoDir
+            }
+        }
     };
 
     if (phpServersComponent) {
@@ -32,11 +43,26 @@ const setupPHPServers = async (workspaceConfigs, workspaceConfig) => {
 
         const serverConfiguration = phpServersComponent.servers.find((server) => server.server[nameKey] === workspaceConfig.serverName);
 
-        if (!serverConfiguration) {
+        if (!serverConfiguration || !serverConfiguration.server) {
             hasChanges = true;
             phpServersComponent.servers.push({
                 server: defaultServerConfig
             });
+        } else if (serverConfiguration.server) {
+            if (!serverConfiguration.server[usePathMappingsKey]) {
+                hasChanges = true;
+                serverConfiguration.server[usePathMappingsKey] = true;
+            }
+            if (!serverConfiguration.server.path_mappings
+                || (
+                    serverConfiguration.server.path_mappings.mapping
+                    && serverConfiguration.server.path_mappings.mapping[remoteRootKey] !== defaultServerConfig.path_mappings.mapping[remoteRootKey]
+                )
+            ) {
+                hasChanges = true;
+                serverConfiguration.server.path_mappings = serverConfiguration.server.path_mappings || {};
+                serverConfiguration.server.path_mappings.mapping = defaultServerConfig.path_mappings.mapping;
+            }
         }
     } else {
         hasChanges = true;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/php-stan-project-configuration-config.js.js

@@ -0,0 +1,50 @@
+const { nameKey, valueKey } = require('../keys');
+
+const PHP_STAN_PROJECT_CONFIGURATION_COMPONENT_NAME = 'PhpStanProjectConfiguration';
+
+const selectedConfigurationIdName = 'selectedConfigurationId';
+const value = 'DEFAULT_INTERPRETER';
+
+const defaultOption = {
+    [nameKey]: selectedConfigurationIdName,
+    [valueKey]: value
+};
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPStanProjectConfiguration = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const phpStanProjectConfigurationComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PHP_STAN_PROJECT_CONFIGURATION_COMPONENT_NAME
+    );
+
+    if (phpStanProjectConfigurationComponent) {
+        if (phpStanProjectConfigurationComponent.option && !Array.isArray(phpStanProjectConfigurationComponent.option)) {
+            hasChanges = true;
+            phpStanProjectConfigurationComponent.option = [phpStanProjectConfigurationComponent.option];
+        } else if (!phpStanProjectConfigurationComponent.option) {
+            hasChanges = true;
+            phpStanProjectConfigurationComponent.option = [];
+        }
+
+        if (
+            phpStanProjectConfigurationComponent.option.length > 0
+            && !phpStanProjectConfigurationComponent.option.some((option) => option[nameKey] === selectedConfigurationIdName)
+        ) {
+            phpStanProjectConfigurationComponent.option = [defaultOption];
+            hasChanges = true;
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: PHP_STAN_PROJECT_CONFIGURATION_COMPONENT_NAME,
+            option: [defaultOption]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPStanProjectConfiguration;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/php-workspace-project-configuration-config.js

@@ -0,0 +1,42 @@
+const { nameKey } = require('../keys');
+
+const PHP_WORKSPACE_PROJECT_CONFIGURATION_COMPONENT_NAME = 'PhpWorkspaceProjectConfiguration';
+
+const interpreterNameKey = '@_interpreter_name';
+
+/**
+ * @param {Array} workspaceConfigs
+ * @param {import('../../../../../typings/context').ListrContext} ctx
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPWorkspaceProjectConfiguration = async (workspaceConfigs, ctx) => {
+    let hasChanges = false;
+    const phpWorkspaceProjectConfigurationComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PHP_WORKSPACE_PROJECT_CONFIGURATION_COMPONENT_NAME
+    );
+    const { php } = ctx.config.docker.getContainers(ctx.ports);
+    const currentInterpreterImage = ctx.debug ? php.debugImage : php.image;
+
+    if (phpWorkspaceProjectConfigurationComponent) {
+        if (
+            !phpWorkspaceProjectConfigurationComponent[interpreterNameKey]
+            || (
+                phpWorkspaceProjectConfigurationComponent[interpreterNameKey] !== currentInterpreterImage
+            )
+        ) {
+            hasChanges = true;
+            phpWorkspaceProjectConfigurationComponent[interpreterNameKey] = currentInterpreterImage;
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: PHP_WORKSPACE_PROJECT_CONFIGURATION_COMPONENT_NAME,
+            [currentInterpreterImage]: currentInterpreterImage,
+            include_path: []
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPWorkspaceProjectConfiguration;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/psalm-project-configuration-config.js.js

@@ -0,0 +1,50 @@
+const { nameKey, valueKey } = require('../keys');
+
+const PSALM_PROJECT_CONFIGURATION_COMPONENT_NAME = 'PsalmProjectConfiguration';
+
+const selectedConfigurationIdName = 'selectedConfigurationId';
+const value = 'DEFAULT_INTERPRETER';
+
+const defaultOption = {
+    [nameKey]: selectedConfigurationIdName,
+    [valueKey]: value
+};
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupPSalmProjectConfiguration = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const psalmProjectConfigurationComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PSALM_PROJECT_CONFIGURATION_COMPONENT_NAME
+    );
+
+    if (psalmProjectConfigurationComponent) {
+        if (psalmProjectConfigurationComponent.option && !Array.isArray(psalmProjectConfigurationComponent.option)) {
+            hasChanges = true;
+            psalmProjectConfigurationComponent.option = [psalmProjectConfigurationComponent.option];
+        } else if (!psalmProjectConfigurationComponent.option) {
+            hasChanges = true;
+            psalmProjectConfigurationComponent.option = [];
+        }
+
+        if (
+            psalmProjectConfigurationComponent.option.length > 0
+            && !psalmProjectConfigurationComponent.option.some((option) => option[nameKey] === selectedConfigurationIdName)
+        ) {
+            psalmProjectConfigurationComponent.option = [defaultOption];
+            hasChanges = true;
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: PSALM_PROJECT_CONFIGURATION_COMPONENT_NAME,
+            option: [defaultOption]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPSalmProjectConfiguration;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/workspace-config.js

@@ -5,8 +5,6 @@ const { baseConfig } = require('../../../../config');
  * @param {import('../../../../../typings/index').CMAConfiguration} app
  */
 const getWorkspaceConfig = (app) => ({
-    v2Port: '9111',
-    v3Port: '9003',
     debugServerAddress: `http://${ app.host }`,
     serverName: 'create-magento-app',
     runManagerName: 'create-magento-app',

package/lib/tasks/file-system/create-ssl-terminator-config.js

@@ -19,7 +19,8 @@ const createSSLTerminatorConfig = () => ({
                 overridenConfiguration,
                 baseConfig
             },
-            isWsl
+            isWsl,
+            debug
         } = ctx;
 
         const {
@@ -84,7 +85,8 @@ const createSSLTerminatorConfig = () => ({
                     hostMachine,
                     hostPort,
                     config: overridenConfiguration,
-                    networkToBindTo
+                    networkToBindTo,
+                    debug
                 }
             });
         } catch (e) {

package/lib/tasks/file-system/create-vscode-config.js

@@ -1,77 +1,85 @@
 const path = require('path');
-const semver = require('semver');
 const fs = require('fs');
-const os = require('os');
 const hjson = require('hjson');
 const pathExists = require('../../util/path-exists');
 const setConfigFile = require('../../util/set-config');
 const UnknownError = require('../../errors/unknown-error');
 
-const phpXDebug2port = 9111;
-const phpXDebug3port = 9003;
 const listenForXDebugConfigName = 'Listen for XDebug';
 
-const vscodeLaunchConfigPath = path.join(process.cwd(), '.vscode', 'launch.json');
+const xdebugPort = 9003;
 
-/**
- * @param {import('../../../typings/context').ListrContext['config']['php']} php
- */
-const getCurrentXDebugPort = (php) => (semver.satisfies(php.extensions.xdebug.version, '>=3')
-    ? phpXDebug3port
-    : phpXDebug2port);
+const vscodeLaunchConfigPath = path.join(process.cwd(), '.vscode', 'launch.json');
 
 /**
- * @param {import('../../../typings/context').ListrContext['config']['php']} php
- */
-const getPHPBinPathWithHomeVariable = (php) => php.binPath.replace(os.homedir(), '$HOME');
-/**
- * @param {import('../../../typings/context').ListrContext['config']['php']} php
+ * @param {import('../../../typings/context').ListrContext} ctx
  */
-const addPHPDebugConfig = (vscodeLaunchConfig, php) => {
+const addPHPDebugConfig = (vscodeLaunchConfig, ctx) => {
     const phpXDebugConfig = vscodeLaunchConfig.configurations.find(
         ({ name }) => name === listenForXDebugConfigName
     );
 
-    const phpXDebugPort = getCurrentXDebugPort(php);
-    const phpBingPath = getPHPBinPathWithHomeVariable(php);
+    let hasChanges = false;
+
+    const newConfiguration = {
+        name: listenForXDebugConfigName,
+        type: 'php',
+        request: 'launch',
+        port: xdebugPort,
+        pathMappings: {
+            // eslint-disable-next-line no-template-curly-in-string
+            [ctx.config.baseConfig.containerMagentoDir]: '${workspaceFolder}'
+        }
+
+    };
+
+    if (phpXDebugConfig && phpXDebugConfig.runtimeExecutable) {
+        vscodeLaunchConfig.configurations = vscodeLaunchConfig.configurations.filter(
+            ({ name }) => name !== listenForXDebugConfigName
+        );
 
+        vscodeLaunchConfig.configurations.push(newConfiguration);
+
+        return true;
+    }
     if (!phpXDebugConfig) {
-        vscodeLaunchConfig.configurations.push({
-            name: listenForXDebugConfigName,
-            type: 'php',
-            request: 'launch',
-            port: phpXDebugPort,
-            runtimeExecutable: phpBingPath
-        });
+        vscodeLaunchConfig.configurations.push(newConfiguration);
 
         return true;
     }
 
     if (
-        phpXDebugConfig.port !== phpXDebugPort
-        && phpXDebugConfig.runtimeExecutable !== phpBingPath
-    ) {
-        phpXDebugConfig.port = phpXDebugPort;
-        phpXDebugConfig.runtimeExecutable = phpBingPath;
+        !phpXDebugConfig.port
+        || phpXDebugConfig.port !== xdebugPort) {
+        phpXDebugConfig.port = xdebugPort;
 
-        return true;
+        hasChanges = true;
+    }
+
+    if (!phpXDebugConfig.pathMappings || !phpXDebugConfig.pathMappings[ctx.config.baseConfig.containerMagentoDir]) {
+        phpXDebugConfig.pathMappings = {
+            // eslint-disable-next-line no-template-curly-in-string
+            [ctx.config.baseConfig.containerMagentoDir]: '${workspaceFolder}'
+        };
+
+        hasChanges = true;
     }
 
-    return false;
+    return hasChanges;
 };
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
-const createPhpFpmConfig = () => ({
+const createVSCodeConfig = () => ({
     title: 'Setting VSCode config',
-    task: async ({ config: { php, baseConfig } }, task) => {
+    task: async (ctx, task) => {
         if (await pathExists(vscodeLaunchConfigPath)) {
             const vscodeLaunchConfig = hjson.parse(await fs.promises.readFile(vscodeLaunchConfigPath, 'utf-8'), {
                 keepWsc: true
             });
 
-            const vscodeConfigEdited = addPHPDebugConfig(vscodeLaunchConfig, php);
+            const vscodeConfigEdited = addPHPDebugConfig(vscodeLaunchConfig, ctx);
 
             // if vscode config is up-to-date, skip task
             if (!vscodeConfigEdited) {
@@ -79,7 +87,15 @@ const createPhpFpmConfig = () => ({
                 return;
             }
 
-            await fs.promises.writeFile(vscodeLaunchConfigPath, hjson.stringify(vscodeLaunchConfig));
+            const result = hjson.stringify(vscodeLaunchConfig, {
+                keepWsc: true,
+                bracesSameLine: true,
+                separator: true,
+                quotes: 'all'
+
+            });
+
+            await fs.promises.writeFile(vscodeLaunchConfigPath, result);
 
             return;
         }
@@ -93,14 +109,13 @@ const createPhpFpmConfig = () => ({
         }
 
         try {
-            const phpXDebugPort = getCurrentXDebugPort(php);
-            const vscodeLaunchConfigTemplatePath = path.join(baseConfig.templateDir, 'vscode-launch.template.json');
+            const vscodeLaunchConfigTemplatePath = path.join(ctx.config.baseConfig.templateDir, 'vscode-launch.template.json');
             await setConfigFile({
                 template: vscodeLaunchConfigTemplatePath,
                 configPathname: vscodeLaunchConfigPath,
                 templateArgs: {
-                    XDebugPort: phpXDebugPort,
-                    PHPBinPath: getPHPBinPathWithHomeVariable(php)
+                    XDebugPort: xdebugPort,
+                    baseConfig: ctx.config.baseConfig
                 }
             });
         } catch (e) {
@@ -109,4 +124,4 @@ const createPhpFpmConfig = () => ({
     }
 });
 
-module.exports = createPhpFpmConfig;
+module.exports = createVSCodeConfig;

package/lib/tasks/file-system/index.js

@@ -20,7 +20,8 @@ const prepareFileSystem = () => ({
         createVSCodeConfig(),
         createVarnishConfig()
     ], {
-        concurrent: true
+        concurrent: true,
+        exitOnError: false
     })
 });
 

package/lib/tasks/link.js

@@ -4,7 +4,6 @@ const getProjectConfiguration = require('../config/get-project-configuration');
 const retrieveThemeData = require('./theme/retrieve-theme-data');
 const linkTheme = require('./theme/link-theme');
 const { startServices } = require('./docker');
-const { startPhpFpm } = require('./php-fpm');
 const checkConfigurationFile = require('../config/check-configuration-file');
 const { connectToMySQL } = require('./mysql');
 
@@ -18,7 +17,7 @@ const linkTask = (themePath) => ({
         getProjectConfiguration(),
         getCachedPorts(),
         startServices(),
-        startPhpFpm(),
+        // startPhpFpm(),
         connectToMySQL(),
         retrieveThemeData(themePath),
         linkTheme()