Code Coverage for projects/plugins/jetpack/class.jetpack-cli.php

	Code Coverage
	Lines			Functions and Methods				Classes and Traits
Total	0.00% covered (danger)	0.00%	0 / 997	0.00% covered (danger)	0.00%	0 / 24	CRAP	0.00% covered (danger)	0.00%	0 / 1
jetpack_cli_are_you_sure	0.00% covered (danger)	0.00%	0 / 16	0.00% covered (danger)	0.00%	0 / 1	20
Jetpack_CLI	0.00% covered (danger)	0.00%	0 / 978	0.00% covered (danger)	0.00%	0 / 23	82656	0.00% covered (danger)	0.00%	0 / 1
status	0.00% covered (danger)	0.00%	0 / 34	0.00% covered (danger)	0.00%	0 / 1	182
test_connection	0.00% covered (danger)	0.00%	0 / 18	0.00% covered (danger)	0.00%	0 / 1	30
disconnect	0.00% covered (danger)	0.00%	0 / 49	0.00% covered (danger)	0.00%	0 / 1	240
reset	0.00% covered (danger)	0.00%	0 / 101	0.00% covered (danger)	0.00%	0 / 1	506
count_option	0.00% covered (danger)	0.00%	0 / 7	0.00% covered (danger)	0.00%	0 / 1	2
module	0.00% covered (danger)	0.00%	0 / 60	0.00% covered (danger)	0.00%	0 / 1	462
protect	0.00% covered (danger)	0.00%	0 / 51	0.00% covered (danger)	0.00%	0 / 1	420
options	0.00% covered (danger)	0.00%	0 / 58	0.00% covered (danger)	0.00%	0 / 1	600
sync	0.00% covered (danger)	0.00%	0 / 119	0.00% covered (danger)	0.00%	0 / 1	1640
sync_queue	0.00% covered (danger)	0.00%	0 / 36	0.00% covered (danger)	0.00%	0 / 1	30
partner_cancel	0.00% covered (danger)	0.00%	0 / 34	0.00% covered (danger)	0.00%	0 / 1	110
partner_provision	0.00% covered (danger)	0.00%	0 / 24	0.00% covered (danger)	0.00%	0 / 1	42
sitemap	0.00% covered (danger)	0.00%	0 / 38	0.00% covered (danger)	0.00%	0 / 1	272
authorize_user	0.00% covered (danger)	0.00%	0 / 13	0.00% covered (danger)	0.00%	0 / 1	20
call_api	0.00% covered (danger)	0.00%	0 / 49	0.00% covered (danger)	0.00%	0 / 1	156
upload_ssh_creds	0.00% covered (danger)	0.00%	0 / 40	0.00% covered (danger)	0.00%	0 / 1	72
get_stats	0.00% covered (danger)	0.00%	0 / 25	0.00% covered (danger)	0.00%	0 / 1	12
publicize	0.00% covered (danger)	0.00%	0 / 87	0.00% covered (danger)	0.00%	0 / 1	1332
get_api_host	0.00% covered (danger)	0.00%	0 / 2	0.00% covered (danger)	0.00%	0 / 1	6
partner_provision_error	0.00% covered (danger)	0.00%	0 / 11	0.00% covered (danger)	0.00%	0 / 1	2
scaffold	0.00% covered (danger)	0.00%	0 / 6	0.00% covered (danger)	0.00%	0 / 1	12
block	0.00% covered (danger)	0.00%	0 / 115	0.00% covered (danger)	0.00%	0 / 1	380
render_block_file	0.00% covered (danger)	0.00%	0 / 1	0.00% covered (danger)	0.00%	0 / 1	2

1	<?php // phpcs:ignore WordPress.Files.FileName.InvalidClassFileName
2	/**
3	* WP-CLI command class.
4	*
5	* @package automattic/jetpack
6	*/
7
8	use Automattic\Jetpack\Connection\Client;
9	use Automattic\Jetpack\Connection\Manager as Connection_Manager;
10	use Automattic\Jetpack\Connection\Tokens;
11	use Automattic\Jetpack\Identity_Crisis;
12	use Automattic\Jetpack\IP\Utils as IP_Utils;
13	use Automattic\Jetpack\Publicize\Connections;
14	use Automattic\Jetpack\Publicize\Publicize;
15	use Automattic\Jetpack\Status;
16	use Automattic\Jetpack\Sync\Actions;
17	use Automattic\Jetpack\Sync\Listener;
18	use Automattic\Jetpack\Sync\Modules;
19	use Automattic\Jetpack\Sync\Queue;
20	use Automattic\Jetpack\Sync\Settings;
21	use Automattic\Jetpack\Waf\Brute_Force_Protection\Brute_Force_Protection_Shared_Functions;
22
23	if ( ! class_exists( 'WP_CLI_Command' ) ) {
24	return;
25	}
26
27	WP_CLI::add_command( 'jetpack', 'Jetpack_CLI' );
28
29	/**
30	* Control your local Jetpack installation.
31	*/
32	class Jetpack_CLI extends WP_CLI_Command {
33	/**
34	* Console escape code for green.
35	*
36	* @var string
37	*/
38	public $green_open = "\033[32m";
39
40	/**
41	* Console escape code for red.
42	*
43	* @var string
44	*/
45	public $red_open = "\033[31m";
46
47	/**
48	* Console escape code for yellow.
49	*
50	* @var string
51	*/
52	public $yellow_open = "\033[33m";
53
54	/**
55	* Console escape code to reset coloring.
56	*
57	* @var string
58	*/
59	public $color_close = "\033[0m";
60
61	/**
62	* Get Jetpack Details
63	*
64	* ## OPTIONS
65	*
66	* empty: Leave it empty for basic stats
67	*
68	* full: View full stats. It's the data from the heartbeat
69	*
70	* ## EXAMPLES
71	*
72	* wp jetpack status
73	* wp jetpack status full
74	*
75	* @param array $args Positional args.
76	*/
77	public function status( $args ) {
78	require_once JETPACK__PLUGIN_DIR . '_inc/lib/debugger.php';
79
80	/* translators: %s is the site URL */
81	WP_CLI::line( sprintf( __( 'Checking status for %s', 'jetpack' ), esc_url( get_home_url() ) ) );
82
83	if ( isset( $args[0] ) && 'full' !== $args[0] ) {
84	/* translators: %s is a command like "prompt" */
85	WP_CLI::error( sprintf( __( '%s is not a valid command.', 'jetpack' ), $args[0] ) );
86	}
87
88	$master_user_email = Jetpack::get_master_user_email();
89
90	$cxntests = new Automattic\Jetpack\Connection\Connection_Health_Tests();
91
92	if ( $cxntests->pass() ) {
93	$cxntests->output_results_for_cli();
94
95	WP_CLI::success( __( 'Jetpack is currently connected to WordPress.com', 'jetpack' ) );
96	} else {
97	$error = array();
98	foreach ( $cxntests->list_fails() as $fail ) {
99	$error[] = $fail['name'] . ( empty( $fail['message'] ) ? '' : ': ' . $fail['message'] );
100	}
101	WP_CLI::error_multi_line( $error );
102
103	$cxntests->output_results_for_cli();
104
105	WP_CLI::error( __( 'One or more tests did not pass. Please investigate!', 'jetpack' ) ); // Exit CLI.
106	}
107
108	/* translators: %s is current version of Jetpack, for example 7.3 */
109	WP_CLI::line( sprintf( __( 'The Jetpack Version is %s', 'jetpack' ), JETPACK__VERSION ) );
110	/* translators: %d is WP.com ID of this blog */
111	WP_CLI::line( sprintf( __( 'The WordPress.com blog_id is %d', 'jetpack' ), Jetpack_Options::get_option( 'id' ) ) );
112	/* translators: %s is the email address of the connection owner */
113	WP_CLI::line( sprintf( __( 'The WordPress.com account for the primary connection is %s', 'jetpack' ), $master_user_email ) );
114
115	/*
116	* Are they asking for all data?
117	*
118	* Loop through heartbeat data and organize by priority.
119	*/
120	$all_data = ( isset( $args[0] ) && 'full' === $args[0] ) ? 'full' : false;
121	if ( $all_data ) {
122	// Heartbeat data.
123	WP_CLI::line( "\n" . __( 'Additional data: ', 'jetpack' ) );
124
125	// Get the filtered heartbeat data.
126	// Filtered so we can color/list by severity.
127	$stats = Jetpack::jetpack_check_heartbeat_data();
128
129	// Display red flags first.
130	foreach ( $stats['bad'] as $stat => $value ) {
131	WP_CLI::line( sprintf( "$this->red_open%-'.16s %s $this->color_close", $stat, $value ) );
132	}
133
134	// Display caution warnings next.
135	foreach ( $stats['caution'] as $stat => $value ) {
136	WP_CLI::line( sprintf( "$this->yellow_open%-'.16s %s $this->color_close", $stat, $value ) );
137	}
138
139	// The rest of the results are good!
140	foreach ( $stats['good'] as $stat => $value ) {
141
142	// Modules should get special spacing for aestetics.
143	if ( strpos( $stat, 'odule-' ) ) {
144	WP_CLI::line( sprintf( "%-'.30s %s", $stat, $value ) );
145	usleep( 4000 ); // For dramatic effect lolz.
146	continue;
147	}
148	WP_CLI::line( sprintf( "%-'.16s %s", $stat, $value ) );
149	usleep( 4000 ); // For dramatic effect lolz.
150	}
151	} else {
152	// Just the basics.
153	WP_CLI::line( "\n" . _x( "View full status with 'wp jetpack status full'", '"wp jetpack status full" is a command - do not translate', 'jetpack' ) );
154	}
155	}
156
157	/**
158	* Tests the active connection
159	*
160	* Does a two-way test to verify that the local site can communicate with remote Jetpack/WP.com servers and that Jetpack/WP.com servers can talk to the local site.
161	*
162	* ## EXAMPLES
163	*
164	* wp jetpack test-connection
165	*
166	* @subcommand test-connection
167	*/
168	public function test_connection() {
169
170	/* translators: %s is the site URL */
171	WP_CLI::line( sprintf( __( 'Testing connection for %s', 'jetpack' ), esc_url( get_site_url() ) ) );
172
173	if ( ! Jetpack::is_connection_ready() ) {
174	WP_CLI::error( __( 'Jetpack is not currently connected to WordPress.com', 'jetpack' ) );
175	}
176
177	$response = Client::wpcom_json_api_request_as_blog(
178	sprintf( '/jetpack-blogs/%d/test-connection', Jetpack_Options::get_option( 'id' ) ),
179	Client::WPCOM_JSON_API_VERSION
180	);
181
182	if ( is_wp_error( $response ) ) {
183	/* translators: %1$s is the error code, %2$s is the error message */
184	WP_CLI::error( sprintf( __( 'Failed to test connection (#%1$s: %2$s)', 'jetpack' ), $response->get_error_code(), $response->get_error_message() ) );
185	}
186
187	$body = wp_remote_retrieve_body( $response );
188	if ( ! $body ) {
189	WP_CLI::error( __( 'Failed to test connection (empty response body)', 'jetpack' ) );
190	}
191
192	$result = json_decode( $body );
193	$is_connected = (bool) $result->connected;
194	$message = $result->message;
195
196	if ( $is_connected ) {
197	WP_CLI::success( $message );
198	} else {
199	WP_CLI::error( $message );
200	}
201	}
202
203	/**
204	* Disconnect Jetpack Blogs or Users
205	*
206	* ## OPTIONS
207	*
208	* blog: Disconnect the entire blog.
209	*
210	* user <user_identifier>: Disconnect a specific user from WordPress.com.
211	*
212	* [--force]
213	* If the user ID provided is the connection owner, it will only be disconnected if --force is passed
214	*
215	* ## EXAMPLES
216	*
217	* wp jetpack disconnect blog
218	* wp jetpack disconnect user 13
219	* wp jetpack disconnect user 1 --force
220	* wp jetpack disconnect user username
221	* wp jetpack disconnect user email@domain.com
222	*
223	* @synopsis <blog\|user> [<user_identifier>] [--force]
224	*
225	* @param array $args Positional args.
226	* @param array $assoc_args Named args.
227	*/
228	public function disconnect( $args, $assoc_args ) {
229	$user = null;
230	if ( ! Jetpack::is_connection_ready() ) {
231	WP_CLI::success( __( 'The site is not currently connected, so nothing to do!', 'jetpack' ) );
232	return;
233	}
234
235	$action = $args[0] ?? 'prompt';
236	if ( ! in_array( $action, array( 'blog', 'user', 'prompt' ), true ) ) {
237	/* translators: %s is a command like "prompt" */
238	WP_CLI::error( sprintf( __( '%s is not a valid command.', 'jetpack' ), $action ) );
239	}
240
241	if ( in_array( $action, array( 'user' ), true ) ) {
242	if ( isset( $args[1] ) ) {
243	$user_id = $args[1];
244	if ( ctype_digit( $user_id ) ) {
245	$field = 'id';
246	$user_id = (int) $user_id;
247	} elseif ( is_email( $user_id ) ) {
248	$field = 'email';
249	$user_id = sanitize_user( $user_id, true );
250	} else {
251	$field = 'login';
252	$user_id = sanitize_user( $user_id, true );
253	}
254	$user = get_user_by( $field, $user_id );
255	if ( ! $user ) {
256	WP_CLI::error( __( 'Please specify a valid user.', 'jetpack' ) );
257	}
258	} else {
259	WP_CLI::error( __( 'Please specify a user by either ID, username, or email.', 'jetpack' ) );
260	}
261	}
262
263	$force_user_disconnect = ! empty( $assoc_args['force'] );
264
265	switch ( $action ) {
266	case 'blog':
267	Jetpack::log( 'disconnect' );
268	( new Connection_Manager( 'jetpack' ) )->disconnect_site();
269	WP_CLI::success(
270	sprintf(
271	/* translators: %s is the site URL */
272	__( 'Jetpack has been successfully disconnected for %s.', 'jetpack' ),
273	esc_url( get_site_url() )
274	)
275	);
276	break;
277	case 'user':
278	$connection_manager = new Connection_Manager( 'jetpack' );
279	$disconnected = $connection_manager->disconnect_user( $user->ID, $force_user_disconnect );
280	if ( $disconnected ) {
281	Jetpack::log( 'unlink', $user->ID );
282	WP_CLI::success( __( 'User has been successfully disconnected.', 'jetpack' ) );
283	} else {
284	if ( ! $connection_manager->is_user_connected( $user->ID ) ) {
285	/* translators: %s is a username */
286	$error_message = sprintf( __( 'User %s could not be disconnected because it is not connected!', 'jetpack' ), "{$user->data->user_login} <{$user->data->user_email}>" );
287	} elseif ( ! $force_user_disconnect && $connection_manager->is_connection_owner( $user->ID ) ) {
288	/* translators: %s is a username */
289	$error_message = sprintf( __( 'User %s could not be disconnected because it is the connection owner! If you want to disconnect in anyway, use the --force parameter.', 'jetpack' ), "{$user->data->user_login} <{$user->data->user_email}>" );
290	} else {
291	/* translators: %s is a username */
292	$error_message = sprintf( __( 'User %s could not be disconnected.', 'jetpack' ), "{$user->data->user_login} <{$user->data->user_email}>" );
293	}
294	WP_CLI::error( $error_message );
295	}
296	break;
297	case 'prompt':
298	WP_CLI::error( __( 'Please specify if you would like to disconnect a blog or user.', 'jetpack' ) );
299	break;
300	}
301	}
302
303	/**
304	* Reset Jetpack options and settings to default
305	*
306	* ## OPTIONS
307	*
308	* modules: Resets modules to default state ( get_default_modules() )
309	*
310	* options: Resets all Jetpack options except:
311	* - All private options (Blog token, user token, etc...)
312	* - id (The Client ID/WP.com Blog ID of this site)
313	* - master_user
314	* - version
315	* - activated
316	*
317	* ## EXAMPLES
318	*
319	* wp jetpack reset options
320	* wp jetpack reset modules
321	* wp jetpack reset sync-checksum --dry-run --offset=0
322	*
323	* @synopsis <modules\|options\|sync-checksum> [--dry-run] [--offset=<offset>]
324	*
325	* @param array $args Positional args.
326	* @param array $assoc_args Named args.
327	*/
328	public function reset( $args, $assoc_args ) {
329	$action = $args[0] ?? 'prompt';
330	if ( ! in_array( $action, array( 'options', 'modules', 'sync-checksum' ), true ) ) {
331	/* translators: %s is a command like "prompt" */
332	WP_CLI::error( sprintf( __( '%s is not a valid command.', 'jetpack' ), $action ) );
333	}
334
335	$is_dry_run = ! empty( $assoc_args['dry-run'] );
336
337	if ( $is_dry_run ) {
338	WP_CLI::warning(
339	__( "\nThis is a dry run.\n", 'jetpack' ) .
340	__( "No actions will be taken.\n", 'jetpack' ) .
341	__( "The following messages will give you preview of what will happen when you run this command.\n\n", 'jetpack' )
342	);
343	} else {
344	// We only need to confirm "Are you sure?" when we are not doing a dry run.
345	jetpack_cli_are_you_sure();
346	}
347
348	switch ( $action ) {
349	case 'options':
350	$options_to_reset = Jetpack_Options::get_options_for_reset();
351	// Reset the Jetpack options.
352	WP_CLI::line(
353	sprintf(
354	/* translators: %s is the site URL */
355	__( "Resetting Jetpack Options for %s...\n", 'jetpack' ),
356	esc_url( get_site_url() )
357	)
358	);
359	sleep( 1 ); // Take a breath.
360	foreach ( $options_to_reset['jp_options'] as $option_to_reset ) {
361	if ( ! $is_dry_run ) {
362	Jetpack_Options::delete_option( $option_to_reset );
363	usleep( 100000 );
364	}
365
366	/* translators: This is the result of an action. The option named %s was reset */
367	WP_CLI::success( sprintf( __( '%s option reset', 'jetpack' ), $option_to_reset ) );
368	}
369
370	// Reset the WP options.
371	WP_CLI::line( __( "Resetting the jetpack options stored in wp_options...\n", 'jetpack' ) );
372	usleep( 500000 ); // Take a breath.
373	foreach ( $options_to_reset['wp_options'] as $option_to_reset ) {
374	if ( ! $is_dry_run ) {
375	delete_option( $option_to_reset );
376	usleep( 100000 );
377	}
378	/* translators: This is the result of an action. The option named %s was reset */
379	WP_CLI::success( sprintf( __( '%s option reset', 'jetpack' ), $option_to_reset ) );
380	}
381
382	// Reset to default modules.
383	WP_CLI::line( __( "Resetting default modules...\n", 'jetpack' ) );
384	usleep( 500000 ); // Take a breath.
385	$default_modules = Jetpack::get_default_modules();
386	if ( ! $is_dry_run ) {
387	Jetpack::update_active_modules( $default_modules );
388	}
389	WP_CLI::success( __( 'Modules reset to default.', 'jetpack' ) );
390	break;
391	case 'modules':
392	if ( ! $is_dry_run ) {
393	$default_modules = Jetpack::get_default_modules();
394	Jetpack::update_active_modules( $default_modules );
395	}
396
397	WP_CLI::success( __( 'Modules reset to default.', 'jetpack' ) );
398	break;
399	case 'prompt':
400	WP_CLI::error( __( 'Please specify if you would like to reset your options, modules or sync-checksum', 'jetpack' ) );
401	break;
402	case 'sync-checksum':
403	$option = 'jetpack_callables_sync_checksum';
404
405	if ( is_multisite() ) {
406	$offset = isset( $assoc_args['offset'] ) ? (int) $assoc_args['offset'] : 0;
407
408	/*
409	* 1000 is a good limit since we don't expect the number of sites to be more than 1000
410	* Offset can be used to paginate and try to clean up more sites.
411	*/
412	$sites = get_sites(
413	array(
414	'number' => 1000,
415	'offset' => $offset,
416	)
417	);
418	$count_fixes = 0;
419	foreach ( $sites as $site ) {
420	switch_to_blog( $site->blog_id );
421	$count = self::count_option( $option );
422	if ( $count > 1 ) {
423	if ( ! $is_dry_run ) {
424	delete_option( $option );
425	}
426	WP_CLI::line(
427	sprintf(
428	/* translators: %1$d is a number, %2$s is the name of an option, %2$s is the site URL. */
429	__( 'Deleted %1$d %2$s options from %3$s', 'jetpack' ),
430	$count,
431	$option,
432	"{$site->domain}{$site->path}"
433	)
434	);
435	++$count_fixes;
436	if ( ! $is_dry_run ) {
437	/*
438	* We could be deleting a lot of options rows at the same time.
439	* Allow some time for replication to catch up.
440	*/
441	sleep( 3 );
442	}
443	}
444
445	restore_current_blog();
446	}
447	if ( $count_fixes ) {
448	WP_CLI::success(
449	sprintf(
450	/* translators: %1$s is the name of an option, %2$d is a number of sites. */
451	__( 'Successfully reset %1$s on %2$d sites.', 'jetpack' ),
452	$option,
453	$count_fixes
454	)
455	);
456	} else {
457	WP_CLI::success( __( 'No options were deleted.', 'jetpack' ) );
458	}
459	return;
460	}
461
462	$count = self::count_option( $option );
463	if ( $count > 1 ) {
464	if ( ! $is_dry_run ) {
465	delete_option( $option );
466	}
467	WP_CLI::success(
468	sprintf(
469	/* translators: %1$d is a number, %2$s is the name of an option. */
470	__( 'Deleted %1$d %2$s options', 'jetpack' ),
471	$count,
472	$option
473	)
474	);
475	return;
476	}
477
478	WP_CLI::success( __( 'No options were deleted.', 'jetpack' ) );
479	break;
480
481	}
482	}
483
484	/**
485	* Return the number of times an option appears
486	* Normally an option would only appear 1 since the option key is supposed to be unique
487	* but if a site hasn't updated the DB schema then that would not be the case.
488	*
489	* @param string $option Option name.
490	*
491	* @return int
492	*/
493	private static function count_option( $option ) {
494	global $wpdb;
495	return (int) $wpdb->get_var(
496	$wpdb->prepare(
497	"SELECT COUNT(*) FROM $wpdb->options WHERE option_name = %s",
498	$option
499	)
500	);
501	}
502
503	/**
504	* Manage Jetpack Modules
505	*
506	* ## OPTIONS
507	*
508	* <list\|activate\|deactivate\|toggle>
509	* : The action to take.
510	* ---
511	* default: list
512	* options:
513	* - list
514	* - activate
515	* - deactivate
516	* - toggle
517	* ---
518	*
519	* [<module_slug>]
520	* : The slug of the module to perform an action on.
521	*
522	* [--format=<format>]
523	* : Allows overriding the output of the command when listing modules.
524	* ---
525	* default: table
526	* options:
527	* - table
528	* - json
529	* - csv
530	* - yaml
531	* - ids
532	* - count
533	* ---
534	*
535	* ## EXAMPLES
536	*
537	* wp jetpack module list
538	* wp jetpack module list --format=json
539	* wp jetpack module activate stats
540	* wp jetpack module deactivate stats
541	* wp jetpack module toggle stats
542	* wp jetpack module activate all
543	* wp jetpack module deactivate all
544	*
545	* @param array $args Positional args.
546	* @param array $assoc_args Named args.
547	*/
548	public function module( $args, $assoc_args ) {
549	$module_slug = null;
550	$action = $args[0] ?? 'list';
551
552	if ( isset( $args[1] ) ) {
553	$module_slug = $args[1];
554	if ( 'all' !== $module_slug && ! Jetpack::is_module( $module_slug ) ) {
555	/* translators: %s is a module slug like "stats" */
556	WP_CLI::error( sprintf( __( '%s is not a valid module.', 'jetpack' ), $module_slug ) );
557	}
558	if ( 'toggle' === $action ) {
559	$action = Jetpack::is_module_active( $module_slug )
560	? 'deactivate'
561	: 'activate';
562	}
563	if ( 'all' === $args[1] ) {
564	$action = ( 'deactivate' === $action )
565	? 'deactivate_all'
566	: 'activate_all';
567	}
568	} elseif ( 'list' !== $action ) {
569	WP_CLI::line( __( 'Please specify a valid module.', 'jetpack' ) );
570	$action = 'list';
571	}
572
573	switch ( $action ) {
574	case 'list':
575	$modules_list = array();
576	$modules = Jetpack::get_available_modules();
577	sort( $modules );
578	foreach ( (array) $modules as $module_slug ) {
579	if ( 'vaultpress' === $module_slug ) {
580	continue;
581	}
582	$modules_list[] = array(
583	'slug' => $module_slug,
584	'status' => Jetpack::is_module_active( $module_slug )
585	? __( 'Active', 'jetpack' )
586	: __( 'Inactive', 'jetpack' ),
587	);
588	}
589	WP_CLI\Utils\format_items( $assoc_args['format'], $modules_list, array( 'slug', 'status' ) );
590	break;
591	case 'activate':
592	$module = Jetpack::get_module( $module_slug );
593	Jetpack::log( 'activate', $module_slug );
594	if ( Jetpack::activate_module( $module_slug, false, false ) ) {
595	if ( ! Jetpack::is_module_active( $module_slug ) ) {
596	/* translators: %s is the name of a Jetpack module */
597	WP_CLI::error( sprintf( __( '%s is disabled by your host or site administrator, so it stays off.', 'jetpack' ), $module['name'] ) );
598	}
599	/* translators: %s is the name of a Jetpack module */
600	WP_CLI::success( sprintf( __( '%s has been activated.', 'jetpack' ), $module['name'] ) );
601	} else {
602	/* translators: %s is the name of a Jetpack module */
603	WP_CLI::error( sprintf( __( '%s could not be activated.', 'jetpack' ), $module['name'] ) );
604	}
605	break;
606	case 'activate_all':
607	$modules = Jetpack::get_available_modules();
608	Jetpack::update_active_modules( $modules );
609	WP_CLI::success( __( 'All modules activated!', 'jetpack' ) );
610	break;
611	case 'deactivate':
612	$module = Jetpack::get_module( $module_slug );
613	Jetpack::log( 'deactivate', $module_slug );
614	Jetpack::deactivate_module( $module_slug );
615	if ( Jetpack::is_module_active( $module_slug ) ) {
616	/* translators: %s is the name of a Jetpack module */
617	WP_CLI::error( sprintf( __( '%s is enabled by your host or site administrator, so it stays on.', 'jetpack' ), $module['name'] ) );
618	}
619	/* translators: %s is the name of a Jetpack module */
620	WP_CLI::success( sprintf( __( '%s has been deactivated.', 'jetpack' ), $module['name'] ) );
621	break;
622	case 'deactivate_all':
623	Jetpack::delete_active_modules();
624	WP_CLI::success( __( 'All modules deactivated!', 'jetpack' ) );
625	break;
626	case 'toggle':
627	// Will never happen, should have been handled above and changed to activate or deactivate.
628	break;
629	}
630	}
631
632	/**
633	* Manage Protect Settings
634	*
635	* ## OPTIONS
636	*
637	* allow: Add an IP address to an always allow list. You can also read or clear the allow list.
638	*
639	*
640	* ## EXAMPLES
641	*
642	* wp jetpack protect allow <ip address>
643	* wp jetpack protect allow list
644	* wp jetpack protect allow clear
645	*
646	* @synopsis <allow> [<ip\|ip_low-ip_high\|list\|clear>]
647	*
648	* @param array $args Positional args.
649	*/
650	public function protect( $args ) {
651	$action = $args[0] ?? 'prompt';
652	if ( ! in_array( $action, array( 'whitelist', 'allow' ), true ) ) { // Still allow "whitelist" for legacy support.
653	/* translators: %s is a command like "prompt" */
654	WP_CLI::error( sprintf( __( '%s is not a valid command.', 'jetpack' ), $action ) );
655	}
656	// Check if module is active.
657	if ( ! Jetpack::is_module_active( __FUNCTION__ ) ) {
658	/* translators: %s is a module name */
659	WP_CLI::error( sprintf( _x( '%1$s is not active. You can activate it with "wp jetpack module activate %2$s"', '"wp jetpack module activate" is a command - do not translate', 'jetpack' ), __FUNCTION__, __FUNCTION__ ) );
660	}
661	if ( in_array( $action, array( 'allow', 'whitelist' ), true ) ) {
662	if ( isset( $args[1] ) ) {
663	$action = 'allow';
664	} else {
665	$action = 'prompt';
666	}
667	}
668	switch ( $action ) {
669	case 'allow':
670	$allow = array();
671	$new_ip = $args[1];
672
673	/*
674	* Build array of IPs that are already on the allowed list.
675	* Re-build manually instead of using format_allow_list() so we can easily get
676	* low & high range params for IP_Utils::ip_address_is_in_range().
677	*/
678	foreach ( Brute_Force_Protection_Shared_Functions::get_local_allow_list() as $allowed ) {
679
680	// IP ranges.
681	if ( $allowed->range ) {
682
683	// Is it already on the allowed list?
684	if ( IP_Utils::ip_address_is_in_range( $new_ip, $allowed->range_low, $allowed->range_high ) ) {
685	/* translators: %s is an IP address */
686	WP_CLI::error( sprintf( __( '%s is already on the always allow list.', 'jetpack' ), $new_ip ) );
687	break;
688	}
689	// A CIDR range has no upper bound of its own.
690	$allow[] = null === $allowed->range_high ? $allowed->range_low : $allowed->range_low . ' - ' . $allowed->range_high;
691
692	} else { // Individual IPs.
693
694	// Check if the IP is already on the allow list (single IP only).
695	if ( $new_ip === $allowed->ip_address ) {
696	/* translators: %s is an IP address */
697	WP_CLI::error( sprintf( __( '%s is already on the always allow list.', 'jetpack' ), $new_ip ) );
698	break;
699	}
700	$allow[] = $allowed->ip_address;
701
702	}
703	}
704
705	// A leftover legacy allow list is merged into every read, so entries already saved come back twice.
706	$allow = array_unique( $allow );
707
708	/*
709	* List the allowed IPs.
710	* Done here because it's easier to read the $allow array after it's been rebuilt.
711	*/
712	if ( isset( $args[1] ) && 'list' === $args[1] ) {
713	if ( ! empty( $allow ) ) {
714	WP_CLI::success( __( 'Here are your always allowed IPs:', 'jetpack' ) );
715	foreach ( $allow as $ip ) {
716	WP_CLI::line( "\t" . str_pad( $ip, 24 ) );
717	}
718	} else {
719	WP_CLI::line( __( 'Always allow list is empty.', 'jetpack' ) );
720	}
721	break;
722	}
723
724	/*
725	* Clear the always allow list.
726	*/
727	if ( isset( $args[1] ) && 'clear' === $args[1] ) {
728	if ( ! empty( $allow ) ) {
729	$allow = array();
730	Brute_Force_Protection_Shared_Functions::save_allow_list( $allow ); // @todo Need to update function name in the Protect module.
731	WP_CLI::success( __( 'Cleared all IPs from the always allow list.', 'jetpack' ) );
732	} else {
733	WP_CLI::line( __( 'Always allow list is empty.', 'jetpack' ) );
734	}
735	break;
736	}
737
738	// Append new IP to allow array.
739	array_push( $allow, $new_ip );
740
741	// Save allow list if there are no errors.
742	$result = Brute_Force_Protection_Shared_Functions::save_allow_list( $allow ); // @todo Need to update function name in the Protect module.
743	if ( is_wp_error( $result ) ) {
744	WP_CLI::error( $result );
745	}
746
747	/* translators: %s is an IP address */
748	WP_CLI::success( sprintf( __( '%s has been added to the always allowed list.', 'jetpack' ), $new_ip ) );
749	break;
750	case 'prompt':
751	WP_CLI::error(
752	__( 'No command found.', 'jetpack' ) . "\n" .
753	__( 'Please enter the IP address you want to always allow.', 'jetpack' ) . "\n" .
754	_x( 'You can save a range of IPs {low_range}-{high_range}. No spaces allowed. (example: 1.1.1.1-2.2.2.2)', 'Instructions on how to add IP ranges - low_range/high_range should be translated.', 'jetpack' ) . "\n" .
755	_x( "You can also 'list' or 'clear' the always allowed list.", "'list' and 'clear' are commands and should not be translated", 'jetpack' ) . "\n"
756	);
757	break;
758	}
759	}
760
761	/**
762	* Manage Jetpack Options
763	*
764	* ## OPTIONS
765	*
766	* list : List all jetpack options and their values
767	* delete : Delete an option
768	* - can only delete options that are white listed.
769	* update : update an option
770	* - can only update option strings
771	* get : get the value of an option
772	*
773	* ## EXAMPLES
774	*
775	* wp jetpack options list
776	* wp jetpack options get <option_name>
777	* wp jetpack options delete <option_name>
778	* wp jetpack options update <option_name> [<option_value>]
779	*
780	* @synopsis <list\|get\|delete\|update> [<option_name>] [<option_value>]
781	*
782	* @param array $args Positional args.
783	*/
784	public function options( $args ) {
785	$action = $args[0] ?? 'list';
786	$safe_to_modify = Jetpack_Options::get_options_for_reset();
787
788	// Is the option flagged as unsafe?
789	$flagged = ! in_array( $args[1], $safe_to_modify, true );
790
791	if ( ! in_array( $action, array( 'list', 'get', 'delete', 'update' ), true ) ) {
792	/* translators: %s is a command like "prompt" */
793	WP_CLI::error( sprintf( __( '%s is not a valid command.', 'jetpack' ), $action ) );
794	}
795
796	if ( isset( $args[0] ) ) {
797	if ( 'get' === $args[0] && isset( $args[1] ) ) {
798	$action = 'get';
799	} elseif ( 'delete' === $args[0] && isset( $args[1] ) ) {
800	$action = 'delete';
801	} elseif ( 'update' === $args[0] && isset( $args[1] ) ) {
802	$action = 'update';
803	} else {
804	$action = 'list';
805	}
806	}
807
808	// Bail if the option isn't found.
809	$option = isset( $args[1] ) ? Jetpack_Options::get_option( $args[1] ) : false;
810	if ( isset( $args[1] ) && ! $option && 'update' !== $args[0] ) {
811	WP_CLI::error( __( 'Option not found or is empty. Use "list" to list option names', 'jetpack' ) );
812	}
813
814	// Let's print_r the option if it's an array.
815	// Used in the 'get' and 'list' actions.
816	// phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_print_r
817	$option = is_array( $option ) ? print_r( $option, true ) : $option;
818
819	switch ( $action ) {
820	case 'get':
821	WP_CLI::success( "\t" . $option );
822	break;
823	case 'delete':
824	jetpack_cli_are_you_sure( $flagged );
825
826	Jetpack_Options::delete_option( $args[1] );
827	/* translators: %s is the option name */
828	WP_CLI::success( sprintf( __( 'Deleted option: %s', 'jetpack' ), $args[1] ) );
829	break;
830	case 'update':
831	jetpack_cli_are_you_sure( $flagged );
832
833	// Updating arrays would get pretty tricky...
834	$value = Jetpack_Options::get_option( $args[1] );
835	if ( $value && is_array( $value ) ) {
836	WP_CLI::error( __( 'Sorry, no updating arrays at this time', 'jetpack' ) );
837	}
838
839	Jetpack_Options::update_option( $args[1], $args[2] );
840	/* translators: %1$s is the previous value, %2$s is the new value */
841	WP_CLI::success( sprintf( _x( 'Updated option: %1$s to "%2$s"', 'Updating an option from "this" to "that".', 'jetpack' ), $args[1], $args[2] ) );
842	break;
843	case 'list':
844	$options_compact = Jetpack_Options::get_option_names();
845	$options_non_compact = Jetpack_Options::get_option_names( 'non_compact' );
846	$options_private = Jetpack_Options::get_option_names( 'private' );
847	$options = array_merge( $options_compact, $options_non_compact, $options_private );
848
849	// Table headers.
850	WP_CLI::line( "\t" . str_pad( __( 'Option', 'jetpack' ), 30 ) . __( 'Value', 'jetpack' ) );
851
852	// List out the options and their values.
853	// Tell them if the value is empty or not.
854	// Tell them if it's an array.
855	foreach ( $options as $option ) {
856	$value = Jetpack_Options::get_option( $option );
857	if ( ! $value ) {
858	WP_CLI::line( "\t" . str_pad( $option, 30 ) . 'Empty' );
859	continue;
860	}
861
862	if ( ! is_array( $value ) ) {
863	WP_CLI::line( "\t" . str_pad( $option, 30 ) . $value );
864	} elseif ( is_array( $value ) ) {
865	WP_CLI::line( "\t" . str_pad( $option, 30 ) . 'Array - Use "get <option>" to read option array.' );
866	}
867	}
868	$option_text = '{' . _x( 'option', 'a variable command that a user can write, provided in the printed instructions', 'jetpack' ) . '}';
869	$value_text = '{' . _x( 'value', 'the value that they want to update the option to', 'jetpack' ) . '}';
870
871	WP_CLI::success(
872	_x( "Above are your options. You may 'get', 'delete', and 'update' them.", "'get', 'delete', and 'update' are commands - do not translate.", 'jetpack' ) . "\n" .
873	str_pad( 'wp jetpack options get', 26 ) . $option_text . "\n" .
874	str_pad( 'wp jetpack options delete', 26 ) . $option_text . "\n" .
875	str_pad( 'wp jetpack options update', 26 ) . "$option_text $value_text\n" .
876	_x( "Type 'wp jetpack options' for more info.", "'wp jetpack options' is a command - do not translate.", 'jetpack' ) . "\n"
877	);
878	break;
879	}
880	}
881
882	/**
883	* Get the status of or start a new Jetpack sync.
884	*
885	* ## OPTIONS
886	*
887	* status : Print the current sync status
888	* settings : Prints the current sync settings
889	* start : Start a full sync from this site to WordPress.com
890	* enable : Enables sync on the site
891	* disable : Disable sync on a site
892	* reset : Disables sync and Resets the sync queues on a site
893	*
894	* ## EXAMPLES
895	*
896	* wp jetpack sync status
897	* wp jetpack sync settings
898	* wp jetpack sync start --modules=functions --sync_wait_time=5
899	* wp jetpack sync enable
900	* wp jetpack sync disable
901	* wp jetpack sync reset
902	* wp jetpack sync reset --queue=full or regular
903	*
904	* @synopsis <status\|start> [--<field>=<value>]
905	*
906	* @param array $args Positional args.
907	* @param array $assoc_args Named args.
908	*/
909	public function sync( $args, $assoc_args ) {
910
911	$action = $args[0] ?? 'status';
912
913	switch ( $action ) {
914	case 'status':
915	$status = Actions::get_sync_status();
916	$collection = array();
917	foreach ( $status as $key => $item ) {
918	$collection[] = array(
919	'option' => $key,
920	'value' => is_scalar( $item ) ? $item : wp_json_encode( $item, JSON_UNESCAPED_SLASHES ),
921	);
922	}
923	WP_CLI::log( __( 'Sync Status:', 'jetpack' ) );
924	WP_CLI\Utils\format_items( 'table', $collection, array( 'option', 'value' ) );
925	break;
926	case 'settings':
927	WP_CLI::log( __( 'Sync Settings:', 'jetpack' ) );
928	$settings = array();
929	foreach ( Settings::get_settings() as $setting => $item ) {
930	$settings[] = array(
931	'setting' => $setting,
932	'value' => is_scalar( $item ) ? $item : wp_json_encode( $item, JSON_UNESCAPED_SLASHES ),
933	);
934	}
935	WP_CLI\Utils\format_items( 'table', $settings, array( 'setting', 'value' ) );
936	break;
937	case 'disable':
938	// Don't set it via the Settings since that also resets the queues.
939	update_option( 'jetpack_sync_settings_disable', 1 );
940	/* translators: %s is the site URL */
941	WP_CLI::log( sprintf( __( 'Sync Disabled on %s', 'jetpack' ), get_site_url() ) );
942	break;
943	case 'enable':
944	Settings::update_settings( array( 'disable' => 0 ) );
945	/* translators: %s is the site URL */
946	WP_CLI::log( sprintf( __( 'Sync Enabled on %s', 'jetpack' ), get_site_url() ) );
947	break;
948	case 'reset':
949	// Don't set it via the Settings since that also resets the queues.
950	update_option( 'jetpack_sync_settings_disable', 1 );
951
952	/* translators: %s is the site URL */
953	WP_CLI::log( sprintf( __( 'Sync Disabled on %s. Use `wp jetpack sync enable` to enable syncing again.', 'jetpack' ), get_site_url() ) );
954	$listener = Listener::get_instance();
955	if ( empty( $assoc_args['queue'] ) ) {
956	$listener->get_sync_queue()->reset();
957	$listener->get_full_sync_queue()->reset();
958	/* translators: %s is the site URL */
959	WP_CLI::log( sprintf( __( 'Reset Full Sync and Regular Queues Queue on %s', 'jetpack' ), get_site_url() ) );
960	break;
961	}
962
963	if ( ! empty( $assoc_args['queue'] ) ) {
964	switch ( $assoc_args['queue'] ) {
965	case 'regular':
966	$listener->get_sync_queue()->reset();
967	/* translators: %s is the site URL */
968	WP_CLI::log( sprintf( __( 'Reset Regular Sync Queue on %s', 'jetpack' ), get_site_url() ) );
969	break;
970	case 'full':
971	$listener->get_full_sync_queue()->reset();
972	/* translators: %s is the site URL */
973	WP_CLI::log( sprintf( __( 'Reset Full Sync Queue on %s', 'jetpack' ), get_site_url() ) );
974	break;
975	default:
976	WP_CLI::error( __( 'Please specify what type of queue do you want to reset: `full` or `regular`.', 'jetpack' ) );
977	break;
978	}
979	}
980
981	break;
982	case 'start':
983	if ( ! Actions::sync_allowed() ) {
984	if ( Settings::get_setting( 'disable' ) ) {
985	WP_CLI::error( __( 'Jetpack sync is not currently allowed for this site. It is currently disabled. Run `wp jetpack sync enable` to enable it.', 'jetpack' ) );
986	return;
987	}
988	$connection = new Connection_Manager();
989	if ( ! $connection->is_connected() ) {
990	if ( ! doing_action( 'jetpack_site_registered' ) ) {
991	WP_CLI::error( __( 'Jetpack sync is not currently allowed for this site. Jetpack is not connected.', 'jetpack' ) );
992	return;
993	}
994	}
995
996	$status = new Status();
997
998	if ( $status->is_offline_mode() ) {
999	WP_CLI::error( __( 'Jetpack sync is not currently allowed for this site. The site is in offline mode.', 'jetpack' ) );
1000	return;
1001	}
1002	if ( $status->in_safe_mode() ) {
1003	WP_CLI::error( __( 'Jetpack sync is not currently allowed for this site. The site is in safe mode.', 'jetpack' ) );
1004	return;
1005	}
1006	}
1007	// Get the original settings so that we can restore them later.
1008	$original_settings = Settings::get_settings();
1009
1010	// Initialize sync settigns so we can sync as quickly as possible.
1011	$sync_settings = wp_parse_args(
1012	array_intersect_key( $assoc_args, Settings::$valid_settings ),
1013	array(
1014	'sync_wait_time' => 0,
1015	'enqueue_wait_time' => 0,
1016	'queue_max_writes_sec' => 10000,
1017	'max_queue_size_full_sync' => 100000,
1018	'full_sync_send_duration' => HOUR_IN_SECONDS,
1019	)
1020	);
1021	Settings::update_settings( $sync_settings );
1022
1023	// Convert comma-delimited string of modules to an array.
1024	if ( ! empty( $assoc_args['modules'] ) ) {
1025	$modules = array_map( 'trim', explode( ',', $assoc_args['modules'] ) );
1026
1027	// Convert the array so that the keys are the module name and the value is true to indicate
1028	// that we want to sync the module.
1029	$modules = array_map( '__return_true', array_flip( $modules ) );
1030	}
1031
1032	foreach ( array( 'posts', 'comments', 'users' ) as $module_name ) {
1033	if (
1034	'users' === $module_name &&
1035	isset( $assoc_args[ $module_name ] ) &&
1036	'initial' === $assoc_args[ $module_name ]
1037	) {
1038	$modules['users'] = 'initial';
1039	} elseif ( isset( $assoc_args[ $module_name ] ) ) {
1040	$ids = explode( ',', $assoc_args[ $module_name ] );
1041	if ( $ids !== array() ) {
1042	$modules[ $module_name ] = $ids;
1043	}
1044	}
1045	}
1046
1047	if ( empty( $modules ) ) {
1048	$modules = null;
1049	}
1050
1051	// Kick off a full sync.
1052	if ( Actions::do_full_sync( $modules, 'jetpack_cli' ) ) {
1053	if ( $modules ) {
1054	/* translators: %s is a comma-separated list of Jetpack modules */
1055	WP_CLI::log( sprintf( __( 'Initialized a new full sync with modules: %s', 'jetpack' ), implode( ', ', array_keys( $modules ) ) ) );
1056	} else {
1057	WP_CLI::log( __( 'Initialized a new full sync', 'jetpack' ) );
1058	}
1059	} else {
1060
1061	// Reset sync settings to original.
1062	Settings::update_settings( $original_settings );
1063
1064	if ( $modules ) {
1065	/* translators: %s is a comma-separated list of Jetpack modules */
1066	WP_CLI::error( sprintf( __( 'Could not start a new full sync with modules: %s', 'jetpack' ), implode( ', ', $modules ) ) );
1067	} else {
1068	WP_CLI::error( __( 'Could not start a new full sync', 'jetpack' ) );
1069	}
1070	}
1071
1072	// Keep sending to WPCOM until there's nothing to send.
1073	$i = 1;
1074	do {
1075	$result = Actions::$sender->do_full_sync();
1076	if ( is_wp_error( $result ) ) {
1077	$queue_empty_error = ( 'empty_queue_full_sync' === $result->get_error_code() );
1078	if ( ! $queue_empty_error \|\| ( $queue_empty_error && ( 1 === $i ) ) ) {
1079	/* translators: %s is an error code */
1080	WP_CLI::error( sprintf( __( 'Sync errored with code: %s', 'jetpack' ), $result->get_error_code() ) );
1081	}
1082	} else {
1083	if ( 1 === $i ) {
1084	WP_CLI::log( __( 'Sent data to WordPress.com', 'jetpack' ) );
1085	} else {
1086	WP_CLI::log( __( 'Sent more data to WordPress.com', 'jetpack' ) );
1087	}
1088
1089	// Immediate Full Sync does not wait for WP.com to process data so we need to enforce a wait.
1090	if ( Modules::get_module( 'full-sync' ) instanceof \Automattic\Jetpack\Sync\Modules\Full_Sync_Immediately ) {
1091	sleep( 15 );
1092	}
1093	}
1094	++$i;
1095	} while ( $result && ! is_wp_error( $result ) );
1096
1097	// Reset sync settings to original.
1098	Settings::update_settings( $original_settings );
1099
1100	WP_CLI::success( __( 'Finished syncing to WordPress.com', 'jetpack' ) );
1101	break;
1102	}
1103	}
1104
1105	/**
1106	* List the contents of a specific Jetpack sync queue.
1107	*
1108	* ## OPTIONS
1109	*
1110	* peek : List the 100 front-most items on the queue.
1111	*
1112	* ## EXAMPLES
1113	*
1114	* wp jetpack sync_queue full_sync peek
1115	*
1116	* @synopsis <incremental\|full_sync> <peek>
1117	*
1118	* @param array $args Positional args.
1119	*/
1120	public function sync_queue( $args ) {
1121	if ( ! Actions::sync_allowed() ) {
1122	WP_CLI::error( __( 'Jetpack sync is not currently allowed for this site.', 'jetpack' ) );
1123	}
1124
1125	$queue_name = $args[0] ?? 'sync';
1126	$action = $args[1] ?? 'peek';
1127
1128	// We map the queue name that way we can support more friendly queue names in the commands, but still use
1129	// the queue name that the code expects.
1130	$allowed_queues = array(
1131	'incremental' => 'sync',
1132	'full' => 'full_sync',
1133	);
1134	$queue_name_map = $allowed_queues;
1135	$mapped_queue_name = $queue_name_map[ $queue_name ] ?? $queue_name;
1136
1137	switch ( $action ) {
1138	case 'peek':
1139	$queue = new Queue( $mapped_queue_name );
1140	$items = $queue->peek( 100 );
1141
1142	if ( empty( $items ) ) {
1143	/* translators: %s is the name of the queue, either 'incremental' or 'full' */
1144	WP_CLI::log( sprintf( __( 'Nothing is in the queue: %s', 'jetpack' ), $queue_name ) );
1145	} else {
1146	$collection = array();
1147	foreach ( $items as $item ) {
1148	$collection[] = array(
1149	'action' => $item[0],
1150	'args' => wp_json_encode( $item[1], JSON_UNESCAPED_SLASHES ),
1151	'current_user_id' => $item[2],
1152	'microtime' => $item[3],
1153	'importing' => (string) $item[4],
1154	);
1155	}
1156	WP_CLI\Utils\format_items(
1157	'table',
1158	$collection,
1159	array(
1160	'action',
1161	'args',
1162	'current_user_id',
1163	'microtime',
1164	'importing',
1165	)
1166	);
1167	}
1168	break;
1169	}
1170	}
1171
1172	/**
1173	* Cancel's the current Jetpack plan granted by this partner, if applicable
1174	*
1175	* Returns success or error JSON
1176	*
1177	* <token_json>
1178	* : JSON blob of WPCOM API token
1179	* [--partner_tracking_id=<partner_tracking_id>]
1180	* : This is an optional ID that a host can pass to help identify a site in logs on WordPress.com
1181	*
1182	* @synopsis <token_json> [--partner_tracking_id=<partner_tracking_id>]
1183	*
1184	* @param array $args Positional args.
1185	* @param array $named_args Named args.
1186	*/
1187	public function partner_cancel( $args, $named_args ) {
1188	list( $token_json ) = $args;
1189
1190	$token = $token_json ? json_decode( $token_json ) : null;
1191	if ( ! $token ) {
1192	/* translators: %s is the invalid JSON string */
1193	$this->partner_provision_error( new WP_Error( 'missing_access_token', sprintf( __( 'Invalid token JSON: %s', 'jetpack' ), $token_json ) ) );
1194	}
1195
1196	if ( isset( $token->error ) ) {
1197	$this->partner_provision_error( new WP_Error( $token->error, $token->message ) );
1198	}
1199
1200	if ( ! isset( $token->access_token ) ) {
1201	$this->partner_provision_error( new WP_Error( 'missing_access_token', __( 'Missing or invalid access token', 'jetpack' ) ) );
1202	}
1203
1204	if ( Identity_Crisis::validate_sync_error_idc_option() ) {
1205	$this->partner_provision_error(
1206	new WP_Error(
1207	'site_in_safe_mode',
1208	esc_html__( 'Cannot cancel a plan while in safe mode. See: https://jetpack.com/support/safe-mode/', 'jetpack' )
1209	)
1210	);
1211	}
1212
1213	$site_identifier = Jetpack_Options::get_option( 'id' );
1214
1215	if ( ! $site_identifier ) {
1216	$status = new Status();
1217	$site_identifier = $status->get_site_suffix();
1218	}
1219
1220	$request = array(
1221	'headers' => array(
1222	'Authorization' => 'Bearer ' . $token->access_token,
1223	'Host' => 'public-api.wordpress.com',
1224	),
1225	'timeout' => 60,
1226	'method' => 'POST',
1227	);
1228
1229	$url = sprintf( '%s/rest/v1.3/jpphp/%s/partner-cancel', $this->get_api_host(), $site_identifier );
1230	if ( ! empty( $named_args ) && ! empty( $named_args['partner_tracking_id'] ) ) {
1231	$url = esc_url_raw( add_query_arg( 'partner_tracking_id', $named_args['partner_tracking_id'], $url ) );
1232	}
1233
1234	// @phan-suppress-next-line PhanAccessMethodInternal -- Phan is correct, but the usage is intentional.
1235	$result = Client::_wp_remote_request( $url, $request );
1236
1237	if ( is_wp_error( $result ) ) {
1238	$this->partner_provision_error( $result );
1239	}
1240
1241	WP_CLI::log( wp_remote_retrieve_body( $result ) );
1242	}
1243
1244	/**
1245	* Provision a site using a Jetpack Partner license
1246	*
1247	* Returns JSON blob
1248	*
1249	* ## OPTIONS
1250	*
1251	* <token_json>
1252	* : JSON blob of WPCOM API token
1253	* [--plan=<plan_name>]
1254	* : Slug of the requested plan, e.g. premium
1255	* [--wpcom_user_id=<user_id>]
1256	* : WordPress.com ID of user to connect as (must be whitelisted against partner key)
1257	* [--wpcom_user_email=<wpcom_user_email>]
1258	* : Override the email we send to WordPress.com for registration
1259	* [--force_register=<register>]
1260	* : Whether to force a site to register
1261	* [--force_connect=<force_connect>]
1262	* : Force JPS to not reuse existing credentials
1263	* [--home_url=<home_url>]
1264	* : Overrides the home option via the home_url filter, or the WP_HOME constant
1265	* [--site_url=<site_url>]
1266	* : Overrides the siteurl option via the site_url filter, or the WP_SITEURL constant
1267	* [--partner_tracking_id=<partner_tracking_id>]
1268	* : This is an optional ID that a host can pass to help identify a site in logs on WordPress.com
1269	*
1270	* ## EXAMPLES
1271	*
1272	* $ wp jetpack partner_provision '{ some: "json" }' premium 1
1273	* { success: true }
1274	*
1275	* @synopsis <token_json> [--wpcom_user_id=<user_id>] [--plan=<plan_name>] [--force_register=<register>] [--force_connect=<force_connect>] [--home_url=<home_url>] [--site_url=<site_url>] [--wpcom_user_email=<wpcom_user_email>] [--partner_tracking_id=<partner_tracking_id>]
1276	*
1277	* @param array $args Positional args.
1278	* @param array $named_args Named args.
1279	*/
1280	public function partner_provision( $args, $named_args ) {
1281	list( $token_json ) = $args;
1282
1283	$token = $token_json ? json_decode( $token_json ) : null;
1284	if ( ! $token ) {
1285	/* translators: %s is the invalid JSON string */
1286	$this->partner_provision_error( new WP_Error( 'missing_access_token', sprintf( __( 'Invalid token JSON: %s', 'jetpack' ), $token_json ) ) );
1287	}
1288
1289	if ( isset( $token->error ) ) {
1290	$message = $token->message ?? '';
1291	$this->partner_provision_error( new WP_Error( $token->error, $message ) );
1292	}
1293
1294	if ( ! isset( $token->access_token ) ) {
1295	$this->partner_provision_error( new WP_Error( 'missing_access_token', __( 'Missing or invalid access token', 'jetpack' ) ) );
1296	}
1297
1298	require_once JETPACK__PLUGIN_DIR . '_inc/class.jetpack-provision.php';
1299
1300	$body_json = Jetpack_Provision::partner_provision( $token->access_token, $named_args );
1301
1302	if ( is_wp_error( $body_json ) ) {
1303	WP_CLI::error(
1304	wp_json_encode(
1305	array(
1306	'success' => false,
1307	'error_code' => $body_json->get_error_code(),
1308	'error_message' => $body_json->get_error_message(),
1309	),
1310	JSON_UNESCAPED_SLASHES
1311	)
1312	);
1313	exit( 1 );
1314	}
1315
1316	WP_CLI::log( wp_json_encode( $body_json, JSON_UNESCAPED_SLASHES ) );
1317	}
1318
1319	/**
1320	* Manages your Jetpack sitemap
1321	*
1322	* ## OPTIONS
1323	*
1324	* rebuild : Rebuild all sitemaps
1325	* --purge : if set, will remove all existing sitemap data before rebuilding
1326	* --monitor : if set, will output elapsed time, peak memory usage, CPU time (user/system), and average CPU utilization
1327	* --suspend-cache-addition : if set, will suspend cache additions during sitemap generation
1328	*
1329	* ## EXAMPLES
1330	*
1331	* wp jetpack sitemap rebuild
1332	* wp jetpack sitemap rebuild --monitor
1333	*
1334	* @subcommand sitemap
1335	* @synopsis <rebuild> [--purge] [--monitor] [--suspend-cache-addition]
1336	*
1337	* @param array $args Positional args.
1338	* @param array $assoc_args Named args.
1339	*/
1340	public function sitemap( $args, $assoc_args ) {
1341	if ( ! Jetpack::is_module_active( 'sitemaps' ) ) {
1342	WP_CLI::error( __( 'Jetpack Sitemaps module is not currently active. Activate it first if you want to work with sitemaps.', 'jetpack' ) );
1343	}
1344	if ( ! class_exists( 'Jetpack_Sitemap_Builder' ) ) {
1345	WP_CLI::error( __( 'Jetpack Sitemaps module is active, but unavailable. This can happen if your site is set to discourage search engine indexing. Please enable search engine indexing to allow sitemap generation.', 'jetpack' ) );
1346	}
1347
1348	if ( isset( $assoc_args['suspend-cache-addition'] ) && $assoc_args['suspend-cache-addition'] ) {
1349	add_filter( 'jetpack_sitemap_suspend_cache_addition', '__return_true' );
1350	WP_CLI::success( 'Suspending cache addition.' );
1351	}
1352
1353	$monitor = isset( $assoc_args['monitor'] ) && $assoc_args['monitor'];
1354
1355	if ( $monitor ) {
1356	$start_time = microtime( true );
1357	$rusage_start = function_exists( 'getrusage' ) ? getrusage() : null;
1358	}
1359
1360	if ( isset( $assoc_args['purge'] ) && $assoc_args['purge'] ) {
1361	$librarian = new Jetpack_Sitemap_Librarian();
1362	$librarian->delete_all_stored_sitemap_data();
1363
1364	// Clear sitemap-related transients
1365	delete_transient( 'jetpack_news_sitemap_xml' );
1366	delete_transient( 'jetpack-sitemap-state-lock' );
1367	WP_CLI::success( __( 'Purged all sitemap data and cleared sitemap transients.', 'jetpack' ) );
1368	}
1369
1370	$sitemap_builder = new Jetpack_Sitemap_Builder();
1371	$sitemap_builder->update_sitemap();
1372
1373	WP_CLI::success( __( 'Sitemap rebuilt successfully.', 'jetpack' ) );
1374
1375	if ( $monitor && isset( $start_time ) ) {
1376	$end_time = microtime( true );
1377	$peak_memory = memory_get_peak_usage();
1378	$elapsed_time = $end_time - $start_time;
1379	$rusage_end = function_exists( 'getrusage' ) ? getrusage() : null;
1380
1381	WP_CLI::log( '----------------------------------' );
1382	WP_CLI::log( __( 'Performance Metrics:', 'jetpack' ) );
1383	/* translators: %s is a float representing seconds */
1384	WP_CLI::log( sprintf( __( 'Elapsed Time: %.4f seconds', 'jetpack' ), $elapsed_time ) );
1385	/* translators: %s is a human-readable memory size (e.g., 128MB) */
1386	WP_CLI::log( sprintf( __( 'Peak Memory Usage: %s', 'jetpack' ), size_format( $peak_memory ) ) );
1387
1388	if ( ! empty( $rusage_start ) && ! empty( $rusage_end ) ) {
1389	$user_cpu_time = ( $rusage_end['ru_utime.tv_sec'] * 1e6 + $rusage_end['ru_utime.tv_usec'] ) - ( $rusage_start['ru_utime.tv_sec'] * 1e6 + $rusage_start['ru_utime.tv_usec'] );
1390	$system_cpu_time = ( $rusage_end['ru_stime.tv_sec'] * 1e6 + $rusage_end['ru_stime.tv_usec'] ) - ( $rusage_start['ru_stime.tv_sec'] * 1e6 + $rusage_start['ru_stime.tv_usec'] );
1391
1392	/* translators: %d is an integer representing microseconds */
1393	WP_CLI::log( sprintf( __( 'CPU time (user): %d microseconds', 'jetpack' ), $user_cpu_time ) );
1394	/* translators: %d is an integer representing microseconds */
1395	WP_CLI::log( sprintf( __( 'CPU time (system): %d microseconds', 'jetpack' ), $system_cpu_time ) );
1396
1397	// Average CPU utilization over the elapsed wall time.
1398	$total_cpu_sec = ( $user_cpu_time + $system_cpu_time ) / 1e6;
1399	$avg_cpu_pct = $elapsed_time > 0 ? ( $total_cpu_sec / $elapsed_time ) * 100 : 0.0;
1400	/* translators: %s is a percentage like 83.4 */
1401	WP_CLI::log( sprintf( __( 'Average CPU Utilization: %.1f%%', 'jetpack' ), $avg_cpu_pct ) );
1402	}
1403	WP_CLI::log( '----------------------------------' );
1404	}
1405	}
1406
1407	/**
1408	* Allows authorizing a user via the command line and will activate
1409	*
1410	* ## EXAMPLES
1411	*
1412	* wp jetpack authorize_user --token=123456789abcdef
1413	*
1414	* @synopsis --token=<value>
1415	*
1416	* @param array $args Positional args.
1417	* @param array $named_args Named args.
1418	*/
1419	public function authorize_user( $args, $named_args ) {
1420	if ( ! is_user_logged_in() ) {
1421	WP_CLI::error( __( 'Please select a user to authorize via the --user global argument.', 'jetpack' ) );
1422	}
1423
1424	if ( empty( $named_args['token'] ) ) {
1425	WP_CLI::error( __( 'A non-empty token argument must be passed.', 'jetpack' ) );
1426	}
1427
1428	$is_connection_owner = ! Jetpack::connection()->has_connected_owner();
1429	$current_user_id = get_current_user_id();
1430
1431	( new Tokens() )->update_user_token( $current_user_id, sprintf( '%s.%d', $named_args['token'], $current_user_id ), $is_connection_owner );
1432
1433	WP_CLI::log( wp_json_encode( $named_args, JSON_UNESCAPED_SLASHES ) );
1434
1435	if ( $is_connection_owner ) {
1436	/**
1437	* Auto-enable SSO module for new Jetpack Start connections
1438	*
1439	* @since 5.0.0
1440	*
1441	* @param bool $enable_sso Whether to enable the SSO module. Default to true.
1442	*/
1443	$enable_sso = apply_filters( 'jetpack_start_enable_sso', true );
1444	Jetpack::handle_post_authorization_actions( $enable_sso, false );
1445
1446	/* translators: %d is a user ID */
1447	WP_CLI::success( sprintf( __( 'Authorized %d and activated default modules.', 'jetpack' ), $current_user_id ) );
1448	} else {
1449	/* translators: %d is a user ID */
1450	WP_CLI::success( sprintf( __( 'Authorized %d.', 'jetpack' ), $current_user_id ) );
1451	}
1452	}
1453
1454	/**
1455	* Allows calling a WordPress.com API endpoint using the current blog's token.
1456	*
1457	* ## OPTIONS
1458	* --resource=<resource>
1459	* : The resource to call with the current blog's token, where `%d` represents the current blog's ID.
1460	*
1461	* [--api_version=<api_version>]
1462	* : The API version to query against.
1463	*
1464	* [--base_api_path=<base_api_path>]
1465	* : The base API path to query.
1466	* ---
1467	* default: rest
1468	* ---
1469	*
1470	* [--body=<body>]
1471	* : A JSON encoded string representing arguments to send in the body.
1472	*
1473	* [--field=<value>]
1474	* : Any number of arguments that should be passed to the resource.
1475	*
1476	* [--pretty]
1477	* : Will pretty print the results of a successful API call.
1478	*
1479	* [--strip-success]
1480	* : Will remove the green success label from successful API calls.
1481	*
1482	* ## EXAMPLES
1483	*
1484	* wp jetpack call_api --resource='/sites/%d'
1485	*
1486	* @param array $args Positional args.
1487	* @param array $named_args Named args.
1488	*/
1489	public function call_api( $args, $named_args ) {
1490	if ( ! Jetpack::is_connection_ready() ) {
1491	WP_CLI::error( __( 'Jetpack is not currently connected to WordPress.com', 'jetpack' ) );
1492	}
1493
1494	$consumed_args = array(
1495	'resource',
1496	'api_version',
1497	'base_api_path',
1498	'body',
1499	'pretty',
1500	);
1501
1502	// Get args that should be passed to resource.
1503	$other_args = array_diff_key( $named_args, array_flip( $consumed_args ) );
1504
1505	$decoded_body = ! empty( $named_args['body'] )
1506	? json_decode( $named_args['body'], true )
1507	: false;
1508
1509	$resource_url = ( ! str_contains( $named_args['resource'], '%d' ) )
1510	? $named_args['resource']
1511	: sprintf( $named_args['resource'], Jetpack_Options::get_option( 'id' ) );
1512
1513	$response = Client::wpcom_json_api_request_as_blog(
1514	$resource_url,
1515	empty( $named_args['api_version'] ) ? Client::WPCOM_JSON_API_VERSION : $named_args['api_version'],
1516	$other_args,
1517	empty( $decoded_body ) ? null : $decoded_body,
1518	empty( $named_args['base_api_path'] ) ? 'rest' : $named_args['base_api_path']
1519	);
1520
1521	if ( is_wp_error( $response ) ) {
1522	WP_CLI::error(
1523	sprintf(
1524	/* translators: %1$s is an endpoint route (ex. /sites/123456), %2$d is an error code, %3$s is an error message. */
1525	__( 'Request to %1$s returned an error: (%2$d) %3$s.', 'jetpack' ),
1526	$resource_url,
1527	$response->get_error_code(),
1528	$response->get_error_message()
1529	)
1530	);
1531	}
1532
1533	if ( 200 !== wp_remote_retrieve_response_code( $response ) ) {
1534	WP_CLI::error(
1535	sprintf(
1536	/* translators: %1$s is an endpoint route (ex. /sites/123456), %2$d is an HTTP status code. */
1537	__( 'Request to %1$s returned a non-200 response code: %2$d.', 'jetpack' ),
1538	$resource_url,
1539	wp_remote_retrieve_response_code( $response )
1540	)
1541	);
1542	}
1543
1544	$output = wp_remote_retrieve_body( $response );
1545	if ( isset( $named_args['pretty'] ) ) {
1546	$decoded_output = json_decode( $output );
1547	if ( $decoded_output ) {
1548	$output = wp_json_encode( $decoded_output, JSON_UNESCAPED_SLASHES \| JSON_PRETTY_PRINT );
1549	}
1550	}
1551
1552	if ( isset( $named_args['strip-success'] ) ) {
1553	WP_CLI::log( $output );
1554	WP_CLI::halt( 0 );
1555	}
1556
1557	WP_CLI::success( $output );
1558	}
1559
1560	/**
1561	* Allows uploading SSH Credentials to the current site for backups, restores, and security scanning.
1562	*
1563	* ## OPTIONS
1564	*
1565	* [--host=<host>]
1566	* : The SSH server's address.
1567	*
1568	* [--ssh-user=<user>]
1569	* : The username to use to log in to the SSH server.
1570	*
1571	* [--pass=<pass>]
1572	* : The password used to log in, if using a password. (optional)
1573	*
1574	* [--kpri=<kpri>]
1575	* : The private key used to log in, if using a private key. (optional)
1576	*
1577	* [--pretty]
1578	* : Will pretty print the results of a successful API call. (optional)
1579	*
1580	* [--strip-success]
1581	* : Will remove the green success label from successful API calls. (optional)
1582	*
1583	* ## EXAMPLES
1584	*
1585	* wp jetpack upload_ssh_creds --host=example.com --ssh-user=example --pass=password
1586	* wp jetpack updload_ssh_creds --host=example.com --ssh-user=example --kpri=key
1587	*
1588	* @param array $args Positional args.
1589	* @param array $named_args Named args.
1590	*/
1591	public function upload_ssh_creds( $args, $named_args ) {
1592	if ( ! Jetpack::is_connection_ready() ) {
1593	WP_CLI::error( __( 'Jetpack is not currently connected to WordPress.com', 'jetpack' ) );
1594	}
1595
1596	$required_args = array(
1597	'host',
1598	'ssh-user',
1599	);
1600
1601	foreach ( $required_args as $arg ) {
1602	if ( empty( $named_args[ $arg ] ) ) {
1603	WP_CLI::error(
1604	sprintf(
1605	/* translators: %s is a slug, such as 'host'. */
1606	__( '`%s` cannot be empty.', 'jetpack' ),
1607	$arg
1608	)
1609	);
1610	}
1611	}
1612
1613	if ( empty( $named_args['pass'] ) && empty( $named_args['kpri'] ) ) {
1614	WP_CLI::error( __( 'Both `pass` and `kpri` fields cannot be blank.', 'jetpack' ) );
1615	}
1616
1617	$values = array(
1618	'credentials' => array(
1619	'site_url' => get_site_url(),
1620	'abspath' => ABSPATH,
1621	'protocol' => 'ssh',
1622	'port' => 22,
1623	'role' => 'main',
1624	'host' => $named_args['host'],
1625	'user' => $named_args['ssh-user'],
1626	'pass' => empty( $named_args['pass'] ) ? '' : $named_args['pass'],
1627	'kpri' => empty( $named_args['kpri'] ) ? '' : $named_args['kpri'],
1628	),
1629	);
1630
1631	$named_args = wp_parse_args(
1632	array(
1633	'resource' => '/activity-log/%d/update-credentials',
1634	'method' => 'POST',
1635	'api_version' => '1.1',
1636	'body' => wp_json_encode( $values, JSON_UNESCAPED_SLASHES ),
1637	'timeout' => 30,
1638	),
1639	$named_args
1640	);
1641
1642	self::call_api( $args, $named_args );
1643	}
1644
1645	/**
1646	* API wrapper for getting stats from the WordPress.com API for the current site.
1647	*
1648	* ## OPTIONS
1649	*
1650	* [--quantity=<quantity>]
1651	* : The number of units to include.
1652	* ---
1653	* default: 30
1654	* ---
1655	*
1656	* [--period=<period>]
1657	* : The unit of time to query stats for.
1658	* ---
1659	* default: day
1660	* options:
1661	* - day
1662	* - week
1663	* - month
1664	* - year
1665	* ---
1666	*
1667	* [--date=<date>]
1668	* : The latest date to return stats for. Ex. - 2018-01-01.
1669	*
1670	* [--pretty]
1671	* : Will pretty print the results of a successful API call.
1672	*
1673	* [--strip-success]
1674	* : Will remove the green success label from successful API calls.
1675	*
1676	* ## EXAMPLES
1677	*
1678	* wp jetpack get_stats
1679	*
1680	* @param array $args Positional args.
1681	* @param array $named_args Named args.
1682	*/
1683	public function get_stats( $args, $named_args ) {
1684	$selected_args = array_intersect_key(
1685	$named_args,
1686	array_flip(
1687	array(
1688	'quantity',
1689	'date',
1690	)
1691	)
1692	);
1693
1694	// The API expects unit, but period seems to be more correct.
1695	$selected_args['unit'] = $named_args['period'];
1696
1697	$command = sprintf(
1698	'jetpack call_api --resource=/sites/%d/stats/%s',
1699	Jetpack_Options::get_option( 'id' ),
1700	add_query_arg( $selected_args, 'visits' )
1701	);
1702
1703	if ( isset( $named_args['pretty'] ) ) {
1704	$command .= ' --pretty';
1705	}
1706
1707	if ( isset( $named_args['strip-success'] ) ) {
1708	$command .= ' --strip-success';
1709	}
1710
1711	WP_CLI::runcommand(
1712	$command,
1713	array(
1714	'launch' => false, // Use the current process.
1715	)
1716	);
1717	}
1718
1719	/**
1720	* Allows management of publicize connections.
1721	*
1722	* ## OPTIONS
1723	*
1724	* <list\|disconnect>
1725	* : The action to perform.
1726	* ---
1727	* options:
1728	* - list
1729	* - disconnect
1730	* ---
1731	*
1732	* [<identifier>]
1733	* : The connection ID or service to perform an action on.
1734	*
1735	* [--ignore-cache]
1736	* : Whether to ignore connections cache.
1737	*
1738	* [--format=<format>]
1739	* : Allows overriding the output of the command when listing connections.
1740	* ---
1741	* default: table
1742	* options:
1743	* - table
1744	* - json
1745	* - csv
1746	* - yaml
1747	* - ids
1748	* - count
1749	* ---
1750	*
1751	* ## EXAMPLES
1752	*
1753	* # List all publicize connections.
1754	* $ wp jetpack publicize list
1755	*
1756	* # List all publicize connections, ignoring the cache.
1757	* $ wp jetpack publicize list --ignore-cache
1758	*
1759	* # List publicize connections for a given service.
1760	* $ wp jetpack publicize list linkedin
1761	*
1762	* # List all publicize connections for a given user.
1763	* $ wp --user=1 jetpack publicize list
1764	*
1765	* # List all publicize connections for a given user and service.
1766	* $ wp --user=1 jetpack publicize list linkedin
1767	*
1768	* # Display details for a given connection.
1769	* $ wp jetpack publicize list 123456
1770	*
1771	* # Diconnection a given connection.
1772	* $ wp jetpack publicize disconnect 123456
1773	*
1774	* # Disconnect all connections.
1775	* $ wp jetpack publicize disconnect all
1776	*
1777	* # Disconnect all connections for a given service.
1778	* $ wp jetpack publicize disconnect linkedin
1779	*
1780	* @param array $args Positional args.
1781	* @param array $named_args Named args.
1782	*/
1783	public function publicize( $args, $named_args ) {
1784	if ( ! Jetpack::connection()->has_connected_owner() ) {
1785	WP_CLI::error( __( 'Jetpack Social requires a user-level connection to WordPress.com', 'jetpack' ) );
1786	}
1787
1788	if ( ! Jetpack::is_module_active( 'publicize' ) ) {
1789	WP_CLI::error( __( 'The Jetpack Social module is not active.', 'jetpack' ) );
1790	}
1791
1792	if ( ( new Status() )->is_offline_mode() ) {
1793	if (
1794	! defined( 'JETPACK_DEV_DEBUG' ) &&
1795	! has_filter( 'jetpack_offline_mode' ) &&
1796	! str_contains( site_url(), '.' )
1797	) {
1798	WP_CLI::error( __( "Jetpack is current in offline mode because the site url does not contain a '.', which often occurs when dynamically setting the WP_SITEURL constant. While in offline mode, the Jetpack Social module will not load.", 'jetpack' ) );
1799	}
1800
1801	WP_CLI::error( __( 'Jetpack is currently in offline mode, so the Jetpack Social module will not load.', 'jetpack' ) );
1802	}
1803
1804	if ( ! class_exists( Publicize::class ) ) {
1805	WP_CLI::error( __( 'The Jetpack Social module is not loaded.', 'jetpack' ) );
1806	}
1807
1808	$action = $args[0];
1809	$publicize = new Publicize();
1810	$identifier = ! empty( $args[1] ) ? $args[1] : false;
1811	$services = array_keys( $publicize->get_services() );
1812	$id_is_service = in_array( $identifier, $services, true );
1813
1814	switch ( $action ) {
1815	case 'list':
1816	$_args = array(
1817	'ignore_cache' => $named_args['ignore-cache'] ?? false,
1818	);
1819	// For the CLI command, let's return all connections when a user isn't specified. This
1820	// differs from the logic in the Publicize class.
1821	$connections_to_return = is_user_logged_in()
1822	? Connections::get_all_for_user( $_args )
1823	: Connections::get_all( $_args );
1824
1825	if ( $id_is_service && ! empty( $identifier ) && ! empty( $connections_to_return ) ) {
1826	$temp_connections = $connections_to_return;
1827	$connections_to_return = array();
1828
1829	foreach ( $temp_connections as $connection ) {
1830	if ( $identifier === $connection['service_name'] ) {
1831	$connections_to_return[] = $connection;
1832	}
1833	}
1834	}
1835
1836	if ( $identifier && ! $id_is_service && ! empty( $connections_to_return ) ) {
1837	$connections_to_return = wp_list_filter( $connections_to_return, array( 'connection_id' => $identifier ) );
1838	}
1839
1840	$expected_keys = array(
1841	'connection_id',
1842	'service_name',
1843	'display_name',
1844	'external_id',
1845	'wpcom_user_id',
1846	'shared',
1847	);
1848
1849	// Somehow, a test site ended up in a state where $connections_to_return looked like:
1850	// array( array( array( 'id' => 0, 'service' => 0 ) ) )
1851	// This caused the CLI command to error when running WP_CLI\Utils\format_items() below. So
1852	// to minimize future issues, this nested loop will remove any connections that don't contain
1853	// any keys that we expect.
1854	foreach ( (array) $connections_to_return as $connection_key => $connection ) {
1855	foreach ( $expected_keys as $expected_key ) {
1856	if ( ! isset( $connection[ $expected_key ] ) ) {
1857	unset( $connections_to_return[ $connection_key ] );
1858	continue;
1859	}
1860	}
1861	}
1862
1863	if ( empty( $connections_to_return ) ) {
1864	return false;
1865	}
1866
1867	WP_CLI\Utils\format_items( $named_args['format'], $connections_to_return, $expected_keys );
1868	break; // list.
1869	case 'disconnect':
1870	if ( ! $identifier ) {
1871	WP_CLI::error( __( 'A connection ID must be passed in order to disconnect.', 'jetpack' ) );
1872	}
1873
1874	// If the connection ID is 'all' then delete all connections. If the connection ID
1875	// matches a service, delete all connections for that service.
1876	if ( 'all' === $identifier \|\| $id_is_service ) {
1877	if ( 'all' === $identifier ) {
1878	WP_CLI::log( __( "You're about to delete all Jetpack Social connections.", 'jetpack' ) );
1879	} else {
1880	/* translators: %s is a lowercase string for a social network. */
1881	WP_CLI::log( sprintf( __( "You're about to delete all Jetpack Social connections to %s.", 'jetpack' ), $identifier ) );
1882	}
1883
1884	jetpack_cli_are_you_sure();
1885
1886	$service = $identifier;
1887	$connections = is_user_logged_in()
1888	? Connections::get_all_for_user()
1889	: Connections::get_all();
1890
1891	if ( 'all' !== $service ) {
1892	$connections = wp_list_filter( $connections, array( 'service_name' => $service ) );
1893	}
1894
1895	if ( ! empty( $connections ) ) {
1896	$count = is_countable( $connections ) ? count( $connections ) : 0;
1897	$progress = \WP_CLI\Utils\make_progress_bar(
1898	/* translators: %s is a lowercase string for a social network. */
1899	sprintf( __( 'Disconnecting all connections to %s.', 'jetpack' ), $service ),
1900	$count
1901	);
1902
1903	foreach ( $connections as $connection ) {
1904	$id = $connection['connection_id'];
1905	if ( false === $publicize->disconnect( false, $id ) ) {
1906	WP_CLI::error(
1907	sprintf(
1908	/* translators: %1$d is a numeric ID and %2$s is a lowercase string for a social network. */
1909	__( 'Jetpack Social connection %d could not be disconnected', 'jetpack' ),
1910	$id
1911	)
1912	);
1913	}
1914
1915	// @phan-suppress-next-line PhanUndeclaredClassMethod - Class is missing from php-stubs/wp-cli-stubs 🤷
1916	$progress->tick();
1917	}
1918
1919	// @phan-suppress-next-line PhanUndeclaredClassMethod - Class is missing from php-stubs/wp-cli-stubs 🤷
1920	$progress->finish();
1921
1922	if ( 'all' === $service ) {
1923	WP_CLI::success( __( 'All Jetpack Social connections were successfully disconnected.', 'jetpack' ) );
1924	} else {
1925	/* translators: %s is a lowercase string for a social network. */
1926	WP_CLI::success( sprintf( __( 'All Jetpack Social connections to %s were successfully disconnected.', 'jetpack' ), $service ) );
1927	}
1928	}
1929	} elseif ( false !== $publicize->disconnect( false, $identifier ) ) {
1930	/* translators: %d is a numeric ID. Example: 1234. */
1931	WP_CLI::success( sprintf( __( 'Jetpack Social connection %d has been disconnected.', 'jetpack' ), $identifier ) );
1932	} else {
1933	/* translators: %d is a numeric ID. Example: 1234. */
1934	WP_CLI::error( sprintf( __( 'Jetpack Social connection %d could not be disconnected.', 'jetpack' ), $identifier ) );
1935	}
1936	break; // disconnect.
1937	}
1938	}
1939
1940	/**
1941	* Get the API host.
1942	*
1943	* @return string URL.
1944	*/
1945	private function get_api_host() {
1946	$env_api_host = getenv( 'JETPACK_START_API_HOST', true );
1947	return $env_api_host ? 'https://' . $env_api_host : JETPACK__WPCOM_JSON_API_BASE;
1948	}
1949
1950	/**
1951	* Log and exit on a partner provision error.
1952	*
1953	* @param WP_Error $error Error.
1954	* @return never
1955	*/
1956	private function partner_provision_error( $error ) {
1957	WP_CLI::log(
1958	wp_json_encode(
1959	array(
1960	'success' => false,
1961	'error_code' => $error->get_error_code(),
1962	'error_message' => $error->get_error_message(),
1963	),
1964	JSON_UNESCAPED_SLASHES
1965	)
1966	);
1967	exit( 1 );
1968	}
1969
1970	/**
1971	* Creates the essential files in Jetpack to start building a Gutenberg block or plugin.
1972	*
1973	* ## TYPES
1974	*
1975	* block: it creates a Jetpack block. All files will be created in a directory under extensions/blocks named based on the block title or a specific given slug.
1976	*
1977	* ## BLOCK TYPE OPTIONS
1978	*
1979	* The first parameter is the block title and it's not associative. Add it wrapped in quotes.
1980	* The title is also used to create the slug and the edit PHP class name. If it's something like "Logo gallery", the slug will be 'logo-gallery' and the class name will be LogoGalleryEdit.
1981	* --slug: Specific slug to identify the block that overrides the one generated based on the title.
1982	* --description: Allows to provide a text description of the block.
1983	* --keywords: Provide up to three keywords separated by comma so users can find this block when they search in Gutenberg's inserter.
1984	* --variation: Allows to decide whether the block should be a production block, experimental, or beta. Defaults to Beta when arg not provided.
1985	*
1986	* ## BLOCK TYPE EXAMPLES
1987	*
1988	* wp jetpack scaffold block "Cool Block"
1989	* wp jetpack scaffold block "Amazing Rock" --slug="good-music" --description="Rock the best music on your site"
1990	* wp jetpack scaffold block "Jukebox" --keywords="music, audio, media"
1991	* wp jetpack scaffold block "Jukebox" --variation="experimental"
1992	*
1993	* @subcommand scaffold block
1994	* @synopsis <type> <title> [--slug] [--description] [--keywords] [--variation]
1995	*
1996	* @param array $args Positional parameters, when strings are passed, wrap them in quotes.
1997	* @param array $assoc_args Associative parameters like --slug="nice-block".
1998	*/
1999	public function scaffold( $args, $assoc_args ) {
2000	// It's ok not to check if it's set, because otherwise WPCLI exits earlier.
2001	switch ( $args[0] ) {
2002	case 'block':
2003	$this->block( $args, $assoc_args );
2004	break;
2005	default:
2006	/* translators: %s is the subcommand */
2007	WP_CLI::error( sprintf( esc_html__( 'Invalid subcommand %s.', 'jetpack' ), $args[0] ) . ' 👻' );
2008	exit( 1 );
2009	}
2010	}
2011
2012	/**
2013	* Creates the essential files in Jetpack to build a Gutenberg block.
2014	*
2015	* @param array $args Positional parameters. Only one is used, that corresponds to the block title.
2016	* @param array $assoc_args Associative parameters defined in the scaffold() method.
2017	*/
2018	public function block( $args, $assoc_args ) {
2019	if ( ! isset( $args[1] ) ) {
2020	WP_CLI::error( esc_html__( 'The title parameter is required.', 'jetpack' ) . ' 👻' );
2021	exit( 1 );
2022	}
2023
2024	$title = ucwords( $args[1] );
2025
2026	$slug = $assoc_args['slug'] ?? sanitize_title( $title );
2027
2028	$next_version = "\x24\x24next-version$$"; // Escapes to hide the string from tools/replace-next-version-tag.sh
2029
2030	$variation_options = array( 'production', 'experimental', 'beta' );
2031	$variation = ( isset( $assoc_args['variation'] ) && in_array( $assoc_args['variation'], $variation_options, true ) )
2032	? $assoc_args['variation']
2033	: 'beta';
2034
2035	if ( preg_match( '#^jetpack/#', $slug ) ) {
2036	$slug = preg_replace( '#^jetpack/#', '', $slug );
2037	}
2038
2039	if ( ! preg_match( '/^[a-z][a-z0-9\-]*$/', $slug ) ) {
2040	WP_CLI::error( esc_html__( 'Invalid block slug. They can contain only lowercase alphanumeric characters or dashes, and start with a letter', 'jetpack' ) . ' 👻' );
2041	}
2042
2043	global $wp_filesystem;
2044	if ( ! WP_Filesystem() ) {
2045	WP_CLI::error( esc_html__( "Can't write files", 'jetpack' ) . ' 😱' );
2046	}
2047
2048	$path = JETPACK__PLUGIN_DIR . "extensions/blocks/$slug";
2049
2050	if ( $wp_filesystem->exists( $path ) && $wp_filesystem->is_dir( $path ) ) {
2051	/* translators: %s is path to the conflicting block */
2052	WP_CLI::error( sprintf( esc_html__( 'Name conflicts with the existing block %s', 'jetpack' ), $path ) . ' ⛔️' );
2053	exit( 1 );
2054	}
2055
2056	$wp_filesystem->mkdir( $path );
2057
2058	$keywords = isset( $assoc_args['keywords'] )
2059	? array_map(
2060	function ( $keyword ) {
2061	return trim( $keyword );
2062	},
2063	array_slice( explode( ',', $assoc_args['keywords'] ), 0, 3 )
2064	)
2065	: array();
2066
2067	$files = array(
2068	"$path/block.json" => self::render_block_file(
2069	'block-block-json',
2070	array(
2071	'slug' => $slug,
2072	'title' => wp_json_encode( $title, JSON_UNESCAPED_SLASHES \| JSON_UNESCAPED_UNICODE ),
2073	'description' => isset( $assoc_args['description'] )
2074	? wp_json_encode( $assoc_args['description'], JSON_UNESCAPED_SLASHES \| JSON_UNESCAPED_UNICODE )
2075	: wp_json_encode( $title, JSON_UNESCAPED_SLASHES \| JSON_UNESCAPED_UNICODE ),
2076	'nextVersion' => $next_version,
2077	'keywords' => wp_json_encode( $keywords, JSON_UNESCAPED_SLASHES \| JSON_UNESCAPED_UNICODE ),
2078	)
2079	),
2080	"$path/$slug.php" => self::render_block_file(
2081	'block-register-php',
2082	array(
2083	'nextVersion' => $next_version,
2084	'title' => $title,
2085	'underscoredTitle' => str_replace( ' ', '_', $title ),
2086	)
2087	),
2088	"$path/editor.js" => self::render_block_file( 'block-editor-js' ),
2089	"$path/editor.scss" => self::render_block_file(
2090	'block-editor-scss',
2091	array(
2092	'slug' => $slug,
2093	'title' => $title,
2094	)
2095	),
2096	"$path/edit.js" => self::render_block_file(
2097	'block-edit-js',
2098	array(
2099	'title' => $title,
2100	'className' => str_replace( ' ', '', ucwords( str_replace( '-', ' ', $slug ) ) ),
2101	)
2102	),
2103	);
2104
2105	$files_written = array();
2106
2107	foreach ( $files as $filename => $contents ) {
2108	if ( $wp_filesystem->put_contents( $filename, $contents ) ) {
2109	$files_written[] = $filename;
2110	} else {
2111	/* translators: %s is a file name */
2112	WP_CLI::error( sprintf( esc_html__( 'Error creating %s', 'jetpack' ), $filename ) );
2113	}
2114	}
2115
2116	if ( empty( $files_written ) ) {
2117	WP_CLI::log( esc_html__( 'No files were created', 'jetpack' ) );
2118	} else {
2119	// Load index.json and insert the slug of the new block in its block variation array.
2120	$block_list_path = JETPACK__PLUGIN_DIR . 'extensions/index.json';
2121	$block_list = $wp_filesystem->get_contents( $block_list_path );
2122	if ( empty( $block_list ) ) {
2123	/* translators: %s is the path to the file with the block list */
2124	WP_CLI::error( sprintf( esc_html__( 'Error fetching contents of %s', 'jetpack' ), $block_list_path ) );
2125	} elseif ( false === stripos( $block_list, $slug ) ) {
2126	$new_block_list = json_decode( $block_list );
2127	$new_block_list->{ $variation }[] = $slug;
2128
2129	// Format the JSON to match our coding standards.
2130	$new_block_list_formatted = wp_json_encode( $new_block_list, JSON_UNESCAPED_SLASHES \| JSON_PRETTY_PRINT ) . "\n";
2131	$new_block_list_formatted = preg_replace_callback(
2132	// Find all occurrences of multiples of 4 spaces a the start of the line.
2133	'/^((?: )+)/m',
2134	function ( $matches ) {
2135	// Replace each occurrence of 4 spaces with a tab character.
2136	return str_repeat( "\t", substr_count( $matches[0], ' ' ) );
2137	},
2138	$new_block_list_formatted
2139	);
2140
2141	if ( ! $wp_filesystem->put_contents( $block_list_path, $new_block_list_formatted ) ) {
2142	/* translators: %s is the path to the file with the block list */
2143	WP_CLI::error( sprintf( esc_html__( 'Error writing new %s', 'jetpack' ), $block_list_path ) );
2144	}
2145	}
2146
2147	if ( 'beta' === $variation \|\| 'experimental' === $variation ) {
2148	$block_constant = sprintf(
2149	/* translators: the placeholder is a constant name */
2150	esc_html__( 'To load the block, add the constant JETPACK_BLOCKS_VARIATION set to %1$s to your wp-config.php file', 'jetpack' ),
2151	$variation
2152	);
2153	} else {
2154	$block_constant = '';
2155	}
2156
2157	WP_CLI::success(
2158	sprintf(
2159	/* translators: the placeholders are a human readable title, and a series of words separated by dashes */
2160	esc_html__( 'Successfully created block %1$s with slug %2$s', 'jetpack' ) . ' 🎉' . "\n" .
2161	"--------------------------------------------------------------------------------------------------------------------\n" .
2162	/* translators: the placeholder is a directory path */
2163	esc_html__( 'The files were created at %3$s', 'jetpack' ) . "\n" .
2164	esc_html__( 'To start using the block, build the blocks with pnpm run build-extensions', 'jetpack' ) . "\n" .
2165	/* translators: the placeholder is a file path */
2166	esc_html__( 'The block slug has been added to the %4$s list at %5$s', 'jetpack' ) . "\n" .
2167	'%6$s' . "\n" .
2168	/* translators: the placeholder is a URL */
2169	"\n" . esc_html__( 'Read more at %7$s', 'jetpack' ) . "\n",
2170	$title,
2171	$slug,
2172	$path,
2173	$variation,
2174	$block_list_path,
2175	$block_constant,
2176	'https://github.com/Automattic/jetpack/blob/trunk/projects/plugins/jetpack/extensions/README.md#developing-block-editor-extensions-in-jetpack'
2177	) . '--------------------------------------------------------------------------------------------------------------------'
2178	);
2179	}
2180	}
2181
2182	/**
2183	* Built the file replacing the placeholders in the template with the data supplied.
2184	*
2185	* @param string $template Template.
2186	* @param array $data Data.
2187	* @return string mixed
2188	*/
2189	private static function render_block_file( $template, $data = array() ) {
2190	return \WP_CLI\Utils\mustache_render( JETPACK__PLUGIN_DIR . "wp-cli-templates/$template.mustache", $data );
2191	}
2192	}
2193
2194	// phpcs:disable Universal.Files.SeparateFunctionsFromOO.Mixed -- TODO: Move these functions to some other file.
2195
2196	/**
2197	* Standard "ask for permission to continue" function.
2198	* If action cancelled, ask if they need help.
2199	*
2200	* Written outside of the class so it's not listed as an executable command w/ 'wp jetpack'
2201	*
2202	* @param bool $flagged false = normal option \| true = flagged by get_jetpack_options_for_reset().
2203	* @param string $error_msg Error message.
2204	*/
2205	function jetpack_cli_are_you_sure( $flagged = false, $error_msg = false ) {
2206	$cli = new Jetpack_CLI();
2207
2208	// Default cancellation message.
2209	if ( ! $error_msg ) {
2210	$error_msg =
2211	__( 'Action cancelled. Have a question?', 'jetpack' )
2212	. ' '
2213	. $cli->green_open
2214	. 'jetpack.com/support'
2215	. $cli->color_close;
2216	}
2217
2218	if ( ! $flagged ) {
2219	$prompt_message = _x( 'Are you sure? This cannot be undone. Type "yes" to continue:', '"yes" is a command - do not translate.', 'jetpack' );
2220	} else {
2221	$prompt_message = _x( 'Are you sure? Modifying this option may disrupt your Jetpack connection. Type "yes" to continue.', '"yes" is a command - do not translate.', 'jetpack' );
2222	}
2223
2224	WP_CLI::line( $prompt_message );
2225	$handle = fopen( 'php://stdin', 'r' );
2226	$line = fgets( $handle );
2227	if ( 'yes' !== trim( $line ) ) {
2228	WP_CLI::error( $error_msg );
2229	}
2230	}