@automattic/vip 2.33.0-dev1 → 2.33.0

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;
     }