/**

private static $logger;

/**

private static $hooks = [];

/**

private static $hooks_passed = [];

/**

private static $capture_exit = false;

/**

private static $deferred_additions = [];

/**

private static $global_arg_names;

/**

public static function set_logger( $logger ) {

self::$logger = $logger;

}

/**

public static function get_logger() {

return self::$logger;

}

/**

public static function get_configurator() {

static $configurator;

if ( ! $configurator ) {

$configurator = new Configurator( WP_CLI_ROOT . '/php/config-spec.php' );

}

return $configurator;

}

/**

public static function get_root_command() {

static $root;

if ( ! $root ) {

$root = new RootCommand();

}

return $root;

}

/**

public static function get_runner() {

static $runner;

if ( ! $runner ) {

$runner = new Runner();

}

return $runner;

}

/**

public static function get_cache() {

static $cache;

if ( ! $cache ) {

$dir = Utils\get_cache_dir();

$ttl = (int) Utils\get_env_or_config( 'WP_CLI_CACHE_EXPIRY' ) ? : 15552000;

$max_size = (int) Utils\get_env_or_config( 'WP_CLI_CACHE_MAX_SIZE' ) ? : 314572800;

// 6 months, 300mb

$cache = new FileCache( $dir, $ttl, $max_size );

// Clean older files on shutdown with 1/50 probability.

// phpcs:ignore WordPress.WP.AlternativeFunctions.rand_mt_rand -- no crypto and WP not loaded.

if ( 0 === mt_rand( 0, 50 ) ) {

register_shutdown_function(

function () use ( $cache ) {

$cache->clean();

}

);

}

}

return $cache;

}

/**

public static function set_url( $url ) {

self::debug( 'Set URL: ' . $url, 'bootstrap' );

$url_parts = Utils\parse_url( $url );

if ( is_array( $url_parts ) ) {

self::set_url_params( $url_parts );

}

}

/**

private static function set_url_params( $url_parts ) {

$f = function ( $key ) use ( $url_parts ) {

return Utils\get_flag_value( $url_parts, $key, '' );

};

if ( isset( $url_parts['host'] ) ) {

if ( isset( $url_parts['scheme'] ) && 'https' === strtolower( (string) $url_parts['scheme'] ) ) {

$_SERVER['HTTPS'] = 'on';

} elseif ( ! self::get_config( 'assume-https' ) ) {

unset( $_SERVER['HTTPS'] );

}

$_SERVER['HTTP_HOST'] = (string) $url_parts['host'];

if ( isset( $url_parts['port'] ) ) {

$_SERVER['HTTP_HOST'] .= ':' . (string) $url_parts['port'];

}

$_SERVER['SERVER_NAME'] = (string) $url_parts['host'];

}

$_SERVER['REQUEST_URI'] = $f( 'path' ) . ( isset( $url_parts['query'] ) ? '?' . (string) $url_parts['query'] : '' );

$_SERVER['SERVER_PORT'] = Utils\get_flag_value( $url_parts, 'port', '80' );

$_SERVER['QUERY_STRING'] = $f( 'query' );

}

/**

public static function get_http_cache_manager() {

static $http_cacher;

if ( ! $http_cacher ) {

$http_cacher = new WpHttpCacheManager( self::get_cache() );

}

return $http_cacher;

}

/**

public static function colorize( $string ) {

return Colors::colorize( $string, self::get_runner()->in_color() );

}

/**

public static function add_hook( $when, $callback ) {

if ( array_key_exists( $when, self::$hooks_passed ) ) {

self::debug(

sprintf(

'Immediately invoking on passed hook "%s": %s',

$when,

Utils\describe_callable( $callback )

),

'hooks'

);

call_user_func_array( $callback, (array) self::$hooks_passed[ $when ] );

}

self::$hooks[ $when ][] = $callback;

}

/**

public static function do_hook( $when, ...$args ) {

self::$hooks_passed[ $when ] = $args;

$has_args = count( $args ) > 0;

if ( ! isset( self::$hooks[ $when ] ) ) {

if ( $has_args ) {

return $args[0];

}

return null;

}

self::debug(

sprintf(

'Processing hook "%s" with %d callbacks',

$when,

count( self::$hooks[ $when ] )

),

'hooks'

);

foreach ( self::$hooks[ $when ] as $callback ) {

self::debug(

sprintf(

'On hook "%s": %s',

$when,

Utils\describe_callable( $callback )

),

'hooks'

);

if ( $has_args ) {

$return_value = $callback( ...$args );

if ( isset( $return_value ) ) {

$args[0] = $return_value;

}

} else {

$callback();

}

}

if ( $has_args ) {

return $args[0];

}

return null;

}

/**

public static function add_wp_hook( $tag, $function_to_add, $priority = 10, $accepted_args = 1 ) {

global $wp_filter, $merged_filters;

if ( function_exists( 'add_filter' ) ) {

add_filter( $tag, $function_to_add, $priority, $accepted_args );

} else {

$idx = self::wp_hook_build_unique_id( $function_to_add );

// phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited -- This is intentional & the purpose of this function.

$wp_filter[ $tag ][ $priority ][ $idx ] = [

'function' => $function_to_add,

'accepted_args' => $accepted_args,

];

unset( $merged_filters[ $tag ] );

}

return true;

}

/**

private static function wp_hook_build_unique_id( $function ) {

if ( is_string( $function ) ) {

return $function;

}

if ( is_object( $function ) ) {

// Closures are currently implemented as objects.

return (string) spl_object_id( $function );

}

$function = (array) $function;

if ( ! isset( $function[1] ) || ! is_string( $function[1] ) ) {

return false;

}

if ( is_object( $function[0] ) ) {

// Object Class Calling.

return ( (string) spl_object_id( $function[0] ) ) . $function[1];

}

if ( is_string( $function[0] ) ) {

// Static Calling.

return $function[0] . '::' . $function[1];

}

return false;

}

/**

private static function is_class_loadable_without_autoloading( $class_name ) {

if ( class_exists( $class_name, false ) ) {

return true;

}

foreach ( spl_autoload_functions() ?: [] as $autoloader ) {

if ( is_array( $autoloader ) && $autoloader[0] instanceof \Composer\Autoload\ClassLoader

&& $autoloader[0]->findFile( ltrim( $class_name, '\\' ) ) ) {

return true;

}

}

return false;

}

/**

public static function add_command( $name, $callable, $args = [] ) {

// Bail immediately if the WP-CLI executable has not been run.

if ( ! defined( 'WP_CLI' ) ) {

return false;

}

// Commands registered by class name are only loaded once they are actually needed,

// unless arguments are passed that require inspecting the command right away.

$is_lazy = is_string( $callable )

&& false === strpos( $callable, '::' )

&& ! function_exists( $callable )

&& self::is_class_loadable_without_autoloading( $callable )

&& ! array_intersect( [ 'shortdesc', 'longdesc', 'synopsis', 'when' ], array_keys( $args ) )

&& ! getenv( 'WP_CLI_DISABLE_LAZY_COMMANDS' );

$valid = false;

if ( $is_lazy ) {

// Validated once the command is materialized.

$valid = true;

} elseif ( is_callable( $callable ) ) {

$valid = true;

} elseif ( is_string( $callable ) && class_exists( $callable ) ) {

$valid = true;

} elseif ( is_object( $callable ) ) {

$valid = true;

} elseif ( is_array( $callable ) && Utils\is_valid_class_and_method_pair( $callable ) ) {

$valid = true;

}

if ( ! $valid ) {

if ( is_array( $callable ) ) {

$callable[0] = is_object( $callable[0] ) ? get_class( $callable[0] ) : $callable[0];

$callable = [ $callable[0], $callable[1] ];

}

self::error( sprintf( 'Callable %s does not exist, and cannot be registered as `wp %s`.', (string) json_encode( $callable ), $name ) );

}

$addition = new CommandAddition();

/**

self::do_hook( "before_add_command:{$name}", $addition );

if ( $addition->was_aborted() ) {

self::warning( "Aborting the addition of the command '{$name}' with reason: {$addition->get_reason()}." );

}

foreach ( [ 'before_invoke', 'after_invoke' ] as $when ) {

if ( isset( $args[ $when ] ) && is_callable( $args[ $when ] ) ) {

self::add_hook( "{$when}:{$name}", $args[ $when ] );

}

}

$path = preg_split( '/\s+/', $name ) ?: [];

$leaf_name = (string) array_pop( $path );

$command = self::get_root_command();

while ( ! empty( $path ) ) {

$subcommand_name = $path[0];

$parent = implode( ' ', $path );

$subcommand = $command->get_registered_subcommand( $subcommand_name );

if ( $subcommand ) {

array_shift( $path );

} else {

$subcommand = $command->find_subcommand( $path );

}

// Parent not found. Defer addition or create an empty container as

// needed.

if ( ! $subcommand ) {

if ( isset( $args['is_deferred'] ) && $args['is_deferred'] ) {

$subcommand = new CompositeCommand(

$command,

$subcommand_name,

new DocParser( '' )

);

self::debug(

"Adding empty container for deferred command: {$name}",

'commands'

);

$command->add_subcommand( $subcommand_name, $subcommand );

} else {

self::debug( "Deferring command: {$name}", 'commands' );

/**

self::defer_command_addition(

$name,

$parent,

$callable,

$args

);

return false;

}

}

$command = $subcommand;

}

$existing_command = $command->get_registered_subcommand( $leaf_name );

if ( $is_lazy && ! $addition->was_aborted() && ( ! $existing_command || $existing_command instanceof LazyCommand ) ) {

/** @var class-string $callable */

if ( $existing_command instanceof LazyCommand ) {

$existing_command->add_class( $callable );

} else {

$command->add_subcommand( $leaf_name, new LazyCommand( $command, $leaf_name, $callable ) );

}

self::debug( "Registering lazy command: {$name}", 'commands' );

/**

self::do_hook( "after_add_command:{$name}" );

return true;

}

if ( $is_lazy && ! class_exists( $callable ) ) {

self::error( sprintf( 'Callable %s does not exist, and cannot be registered as `wp %s`.', (string) json_encode( $callable ), $name ) );

}

$leaf_command = CommandFactory::create( $leaf_name, $callable, $command );

if ( $addition->was_aborted() ) {

$leaf_command = new DisabledCommand( $command, $leaf_name, $leaf_command->get_docparser(), $addition->get_reason() );

}

// Only add a command namespace if the command itself does not exist yet.

if ( $leaf_command instanceof CommandNamespace

&& false !== $command->get_registered_subcommand( $leaf_name ) ) {

return false;

}

// Reattach commands attached to namespace to real command.

$subcommand_name = (array) $leaf_name;

$existing_command = $command->get_registered_subcommand( $leaf_name );

if ( $existing_command instanceof LazyCommand ) {

$existing_command = $command->find_subcommand( $subcommand_name );

}

if ( $existing_command instanceof CompositeCommand && $existing_command->can_have_subcommands() ) {

if ( $leaf_command instanceof CommandNamespace || ! $leaf_command->can_have_subcommands() ) {

$command_to_keep = $existing_command;

} else {

$command_to_keep = $leaf_command;

}

self::merge_sub_commands( $command_to_keep, $existing_command, $leaf_command );

}

/** @var Dispatcher\Subcommand|Dispatcher\CompositeCommand|Dispatcher\CommandNamespace $leaf_command */

if ( ! $command->can_have_subcommands() ) {

throw new Exception(

sprintf(

"'%s' can't have subcommands.",

implode( ' ', Dispatcher\get_path( $command ) )

)

);

}

/** @var Dispatcher\Subcommand $leaf_command */

if ( isset( $args['shortdesc'] ) && is_string( $args['shortdesc'] ) ) {

$leaf_command->set_shortdesc( $args['shortdesc'] );

}

if ( isset( $args['longdesc'] ) && is_string( $args['longdesc'] ) ) {

$leaf_command->set_longdesc( $args['longdesc'] );

}

if ( isset( $args['synopsis'] ) ) {

if ( is_string( $args['synopsis'] ) ) {

$leaf_command->set_synopsis( $args['synopsis'] );

} elseif ( is_array( $args['synopsis'] ) ) {

/** @var array<int, array<string, mixed>> $synopsis_array */

$synopsis_array = $args['synopsis'];

$synopsis = SynopsisParser::render( $synopsis_array );

$leaf_command->set_synopsis( $synopsis );

$long_desc = '';

$bits = explode( ' ', $synopsis );

foreach ( $synopsis_array as $key => $arg ) {

$long_desc .= $bits[ $key ] . "\n";

if ( ! empty( $arg['description'] ) && is_string( $arg['description'] ) ) {

$long_desc .= ': ' . $arg['description'] . "\n";

}

$yamlify = [];

foreach ( [ 'default', 'options' ] as $_key ) {

if ( isset( $arg[ $_key ] ) ) {

$yamlify[ $_key ] = $arg[ $_key ];

}

}

if ( ! empty( $yamlify ) ) {

$long_desc .= Spyc::YAMLDump( $yamlify );

$long_desc .= '---' . "\n";

}

$long_desc .= "\n";

}

if ( ! empty( $long_desc ) ) {

$long_desc = rtrim( $long_desc, "\r\n" );

$long_desc = '## OPTIONS' . "\n\n" . $long_desc;

if ( ! empty( $args['longdesc'] ) && is_string( $args['longdesc'] ) ) {

$long_desc .= "\n\n" . ltrim( $args['longdesc'], "\r\n" );

}

$leaf_command->set_longdesc( $long_desc );

}

}

}

if ( isset( $args['when'] ) && is_string( $args['when'] ) ) {

self::get_runner()->register_early_invoke( $args['when'], $leaf_command );

}

$command_type = $leaf_command instanceof CommandNamespace ? 'namespace' : 'command';

if ( ! empty( $parent ) ) {

$sub_command = trim( str_replace( $parent, '', $name ) );

self::debug( "Adding {$command_type}: {$sub_command} in {$parent} Namespace", 'commands' );

} else {

self::debug( "Adding {$command_type}: {$name}", 'commands' );

}

$command->add_subcommand( $leaf_name, $leaf_command );

/**

self::do_hook( "after_add_command:{$name}" );

return true;

}

/**

private static function merge_sub_commands(

CompositeCommand $command_to_keep,

CompositeCommand $old_command,

CompositeCommand $new_command

) {

foreach ( $old_command->get_subcommands() as $subname => $subcommand ) {

$command_to_keep->add_subcommand( $subname, $subcommand, false );

}

foreach ( $new_command->get_subcommands() as $subname => $subcommand ) {

$command_to_keep->add_subcommand( $subname, $subcommand, true );

}

}

/**

private static function defer_command_addition( $name, $parent, $callable, $args = [] ) {

$args['is_deferred'] = true;

self::$deferred_additions[ $name ] = [

'parent' => $parent,

'callable' => $callable,

'args' => $args,

];

self::add_hook(

"after_add_command:$parent",

function () use ( $name ) {

$deferred_additions = WP_CLI::get_deferred_additions();

if ( ! array_key_exists( $name, $deferred_additions ) || ! is_array( $deferred_additions[ $name ] ) ) {

return;

}

/** @var callable $callable */

$callable = $deferred_additions[ $name ]['callable'];

/** @var array<string, mixed> $args */

$args = $deferred_additions[ $name ]['args'];

WP_CLI::remove_deferred_addition( $name );

WP_CLI::add_command( $name, $callable, $args );

}

);

}

/**

public static function get_deferred_additions() {

return self::$deferred_additions;

}

/**

public static function remove_deferred_addition( $name ) {

if ( ! array_key_exists( $name, self::$deferred_additions ) ) {

self::warning( "Trying to remove a non-existent command addition '{$name}'." );

}

unset( self::$deferred_additions[ $name ] );

}

/**

public static function check_global_arg_conflicts( $command_name, $command ) {

$synopsis = $command->get_synopsis();

if ( ! $synopsis ) {

return;

}

// Check if command has opted out of this check

if ( self::command_skips_global_arg_check( $command ) ) {

return;

}

// Get global argument names from config spec (cached)

if ( null === self::$global_arg_names ) {

self::$global_arg_names = [];

foreach ( self::get_configurator()->get_spec() as $key => $details ) {

if ( false === $details['runtime'] ) {

continue;

}

if ( isset( $details['deprecated'] ) ) {

continue;

}

if ( isset( $details['hidden'] ) ) {

continue;

}

self::$global_arg_names[] = $key;

}

}

// Parse the command's synopsis to get its argument names

$synopsis_params = SynopsisParser::parse( $synopsis );

$conflicts = [];

foreach ( $synopsis_params as $param ) {

// Check assoc and flag types; generic type has no specific name to conflict

if ( in_array( $param['type'], [ 'assoc', 'flag' ], true ) && isset( $param['name'] ) ) {

if ( in_array( $param['name'], self::$global_arg_names, true ) ) {

$conflicts[] = $param['name'];

}

}

}

// Warn about any conflicts found

foreach ( $conflicts as $conflict ) {

self::warning(

sprintf(

"The `%s` command is registering an argument '--%s' that conflicts with a global argument of the same name.",

$command_name,

$conflict

)

);

}

}

/**

private static function command_skips_global_arg_check( $command ) {

$docparser = $command->get_docparser();

if ( ! $docparser ) {

return false;

}

return $docparser->has_tag( 'skipglobalargcheck' );

}

/**

public static function line( $message = '', $newline = true ) {

echo $message . ( $newline ? "\n" : '' );

}

/**

public static function log( $message, $newline = true ) {

if ( null === self::$logger ) {

return;

}

self::$logger->info( $message, $newline );

}

/**