PluginProbe
Jetpack – WP Security, Backup, Speed, & Growth / 16.3
Jetpack – WP Security, Backup, Speed, & Growth v16.3
16.3 16.3-beta 16.3-a.5 16.3-a.7 16.3-a.3 16.3-a.1 16.2 16.2-beta 12.0.3 12.1.3 12.2.3 12.3.2 12.4.2 12.5.2 12.6.4 12.7.3 12.8.3 12.9.5 13.0.2 13.1.5 13.2.4 13.3.3 13.4.5 13.5.2 13.6.2 All 508 releases
← All changes | class.jetpack-cli.php +2225 -0 16.2-beta → 16.3 View file →
@@ -1,0 +1,2225 @@
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 protected]
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 + $current_allow = get_site_option( 'jetpack_protect_whitelist', array() ); // @todo Update the option name.
673 +
674 + // Build array of IPs that are already on the allowed list.
675 + // Re-build manually instead of using jetpack_protect_format_allow_list() so we can easily get
676 + // low & high range params for IP_Utils::ip_address_is_in_range().
677 + foreach ( $current_allow as $allowed ) {
678 +
679 + // IP ranges.
680 + if ( $allowed->range ) {
681 +
682 + // Is it already on the allowed list?
683 + if ( IP_Utils::ip_address_is_in_range( $new_ip, $allowed->range_low, $allowed->range_high ) ) {
684 + /* translators: %s is an IP address */
685 + WP_CLI::error( sprintf( __( '%s is already on the always allow list.', 'jetpack' ), $new_ip ) );
686 + break;
687 + }
688 + $allow[] = $allowed->range_low . ' - ' . $allowed->range_high;
689 +
690 + } else { // Individual IPs.
691 +
692 + // Check if the IP is already on the allow list (single IP only).
693 + if ( $new_ip === $allowed->ip_address ) {
694 + /* translators: %s is an IP address */
695 + WP_CLI::error( sprintf( __( '%s is already on the always allow list.', 'jetpack' ), $new_ip ) );
696 + break;
697 + }
698 + $allow[] = $allowed->ip_address;
699 +
700 + }
701 + }
702 +
703 + /*
704 + * List the allowed IPs.
705 + * Done here because it's easier to read the $allow array after it's been rebuilt.
706 + */
707 + if ( isset( $args[1] ) && 'list' === $args[1] ) {
708 + if ( ! empty( $allow ) ) {
709 + WP_CLI::success( __( 'Here are your always allowed IPs:', 'jetpack' ) );
710 + foreach ( $allow as $ip ) {
711 + WP_CLI::line( "\t" . str_pad( $ip, 24 ) );
712 + }
713 + } else {
714 + WP_CLI::line( __( 'Always allow list is empty.', 'jetpack' ) );
715 + }
716 + break;
717 + }
718 +
719 + /*
720 + * Clear the always allow list.
721 + */
722 + if ( isset( $args[1] ) && 'clear' === $args[1] ) {
723 + if ( ! empty( $allow ) ) {
724 + $allow = array();
725 + Brute_Force_Protection_Shared_Functions::save_allow_list( $allow ); // @todo Need to update function name in the Protect module.
726 + WP_CLI::success( __( 'Cleared all IPs from the always allow list.', 'jetpack' ) );
727 + } else {
728 + WP_CLI::line( __( 'Always allow list is empty.', 'jetpack' ) );
729 + }
730 + break;
731 + }
732 +
733 + // Append new IP to allow array.
734 + array_push( $allow, $new_ip );
735 +
736 + // Save allow list if there are no errors.
737 + $result = Brute_Force_Protection_Shared_Functions::save_allow_list( $allow ); // @todo Need to update function name in the Protect module.
738 + if ( is_wp_error( $result ) ) {
739 + WP_CLI::error( $result );
740 + }
741 +
742 + /* translators: %s is an IP address */
743 + WP_CLI::success( sprintf( __( '%s has been added to the always allowed list.', 'jetpack' ), $new_ip ) );
744 + break;
745 + case 'prompt':
746 + WP_CLI::error(
747 + __( 'No command found.', 'jetpack' ) . "\n" .
748 + __( 'Please enter the IP address you want to always allow.', 'jetpack' ) . "\n" .
749 + _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" .
750 + _x( "You can also 'list' or 'clear' the always allowed list.", "'list' and 'clear' are commands and should not be translated", 'jetpack' ) . "\n"
751 + );
752 + break;
753 + }
754 + }
755 +
756 + /**
757 + * Manage Jetpack Options
758 + *
759 + * ## OPTIONS
760 + *
761 + * list : List all jetpack options and their values
762 + * delete : Delete an option
763 + * - can only delete options that are white listed.
764 + * update : update an option
765 + * - can only update option strings
766 + * get : get the value of an option
767 + *
768 + * ## EXAMPLES
769 + *
770 + * wp jetpack options list
771 + * wp jetpack options get <option_name>
772 + * wp jetpack options delete <option_name>
773 + * wp jetpack options update <option_name> [<option_value>]
774 + *
775 + * @synopsis <list|get|delete|update> [<option_name>] [<option_value>]
776 + *
777 + * @param array $args Positional args.
778 + */
779 + public function options( $args ) {
780 + $action = $args[0] ?? 'list';
781 + $safe_to_modify = Jetpack_Options::get_options_for_reset();
782 +
783 + // Is the option flagged as unsafe?
784 + $flagged = ! in_array( $args[1], $safe_to_modify, true );
785 +
786 + if ( ! in_array( $action, array( 'list', 'get', 'delete', 'update' ), true ) ) {
787 + /* translators: %s is a command like "prompt" */
788 + WP_CLI::error( sprintf( __( '%s is not a valid command.', 'jetpack' ), $action ) );
789 + }
790 +
791 + if ( isset( $args[0] ) ) {
792 + if ( 'get' === $args[0] && isset( $args[1] ) ) {
793 + $action = 'get';
794 + } elseif ( 'delete' === $args[0] && isset( $args[1] ) ) {
795 + $action = 'delete';
796 + } elseif ( 'update' === $args[0] && isset( $args[1] ) ) {
797 + $action = 'update';
798 + } else {
799 + $action = 'list';
800 + }
801 + }
802 +
803 + // Bail if the option isn't found.
804 + $option = isset( $args[1] ) ? Jetpack_Options::get_option( $args[1] ) : false;
805 + if ( isset( $args[1] ) && ! $option && 'update' !== $args[0] ) {
806 + WP_CLI::error( __( 'Option not found or is empty. Use "list" to list option names', 'jetpack' ) );
807 + }
808 +
809 + // Let's print_r the option if it's an array.
810 + // Used in the 'get' and 'list' actions.
811 + // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_print_r
812 + $option = is_array( $option ) ? print_r( $option, true ) : $option;
813 +
814 + switch ( $action ) {
815 + case 'get':
816 + WP_CLI::success( "\t" . $option );
817 + break;
818 + case 'delete':
819 + jetpack_cli_are_you_sure( $flagged );
820 +
821 + Jetpack_Options::delete_option( $args[1] );
822 + /* translators: %s is the option name */
823 + WP_CLI::success( sprintf( __( 'Deleted option: %s', 'jetpack' ), $args[1] ) );
824 + break;
825 + case 'update':
826 + jetpack_cli_are_you_sure( $flagged );
827 +
828 + // Updating arrays would get pretty tricky...
829 + $value = Jetpack_Options::get_option( $args[1] );
830 + if ( $value && is_array( $value ) ) {
831 + WP_CLI::error( __( 'Sorry, no updating arrays at this time', 'jetpack' ) );
832 + }
833 +
834 + Jetpack_Options::update_option( $args[1], $args[2] );
835 + /* translators: %1$s is the previous value, %2$s is the new value */
836 + WP_CLI::success( sprintf( _x( 'Updated option: %1$s to "%2$s"', 'Updating an option from "this" to "that".', 'jetpack' ), $args[1], $args[2] ) );
837 + break;
838 + case 'list':
839 + $options_compact = Jetpack_Options::get_option_names();
840 + $options_non_compact = Jetpack_Options::get_option_names( 'non_compact' );
841 + $options_private = Jetpack_Options::get_option_names( 'private' );
842 + $options = array_merge( $options_compact, $options_non_compact, $options_private );
843 +
844 + // Table headers.
845 + WP_CLI::line( "\t" . str_pad( __( 'Option', 'jetpack' ), 30 ) . __( 'Value', 'jetpack' ) );
846 +
847 + // List out the options and their values.
848 + // Tell them if the value is empty or not.
849 + // Tell them if it's an array.
850 + foreach ( $options as $option ) {
851 + $value = Jetpack_Options::get_option( $option );
852 + if ( ! $value ) {
853 + WP_CLI::line( "\t" . str_pad( $option, 30 ) . 'Empty' );
854 + continue;
855 + }
856 +
857 + if ( ! is_array( $value ) ) {
858 + WP_CLI::line( "\t" . str_pad( $option, 30 ) . $value );
859 + } elseif ( is_array( $value ) ) {
860 + WP_CLI::line( "\t" . str_pad( $option, 30 ) . 'Array - Use "get <option>" to read option array.' );
861 + }
862 + }
863 + $option_text = '{' . _x( 'option', 'a variable command that a user can write, provided in the printed instructions', 'jetpack' ) . '}';
864 + $value_text = '{' . _x( 'value', 'the value that they want to update the option to', 'jetpack' ) . '}';
865 +
866 + WP_CLI::success(
867 + _x( "Above are your options. You may 'get', 'delete', and 'update' them.", "'get', 'delete', and 'update' are commands - do not translate.", 'jetpack' ) . "\n" .
868 + str_pad( 'wp jetpack options get', 26 ) . $option_text . "\n" .
869 + str_pad( 'wp jetpack options delete', 26 ) . $option_text . "\n" .
870 + str_pad( 'wp jetpack options update', 26 ) . "$option_text $value_text\n" .
871 + _x( "Type 'wp jetpack options' for more info.", "'wp jetpack options' is a command - do not translate.", 'jetpack' ) . "\n"
872 + );
873 + break;
874 + }
875 + }
876 +
877 + /**
878 + * Get the status of or start a new Jetpack sync.
879 + *
880 + * ## OPTIONS
881 + *
882 + * status : Print the current sync status
883 + * settings : Prints the current sync settings
884 + * start : Start a full sync from this site to WordPress.com
885 + * enable : Enables sync on the site
886 + * disable : Disable sync on a site
887 + * reset : Disables sync and Resets the sync queues on a site
888 + *
889 + * ## EXAMPLES
890 + *
891 + * wp jetpack sync status
892 + * wp jetpack sync settings
893 + * wp jetpack sync start --modules=functions --sync_wait_time=5
894 + * wp jetpack sync enable
895 + * wp jetpack sync disable
896 + * wp jetpack sync reset
897 + * wp jetpack sync reset --queue=full or regular
898 + *
899 + * @synopsis <status|start> [--<field>=<value>]
900 + *
901 + * @param array $args Positional args.
902 + * @param array $assoc_args Named args.
903 + */
904 + public function sync( $args, $assoc_args ) {
905 +
906 + $action = $args[0] ?? 'status';
907 +
908 + switch ( $action ) {
909 + case 'status':
910 + $status = Actions::get_sync_status();
911 + $collection = array();
912 + foreach ( $status as $key => $item ) {
913 + $collection[] = array(
914 + 'option' => $key,
915 + 'value' => is_scalar( $item ) ? $item : wp_json_encode( $item, JSON_UNESCAPED_SLASHES ),
916 + );
917 + }
918 + WP_CLI::log( __( 'Sync Status:', 'jetpack' ) );
919 + WP_CLI\Utils\format_items( 'table', $collection, array( 'option', 'value' ) );
920 + break;
921 + case 'settings':
922 + WP_CLI::log( __( 'Sync Settings:', 'jetpack' ) );
923 + $settings = array();
924 + foreach ( Settings::get_settings() as $setting => $item ) {
925 + $settings[] = array(
926 + 'setting' => $setting,
927 + 'value' => is_scalar( $item ) ? $item : wp_json_encode( $item, JSON_UNESCAPED_SLASHES ),
928 + );
929 + }
930 + WP_CLI\Utils\format_items( 'table', $settings, array( 'setting', 'value' ) );
931 + break;
932 + case 'disable':
933 + // Don't set it via the Settings since that also resets the queues.
934 + update_option( 'jetpack_sync_settings_disable', 1 );
935 + /* translators: %s is the site URL */
936 + WP_CLI::log( sprintf( __( 'Sync Disabled on %s', 'jetpack' ), get_site_url() ) );
937 + break;
938 + case 'enable':
939 + Settings::update_settings( array( 'disable' => 0 ) );
940 + /* translators: %s is the site URL */
941 + WP_CLI::log( sprintf( __( 'Sync Enabled on %s', 'jetpack' ), get_site_url() ) );
942 + break;
943 + case 'reset':
944 + // Don't set it via the Settings since that also resets the queues.
945 + update_option( 'jetpack_sync_settings_disable', 1 );
946 +
947 + /* translators: %s is the site URL */
948 + WP_CLI::log( sprintf( __( 'Sync Disabled on %s. Use `wp jetpack sync enable` to enable syncing again.', 'jetpack' ), get_site_url() ) );
949 + $listener = Listener::get_instance();
950 + if ( empty( $assoc_args['queue'] ) ) {
951 + $listener->get_sync_queue()->reset();
952 + $listener->get_full_sync_queue()->reset();
953 + /* translators: %s is the site URL */
954 + WP_CLI::log( sprintf( __( 'Reset Full Sync and Regular Queues Queue on %s', 'jetpack' ), get_site_url() ) );
955 + break;
956 + }
957 +
958 + if ( ! empty( $assoc_args['queue'] ) ) {
959 + switch ( $assoc_args['queue'] ) {
960 + case 'regular':
961 + $listener->get_sync_queue()->reset();
962 + /* translators: %s is the site URL */
963 + WP_CLI::log( sprintf( __( 'Reset Regular Sync Queue on %s', 'jetpack' ), get_site_url() ) );
964 + break;
965 + case 'full':
966 + $listener->get_full_sync_queue()->reset();
967 + /* translators: %s is the site URL */
968 + WP_CLI::log( sprintf( __( 'Reset Full Sync Queue on %s', 'jetpack' ), get_site_url() ) );
969 + break;
970 + default:
971 + WP_CLI::error( __( 'Please specify what type of queue do you want to reset: `full` or `regular`.', 'jetpack' ) );
972 + break;
973 + }
974 + }
975 +
976 + break;
977 + case 'start':
978 + if ( ! Actions::sync_allowed() ) {
979 + if ( Settings::get_setting( 'disable' ) ) {
980 + 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' ) );
981 + return;
982 + }
983 + $connection = new Connection_Manager();
984 + if ( ! $connection->is_connected() ) {
985 + if ( ! doing_action( 'jetpack_site_registered' ) ) {
986 + WP_CLI::error( __( 'Jetpack sync is not currently allowed for this site. Jetpack is not connected.', 'jetpack' ) );
987 + return;
988 + }
989 + }
990 +
991 + $status = new Status();
992 +
993 + if ( $status->is_offline_mode() ) {
994 + WP_CLI::error( __( 'Jetpack sync is not currently allowed for this site. The site is in offline mode.', 'jetpack' ) );
995 + return;
996 + }
997 + if ( $status->in_safe_mode() ) {
998 + WP_CLI::error( __( 'Jetpack sync is not currently allowed for this site. The site is in safe mode.', 'jetpack' ) );
999 + return;
1000 + }
1001 + }
1002 + // Get the original settings so that we can restore them later.
1003 + $original_settings = Settings::get_settings();
1004 +
1005 + // Initialize sync settigns so we can sync as quickly as possible.
1006 + $sync_settings = wp_parse_args(
1007 + array_intersect_key( $assoc_args, Settings::$valid_settings ),
1008 + array(
1009 + 'sync_wait_time' => 0,
1010 + 'enqueue_wait_time' => 0,
1011 + 'queue_max_writes_sec' => 10000,
1012 + 'max_queue_size_full_sync' => 100000,
1013 + 'full_sync_send_duration' => HOUR_IN_SECONDS,
1014 + )
1015 + );
1016 + Settings::update_settings( $sync_settings );
1017 +
1018 + // Convert comma-delimited string of modules to an array.
1019 + if ( ! empty( $assoc_args['modules'] ) ) {
1020 + $modules = array_map( 'trim', explode( ',', $assoc_args['modules'] ) );
1021 +
1022 + // Convert the array so that the keys are the module name and the value is true to indicate
1023 + // that we want to sync the module.
1024 + $modules = array_map( '__return_true', array_flip( $modules ) );
1025 + }
1026 +
1027 + foreach ( array( 'posts', 'comments', 'users' ) as $module_name ) {
1028 + if (
1029 + 'users' === $module_name &&
1030 + isset( $assoc_args[ $module_name ] ) &&
1031 + 'initial' === $assoc_args[ $module_name ]
1032 + ) {
1033 + $modules['users'] = 'initial';
1034 + } elseif ( isset( $assoc_args[ $module_name ] ) ) {
1035 + $ids = explode( ',', $assoc_args[ $module_name ] );
1036 + if ( $ids !== array() ) {
1037 + $modules[ $module_name ] = $ids;
1038 + }
1039 + }
1040 + }
1041 +
1042 + if ( empty( $modules ) ) {
1043 + $modules = null;
1044 + }
1045 +
1046 + // Kick off a full sync.
1047 + if ( Actions::do_full_sync( $modules, 'jetpack_cli' ) ) {
1048 + if ( $modules ) {
1049 + /* translators: %s is a comma-separated list of Jetpack modules */
1050 + WP_CLI::log( sprintf( __( 'Initialized a new full sync with modules: %s', 'jetpack' ), implode( ', ', array_keys( $modules ) ) ) );
1051 + } else {
1052 + WP_CLI::log( __( 'Initialized a new full sync', 'jetpack' ) );
1053 + }
1054 + } else {
1055 +
1056 + // Reset sync settings to original.
1057 + Settings::update_settings( $original_settings );
1058 +
1059 + if ( $modules ) {
1060 + /* translators: %s is a comma-separated list of Jetpack modules */
1061 + WP_CLI::error( sprintf( __( 'Could not start a new full sync with modules: %s', 'jetpack' ), implode( ', ', $modules ) ) );
1062 + } else {
1063 + WP_CLI::error( __( 'Could not start a new full sync', 'jetpack' ) );
1064 + }
1065 + }
1066 +
1067 + // Keep sending to WPCOM until there's nothing to send.
1068 + $i = 1;
1069 + do {
1070 + $result = Actions::$sender->do_full_sync();
1071 + if ( is_wp_error( $result ) ) {
1072 + $queue_empty_error = ( 'empty_queue_full_sync' === $result->get_error_code() );
1073 + if ( ! $queue_empty_error || ( $queue_empty_error && ( 1 === $i ) ) ) {
1074 + /* translators: %s is an error code */
1075 + WP_CLI::error( sprintf( __( 'Sync errored with code: %s', 'jetpack' ), $result->get_error_code() ) );
1076 + }
1077 + } else {
1078 + if ( 1 === $i ) {
1079 + WP_CLI::log( __( 'Sent data to WordPress.com', 'jetpack' ) );
1080 + } else {
1081 + WP_CLI::log( __( 'Sent more data to WordPress.com', 'jetpack' ) );
1082 + }
1083 +
1084 + // Immediate Full Sync does not wait for WP.com to process data so we need to enforce a wait.
1085 + if ( Modules::get_module( 'full-sync' ) instanceof \Automattic\Jetpack\Sync\Modules\Full_Sync_Immediately ) {
1086 + sleep( 15 );
1087 + }
1088 + }
1089 + ++$i;
1090 + } while ( $result && ! is_wp_error( $result ) );
1091 +
1092 + // Reset sync settings to original.
1093 + Settings::update_settings( $original_settings );
1094 +
1095 + WP_CLI::success( __( 'Finished syncing to WordPress.com', 'jetpack' ) );
1096 + break;
1097 + }
1098 + }
1099 +
1100 + /**
1101 + * List the contents of a specific Jetpack sync queue.
1102 + *
1103 + * ## OPTIONS
1104 + *
1105 + * peek : List the 100 front-most items on the queue.
1106 + *
1107 + * ## EXAMPLES
1108 + *
1109 + * wp jetpack sync_queue full_sync peek
1110 + *
1111 + * @synopsis <incremental|full_sync> <peek>
1112 + *
1113 + * @param array $args Positional args.
1114 + */
1115 + public function sync_queue( $args ) {
1116 + if ( ! Actions::sync_allowed() ) {
1117 + WP_CLI::error( __( 'Jetpack sync is not currently allowed for this site.', 'jetpack' ) );
1118 + }
1119 +
1120 + $queue_name = $args[0] ?? 'sync';
1121 + $action = $args[1] ?? 'peek';
1122 +
1123 + // We map the queue name that way we can support more friendly queue names in the commands, but still use
1124 + // the queue name that the code expects.
1125 + $allowed_queues = array(
1126 + 'incremental' => 'sync',
1127 + 'full' => 'full_sync',
1128 + );
1129 + $queue_name_map = $allowed_queues;
1130 + $mapped_queue_name = $queue_name_map[ $queue_name ] ?? $queue_name;
1131 +
1132 + switch ( $action ) {
1133 + case 'peek':
1134 + $queue = new Queue( $mapped_queue_name );
1135 + $items = $queue->peek( 100 );
1136 +
1137 + if ( empty( $items ) ) {
1138 + /* translators: %s is the name of the queue, either 'incremental' or 'full' */
1139 + WP_CLI::log( sprintf( __( 'Nothing is in the queue: %s', 'jetpack' ), $queue_name ) );
1140 + } else {
1141 + $collection = array();
1142 + foreach ( $items as $item ) {
1143 + $collection[] = array(
1144 + 'action' => $item[0],
1145 + 'args' => wp_json_encode( $item[1], JSON_UNESCAPED_SLASHES ),
1146 + 'current_user_id' => $item[2],
1147 + 'microtime' => $item[3],
1148 + 'importing' => (string) $item[4],
1149 + );
1150 + }
1151 + WP_CLI\Utils\format_items(
1152 + 'table',
1153 + $collection,
1154 + array(
1155 + 'action',
1156 + 'args',
1157 + 'current_user_id',
1158 + 'microtime',
1159 + 'importing',
1160 + )
1161 + );
1162 + }
1163 + break;
1164 + }
1165 + }
1166 +
1167 + /**
1168 + * Cancel's the current Jetpack plan granted by this partner, if applicable
1169 + *
1170 + * Returns success or error JSON
1171 + *
1172 + * <token_json>
1173 + * : JSON blob of WPCOM API token
1174 + * [--partner_tracking_id=<partner_tracking_id>]
1175 + * : This is an optional ID that a host can pass to help identify a site in logs on WordPress.com
1176 + *
1177 + * @synopsis <token_json> [--partner_tracking_id=<partner_tracking_id>]
1178 + *
1179 + * @param array $args Positional args.
1180 + * @param array $named_args Named args.
1181 + */
1182 + public function partner_cancel( $args, $named_args ) {
1183 + list( $token_json ) = $args;
1184 +
1185 + $token = $token_json ? json_decode( $token_json ) : null;
1186 + if ( ! $token ) {
1187 + /* translators: %s is the invalid JSON string */
1188 + $this->partner_provision_error( new WP_Error( 'missing_access_token', sprintf( __( 'Invalid token JSON: %s', 'jetpack' ), $token_json ) ) );
1189 + }
1190 +
1191 + if ( isset( $token->error ) ) {
1192 + $this->partner_provision_error( new WP_Error( $token->error, $token->message ) );
1193 + }
1194 +
1195 + if ( ! isset( $token->access_token ) ) {
1196 + $this->partner_provision_error( new WP_Error( 'missing_access_token', __( 'Missing or invalid access token', 'jetpack' ) ) );
1197 + }
1198 +
1199 + if ( Identity_Crisis::validate_sync_error_idc_option() ) {
1200 + $this->partner_provision_error(
1201 + new WP_Error(
1202 + 'site_in_safe_mode',
1203 + esc_html__( 'Cannot cancel a plan while in safe mode. See: https://jetpack.com/support/safe-mode/', 'jetpack' )
1204 + )
1205 + );
1206 + }
1207 +
1208 + $site_identifier = Jetpack_Options::get_option( 'id' );
1209 +
1210 + if ( ! $site_identifier ) {
1211 + $status = new Status();
1212 + $site_identifier = $status->get_site_suffix();
1213 + }
1214 +
1215 + $request = array(
1216 + 'headers' => array(
1217 + 'Authorization' => 'Bearer ' . $token->access_token,
1218 + 'Host' => 'public-api.wordpress.com',
1219 + ),
1220 + 'timeout' => 60,
1221 + 'method' => 'POST',
1222 + );
1223 +
1224 + $url = sprintf( '%s/rest/v1.3/jpphp/%s/partner-cancel', $this->get_api_host(), $site_identifier );
1225 + if ( ! empty( $named_args ) && ! empty( $named_args['partner_tracking_id'] ) ) {
1226 + $url = esc_url_raw( add_query_arg( 'partner_tracking_id', $named_args['partner_tracking_id'], $url ) );
1227 + }
1228 +
1229 + // @phan-suppress-next-line PhanAccessMethodInternal -- Phan is correct, but the usage is intentional.
1230 + $result = Client::_wp_remote_request( $url, $request );
1231 +
1232 + if ( is_wp_error( $result ) ) {
1233 + $this->partner_provision_error( $result );
1234 + }
1235 +
1236 + WP_CLI::log( wp_remote_retrieve_body( $result ) );
1237 + }
1238 +
1239 + /**
1240 + * Provision a site using a Jetpack Partner license
1241 + *
1242 + * Returns JSON blob
1243 + *
1244 + * ## OPTIONS
1245 + *
1246 + * <token_json>
1247 + * : JSON blob of WPCOM API token
1248 + * [--plan=<plan_name>]
1249 + * : Slug of the requested plan, e.g. premium
1250 + * [--wpcom_user_id=<user_id>]
1251 + * : WordPress.com ID of user to connect as (must be whitelisted against partner key)
1252 + * [--wpcom_user_email=<wpcom_user_email>]
1253 + * : Override the email we send to WordPress.com for registration
1254 + * [--force_register=<register>]
1255 + * : Whether to force a site to register
1256 + * [--force_connect=<force_connect>]
1257 + * : Force JPS to not reuse existing credentials
1258 + * [--home_url=<home_url>]
1259 + * : Overrides the home option via the home_url filter, or the WP_HOME constant
1260 + * [--site_url=<site_url>]
1261 + * : Overrides the siteurl option via the site_url filter, or the WP_SITEURL constant
1262 + * [--partner_tracking_id=<partner_tracking_id>]
1263 + * : This is an optional ID that a host can pass to help identify a site in logs on WordPress.com
1264 + *
1265 + * ## EXAMPLES
1266 + *
1267 + * $ wp jetpack partner_provision '{ some: "json" }' premium 1
1268 + * { success: true }
1269 + *
1270 + * @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>]
1271 + *
1272 + * @param array $args Positional args.
1273 + * @param array $named_args Named args.
1274 + */
1275 + public function partner_provision( $args, $named_args ) {
1276 + list( $token_json ) = $args;
1277 +
1278 + $token = $token_json ? json_decode( $token_json ) : null;
1279 + if ( ! $token ) {
1280 + /* translators: %s is the invalid JSON string */
1281 + $this->partner_provision_error( new WP_Error( 'missing_access_token', sprintf( __( 'Invalid token JSON: %s', 'jetpack' ), $token_json ) ) );
1282 + }
1283 +
1284 + if ( isset( $token->error ) ) {
1285 + $message = $token->message ?? '';
1286 + $this->partner_provision_error( new WP_Error( $token->error, $message ) );
1287 + }
1288 +
1289 + if ( ! isset( $token->access_token ) ) {
1290 + $this->partner_provision_error( new WP_Error( 'missing_access_token', __( 'Missing or invalid access token', 'jetpack' ) ) );
1291 + }
1292 +
1293 + require_once JETPACK__PLUGIN_DIR . '_inc/class.jetpack-provision.php';
1294 +
1295 + $body_json = Jetpack_Provision::partner_provision( $token->access_token, $named_args );
1296 +
1297 + if ( is_wp_error( $body_json ) ) {
1298 + WP_CLI::error(
1299 + wp_json_encode(
1300 + array(
1301 + 'success' => false,
1302 + 'error_code' => $body_json->get_error_code(),
1303 + 'error_message' => $body_json->get_error_message(),
1304 + ),
1305 + JSON_UNESCAPED_SLASHES
1306 + )
1307 + );
1308 + exit( 1 );
1309 + }
1310 +
1311 + WP_CLI::log( wp_json_encode( $body_json, JSON_UNESCAPED_SLASHES ) );
1312 + }
1313 +
1314 + /**
1315 + * Manages your Jetpack sitemap
1316 + *
1317 + * ## OPTIONS
1318 + *
1319 + * rebuild : Rebuild all sitemaps
1320 + * --purge : if set, will remove all existing sitemap data before rebuilding
1321 + * --monitor : if set, will output elapsed time, peak memory usage, CPU time (user/system), and average CPU utilization
1322 + * --suspend-cache-addition : if set, will suspend cache additions during sitemap generation
1323 + *
1324 + * ## EXAMPLES
1325 + *
1326 + * wp jetpack sitemap rebuild
1327 + * wp jetpack sitemap rebuild --monitor
1328 + *
1329 + * @subcommand sitemap
1330 + * @synopsis <rebuild> [--purge] [--monitor] [--suspend-cache-addition]
1331 + *
1332 + * @param array $args Positional args.
1333 + * @param array $assoc_args Named args.
1334 + */
1335 + public function sitemap( $args, $assoc_args ) {
1336 + if ( ! Jetpack::is_module_active( 'sitemaps' ) ) {
1337 + WP_CLI::error( __( 'Jetpack Sitemaps module is not currently active. Activate it first if you want to work with sitemaps.', 'jetpack' ) );
1338 + }
1339 + if ( ! class_exists( 'Jetpack_Sitemap_Builder' ) ) {
1340 + 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' ) );
1341 + }
1342 +
1343 + if ( isset( $assoc_args['suspend-cache-addition'] ) && $assoc_args['suspend-cache-addition'] ) {
1344 + add_filter( 'jetpack_sitemap_suspend_cache_addition', '__return_true' );
1345 + WP_CLI::success( 'Suspending cache addition.' );
1346 + }
1347 +
1348 + $monitor = isset( $assoc_args['monitor'] ) && $assoc_args['monitor'];
1349 +
1350 + if ( $monitor ) {
1351 + $start_time = microtime( true );
1352 + $rusage_start = function_exists( 'getrusage' ) ? getrusage() : null;
1353 + }
1354 +
1355 + if ( isset( $assoc_args['purge'] ) && $assoc_args['purge'] ) {
1356 + $librarian = new Jetpack_Sitemap_Librarian();
1357 + $librarian->delete_all_stored_sitemap_data();
1358 +
1359 + // Clear sitemap-related transients
1360 + delete_transient( 'jetpack_news_sitemap_xml' );
1361 + delete_transient( 'jetpack-sitemap-state-lock' );
1362 + WP_CLI::success( __( 'Purged all sitemap data and cleared sitemap transients.', 'jetpack' ) );
1363 + }
1364 +
1365 + $sitemap_builder = new Jetpack_Sitemap_Builder();
1366 + $sitemap_builder->update_sitemap();
1367 +
1368 + WP_CLI::success( __( 'Sitemap rebuilt successfully.', 'jetpack' ) );
1369 +
1370 + if ( $monitor && isset( $start_time ) ) {
1371 + $end_time = microtime( true );
1372 + $peak_memory = memory_get_peak_usage();
1373 + $elapsed_time = $end_time - $start_time;
1374 + $rusage_end = function_exists( 'getrusage' ) ? getrusage() : null;
1375 +
1376 + WP_CLI::log( '----------------------------------' );
1377 + WP_CLI::log( __( 'Performance Metrics:', 'jetpack' ) );
1378 + /* translators: %s is a float representing seconds */
1379 + WP_CLI::log( sprintf( __( 'Elapsed Time: %.4f seconds', 'jetpack' ), $elapsed_time ) );
1380 + /* translators: %s is a human-readable memory size (e.g., 128MB) */
1381 + WP_CLI::log( sprintf( __( 'Peak Memory Usage: %s', 'jetpack' ), size_format( $peak_memory ) ) );
1382 +
1383 + if ( ! empty( $rusage_start ) && ! empty( $rusage_end ) ) {
1384 + $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'] );
1385 + $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'] );
1386 +
1387 + /* translators: %d is an integer representing microseconds */
1388 + WP_CLI::log( sprintf( __( 'CPU time (user): %d microseconds', 'jetpack' ), $user_cpu_time ) );
1389 + /* translators: %d is an integer representing microseconds */
1390 + WP_CLI::log( sprintf( __( 'CPU time (system): %d microseconds', 'jetpack' ), $system_cpu_time ) );
1391 +
1392 + // Average CPU utilization over the elapsed wall time.
1393 + $total_cpu_sec = ( $user_cpu_time + $system_cpu_time ) / 1e6;
1394 + $avg_cpu_pct = $elapsed_time > 0 ? ( $total_cpu_sec / $elapsed_time ) * 100 : 0.0;
1395 + /* translators: %s is a percentage like 83.4 */
1396 + WP_CLI::log( sprintf( __( 'Average CPU Utilization: %.1f%%', 'jetpack' ), $avg_cpu_pct ) );
1397 + }
1398 + WP_CLI::log( '----------------------------------' );
1399 + }
1400 + }
1401 +
1402 + /**
1403 + * Allows authorizing a user via the command line and will activate
1404 + *
1405 + * ## EXAMPLES
1406 + *
1407 + * wp jetpack authorize_user --token=123456789abcdef
1408 + *
1409 + * @synopsis --token=<value>
1410 + *
1411 + * @param array $args Positional args.
1412 + * @param array $named_args Named args.
1413 + */
1414 + public function authorize_user( $args, $named_args ) {
1415 + if ( ! is_user_logged_in() ) {
1416 + WP_CLI::error( __( 'Please select a user to authorize via the --user global argument.', 'jetpack' ) );
1417 + }
1418 +
1419 + if ( empty( $named_args['token'] ) ) {
1420 + WP_CLI::error( __( 'A non-empty token argument must be passed.', 'jetpack' ) );
1421 + }
1422 +
1423 + $is_connection_owner = ! Jetpack::connection()->has_connected_owner();
1424 + $current_user_id = get_current_user_id();
1425 +
1426 + ( new Tokens() )->update_user_token( $current_user_id, sprintf( '%s.%d', $named_args['token'], $current_user_id ), $is_connection_owner );
1427 +
1428 + WP_CLI::log( wp_json_encode( $named_args, JSON_UNESCAPED_SLASHES ) );
1429 +
1430 + if ( $is_connection_owner ) {
1431 + /**
1432 + * Auto-enable SSO module for new Jetpack Start connections
1433 + *
1434 + * @since 5.0.0
1435 + *
1436 + * @param bool $enable_sso Whether to enable the SSO module. Default to true.
1437 + */
1438 + $enable_sso = apply_filters( 'jetpack_start_enable_sso', true );
1439 + Jetpack::handle_post_authorization_actions( $enable_sso, false );
1440 +
1441 + /* translators: %d is a user ID */
1442 + WP_CLI::success( sprintf( __( 'Authorized %d and activated default modules.', 'jetpack' ), $current_user_id ) );
1443 + } else {
1444 + /* translators: %d is a user ID */
1445 + WP_CLI::success( sprintf( __( 'Authorized %d.', 'jetpack' ), $current_user_id ) );
1446 + }
1447 + }
1448 +
1449 + /**
1450 + * Allows calling a WordPress.com API endpoint using the current blog's token.
1451 + *
1452 + * ## OPTIONS
1453 + * --resource=<resource>
1454 + * : The resource to call with the current blog's token, where `%d` represents the current blog's ID.
1455 + *
1456 + * [--api_version=<api_version>]
1457 + * : The API version to query against.
1458 + *
1459 + * [--base_api_path=<base_api_path>]
1460 + * : The base API path to query.
1461 + * ---
1462 + * default: rest
1463 + * ---
1464 + *
1465 + * [--body=<body>]
1466 + * : A JSON encoded string representing arguments to send in the body.
1467 + *
1468 + * [--field=<value>]
1469 + * : Any number of arguments that should be passed to the resource.
1470 + *
1471 + * [--pretty]
1472 + * : Will pretty print the results of a successful API call.
1473 + *
1474 + * [--strip-success]
1475 + * : Will remove the green success label from successful API calls.
1476 + *
1477 + * ## EXAMPLES
1478 + *
1479 + * wp jetpack call_api --resource='/sites/%d'
1480 + *
1481 + * @param array $args Positional args.
1482 + * @param array $named_args Named args.
1483 + */
1484 + public function call_api( $args, $named_args ) {
1485 + if ( ! Jetpack::is_connection_ready() ) {
1486 + WP_CLI::error( __( 'Jetpack is not currently connected to WordPress.com', 'jetpack' ) );
1487 + }
1488 +
1489 + $consumed_args = array(
1490 + 'resource',
1491 + 'api_version',
1492 + 'base_api_path',
1493 + 'body',
1494 + 'pretty',
1495 + );
1496 +
1497 + // Get args that should be passed to resource.
1498 + $other_args = array_diff_key( $named_args, array_flip( $consumed_args ) );
1499 +
1500 + $decoded_body = ! empty( $named_args['body'] )
1501 + ? json_decode( $named_args['body'], true )
1502 + : false;
1503 +
1504 + $resource_url = ( ! str_contains( $named_args['resource'], '%d' ) )
1505 + ? $named_args['resource']
1506 + : sprintf( $named_args['resource'], Jetpack_Options::get_option( 'id' ) );
1507 +
1508 + $response = Client::wpcom_json_api_request_as_blog(
1509 + $resource_url,
1510 + empty( $named_args['api_version'] ) ? Client::WPCOM_JSON_API_VERSION : $named_args['api_version'],
1511 + $other_args,
1512 + empty( $decoded_body ) ? null : $decoded_body,
1513 + empty( $named_args['base_api_path'] ) ? 'rest' : $named_args['base_api_path']
1514 + );
1515 +
1516 + if ( is_wp_error( $response ) ) {
1517 + WP_CLI::error(
1518 + sprintf(
1519 + /* translators: %1$s is an endpoint route (ex. /sites/123456), %2$d is an error code, %3$s is an error message. */
1520 + __( 'Request to %1$s returned an error: (%2$d) %3$s.', 'jetpack' ),
1521 + $resource_url,
1522 + $response->get_error_code(),
1523 + $response->get_error_message()
1524 + )
1525 + );
1526 + }
1527 +
1528 + if ( 200 !== wp_remote_retrieve_response_code( $response ) ) {
1529 + WP_CLI::error(
1530 + sprintf(
1531 + /* translators: %1$s is an endpoint route (ex. /sites/123456), %2$d is an HTTP status code. */
1532 + __( 'Request to %1$s returned a non-200 response code: %2$d.', 'jetpack' ),
1533 + $resource_url,
1534 + wp_remote_retrieve_response_code( $response )
1535 + )
1536 + );
1537 + }
1538 +
1539 + $output = wp_remote_retrieve_body( $response );
1540 + if ( isset( $named_args['pretty'] ) ) {
1541 + $decoded_output = json_decode( $output );
1542 + if ( $decoded_output ) {
1543 + $output = wp_json_encode( $decoded_output, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT );
1544 + }
1545 + }
1546 +
1547 + if ( isset( $named_args['strip-success'] ) ) {
1548 + WP_CLI::log( $output );
1549 + WP_CLI::halt( 0 );
1550 + }
1551 +
1552 + WP_CLI::success( $output );
1553 + }
1554 +
1555 + /**
1556 + * Allows uploading SSH Credentials to the current site for backups, restores, and security scanning.
1557 + *
1558 + * ## OPTIONS
1559 + *
1560 + * [--host=<host>]
1561 + * : The SSH server's address.
1562 + *
1563 + * [--ssh-user=<user>]
1564 + * : The username to use to log in to the SSH server.
1565 + *
1566 + * [--pass=<pass>]
1567 + * : The password used to log in, if using a password. (optional)
1568 + *
1569 + * [--kpri=<kpri>]
1570 + * : The private key used to log in, if using a private key. (optional)
1571 + *
1572 + * [--pretty]
1573 + * : Will pretty print the results of a successful API call. (optional)
1574 + *
1575 + * [--strip-success]
1576 + * : Will remove the green success label from successful API calls. (optional)
1577 + *
1578 + * ## EXAMPLES
1579 + *
1580 + * wp jetpack upload_ssh_creds --host=example.com --ssh-user=example --pass=password
1581 + * wp jetpack updload_ssh_creds --host=example.com --ssh-user=example --kpri=key
1582 + *
1583 + * @param array $args Positional args.
1584 + * @param array $named_args Named args.
1585 + */
1586 + public function upload_ssh_creds( $args, $named_args ) {
1587 + if ( ! Jetpack::is_connection_ready() ) {
1588 + WP_CLI::error( __( 'Jetpack is not currently connected to WordPress.com', 'jetpack' ) );
1589 + }
1590 +
1591 + $required_args = array(
1592 + 'host',
1593 + 'ssh-user',
1594 + );
1595 +
1596 + foreach ( $required_args as $arg ) {
1597 + if ( empty( $named_args[ $arg ] ) ) {
1598 + WP_CLI::error(
1599 + sprintf(
1600 + /* translators: %s is a slug, such as 'host'. */
1601 + __( '`%s` cannot be empty.', 'jetpack' ),
1602 + $arg
1603 + )
1604 + );
1605 + }
1606 + }
1607 +
1608 + if ( empty( $named_args['pass'] ) && empty( $named_args['kpri'] ) ) {
1609 + WP_CLI::error( __( 'Both `pass` and `kpri` fields cannot be blank.', 'jetpack' ) );
1610 + }
1611 +
1612 + $values = array(
1613 + 'credentials' => array(
1614 + 'site_url' => get_site_url(),
1615 + 'abspath' => ABSPATH,
1616 + 'protocol' => 'ssh',
1617 + 'port' => 22,
1618 + 'role' => 'main',
1619 + 'host' => $named_args['host'],
1620 + 'user' => $named_args['ssh-user'],
1621 + 'pass' => empty( $named_args['pass'] ) ? '' : $named_args['pass'],
1622 + 'kpri' => empty( $named_args['kpri'] ) ? '' : $named_args['kpri'],
1623 + ),
1624 + );
1625 +
1626 + $named_args = wp_parse_args(
1627 + array(
1628 + 'resource' => '/activity-log/%d/update-credentials',
1629 + 'method' => 'POST',
1630 + 'api_version' => '1.1',
1631 + 'body' => wp_json_encode( $values, JSON_UNESCAPED_SLASHES ),
1632 + 'timeout' => 30,
1633 + ),
1634 + $named_args
1635 + );
1636 +
1637 + self::call_api( $args, $named_args );
1638 + }
1639 +
1640 + /**
1641 + * API wrapper for getting stats from the WordPress.com API for the current site.
1642 + *
1643 + * ## OPTIONS
1644 + *
1645 + * [--quantity=<quantity>]
1646 + * : The number of units to include.
1647 + * ---
1648 + * default: 30
1649 + * ---
1650 + *
1651 + * [--period=<period>]
1652 + * : The unit of time to query stats for.
1653 + * ---
1654 + * default: day
1655 + * options:
1656 + * - day
1657 + * - week
1658 + * - month
1659 + * - year
1660 + * ---
1661 + *
1662 + * [--date=<date>]
1663 + * : The latest date to return stats for. Ex. - 2018-01-01.
1664 + *
1665 + * [--pretty]
1666 + * : Will pretty print the results of a successful API call.
1667 + *
1668 + * [--strip-success]
1669 + * : Will remove the green success label from successful API calls.
1670 + *
1671 + * ## EXAMPLES
1672 + *
1673 + * wp jetpack get_stats
1674 + *
1675 + * @param array $args Positional args.
1676 + * @param array $named_args Named args.
1677 + */
1678 + public function get_stats( $args, $named_args ) {
1679 + $selected_args = array_intersect_key(
1680 + $named_args,
1681 + array_flip(
1682 + array(
1683 + 'quantity',
1684 + 'date',
1685 + )
1686 + )
1687 + );
1688 +
1689 + // The API expects unit, but period seems to be more correct.
1690 + $selected_args['unit'] = $named_args['period'];
1691 +
1692 + $command = sprintf(
1693 + 'jetpack call_api --resource=/sites/%d/stats/%s',
1694 + Jetpack_Options::get_option( 'id' ),
1695 + add_query_arg( $selected_args, 'visits' )
1696 + );
1697 +
1698 + if ( isset( $named_args['pretty'] ) ) {
1699 + $command .= ' --pretty';
1700 + }
1701 +
1702 + if ( isset( $named_args['strip-success'] ) ) {
1703 + $command .= ' --strip-success';
1704 + }
1705 +
1706 + WP_CLI::runcommand(
1707 + $command,
1708 + array(
1709 + 'launch' => false, // Use the current process.
1710 + )
1711 + );
1712 + }
1713 +
1714 + /**
1715 + * Allows management of publicize connections.
1716 + *
1717 + * ## OPTIONS
1718 + *
1719 + * <list|disconnect>
1720 + * : The action to perform.
1721 + * ---
1722 + * options:
1723 + * - list
1724 + * - disconnect
1725 + * ---
1726 + *
1727 + * [<identifier>]
1728 + * : The connection ID or service to perform an action on.
1729 + *
1730 + * [--ignore-cache]
1731 + * : Whether to ignore connections cache.
1732 + *
1733 + * [--format=<format>]
1734 + * : Allows overriding the output of the command when listing connections.
1735 + * ---
1736 + * default: table
1737 + * options:
1738 + * - table
1739 + * - json
1740 + * - csv
1741 + * - yaml
1742 + * - ids
1743 + * - count
1744 + * ---
1745 + *
1746 + * ## EXAMPLES
1747 + *
1748 + * # List all publicize connections.
1749 + * $ wp jetpack publicize list
1750 + *
1751 + * # List all publicize connections, ignoring the cache.
1752 + * $ wp jetpack publicize list --ignore-cache
1753 + *
1754 + * # List publicize connections for a given service.
1755 + * $ wp jetpack publicize list linkedin
1756 + *
1757 + * # List all publicize connections for a given user.
1758 + * $ wp --user=1 jetpack publicize list
1759 + *
1760 + * # List all publicize connections for a given user and service.
1761 + * $ wp --user=1 jetpack publicize list linkedin
1762 + *
1763 + * # Display details for a given connection.
1764 + * $ wp jetpack publicize list 123456
1765 + *
1766 + * # Diconnection a given connection.
1767 + * $ wp jetpack publicize disconnect 123456
1768 + *
1769 + * # Disconnect all connections.
1770 + * $ wp jetpack publicize disconnect all
1771 + *
1772 + * # Disconnect all connections for a given service.
1773 + * $ wp jetpack publicize disconnect linkedin
1774 + *
1775 + * @param array $args Positional args.
1776 + * @param array $named_args Named args.
1777 + */
1778 + public function publicize( $args, $named_args ) {
1779 + if ( ! Jetpack::connection()->has_connected_owner() ) {
1780 + WP_CLI::error( __( 'Jetpack Social requires a user-level connection to WordPress.com', 'jetpack' ) );
1781 + }
1782 +
1783 + if ( ! Jetpack::is_module_active( 'publicize' ) ) {
1784 + WP_CLI::error( __( 'The Jetpack Social module is not active.', 'jetpack' ) );
1785 + }
1786 +
1787 + if ( ( new Status() )->is_offline_mode() ) {
1788 + if (
1789 + ! defined( 'JETPACK_DEV_DEBUG' ) &&
1790 + ! has_filter( 'jetpack_offline_mode' ) &&
1791 + ! str_contains( site_url(), '.' )
1792 + ) {
1793 + 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' ) );
1794 + }
1795 +
1796 + WP_CLI::error( __( 'Jetpack is currently in offline mode, so the Jetpack Social module will not load.', 'jetpack' ) );
1797 + }
1798 +
1799 + if ( ! class_exists( Publicize::class ) ) {
1800 + WP_CLI::error( __( 'The Jetpack Social module is not loaded.', 'jetpack' ) );
1801 + }
1802 +
1803 + $action = $args[0];
1804 + $publicize = new Publicize();
1805 + $identifier = ! empty( $args[1] ) ? $args[1] : false;
1806 + $services = array_keys( $publicize->get_services() );
1807 + $id_is_service = in_array( $identifier, $services, true );
1808 +
1809 + switch ( $action ) {
1810 + case 'list':
1811 + $_args = array(
1812 + 'ignore_cache' => $named_args['ignore-cache'] ?? false,
1813 + );
1814 + // For the CLI command, let's return all connections when a user isn't specified. This
1815 + // differs from the logic in the Publicize class.
1816 + $connections_to_return = is_user_logged_in()
1817 + ? Connections::get_all_for_user( $_args )
1818 + : Connections::get_all( $_args );
1819 +
1820 + if ( $id_is_service && ! empty( $identifier ) && ! empty( $connections_to_return ) ) {
1821 + $temp_connections = $connections_to_return;
1822 + $connections_to_return = array();
1823 +
1824 + foreach ( $temp_connections as $connection ) {
1825 + if ( $identifier === $connection['service_name'] ) {
1826 + $connections_to_return[] = $connection;
1827 + }
1828 + }
1829 + }
1830 +
1831 + if ( $identifier && ! $id_is_service && ! empty( $connections_to_return ) ) {
1832 + $connections_to_return = wp_list_filter( $connections_to_return, array( 'connection_id' => $identifier ) );
1833 + }
1834 +
1835 + $expected_keys = array(
1836 + 'connection_id',
1837 + 'service_name',
1838 + 'display_name',
1839 + 'external_id',
1840 + 'wpcom_user_id',
1841 + 'shared',
1842 + );
1843 +
1844 + // Somehow, a test site ended up in a state where $connections_to_return looked like:
1845 + // array( array( array( 'id' => 0, 'service' => 0 ) ) )
1846 + // This caused the CLI command to error when running WP_CLI\Utils\format_items() below. So
1847 + // to minimize future issues, this nested loop will remove any connections that don't contain
1848 + // any keys that we expect.
1849 + foreach ( (array) $connections_to_return as $connection_key => $connection ) {
1850 + foreach ( $expected_keys as $expected_key ) {
1851 + if ( ! isset( $connection[ $expected_key ] ) ) {
1852 + unset( $connections_to_return[ $connection_key ] );
1853 + continue;
1854 + }
1855 + }
1856 + }
1857 +
1858 + if ( empty( $connections_to_return ) ) {
1859 + return false;
1860 + }
1861 +
1862 + WP_CLI\Utils\format_items( $named_args['format'], $connections_to_return, $expected_keys );
1863 + break; // list.
1864 + case 'disconnect':
1865 + if ( ! $identifier ) {
1866 + WP_CLI::error( __( 'A connection ID must be passed in order to disconnect.', 'jetpack' ) );
1867 + }
1868 +
1869 + // If the connection ID is 'all' then delete all connections. If the connection ID
1870 + // matches a service, delete all connections for that service.
1871 + if ( 'all' === $identifier || $id_is_service ) {
1872 + if ( 'all' === $identifier ) {
1873 + WP_CLI::log( __( "You're about to delete all Jetpack Social connections.", 'jetpack' ) );
1874 + } else {
1875 + /* translators: %s is a lowercase string for a social network. */
1876 + WP_CLI::log( sprintf( __( "You're about to delete all Jetpack Social connections to %s.", 'jetpack' ), $identifier ) );
1877 + }
1878 +
1879 + jetpack_cli_are_you_sure();
1880 +
1881 + $service = $identifier;
1882 + $connections = is_user_logged_in()
1883 + ? Connections::get_all_for_user()
1884 + : Connections::get_all();
1885 +
1886 + if ( 'all' !== $service ) {
1887 + $connections = wp_list_filter( $connections, array( 'service_name' => $service ) );
1888 + }
1889 +
1890 + if ( ! empty( $connections ) ) {
1891 + $count = is_countable( $connections ) ? count( $connections ) : 0;
1892 + $progress = \WP_CLI\Utils\make_progress_bar(
1893 + /* translators: %s is a lowercase string for a social network. */
1894 + sprintf( __( 'Disconnecting all connections to %s.', 'jetpack' ), $service ),
1895 + $count
1896 + );
1897 +
1898 + foreach ( $connections as $connection ) {
1899 + $id = $connection['connection_id'];
1900 + if ( false === $publicize->disconnect( false, $id ) ) {
1901 + WP_CLI::error(
1902 + sprintf(
1903 + /* translators: %1$d is a numeric ID and %2$s is a lowercase string for a social network. */
1904 + __( 'Jetpack Social connection %d could not be disconnected', 'jetpack' ),
1905 + $id
1906 + )
1907 + );
1908 + }
1909 +
1910 + // @phan-suppress-next-line PhanUndeclaredClassMethod - Class is missing from php-stubs/wp-cli-stubs 🤷
1911 + $progress->tick();
1912 + }
1913 +
1914 + // @phan-suppress-next-line PhanUndeclaredClassMethod - Class is missing from php-stubs/wp-cli-stubs 🤷
1915 + $progress->finish();
1916 +
1917 + if ( 'all' === $service ) {
1918 + WP_CLI::success( __( 'All Jetpack Social connections were successfully disconnected.', 'jetpack' ) );
1919 + } else {
1920 + /* translators: %s is a lowercase string for a social network. */
1921 + WP_CLI::success( sprintf( __( 'All Jetpack Social connections to %s were successfully disconnected.', 'jetpack' ), $service ) );
1922 + }
1923 + }
1924 + } elseif ( false !== $publicize->disconnect( false, $identifier ) ) {
1925 + /* translators: %d is a numeric ID. Example: 1234. */
1926 + WP_CLI::success( sprintf( __( 'Jetpack Social connection %d has been disconnected.', 'jetpack' ), $identifier ) );
1927 + } else {
1928 + /* translators: %d is a numeric ID. Example: 1234. */
1929 + WP_CLI::error( sprintf( __( 'Jetpack Social connection %d could not be disconnected.', 'jetpack' ), $identifier ) );
1930 + }
1931 + break; // disconnect.
1932 + }
1933 + }
1934 +
1935 + /**
1936 + * Get the API host.
1937 + *
1938 + * @return string URL.
1939 + */
1940 + private function get_api_host() {
1941 + $env_api_host = getenv( 'JETPACK_START_API_HOST', true );
1942 + return $env_api_host ? 'https://' . $env_api_host : JETPACK__WPCOM_JSON_API_BASE;
1943 + }
1944 +
1945 + /**
1946 + * Log and exit on a partner provision error.
1947 + *
1948 + * @param WP_Error $error Error.
1949 + * @return never
1950 + */
1951 + private function partner_provision_error( $error ) {
1952 + WP_CLI::log(
1953 + wp_json_encode(
1954 + array(
1955 + 'success' => false,
1956 + 'error_code' => $error->get_error_code(),
1957 + 'error_message' => $error->get_error_message(),
1958 + ),
1959 + JSON_UNESCAPED_SLASHES
1960 + )
1961 + );
1962 + exit( 1 );
1963 + }
1964 +
1965 + /**
1966 + * Creates the essential files in Jetpack to start building a Gutenberg block or plugin.
1967 + *
1968 + * ## TYPES
1969 + *
1970 + * 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.
1971 + *
1972 + * ## BLOCK TYPE OPTIONS
1973 + *
1974 + * The first parameter is the block title and it's not associative. Add it wrapped in quotes.
1975 + * 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.
1976 + * --slug: Specific slug to identify the block that overrides the one generated based on the title.
1977 + * --description: Allows to provide a text description of the block.
1978 + * --keywords: Provide up to three keywords separated by comma so users can find this block when they search in Gutenberg's inserter.
1979 + * --variation: Allows to decide whether the block should be a production block, experimental, or beta. Defaults to Beta when arg not provided.
1980 + *
1981 + * ## BLOCK TYPE EXAMPLES
1982 + *
1983 + * wp jetpack scaffold block "Cool Block"
1984 + * wp jetpack scaffold block "Amazing Rock" --slug="good-music" --description="Rock the best music on your site"
1985 + * wp jetpack scaffold block "Jukebox" --keywords="music, audio, media"
1986 + * wp jetpack scaffold block "Jukebox" --variation="experimental"
1987 + *
1988 + * @subcommand scaffold block
1989 + * @synopsis <type> <title> [--slug] [--description] [--keywords] [--variation]
1990 + *
1991 + * @param array $args Positional parameters, when strings are passed, wrap them in quotes.
1992 + * @param array $assoc_args Associative parameters like --slug="nice-block".
1993 + */
1994 + public function scaffold( $args, $assoc_args ) {
1995 + // It's ok not to check if it's set, because otherwise WPCLI exits earlier.
1996 + switch ( $args[0] ) {
1997 + case 'block':
1998 + $this->block( $args, $assoc_args );
1999 + break;
2000 + default:
2001 + /* translators: %s is the subcommand */
2002 + WP_CLI::error( sprintf( esc_html__( 'Invalid subcommand %s.', 'jetpack' ), $args[0] ) . ' 👻' );
2003 + exit( 1 );
2004 + }
2005 + }
2006 +
2007 + /**
2008 + * Creates the essential files in Jetpack to build a Gutenberg block.
2009 + *
2010 + * @param array $args Positional parameters. Only one is used, that corresponds to the block title.
2011 + * @param array $assoc_args Associative parameters defined in the scaffold() method.
2012 + */
2013 + public function block( $args, $assoc_args ) {
2014 + if ( ! isset( $args[1] ) ) {
2015 + WP_CLI::error( esc_html__( 'The title parameter is required.', 'jetpack' ) . ' 👻' );
2016 + exit( 1 );
2017 + }
2018 +
2019 + $title = ucwords( $args[1] );
2020 +
2021 + $slug = $assoc_args['slug'] ?? sanitize_title( $title );
2022 +
2023 + $next_version = "\x24\x24next-version$$"; // Escapes to hide the string from tools/replace-next-version-tag.sh
2024 +
2025 + $variation_options = array( 'production', 'experimental', 'beta' );
2026 + $variation = ( isset( $assoc_args['variation'] ) && in_array( $assoc_args['variation'], $variation_options, true ) )
2027 + ? $assoc_args['variation']
2028 + : 'beta';
2029 +
2030 + if ( preg_match( '#^jetpack/#', $slug ) ) {
2031 + $slug = preg_replace( '#^jetpack/#', '', $slug );
2032 + }
2033 +
2034 + if ( ! preg_match( '/^[a-z][a-z0-9\-]*$/', $slug ) ) {
2035 + WP_CLI::error( esc_html__( 'Invalid block slug. They can contain only lowercase alphanumeric characters or dashes, and start with a letter', 'jetpack' ) . ' 👻' );
2036 + }
2037 +
2038 + global $wp_filesystem;
2039 + if ( ! WP_Filesystem() ) {
2040 + WP_CLI::error( esc_html__( "Can't write files", 'jetpack' ) . ' 😱' );
2041 + }
2042 +
2043 + $path = JETPACK__PLUGIN_DIR . "extensions/blocks/$slug";
2044 +
2045 + if ( $wp_filesystem->exists( $path ) && $wp_filesystem->is_dir( $path ) ) {
2046 + /* translators: %s is path to the conflicting block */
2047 + WP_CLI::error( sprintf( esc_html__( 'Name conflicts with the existing block %s', 'jetpack' ), $path ) . ' ⛔️' );
2048 + exit( 1 );
2049 + }
2050 +
2051 + $wp_filesystem->mkdir( $path );
2052 +
2053 + $keywords = isset( $assoc_args['keywords'] )
2054 + ? array_map(
2055 + function ( $keyword ) {
2056 + return trim( $keyword );
2057 + },
2058 + array_slice( explode( ',', $assoc_args['keywords'] ), 0, 3 )
2059 + )
2060 + : array();
2061 +
2062 + $files = array(
2063 + "$path/block.json" => self::render_block_file(
2064 + 'block-block-json',
2065 + array(
2066 + 'slug' => $slug,
2067 + 'title' => wp_json_encode( $title, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE ),
2068 + 'description' => isset( $assoc_args['description'] )
2069 + ? wp_json_encode( $assoc_args['description'], JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE )
2070 + : wp_json_encode( $title, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE ),
2071 + 'nextVersion' => $next_version,
2072 + 'keywords' => wp_json_encode( $keywords, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE ),
2073 + )
2074 + ),
2075 + "$path/$slug.php" => self::render_block_file(
2076 + 'block-register-php',
2077 + array(
2078 + 'nextVersion' => $next_version,
2079 + 'title' => $title,
2080 + 'underscoredTitle' => str_replace( ' ', '_', $title ),
2081 + )
2082 + ),
2083 + "$path/editor.js" => self::render_block_file( 'block-editor-js' ),
2084 + "$path/editor.scss" => self::render_block_file(
2085 + 'block-editor-scss',
2086 + array(
2087 + 'slug' => $slug,
2088 + 'title' => $title,
2089 + )
2090 + ),
2091 + "$path/edit.js" => self::render_block_file(
2092 + 'block-edit-js',
2093 + array(
2094 + 'title' => $title,
2095 + 'className' => str_replace( ' ', '', ucwords( str_replace( '-', ' ', $slug ) ) ),
2096 + )
2097 + ),
2098 + );
2099 +
2100 + $files_written = array();
2101 +
2102 + foreach ( $files as $filename => $contents ) {
2103 + if ( $wp_filesystem->put_contents( $filename, $contents ) ) {
2104 + $files_written[] = $filename;
2105 + } else {
2106 + /* translators: %s is a file name */
2107 + WP_CLI::error( sprintf( esc_html__( 'Error creating %s', 'jetpack' ), $filename ) );
2108 + }
2109 + }
2110 +
2111 + if ( empty( $files_written ) ) {
2112 + WP_CLI::log( esc_html__( 'No files were created', 'jetpack' ) );
2113 + } else {
2114 + // Load index.json and insert the slug of the new block in its block variation array.
2115 + $block_list_path = JETPACK__PLUGIN_DIR . 'extensions/index.json';
2116 + $block_list = $wp_filesystem->get_contents( $block_list_path );
2117 + if ( empty( $block_list ) ) {
2118 + /* translators: %s is the path to the file with the block list */
2119 + WP_CLI::error( sprintf( esc_html__( 'Error fetching contents of %s', 'jetpack' ), $block_list_path ) );
2120 + } elseif ( false === stripos( $block_list, $slug ) ) {
2121 + $new_block_list = json_decode( $block_list );
2122 + $new_block_list->{ $variation }[] = $slug;
2123 +
2124 + // Format the JSON to match our coding standards.
2125 + $new_block_list_formatted = wp_json_encode( $new_block_list, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT ) . "\n";
2126 + $new_block_list_formatted = preg_replace_callback(
2127 + // Find all occurrences of multiples of 4 spaces a the start of the line.
2128 + '/^((?: )+)/m',
2129 + function ( $matches ) {
2130 + // Replace each occurrence of 4 spaces with a tab character.
2131 + return str_repeat( "\t", substr_count( $matches[0], ' ' ) );
2132 + },
2133 + $new_block_list_formatted
2134 + );
2135 +
2136 + if ( ! $wp_filesystem->put_contents( $block_list_path, $new_block_list_formatted ) ) {
2137 + /* translators: %s is the path to the file with the block list */
2138 + WP_CLI::error( sprintf( esc_html__( 'Error writing new %s', 'jetpack' ), $block_list_path ) );
2139 + }
2140 + }
2141 +
2142 + if ( 'beta' === $variation || 'experimental' === $variation ) {
2143 + $block_constant = sprintf(
2144 + /* translators: the placeholder is a constant name */
2145 + esc_html__( 'To load the block, add the constant JETPACK_BLOCKS_VARIATION set to %1$s to your wp-config.php file', 'jetpack' ),
2146 + $variation
2147 + );
2148 + } else {
2149 + $block_constant = '';
2150 + }
2151 +
2152 + WP_CLI::success(
2153 + sprintf(
2154 + /* translators: the placeholders are a human readable title, and a series of words separated by dashes */
2155 + esc_html__( 'Successfully created block %1$s with slug %2$s', 'jetpack' ) . ' 🎉' . "\n" .
2156 + "--------------------------------------------------------------------------------------------------------------------\n" .
2157 + /* translators: the placeholder is a directory path */
2158 + esc_html__( 'The files were created at %3$s', 'jetpack' ) . "\n" .
2159 + esc_html__( 'To start using the block, build the blocks with pnpm run build-extensions', 'jetpack' ) . "\n" .
2160 + /* translators: the placeholder is a file path */
2161 + esc_html__( 'The block slug has been added to the %4$s list at %5$s', 'jetpack' ) . "\n" .
2162 + '%6$s' . "\n" .
2163 + /* translators: the placeholder is a URL */
2164 + "\n" . esc_html__( 'Read more at %7$s', 'jetpack' ) . "\n",
2165 + $title,
2166 + $slug,
2167 + $path,
2168 + $variation,
2169 + $block_list_path,
2170 + $block_constant,
2171 + 'https://github.com/Automattic/jetpack/blob/trunk/projects/plugins/jetpack/extensions/README.md#developing-block-editor-extensions-in-jetpack'
2172 + ) . '--------------------------------------------------------------------------------------------------------------------'
2173 + );
2174 + }
2175 + }
2176 +
2177 + /**
2178 + * Built the file replacing the placeholders in the template with the data supplied.
2179 + *
2180 + * @param string $template Template.
2181 + * @param array $data Data.
2182 + * @return string mixed
2183 + */
2184 + private static function render_block_file( $template, $data = array() ) {
2185 + return \WP_CLI\Utils\mustache_render( JETPACK__PLUGIN_DIR . "wp-cli-templates/$template.mustache", $data );
2186 + }
2187 +}
2188 +
2189 +// phpcs:disable Universal.Files.SeparateFunctionsFromOO.Mixed -- TODO: Move these functions to some other file.
2190 +
2191 +/**
2192 + * Standard "ask for permission to continue" function.
2193 + * If action cancelled, ask if they need help.
2194 + *
2195 + * Written outside of the class so it's not listed as an executable command w/ 'wp jetpack'
2196 + *
2197 + * @param bool $flagged false = normal option | true = flagged by get_jetpack_options_for_reset().
2198 + * @param string $error_msg Error message.
2199 + */
2200 +function jetpack_cli_are_you_sure( $flagged = false, $error_msg = false ) {
2201 + $cli = new Jetpack_CLI();
2202 +
2203 + // Default cancellation message.
2204 + if ( ! $error_msg ) {
2205 + $error_msg =
2206 + __( 'Action cancelled. Have a question?', 'jetpack' )
2207 + . ' '
2208 + . $cli->green_open
2209 + . 'jetpack.com/support'
2210 + . $cli->color_close;
2211 + }
2212 +
2213 + if ( ! $flagged ) {
2214 + $prompt_message = _x( 'Are you sure? This cannot be undone. Type "yes" to continue:', '"yes" is a command - do not translate.', 'jetpack' );
2215 + } else {
2216 + $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' );
2217 + }
2218 +
2219 + WP_CLI::line( $prompt_message );
2220 + $handle = fopen( 'php://stdin', 'r' );
2221 + $line = fgets( $handle );
2222 + if ( 'yes' !== trim( $line ) ) {
2223 + WP_CLI::error( $error_msg );
2224 + }
2225 +}