dashboard-shell-shell 1.0.111

package/composables/useUserRetentionValidation.ts

@@ -0,0 +1,201 @@
+import { Ref, ComputedRef, ref, computed } from 'vue';
+import { useStore } from 'vuex';
+
+import { SETTING } from '@shell/config/settings';
+import { useI18n } from '@shell/composables/useI18n';
+import type { Setting } from '@shell/types/resources/settings';
+
+import { isValidCron } from 'cron-validator';
+import dayjs from 'dayjs';
+import duration from 'dayjs/plugin/duration';
+dayjs.extend(duration);
+
+type SettingValidation = 'user-retention-cron' | 'disable-inactive-user-after' | 'delete-inactive-user-after';
+
+type Validation = {
+  [SETTING.DISABLE_INACTIVE_USER_AFTER]?: boolean;
+  [SETTING.DELETE_INACTIVE_USER_AFTER]?: boolean;
+  [SETTING.USER_RETENTION_CRON]?: boolean;
+}
+
+interface UseUserRetentionValidation {
+  validateUserRetentionCron: (cronSetting: string | null) => string | undefined;
+  validateDisableInactiveUserAfterDuration: (duration: string) => string | undefined;
+  validateDeleteInactiveUserAfterDuration: (duration: string) => string | undefined;
+  validateDeleteInactiveUserAfter: (duration: string) => string | undefined;
+  validateDurationAgainstAuthUserSession: (duration: string) => string | undefined;
+  setValidation: (formField: SettingValidation, isValid: boolean) => void;
+  removeValidation : (setting: SettingValidation) => void;
+  addValidation: (setting: SettingValidation) => void;
+  isFormValid: ComputedRef<boolean>;
+}
+
+class ExpectedValidationError extends Error {
+  isExpected = true;
+  constructor(message: string) {
+    super(message);
+    this.name = 'ExpectedError';
+  }
+}
+
+export const useUserRetentionValidation = (disableAfterPeriod: Ref<boolean>, deleteAfterPeriod: Ref<boolean>, authUserSessionTtlMinutes: Ref<Setting | null>): UseUserRetentionValidation => {
+  const store = useStore();
+  const { t } = useI18n(store);
+
+  /**
+   * Tracks the validation state for user retention fields
+   */
+  const validation = ref<Validation>({
+    [SETTING.DISABLE_INACTIVE_USER_AFTER]: true,
+    [SETTING.DELETE_INACTIVE_USER_AFTER]:  true,
+    [SETTING.USER_RETENTION_CRON]:         true,
+  });
+
+  const isFormValid = computed(() => {
+    const validations = validation.value;
+
+    return !Object.values(validations).includes(false);
+  });
+
+  const setValidation = (formField: SettingValidation, isValid: boolean) => {
+    validation.value[formField] = isValid;
+  };
+
+  const removeValidation = (setting: SettingValidation) => {
+    const { [setting]: _, ...rest } = validation.value;
+
+    validation.value = rest;
+  };
+
+  const addValidation = (setting: SettingValidation) => {
+    validation.value = {
+      ...validation.value,
+      [setting]: true,
+    };
+  };
+
+  /**
+   * Takes a duration string and produces a dayjs duration object.
+   * @param duration Duration string in {h|m|s} (e.g. 6h3m2s)
+   * @returns Day.js duration object
+   */
+  const parseDuration = (duration: string) => {
+    const durationPattern = /^(\d+)h|(\d+)m|(\d+)s$/;
+    const match = duration?.match(durationPattern);
+
+    if (!match) {
+      throw new ExpectedValidationError('Invalid duration format. Accepted duration units are Hours, Minutes, and Seconds ({h|m|s})');
+    }
+
+    const hours = match[1] ? parseInt(match[1]) : 0;
+    const minutes = match[2] ? parseInt(match[2]) : 0;
+    const seconds = match[3] ? parseInt(match[3]) : 0;
+
+    return dayjs.duration({
+      hours, minutes, seconds
+    });
+  };
+
+  /**
+   * Asserts that a given string is a valid cron expression
+   * @param cronSetting Cron expression to test
+   * @returns Undefined if cron expression is valid; Error string for an invalid
+   * cron expression.
+   */
+  const validateUserRetentionCron = (cronSetting: string | null): string | undefined => {
+    // Only require user retention cron when disable or delete after are active
+    if (!disableAfterPeriod.value && !deleteAfterPeriod.value) {
+      return;
+    }
+
+    if (
+      !cronSetting ||
+      (typeof cronSetting === 'string' && !isValidCron(cronSetting))
+    ) {
+      return t('user.retention.edit.form.cron.errorMessage');
+    }
+  };
+
+  const validateDisableInactiveUserAfterDuration = (duration: string): string | undefined => {
+    if (!disableAfterPeriod.value) {
+      return;
+    }
+
+    try {
+      parseDuration(duration);
+    } catch (error: any) {
+      return error.message;
+    }
+  };
+
+  const validateDeleteInactiveUserAfterDuration = (duration: string): string | undefined => {
+    if (!deleteAfterPeriod.value) {
+      return;
+    }
+
+    try {
+      parseDuration(duration);
+    } catch (error: any) {
+      return error.message;
+    }
+  };
+
+  /**
+   * Asserts that the provided duration is greater than the default minimum of
+   * 336h
+   * @param duration Duration string in {h|m|s} (e.g. 6h3m2s)
+   * @returns Undefined if duration is valid; Error string for an invalid
+   * duration
+   */
+  const validateDeleteInactiveUserAfter = (duration: string): string | undefined => {
+    try {
+      const inputDuration = parseDuration(duration);
+      const minDuration = dayjs.duration({ hours: 336 });
+
+      if (inputDuration.asMilliseconds() < minDuration.asMilliseconds()) {
+        return `Invalid value: "${ duration }": must be at least 336h0m0s`;
+      }
+    } catch (error: any) {
+      if (error instanceof ExpectedValidationError) {
+
+      } else {
+        return error.message;
+      }
+    }
+  };
+
+  /**
+   * Asserts that the provided duration is not less than the user session TTL
+   * @param duration Duration string in {h|m|s} (e.g. 6h3m2s)
+   * @returns Undefined if duration is valid; Error string for an invalid
+   * duration
+   */
+  const validateDurationAgainstAuthUserSession = (duration: string): string | undefined => {
+    try {
+      const inputDuration = parseDuration(duration);
+      const minDuration = dayjs.duration({ minutes: authUserSessionTtlMinutes.value?.value });
+
+      if (inputDuration.asMilliseconds() < minDuration.asMilliseconds()) {
+        return `Invalid value: "${ duration }": must be at least ${ SETTING.AUTH_USER_SESSION_TTL_MINUTES } (${ authUserSessionTtlMinutes.value?.value }m)`;
+      }
+    } catch (error: any) {
+      if (error instanceof ExpectedValidationError) {
+
+      } else {
+        return error.message;
+      }
+    }
+  };
+
+  return {
+    validateUserRetentionCron,
+    validateDisableInactiveUserAfterDuration,
+    validateDeleteInactiveUserAfterDuration,
+    validateDeleteInactiveUserAfter,
+    validateDurationAgainstAuthUserSession,
+    setValidation,
+    removeValidation,
+    addValidation,
+    isFormValid,
+  };
+};

package/config/__test__/home-links.test.ts

@@ -0,0 +1,57 @@
+import { createStore } from 'vuex';
+import { ensureSupportLink } from '@shell/config/home-links.js';
+import { getters, state, mutations } from '@shell/store/i18n.js';
+
+jest.mock('@shell/assets/translations/en-us.yaml', () => ({
+  locale: {
+    'en-us':   'English',
+    'zh-hans': '简体中文',
+    none:      '(None)',
+  }
+}));
+
+describe('fx: ensureSupportLink', () => {
+  const store = createStore({
+    state,
+    getters: {
+      'i18n/selectedLocaleLabel': getters.selectedLocaleLabel,
+      'i18n/t':                   getters.t,
+    },
+    mutations,
+  });
+
+  store.commit('loadTranslations', {
+    locale:       'zh-zhans',
+    translations: {
+      locale: {
+        'en-us':   'English',
+        'zh-hans': '简体中文',
+        none:      '(None)',
+      }
+    }
+  });
+
+  const testCases = [
+    ['en-us', false],
+    ['zh-hans', true],
+    ['none', false],
+    [null, false],
+  ];
+
+  it.each(testCases)('should return cn forum link if the language is zh-hans', (language:String, value) => {
+    store.commit('setSelected', language);
+
+    const links = { defaults: [], custom: [] };
+    const hasSupport = true;
+    const isSupportPage = true;
+
+    const localThis = {
+      $store: store,
+      t:      store.getters['i18n/t'],
+    };
+
+    const result = ensureSupportLink(links, hasSupport, isSupportPage, localThis.t, store);
+
+    expect(!!result.defaults.find((link) => link.key === 'cnforums')).toBe(value);
+  });
+});

package/config/cookies.js

@@ -0,0 +1,4 @@
+export const CSRF = 'CSRF';
+export const USERNAME = 'R_USERNAME';
+export const LOCALE = 'R_LOCALE';
+export const REDIRECTED = 'R_REDIRECTED';

package/config/elemental-types.js

@@ -0,0 +1,9 @@
+export const ELEMENTAL_PRODUCT_NAME = 'elemental';
+export const ELEMENTAL_CLUSTER_PROVIDER = 'machineinventoryselectortemplate';
+
+export const ELEMENTAL_SCHEMA_IDS = {
+  MACHINE_INVENTORIES:            'elemental.cattle.io.machineinventory',
+  MACHINE_INV_SELECTOR_TEMPLATES: 'elemental.cattle.io.machineinventoryselectortemplate',
+};
+
+export const KIND = { MACHINE_INV_SELECTOR_TEMPLATES: 'MachineInventorySelectorTemplate' };

package/config/features.js

@@ -0,0 +1,6 @@
+export const ONE_WAY = [
+  'token-hashing', 'multi-cluster-management'
+];
+
+export const HARVESTER_NAME = 'harvester';
+export const SCHEDULING_CUSTOMIZATION = 'cluster-agent-scheduling-customization';

package/config/harvester-manager-types.js

@@ -0,0 +1,3 @@
+export const NAME = 'harvesterManager';
+
+export const KIND = { MACHINE_TEMPLATE: 'HarvesterMachineTemplate' };

package/config/home-links.js

@@ -0,0 +1,209 @@
+import { DOCS_BASE } from '@shell/config/private-label';
+import { MANAGEMENT } from '@shell/config/types';
+import { SETTING } from '@shell/config/settings';
+import { allHash } from '@shell/utils/promise';
+import { isRancherPrime } from '@shell/config/version';
+
+// i18n-uses customLinks.defaults.*
+const DEFAULT_LINKS = [
+  {
+    key:     'docs',
+    value:   DOCS_BASE,
+    enabled: true,
+  },
+  {
+    key:     'forums',
+    value:   'https://forums.suse.com/',
+    enabled: true,
+  },
+  {
+    key:     'slack',
+    value:   'https://slack.rancher.io/',
+    enabled: true,
+  },
+  {
+    key:     'issues',
+    value:   'https://github.com/rancher/dashboard/issues/new/choose',
+    enabled: true,
+  },
+  {
+    key:     'getStarted',
+    value:   `${ DOCS_BASE }/getting-started/overview`,
+    enabled: true,
+  },
+];
+
+const COLLECTIVE_LINK_ID = 'suseCollective';
+
+const APP_COLLECTION_LINK = {
+  key:     'appCo',
+  value:   'https://apps.rancher.io/',
+  enabled: true,
+};
+
+const SUPPORT_LINK = {
+  key:      'commercialSupport',
+  value:    '/support',
+  enabled:  true,
+  readonly: true
+};
+
+const CN_FORUMS_LINK = {
+  key:     'cnforums',
+  value:   'https://forums.rancher.cn/',
+  enabled: true,
+};
+
+// We add a version attribute to the setting so we know what has been migrated and which version of the setting we have
+export const CUSTOM_LINKS_VERSION = 'v1';
+
+// Version with SUSE Collective link added (Prime)
+export const CUSTOM_LINKS_COLLECTIVE_VERSION = 'v1.1';
+
+// Version with Application Collective added (Prime)
+export const CUSTOM_LINKS_APP_CO_VERSION = 'v1.2';
+
+// Fetch the settings required for the links, taking into account legacy settings if we have not migrated
+export async function fetchLinks(store, hasSupport, isSupportPage, t) {
+  let uiLinks = {};
+
+  try {
+    const uiLinksSetting = await store.dispatch('management/find', { type: MANAGEMENT.SETTING, id: SETTING.UI_CUSTOM_LINKS });
+
+    // Don't try and parse empty string
+    if (uiLinksSetting.value) {
+      uiLinks = JSON.parse(uiLinksSetting.value);
+    }
+  } catch (e) {
+    console.warn('Could not parse custom link settings', e); // eslint-disable-line no-console
+  }
+
+  // If uiLinks is set and has the correct version, then we are okay, otherwise we need to migrate from the old settings
+  if (uiLinks?.version?.startsWith(CUSTOM_LINKS_VERSION)) {
+    // v1 or v1.1 > v1.2 migration
+    if (uiLinks?.version === CUSTOM_LINKS_VERSION || uiLinks?.version === CUSTOM_LINKS_COLLECTIVE_VERSION) {
+      uiLinks.version = CUSTOM_LINKS_APP_CO_VERSION;
+
+      // Add collective link so that it is enabled by default
+      if (!uiLinks.defaults.includes(APP_COLLECTION_LINK.key)) {
+        uiLinks.defaults.push(APP_COLLECTION_LINK.key);
+      }
+
+      // Delete the SUSE Collective link if it is there since it has been removed
+      uiLinks.defaults = uiLinks.defaults.filter((link) => link !== COLLECTIVE_LINK_ID);
+    }
+
+    // Map out the default settings, as we only store keys of the ones to show
+    if (uiLinks.defaults) {
+      const defaults = [...DEFAULT_LINKS];
+
+      // Add Prime link if necessary
+      if (isRancherPrime()) {
+        defaults.push(APP_COLLECTION_LINK);
+      }
+
+      // Map the link name stored to the default link, if it exists
+      defaults.forEach((link) => {
+        const enabled = uiLinks.defaults.find((linkName) => linkName === link.key);
+
+        link.enabled = !!enabled;
+      });
+
+      uiLinks.defaults = defaults;
+    }
+
+    return ensureSupportLink(uiLinks, hasSupport, isSupportPage, t, store);
+  }
+
+  // No new setting, so return the required structure
+  // We don't migrate here, as we may not have permissions to create the setting
+  const links = {
+    version:  CUSTOM_LINKS_VERSION,
+    defaults: [...DEFAULT_LINKS],
+    custom:   []
+  };
+
+  // Add prime link (application collection) if necessary
+  if (isRancherPrime()) {
+    links.defaults.push(APP_COLLECTION_LINK);
+  }
+
+  // There are two legacy settings:
+  // SETTING.ISSUES - can specify a custom link to use for 'File an issue'
+  // SETTING.COMMUNITY_LINKS - can specify whether to hide all of the default links (other than 'File an issue')
+  try {
+    const { uiIssuesSetting, uiCommunitySetting } = await allHash({
+      uiIssuesSetting:    store.dispatch('management/find', { type: MANAGEMENT.SETTING, id: SETTING.ISSUES }),
+      uiCommunitySetting: store.dispatch('management/find', { type: MANAGEMENT.SETTING, id: SETTING.COMMUNITY_LINKS })
+    });
+
+    // Should we show the default set of links?
+    if (uiCommunitySetting?.value === 'false') {
+      // Hide all of the default links
+      links.defaults.forEach((link) => (link.enabled = false));
+    }
+
+    // Do we have a custom 'File an issue' link ?
+    if (uiIssuesSetting?.value) {
+      links.custom.push({
+        label: t ? t('customLinks.defaults.issues') : 'Issues',
+        value: uiIssuesSetting.value
+      });
+
+      // Hide the default 'File an issue' link
+      const issueLink = links.defaults?.find((link) => link.key === 'issues');
+
+      if (issueLink) {
+        issueLink.enabled = false;
+        issueLink.readOnly = true;
+      }
+    }
+  } catch (e) {
+    console.warn('Could not parse legacy link settings', e); // eslint-disable-line no-console
+  }
+
+  return ensureSupportLink(links, hasSupport, isSupportPage, t, store);
+}
+
+// Ensure the support link is added if needed
+export function ensureSupportLink(links, hasSupport, isSupportPage, t, store) {
+  if (!hasSupport && !isSupportPage) {
+    const supportLink = links.defaults?.find((link) => link.key === 'commercialSupport');
+
+    if (!supportLink) {
+      links.defaults.push(SUPPORT_LINK);
+    }
+  }
+
+  const selectedLocaleLabel = store.getters['i18n/selectedLocaleLabel'];
+
+  if (selectedLocaleLabel === t('locale.zh-hans')) {
+    links.defaults.push(CN_FORUMS_LINK);
+  }
+
+  // Localise the default links
+  links.defaults = links.defaults.map((link) => {
+    return {
+      ...link,
+      label: t(`'customLinks.defaults.${ link.key }`)
+    };
+  });
+
+  // Ensure that if any custom links have the same name as a default link, we use the custom link
+  const customNamesMap = links.custom.reduce((linkMap, link) => {
+    linkMap[link.label] = link;
+
+    return linkMap;
+  }, {});
+
+  // If any custom links have the same name as a default link, then hide and mark readonly the default link
+  // Main use case if the 'File an Issue' link when migrating the old settings
+  links.defaults.forEach((link) => {
+    if (customNamesMap[link.label]) {
+      link.enabled = false;
+      link.readonly = true;
+    }
+  });
+
+  return links;
+}

package/config/labels-annotations.js

@@ -0,0 +1,192 @@
+export const NORMAN_NAME = 'field.cattle.io/name';
+export const DESCRIPTION = 'field.cattle.io/description';
+export const HOSTNAME = 'kubernetes.io/hostname';
+export const TIMESTAMP = 'cattle.io/timestamp';
+export const SYSTEM_NAMESPACE = 'management.cattle.io/system-namespace';
+export const PROJECT = 'field.cattle.io/projectId';
+export const DEFAULT_PROJECT = 'authz.management.cattle.io/default-project';
+export const SYSTEM_PROJECT = 'authz.management.cattle.io/system-project';
+export const CONTAINER_DEFAULT_RESOURCE_LIMIT = 'field.cattle.io/containerDefaultResourceLimit';
+export const CATTLE_PUBLIC_ENDPOINTS = 'field.cattle.io/publicEndpoints';
+export const TARGET_WORKLOADS = 'field.cattle.io/targetWorkloadIds';
+export const UI_MANAGED = 'management.cattle.io/ui-managed';
+export const CREATOR_ID = 'field.cattle.io/creatorId';
+export const CREATOR_PRINCIPAL_ID = 'field.cattle.io/creator-principal-name';
+export const RESOURCE_QUOTA = 'field.cattle.io/resourceQuota';
+export const AZURE_MIGRATED = 'auth.cattle.io/azuread-endpoint-migrated';
+export const WORKSPACE_ANNOTATION = 'objectset.rio.cattle.io/id';
+export const NODE_ARCHITECTURE = 'kubernetes.io/arch';
+export const IMPORTED_CLUSTER_VERSION_MANAGEMENT = 'rancher.io/imported-cluster-version-management';
+
+export const KUBERNETES = {
+  SERVICE_ACCOUNT_UID:  'kubernetes.io/service-account.uid',
+  SERVICE_ACCOUNT_NAME: 'kubernetes.io/service-account.name',
+  MANAGED_BY:           'app.kubernetes.io/managed-by',
+  MANAGED_NAME:         'app.kubernetes.io/name',
+  INSTANCE:             'app.kubernetes.io/instance',
+};
+
+export const CERTMANAGER = { ISSUER: 'cert-manager.io/issuer-name' };
+
+export const STORAGE = {
+  DEFAULT_STORAGE_CLASS:      'storageclass.kubernetes.io/is-default-class',
+  BETA_DEFAULT_STORAGE_CLASS: 'storageclass.beta.kubernetes.io/is-default-class'
+};
+
+export const MANAGEMENT_NODE = { NODE_NAME: 'management.cattle.io/nodename' };
+
+export const NODE_ROLES = {
+  CONTROL_PLANE_OLD: 'node-role.kubernetes.io/controlplane',
+  CONTROL_PLANE:     'node-role.kubernetes.io/control-plane',
+  WORKER:            'node-role.kubernetes.io/worker',
+  ETCD:              'node-role.kubernetes.io/etcd',
+};
+
+export const MACHINE_ROLES = {
+  CONTROL_PLANE: 'rke.cattle.io/control-plane-role',
+  WORKER:        'rke.cattle.io/worker-role',
+  ETCD:          'rke.cattle.io/etcd-role',
+};
+
+export const CAPI = {
+  DEPLOYMENT_NAME:      'cluster.x-k8s.io/deployment-name',
+  CREDENTIAL_DRIVER:    'provisioning.cattle.io/driver',
+  CLUSTER_NAMESPACE:    'cluster.x-k8s.io/cluster-namespace',
+  FORCE_MACHINE_REMOVE: 'provisioning.cattle.io/force-machine-remove',
+  MACHINE_NAME:         'cluster.x-k8s.io/machine',
+  DELETE_MACHINE:       'cluster.x-k8s.io/delete-machine',
+  PROVIDER:             'provider.cattle.io',
+  /**
+   * RKE2 - metadata.name is human name
+   * RKE1 and some others - metadata.name is v1 mgmt id and it's the v1 mgmt cluster that contains human name
+   * This label ensures something is in the v1 prov cluster that can be sorted/filtered on
+   */
+  HUMAN_NAME:           'provisioning.cattle.io/management-cluster-display-name',
+  SECRET_AUTH:          'v2prov-secret-authorized-for-cluster',
+  SECRET_WILL_DELETE:   'v2prov-authorized-secret-deletes-on-cluster-removal',
+  /**
+   * Annotation for overriding the cluster provider,
+   */
+  UI_CUSTOM_PROVIDER:   'ui.rancher/provider'
+};
+
+export const CATALOG = {
+  CERTIFIED: 'catalog.cattle.io/certified',
+  _RANCHER:  'rancher',
+  _PARTNER:  'partner',
+  _OTHER:    'other',
+
+  EXPERIMENTAL: 'catalog.cattle.io/experimental',
+  NAMESPACE:    'catalog.cattle.io/namespace',
+  RELEASE_NAME: 'catalog.cattle.io/release-name',
+  FEATURED:     'catalog.cattle.io/featured',
+
+  REQUIRES_GVK:     'catalog.cattle.io/requires-gvr',
+  PROVIDES:         'catalog.cattle.io/provides-gvr',
+  AUTO_INSTALL_GVK: 'catalog.cattle.io/auto-install-gvr',
+  AUTO_INSTALL:     'catalog.cattle.io/auto-install',
+  HIDDEN:           'catalog.cattle.io/hidden',
+  REQUESTS_CPU:     'catalog.cattle.io/requests-cpu',
+  REQUESTS_MEMORY:  'catalog.cattle.io/requests-memory',
+
+  SCOPE:       'catalog.cattle.io/scope',
+  _MANAGEMENT: 'management',
+  _DOWNSTREAM: 'downstream',
+
+  TYPE:          'catalog.cattle.io/type',
+  _APP:          'app',
+  _CLUSTER_TPL:  'cluster-template',
+  _CLUSTER_TOOL: 'cluster-tool',
+
+  COMPONENT:         'catalog.cattle.io/ui-component',
+  SOURCE_REPO_TYPE:  'catalog.cattle.io/ui-source-repo-type',
+  SOURCE_REPO_NAME:  'catalog.cattle.io/ui-source-repo',
+  COLOR:             'catalog.cattle.io/ui-color',
+  DISPLAY_NAME:      'catalog.cattle.io/display-name',
+  CLUSTER_REPO_NAME: 'catalog.cattle.io/cluster-repo-name',
+
+  SUPPORTED_OS: 'catalog.cattle.io/os',
+  PERMITTED_OS: 'catalog.cattle.io/permits-os',
+  DEPLOYED_OS:  'catalog.cattle.io/deploys-on-os',
+
+  MIGRATED: 'apps.cattle.io/migrated',
+  MANAGED:  'catalog.cattle.io/managed',
+
+  HIDDEN_REPO: 'clusterrepo.cattle.io/hidden'
+};
+
+export const FLEET = {
+  REPO_NAME:            'fleet.cattle.io/repo-name',
+  CLUSTER_DISPLAY_NAME: 'management.cattle.io/cluster-display-name',
+  CLUSTER_NAME:         'management.cattle.io/cluster-name',
+  BUNDLE_ID:            'fleet.cattle.io/bundle-id',
+  BUNDLE_NAME:          'fleet.cattle.io/bundle-name',
+  BUNDLE_NAMESPACE:     'fleet.cattle.io/bundle-namespace',
+  MANAGED:              'fleet.cattle.io/managed',
+  CLUSTER_NAMESPACE:    'fleet.cattle.io/cluster-namespace',
+  CLUSTER:              'fleet.cattle.io/cluster',
+  CREATED_BY_USER_ID:   'fleet.cattle.io/created-by-user-id',
+  CREATED_BY_USER_NAME: 'fleet.cattle.io/created-by-display-name',
+};
+
+export const RBAC = { PRODUCT: 'management.cattle.io/ui-product' };
+
+export const RKE = { EXTERNAL_IP: 'rke.cattle.io/external-ip' };
+
+export const SNAPSHOT = { CLUSTER_NAME: 'rke.cattle.io/cluster-name' };
+
+export const ISTIO = { AUTO_INJECTION: 'istio-injection' };
+
+const CATTLE_REGEX = /cattle\.io\//;
+
+export const LABELS_TO_IGNORE_REGEX = [
+  CATTLE_REGEX
+];
+
+export const ANNOTATIONS_TO_IGNORE_REGEX = [
+  CATTLE_REGEX
+];
+
+export const ANNOTATIONS_TO_FOLD = [
+  /^kubectl\.kubernetes\.io\/.*$/,
+  /^objectset\.rio\.cattle\.io\/.*$/,
+];
+
+export const HCI = {
+  CLOUD_INIT:          'harvesterhci.io/cloud-init-template',
+  CLOUD_PROVIDER_IPAM: 'cloudprovider.harvesterhci.io/ipam',
+  NETWORK_ROUTE:       'network.harvesterhci.io/route',
+  IMAGE_NAME:          'harvesterhci.io/image-name',
+  NETWORK_TYPE:        'network.harvesterhci.io/type',
+  CLUSTER_NETWORK:     'network.harvesterhci.io/clusternetwork',
+  PRIMARY_SERVICE:     'cloudprovider.harvesterhci.io/primary-service',
+};
+
+// Annotations that can be on management.cattle.io.cluster to configure a custom badge
+// Can't use ui.cattle.io - it seems to strip these out - so using io.rancher
+export const CLUSTER_BADGE = {
+  // Badge text - badge is only shown if badge text is not empty
+  TEXT:      'ui.rancher/badge-text',
+  // Badge color - as a hex color - e.g. #ff00ff
+  COLOR:     'ui.rancher/badge-color',
+  // Custom icon text - max 3 characters
+  ICON_TEXT: 'ui.rancher/badge-icon-text',
+};
+
+export const SYSTEM_LABELS = [
+  'io.cattle.lifecycle.',
+  'beta.kubernetes.io',
+  'failure-domain.beta.kubernetes.io',
+  'node-role.kubernetes.io',
+  'kubernetes.io',
+  'cattle.io',
+  'authz.management.cattle.io',
+  'rke.cattle.io',
+  'field.cattle.io',
+  'workload.user.cattle.io',
+  'k3s.io',
+  'node.kubernetes.io',
+  'egress.rke2.io'
+];
+
+export const CLOUD_CREDENTIALS = { EXPIRATION: 'rancher.io/expiration-timestamp' };

package/config/local-storage.js

@@ -0,0 +1,6 @@
+// Github repo cache
+export const GITHUB_REPOS = 'githubRepos';
+export const GITHUB_SCOPES = 'githubScopes';
+export const _DATE = 'Updated';
+
+export const BACK_TO = 'backTo';