@rancher/shell 3.0.8-rc.8 → 3.0.8

package/config/__test__/uiplugins.test.ts

@@ -0,0 +1,309 @@
+import {
+  UI_PLUGIN_ANNOTATION,
+  UI_PLUGIN_CHART_ANNOTATIONS,
+  EXTENSIONS_INCOMPATIBILITY_TYPES,
+  isUIPlugin,
+  uiPluginHasAnnotation,
+  parseRancherVersion,
+  // shouldNotLoadPlugin, this is required per test so that we can mock semver.coerce
+  isSupportedChartVersion,
+  isChartVersionHigher
+} from '@shell/config/uiplugins';
+
+import * as VersionModule from '@shell/config/version';
+
+let semver;
+let originalCoerce: any;
+const MOCK_API_VERSION = '33.33.33';
+
+describe('uiPlugins Config methods', () => {
+  describe('fx: isUIPlugin', () => {
+    const pluginChart = { versions: [{ annotations: { [UI_PLUGIN_ANNOTATION.NAME]: UI_PLUGIN_ANNOTATION.VALUE } }, { annotations: {} }] };
+
+    it('should return true if any version has the UI plugin annotation', () => {
+      expect(isUIPlugin(pluginChart)).toBe(true);
+    });
+    it('should return false if chart is null/undefined', () => {
+      expect(isUIPlugin(null)).toBe(false);
+    });
+  });
+
+  describe('fx: uiPluginHasAnnotation', () => {
+    const version1 = { annotations: { [UI_PLUGIN_ANNOTATION.NAME]: UI_PLUGIN_ANNOTATION.VALUE } };
+    const chart = { versions: [version1] };
+
+    it('should return true if it finds version with annotation and its corresponding value', () => {
+      expect(uiPluginHasAnnotation(chart, UI_PLUGIN_ANNOTATION.NAME, UI_PLUGIN_ANNOTATION.VALUE)).toBe(true);
+    });
+    it('should return false if chart has no version with a given pair of annotation/value', () => {
+      expect(uiPluginHasAnnotation(chart, 'bananas', UI_PLUGIN_ANNOTATION.VALUE)).toBe(false);
+    });
+  });
+
+  describe('fx: parseRancherVersion', () => {
+    it('should handle standard version strings', () => {
+      expect(parseRancherVersion('v2.8.1')).toBe('2.8.1');
+    });
+    it('should apply .999 patch for RC versions', () => {
+      expect(parseRancherVersion('v2.8.1-rc1')).toBe('2.8.999');
+    });
+    it('should apply .999 patch for "head" versions', () => {
+      expect(parseRancherVersion('2.8.0-head')).toBe('2.8.999');
+    });
+  });
+
+  const PLUGIN_NAME = 'test-plugin';
+
+  const basePluginResource = {
+    name:     PLUGIN_NAME,
+    version:  '1.0.0',
+    endpoint: '/some/path',
+    metadata: { [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=1.0.0' }
+  };
+  const compatibleEnv = {
+    rancherVersion: '2.7.5',
+    kubeVersion:    'v1.25.10',
+  };
+
+  describe('fx: shouldNotLoadPlugin', () => {
+    beforeEach(() => {
+      jest.resetModules();
+      process.env.UI_EXTENSIONS_API_VERSION = MOCK_API_VERSION;
+
+      semver = require('semver');
+      originalCoerce = semver.coerce;
+
+      jest.spyOn(semver, 'coerce').mockImplementation((v) => {
+        if (v === MOCK_API_VERSION) {
+          return { version: '3.0.0' };
+        }
+
+        // Use the original for all other inputs (Rancher, Kube)
+        return originalCoerce(v);
+      });
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('should return false when compatible', () => {
+      const { shouldNotLoadPlugin } = require('./../uiplugins');
+
+      expect(shouldNotLoadPlugin(basePluginResource, compatibleEnv, [])).toBe(false);
+    });
+
+    it('should return "plugins.error.api" if Extensions API version is incompatible', () => {
+      const { shouldNotLoadPlugin } = require('./../uiplugins');
+
+      const incompatibleApiPlugin = {
+        ...basePluginResource,
+        metadata: { [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=4.0.0' }
+      };
+
+      expect(shouldNotLoadPlugin(incompatibleApiPlugin, compatibleEnv, [])).toBe('plugins.error.api');
+    });
+
+    it('should return "plugins.error.primeOnly" if extension is Prime-only and Rancher is not Prime', () => {
+      const { shouldNotLoadPlugin } = require('./../uiplugins');
+
+      jest.spyOn(VersionModule, 'isRancherPrime').mockReturnValue(false);
+
+      const incompatibleApiPlugin = {
+        ...basePluginResource,
+        metadata: {
+          [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=1.0.0',
+          [UI_PLUGIN_CHART_ANNOTATIONS.PRIME_ONLY]:         'true'
+        }
+      };
+
+      expect(shouldNotLoadPlugin(incompatibleApiPlugin, compatibleEnv, [])).toBe('plugins.error.primeOnly');
+    });
+
+    it('should return "plugins.error.host" if HOST application value is incompatible', () => {
+      const { shouldNotLoadPlugin } = require('./../uiplugins');
+
+      const incompatibleApiPlugin = {
+        ...basePluginResource,
+        metadata: {
+          [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=1.0.0',
+          [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_HOST]:    'rancher-dummy-host'
+        }
+      };
+
+      expect(shouldNotLoadPlugin(incompatibleApiPlugin, compatibleEnv, [])).toBe('plugins.error.host');
+    });
+
+    it('should return "plugins.error.kubeVersion" if incompatible', () => {
+      const { shouldNotLoadPlugin } = require('./../uiplugins');
+
+      const incompatibleApiPlugin = {
+        ...basePluginResource,
+        metadata: {
+          [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=1.0.0',
+          [UI_PLUGIN_CHART_ANNOTATIONS.KUBE_VERSION]:       '>= 2.0.0'
+        }
+      };
+
+      expect(shouldNotLoadPlugin(incompatibleApiPlugin, compatibleEnv, [])).toBe('plugins.error.kubeVersion');
+    });
+
+    it('should return "plugins.error.version" if incompatible', () => {
+      const { shouldNotLoadPlugin } = require('./../uiplugins');
+
+      const incompatibleApiPlugin = {
+        ...basePluginResource,
+        metadata: {
+          [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=1.0.0',
+          [UI_PLUGIN_CHART_ANNOTATIONS.RANCHER_VERSION]:    '>= 3.0.0'
+        }
+      };
+
+      expect(shouldNotLoadPlugin(incompatibleApiPlugin, compatibleEnv, [])).toBe('plugins.error.version');
+    });
+
+    it('should return "plugins.error.developerPkg" if a builtin extension with the same name was loaded first', () => {
+      const { shouldNotLoadPlugin } = require('./../uiplugins');
+
+      const incompatibleApiPlugin = {
+        ...basePluginResource,
+        metadata: { [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=1.0.0' }
+      };
+
+      expect(shouldNotLoadPlugin(incompatibleApiPlugin, compatibleEnv, [{ name: PLUGIN_NAME, builtin: true }])).toBe('plugins.error.developerPkg');
+    });
+  });
+
+  describe('fx: isSupportedChartVersion', () => {
+    beforeEach(() => {
+      jest.resetModules();
+      process.env.UI_EXTENSIONS_API_VERSION = MOCK_API_VERSION;
+
+      semver = require('semver');
+      originalCoerce = semver.coerce;
+
+      jest.spyOn(semver, 'coerce').mockImplementation((v) => {
+        if (v === MOCK_API_VERSION) {
+          return { version: '3.0.0' };
+        }
+
+        // Use the original for all other inputs (Rancher, Kube)
+        return originalCoerce(v);
+      });
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    const versionData = {
+      rancherVersion: 'v2.7.5',
+      kubeVersion:    'v1.25.10',
+      version:        '1.0.0'
+    };
+
+    it('should return "isVersionCompatible" true when compatible', () => {
+      const { isSupportedChartVersion } = require('./../uiplugins');
+
+      const annotations = {
+        [UI_PLUGIN_CHART_ANNOTATIONS.KUBE_VERSION]:       '>=1.0.0',
+        [UI_PLUGIN_CHART_ANNOTATIONS.RANCHER_VERSION]:    '>=2.0.0',
+        [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=2.0.0'
+      };
+      const data = { ...versionData, version: { annotations } };
+      const result = isSupportedChartVersion(data, true);
+
+      expect(result.isVersionCompatible).toBe(true);
+      expect(result.versionIncompatibilityData).toStrictEqual({});
+    });
+
+    it('should return incompatibility object for kube version mismatch', () => {
+      const annotations = { [UI_PLUGIN_CHART_ANNOTATIONS.KUBE_VERSION]: '>=2.0.0' };
+      const data = { ...versionData, version: { annotations } };
+      const result = isSupportedChartVersion(data, true);
+
+      expect(result.isVersionCompatible).toBe(false);
+      expect(result.versionIncompatibilityData.type).toBe(EXTENSIONS_INCOMPATIBILITY_TYPES.KUBE);
+      expect(result.versionIncompatibilityData.required).toBe('>=2.0.0');
+    });
+
+    it('should return incompatibility object for Rancher version mismatch', () => {
+      const annotations = { [UI_PLUGIN_CHART_ANNOTATIONS.RANCHER_VERSION]: '>=3.0.0' };
+      const data = { ...versionData, version: { annotations } };
+      const result = isSupportedChartVersion(data, true);
+
+      expect(result.isVersionCompatible).toBe(false);
+      expect(result.versionIncompatibilityData.type).toBe(EXTENSIONS_INCOMPATIBILITY_TYPES.UI);
+      expect(result.versionIncompatibilityData.required).toBe('>=3.0.0');
+    });
+
+    it('should return incompatibility object for UI version mismatch', () => {
+      const annotations = { [UI_PLUGIN_CHART_ANNOTATIONS.UI_VERSION]: '>=3.0.0' };
+      const data = { ...versionData, version: { annotations } };
+      const result = isSupportedChartVersion(data, true);
+
+      expect(result.isVersionCompatible).toBe(false);
+      expect(result.versionIncompatibilityData.type).toBe(EXTENSIONS_INCOMPATIBILITY_TYPES.UI);
+      expect(result.versionIncompatibilityData.required).toBe('>=3.0.0');
+    });
+
+    it('should return incompatibility object for extensions api missing', () => {
+      const annotations = {};
+      const data = { ...versionData, version: { annotations } };
+      const result = isSupportedChartVersion(data, true);
+
+      expect(result.isVersionCompatible).toBe(false);
+      expect(result.versionIncompatibilityData.type).toBe(EXTENSIONS_INCOMPATIBILITY_TYPES.EXTENSIONS_API_MISSING);
+      expect(result.versionIncompatibilityData.required).toBeUndefined();
+    });
+
+    it('should return incompatibility object for extensions API version mismatch', () => {
+      const { isSupportedChartVersion } = require('./../uiplugins');
+
+      const annotations = { [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=4.0.0' };
+      const data = { ...versionData, version: { annotations } };
+      const result = isSupportedChartVersion(data, true);
+
+      expect(result.isVersionCompatible).toBe(false);
+      expect(result.versionIncompatibilityData.type).toBe(EXTENSIONS_INCOMPATIBILITY_TYPES.EXTENSIONS_API);
+      expect(result.versionIncompatibilityData.required).toBe('>=4.0.0');
+    });
+
+    it('should return incompatibility object for HOST_APP mismatch', () => {
+      const { isSupportedChartVersion } = require('./../uiplugins');
+
+      const annotations = { [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=1.0.0 < 5.0.0', [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_HOST]: 'rancher-dummy-host' };
+      const data = { ...versionData, version: { annotations } };
+      const result = isSupportedChartVersion(data, true);
+
+      expect(result.isVersionCompatible).toBe(false);
+      expect(result.versionIncompatibilityData.type).toBe(EXTENSIONS_INCOMPATIBILITY_TYPES.HOST);
+      expect(result.versionIncompatibilityData.required).toBe('rancher-dummy-host');
+    });
+
+    it('should return incompatibility object for Prime only extension running in non-prime env', () => {
+      const { isSupportedChartVersion } = require('./../uiplugins');
+
+      jest.spyOn(VersionModule, 'isRancherPrime').mockReturnValue(false);
+
+      const annotations = { [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=1.0.0 < 5.0.0', [UI_PLUGIN_CHART_ANNOTATIONS.PRIME_ONLY]: 'true' };
+      const data = { ...versionData, version: { annotations } };
+      const result = isSupportedChartVersion(data, true);
+
+      expect(result.isVersionCompatible).toBe(false);
+      expect(result.versionIncompatibilityData.type).toBe(EXTENSIONS_INCOMPATIBILITY_TYPES.PRIME_ONLY);
+      expect(result.versionIncompatibilityData.required).toBe(true);
+    });
+  });
+
+  describe('fx: isChartVersionHigher', () => {
+    // Tests now rely on the actual semver.gt implementation
+    it('should return true when version A is higher', () => {
+      expect(isChartVersionHigher('2.1.0', '2.0.0')).toBe(true);
+    });
+    it('should return false when version A is lower or equal', () => {
+      expect(isChartVersionHigher('2.0.0', '2.1.0')).toBe(false);
+      expect(isChartVersionHigher('2.0.0', '2.0.0')).toBe(false);
+    });
+  });
+});

package/config/labels-annotations.js

@@ -85,6 +85,7 @@ export const CATALOG = {
   _PARTNER:  'partner',
   _OTHER:    'other',
 
+  PRIME_ONLY:   'catalog.cattle.io/prime-only',
   EXPERIMENTAL: 'catalog.cattle.io/experimental',
   NAMESPACE:    'catalog.cattle.io/namespace',
   RELEASE_NAME: 'catalog.cattle.io/release-name',

package/config/product/explorer.js

@@ -180,7 +180,8 @@ export function init(store) {
   mapGroup(/^(.*\.)?(scc)\.cattle\.io$/, 'SCC');
 
   const dePaginateBindings = configureConditionalDepaginate({ maxResourceCount: 5000 });
-  const dePaginateNormanBindings = configureConditionalDepaginate({ maxResourceCount: 5000, isNorman: true }) ;
+  const dePaginateNormanBindings = configureConditionalDepaginate({ maxResourceCount: 5000, isNorman: true });
+  const dePaginateNormanUsers = configureConditionalDepaginate({ maxResourceCount: 5000, isNorman: true });
 
   configureType(NODE, { isCreatable: false, isEditable: true });
   configureType(WORKLOAD_TYPES.JOB, { isEditable: false, match: WORKLOAD_TYPES.JOB });
@@ -189,6 +190,7 @@ export function init(store) {
   configureType(MANAGEMENT.PROJECT, { displayName: store.getters['i18n/t']('namespace.project.label') });
   configureType(NORMAN.CLUSTER_ROLE_TEMPLATE_BINDING, { depaginate: dePaginateNormanBindings });
   configureType(NORMAN.PROJECT_ROLE_TEMPLATE_BINDING, { depaginate: dePaginateNormanBindings });
+  configureType(NORMAN.USER, { depaginate: dePaginateNormanUsers });
   configureType(SNAPSHOT, { depaginate: true });
 
   configureType(SECRET, { showListMasthead: false });

package/config/product/fleet.js

@@ -34,7 +34,7 @@ export function init(store) {
     showWorkspaceSwitcher: true,
     to:                    {
       name:   'c-cluster-fleet',
-      params: { resource: FLEET.DASHBOARD, cluster: BLANK_CLUSTER }
+      params: { cluster: BLANK_CLUSTER }
     },
   });
 

package/config/router/navigation-guards/clusters.js

@@ -30,12 +30,12 @@ export async function loadClusters(to, from, next, { store }) {
     const oldPkg = getPackageFromRoute(from);
     const oldProduct = getProductFromRoute(from);
 
-    // TODO: Replace all references to store.$plugin.
+    // TODO: Replace all references to store.$extension.
     //       Unfortunately the initialization code has circular dependencies between creating
     //       the router and creating the store that will need to be untangled before this can be tackled.
 
     // Leave an old pkg where we weren't before?
-    const oldPkgPlugin = oldPkg ? Object.values(store.$plugin.getPlugins()).find((p) => p.name === oldPkg) : null;
+    const oldPkgPlugin = oldPkg ? Object.values(store.$extension.getPlugins()).find((p) => p.name === oldPkg) : null;
 
     if (oldPkg && oldPkg !== pkg ) {
       // Execute anything optional the plugin wants to. For example resetting it's store to remove data
@@ -53,7 +53,7 @@ export async function loadClusters(to, from, next, { store }) {
     ];
 
     // Entering a new package where we weren't before?
-    const newPkgPlugin = pkg ? Object.values(store.$plugin.getPlugins()).find((p) => p.name === pkg) : null;
+    const newPkgPlugin = pkg ? Object.values(store.$extension.getPlugins()).find((p) => p.name === pkg) : null;
 
     // Note - We can't block on oldPkg !== newPkg because on a fresh load the `from` route equals the `to` route
     if (pkg && (oldPkg !== pkg || from.fullPath === to.fullPath)) {

package/config/router/navigation-guards/products.js

@@ -9,7 +9,7 @@ export async function loadProducts(to, from, next, { store }) {
   // GC should be notified of route change before any find/get request is made that might be used for that page
   store.dispatch('gcRouteChanged', to);
 
-  await applyProducts(store, store.$plugin);
+  await applyProducts(store, store.$extension);
   setProduct(store, to);
   next();
 }

package/config/router/routes.js

@@ -1,5 +1,4 @@
 import { NAME as APPS } from '@shell/config/product/apps';
-import { NAME as EXPLORER } from '@shell/config/product/explorer';
 import { NAME as MANAGER } from '@shell/config/product/manager';
 import {
   CAPI, MANAGEMENT, BACKUP_RESTORE, COMPLIANCE, VIRTUAL_TYPES
@@ -81,9 +80,13 @@ export default [
       {
         path:      '/c/:cluster/uiplugins',
         name:      'c-cluster-uiplugins',
-        component: () => interopDefault(import('@shell/pages/c/_cluster/uiplugins/index.vue')),
+        component: () => interopDefault(import('@shell/pages/c/_cluster/uiplugins/index.vue'))
+      },
+      {
+        path:      '/c/:cluster/uiplugins/catalogs',
+        component: () => interopDefault(import('@shell/pages/c/_cluster/uiplugins/catalogs.vue')),
+        name:      'c-cluster-uiplugins-catalogs'
       },
-
       {
         path:      '/diagnostic',
         component: () => interopDefault(import('@shell/pages/diagnostic.vue')),
@@ -180,10 +183,7 @@ export default [
         redirect(to) {
           return {
             name:   'c-cluster-explorer',
-            params: {
-              ...(to?.params || {}),
-              product: EXPLORER,
-            }
+            params: { ...(to?.params || {}) }
           };
         }
       },

package/config/types.js

@@ -222,6 +222,13 @@ export const MANAGEMENT = {
   OIDC_CLIENT:                   'management.cattle.io.oidcclient'
 };
 
+export const BRAND = {
+  SUSE:    'suse',
+  CSP:     'csp',
+  FEDERAL: 'federal',
+  RGS:     'rgs',
+};
+
 export const EXT = { USER_ACTIVITY: 'ext.cattle.io.useractivity' };
 
 export const CAPI = {

package/config/uiplugins.js

@@ -1,4 +1,5 @@
 import semver from 'semver';
+import { isRancherPrime } from '@shell/config/version';
 
 // Version of the plugin API supported
 // here we inject the current shell version that we read in vue.config
@@ -43,6 +44,7 @@ export const UI_PLUGIN_CHART_ANNOTATIONS = {
   EXTENSIONS_HOST:    'catalog.cattle.io/ui-extensions-host',
   DISPLAY_NAME:       'catalog.cattle.io/display-name',
   HIDDEN_BUILTIN:     'catalog.cattle.io/ui-hidden-builtin',
+  PRIME_ONLY:         'catalog.cattle.io/prime-only'
 };
 
 // Extension catalog labels
@@ -58,6 +60,7 @@ export const EXTENSIONS_INCOMPATIBILITY_TYPES = {
   EXTENSIONS_API:         'extensionsApiVersion',
   KUBE:                   'kubeVersion',
   HOST:                   'host',
+  PRIME_ONLY:             'primeOnly',
 };
 
 export const EXTENSIONS_INCOMPATIBILITY_DATA = {
@@ -87,6 +90,11 @@ export const EXTENSIONS_INCOMPATIBILITY_DATA = {
     tooltipKey:     'plugins.info.requiresHost',
     mainHost:       UI_PLUGIN_HOST_APP,
   },
+  PRIME_ONLY: {
+    type:           EXTENSIONS_INCOMPATIBILITY_TYPES.PRIME_ONLY,
+    cardMessageKey: 'plugins.incompatiblePrimeOnly',
+    tooltipKey:     'plugins.info.requiresRancherPrime',
+  },
 };
 
 export function isUIPlugin(chart) {
@@ -124,10 +132,29 @@ export function parseRancherVersion(v) {
  * Check if a version is incompatible with the current environment
  */
 function checkIncompatibility(currentVersion, requiredVersion, incompatibilityData, returnObj, versionObj) {
-  if ((incompatibilityData.type === EXTENSIONS_INCOMPATIBILITY_TYPES.EXTENSIONS_API_MISSING && !requiredVersion) || (requiredVersion && !semver.satisfies(currentVersion, requiredVersion))) {
+  let passed = true;
+
+  switch (incompatibilityData.type) {
+  case EXTENSIONS_INCOMPATIBILITY_TYPES.PRIME_ONLY:
+    if (requiredVersion && !currentVersion) {
+      passed = false;
+    }
+    break;
+  case EXTENSIONS_INCOMPATIBILITY_TYPES.EXTENSIONS_API_MISSING:
+    !requiredVersion ? passed = false : passed = true;
+    break;
+  default:
+    if (requiredVersion && !semver.satisfies(currentVersion, requiredVersion)) {
+      passed = false;
+    }
+    break;
+  }
+
+  if (!passed) {
     if (!returnObj) {
       return false;
     }
+
     versionObj.isVersionCompatible = false;
     versionObj.versionIncompatibilityData = { ...incompatibilityData, required: requiredVersion };
 
@@ -137,7 +164,7 @@ function checkIncompatibility(currentVersion, requiredVersion, incompatibilityDa
   return true;
 }
 
-// i18n-uses plugins.error.generic, plugins.error.api, plugins.error.host, plugins.error.kubeVersion, plugins.error.version, plugins.error.developerPkg, plugins.error.apiAnnotationMissing
+// i18n-uses plugins.error.generic, plugins.error.api, plugins.error.host, plugins.error.kubeVersion, plugins.error.version, plugins.error.developerPkg, plugins.error.apiAnnotationMissing, plugins.error.primeOnly
 
 /**
  * Whether an extension should be loaded based on the metadata returned by the backend in the UIPlugins resource instance
@@ -148,6 +175,8 @@ function checkIncompatibility(currentVersion, requiredVersion, incompatibilityDa
  * @returns String | Boolean
  */
 export function shouldNotLoadPlugin(UIPluginResource, { rancherVersion, kubeVersion }, loadedPlugins) {
+  const isCurrRancherPrime = isRancherPrime();
+
   const {
     name, version, endpoint, compressedEndpoint
   } = UIPluginResource;
@@ -171,6 +200,13 @@ export function shouldNotLoadPlugin(UIPluginResource, { rancherVersion, kubeVers
     return 'plugins.error.api';
   }
 
+  // Prime only
+  const primeOnlyAnnotation = UIPluginResource.metadata?.[UI_PLUGIN_CHART_ANNOTATIONS.PRIME_ONLY] === 'true';
+
+  if (!isCurrRancherPrime && primeOnlyAnnotation) {
+    return 'plugins.error.primeOnly';
+  }
+
   // Host application
   const requiredHost = UIPluginResource.metadata?.[UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_HOST];
 
@@ -220,10 +256,13 @@ export function shouldNotLoadPlugin(UIPluginResource, { rancherVersion, kubeVers
  * @returns Boolean | Object
  */
 export function isSupportedChartVersion(versionData, returnObj = false) {
+  const isCurrRancherPrime = isRancherPrime();
+
   const { version, rancherVersion, kubeVersion } = versionData;
   const versionObj = {
     ...version, isVersionCompatible: true, versionIncompatibilityData: {}
   };
+
   const parsedRancherVersion = rancherVersion ? parseRancherVersion(rancherVersion) : '';
   const parsedUiExtensionsApiVersion = semver.coerce(UI_EXTENSIONS_API_VERSION)?.version;
 
@@ -258,6 +297,11 @@ export function isSupportedChartVersion(versionData, returnObj = false) {
       requiredVersion:     version.annotations?.[UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_HOST],
       incompatibilityData: EXTENSIONS_INCOMPATIBILITY_DATA.HOST,
     },
+    {
+      currentVersion:      isCurrRancherPrime,
+      requiredVersion:     version.annotations?.[UI_PLUGIN_CHART_ANNOTATIONS.PRIME_ONLY] === 'true',
+      incompatibilityData: EXTENSIONS_INCOMPATIBILITY_DATA.PRIME_ONLY,
+    }
   ];
 
   for (const { currentVersion, requiredVersion, incompatibilityData } of checks) {