@rancher/shell 3.0.12-rc.3 → 3.0.12-rc.5

package/list/harvesterhci.io.management.cluster.vue

@@ -8,6 +8,7 @@ import { HARVESTER_NAME as VIRTUAL } from '@shell/config/features';
 import { CAPI, HCI, MANAGEMENT } from '@shell/config/types';
 import { isHarvesterCluster } from '@shell/utils/cluster';
 import { allHash } from '@shell/utils/promise';
+import { RcButton } from '@components/RcButton';
 
 export default {
   components: {
@@ -15,7 +16,8 @@ export default {
     ResourceTable,
     Masthead,
     TypeDescription,
-    Loading
+    Loading,
+    RcButton,
   },
 
   props: {
@@ -128,12 +130,12 @@ export default {
         v-if="canCreateCluster"
         slot="extraActions"
       >
-        <n-link
+        <rc-button
           :to="importLocation"
-          class="btn role-primary"
+          size="large"
         >
           {{ t('cluster.importAction') }}
-        </n-link>
+        </rc-button>
       </template>
     </Masthead>
 
@@ -166,12 +168,9 @@ export default {
       </template>
 
       <template #cell:harvester="{row}">
-        <n-link
-          class="btn btn-sm role-primary"
-          :to="row.detailLocation"
-        >
+        <rc-button :to="row.detailLocation">
           {{ t('harvesterManager.manage') }}
-        </n-link>
+        </rc-button>
       </template>
     </ResourceTable>
     <div v-else>

package/list/management.cattle.io.user.vue

@@ -7,6 +7,7 @@ import Masthead from '@shell/components/ResourceList/Masthead';
 import ResourceFetch from '@shell/mixins/resource-fetch';
 import { isAdminUser } from '@shell/store/type-map';
 import TableDataUserIcon from '@shell/components/TableDataUserIcon';
+import { RcButton } from '@components/RcButton';
 
 export default {
   components: {
@@ -14,6 +15,7 @@ export default {
     ResourceTable,
     Masthead,
     TableDataUserIcon,
+    RcButton
   },
   mixins: [ResourceFetch],
   props:  {
@@ -128,14 +130,17 @@ export default {
         v-if="isAdmin"
         #subHeader
       >
-        <router-link
+        <rc-button
+          variant="link"
+          class="btn-user-retention"
           :to="{ name: 'c-cluster-auth-user.retention'}"
-          class="btn role-link btn-sm btn-user-retention"
           data-testid="router-link-user-retention"
         >
-          <i class="icon icon-gear" />
+          <template #before>
+            <i class="icon icon-gear" />
+          </template>
           {{ t('user.retention.button.label') }}
-        </router-link>
+        </rc-button>
       </template>
     </Masthead>
 
@@ -159,10 +164,8 @@ export default {
   </div>
 </template>
 
-<style lang="scss">
-  .btn-user-retention {
-    display: flex;
-    gap: 0.25rem;
-    padding: 0;
+<style lang="scss" scoped>
+  a.rc-button.variant-link.btn-user-retention {
+    padding: 0; //retain the padding override for left-alignment with the header
   }
 </style>

package/list/provisioning.cattle.io.cluster.vue

@@ -17,10 +17,15 @@ import ProvCluster from '@shell/models/provisioning.cattle.io.cluster';
 import ManagementClusterUtils from '@shell/list/utils/management.cattle.io.cluster.utils';
 import { STEVE_AUTOSCALER_ENABLED } from '@shell/config/pagination-table-headers';
 import { filterHiddenLocalCluster, filterOnlyKubernetesClusters } from '@shell/utils/cluster';
+import { RcButton } from '@components/RcButton';
 
 export default {
   components: {
-    Banner, PaginatedResourceTable, Masthead, MachineSummaryGraph
+    Banner,
+    PaginatedResourceTable,
+    Masthead,
+    MachineSummaryGraph,
+    RcButton,
   },
 
   data() {
@@ -289,13 +294,14 @@ export default {
           v-if="canImport"
           #extraActions
         >
-          <router-link
+          <rc-button
+            size="large"
+            class="mr-10"
             :to="importLocation"
-            class="btn role-primary mr-10"
             data-testid="cluster-manager-list-import"
           >
             {{ t('cluster.importAction') }}
-          </router-link>
+          </rc-button>
         </template>
       </Masthead>
 
@@ -329,22 +335,22 @@ export default {
         </template>
         <template #cell:explorer="{row}">
           <!-- Align side nav cluster, home page name link and cluster management cluster explor buttons on canExplore -->
-          <router-link
+          <rc-button
             v-if="row.canExplore"
+            variant="secondary"
             data-testid="cluster-manager-list-explore-management"
-            class="btn btn-sm role-secondary"
             :to="{name: 'c-cluster', params: {cluster: row.id}}"
           >
             {{ t('cluster.explore') }}
-          </router-link>
-          <button
+          </rc-button>
+          <rc-button
             v-else
+            variant="secondary"
             data-testid="cluster-manager-list-explore"
             :disabled="true"
-            class="btn btn-sm role-secondary"
           >
             {{ t('cluster.explore') }}
-          </button>
+          </rc-button>
         </template>
       </PaginatedResourceTable>
     </template>

package/mixins/__tests__/auth-config.test.ts

@@ -69,4 +69,94 @@ describe('mixin: authConfigMixin', () => {
       expect(instance.model.scope).toStrictEqual(scope);
     });
   });
+
+  describe('accessMode on enable', () => {
+    const FakeComponent = {
+      render() {},
+      mixins:  [authConfigMixin, childHook],
+      methods: { applyHooks: jest.fn() },
+    };
+
+    const createMock = (model: any, overrides: Record<string, any> = {}) => ({
+      data: () => ({
+        value: { configType: 'oidc' },
+        model,
+        ...overrides,
+      }),
+      computed: { principal: () => ({ me: {} }) },
+      global:   {
+        mocks: {
+          $store: { dispatch: () => model },
+          $route: {
+            params: { id: model.id || '123' },
+            query:  { mode: 'edit' },
+          },
+        }
+      }
+    });
+
+    it.each([
+      'github',
+      'githubapp',
+    ])('should default accessMode to restricted for %s on enable', async(id) => {
+      const model = {
+        id,
+        enabled:        false,
+        authConfigName: 'whatever',
+        doAction:       jest.fn(),
+        save:           jest.fn(),
+      };
+      const instance = mount(FakeComponent, createMock(model)).vm as any;
+
+      await instance.save(jest.fn());
+
+      expect(model.save).toHaveBeenCalled();
+      expect(instance.model.accessMode).toStrictEqual('required');
+    });
+
+    it('should default accessMode to unrestricted for non-github oauth on enable', async() => {
+      const model = {
+        id:             'googleoauth',
+        enabled:        false,
+        authConfigName: 'whatever',
+        doAction:       jest.fn(),
+        save:           jest.fn(),
+      };
+      const instance = mount(FakeComponent, createMock(model)).vm as any;
+
+      await instance.save(jest.fn());
+
+      expect(instance.model.accessMode).toStrictEqual('required');
+    });
+
+    it('should set accessMode to required after enabling a provider', async() => {
+      const model = {
+        enabled:        false,
+        accessMode:     'unrestricted',
+        authConfigName: 'whatever',
+        doAction:       jest.fn(),
+        save:           async() => {}
+      };
+      const instance = mount(FakeComponent, createMock(model)).vm as any;
+
+      await instance.save(jest.fn());
+
+      expect(instance.model.accessMode).toStrictEqual('required');
+    });
+
+    it('should not change accessMode when editing an already enabled provider', async() => {
+      const model = {
+        enabled:        true,
+        accessMode:     'unrestricted',
+        authConfigName: 'whatever',
+        doAction:       jest.fn(),
+        save:           async() => {}
+      };
+      const instance = mount(FakeComponent, createMock(model, { editConfig: true })).vm as any;
+
+      await instance.save(jest.fn());
+
+      expect(instance.model.accessMode).toStrictEqual('unrestricted');
+    });
+  });
 });

package/mixins/__tests__/chart.test.ts

@@ -581,5 +581,99 @@ describe('chartMixin', () => {
         '0.0.1'
       ]);
     });
+
+    it('should correctly format current version when it is Linux-only', () => {
+      const versions = [
+        {
+          version:     '1.0.0',
+          created:     '2026-01-01',
+          annotations: { 'catalog.cattle.io/permits-os': 'linux' }
+        }
+      ];
+
+      const mockStore = {
+        dispatch: jest.fn(() => Promise.resolve()),
+        getters:  {
+          currentCluster:  () => ({ workerOSs: ['linux'] }),
+          isRancher:       () => true,
+          'catalog/repo':  () => () => 'repo',
+          'catalog/chart': () => ({ versions }),
+          'prefs/get':     () => () => true,
+          'i18n/t':        () => jest.fn()
+        }
+      };
+
+      const DummyComponent = {
+        mixins:   [ChartMixin],
+        template: '<div></div>',
+      };
+
+      const wrapper = mount(
+        DummyComponent,
+        {
+          data: () => ({
+            chart:    { versions },
+            existing: { spec: { chart: { metadata: { version: '1.0.0' } } } }
+          }),
+          global: {
+            mocks: {
+              $store: mockStore,
+              $route: { query: { version: '1.0.0' } },
+              t:      (key: string, args: any) => `${ args?.ver } (Current, Linux-only)`
+            }
+          }
+        });
+
+      const result = (wrapper.vm as any).mappedVersions;
+
+      expect(result[0].label).toBe('1.0.0 (Current, Linux-only)');
+    });
+
+    it('should correctly format current version when it is not OS-restricted', () => {
+      const versions = [
+        {
+          version:     '1.0.0',
+          created:     '2026-01-01',
+          annotations: {}
+        }
+      ];
+
+      const mockStore = {
+        dispatch: jest.fn(() => Promise.resolve()),
+        getters:  {
+          currentCluster:  () => ({ workerOSs: ['linux'] }),
+          isRancher:       () => true,
+          'catalog/repo':  () => () => 'repo',
+          'catalog/chart': () => ({ versions }),
+          'prefs/get':     () => () => true,
+          'i18n/t':        () => jest.fn()
+        }
+      };
+
+      const DummyComponent = {
+        mixins:   [ChartMixin],
+        template: '<div></div>',
+      };
+
+      const wrapper = mount(
+        DummyComponent,
+        {
+          data: () => ({
+            chart:    { versions },
+            existing: { spec: { chart: { metadata: { version: '1.0.0' } } } }
+          }),
+          global: {
+            mocks: {
+              $store: mockStore,
+              $route: { query: { version: '1.0.0' } },
+              t:      (key: string, args: any) => `${ args?.ver } (Current)`
+            }
+          }
+        });
+
+      const result = (wrapper.vm as any).mappedVersions;
+
+      expect(result[0].label).toBe('1.0.0 (Current)');
+    });
   });
 });

package/mixins/__tests__/resource-fetch-api-pagination.test.ts

@@ -0,0 +1,48 @@
+import { parseStateFilter } from '@shell/mixins/resource-fetch-api-pagination';
+import { PaginationFilterEquality } from '@shell/types/store/pagination.types';
+
+describe('parseStateFilter', () => {
+  it('should return null for null input', () => {
+    expect(parseStateFilter(null)).toBeNull();
+  });
+
+  it('should return null for undefined input', () => {
+    expect(parseStateFilter(undefined)).toBeNull();
+  });
+
+  it('should return null for empty string', () => {
+    expect(parseStateFilter('')).toBeNull();
+  });
+
+  it('should parse a single state', () => {
+    const result = parseStateFilter('running');
+
+    expect(result).toHaveLength(1);
+    expect(result?.[0].field).toStrictEqual('metadata.state.name');
+    expect(result?.[0].value).toStrictEqual('running');
+    expect(result?.[0].equality).toStrictEqual(PaginationFilterEquality.IN);
+  });
+
+  it('should parse multiple comma-separated states', () => {
+    const result = parseStateFilter('running,active');
+
+    expect(result).toHaveLength(1);
+    expect(result?.[0].field).toStrictEqual('metadata.state.name');
+    expect(result?.[0].value).toStrictEqual('running,active');
+    expect(result?.[0].equality).toStrictEqual(PaginationFilterEquality.IN);
+  });
+
+  it('should parse three comma-separated states', () => {
+    const result = parseStateFilter('running,active,waiting');
+
+    expect(result).toHaveLength(1);
+    expect(result?.[0].value).toStrictEqual('running,active,waiting');
+  });
+
+  it('should ignore empty segments from trailing commas', () => {
+    const result = parseStateFilter('running,,active,');
+
+    expect(result).toHaveLength(1);
+    expect(result?.[0].value).toStrictEqual('running,active');
+  });
+});

package/mixins/auth-config.js

@@ -201,6 +201,9 @@ export default {
             if (!this.model.accessMode) {
               this.model.accessMode = 'unrestricted';
             }
+            if (this.model.id === 'github' || this.model.id === 'githubapp') {
+              this.model.accessMode = 'restricted';
+            }
             await this.model.doAction('testAndApply', obj, { redirectUnauthorized: false });
           }
 
@@ -241,6 +244,10 @@ export default {
           } else {
             console.warn(`Unable to find principal marked as 'me'`); // eslint-disable-line no-console
           }
+
+          if (!wasEnabled) {
+            this.model.accessMode = 'required';
+          }
         }
         if (wasEnabled && configType === 'oauth') {
           await this.model.save({ ignoreFields: ['oauthCredential', 'serviceAccountCredential'] } );

package/mixins/chart.js

@@ -71,6 +71,8 @@ export default {
 
       const selectedVersion = this.targetVersion;
       const OSs = this.currentCluster?.workerOSs;
+      const isRancher = isRancherRepo(this.repo, this.chart);
+      const permittedSystemsByVersion = new Map();
       const out = [];
 
       versions.forEach((version) => {
@@ -84,9 +86,10 @@ export default {
           keywords:        version.keywords
         };
 
-        const isRancher = isRancherRepo(this.repo, this.chart);
         const permittedSystems = getPermittedOSs(version?.annotations, isRancher);
 
+        permittedSystemsByVersion.set(version.version, permittedSystems);
+
         if (permittedSystems.length > 0 && difference(OSs, permittedSystems).length > 0) {
           nue.disabled = true;
         }
@@ -118,7 +121,13 @@ export default {
       const currentVersion = out.find((v) => v.originalVersion === this.currentVersion);
 
       if (currentVersion) {
-        currentVersion.label = this.t('catalog.install.versions.current', { ver: this.currentVersion });
+        const permittedSystems = permittedSystemsByVersion.get(currentVersion.originalVersion) || [];
+
+        if (permittedSystems.length === 1) {
+          currentVersion.label = this.t(`catalog.install.versions.current_${ permittedSystems[0] }`, { ver: this.currentVersion });
+        } else {
+          currentVersion.label = this.t('catalog.install.versions.current', { ver: this.currentVersion });
+        }
       }
 
       return out;

package/mixins/child-hook.js

@@ -8,20 +8,26 @@ export const AFTER_SAVE_HOOKS = '_afterSaveHooks';
 
 export default {
   methods: {
+    registerHook(key, boundFn, name, priority = 99, boundFnContext) {
+      this._registerHook(key, boundFn, name, priority, boundFnContext);
+    },
+
     registerBeforeHook(boundFn, name, priority = 99, boundFnContext) {
-      this._registerHook(BEFORE_SAVE_HOOKS, boundFn, name, priority, boundFnContext);
+      this.registerHook(BEFORE_SAVE_HOOKS, boundFn, name, priority, boundFnContext);
     },
 
-    unregisterBeforeSaveHook(name) {
-      this[BEFORE_SAVE_HOOKS] = this[BEFORE_SAVE_HOOKS].filter((hook) => {
-        // BEFORE_SAVE_HOOKS is an array of objects with keys
-        // fn, name and priority.
+    unregisterHook(key, name) {
+      this[key] = (this[key] || []).filter((hook) => {
         return hook.name !== name;
       });
     },
 
+    unregisterBeforeSaveHook(name) {
+      this.unregisterHook(BEFORE_SAVE_HOOKS, name);
+    },
+
     registerAfterHook(boundFn, name, priority = 99, boundFnContext) {
-      this._registerHook(AFTER_SAVE_HOOKS, boundFn, name, priority, boundFnContext);
+      this.registerHook(AFTER_SAVE_HOOKS, boundFn, name, priority, boundFnContext);
     },
 
     async applyHooks(key, ...args) {

package/mixins/create-edit-view/impl.js

@@ -1,6 +1,6 @@
 import { _CREATE, _EDIT, _VIEW } from '@shell/config/query-params';
 import { LAST_NAMESPACE } from '@shell/store/prefs';
-import { exceptionToErrorsArray } from '@shell/utils/error';
+import { exceptionToErrorsArray, isDoNotLogError } from '@shell/utils/error';
 import ChildHook, { BEFORE_SAVE_HOOKS, AFTER_SAVE_HOOKS } from '@shell/mixins/child-hook';
 import { clear } from '@shell/utils/array';
 import { DEFAULT_WORKSPACE } from '@shell/config/types';
@@ -184,8 +184,10 @@ export default {
         } else {
           this.errors = exceptionToErrorsArray(err);
         }
-        // Provide a stack trace for easier debugging of save errors
-        console.error('CreateEditView mixin failed to save: ', err); // eslint-disable-line no-console
+        if (!isDoNotLogError(err)) {
+          // Provide a stack trace for easier debugging of save errors
+          console.error('CreateEditView mixin failed to save: ', err); // eslint-disable-line no-console
+        }
         buttonDone && buttonDone(false);
       }
     },

package/mixins/resource-fetch-api-pagination.js

@@ -5,10 +5,28 @@ import { mapGetters } from 'vuex';
 import { ResourceListComponentName } from '../components/ResourceList/resource-list.config';
 import paginationUtils from '@shell/utils/pagination-utils';
 import debounce from 'lodash/debounce';
-import { PaginationParamFilter, PaginationFilterField, PaginationArgs } from '@shell/types/store/pagination.types';
+import { PaginationParamFilter, PaginationFilterField, PaginationFilterEquality, PaginationArgs } from '@shell/types/store/pagination.types';
 import stevePaginationUtils from '@shell/plugins/steve/steve-pagination-utils';
 import { STEVE_WATCH_MODE } from '@shell/types/store/subscribe.types';
 
+export function parseStateFilter(stateFilter) {
+  if (!stateFilter) {
+    return null;
+  }
+
+  const states = stateFilter.split(',').filter(Boolean);
+
+  if (!states.length) {
+    return null;
+  }
+
+  return [new PaginationFilterField({
+    field:    'metadata.state.name',
+    value:    states.join(','),
+    equality: PaginationFilterEquality.IN,
+  })];
+}
+
 /**
  * Companion mixin used with `resource-fetch` for `ResourceList` to determine if the user needs to filter the list by a single namespace
  */
@@ -75,6 +93,7 @@ export default {
       const {
         page, perPage, filter, sort, descending
       } = event;
+      const stateFilters = parseStateFilter(this.$route?.query?.stateFilter) || [];
       const searchFilters = filter.searchQuery ? filter.searchFields.map((field) => new PaginationFilterField({
         field,
         value: filter.searchQuery,
@@ -91,6 +110,7 @@ export default {
         projectsOrNamespaces: this.requestFilters.projectsOrNamespaces,
         filters:              [
           new PaginationParamFilter({ fields: searchFilters }),
+          new PaginationParamFilter({ fields: stateFilters }),
           ...this.requestFilters.filters, // Apply the additional filters. these aren't from the user but from ns filtering
         ]
       });

package/models/__tests__/catalog.cattle.io.clusterrepo.test.ts

@@ -17,6 +17,7 @@ describe('clusterRepo', () => {
     jest.spyOn(model, 'save').mockImplementation().mockResolvedValue(true);
     jest.spyOn(model, 'waitForState').mockImplementation().mockResolvedValue(true);
     jest.spyOn(model, '$dispatch', 'get').mockReturnValue(jest.fn());
+    jest.spyOn(model, 't', 'get').mockReturnValue((key: string) => key);
   });
 
   describe('refresh', () => {
@@ -59,6 +60,62 @@ describe('clusterRepo', () => {
     });
   });
 
+  describe('defaultRefreshIntervalHours', () => {
+    it('returns 24 for OCI repos', () => {
+      model.spec.url = 'oci://example.com/chart';
+      model.spec.insecurePlainHttp = false;
+      expect(model.defaultRefreshIntervalHours).toStrictEqual(24);
+    });
+
+    it('returns 1 for git repos', () => {
+      model.spec = { gitRepo: 'https://github.com/example/charts' };
+      expect(model.defaultRefreshIntervalHours).toStrictEqual(1);
+    });
+
+    it('returns 1 for helm repos', () => {
+      model.spec = { url: 'https://charts.example.com' };
+      expect(model.defaultRefreshIntervalHours).toStrictEqual(1);
+    });
+  });
+
+  describe('defaultRefreshInterval', () => {
+    it('returns seconds for OCI repos (24 hours)', () => {
+      model.spec.url = 'oci://example.com/chart';
+      model.spec.insecurePlainHttp = false;
+      expect(model.defaultRefreshInterval).toStrictEqual(86400);
+    });
+
+    it('returns seconds for non-OCI repos (1 hour)', () => {
+      model.spec = { gitRepo: 'https://github.com/example/charts' };
+      expect(model.defaultRefreshInterval).toStrictEqual(3600);
+    });
+  });
+
+  describe('refreshIntervalDisplay', () => {
+    it.each([
+      -1,
+      -100,
+    ])('returns "Disabled" when value is %p', (val) => {
+      model.spec.refreshInterval = val;
+      expect(model.refreshIntervalDisplay).toStrictEqual('generic.disabled');
+    });
+
+    it('returns formatted duration for positive values', () => {
+      model.spec.refreshInterval = 3661;
+      expect(model.refreshIntervalDisplay).toStrictEqual('1h 1m 1s');
+    });
+
+    it('returns default formatted duration when not set', () => {
+      model.spec = { url: 'https://charts.example.com' };
+      expect(model.refreshIntervalDisplay).toStrictEqual('1h');
+    });
+
+    it('returns default formatted duration for OCI when not set', () => {
+      model.spec = { url: 'oci://example.com/chart', insecurePlainHttp: false };
+      expect(model.refreshIntervalDisplay).toStrictEqual('1d');
+    });
+  });
+
   describe('refreshBulk', () => {
     it('calls refresh(false) on all items and then dispatches a single catalog/load with all repoKeys', async() => {
       const mockItem1 = {