@automattic/vip 2.21.0 → 2.23.0

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

@@ -3,59 +3,40 @@
 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.getApplicationInformation = getApplicationInformation;
+exports.getEnvironmentPath = getEnvironmentPath;
+exports.getVersionList = getVersionList;
+exports.importMediaPath = importMediaPath;
 exports.printAllEnvironmentsInfo = printAllEnvironmentsInfo;
 exports.printEnvironmentInfo = printEnvironmentInfo;
-exports.exec = exec;
-exports.doesEnvironmentExist = doesEnvironmentExist;
 exports.readEnvironmentData = readEnvironmentData;
-exports.getEnvironmentPath = getEnvironmentPath;
-exports.getApplicationInformation = getApplicationInformation;
 exports.resolveImportPath = resolveImportPath;
-exports.importMediaPath = importMediaPath;
-exports.fetchVersionList = fetchVersionList;
-exports.getVersionList = getVersionList;
-
+exports.startEnvironment = startEnvironment;
+exports.stopEnvironment = stopEnvironment;
+exports.updateEnvironment = updateEnvironment;
 var _debug = _interopRequireDefault(require("debug"));
-
 var _xdgBasedir = _interopRequireDefault(require("xdg-basedir"));
-
 var _nodeFetch = _interopRequireDefault(require("node-fetch"));
-
 var _os = _interopRequireDefault(require("os"));
-
 var _fs = _interopRequireDefault(require("fs"));
-
 var _ejs = _interopRequireDefault(require("ejs"));
-
 var _path = _interopRequireDefault(require("path"));
-
 var _chalk = _interopRequireDefault(require("chalk"));
-
 var _enquirer = require("enquirer");
-
 var _copyDir = _interopRequireDefault(require("copy-dir"));
-
 var _devEnvironmentLando = require("./dev-environment-lando");
-
 var _searchAndReplace = require("../search-and-replace");
-
 var _devEnvironmentCli = require("./dev-environment-cli");
-
 var _app = _interopRequireDefault(require("../api/app"));
-
 var _devEnvironment = require("../constants/dev-environment");
-
 var _software = require("../config/software");
-
 var _userError = _interopRequireDefault(require("../user-error"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * 
  * @format
@@ -68,136 +49,104 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 /**
  * Internal dependencies
  */
-const debug = (0, _debug.default)('@automattic/vip:bin:dev-environment');
 
+const debug = (0, _debug.default)('@automattic/vip:bin:dev-environment');
 const landoFileTemplatePath = _path.default.join(__dirname, '..', '..', '..', 'assets', 'dev-env.lando.template.yml.ejs');
-
 const nginxFileTemplatePath = _path.default.join(__dirname, '..', '..', '..', 'assets', 'dev-env.nginx.template.conf.ejs');
-
 const landoFileName = '.lando.yml';
 const nginxFileName = 'extra.conf';
 const instanceDataFileName = 'instance_data.json';
 const homeDirPathInsideContainers = '/user';
 const uploadPathString = 'uploads';
 const nginxPathString = 'nginx';
-
 async function startEnvironment(slug, options) {
   debug('Will start an environment', slug);
   const instancePath = getEnvironmentPath(slug);
   debug('Instance path for', slug, 'is:', instancePath);
-
   const environmentExists = _fs.default.existsSync(instancePath);
-
   if (!environmentExists) {
     throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
   }
-
   let updated = false;
-
   if (!options.skipWpVersionsCheck) {
     updated = await updateWordPressImage(slug);
   }
-
   if (options.skipRebuild && !updated) {
     await (0, _devEnvironmentLando.landoStart)(instancePath);
   } else {
     await (0, _devEnvironmentLando.landoRebuild)(instancePath);
   }
-
   await printEnvironmentInfo(slug, {
     extended: false
   });
 }
-
 async function stopEnvironment(slug) {
   debug('Will stop an environment', slug);
   const instancePath = getEnvironmentPath(slug);
   debug('Instance path for', slug, 'is:', instancePath);
-
   const environmentExists = _fs.default.existsSync(instancePath);
-
   if (!environmentExists) {
     throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
   }
-
   await (0, _devEnvironmentLando.landoStop)(instancePath);
 }
-
 async function createEnvironment(instanceData) {
   const slug = instanceData.siteSlug;
   debug('Will create an environment', slug, 'with instanceData: ', instanceData);
   const instancePath = getEnvironmentPath(slug);
   debug('Instance path for', slug, 'is:', instancePath);
-
   const alreadyExists = _fs.default.existsSync(instancePath);
-
   if (alreadyExists) {
     throw new Error('Environment already exists.');
   }
-
   const preProcessedInstanceData = preProcessInstanceData(instanceData);
   await prepareLandoEnv(preProcessedInstanceData, instancePath);
 }
-
 async function updateEnvironment(instanceData) {
   const slug = instanceData.siteSlug;
   debug('Will update an environment', slug, 'with instanceData: ', instanceData);
   const instancePath = getEnvironmentPath(slug);
   debug('Instance path for', slug, 'is:', instancePath);
-
   const alreadyExists = _fs.default.existsSync(instancePath);
-
   if (!alreadyExists) {
     throw new Error('Environment doesn\'t exist.');
   }
-
   const preProcessedInstanceData = preProcessInstanceData(instanceData);
   await prepareLandoEnv(preProcessedInstanceData, instancePath);
 }
-
 function preProcessInstanceData(instanceData) {
-  const newInstanceData = { ...instanceData
+  const newInstanceData = {
+    ...instanceData
   };
-
   if (instanceData.mediaRedirectDomain && !instanceData.mediaRedirectDomain.match(/^http/)) {
     // We need to make sure the redirect is an absolute path
     newInstanceData.mediaRedirectDomain = `https://${instanceData.mediaRedirectDomain}`;
   }
-
   newInstanceData.elasticsearch = instanceData.elasticsearch || false;
   newInstanceData.php = instanceData.php || _devEnvironment.DEV_ENVIRONMENT_PHP_VERSIONS.default;
-
   if (newInstanceData.php.startsWith('image:')) {
     newInstanceData.php = newInstanceData.php.slice('image:'.length);
   }
-
   if (!newInstanceData.xdebugConfig) {
     newInstanceData.xdebugConfig = '';
   }
-
   return newInstanceData;
 }
-
 async function destroyEnvironment(slug, removeFiles) {
   debug('Will destroy an environment', slug);
   const instancePath = getEnvironmentPath(slug);
   debug('Instance path for', slug, 'is:', instancePath);
-
   const environmentExists = _fs.default.existsSync(instancePath);
-
   if (!environmentExists) {
     throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
   }
-
   const landoFilePath = _path.default.join(instancePath, landoFileName);
-
   if (_fs.default.existsSync(landoFilePath)) {
     debug('Lando file exists, will lando destroy.');
     await (0, _devEnvironmentLando.landoDestroy)(instancePath);
   } else {
     debug("Lando file doesn't exist, skipping lando destroy.");
   }
-
   if (removeFiles) {
     await _fs.default.promises.rm(instancePath, {
       recursive: true
@@ -205,39 +154,30 @@ async function destroyEnvironment(slug, removeFiles) {
     console.log(`${_chalk.default.green('✓')} Environment files deleted successfully.`);
   }
 }
-
 async function printAllEnvironmentsInfo(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) {
     console.log('\n');
     await printEnvironmentInfo(envName, options);
   }
 }
-
 function parseComponentForInfo(component) {
   if (component.mode === 'local') {
     return component.dir || '';
   }
-
   return component.tag || '[demo-image]';
 }
-
 async function printEnvironmentInfo(slug, options) {
   debug('Will get info for an environment', slug);
   const instancePath = getEnvironmentPath(slug);
   debug('Instance path for', slug, 'is:', instancePath);
-
   const environmentExists = _fs.default.existsSync(instancePath);
-
   if (!environmentExists) {
     throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
   }
-
   const appInfo = await (0, _devEnvironmentLando.landoInfo)(instancePath);
-
   if (options.extended) {
     const environmentData = readEnvironmentData(slug);
     appInfo.title = environmentData.wpTitle;
@@ -246,131 +186,95 @@ async function printEnvironmentInfo(slug, options) {
     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);
 }
-
 async function exec(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 environmentExists = _fs.default.existsSync(instancePath);
-
   if (!environmentExists) {
     throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
   }
-
   const command = args.shift();
   const commandArgs = [...args];
   await (0, _devEnvironmentLando.landoExec)(instancePath, command, commandArgs, options);
 }
-
 function doesEnvironmentExist(slug) {
   debug('Will check for environment', slug);
   const instancePath = getEnvironmentPath(slug);
   debug('Instance path for', slug, 'is:', instancePath);
   return _fs.default.existsSync(instancePath);
 }
-
 function readEnvironmentData(slug) {
   debug('Will try to get instance data for environment', slug);
   const instancePath = getEnvironmentPath(slug);
-
   const instanceDataTargetPath = _path.default.join(instancePath, instanceDataFileName);
-
   const instanceDataString = _fs.default.readFileSync(instanceDataTargetPath, 'utf8');
-
   const instanceData = JSON.parse(instanceDataString);
+
   /**
    ***********************************
    * BACKWARDS COMPATIBILITY SECTION
    ***********************************/
-  // REMOVEME after the wheel of time spins around few times
 
+  // 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
-
+  }
 
+  // REMOVEME after the wheel of time spins around few times
   if (instanceData.clientCode) {
     // clientCode was renamed to appCode
     instanceData.appCode = instanceData.clientCode;
   }
-
   return instanceData;
 }
-
 async function prepareLandoEnv(instanceData, instancePath) {
   const landoFile = await _ejs.default.renderFile(landoFileTemplatePath, instanceData);
   const nginxFile = await _ejs.default.renderFile(nginxFileTemplatePath, instanceData);
   const instanceDataFile = JSON.stringify(instanceData);
-
   const landoFileTargetPath = _path.default.join(instancePath, landoFileName);
-
   const nginxFolderPath = _path.default.join(instancePath, nginxPathString);
-
   const nginxFileTargetPath = _path.default.join(nginxFolderPath, nginxFileName);
-
   const instanceDataTargetPath = _path.default.join(instancePath, instanceDataFileName);
-
-  _fs.default.mkdirSync(instancePath, {
+  await _fs.default.promises.mkdir(instancePath, {
     recursive: true
   });
-
-  _fs.default.mkdirSync(nginxFolderPath, {
+  await _fs.default.promises.mkdir(nginxFolderPath, {
     recursive: true
   });
-
-  _fs.default.writeFileSync(landoFileTargetPath, landoFile);
-
-  _fs.default.writeFileSync(nginxFileTargetPath, nginxFile);
-
-  _fs.default.writeFileSync(instanceDataTargetPath, instanceDataFile);
-
+  await Promise.all([_fs.default.promises.writeFile(landoFileTargetPath, landoFile), _fs.default.promises.writeFile(nginxFileTargetPath, nginxFile), _fs.default.promises.writeFile(instanceDataTargetPath, instanceDataFile)]);
   debug(`Lando file created in ${landoFileTargetPath}`);
   debug(`Nginx file created in ${nginxFileTargetPath}`);
   debug(`Instance data file created in ${instanceDataTargetPath}`);
 }
-
 function getAllEnvironmentNames() {
   const mainEnvironmentPath = _xdgBasedir.default.data || _os.default.tmpdir();
-
   const baseDir = _path.default.join(mainEnvironmentPath, 'vip', 'dev-environment');
-
   const doWeHaveAnyEnvironment = _fs.default.existsSync(baseDir);
-
   let envNames = [];
-
   if (doWeHaveAnyEnvironment) {
     const files = _fs.default.readdirSync(baseDir);
-
     envNames = files.filter(file => {
       const fullPath = _path.default.join(baseDir, file);
-
       return _fs.default.lstatSync(fullPath).isDirectory();
     });
   }
-
   return envNames;
 }
-
 function getEnvironmentPath(name) {
   if (!name) {
     throw new Error('Name was not provided');
   }
-
   const mainEnvironmentPath = _xdgBasedir.default.data || _os.default.tmpdir();
-
   return _path.default.join(mainEnvironmentPath, 'vip', 'dev-environment', name + '');
 }
-
 async function getApplicationInformation(appId, envType) {
   // $FlowFixMe: gql template is not supported by flow
   const fieldsQuery = `
@@ -400,16 +304,13 @@ async function getApplicationInformation(appId, envType) {
 		}`;
   const queryResult = await (0, _app.default)(appId, fieldsQuery, _software.appQueryFragments);
   const appData = {};
-
   if (queryResult) {
     var _queryResult$reposito;
-
     appData.id = queryResult.id;
     appData.name = queryResult.name;
     appData.repository = (_queryResult$reposito = queryResult.repository) === null || _queryResult$reposito === void 0 ? void 0 : _queryResult$reposito.htmlUrl;
     const environments = queryResult.environments || [];
     let envData;
-
     if (envType) {
       envData = environments.find(candidateEnv => candidateEnv.type === envType);
     } else if (1 === environments.length) {
@@ -426,10 +327,8 @@ async function getApplicationInformation(appId, envType) {
       });
       envData = environments.find(candidateEnv => candidateEnv.type === env);
     }
-
     if (envData) {
       var _envData$primaryDomai, _envData$softwareSett, _envData$softwareSett2, _envData$softwareSett3, _envData$softwareSett4, _envData$softwareSett5, _envData$softwareSett6;
-
       appData.environment = {
         name: envData.name,
         branch: envData.branch,
@@ -441,24 +340,26 @@ async function getApplicationInformation(appId, envType) {
       };
     }
   }
-
   return appData;
 }
-
 async function resolveImportPath(slug, fileName, searchReplace, inPlace) {
   debug(`Will try to resolve path - ${fileName}`);
   let resolvedPath = (0, _devEnvironmentCli.resolvePath)(fileName);
+  const instancePath = getEnvironmentPath(slug);
+  debug(`Instance path for ${slug} is ${instancePath}`);
+  const environmentExists = _fs.default.existsSync(instancePath);
+  if (!environmentExists) {
+    throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
+  }
   debug(`Filename ${fileName} resolved to ${resolvedPath}`);
-
   if (!_fs.default.existsSync(resolvedPath)) {
     throw new _userError.default(`The provided file ${resolvedPath} does not exist or it is not valid (see "--help" for examples)`);
   }
-
   if (_fs.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
-
+  }
 
+  // Run Search and Replace if the --search-replace flag was provided
   if (searchReplace && searchReplace.length) {
     const {
       outputFileName
@@ -467,71 +368,53 @@ async function resolveImportPath(slug, fileName, searchReplace, inPlace) {
       output: true,
       inPlace
     });
-
     if (typeof outputFileName !== 'string') {
       throw new Error('Unable to determine location of the intermediate search & replace file.');
     }
-
-    const environmentPath = getEnvironmentPath(slug);
-
     const baseName = _path.default.basename(outputFileName);
-
-    resolvedPath = _path.default.join(environmentPath, baseName);
-
+    resolvedPath = _path.default.join(instancePath, baseName);
     _fs.default.renameSync(outputFileName, resolvedPath);
   }
+
   /**
    * Docker container does not have acces to the host filesystem.
    * However lando maps os.homedir() to /user in the container. So if we replace the path in the same way
    * in the Docker container will get the file from within the mapped volume under /user.
    */
-
-
   let inContainerPath = resolvedPath.replace(_os.default.homedir(), homeDirPathInsideContainers);
-
   if (_path.default.sep === '\\') {
     // Because the file path generated for windows will have \ instead of / we need to replace that as well so that the path inside the container (unix) still works.
     inContainerPath = inContainerPath.replace(/\\/g, '/');
   }
-
   debug(`Import file path ${resolvedPath} will be mapped to ${inContainerPath}`);
   return {
     resolvedPath,
     inContainerPath
   };
 }
-
 async function importMediaPath(slug, filePath) {
   const resolvedPath = (0, _devEnvironmentCli.resolvePath)(filePath);
-
   if (!_fs.default.existsSync(resolvedPath) || !_fs.default.lstatSync(resolvedPath).isDirectory()) {
     throw new Error('The provided path does not exist or it is not valid (see "--help" for examples)');
   }
-
   const files = _fs.default.readdirSync(resolvedPath);
-
   if (files.indexOf(uploadPathString) > -1) {
     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 environmentPath = getEnvironmentPath(slug);
-
   const uploadsPath = _path.default.join(environmentPath, uploadPathString);
-
   console.log(`${_chalk.default.yellow('-')} Started copying files`);
-
   _copyDir.default.sync(resolvedPath, uploadsPath);
-
   console.log(`${_chalk.default.green('✓')} Files successfully copied to ${uploadsPath}.`);
 }
+
 /**
  * Uses the WordPress versions manifest on github.com
  * Informs the user several things:
@@ -542,12 +425,11 @@ async function importMediaPath(slug, filePath) {
  * @param  {Object=} slug slug
  * @return {boolean} boolean
  */
-
-
 async function updateWordPressImage(slug) {
   const versions = await getVersionList();
-  let message, envData, currentWordPressTag; // Get the current environment configuration
+  let message, envData, currentWordPressTag;
 
+  // Get the current environment configuration
   try {
     envData = readEnvironmentData(slug);
     currentWordPressTag = envData.wordpress.tag;
@@ -559,131 +441,128 @@ async function updateWordPressImage(slug) {
     } else {
       message = `An error prevented reading the configuration of: ${slug}\n\n ${error}`;
     }
-
     (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
+  // 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.
+  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! ');
     return false;
-  } // Determine if there is an image available for the current WordPress version
-
+  }
 
+  // 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
+  }) => 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 || false) {
+    if (envData.wordpress.doNotUpgrade) {
       return false;
     }
-  } // Prompt the user to select a new WordPress Version
-
+  }
 
+  // Prompt the user to select a new WordPress Version
   const confirm = await (0, _enquirer.prompt)({
     type: 'select',
     name: 'upgrade',
     message: 'Would You like to change the WordPress version? ',
     choices: ['yes', 'no', "no (don't ask anymore)"]
-  }); // If the user takes the new WP version path
+  });
 
+  // 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
+    console.log('Upgrading from: ' + _chalk.default.yellow(currentWordPressTag) + ' to:');
 
-    const choice = await (0, _devEnvironmentCli.promptForComponent)('wordpress');
+    // Select a new image
+    const choice = await (0, _devEnvironmentCli.promptForComponent)('wordpress', false, null);
     const version = versions.find(({
       tag
-    }) => tag.trim() === choice.tag.trim()); // Write new data and stage for rebuild
+    }) => tag.trim() === choice.tag.trim());
 
+    // Write new data and stage for rebuild
     envData.wordpress.tag = version.tag;
     envData.wordpress.ref = version.ref;
     await updateEnvironment(envData);
     return true;
   }
-
   if (confirm.upgrade === "no (don't ask anymore)") {
     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(`vip dev-env update --slug=${slug}`)}`);
     await updateEnvironment(envData);
   }
-
   return false;
 }
+
 /**
  * Makes a web call to raw.githubusercontent.com
  */
-
-
 async function fetchVersionList() {
   const url = `https://${_devEnvironment.DEV_ENVIRONMENT_RAW_GITHUB_HOST}${_devEnvironment.DEV_ENVIRONMENT_WORDPRESS_VERSIONS_URI}`;
   return (0, _nodeFetch.default)(url).then(res => res.text());
 }
+
 /**
  * Encapsulates the logic for determining if a file is expired by an arbitrary TTL
  * @param  {string} cacheFile uri of cache file
  * @param  {number} ttl time to live in seconds
  * @returns {boolean} version list expired true/false
  */
-
-
 function isVersionListExpired(cacheFile, ttl) {
   const stats = _fs.default.statSync(cacheFile);
-
   const expire = new Date(stats.mtime);
   expire.setSeconds(expire.getSeconds() + ttl);
   return +new Date() > expire;
 }
+
 /**
  * Uses a cache file to keep the version list in tow until it is ultimately outdated
  */
-
-
 async function getVersionList() {
   let res;
-
   const mainEnvironmentPath = _xdgBasedir.default.data || _os.default.tmpdir();
-
-  const cacheFile = _path.default.join(mainEnvironmentPath, 'vip', _devEnvironment.DEV_ENVIRONMENT_WORDPRESS_CACHE_KEY); // Handle from cache
-
-
+  const cacheFilePath = _path.default.join(mainEnvironmentPath, 'vip');
+  const cacheFile = _path.default.join(cacheFilePath, _devEnvironment.DEV_ENVIRONMENT_WORDPRESS_CACHE_KEY);
+  // Handle from cache
   try {
-    // If the cache doesn't exist, create it
-    if (!_fs.default.existsSync(cacheFile)) {
-      res = await fetchVersionList();
-
-      _fs.default.writeFileSync(cacheFile, res);
-    } // If the cache is expired, refresh it
-
+    // If the path for the cache file doesn't exist, create it
+    if (!_fs.default.existsSync(cacheFilePath)) {
+      await _fs.default.promises.mkdir(cacheFilePath, {
+        recursive: true
+      });
+    }
 
-    if (isVersionListExpired(cacheFile, _devEnvironment.DEV_ENVIRONMENT_WORDPRESS_VERSION_TTL)) {
+    // If the cache doesn't exist, create it
+    // If the cache is expired, refresh it
+    if (!_fs.default.existsSync(cacheFile) || isVersionListExpired(cacheFile, _devEnvironment.DEV_ENVIRONMENT_WORDPRESS_VERSION_TTL)) {
       res = await fetchVersionList();
-
-      _fs.default.writeFileSync(cacheFile, res);
+      await _fs.default.promises.writeFile(cacheFile, 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 to parse the cached file if it exists.
   try {
-    return JSON.parse(_fs.default.readFileSync(cacheFile));
+    const data = await _fs.default.promises.readFile(cacheFile, 'utf8');
+    return JSON.parse(data);
   } catch (err) {
     debug(err);
     return [];