@automattic/vip 2.28.0-dev7 → 2.28.0

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

@@ -30,6 +30,7 @@ var _dns = _interopRequireDefault(require("dns"));
 var _xdgBasedir = _interopRequireDefault(require("xdg-basedir"));
 var _devEnvironmentCore = require("./dev-environment-core");
 var _devEnvironment = require("../constants/dev-environment");
+var _dockerUtils = require("./docker-utils");
 var _userError = _interopRequireDefault(require("../user-error"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // @format
@@ -83,13 +84,7 @@ async function getLandoConfig() {
       subdir: '.',
       namespace: '@lando'
     }],
-    disablePlugins: [
-    // Plugins we need:
-    // '@lando/compose',
-    // '@lando/mailhog',
-    // '@lando/phpmyadmin',
-    // The rest we don't need
-    '@lando/acquia', '@lando/apache', '@lando/argv', '@lando/backdrop', '@lando/dotnet', '@lando/drupal', '@lando/elasticsearch', '@lando/go', '@lando/joomla', '@lando/lagoon', '@lando/lamp', '@lando/laravel', '@lando/lemp', '@lando/mariadb', '@lando/mean', '@lando/memcached', '@lando/mongo', '@lando/mssql', '@lando/mysql', '@lando/nginx', '@lando/node', '@lando/pantheon', '@lando/php', '@lando/platformsh', '@lando/postgres', '@lando/python', '@lando/redis', '@lando/ruby', '@lando/solr', '@lando/symfony', '@lando/tomcat', '@lando/varnish', '@lando/wordpress'],
+    disablePlugins: ['@lando/argv', '@lando/mailhog'],
     proxyName: 'vip-dev-env-proxy',
     userConfRoot: landoDir,
     home: fakeHomeDir,
@@ -111,6 +106,7 @@ async function regenerateLandofile(instancePath) {
   }
   const slug = _path.default.basename(instancePath);
   const currentInstanceData = (0, _devEnvironmentCore.readEnvironmentData)(slug);
+  currentInstanceData.pullAfter = 0;
   await (0, _devEnvironmentCore.updateEnvironment)(currentInstanceData);
 }
 async function landoRecovery(lando, instancePath, error) {
@@ -133,126 +129,207 @@ async function landoRecovery(lando, instancePath, error) {
   }
 }
 async function getLandoApplication(lando, instancePath) {
-  if (appMap.has(instancePath)) {
-    return Promise.resolve(appMap.get(instancePath));
-  }
-  if (!(await (0, _devEnvironmentCore.doesEnvironmentExist)(instancePath))) {
-    throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
-  }
-  let app;
+  const started = new Date();
   try {
-    app = lando.getApp(instancePath);
-    await app.init();
-  } catch (error) {
-    app = await landoRecovery(lando, instancePath, error);
+    if (appMap.has(instancePath)) {
+      return Promise.resolve(appMap.get(instancePath));
+    }
+    if (!(await (0, _devEnvironmentCore.doesEnvironmentExist)(instancePath))) {
+      throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
+    }
+    let app;
+    try {
+      app = lando.getApp(instancePath);
+      await app.init();
+    } catch (error) {
+      app = await landoRecovery(lando, instancePath, error);
+    }
+    appMap.set(instancePath, app);
+    return app;
+  } finally {
+    const duration = new Date().getTime() - started.getTime();
+    debug('getLandoApplication() took %d ms', duration);
   }
-  appMap.set(instancePath, app);
-  return app;
 }
 async function bootstrapLando() {
-  const lando = new _lando.default(await getLandoConfig());
-  lando.events.once('pre-engine-build', async data => {
-    const instanceData = (0, _devEnvironmentCore.readEnvironmentData)(data.name);
-    let registryResolvable = false;
-    try {
-      registryResolvable = (await _dns.default.promises.lookup('ghcr.io')).address || false;
-      debug('Registry ghcr.io is resolvable');
-    } catch (err) {
-      debug('Registry ghcr.io is not resolvable, image pull might be broken.');
-      registryResolvable = false;
-    }
-    const pull = registryResolvable && (instanceData.pullAfter || 0) < Date.now();
-    if (Array.isArray(data.opts.pullable) && Array.isArray(data.opts.local) && data.opts.local.length === 0 && !pull) {
-      // Setting `data.opts.pullable` to an empty array prevents Lando from pulling images with `docker pull`.
-      // Note that if some of the images are not available, they will still be pulled by `docker-compose`.
-      data.opts.local = data.opts.pullable;
-      data.opts.pullable = [];
-    }
-    if (pull || !instanceData.pullAfter) {
-      instanceData.pullAfter = Date.now() + 7 * 24 * 60 * 60 * 1000;
-      (0, _devEnvironmentCore.writeEnvironmentData)(data.name, instanceData);
+  const started = new Date();
+  try {
+    const socket = await (0, _dockerUtils.getDockerSocket)();
+    const config = await getLandoConfig();
+    if (socket) {
+      config.engineConfig = await (0, _dockerUtils.getEngineConfig)(socket);
     }
-  });
-  await lando.bootstrap();
-  return lando;
+    const lando = new _lando.default(config);
+    lando.events.once('pre-engine-build', async data => {
+      const instanceData = (0, _devEnvironmentCore.readEnvironmentData)(data.name);
+      let registryResolvable = false;
+      try {
+        registryResolvable = (await _dns.default.promises.lookup('ghcr.io')).address || false;
+        debug('Registry ghcr.io is resolvable');
+      } catch (err) {
+        debug('Registry ghcr.io is not resolvable, image pull might be broken.');
+        registryResolvable = false;
+      }
+      const pull = registryResolvable && (instanceData.pullAfter || 0) < Date.now();
+      if (Array.isArray(data.opts.pullable) && Array.isArray(data.opts.local) && data.opts.local.length === 0 && !pull) {
+        // Setting `data.opts.pullable` to an empty array prevents Lando from pulling images with `docker pull`.
+        // Note that if some of the images are not available, they will still be pulled by `docker-compose`.
+        data.opts.local = data.opts.pullable;
+        data.opts.pullable = [];
+      }
+      if (pull || !instanceData.pullAfter) {
+        instanceData.pullAfter = Date.now() + 7 * 24 * 60 * 60 * 1000;
+        (0, _devEnvironmentCore.writeEnvironmentData)(data.name, instanceData);
+      }
+    });
+    await lando.bootstrap();
+    return lando;
+  } finally {
+    const duration = new Date().getTime() - started.getTime();
+    debug('bootstrapLando() took %d ms', duration);
+  }
 }
 async function landoStart(lando, instancePath) {
-  debug('Will start lando app on path:', instancePath);
-  const app = await getLandoApplication(lando, instancePath);
-  await app.start();
+  const started = new Date();
+  try {
+    debug('Will start lando app on path:', instancePath);
+    const app = await getLandoApplication(lando, instancePath);
+    await app.start();
+  } finally {
+    const duration = new Date().getTime() - started.getTime();
+    debug('landoStart() took %d ms', duration);
+  }
 }
 async function landoLogs(lando, instancePath, options) {
-  debug('Will show lando logs on path:', instancePath, ' with options: ', options);
-  const app = await getLandoApplication(lando, instancePath);
-  const logTask = lando.tasks.find(task => task.command === 'logs');
-  await logTask.run({
-    follow: options.follow,
-    service: options.service,
-    timestamps: options.timestamps,
-    _app: app
-  });
+  const started = new Date();
+  try {
+    debug('Will show lando logs on path:', instancePath, ' with options: ', options);
+    const app = await getLandoApplication(lando, instancePath);
+    const logTask = lando.tasks.find(task => task.command === 'logs');
+    await logTask.run({
+      follow: options.follow,
+      service: options.service,
+      timestamps: options.timestamps,
+      _app: app
+    });
+  } finally {
+    const duration = new Date().getTime() - started.getTime();
+    debug('landoLogs() took %d ms', duration);
+  }
 }
 async function landoRebuild(lando, instancePath) {
-  debug('Will rebuild lando app on path:', instancePath);
-  const app = await getLandoApplication(lando, instancePath);
-  await ensureNoOrphantProxyContainer(lando);
-  await app.rebuild();
+  const started = new Date();
+  try {
+    debug('Will rebuild lando app on path:', instancePath);
+    const app = await getLandoApplication(lando, instancePath);
+    await ensureNoOrphantProxyContainer(lando);
+    await app.rebuild();
+  } finally {
+    const duration = new Date().getTime() - started.getTime();
+    debug('landoRebuild() took %d ms', duration);
+  }
+}
+
+/**
+ * @return {Promise<import('dockerode').NetworkInspectInfo | null>}
+ */
+async function getBridgeNetwork(lando) {
+  const networkName = lando.config.networkBridge || 'lando_bridge_network';
+  try {
+    return await lando.engine.getNetwork(networkName).inspect();
+  } catch (err) {
+    debug('Error getting network %s: %s', networkName, err.message);
+    return null;
+  }
+}
+async function cleanUpLandoProxy(lando) {
+  const network = await getBridgeNetwork(lando);
+  if (network && network.Containers && !Object.keys(network.Containers).length) {
+    const proxy = lando.engine.docker.getContainer(lando.config.proxyContainer);
+    try {
+      await proxy.remove({
+        force: true
+      });
+    } catch (err) {
+      debug('Error removing proxy container: %s', err.message);
+    }
+  }
 }
 async function landoStop(lando, instancePath) {
-  debug('Will stop lando app on path:', instancePath);
-  const app = await getLandoApplication(lando, instancePath);
-  await app.stop();
+  const started = new Date();
+  try {
+    debug('Will stop lando app on path:', instancePath);
+    const app = await getLandoApplication(lando, instancePath);
+    app.events.once('post-stop', () => cleanUpLandoProxy(lando));
+    await app.stop();
+  } finally {
+    const duration = new Date().getTime() - started.getTime();
+    debug('landoStop() took %d ms', duration);
+  }
 }
 async function landoDestroy(lando, instancePath) {
-  debug('Will destroy lando app on path:', instancePath);
-  const app = await getLandoApplication(lando, instancePath);
-  await app.destroy();
+  const started = new Date();
+  try {
+    debug('Will destroy lando app on path:', instancePath);
+    const app = await getLandoApplication(lando, instancePath);
+    app.events.once('post-stop', () => cleanUpLandoProxy(lando));
+    await app.destroy();
+  } finally {
+    const duration = new Date().getTime() - started.getTime();
+    debug('landoDestroy() took %d ms', duration);
+  }
 }
 async function landoInfo(lando, instancePath, suppressWarnings) {
-  var _app$info$find;
-  const app = await getLandoApplication(lando, instancePath);
-  let appInfo = _utils.default.startTable(app);
-  const reachableServices = app.info.filter(service => service.urls.length);
-  reachableServices.forEach(service => appInfo[`${service.service} urls`] = service.urls);
-  const health = await checkEnvHealth(lando, instancePath);
-  const frontEndUrl = (_app$info$find = app.info.find(service => 'nginx' === service.service)) === null || _app$info$find === void 0 ? void 0 : _app$info$find.urls[0];
-  const extraService = await getExtraServicesConnections(lando, app);
-  appInfo = {
-    slug: appInfo.name.replace(/^vipdev/, ''),
-    ...appInfo,
-    ...extraService
-  };
-  delete appInfo.name;
-  const hasResults = Object.values(health).length > 0;
-  const hasWarnings = Object.values(health).some(status => !status);
-  if (hasResults && !hasWarnings) {
-    appInfo.status = _chalk.default.green('UP');
-  } else if (health.nginx) {
-    appInfo.status = _chalk.default.yellow('PARTIALLY UP');
-  } else {
-    appInfo.status = _chalk.default.red('DOWN');
-  }
+  const started = new Date();
+  try {
+    var _app$info$find;
+    const app = await getLandoApplication(lando, instancePath);
+    let appInfo = _utils.default.startTable(app);
+    const reachableServices = app.info.filter(service => service.urls.length);
+    reachableServices.forEach(service => appInfo[`${service.service} urls`] = service.urls);
+    const health = await checkEnvHealth(lando, instancePath);
+    const frontEndUrl = (_app$info$find = app.info.find(service => 'nginx' === service.service)) === null || _app$info$find === void 0 ? void 0 : _app$info$find.urls[0];
+    const extraService = await getExtraServicesConnections(lando, app);
+    appInfo = {
+      slug: appInfo.name.replace(/^vipdev/, ''),
+      ...appInfo,
+      ...extraService
+    };
+    delete appInfo.name;
+    const hasResults = Object.values(health).length > 0;
+    const hasWarnings = Object.values(health).some(status => !status);
+    if (hasResults && !hasWarnings) {
+      appInfo.status = _chalk.default.green('UP');
+    } else if (health.nginx) {
+      appInfo.status = _chalk.default.yellow('PARTIALLY UP');
+    } else {
+      appInfo.status = _chalk.default.red('DOWN');
+    }
 
-  // Add login information
-  if (frontEndUrl) {
-    const loginUrl = `${frontEndUrl}wp-admin/`;
-    appInfo['Login URL'] = loginUrl;
-    appInfo['Default username'] = 'vipgo';
-    appInfo['Default password'] = 'password';
-  }
-  if (!suppressWarnings && hasWarnings) {
-    let message = _chalk.default.bold.yellow('The following services have failed health checks:\n');
-    Object.keys(health).forEach(service => {
-      if (!health[service]) {
-        message += `${_chalk.default.red(service)}\n`;
-      }
-    });
-    appInfo['Health warnings'] = message;
-  }
+    // Add login information
+    if (frontEndUrl) {
+      const loginUrl = `${frontEndUrl}wp-admin/`;
+      appInfo['Login URL'] = loginUrl;
+      appInfo['Default username'] = 'vipgo';
+      appInfo['Default password'] = 'password';
+    }
+    if (!suppressWarnings && hasWarnings) {
+      let message = _chalk.default.bold.yellow('The following services have failed health checks:\n');
+      Object.keys(health).forEach(service => {
+        if (!health[service]) {
+          message += `${_chalk.default.red(service)}\n`;
+        }
+      });
+      appInfo['Health warnings'] = message;
+    }
 
-  // Add documentation link
-  appInfo.Documentation = 'https://docs.wpvip.com/technical-references/vip-local-development-environment/';
-  return appInfo;
+    // Add documentation link
+    appInfo.Documentation = 'https://docs.wpvip.com/technical-references/vip-local-development-environment/';
+    return appInfo;
+  } finally {
+    const duration = new Date().getTime() - started.getTime();
+    debug('landoInfo() took %d ms', duration);
+  }
 }
 const extraServiceDisplayConfiguration = [{
   name: 'elasticsearch',
@@ -265,6 +342,9 @@ const extraServiceDisplayConfiguration = [{
 }, {
   name: 'mailhog',
   skip: true
+}, {
+  name: 'mailpit',
+  skip: true
 }];
 async function getExtraServicesConnections(lando, app) {
   const extraServices = {};

package/dist/lib/dev-environment/docker-utils.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDockerSocket = getDockerSocket;
+exports.getEngineConfig = getEngineConfig;
+exports.splitca = splitca;
+var _nodeFs = require("node:fs");
+var _promises = require("node:fs/promises");
+var _nodeOs = require("node:os");
+var _nodePath = _interopRequireDefault(require("node:path"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/* eslint-disable no-await-in-loop */
+/**
+ * External dependencies
+ */
+/**
+ * Reads a Certificate Authority file and returns it as an array of certificates
+ *
+ * @param {string} filepath Path to the file
+ * @return {string[]} Array of certificates
+ */
+async function splitca(filepath) {
+  const ca = [];
+  const data = await (0, _promises.readFile)(filepath, 'utf-8');
+  if (data.indexOf('-END CERTIFICATE-') < 0 || data.indexOf('-BEGIN CERTIFICATE-') < 0) {
+    throw new Error("File does not contain 'BEGIN CERTIFICATE' or 'END CERTIFICATE'");
+  }
+  const chain = data.split('\n');
+  let cert = [];
+  for (const line of chain) {
+    if (line) {
+      cert.push(line);
+      if (line.match(/-END CERTIFICATE-/)) {
+        ca.push(cert.join('\n'));
+        cert = [];
+      }
+    }
+  }
+  return ca;
+}
+async function canReadWrite(what) {
+  try {
+    // eslint-disable-next-line no-bitwise
+    await (0, _promises.access)(what, _nodeFs.constants.R_OK | _nodeFs.constants.W_OK);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+async function getDockerSocket() {
+  if ((0, _nodeOs.platform)() !== 'win32') {
+    var _process$env$DOCKER_H;
+    const possibleSocket = (_process$env$DOCKER_H = process.env.DOCKER_HOST) !== null && _process$env$DOCKER_H !== void 0 ? _process$env$DOCKER_H : '';
+    // If `DOCKER_HOST` is set and not empty, and if it does not point to a unix socket, return - not much that we can do here.
+    if (possibleSocket && !/^unix:\/\//.test(possibleSocket)) {
+      return possibleSocket;
+    }
+    const paths = [];
+    if (possibleSocket) {
+      // This is a UNIX socket, strip the leading `unix://` prefix and make sure the path starts with a slash.
+      // (there are cases when the path is prefixed with two or three slashes)
+      paths.push(possibleSocket.replace(/^unix:\/+/, '/'));
+    }
+
+    // Try the default location
+    paths.push('/var/run/docker.sock');
+    // Try an alternative location
+    paths.push(_nodePath.default.join((0, _nodeOs.homedir)(), '.docker', 'run', 'docker.sock'));
+    for (const socketPath of paths) {
+      try {
+        const stats = await (0, _promises.stat)(socketPath);
+        if (stats.isSocket() && (await canReadWrite(socketPath))) {
+          process.env.DOCKER_HOST = `unix://${socketPath}`;
+          return socketPath;
+        }
+      } catch (err) {
+        // Do nothing
+      }
+    }
+  }
+  return null;
+}
+async function getEngineConfig(dockerHost) {
+  const opts = {};
+  if (dockerHost.startsWith('tcp://')) {
+    const split = /(?:tcp:\/\/)?(.*?):(\d+)/g.exec(dockerHost);
+    if (split && split.length === 3) {
+      opts.host = split[1];
+      opts.port = split[2];
+    } else {
+      throw new Error('Invalid DOCKER_HOST format');
+    }
+  } else {
+    opts.socketPath = dockerHost;
+  }
+  if (process.env.DOCKER_TLS_VERIFY === '1' || opts.port === '2376') {
+    opts.protocol = 'https';
+  } else {
+    opts.protocol = 'http';
+  }
+  const certPath = process.env.DOCKER_CERT_PATH;
+  if (certPath) {
+    const [ca, cert, key] = await Promise.all([splitca(_nodePath.default.join(certPath, 'ca.pem')), (0, _promises.readFile)(_nodePath.default.join(certPath, 'cert.pem'), 'utf-8'), (0, _promises.readFile)(_nodePath.default.join(certPath, 'key.pem'), 'utf-8')]);
+    opts.ca = ca;
+    opts.cert = cert;
+    opts.key = key;
+  }
+  if (process.env.DOCKER_CLIENT_TIMEOUT) {
+    opts.timeout = parseInt(process.env.DOCKER_CLIENT_TIMEOUT, 10);
+  }
+  return opts;
+}

package/dist/lib/keychain/browser.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+/* global window */
 /**
  * Internal dependencies
  */

package/dist/lib/keychain/secure.js

@@ -9,6 +9,9 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 /**
  * External dependencies
  */
+/**
+ * Internal dependencies
+ */
 class Secure {
   getPassword(service) {
     return _keytar.default.getPassword(service, service);

package/dist/lib/keychain.js

@@ -7,6 +7,7 @@ exports.default = void 0;
 var _insecure = _interopRequireDefault(require("./keychain/insecure"));
 var _browser = _interopRequireDefault(require("./keychain/browser"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/* global window */
 /**
  * External dependencies
  */

package/dist/lib/site-import/status.js

@@ -234,8 +234,8 @@ ${maybeExitPrompt}
       let {
         importJob
       } = status;
-      let jobStatus,
-        jobSteps = [];
+      let jobStatus;
+      let jobSteps = [];
       if (env.isK8sResident) {
         // in the future the API may provide this in k8s jobs so account for that.
         // Until then we need to create the importJob from the status object.

package/dist/lib/tracker.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.aliasUser = aliasUser;
-exports.makeCommandTracker = makeCommandTracker;
 exports.trackEvent = trackEvent;
 exports.trackEventWithEnv = trackEventWithEnv;
 var _index = _interopRequireDefault(require("./analytics/index"));
@@ -78,13 +77,4 @@ async function trackEventWithEnv(appId, envId, eventName, eventProps = {}) {
     app_id: appId,
     env_id: envId
   });
-}
-function makeCommandTracker(command, trackingInfo = {}) {
-  const trackerFn = async (type, data = {}) => {
-    await trackEvent(`${command}_command_${type}`, {
-      ...trackingInfo,
-      ...data
-    });
-  };
-  return trackerFn;
 }

package/dist/lib/validations/sql.js

@@ -25,6 +25,8 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * Internal dependencies
  */
 
+// eslint-disable-next-line no-duplicate-imports
+
 let problemsFound = 0;
 let lineNum = 1;
 const tableNames = [];
@@ -118,9 +120,9 @@ const infoCheckFormatter = check => {
   };
 };
 function checkTablePrefixes(results, errors, infos) {
-  const wpTables = [],
-    notWPTables = [],
-    wpMultisiteTables = [];
+  const wpTables = [];
+  const notWPTables = [];
+  const wpMultisiteTables = [];
   results.forEach(result => {
     const tableName = result.text || '';
     if (tableName.match(/^wp_(\d+_)/)) {

package/dist/lib/vip-import-validate-files.js

@@ -118,7 +118,10 @@ const findNestedDirectories = directory => {
  */
 exports.findNestedDirectories = findNestedDirectories;
 const getIndexPositionOfFolders = (folderPath, sites) => {
-  let sitesIndex, siteIDIndex, yearIndex, monthIndex;
+  let sitesIndex;
+  let siteIDIndex;
+  let yearIndex;
+  let monthIndex;
   let pathMutate = folderPath; // Mutate `path` for multisites
 
   // Turn the path into an array to determine index position