@wordpress/env 10.39.0 → 11.0.1-next.v.0

package/README.md

@@ -498,16 +498,36 @@ Options:
   --watch    Watch for logs as they happen.            [boolean] [default: true]
 ```
 
-### `wp-env install-path`
+### `wp-env status`
 
-Get the path where all of the environment files are stored. This includes the Docker files, WordPress, PHPUnit files, and any sources that were downloaded.
+Get the status of the wp-env environment including whether it's running, URLs, ports, and configuration.
 
 Example:
 
 ```sh
-$ wp-env install-path
+$ wp-env status
 
-/home/user/.wp-env/63263e6506becb7b8613b02d42280a49
+status: running
+    - runtime: docker
+    - install path: /home/user/.wp-env/63263e6506becb7b8613b02d42280a49
+    - config: /home/user/my-plugin
+
+environment:
+        - url: http://localhost:8888
+        - multisite: no
+        - xdebug: off
+        - http port: 8888
+        - mysql port: 13306
+        - test http port: 8889
+```
+
+```sh
+$ wp-env status --help
+Get the status of the wp-env environment including URLs, ports, and configuration.
+
+Options:
+  --debug    Enable debug output.                      [boolean] [default: false]
+  --json     Output status as JSON.                    [boolean] [default: false]
 ```
 
 ## .wp-env.json

package/lib/cli.js

@@ -258,10 +258,16 @@ module.exports = function cli() {
 		withSpinner( env.destroy )
 	);
 	yargs.command(
-		'install-path',
-		'Get the path where all of the environment files are stored. This includes the Docker files, WordPress, PHPUnit files, and any sources that were downloaded.',
-		() => {},
-		withSpinner( env.installPath )
+		'status',
+		'Get the status of the wp-env environment including URLs, ports, and configuration.',
+		( args ) => {
+			args.option( 'json', {
+				type: 'boolean',
+				describe: 'Output status as JSON.',
+				default: false,
+			} );
+		},
+		withSpinner( env.status )
 	);
 
 	return yargs;

package/lib/commands/index.js

@@ -8,7 +8,7 @@ const clean = require( './clean' );
 const run = require( './run' );
 const destroy = require( './destroy' );
 const logs = require( './logs' );
-const installPath = require( './install-path' );
+const status = require( './status' );
 
 module.exports = {
 	start,
@@ -17,5 +17,5 @@ module.exports = {
 	run,
 	destroy,
 	logs,
-	installPath,
+	status,
 };

package/lib/commands/status.js

@@ -0,0 +1,154 @@
+'use strict';
+/**
+ * External dependencies
+ */
+const path = require( 'path' );
+const { existsSync } = require( 'fs' );
+const chalk = require( 'chalk' );
+
+/**
+ * Internal dependencies
+ */
+const { loadConfig } = require( '../config' );
+const { getRuntime, detectRuntime } = require( '../runtime' );
+
+/**
+ * Check if an environment has been initialized by looking for runtime-specific files.
+ *
+ * @param {Object} config The wp-env configuration object.
+ * @return {boolean} True if the environment has been initialized.
+ */
+function isEnvironmentInitialized( config ) {
+	// Check for Docker's docker-compose.yml
+	if ( existsSync( config.dockerComposeConfigPath ) ) {
+		return true;
+	}
+
+	// Check for Playground's blueprint file
+	const playgroundBlueprintPath = path.join(
+		config.workDirectoryPath,
+		'playground-blueprint.json'
+	);
+	if ( existsSync( playgroundBlueprintPath ) ) {
+		return true;
+	}
+
+	return false;
+}
+
+/**
+ * Outputs the status of the wp-env environment.
+ *
+ * @param {Object}  options
+ * @param {Object}  options.spinner A CLI spinner which indicates progress.
+ * @param {boolean} options.debug   True if debug mode is enabled.
+ * @param {boolean} options.json    True to output as JSON.
+ */
+module.exports = async function status( { spinner, debug, json } ) {
+	spinner.text = 'Getting environment status.';
+
+	const config = await loadConfig( path.resolve( '.' ) );
+
+	// Check if environment is initialized by looking for runtime-specific files.
+	// We check for these files specifically because the work directory may exist
+	// just from caching the WordPress version, but these files are only created
+	// when `wp-env start` is actually run.
+	if ( ! isEnvironmentInitialized( config ) ) {
+		spinner.stop();
+		if ( json ) {
+			console.log(
+				JSON.stringify( {
+					status: 'uninitialized',
+					installPath: config.workDirectoryPath,
+					configPath: config.configDirectoryPath,
+				} )
+			);
+		} else {
+			console.log( formatNotInitialized( config ) );
+		}
+		return;
+	}
+
+	// Detect and get runtime.
+	const runtimeName = detectRuntime( config.workDirectoryPath );
+	const runtime = getRuntime( runtimeName );
+
+	// Get status from runtime.
+	const statusData = await runtime.getStatus( config, { spinner, debug } );
+
+	spinner.stop();
+	if ( json ) {
+		console.log( JSON.stringify( statusData ) );
+	} else {
+		console.log( formatStatus( statusData ) );
+	}
+};
+
+/**
+ * Format status for human-readable output when not initialized.
+ *
+ * @param {Object} config The config object.
+ * @return {string} Formatted output.
+ */
+function formatNotInitialized( config ) {
+	const indent = '    - ';
+	return `
+${ chalk.bold( 'status' ) }: ${ chalk.red( 'uninitialized' ) }
+${ indent }install path: ${ chalk.dim( config.workDirectoryPath ) }
+${ indent }config: ${ chalk.dim( config.configDirectoryPath ) }
+
+${ chalk.dim( 'Run `wp-env start` to initialize the environment.' ) }
+`;
+}
+
+/**
+ * Format status data for human-readable output.
+ *
+ * @param {Object} status The status object from runtime.
+ * @return {string} Formatted output.
+ */
+function formatStatus( status ) {
+	const statusColor = status.status === 'running' ? chalk.green : chalk.red;
+	const indent = '    - ';
+
+	let output = `
+${ chalk.bold( 'status' ) }: ${ statusColor( status.status ) }
+${ indent }runtime: ${ chalk.dim( status.runtime ) }
+${ indent }install path: ${ chalk.dim( status.installPath ) }
+${ indent }config: ${ chalk.dim( status.configPath ) }
+`;
+
+	// Environment section.
+	output += `\n${ chalk.bold( 'environment' ) }:\n`;
+	if ( status.urls?.development ) {
+		output += `${ indent }url: ${ chalk.dim( status.urls.development ) }\n`;
+	}
+	output += `${ indent }multisite: ${ chalk.dim(
+		status.config?.multisite ? 'yes' : 'no'
+	) }\n`;
+	output += `${ indent }xdebug: ${ chalk.dim(
+		status.config?.xdebug || 'off'
+	) }\n`;
+	if ( status.ports?.development ) {
+		output += `${ indent }http port: ${ chalk.dim(
+			status.ports.development
+		) }\n`;
+	}
+	if ( status.urls?.phpmyadmin ) {
+		output += `${ indent }phpmyadmin url: ${ chalk.dim(
+			status.urls.phpmyadmin
+		) }\n`;
+	}
+	if ( status.ports?.mysql ) {
+		output += `${ indent }mysql port: ${ chalk.dim(
+			status.ports.mysql
+		) }\n`;
+	}
+	if ( status.ports?.tests ) {
+		output += `${ indent }test http port: ${ chalk.dim(
+			status.ports.tests
+		) }\n`;
+	}
+
+	return output;
+}

package/lib/runtime/docker/index.js

@@ -577,6 +577,74 @@ class DockerRuntime {
 		spinner.text = 'Finished showing logs.';
 	}
 
+	/**
+	 * Get the status of the Docker environment.
+	 *
+	 * @param {WPConfig} config          The wp-env config object.
+	 * @param {Object}   options         Status options.
+	 * @param {Object}   options.spinner A CLI spinner which indicates progress.
+	 * @param {boolean}  options.debug   True if debug mode is enabled.
+	 * @return {Promise<Object>} Status object with environment information.
+	 */
+	async getStatus( config, { spinner, debug } ) {
+		spinner.text = 'Getting environment status.';
+
+		const fullConfig = await initConfig( { spinner, debug } );
+		const dockerComposeConfig = {
+			config: fullConfig.dockerComposeConfigPath,
+			log: debug,
+		};
+
+		// Check if containers are running by trying to get a port.
+		let isRunning = false;
+		let mySQLPort = null;
+		let phpmyadminPort = null;
+
+		try {
+			mySQLPort = await this._getPublicDockerPort(
+				'mysql',
+				3306,
+				dockerComposeConfig
+			);
+			isRunning = true;
+
+			if ( fullConfig.env.development.phpmyadminPort ) {
+				phpmyadminPort = await this._getPublicDockerPort(
+					'phpmyadmin',
+					80,
+					dockerComposeConfig
+				);
+			}
+		} catch {
+			// Containers are not running.
+		}
+
+		const siteUrl = fullConfig.env.development.config.WP_SITEURL;
+
+		return {
+			status: isRunning ? 'running' : 'stopped',
+			runtime: 'docker',
+			urls: {
+				development: isRunning ? siteUrl : null,
+				phpmyadmin:
+					isRunning && phpmyadminPort
+						? `http://localhost:${ phpmyadminPort }`
+						: null,
+			},
+			ports: {
+				development: fullConfig.env.development.port,
+				tests: fullConfig.env.tests.port,
+				mysql: mySQLPort,
+			},
+			config: {
+				multisite: fullConfig.env.development.multisite,
+				xdebug: fullConfig.xdebug || 'off',
+			},
+			configPath: fullConfig.configDirectoryPath,
+			installPath: fullConfig.workDirectoryPath,
+		};
+	}
+
 	/**
 	 * Runs an arbitrary command on the given Docker container.
 	 *

package/lib/runtime/playground/index.js

@@ -384,6 +384,56 @@ class PlaygroundRuntime {
 		spinner.text = 'Cleaned WordPress Playground environment.';
 	}
 
+	/**
+	 * Get the status of the Playground environment.
+	 *
+	 * @param {Object} config          The wp-env config object.
+	 * @param {Object} options         Status options.
+	 * @param {Object} options.spinner A CLI spinner which indicates progress.
+	 * @return {Promise<Object>} Status object with environment information.
+	 */
+	async getStatus( config, { spinner } ) {
+		spinner.text = 'Getting environment status.';
+
+		const envConfig = config.env.development;
+		const port = envConfig.port || 8888;
+		const pidFile = path.join( config.workDirectoryPath, 'playground.pid' );
+
+		// Check if server is running.
+		let isRunning = false;
+
+		try {
+			const pidContent = await fs.readFile( pidFile, 'utf8' );
+			const pid = parseInt( pidContent.trim(), 10 );
+
+			// Check if process is still alive.
+			process.kill( pid, 0 );
+
+			// Check if server is responding.
+			await this._checkServer( port );
+			isRunning = true;
+		} catch {
+			// Process not running or server not responding.
+		}
+
+		return {
+			status: isRunning ? 'running' : 'stopped',
+			runtime: 'playground',
+			urls: {
+				development: isRunning ? `http://localhost:${ port }` : null,
+			},
+			ports: {
+				development: port,
+			},
+			config: {
+				multisite: envConfig.multisite,
+				xdebug: 'off',
+			},
+			configPath: config.configDirectoryPath,
+			installPath: config.workDirectoryPath,
+		};
+	}
+
 	/**
 	 * Show logs from the Playground environment.
 	 *

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@wordpress/env",
-	"version": "10.39.0",
+	"version": "11.0.1-next.v.0+5aba098fc",
 	"description": "A zero-config, self contained local WordPress environment for development and testing.",
 	"author": "The WordPress Contributors",
 	"license": "GPL-2.0-or-later",
@@ -64,5 +64,5 @@
 	"scripts": {
 		"test": "echo \"Error: run tests from root\" && exit 1"
 	},
-	"gitHead": "eee1cfb1472f11183e40fb77465a5f13145df7ad"
+	"gitHead": "d730f9e00f5462d1b9d2660632850f5f43ccff44"
 }

package/lib/commands/install-path.js

@@ -1,33 +0,0 @@
-'use strict';
-/**
- * External dependencies
- */
-const path = require( 'path' );
-const { existsSync } = require( 'fs' );
-
-/**
- * Internal dependencies
- */
-const { loadConfig } = require( '../config' );
-
-/**
- * Logs the path to where wp-env files are installed.
- *
- * @param {Object} options
- * @param {Object} options.spinner
- */
-module.exports = async function installPath( { spinner } ) {
-	// Stop the spinner so that stdout is not polluted.
-	spinner.stop();
-
-	const config = await loadConfig( path.resolve( '.' ) );
-
-	if ( ! existsSync( config.workDirectoryPath ) ) {
-		console.error(
-			'wp-env has not yet been initialized. Please run `wp-env start` first.'
-		);
-		process.exit( 1 );
-	}
-
-	console.log( config.workDirectoryPath );
-};