if ( ! Path::inside_phar( $path ) ) {

return $path;

}

$fname = Path::basename( $path );

$tmp_path = make_temp_file( 'wp-cli-extract-from-phar-', "-$fname" );

copy( $path, $tmp_path );

register_shutdown_function(

function () use ( $tmp_path ) {

if ( file_exists( $tmp_path ) ) {

unlink( $tmp_path );

}

}

);

return $tmp_path;

if ( Path::inside_phar() ) {

if ( file_exists( WP_CLI_ROOT . '/vendor/autoload.php' ) ) {

require WP_CLI_ROOT . '/vendor/autoload.php';

} elseif ( file_exists( dirname( dirname( WP_CLI_ROOT ) ) . '/autoload.php' ) ) {

require dirname( dirname( WP_CLI_ROOT ) ) . '/autoload.php';

}

return;

}

$has_autoload = false;

foreach ( get_vendor_paths() as $vendor_path ) {

if ( file_exists( $vendor_path . '/autoload.php' ) ) {

require $vendor_path . '/autoload.php';

$has_autoload = true;

break;

}

}

if ( ! $has_autoload ) {

fwrite( STDERR, "Internal error: Can't find Composer autoloader.\nTry running: composer install\n" );

exit( 3 );

}

$vendor_paths = [

WP_CLI_ROOT . '/../../../vendor', // Part of a larger project / installed via Composer (preferred).

WP_CLI_ROOT . '/vendor', // Top-level project / installed as Git clone.

];

$maybe_composer_json = WP_CLI_ROOT . '/../../../composer.json';

if ( file_exists( $maybe_composer_json ) && is_readable( $maybe_composer_json ) ) {

/**

$composer = json_decode( (string) file_get_contents( $maybe_composer_json ), false );

if ( ! empty( $composer->config ) && ! empty( $composer->config->{'vendor-dir'} ) ) {

array_unshift( $vendor_paths, WP_CLI_ROOT . '/../../../' . $composer->config->{'vendor-dir'} );

}

}

return $vendor_paths;

$path = WP_CLI_ROOT . "/php/commands/$name.php";

if ( is_readable( $path ) ) {

include_once $path;

}

if ( is_array( $it ) ) {

$it = new ArrayIterator( $it );

}

if ( ! method_exists( $it, 'add_transform' ) ) {

$it = new Transform( $it );

}

foreach ( $fns as $fn ) {

/**

$it->add_transform( $fn );

}

return $it;

$open_basedir = ini_get( 'open_basedir' );

if ( empty( $open_basedir ) ) {

return true;

}

// Normalize the path to check and remove trailing slashes.

$path = Path::normalize( $path );

$path = rtrim( $path, '/\\' );

$allowed_paths = explode( PATH_SEPARATOR, $open_basedir );

foreach ( $allowed_paths as $allowed ) {

if ( empty( $allowed ) ) {

continue;

}

// Normalize the allowed path using realpath (allowed paths should be accessible).

$allowed = rtrim( $allowed, '/\\' );

$real_allowed = realpath( $allowed );

if ( false !== $real_allowed ) {

$allowed = $real_allowed;

}

$allowed = Path::normalize( $allowed );

$allowed = rtrim( $allowed, '/\\' );

// Check if path starts with allowed directory.

// On Windows, use case-insensitive comparison as filesystem paths are case-insensitive.

$is_windows = is_windows();

if ( $is_windows ) {

if ( 0 === stripos( $path . '/', $allowed . '/' ) ) {

return true;

}

} elseif ( 0 === strpos( $path . '/', $allowed . '/' ) ) {

return true;

}

}

return false;

$files = (array) $files;

if ( is_null( $dir ) ) {

$dir = getcwd();

}

// Normalize the directory path using string operations to avoid filesystem access

// that could trigger open_basedir warnings

if ( false !== $dir ) {

$dir = Path::normalize( $dir );

}

while ( $dir && is_path_within_open_basedir( $dir ) && is_readable( $dir ) ) {

// Stop walking up when the supplied callable returns true being passed the $dir

if ( is_callable( $stop_check ) && call_user_func( $stop_check, $dir ) ) {

return null;

}

foreach ( $files as $file ) {

$path = $dir . DIRECTORY_SEPARATOR . $file;

if ( file_exists( $path ) ) {

return $path;

}

}

$parent_dir = dirname( $dir );

if ( empty( $parent_dir ) || $parent_dir === $dir ) {

break;

}

$dir = $parent_dir;

}

return null;

// Check if argument starts with ~/

if ( substr( $arg, 0, 2 ) === '~/' ) {

// Extract everything after ~/

$remainder = substr( $arg, 2 );

// Return ~/ followed by the escaped remainder

return '~/' . escapeshellarg( $remainder );

}

// For all other cases, use standard escapeshellarg

return escapeshellarg( $arg );

$str = '';

foreach ( $assoc_args as $key => $value ) {

if ( ! preg_match( '/\A[a-zA-Z0-9_:\.-]+\z/', (string) $key ) ) {

throw new InvalidArgumentException(

sprintf(

"Invalid associative argument key '%s'.",

$key

)

);

}

if ( true === $value ) {

$str .= " --$key";

} elseif ( is_array( $value ) ) {

foreach ( $value as $v ) {

$str .= assoc_args_to_str(

[

$key => $v,

],

$sensitive_args

);

}

} elseif ( in_array( $key, $sensitive_args, true ) ) {

// Mask the value if this is a sensitive argument

$str .= " --$key=" . escapeshellarg( '[REDACTED]' );

} else {

/**

$str .= " --$key=" . escapeshellarg( (string) $value );

}

}

return $str;

if ( func_num_args() < 2 ) {

trigger_error( 'esc_cmd() requires at least two arguments.', E_USER_WARNING );

}

return vsprintf( $cmd, array_map( 'escapeshellarg', $args ) );

static $path;

if ( null === $path ) {

$path = false;

$config_path = (string) getenv( 'WP_CONFIG_PATH' );

if ( $config_path && file_exists( $config_path ) ) {

$path = $config_path;

} elseif ( file_exists( ABSPATH . 'wp-config.php' ) ) {

$path = ABSPATH . 'wp-config.php';

} elseif ( file_exists( dirname( ABSPATH ) . '/wp-config.php' ) && ! file_exists( dirname( ABSPATH ) . '/wp-settings.php' ) ) {

$path = dirname( ABSPATH ) . '/wp-config.php';

}

if ( $path ) {

$path = realpath( $path );

}

}

return $path;

/**

$wp_version = $GLOBALS['wp_version'];

$wp_version = str_replace( '-src', '', $wp_version );

$since = str_replace( '-src', '', $since );

return version_compare( $wp_version, $since, $operator );

$assoc_args = [

'format' => $format,

'fields' => $fields,

];

$formatter = new Formatter( $assoc_args );

$formatter->display_items( $items );

if ( ! empty( $headers ) ) {

// Escape the header cells only; rows are looked up by the original field names.

fputcsv( $fd, array_map( __NAMESPACE__ . '\escape_csv_value', $headers ), ',', '"', '\\' );

}

/**

foreach ( $rows as $row ) {

if ( ! empty( $headers ) ) {

$row = pick_fields( $row, $headers );

}

/**

$callback = __NAMESPACE__ . '\escape_csv_value';

$row = array_map( $callback, $row );

fputcsv( $fd, array_values( $row ), ',', '"', '\\' );

}

$values = [];

if ( is_object( $item ) ) {

foreach ( $fields as $field ) {

$values[ $field ] = isset( $item->$field ) ? $item->$field : null;

}

} else {

foreach ( $fields as $field ) {

$values[ $field ] = isset( $item[ $field ] ) ? $item[ $field ] : null;

}

}

return $values;

check_proc_available( 'launch_editor_for_input' );

$tmpdir = get_temp_dir();

$created = false;

$attempts = 0;

do {

$tmpfile = Path::basename( $title );

$tmpfile = preg_replace( '|\.[^.]*$|', '', $tmpfile );

$tmpfile .= '-' . substr( md5( (string) mt_rand() ), 0, 6 ); // phpcs:ignore WordPress.WP.AlternativeFunctions.rand_mt_rand -- no crypto and WP not loaded.

$tmpfile = $tmpdir . $tmpfile . '.' . $ext;

// Restrict the file to its owner, as it can hold sensitive input.

$old_umask = umask( 0177 );

$fp = @fopen( $tmpfile, 'xb' );

umask( $old_umask );

if ( $fp ) {

$created = true;

// A short write (e.g. on a full disk) must not leave a truncated file for the editor to open.

if ( strlen( $input ) !== fwrite( $fp, $input ) ) {

fclose( $fp );

@unlink( $tmpfile );

WP_CLI::error( 'Error writing to temporary file.' );

}

fclose( $fp );

break;

}

$tmpfile = '';

++$attempts;

} while ( $attempts < 100 );

if ( ! $created ) {

WP_CLI::error( 'Error creating temporary file.' );

}

$editor = getenv( 'EDITOR' );

if ( ! $editor ) {

$editor = is_windows() ? 'notepad' : 'vi';

}

$descriptorspec = [ STDIN, STDOUT, STDERR ];

$process = proc_open_compat( "$editor " . escapeshellarg( $tmpfile ), $descriptorspec, $pipes );

if ( $process ) {

$r = proc_close( $process );

if ( $r ) {

exit( $r );

}

}

$output = file_get_contents( $tmpfile );

unlink( $tmpfile );

if ( $output === $input ) {

return false;

}

return $output;

$assoc_args = [];

/**

if ( substr( $raw_host, 0, 2 ) === 'p:' ) {

$raw_host = substr_replace( $raw_host, '', 0, 2 );

}

$host_parts = explode( ':', $raw_host );

if ( count( $host_parts ) === 2 ) {

list( $assoc_args['host'], $extra ) = $host_parts;

$extra = trim( $extra );

if ( is_numeric( $extra ) ) {

$assoc_args['port'] = (int) $extra;

$assoc_args['protocol'] = 'tcp';

} elseif ( '' !== $extra ) {

$assoc_args['socket'] = $extra;

}

} else {

$assoc_args['host'] = $raw_host;

}

return $assoc_args;

check_proc_available( 'run_mysql_command' );

/**

$descriptors = ( $interactive || $send_to_shell ) ?

[

0 => STDIN,

1 => STDOUT,

2 => STDERR,

] :

[

0 => STDIN,

1 => [ 'pipe', 'w' ],

2 => [ 'pipe', 'w' ],

];

$stdout = '';

$stderr = '';

/**

$pipes = [];

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

// phpcs:ignore WordPress.DB.RestrictedFunctions.mysql_mysql_host_to_cli_args -- Misidentified as PHP native MySQL function.

$assoc_args = array_merge( $assoc_args, mysql_host_to_cli_args( $assoc_args['host'] ) );

}

if ( isset( $assoc_args['pass'] ) ) {

$old_password = getenv( 'MYSQL_PWD' );

putenv( 'MYSQL_PWD=' . $assoc_args['pass'] );

unset( $assoc_args['pass'] );

}

$final_cmd = force_env_on_nix_systems( $cmd ) . assoc_args_to_str( $assoc_args );

WP_CLI::debug( 'Final MySQL command: ' . $final_cmd, 'db' );

$process = proc_open_compat( $final_cmd, $descriptors, $pipes );

if ( isset( $old_password ) ) {

putenv( 'MYSQL_PWD=' . $old_password );

}

if ( ! $process ) {

WP_CLI::debug( 'Failed to create a valid process using proc_open_compat()', 'db' );

exit( 1 );

}

if ( is_resource( $process ) && ! $send_to_shell && ! $interactive ) {

$stdout = stream_get_contents( $pipes[1] );

$stderr = stream_get_contents( $pipes[2] );

fclose( $pipes[1] );

fclose( $pipes[2] );

}

$exit_code = proc_close( $process );

if ( $exit_code && ( $send_to_shell || $interactive ) ) {

exit( $exit_code );

}

return [

$stdout,

$stderr,

$exit_code,

];

if ( ! file_exists( $template_name ) ) {

$template_name = WP_CLI_ROOT . "/templates/$template_name";

}

$template = (string) file_get_contents( $template_name );

$mustache = new Mustache_Engine(

[

'escape' => function ( $val ) {

return $val; },

]

);

return $mustache->render( $template, $data );

if ( Shell::isPiped() ) {

return new NoOp();

}

return new Bar( $message, $count, $interval );

if ( function_exists( 'wp_parse_url' ) ) {

$url_parts = wp_parse_url( $url, $component );

} else {

// phpcs:ignore WordPress.WP.AlternativeFunctions.parse_url_parse_url -- Fallback.

$url_parts = \parse_url( $url, $component );

}

// phpcs:ignore WordPress.WP.AlternativeFunctions.parse_url_parse_url -- Own version based on WP one.

if ( $auto_add_scheme && ! parse_url( $url, PHP_URL_SCHEME, false ) ) {

// phpcs:ignore WordPress.WP.AlternativeFunctions.parse_url_parse_url -- Own version based on WP one.

$url_parts = parse_url( 'http://' . $url, $component, false );

}

return $url_parts;

$insecure = isset( $options['insecure'] ) && (bool) $options['insecure'];

$halt_on_error = ! isset( $options['halt_on_error'] ) || (bool) $options['halt_on_error'];

$max_retries = isset( $options['max_retries'] ) && is_numeric( $options['max_retries'] ) ? (int) $options['max_retries'] : 3;

unset( $options['halt_on_error'] );

if ( ! isset( $options['verify'] ) ) {

// 'curl.cainfo' enforces the CA file to use, otherwise fallback to system-wide defaults then use the embedded CA file.

$options['verify'] = ! empty( ini_get( 'curl.cainfo' ) ) ? ini_get( 'curl.cainfo' ) : true;

}

/**

$options = WP_CLI::do_hook( 'http_request_options', $options, $method, $url, $data, $headers );

RequestsLibrary::register_autoloader();

/**

$request_method = [ RequestsLibrary::get_class_name(), 'request' ];

$attempt = 0;

$last_exception = null;

$retry_after_delay = 1; // Start with 1 second delay.

while ( $attempt < $max_retries ) {

++$attempt;

try {

try {

return $request_method( $url, $headers, $data, $method, $options );

} catch ( \Requests_Exception | \WpOrg\Requests\Exception $exception ) {

$curl_handle = $exception->getData();

// Get curl error code safely - only if curl is available and handle is valid.

$curl_errno = null;

if ( function_exists( 'curl_errno' ) && ( is_resource( $curl_handle ) || ( is_object( $curl_handle ) && $curl_handle instanceof \CurlHandle ) ) ) {

// @phpstan-ignore argument.type

$curl_errno = curl_errno( $curl_handle );