← All changes | jetpack_vendor/automattic/jetpack-my-jetpack/src/class-initializer.php +1055 -51 12.4.2 → 16.3-beta View file →

		@@ -8,19 +8,35 @@
8	8	namespace Automattic\Jetpack\My_Jetpack;
9	9
10	10	use Automattic\Jetpack\Admin_UI\Admin_Menu;
11	11	use Automattic\Jetpack\Assets;
12		-use Automattic\Jetpack\Connection\Client as Client;
	12	+use Automattic\Jetpack\Boost_Speed_Score\Speed_Score;
	13	+use Automattic\Jetpack\Boost_Speed_Score\Speed_Score_History;
	14	+use Automattic\Jetpack\Connection\Client;
	15	+use Automattic\Jetpack\Connection\Error_Handler as Connection_Error_Handler;
13	16	use Automattic\Jetpack\Connection\Initial_State as Connection_Initial_State;
14	17	use Automattic\Jetpack\Connection\Manager as Connection_Manager;
15	18	use Automattic\Jetpack\Connection\Rest_Authentication as Connection_Rest_Authentication;
	19	+use Automattic\Jetpack\Connection\REST_Jetpack_AI_JWT;
16	20	use Automattic\Jetpack\Constants as Jetpack_Constants;
17		-use Automattic\Jetpack\JITMS\JITM as JITM;
	21	+use Automattic\Jetpack\ExPlat;
	22	+use Automattic\Jetpack\Feature_Flags\Feature_Flags;
	23	+use Automattic\Jetpack\JITMS\JITM;
18	24	use Automattic\Jetpack\Licensing;
	25	+use Automattic\Jetpack\Menu_Badges\Menu_Badges;
	26	+use Automattic\Jetpack\Menu_Badges\Notification_Counts;
	27	+use Automattic\Jetpack\Modules;
	28	+use Automattic\Jetpack\Partner_Coupon;
19	29	use Automattic\Jetpack\Plugins_Installer;
20		-use Automattic\Jetpack\Status as Status;
	30	+use Automattic\Jetpack\Status;
	31	+use Automattic\Jetpack\Status\Host as Status_Host;
	32	+use Automattic\Jetpack\Sync\Functions as Sync_Functions;
21	33	use Automattic\Jetpack\Terms_Of_Service;
22	34	use Automattic\Jetpack\Tracking;
	35	+use Automattic\Jetpack\WP_Build_Polyfills\WP_Build_Polyfills;
	36	+use Automattic\Jetpack\WP_Build_Polyfills\WP_Build_Screen_Id;
	37	+use Jetpack;
	38	+use WP_Error;
23	39
24	40	/**
25	41	* The main Initializer class that registers the admin menu and eneuque the assets.
26	42	*/
		@@ -30,20 +46,85 @@
30	46	* My Jetpack package version
31	47	*
32	48	* @var string
33	49	*/
34		- const PACKAGE_VERSION = '3.2.0';
	50	+ const PACKAGE_VERSION = '6.8.0';
35	51
36	52	/**
	53	+ * Feature flag that swaps the My Jetpack Products tab for a Features tab.
	54	+ */
	55	+ const FEATURES_TAB_FEATURE_FLAG = 'my-jetpack-features-tab';
	56	+
	57	+ /**
	58	+ * Handle for the classic script that carries the React initial state.
	59	+ *
	60	+ * Plugins that render My Jetpack components on their own pages (Boost) depend on this name.
	61	+ */
	62	+ const DATA_SCRIPT_HANDLE = 'my_jetpack_main_app';
	63	+
	64	+ /**
	65	+ * Handle for the webpack bundle that renders the onboarding takeover.
	66	+ */
	67	+ const ONBOARDING_SCRIPT_HANDLE = 'my_jetpack_onboarding';
	68	+
	69	+ /**
	70	+ * The wp-build page ID, which the generated enqueue check expects as the screen ID.
	71	+ */
	72	+ const WP_BUILD_PAGE_ID = 'my-jetpack-dashboard';
	73	+
	74	+ /**
	75	+ * HTML container ID for the IDC screen on My Jetpack page.
	76	+ */
	77	+ private const IDC_CONTAINER_ID = 'my-jetpack-identity-crisis-container';
	78	+
	79	+ public const JETPACK_PLUGIN_SLUGS = array(
	80	+ 'jetpack-backup',
	81	+ 'jetpack-boost',
	82	+ 'zerobscrm',
	83	+ 'jetpack',
	84	+ 'jetpack-protect',
	85	+ 'jetpack-social',
	86	+ 'jetpack-videopress',
	87	+ 'jetpack-search',
	88	+ 'jetpack-stats',
	89	+ );
	90	+
	91	+ private const MY_JETPACK_SITE_INFO_TRANSIENT_KEY = 'my-jetpack-site-info';
	92	+
	93	+ /**
	94	+ * Holds info/data about the site (from the /sites/%d endpoint)
	95	+ *
	96	+ * @var object
	97	+ */
	98	+ public static $site_info;
	99	+
	100	+ /**
	101	+ * The screen ID alias_screen_id_for_wp_build() replaced, until it is restored.
	102	+ *
	103	+ * @var string|null
	104	+ */
	105	+ private static $wp_build_original_screen_id = null;
	106	+
	107	+ /**
37	108	* Initialize My Jetpack
38	109	*
39	110	* @return void
40	111	*/
41	112	public static function init() {
	113	+ // Before the gate, so the flag stays listed while diagnosing why My Jetpack is off.
	114	+ self::register_feature_flags();
	115	+
	116	+ // Before the gate: the Jetpack plugin renders this package's connection screen and footer
	117	+ // links even where My Jetpack is off, and `myJetpackInitialState` only exists on its own page.
	118	+ add_filter( 'jetpack_admin_js_script_data', array( __CLASS__, 'add_admin_script_data' ) );
	119	+
42	120	if ( ! self::should_initialize() || did_action( 'my_jetpack_init' ) ) {
43	121	return;
44	122	}
45	123
	124	+ // Answer "is this product on?" for admin menu registration.
	125	+ Menu_Visibility::init();
	126	+
46	127	// Extend jetpack plugins action links.
47	128	Products::extend_plugins_action_links();
48	129
49	130	// Set up the REST authentication hooks.
		@@ -52,25 +133,35 @@
52	133	if ( self::is_licensing_ui_enabled() ) {
53	134	Licensing::instance()->initialize();
54	135	}
55	136
	137	+ // Initialize Boost Speed Score
	138	+ new Speed_Score( array(), 'jetpack-my-jetpack' );
	139	+
56	140	// Add custom WP REST API endoints.
57	141	add_action( 'rest_api_init', array( __CLASS__, 'register_rest_endpoints' ) );
58	142
59		- $page_suffix = Admin_Menu::add_menu(
60		- __( 'My Jetpack', 'jetpack-my-jetpack' ),
61		- __( 'My Jetpack', 'jetpack-my-jetpack' ),
62		- 'manage_options',
63		- 'my-jetpack',
64		- array( __CLASS__, 'admin_page' ),
65		- 999
66		- );
	143	+ // Both of wp-build's deadlines fall later in this request: its enqueue check must be
	144	+ // hooked before `admin_enqueue_scripts`, and its render function defined before
	145	+ // the page callback.
	146	+ add_action( 'admin_menu', array( __CLASS__, 'maybe_load_wp_build' ), 1 );
67	147
68		- add_action( 'load-' . $page_suffix, array( __CLASS__, 'admin_init' ) );
	148	+ add_action( 'admin_menu', array( __CLASS__, 'add_my_jetpack_menu_item' ) );
69	149
	150	+ add_action( 'admin_init', array( __CLASS__, 'setup_historically_active_jetpack_modules_sync' ) );
	151	+ // Registered on admin_menu (not admin_init) and well before priority 100000, so the
	152	+ // counts it registers exist before the menu-badges renderer runs on admin_menu 100000.
	153	+ add_action( 'admin_menu', array( __CLASS__, 'maybe_show_red_bubble' ), 30 );
	154	+
	155	+ // Set up the ExPlat package endpoints
	156	+ ExPlat::init();
	157	+
70	158	// Sets up JITMS.
71	159	JITM::configure();
72	160
	161	+ // Add "Jetpack Manage" menu item.
	162	+ Jetpack_Manage::init();
	163	+
73	164	/**
74	165	* Fires after the My Jetpack package is initialized
75	166	*
76	167	* @since 0.1.0
		@@ -111,21 +202,157 @@
111	202	);
112	203	}
113	204
114	205	/**
	206	+ * Add My Jetpack menu item to the admin menu.
	207	+ *
	208	+ * @return void
	209	+ */
	210	+ public static function add_my_jetpack_menu_item() {
	211	+ $position = defined( Admin_Menu::class . '::POSITION_FIRST' ) ? Admin_Menu::POSITION_FIRST : -10;
	212	+ $menu_slug = 'my-jetpack';
	213	+ $page_suffix = Admin_Menu::add_menu(
	214	+ __( 'My Jetpack', 'jetpack-my-jetpack' ),
	215	+ __( 'My Jetpack', 'jetpack-my-jetpack' ),
	216	+ 'edit_posts',
	217	+ $menu_slug,
	218	+ array( __CLASS__, 'admin_page' ),
	219	+ $position
	220	+ );
	221	+ add_action( 'load-' . $page_suffix, array( __CLASS__, 'admin_init' ) );
	222	+ // Users who can edit posts but have no Jetpack menu get an admin_page_ hook instead.
	223	+ add_action( 'load-admin_page_' . $menu_slug, array( __CLASS__, 'admin_init' ) );
	224	+ }
	225	+
	226	+ /**
115	227	* Callback for the load my jetpack page hook.
116	228	*
117	229	* @return void
118	230	*/
119	231	public static function admin_init() {
	232	+ $connection = new Connection_Manager();
	233	+
	234	+ // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- No nonce needed for redirect flow control
	235	+ $step = isset( $_GET['step'] ) ? sanitize_text_field( wp_unslash( $_GET['step'] ) ) : '';
	236	+
	237	+ // Handle onboarding redirects based on connection status. Onboarding's only action is the
	238	+ // connect request, which answers a user without `jetpack_connect` with a 403.
	239	+ $redirect_args = self::get_onboarding_redirect_args(
	240	+ $step,
	241	+ $connection->is_connected(),
	242	+ self::is_onboarding_available() && current_user_can( 'jetpack_connect' )
	243	+ );
	244	+
	245	+ if ( null !== $redirect_args ) {
	246	+ $admin_page = add_query_arg( $redirect_args, admin_url( 'admin.php' ) );
	247	+ $location = wp_sanitize_redirect( $admin_page );
	248	+
	249	+ // Remove wp_get_referer filter applied in `fix_redirect` method of `Jetpack_Admin` class
	250	+ remove_filter( 'wp_redirect', 'wp_get_referer' );
	251	+ wp_safe_redirect( $location );
	252	+
	253	+ exit( 0 );
	254	+ }
	255	+
	256	+ // If the user reaches the onboarding page, add a class to the body
	257	+ if ( $step === 'onboarding' ) {
	258	+ add_filter( 'admin_body_class', array( __CLASS__, 'add_onboarding_admin_body_class' ) );
	259	+ }
	260	+
	261	+ self::$site_info = self::get_site_info();
	262	+ add_filter( 'identity_crisis_container_id', array( static::class, 'get_idc_container_id' ) );
120	263	add_action( 'admin_enqueue_scripts', array( __CLASS__, 'enqueue_scripts' ) );
121		- // Product statuses are constantly changing, so we never want to cache the page.
122		- header( 'Cache-Control: no-cache, no-store, must-revalidate' );
123		- header( 'Pragma: no-cache' );
124		- header( 'Expires: 0' );
125	264	}
126	265
127	266	/**
	267	+ * Whether the My Jetpack onboarding flow is available on this site.
	268	+ *
	269	+ * WordPress.com Simple sites are connected by definition and don't manage their
	270	+ * connection through My Jetpack, so the onboarding flow (which asks the user to
	271	+ * connect) never applies there. A pending partner coupon brings its own connect screen.
	272	+ *
	273	+ * @internal Not part of the package's public API.
	274	+ *
	275	+ * @return bool
	276	+ */
	277	+ public static function is_onboarding_available() {
	278	+ return ! ( new Status_Host() )->is_wpcom_simple() && null === self::get_partner_coupon_screen();
	279	+ }
	280	+
	281	+ /**
	282	+ * The partner coupon screen's data, when it should replace the dashboard.
	283	+ *
	284	+ * Coupons exist only with the Jetpack plugin, which supplies their products and images.
	285	+ *
	286	+ * @since 6.5.0
	287	+ *
	288	+ * @return array{coupon: array, assetBaseUrl: string}|null
	289	+ */
	290	+ public static function get_partner_coupon_screen() {
	291	+ if (
	292	+ ! self::should_initialize()
	293	+ || ! current_user_can( 'manage_options' )
	294	+ || ! Jetpack_Constants::is_defined( 'JETPACK__PLUGIN_FILE' )
	295	+ ) {
	296	+ return null;
	297	+ }
	298	+
	299	+ $coupon = Partner_Coupon::get_coupon();
	300	+ if ( ! $coupon ) {
	301	+ return null;
	302	+ }
	303	+
	304	+ // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Only picks which screen renders.
	305	+ if ( ! isset( $_GET['showCouponRedemption'] ) && ( new Connection_Manager() )->has_connected_owner() ) {
	306	+ return null;
	307	+ }
	308	+
	309	+ return array(
	310	+ 'coupon' => $coupon,
	311	+ 'assetBaseUrl' => plugins_url( '', Jetpack_Constants::get_constant( 'JETPACK__PLUGIN_FILE' ) ),
	312	+ );
	313	+ }
	314	+
	315	+ /**
	316	+ * Decide whether the current My Jetpack request should redirect, and where to.
	317	+ *
	318	+ * @internal Not part of the package's public API.
	319	+ *
	320	+ * @param string $step The current `step` query param.
	321	+ * @param bool $is_connected Whether the site is connected to WordPress.com.
	322	+ * @param bool $onboarding_available Whether the onboarding flow is available on this site.
	323	+ * @return array|null Query args for the redirect, or null to stay on the current page.
	324	+ */
	325	+ public static function get_onboarding_redirect_args( $step, $is_connected, $onboarding_available ) {
	326	+ if ( $onboarding_available && ! $is_connected && $step !== 'onboarding' ) {
	327	+ // Redirect to onboarding if not connected
	328	+ return array(
	329	+ 'page' => 'my-jetpack',
	330	+ 'step' => 'onboarding',
	331	+ );
	332	+ }
	333	+
	334	+ if ( $step === 'onboarding' && ( ! $onboarding_available || $is_connected ) ) {
	335	+ // Redirect away from onboarding if already connected or onboarding is not available on this site
	336	+ return array( 'page' => 'my-jetpack' );
	337	+ }
	338	+
	339	+ return null;
	340	+ }
	341	+
	342	+ /**
	343	+ * Add a body class to the My Jetpack onboarding page.
	344	+ * This class hides the WP Admin toolbar and the sidebar menu.
	345	+ *
	346	+ * @param string $classes The body classes.
	347	+ * @return string The modified body classes.
	348	+ */
	349	+ public static function add_onboarding_admin_body_class( $classes ) {
	350	+ $classes .= 'jetpack-admin-full-screen';
	351	+ return $classes;
	352	+ }
	353	+
	354	+ /**
128	355	* Returns whether we are in condition to track to use
129	356	* Analytics functionality like Tracks, MC, or GA.
130	357	*/
131	358	public static function can_use_analytics() {
		@@ -134,48 +361,344 @@
134	361	$tracking = new Tracking( 'jetpack', $connection );
135	362
136	363	return $tracking->should_enable_tracking( new Terms_Of_Service(), $status );
137	364	}
	365	+
138	366	/**
139		- * Enqueue admin page assets.
	367	+ * Register the package's feature flags.
140	368	*
	369	+ * @since 6.3.0
	370	+ *
141	371	* @return void
142	372	*/
143		- public static function enqueue_scripts() {
144		- Assets::register_script(
145		- 'my_jetpack_main_app',
146		- '../build/index.js',
147		- __FILE__,
	373	+ public static function register_feature_flags() {
	374	+ Feature_Flags::register(
	375	+ self::FEATURES_TAB_FEATURE_FLAG,
148	376	array(
149		- 'enqueue' => true,
150		- 'in_footer' => true,
151		- 'textdomain' => 'jetpack-my-jetpack',
	377	+ 'default' => true,
	378	+ 'description' => 'Replace the My Jetpack Products tab with a Features tab.',
	379	+ 'owner' => 'my-jetpack',
152	380	)
153	381	);
	382	+ }
	383	+
	384	+ /**
	385	+ * Whether the dashboard shows a Features tab in place of the Products tab.
	386	+ *
	387	+ * @since 6.4.0
	388	+ *
	389	+ * @return bool
	390	+ */
	391	+ public static function is_features_tab_enabled() {
	392	+ return Feature_Flags::is_enabled( self::FEATURES_TAB_FEATURE_FLAG );
	393	+ }
	394	+
	395	+ /**
	396	+ * Get the slug and label that replace the Products tab, for links to it.
	397	+ *
	398	+ * Null while the tab is unchanged, so links keep their own translated "Products" label.
	399	+ *
	400	+ * @since 6.4.0
	401	+ *
	402	+ * @return array{slug: string, label: string}|null
	403	+ */
	404	+ public static function get_products_section() {
	405	+ if ( ! self::is_features_tab_enabled() ) {
	406	+ return null;
	407	+ }
	408	+
	409	+ return array(
	410	+ 'slug' => 'features',
	411	+ 'label' => _x( 'Features', 'Navigation item', 'jetpack-my-jetpack' ),
	412	+ );
	413	+ }
	414	+
	415	+ /**
	416	+ * Whether the current request targets the My Jetpack admin page.
	417	+ *
	418	+ * @since 6.3.0
	419	+ *
	420	+ * @return bool
	421	+ */
	422	+ public static function is_my_jetpack_admin_request() {
	423	+ if ( ! isset( $_GET['page'] ) ) { // phpcs:ignore WordPress.Security.NonceVerification.Recommended
	424	+ return false;
	425	+ }
	426	+
	427	+ return sanitize_text_field( wp_unslash( $_GET['page'] ) ) === 'my-jetpack'; // phpcs:ignore WordPress.Security.NonceVerification.Recommended
	428	+ }
	429	+
	430	+ /**
	431	+ * Whether the current request is the full-viewport onboarding takeover.
	432	+ *
	433	+ * Onboarding hides all wp-admin chrome and never renders through wp-build.
	434	+ *
	435	+ * @since 6.3.0
	436	+ *
	437	+ * @return bool
	438	+ */
	439	+ public static function is_onboarding_request() {
	440	+ if ( ! isset( $_GET['step'] ) ) { // phpcs:ignore WordPress.Security.NonceVerification.Recommended
	441	+ return false;
	442	+ }
	443	+
	444	+ return sanitize_text_field( wp_unslash( $_GET['step'] ) ) === 'onboarding'; // phpcs:ignore WordPress.Security.NonceVerification.Recommended
	445	+ }
	446	+
	447	+ /**
	448	+ * Whether this request is the onboarding takeover rather than the dashboard.
	449	+ *
	450	+ * Loading wp-build, enqueueing scripts and rendering the page must all agree,
	451	+ * so they share this one expression.
	452	+ *
	453	+ * @since 6.3.0
	454	+ *
	455	+ * @return bool
	456	+ */
	457	+ public static function is_onboarding_takeover() {
	458	+ return self::is_onboarding_request() && self::is_onboarding_available();
	459	+ }
	460	+
	461	+ /**
	462	+ * Alias the screen ID to satisfy wp-build's generated enqueue check.
	463	+ *
	464	+ * @since 6.3.0
	465	+ *
	466	+ * @return void
	467	+ */
	468	+ public static function alias_screen_id_for_wp_build() {
	469	+ $screen = get_current_screen();
	470	+
	471	+ if ( ! $screen ) {
	472	+ return;
	473	+ }
	474	+
	475	+ self::$wp_build_original_screen_id = $screen->id;
	476	+ $screen->id = self::WP_BUILD_PAGE_ID;
	477	+ }
	478	+
	479	+ /**
	480	+ * Undo alias_screen_id_for_wp_build(), since JITM builds its message path from the screen ID.
	481	+ *
	482	+ * @since 6.3.0
	483	+ *
	484	+ * @return void
	485	+ */
	486	+ public static function restore_screen_id_after_wp_build() {
	487	+ $screen = get_current_screen();
	488	+
	489	+ if ( ! $screen || null === self::$wp_build_original_screen_id ) {
	490	+ return;
	491	+ }
	492	+
	493	+ $screen->id = self::$wp_build_original_screen_id;
	494	+ self::$wp_build_original_screen_id = null;
	495	+ }
	496	+
	497	+ /**
	498	+ * Whether this request should load wp-build at all.
	499	+ *
	500	+ * Also what keeps WP_Build_Polyfills from replacing core scripts on every other admin page.
	501	+ *
	502	+ * @since 6.3.0
	503	+ *
	504	+ * @return bool
	505	+ */
	506	+ public static function should_load_wp_build() {
	507	+ return self::is_my_jetpack_admin_request() && ! self::is_onboarding_takeover();
	508	+ }
	509	+
	510	+ /**
	511	+ * Whether this request renders the dashboard through wp-build.
	512	+ *
	513	+ * The generated render function is missing where the package was never built.
	514	+ *
	515	+ * @since 6.3.0
	516	+ *
	517	+ * @return bool
	518	+ */
	519	+ public static function should_render_wp_build() {
	520	+ return ! self::is_onboarding_takeover()
	521	+ && function_exists( 'jetpack_my_jetpack_my_jetpack_dashboard_wp_admin_render_page' );
	522	+ }
	523	+
	524	+ /**
	525	+ * Load wp-build for the My Jetpack dashboard.
	526	+ *
	527	+ * @since 6.3.0
	528	+ *
	529	+ * @return void
	530	+ */
	531	+ public static function maybe_load_wp_build() {
	532	+ if ( ! self::should_load_wp_build() ) {
	533	+ return;
	534	+ }
	535	+
	536	+ $build_index = dirname( __DIR__ ) . '/build/build.php';
	537	+
	538	+ if ( file_exists( $build_index ) ) {
	539	+ self::load_wp_build( $build_index );
	540	+ }
	541	+ }
	542	+
	543	+ /**
	544	+ * Require the generated wp-build index and wire it into this request.
	545	+ *
	546	+ * @since 6.3.0
	547	+ *
	548	+ * @param string $build_index Path to the generated `build.php`.
	549	+ * @return void
	550	+ */
	551	+ public static function load_wp_build( $build_index ) {
	552	+ self::require_wp_build_with_screen_alias( $build_index );
	553	+
	554	+ // wp-build hooks module registration to wp_default_scripts, which has
	555	+ // already fired by admin_menu — call it directly or the init module
	556	+ // never reaches the import map.
	557	+ if ( function_exists( 'jetpack_my_jetpack_register_script_modules' ) ) {
	558	+ jetpack_my_jetpack_register_script_modules(); // @phan-suppress-current-line PhanUndeclaredFunction -- Checked with function_exists(); defined in the generated build/modules.php, which Phan excludes.
	559	+ }
	560	+
	561	+ WP_Build_Polyfills::register(
	562	+ 'my-jetpack',
	563	+ array_merge( WP_Build_Polyfills::SCRIPT_HANDLES, WP_Build_Polyfills::MODULE_IDS )
	564	+ );
	565	+ }
	566	+
	567	+ /**
	568	+ * Require the generated build file with the screen ID aliased across its enqueue check.
	569	+ *
	570	+ * @see WP_Build_Screen_Id::load_with_alias()
	571	+ * @param string $build_index Path to the generated `build.php`.
	572	+ * @return void
	573	+ */
	574	+ private static function require_wp_build_with_screen_alias( $build_index ) {
	575	+ // Fallback: an older wp-build-polyfills under the jetpack-autoloader may predate load_with_alias().
	576	+ if ( method_exists( WP_Build_Screen_Id::class, 'load_with_alias' ) ) {
	577	+ WP_Build_Screen_Id::load_with_alias(
	578	+ array( __CLASS__, 'alias_screen_id_for_wp_build' ),
	579	+ array( __CLASS__, 'restore_screen_id_after_wp_build' ),
	580	+ function () use ( $build_index ) {
	581	+ require_once $build_index;
	582	+ }
	583	+ );
	584	+ return;
	585	+ }
	586	+
	587	+ add_action( 'admin_enqueue_scripts', array( __CLASS__, 'alias_screen_id_for_wp_build' ) );
	588	+ require_once $build_index;
	589	+ add_action( 'admin_enqueue_scripts', array( __CLASS__, 'restore_screen_id_after_wp_build' ) );
	590	+ }
	591	+
	592	+ /**
	593	+ * Enqueue admin page assets.
	594	+ *
	595	+ * @return void
	596	+ */
	597	+ public static function enqueue_scripts() {
	598	+ /**
	599	+ * Fires after the My Jetpack page is initialized.
	600	+ * Allows for enqueuing additional scripts only on the My Jetpack page.
	601	+ *
	602	+ * @since 4.35.7
	603	+ */
	604	+ do_action( 'myjetpack_enqueue_scripts' );
	605	+ add_filter( 'jetpack_admin_js_script_data', array( __CLASS__, 'add_script_data' ) );
	606	+
	607	+ // Script-less: it only prints the state below, before the dashboard's boot runs on DOMContentLoaded.
	608	+ $data_handle = self::DATA_SCRIPT_HANDLE;
	609	+ wp_register_script( $data_handle, false, array(), self::PACKAGE_VERSION, true );
	610	+ wp_enqueue_script( $data_handle );
	611	+
	612	+ if ( self::is_my_jetpack_admin_request() && self::is_onboarding_takeover() ) {
	613	+ Assets::register_script(
	614	+ self::ONBOARDING_SCRIPT_HANDLE,
	615	+ '../build/onboarding.js',
	616	+ __FILE__,
	617	+ array(
	618	+ 'dependencies' => array( $data_handle ),
	619	+ 'enqueue' => true,
	620	+ 'in_footer' => true,
	621	+ 'textdomain' => 'jetpack-my-jetpack',
	622	+ )
	623	+ );
	624	+ } elseif ( self::should_render_wp_build() && wp_script_is( 'wp-jp-i18n-loader', 'registered' ) ) {
	625	+ // Registered on every admin page but only enqueued when depended on; the esbuild bundles don't pull it in.
	626	+ wp_enqueue_script( 'wp-jp-i18n-loader' );
	627	+ }
	628	+
	629	+ $modules = new Modules();
	630	+ $connection = new Connection_Manager();
	631	+ $speed_score_history = new Speed_Score_History( get_site_url() );
	632	+ $latest_score = $speed_score_history->latest();
	633	+ $previous_score = array();
	634	+ if ( $speed_score_history->count() > 1 ) {
	635	+ $previous_score = $speed_score_history->latest( 1 );
	636	+ }
	637	+ $latest_score['previousScores'] = $previous_score['scores'] ?? array();
	638	+
	639	+ $sandboxed_domain = '';
	640	+ $is_dev_version = false;
	641	+ if ( class_exists( 'Jetpack' ) ) {
	642	+ $is_dev_version = Jetpack::is_development_version();
	643	+ $sandboxed_domain = defined( 'JETPACK__SANDBOX_DOMAIN' ) ? JETPACK__SANDBOX_DOMAIN : '';
	644	+ }
	645	+
	646	+ $features_tab_enabled = self::is_features_tab_enabled();
	647	+
154	648	wp_localize_script(
155		- 'my_jetpack_main_app',
	649	+ $data_handle,
156	650	'myJetpackInitialState',
157	651	array(
158		- 'products' => array(
	652	+ 'products' => array(
159	653	'items' => Products::get_products(),
160	654	),
161		- 'purchases' => array(
162		- 'items' => array(),
	655	+ 'mainFeatures' => $features_tab_enabled ? Main_Features::get_state() : null,
	656	+ 'featuresBanner' => $features_tab_enabled ? array( 'isDismissed' => REST_Main_Features::is_banner_dismissed() ) : null,
	657	+ 'plugins' => Plugins_Installer::get_plugins(),
	658	+ 'themes' => Sync_Functions::get_themes(),
	659	+ 'myJetpackUrl' => admin_url( 'admin.php?page=my-jetpack' ),
	660	+ 'myJetpackCheckoutUri' => admin_url( 'admin.php?page=my-jetpack' ),
	661	+ 'topJetpackMenuItemUrl' => Admin_Menu::get_top_level_menu_item_url(),
	662	+ 'siteSuffix' => ( new Status() )->get_site_suffix(),
	663	+ 'siteUrl' => esc_url( get_site_url() ),
	664	+ 'blogID' => Connection_Manager::get_site_id( true ),
	665	+ 'myJetpackVersion' => self::PACKAGE_VERSION,
	666	+ 'myJetpackFlags' => self::get_my_jetpack_flags(),
	667	+ 'fileSystemWriteAccess' => self::has_file_system_write_access(),
	668	+ 'loadAddLicenseScreen' => self::is_licensing_ui_enabled(),
	669	+ 'adminUrl' => esc_url( admin_url() ),
	670	+ 'assetsUrl' => self::get_assets_url(),
	671	+ 'IDCContainerID' => static::get_idc_container_id(),
	672	+ 'userIsAdmin' => current_user_can( 'manage_options' ),
	673	+ 'lifecycleStats' => array(
	674	+ 'jetpackPlugins' => self::get_installed_jetpack_plugins(),
	675	+ 'historicallyActiveModules' => \Jetpack_Options::get_option( 'historically_active_modules', array() ),
	676	+ 'brokenModules' => Red_Bubble_Notifications::check_for_broken_modules(),
	677	+ 'isSiteConnected' => $connection->is_connected(),
	678	+ 'isUserConnected' => $connection->is_user_connected(),
	679	+ 'modules' => self::get_active_modules(),
163	680	),
164		- 'plugins' => Plugins_Installer::get_plugins(),
165		- 'myJetpackUrl' => admin_url( 'admin.php?page=my-jetpack' ),
166		- 'topJetpackMenuItemUrl' => Admin_Menu::get_top_level_menu_item_url(),
167		- 'siteSuffix' => ( new Status() )->get_site_suffix(),
168		- 'myJetpackVersion' => self::PACKAGE_VERSION,
169		- 'myJetpackFlags' => self::get_my_jetpack_flags(),
170		- 'fileSystemWriteAccess' => self::has_file_system_write_access(),
171		- 'loadAddLicenseScreen' => self::is_licensing_ui_enabled(),
172		- 'adminUrl' => esc_url( admin_url() ),
	681	+ 'recommendedModules' => array(
	682	+ 'modules' => self::get_recommended_modules(),
	683	+ 'isFirstRun' => \Jetpack_Options::get_option( 'recommendations_first_run', true ),
	684	+ 'dismissed' => \Jetpack_Options::get_option( 'dismissed_recommendations', false ),
	685	+ ),
	686	+ 'isStatsModuleActive' => $modules->is_active( 'stats' ),
	687	+ 'canUserViewStats' => current_user_can( 'manage_options' ) || current_user_can( 'view_stats' ),
	688	+ 'hiddenFeatures' => Feature_Visibility::get_hidden(),
	689	+ 'sandboxedDomain' => $sandboxed_domain,
	690	+ 'isDevVersion' => $is_dev_version,
	691	+ 'isAtomic' => ( new Status_Host() )->is_woa_site(),
	692	+ 'isJetpackPluginActive' => class_exists( 'Jetpack' ),
	693	+ 'latestBoostSpeedScores' => $latest_score,
	694	+ 'seoOptIn' => self::get_seo_opt_in_state(),
	695	+ 'partnerCoupon' => self::get_partner_coupon_screen(),
173	696	)
174	697	);
175	698
176	699	wp_localize_script(
177		- 'my_jetpack_main_app',
	700	+ $data_handle,
178	701	'myJetpackRest',
179	702	array(
180	703	'apiRoot' => esc_url_raw( rest_url() ),
181	704	'apiNonce' => wp_create_nonce( 'wp_rest' ),
		@@ -182,9 +705,9 @@
182	705	)
183	706	);
184	707
185	708	// Connection Initial State.
186		- wp_add_inline_script( 'my_jetpack_main_app', Connection_Initial_State::render(), 'before' );
	709	+ Connection_Initial_State::render_script( $data_handle );
187	710
188	711	// Required for Analytics.
189	712	if ( self::can_use_analytics() ) {
190	713	Tracking::register_tracks_functions_scripts( true );
		@@ -191,8 +714,161 @@
191	714	}
192	715	}
193	716
194	717	/**
	718	+ * Add My Jetpack data to the unified script data object.
	719	+ *
	720	+ * @param array $data The script data.
	721	+ * @return array
	722	+ */
	723	+ public static function add_script_data( $data ) {
	724	+ $block_availability = class_exists( '\Jetpack_Gutenberg' )
	725	+ ? \Jetpack_Gutenberg::get_cached_availability()
	726	+ : array();
	727	+
	728	+ $data['myJetpack']['siteEditor'] = array(
	729	+ 'isBlockTheme' => function_exists( 'wp_is_block_theme' ) && wp_is_block_theme(),
	730	+ 'isSharingBlockAvailable' => isset( $block_availability['sharing-buttons'] )
	731	+ && $block_availability['sharing-buttons']['available'],
	732	+ 'isLikeBlockAvailable' => isset( $block_availability['like'] )
	733	+ && $block_availability['like']['available'],
	734	+ 'activeThemeStylesheet' => get_stylesheet(),
	735	+ );
	736	+
	737	+ return $data;
	738	+ }
	739	+
	740	+ /**
	741	+ * Add My Jetpack availability, image base URL, and products tab to admin script data.
	742	+ *
	743	+ * Printed on every admin page by Script_Data, so the connection screen can resolve its
	744	+ * illustrations and Jetpack footers can link to the products tab off the My Jetpack page.
	745	+ *
	746	+ * @since 6.3.0
	747	+ *
	748	+ * @param array $data Script data.
	749	+ * @return array
	750	+ */
	751	+ public static function add_admin_script_data( $data ) {
	752	+ $data['myJetpack']['isAvailable'] = self::is_admin_page_available();
	753	+ $data['myJetpack']['assetsUrl'] = self::get_assets_url();
	754	+ $data['myJetpack']['productsSection'] = self::get_products_section();
	755	+
	756	+ return $data;
	757	+ }
	758	+
	759	+ /**
	760	+ * Whether My Jetpack's admin page is available to the current user.
	761	+ *
	762	+ * Meaningful only after admin_menu has registered the page.
	763	+ *
	764	+ * @since 6.5.0
	765	+ *
	766	+ * @return bool
	767	+ */
	768	+ public static function is_admin_page_available() {
	769	+ global $_registered_pages;
	770	+
	771	+ return did_action( 'my_jetpack_init' ) > 0
	772	+ && isset( $_registered_pages[ get_plugin_page_hookname( 'my-jetpack', 'jetpack' ) ] )
	773	+ && current_user_can( 'edit_posts' );
	774	+ }
	775	+
	776	+ /**
	777	+ * Get the base URL of the package's built images, with a trailing slash.
	778	+ *
	779	+ * @since 6.3.0
	780	+ *
	781	+ * @return string
	782	+ */
	783	+ public static function get_assets_url() {
	784	+ return trailingslashit( Assets::normalize_path( plugins_url( '../build/images/', __FILE__ ) ) );
	785	+ }
	786	+
	787	+ /**
	788	+ * Get installed Jetpack plugins
	789	+ *
	790	+ * @return array
	791	+ */
	792	+ public static function get_installed_jetpack_plugins() {
	793	+ $plugin_slugs = array_keys( Plugins_Installer::get_plugins() );
	794	+ $plugin_slugs = array_map(
	795	+ static function ( $slug ) {
	796	+ $parts = explode( '/', $slug );
	797	+ // Return the last segment of the filepath without the PHP extension
	798	+ return str_replace( '.php', '', $parts[ count( $parts ) - 1 ] );
	799	+ },
	800	+ $plugin_slugs
	801	+ );
	802	+
	803	+ return array_values( array_intersect( self::JETPACK_PLUGIN_SLUGS, $plugin_slugs ) );
	804	+ }
	805	+
	806	+ /**
	807	+ * Get active modules (except ones enabled by default)
	808	+ *
	809	+ * @return array
	810	+ */
	811	+ public static function get_active_modules() {
	812	+ $modules = new Modules();
	813	+ $active_modules = $modules->get_active();
	814	+
	815	+ // if the Jetpack plugin is active, filter out the modules that are active by default
	816	+ if ( class_exists( 'Jetpack' ) && ! empty( $active_modules ) ) {
	817	+ $active_modules = array_diff( $active_modules, Jetpack::get_default_modules() );
	818	+ }
	819	+ return array_values( $active_modules );
	820	+ }
	821	+
	822	+ /**
	823	+ * Determine if the current user is "new" to Jetpack
	824	+ * This is used to vary some messaging in My Jetpack
	825	+ *
	826	+ * On the front-end, purchases are also taken into account
	827	+ *
	828	+ * @return bool
	829	+ */
	830	+ public static function is_jetpack_user_new() {
	831	+ // is the user connected?
	832	+ $connection = new Connection_Manager();
	833	+ if ( $connection->is_user_connected() ) {
	834	+ return false;
	835	+ }
	836	+
	837	+ // TODO: add a data point for the last known connection/ disconnection time
	838	+
	839	+ // are any modules active?
	840	+ $active_modules = self::get_active_modules();
	841	+ if ( ! empty( $active_modules ) ) {
	842	+ return false;
	843	+ }
	844	+
	845	+ // check for other Jetpack plugins that are installed on the site (active or not)
	846	+ // If there's more than one Jetpack plugin active, this user is not "new"
	847	+ $plugin_slugs = array_keys( Plugins_Installer::get_plugins() );
	848	+ $plugin_slugs = array_map(
	849	+ static function ( $slug ) {
	850	+ $parts = explode( '/', $slug );
	851	+ // Return the last segment of the filepath without the PHP extension
	852	+ return str_replace( '.php', '', $parts[ count( $parts ) - 1 ] );
	853	+ },
	854	+ $plugin_slugs
	855	+ );
	856	+ $installed_jetpack_plugins = array_intersect( self::JETPACK_PLUGIN_SLUGS, $plugin_slugs );
	857	+ if ( is_countable( $installed_jetpack_plugins ) && count( $installed_jetpack_plugins ) >= 2 ) {
	858	+ return false;
	859	+ }
	860	+
	861	+ // Does the site have any purchases?
	862	+ $purchases = Wpcom_Products::get_site_current_purchases();
	863	+ if ( ! empty( $purchases ) && ! is_wp_error( $purchases ) ) {
	864	+ return false;
	865	+ }
	866	+
	867	+ return true;
	868	+ }
	869	+
	870	+ /**
195	871	* Build flags for My Jetpack UI
196	872	*
197	873	* @return array
198	874	*/
		@@ -197,10 +873,14 @@
197	873	* @return array
198	874	*/
199	875	public static function get_my_jetpack_flags() {
200	876	$flags = array(
201		- 'videoPressStats' => Jetpack_Constants::is_true( 'JETPACK_MY_JETPACK_VIDEOPRESS_STATS_ENABLED' ),
202		- 'showJetpackStatsCard' => class_exists( 'Jetpack' ),
	877	+ 'videoPressStats' => Jetpack_Constants::is_true( 'JETPACK_MY_JETPACK_VIDEOPRESS_STATS_ENABLED' ),
	878	+ 'showFullJetpackStatsCard' => class_exists( 'Jetpack' ) || Products\Stats::is_standalone_plugin_active(),
	879	+ // Only says which destination `manage_url` is: the legacy Stats page
	880	+ // caches its report and wants a `force_refresh` hint the dashboard does not.
	881	+ 'premiumAnalyticsEnabled' => Products\Stats::is_premium_analytics_enabled(),
	882	+ 'showAiModuleToggle' => Products\Jetpack_Ai::is_feature_ui_enabled(),
203	883	);
204	884
205	885	return $flags;
206	886	}
		@@ -205,14 +885,63 @@
205	885	return $flags;
206	886	}
207	887
208	888	/**
	889	+ * Build the state the My Jetpack "try the new SEO experience" opt-in card hydrates from.
	890	+ *
	891	+ * The card invites an existing self-hosted install to switch over to the new Jetpack SEO
	892	+ * dashboard (JETPACK-1700). Gating lives server-side, where the signals actually are. The
	893	+ * card shows only when all of:
	894	+ *
	895	+ * - the new SEO product is available — the `rsm_jetpack_seo` feature filter is on (the SEO
	896	+ * package autoloads regardless, so `class_exists()` alone isn't enough; the filter is the
	897	+ * real availability switch and the same one the SEO package gates its own surface behind);
	898	+ * - the site is self-hosted — WordPress.com (Simple + Atomic) decides its own SEO surface, so
	899	+ * the opt-in card is for self-hosted installs only;
	900	+ * - the install hasn't opted in yet — `jetpack_seo_surface_visible` is still false. On wpcom
	901	+ * the SEO package's `is_seo_surface_visible()` short-circuits to `true`, so the
	902	+ * "not visible yet" check also doubles as the self-hosted guard, but we check the platform
	903	+ * explicitly for clarity.
	904	+ *
	905	+ * Referenced through `class_exists()` rather than a hard composer dependency: both packages
	906	+ * ship inside the Jetpack plugin and the SEO surface is feature-flagged, so a guarded read of
	907	+ * its public API keeps this from adding plumbing to consumers that don't load SEO.
	908	+ *
	909	+ * The on-success destination is computed by the opt-in endpoint itself; we only seed the card
	910	+ * with the same admin URL so the button has a sensible fallback before the request resolves.
	911	+ *
	912	+ * @return array{showCard: bool, redirect: string}
	913	+ */
	914	+ public static function get_seo_opt_in_state() {
	915	+ // Guard with method_exists rather than class_exists: an older bundled SEO package can ship
	916	+ // the Initializer class without this method, and class_exists alone would still fatal.
	917	+ $seo_initializer = 'Automattic\Jetpack\SEO\Initializer';
	918	+ // @phan-suppress-next-line PhanUndeclaredClassReference -- optional SEO package, guarded by method_exists.
	919	+ $show_card = method_exists( $seo_initializer, 'is_optin_available' ) && $seo_initializer::is_optin_available();
	920	+
	921	+ return array(
	922	+ 'showCard' => $show_card,
	923	+ 'redirect' => admin_url( 'admin.php?page=jetpack-seo' ),
	924	+ );
	925	+ }
	926	+
	927	+ /**
209	928	* Echoes the admin page content.
210	929	*
211	930	* @return void
212	931	*/
213	932	public static function admin_page() {
214		- echo '<div id="my-jetpack-container"></div>';
	933	+ // No connection check needed here: admin_init() has already redirected connected users
	934	+ // away from onboarding. Availability is re-checked inside the helper on purpose — this
	935	+ // render can run even when that redirect did not.
	936	+ if ( self::is_onboarding_takeover() ) {
	937	+ echo '<div id="my-jetpack-container"></div>';
	938	+ return;
	939	+ }
	940	+
	941	+ if ( self::should_render_wp_build() ) {
	942	+ jetpack_my_jetpack_my_jetpack_dashboard_wp_admin_render_page(); // @phan-suppress-current-line PhanUndeclaredFunction -- should_render_wp_build() checks function_exists(); defined in the generated build/pages/, which Phan excludes.
	943	+ }
215	944	}
216	945
217	946	/**
218	947	* Register the REST API routes.
		@@ -221,11 +950,20 @@
221	950	*/
222	951	public static function register_rest_endpoints() {
223	952	new REST_Products();
224	953	new REST_Purchases();
225		- new REST_Zendesk_Chat();
226		- new REST_AI();
	954	+ ( new REST_Jetpack_AI_JWT() )->register_rest_route();
	955	+ new REST_Recommendations_Evaluation();
227	956
	957	+ if ( self::is_features_tab_enabled() ) {
	958	+ ( new REST_Main_Features() )->register_rest_routes();
	959	+ }
	960	+
	961	+ Products::register_product_endpoints();
	962	+ Historically_Active_Modules::register_rest_endpoints();
	963	+ Jetpack_Manage::register_rest_endpoints();
	964	+ Red_Bubble_Notifications::register_rest_endpoints();
	965	+
228	966	register_rest_route(
229	967	'my-jetpack/v1',
230	968	'site',
231	969	array(
		@@ -233,8 +971,18 @@
233	971	'callback' => __CLASS__ . '::get_site',
234	972	'permission_callback' => __CLASS__ . '::permissions_callback',
235	973	)
236	974	);
	975	+
	976	+ register_rest_route(
	977	+ 'my-jetpack/v1',
	978	+ 'site/dismiss-welcome-banner',
	979	+ array(
	980	+ 'methods' => \WP_REST_Server::EDITABLE,
	981	+ 'callback' => __CLASS__ . '::dismiss_welcome_banner',
	982	+ 'permission_callback' => __CLASS__ . '::permissions_callback',
	983	+ )
	984	+ );
237	985	}
238	986
239	987	/**
240	988	* Check user capability to access the endpoint.
		@@ -253,9 +1001,10 @@
253	1001	*/
254	1002	public static function should_initialize() {
255	1003	$should = true;
256	1004
257		- if ( is_multisite() ) {
	1005	+ // All options presented in My Jetpack require a connection to WordPress.com.
	1006	+ if ( ( new Status() )->is_offline_mode() ) {
258	1007	$should = false;
259	1008	}
260	1009
261	1010	/**
		@@ -268,8 +1017,36 @@
268	1017	return apply_filters( 'jetpack_my_jetpack_should_initialize', $should );
269	1018	}
270	1019
271	1020	/**
	1021	+ * Hook into several connection-based actions to update the historically active Jetpack modules
	1022	+ * If the transient that indicates the list needs to be synced, update it and delete the transient
	1023	+ *
	1024	+ * @return void
	1025	+ */
	1026	+ public static function setup_historically_active_jetpack_modules_sync() {
	1027	+ // yummmm. ham.
	1028	+ $ham = new Historically_Active_Modules();
	1029	+ if ( get_transient( $ham::UPDATE_HISTORICALLY_ACTIVE_JETPACK_MODULES_KEY ) && ! wp_doing_ajax() ) {
	1030	+ $ham::update_historically_active_jetpack_modules();
	1031	+ delete_transient( $ham::UPDATE_HISTORICALLY_ACTIVE_JETPACK_MODULES_KEY );
	1032	+ }
	1033	+
	1034	+ $actions = array(
	1035	+ 'jetpack_site_registered',
	1036	+ 'jetpack_user_authorized',
	1037	+ 'activated_plugin',
	1038	+ );
	1039	+
	1040	+ foreach ( $actions as $action ) {
	1041	+ add_action( $action, array( $ham, 'queue_historically_active_jetpack_modules_update' ), 5 );
	1042	+ }
	1043	+
	1044	+ // Modules are often updated async, so we need to update them right away as there will sometimes be no page reload.
	1045	+ add_action( 'jetpack_activate_module', array( $ham, 'update_historically_active_jetpack_modules' ), 5 );
	1046	+ }
	1047	+
	1048	+ /**
272	1049	* Site full-data endpoint.
273	1050	*
274	1051	* @return object Site data.
275	1052	*/
		@@ -281,18 +1058,78 @@
281	1058	$response_code = wp_remote_retrieve_response_code( $response );
282	1059	$body = json_decode( wp_remote_retrieve_body( $response ) );
283	1060
284	1061	if ( is_wp_error( $response ) || empty( $response['body'] ) ) {
285		- return new \WP_Error( 'site_data_fetch_failed', 'Site data fetch failed', array( 'status' => $response_code ) );
	1062	+ return new WP_Error( 'site_data_fetch_failed', 'Site data fetch failed', array( 'status' => $response_code ) );
286	1063	}
287	1064
288		- return rest_ensure_response( $body, 200 );
	1065	+ return rest_ensure_response( $body );
289	1066	}
290	1067
291	1068	/**
292		- * Returns true if the site has file write access to the plugins folder, false otherwise.
	1069	+ * Populates the self::$site_info var with site data from the /sites/%d endpoint
293	1070	*
	1071	+ * @return object|WP_Error
	1072	+ */
	1073	+ public static function get_site_info() {
	1074	+ static $site_info = null;
	1075	+
	1076	+ if ( $site_info !== null ) {
	1077	+ return $site_info;
	1078	+ }
	1079	+
	1080	+ // Check for a cached value before doing lookup
	1081	+ $stored_site_info = get_transient( self::MY_JETPACK_SITE_INFO_TRANSIENT_KEY );
	1082	+ if ( $stored_site_info !== false ) {
	1083	+ return $stored_site_info;
	1084	+ }
	1085	+
	1086	+ $response = self::get_site();
	1087	+ if ( is_wp_error( $response ) ) {
	1088	+ return $response;
	1089	+ }
	1090	+ $site_info = $response->data;
	1091	+ set_transient( self::MY_JETPACK_SITE_INFO_TRANSIENT_KEY, $site_info, DAY_IN_SECONDS );
	1092	+
	1093	+ return $site_info;
	1094	+ }
	1095	+
	1096	+ /**
	1097	+ * Returns whether a site has been determined "commercial" or not.
	1098	+ *
	1099	+ * @return bool|null
	1100	+ */
	1101	+ public static function is_commercial_site() {
	1102	+ if ( is_wp_error( self::$site_info ) ) {
	1103	+ return null;
	1104	+ }
	1105	+
	1106	+ return empty( self::$site_info->options->is_commercial ) ? false : self::$site_info->options->is_commercial;
	1107	+ }
	1108	+
	1109	+ /**
	1110	+ * Check if site is registered (has been connected before).
	1111	+ *
294	1112	* @return bool
	1113	+ */
	1114	+ public static function is_registered() {
	1115	+ return (bool) \Jetpack_Options::get_option( 'id' );
	1116	+ }
	1117	+
	1118	+ /**
	1119	+ * Dismiss the welcome banner.
	1120	+ *
	1121	+ * @return \WP_REST_Response
	1122	+ */
	1123	+ public static function dismiss_welcome_banner() {
	1124	+ \Jetpack_Options::update_option( 'dismissed_welcome_banner', true );
	1125	+ return rest_ensure_response( array( 'success' => true ) );
	1126	+ }
	1127	+
	1128	+ /**
	1129	+ * Returns "yes" if the site has file write access to the plugins folder, "no" otherwise.
	1130	+ *
	1131	+ * @return string
295	1132	**/
296	1133	public static function has_file_system_write_access() {
297	1134
298	1135	$cache = get_transient( 'my_jetpack_write_access' );
		@@ -313,9 +1150,9 @@
313	1150	if ( 'direct' === $filesystem_method ) {
314	1151	$write_access = 'yes';
315	1152	}
316	1153
317		- if ( ! $write_access ) {
	1154	+ if ( 'no' === $write_access ) {
318	1155	ob_start();
319	1156	$filesystem_credentials_are_stored = request_filesystem_credentials( self_admin_url() );
320	1157	ob_end_clean();
321	1158
		@@ -328,5 +1165,172 @@
328	1165
329	1166	return $write_access;
330	1167	}
331	1168
	1169	+ /**
	1170	+ * Get container IDC for the IDC screen.
	1171	+ *
	1172	+ * @return string
	1173	+ */
	1174	+ public static function get_idc_container_id() {
	1175	+ return static::IDC_CONTAINER_ID;
	1176	+ }
	1177	+
	1178	+ /**
	1179	+ * Conditionally append the red bubble notification to the "Jetpack" menu item if there are alerts to show.
	1180	+ *
	1181	+ * On My Jetpack page: Uses blocking behavior to fetch fresh data.
	1182	+ * On other admin pages: Uses cached data only to avoid blocking, with async JS fetch if cache is empty.
	1183	+ *
	1184	+ * @return void
	1185	+ */
	1186	+ public static function maybe_show_red_bubble() {
	1187	+ global $pagenow;
	1188	+
	1189	+ // Don't show red bubble alerts for non-admin users
	1190	+ // These alerts are generally only actionable for admins
	1191	+ if ( ! current_user_can( 'manage_options' ) ) {
	1192	+ return;
	1193	+ }
	1194	+
	1195	+ // Don't show any red bubbles when Jetpack is disconnected
	1196	+ // Users can't act on most alerts without a connection
	1197	+ $connection = new Connection_Manager();
	1198	+ if ( ! $connection->is_connected() ) {
	1199	+ return;
	1200	+ }
	1201	+
	1202	+ // Check if we're on the My Jetpack page.
	1203	+ // phpcs:ignore WordPress.Security.NonceVerification.Recommended
	1204	+ $page = isset( $_GET['page'] ) ? sanitize_text_field( wp_unslash( $_GET['page'] ) ) : '';
	1205	+ $is_my_jetpack_page = $pagenow === 'admin.php' && $page === 'my-jetpack';
	1206	+
	1207	+ if ( $is_my_jetpack_page ) {
	1208	+ // On My Jetpack page: use blocking behavior for fresh data.
	1209	+ add_filter( 'my_jetpack_red_bubble_notification_slugs', array( Red_Bubble_Notifications::class, 'add_red_bubble_alerts' ) );
	1210	+ $red_bubble_alerts = Red_Bubble_Notifications::get_red_bubble_alerts();
	1211	+ } else {
	1212	+ // On other pages: use cached data only to avoid blocking.
	1213	+ $cached_alerts = Red_Bubble_Notifications::get_cached_alerts();
	1214	+
	1215	+ if ( false === $cached_alerts ) {
	1216	+ // No cache: warm it asynchronously via JS. Register a hidden zero-count
	1217	+ // placeholder so Menu_Renderer emits a `my-jetpack` badge element the
	1218	+ // warmer can reveal (see async-notification-bubble.ts) without a reload.
	1219	+ Menu_Badges::init(); // idempotent; wires the renderer.
	1220	+ Notification_Counts::register(
	1221	+ 'my-jetpack',
	1222	+ array(
	1223	+ 'menu_slug' => 'my-jetpack',
	1224	+ 'count' => 0,
	1225	+ 'type' => 'count',
	1226	+ )
	1227	+ );
	1228	+ add_action( 'admin_enqueue_scripts', array( __CLASS__, 'enqueue_red_bubble_script' ) );
	1229	+ return;
	1230	+ }
	1231	+
	1232	+ $red_bubble_alerts = $cached_alerts;
	1233	+ }
	1234	+
	1235	+ // Filter out silent alerts.
	1236	+ $red_bubble_alerts = array_filter(
	1237	+ $red_bubble_alerts,
	1238	+ function ( $alert ) {
	1239	+ return empty( $alert['is_silent'] );
	1240	+ }
	1241	+ );
	1242	+
	1243	+ // Report each non-silent alert to the central menu-badges registry as an
	1244	+ // attention entry (count 1). The registry + renderer own the badge.
	1245	+ Menu_Badges::init(); // idempotent; wires the renderer.
	1246	+
	1247	+ // Connection errors are owned by the Error Handler (the single source of truth):
	1248	+ // surface any it reports for this viewer as their own attention entry. Read live
	1249	+ // rather than from the red-bubble transient, since that cache is not viewer-keyed.
	1250	+ $has_connection_error = self::has_connection_error();
	1251	+ if ( $has_connection_error ) {
	1252	+ Notification_Counts::register(
	1253	+ 'my-jetpack-connection-error',
	1254	+ array(
	1255	+ 'menu_slug' => 'my-jetpack',
	1256	+ 'type' => 'attention',
	1257	+ )
	1258	+ );
	1259	+ }
	1260	+
	1261	+ foreach ( array_keys( $red_bubble_alerts ) as $slug ) {
	1262	+ // Protect reports its own count directly to the registry, but only when its
	1263	+ // standalone plugin is active (see class-jetpack-protect.php::admin_page_init()).
	1264	+ // If the standalone plugin isn't active, nobody else registers this count, so we
	1265	+ // must not skip it here or the alert silently disappears from the menu total.
	1266	+ if ( 'protect_has_threats' === $slug && Products\Protect::is_standalone_plugin_active() ) {
	1267	+ continue;
	1268	+ }
	1269	+ // The missing-connection slug and a connection error describe the same broken
	1270	+ // connection; count it once (the error, above, is the more specific signal).
	1271	+ if ( $has_connection_error && 'missing-connection' === $slug ) {
	1272	+ continue;
	1273	+ }
	1274	+ Notification_Counts::register(
	1275	+ 'my-jetpack-' . $slug,
	1276	+ array(
	1277	+ 'menu_slug' => 'my-jetpack',
	1278	+ 'type' => 'attention',
	1279	+ )
	1280	+ );
	1281	+ }
	1282	+ }
	1283	+
	1284	+ /**
	1285	+ * Whether the Connection Error Handler reports a displayable connection error
	1286	+ * for the current viewer.
	1287	+ *
	1288	+ * Read live (not via the red-bubble transient): get_displayable_errors() is a
	1289	+ * cached option read that the Error Handler already scopes and caches per viewer.
	1290	+ * Guarded for the mid-plugin-update window, where a stale connection package
	1291	+ * predating the method can be loaded.
	1292	+ *
	1293	+ * @return bool
	1294	+ */
	1295	+ private static function has_connection_error() {
	1296	+ if ( ! class_exists( Connection_Error_Handler::class ) || ! method_exists( Connection_Error_Handler::class, 'get_displayable_errors' ) ) {
	1297	+ return false;
	1298	+ }
	1299	+ return ! empty( Connection_Error_Handler::get_instance()->get_displayable_errors() );
	1300	+ }
	1301	+
	1302	+ /**
	1303	+ * Enqueue the notification bubble script.
	1304	+ * Fetches fresh alert data via REST API without blocking page load.
	1305	+ *
	1306	+ * @return void
	1307	+ */
	1308	+ public static function enqueue_red_bubble_script() {
	1309	+ Assets::register_script(
	1310	+ 'my-jetpack-notification-bubble',
	1311	+ '../build/async-notification-bubble.js',
	1312	+ __FILE__,
	1313	+ array(
	1314	+ 'enqueue' => true,
	1315	+ 'in_footer' => true,
	1316	+ )
	1317	+ );
	1318	+ }
	1319	+
	1320	+ /**
	1321	+ * Get list of module names sorted by their recommendation score
	1322	+ *
	1323	+ * @return array|null
	1324	+ */
	1325	+ public static function get_recommended_modules() {
	1326	+ $recommendations_evaluation = \Jetpack_Options::get_option( 'recommendations_evaluation', null );
	1327	+
	1328	+ if ( empty( $recommendations_evaluation ) || ! is_array( $recommendations_evaluation ) ) {
	1329	+ return null;
	1330	+ }
	1331	+
	1332	+ arsort( $recommendations_evaluation ); // Sort by scores in descending order
	1333	+
	1334	+ return array_keys( $recommendations_evaluation ); // Get only module names
	1335	+ }
332	1336	}