@automattic/vip 2.32.4 → 2.33.0

package/dist/lib/cli/format.js

@@ -7,7 +7,9 @@ exports.RunningSprite = exports.RUNNING_SPRITE_GLYPHS = void 0;
 exports.capitalize = capitalize;
 exports.formatBytes = void 0;
 exports.formatData = formatData;
+exports.formatDuration = formatDuration;
 exports.formatEnvironment = formatEnvironment;
+exports.formatMetricBytes = void 0;
 exports.formatSearchReplaceValues = formatSearchReplaceValues;
 exports.getGlyphForStatus = getGlyphForStatus;
 exports.isJson = isJson;
@@ -185,14 +187,56 @@ function formatSearchReplaceValues(values, message) {
 }
 
 // Format bytes into kilobytes, megabytes, etc based on the size
-const formatBytes = (bytes, decimals = 2) => {
+// for historical reasons, this uses KB instead of KiB, MB instead of MiB and so on.
+const formatBytes = (bytes, decimals = 2, bytesMultiplier = 1024, sizes = ['bytes', 'KB', 'MB', 'GB', 'TB']) => {
   if (0 === bytes) {
     return '0 Bytes';
   }
-  const bytesMultiplier = 1024;
   const dm = decimals < 0 ? 0 : decimals;
-  const sizes = ['bytes', 'KB', 'MB', 'GB', 'TB'];
   const idx = Math.floor(Math.log(bytes) / Math.log(bytesMultiplier));
   return `${parseFloat((bytes / Math.pow(bytesMultiplier, idx)).toFixed(dm))} ${sizes[idx]}`;
 };
-exports.formatBytes = formatBytes;
+
+/**
+ * Format bytes in powers of 1000, based on the size
+ * This is how it's displayed on Macs
+ */
+exports.formatBytes = formatBytes;
+const formatMetricBytes = (bytes, decimals = 2) => {
+  return formatBytes(bytes, decimals, 1000);
+};
+
+/*
+ * Get the duration between two dates
+ *
+ * @param {Date} from The start date
+ * @param {Date} to  The end date
+ * @returns {string} The duration between the two dates
+ */
+exports.formatMetricBytes = formatMetricBytes;
+function formatDuration(from, to) {
+  const millisecondsPerSecond = 1000;
+  const millisecondsPerMinute = 60 * millisecondsPerSecond;
+  const millisecondsPerHour = 60 * millisecondsPerMinute;
+  const millisecondsPerDay = 24 * millisecondsPerHour;
+  const duration = to.getTime() - from.getTime();
+  if (duration < 1000) return '0 second';
+  const days = Math.floor(duration / millisecondsPerDay);
+  const hours = Math.floor(duration % millisecondsPerDay / millisecondsPerHour);
+  const minutes = Math.floor(duration % millisecondsPerHour / millisecondsPerMinute);
+  const seconds = Math.floor(duration % millisecondsPerMinute / millisecondsPerSecond);
+  let durationString = '';
+  if (days > 0) {
+    durationString += `${days} day${days > 1 ? 's' : ''} `;
+  }
+  if (hours > 0) {
+    durationString += `${hours} hour${hours > 1 ? 's' : ''} `;
+  }
+  if (minutes > 0) {
+    durationString += `${minutes} minute${minutes > 1 ? 's' : ''} `;
+  }
+  if (seconds > 0) {
+    durationString += `${seconds} second${seconds > 1 ? 's' : ''}`;
+  }
+  return durationString.trim();
+}

package/dist/lib/cli/progress.js

@@ -3,9 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.ProgressTracker = void 0;
+exports.StepStatus = exports.ProgressTracker = void 0;
 var _singleLineLog = require("single-line-log");
 var _format = require("../../lib/cli/format");
+var _os = _interopRequireDefault(require("os"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // @format
 
 /**
@@ -17,7 +19,17 @@ var _format = require("../../lib/cli/format");
  */
 
 const PRINT_INTERVAL = process.env.DEBUG ? 5000 : 200; // How often the report is printed. Mainly affects the "spinner" animation.
-const COMPLETED_STEP_SLUGS = ['success', 'skipped'];
+let StepStatus = /*#__PURE__*/function (StepStatus) {
+  StepStatus["PENDING"] = "pending";
+  StepStatus["RUNNING"] = "running";
+  StepStatus["SUCCESS"] = "success";
+  StepStatus["FAILED"] = "failed";
+  StepStatus["UNKNOWN"] = "unknown";
+  StepStatus["SKIPPED"] = "skipped";
+  return StepStatus;
+}({});
+exports.StepStatus = StepStatus;
+const COMPLETED_STEP_SLUGS = [StepStatus.SUCCESS, StepStatus.SKIPPED];
 class ProgressTracker {
   // Track the state of each step
 
@@ -27,6 +39,14 @@ class ProgressTracker {
 
   // This gets printed after the step status
 
+  /**
+   * This determines from which step should we display the steps
+   *
+   * Useful when you want to display a prompt.
+   *
+   * And we don't want to repeatedly display the steps that has finished.
+   */
+  displayFromStep = 0;
   constructor(steps) {
     this.runningSprite = new _format.RunningSprite();
     this.hasFailure = false;
@@ -48,7 +68,7 @@ class ProgressTracker {
       map.set(id, {
         id,
         name,
-        status: status || 'pending'
+        status: status || StepStatus.PENDING
       });
       return map;
     }, new Map());
@@ -90,7 +110,7 @@ class ProgressTracker {
       }) => status === 'pending');
       if (firstPendingStepIndex !== -1) {
         // "Promote" the first "pending" to "running"
-        formattedSteps[firstPendingStepIndex].status = 'running';
+        formattedSteps[firstPendingStepIndex].status = StepStatus.RUNNING;
       }
     }
     this.stepsFromServer = this.mapSteps(formattedSteps);
@@ -114,16 +134,16 @@ class ProgressTracker {
     }) => status === 'running');
   }
   stepRunning(stepId) {
-    this.setStatusForStepId(stepId, 'running');
+    this.setStatusForStepId(stepId, StepStatus.RUNNING);
   }
   stepFailed(stepId) {
-    this.setStatusForStepId(stepId, 'failed');
+    this.setStatusForStepId(stepId, StepStatus.FAILED);
   }
   stepSkipped(stepId) {
-    this.setStatusForStepId(stepId, 'skipped');
+    this.setStatusForStepId(stepId, StepStatus.SKIPPED);
   }
   stepSuccess(stepId) {
-    this.setStatusForStepId(stepId, 'success');
+    this.setStatusForStepId(stepId, StepStatus.SUCCESS);
     // The stepSuccess helper automatically sets the next step to "running"
     const nextStep = this.getNextStep();
     if (nextStep) {
@@ -163,6 +183,32 @@ class ProgressTracker {
       clearInterval(this.printInterval);
     }
   }
+  async handleContinuePrompt(prompt) {
+    this.print();
+    this.stopPrinting();
+    const returnValue = await prompt();
+    this.displayFromStep = [...this.getSteps().values()].findIndex(step => step.status === StepStatus.RUNNING);
+    let hasPrintedOnce = false;
+    const printingStartedPromise = new Promise(resolve => {
+      this.startPrinting(() => {
+        if (hasPrintedOnce) {
+          return;
+        }
+
+        // this is so that we leave some room for the progress tracker to refresh
+        // without this, any prompt, or any text in between will get overwritten by the progress tracker
+        let linesToSkip = '';
+        for (let iteration = 0; iteration < this.stepsFromCaller.size; iteration++) {
+          linesToSkip += _os.default.EOL;
+        }
+        process.stdout.write(linesToSkip);
+        hasPrintedOnce = true;
+        resolve();
+      });
+    });
+    await printingStartedPromise;
+    return returnValue;
+  }
   print({
     clearAfter = false
   } = {}) {
@@ -177,7 +223,10 @@ class ProgressTracker {
       percentage,
       status,
       progress
-    }) => {
+    }, stepNumber) => {
+      if (stepNumber < this.displayFromStep) {
+        return accumulator;
+      }
       const statusIcon = (0, _format.getGlyphForStatus)(status, this.runningSprite);
       let suffix = '';
       if (id === 'upload') {

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

@@ -24,13 +24,13 @@ exports.startEnvironment = startEnvironment;
 exports.stopEnvironment = stopEnvironment;
 exports.updateEnvironment = updateEnvironment;
 exports.writeEnvironmentData = writeEnvironmentData;
+var _nodeOs = _interopRequireDefault(require("node:os"));
+var _nodeFs = _interopRequireDefault(require("node:fs"));
+var _nodePath = _interopRequireDefault(require("node:path"));
 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"));
@@ -43,6 +43,7 @@ var _app = _interopRequireDefault(require("../api/app"));
 var _devEnvironment = require("../constants/dev-environment");
 var _software = require("../config/software");
 var _userError = _interopRequireDefault(require("../user-error"));
+var _proxyAgent = require("../http/proxy-agent");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
  * External dependencies
@@ -53,8 +54,8 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  */
 
 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 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');
 const landoFileName = '.lando.yml';
 const landoBackupFileName = '.lando.backup.yml';
 const nginxFileName = 'extra.conf';
@@ -63,13 +64,13 @@ const uploadPathString = 'uploads';
 const nginxPathString = 'nginx';
 function xdgDataDirectory() {
   var _xdgBasedir$data;
-  return (_xdgBasedir$data = _xdgBasedir.default.data) !== null && _xdgBasedir$data !== void 0 && _xdgBasedir$data.length ? _xdgBasedir.default.data : _os.default.tmpdir();
+  return (_xdgBasedir$data = _xdgBasedir.default.data) !== null && _xdgBasedir$data !== void 0 && _xdgBasedir$data.length ? _xdgBasedir.default.data : _nodeOs.default.tmpdir();
 }
 async function startEnvironment(lando, 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);
+  const environmentExists = _nodeFs.default.existsSync(instancePath);
   if (!environmentExists) {
     throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
   }
@@ -91,7 +92,7 @@ async function stopEnvironment(lando, slug) {
   debug('Will stop an environment', slug);
   const instancePath = getEnvironmentPath(slug);
   debug('Instance path for', slug, 'is:', instancePath);
-  const environmentExists = _fs.default.existsSync(instancePath);
+  const environmentExists = _nodeFs.default.existsSync(instancePath);
   if (!environmentExists) {
     throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
   }
@@ -102,7 +103,7 @@ async function createEnvironment(instanceData) {
   debug('Will process an environment', slug, 'with instanceData for creation: ', instanceData);
   const instancePath = getEnvironmentPath(slug);
   debug('Instance path for', slug, 'is:', instancePath);
-  const alreadyExists = _fs.default.existsSync(instancePath);
+  const alreadyExists = _nodeFs.default.existsSync(instancePath);
   if (alreadyExists) {
     throw new Error('Environment already exists.');
   }
@@ -115,7 +116,7 @@ async function updateEnvironment(instanceData) {
   debug('Will process an environment', slug, 'with instanceData for updating: ', instanceData);
   const instancePath = getEnvironmentPath(slug);
   debug('Instance path for', slug, 'is:', instancePath);
-  const alreadyExists = _fs.default.existsSync(instancePath);
+  const alreadyExists = _nodeFs.default.existsSync(instancePath);
   if (!alreadyExists) {
     throw new Error("Environment doesn't exist.");
   }
@@ -180,15 +181,15 @@ async function destroyEnvironment(lando, slug, removeFiles) {
   if (!environmentExists) {
     throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
   }
-  const landoFilePath = _path.default.join(instancePath, landoFileName);
-  if (_fs.default.existsSync(landoFilePath)) {
+  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.");
   }
   if (removeFiles) {
-    await _fs.default.promises.rm(instancePath, {
+    await _nodeFs.default.promises.rm(instancePath, {
       recursive: true
     });
     console.log(`${_chalk.default.green('✓')} Environment files deleted successfully.`);
@@ -265,9 +266,9 @@ function exec(lando, slug, args, options = {}) {
 }
 async function doesEnvironmentExist(instancePath) {
   debug('Will check for environment at', instancePath);
-  const file = _path.default.join(instancePath, instanceDataFileName);
+  const file = _nodePath.default.join(instancePath, instanceDataFileName);
   try {
-    const stats = await _fs.default.promises.stat(file);
+    const stats = await _nodeFs.default.promises.stat(file);
     return stats.isFile();
   } catch (err) {
     return false;
@@ -276,11 +277,11 @@ async function doesEnvironmentExist(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 instanceDataTargetPath = _nodePath.default.join(instancePath, instanceDataFileName);
   let instanceDataString;
   let instanceData;
   try {
-    instanceDataString = _fs.default.readFileSync(instanceDataTargetPath, 'utf8');
+    instanceDataString = _nodeFs.default.readFileSync(instanceDataTargetPath, 'utf8');
   } catch (error) {
     const err = error;
     throw new _userError.default(`There was an error reading file "${instanceDataTargetPath}": ${err.message}.`);
@@ -326,44 +327,44 @@ function readEnvironmentData(slug) {
 function writeEnvironmentData(slug, data) {
   debug('Will try to write instance data for environment', slug);
   const instancePath = getEnvironmentPath(slug);
-  const instanceDataTargetPath = _path.default.join(instancePath, instanceDataFileName);
-  return _fs.default.promises.writeFile(instanceDataTargetPath, JSON.stringify(data, null, 2));
+  const instanceDataTargetPath = _nodePath.default.join(instancePath, instanceDataFileName);
+  return _nodeFs.default.promises.writeFile(instanceDataTargetPath, JSON.stringify(data, null, 2));
 }
 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 landoBackupFileTargetPath = _path.default.join(instancePath, landoBackupFileName);
-  const nginxFolderPath = _path.default.join(instancePath, nginxPathString);
-  const nginxFileTargetPath = _path.default.join(nginxFolderPath, nginxFileName);
-  const instanceDataTargetPath = _path.default.join(instancePath, instanceDataFileName);
-  await _fs.default.promises.mkdir(instancePath, {
+  const landoFileTargetPath = _nodePath.default.join(instancePath, landoFileName);
+  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);
+  await _nodeFs.default.promises.mkdir(instancePath, {
     recursive: true
   });
-  await _fs.default.promises.mkdir(nginxFolderPath, {
+  await _nodeFs.default.promises.mkdir(nginxFolderPath, {
     recursive: true
   });
-  const landoFileExists = await _fs.default.promises.stat(landoFileTargetPath).catch(() => false);
+  const landoFileExists = await _nodeFs.default.promises.stat(landoFileTargetPath).catch(() => false);
   if (landoFileExists) {
-    await _fs.default.promises.copyFile(landoFileTargetPath, landoBackupFileTargetPath);
+    await _nodeFs.default.promises.copyFile(landoFileTargetPath, landoBackupFileTargetPath);
     console.log(`Backup of ${landoFileName} was created in ${landoBackupFileTargetPath}`);
   }
-  await Promise.all([_fs.default.promises.writeFile(landoFileTargetPath, landoFile), _fs.default.promises.writeFile(nginxFileTargetPath, nginxFile), _fs.default.promises.writeFile(instanceDataTargetPath, instanceDataFile)]);
+  await Promise.all([_nodeFs.default.promises.writeFile(landoFileTargetPath, landoFile), _nodeFs.default.promises.writeFile(nginxFileTargetPath, nginxFile), _nodeFs.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 = xdgDataDirectory();
-  const baseDir = _path.default.join(mainEnvironmentPath, 'vip', 'dev-environment');
-  const doWeHaveAnyEnvironment = _fs.default.existsSync(baseDir);
+  const baseDir = _nodePath.default.join(mainEnvironmentPath, 'vip', 'dev-environment');
+  const doWeHaveAnyEnvironment = _nodeFs.default.existsSync(baseDir);
   let envNames = [];
   if (doWeHaveAnyEnvironment) {
-    const files = _fs.default.readdirSync(baseDir);
+    const files = _nodeFs.default.readdirSync(baseDir);
     envNames = files.filter(file => {
-      const fullPath = _path.default.join(baseDir, file);
-      return _fs.default.lstatSync(fullPath).isDirectory();
+      const fullPath = _nodePath.default.join(baseDir, file);
+      return _nodeFs.default.lstatSync(fullPath).isDirectory();
     });
   }
   return envNames;
@@ -373,7 +374,7 @@ function getEnvironmentPath(name) {
     throw new Error('Name was not provided');
   }
   const mainEnvironmentPath = xdgDataDirectory();
-  return _path.default.join(mainEnvironmentPath, 'vip', 'dev-environment', name + '');
+  return _nodePath.default.join(mainEnvironmentPath, 'vip', 'dev-environment', name + '');
 }
 async function getApplicationInformation(appId, envType) {
   // $FlowFixMe: gql template is not supported by flow
@@ -448,10 +449,10 @@ 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 (!_fs.default.existsSync(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 (_fs.default.lstatSync(resolvedPath).isDirectory()) {
+  if (_nodeFs.default.lstatSync(resolvedPath).isDirectory()) {
     throw new _userError.default(`The provided file ${resolvedPath} is a directory. Please point to a sql file.`);
   }
 
@@ -473,14 +474,14 @@ async function resolveImportPath(slug, fileName, searchReplace, inPlace) {
 }
 async function importMediaPath(slug, filePath) {
   const resolvedPath = (0, _devEnvironmentCli.resolvePath)(filePath);
-  if (!_fs.default.existsSync(resolvedPath) || !_fs.default.lstatSync(resolvedPath).isDirectory()) {
+  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 = _fs.default.readdirSync(resolvedPath);
+  const files = _nodeFs.default.readdirSync(resolvedPath);
   if (files.includes(uploadPathString)) {
     const confirm = await (0, _enquirer.prompt)({
       type: 'confirm',
@@ -491,7 +492,7 @@ async function importMediaPath(slug, filePath) {
       return;
     }
   }
-  const uploadsPath = _path.default.join(environmentPath, uploadPathString);
+  const uploadsPath = _nodePath.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}.`);
@@ -617,7 +618,10 @@ async function maybeUpdateVersion(slug) {
  */
 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.json());
+  const proxyAgent = (0, _proxyAgent.createProxyAgent)(url);
+  return (0, _nodeFetch.default)(url, {
+    agent: proxyAgent ?? undefined
+  }).then(res => res.json());
 }
 
 /**
@@ -631,7 +635,7 @@ async function isVersionListExpired(cacheFile, ttl) {
   try {
     const {
       mtime: expire
-    } = await _fs.default.promises.stat(cacheFile);
+    } = await _nodeFs.default.promises.stat(cacheFile);
     expire.setSeconds(expire.getSeconds() + ttl);
     return +new Date() > +expire;
   } catch (err) {
@@ -645,13 +649,13 @@ async function isVersionListExpired(cacheFile, ttl) {
 async function getVersionList() {
   let res;
   const mainEnvironmentPath = xdgDataDirectory();
-  const cacheFilePath = _path.default.join(mainEnvironmentPath, 'vip');
-  const cacheFile = _path.default.join(cacheFilePath, _devEnvironment.DEV_ENVIRONMENT_WORDPRESS_CACHE_KEY);
+  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 (!_fs.default.existsSync(cacheFilePath)) {
-      await _fs.default.promises.mkdir(cacheFilePath, {
+    if (!_nodeFs.default.existsSync(cacheFilePath)) {
+      await _nodeFs.default.promises.mkdir(cacheFilePath, {
         recursive: true
       });
     }
@@ -659,7 +663,7 @@ async function getVersionList() {
     // 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 _fs.default.promises.writeFile(cacheFile, JSON.stringify(res));
+      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.
@@ -669,7 +673,7 @@ async function getVersionList() {
 
   // Try to parse the cached file if it exists.
   try {
-    const data = await _fs.default.promises.readFile(cacheFile, 'utf8');
+    const data = await _nodeFs.default.promises.readFile(cacheFile, 'utf8');
     return JSON.parse(data);
   } catch (err) {
     debug(err);
@@ -721,7 +725,7 @@ function generateVSCodeWorkspace(slug) {
       }]
     }
   };
-  _fs.default.writeFileSync(workspacePath, JSON.stringify(workspace, null, 2));
+  _nodeFs.default.writeFileSync(workspacePath, JSON.stringify(workspace, null, 2));
   return workspacePath;
 }
 const generatePathMappings = (location, instanceData) => {
@@ -730,19 +734,19 @@ const generatePathMappings = (location, instanceData) => {
     pathMappings['/wp/wp-content/mu-plugins'] = instanceData.muPlugins.dir;
   }
   if (instanceData.appCode.dir) {
-    pathMappings['/wp/wp-content/client-mu-plugins'] = _path.default.resolve(instanceData.appCode.dir, 'client-mu-plugins');
-    pathMappings['/wp/wp-content/images'] = _path.default.resolve(instanceData.appCode.dir, 'images');
-    pathMappings['/wp/wp-content/languages'] = _path.default.resolve(instanceData.appCode.dir, 'languages');
-    pathMappings['/wp/wp-content/plugins'] = _path.default.resolve(instanceData.appCode.dir, 'plugins');
-    pathMappings['/wp/wp-content/private'] = _path.default.resolve(instanceData.appCode.dir, 'private');
-    pathMappings['/wp/wp-content/themes'] = _path.default.resolve(instanceData.appCode.dir, 'themes');
-    pathMappings['/wp/wp-content/vip-config'] = _path.default.resolve(instanceData.appCode.dir, 'vip-config');
-  }
-  pathMappings['/wp'] = _path.default.resolve(location, 'wordpress');
+    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/wp-content/vip-config'] = _nodePath.default.resolve(instanceData.appCode.dir, 'vip-config');
+  }
+  pathMappings['/wp'] = _nodePath.default.resolve(location, 'wordpress');
   return pathMappings;
 };
 function getVSCodeWorkspacePath(slug) {
   const location = getEnvironmentPath(slug);
-  const workspacePath = _path.default.join(location, `${slug}.code-workspace`);
+  const workspacePath = _nodePath.default.join(location, `${slug}.code-workspace`);
   return workspacePath;
 }

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

@@ -366,9 +366,14 @@ async function getExtraServicesConnections(lando, app) {
   const allServices = await lando.engine.list({
     project: app.project
   });
+  const defaultDisplayConfiguration = {
+    skip: false,
+    label: null,
+    protocol: null
+  };
   for (const service of allServices) {
-    const displayConfiguration = extraServiceDisplayConfiguration.find(conf => conf.name === service.service);
-    if (!displayConfiguration || displayConfiguration.skip) {
+    const displayConfiguration = extraServiceDisplayConfiguration.find(conf => conf.name === service.service) ?? defaultDisplayConfiguration;
+    if (displayConfiguration.skip) {
       continue;
     }
 
@@ -398,7 +403,7 @@ async function checkEnvHealth(lando, instancePath) {
       urls[url] = service.service;
     });
   });
-  const urlsToScan = Object.keys(urls);
+  const urlsToScan = Object.keys(urls).filter(url => !url.includes('*'));
   let scanResults = [];
   if (Array.isArray(app.urls)) {
     scanResults = app.urls;