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