@automattic/vip 4.1.6 → 4.1.8

package/dist/lib/dev-environment/dev-environment-core.js

@@ -1,53 +1,54 @@
 "use strict";
-
-exports.__esModule = true;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startEnvironment = startEnvironment;
+exports.stopEnvironment = stopEnvironment;
 exports.createEnvironment = createEnvironment;
+exports.updateEnvironment = updateEnvironment;
 exports.destroyEnvironment = destroyEnvironment;
-exports.doesEnvironmentExist = doesEnvironmentExist;
-exports.exec = exec;
-exports.fetchVersionList = fetchVersionList;
-exports.generatePHPStormWorkspace = generatePHPStormWorkspace;
-exports.generateVSCodeWorkspace = generateVSCodeWorkspace;
-exports.getAllEnvironmentNames = getAllEnvironmentNames;
-exports.getApplicationInformation = getApplicationInformation;
-exports.getEnvironmentPath = getEnvironmentPath;
-exports.getVSCodeWorkspacePath = getVSCodeWorkspacePath;
-exports.getVersionList = getVersionList;
-exports.importMediaPath = importMediaPath;
 exports.printAllEnvironmentsInfo = printAllEnvironmentsInfo;
+exports.showLogs = showLogs;
 exports.printEnvironmentInfo = printEnvironmentInfo;
+exports.exec = exec;
+exports.doesEnvironmentExist = doesEnvironmentExist;
 exports.readEnvironmentData = readEnvironmentData;
-exports.resolveImportPath = resolveImportPath;
-exports.showLogs = showLogs;
-exports.startEnvironment = startEnvironment;
-exports.stopEnvironment = stopEnvironment;
-exports.updateEnvironment = updateEnvironment;
 exports.writeEnvironmentData = writeEnvironmentData;
-var _chalk = _interopRequireDefault(require("chalk"));
-var _debug = _interopRequireDefault(require("debug"));
-var _ejs = _interopRequireDefault(require("ejs"));
-var _enquirer = require("enquirer");
-var _graphql = require("graphql");
-var _nodeCrypto = require("node:crypto");
-var _nodeFs = _interopRequireDefault(require("node:fs"));
-var _promises = require("node:fs/promises");
-var _nodePath = _interopRequireDefault(require("node:path"));
-var _semver = _interopRequireDefault(require("semver"));
-var _undici = require("undici");
-var _devEnvironmentCli = require("./dev-environment-cli");
-var _devEnvironmentLando = require("./dev-environment-lando");
-var _landoLoader = require("./lando-loader");
-var _app = _interopRequireDefault(require("../api/app"));
-var _software = require("../config/software");
-var _devEnvironment = require("../constants/dev-environment");
-var _proxyDispatcher = require("../http/proxy-dispatcher");
-var _searchAndReplace = require("../search-and-replace");
-var _userError = _interopRequireDefault(require("../user-error"));
-var _xdgData = require("../xdg-data");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const debug = (0, _debug.default)('@automattic/vip:bin:dev-environment');
-const landoFileTemplatePath = _nodePath.default.join(__dirname, '..', '..', '..', 'assets', 'dev-env.lando.template.yml.ejs');
-const nginxFileTemplatePath = _nodePath.default.join(__dirname, '..', '..', '..', 'assets', 'dev-env.nginx.template.conf.ejs');
+exports.getAllEnvironmentNames = getAllEnvironmentNames;
+exports.getEnvironmentPath = getEnvironmentPath;
+exports.getApplicationInformation = getApplicationInformation;
+exports.resolveImportPath = resolveImportPath;
+exports.importMediaPath = importMediaPath;
+exports.fetchVersionList = fetchVersionList;
+exports.getVersionList = getVersionList;
+exports.generateVSCodeWorkspace = generateVSCodeWorkspace;
+exports.getVSCodeWorkspacePath = getVSCodeWorkspacePath;
+exports.generatePHPStormWorkspace = generatePHPStormWorkspace;
+const chalk_1 = __importDefault(require("chalk"));
+const debug_1 = __importDefault(require("debug"));
+const ejs_1 = __importDefault(require("ejs"));
+const enquirer_1 = require("enquirer");
+const graphql_1 = require("graphql");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const semver_1 = __importDefault(require("semver"));
+const undici_1 = require("undici");
+const dev_environment_cli_1 = require("./dev-environment-cli");
+const dev_environment_lando_1 = require("./dev-environment-lando");
+const lando_loader_1 = require("./lando-loader");
+const app_1 = __importDefault(require("../api/app"));
+const software_1 = require("../config/software");
+const dev_environment_1 = require("../constants/dev-environment");
+const proxy_dispatcher_1 = require("../http/proxy-dispatcher");
+const search_and_replace_1 = require("../search-and-replace");
+const user_error_1 = __importDefault(require("../user-error"));
+const xdg_data_1 = require("../xdg-data");
+const debug = (0, debug_1.default)('@automattic/vip:bin:dev-environment');
+const landoFileTemplatePath = node_path_1.default.join(__dirname, '..', '..', '..', 'assets', 'dev-env.lando.template.yml.ejs');
+const nginxFileTemplatePath = node_path_1.default.join(__dirname, '..', '..', '..', 'assets', 'dev-env.nginx.template.conf.ejs');
 const landoFileName = '.lando.yml';
 const landoOverridesFileName = '.lando.local.yml';
 const landoBackupFileName = '.lando.backup.yml';
@@ -61,290 +62,287 @@ const integrationsConfigPathString = 'integrations-config';
 const STARTUP_READY_ATTEMPTS = 6;
 const STARTUP_READY_DELAY_MS = 2000;
 let dockerComposifyFromLando = null;
-const dockerComposify = value => {
-  if (!dockerComposifyFromLando) {
-    const landoUtils = (0, _landoLoader.loadLandoModule)('lando/lib/utils');
-    dockerComposifyFromLando = landoUtils.dockerComposify;
-  }
-  return dockerComposifyFromLando(value);
+const dockerComposify = (value) => {
+    if (!dockerComposifyFromLando) {
+        const landoUtils = (0, lando_loader_1.loadLandoModule)('lando/lib/utils');
+        dockerComposifyFromLando = landoUtils.dockerComposify;
+    }
+    return dockerComposifyFromLando(value);
 };
-const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
-const renderTemplateFile = async (filePath, templateData) => _ejs.default.renderFile(filePath, templateData);
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+const renderTemplateFile = async (filePath, templateData) => ejs_1.default.renderFile(filePath, templateData);
 async function waitForEnvironmentToBeUp(lando, instancePath) {
-  return pollEnvironmentUpStatus(lando, instancePath, 1);
+    return pollEnvironmentUpStatus(lando, instancePath, 1);
 }
 async function pollEnvironmentUpStatus(lando, instancePath, attempt) {
-  if (await (0, _devEnvironmentLando.isEnvUp)(lando, instancePath)) {
-    return true;
-  }
-  if (attempt >= STARTUP_READY_ATTEMPTS) {
-    return false;
-  }
-  await sleep(STARTUP_READY_DELAY_MS);
-  return pollEnvironmentUpStatus(lando, instancePath, attempt + 1);
+    if (await (0, dev_environment_lando_1.isEnvUp)(lando, instancePath)) {
+        return true;
+    }
+    if (attempt >= STARTUP_READY_ATTEMPTS) {
+        return false;
+    }
+    await sleep(STARTUP_READY_DELAY_MS);
+    return pollEnvironmentUpStatus(lando, instancePath, attempt + 1);
 }
 async function startEnvironment(lando, slug, options) {
-  debug('Will start an environment', slug);
-  const instancePath = getEnvironmentPath(slug);
-  debug('Instance path for %s is %s', slug, instancePath);
-  const environmentExists = _nodeFs.default.existsSync(instancePath);
-  if (!environmentExists) {
-    throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
-  }
-  const envFilePath = _nodePath.default.join(instancePath, '.env');
-  _nodeFs.default.appendFileSync(envFilePath, '');
-  let updated = false;
-  if (!options.skipWpVersionsCheck && process.stdin.isTTY) {
-    updated = await maybeUpdateWordPressImage(lando, slug);
-  }
-  updated = updated || (await maybeUpdateVersion(lando, slug));
-  const proxyContainer = await (0, _devEnvironmentLando.getProxyContainer)(lando);
-  if (!proxyContainer?.State.Running) {
-    await (0, _devEnvironmentLando.removeProxyCache)(lando);
-  }
-  if (options.skipRebuild && !updated) {
-    await (0, _devEnvironmentLando.landoStart)(lando, instancePath);
-  } else {
-    await (0, _devEnvironmentLando.landoRebuild)(lando, instancePath);
-  }
-  let isEnvironmentUp = await waitForEnvironmentToBeUp(lando, instancePath);
-  if (!isEnvironmentUp) {
-    // A second startup pass helps recover after Docker network auto-cleanup edge cases.
-    await (0, _devEnvironmentLando.landoStart)(lando, instancePath);
-    isEnvironmentUp = await waitForEnvironmentToBeUp(lando, instancePath);
-  }
-  if (!isEnvironmentUp) {
-    throw new _userError.default(`Environment "${slug}" did not reach a running state. Please try "${_chalk.default.bold(`vip dev-env start --slug ${slug}`)}" again.`);
-  }
-  await printEnvironmentInfo(lando, slug, {
-    extended: false
-  });
+    debug('Will start an environment', slug);
+    const instancePath = getEnvironmentPath(slug);
+    debug('Instance path for %s is %s', slug, instancePath);
+    const environmentExists = node_fs_1.default.existsSync(instancePath);
+    if (!environmentExists) {
+        throw new Error(dev_environment_1.DEV_ENVIRONMENT_NOT_FOUND);
+    }
+    const envFilePath = node_path_1.default.join(instancePath, '.env');
+    node_fs_1.default.appendFileSync(envFilePath, '');
+    let updated = false;
+    if (!options.skipWpVersionsCheck && process.stdin.isTTY) {
+        updated = await maybeUpdateWordPressImage(lando, slug);
+    }
+    updated = updated || (await maybeUpdateVersion(lando, slug));
+    const proxyContainer = await (0, dev_environment_lando_1.getProxyContainer)(lando);
+    if (!proxyContainer?.State.Running) {
+        await (0, dev_environment_lando_1.removeProxyCache)(lando);
+    }
+    if (options.skipRebuild && !updated) {
+        await (0, dev_environment_lando_1.landoStart)(lando, instancePath);
+    }
+    else {
+        await (0, dev_environment_lando_1.landoRebuild)(lando, instancePath);
+    }
+    let isEnvironmentUp = await waitForEnvironmentToBeUp(lando, instancePath);
+    if (!isEnvironmentUp) {
+        // A second startup pass helps recover after Docker network auto-cleanup edge cases.
+        await (0, dev_environment_lando_1.landoStart)(lando, instancePath);
+        isEnvironmentUp = await waitForEnvironmentToBeUp(lando, instancePath);
+    }
+    if (!isEnvironmentUp) {
+        throw new user_error_1.default(`Environment "${slug}" did not reach a running state. Please try "${chalk_1.default.bold(`vip dev-env start --slug ${slug}`)}" again.`);
+    }
+    await printEnvironmentInfo(lando, slug, { extended: false });
 }
 async function stopEnvironment(lando, slug) {
-  debug('Will stop an environment', slug);
-  const instancePath = getEnvironmentPath(slug);
-  debug('Instance path for', slug, 'is:', instancePath);
-  const environmentExists = _nodeFs.default.existsSync(instancePath);
-  if (!environmentExists) {
-    throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
-  }
-  await (0, _devEnvironmentLando.landoStop)(lando, instancePath);
+    debug('Will stop an environment', slug);
+    const instancePath = getEnvironmentPath(slug);
+    debug('Instance path for', slug, 'is:', instancePath);
+    const environmentExists = node_fs_1.default.existsSync(instancePath);
+    if (!environmentExists) {
+        throw new Error(dev_environment_1.DEV_ENVIRONMENT_NOT_FOUND);
+    }
+    await (0, dev_environment_lando_1.landoStop)(lando, instancePath);
 }
 function createEnvironment(lando, instanceData, integrationsConfig, envVars) {
-  const slug = instanceData.siteSlug;
-  integrationsConfig ??= {};
-  debug('Will process an environment', slug, 'with instanceData for creation: ', instanceData);
-  const instancePath = getEnvironmentPath(slug);
-  debug('Instance path for', slug, 'is:', instancePath);
-  const alreadyExists = _nodeFs.default.existsSync(instancePath);
-  if (alreadyExists) {
-    return Promise.reject(new Error('Environment already exists.'));
-  }
-  const preProcessedInstanceData = preProcessInstanceData(instanceData);
-  debug('Will create an environment', slug, 'with instanceData: ', preProcessedInstanceData);
-  return prepareLandoEnv(lando, preProcessedInstanceData, instancePath, integrationsConfig, envVars);
+    const slug = instanceData.siteSlug;
+    integrationsConfig ??= {};
+    debug('Will process an environment', slug, 'with instanceData for creation: ', instanceData);
+    const instancePath = getEnvironmentPath(slug);
+    debug('Instance path for', slug, 'is:', instancePath);
+    const alreadyExists = node_fs_1.default.existsSync(instancePath);
+    if (alreadyExists) {
+        return Promise.reject(new Error('Environment already exists.'));
+    }
+    const preProcessedInstanceData = preProcessInstanceData(instanceData);
+    debug('Will create an environment', slug, 'with instanceData: ', preProcessedInstanceData);
+    return prepareLandoEnv(lando, preProcessedInstanceData, instancePath, integrationsConfig, envVars);
 }
 async function updateEnvironment(lando, instanceData) {
-  const slug = instanceData.siteSlug;
-  debug('Will process an environment', slug, 'with instanceData for updating: ', instanceData);
-  const instancePath = getEnvironmentPath(slug);
-  debug('Instance path for', slug, 'is:', instancePath);
-  const alreadyExists = _nodeFs.default.existsSync(instancePath);
-  if (!alreadyExists) {
-    throw new Error("Environment doesn't exist.");
-  }
-  const preProcessedInstanceData = preProcessInstanceData(instanceData);
-  debug('Will create an environment', slug, 'with instanceData: ', preProcessedInstanceData);
-  await prepareLandoEnv(lando, preProcessedInstanceData, instancePath, undefined, undefined);
+    const slug = instanceData.siteSlug;
+    debug('Will process an environment', slug, 'with instanceData for updating: ', instanceData);
+    const instancePath = getEnvironmentPath(slug);
+    debug('Instance path for', slug, 'is:', instancePath);
+    const alreadyExists = node_fs_1.default.existsSync(instancePath);
+    if (!alreadyExists) {
+        throw new Error("Environment doesn't exist.");
+    }
+    const preProcessedInstanceData = preProcessInstanceData(instanceData);
+    debug('Will create an environment', slug, 'with instanceData: ', preProcessedInstanceData);
+    await prepareLandoEnv(lando, preProcessedInstanceData, instancePath, undefined, undefined);
 }
 function preProcessInstanceData(instanceData) {
-  const newInstanceData = {
-    ...instanceData,
-    xdebugConfig: instanceData.xdebugConfig ?? '',
-    mariadb: instanceData.mariadb ?? '',
-    elasticsearch: instanceData.elasticsearch || false,
-    // NOSONAR
-    php: instanceData.php ?? _devEnvironment.DEV_ENVIRONMENT_PHP_VERSIONS[_devEnvironment.DEV_ENVIRONMENT_DEFAULT_PHP_VERSION].image,
-    xdebug: Boolean(instanceData.xdebug),
-    phpmyadmin: Boolean(instanceData.phpmyadmin),
-    photon: Boolean(instanceData.photon),
-    cron: Boolean(instanceData.cron),
-    mailpit: Boolean(instanceData.mailpit),
-    pullAfter: instanceData.pullAfter ?? 0,
-    autologinKey: (0, _nodeCrypto.randomUUID)(),
-    adminPassword: instanceData.adminPassword ?? 'password',
-    version: _devEnvironment.DEV_ENVIRONMENT_VERSION,
-    overrides: instanceData.overrides ?? ''
-  };
-  if (instanceData.mediaRedirectDomain && !/^https?:/.test(instanceData.mediaRedirectDomain)) {
-    // We need to make sure the redirect is an absolute path
-    newInstanceData.mediaRedirectDomain = `https://${instanceData.mediaRedirectDomain}`;
-  }
-  if (isNaN(instanceData.wordpress.tag)) {
-    newInstanceData.wordpress.tag = 'trunk';
-  }
-  return newInstanceData;
+    const newInstanceData = {
+        ...instanceData,
+        xdebugConfig: instanceData.xdebugConfig ?? '',
+        mariadb: instanceData.mariadb ?? '',
+        elasticsearch: instanceData.elasticsearch || false, // NOSONAR
+        php: instanceData.php ?? dev_environment_1.DEV_ENVIRONMENT_PHP_VERSIONS[dev_environment_1.DEV_ENVIRONMENT_DEFAULT_PHP_VERSION].image,
+        xdebug: Boolean(instanceData.xdebug),
+        phpmyadmin: Boolean(instanceData.phpmyadmin),
+        photon: Boolean(instanceData.photon),
+        cron: Boolean(instanceData.cron),
+        mailpit: Boolean(instanceData.mailpit),
+        pullAfter: instanceData.pullAfter ?? 0,
+        autologinKey: (0, node_crypto_1.randomUUID)(),
+        adminPassword: instanceData.adminPassword ?? 'password',
+        version: dev_environment_1.DEV_ENVIRONMENT_VERSION,
+        overrides: instanceData.overrides ?? '',
+    };
+    if (instanceData.mediaRedirectDomain && !/^https?:/.test(instanceData.mediaRedirectDomain)) {
+        // We need to make sure the redirect is an absolute path
+        newInstanceData.mediaRedirectDomain = `https://${instanceData.mediaRedirectDomain}`;
+    }
+    if (isNaN(instanceData.wordpress.tag)) {
+        newInstanceData.wordpress.tag = 'trunk';
+    }
+    return newInstanceData;
 }
 async function destroyEnvironment(lando, slug, removeFiles) {
-  debug('Will destroy an environment', slug);
-  const instancePath = getEnvironmentPath(slug);
-  debug('Instance path for', slug, 'is:', instancePath);
-  const environmentExists = await doesEnvironmentExist(instancePath);
-  if (!environmentExists) {
-    throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
-  }
-  const landoFilePath = _nodePath.default.join(instancePath, landoFileName);
-  if (_nodeFs.default.existsSync(landoFilePath)) {
-    debug('Lando file exists, will lando destroy.');
-    await (0, _devEnvironmentLando.landoDestroy)(lando, instancePath);
-  } else {
-    debug("Lando file doesn't exist, skipping lando destroy.");
-  }
-  await _nodeFs.default.promises.rm(_nodePath.default.join((0, _xdgData.xdgData)(), 'vip', 'lando', 'compose', dockerComposify(slug)), {
-    force: true,
-    recursive: true
-  });
-  if (removeFiles) {
-    await _nodeFs.default.promises.rm(instancePath, {
-      recursive: true
+    debug('Will destroy an environment', slug);
+    const instancePath = getEnvironmentPath(slug);
+    debug('Instance path for', slug, 'is:', instancePath);
+    const environmentExists = await doesEnvironmentExist(instancePath);
+    if (!environmentExists) {
+        throw new Error(dev_environment_1.DEV_ENVIRONMENT_NOT_FOUND);
+    }
+    const landoFilePath = node_path_1.default.join(instancePath, landoFileName);
+    if (node_fs_1.default.existsSync(landoFilePath)) {
+        debug('Lando file exists, will lando destroy.');
+        await (0, dev_environment_lando_1.landoDestroy)(lando, instancePath);
+    }
+    else {
+        debug("Lando file doesn't exist, skipping lando destroy.");
+    }
+    await node_fs_1.default.promises.rm(node_path_1.default.join((0, xdg_data_1.xdgData)(), 'vip', 'lando', 'compose', dockerComposify(slug)), {
+        force: true,
+        recursive: true,
     });
-    console.log(`${_chalk.default.green('✓')} Environment files deleted successfully.`);
-  }
+    if (removeFiles) {
+        await node_fs_1.default.promises.rm(instancePath, { recursive: true });
+        console.log(`${chalk_1.default.green('✓')} Environment files deleted successfully.`);
+    }
 }
 async function printAllEnvironmentsInfo(lando, options) {
-  const allEnvNames = getAllEnvironmentNames();
-  debug('Will print info for all environments. Names found: ', allEnvNames);
-  console.log('Found ' + _chalk.default.bold(allEnvNames.length) + ' environments' + (allEnvNames.length ? ':' : '.'));
-  for (const envName of allEnvNames) {
-    try {
-      console.log('\n');
-      // eslint-disable-next-line no-await-in-loop
-      await printEnvironmentInfo(lando, envName, options);
-    } catch (error) {
-      if (error instanceof _userError.default) {
-        console.warn('\nWARNING: "%s" is not a valid environment\n', envName);
-      } else {
-        throw error;
-      }
+    const allEnvNames = getAllEnvironmentNames();
+    debug('Will print info for all environments. Names found: ', allEnvNames);
+    console.log('Found ' +
+        chalk_1.default.bold(allEnvNames.length) +
+        ' environments' +
+        (allEnvNames.length ? ':' : '.'));
+    for (const envName of allEnvNames) {
+        try {
+            console.log('\n');
+            // eslint-disable-next-line no-await-in-loop
+            await printEnvironmentInfo(lando, envName, options);
+        }
+        catch (error) {
+            if (error instanceof user_error_1.default) {
+                console.warn('\nWARNING: "%s" is not a valid environment\n', envName);
+            }
+            else {
+                throw error;
+            }
+        }
     }
-  }
 }
 function parseComponentForInfo(component) {
-  if (component.mode === 'local') {
-    return component.dir ?? '';
-  }
-
-  // Environments created by the old code will have `component.tag` set to `demo` instead of `undefined`.
-  if (component.tag === 'demo' || component.tag === 'latest') {
-    component.tag = undefined;
-  }
-  return component.tag ?? '[demo-image]';
+    if (component.mode === 'local') {
+        return component.dir ?? '';
+    }
+    // Environments created by the old code will have `component.tag` set to `demo` instead of `undefined`.
+    if (component.tag === 'demo' || component.tag === 'latest') {
+        component.tag = undefined;
+    }
+    return component.tag ?? '[demo-image]';
 }
 async function showLogs(lando, slug, options = {}) {
-  debug('Will display logs command on env', slug, 'with options', options);
-  const instancePath = getEnvironmentPath(slug);
-  debug('Instance path for %s is %s', slug, instancePath);
-  if (options.service) {
-    const application = await (0, _devEnvironmentLando.getLandoApplication)(lando, instancePath);
-    const services = application.info.map(service => service.service);
-    if (!services.includes(options.service)) {
-      throw new _userError.default(`Service '${options.service}' not found. Please choose from: ${services.join(', ')}`);
-    }
-  }
-  return (0, _devEnvironmentLando.landoLogs)(lando, instancePath, options);
+    debug('Will display logs command on env', slug, 'with options', options);
+    const instancePath = getEnvironmentPath(slug);
+    debug('Instance path for %s is %s', slug, instancePath);
+    if (options.service) {
+        const application = await (0, dev_environment_lando_1.getLandoApplication)(lando, instancePath);
+        const services = application.info.map(service => service.service);
+        if (!services.includes(options.service)) {
+            throw new user_error_1.default(`Service '${options.service}' not found. Please choose from: ${services.join(', ')}`);
+        }
+    }
+    return (0, dev_environment_lando_1.landoLogs)(lando, instancePath, options);
 }
 async function printEnvironmentInfo(lando, slug, options) {
-  debug('Will get info for an environment', slug);
-  const instancePath = getEnvironmentPath(slug);
-  debug('Instance path for', slug, 'is:', instancePath);
-  const environmentExists = await doesEnvironmentExist(instancePath);
-  if (!environmentExists) {
-    throw new _userError.default(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
-  }
-  const environmentData = readEnvironmentData(slug);
-  const appInfo = await (0, _devEnvironmentLando.landoInfo)(lando, instancePath, {
-    suppressWarnings: Boolean(options.suppressWarnings),
-    autologinKey: environmentData.autologinKey
-  });
-  if (options.extended) {
-    appInfo.title = environmentData.wpTitle;
-    appInfo.multisite = Boolean(environmentData.multisite);
-    appInfo.php = environmentData.php.split(':')[1];
-    let xdebug = environmentData.xdebug ? 'enabled' : 'disabled';
-    if (environmentData.xdebug && environmentData.xdebugConfig) {
-      xdebug += ' (with additional configuration)';
-    }
-    appInfo.xdebug = xdebug;
-    appInfo.cron = environmentData.cron ? 'enabled' : 'disabled';
-    appInfo.wordpress = parseComponentForInfo(environmentData.wordpress);
-    appInfo['Mu plugins'] = parseComponentForInfo(environmentData.muPlugins);
-    appInfo['App Code'] = parseComponentForInfo(environmentData.appCode);
-    if (environmentData.mediaRedirectDomain) {
-      appInfo['Media Redirect'] = environmentData.mediaRedirectDomain;
-    }
-  }
-  (0, _devEnvironmentCli.printTable)(appInfo);
+    debug('Will get info for an environment', slug);
+    const instancePath = getEnvironmentPath(slug);
+    debug('Instance path for', slug, 'is:', instancePath);
+    const environmentExists = await doesEnvironmentExist(instancePath);
+    if (!environmentExists) {
+        throw new user_error_1.default(dev_environment_1.DEV_ENVIRONMENT_NOT_FOUND);
+    }
+    const environmentData = readEnvironmentData(slug);
+    const appInfo = await (0, dev_environment_lando_1.landoInfo)(lando, instancePath, {
+        suppressWarnings: Boolean(options.suppressWarnings),
+        autologinKey: environmentData.autologinKey,
+    });
+    if (options.extended) {
+        appInfo.title = environmentData.wpTitle;
+        appInfo.multisite = Boolean(environmentData.multisite);
+        appInfo.php = environmentData.php.split(':')[1];
+        let xdebug = environmentData.xdebug ? 'enabled' : 'disabled';
+        if (environmentData.xdebug && environmentData.xdebugConfig) {
+            xdebug += ' (with additional configuration)';
+        }
+        appInfo.xdebug = xdebug;
+        appInfo.cron = environmentData.cron ? 'enabled' : 'disabled';
+        appInfo.wordpress = parseComponentForInfo(environmentData.wordpress);
+        appInfo['Mu plugins'] = parseComponentForInfo(environmentData.muPlugins);
+        appInfo['App Code'] = parseComponentForInfo(environmentData.appCode);
+        if (environmentData.mediaRedirectDomain) {
+            appInfo['Media Redirect'] = environmentData.mediaRedirectDomain;
+        }
+    }
+    (0, dev_environment_cli_1.printTable)(appInfo);
 }
 function exec(lando, slug, args, options = {}) {
-  debug('Will run a wp command on env', slug, 'with args', args, ' and options', options);
-  const instancePath = getEnvironmentPath(slug);
-  debug('Instance path for', slug, 'is:', instancePath);
-  const [command, ...commandArgs] = args;
-  return (0, _devEnvironmentLando.landoExec)(lando, instancePath, command, commandArgs, options);
+    debug('Will run a wp command on env', slug, 'with args', args, ' and options', options);
+    const instancePath = getEnvironmentPath(slug);
+    debug('Instance path for', slug, 'is:', instancePath);
+    const [command, ...commandArgs] = args;
+    return (0, dev_environment_lando_1.landoExec)(lando, instancePath, command, commandArgs, options);
 }
 async function doesEnvironmentExist(instancePath) {
-  debug('Will check for environment at %s', instancePath);
-  const file = _nodePath.default.join(instancePath, instanceDataFileName);
-  try {
-    const stats = await _nodeFs.default.promises.stat(file);
-    return stats.isFile();
-  } catch {
-    return false;
-  }
+    debug('Will check for environment at %s', instancePath);
+    const file = node_path_1.default.join(instancePath, instanceDataFileName);
+    try {
+        const stats = await node_fs_1.default.promises.stat(file);
+        return stats.isFile();
+    }
+    catch {
+        return false;
+    }
 }
 function readEnvironmentData(slug) {
-  debug('Will try to get instance data for environment', slug);
-  const instancePath = getEnvironmentPath(slug);
-  const instanceDataTargetPath = _nodePath.default.join(instancePath, instanceDataFileName);
-  let instanceDataString;
-  let instanceData;
-  try {
-    instanceDataString = _nodeFs.default.readFileSync(instanceDataTargetPath, 'utf8');
-  } catch (error) {
-    const err = error;
-    throw new _userError.default(`There was an error reading file "${instanceDataTargetPath}": ${err.message}.`, {
-      cause: error
-    });
-  }
-  try {
-    instanceData = JSON.parse(instanceDataString);
-  } catch (error) {
-    const err = error;
-    throw new _userError.default(`There was an error parsing file "${instanceDataTargetPath}": ${err.message}. You may need to recreate the environment.`, {
-      cause: error
-    });
-  }
-
-  /**
-   ***********************************
-   * BACKWARDS COMPATIBILITY SECTION
-   **********************************
-   */
-
-  // REMOVEME after the wheel of time spins around few times
-  if (instanceData.enterpriseSearchEnabled || instanceData.elasticsearchEnabled) {
-    // enterpriseSearchEnabled and elasticsearchEnabled was renamed to elasticsearch
-    instanceData.elasticsearch = instanceData.enterpriseSearchEnabled || instanceData.elasticsearchEnabled;
-  }
-
-  // REMOVEME after the wheel of time spins around few times
-  if (instanceData.clientCode) {
-    // clientCode was renamed to appCode
-    instanceData.appCode = instanceData.clientCode;
-  }
-  return instanceData;
+    debug('Will try to get instance data for environment', slug);
+    const instancePath = getEnvironmentPath(slug);
+    const instanceDataTargetPath = node_path_1.default.join(instancePath, instanceDataFileName);
+    let instanceDataString;
+    let instanceData;
+    try {
+        instanceDataString = node_fs_1.default.readFileSync(instanceDataTargetPath, 'utf8');
+    }
+    catch (error) {
+        const err = error;
+        throw new user_error_1.default(`There was an error reading file "${instanceDataTargetPath}": ${err.message}.`, { cause: error });
+    }
+    try {
+        instanceData = JSON.parse(instanceDataString);
+    }
+    catch (error) {
+        const err = error;
+        throw new user_error_1.default(`There was an error parsing file "${instanceDataTargetPath}": ${err.message}. You may need to recreate the environment.`, { cause: error });
+    }
+    /**
+     ***********************************
+     * BACKWARDS COMPATIBILITY SECTION
+     **********************************
+     */
+    // REMOVEME after the wheel of time spins around few times
+    if (instanceData.enterpriseSearchEnabled || instanceData.elasticsearchEnabled) {
+        // enterpriseSearchEnabled and elasticsearchEnabled was renamed to elasticsearch
+        instanceData.elasticsearch = (instanceData.enterpriseSearchEnabled ||
+            instanceData.elasticsearchEnabled);
+    }
+    // REMOVEME after the wheel of time spins around few times
+    if (instanceData.clientCode) {
+        // clientCode was renamed to appCode
+        instanceData.appCode = instanceData.clientCode;
+    }
+    return instanceData;
 }
-
 /**
  * Writes the instance data.
  *
@@ -353,108 +351,108 @@ function readEnvironmentData(slug) {
  * @return {Promise<void>} Promise
  */
 function writeEnvironmentData(slug, data) {
-  debug('Will try to write instance data for environment', slug);
-  const instancePath = getEnvironmentPath(slug);
-  const instanceDataTargetPath = _nodePath.default.join(instancePath, instanceDataFileName);
-  return _nodeFs.default.promises.writeFile(instanceDataTargetPath, JSON.stringify(data, null, 2));
+    debug('Will try to write instance data for environment', slug);
+    const instancePath = getEnvironmentPath(slug);
+    const instanceDataTargetPath = node_path_1.default.join(instancePath, instanceDataFileName);
+    return node_fs_1.default.promises.writeFile(instanceDataTargetPath, JSON.stringify(data, null, 2));
 }
 async function writeIntegrationsConfig(instancePath, integrationsConfig) {
-  const integrationsConfigPath = _nodePath.default.join(instancePath, integrationsConfigPathString);
-  const integrationsConfigTargetPath = _nodePath.default.join(integrationsConfigPath, integrationsConfigFileName);
-  await _nodeFs.default.promises.mkdir(integrationsConfigPath, {
-    recursive: true
-  });
-  if (integrationsConfig !== undefined) {
-    const integrationsConfigBackupTargetPath = _nodePath.default.join(integrationsConfigPath, integrationsConfigBackupFileName);
-    try {
-      await _nodeFs.default.promises.rename(integrationsConfigTargetPath, integrationsConfigBackupTargetPath);
-      console.log(`Backup of ${integrationsConfigFileName} was created in ${integrationsConfigBackupTargetPath}`);
-    } catch (err) {
-      if ('ENOENT' !== err.code) {
-        throw err;
-      }
-    }
-    const configJson = JSON.stringify(integrationsConfig, null, 4);
-    await _nodeFs.default.promises.writeFile(integrationsConfigTargetPath, configJson);
-    debug(`Integrations configuration file created in ${integrationsConfigTargetPath}`);
-  }
+    const integrationsConfigPath = node_path_1.default.join(instancePath, integrationsConfigPathString);
+    const integrationsConfigTargetPath = node_path_1.default.join(integrationsConfigPath, integrationsConfigFileName);
+    await node_fs_1.default.promises.mkdir(integrationsConfigPath, { recursive: true });
+    if (integrationsConfig !== undefined) {
+        const integrationsConfigBackupTargetPath = node_path_1.default.join(integrationsConfigPath, integrationsConfigBackupFileName);
+        try {
+            await node_fs_1.default.promises.rename(integrationsConfigTargetPath, integrationsConfigBackupTargetPath);
+            console.log(`Backup of ${integrationsConfigFileName} was created in ${integrationsConfigBackupTargetPath}`);
+        }
+        catch (err) {
+            if ('ENOENT' !== err.code) {
+                throw err;
+            }
+        }
+        const configJson = JSON.stringify(integrationsConfig, null, 4);
+        await node_fs_1.default.promises.writeFile(integrationsConfigTargetPath, configJson);
+        debug(`Integrations configuration file created in ${integrationsConfigTargetPath}`);
+    }
 }
 async function prepareLandoEnv(lando, instanceData, instancePath, integrationsConfig, envVars) {
-  const templateData = {
-    ...instanceData,
-    domain: lando.config.domain
-  };
-  const landoFile = await renderTemplateFile(landoFileTemplatePath, templateData);
-  const nginxFile = await renderTemplateFile(nginxFileTemplatePath, templateData);
-  const instanceDataFile = JSON.stringify(instanceData);
-  const landoFileTargetPath = _nodePath.default.join(instancePath, landoFileName);
-  const landoOverridesFileTargetPath = _nodePath.default.join(instancePath, landoOverridesFileName);
-  const landoBackupFileTargetPath = _nodePath.default.join(instancePath, landoBackupFileName);
-  const nginxFolderPath = _nodePath.default.join(instancePath, nginxPathString);
-  const nginxFileTargetPath = _nodePath.default.join(nginxFolderPath, nginxFileName);
-  const instanceDataTargetPath = _nodePath.default.join(instancePath, instanceDataFileName);
-  const envFilePath = _nodePath.default.join(instancePath, '.env');
-  await _nodeFs.default.promises.mkdir(instancePath, {
-    recursive: true
-  });
-  await _nodeFs.default.promises.mkdir(nginxFolderPath, {
-    recursive: true
-  });
-  try {
-    await _nodeFs.default.promises.rename(landoFileTargetPath, landoBackupFileTargetPath);
-    console.log(`Backup of ${landoFileName} was created in ${landoBackupFileTargetPath}`);
-  } catch (err) {
-    // If the file doesn't exist, that's fine. Otherwise, throw the error.
-    if ('ENOENT' !== err.code) {
-      throw err;
-    }
-  }
-  await Promise.all([_nodeFs.default.promises.writeFile(landoFileTargetPath, landoFile), _nodeFs.default.promises.writeFile(nginxFileTargetPath, nginxFile), _nodeFs.default.promises.writeFile(instanceDataTargetPath, instanceDataFile)]);
-  if (envVars !== undefined) {
-    const env = [];
-    Object.entries(envVars ?? {}).forEach(([key]) => {
-      env.push(`VIP_ENV_VAR_${key}=`);
-    });
-    await _nodeFs.default.promises.writeFile(envFilePath, env.join('\n'));
-  } else {
-    await _nodeFs.default.promises.appendFile(envFilePath, '');
-  }
-  debug(`Lando file created in ${landoFileTargetPath}`);
-  debug(`Nginx file created in ${nginxFileTargetPath}`);
-  debug(`Instance data file created in ${instanceDataTargetPath}`);
-  await writeIntegrationsConfig(instancePath, integrationsConfig);
-  if (instanceData.overrides) {
-    await _nodeFs.default.promises.writeFile(landoOverridesFileTargetPath, instanceData.overrides);
-  } else {
-    await _nodeFs.default.promises.rm(landoOverridesFileTargetPath, {
-      force: true
-    });
-  }
+    const templateData = {
+        ...instanceData,
+        domain: lando.config.domain,
+    };
+    const landoFile = await renderTemplateFile(landoFileTemplatePath, templateData);
+    const nginxFile = await renderTemplateFile(nginxFileTemplatePath, templateData);
+    const instanceDataFile = JSON.stringify(instanceData);
+    const landoFileTargetPath = node_path_1.default.join(instancePath, landoFileName);
+    const landoOverridesFileTargetPath = node_path_1.default.join(instancePath, landoOverridesFileName);
+    const landoBackupFileTargetPath = node_path_1.default.join(instancePath, landoBackupFileName);
+    const nginxFolderPath = node_path_1.default.join(instancePath, nginxPathString);
+    const nginxFileTargetPath = node_path_1.default.join(nginxFolderPath, nginxFileName);
+    const instanceDataTargetPath = node_path_1.default.join(instancePath, instanceDataFileName);
+    const envFilePath = node_path_1.default.join(instancePath, '.env');
+    await node_fs_1.default.promises.mkdir(instancePath, { recursive: true });
+    await node_fs_1.default.promises.mkdir(nginxFolderPath, { recursive: true });
+    try {
+        await node_fs_1.default.promises.rename(landoFileTargetPath, landoBackupFileTargetPath);
+        console.log(`Backup of ${landoFileName} was created in ${landoBackupFileTargetPath}`);
+    }
+    catch (err) {
+        // If the file doesn't exist, that's fine. Otherwise, throw the error.
+        if ('ENOENT' !== err.code) {
+            throw err;
+        }
+    }
+    await Promise.all([
+        node_fs_1.default.promises.writeFile(landoFileTargetPath, landoFile),
+        node_fs_1.default.promises.writeFile(nginxFileTargetPath, nginxFile),
+        node_fs_1.default.promises.writeFile(instanceDataTargetPath, instanceDataFile),
+    ]);
+    if (envVars !== undefined) {
+        const env = [];
+        Object.entries(envVars ?? {}).forEach(([key]) => {
+            env.push(`VIP_ENV_VAR_${key}=`);
+        });
+        await node_fs_1.default.promises.writeFile(envFilePath, env.join('\n'));
+    }
+    else {
+        await node_fs_1.default.promises.appendFile(envFilePath, '');
+    }
+    debug(`Lando file created in ${landoFileTargetPath}`);
+    debug(`Nginx file created in ${nginxFileTargetPath}`);
+    debug(`Instance data file created in ${instanceDataTargetPath}`);
+    await writeIntegrationsConfig(instancePath, integrationsConfig);
+    if (instanceData.overrides) {
+        await node_fs_1.default.promises.writeFile(landoOverridesFileTargetPath, instanceData.overrides);
+    }
+    else {
+        await node_fs_1.default.promises.rm(landoOverridesFileTargetPath, { force: true });
+    }
 }
 function getAllEnvironmentNames() {
-  const mainEnvironmentPath = (0, _xdgData.xdgData)();
-  const baseDir = _nodePath.default.join(mainEnvironmentPath, 'vip', 'dev-environment');
-  const doWeHaveAnyEnvironment = _nodeFs.default.existsSync(baseDir);
-  let envNames = [];
-  if (doWeHaveAnyEnvironment) {
-    const files = _nodeFs.default.readdirSync(baseDir);
-    envNames = files.filter(file => {
-      const fullPath = _nodePath.default.join(baseDir, file);
-      return _nodeFs.default.lstatSync(fullPath).isDirectory();
-    });
-  }
-  return envNames;
+    const mainEnvironmentPath = (0, xdg_data_1.xdgData)();
+    const baseDir = node_path_1.default.join(mainEnvironmentPath, 'vip', 'dev-environment');
+    const doWeHaveAnyEnvironment = node_fs_1.default.existsSync(baseDir);
+    let envNames = [];
+    if (doWeHaveAnyEnvironment) {
+        const files = node_fs_1.default.readdirSync(baseDir);
+        envNames = files.filter(file => {
+            const fullPath = node_path_1.default.join(baseDir, file);
+            return node_fs_1.default.lstatSync(fullPath).isDirectory();
+        });
+    }
+    return envNames;
 }
 function getEnvironmentPath(name) {
-  if (!name) {
-    throw new Error('Name was not provided');
-  }
-  const mainEnvironmentPath = (0, _xdgData.xdgData)();
-  return _nodePath.default.join(mainEnvironmentPath, 'vip', 'dev-environment', String(name));
+    if (!name) {
+        throw new Error('Name was not provided');
+    }
+    const mainEnvironmentPath = (0, xdg_data_1.xdgData)();
+    return node_path_1.default.join(mainEnvironmentPath, 'vip', 'dev-environment', String(name));
 }
 async function getApplicationInformation(appId, envType) {
-  // $FlowFixMe: gql template is not supported by flow
-  const fieldsQuery = `
+    // $FlowFixMe: gql template is not supported by flow
+    const fieldsQuery = `
 		id,
 		name,
 		repository {
@@ -487,114 +485,109 @@ async function getApplicationInformation(appId, envType) {
 				}
 			}
 		}`;
-  const queryResult = await (0, _app.default)(appId, fieldsQuery, (0, _graphql.print)(_software.appQueryFragments));
-  const appData = {};
-  if (queryResult.id) {
-    appData.id = queryResult.id;
-    appData.name = queryResult.name;
-    appData.repository = queryResult.repository?.htmlUrl;
-
-    // FIXME: This is casted as AppEnvironment[] but pedantically, Parker's schema made it so that the array may contain nullable. Code-wise though, that doesn't actually happen.
-    const environments = queryResult.environments ?? [];
-    let envData;
-    if (envType) {
-      envData = environments.find(candidateEnv => candidateEnv.type === envType);
-    } else if (1 === environments.length) {
-      envData = environments[0];
-    } else {
-      const choices = environments.map(candidateEnv => candidateEnv.type);
-      const {
-        env
-      } = await (0, _enquirer.prompt)({
-        type: 'select',
-        name: 'env',
-        message: 'Which environment?',
-        choices
-      });
-      envData = environments.find(candidateEnv => candidateEnv.type === env);
-    }
-    if (envData) {
-      const envVars = {};
-      envData.environmentVariables?.nodes?.forEach(envvar => {
-        if (envvar?.name) {
-          envVars[envvar.name] = '';
+    const queryResult = await (0, app_1.default)(appId, fieldsQuery, (0, graphql_1.print)(software_1.appQueryFragments));
+    const appData = {};
+    if (queryResult.id) {
+        appData.id = queryResult.id;
+        appData.name = queryResult.name;
+        appData.repository = queryResult.repository?.htmlUrl;
+        // FIXME: This is casted as AppEnvironment[] but pedantically, Parker's schema made it so that the array may contain nullable. Code-wise though, that doesn't actually happen.
+        const environments = (queryResult.environments ?? []);
+        let envData;
+        if (envType) {
+            envData = environments.find(candidateEnv => candidateEnv.type === envType);
+        }
+        else if (1 === environments.length) {
+            envData = environments[0];
+        }
+        else {
+            const choices = environments.map(candidateEnv => candidateEnv.type);
+            const { env } = await (0, enquirer_1.prompt)({
+                type: 'select',
+                name: 'env',
+                message: 'Which environment?',
+                choices,
+            });
+            envData = environments.find(candidateEnv => candidateEnv.type === env);
         }
-      });
-      appData.environment = {
-        name: envData.name,
-        branch: envData.branch,
-        type: envData.type,
-        isMultisite: envData.isMultisite,
-        primaryDomain: envData.primaryDomain?.name ?? '',
-        php: envData.softwareSettings?.php?.current.version ?? '',
-        wordpress: envData.softwareSettings?.wordpress?.current.version ?? '',
-        integrations: envData.getIntegrationsDevEnvConfig?.data ?? {},
-        envVars
-      };
-    }
-  }
-  return appData;
+        if (envData) {
+            const envVars = {};
+            envData.environmentVariables?.nodes?.forEach(envvar => {
+                if (envvar?.name) {
+                    envVars[envvar.name] = '';
+                }
+            });
+            appData.environment = {
+                name: envData.name,
+                branch: envData.branch,
+                type: envData.type,
+                isMultisite: envData.isMultisite,
+                primaryDomain: envData.primaryDomain?.name ?? '',
+                php: envData.softwareSettings?.php?.current.version ?? '',
+                wordpress: envData.softwareSettings?.wordpress?.current.version ?? '',
+                integrations: envData.getIntegrationsDevEnvConfig?.data ??
+                    {},
+                envVars,
+            };
+        }
+    }
+    return appData;
 }
 async function resolveImportPath(slug, fileName, searchReplace, inPlace) {
-  debug(`Will try to resolve path - ${fileName}`);
-  let resolvedPath = (0, _devEnvironmentCli.resolvePath)(fileName);
-  debug(`Filename ${fileName} resolved to ${resolvedPath}`);
-  if (!_nodeFs.default.existsSync(resolvedPath)) {
-    throw new _userError.default(`The provided file ${resolvedPath} does not exist or it is not valid (see "--help" for examples)`);
-  }
-  if (_nodeFs.default.lstatSync(resolvedPath).isDirectory()) {
-    throw new _userError.default(`The provided file ${resolvedPath} is a directory. Please point to a sql file.`);
-  }
-
-  // Run Search and Replace if the --search-replace flag was provided
-  if (searchReplace?.length) {
-    const {
-      outputFileName
-    } = await (0, _searchAndReplace.searchAndReplace)(resolvedPath, searchReplace, {
-      isImport: true,
-      output: true,
-      inPlace
-    });
-    if (typeof outputFileName !== 'string') {
-      throw new Error('Unable to determine location of the intermediate search & replace file.');
+    debug(`Will try to resolve path - ${fileName}`);
+    let resolvedPath = (0, dev_environment_cli_1.resolvePath)(fileName);
+    debug(`Filename ${fileName} resolved to ${resolvedPath}`);
+    if (!node_fs_1.default.existsSync(resolvedPath)) {
+        throw new user_error_1.default(`The provided file ${resolvedPath} does not exist or it is not valid (see "--help" for examples)`);
+    }
+    if (node_fs_1.default.lstatSync(resolvedPath).isDirectory()) {
+        throw new user_error_1.default(`The provided file ${resolvedPath} is a directory. Please point to a sql file.`);
     }
-    resolvedPath = outputFileName;
-  }
-  return resolvedPath;
+    // Run Search and Replace if the --search-replace flag was provided
+    if (searchReplace?.length) {
+        const { outputFileName } = await (0, search_and_replace_1.searchAndReplace)(resolvedPath, searchReplace, {
+            isImport: true,
+            output: true,
+            inPlace,
+        });
+        if (typeof outputFileName !== 'string') {
+            throw new Error('Unable to determine location of the intermediate search & replace file.');
+        }
+        resolvedPath = outputFileName;
+    }
+    return resolvedPath;
 }
 async function importMediaPath(slug, filePath) {
-  const resolvedPath = (0, _devEnvironmentCli.resolvePath)(filePath);
-  if (!_nodeFs.default.existsSync(resolvedPath) || !_nodeFs.default.lstatSync(resolvedPath).isDirectory()) {
-    throw new Error('The provided path does not exist or it is not valid (see "--help" for examples)');
-  }
-  const environmentPath = getEnvironmentPath(slug);
-  if (!(await doesEnvironmentExist(environmentPath))) {
-    throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
-  }
-  const files = await (0, _promises.readdir)(resolvedPath);
-  if (files.includes(uploadPathString)) {
-    const confirm = await (0, _enquirer.prompt)({
-      type: 'confirm',
-      name: 'continue',
-      message: 'The provided path contains an uploads folder inside. Do you want to continue?'
-    });
-    if (!confirm.continue) {
-      return;
-    }
-  }
-  const uploadsPath = _nodePath.default.join(environmentPath, uploadPathString);
-  console.log(`${_chalk.default.yellow('-')} Started copying files`);
-  try {
-    await (0, _promises.cp)(resolvedPath, uploadsPath, {
-      recursive: true
-    });
-    console.log(`${_chalk.default.green('✓')} Files successfully copied to ${uploadsPath}.`);
-  } catch (error) {
-    console.error(`${_chalk.default.red('✗')} Error copying files to ${uploadsPath}.`);
-    throw error;
-  }
+    const resolvedPath = (0, dev_environment_cli_1.resolvePath)(filePath);
+    if (!node_fs_1.default.existsSync(resolvedPath) || !node_fs_1.default.lstatSync(resolvedPath).isDirectory()) {
+        throw new Error('The provided path does not exist or it is not valid (see "--help" for examples)');
+    }
+    const environmentPath = getEnvironmentPath(slug);
+    if (!(await doesEnvironmentExist(environmentPath))) {
+        throw new Error(dev_environment_1.DEV_ENVIRONMENT_NOT_FOUND);
+    }
+    const files = await (0, promises_1.readdir)(resolvedPath);
+    if (files.includes(uploadPathString)) {
+        const confirm = await (0, enquirer_1.prompt)({
+            type: 'confirm',
+            name: 'continue',
+            message: 'The provided path contains an uploads folder inside. Do you want to continue?',
+        });
+        if (!confirm.continue) {
+            return;
+        }
+    }
+    const uploadsPath = node_path_1.default.join(environmentPath, uploadPathString);
+    console.log(`${chalk_1.default.yellow('-')} Started copying files`);
+    try {
+        await (0, promises_1.cp)(resolvedPath, uploadsPath, { recursive: true });
+        console.log(`${chalk_1.default.green('✓')} Files successfully copied to ${uploadsPath}.`);
+    }
+    catch (error) {
+        console.error(`${chalk_1.default.red('✗')} Error copying files to ${uploadsPath}.`);
+        throw error;
+    }
 }
-
 /**
  * Uses the WordPress versions manifest on github.com
  * Informs the user several things:
@@ -606,122 +599,106 @@ async function importMediaPath(slug, filePath) {
  * @return {boolean} boolean
  */
 async function maybeUpdateWordPressImage(lando, slug) {
-  const versions = await getVersionList();
-  if (!versions.length) {
-    return false;
-  }
-  let message;
-  let envData;
-  let currentWordPressTag;
-
-  // Get the current environment configuration
-  try {
-    envData = readEnvironmentData(slug);
-    currentWordPressTag = envData.wordpress.tag;
-    if (currentWordPressTag === 'trunk') {
-      return false;
-    }
-  } catch (err) {
-    const error = err;
-    // This can throw an exception if the env is build with older vip version
-    if ('ENOENT' === error.code) {
-      message = 'Environment was created before update was supported.\n\n';
-      message += 'To update environment please destroy it and create a new one.';
-    } else {
-      message = `An error prevented reading the configuration of: ${slug}\n\n ${error.message}`;
-    }
-    await (0, _devEnvironmentCli.handleCLIException)(new Error(message));
-    return false;
-  }
-
-  // sort
-  versions.sort((before, after) => before.tag < after.tag ? 1 : -1);
-  // Newest WordPress Image but that is not trunk
-  const newestWordPressImage = versions.find(({
-    tag
-  }) => tag !== 'trunk');
-  console.log('The most recent WordPress version available is: ' + _chalk.default.green(newestWordPressImage?.tag));
-
-  // If the currently used version is the most up to date: exit.
-  if (currentWordPressTag === newestWordPressImage?.tag) {
-    console.log('Environment WordPress version is: ' + _chalk.default.green(currentWordPressTag) + '  ... 😎 nice! ');
+    const versions = await getVersionList();
+    if (!versions.length) {
+        return false;
+    }
+    let message;
+    let envData;
+    let currentWordPressTag;
+    // Get the current environment configuration
+    try {
+        envData = readEnvironmentData(slug);
+        currentWordPressTag = envData.wordpress.tag;
+        if (currentWordPressTag === 'trunk') {
+            return false;
+        }
+    }
+    catch (err) {
+        const error = err;
+        // This can throw an exception if the env is build with older vip version
+        if ('ENOENT' === error.code) {
+            message = 'Environment was created before update was supported.\n\n';
+            message += 'To update environment please destroy it and create a new one.';
+        }
+        else {
+            message = `An error prevented reading the configuration of: ${slug}\n\n ${error.message}`;
+        }
+        await (0, dev_environment_cli_1.handleCLIException)(new Error(message));
+        return false;
+    }
+    // sort
+    versions.sort((before, after) => (before.tag < after.tag ? 1 : -1));
+    // Newest WordPress Image but that is not trunk
+    const newestWordPressImage = versions.find(({ tag }) => tag !== 'trunk');
+    console.log('The most recent WordPress version available is: ' + chalk_1.default.green(newestWordPressImage?.tag));
+    // If the currently used version is the most up to date: exit.
+    if (currentWordPressTag === newestWordPressImage?.tag) {
+        console.log('Environment WordPress version is: ' + chalk_1.default.green(currentWordPressTag) + '  ... 😎 nice! ');
+        return false;
+    }
+    // Determine if there is an image available for the current WordPress version
+    const match = versions.find(({ tag }) => tag === currentWordPressTag);
+    // If there is no available image for the currently installed version, give user a path to change
+    if (typeof match === 'undefined') {
+        console.log(`Installed WordPress: ${currentWordPressTag} has no available container image in repository. `);
+        console.log('You must select a new WordPress image to continue... ');
+    }
+    else {
+        console.log('Environment WordPress version is: ' + chalk_1.default.yellow(`${match.tag} (${match.ref})`));
+        if (envData.wordpress.doNotUpgrade) {
+            return false;
+        }
+    }
+    // Prompt the user to select a new WordPress Version
+    const confirm = await (0, enquirer_1.prompt)({
+        type: 'select',
+        name: 'upgrade',
+        message: 'Would you like to upgrade WordPress? ',
+        choices: ['yes', 'no', "no (don't ask anymore)"],
+    });
+    // If the user takes the new WP version path
+    if (confirm.upgrade === 'yes') {
+        console.log('Upgrading from: ' + chalk_1.default.yellow(currentWordPressTag) + ' to:');
+        // Select a new image
+        const choice = await (0, dev_environment_cli_1.promptForWordPress)(newestWordPressImage?.tag ?? null);
+        const version = versions.find(({ tag }) => tag.trim() === choice.tag.trim());
+        // Write new data and stage for rebuild
+        // FIXME: version?.tag is possibly null. Should we throw if we can't find a version somehow?
+        envData.wordpress.tag = version?.tag ?? '';
+        envData.wordpress.ref = version?.ref;
+        await updateEnvironment(lando, envData);
+        return true;
+    }
+    if (confirm.upgrade === "no (don't ask anymore)") {
+        const updateCommand = `vip dev-env update --slug=${slug}`;
+        envData.wordpress.doNotUpgrade = true;
+        console.log("We won't ask about upgrading this environment anymore.");
+        console.log(`To manually upgrade please run: ${chalk_1.default.yellow(updateCommand)}`);
+        await updateEnvironment(lando, envData);
+    }
     return false;
-  }
-
-  // Determine if there is an image available for the current WordPress version
-  const match = versions.find(({
-    tag
-  }) => tag === currentWordPressTag);
-
-  // If there is no available image for the currently installed version, give user a path to change
-  if (typeof match === 'undefined') {
-    console.log(`Installed WordPress: ${currentWordPressTag} has no available container image in repository. `);
-    console.log('You must select a new WordPress image to continue... ');
-  } else {
-    console.log('Environment WordPress version is: ' + _chalk.default.yellow(`${match.tag} (${match.ref})`));
-    if (envData.wordpress.doNotUpgrade) {
-      return false;
-    }
-  }
-
-  // Prompt the user to select a new WordPress Version
-  const confirm = await (0, _enquirer.prompt)({
-    type: 'select',
-    name: 'upgrade',
-    message: 'Would you like to upgrade WordPress? ',
-    choices: ['yes', 'no', "no (don't ask anymore)"]
-  });
-
-  // If the user takes the new WP version path
-  if (confirm.upgrade === 'yes') {
-    console.log('Upgrading from: ' + _chalk.default.yellow(currentWordPressTag) + ' to:');
-
-    // Select a new image
-    const choice = await (0, _devEnvironmentCli.promptForWordPress)(newestWordPressImage?.tag ?? null);
-    const version = versions.find(({
-      tag
-    }) => tag.trim() === choice.tag.trim());
-
-    // Write new data and stage for rebuild
-    // FIXME: version?.tag is possibly null. Should we throw if we can't find a version somehow?
-    envData.wordpress.tag = version?.tag ?? '';
-    envData.wordpress.ref = version?.ref;
-    await updateEnvironment(lando, envData);
-    return true;
-  }
-  if (confirm.upgrade === "no (don't ask anymore)") {
-    const updateCommand = `vip dev-env update --slug=${slug}`;
-    envData.wordpress.doNotUpgrade = true;
-    console.log("We won't ask about upgrading this environment anymore.");
-    console.log(`To manually upgrade please run: ${_chalk.default.yellow(updateCommand)}`);
-    await updateEnvironment(lando, envData);
-  }
-  return false;
 }
 async function maybeUpdateVersion(lando, slug) {
-  const envData = readEnvironmentData(slug);
-  const currentVersion = envData.version;
-  console.log('Current local environment version is: ' + _chalk.default.yellow(currentVersion));
-  if (!currentVersion || _semver.default.lt(currentVersion, _devEnvironment.DEV_ENVIRONMENT_VERSION)) {
-    envData.pullAfter = undefined;
-    await updateEnvironment(lando, envData);
-    console.log('Local environment version updated to: ' + _chalk.default.green(_devEnvironment.DEV_ENVIRONMENT_VERSION));
-    return true;
-  }
-  return false;
+    const envData = readEnvironmentData(slug);
+    const currentVersion = envData.version;
+    console.log('Current local environment version is: ' + chalk_1.default.yellow(currentVersion));
+    if (!currentVersion || semver_1.default.lt(currentVersion, dev_environment_1.DEV_ENVIRONMENT_VERSION)) {
+        envData.pullAfter = undefined;
+        await updateEnvironment(lando, envData);
+        console.log('Local environment version updated to: ' + chalk_1.default.green(dev_environment_1.DEV_ENVIRONMENT_VERSION));
+        return true;
+    }
+    return false;
 }
-
 /**
  * Makes a web call to raw.githubusercontent.com
  */
 function fetchVersionList() {
-  const url = `https://${_devEnvironment.DEV_ENVIRONMENT_RAW_GITHUB_HOST}${_devEnvironment.DEV_ENVIRONMENT_WORDPRESS_VERSIONS_URI}`;
-  const proxyDispatcher = (0, _proxyDispatcher.createProxyDispatcher)(url);
-  return (0, _undici.fetch)(url, {
-    dispatcher: proxyDispatcher ?? undefined
-  }).then(res => res.json());
+    const url = `https://${dev_environment_1.DEV_ENVIRONMENT_RAW_GITHUB_HOST}${dev_environment_1.DEV_ENVIRONMENT_WORDPRESS_VERSIONS_URI}`;
+    const proxyDispatcher = (0, proxy_dispatcher_1.createProxyDispatcher)(url);
+    return (0, undici_1.fetch)(url, { dispatcher: proxyDispatcher ?? undefined }).then(res => res.json());
 }
-
 /**
  * Encapsulates the logic for determining if a file is expired by an arbitrary TTL
  *
@@ -730,62 +707,59 @@ function fetchVersionList() {
  * @return {Promise<boolean>} version list expired true/false
  */
 async function isVersionListExpired(cacheFile, ttl) {
-  try {
-    const {
-      mtime: expire
-    } = await _nodeFs.default.promises.stat(cacheFile);
-    expire.setSeconds(expire.getSeconds() + ttl);
-    return Number(new Date()) > Number(expire);
-  } catch (error) {
-    debug(`Error checking version list expiration for cache file ${cacheFile}:`, error);
-    return true;
-  }
+    try {
+        const { mtime: expire } = await node_fs_1.default.promises.stat(cacheFile);
+        expire.setSeconds(expire.getSeconds() + ttl);
+        return Number(new Date()) > Number(expire);
+    }
+    catch (error) {
+        debug(`Error checking version list expiration for cache file ${cacheFile}:`, error);
+        return true;
+    }
 }
-
 /**
  * Uses a cache file to keep the version list in tow until it is ultimately outdated
  */
 async function getVersionList() {
-  let res;
-  const mainEnvironmentPath = (0, _xdgData.xdgData)();
-  const cacheFilePath = _nodePath.default.join(mainEnvironmentPath, 'vip');
-  const cacheFile = _nodePath.default.join(cacheFilePath, _devEnvironment.DEV_ENVIRONMENT_WORDPRESS_CACHE_KEY);
-  // Handle from cache
-  try {
-    // If the path for the cache file doesn't exist, create it
-    if (!_nodeFs.default.existsSync(cacheFilePath)) {
-      await _nodeFs.default.promises.mkdir(cacheFilePath, {
-        recursive: true
-      });
-    }
-
-    // If the cache does not exist or has expired, refresh it
-    if (await isVersionListExpired(cacheFile, _devEnvironment.DEV_ENVIRONMENT_WORDPRESS_VERSION_TTL)) {
-      res = await fetchVersionList();
-      await _nodeFs.default.promises.writeFile(cacheFile, JSON.stringify(res));
-    }
-  } catch (err) {
-    // Soft error handling here, since it's still possible to use a previously cached file.
-    console.log(_chalk.default.yellow('fetchWordPressVersionList failed to retrieve an updated version list'));
-    debug(err);
-  }
-
-  // Try to parse the cached file if it exists.
-  try {
-    const data = await _nodeFs.default.promises.readFile(cacheFile, 'utf8');
-    return JSON.parse(data);
-  } catch (err) {
-    debug(err);
-    return [{
-      ref: 'HEAD',
-      tag: 'trunk',
-      cacheable: false,
-      locked: false,
-      prerelease: true
-    }];
-  }
+    let res;
+    const mainEnvironmentPath = (0, xdg_data_1.xdgData)();
+    const cacheFilePath = node_path_1.default.join(mainEnvironmentPath, 'vip');
+    const cacheFile = node_path_1.default.join(cacheFilePath, dev_environment_1.DEV_ENVIRONMENT_WORDPRESS_CACHE_KEY);
+    // Handle from cache
+    try {
+        // If the path for the cache file doesn't exist, create it
+        if (!node_fs_1.default.existsSync(cacheFilePath)) {
+            await node_fs_1.default.promises.mkdir(cacheFilePath, { recursive: true });
+        }
+        // If the cache does not exist or has expired, refresh it
+        if (await isVersionListExpired(cacheFile, dev_environment_1.DEV_ENVIRONMENT_WORDPRESS_VERSION_TTL)) {
+            res = await fetchVersionList();
+            await node_fs_1.default.promises.writeFile(cacheFile, JSON.stringify(res));
+        }
+    }
+    catch (err) {
+        // Soft error handling here, since it's still possible to use a previously cached file.
+        console.log(chalk_1.default.yellow('fetchWordPressVersionList failed to retrieve an updated version list'));
+        debug(err);
+    }
+    // Try to parse the cached file if it exists.
+    try {
+        const data = await node_fs_1.default.promises.readFile(cacheFile, 'utf8');
+        return JSON.parse(data);
+    }
+    catch (err) {
+        debug(err);
+        return [
+            {
+                ref: 'HEAD',
+                tag: 'trunk',
+                cacheable: false,
+                locked: false,
+                prerelease: true,
+            },
+        ];
+    }
 }
-
 /**
  * Functions generates workspace config including the launch config
  *
@@ -793,73 +767,64 @@ async function getVersionList() {
  * @return {string} Workspace path
  */
 function generateVSCodeWorkspace(slug) {
-  debug('Generating VS Code Workspace');
-  const location = getEnvironmentPath(slug);
-  const workspacePath = getVSCodeWorkspacePath(slug);
-  const instanceData = readEnvironmentData(slug);
-  const pathMappings = generatePathMappings(location, instanceData);
-  const folders = [{
-    path: location
-  }];
-  if (instanceData.muPlugins.dir) {
-    folders.push({
-      path: instanceData.muPlugins.dir
-    });
-  }
-  if (instanceData.appCode.dir) {
-    folders.push({
-      path: instanceData.appCode.dir
-    });
-  }
-
-  // Create debug configuration
-  const debugConfig = {
-    name: `Debug ${slug}`,
-    type: 'php',
-    request: 'launch',
-    port: 9003,
-    pathMappings
-  };
-
-  // Check if running under WSL and add hostname if needed
-  // This is to allow xdebug to work when running under WSL
-  if (process.env?.WSL_DISTRO_NAME) {
-    debug('WSL detected, adding hostname to debug configuration');
-    debugConfig.hostname = '0.0.0.0';
-  }
-  const workspace = {
-    folders,
-    launch: {
-      version: '0.2.0',
-      configurations: [debugConfig]
-    }
-  };
-  _nodeFs.default.writeFileSync(workspacePath, JSON.stringify(workspace, null, 2));
-  return workspacePath;
+    debug('Generating VS Code Workspace');
+    const location = getEnvironmentPath(slug);
+    const workspacePath = getVSCodeWorkspacePath(slug);
+    const instanceData = readEnvironmentData(slug);
+    const pathMappings = generatePathMappings(location, instanceData);
+    const folders = [{ path: location }];
+    if (instanceData.muPlugins.dir) {
+        folders.push({ path: instanceData.muPlugins.dir });
+    }
+    if (instanceData.appCode.dir) {
+        folders.push({ path: instanceData.appCode.dir });
+    }
+    // Create debug configuration
+    const debugConfig = {
+        name: `Debug ${slug}`,
+        type: 'php',
+        request: 'launch',
+        port: 9003,
+        pathMappings,
+    };
+    // Check if running under WSL and add hostname if needed
+    // This is to allow xdebug to work when running under WSL
+    if (process.env?.WSL_DISTRO_NAME) {
+        debug('WSL detected, adding hostname to debug configuration');
+        debugConfig.hostname = '0.0.0.0';
+    }
+    const workspace = {
+        folders,
+        launch: {
+            version: '0.2.0',
+            configurations: [debugConfig],
+        },
+    };
+    node_fs_1.default.writeFileSync(workspacePath, JSON.stringify(workspace, null, 2));
+    return workspacePath;
 }
 const generatePathMappings = (location, instanceData) => {
-  const pathMappings = {};
-  if (instanceData.muPlugins.dir) {
-    pathMappings['/wp/wp-content/mu-plugins'] = instanceData.muPlugins.dir;
-  }
-  if (instanceData.appCode.dir) {
-    pathMappings['/wp/wp-content/client-mu-plugins'] = _nodePath.default.resolve(instanceData.appCode.dir, 'client-mu-plugins');
-    pathMappings['/wp/wp-content/images'] = _nodePath.default.resolve(instanceData.appCode.dir, 'images');
-    pathMappings['/wp/wp-content/languages'] = _nodePath.default.resolve(instanceData.appCode.dir, 'languages');
-    pathMappings['/wp/wp-content/plugins'] = _nodePath.default.resolve(instanceData.appCode.dir, 'plugins');
-    pathMappings['/wp/wp-content/private'] = _nodePath.default.resolve(instanceData.appCode.dir, 'private');
-    pathMappings['/wp/wp-content/themes'] = _nodePath.default.resolve(instanceData.appCode.dir, 'themes');
-    pathMappings['/wp/vip-config'] = _nodePath.default.resolve(instanceData.appCode.dir, 'vip-config');
-  }
-  pathMappings['/wp'] = _nodePath.default.resolve(location, 'wordpress');
-  return pathMappings;
+    const pathMappings = {};
+    if (instanceData.muPlugins.dir) {
+        pathMappings['/wp/wp-content/mu-plugins'] = instanceData.muPlugins.dir;
+    }
+    if (instanceData.appCode.dir) {
+        pathMappings['/wp/wp-content/client-mu-plugins'] = node_path_1.default.resolve(instanceData.appCode.dir, 'client-mu-plugins');
+        pathMappings['/wp/wp-content/images'] = node_path_1.default.resolve(instanceData.appCode.dir, 'images');
+        pathMappings['/wp/wp-content/languages'] = node_path_1.default.resolve(instanceData.appCode.dir, 'languages');
+        pathMappings['/wp/wp-content/plugins'] = node_path_1.default.resolve(instanceData.appCode.dir, 'plugins');
+        pathMappings['/wp/wp-content/private'] = node_path_1.default.resolve(instanceData.appCode.dir, 'private');
+        pathMappings['/wp/wp-content/themes'] = node_path_1.default.resolve(instanceData.appCode.dir, 'themes');
+        pathMappings['/wp/vip-config'] = node_path_1.default.resolve(instanceData.appCode.dir, 'vip-config');
+    }
+    pathMappings['/wp'] = node_path_1.default.resolve(location, 'wordpress');
+    return pathMappings;
 };
 function getVSCodeWorkspacePath(slug) {
-  const location = getEnvironmentPath(slug);
-  const workspacePath = _nodePath.default.join(location, `${slug}.code-workspace`);
-  return workspacePath;
+    const location = getEnvironmentPath(slug);
+    const workspacePath = node_path_1.default.join(location, `${slug}.code-workspace`);
+    return workspacePath;
 }
-
 /**
  * Generates PHPStorm project configuration including debug settings
  *
@@ -867,18 +832,14 @@ function getVSCodeWorkspacePath(slug) {
  * @return {string} Project directory path
  */
 function generatePHPStormWorkspace(slug) {
-  debug('Generating PHPStorm Workspace');
-  const location = getEnvironmentPath(slug);
-  const instanceData = readEnvironmentData(slug);
-  const pathMappings = generatePathMappings(location, instanceData);
-
-  // Create .idea directory
-  _nodeFs.default.mkdirSync(_nodePath.default.join(location, '.idea', 'runConfigurations'), {
-    recursive: true
-  });
-
-  // Generate workspace.xml
-  const workspaceXml = `<?xml version="1.0" encoding="UTF-8"?>
+    debug('Generating PHPStorm Workspace');
+    const location = getEnvironmentPath(slug);
+    const instanceData = readEnvironmentData(slug);
+    const pathMappings = generatePathMappings(location, instanceData);
+    // Create .idea directory
+    node_fs_1.default.mkdirSync(node_path_1.default.join(location, '.idea', 'runConfigurations'), { recursive: true });
+    // Generate workspace.xml
+    const workspaceXml = `<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="PhpWorkspaceProjectConfiguration">
     <include_path>
@@ -893,15 +854,19 @@ ${instanceData?.appCode?.dir ? `<path value="${instanceData.appCode.dir}" />` :
       <server host="localhost" port="9003" />
     </debug_server_list>
     <path_mappings>
-${Object.entries(pathMappings).map(([serverPath, localPath]) => `      <mapping local-root="${serverPath}" remote-root="$PROJECT_DIR$/${_nodePath.default.relative(location, localPath)}" />`).join('\n')}
+${Object.entries(pathMappings)
+        .map(([serverPath, localPath]) => `      <mapping local-root="${serverPath}" remote-root="$PROJECT_DIR$/${node_path_1.default.relative(location, localPath)}" />`)
+        .join('\n')}
     </path_mappings>
   </component>
   <component name="PhpServers">
     <servers>
-      <server host="localhost" id="${(0, _nodeCrypto.randomUUID)()}" name="localhost" use_path_mappings="true">
+      <server host="localhost" id="${(0, node_crypto_1.randomUUID)()}" name="localhost" use_path_mappings="true">
         <path_mappings>
           <mapping local-root="$PROJECT_DIR$/wordpress" remote-root="/wp" />
-          ${Object.entries(pathMappings).map(([serverPath, localPath]) => `<mapping local-root="${localPath}" remote-root="${serverPath}" />`).join('\n')}
+          ${Object.entries(pathMappings)
+        .map(([serverPath, localPath]) => `<mapping local-root="${localPath}" remote-root="${serverPath}" />`)
+        .join('\n')}
         </path_mappings>
       </server>
     </servers>
@@ -910,15 +875,15 @@ ${Object.entries(pathMappings).map(([serverPath, localPath]) => `      <mapping
     <wordpressPath>$PROJECT_DIR$/wordpress</wordpressPath>
   </component>
 </project>`;
-  _nodeFs.default.writeFileSync(_nodePath.default.join(location, '.idea', 'workspace.xml'), workspaceXml);
-  const xdebugXml = `<component name="ProjectRunConfigurationManager">
+    node_fs_1.default.writeFileSync(node_path_1.default.join(location, '.idea', 'workspace.xml'), workspaceXml);
+    const xdebugXml = `<component name="ProjectRunConfigurationManager">
 	<configuration default="false" name="VIP Debug" type="PhpRemoteDebugRunConfigurationType" factoryName="PHP Remote Debug" nameIsGenerated="true" filter_connections="NOT_FILTER" server_name="localhost" session_id="XDEBUG">
 		<method v="2" />
   </configuration>
 </component>
 `;
-  _nodeFs.default.writeFileSync(_nodePath.default.join(location, '.idea', 'runConfigurations', 'vip-xdebug.xml'), xdebugXml);
-  const projectXml = `<?xml version="1.0" encoding="UTF-8"?>
+    node_fs_1.default.writeFileSync(node_path_1.default.join(location, '.idea', 'runConfigurations', 'vip-xdebug.xml'), xdebugXml);
+    const projectXml = `<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
 	<component name="ProjectModuleManager">
 		<modules>
@@ -927,18 +892,18 @@ ${Object.entries(pathMappings).map(([serverPath, localPath]) => `      <mapping
 	</component>
 </project>
 `;
-  _nodeFs.default.writeFileSync(_nodePath.default.join(location, '.idea', 'modules.xml'), projectXml);
-  const modulesXml = `<?xml version="1.0" encoding="UTF-8"?>
+    node_fs_1.default.writeFileSync(node_path_1.default.join(location, '.idea', 'modules.xml'), projectXml);
+    const modulesXml = `<?xml version="1.0" encoding="UTF-8"?>
 	<module type="WEB_MODULE" version="4">
 		<component name="NewModuleRootManager">
-		<content url="file://$MODULE_DIR$/${_nodePath.default.relative(location, instanceData?.appCode?.dir ?? '')}" />
-		<content url="file://$MODULE_DIR$/${_nodePath.default.relative(location, instanceData?.muPlugins?.dir ?? '')}" />
+		<content url="file://$MODULE_DIR$/${node_path_1.default.relative(location, instanceData?.appCode?.dir ?? '')}" />
+		<content url="file://$MODULE_DIR$/${node_path_1.default.relative(location, instanceData?.muPlugins?.dir ?? '')}" />
 			<content url="file://$MODULE_DIR$" />
 			<orderEntry type="sourceFolder" forTests="false" />
 		<orderEntry type="inheritedJdk" />
 		</component>
 </module>
 `;
-  _nodeFs.default.writeFileSync(_nodePath.default.join(location, '.idea', slug + '.iml'), modulesXml);
-  return location;
-}
+    node_fs_1.default.writeFileSync(node_path_1.default.join(location, '.idea', slug + '.iml'), modulesXml);
+    return location;
+}