@automattic/vip 3.25.1 → 3.25.2-dev.0

package/dist/lib/cli/config.js

@@ -4,8 +4,9 @@ exports.__esModule = true;
 exports.default = void 0;
 exports.loadConfigFile = loadConfigFile;
 var _debug = _interopRequireDefault(require("debug"));
-var _nodeFs = require("node:fs");
+var _nodeFs = _interopRequireDefault(require("node:fs"));
 var _nodePath = _interopRequireDefault(require("node:path"));
+var _configPublish = _interopRequireDefault(require("../../../config/config.publish.json"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // I don't like using synchronous versions, but until we migrate to ESM, we have to.
 
@@ -14,26 +15,33 @@ function loadConfigFile() {
   const paths = [
   // Get `local` config first; this will only exist in dev as it's npmignore-d.
   _nodePath.default.join(__dirname, '../../../config/config.local.json'), _nodePath.default.join(__dirname, '../../../config/config.publish.json')];
+  let hasNonEnoentError = false;
   for (const filePath of paths) {
     try {
-      const data = (0, _nodeFs.readFileSync)(filePath, 'utf-8');
+      const data = _nodeFs.default.readFileSync(filePath, 'utf-8');
       debug(`Found config file at ${filePath}`);
       return JSON.parse(data);
     } catch (err) {
-      if (!(err instanceof Error) || !('code' in err) || err.code !== 'ENOENT') {
+      const isEnoent = err instanceof Error && 'code' in err && err.code === 'ENOENT';
+      if (!isEnoent) {
+        hasNonEnoentError = true;
         debug(`Error reading config file at ${filePath}:`, err);
       }
     }
   }
+
+  // SEA builds can miss on-disk config files, so use the bundled publish config only for ENOENT.
+  if (!hasNonEnoentError) {
+    return _configPublish.default;
+  }
   return null;
 }
 const configFromFile = loadConfigFile();
 if (null === configFromFile) {
-  // This should not happen because `config/config.publish.json` is always present.
   console.error('FATAL ERROR: Could not find a valid configuration file');
   process.exit(1);
 }
 
-// Without this, TypeScript will export `configFromFile` as `Config | null`
+// Without this, TypeScript will export `configFromFile` as `Config | null`.
 const exportedConfig = configFromFile;
 var _default = exports.default = exportedConfig;

package/dist/lib/cli/exit.js

@@ -4,6 +4,7 @@ exports.__esModule = true;
 exports.withError = withError;
 var _chalk = _interopRequireDefault(require("chalk"));
 var _debug = _interopRequireDefault(require("debug"));
+var _runtimeMode = require("./runtime-mode");
 var _env = _interopRequireDefault(require("../../lib/env"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function withError(message) {
@@ -13,7 +14,7 @@ function withError(message) {
   // Debug ouput is printed below error output both for information
   // hierarchy and to make it more likely that the user copies it to their
   // clipboard when dragging across output.
-  console.log(`${_chalk.default.yellow('Debug: ')} VIP-CLI v${_env.default.app.version}, Node ${_env.default.node.version}, ${_env.default.os.name} ${_env.default.os.version} ${_env.default.os.arch}`);
+  console.log(`${_chalk.default.yellow('Debug: ')} VIP-CLI v${_env.default.app.version}, Node ${_env.default.node.version}, ${_env.default.os.name} ${_env.default.os.version} ${_env.default.os.arch}, Runtime ${(0, _runtimeMode.getRuntimeModeLabel)()}`);
   if (_debug.default.names.length > 0 && message instanceof Error) {
     console.error(_chalk.default.yellow('Debug: '), message);
   }

package/dist/lib/cli/internal-bin-loader.js

@@ -0,0 +1,81 @@
+"use strict";
+
+exports.__esModule = true;
+exports.hasInternalBin = hasInternalBin;
+exports.internalBinNames = void 0;
+exports.loadInternalBin = loadInternalBin;
+const internalBinLoaders = {
+  vip: () => import('../../bin/vip'),
+  'vip-app': () => import('../../bin/vip-app'),
+  'vip-app-deploy': () => import('../../bin/vip-app-deploy'),
+  'vip-app-deploy-validate': () => import('../../bin/vip-app-deploy-validate'),
+  'vip-app-list': () => import('../../bin/vip-app-list'),
+  'vip-backup': () => import('../../bin/vip-backup'),
+  'vip-backup-db': () => import('../../bin/vip-backup-db'),
+  'vip-cache': () => import('../../bin/vip-cache'),
+  'vip-cache-purge-url': () => import('../../bin/vip-cache-purge-url'),
+  'vip-config': () => import('../../bin/vip-config'),
+  'vip-config-envvar': () => import('../../bin/vip-config-envvar'),
+  'vip-config-envvar-delete': () => import('../../bin/vip-config-envvar-delete'),
+  'vip-config-envvar-get': () => import('../../bin/vip-config-envvar-get'),
+  'vip-config-envvar-get-all': () => import('../../bin/vip-config-envvar-get-all'),
+  'vip-config-envvar-list': () => import('../../bin/vip-config-envvar-list'),
+  'vip-config-envvar-set': () => import('../../bin/vip-config-envvar-set'),
+  'vip-config-software': () => import('../../bin/vip-config-software'),
+  'vip-config-software-get': () => import('../../bin/vip-config-software-get'),
+  'vip-config-software-update': () => import('../../bin/vip-config-software-update'),
+  'vip-db': () => import('../../bin/vip-db'),
+  'vip-db-phpmyadmin': () => import('../../bin/vip-db-phpmyadmin'),
+  'vip-dev-env': () => import('../../bin/vip-dev-env'),
+  'vip-dev-env-create': () => import('../../bin/vip-dev-env-create'),
+  'vip-dev-env-destroy': () => import('../../bin/vip-dev-env-destroy'),
+  'vip-dev-env-envvar': () => import('../../bin/vip-dev-env-envvar'),
+  'vip-dev-env-envvar-delete': () => import('../../bin/vip-dev-env-envvar-delete'),
+  'vip-dev-env-envvar-get': () => import('../../bin/vip-dev-env-envvar-get'),
+  'vip-dev-env-envvar-get-all': () => import('../../bin/vip-dev-env-envvar-get-all'),
+  'vip-dev-env-envvar-list': () => import('../../bin/vip-dev-env-envvar-list'),
+  'vip-dev-env-envvar-set': () => import('../../bin/vip-dev-env-envvar-set'),
+  'vip-dev-env-exec': () => import('../../bin/vip-dev-env-exec'),
+  'vip-dev-env-import': () => import('../../bin/vip-dev-env-import'),
+  'vip-dev-env-import-media': () => import('../../bin/vip-dev-env-import-media'),
+  'vip-dev-env-import-sql': () => import('../../bin/vip-dev-env-import-sql'),
+  'vip-dev-env-info': () => import('../../bin/vip-dev-env-info'),
+  'vip-dev-env-list': () => import('../../bin/vip-dev-env-list'),
+  'vip-dev-env-logs': () => import('../../bin/vip-dev-env-logs'),
+  'vip-dev-env-purge': () => import('../../bin/vip-dev-env-purge'),
+  'vip-dev-env-shell': () => import('../../bin/vip-dev-env-shell'),
+  'vip-dev-env-start': () => import('../../bin/vip-dev-env-start'),
+  'vip-dev-env-stop': () => import('../../bin/vip-dev-env-stop'),
+  'vip-dev-env-sync': () => import('../../bin/vip-dev-env-sync'),
+  'vip-dev-env-sync-sql': () => import('../../bin/vip-dev-env-sync-sql'),
+  'vip-dev-env-update': () => import('../../bin/vip-dev-env-update'),
+  'vip-export': () => import('../../bin/vip-export'),
+  'vip-export-sql': () => import('../../bin/vip-export-sql'),
+  'vip-import': () => import('../../bin/vip-import'),
+  'vip-import-media': () => import('../../bin/vip-import-media'),
+  'vip-import-media-abort': () => import('../../bin/vip-import-media-abort'),
+  'vip-import-media-status': () => import('../../bin/vip-import-media-status'),
+  'vip-import-sql': () => import('../../bin/vip-import-sql'),
+  'vip-import-sql-status': () => import('../../bin/vip-import-sql-status'),
+  'vip-import-validate-files': () => import('../../bin/vip-import-validate-files'),
+  'vip-import-validate-sql': () => import('../../bin/vip-import-validate-sql'),
+  'vip-logout': () => import('../../bin/vip-logout'),
+  'vip-logs': () => import('../../bin/vip-logs'),
+  'vip-search-replace': () => import('../../bin/vip-search-replace'),
+  'vip-slowlogs': () => import('../../bin/vip-slowlogs'),
+  'vip-sync': () => import('../../bin/vip-sync'),
+  'vip-whoami': () => import('../../bin/vip-whoami'),
+  'vip-wp': () => import('../../bin/vip-wp')
+};
+const internalBinNames = exports.internalBinNames = Object.freeze(Object.keys(internalBinLoaders));
+async function loadInternalBin(binName) {
+  const loader = internalBinLoaders[binName];
+  if (!loader) {
+    return false;
+  }
+  await loader();
+  return true;
+}
+function hasInternalBin(binName) {
+  return Object.hasOwn(internalBinLoaders, binName);
+}

package/dist/lib/cli/runtime-mode.js

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.__esModule = true;
+exports.getRuntimeModeLabel = getRuntimeModeLabel;
+exports.isStandaloneExecutableRuntime = isStandaloneExecutableRuntime;
+var _nodeModule = require("node:module");
+const runtimeRequire = (0, _nodeModule.createRequire)(__filename);
+function isStandaloneExecutableRuntime() {
+  if (process.env.VIP_CLI_SEA_MODE === '1') {
+    return true;
+  }
+  try {
+    const sea = runtimeRequire('node:sea');
+    return Boolean(sea?.isSea?.());
+  } catch {
+    return false;
+  }
+}
+function getRuntimeModeLabel() {
+  return isStandaloneExecutableRuntime() ? 'standalone-sea' : 'node-script';
+}

package/dist/lib/cli/sea-dispatch.js

@@ -0,0 +1,88 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isSeaRuntime = isSeaRuntime;
+exports.resolveInternalBinFromArgv = resolveInternalBinFromArgv;
+exports.rewriteArgvForInternalBin = rewriteArgvForInternalBin;
+var _envAlias = require("./envAlias");
+var _internalBinLoader = require("./internal-bin-loader");
+const internalBinSet = new Set(_internalBinLoader.internalBinNames);
+
+/**
+ * Resolve the best matching internal bin for a command argv.
+ *
+ * @param {string[]} argv process.argv style array
+ * @returns {{ bin: string, start: number, length: number }}
+ */
+function resolveInternalBinFromArgv(argv) {
+  const args = argv.slice(2);
+  const dashDashIndex = args.indexOf('--');
+  const commandBoundary = dashDashIndex > -1 ? dashDashIndex : args.length;
+  let best = {
+    bin: 'vip',
+    start: 0,
+    length: 0
+  };
+  for (let start = 0; start < commandBoundary; start++) {
+    const firstToken = args[start];
+    if (!firstToken || firstToken.startsWith('-') || (0, _envAlias.isAlias)(firstToken)) {
+      continue;
+    }
+    const commandParts = [];
+    for (let index = start; index < commandBoundary; index++) {
+      const token = args[index];
+      if (!token || token.startsWith('-') || (0, _envAlias.isAlias)(token)) {
+        break;
+      }
+      commandParts.push(token);
+      const candidateBin = `vip-${commandParts.join('-')}`;
+      if (internalBinSet.has(candidateBin)) {
+        const isLongerMatch = commandParts.length > best.length;
+        const isEarlierEqualMatch = commandParts.length === best.length && commandParts.length > 0 && start < best.start;
+        if (isLongerMatch || isEarlierEqualMatch) {
+          best = {
+            bin: candidateBin,
+            start,
+            length: commandParts.length
+          };
+        }
+      }
+    }
+  }
+  return best;
+}
+
+/**
+ * Rewrites argv so the resolved command segment is removed and the target bin
+ * can parse its native flags/args shape.
+ *
+ * @param {string[]} argv process.argv style array
+ * @param {{ start: number, length: number }} resolution command resolution
+ * @returns {string[]} rewritten argv
+ */
+function rewriteArgvForInternalBin(argv, resolution) {
+  const args = argv.slice(2);
+  const start = resolution.start ?? 0;
+  const length = resolution.length ?? 0;
+  if (length <= 0) {
+    return argv.slice(0);
+  }
+  const rewrittenArgs = args.slice(0, start).concat(args.slice(start + length));
+  return [argv[0], argv[1], ...rewrittenArgs];
+}
+
+/**
+ * @returns {boolean}
+ */
+function isSeaRuntime() {
+  try {
+    const runtimeRequire = typeof module !== 'undefined' && module?.require ? module.require.bind(module) : null;
+    if (!runtimeRequire) {
+      return false;
+    }
+    const sea = runtimeRequire('node:sea');
+    return Boolean(sea?.isSea?.());
+  } catch {
+    return false;
+  }
+}

package/dist/lib/cli/sea-runtime.js

@@ -0,0 +1,75 @@
+"use strict";
+
+exports.__esModule = true;
+exports.prepareSeaRuntimeFilesystem = prepareSeaRuntimeFilesystem;
+var _nodeFs = require("node:fs");
+var _promises = require("node:fs/promises");
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _package = _interopRequireDefault(require("../../../package.json"));
+var _xdgData = require("../xdg-data");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const RUNTIME_ARCHIVE_KEY = 'sea.node_modules.tgz';
+const RUNTIME_DIR_NAME = 'sea-runtime';
+const READY_FILE_NAME = '.ready';
+const ARCHIVE_FILE_NAME = 'node_modules.tgz';
+async function getSeaModule() {
+  try {
+    return await import('node:sea');
+  } catch {
+    return null;
+  }
+}
+function getRuntimeRootPath() {
+  return _nodePath.default.join((0, _xdgData.xdgData)(), 'vip', RUNTIME_DIR_NAME, _package.default.version);
+}
+function getRuntimeNodeModulesPath(runtimeRootPath) {
+  return _nodePath.default.join(runtimeRootPath, 'node_modules');
+}
+function getRuntimeReadyPath(runtimeRootPath) {
+  return _nodePath.default.join(runtimeRootPath, READY_FILE_NAME);
+}
+function appendNodePath(nodeModulesPath) {
+  const existing = process.env.NODE_PATH ? process.env.NODE_PATH.split(_nodePath.default.delimiter) : [];
+  if (!existing.includes(nodeModulesPath)) {
+    process.env.NODE_PATH = [nodeModulesPath, ...existing].join(_nodePath.default.delimiter);
+  }
+  const Module = require('node:module');
+  Module.Module._initPaths();
+  const runtimeEntryPath = _nodePath.default.join(nodeModulesPath, '..', '__sea-entry__.js');
+  const runtimeRequire = Module.createRequire(runtimeEntryPath);
+  module.filename = runtimeEntryPath;
+  module.paths = Module._nodeModulePaths(_nodePath.default.dirname(runtimeEntryPath));
+  module.require = runtimeRequire;
+}
+async function extractRuntimeDependencies(runtimeRootPath, archiveBuffer) {
+  await (0, _promises.rm)(runtimeRootPath, {
+    recursive: true,
+    force: true
+  });
+  await (0, _promises.mkdir)(runtimeRootPath, {
+    recursive: true
+  });
+  const archivePath = _nodePath.default.join(runtimeRootPath, ARCHIVE_FILE_NAME);
+  await (0, _promises.writeFile)(archivePath, archiveBuffer);
+  const tar = require('tar');
+  await tar.x({
+    file: archivePath,
+    cwd: runtimeRootPath
+  });
+  await (0, _promises.writeFile)(getRuntimeReadyPath(runtimeRootPath), _package.default.version, 'utf8');
+}
+async function prepareSeaRuntimeFilesystem() {
+  const sea = await getSeaModule();
+  if (!sea?.isSea?.() || !sea.getAsset) {
+    return;
+  }
+  const runtimeRootPath = getRuntimeRootPath();
+  const runtimeNodeModulesPath = getRuntimeNodeModulesPath(runtimeRootPath);
+  const runtimeReadyPath = getRuntimeReadyPath(runtimeRootPath);
+  if (!(0, _nodeFs.existsSync)(runtimeReadyPath) || !(0, _nodeFs.existsSync)(runtimeNodeModulesPath)) {
+    const archiveAsset = sea.getAsset(RUNTIME_ARCHIVE_KEY);
+    const archiveBuffer = Buffer.isBuffer(archiveAsset) ? archiveAsset : Buffer.from(archiveAsset);
+    await extractRuntimeDependencies(runtimeRootPath, archiveBuffer);
+  }
+  appendNodePath(runtimeNodeModulesPath);
+}

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

@@ -38,7 +38,6 @@ var _chalk = _interopRequireDefault(require("chalk"));
 var _child_process = require("child_process");
 var _debug = _interopRequireDefault(require("debug"));
 var _enquirer = require("enquirer");
-var _formatters = _interopRequireDefault(require("lando/lib/formatters"));
 var _nodeFs = require("node:fs");
 var _nodeOs = require("node:os");
 var _path = _interopRequireDefault(require("path"));
@@ -46,6 +45,7 @@ var _shelljs = require("shelljs");
 var _devEnvironmentConfigurationFile = require("./dev-environment-configuration-file");
 var _devEnvironmentCore = require("./dev-environment-core");
 var _devEnvironmentLando = require("./dev-environment-lando");
+var _landoLoader = require("./lando-loader");
 var _user = require("../api/user");
 var _devEnvironment = require("../constants/dev-environment");
 var _tracker = require("../tracker");
@@ -55,6 +55,13 @@ const debug = (0, _debug.default)('@automattic/vip:bin:dev-environment');
 const DEFAULT_SLUG = exports.DEFAULT_SLUG = 'vip-local';
 const CONFIGURATION_FOLDER = exports.CONFIGURATION_FOLDER = '.wpvip';
 let isStdinTTY = Boolean(process.stdin.isTTY);
+let landoFormatters = null;
+const getLandoFormatters = () => {
+  if (!landoFormatters) {
+    landoFormatters = (0, _landoLoader.loadLandoModule)('lando/lib/formatters');
+  }
+  return landoFormatters;
+};
 
 /**
  * Used internally for tests
@@ -150,7 +157,7 @@ function getEnvironmentStartCommand(slug, configurationFileOptions) {
   return `${_devEnvironment.DEV_ENVIRONMENT_FULL_COMMAND} start --slug ${slug}`;
 }
 function printTable(data) {
-  const formattedData = _formatters.default.formatData(data, {
+  const formattedData = getLandoFormatters().formatData(data, {
     format: 'table'
   }, {
     border: false

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

@@ -28,7 +28,6 @@ var _debug = _interopRequireDefault(require("debug"));
 var _ejs = _interopRequireDefault(require("ejs"));
 var _enquirer = require("enquirer");
 var _graphql = require("graphql");
-var _utils = require("lando/lib/utils");
 var _nodeFetch = _interopRequireDefault(require("node-fetch"));
 var _nodeCrypto = require("node:crypto");
 var _nodeFs = _interopRequireDefault(require("node:fs"));
@@ -37,6 +36,7 @@ var _nodePath = _interopRequireDefault(require("node:path"));
 var _semver = _interopRequireDefault(require("semver"));
 var _devEnvironmentCli = require("./dev-environment-cli");
 var _devEnvironmentLando = require("./dev-environment-lando");
+var _landoLoader = require("./lando-loader");
 var _app = _interopRequireDefault(require("../api/app"));
 var _software = require("../config/software");
 var _devEnvironment = require("../constants/dev-environment");
@@ -47,7 +47,9 @@ var _xdgData = require("../xdg-data");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const debug = (0, _debug.default)('@automattic/vip:bin:dev-environment');
 const landoFileTemplatePath = _nodePath.default.join(__dirname, '..', '..', '..', 'assets', 'dev-env.lando.template.yml.ejs');
+const landoTemplateAssetKey = 'dev-env.lando.template.yml.ejs';
 const nginxFileTemplatePath = _nodePath.default.join(__dirname, '..', '..', '..', 'assets', 'dev-env.nginx.template.conf.ejs');
+const nginxTemplateAssetKey = 'dev-env.nginx.template.conf.ejs';
 const landoFileName = '.lando.yml';
 const landoOverridesFileName = '.lando.local.yml';
 const landoBackupFileName = '.lando.backup.yml';
@@ -58,6 +60,53 @@ const integrationsConfigBackupFileName = 'integrations.json.bak';
 const uploadPathString = 'uploads';
 const nginxPathString = 'nginx';
 const integrationsConfigPathString = 'integrations-config';
+const STARTUP_READY_ATTEMPTS = 6;
+const STARTUP_READY_DELAY_MS = 2000;
+let dockerComposifyFromLando = null;
+const dockerComposify = value => {
+  if (!dockerComposifyFromLando) {
+    const landoUtils = (0, _landoLoader.loadLandoModule)('lando/lib/utils');
+    dockerComposifyFromLando = landoUtils.dockerComposify;
+  }
+  return dockerComposifyFromLando(value);
+};
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+let seaModulePromise = null;
+const getSeaModule = async () => {
+  if (!seaModulePromise) {
+    seaModulePromise = (async () => {
+      try {
+        return await import('node:sea');
+      } catch {
+        return null;
+      }
+    })();
+  }
+  return seaModulePromise;
+};
+const renderTemplateFile = async (filePath, assetKey, templateData) => {
+  const sea = await getSeaModule();
+  if (sea?.isSea?.() && sea.getAsset) {
+    const template = sea.getAsset(assetKey, 'utf8');
+    if (typeof template === 'string') {
+      return _ejs.default.render(template, templateData);
+    }
+  }
+  return _ejs.default.renderFile(filePath, templateData);
+};
+async function waitForEnvironmentToBeUp(lando, instancePath) {
+  return pollEnvironmentUpStatus(lando, instancePath, 1);
+}
+async function pollEnvironmentUpStatus(lando, instancePath, attempt) {
+  if (await (0, _devEnvironmentLando.isEnvUp)(lando, instancePath)) {
+    return true;
+  }
+  if (attempt >= STARTUP_READY_ATTEMPTS) {
+    return false;
+  }
+  await sleep(STARTUP_READY_DELAY_MS);
+  return pollEnvironmentUpStatus(lando, instancePath, attempt + 1);
+}
 async function startEnvironment(lando, slug, options) {
   debug('Will start an environment', slug);
   const instancePath = getEnvironmentPath(slug);
@@ -82,6 +131,15 @@ async function startEnvironment(lando, slug, options) {
   } else {
     await (0, _devEnvironmentLando.landoRebuild)(lando, instancePath);
   }
+  let isEnvironmentUp = await waitForEnvironmentToBeUp(lando, instancePath);
+  if (!isEnvironmentUp) {
+    // A second startup pass helps recover after Docker network auto-cleanup edge cases.
+    await (0, _devEnvironmentLando.landoStart)(lando, instancePath);
+    isEnvironmentUp = await waitForEnvironmentToBeUp(lando, instancePath);
+  }
+  if (!isEnvironmentUp) {
+    throw new _userError.default(`Environment "${slug}" did not reach a running state. Please try "${_chalk.default.bold(`vip dev-env start --slug ${slug}`)}" again.`);
+  }
   await printEnvironmentInfo(lando, slug, {
     extended: false
   });
@@ -166,7 +224,7 @@ async function destroyEnvironment(lando, slug, removeFiles) {
   } else {
     debug("Lando file doesn't exist, skipping lando destroy.");
   }
-  await _nodeFs.default.promises.rm(_nodePath.default.join((0, _xdgData.xdgData)(), 'vip', 'lando', 'compose', (0, _utils.dockerComposify)(slug)), {
+  await _nodeFs.default.promises.rm(_nodePath.default.join((0, _xdgData.xdgData)(), 'vip', 'lando', 'compose', dockerComposify(slug)), {
     force: true,
     recursive: true
   });
@@ -349,8 +407,8 @@ async function prepareLandoEnv(lando, instanceData, instancePath, integrationsCo
     ...instanceData,
     domain: lando.config.domain
   };
-  const landoFile = await _ejs.default.renderFile(landoFileTemplatePath, templateData);
-  const nginxFile = await _ejs.default.renderFile(nginxFileTemplatePath, templateData);
+  const landoFile = await renderTemplateFile(landoFileTemplatePath, landoTemplateAssetKey, templateData);
+  const nginxFile = await renderTemplateFile(nginxFileTemplatePath, nginxTemplateAssetKey, templateData);
   const instanceDataFile = JSON.stringify(instanceData);
   const landoFileTargetPath = _nodePath.default.join(instancePath, landoFileName);
   const landoOverridesFileTargetPath = _nodePath.default.join(instancePath, landoOverridesFileName);

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

@@ -18,10 +18,6 @@ exports.removeProxyCache = removeProxyCache;
 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");
@@ -31,6 +27,8 @@ 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"));
@@ -43,6 +41,44 @@ 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;
@@ -146,7 +182,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('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('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)), '===', '', ''];
   await (0, _promises2.writeFile)(logFilePath, bannerLines.join('\n'), {
     flag: 'a'
   });
@@ -157,7 +193,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)(require.resolve('lando')));
+  const landoPath = (0, _nodePath.dirname)((0, _nodePath.dirname)((0, _landoLoader.resolveLandoModule)('lando')));
   debug(`Getting Lando config, using paths '${landoPath}' for plugins`);
   const isLandoDebugSelected = _debug.default.enabled(DEBUG_KEY);
   const isAllDebugSelected = _debug.default.enabled('"*"');
@@ -201,7 +237,7 @@ async function getLandoConfig(options = {}) {
       LANDO_HOST_GROUP_ID: process.platform === 'win32' ? '1000' : `${(0, _nodeOs.userInfo)().gid}`
     }
   };
-  return (0, _bootstrap.buildConfig)(config);
+  return getLandoBuildConfig()(config);
 }
 const appMap = new Map();
 async function initLandoApplication(lando, instancePath) {
@@ -290,7 +326,8 @@ async function bootstrapLando(options = {}) {
     }
     registerLogPathOutput(config, Boolean(options.quiet));
     await writeLogBanner(config);
-    const lando = new _lando.default(config);
+    const LandoClass = getLandoConstructor();
+    const lando = new LandoClass(config);
     _debug.default.log = (message, ...args) => {
       lando.log.debug(message, ...args);
     };
@@ -425,7 +462,7 @@ async function landoInfo(lando, instancePath, options = {}) {
   const started = new Date();
   try {
     const app = await getLandoApplication(lando, instancePath);
-    const info = _utils.default.startTable(app);
+    const info = getLandoUtils().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);
@@ -638,7 +675,7 @@ async function landoExec(lando, instancePath, toolName, args, options) {
     if (options.stdio) {
       tool.stdio = options.stdio;
     }
-    const task = (0, _build.default)(tool, lando);
+    const task = getLandoBuildTask()(tool, lando);
     const argv = {
       // eslint-disable-next-line id-length
       _: args

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

@@ -0,0 +1,48 @@
+"use strict";
+
+exports.__esModule = true;
+exports.loadLandoModule = loadLandoModule;
+exports.resolveLandoModule = resolveLandoModule;
+var _nodeFs = require("node:fs");
+var _nodeModule = require("node:module");
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _package = _interopRequireDefault(require("../../../package.json"));
+var _xdgData = require("../xdg-data");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const SEA_RUNTIME_DIR_NAME = 'sea-runtime';
+let cachedRequire = null;
+let didResolveRequire = false;
+const baseRequire = (0, _nodeModule.createRequire)(__filename);
+function isSeaRuntime() {
+  try {
+    const sea = baseRequire('node:sea');
+    return Boolean(sea?.isSea?.());
+  } catch {
+    return false;
+  }
+}
+function getSeaRuntimeNodeModulesPath() {
+  return _nodePath.default.join((0, _xdgData.xdgData)(), 'vip', SEA_RUNTIME_DIR_NAME, _package.default.version, 'node_modules');
+}
+function getRuntimeRequire() {
+  if (didResolveRequire && cachedRequire) {
+    return cachedRequire;
+  }
+  didResolveRequire = true;
+  if (isSeaRuntime()) {
+    const runtimeNodeModulesPath = getSeaRuntimeNodeModulesPath();
+    if ((0, _nodeFs.existsSync)(runtimeNodeModulesPath)) {
+      const runtimeEntryPath = _nodePath.default.join(runtimeNodeModulesPath, '..', '__sea-entry__.js');
+      cachedRequire = (0, _nodeModule.createRequire)(runtimeEntryPath);
+      return cachedRequire;
+    }
+  }
+  cachedRequire = baseRequire;
+  return cachedRequire;
+}
+function loadLandoModule(request) {
+  return getRuntimeRequire()(request);
+}
+function resolveLandoModule(request) {
+  return getRuntimeRequire().resolve(request);
+}