@rancher/shell 3.0.8-rc.1 → 3.0.8-rc.12

package/config/product/manager.js

@@ -6,12 +6,12 @@ import {
   HCI,
   MANAGEMENT,
   SNAPSHOT,
-  VIRTUAL_TYPES
+  VIRTUAL_TYPES,
+  HOSTED_PROVIDER
 } from '@shell/config/types';
 import { MULTI_CLUSTER } from '@shell/store/features';
 import { DSL } from '@shell/store/type-map';
 import { BLANK_CLUSTER } from '@shell/store/store-types.js';
-
 export const NAME = 'manager';
 
 export function init(store) {
@@ -63,7 +63,7 @@ export function init(store) {
   basicType([
     CAPI.RANCHER_CLUSTER,
     'cloud-credentials',
-    'drivers',
+    'providers',
   ]);
 
   configureType(SNAPSHOT, { depaginate: true });
@@ -73,12 +73,22 @@ export function init(store) {
   });
   weightType(CAPI.RANCHER_CLUSTER, 100, true);
   weightType('cloud-credentials', 99, true);
-  weightType('drivers', 98, true);
+  weightType('providers', 98, true);
   weightType(CATALOG.CLUSTER_REPO, 97, true);
+  virtualType({
+    labelKey:   'providers.hosted.title',
+    name:       HOSTED_PROVIDER,
+    group:      'Root',
+    weight:     1,
+    namespaced: false,
+    icon:       'globe',
+    route:      { name: 'c-cluster-manager-hostedprovider' },
+    exact:      true
+  });
 
   virtualType({
     labelKey:   'drivers.kontainer.title',
-    name:       'rke-kontainer-drivers',
+    name:       'rke-kontainer-providers',
     group:      'Root',
     namespaced: false,
     icon:       'globe',
@@ -87,7 +97,7 @@ export function init(store) {
   });
   virtualType({
     labelKey:   'drivers.node.title',
-    name:       'rke-node-drivers',
+    name:       'rke-node-providers',
     group:      'Root',
     namespaced: false,
     icon:       'globe',
@@ -107,9 +117,10 @@ export function init(store) {
   });
 
   basicType([
-    'rke-kontainer-drivers',
-    'rke-node-drivers',
-  ], 'drivers');
+    HOSTED_PROVIDER,
+    'rke-kontainer-providers',
+    'rke-node-providers',
+  ], 'providers');
 
   weightType(CAPI.MACHINE_DEPLOYMENT, 4, true);
   weightType(CAPI.MACHINE_SET, 3, true);

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

@@ -81,9 +81,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')),
@@ -363,6 +367,10 @@ export default [
         path:      '/c/:cluster/manager/nodeDriver',
         component: () => interopDefault(import('@shell/pages/c/_cluster/manager/drivers/nodeDriver/index.vue')),
         name:      'c-cluster-manager-driver-nodedriver'
+      }, {
+        path:      '/c/:cluster/manager/hostedprovider',
+        component: () => interopDefault(import('@shell/pages/c/_cluster/manager/hostedprovider/index.vue')),
+        name:      'c-cluster-manager-hostedprovider'
       }, {
         path:      '/c/:cluster/monitoring/alertmanagerconfig',
         component: () => interopDefault(import('@shell/pages/c/_cluster/monitoring/alertmanagerconfig/index.vue')),

package/config/settings.ts

@@ -111,6 +111,7 @@ export const SETTING = {
   IMPORTED_CLUSTER_VERSION_MANAGEMENT:           'imported-cluster-version-management',
   CLUSTER_AGENT_DEFAULT_PRIORITY_CLASS:          'cluster-agent-default-priority-class',
   CLUSTER_AGENT_DEFAULT_POD_DISTRIBUTION_BUDGET: 'cluster-agent-default-pod-disruption-budget',
+  KEV2_OPERATORS:                                'kev2-operators',
   /**
    * Dynamic Content settings
    */
@@ -193,7 +194,7 @@ export const PROVISIONING_SETTINGS = [
   SETTING.K3S_UPGRADER_UNINSTALL_CONCURRENCY,
   SETTING.IMPORTED_CLUSTER_VERSION_MANAGEMENT,
   SETTING.CLUSTER_AGENT_DEFAULT_PRIORITY_CLASS,
-  SETTING.CLUSTER_AGENT_DEFAULT_POD_DISTRIBUTION_BUDGET
+  SETTING.CLUSTER_AGENT_DEFAULT_POD_DISTRIBUTION_BUDGET,
 ];
 
 /**

package/config/store.js

@@ -35,11 +35,12 @@ let store = {};
   resolveStoreModules(require('../store/slideInPanel.ts'), 'slideInPanel.ts');
   resolveStoreModules(require('../store/type-map.js'), 'type-map.js');
   resolveStoreModules(require('../store/uiplugins.ts'), 'uiplugins.ts');
-  resolveStoreModules(require('../store/wm.js'), 'wm.js');
+  resolveStoreModules(require('../store/wm.ts'), 'wm.ts');
   resolveStoreModules(require('../store/customisation.js'), 'customisation.js');
   resolveStoreModules(require('../store/cru-resource.ts'), 'cru-resource.ts');
   resolveStoreModules(require('../store/notifications.ts'), 'notifications.ts');
   resolveStoreModules(require('../store/cookies.ts'), 'cookies.ts');
+  resolveStoreModules(require('../store/ui-context.ts'), 'ui-context.ts');
 
   // If the environment supports hot reloading...
 
@@ -66,11 +67,12 @@ let store = {};
       '../store/slideInPanel.ts',
       '../store/type-map.js',
       '../store/uiplugins.ts',
-      '../store/wm.js',
+      '../store/wm.ts',
       '../store/customisation.js',
       '../store/cru-resource.ts',
       '../store/notifications.ts',
       '../store/cookies.ts',
+      '../store/ui-context.ts',
     ], () => {
       // Update `root.modules` with the latest definitions.
       updateModules();

package/config/table-headers.js

@@ -1183,3 +1183,11 @@ export const PROJECT = {
   name:     'project',
   labelKey: 'tableHeaders.project',
 };
+
+export const AUTOSCALER_ENABLED = {
+  name:      'autoscaler',
+  labelKey:  'tableHeaders.autoscaler',
+  value:     'isAutoscalerEnabled',
+  sort:      ['autoscaler'],
+  formatter: 'Autoscaler',
+};

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 = {
@@ -364,3 +371,5 @@ export const DEFAULT_GRAFANA_STORAGE_SIZE = '10Gi';
 
 export const DEPRECATED = 'Deprecated';
 export const EXPERIMENTAL = 'Experimental';
+export const AUTOSCALER_CONFIG_MAP_ID = 'kube-system/cluster-autoscaler-status';
+export const HOSTED_PROVIDER = 'hostedprovider';

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) {

package/config/version.js

@@ -30,4 +30,4 @@ export function setKubeVersionData(v) {
   _kubeVersionData = JSON.parse(JSON.stringify(v));
 }
 
-export const CURRENT_RANCHER_VERSION = '2.12';
+export const CURRENT_RANCHER_VERSION = '2.13';

package/core/__test__/extension-manager-impl.test.js

@@ -0,0 +1,236 @@
+import { DEVELOPER_LOAD_NAME_SUFFIX } from '@shell/core/extension-manager-impl';
+
+// Mock external dependencies
+jest.mock('@shell/store/type-map', () => ({ productsLoaded: jest.fn().mockReturnValue(true) }));
+
+jest.mock('@shell/plugins/dashboard-store/model-loader', () => ({ clearModelCache: jest.fn() }));
+
+jest.mock('@shell/config/uiplugins', () => ({ UI_PLUGIN_BASE_URL: '/api/v1/uiplugins' }));
+
+jest.mock('@shell/plugins/clean-html', () => ({
+  addLinkInterceptor:    jest.fn(),
+  removeLinkInterceptor: jest.fn(),
+}));
+
+// Mock the Plugin class
+jest.mock('@shell/core/plugin', () => {
+  return {
+    Plugin: jest.fn().mockImplementation((id) => ({
+      id,
+      name:            id,
+      types:           {},
+      uiConfig:        {},
+      l10n:            {},
+      modelExtensions: {},
+      stores:          [],
+      locales:         [],
+      routes:          [],
+      validators:      {},
+      uninstallHooks:  [],
+      productNames:    [],
+    })),
+    EXT_IDS: {
+      MODELS:          'models',
+      MODEL_EXTENSION: 'model-extension'
+    },
+    ExtensionPoint: { EDIT_YAML: 'edit-yaml' }
+  };
+});
+
+// Mock PluginRoutes
+jest.mock('@shell/core/plugin-routes', () => {
+  return { PluginRoutes: jest.fn().mockImplementation(() => ({ addRoutes: jest.fn() })) };
+});
+
+describe('extension Manager', () => {
+  let mockStore;
+  let mockApp;
+  let context;
+
+  // These variables will be assigned the fresh functions inside beforeEach
+  let initExtensionManager;
+  let getExtensionManager;
+
+  beforeEach(() => {
+    // singleton instance for every test run, preventing mock store leaks.
+    jest.resetModules();
+
+    // Re-require the System Under Test (SUT)
+    const extensionManagerModule = require('../extension-manager-impl');
+
+    initExtensionManager = extensionManagerModule.initExtensionManager;
+    getExtensionManager = extensionManagerModule.getExtensionManager;
+
+    jest.clearAllMocks();
+
+    // Setup Mock Context
+    mockStore = {
+      getters:  { 'i18n/t': jest.fn() },
+      dispatch: jest.fn(),
+      commit:   jest.fn(),
+    };
+
+    mockApp = { router: {} };
+
+    context = {
+      app:      mockApp,
+      store:    mockStore,
+      $axios:   {},
+      redirect: jest.fn(),
+    };
+
+    // Clean up DOM from previous tests
+    document.head.innerHTML = '';
+  });
+
+  describe('singleton Pattern', () => {
+    it('initializes and returns the same instance', () => {
+      const instance1 = initExtensionManager(context);
+      const instance2 = getExtensionManager();
+      const instance3 = initExtensionManager(context);
+
+      expect(instance1).toBeDefined();
+      expect(instance1).toBe(instance2);
+      expect(instance1).toBe(instance3);
+    });
+  });
+
+  describe('registration (Dynamic)', () => {
+    it('registers and retrieves a dynamic component', () => {
+      const manager = initExtensionManager(context);
+      const mockFn = jest.fn();
+
+      manager.register('component', 'my-component', mockFn);
+
+      const retrieved = manager.getDynamic('component', 'my-component');
+
+      expect(retrieved).toBe(mockFn);
+    });
+
+    it('unregisters a dynamic component', () => {
+      const manager = initExtensionManager(context);
+      const mockFn = jest.fn();
+
+      manager.register('component', 'my-component', mockFn);
+      manager.unregister('component', 'my-component');
+
+      const retrieved = manager.getDynamic('component', 'my-component');
+
+      expect(retrieved).toBeUndefined();
+    });
+  });
+
+  describe('loadPluginAsync (URL Generation)', () => {
+    let manager;
+
+    beforeEach(() => {
+      manager = initExtensionManager(context);
+      // Mock the internal loadAsync so we only test URL generation here
+      jest.spyOn(manager, 'loadAsync').mockImplementation().mockResolvedValue();
+    });
+
+    it('generates correct URL for standard plugin', async() => {
+      const pluginData = { name: 'elemental', version: '1.0.0' };
+      const expectedId = 'elemental-1.0.0';
+      const expectedUrl = `/api/v1/uiplugins/elemental/1.0.0/plugin/elemental-1.0.0.umd.min.js`;
+
+      await manager.loadPluginAsync(pluginData);
+
+      expect(manager.loadAsync).toHaveBeenCalledWith(expectedId, expectedUrl);
+    });
+
+    it('handles "direct" metadata plugins', async() => {
+      const pluginData = {
+        name:     'direct-plugin',
+        version:  '1.0.0',
+        endpoint: 'http://localhost:8000/plugin.js',
+        metadata: { direct: 'true' }
+      };
+
+      await manager.loadPluginAsync(pluginData);
+
+      expect(manager.loadAsync).toHaveBeenCalledWith('direct-plugin-1.0.0', 'http://localhost:8000/plugin.js');
+    });
+
+    it('removes developer suffix from ID but keeps it for internal logic', async() => {
+      const pluginData = {
+        name:    `my-plugin${ DEVELOPER_LOAD_NAME_SUFFIX }`,
+        version: `1.0.0`
+      };
+
+      await manager.loadPluginAsync(pluginData);
+
+      // Expected ID passed to loadAsync should NOT have the suffix
+      const expectedIdWithoutSuffix = 'my-plugin-1.0.0';
+
+      expect(manager.loadAsync).toHaveBeenCalledWith(
+        expectedIdWithoutSuffix,
+        expect.any(String)
+      );
+    });
+  });
+
+  describe('loadAsync (Script Injection)', () => {
+    let manager;
+
+    beforeEach(() => {
+      manager = initExtensionManager(context);
+    });
+
+    it('resolves immediately if element already exists', async() => {
+      const id = 'existing-plugin';
+      const script = document.createElement('script');
+
+      script.id = id;
+      document.body.appendChild(script);
+
+      await expect(manager.loadAsync(id, 'url.js')).resolves.toBeUndefined();
+
+      document.body.removeChild(script);
+    });
+
+    it('injects script tag and initializes plugin on load', async() => {
+      const pluginId = 'test-plugin';
+      const pluginUrl = 'http://test.com/plugin.js';
+
+      // Mock the window object to simulate the plugin loading into global scope
+      const mockPluginInit = jest.fn();
+
+      window[pluginId] = { default: mockPluginInit };
+
+      // Start the load
+      const loadPromise = manager.loadAsync(pluginId, pluginUrl);
+
+      // Find the injected script tag in the DOM
+      const script = document.head.querySelector(`script[id="${ pluginId }"]`);
+
+      expect(script).toBeTruthy();
+      expect(script.src).toBe(pluginUrl);
+
+      // Manually trigger the onload event
+      script.onload();
+
+      // Await the promise
+      await loadPromise;
+
+      // Assertions
+      expect(mockPluginInit).toHaveBeenCalledWith(expect.objectContaining({ id: pluginId }), expect.objectContaining({ ...context }));
+      expect(mockStore.dispatch).toHaveBeenCalledWith('uiplugins/addPlugin', expect.objectContaining({ id: pluginId }));
+
+      // Cleanup
+      delete window[pluginId];
+    });
+
+    it('rejects if script load fails', async() => {
+      const pluginId = 'fail-plugin';
+      const loadPromise = manager.loadAsync(pluginId, 'bad-url.js');
+
+      const script = document.head.querySelector(`script[id="${ pluginId }"]`);
+
+      // Trigger error
+      script.onerror({ target: { src: 'bad-url.js' } });
+
+      await expect(loadPromise).rejects.toThrow('Failed to load script');
+    });
+  });
+});

package/core/extension-manager-impl.js

@@ -6,6 +6,8 @@ import { UI_PLUGIN_BASE_URL } from '@shell/config/uiplugins';
 import { ExtensionPoint } from './types';
 import { addLinkInterceptor, removeLinkInterceptor } from '@shell/plugins/clean-html';
 
+export const DEVELOPER_LOAD_NAME_SUFFIX = '-developer-load';
+
 let extensionManagerInstance;
 
 const createExtensionManager = (context) => {
@@ -33,13 +35,13 @@ const createExtensionManager = (context) => {
   /**
    * When an extension adds a model extension, it provides the class - we will instantiate that class and store and use that
    */
-  function instantiateModelExtension($plugin, clz) {
+  function instantiateModelExtension($extension, clz) {
     const context = {
       dispatch: store.dispatch,
       getters:  store.getters,
       t:        store.getters['i18n/t'],
       $axios,
-      $plugin,
+      $extension,
     };
 
     return new clz(context);
@@ -63,9 +65,18 @@ const createExtensionManager = (context) => {
     // Load a plugin from a UI package
     loadPluginAsync(plugin) {
       const { name, version } = plugin;
-      const id = `${ name }-${ version }`;
+      let id = `${ name }-${ version }`;
       let url;
 
+      // for a developer load, we need to remove the suffix applied
+      // otherwise the extension won't load correctly
+      // but with this at least we won't hit developer loaded cards find charts
+      // when they aren't supposed to
+      if (id.includes(DEVELOPER_LOAD_NAME_SUFFIX)) {
+        id = id.replace(DEVELOPER_LOAD_NAME_SUFFIX, '');
+      }
+
+      // this is where a developer load hits (direct=true, developer=true)
       if (plugin?.metadata?.direct === 'true') {
         url = plugin.endpoint;
       } else {
@@ -455,7 +466,13 @@ const createExtensionManager = (context) => {
         try {
           const provisioner = context.$extension.getDynamic('provisioner', name);
 
-          return new provisioner({ ...context });
+          const defaults = {
+            isCreate: false,
+            isEdit:   false,
+            isView:   false
+          };
+
+          return new provisioner({ ...defaults, ...context });
         } catch (e) {
           console.error('Error loading provisioner(s) from extensions', e); // eslint-disable-line no-console
         }

package/core/plugin-helpers.ts

@@ -147,8 +147,8 @@ export function getApplicableExtensionEnhancements<T>(
   const extensionEnhancements: T[] = [];
 
   // gate it so that we prevent errors on older versions of dashboard
-  if (pluginCtx.$plugin?.getUIConfig) {
-    const actions = pluginCtx.$plugin.getUIConfig(actionType, uiArea);
+  if (pluginCtx.$extension?.getUIConfig) {
+    const actions = pluginCtx.$extension.getUIConfig(actionType, uiArea);
 
     actions.forEach((action: any, i: number) => {
       if (checkExtensionRouteBinding(currRoute, action.locationConfig, context || {})) {
@@ -195,6 +195,8 @@ export function getApplicableExtensionEnhancements<T>(
                 if (i < keyboardCombo.length - 1) {
                   if (key === 'meta') {
                     key = '\u2318';
+                  } else if (isMac && key === 'alt') {
+                    key = '⌥';
                   } else {
                     key = ucFirst(key);
                   }

package/core/plugins-loader.js

@@ -13,10 +13,10 @@ export default function({
   store,
   $axios,
   redirect,
-  $plugin,
+  $extension,
 }, inject) {
   if (dynamicLoader) {
-    dynamicLoader.default($plugin);
+    dynamicLoader.default($extension);
   }
 
   // The libraries we build have Vue externalised, so we need to expose Vue as a global for