@automattic/vip 3.12.2 → 3.14.0

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

@@ -23,6 +23,7 @@ exports.promptForComponent = promptForComponent;
 exports.promptForMultisite = promptForMultisite;
 exports.promptForPhpVersion = promptForPhpVersion;
 exports.promptForText = promptForText;
+exports.promptForURL = promptForURL;
 exports.promptForWordPress = promptForWordPress;
 exports.resolvePath = resolvePath;
 exports.resolvePhpVersion = resolvePhpVersion;
@@ -161,7 +162,7 @@ function processComponentOptionInput(passedParam, allowLocal) {
   }
   return {
     mode: 'image',
-    tag: param === 'demo' ? undefined : param
+    tag: param === 'demo' || param === 'image' ? undefined : param
   };
 }
 function getOptionsFromAppInfo(appInfo) {
@@ -190,6 +191,13 @@ function getOptionsFromAppInfo(appInfo) {
 // eslint-disable-next-line complexity
 async function promptForArguments(preselectedOptions, defaultOptions, suppressPrompts, create) {
   debug('Provided preselected', preselectedOptions, 'and default', defaultOptions);
+  let isVIPUser;
+  try {
+    const currentUser = await (0, _user.getCurrentUserInfo)(true);
+    isVIPUser = currentUser?.isVIP ?? false;
+  } catch (err) {
+    isVIPUser = false;
+  }
   if (suppressPrompts) {
     preselectedOptions = {
       ...defaultOptions,
@@ -208,7 +216,7 @@ async function promptForArguments(preselectedOptions, defaultOptions, suppressPr
     elasticsearch: false,
     php: preselectedOptions.php ? resolvePhpVersion(preselectedOptions.php) : await promptForPhpVersion(resolvePhpVersion(defaultOptions.php ?? _devEnvironment.DEV_ENVIRONMENT_DEFAULTS.phpVersion)),
     mariadb: preselectedOptions.mariadb ?? defaultOptions.mariadb,
-    mediaRedirectDomain: preselectedOptions.mediaRedirectDomain ?? '',
+    mediaRedirectDomain: preselectedOptions.mediaRedirectDomain ?? defaultOptions.mediaRedirectDomain ?? '',
     wordpress: {
       mode: 'image',
       tag: ''
@@ -241,16 +249,19 @@ async function promptForArguments(preselectedOptions, defaultOptions, suppressPr
     if (setMediaRedirectDomain) {
       instanceData.mediaRedirectDomain = defaultOptions.mediaRedirectDomain;
     }
-  }
-  instanceData.wordpress = await processWordPress((preselectedOptions.wordpress ?? '').toString(), (defaultOptions.wordpress ?? '').toString());
-  for (const component of _devEnvironment.DEV_ENVIRONMENT_COMPONENTS) {
-    const option = (preselectedOptions[component] ?? '').toString();
-    const defaultValue = (defaultOptions[component] ?? '').toString();
-
-    // eslint-disable-next-line no-await-in-loop
-    const result = await processComponent(component, option, defaultValue, suppressPrompts);
-    instanceData[component] = result;
-  }
+  } else if (!create && defaultOptions.mediaRedirectDomain) {
+    const mediaRedirectPromptText = 'URL to redirect for missing media files ("n" to disable)?';
+    const mediaRedirectDomain = await promptForURL(mediaRedirectPromptText, defaultOptions.mediaRedirectDomain);
+    instanceData.mediaRedirectDomain = mediaRedirectDomain;
+  }
+  instanceData.wordpress = await processWordPress(preselectedOptions.wordpress ?? '', defaultOptions.wordpress ?? '');
+  instanceData.appCode = await processComponent('appCode', preselectedOptions.appCode ?? '', defaultOptions.appCode ?? '', suppressPrompts, validateAppCodeLocalPath);
+  let preselectedMU = preselectedOptions.muPlugins;
+  const defaultMU = defaultOptions.muPlugins;
+  if (!preselectedMU && !isVIPUser && (!defaultMU || ['demo', 'image'].includes(defaultMU))) {
+    preselectedMU = 'image';
+  }
+  instanceData.muPlugins = await processComponent('muPlugins', preselectedMU ?? '', defaultMU ?? '', suppressPrompts, validateMuPluginsLocalPath);
   debug(`Processing elasticsearch with preselected "%s"`, preselectedOptions.elasticsearch);
   if ('elasticsearch' in preselectedOptions) {
     instanceData.elasticsearch = Boolean(preselectedOptions.elasticsearch);
@@ -295,48 +306,41 @@ async function processWordPress(preselectedValue, defaultValue) {
   debug(result);
   return result;
 }
-async function processComponent(component, preselectedValue, defaultValue, suppressPrompts = false) {
-  debug(`processing a component '${component}', with preselected/default - ${preselectedValue}/${defaultValue}`);
-  let result;
-  let allowLocal = true;
-  if (component === 'muPlugins') {
-    try {
-      const currentUser = await (0, _user.getCurrentUserInfo)(true);
-      allowLocal = currentUser?.isVIP ?? false;
-    } catch (err) {
-      allowLocal = false;
-    }
+async function processComponent(componentType, preselectedValue, defaultValue, suppressPrompts, localPathValidator) {
+  debug(`Processing the '${componentType}' component, with preselected = %s, default = %s`, preselectedValue, defaultValue);
+  const defaultObject = defaultValue ? processComponentOptionInput(defaultValue, true) : null;
+  if (preselectedValue && !suppressPrompts) {
+    console.log('%s Path to your local %s: %s', _chalk.default.green('✓'), componentDisplayNames[componentType], preselectedValue);
   }
-  const defaultObject = defaultValue ? processComponentOptionInput(defaultValue, allowLocal) : null;
-  if (preselectedValue) {
-    result = processComponentOptionInput(preselectedValue, allowLocal);
-    if (!suppressPrompts) {
-      console.log(`${_chalk.default.green('✓')} Path to your local ${componentDisplayNames[component]}: ${preselectedValue}`);
-    }
-  } else {
-    result = await promptForComponent(component, allowLocal, defaultObject);
+  let result = preselectedValue ? processComponentOptionInput(preselectedValue, true) : await promptForComponent(componentType, true, defaultObject);
+  debug(result);
+  if (result.mode === 'local') {
+    result = await validateLocalPath(result, localPathValidator, componentType, defaultObject);
   }
   debug(result);
-  while ('local' === result.mode) {
-    const resolvedPath = resolvePath(result.dir ?? '');
-    result.dir = resolvedPath;
+  return result;
+}
+async function validateLocalPath(config, validator, componentName, defaultObject) {
+  while (config.mode === 'local') {
+    const resolvedPath = resolvePath(config.dir ?? '');
+    config.dir = resolvedPath;
     const {
       result: isPathValid,
       message
-    } = validateLocalPath(component, resolvedPath);
+    } = validator(resolvedPath);
     if (isPathValid) {
       break;
     } else if (isStdinTTY) {
       console.log(_chalk.default.yellow('Warning:'), message);
       // eslint-disable-next-line no-await-in-loop
-      result = await promptForComponent(component, allowLocal, defaultObject);
+      config = await promptForComponent(componentName, true, defaultObject);
     } else {
       throw new Error(message);
     }
   }
-  return result;
+  return config;
 }
-function validateLocalPath(component, providedPath) {
+function validateMuPluginsLocalPath(providedPath) {
   if (!isNonEmptyDirectory(providedPath)) {
     const message = `Provided path "${providedPath}" does not point to a valid or existing directory.`;
     return {
@@ -344,24 +348,35 @@ function validateLocalPath(component, providedPath) {
       message
     };
   }
-  if (component === 'appCode') {
-    const files = ['languages', 'plugins', 'themes', 'private', 'images', 'client-mu-plugins', 'vip-config'];
-    const missingFiles = [];
-    for (const file of files) {
-      const filePath = _path.default.resolve(providedPath, file);
-      if (!(0, _nodeFs.existsSync)(filePath)) {
-        missingFiles.push(file);
-      }
-    }
-    if (missingFiles.length > 0) {
-      // eslint-disable-next-line max-len
-      const message = `Provided path "${providedPath}" is missing following files/folders: ${missingFiles.join(', ')}. Learn more: https://docs.wpvip.com/wordpress-skeleton/`;
-      return {
-        result: false,
-        message
-      };
+  return {
+    result: true,
+    message: ''
+  };
+}
+function validateAppCodeLocalPath(providedPath) {
+  if (!isNonEmptyDirectory(providedPath)) {
+    const message = `Provided path "${providedPath}" does not point to a valid or existing directory.`;
+    return {
+      result: false,
+      message
+    };
+  }
+  const files = ['languages', 'plugins', 'themes', 'private', 'images', 'client-mu-plugins', 'vip-config'];
+  const missingFiles = [];
+  for (const file of files) {
+    const filePath = _path.default.resolve(providedPath, file);
+    if (!(0, _nodeFs.existsSync)(filePath)) {
+      missingFiles.push(file);
     }
   }
+  if (missingFiles.length > 0) {
+    // eslint-disable-next-line max-len
+    const message = `Provided path "${providedPath}" is missing following files/folders: ${missingFiles.join(', ')}. Learn more: https://docs.wpvip.com/wordpress-skeleton/`;
+    return {
+      result: false,
+      message
+    };
+  }
   return {
     result: true,
     message: ''
@@ -399,6 +414,36 @@ async function promptForText(message, initial) {
   }
   return (result.input || '').trim();
 }
+async function promptForURL(message, initial) {
+  let result = {
+    input: initial
+  };
+  if (isStdinTTY) {
+    const URLValidator = value => {
+      if (!value.trim() || value === 'n') {
+        return true;
+      }
+      try {
+        const url = new URL(value);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+          return 'value must be a http:// or https:// URL';
+        }
+        return true;
+      } catch {
+        return 'value needs to be a valid URL or an empty string';
+      }
+    };
+    result = await (0, _enquirer.prompt)({
+      type: 'input',
+      name: 'input',
+      message,
+      initial,
+      validate: URLValidator
+    });
+  }
+  const retval = result.input.trim();
+  return retval === 'n' ? '' : retval;
+}
 const multisiteOptions = ['subdomain', 'subdirectory'];
 async function promptForMultisite(message, initial) {
   // `undefined` is used here only because our tests need overhauling
@@ -676,30 +721,92 @@ function getEnvTrackingInfo(slug) {
     };
   }
 }
+// Map of supported editors and their configurations
+const SUPPORTED_EDITORS = {
+  vscode: {
+    displayName: 'VS Code',
+    candidates: ['code', 'code-insiders', 'codium'],
+    workspace: {
+      extension: 'code-workspace',
+      generator: _devEnvironmentCore.generateVSCodeWorkspace
+    }
+  },
+  cursor: {
+    displayName: 'Cursor',
+    candidates: ['cursor'],
+    workspace: {
+      extension: 'code-workspace',
+      generator: _devEnvironmentCore.generateVSCodeWorkspace
+    }
+  },
+  phpstorm: {
+    displayName: 'PHPStorm',
+    candidates: ['phpstorm', 'phpstorm64.exe'],
+    errors: {
+      notFound: `PHPStorm launcher was not detected in the expected path.\nPlease follow the setup instructions: https://www.jetbrains.com/help/phpstorm/working-with-the-ide-features-from-command-line.html#standalone`
+    },
+    workspace: {
+      extension: 'iml',
+      generator: _devEnvironmentCore.generatePHPStormWorkspace
+    }
+  },
+  windsurf: {
+    displayName: 'Windsurf',
+    candidates: ['windsurf'],
+    workspace: {
+      extension: 'code-workspace',
+      generator: _devEnvironmentCore.generateVSCodeWorkspace
+    }
+  }
+};
+
+// Helper to get workspace path for any editor
+function getWorkspacePath(slug, editor) {
+  const {
+    workspace
+  } = SUPPORTED_EDITORS[editor];
+  if (editor === 'phpstorm') {
+    return _path.default.join((0, _devEnvironmentCore.getEnvironmentPath)(slug), '.idea', `${slug}.${workspace.extension}`);
+  }
+  return _path.default.join((0, _devEnvironmentCore.getEnvironmentPath)(slug), `${slug}.${workspace.extension}`);
+}
 function postStart(slug, options) {
-  if (options.openVSCode) {
-    launchVSCode(slug);
+  let editorType;
+  if (options.editor) {
+    const editor = options.editor.toLowerCase();
+    if (!Object.keys(SUPPORTED_EDITORS).includes(editor)) {
+      throw new Error(`Invalid editor specified. Supported editors are: ${Object.keys(SUPPORTED_EDITORS).join(', ')}`);
+    }
+    editorType = editor;
+  } else if (options.vscode) {
+    editorType = 'vscode';
+  }
+  if (editorType) {
+    launchEditor(slug, editorType);
   }
 }
-const launchVSCode = slug => {
-  const workspacePath = (0, _devEnvironmentCore.getVSCodeWorkspacePath)(slug);
+const launchEditor = (slug, type) => {
+  const editorConfig = SUPPORTED_EDITORS[type];
+  const workspacePath = getWorkspacePath(slug, type);
   if ((0, _nodeFs.existsSync)(workspacePath)) {
-    console.log('VS Code workspace already exists, skipping creation.');
+    console.log('Project already exists, skipping creation.');
   } else {
-    (0, _devEnvironmentCore.generateVSCodeWorkspace)(slug);
-    console.log('VS Code workspace generated');
-  }
-  const vsCodeExecutable = getVSCodeExecutable();
-  if (vsCodeExecutable) {
-    (0, _child_process.spawn)(vsCodeExecutable, [workspacePath], {
+    editorConfig.workspace.generator(slug);
+    console.log(`${editorConfig.displayName} project generated`);
+  }
+  console.log(`Project file location:\n${workspacePath}\n`);
+  const executable = findExecutable(editorConfig.candidates);
+  if (executable) {
+    // For PHPStorm, pass the environment home folder instead of the workspace path
+    const launchPath = type === 'phpstorm' ? (0, _devEnvironmentCore.getEnvironmentPath)(slug) : workspacePath;
+    (0, _child_process.spawn)(executable, [launchPath], {
       shell: process.platform === 'win32'
     });
   } else {
-    console.log(`VS Code was not detected in the expected path. VS Code Workspace file location:\n${workspacePath}`);
+    console.log(editorConfig.errors?.notFound || `${editorConfig.displayName} was not detected in the expected path.`);
   }
 };
-const getVSCodeExecutable = () => {
-  const candidates = ['code', 'code-insiders', 'codium'];
+const findExecutable = candidates => {
   for (const candidate of candidates) {
     const result = (0, _shelljs.which)(candidate);
     if (result) {

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

@@ -6,6 +6,7 @@ exports.destroyEnvironment = destroyEnvironment;
 exports.doesEnvironmentExist = doesEnvironmentExist;
 exports.exec = exec;
 exports.fetchVersionList = fetchVersionList;
+exports.generatePHPStormWorkspace = generatePHPStormWorkspace;
 exports.generateVSCodeWorkspace = generateVSCodeWorkspace;
 exports.getAllEnvironmentNames = getAllEnvironmentNames;
 exports.getApplicationInformation = getApplicationInformation;
@@ -23,7 +24,6 @@ exports.stopEnvironment = stopEnvironment;
 exports.updateEnvironment = updateEnvironment;
 exports.writeEnvironmentData = writeEnvironmentData;
 var _chalk = _interopRequireDefault(require("chalk"));
-var _copyDir = _interopRequireDefault(require("copy-dir"));
 var _debug = _interopRequireDefault(require("debug"));
 var _ejs = _interopRequireDefault(require("ejs"));
 var _enquirer = require("enquirer");
@@ -31,6 +31,7 @@ var _graphql = require("graphql");
 var _utils = require("lando/lib/utils");
 var _nodeFetch = _interopRequireDefault(require("node-fetch"));
 var _nodeFs = _interopRequireDefault(require("node:fs"));
+var _promises = require("node:fs/promises");
 var _nodePath = _interopRequireDefault(require("node:path"));
 var _semver = _interopRequireDefault(require("semver"));
 var _uuid = require("uuid");
@@ -69,11 +70,13 @@ function xdgDataDirectory() {
 async function startEnvironment(lando, slug, options) {
   debug('Will start an environment', slug);
   const instancePath = getEnvironmentPath(slug);
-  debug('Instance path for', slug, 'is:', instancePath);
+  debug('Instance path for %s is %s', slug, instancePath);
   const environmentExists = _nodeFs.default.existsSync(instancePath);
   if (!environmentExists) {
     throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
   }
+  const envFilePath = _nodePath.default.join(instancePath, '.env');
+  _nodeFs.default.appendFileSync(envFilePath, '');
   let updated = false;
   if (!options.skipWpVersionsCheck && process.stdin.isTTY) {
     updated = await maybeUpdateWordPressImage(lando, slug);
@@ -98,7 +101,7 @@ async function stopEnvironment(lando, slug) {
   }
   await (0, _devEnvironmentLando.landoStop)(lando, instancePath);
 }
-async function createEnvironment(lando, instanceData, integrationsConfig) {
+async function createEnvironment(lando, instanceData, integrationsConfig, envVars) {
   const slug = instanceData.siteSlug;
   integrationsConfig ??= {};
   debug('Will process an environment', slug, 'with instanceData for creation: ', instanceData);
@@ -110,7 +113,7 @@ async function createEnvironment(lando, instanceData, integrationsConfig) {
   }
   const preProcessedInstanceData = preProcessInstanceData(instanceData);
   debug('Will create an environment', slug, 'with instanceData: ', preProcessedInstanceData);
-  await prepareLandoEnv(lando, preProcessedInstanceData, instancePath, integrationsConfig);
+  await prepareLandoEnv(lando, preProcessedInstanceData, instancePath, integrationsConfig, envVars);
 }
 async function updateEnvironment(lando, instanceData) {
   const slug = instanceData.siteSlug;
@@ -123,7 +126,7 @@ async function updateEnvironment(lando, instanceData) {
   }
   const preProcessedInstanceData = preProcessInstanceData(instanceData);
   debug('Will create an environment', slug, 'with instanceData: ', preProcessedInstanceData);
-  await prepareLandoEnv(lando, preProcessedInstanceData, instancePath, undefined);
+  await prepareLandoEnv(lando, preProcessedInstanceData, instancePath, undefined, undefined);
 }
 function preProcessInstanceData(instanceData) {
   const newInstanceData = {
@@ -366,7 +369,7 @@ async function writeIntegrationsConfig(instancePath, integrationsConfig) {
     debug(`Integrations configuration file created in ${integrationsConfigTargetPath}`);
   }
 }
-async function prepareLandoEnv(lando, instanceData, instancePath, integrationsConfig) {
+async function prepareLandoEnv(lando, instanceData, instancePath, integrationsConfig, envVars) {
   const templateData = {
     ...instanceData,
     domain: lando.config.domain
@@ -380,6 +383,7 @@ async function prepareLandoEnv(lando, instanceData, instancePath, integrationsCo
   const nginxFolderPath = _nodePath.default.join(instancePath, nginxPathString);
   const nginxFileTargetPath = _nodePath.default.join(nginxFolderPath, nginxFileName);
   const instanceDataTargetPath = _nodePath.default.join(instancePath, instanceDataFileName);
+  const envFilePath = _nodePath.default.join(instancePath, '.env');
   await _nodeFs.default.promises.mkdir(instancePath, {
     recursive: true
   });
@@ -396,6 +400,15 @@ async function prepareLandoEnv(lando, instanceData, instancePath, integrationsCo
     }
   }
   await Promise.all([_nodeFs.default.promises.writeFile(landoFileTargetPath, landoFile), _nodeFs.default.promises.writeFile(nginxFileTargetPath, nginxFile), _nodeFs.default.promises.writeFile(instanceDataTargetPath, instanceDataFile)]);
+  if (envVars !== undefined) {
+    const env = [];
+    Object.entries(envVars ?? {}).forEach(([key]) => {
+      env.push(`VIP_ENV_VAR_${key}=`);
+    });
+    await _nodeFs.default.promises.writeFile(envFilePath, env.join('\n'));
+  } else {
+    await _nodeFs.default.promises.appendFile(envFilePath, '');
+  }
   debug(`Lando file created in ${landoFileTargetPath}`);
   debug(`Nginx file created in ${nginxFileTargetPath}`);
   debug(`Instance data file created in ${instanceDataTargetPath}`);
@@ -444,6 +457,11 @@ async function getApplicationInformation(appId, envType) {
 			type,
 			branch,
 			isMultisite,
+			environmentVariables {
+				nodes {
+					name
+				}
+			}
 			getIntegrationsDevEnvConfig {
 				data
 			}
@@ -486,6 +504,12 @@ async function getApplicationInformation(appId, envType) {
       envData = environments.find(candidateEnv => candidateEnv.type === env);
     }
     if (envData) {
+      const envVars = {};
+      envData.environmentVariables?.nodes?.forEach(envvar => {
+        if (envvar?.name) {
+          envVars[envvar.name] = '';
+        }
+      });
       appData.environment = {
         name: envData.name,
         branch: envData.branch,
@@ -494,7 +518,8 @@ async function getApplicationInformation(appId, envType) {
         primaryDomain: envData.primaryDomain?.name ?? '',
         php: envData.softwareSettings?.php?.current.version ?? '',
         wordpress: envData.softwareSettings?.wordpress?.current.version ?? '',
-        integrations: envData.getIntegrationsDevEnvConfig?.data ?? {}
+        integrations: envData.getIntegrationsDevEnvConfig?.data ?? {},
+        envVars
       };
     }
   }
@@ -536,7 +561,7 @@ async function importMediaPath(slug, filePath) {
   if (!(await doesEnvironmentExist(environmentPath))) {
     throw new Error(_devEnvironment.DEV_ENVIRONMENT_NOT_FOUND);
   }
-  const files = _nodeFs.default.readdirSync(resolvedPath);
+  const files = await (0, _promises.readdir)(resolvedPath);
   if (files.includes(uploadPathString)) {
     const confirm = await (0, _enquirer.prompt)({
       type: 'confirm',
@@ -549,8 +574,15 @@ async function importMediaPath(slug, filePath) {
   }
   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}.`);
+  try {
+    await (0, _promises.cp)(resolvedPath, uploadsPath, {
+      recursive: true
+    });
+    console.log(`${_chalk.default.green('✓')} Files successfully copied to ${uploadsPath}.`);
+  } catch (error) {
+    console.error(`${_chalk.default.red('✗')} Error copying files to ${uploadsPath}.`);
+    throw error;
+  }
 }
 
 /**
@@ -768,17 +800,27 @@ function generateVSCodeWorkspace(slug) {
       path: instanceData.appCode.dir
     });
   }
+
+  // Create debug configuration
+  const debugConfig = {
+    name: `Debug ${slug}`,
+    type: 'php',
+    request: 'launch',
+    port: 9003,
+    pathMappings
+  };
+
+  // Check if running under WSL and add hostname if needed
+  // This is to allow xdebug to work when running under WSL
+  if (process.env?.WSL_DISTRO_NAME) {
+    debug('WSL detected, adding hostname to debug configuration');
+    debugConfig.hostname = '0.0.0.0';
+  }
   const workspace = {
     folders,
     launch: {
       version: '0.2.0',
-      configurations: [{
-        name: `Debug ${slug}`,
-        type: 'php',
-        request: 'launch',
-        port: 9003,
-        pathMappings
-      }]
+      configurations: [debugConfig]
     }
   };
   _nodeFs.default.writeFileSync(workspacePath, JSON.stringify(workspace, null, 2));
@@ -796,7 +838,7 @@ const generatePathMappings = (location, instanceData) => {
     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/vip-config'] = _nodePath.default.resolve(instanceData.appCode.dir, 'vip-config');
   }
   pathMappings['/wp'] = _nodePath.default.resolve(location, 'wordpress');
   return pathMappings;
@@ -805,4 +847,88 @@ function getVSCodeWorkspacePath(slug) {
   const location = getEnvironmentPath(slug);
   const workspacePath = _nodePath.default.join(location, `${slug}.code-workspace`);
   return workspacePath;
+}
+
+/**
+ * Generates PHPStorm project configuration including debug settings
+ *
+ * @param {string} slug - The slug of the environment to generate PHPStorm config for
+ * @return {string} Project directory path
+ */
+function generatePHPStormWorkspace(slug) {
+  debug('Generating PHPStorm Workspace');
+  const location = getEnvironmentPath(slug);
+  // const location = location;
+  const instanceData = readEnvironmentData(slug);
+  const pathMappings = generatePathMappings(location, instanceData);
+
+  // Create .idea directory
+  _nodeFs.default.mkdirSync(_nodePath.default.join(location, '.idea', 'runConfigurations'), {
+    recursive: true
+  });
+
+  // Generate workspace.xml
+  const workspaceXml = `<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="PhpWorkspaceProjectConfiguration">
+    <include_path>
+      <path value="$PROJECT_DIR$/wordpress" />
+${instanceData?.muPlugins?.dir ? `<path value="${instanceData.muPlugins.dir}" />` : ''}
+${instanceData?.appCode?.dir ? `<path value="${instanceData.appCode.dir}" />` : ''}
+    </include_path>
+  </component>
+  <component name="PhpDebugGeneral" listening_started="true" />
+  <component name="PhpDebugXdebugSettings">
+    <debug_server_list>
+      <server host="localhost" port="9003" />
+    </debug_server_list>
+    <path_mappings>
+${Object.entries(pathMappings).map(([serverPath, localPath]) => `      <mapping local-root="${serverPath}" remote-root="$PROJECT_DIR$/${_nodePath.default.relative(location, localPath)}" />`).join('\n')}
+    </path_mappings>
+  </component>
+  <component name="PhpServers">
+    <servers>
+      <server host="localhost" id="${(0, _uuid.v4)()}" name="localhost" use_path_mappings="true">
+        <path_mappings>
+          <mapping local-root="$PROJECT_DIR$/wordpress" remote-root="/wp" />
+          ${Object.entries(pathMappings).map(([serverPath, localPath]) => `<mapping local-root="${localPath}" remote-root="${serverPath}" />`).join('\n')}
+        </path_mappings>
+      </server>
+    </servers>
+  </component>
+		<component name="WordPressConfiguration" enabled="true">
+    <wordpressPath>$PROJECT_DIR$/wordpress</wordpressPath>
+  </component>
+</project>`;
+  _nodeFs.default.writeFileSync(_nodePath.default.join(location, '.idea', 'workspace.xml'), workspaceXml);
+  const xdebugXml = `<component name="ProjectRunConfigurationManager">
+	<configuration default="false" name="VIP Debug" type="PhpRemoteDebugRunConfigurationType" factoryName="PHP Remote Debug" nameIsGenerated="true" filter_connections="NOT_FILTER" server_name="localhost" session_id="XDEBUG">
+		<method v="2" />
+  </configuration>
+</component>
+`;
+  _nodeFs.default.writeFileSync(_nodePath.default.join(location, '.idea', 'runConfigurations', 'vip-xdebug.xml'), xdebugXml);
+  const projectXml = `<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+	<component name="ProjectModuleManager">
+		<modules>
+			<module fileurl="file://$PROJECT_DIR$/.idea/${slug}.iml" filepath="$PROJECT_DIR$/.idea/${slug}.iml" />
+		</modules>
+	</component>
+</project>
+`;
+  _nodeFs.default.writeFileSync(_nodePath.default.join(location, '.idea', 'modules.xml'), projectXml);
+  const modulesXml = `<?xml version="1.0" encoding="UTF-8"?>
+	<module type="WEB_MODULE" version="4">
+		<component name="NewModuleRootManager">
+		<content url="file://$MODULE_DIR$/${_nodePath.default.relative(location, instanceData?.appCode?.dir ?? '')}" />
+		<content url="file://$MODULE_DIR$/${_nodePath.default.relative(location, instanceData?.muPlugins?.dir ?? '')}" />
+			<content url="file://$MODULE_DIR$" />
+			<orderEntry type="sourceFolder" forTests="false" />
+		<orderEntry type="inheritedJdk" />
+		</component>
+</module>
+`;
+  _nodeFs.default.writeFileSync(_nodePath.default.join(location, '.idea', slug + '.iml'), modulesXml);
+  return location;
 }

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

@@ -44,9 +44,7 @@ const debug = (0, _debug.default)(DEBUG_KEY);
 async function getLandoConfig() {
   // 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')));
-  // The path will be smth like `yarn/global/node_modules/@lando/compose/index.js`; we need the path up to `@lando` (inclusive)
-  const atLandoPath = (0, _nodePath.dirname)((0, _nodePath.dirname)(require.resolve('@lando/compose')));
-  debug(`Getting Lando config, using paths '${landoPath}' and '${atLandoPath}' for plugins`);
+  debug(`Getting Lando config, using paths '${landoPath}' for plugins`);
   const isLandoDebugSelected = _debug.default.enabled(DEBUG_KEY);
   const isAllDebugSelected = _debug.default.enabled('"*"');
   let logLevelConsole;
@@ -75,11 +73,7 @@ async function getLandoConfig() {
     landoFile: '.lando.yml',
     preLandoFiles: ['.lando.base.yml', '.lando.dist.yml', '.lando.upstream.yml'],
     postLandoFiles: ['.lando.local.yml'],
-    pluginDirs: [landoPath, {
-      path: atLandoPath,
-      subdir: '.',
-      namespace: '@lando'
-    }],
+    pluginDirs: [landoPath],
     disablePlugins: [],
     proxyName: 'vip-dev-env-proxy',
     userConfRoot: landoDir,

package/dist/lib/media-import/progress.js

@@ -2,7 +2,7 @@
 
 exports.__esModule = true;
 exports.MediaImportProgressTracker = void 0;
-var _singleLineLog = require("single-line-log");
+var _singleLineLog = require("@wwa/single-line-log");
 var _format = require("../../lib/cli/format");
 var _status = require("../../lib/media-import/status");
 const PRINT_INTERVAL = process.env.DEBUG ? 5000 : 200; // How often the report is printed. Mainly affects the "spinner" animation.