@openshift-assisted/ui-lib 2.39.1 → 2.39.3

package/lib/common/components/operators/operatorSpecs.tsx

@@ -0,0 +1,343 @@
+import React from 'react';
+import { Cluster } from '@openshift-assisted/types/assisted-installer-service';
+import { FeatureId } from '../../types';
+import {
+  OPERATOR_NAME_AMD_GPU,
+  OPERATOR_NAME_AUTHORINO,
+  OPERATOR_NAME_CNV,
+  OPERATOR_NAME_KMM,
+  OPERATOR_NAME_LSO,
+  OPERATOR_NAME_LVM,
+  OPERATOR_NAME_MCE,
+  OPERATOR_NAME_MTV,
+  OPERATOR_NAME_NMSTATE,
+  OPERATOR_NAME_NODE_FEATURE_DISCOVERY,
+  OPERATOR_NAME_NVIDIA_GPU,
+  OPERATOR_NAME_ODF,
+  OPERATOR_NAME_OPENSHIFT_AI,
+  OPERATOR_NAME_OSC,
+  OPERATOR_NAME_PIPELINES,
+  OPERATOR_NAME_SERVERLESS,
+  OPERATOR_NAME_SERVICEMESH,
+  OPERATOR_NAME_NODE_HEALTHCHECK,
+  OPERATOR_NAME_SELF_NODE_REMEDIATION,
+  OPERATOR_NAME_FENCE_AGENTS_REMEDIATION,
+  OPERATOR_NAME_NODE_MAINTENANCE,
+  OPERATOR_NAME_KUBE_DESCHEDULER,
+} from '../../config/constants';
+import { ExternalLink } from '../ui';
+import {
+  AUTHORINO_OPERATOR_LINK,
+  CNV_LINK,
+  FENCE_AGENTS_REMEDIATION_LINK,
+  getLsoLink,
+  getLvmsDocsLink,
+  getMceDocsLink,
+  getNmstateLink,
+  getNodeFeatureDiscoveryLink,
+  getNvidiaGpuLink,
+  getServiceMeshLink,
+  KMM_LINK,
+  MTV_LINK,
+  NODE_HEALTHCHECK_LINK,
+  ODF_LINK,
+  ODF_REQUIREMENTS_LINK,
+  OPENSHIFT_AI_LINK,
+  OPENSHIFT_AI_REQUIREMENTS_LINK,
+  OSC_LINK,
+  OSC_REQUIREMENTS_LINK,
+  PIPELINES_OPERATOR_LINK,
+  SELF_NODE_REMEDIATION_LINK,
+  SERVERLESS_OPERATOR_LINK,
+} from '../../config';
+import { getMajorMinorVersion } from '../../utils';
+import { useNewFeatureSupportLevel } from '../newFeatureSupportLevels';
+
+export const isOCPVersionEqualsOrMore = (
+  openshiftVersion: string,
+  ocpVersionToCompare: string,
+): boolean => {
+  const [majorA, minorA] = getMajorMinorVersion(openshiftVersion).split('.');
+  const [majorB, minorB] = ocpVersionToCompare.split('.');
+  return (
+    Number(majorA) > Number(majorB) ||
+    (Number(majorA) === Number(majorB) && Number(minorA) >= Number(minorB))
+  );
+};
+
+export type OperatorSpec = {
+  title: string;
+  featureId: FeatureId;
+  Description?: React.ComponentType<{ openshiftVersion?: string }>;
+  notStandalone?: boolean;
+  Requirements?: React.ComponentType<{ cluster: Cluster }>;
+};
+
+export const getOperatorSpecs = (useLVMS?: boolean): { [key: string]: OperatorSpec } => {
+  return {
+    [OPERATOR_NAME_MTV]: {
+      title: 'Migration Toolkit for Virtualization',
+      featureId: 'MTV',
+      Description: () => (
+        <>
+          This Toolkit (MTV) enables you to migrate virtual machines from VMware vSphere, Red Hat
+          Virtualization, or OpenStack to OpenShift Virtualization running on Red Hat OpenShift.{' '}
+          <ExternalLink href={MTV_LINK}>Learn more</ExternalLink>
+        </>
+      ),
+    },
+    [OPERATOR_NAME_AMD_GPU]: {
+      title: 'AMD GPU',
+      featureId: 'AMD_GPU',
+      Requirements: () => <>Requires at least one supported AMD GPU</>,
+      Description: () => (
+        <>
+          Automate the management of AMD software components needed to provision and monitor GPUs.
+        </>
+      ),
+    },
+    [OPERATOR_NAME_LSO]: {
+      title: 'Local Storage Operator',
+      featureId: 'LSO',
+      Description: ({ openshiftVersion }) => (
+        <>
+          Allows provisioning of persistent storage by using local volumes.{' '}
+          <ExternalLink href={getLsoLink(openshiftVersion)}>Learn more</ExternalLink>
+        </>
+      ),
+      notStandalone: true,
+    },
+    [OPERATOR_NAME_AUTHORINO]: {
+      title: 'Authorino',
+      featureId: 'AUTHORINO',
+      Description: () => (
+        <>
+          Lightweight external authorization service for tailor-made Zero Trust API security.{' '}
+          <ExternalLink href={AUTHORINO_OPERATOR_LINK}>Learn more</ExternalLink>
+        </>
+      ),
+      notStandalone: true,
+    },
+    [OPERATOR_NAME_CNV]: {
+      title: 'OpenShift Virtualization',
+      featureId: 'CNV',
+      Requirements: () => (
+        <>Enabled CPU virtualization support in BIOS (Intel-VT / AMD-V) on all nodes</>
+      ),
+      Description: () => (
+        <>
+          Run virtual machines alongside containers on one platform.{' '}
+          <ExternalLink href={CNV_LINK}>Learn more</ExternalLink>
+        </>
+      ),
+    },
+    [OPERATOR_NAME_FENCE_AGENTS_REMEDIATION]: {
+      title: 'Fence Agents Remediation',
+      featureId: 'FENCE_AGENTS_REMEDIATION',
+      Description: () => (
+        <>
+          Externally fences failed nodes using power controllers.{' '}
+          <ExternalLink href={FENCE_AGENTS_REMEDIATION_LINK}>Learn more</ExternalLink>
+        </>
+      ),
+      notStandalone: true,
+    },
+    [OPERATOR_NAME_KMM]: {
+      title: 'Kernel Module Management',
+      featureId: 'KMM',
+      Description: () => (
+        <>
+          Management of kernel modules. <ExternalLink href={KMM_LINK}>Learn more</ExternalLink>
+        </>
+      ),
+    },
+    [OPERATOR_NAME_KUBE_DESCHEDULER]: {
+      title: 'Kube Descheduler',
+      featureId: 'KUBE_DESCHEDULER',
+      Description: () => (
+        <>
+          Evicts pods to reschedule them onto more suitable nodes.{' '}
+          <ExternalLink href={NODE_HEALTHCHECK_LINK}>Learn more</ExternalLink>
+        </>
+      ),
+      notStandalone: true,
+    },
+    [OPERATOR_NAME_MCE]: {
+      title: 'Multicluster engine',
+      featureId: 'MCE',
+      Description: ({ openshiftVersion }) => (
+        <>
+          Create, import, and manage multiple clusters from this cluster.{' '}
+          <ExternalLink href={getMceDocsLink(openshiftVersion)}>Learn more</ExternalLink>
+        </>
+      ),
+    },
+    [OPERATOR_NAME_NMSTATE]: {
+      title: 'NMState',
+      featureId: 'NMSTATE',
+      Description: ({ openshiftVersion }) => (
+        <>
+          Provides users with functionality to configure various network interface types, DNS, and
+          routing on cluster nodes.{' '}
+          <ExternalLink href={getNmstateLink(openshiftVersion)}>Learn more</ExternalLink>
+        </>
+      ),
+    },
+    [OPERATOR_NAME_NODE_FEATURE_DISCOVERY]: {
+      title: 'Node Feature Discovery',
+      featureId: 'NODE_FEATURE_DISCOVERY',
+      Description: ({ openshiftVersion }) => (
+        <>
+          Manage the detection of hardware features and configuration by labeling nodes with
+          hardware-specific information.{' '}
+          <ExternalLink href={getNodeFeatureDiscoveryLink(openshiftVersion)}>
+            Learn more
+          </ExternalLink>
+        </>
+      ),
+    },
+    [OPERATOR_NAME_NODE_HEALTHCHECK]: {
+      title: 'Node Healthcheck',
+      featureId: 'NODE_HEALTHCHECK',
+      Description: () => (
+        <>
+          Identify Unhealthy Nodes.{' '}
+          <ExternalLink href={NODE_HEALTHCHECK_LINK}>Learn more</ExternalLink>
+        </>
+      ),
+      notStandalone: true,
+    },
+    [OPERATOR_NAME_NODE_MAINTENANCE]: {
+      title: 'Node Maintenance',
+      featureId: 'NODE_MAINTENANCE',
+      Description: () => (
+        <>
+          Place nodes in maintenance mode.{' '}
+          <ExternalLink href={NODE_HEALTHCHECK_LINK}>Learn more</ExternalLink>
+        </>
+      ),
+      notStandalone: true,
+    },
+    [OPERATOR_NAME_NVIDIA_GPU]: {
+      title: 'NVIDIA GPU',
+      featureId: 'NVIDIA_GPU',
+      Requirements: () => <>Requires at least one supported NVIDIA GPU</>,
+      Description: ({ openshiftVersion }) => (
+        <>
+          Automate the management of NVIDIA software components needed to provision and monitor
+          GPUs. <ExternalLink href={getNvidiaGpuLink(openshiftVersion)}>Learn more</ExternalLink>
+        </>
+      ),
+    },
+    [OPERATOR_NAME_ODF]: {
+      title: 'OpenShift Data Foundation',
+      featureId: 'ODF',
+      Requirements: () => (
+        <ExternalLink href={ODF_REQUIREMENTS_LINK}>
+          Learn more about the requirements for OpenShift Data Foundation
+        </ExternalLink>
+      ),
+      Description: () => (
+        <>
+          Persistent software-defined storage for hybrid applications.{' '}
+          <ExternalLink href={ODF_LINK}>Learn more</ExternalLink>
+        </>
+      ),
+    },
+    [OPERATOR_NAME_OPENSHIFT_AI]: {
+      title: 'OpenShift AI',
+      featureId: 'OPENSHIFT_AI',
+      Requirements: () => (
+        <ExternalLink href={OPENSHIFT_AI_REQUIREMENTS_LINK}>Learn more</ExternalLink>
+      ),
+      Description: () => (
+        <>
+          Train, serve, monitor and manage AI/ML models and applications.{' '}
+          <ExternalLink href={OPENSHIFT_AI_LINK}>Learn more</ExternalLink>
+        </>
+      ),
+    },
+    [OPERATOR_NAME_OSC]: {
+      title: 'OpenShift sandboxed containers',
+      featureId: 'OSC',
+      Requirements: () => (
+        <ExternalLink href={OSC_REQUIREMENTS_LINK}>
+          Learn more about the requirements for OpenShift sandboxed containers
+        </ExternalLink>
+      ),
+      Description: () => (
+        <>
+          OpenShift sandboxed containers support for OpenShift Container Platform provides users
+          with built-in support for running Kata Containers as an additional optional runtime. It
+          provides an additional virtualization machine(VM) isolation layer for pods.{' '}
+          <ExternalLink href={OSC_LINK}>Learn more</ExternalLink>
+        </>
+      ),
+    },
+    [OPERATOR_NAME_PIPELINES]: {
+      title: 'Pipelines',
+      featureId: 'PIPELINES',
+      Description: () => (
+        <>
+          Cloud-native continuous integration and delivery (CI/CD) solution for building pipelines
+          using Tekton. <ExternalLink href={PIPELINES_OPERATOR_LINK}>Learn more</ExternalLink>
+        </>
+      ),
+      notStandalone: true,
+    },
+    [OPERATOR_NAME_SELF_NODE_REMEDIATION]: {
+      title: 'Self Node Remediation',
+      featureId: 'SELF_NODE_REMEDIATION',
+      Description: () => (
+        <>
+          Allows nodes to reboot themselves when they become unhealthy.{' '}
+          <ExternalLink href={SELF_NODE_REMEDIATION_LINK}>Learn more</ExternalLink>
+        </>
+      ),
+      notStandalone: true,
+    },
+    [OPERATOR_NAME_SERVERLESS]: {
+      title: 'Serverless',
+      featureId: 'SERVERLESS',
+      Description: () => (
+        <>
+          Deploy workflow applications based on the CNCF Serverless Workflow specification.{' '}
+          <ExternalLink href={SERVERLESS_OPERATOR_LINK}>Learn more</ExternalLink>
+        </>
+      ),
+      notStandalone: true,
+    },
+    [OPERATOR_NAME_SERVICEMESH]: {
+      title: 'Service Mesh',
+      featureId: 'SERVICEMESH',
+      Description: ({ openshiftVersion }) => (
+        <>
+          Platform that provides behavioral insight and operational control over a service mesh.{' '}
+          <ExternalLink href={getServiceMeshLink(openshiftVersion)}>Learn more</ExternalLink>
+        </>
+      ),
+      notStandalone: true,
+    },
+    [OPERATOR_NAME_LVM]: {
+      title: useLVMS ? 'Logical Volume Manager Storage' : 'Logical Volume Manager',
+      featureId: 'LVM',
+      Description: ({ openshiftVersion }) =>
+        useLVMS ? (
+          <>
+            Storage virtualization that offers a more flexible approach for disk space management.{' '}
+            <ExternalLink href={getLvmsDocsLink(openshiftVersion)}>Learn more</ExternalLink>
+          </>
+        ) : (
+          <>
+            Storage virtualization that offers a more flexible approach for disk space management.
+          </>
+        ),
+    },
+  };
+};
+
+export const useOperatorSpecs = () => {
+  const { getFeatureSupportLevel } = useNewFeatureSupportLevel();
+  const useLVMS = getFeatureSupportLevel('LVM') === 'supported';
+  return React.useMemo(() => getOperatorSpecs(useLVMS), [useLVMS]);
+};

package/lib/common/config/constants.ts

@@ -8,13 +8,8 @@ import {
   HostValidationId,
 } from '@openshift-assisted/types/assisted-installer-service';
 import { ValidationGroup as ClusterValidationGroup } from '../types/clusters';
-import { FeatureSupportLevelData } from '../components/featureSupportLevels/FeatureSupportLevelContext';
-import type { NewFeatureSupportLevelData } from '../components/newFeatureSupportLevels';
 import buildManifest from '@openshift-assisted/ui-lib/package.json';
 
-// TODO(mlibra): Retrieve branding dynamically, if needed, i.e. via injecting to the "window" object
-export const getProductBrandingCode = () => 'redhat';
-
 export const POLLING_INTERVAL = 10 * 1000;
 export const EVENTS_POLLING_INTERVAL = 10 * 1000 * 6;
 
@@ -303,7 +298,6 @@ export const OPERATOR_NAME_CNV = 'cnv';
 export const OPERATOR_NAME_LSO = 'lso';
 export const OPERATOR_NAME_ODF = 'odf';
 export const OPERATOR_NAME_LVM = 'lvm';
-export const OPERATOR_NAME_LVMS = 'lvms';
 export const OPERATOR_NAME_MCE = 'mce';
 export const OPERATOR_NAME_MTV = 'mtv';
 export const OPERATOR_NAME_NODE_FEATURE_DISCOVERY = 'node-feature-discovery';
@@ -323,108 +317,20 @@ export const OPERATOR_NAME_FENCE_AGENTS_REMEDIATION = 'fence-agents-remediation'
 export const OPERATOR_NAME_NODE_MAINTENANCE = 'node-maintenance';
 export const OPERATOR_NAME_KUBE_DESCHEDULER = 'kube-descheduler';
 
-const OperatorNames = [
+export const singleClusterOperators = [
   OPERATOR_NAME_CNV,
-  OPERATOR_NAME_LSO,
-  OPERATOR_NAME_ODF,
-  OPERATOR_NAME_LVM,
-  OPERATOR_NAME_LVMS,
-  OPERATOR_NAME_MCE,
-  OPERATOR_NAME_MTV,
-  OPERATOR_NAME_NODE_FEATURE_DISCOVERY,
-  OPERATOR_NAME_NVIDIA_GPU,
-  OPERATOR_NAME_PIPELINES,
-  OPERATOR_NAME_SERVICEMESH,
-  OPERATOR_NAME_SERVERLESS,
-  OPERATOR_NAME_OPENSHIFT_AI,
-  OPERATOR_NAME_OSC,
-  OPERATOR_NAME_NMSTATE,
-  OPERATOR_NAME_AUTHORINO,
-  OPERATOR_NAME_AMD_GPU,
-  OPERATOR_NAME_KMM,
   OPERATOR_NAME_NODE_HEALTHCHECK,
-  OPERATOR_NAME_SELF_NODE_REMEDIATION,
   OPERATOR_NAME_FENCE_AGENTS_REMEDIATION,
   OPERATOR_NAME_NODE_MAINTENANCE,
-  OPERATOR_NAME_KUBE_DESCHEDULER,
-];
-export const ExposedOperatorNames = [
-  OPERATOR_NAME_CNV,
-  OPERATOR_NAME_ODF,
-  OPERATOR_NAME_LVM,
-  OPERATOR_NAME_LVMS,
-  OPERATOR_NAME_MCE,
   OPERATOR_NAME_MTV,
-  OPERATOR_NAME_NODE_FEATURE_DISCOVERY,
-  OPERATOR_NAME_NVIDIA_GPU,
-  OPERATOR_NAME_PIPELINES,
-  OPERATOR_NAME_SERVICEMESH,
-  OPERATOR_NAME_SERVERLESS,
-  OPERATOR_NAME_OPENSHIFT_AI,
-  OPERATOR_NAME_OSC,
+  OPERATOR_NAME_KUBE_DESCHEDULER,
   OPERATOR_NAME_NMSTATE,
-  OPERATOR_NAME_AUTHORINO,
-  OPERATOR_NAME_AMD_GPU,
-  OPERATOR_NAME_KMM,
-  OPERATOR_NAME_NODE_HEALTHCHECK,
   OPERATOR_NAME_SELF_NODE_REMEDIATION,
-  OPERATOR_NAME_FENCE_AGENTS_REMEDIATION,
-  OPERATOR_NAME_NODE_MAINTENANCE,
-  OPERATOR_NAME_KUBE_DESCHEDULER,
+  OPERATOR_NAME_ODF,
+  OPERATOR_NAME_LSO,
 ];
 
-export type OperatorName = (typeof OperatorNames)[number];
-export type ExposedOperatorName = (typeof ExposedOperatorNames)[number];
-
-export const operatorLabelsCim = (
-  t: TFunction,
-  openshiftVersion: Cluster['openshiftVersion'],
-  featureSupportLevel: FeatureSupportLevelData,
-): { [key in ExposedOperatorName]: string } => {
-  const useLVMS =
-    featureSupportLevel.getFeatureSupportLevel(openshiftVersion || '', 'LVM') === 'supported';
-
-  return {
-    [OPERATOR_NAME_ODF]: t('ai:OpenShift Data Foundation'),
-    [OPERATOR_NAME_CNV]: t('ai:OpenShift Virtualization'),
-    [OPERATOR_NAME_LVM]: useLVMS
-      ? t('ai:Logical Volume Manager Storage')
-      : t('ai:Logical Volume Manager'),
-  };
-};
-
-export const operatorLabels = (
-  t: TFunction,
-  featureSupportLevel: NewFeatureSupportLevelData,
-): { [key in ExposedOperatorName]: string } => {
-  const useLVMS = featureSupportLevel.getFeatureSupportLevel('LVM') === 'supported';
-
-  return {
-    [OPERATOR_NAME_ODF]: t('ai:OpenShift Data Foundation'),
-    [OPERATOR_NAME_CNV]: t('ai:OpenShift Virtualization'),
-    [OPERATOR_NAME_LVM]: useLVMS
-      ? t('ai:Logical Volume Manager Storage')
-      : t('ai:Logical Volume Manager'),
-    [OPERATOR_NAME_MCE]: t('ai:Multicluster engine'),
-    [OPERATOR_NAME_NODE_FEATURE_DISCOVERY]: t('ai:Node Feature Discovery'),
-    [OPERATOR_NAME_NVIDIA_GPU]: t('ai:NVIDIA GPU'),
-    [OPERATOR_NAME_PIPELINES]: t('ai:Pipelines'),
-    [OPERATOR_NAME_SERVICEMESH]: t('ai:Service Mesh'),
-    [OPERATOR_NAME_SERVERLESS]: t('ai:Serverless'),
-    [OPERATOR_NAME_OPENSHIFT_AI]: t('ai:OpenShift AI'),
-    [OPERATOR_NAME_OSC]: t('ai:OpenShift sandboxed containers'),
-    [OPERATOR_NAME_MTV]: t('ai:Migration Toolkit for Virtualization'),
-    [OPERATOR_NAME_NMSTATE]: t('ai:NMState'),
-    [OPERATOR_NAME_AUTHORINO]: t('ai:Authorino'),
-    [OPERATOR_NAME_AMD_GPU]: t('ai:AMD GPU'),
-    [OPERATOR_NAME_KMM]: t('ai:Kernel Module Management'),
-    [OPERATOR_NAME_NODE_HEALTHCHECK]: t('ai:Node Healthcheck'),
-    [OPERATOR_NAME_SELF_NODE_REMEDIATION]: t('ai:Self Node Remediation'),
-    [OPERATOR_NAME_FENCE_AGENTS_REMEDIATION]: t('ai:Fence Agents Remediation'),
-    [OPERATOR_NAME_NODE_MAINTENANCE]: t('ai:Node Maintenace'),
-    [OPERATOR_NAME_KUBE_DESCHEDULER]: t('ai:Kube Descheduler'),
-  };
-};
+export const singleClusterBundles = ['virtualization'];
 
 export const AI_UI_TAG = 'ui_ocm';
 

package/lib/common/selectors/clusterSelectors.ts

@@ -1,7 +1,6 @@
 import head from 'lodash-es/head.js';
 import { SupportedPlatformIntegrations, ValidationsInfo } from '../types';
 import { Cluster, Ip } from '@openshift-assisted/types/assisted-installer-service';
-import { ExposedOperatorName } from '../config';
 import { stringToJSON } from '../utils';
 
 export const selectMachineNetworkCIDR = ({
@@ -46,7 +45,7 @@ export const selectOlmOperators = (cluster?: Pick<Cluster, 'monitoredOperators'>
 
 export const hasEnabledOperators = (
   monitoredOperators: Cluster['monitoredOperators'],
-  searchOperator: ExposedOperatorName,
+  searchOperator: string,
 ) => {
   return selectMonitoredOperators(monitoredOperators).some(
     (operator) => operator.name && operator.name === searchOperator,

package/lib/common/types/clusters.ts

@@ -58,29 +58,9 @@ export type HostDiscoveryValues = V2ClusterUpdateParams & {
 export type StorageValues = V2ClusterUpdateParams & {
   nodeLabeling: string;
 };
-export type OperatorsValues = V2ClusterUpdateParams & {
-  useOpenShiftDataFoundation: boolean;
-  useOdfLogicalVolumeManager: boolean;
-  useContainerNativeVirtualization: boolean;
-  useMultiClusterEngine: boolean;
-  useMigrationToolkitforVirtualization: boolean;
-  useOpenShiftAI: boolean;
-  useOsc: boolean;
-  useNodeFeatureDiscovery: boolean;
-  useNmstate: boolean;
-  useLso: boolean;
-  useServerless: boolean;
-  useAuthorino: boolean;
-  usePipelines: boolean;
-  useServicemesh: boolean;
-  useNvidiaGpu: boolean;
-  useAmdGpu: boolean;
-  useKmm: boolean;
-  useNodeHealthcheck: boolean;
-  useSelfNodeRemediation: boolean;
-  useFenceAgentsRemediation: boolean;
-  useNodeMaintenance: boolean;
-  useKubeDescheduler: boolean;
+export type OperatorsValues = {
+  selectedBundles: string[];
+  selectedOperators: string[];
 };
 
 export type SupportedPlatformType = Extract<PlatformType, 'vsphere' | 'nutanix' | 'external'>;

package/lib/common/utils.ts

@@ -106,3 +106,8 @@ export const downloadFile = (fileUrl?: string, dataBlob?: Blob, fileName?: strin
   link.click();
   document.body.removeChild(link);
 };
+
+export const getMajorMinorVersion = (version = '') => {
+  const match = /[0-9].[0-9][0-9]?/g.exec(version);
+  return match?.[0] || '';
+};

package/lib/ocm/components/clusterConfiguration/DiscoveryImageModal.tsx

@@ -120,7 +120,7 @@ export const DiscoveryImageModal = () => {
           isSNO={isSNOCluster}
           onReset={onReset}
           onClose={close}
-          updateTagsForCiscoIntersight={() => updateTagsForCiscoIntersight(cluster)}
+          updateTagsForCiscoIntersight={() => void updateTagsForCiscoIntersight(cluster)}
         />
       ) : ipxeDownloadUrl ? (
         <DownloadIpxeScript

package/lib/ocm/components/clusterConfiguration/OcmClusterProgressItems.tsx

@@ -52,10 +52,7 @@ const OcmClusterProgressItems = ({
           </GridItem>
           <RenderIf condition={olmOperators.length > 0}>
             <GridItem span={3}>
-              <OcmOperatorsProgressItem
-                operators={olmOperators}
-                openshiftVersion={cluster.openshiftVersion}
-              />
+              <OcmOperatorsProgressItem operators={olmOperators} />
             </GridItem>
           </RenderIf>
         </Grid>

package/lib/ocm/components/clusterConfiguration/OcmOperatorProgressItem.tsx

@@ -12,14 +12,12 @@ import { TFunction } from 'i18next';
 import './OcmOperatorsProgressItem.css';
 import { useTranslation } from '../../../common/hooks/use-translation-wrapper';
 import ClusterProgressItem from '../../../common/components/clusterDetail/ClusterProgressItem';
-import { operatorLabels, OperatorName } from '../../../common';
-import { useNewFeatureSupportLevel } from '../../../common/components/newFeatureSupportLevels';
 import {
-  Cluster,
   MonitoredOperator,
   MonitoredOperatorsList,
   OperatorStatus,
 } from '@openshift-assisted/types/assisted-installer-service';
+import { useOperatorSpecs } from '../../../common/components/operators/operatorSpecs';
 
 export function getAggregatedStatus(operators: MonitoredOperatorsList) {
   const operatorStates: (OperatorStatus | 'pending')[] = operators.map(
@@ -74,7 +72,6 @@ export function getOperatorsIcon(status: OperatorStatus | 'pending') {
 
 type OperatorListProps = {
   operators: MonitoredOperatorsList;
-  openshiftVersion: Cluster['openshiftVersion'];
 };
 
 type OperatorsPopoverProps = OperatorListProps & {
@@ -83,7 +80,7 @@ type OperatorsPopoverProps = OperatorListProps & {
 
 const OperatorsPopover = ({ operators, children }: OperatorsPopoverProps) => {
   const { t } = useTranslation();
-  const featureSupportLevel = useNewFeatureSupportLevel();
+  const opSpecs = useOperatorSpecs();
 
   return (
     <Popover
@@ -95,9 +92,7 @@ const OperatorsPopover = ({ operators, children }: OperatorsPopoverProps) => {
             if (operator.status === 'available') {
               status = 'installed';
             }
-            const name =
-              operatorLabels(t, featureSupportLevel)[operator.name as OperatorName] ||
-              operator.name;
+            const name = opSpecs[operator.name as string]?.title || operator.name;
             return (
               <ListItem key={operator.name} title={operator.statusInfo}>
                 {name} {status}
@@ -114,14 +109,14 @@ const OperatorsPopover = ({ operators, children }: OperatorsPopoverProps) => {
   );
 };
 
-const OcmOperatorsProgressItem = ({ operators, openshiftVersion }: OperatorListProps) => {
+const OcmOperatorsProgressItem = ({ operators }: OperatorListProps) => {
   const { t } = useTranslation();
   const icon = getOperatorsIcon(getAggregatedStatus(operators));
   const label = getOperatorsLabel(operators, t);
   return (
     <ClusterProgressItem icon={icon}>
       <>
-        <OperatorsPopover operators={operators} openshiftVersion={openshiftVersion}>
+        <OperatorsPopover operators={operators}>
           <Button variant={ButtonVariant.link} isInline data-testid="operators-progress-item">
             {t('ai:Operators')}
           </Button>