fix(app): run probe resources at two stages

src/utils/access-probes.ts

@@ -0,0 +1,126 @@
+/**
+ * Access probes used to gate Kubernetes-only menus (GPU Service / the
+ * full Usage page).
+ *
+ * These live outside `src/app.tsx` because umi treats every export from
+ * the runtime-config file as a registration key — exporting helpers from
+ * there throws "register failed, invalid key". `getInitialState` (in
+ * app.tsx) and the login flow both import from here.
+ */
+import { queryClusterList } from '@/pages/cluster-management/apis';
+import { ProviderValueMap } from '@/pages/cluster-management/config';
+import { queryResourceEvents } from '@/pages/usage/apis/resource';
+
+// Probes the caller's cluster list once so access predicates can gate
+// GPU Service (Kubernetes-only). Cheap (one list request) and never
+// blocks login — any failure just falls back to `undefined`, which
+// the predicate treats as "unknown / don't restrict beyond role".
+// The result is also mirrored into sessionStorage so access extensions
+// that run without the initialState argument can read it (e.g. to
+// override the admin shortcut in scopes where the menu shouldn't
+// show even for admins).
+const HAS_K8S_CLUSTER_KEY = 'hasKubernetesCluster';
+export const probeHasKubernetesCluster = async (): Promise<
+  boolean | undefined
+> => {
+  try {
+    const res = await queryClusterList(
+      { page: -1 },
+      {
+        skipErrorHandler: true
+      }
+    );
+    const value = (res?.items ?? []).some(
+      (c) => c?.provider === ProviderValueMap.Kubernetes
+    );
+    try {
+      window.sessionStorage.setItem(HAS_K8S_CLUSTER_KEY, JSON.stringify(value));
+    } catch {
+      // sessionStorage may be unavailable (Safari private mode); the
+      // access predicate already handles a missing value as "unknown".
+    }
+    return value;
+  } catch (error) {
+    console.error('probeHasKubernetesCluster error', error);
+    try {
+      window.sessionStorage.removeItem(HAS_K8S_CLUSTER_KEY);
+    } catch {
+      // ignore
+    }
+    return undefined;
+  }
+};
+
+// Probes whether the caller has ANY resource-usage events (GPU/CPU instance or
+// storage lifecycle). Used alongside the cluster probe so a user who has run
+// GPU instances still sees GPU Service / the full Usage page even if they
+// currently have no Kubernetes cluster. Mirrored into sessionStorage for the
+// access extensions; any failure → undefined ("unknown — don't restrict").
+const HAS_RESOURCE_EVENTS_KEY = 'hasResourceEvents';
+export const probeHasResourceEvents = async (): Promise<
+  boolean | undefined
+> => {
+  try {
+    // No date range = "ever"; scope is clamped to the caller server-side.
+    const res = await queryResourceEvents(
+      { perPage: 1 },
+      {
+        skipErrorHandler: true
+      }
+    );
+    const value = (res?.pagination?.total ?? 0) > 0;
+    try {
+      window.sessionStorage.setItem(
+        HAS_RESOURCE_EVENTS_KEY,
+        JSON.stringify(value)
+      );
+    } catch {
+      // sessionStorage may be unavailable; predicate treats missing as unknown.
+    }
+    return value;
+  } catch (error) {
+    console.error('probeHasResourceEvents error', error);
+    try {
+      window.sessionStorage.removeItem(HAS_RESOURCE_EVENTS_KEY);
+    } catch {
+      // ignore
+    }
+    return undefined;
+  }
+};
+
+// Runs both access probes in parallel. Used after login (when
+// `getInitialState` skipped them because the app booted on the login
+// page) so the access predicate has definitive cluster / resource-event
+// answers before the user navigates — otherwise GPU Service / the full
+// Usage page flash on (undefined => "don't restrict") and only collapse
+// to the correct set on the next refresh.
+export const probeAccessFlags = async (): Promise<{
+  hasKubernetesCluster?: boolean;
+  hasResourceEvents?: boolean;
+}> => {
+  const [hasKubernetesCluster, hasResourceEvents] = await Promise.all([
+    probeHasKubernetesCluster(),
+    probeHasResourceEvents()
+  ]);
+  return { hasKubernetesCluster: false, hasResourceEvents: false };
+};
+
+// Module-scoped marker for "did `getInitialState` actually run the access
+// probes during THIS page load". It resets to `false` on every full
+// reload (the module is re-evaluated) and stays sticky across SPA
+// navigations within the same load.
+//
+// The layout uses it to decide whether it must probe: on a refresh of an
+// authenticated page `getInitialState` already probed (marks `true`), so
+// the layout skips and avoids a duplicate request; on a first login the
+// app booted on `/login` where `getInitialState` skipped probing (stays
+// `false`), so the layout is the one that resolves the flags. Keeping
+// this in module scope — rather than reading the flag values off
+// `initialState` — decouples the decision from React's state-update
+// timing, which is what made the earlier flag-gated effect fragile.
+let initialStateDidProbe = false;
+export const markInitialStateProbed = () => {
+  initialStateDidProbe = true;
+};
+export const didInitialStateProbe = () => initialStateDidProbe;