@automattic/vip 3.25.2-dev.0 → 3.25.3-dev.0

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

@@ -15,9 +15,14 @@ exports.landoShell = landoShell;
 exports.landoStart = landoStart;
 exports.landoStop = landoStop;
 exports.removeProxyCache = removeProxyCache;
+exports.tryResolveDomains = tryResolveDomains;
 exports.validateDockerInstalled = validateDockerInstalled;
 var _chalk = _interopRequireDefault(require("chalk"));
 var _debug = _interopRequireDefault(require("debug"));
+var _bootstrap = require("lando/lib/bootstrap");
+var _lando = _interopRequireDefault(require("lando/lib/lando"));
+var _utils = _interopRequireDefault(require("lando/plugins/lando-core/lib/utils"));
+var _build = _interopRequireDefault(require("lando/plugins/lando-tooling/lib/build"));
 var _nodeChild_process = require("node:child_process");
 var _promises = require("node:dns/promises");
 var _promises2 = require("node:fs/promises");
@@ -27,12 +32,11 @@ var _nodeUtil = require("node:util");
 var _semver = require("semver");
 var _devEnvironmentCore = require("./dev-environment-core");
 var _dockerUtils = require("./docker-utils");
-var _landoLoader = require("./lando-loader");
-var _runtimeMode = require("../cli/runtime-mode");
 var _devEnvironment = require("../constants/dev-environment");
 var _env = _interopRequireDefault(require("../env"));
 var _userError = _interopRequireDefault(require("../user-error"));
 var _xdgData = require("../xdg-data");
+var _hostsUpdater = require("./hosts-updater");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
@@ -41,44 +45,6 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
 const DEBUG_KEY = '@automattic/vip:bin:dev-environment';
 const debug = (0, _debug.default)(DEBUG_KEY);
 const execFileAsync = (0, _nodeUtil.promisify)(_nodeChild_process.execFile);
-const unwrapLandoModuleDefault = loaded => {
-  if (loaded && typeof loaded === 'object' && 'default' in loaded) {
-    return loaded.default;
-  }
-  return loaded;
-};
-let landoConstructor = null;
-let landoBuildTaskFn = null;
-let landoUtilsModule = null;
-let buildConfigFn = null;
-const getLandoConstructor = () => {
-  if (!landoConstructor) {
-    landoConstructor = unwrapLandoModuleDefault((0, _landoLoader.loadLandoModule)('lando/lib/lando'));
-  }
-  return landoConstructor;
-};
-const getLandoBuildTask = () => {
-  if (!landoBuildTaskFn) {
-    landoBuildTaskFn = unwrapLandoModuleDefault((0, _landoLoader.loadLandoModule)('lando/plugins/lando-tooling/lib/build'));
-  }
-  return landoBuildTaskFn;
-};
-const getLandoUtils = () => {
-  if (!landoUtilsModule) {
-    landoUtilsModule = unwrapLandoModuleDefault((0, _landoLoader.loadLandoModule)('lando/plugins/lando-core/lib/utils'));
-  }
-  return landoUtilsModule;
-};
-const getLandoBuildConfig = () => {
-  if (!buildConfigFn) {
-    const loaded = (0, _landoLoader.loadLandoModule)('lando/lib/bootstrap');
-    buildConfigFn = loaded.buildConfig ?? loaded.default?.buildConfig ?? null;
-    if (!buildConfigFn) {
-      throw new Error('Unable to load Lando bootstrap buildConfig.');
-    }
-  }
-  return buildConfigFn;
-};
 const bannerLabelWidth = 18;
 let logPathRegistered = false;
 let resolvedLogPath = null;
@@ -182,7 +148,7 @@ const writeLogBanner = async config => {
   });
   const dockerVersions = await getDockerVersions(config);
   const command = process.argv.slice(1).join(' ');
-  const bannerLines = ['=== VIP Dev Env Log ===', formatBannerLine('COMMAND', command), formatBannerLine('OS', `${_env.default.os.name} ${_env.default.os.version} ${_env.default.os.arch}`), formatBannerLine('NODE', _env.default.node.version), formatBannerLine('VIP-CLI', _env.default.app.version), formatBannerLine('RUNTIME', (0, _runtimeMode.getRuntimeModeLabel)()), formatBannerLine('DOCKER ENGINE', dockerVersions.engine), formatBannerLine('DOCKER COMPOSE', dockerVersions.compose), formatBannerLine('COMPOSE PLUGIN', dockerVersions.composePlugin), formatBannerLine('DOCKER BIN', config.dockerBin ?? 'unknown'), formatBannerLine('COMPOSE BIN', config.composeBin ?? 'unknown'), formatBannerLine('RAM', formatBytes((0, _nodeOs.totalmem)())), formatBannerLine('CPU', String((0, _nodeOs.cpus)().length)), '===', '', ''];
+  const bannerLines = ['=== VIP Dev Env Log ===', formatBannerLine('COMMAND', command), formatBannerLine('OS', `${_env.default.os.name} ${_env.default.os.version} ${_env.default.os.arch}`), formatBannerLine('NODE', _env.default.node.version), formatBannerLine('VIP-CLI', _env.default.app.version), formatBannerLine('DOCKER ENGINE', dockerVersions.engine), formatBannerLine('DOCKER COMPOSE', dockerVersions.compose), formatBannerLine('COMPOSE PLUGIN', dockerVersions.composePlugin), formatBannerLine('DOCKER BIN', config.dockerBin ?? 'unknown'), formatBannerLine('COMPOSE BIN', config.composeBin ?? 'unknown'), formatBannerLine('RAM', formatBytes((0, _nodeOs.totalmem)())), formatBannerLine('CPU', String((0, _nodeOs.cpus)().length)), '===', '', ''];
   await (0, _promises2.writeFile)(logFilePath, bannerLines.join('\n'), {
     flag: 'a'
   });
@@ -193,7 +159,7 @@ const writeLogBanner = async config => {
  */
 async function getLandoConfig(options = {}) {
   // The path will be smth like `yarn/global/node_modules/lando/lib/lando.js`; we need the path up to `lando` (inclusive)
-  const landoPath = (0, _nodePath.dirname)((0, _nodePath.dirname)((0, _landoLoader.resolveLandoModule)('lando')));
+  const landoPath = (0, _nodePath.dirname)((0, _nodePath.dirname)(require.resolve('lando')));
   debug(`Getting Lando config, using paths '${landoPath}' for plugins`);
   const isLandoDebugSelected = _debug.default.enabled(DEBUG_KEY);
   const isAllDebugSelected = _debug.default.enabled('"*"');
@@ -237,7 +203,7 @@ async function getLandoConfig(options = {}) {
       LANDO_HOST_GROUP_ID: process.platform === 'win32' ? '1000' : `${(0, _nodeOs.userInfo)().gid}`
     }
   };
-  return getLandoBuildConfig()(config);
+  return (0, _bootstrap.buildConfig)(config);
 }
 const appMap = new Map();
 async function initLandoApplication(lando, instancePath) {
@@ -326,8 +292,7 @@ async function bootstrapLando(options = {}) {
     }
     registerLogPathOutput(config, Boolean(options.quiet));
     await writeLogBanner(config);
-    const LandoClass = getLandoConstructor();
-    const lando = new LandoClass(config);
+    const lando = new _lando.default(config);
     _debug.default.log = (message, ...args) => {
       lando.log.debug(message, ...args);
     };
@@ -360,11 +325,32 @@ async function bootstrapLando(options = {}) {
     debug('bootstrapLando() took %d ms', duration);
   }
 }
-async function landoStart(lando, instancePath) {
+const autofixedApps = new WeakSet();
+function installDnsAutofixer(app) {
+  if (autofixedApps.has(app)) {
+    return;
+  }
+  autofixedApps.add(app);
+  app.events.on('post-start', 9, async () => {
+    const urlsToScan = [];
+    app.info.filter(service => service.urls.length).forEach(service => {
+      service.urls.forEach(url => {
+        if (!/^https?:\/\/(localhost|127\.0\.0\.1):/.exec(url) && !url.includes('*')) {
+          urlsToScan.push(url);
+        }
+      });
+    });
+    await tryResolveDomains(urlsToScan, true);
+  });
+}
+async function landoStart(lando, instancePath, autoFixDomainResolution = false) {
   const started = new Date();
   try {
     debug('Will start lando app on path:', instancePath);
     const app = await getLandoApplication(lando, instancePath);
+    if (autoFixDomainResolution) {
+      installDnsAutofixer(app);
+    }
     await app.start();
   } finally {
     const duration = new Date().getTime() - started.getTime();
@@ -388,11 +374,14 @@ async function landoLogs(lando, instancePath, options) {
     debug('landoLogs() took %d ms', duration);
   }
 }
-async function landoRebuild(lando, instancePath) {
+async function landoRebuild(lando, instancePath, autoFixDomainResolution = false) {
   const started = new Date();
   try {
     debug('Will rebuild lando app on path:', instancePath);
     const app = await getLandoApplication(lando, instancePath);
+    if (autoFixDomainResolution) {
+      installDnsAutofixer(app);
+    }
     await ensureNoOrphantProxyContainer(lando);
     await app.rebuild();
   } finally {
@@ -462,7 +451,7 @@ async function landoInfo(lando, instancePath, options = {}) {
   const started = new Date();
   try {
     const app = await getLandoApplication(lando, instancePath);
-    const info = getLandoUtils().startTable(app);
+    const info = _utils.default.startTable(app);
     const reachableServices = app.info.filter(service => service.urls.length);
     reachableServices.forEach(service => info[`${service.service} urls`] = service.urls);
     const health = await checkEnvHealth(lando, app);
@@ -566,7 +555,7 @@ async function getExtraServicesConnections(lando, app) {
   }
   return extraServices;
 }
-async function tryResolveDomains(urls) {
+async function tryResolveDomains(urls, autofix) {
   const domains = [...new Set(urls.filter(url => url.toLowerCase().startsWith('http')).map(url => {
     try {
       return new URL(url).hostname;
@@ -575,6 +564,7 @@ async function tryResolveDomains(urls) {
     }
   }).filter(domain => domain !== undefined))];
   const domainsToFix = [];
+  const pendingWarnings = [];
   for (const domain of domains) {
     try {
       // eslint-disable-next-line no-await-in-loop
@@ -582,20 +572,72 @@ async function tryResolveDomains(urls) {
       debug('%s resolves to %s', domain, address.address);
       if (address.address !== '127.0.0.1') {
         domainsToFix.push(domain);
-        console.warn(_chalk.default.yellow.bold('WARNING:'), `${domain} resolves to ${address.address} instead of 127.0.0.1. Things may not work as expected.`);
+        pendingWarnings.push(`${domain} resolves to ${address.address} instead of 127.0.0.1. Things may not work as expected.`);
       }
     } catch (err) {
       const msg = err instanceof Error ? err.message : 'Unknown error';
       domainsToFix.push(domain);
-      console.warn(_chalk.default.yellow.bold('WARNING:'), `Failed to resolve ${domain}: ${msg}`);
+      pendingWarnings.push(`Failed to resolve ${domain}: ${msg}`);
     }
   }
   if (domainsToFix.length) {
+    if (autofix) {
+      console.log(_chalk.default.green('Attempting to fix domain resolution issues...'));
+      const result = await autofixDomains(domainsToFix);
+      if (result instanceof Error) {
+        // Autofix failed — surface the original DNS warnings so the user knows what went wrong
+        pendingWarnings.forEach(msg => console.warn(_chalk.default.yellow.bold('WARNING:'), msg));
+        console.error(_chalk.default.red(result.message));
+        if (result.cause) {
+          console.error(_chalk.default.red('Cause: '), result.cause.message);
+        }
+      } else {
+        // Autofix succeeded — suppress the warnings so a clean start looks clean
+        console.log(_chalk.default.green('Domain resolution issues fixed successfully.'));
+        return;
+      }
+    } else {
+      pendingWarnings.forEach(msg => console.warn(_chalk.default.yellow.bold('WARNING:'), msg));
+    }
     console.warn(_chalk.default.yellow('Please add the following lines to the hosts file on your system:\n'));
     console.warn(domainsToFix.map(domain => `127.0.0.1 ${domain}`).join('\n'));
     console.warn(_chalk.default.yellow('\nLearn more: https://docs.wpvip.com/vip-local-development-environment/troubleshooting-dev-env/#h-resolve-networking-configuration-issues\n'));
   }
 }
+function ensureError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error));
+}
+const AUTOFIX_DOWNLOAD_TIMEOUT_MS = 30_000;
+async function autofixDomains(domains) {
+  const dir = await (0, _hostsUpdater.getInstallDir)();
+  const filename = (0, _hostsUpdater.getExeName)();
+  let binary = _nodePath.default.join(dir, filename);
+  try {
+    await (0, _promises2.access)(binary, _promises2.constants.X_OK);
+  } catch {
+    try {
+      binary = await (0, _hostsUpdater.installBinary)('latest', dir, AUTOFIX_DOWNLOAD_TIMEOUT_MS);
+    } catch (err) {
+      return new Error('Failed to install hosts updater binary, cannot autofix domain resolution issues.', {
+        cause: ensureError(err)
+      });
+    }
+  }
+  const fixableDomains = domains.filter(domain => !domain.includes('*'));
+  if (fixableDomains.length) {
+    try {
+      await (0, _hostsUpdater.updateDomains)(binary, fixableDomains);
+    } catch (err) {
+      return new Error('Failed to update hosts file, cannot autofix domain resolution issues.', {
+        cause: ensureError(err)
+      });
+    }
+  }
+  return true;
+}
 async function getRunningServicesForProject(docker, project) {
   const containers = await docker.listContainers({
     filters: {
@@ -616,7 +658,7 @@ async function checkEnvHealth(lando, app) {
     });
   });
   const urlsToScan = Object.keys(urls).filter(url => !url.includes('*'));
-  await tryResolveDomains(urlsToScan);
+  await tryResolveDomains(urlsToScan, false);
   app.urls.forEach(entry => {
     // We use different status codes to see if the service is up.
     // We may consider the service is up when Lando considers it is down.
@@ -675,7 +717,7 @@ async function landoExec(lando, instancePath, toolName, args, options) {
     if (options.stdio) {
       tool.stdio = options.stdio;
     }
-    const task = getLandoBuildTask()(tool, lando);
+    const task = (0, _build.default)(tool, lando);
     const argv = {
       // eslint-disable-next-line id-length
       _: args

package/dist/lib/dev-environment/hosts-updater.js

@@ -0,0 +1,184 @@
+"use strict";
+
+exports.__esModule = true;
+exports.InvalidChecksumError = exports.DownloadError = void 0;
+exports.download = download;
+exports.getExeName = getExeName;
+exports.getInstallDir = getInstallDir;
+exports.getReleaseUrl = getReleaseUrl;
+exports.installBinary = installBinary;
+exports.updateDomains = updateDomains;
+var _nodeFetch = _interopRequireDefault(require("node-fetch"));
+var _nodeChild_process = require("node:child_process");
+var _nodeCrypto = require("node:crypto");
+var _nodeFs = require("node:fs");
+var _promises = require("node:fs/promises");
+var _nodeOs = require("node:os");
+var _nodePath = require("node:path");
+var _nodeStream = require("node:stream");
+var _promises2 = require("node:stream/promises");
+var _nodeUtil = require("node:util");
+var _nodeZlib = require("node:zlib");
+var _proxyAgent = require("../http/proxy-agent");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class DownloadError extends Error {
+  constructor(url, code, options) {
+    super((0, _nodeUtil.format)('Failed to download file: %s (status code: %d)', url, code), options);
+    this.name = 'DownloadError';
+  }
+}
+exports.DownloadError = DownloadError;
+class InvalidChecksumError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = 'InvalidChecksumError';
+  }
+}
+exports.InvalidChecksumError = InvalidChecksumError;
+const archMap = {
+  ia32: '386',
+  x64: 'amd64',
+  arm64: 'arm64'
+};
+const platformMap = {
+  win32: 'windows',
+  darwin: 'darwin',
+  linux: 'linux'
+};
+function getReleaseUrl(version = 'latest', arch = process.arch, platform = process.platform) {
+  const resolvedArch = archMap[arch];
+  const resolvedPlatform = platformMap[platform];
+  if (!resolvedArch || !resolvedPlatform) {
+    throw new Error('Unsupported platform or architecture');
+  }
+  const suffix = 'windows' === resolvedPlatform ? '.exe' : '';
+  if (version !== 'latest') {
+    const binary = `https://github.com/Automattic/dev-env-update-hosts/releases/download/${version}/dev-env-update-hosts-${resolvedPlatform}-${resolvedArch}${suffix}.gz`;
+    const checksum = `${binary}.sum`;
+    return [binary, checksum];
+  }
+  const binary = `https://github.com/Automattic/dev-env-update-hosts/releases/latest/download/dev-env-update-hosts-${resolvedPlatform}-${resolvedArch}${suffix}.gz`;
+  const checksum = `${binary}.sum`;
+  return [binary, checksum];
+}
+async function download(url, asText, timeout = 0) {
+  const controller = new AbortController();
+  const timeoutId = timeout > 0 ? setTimeout(() => controller.abort(), timeout) : null;
+  const clearTimer = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  };
+  const proxyAgent = (0, _proxyAgent.createProxyAgent)(url.toString());
+  let response;
+  try {
+    response = await (0, _nodeFetch.default)(url, {
+      signal: controller.signal,
+      redirect: 'follow',
+      agent: proxyAgent ?? undefined
+    });
+  } catch (err) {
+    clearTimer();
+    throw err;
+  }
+  if (!response.ok) {
+    clearTimer();
+    throw new DownloadError(url, response.status);
+  }
+  if (asText) {
+    try {
+      return await response.text();
+    } finally {
+      clearTimer();
+    }
+  }
+
+  // For streams: unref the timer so it will not prevent process exit once the
+  // body has been fully consumed, but it will still abort a stalled read while
+  // the event loop is kept alive by the active stream pipeline.
+  timeoutId?.unref();
+  return response.body;
+}
+function getExeName(platform = process.platform, arch = process.arch) {
+  const exeSuffix = platform === 'win32' ? '.exe' : '';
+  return `dev-env-update-host-${platform}-${arch}${exeSuffix}`;
+}
+async function installBinary(version, dest, timeout = 0, arch = process.arch, platform = process.platform) {
+  const [binaryUrl, checksumUrl] = getReleaseUrl(version, arch, platform);
+  const checksum = (await download(new URL(checksumUrl), true, timeout)).trim();
+  const compressedStream = await download(new URL(binaryUrl), false, timeout);
+  if (!compressedStream) {
+    throw new Error('Failed to download binary');
+  }
+  const hash = (0, _nodeCrypto.createHash)('sha256');
+  const hashTap = new _nodeStream.Transform({
+    transform(chunk, _encoding, callback) {
+      hash.update(chunk);
+      callback(null, chunk);
+    }
+  });
+  const destFilename = (0, _nodePath.join)(dest, getExeName(platform, arch));
+  // Use a unique temp name to avoid collisions when multiple processes install concurrently.
+  const tempFilename = `${destFilename}.${(0, _nodeCrypto.randomBytes)(8).toString('hex')}.tmp`;
+  const outStream = (0, _nodeFs.createWriteStream)(tempFilename, {
+    mode: 0o755
+  });
+  let removeTmp = true;
+  try {
+    await (0, _promises2.pipeline)(compressedStream, hashTap, (0, _nodeZlib.createGunzip)(), outStream);
+    const calculatedChecksum = hash.digest('hex');
+    if (!(0, _nodeCrypto.timingSafeEqual)(Buffer.from(calculatedChecksum, 'hex'), Buffer.from(checksum, 'hex'))) {
+      throw new InvalidChecksumError((0, _nodeUtil.format)('Downloaded file checksum does not match expected value (expected: %s, got: %s)', checksum, calculatedChecksum));
+    }
+    await (0, _promises.rename)(tempFilename, destFilename);
+    removeTmp = false;
+  } finally {
+    if (removeTmp) {
+      await (0, _promises.rm)(tempFilename, {
+        force: true
+      }).catch(err => {
+        console.warn('Error removing temporary file %s: %s', tempFilename, err);
+      });
+    }
+  }
+  return destFilename;
+}
+async function getInstallDir() {
+  const binDir = (0, _nodePath.join)((0, _nodePath.dirname)(__dirname), 'bin');
+  try {
+    await (0, _promises.mkdir)(binDir, {
+      recursive: true
+    });
+    await (0, _promises.access)(binDir, _promises.constants.W_OK);
+    return binDir;
+  } catch {
+    // Swallow errors and fall back to a temporary directory
+  }
+  const tmpDir = await (0, _promises.mkdtemp)((0, _nodePath.join)((0, _nodeOs.tmpdir)(), 'dev-env-update-hosts-'));
+  process.once('exit', () => {
+    try {
+      (0, _nodeFs.rmSync)(tmpDir, {
+        recursive: true,
+        force: true
+      });
+    } catch (err) {
+      console.warn('Error removing temporary dir: %s', err);
+    }
+  });
+  return tmpDir;
+}
+function updateDomains(binary, domains) {
+  return new Promise((resolve, reject) => {
+    const child = (0, _nodeChild_process.spawn)(binary, domains, {
+      stdio: 'inherit'
+    });
+    child.on('error', err => reject(err));
+    child.on('exit', code => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Binary exited with code ${code}`));
+      }
+    });
+  });
+}