sync src/ from master

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

packages/core/src/common/certificate-authorities/request-system-cas.injectable.win32.ts

@@ -3,7 +3,6 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import * as path from "path";
 import execFileInjectable from "../fs/exec-file.injectable";
 import loggerInjectable from "../logger.injectable";
 import { requestSystemCAsInjectionToken } from "./request-system-cas-token";
@@ -24,7 +23,7 @@ const pemEncoding = (hexEncodedCert: String) => {
 const requestSystemCAsInjectable = getInjectable({
   id: "request-system-cas",
   instantiate: (di) => {
-    const wincaRootsExePath: string = path.resolve(require.resolve("win-ca"), "..", "roots.exe");
+    const wincaRootsExePath: string = __non_webpack_require__.resolve("win-ca/lib/roots.exe");
     const execFile = di.inject(execFileInjectable);
     const logger = di.inject(loggerInjectable);
 

packages/core/src/common/k8s-api/endpoints/horizontal-pod-autoscaler.api.ts

@@ -3,11 +3,11 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 
-import type { BaseKubeObjectCondition, LabelSelector, NamespaceScopedMetadata } from "../kube-object";
+import type { OptionVarient } from "../../utils";
-import { KubeObject } from "../kube-object";
 import type { DerivedKubeApiOptions, KubeApiDependencies } from "../kube-api";
 import { KubeApi } from "../kube-api";
-import type { OptionVarient } from "../../utils";
+import type { BaseKubeObjectCondition, LabelSelector, NamespaceScopedMetadata } from "../kube-object";
+import { KubeObject } from "../kube-object";
 
 export enum HpaMetricType {
   Resource = "Resource",
@@ -17,46 +17,131 @@ export enum HpaMetricType {
   ContainerResource = "ContainerResource",
 }
 
+export interface MetricCurrentTarget {
+  current?: string;
+  target?: string;
+}
+
 export interface HorizontalPodAutoscalerMetricTarget {
   kind: string;
   name: string;
   apiVersion: string;
 }
 
-export interface ContainerResourceMetricSource {
+export interface V2ContainerResourceMetricSource {
+  container: string;
+  name: string;
+  target?: {
+    averageUtilization?: number;
+    averageValue?: string;
+    type?: string;
+  };
+}
+
+export interface V2Beta1ContainerResourceMetricSource {
   container: string;
   name: string;
   targetAverageUtilization?: number;
   targetAverageValue?: string;
 }
 
-export interface ExternalMetricSource {
+export type ContainerResourceMetricSource = 
-  metricName: string;
+  | V2ContainerResourceMetricSource
+  | V2Beta1ContainerResourceMetricSource;
+
+export interface V2ExternalMetricSource {
+  metricName?: string;
+  metricSelector?: LabelSelector;
+  metric?: {
+    name?: string;
+    selector?: LabelSelector;
+  };
+  target?: {
+    type: string;
+    value?: string;
+    averageValue?: string;
+  };
+}
+
+export interface V2Beta1ExternalMetricSource {
+  metricName?: string;
   metricSelector?: LabelSelector;
   targetAverageValue?: string;
   targetValue?: string;
+  metric?: {
+    selector?: LabelSelector;
+  };
 }
 
-export interface ObjectMetricSource {
+export type ExternalMetricSource = 
+  | V2Beta1ExternalMetricSource
+  | V2ExternalMetricSource;
+
+export interface V2ObjectMetricSource {
+  metric?: {
+    name?: string;
+    selector?: LabelSelector;
+  };
+  target?: {
+    type?: string;
+    value?: string;
+    averageValue?: string;
+  };
+  describedObject?: CrossVersionObjectReference;
+}
+
+export interface V2Beta1ObjectMetricSource {
   averageValue?: string;
-  metricName: string;
+  metricName?: string;
   selector?: LabelSelector;
-  target: CrossVersionObjectReference;
+  targetValue?: string;
-  targetValue: string;
+  describedObject?: CrossVersionObjectReference;
 }
 
-export interface PodsMetricSource {
+export type ObjectMetricSource =
-  metricName: string;
+  | V2ObjectMetricSource
-  selector?: LabelSelector;
+  | V2Beta1ObjectMetricSource;
-  targetAverageValue: string;
+
+export interface V2PodsMetricSource {
+  metric?: {
+    name?: string;
+    selector?: LabelSelector;
+  };
+  target?: {
+    averageValue?: string;
+    type?: string;
+  };
 }
 
-export interface ResourceMetricSource {
+export interface V2Beta1PodsMetricSource {
+  metricName?: string;
+  selector?: LabelSelector;
+  targetAverageValue?: string;
+}
+
+export type PodsMetricSource =
+  | V2PodsMetricSource
+  | V2Beta1PodsMetricSource;
+
+export interface V2ResourceMetricSource {
+  name: string;
+  target?: {
+    averageUtilization?: number;
+    averageValue?: string;
+    type?: string;
+  };
+}
+
+export interface V2Beta1ResourceMetricSource {
   name: string;
   targetAverageUtilization?: number;
   targetAverageValue?: string;
 }
 
+export type ResourceMetricSource =
+  | V2ResourceMetricSource
+  | V2Beta1ResourceMetricSource;
+
 export interface BaseHorizontalPodAutoscalerMetricSpec {
   containerResource: ContainerResourceMetricSource;
   external: ExternalMetricSource;
@@ -93,40 +178,112 @@ interface HPAScalingPolicy {
 
 type HPAScalingPolicyType = string;
 
-export interface ContainerResourceMetricStatus {
+export interface V2ContainerResourceMetricStatus {
-  container: string;
+  container?: string;
+  name: string;
+  current?: {
+    averageUtilization?: number;
+    averageValue?: string;
+  };
+}
+
+export interface V2Beta1ContainerResourceMetricStatus {
+  container?: string;
   currentAverageUtilization?: number;
-  currentAverageValue: string;
+  currentAverageValue?: string;
   name: string;
 }
 
-export interface ExternalMetricStatus {
+export type ContainerResourceMetricStatus =
+  | V2ContainerResourceMetricStatus
+  | V2Beta1ContainerResourceMetricStatus;
+
+export interface V2ExternalMetricStatus {
+  metric?: {
+    name?: string;
+    selector?: LabelSelector;
+  };
+  current?: {
+    averageValue?: string;
+    value?: string;
+  };
+}
+
+export interface V2Beta1ExternalMetricStatus {
   currentAverageValue?: string;
-  currentValue: string;
+  currentValue?: string;
-  metricName: string;
+  metricName?: string;
   metricSelector?: LabelSelector;
 }
 
-export interface ObjectMetricStatus {
+export type ExternalMetricStatus =
+  | V2Beta1ExternalMetricStatus
+  | V2ExternalMetricStatus;
+
+export interface V2ObjectMetricStatus {
+  metric?: {
+    name?: string;
+    selector?: LabelSelector;
+  };
+  current?: {
+    type?: string;
+    value?: string;
+    averageValue?: string;
+  };
+  describedObject?: CrossVersionObjectReference;
+}
+
+export interface V2Beta1ObjectMetricStatus {
   averageValue?: string;
   currentValue?: string;
-  metricName: string;
+  metricName?: string;
   selector?: LabelSelector;
-  target: CrossVersionObjectReference;
+  describedObject?: CrossVersionObjectReference;
 }
 
-export interface PodsMetricStatus {
+export type ObjectMetricStatus =
-  currentAverageValue: string;
+  | V2Beta1ObjectMetricStatus
-  metricName: string;
+  | V2ObjectMetricStatus;
+
+export interface V2PodsMetricStatus {
+  selector?: LabelSelector;
+  metric?: {
+    name?: string;
+    selector?: LabelSelector;
+  };
+  current?: {
+    averageValue?: string;
+  };
+}
+
+export interface V2Beta1PodsMetricStatus {
+  currentAverageValue?: string;
+  metricName?: string;
   selector?: LabelSelector;
 }
 
-export interface ResourceMetricStatus {
+export type PodsMetricStatus =
+  | V2Beta1PodsMetricStatus
+  | V2PodsMetricStatus;
+
+export interface V2ResourceMetricStatus {
+  name: string;
+  current?: {
+    averageUtilization?: number;
+    averageValue?: string;
+  };
+}
+
+export interface V2Beta1ResourceMetricStatus {
   currentAverageUtilization?: number;
-  currentAverageValue: string;
+  currentAverageValue?: string;
   name: string;
 }
 
+export type ResourceMetricStatus =
+  | V2Beta1ResourceMetricStatus
+  | V2ResourceMetricStatus;
+
 export interface BaseHorizontalPodAutoscalerMetricStatus {
   containerResource: ContainerResourceMetricStatus;
   external: ExternalMetricStatus;
@@ -154,6 +311,7 @@ export interface HorizontalPodAutoscalerSpec {
   maxReplicas: number;
   metrics?: HorizontalPodAutoscalerMetricSpec[];
   behavior?: HorizontalPodAutoscalerBehavior;
+  targetCPUUtilizationPercentage?: number; // used only in autoscaling/v1
 }
 
 export interface HorizontalPodAutoscalerStatus {
@@ -161,11 +319,7 @@ export interface HorizontalPodAutoscalerStatus {
   currentReplicas: number;
   desiredReplicas: number;
   currentMetrics?: HorizontalPodAutoscalerMetricStatus[];
-}
+  currentCPUUtilizationPercentage?: number; // used only in autoscaling/v1
-
-interface MetricCurrentTarget {
-  current?: string;
-  target?: string;
 }
 
 export class HorizontalPodAutoscaler extends KubeObject<
@@ -212,15 +366,6 @@ export class HorizontalPodAutoscaler extends KubeObject<
   getCurrentMetrics() {
     return this.status?.currentMetrics ?? [];
   }
-
-  getMetricValues(metric: HorizontalPodAutoscalerMetricSpec): string {
-    const {
-      current = "unknown",
-      target = "unknown",
-    } = getMetricCurrentTarget(metric, this.getCurrentMetrics());
-
-    return `${current} / ${target}`;
-  }
 }
 
 export class HorizontalPodAutoscalerApi extends KubeApi<HorizontalPodAutoscaler> {
@@ -229,114 +374,6 @@ export class HorizontalPodAutoscalerApi extends KubeApi<HorizontalPodAutoscaler>
       ...opts ?? {},
       objectConstructor: HorizontalPodAutoscaler,
       checkPreferredVersion: true,
-      // Kubernetes < 1.26
-      fallbackApiBases: [
-        "/apis/autoscaling/v2beta2/horizontalpodautoscalers",
-        "/apis/autoscaling/v2beta1/horizontalpodautoscalers",
-        "/apis/autoscaling/v1/horizontalpodautoscalers",
-      ],
     });
   }
 }
-
-function getMetricName(metric: HorizontalPodAutoscalerMetricSpec | HorizontalPodAutoscalerMetricStatus): string | undefined {
-  switch (metric.type) {
-    case HpaMetricType.Resource:
-      return metric.resource.name;
-    case HpaMetricType.Pods:
-      return metric.pods.metricName;
-    case HpaMetricType.Object:
-      return metric.object.metricName;
-    case HpaMetricType.External:
-      return metric.external.metricName;
-    case HpaMetricType.ContainerResource:
-      return metric.containerResource.name;
-    default:
-      return undefined;
-  }
-}
-
-function getResourceMetricValue(currentMetric: ResourceMetricStatus | undefined, targetMetric: ResourceMetricSource): MetricCurrentTarget {
-  return {
-    current: (
-      typeof currentMetric?.currentAverageUtilization === "number"
-        ? `${currentMetric.currentAverageUtilization}%`
-        : currentMetric?.currentAverageValue
-    ),
-    target: (
-      typeof targetMetric?.targetAverageUtilization === "number"
-        ? `${targetMetric.targetAverageUtilization}%`
-        : targetMetric?.targetAverageValue
-    ),
-  };
-}
-
-function getPodsMetricValue(currentMetric: PodsMetricStatus | undefined, targetMetric: PodsMetricSource): MetricCurrentTarget {
-  return {
-    current: currentMetric?.currentAverageValue,
-    target: targetMetric?.targetAverageValue,
-  };
-}
-
-function getObjectMetricValue(currentMetric: ObjectMetricStatus | undefined, targetMetric: ObjectMetricSource): MetricCurrentTarget {
-  return {
-    current: (
-      currentMetric?.currentValue
-        ?? currentMetric?.averageValue
-    ),
-    target: (
-      targetMetric?.targetValue
-        ?? targetMetric?.averageValue
-    ),
-  };
-}
-
-function getExternalMetricValue(currentMetric: ExternalMetricStatus | undefined, targetMetric: ExternalMetricSource): MetricCurrentTarget {
-  return {
-    current: (
-      currentMetric?.currentValue
-        ?? currentMetric?.currentAverageValue
-    ),
-    target: (
-      targetMetric?.targetValue
-        ?? targetMetric?.targetAverageValue
-    ),
-  };
-}
-
-function getContainerResourceMetricValue(currentMetric: ContainerResourceMetricStatus | undefined, targetMetric: ContainerResourceMetricSource): MetricCurrentTarget {
-  return {
-    current: (
-      typeof currentMetric?.currentAverageUtilization === "number"
-        ? `${currentMetric.currentAverageUtilization}%`
-        : currentMetric?.currentAverageValue
-    ),
-    target: (
-      typeof targetMetric?.targetAverageUtilization === "number"
-        ? `${targetMetric.targetAverageUtilization}%`
-        : targetMetric?.targetAverageValue
-    ),
-  };
-}
-
-function getMetricCurrentTarget(spec: HorizontalPodAutoscalerMetricSpec, status: HorizontalPodAutoscalerMetricStatus[]): MetricCurrentTarget {
-  const currentMetric = status.find(m => (
-    m.type === spec.type
-      && getMetricName(m) === getMetricName(spec)
-  ));
-
-  switch (spec.type) {
-    case HpaMetricType.Resource:
-      return getResourceMetricValue(currentMetric?.resource, spec.resource);
-    case HpaMetricType.Pods:
-      return getPodsMetricValue(currentMetric?.pods, spec.pods);
-    case HpaMetricType.Object:
-      return getObjectMetricValue(currentMetric?.object, spec.object);
-    case HpaMetricType.External:
-      return getExternalMetricValue(currentMetric?.external, spec.external);
-    case HpaMetricType.ContainerResource:
-      return getContainerResourceMetricValue(currentMetric?.containerResource, spec.containerResource);
-    default:
-      return {};
-  }
-}

packages/core/src/renderer/components/+config-autoscalers/hpa-details.scss

@@ -11,9 +11,19 @@
   }
 
   .metrics .Table {
+    margin: 0 (-$margin * 3);
+
     .TableCell {
       word-break: break-word;
 
+      &:first-child {
+        margin-left: $margin * 2;
+      }
+
+      &:last-child {
+        margin-right: $margin * 2;
+      }
+
       &.name {
         flex-grow: 2;
       }

packages/core/src/renderer/components/+config-autoscalers/hpa-details.tsx

@@ -22,6 +22,8 @@ import { withInjectables } from "@ogre-tools/injectable-react";
 import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
 import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injectable";
 import loggerInjectable from "../../../common/logger.injectable";
+import getHorizontalPodAutoscalerMetrics from "./get-hpa-metrics.injectable";
+import { getMetricName } from "./get-hpa-metric-name";
 
 export interface HpaDetailsProps extends KubeObjectDetailsProps<HorizontalPodAutoscaler> {
 }
@@ -30,6 +32,7 @@ interface Dependencies {
   apiManager: ApiManager;
   logger: Logger;
   getDetailsUrl: GetDetailsUrl;
+  getMetrics: (hpa: HorizontalPodAutoscaler) => string[];
 }
 
 @observer
@@ -57,47 +60,46 @@ class NonInjectedHpaDetails extends React.Component<HpaDetailsProps & Dependenci
     const { object: hpa } = this.props;
 
     const renderName = (metric: HorizontalPodAutoscalerMetricSpec) => {
+      const metricName = getMetricName(metric);
+
       switch (metric.type) {
         case HpaMetricType.ContainerResource:
 
         // fallthrough
         case HpaMetricType.Resource: {
           const metricSpec = metric.resource ?? metric.containerResource;
-          const addition = metricSpec.targetAverageUtilization
-            ? " (as a percentage of request)"
-            : "";
 
-          return `Resource ${metricSpec.name} on Pods${addition}`;
+          return `Resource ${metricSpec.name} on Pods`;
         }
         case HpaMetricType.Pods:
-          return `${metric.pods.metricName} on Pods`;
+          return `${metricName} on Pods`;
 
         case HpaMetricType.Object: {
           return (
             <>
-              {metric.object.metricName}
+              {metricName}
               {" "}
-              {this.renderTargetLink(metric.object.target)}
+              {this.renderTargetLink(metric.object?.describedObject)}
             </>
           );
         }
         case HpaMetricType.External:
-          return `${metric.external.metricName} on ${JSON.stringify(metric.external.metricSelector)}`;
+          return `${metricName} on ${JSON.stringify(metric.external.metricSelector ?? metric.external.metric?.selector)}`;
       }
     };
 
     return (
       <Table>
-        <TableHead>
+        <TableHead flat>
           <TableCell className="name">Name</TableCell>
           <TableCell className="metrics">Current / Target</TableCell>
         </TableHead>
         {
-          hpa.getMetrics()
+          this.props.getMetrics(hpa)
-            .map((metric, index) => (
+            .map((metrics, index) => (
               <TableRow key={index}>
-                <TableCell className="name">{renderName(metric)}</TableCell>
+                <TableCell className="name">{renderName(hpa.getMetrics()[index])}</TableCell>
-                <TableCell className="metrics">{hpa.getMetricValues(metric)}</TableCell>
+                <TableCell className="metrics">{metrics}</TableCell>
               </TableRow>
             ))
         }
@@ -175,5 +177,6 @@ export const HpaDetails = withInjectables<Dependencies, HpaDetailsProps>(NonInje
     apiManager: di.inject(apiManagerInjectable),
     getDetailsUrl: di.inject(getDetailsUrlInjectable),
     logger: di.inject(loggerInjectable),
+    getMetrics: di.inject(getHorizontalPodAutoscalerMetrics),
   }),
 });

packages/core/src/renderer/components/+config-autoscalers/hpa.tsx

@@ -17,6 +17,7 @@ import { KubeObjectAge } from "../kube-object/age";
 import type { HorizontalPodAutoscalerStore } from "./store";
 import { withInjectables } from "@ogre-tools/injectable-react";
 import horizontalPodAutoscalerStoreInjectable from "./store.injectable";
+import getHorizontalPodAutoscalerMetrics from "./get-hpa-metrics.injectable";
 import { NamespaceSelectBadge } from "../+namespaces/namespace-select-badge";
 
 enum columnId {
@@ -32,6 +33,7 @@ enum columnId {
 
 interface Dependencies {
   horizontalPodAutoscalerStore: HorizontalPodAutoscalerStore;
+  getMetrics: (hpa: HorizontalPodAutoscaler) => string[];
 }
 
 @observer
@@ -39,7 +41,7 @@ class NonInjectedHorizontalPodAutoscalers extends React.Component<Dependencies>
   getTargets(hpa: HorizontalPodAutoscaler) {
     const metrics = hpa.getMetrics();
 
-    if (metrics.length === 0) {
+    if (metrics.length === 0 && !hpa.spec?.targetCPUUtilizationPercentage) {
       return <p>--</p>;
     }
 
@@ -47,7 +49,7 @@ class NonInjectedHorizontalPodAutoscalers extends React.Component<Dependencies>
 
     return (
       <p>
-        {hpa.getMetricValues(metrics[0])}
+        {this.props.getMetrics(hpa)[0]}
         {" "}
         {metricsRemain}
       </p>
@@ -120,5 +122,6 @@ export const HorizontalPodAutoscalers = withInjectables<Dependencies>(NonInjecte
   getProps: (di, props) => ({
     ...props,
     horizontalPodAutoscalerStore: di.inject(horizontalPodAutoscalerStoreInjectable),
+    getMetrics: di.inject(getHorizontalPodAutoscalerMetrics),
   }),
 });

packages/core/src/renderer/components/kube-object-details/kube-object-detail-items/implementations/horizontal-pod-autoscaler-detail-item.injectable.ts

@@ -27,7 +27,7 @@ const horizontalPodAutoscalerDetailItemInjectable = getInjectable({
 
 export const isHorizontalPodAutoscaler = kubeObjectMatchesToKindAndApiVersion(
   "HorizontalPodAutoscaler",
-  ["autoscaling/v2beta1"],
+  ["autoscaling/v2", "autoscaling/v2beta2", "autoscaling/v2beta1", "autoscaling/v1"],
 );
 
 export default horizontalPodAutoscalerDetailItemInjectable;

src/common/__tests__/catalog-category-registry.test.ts

@@ -1,90 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { CatalogCategorySpec } from "../catalog";
-import { CatalogCategory, CatalogCategoryRegistry } from "../catalog";
-
-class TestCatalogCategoryRegistry extends CatalogCategoryRegistry { }
-
-class TestCatalogCategory extends CatalogCategory {
-  public readonly apiVersion = "catalog.k8slens.dev/v1alpha1";
-  public readonly kind = "CatalogCategory";
-  public metadata = {
-    name: "Test Category",
-    icon: "",
-  };
-  public spec: CatalogCategorySpec = {
-    group: "entity.k8slens.dev",
-    versions: [],
-    names: {
-      kind: "Test",
-    },
-  };
-}
-
-class TestCatalogCategory2 extends CatalogCategory {
-  public readonly apiVersion = "catalog.k8slens.dev/v1alpha1";
-  public readonly kind = "CatalogCategory";
-  public metadata = {
-    name: "Test Category 2",
-    icon: "",
-  };
-  public spec: CatalogCategorySpec = {
-    group: "entity.k8slens.dev",
-    versions: [],
-    names: {
-      kind: "Test2",
-    },
-  };
-}
-
-describe("CatalogCategoryRegistry", () => {
-  it("should remove only the category registered when running the disposer", () => {
-    const registry = new TestCatalogCategoryRegistry();
-
-    expect(registry.items.length).toBe(0);
-
-    const d1 = registry.add(new TestCatalogCategory());
-    const d2 = registry.add(new TestCatalogCategory2());
-
-    expect(registry.items.length).toBe(2);
-
-    d1();
-    expect(registry.items.length).toBe(1);
-
-    d2();
-    expect(registry.items.length).toBe(0);
-  });
-
-  it("doesn't return items that are filtered out", () => {
-    const registry = new TestCatalogCategoryRegistry();
-
-    registry.add(new TestCatalogCategory());
-    registry.add(new TestCatalogCategory2());
-
-    expect(registry.items.length).toBe(2);
-    expect(registry.filteredItems.length).toBe(2);
-
-    const disposer = registry.addCatalogCategoryFilter(category => category.metadata.name === "Test Category");
-
-    expect(registry.items.length).toBe(2);
-    expect(registry.filteredItems.length).toBe(1);
-
-    const disposer2 = registry.addCatalogCategoryFilter(category => category.metadata.name === "foo");
-
-    expect(registry.items.length).toBe(2);
-    expect(registry.filteredItems.length).toBe(0);
-
-    disposer();
-
-    expect(registry.items.length).toBe(2);
-    expect(registry.filteredItems.length).toBe(0);
-
-    disposer2();
-
-    expect(registry.items.length).toBe(2);
-    expect(registry.filteredItems.length).toBe(2);
-  });
-});

src/common/__tests__/catalog-entity.test.tsx

@@ -1,52 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import React from "react";
-import { CatalogCategory } from "../catalog";
-import type { CatalogCategorySpec } from "../catalog";
-
-class TestCatalogCategoryWithoutBadge extends CatalogCategory {
-  public readonly apiVersion = "catalog.k8slens.dev/v1alpha1";
-  public readonly kind = "CatalogCategory";
-
-  public metadata = {
-    name: "Test Category",
-    icon: "",
-  };
-
-  public spec: CatalogCategorySpec = {
-    group: "entity.k8slens.dev",
-    versions: [],
-    names: {
-      kind: "Test",
-    },
-  };
-}
-
-class TestCatalogCategoryWithBadge extends TestCatalogCategoryWithoutBadge {
-  getBadge() {
-    return (<div>Test Badge</div>);
-  }
-}
-
-describe("CatalogCategory", () => {
-  it("returns name", () => {
-    const category = new TestCatalogCategoryWithoutBadge();
-
-    expect(category.getName()).toEqual("Test Category");
-  });
-
-  it("doesn't return badge by default", () => {
-    const category = new TestCatalogCategoryWithoutBadge();
-
-    expect(category.getBadge()).toEqual(null);
-  });
-
-  it("returns a badge", () => {
-    const category = new TestCatalogCategoryWithBadge();
-
-    expect(category.getBadge()).toBeTruthy();
-  });
-});

src/common/__tests__/cluster-store.test.ts

@@ -1,359 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { ClusterStore } from "../cluster-store/cluster-store";
-import type { GetCustomKubeConfigFilePath } from "../app-paths/get-custom-kube-config-directory/get-custom-kube-config-directory.injectable";
-import getCustomKubeConfigFilePathInjectable from "../app-paths/get-custom-kube-config-directory/get-custom-kube-config-directory.injectable";
-import clusterStoreInjectable from "../cluster-store/cluster-store.injectable";
-import type { DiContainer } from "@ogre-tools/injectable";
-import type { CreateCluster } from "../cluster/create-cluster-injection-token";
-import { createClusterInjectionToken } from "../cluster/create-cluster-injection-token";
-import directoryForUserDataInjectable from "../app-paths/directory-for-user-data/directory-for-user-data.injectable";
-import { getDiForUnitTesting } from "../../main/getDiForUnitTesting";
-import assert from "assert";
-import directoryForTempInjectable from "../app-paths/directory-for-temp/directory-for-temp.injectable";
-import kubectlBinaryNameInjectable from "../../main/kubectl/binary-name.injectable";
-import kubectlDownloadingNormalizedArchInjectable from "../../main/kubectl/normalized-arch.injectable";
-import normalizedPlatformInjectable from "../vars/normalized-platform.injectable";
-import storeMigrationVersionInjectable from "../vars/store-migration-version.injectable";
-import type { WriteJsonSync } from "../fs/write-json-sync.injectable";
-import writeJsonSyncInjectable from "../fs/write-json-sync.injectable";
-import type { ReadFileSync } from "../fs/read-file-sync.injectable";
-import readFileSyncInjectable from "../fs/read-file-sync.injectable";
-import { readFileSync } from "fs";
-import type { WriteFileSync } from "../fs/write-file-sync.injectable";
-import writeFileSyncInjectable from "../fs/write-file-sync.injectable";
-import type { WriteBufferSync } from "../fs/write-buffer-sync.injectable";
-import writeBufferSyncInjectable from "../fs/write-buffer-sync.injectable";
-
-// NOTE: this is intended to read the actual file system
-const testDataIcon = readFileSync("test-data/cluster-store-migration-icon.png");
-const clusterServerUrl = "https://localhost";
-const kubeconfig = `
-apiVersion: v1
-clusters:
-- cluster:
-    server: ${clusterServerUrl}
-  name: test
-contexts:
-- context:
-    cluster: test
-    user: test
-  name: foo
-- context:
-    cluster: test
-    user: test
-  name: foo2
-current-context: test
-kind: Config
-preferences: {}
-users:
-- name: test
-  user:
-    token: kubeconfig-user-q4lm4:xxxyyyy
-`;
-
-describe("cluster-store", () => {
-  let di: DiContainer;
-  let clusterStore: ClusterStore;
-  let createCluster: CreateCluster;
-  let writeJsonSync: WriteJsonSync;
-  let writeFileSync: WriteFileSync;
-  let writeBufferSync: WriteBufferSync;
-  let readFileSync: ReadFileSync;
-  let getCustomKubeConfigFilePath: GetCustomKubeConfigFilePath;
-  let writeFileSyncAndReturnPath: (filePath: string, contents: string) => string;
-
-  beforeEach(async () => {
-    di = getDiForUnitTesting({ doGeneralOverrides: true });
-
-    di.override(directoryForUserDataInjectable, () => "/some-directory-for-user-data");
-    di.override(directoryForTempInjectable, () => "/some-temp-directory");
-    di.override(kubectlBinaryNameInjectable, () => "kubectl");
-    di.override(kubectlDownloadingNormalizedArchInjectable, () => "amd64");
-    di.override(normalizedPlatformInjectable, () => "darwin");
-    createCluster = di.inject(createClusterInjectionToken);
-    getCustomKubeConfigFilePath = di.inject(getCustomKubeConfigFilePathInjectable);
-    writeJsonSync = di.inject(writeJsonSyncInjectable);
-    writeFileSync = di.inject(writeFileSyncInjectable);
-    writeBufferSync = di.inject(writeBufferSyncInjectable);
-    readFileSync = di.inject(readFileSyncInjectable);
-    writeFileSyncAndReturnPath = (filePath, contents) => (writeFileSync(filePath, contents), filePath);
-  });
-
-  describe("empty config", () => {
-    beforeEach(async () => {
-      writeJsonSync("/some-directory-for-user-data/lens-cluster-store.json", {});
-      clusterStore = di.inject(clusterStoreInjectable);
-      clusterStore.load();
-    });
-
-    describe("with foo cluster added", () => {
-      beforeEach(() => {
-        const cluster = createCluster({
-          id: "foo",
-          contextName: "foo",
-          preferences: {
-            terminalCWD: "/some-directory-for-user-data",
-            icon: "data:image/jpeg;base64, iVBORw0KGgoAAAANSUhEUgAAA1wAAAKoCAYAAABjkf5",
-            clusterName: "minikube",
-          },
-          kubeConfigPath: writeFileSyncAndReturnPath(
-            getCustomKubeConfigFilePath("foo"),
-            kubeconfig,
-          ),
-        }, {
-          clusterServerUrl,
-        });
-
-        clusterStore.addCluster(cluster);
-      });
-
-      it("adds new cluster to store", async () => {
-        const storedCluster = clusterStore.getById("foo");
-
-        assert(storedCluster);
-
-        expect(storedCluster.id).toBe("foo");
-        expect(storedCluster.preferences.terminalCWD).toBe("/some-directory-for-user-data");
-        expect(storedCluster.preferences.icon).toBe(
-          "data:image/jpeg;base64, iVBORw0KGgoAAAANSUhEUgAAA1wAAAKoCAYAAABjkf5",
-        );
-      });
-    });
-
-    describe("with prod and dev clusters added", () => {
-      beforeEach(() => {
-        const store = clusterStore;
-
-        store.addCluster({
-          id: "prod",
-          contextName: "foo",
-          preferences: {
-            clusterName: "prod",
-          },
-          kubeConfigPath: writeFileSyncAndReturnPath(
-            getCustomKubeConfigFilePath("prod"),
-            kubeconfig,
-          ),
-        });
-        store.addCluster({
-          id: "dev",
-          contextName: "foo2",
-          preferences: {
-            clusterName: "dev",
-          },
-          kubeConfigPath: writeFileSyncAndReturnPath(
-            getCustomKubeConfigFilePath("dev"),
-            kubeconfig,
-          ),
-        });
-      });
-
-      it("check if store can contain multiple clusters", () => {
-        expect(clusterStore.hasClusters()).toBeTruthy();
-        expect(clusterStore.clusters.size).toBe(2);
-      });
-
-      it("check if cluster's kubeconfig file saved", () => {
-        const file = writeFileSyncAndReturnPath(getCustomKubeConfigFilePath("boo"), "kubeconfig");
-
-        expect(readFileSync(file)).toBe("kubeconfig");
-      });
-    });
-  });
-
-  describe("config with existing clusters", () => {
-    beforeEach(() => {
-      writeFileSync("/temp-kube-config", kubeconfig);
-      writeJsonSync("/some-directory-for-user-data/lens-cluster-store.json", {
-        __internal__: {
-          migrations: {
-            version: "99.99.99",
-          },
-        },
-        clusters: [
-          {
-            id: "cluster1",
-            kubeConfigPath: "/temp-kube-config",
-            contextName: "foo",
-            preferences: { terminalCWD: "/foo" },
-            workspace: "default",
-          },
-          {
-            id: "cluster2",
-            kubeConfigPath: "/temp-kube-config",
-            contextName: "foo2",
-            preferences: { terminalCWD: "/foo2" },
-          },
-          {
-            id: "cluster3",
-            kubeConfigPath: "/temp-kube-config",
-            contextName: "foo",
-            preferences: { terminalCWD: "/foo" },
-            workspace: "foo",
-            ownerRef: "foo",
-          },
-        ],
-      });
-      clusterStore = di.inject(clusterStoreInjectable);
-      clusterStore.load();
-    });
-    it("allows to retrieve a cluster", () => {
-      const storedCluster = clusterStore.getById("cluster1");
-
-      assert(storedCluster);
-
-      expect(storedCluster.id).toBe("cluster1");
-      expect(storedCluster.preferences.terminalCWD).toBe("/foo");
-    });
-
-    it("allows getting all of the clusters", async () => {
-      const storedClusters = clusterStore.clustersList;
-
-      expect(storedClusters.length).toBe(3);
-      expect(storedClusters[0].id).toBe("cluster1");
-      expect(storedClusters[0].preferences.terminalCWD).toBe("/foo");
-      expect(storedClusters[1].id).toBe("cluster2");
-      expect(storedClusters[1].preferences.terminalCWD).toBe("/foo2");
-      expect(storedClusters[2].id).toBe("cluster3");
-    });
-  });
-
-  describe("config with invalid cluster kubeconfig", () => {
-    beforeEach(() => {
-      writeFileSync("/invalid-kube-config", invalidKubeconfig);
-      writeFileSync("/valid-kube-config", kubeconfig);
-      writeJsonSync("/some-directory-for-user-data/lens-cluster-store.json", {
-        __internal__: {
-          migrations: {
-            version: "99.99.99",
-          },
-        },
-        clusters: [
-          {
-            id: "cluster1",
-            kubeConfigPath: "/invalid-kube-config",
-            contextName: "test",
-            preferences: { terminalCWD: "/foo" },
-            workspace: "foo",
-          },
-          {
-            id: "cluster2",
-            kubeConfigPath: "/valid-kube-config",
-            contextName: "foo",
-            preferences: { terminalCWD: "/foo" },
-            workspace: "default",
-          },
-        ],
-      });
-      clusterStore = di.inject(clusterStoreInjectable);
-      clusterStore.load();
-    });
-
-    it("does not enable clusters with invalid kubeconfig", () => {
-      const storedClusters = clusterStore.clustersList;
-
-      expect(storedClusters.length).toBe(1);
-    });
-  });
-
-  describe("pre 3.6.0-beta.1 config with an existing cluster", () => {
-    beforeEach(() => {
-      writeJsonSync("/some-directory-for-user-data/lens-cluster-store.json", {
-        __internal__: {
-          migrations: {
-            version: "3.5.0",
-          },
-        },
-        clusters: [
-          {
-            id: "cluster1",
-            kubeConfig: minimalValidKubeConfig,
-            contextName: "cluster",
-            preferences: {
-              icon: "store://icon_path",
-            },
-          },
-        ],
-      });
-      writeBufferSync("/some-directory-for-user-data/icon_path", testDataIcon);
-
-      di.override(storeMigrationVersionInjectable, () => "3.6.0");
-
-      clusterStore = di.inject(clusterStoreInjectable);
-      clusterStore.load();
-    });
-
-    it("migrates to modern format with kubeconfig in a file", async () => {
-      const config = clusterStore.clustersList[0].kubeConfigPath;
-
-      expect(readFileSync(config)).toBe(minimalValidKubeConfig);
-    });
-
-    it("migrates to modern format with icon not in file", async () => {
-      expect(clusterStore.clustersList[0].preferences.icon).toMatch(/data:;base64,/);
-    });
-  });
-});
-
-const invalidKubeconfig = JSON.stringify({
-  apiVersion: "v1",
-  clusters: [{
-    cluster: {
-      server: "https://localhost",
-    },
-    name: "test2",
-  }],
-  contexts: [{
-    context: {
-      cluster: "test",
-      user: "test",
-    },
-    name: "test",
-  }],
-  "current-context": "test",
-  kind: "Config",
-  preferences: {},
-  users: [{
-    user: {
-      token: "kubeconfig-user-q4lm4:xxxyyyy",
-    },
-    name: "test",
-  }],
-});
-
-const minimalValidKubeConfig = JSON.stringify({
-  apiVersion: "v1",
-  clusters: [
-    {
-      name: "minikube",
-      cluster: {
-        server: "https://192.168.64.3:8443",
-      },
-    },
-  ],
-  "current-context": "minikube",
-  contexts: [
-    {
-      context: {
-        cluster: "minikube",
-        user: "minikube",
-      },
-      name: "minikube",
-    },
-  ],
-  users: [
-    {
-      name: "minikube",
-      user: {
-        "client-certificate": "/Users/foo/.minikube/client.crt",
-        "client-key": "/Users/foo/.minikube/client.key",
-      },
-    },
-  ],
-  kind: "Config",
-  preferences: {},
-});

src/common/__tests__/event-emitter.test.ts

@@ -1,86 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { EventEmitter } from "../event-emitter";
-
-describe("EventEmitter", () => {
-  it("should stop early if a listener returns false", () => {
-    let called = false;
-    const e = new EventEmitter<[]>();
-
-    e.addListener(() => false, {});
-    e.addListener(() => { called = true; }, {});
-    e.emit();
-
-    expect(called).toBe(false);
-  });
-
-  it("shouldn't stop early if a listener returns 0", () => {
-    let called = false;
-    const e = new EventEmitter<[]>();
-
-    e.addListener(() => 0 as never, {});
-    e.addListener(() => { called = true; }, {});
-    e.emit();
-
-    expect(called).toBe(true);
-  });
-
-  it("prepended listeners should be called before others", () => {
-    const callOrder: number[] = [];
-    const e = new EventEmitter<[]>();
-
-    e.addListener(() => { callOrder.push(1); }, {});
-    e.addListener(() => { callOrder.push(2); }, {});
-    e.addListener(() => { callOrder.push(3); }, { prepend: true });
-    e.emit();
-
-    expect(callOrder).toStrictEqual([3, 1, 2]);
-  });
-
-  it("once listeners should be called only once", () => {
-    const callOrder: number[] = [];
-    const e = new EventEmitter<[]>();
-
-    e.addListener(() => { callOrder.push(1); }, {});
-    e.addListener(() => { callOrder.push(2); }, {});
-    e.addListener(() => { callOrder.push(3); }, { once: true });
-    e.emit();
-    e.emit();
-
-    expect(callOrder).toStrictEqual([1, 2, 3, 1, 2]);
-  });
-
-  it("removeListener should stop the listener from being called", () => {
-    const callOrder: number[] = [];
-    const e = new EventEmitter<[]>();
-    const r = () => { callOrder.push(3); };
-
-    e.addListener(() => { callOrder.push(1); }, {});
-    e.addListener(() => { callOrder.push(2); }, {});
-    e.addListener(r);
-
-    e.emit();
-    e.removeListener(r);
-    e.emit();
-
-    expect(callOrder).toStrictEqual([1, 2, 3, 1, 2]);
-  });
-
-  it("removeAllListeners should stop the all listeners from being called", () => {
-    const callOrder: number[] = [];
-    const e = new EventEmitter<[]>();
-
-    e.addListener(() => { callOrder.push(1); });
-    e.addListener(() => { callOrder.push(2); });
-    e.addListener(() => { callOrder.push(3); });
-
-    e.emit();
-    e.removeAllListeners();
-    e.emit();
-
-    expect(callOrder).toStrictEqual([1, 2, 3]);
-  });
-});

src/common/__tests__/hotbar-store.test.ts

@@ -1,356 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { anyObject } from "jest-mock-extended";
-import type { CatalogEntity, CatalogEntityData, CatalogEntityKindData } from "../catalog";
-import { getDiForUnitTesting } from "../../main/getDiForUnitTesting";
-import type { DiContainer } from "@ogre-tools/injectable";
-import hotbarStoreInjectable from "../hotbars/store.injectable";
-import type { HotbarStore } from "../hotbars/store";
-import catalogEntityRegistryInjectable from "../../main/catalog/entity-registry.injectable";
-import { computed } from "mobx";
-import hasCategoryForEntityInjectable from "../catalog/has-category-for-entity.injectable";
-import catalogCatalogEntityInjectable from "../catalog-entities/general-catalog-entities/implementations/catalog-catalog-entity.injectable";
-import loggerInjectable from "../logger.injectable";
-import type { Logger } from "../logger";
-import directoryForUserDataInjectable from "../app-paths/directory-for-user-data/directory-for-user-data.injectable";
-import storeMigrationVersionInjectable from "../vars/store-migration-version.injectable";
-import writeJsonSyncInjectable from "../fs/write-json-sync.injectable";
-
-function getMockCatalogEntity(data: Partial<CatalogEntityData> & CatalogEntityKindData): CatalogEntity {
-  return {
-    getName: jest.fn(() => data.metadata?.name),
-    getId: jest.fn(() => data.metadata?.uid),
-    getSource: jest.fn(() => data.metadata?.source ?? "unknown"),
-    isEnabled: jest.fn(() => data.status?.enabled ?? true),
-    onContextMenuOpen: jest.fn(),
-    onSettingsOpen: jest.fn(),
-    metadata: {},
-    spec: {},
-    status: {},
-    ...data,
-  } as CatalogEntity;
-}
-
-describe("HotbarStore", () => {
-  let di: DiContainer;
-  let hotbarStore: HotbarStore;
-  let testCluster: CatalogEntity;
-  let minikubeCluster: CatalogEntity;
-  let awsCluster: CatalogEntity;
-  let loggerMock: jest.Mocked<Logger>;
-
-  beforeEach(async () => {
-    di = getDiForUnitTesting({ doGeneralOverrides: true });
-
-    testCluster = getMockCatalogEntity({
-      apiVersion: "v1",
-      kind: "Cluster",
-      status: {
-        phase: "Running",
-      },
-      metadata: {
-        uid: "some-test-id",
-        name: "my-test-cluster",
-        source: "local",
-        labels: {},
-      },
-    });
-    minikubeCluster = getMockCatalogEntity({
-      apiVersion: "v1",
-      kind: "Cluster",
-      status: {
-        phase: "Running",
-      },
-      metadata: {
-        uid: "some-minikube-id",
-        name: "my-minikube-cluster",
-        source: "local",
-        labels: {},
-      },
-    });
-    awsCluster = getMockCatalogEntity({
-      apiVersion: "v1",
-      kind: "Cluster",
-      status: {
-        phase: "Running",
-      },
-      metadata: {
-        uid: "some-aws-id",
-        name: "my-aws-cluster",
-        source: "local",
-        labels: {},
-      },
-    });
-
-    di.override(hasCategoryForEntityInjectable, () => () => true);
-
-    loggerMock = {
-      warn: jest.fn(),
-      debug: jest.fn(),
-      error: jest.fn(),
-      info: jest.fn(),
-      silly: jest.fn(),
-    };
-
-    di.override(loggerInjectable, () => loggerMock);
-
-    di.override(directoryForUserDataInjectable, () => "/some-directory-for-user-data");
-
-    const catalogEntityRegistry = di.inject(catalogEntityRegistryInjectable);
-    const catalogCatalogEntity = di.inject(catalogCatalogEntityInjectable);
-
-    catalogEntityRegistry.addComputedSource("some-id", computed(() => [
-      testCluster,
-      minikubeCluster,
-      awsCluster,
-      catalogCatalogEntity,
-    ]));
-  });
-
-  describe("given no previous data in store, running all migrations", () => {
-    beforeEach(() => {
-      hotbarStore = di.inject(hotbarStoreInjectable);
-
-      hotbarStore.load();
-    });
-
-    describe("load", () => {
-      it("loads one hotbar by default", () => {
-        expect(hotbarStore.hotbars.length).toEqual(1);
-      });
-    });
-
-    describe("add", () => {
-      it("adds a hotbar", () => {
-        hotbarStore.add({ name: "hottest" });
-        expect(hotbarStore.hotbars.length).toEqual(2);
-      });
-    });
-
-    describe("hotbar items", () => {
-      it("initially creates 12 empty cells", () => {
-        expect(hotbarStore.getActive().items.length).toEqual(12);
-      });
-
-      it("initially adds catalog entity as first item", () => {
-        expect(hotbarStore.getActive().items[0]?.entity.name).toEqual("Catalog");
-      });
-
-      it("adds items", () => {
-        hotbarStore.addToHotbar(testCluster);
-        const items = hotbarStore.getActive().items.filter(Boolean);
-
-        expect(items.length).toEqual(2);
-      });
-
-      it("removes items", () => {
-        hotbarStore.addToHotbar(testCluster);
-        hotbarStore.removeFromHotbar("some-test-id");
-        hotbarStore.removeFromHotbar("catalog-entity");
-        const items = hotbarStore.getActive().items.filter(Boolean);
-
-        expect(items).toStrictEqual([]);
-      });
-
-      it("does nothing if removing with invalid uid", () => {
-        hotbarStore.addToHotbar(testCluster);
-        hotbarStore.removeFromHotbar("invalid uid");
-        const items = hotbarStore.getActive().items.filter(Boolean);
-
-        expect(items.length).toEqual(2);
-      });
-
-      it("moves item to empty cell", () => {
-        hotbarStore.addToHotbar(testCluster);
-        hotbarStore.addToHotbar(minikubeCluster);
-        hotbarStore.addToHotbar(awsCluster);
-
-        expect(hotbarStore.getActive().items[6]).toBeNull();
-
-        hotbarStore.restackItems(1, 5);
-
-        expect(hotbarStore.getActive().items[5]).toBeTruthy();
-        expect(hotbarStore.getActive().items[5]?.entity.uid).toEqual("some-test-id");
-      });
-
-      it("moves items down", () => {
-        hotbarStore.addToHotbar(testCluster);
-        hotbarStore.addToHotbar(minikubeCluster);
-        hotbarStore.addToHotbar(awsCluster);
-
-        // aws -> catalog
-        hotbarStore.restackItems(3, 0);
-
-        const items = hotbarStore.getActive().items.map(item => item?.entity.uid || null);
-
-        expect(items.slice(0, 4)).toEqual(["some-aws-id", "catalog-entity", "some-test-id", "some-minikube-id"]);
-      });
-
-      it("moves items up", () => {
-        hotbarStore.addToHotbar(testCluster);
-        hotbarStore.addToHotbar(minikubeCluster);
-        hotbarStore.addToHotbar(awsCluster);
-
-        // test -> aws
-        hotbarStore.restackItems(1, 3);
-
-        const items = hotbarStore.getActive().items.map(item => item?.entity.uid || null);
-
-        expect(items.slice(0, 4)).toEqual(["catalog-entity", "some-minikube-id", "some-aws-id", "some-test-id"]);
-      });
-
-      it("logs an error if cellIndex is out of bounds", () => {
-        hotbarStore.add({ name: "hottest", id: "hottest" });
-        hotbarStore.setActiveHotbar("hottest");
-
-        hotbarStore.addToHotbar(testCluster, -1);
-        expect(loggerMock.error).toBeCalledWith("[HOTBAR-STORE]: cannot pin entity to hotbar outside of index range", anyObject());
-
-        hotbarStore.addToHotbar(testCluster, 12);
-        expect(loggerMock.error).toBeCalledWith("[HOTBAR-STORE]: cannot pin entity to hotbar outside of index range", anyObject());
-
-        hotbarStore.addToHotbar(testCluster, 13);
-        expect(loggerMock.error).toBeCalledWith("[HOTBAR-STORE]: cannot pin entity to hotbar outside of index range", anyObject());
-      });
-
-      it("throws an error if getId is invalid or returns not a string", () => {
-        expect(() => hotbarStore.addToHotbar({} as any)).toThrowError(TypeError);
-        expect(() => hotbarStore.addToHotbar({ getId: () => true } as any)).toThrowError(TypeError);
-      });
-
-      it("throws an error if getName is invalid or returns not a string", () => {
-        expect(() => hotbarStore.addToHotbar({ getId: () => "" } as any)).toThrowError(TypeError);
-        expect(() => hotbarStore.addToHotbar({ getId: () => "", getName: () => 4 } as any)).toThrowError(TypeError);
-      });
-
-      it("does nothing when item moved to same cell", () => {
-        hotbarStore.addToHotbar(testCluster);
-        hotbarStore.restackItems(1, 1);
-
-        expect(hotbarStore.getActive().items[1]?.entity.uid).toEqual("some-test-id");
-      });
-
-      it("new items takes first empty cell", () => {
-        hotbarStore.addToHotbar(testCluster);
-        hotbarStore.addToHotbar(awsCluster);
-        hotbarStore.restackItems(0, 3);
-        hotbarStore.addToHotbar(minikubeCluster);
-
-        expect(hotbarStore.getActive().items[0]?.entity.uid).toEqual("some-minikube-id");
-      });
-
-      it("throws if invalid arguments provided", () => {
-        hotbarStore.addToHotbar(testCluster);
-
-        expect(() => hotbarStore.restackItems(-5, 0)).toThrow();
-        expect(() => hotbarStore.restackItems(2, -1)).toThrow();
-        expect(() => hotbarStore.restackItems(14, 1)).toThrow();
-        expect(() => hotbarStore.restackItems(11, 112)).toThrow();
-      });
-
-      it("checks if entity already pinned to hotbar", () => {
-        hotbarStore.addToHotbar(testCluster);
-
-        expect(hotbarStore.isAddedToActive(testCluster)).toBeTruthy();
-        expect(hotbarStore.isAddedToActive(awsCluster)).toBeFalsy();
-      });
-    });
-  });
-
-  describe("given data from 5.0.0-beta.3 and version being 5.0.0-beta.10", () => {
-    beforeEach(() => {
-      const writeJsonSync = di.inject(writeJsonSyncInjectable);
-
-      writeJsonSync("/some-directory-for-user-data/lens-hotbar-store.json", {
-        __internal__: {
-          migrations: {
-            version: "5.0.0-beta.3",
-          },
-        },
-        hotbars: [
-          {
-            id: "3caac17f-aec2-4723-9694-ad204465d935",
-            name: "myhotbar",
-            items: [
-              {
-                entity: {
-                  uid: "some-aws-id",
-                },
-              },
-              {
-                entity: {
-                  uid: "55b42c3c7ba3b04193416cda405269a5",
-                },
-              },
-              {
-                entity: {
-                  uid: "176fd331968660832f62283219d7eb6e",
-                },
-              },
-              {
-                entity: {
-                  uid: "61c4fb45528840ebad1badc25da41d14",
-                  name: "user1-context",
-                  source: "local",
-                },
-              },
-              {
-                entity: {
-                  uid: "27d6f99fe9e7548a6e306760bfe19969",
-                  name: "foo2",
-                  source: "local",
-                },
-              },
-              null,
-              {
-                entity: {
-                  uid: "c0b20040646849bb4dcf773e43a0bf27",
-                  name: "multinode-demo",
-                  source: "local",
-                },
-              },
-              null,
-              null,
-              null,
-              null,
-              null,
-            ],
-          },
-        ],
-      });
-
-      di.override(storeMigrationVersionInjectable, () => "5.0.0-beta.10");
-
-      hotbarStore = di.inject(hotbarStoreInjectable);
-
-      hotbarStore.load();
-    });
-
-    it("allows to retrieve a hotbar", () => {
-      const hotbar = hotbarStore.findById("3caac17f-aec2-4723-9694-ad204465d935");
-
-      expect(hotbar?.id).toBe("3caac17f-aec2-4723-9694-ad204465d935");
-    });
-
-    it("clears cells without entity", () => {
-      const items = hotbarStore.hotbars[0].items;
-
-      expect(items[2]).toBeNull();
-    });
-
-    it("adds extra data to cells with according entity", () => {
-      const items = hotbarStore.hotbars[0].items;
-
-      expect(items[0]).toEqual({
-        entity: {
-          name: "my-aws-cluster",
-          source: "local",
-          uid: "some-aws-id",
-        },
-      });
-    });
-  });
-});

src/common/__tests__/kube-helpers.test.ts

@@ -1,235 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { KubeConfig } from "@kubernetes/client-node";
-import { validateKubeConfig, loadConfigFromString } from "../kube-helpers";
-
-const kubeconfig = `
-apiVersion: v1
-clusters:
-- cluster:
-    server: https://localhost
-  name: test
-contexts:
-- context:
-    cluster: test
-    user: test
-  name: valid
-- context:
-    cluster: test2
-    user: test
-  name: invalidCluster
-- context:
-    cluster: test
-    user: test2
-  name: invalidUser
-- context:
-    cluster: test
-    user: invalidExec
-  name: invalidExec
-current-context: test
-kind: Config
-preferences: {}
-users:
-- name: test
-  user:
-    exec:
-      command: echo
-- name: invalidExec
-  user:
-    exec:
-      command: foo
-`;
-
-interface Kubeconfig {
-  apiVersion: string;
-  clusters: [{
-    name: string;
-    cluster: {
-      server: string;
-    };
-  }];
-  contexts: [{
-    context: {
-      cluster: string;
-      user: string;
-    };
-    name: string;
-  }];
-  users: [{
-    name: string;
-  }];
-  kind: string;
-  "current-context": string;
-  preferences: {};
-}
-
-let mockKubeConfig: Kubeconfig;
-
-describe("kube helpers", () => {
-  describe("validateKubeconfig", () => {
-    const kc = new KubeConfig();
-
-    beforeAll(() => {
-      kc.loadFromString(kubeconfig);
-    });
-    describe("with default validation options", () => {
-      describe("with valid kubeconfig", () => {
-        it("does not return an error", () => {
-          expect(validateKubeConfig(kc, "valid")).toBeDefined();
-        });
-      });
-      describe("with invalid context object", () => {
-        it("returns an error", () => {
-          expect(validateKubeConfig(kc, "invalid").error?.toString()).toEqual(
-            expect.stringContaining("No valid context object provided in kubeconfig for context 'invalid'"),
-          );
-        });
-      });
-
-      describe("with invalid cluster object", () => {
-        it("returns an error", () => {
-          expect(validateKubeConfig(kc, "invalidCluster").error?.toString()).toEqual(
-            expect.stringContaining("No valid cluster object provided in kubeconfig for context 'invalidCluster'"),
-          );
-        });
-      });
-
-      describe("with invalid user object", () => {
-        it("returns an error", () => {
-          expect(validateKubeConfig(kc, "invalidUser").error?.toString()).toEqual(
-            expect.stringContaining("No valid user object provided in kubeconfig for context 'invalidUser'"),
-          );
-        });
-      });
-    });
-  });
-
-  describe("pre-validate context object in kubeconfig tests", () => {
-    beforeEach(() => {
-      jest.clearAllMocks();
-    });
-
-    describe("Check logger.error() output", () => {
-      it("invalid yaml string", () => {
-        const invalidYAMLString = "fancy foo config";
-
-        expect(loadConfigFromString(invalidYAMLString).error).toBeInstanceOf(Error);
-      });
-      it("empty contexts", () => {
-        const emptyContexts = `apiVersion: v1\ncontexts: []`;
-
-        expect(loadConfigFromString(emptyContexts).error).toBeUndefined();
-      });
-    });
-
-    describe("Check valid kubeconfigs", () => {
-      beforeEach(() => {
-        mockKubeConfig = {
-          apiVersion: "v1",
-          clusters: [{
-            name: "minikube",
-            cluster: {
-              server: "https://192.168.64.3:8443",
-            },
-          }],
-          contexts: [{
-            context: {
-              cluster: "minikube",
-              user: "minikube",
-            },
-            name: "minikube",
-          }],
-          users: [{
-            name: "minikube",
-          }],
-          kind: "Config",
-          "current-context": "minikube",
-          preferences: {},
-        };
-      });
-
-      it("single context is ok", async () => {
-        const { config } = loadConfigFromString(JSON.stringify(mockKubeConfig));
-
-        expect(config.getCurrentContext()).toBe("minikube");
-      });
-
-      it("multiple context is ok", async () => {
-        mockKubeConfig.contexts.push({ context: { cluster: "cluster-2", user: "cluster-2" }, name: "cluster-2" });
-        const { config } = loadConfigFromString(JSON.stringify(mockKubeConfig));
-
-        expect(config.getCurrentContext()).toBe("minikube");
-        expect(config.contexts.length).toBe(2);
-      });
-    });
-
-    describe("Check invalid kubeconfigs", () => {
-      beforeEach(() => {
-        mockKubeConfig = {
-          apiVersion: "v1",
-          clusters: [{
-            name: "minikube",
-            cluster: {
-              server: "https://192.168.64.3:8443",
-            },
-          }],
-          contexts: [{
-            context: {
-              cluster: "minikube",
-              user: "minikube",
-            },
-            name: "minikube",
-          }],
-          users: [{
-            name: "minikube",
-          }],
-          kind: "Config",
-          "current-context": "minikube",
-          preferences: {},
-        };
-      });
-
-      it("empty name in context causes it to be removed", async () => {
-        mockKubeConfig.contexts.push({ context: { cluster: "cluster-2", user: "cluster-2" }, name: "" });
-        expect(mockKubeConfig.contexts.length).toBe(2);
-        const { config } = loadConfigFromString(JSON.stringify(mockKubeConfig));
-
-        expect(config.getCurrentContext()).toBe("minikube");
-        expect(config.contexts.length).toBe(1);
-      });
-
-      it("empty cluster in context causes it to be removed", async () => {
-        mockKubeConfig.contexts.push({ context: { cluster: "", user: "cluster-2" }, name: "cluster-2" });
-        expect(mockKubeConfig.contexts.length).toBe(2);
-        const { config } = loadConfigFromString(JSON.stringify(mockKubeConfig));
-
-        expect(config.getCurrentContext()).toBe("minikube");
-        expect(config.contexts.length).toBe(1);
-      });
-
-      it("empty user in context causes it to be removed", async () => {
-        mockKubeConfig.contexts.push({ context: { cluster: "cluster-2", user: "" }, name: "cluster-2" });
-        expect(mockKubeConfig.contexts.length).toBe(2);
-        const { config } = loadConfigFromString(JSON.stringify(mockKubeConfig));
-
-        expect(config.getCurrentContext()).toBe("minikube");
-        expect(config.contexts.length).toBe(1);
-      });
-
-      it("invalid context in between valid contexts is removed", async () => {
-        mockKubeConfig.contexts.push({ context: { cluster: "cluster-2", user: "" }, name: "cluster-2" });
-        mockKubeConfig.contexts.push({ context: { cluster: "cluster-3", user: "cluster-3" }, name: "cluster-3" });
-        expect(mockKubeConfig.contexts.length).toBe(3);
-        const { config } = loadConfigFromString(JSON.stringify(mockKubeConfig));
-
-        expect(config.getCurrentContext()).toBe("minikube");
-        expect(config.contexts.length).toBe(2);
-        expect(config.contexts[0].name).toBe("minikube");
-        expect(config.contexts[1].name).toBe("cluster-3");
-      });
-    });
-  });
-});

src/common/__tests__/timezones.test.ts

@@ -1,12 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-describe("Timezones", () => {
-  it("should always be UTC", () => {
-    expect(new Date().getTimezoneOffset()).toBe(0);
-  });
-});
-
-export {};

src/common/__tests__/user-store.test.ts

@@ -1,105 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import type { UserStore } from "../user-store";
-import userStoreInjectable from "../user-store/user-store.injectable";
-import type { DiContainer } from "@ogre-tools/injectable";
-import directoryForUserDataInjectable from "../app-paths/directory-for-user-data/directory-for-user-data.injectable";
-import type { ClusterStoreModel } from "../cluster-store/cluster-store";
-import { defaultThemeId } from "../vars";
-import writeFileInjectable from "../fs/write-file.injectable";
-import { getDiForUnitTesting } from "../../main/getDiForUnitTesting";
-import storeMigrationVersionInjectable from "../vars/store-migration-version.injectable";
-import releaseChannelInjectable from "../vars/release-channel.injectable";
-import defaultUpdateChannelInjectable from "../../features/application-update/common/selected-update-channel/default-update-channel.injectable";
-import writeJsonSyncInjectable from "../fs/write-json-sync.injectable";
-import writeFileSyncInjectable from "../fs/write-file-sync.injectable";
-
-describe("user store tests", () => {
-  let userStore: UserStore;
-  let di: DiContainer;
-
-  beforeEach(async () => {
-    di = getDiForUnitTesting({ doGeneralOverrides: true });
-
-    di.override(writeFileInjectable, () => () => Promise.resolve());
-    di.override(directoryForUserDataInjectable, () => "/some-directory-for-user-data");
-
-    di.override(releaseChannelInjectable, () => ({
-      get: () => "latest" as const,
-      init: async () => {},
-    }));
-    await di.inject(defaultUpdateChannelInjectable).init();
-
-    userStore = di.inject(userStoreInjectable);
-  });
-
-  describe("for an empty config", () => {
-    beforeEach(() => {
-      const writeJsonSync = di.inject(writeJsonSyncInjectable);
-
-      writeJsonSync("/some-directory-for-user-data/lens-user-store.json", {});
-      writeJsonSync("/some-directory-for-user-data/kube_config", {});
-
-      userStore.load();
-    });
-
-    it("allows setting and getting preferences", () => {
-      userStore.httpsProxy = "abcd://defg";
-
-      expect(userStore.httpsProxy).toBe("abcd://defg");
-      expect(userStore.colorTheme).toBe(defaultThemeId);
-
-      userStore.colorTheme = "light";
-      expect(userStore.colorTheme).toBe("light");
-    });
-
-    it("correctly resets theme to default value", async () => {
-      userStore.colorTheme = "some other theme";
-      userStore.resetTheme();
-      expect(userStore.colorTheme).toBe(defaultThemeId);
-    });
-  });
-
-  describe("migrations", () => {
-    beforeEach(() => {
-      const writeJsonSync = di.inject(writeJsonSyncInjectable);
-      const writeFileSync = di.inject(writeFileSyncInjectable);
-
-      writeJsonSync("/some-directory-for-user-data/lens-user-store.json", {
-        preferences: { colorTheme: "light" },
-      });
-
-      writeJsonSync("/some-directory-for-user-data/lens-cluster-store.json", {
-        clusters: [
-          {
-            id: "foobar",
-            kubeConfigPath: "/some-directory-for-user-data/extension_data/foo/bar",
-          },
-          {
-            id: "barfoo",
-            kubeConfigPath: "/some/other/path",
-          },
-        ],
-      } as ClusterStoreModel);
-
-      writeJsonSync("/some-directory-for-user-data/extension_data", {});
-
-      writeFileSync("/some/other/path", "is file");
-
-      di.override(storeMigrationVersionInjectable, () => "10.0.0");
-
-      userStore.load();
-    });
-
-    it("skips clusters for adding to kube-sync with files under extension_data/", () => {
-      expect(userStore.syncKubeconfigEntries.has("/some-directory-for-user-data/extension_data/foo/bar")).toBe(false);
-      expect(userStore.syncKubeconfigEntries.has("/some/other/path")).toBe(true);
-    });
-
-    it("allows access to the colorTheme preference", () => {
-      expect(userStore.colorTheme).toBe("light");
-    });
-  });
-});

src/common/app-event-bus/app-event-bus.injectable.ts

@@ -1,15 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import { EventEmitter } from "../event-emitter";
-import type { AppEvent } from "./event-bus";
-
-const appEventBusInjectable = getInjectable({
-  id: "app-event-bus",
-  instantiate: () => new EventEmitter<[AppEvent]>,
-  decorable: false,
-});
-
-export default appEventBusInjectable;

src/common/app-event-bus/emit-event.injectable.ts

@@ -1,21 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import appEventBusInjectable from "./app-event-bus.injectable";
-import type { AppEvent } from "./event-bus";
-
-export type EmitAppEvent = (event: AppEvent) => void;
-
-const emitAppEventInjectable = getInjectable({
-  id: "emit-app-event",
-  instantiate: (di): EmitAppEvent => {
-    const bus = di.inject(appEventBusInjectable);
-
-    return (event) => bus.emit(event);
-  },
-  decorable: false,
-});
-
-export default emitAppEventInjectable;

src/common/app-event-bus/event-bus.ts

@@ -1,14 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-/**
- * Data for telemetry
- */
-export interface AppEvent {
-  name: string;
-  action: string;
-  destination?: string;
-  params?: Record<string, any>;
-}

src/common/app-paths/app-path-injection-token.ts

@@ -1,7 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import type { PathName } from "./app-path-names";
-
-export type AppPaths = Record<PathName, string>;

src/common/app-paths/app-path-names.ts

@@ -1,27 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import type { app as electronApp } from "electron";
-
-export type PathName = Parameters<typeof electronApp["getPath"]>[0] | "currentApp";
-
-export const pathNames: PathName[] = [
-  "currentApp",
-  "home",
-  "appData",
-  "userData",
-  "cache",
-  "temp",
-  "exe",
-  "module",
-  "desktop",
-  "documents",
-  "downloads",
-  "music",
-  "pictures",
-  "videos",
-  "logs",
-  "crashDumps",
-  "recent",
-];

src/common/app-paths/app-paths-channel.ts

@@ -1,13 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import type { AppPaths } from "./app-path-injection-token";
-import type { RequestChannel } from "../utils/channel/request-channel-listener-injection-token";
-
-export type AppPathsChannel = RequestChannel<void, AppPaths>;
-
-export const appPathsChannel: AppPathsChannel = {
-  id: "app-paths",
-};
-

src/common/app-paths/app-paths-state.injectable.ts

@@ -1,34 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import type { AppPaths } from "./app-path-injection-token";
-
-const appPathsStateInjectable = getInjectable({
-  id: "app-paths-state",
-
-  instantiate: () => {
-    let state: AppPaths;
-
-    return {
-      get: () =>{
-        if (!state) {
-          throw new Error("Tried to get app paths before state is setupped.");
-        }
-
-        return state;
-      },
-
-      set: (newState: AppPaths) => {
-        if (state) {
-          throw new Error("Tried to overwrite existing state of app paths.");
-        }
-
-        state = newState;
-      },
-    };
-  },
-});
-
-export default appPathsStateInjectable;

src/common/app-paths/app-paths.injectable.ts

@@ -1,13 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import appPathsStateInjectable from "./app-paths-state.injectable";
-
-const appPathsInjectable = getInjectable({
-  id: "app-paths",
-  instantiate: (di) => di.inject(appPathsStateInjectable).get(),
-});
-
-export default appPathsInjectable;

src/common/app-paths/app-paths.test.ts

@@ -1,153 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import type { AppPaths } from "./app-path-injection-token";
-import getElectronAppPathInjectable from "../../main/app-paths/get-electron-app-path/get-electron-app-path.injectable";
-import type { PathName } from "./app-path-names";
-import setElectronAppPathInjectable from "../../main/app-paths/set-electron-app-path/set-electron-app-path.injectable";
-import directoryForIntegrationTestingInjectable from "../../main/app-paths/directory-for-integration-testing/directory-for-integration-testing.injectable";
-import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
-import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
-import type { DiContainer } from "@ogre-tools/injectable";
-import appPathsInjectable from "./app-paths.injectable";
-
-describe("app-paths", () => {
-  let builder: ApplicationBuilder;
-
-  beforeEach(() => {
-    builder = getApplicationBuilder();
-
-    const defaultAppPathsStub: AppPaths = {
-      currentApp: "/some-current-app",
-      appData: "/some-app-data",
-      cache: "/some-cache",
-      crashDumps: "/some-crash-dumps",
-      desktop: "/some-desktop",
-      documents: "/some-documents",
-      downloads: "/some-downloads",
-      exe: "/some-exe",
-      home: "/some-home-path",
-      logs: "/some-logs",
-      module: "/some-module",
-      music: "/some-music",
-      pictures: "/some-pictures",
-      recent: "/some-recent",
-      temp: "/some-temp",
-      videos: "/some-videos",
-      userData: "/some-irrelevant-user-data",
-    };
-
-    builder.beforeApplicationStart((mainDi) => {
-      mainDi.override(
-        getElectronAppPathInjectable,
-        () =>
-          (key: PathName): string | null =>
-            defaultAppPathsStub[key],
-      );
-
-      mainDi.override(
-        setElectronAppPathInjectable,
-        () =>
-          (key: PathName, path: string): void => {
-            defaultAppPathsStub[key] = path;
-          },
-      );
-    });
-  });
-
-  describe("normally", () => {
-    let windowDi: DiContainer;
-    let mainDi: DiContainer;
-
-    beforeEach(async () => {
-      await builder.render();
-
-      windowDi = builder.applicationWindow.only.di;
-      mainDi = builder.mainDi;
-    });
-
-    it("given in renderer, when injecting app paths, returns application specific app paths", () => {
-      const actual = windowDi.inject(appPathsInjectable);
-
-      expect(actual).toEqual({
-        currentApp: "/some-current-app",
-        appData: "/some-app-data",
-        cache: "/some-cache",
-        crashDumps: "/some-crash-dumps",
-        desktop: "/some-desktop",
-        documents: "/some-documents",
-        downloads: "/some-downloads",
-        exe: "/some-exe",
-        home: "/some-home-path",
-        logs: "/some-logs",
-        module: "/some-module",
-        music: "/some-music",
-        pictures: "/some-pictures",
-        recent: "/some-recent",
-        temp: "/some-temp",
-        videos: "/some-videos",
-        userData: "/some-app-data/some-product-name",
-      });
-    });
-
-    it("given in main, when injecting app paths, returns application specific app paths", () => {
-      const actual = mainDi.inject(appPathsInjectable);
-
-      expect(actual).toEqual({
-        currentApp: "/some-current-app",
-        appData: "/some-app-data",
-        cache: "/some-cache",
-        crashDumps: "/some-crash-dumps",
-        desktop: "/some-desktop",
-        documents: "/some-documents",
-        downloads: "/some-downloads",
-        exe: "/some-exe",
-        home: "/some-home-path",
-        logs: "/some-logs",
-        module: "/some-module",
-        music: "/some-music",
-        pictures: "/some-pictures",
-        recent: "/some-recent",
-        temp: "/some-temp",
-        videos: "/some-videos",
-        userData: "/some-app-data/some-product-name",
-      });
-    });
-  });
-
-  describe("when running integration tests", () => {
-    let windowDi: DiContainer;
-
-    beforeEach(async () => {
-      builder.beforeApplicationStart((mainDi) => {
-        mainDi.override(
-          directoryForIntegrationTestingInjectable,
-          () => "/some-integration-testing-app-data",
-        );
-      });
-
-      await builder.render();
-
-      windowDi = builder.applicationWindow.only.di;
-    });
-
-    it("given in renderer, when injecting path for app data, has integration specific app data path", () => {
-      const { appData, userData } = windowDi.inject(appPathsInjectable);
-
-      expect({ appData, userData }).toEqual({
-        appData: "/some-integration-testing-app-data",
-        userData: "/some-integration-testing-app-data/some-product-name",
-      });
-    });
-
-    it("given in main, when injecting path for app data, has integration specific app data path", () => {
-      const { appData, userData } = windowDi.inject(appPathsInjectable);
-
-      expect({ appData, userData }).toEqual({
-        appData: "/some-integration-testing-app-data",
-        userData: "/some-integration-testing-app-data/some-product-name",
-      });
-    });
-  });
-});

src/common/app-paths/directory-for-binaries/directory-for-binaries.injectable.ts

@@ -1,20 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import directoryForUserDataInjectable from "../directory-for-user-data/directory-for-user-data.injectable";
-import joinPathsInjectable from "../../path/join-paths.injectable";
-
-const directoryForBinariesInjectable = getInjectable({
-  id: "directory-for-binaries",
-
-  instantiate: (di) => {
-    const joinPaths = di.inject(joinPathsInjectable);
-    const directoryForUserData = di.inject(directoryForUserDataInjectable);
-
-    return joinPaths(directoryForUserData, "binaries");
-  },
-});
-
-export default directoryForBinariesInjectable;

src/common/app-paths/directory-for-downloads/directory-for-downloads.injectable.ts

@@ -1,13 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import appPathsInjectable from "../app-paths.injectable";
-
-const directoryForDownloadsInjectable = getInjectable({
-  id: "directory-for-downloads",
-  instantiate: (di) => di.inject(appPathsInjectable).downloads,
-});
-
-export default directoryForDownloadsInjectable;

src/common/app-paths/directory-for-exes/directory-for-exes.injectable.ts

@@ -1,13 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import appPathsInjectable from "../app-paths.injectable";
-
-const directoryForExesInjectable = getInjectable({
-  id: "directory-for-exes",
-  instantiate: (di) => di.inject(appPathsInjectable).exe,
-});
-
-export default directoryForExesInjectable;

src/common/app-paths/directory-for-kube-configs/directory-for-kube-configs.injectable.ts

@@ -1,20 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import directoryForUserDataInjectable from "../directory-for-user-data/directory-for-user-data.injectable";
-import joinPathsInjectable from "../../path/join-paths.injectable";
-
-const directoryForKubeConfigsInjectable = getInjectable({
-  id: "directory-for-kube-configs",
-
-  instantiate: (di) => {
-    const joinPaths = di.inject(joinPathsInjectable);
-    const directoryForUserData = di.inject(directoryForUserDataInjectable);
-
-    return joinPaths(directoryForUserData, "kubeconfigs");
-  },
-});
-
-export default directoryForKubeConfigsInjectable;

src/common/app-paths/directory-for-kubectl-binaries/directory-for-kubectl-binaries.injectable.ts

@@ -1,20 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import directoryForBinariesInjectable from "../directory-for-binaries/directory-for-binaries.injectable";
-import joinPathsInjectable from "../../path/join-paths.injectable";
-
-const directoryForKubectlBinariesInjectable = getInjectable({
-  id: "directory-for-kubectl-binaries",
-
-  instantiate: (di) => {
-    const joinPaths = di.inject(joinPathsInjectable);
-    const directoryForBinaries = di.inject(directoryForBinariesInjectable);
-
-    return joinPaths(directoryForBinaries, "kubectl");
-  },
-});
-
-export default directoryForKubectlBinariesInjectable;

src/common/app-paths/directory-for-logs.injectable.ts

@@ -1,13 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import appPathsInjectable from "./app-paths.injectable";
-
-const directoryForLogsInjectable = getInjectable({
-  id: "directory-for-logs",
-  instantiate: (di) => di.inject(appPathsInjectable).logs,
-});
-
-export default directoryForLogsInjectable;

src/common/app-paths/directory-for-temp/directory-for-temp.injectable.ts

@@ -1,13 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import appPathsInjectable from "../app-paths.injectable";
-
-const directoryForTempInjectable = getInjectable({
-  id: "directory-for-temp",
-  instantiate: (di) => di.inject(appPathsInjectable).temp,
-});
-
-export default directoryForTempInjectable;

src/common/app-paths/directory-for-user-data/directory-for-user-data.injectable.ts

@@ -1,13 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import appPathsInjectable from "../app-paths.injectable";
-
-const directoryForUserDataInjectable = getInjectable({
-  id: "directory-for-user-data",
-  instantiate: (di) => di.inject(appPathsInjectable).userData,
-});
-
-export default directoryForUserDataInjectable;

src/common/app-paths/get-custom-kube-config-directory/get-custom-kube-config-directory.injectable.ts

@@ -1,22 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import directoryForKubeConfigsInjectable from "../directory-for-kube-configs/directory-for-kube-configs.injectable";
-import joinPathsInjectable from "../../path/join-paths.injectable";
-
-export type GetCustomKubeConfigFilePath = (fileName: string) => string;
-
-const getCustomKubeConfigFilePathInjectable = getInjectable({
-  id: "get-custom-kube-config-directory",
-
-  instantiate: (di): GetCustomKubeConfigFilePath => {
-    const directoryForKubeConfigs = di.inject(directoryForKubeConfigsInjectable);
-    const joinPaths = di.inject(joinPathsInjectable);
-
-    return (fileName) => joinPaths(directoryForKubeConfigs, fileName);
-  },
-});
-
-export default getCustomKubeConfigFilePathInjectable;

src/common/app-paths/path-to-npm-cli.global-override-for-injectable.ts

@@ -1,9 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { getGlobalOverride } from "../test-utils/get-global-override";
-import pathToNpmCliInjectable from "./path-to-npm-cli.injectable";
-
-export default getGlobalOverride(pathToNpmCliInjectable, () => "/some/npm/cli/path");

src/common/app-paths/path-to-npm-cli.injectable.ts

@@ -1,13 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-
-const pathToNpmCliInjectable = getInjectable({
-  id: "path-to-npm-cli",
-  instantiate: () => __non_webpack_require__.resolve("npm"),
-  causesSideEffects: true,
-});
-
-export default pathToNpmCliInjectable;

src/common/base-store/base-store.ts

@@ -1,148 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type Config from "conf";
-import type { Migrations, Options as ConfOptions } from "conf/dist/source/types";
-import type { IEqualsComparer } from "mobx";
-import { makeObservable, reaction } from "mobx";
-import { disposer, isPromiseLike, toJS } from "../utils";
-import { broadcastMessage } from "../ipc";
-import isEqual from "lodash/isEqual";
-import { kebabCase } from "lodash";
-import type { GetConfigurationFileModel } from "../get-configuration-file-model/get-configuration-file-model.injectable";
-import type { Logger } from "../logger";
-import type { PersistStateToConfig } from "./save-to-file";
-import type { GetBasenameOfPath } from "../path/get-basename.injectable";
-import type { EnlistMessageChannelListener } from "../utils/channel/enlist-message-channel-listener-injection-token";
-
-export interface BaseStoreParams<T> extends Omit<ConfOptions<T>, "migrations"> {
-  syncOptions?: {
-    fireImmediately?: boolean;
-    equals?: IEqualsComparer<T>;
-  };
-  configName: string;
-}
-
-export interface IpcChannelPrefixes {
-  local: string;
-  remote: string;
-}
-
-export interface BaseStoreDependencies {
-  readonly logger: Logger;
-  readonly storeMigrationVersion: string;
-  readonly directoryForUserData: string;
-  readonly migrations: Migrations<Record<string, unknown>>;
-  readonly ipcChannelPrefixes: IpcChannelPrefixes;
-  readonly shouldDisableSyncInListener: boolean;
-  getConfigurationFileModel: GetConfigurationFileModel;
-  persistStateToConfig: PersistStateToConfig;
-  getBasenameOfPath: GetBasenameOfPath;
-  enlistMessageChannelListener: EnlistMessageChannelListener;
-}
-
-/**
- * Note: T should only contain base JSON serializable types.
- */
-export abstract class BaseStore<T extends object> {
-  private readonly syncDisposers = disposer();
-
-  readonly displayName = kebabCase(this.params.configName).toUpperCase();
-
-  protected constructor(
-    protected readonly dependencies: BaseStoreDependencies,
-    protected readonly params: BaseStoreParams<T>,
-  ) {
-    makeObservable(this);
-  }
-
-  /**
-   * This must be called after the last child's constructor is finished (or just before it finishes)
-   */
-  load() {
-    this.dependencies.logger.info(`[${this.displayName}]: LOADING ...`);
-
-    const config = this.dependencies.getConfigurationFileModel({
-      projectName: "lens",
-      projectVersion: this.dependencies.storeMigrationVersion,
-      cwd: this.cwd(),
-      ...this.params,
-      migrations: this.dependencies.migrations as Migrations<T>,
-    });
-
-    const res = this.fromStore(config.store);
-
-    if (isPromiseLike(res)) {
-      this.dependencies.logger.error(`${this.displayName} extends BaseStore<T>'s fromStore method returns a Promise or promise-like object. This is an error and must be fixed.`);
-    }
-
-    this.startSyncing(config);
-    this.dependencies.logger.info(`[${this.displayName}]: LOADED from ${config.path}`);
-  }
-
-  protected cwd() {
-    return this.dependencies.directoryForUserData;
-  }
-
-  private startSyncing(config: Config<T>) {
-    const name = this.dependencies.getBasenameOfPath(config.path);
-
-    const disableSync = () => this.syncDisposers();
-    const enableSync = () => {
-      this.syncDisposers.push(
-        reaction(
-          () => toJS(this.toJSON()), // unwrap possible observables and react to everything
-          model => {
-            this.dependencies.persistStateToConfig(config, model);
-            broadcastMessage(`${this.dependencies.ipcChannelPrefixes.remote}:${config.path}`, model);
-          },
-          this.params.syncOptions,
-        ),
-        this.dependencies.enlistMessageChannelListener({
-          channel: {
-            id: `${this.dependencies.ipcChannelPrefixes.local}:${config.path}`,
-          },
-          handler: (model) => {
-            this.dependencies.logger.silly(`[${this.displayName}]: syncing ${name}`, { model });
-
-            if (this.dependencies.shouldDisableSyncInListener) {
-              disableSync();
-            }
-
-            // todo: use "resourceVersion" if merge required (to avoid equality checks => better performance)
-            if (!isEqual(this.toJSON(), model)) {
-              this.fromStore(model as T);
-            }
-
-            if (this.dependencies.shouldDisableSyncInListener) {
-              enableSync();
-            }
-          },
-        }),
-      );
-    };
-
-    enableSync();
-  }
-
-  /**
-   * fromStore is called internally when a child class syncs with the file
-   * system.
-   *
-   * Note: This function **must** be synchronous.
-   *
-   * @param data the parsed information read from the stored JSON file
-   */
-  protected abstract fromStore(data: T): void;
-
-  /**
-   * toJSON is called when syncing the store to the filesystem. It should
-   * produce a JSON serializable object representation of the current state.
-   *
-   * It is recommended that a round trip is valid. Namely, calling
-   * `this.fromStore(this.toJSON())` shouldn't change the state.
-   */
-  abstract toJSON(): T;
-}

src/common/base-store/channel-prefix.ts

@@ -1,11 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type { IpcChannelPrefixes } from "./base-store";
-
-export const baseStoreIpcChannelPrefixesInjectionToken = getInjectionToken<IpcChannelPrefixes>({
-  id: "base-store-ipc-channel-prefix-token",
-});

src/common/base-store/disable-sync.ts

@@ -1,10 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { getInjectionToken } from "@ogre-tools/injectable";
-
-export const shouldBaseStoreDisableSyncInIpcListenerInjectionToken = getInjectionToken<boolean>({
-  id: "should-base-store-disable-sync-in-ipc-listener-token",
-});

src/common/base-store/migrations.injectable.ts

@@ -1,46 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import type { InjectionToken } from "@ogre-tools/injectable";
-import { lifecycleEnum, getInjectable } from "@ogre-tools/injectable";
-import type Conf from "conf/dist/source";
-import type { Migrations } from "conf/dist/source/types";
-import loggerInjectable from "../logger.injectable";
-import { getOrInsert, iter } from "../utils";
-
-export interface MigrationDeclaration {
-  version: string;
-  run(store: Conf<Partial<Record<string, unknown>>>): void;
-}
-
-const storeMigrationsInjectable = getInjectable({
-  id: "store-migrations",
-  instantiate: (di, token): Migrations<Record<string, unknown>> => {
-    const logger = di.inject(loggerInjectable);
-    const declarations = di.injectMany(token);
-    const migrations = new Map<string, MigrationDeclaration["run"][]>();
-
-    for (const decl of declarations) {
-      getOrInsert(migrations, decl.version, []).push(decl.run);
-    }
-
-    return Object.fromEntries(
-      iter.map(
-        migrations,
-        ([v, fns]) => [v, (store) => {
-          logger.info(`Running ${v} migration for ${store.path}`);
-
-          for (const fn of fns) {
-            fn(store);
-          }
-        }],
-      ),
-    );
-  },
-  lifecycle: lifecycleEnum.keyedSingleton({
-    getInstanceKey: (di, token: InjectionToken<MigrationDeclaration, void>) => token.id,
-  }),
-});
-
-export default storeMigrationsInjectable;

src/common/base-store/save-to-file.ts

@@ -1,12 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type Config from "conf";
-
-export type PersistStateToConfig = <T extends object>(config: Config<T>, state: T) => void;
-
-export const persistStateToConfigInjectionToken = getInjectionToken<PersistStateToConfig>({
-  id: "persist-state-to-config-token",
-});

src/common/catalog-entities/__tests__/kubernetes-cluster.test.ts

@@ -1,56 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { getDiForUnitTesting } from "../../../renderer/getDiForUnitTesting";
-import kubernetesClusterCategoryInjectable from "../../catalog/categories/kubernetes-cluster.injectable";
-import type { KubernetesClusterCategory } from "../kubernetes-cluster";
-
-
-describe("kubernetesClusterCategory", () => {
-  let kubernetesClusterCategory: KubernetesClusterCategory;
-
-  beforeEach(() => {
-    const di = getDiForUnitTesting({ doGeneralOverrides: true });
-
-    kubernetesClusterCategory = di.inject(kubernetesClusterCategoryInjectable);
-  });
-
-  describe("filteredItems", () => {
-    const item1 = {
-      icon: "Icon",
-      title: "Title",
-      onClick: () => {},
-    };
-    const item2 = {
-      icon: "Icon 2",
-      title: "Title 2",
-      onClick: () => {},
-    };
-
-    it("returns all items if no filter set", () => {
-      expect(kubernetesClusterCategory.filteredItems([item1, item2])).toEqual([item1, item2]);
-    });
-
-    it("returns filtered items", () => {
-      expect(kubernetesClusterCategory.filteredItems([item1, item2])).toEqual([item1, item2]);
-
-      const disposer1 = kubernetesClusterCategory.addMenuFilter(item => item.icon === "Icon");
-
-      expect(kubernetesClusterCategory.filteredItems([item1, item2])).toEqual([item1]);
-
-      const disposer2 = kubernetesClusterCategory.addMenuFilter(item => item.title === "Title 2");
-
-      expect(kubernetesClusterCategory.filteredItems([item1, item2])).toEqual([]);
-
-      disposer1();
-
-      expect(kubernetesClusterCategory.filteredItems([item1, item2])).toEqual([item2]);
-
-      disposer2();
-
-      expect(kubernetesClusterCategory.filteredItems([item1, item2])).toEqual([item1, item2]);
-    });
-  });
-});

src/common/catalog-entities/general-catalog-entities/general-catalog-entity-injection-token.ts

@@ -1,10 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type { GeneralEntity } from "../index";
-
-export const generalCatalogEntityInjectionToken = getInjectionToken<GeneralEntity>({
-  id: "general-catalog-entity-injection-token",
-});

src/common/catalog-entities/general-catalog-entities/implementations/catalog-catalog-entity.injectable.ts

@@ -1,41 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import { generalCatalogEntityInjectionToken } from "../general-catalog-entity-injection-token";
-import { GeneralEntity } from "../../index";
-import { buildURL } from "../../../utils/buildUrl";
-import catalogRouteInjectable from "../../../front-end-routing/routes/catalog/catalog-route.injectable";
-
-const catalogCatalogEntityInjectable = getInjectable({
-  id: "general-catalog-entity-for-catalog",
-
-  instantiate: (di) => {
-    const route = di.inject(catalogRouteInjectable);
-    const url = buildURL(route.path);
-
-    return new GeneralEntity({
-      metadata: {
-        uid: "catalog-entity",
-        name: "Catalog",
-        source: "app",
-        labels: {},
-      },
-      spec: {
-        path: url,
-        icon: {
-          material: "view_list",
-          background: "#3d90ce",
-        },
-      },
-      status: {
-        phase: "active",
-      },
-    });
-  },
-
-  injectionToken: generalCatalogEntityInjectionToken,
-});
-
-export default catalogCatalogEntityInjectable;

src/common/catalog-entities/general-catalog-entities/implementations/welcome-catalog-entity.injectable.ts

@@ -1,41 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import { generalCatalogEntityInjectionToken } from "../general-catalog-entity-injection-token";
-import { GeneralEntity } from "../../index";
-import { buildURL } from "../../../utils/buildUrl";
-import welcomeRouteInjectable from "../../../front-end-routing/routes/welcome/welcome-route.injectable";
-
-const welcomeCatalogEntityInjectable = getInjectable({
-  id: "general-catalog-entity-for-welcome",
-
-  instantiate: (di) => {
-    const route = di.inject(welcomeRouteInjectable);
-    const url = buildURL(route.path);
-
-    return new GeneralEntity({
-      metadata: {
-        uid: "welcome-page-entity",
-        name: "Welcome Page",
-        source: "app",
-        labels: {},
-      },
-      spec: {
-        path: url,
-        icon: {
-          material: "meeting_room",
-          background: "#3d90ce",
-        },
-      },
-      status: {
-        phase: "active",
-      },
-    });
-  },
-
-  injectionToken: generalCatalogEntityInjectionToken,
-});
-
-export default welcomeCatalogEntityInjectable;

src/common/catalog-entities/general.ts

@@ -1,43 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { CatalogEntityMetadata, CatalogEntitySpec, CatalogEntityStatus } from "../catalog";
-import type { CatalogEntityActionContext } from "../catalog/catalog-entity";
-import { CatalogCategory, CatalogEntity, categoryVersion } from "../catalog/catalog-entity";
-
-interface GeneralEntitySpec extends CatalogEntitySpec {
-  path: string;
-  icon?: {
-    material?: string;
-    background?: string;
-  };
-}
-
-export class GeneralEntity extends CatalogEntity<CatalogEntityMetadata, CatalogEntityStatus, GeneralEntitySpec> {
-  public readonly apiVersion = "entity.k8slens.dev/v1alpha1";
-  public readonly kind = "General";
-
-  async onRun(context: CatalogEntityActionContext) {
-    context.navigate(this.spec.path);
-  }
-}
-
-export class GeneralCategory extends CatalogCategory {
-  public readonly apiVersion = "catalog.k8slens.dev/v1alpha1";
-  public readonly kind = "CatalogCategory";
-  public metadata = {
-    name: "General",
-    icon: "settings",
-  };
-  public spec = {
-    group: "entity.k8slens.dev",
-    versions: [
-      categoryVersion("v1alpha1", GeneralEntity),
-    ],
-    names: {
-      kind: "General",
-    },
-  };
-}

src/common/catalog-entities/icons/kubernetes.svg

@@ -1,46 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 20.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 256 249" style="enable-background:new 0 0 256 249;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#FFFFFF;}
-</style>
-<path class="st0" d="M247.7,151.3L247.7,151.3L247.7,151.3C247.4,151.3,247.4,151.3,247.7,151.3h-0.2c-0.2,0-0.5,0-0.5-0.2
-	c-0.5,0-1-0.2-1.4-0.2c-1.7-0.2-3.1-0.5-4.5-0.5c-0.7,0-1.4,0-2.4-0.2h-0.2c-5-0.5-9-1-12.8-2.1c-1.7-0.7-2.1-1.7-2.6-2.6
-	c0-0.2-0.2-0.2-0.2-0.5l0,0l-3.1-1c1.4-10.9,1-22.3-1.7-33.5c-2.6-11.2-7.1-21.6-13.3-31.1l2.4-2.1v-0.5c0-1.2,0.2-2.4,1.2-3.6
-	c2.9-2.6,6.4-4.8,10.7-7.4l0,0c0.7-0.5,1.4-0.7,2.1-1.2c1.4-0.7,2.6-1.4,4-2.4c0.2-0.2,0.7-0.5,1.2-1c0.2-0.2,0.5-0.2,0.5-0.5l0,0
-	c3.3-2.9,4-7.6,1.7-10.7c-1.2-1.7-3.3-2.6-5.5-2.6c-1.9,0-3.6,0.7-5.2,1.9l0,0l0,0c-0.2,0.2-0.2,0.2-0.5,0.5c-0.5,0.2-0.7,0.7-1.2,1
-	c-1.2,1.2-2.1,2.1-3.1,3.3c-0.5,0.5-1,1.2-1.7,1.7l0,0c-3.3,3.6-6.4,6.4-9.5,8.6c-0.7,0.5-1.4,0.7-2.1,0.7c-0.5,0-1,0-1.4-0.2h-0.5
-	l0,0l-2.9,1.9c-3.1-3.3-6.4-6.2-9.7-9c-14.3-11.2-31.6-18.1-49.6-19.7l-0.2-3.1c-0.2-0.2-0.2-0.2-0.5-0.5c-0.7-0.7-1.7-1.4-1.9-3.1
-	c-0.2-3.8,0.2-8.1,0.7-12.8v-0.2c0-0.7,0.2-1.7,0.5-2.4c0.2-1.4,0.5-2.9,0.7-4.5V10V9.3l0,0l0,0c0-4.3-3.3-7.8-7.4-7.8
-	c-1.9,0-3.8,1-5.2,2.4c-1.4,1.4-2.1,3.3-2.1,5.5l0,0l0,0v0.5v1.4c0,1.7,0.2,3.1,0.7,4.5c0.2,0.7,0.2,1.4,0.5,2.4v0.2
-	c0.5,4.8,1.2,9,0.7,12.8c-0.2,1.7-1.2,2.4-1.9,3.1c-0.2,0.2-0.2,0.2-0.5,0.5l0,0l-0.2,3.1c-4.3,0.5-8.6,1-12.8,1.9
-	c-18.3,4-34.4,13.3-47,26.6l-2.4-1.7h-0.5c-0.5,0-1,0.2-1.4,0.2c-0.7,0-1.4-0.2-2.1-0.7c-3.1-2.1-6.2-5.2-9.5-8.8l0,0
-	c-0.5-0.5-1-1.2-1.7-1.7c-1-1.2-1.9-2.1-3.1-3.3c-0.2-0.2-0.7-0.5-1.2-1c-0.2-0.2-0.5-0.2-0.5-0.5l0,0c-1.4-1.2-3.3-1.9-5.2-1.9
-	c-2.1,0-4.3,1-5.5,2.6c-2.4,3.1-1.7,7.8,1.7,10.7l0,0l0,0c0.2,0,0.2,0.2,0.5,0.2c0.5,0.2,0.7,0.7,1.2,1c1.4,1,2.6,1.7,4,2.4
-	c0.7,0.2,1.4,0.7,2.1,1.2l0,0c4.3,2.6,7.8,4.8,10.7,7.4c1.2,1.2,1.2,2.4,1.2,3.6v0.5l0,0l2.4,2.1c-0.5,0.7-1,1.2-1.2,1.9
-	c-11.9,18.8-16.4,40.9-13.3,62.7l-3.1,1c0,0.2-0.2,0.2-0.2,0.5c-0.5,1-1.2,1.9-2.6,2.6c-3.6,1.2-7.8,1.7-12.8,2.1h-0.2
-	c-0.7,0-1.7,0-2.4,0.2c-1.4,0-2.9,0.2-4.5,0.5c-0.5,0-1,0.2-1.4,0.2c-0.2,0-0.5,0-0.7,0.2l0,0l0,0c-4.3,1-6.9,5-6.2,8.8
-	c0.7,3.3,3.8,5.5,7.6,5.5c0.7,0,1.2,0,1.9-0.2l0,0l0,0c0.2,0,0.5,0,0.5-0.2c0.5,0,1-0.2,1.4-0.2c1.7-0.5,2.9-1,4.3-1.7
-	c0.7-0.2,1.4-0.7,2.1-1h0.2c4.5-1.7,8.6-3.1,12.4-3.6h0.5c1.4,0,2.4,0.7,3.1,1.2c0.2,0,0.2,0.2,0.5,0.2l0,0l3.3-0.5
-	c5.7,17.6,16.6,33.3,31.1,44.7c3.3,2.6,6.7,4.8,10.2,6.9l-1.4,3.1c0,0.2,0.2,0.2,0.2,0.5c0.5,1,1,2.1,0.5,3.8
-	c-1.4,3.6-3.6,7.1-6.2,11.2v0.2c-0.5,0.7-1,1.2-1.4,1.9c-1,1.2-1.7,2.4-2.6,3.8c-0.2,0.2-0.5,0.7-0.7,1.2c0,0.2-0.2,0.5-0.2,0.5l0,0
-	l0,0c-1.9,4-0.5,8.6,3.1,10.2c1,0.5,1.9,0.7,2.9,0.7c2.9,0,5.7-1.9,7.1-4.5l0,0l0,0c0-0.2,0.2-0.5,0.2-0.5c0.2-0.5,0.5-1,0.7-1.2
-	c0.7-1.7,1-2.9,1.4-4.3c0.2-0.7,0.5-1.4,0.7-2.1l0,0c1.7-4.8,2.9-8.6,5-11.9c1-1.4,2.1-1.7,3.1-2.1c0.2,0,0.2,0,0.5-0.2l0,0l1.7-3.1
-	c10.5,4,21.9,6.2,33.3,6.2c6.9,0,14-0.7,20.7-2.4c4.3-1,8.3-2.1,12.4-3.6l1.4,2.6c0.2,0,0.2,0,0.5,0.2c1.2,0.2,2.1,0.7,3.1,2.1
-	c1.9,3.3,3.3,7.4,5,11.9v0.2c0.2,0.7,0.5,1.4,0.7,2.1c0.5,1.4,0.7,2.9,1.4,4.3c0.2,0.5,0.5,0.7,0.7,1.2c0,0.2,0.2,0.5,0.2,0.5l0,0
-	l0,0c1.4,2.9,4.3,4.5,7.1,4.5c1,0,1.9-0.2,2.9-0.7c1.7-1,3.1-2.4,3.6-4.3s0.5-4-0.5-5.9l0,0l0,0c0-0.2-0.2-0.2-0.2-0.5
-	c-0.2-0.5-0.5-1-0.7-1.2c-0.7-1.4-1.7-2.6-2.6-3.8c-0.5-0.7-1-1.2-1.4-1.9V229c-2.6-4-5-7.6-6.2-11.2c-0.5-1.7,0-2.6,0.2-3.8
-	c0-0.2,0.2-0.2,0.2-0.5l0,0l-1.2-2.9c12.6-7.4,23.3-17.8,31.4-30.6c4.3-6.7,7.6-14,10-21.4l2.9,0.5c0.2,0,0.2-0.2,0.5-0.2
-	c1-0.5,1.7-1.2,3.1-1.2h0.5c3.8,0.5,7.8,1.9,12.4,3.6h0.2c0.7,0.2,1.4,0.7,2.1,1c1.4,0.7,2.6,1.2,4.3,1.7c0.5,0,1,0.2,1.4,0.2
-	c0.2,0,0.5,0,0.7,0.2l0,0c0.7,0.2,1.2,0.2,1.9,0.2c3.6,0,6.7-2.4,7.6-5.5C254.6,156.3,251.9,152.5,247.7,151.3L247.7,151.3z
-	 M137.7,139.7l-10.5,5l-10.5-5l-2.6-11.2l7.1-9h11.6l7.1,9L137.7,139.7L137.7,139.7z M199.7,115c1.9,8.1,2.4,16.2,1.7,24L165,128.5
-	c-3.3-1-5.2-4.3-4.5-7.6c0.2-1,0.7-1.9,1.4-2.6l28.7-25.9C194.7,99.1,197.8,106.7,199.7,115L199.7,115z M179.3,78.2l-31.1,22.1
-	c-2.6,1.7-6.2,1.2-8.3-1.4c-0.7-0.7-1-1.7-1.2-2.6l-2.1-38.7C152.9,59.4,167.8,66.8,179.3,78.2L179.3,78.2z M110.4,58.7
-	c2.6-0.5,5-1,7.6-1.4l-2.1,38c-0.2,3.3-2.9,6.2-6.4,6.2c-1,0-2.1-0.2-2.9-0.7L75,78.2C84.7,68.4,96.8,61.8,110.4,58.7L110.4,58.7z
-	 M63.6,92.4l28.3,25.2c2.6,2.1,2.9,6.2,0.7,8.8c-0.7,1-1.7,1.7-2.9,1.9L52.9,139C51.4,122.8,55,106.4,63.6,92.4L63.6,92.4z
-	 M57.1,156.8l37.8-6.4c3.1-0.2,5.9,1.9,6.7,5c0.2,1.4,0.2,2.6-0.2,3.8l0,0l-14.5,34.9C73.5,185.6,62.8,172.5,57.1,156.8L57.1,156.8z
-	 M143.9,204.1c-5.5,1.2-10.9,1.9-16.6,1.9c-8.3,0-16.4-1.4-24-3.8l18.8-34c1.9-2.1,5-3.1,7.6-1.7c1.2,0.7,2.1,1.7,2.9,2.6l0,0
-	l18.3,33C148.6,202.9,146.2,203.4,143.9,204.1L143.9,204.1z M190.2,171.1c-5.9,9.5-13.8,17.1-22.8,23l-15-35.9
-	c-0.7-2.9,0.5-5.9,3.3-7.4c1-0.5,2.1-0.7,3.3-0.7l38,6.4C195.6,161.8,193.3,166.5,190.2,171.1L190.2,171.1z"/>
-</svg>

src/common/catalog-entities/index.ts

@@ -1,8 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-export * from "./general";
-export * from "./kubernetes-cluster";
-export * from "./web-link";

src/common/catalog-entities/kubernetes-cluster.ts

@@ -1,160 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { CatalogEntityActionContext, CatalogEntityContextMenuContext, CatalogEntityMetadata, CatalogEntityStatus, CatalogCategorySpec } from "../catalog";
-import { CatalogEntity, CatalogCategory, categoryVersion } from "../catalog/catalog-entity";
-import { broadcastMessage } from "../ipc";
-import { app } from "electron";
-import type { CatalogEntityConstructor, CatalogEntitySpec } from "../catalog/catalog-entity";
-import { IpcRendererNavigationEvents } from "../ipc/navigation-events";
-import { requestClusterActivation, requestClusterDisconnection } from "../../renderer/ipc";
-import KubeClusterCategoryIcon from "./icons/kubernetes.svg";
-import getClusterByIdInjectable from "../cluster-store/get-by-id.injectable";
-import { getLegacyGlobalDiForExtensionApi } from "../../extensions/as-legacy-globals-for-extension-api/legacy-global-di-for-extension-api";
-
-export interface KubernetesClusterPrometheusMetrics {
-  address?: {
-    namespace: string;
-    service: string;
-    port: number;
-    prefix: string;
-  };
-  type?: string;
-}
-
-export interface KubernetesClusterSpec extends CatalogEntitySpec {
-  kubeconfigPath: string;
-  kubeconfigContext: string;
-  metrics?: {
-    source: string;
-    prometheus?: KubernetesClusterPrometheusMetrics;
-  };
-  icon?: {
-    // TODO: move to CatalogEntitySpec once any-entity icons are supported
-    src?: string;
-    material?: string;
-    background?: string;
-  };
-  accessibleNamespaces?: string[];
-}
-
-export enum LensKubernetesClusterStatus {
-  DELETING = "deleting",
-  CONNECTING = "connecting",
-  CONNECTED = "connected",
-  DISCONNECTED = "disconnected",
-}
-
-export interface KubernetesClusterMetadata extends CatalogEntityMetadata {
-  distro?: string;
-  kubeVersion?: string;
-}
-
-/**
- * @deprecated This is no longer used as it is incorrect. Other sources can add more values
- */
-export type KubernetesClusterStatusPhase = "connected" | "connecting" | "disconnected" | "deleting";
-
-export interface KubernetesClusterStatus extends CatalogEntityStatus {
-}
-
-export function isKubernetesCluster(item: unknown): item is KubernetesCluster {
-  return item instanceof KubernetesCluster;
-}
-
-export class KubernetesCluster<
-  Metadata extends KubernetesClusterMetadata = KubernetesClusterMetadata,
-  Status extends KubernetesClusterStatus = KubernetesClusterStatus,
-  Spec extends KubernetesClusterSpec = KubernetesClusterSpec,
-> extends CatalogEntity<Metadata, Status, Spec> {
-  public static readonly apiVersion: string = "entity.k8slens.dev/v1alpha1";
-  public static readonly kind: string = "KubernetesCluster";
-
-  public readonly apiVersion = KubernetesCluster.apiVersion;
-  public readonly kind = KubernetesCluster.kind;
-
-  async connect(): Promise<void> {
-    if (app) {
-      const di = getLegacyGlobalDiForExtensionApi();
-      const getClusterById = di.inject(getClusterByIdInjectable);
-
-      await getClusterById(this.getId())?.activate();
-    } else {
-      await requestClusterActivation(this.getId(), false);
-    }
-  }
-
-  async disconnect(): Promise<void> {
-    if (app) {
-      const di = getLegacyGlobalDiForExtensionApi();
-      const getClusterById = di.inject(getClusterByIdInjectable);
-
-      getClusterById(this.getId())?.disconnect();
-    } else {
-      await requestClusterDisconnection(this.getId(), false);
-    }
-  }
-
-  async onRun(context: CatalogEntityActionContext) {
-    context.navigate(`/cluster/${this.getId()}`);
-  }
-
-  onDetailsOpen(): void {
-    //
-  }
-
-  onSettingsOpen(): void {
-    //
-  }
-
-  onContextMenuOpen(context: CatalogEntityContextMenuContext) {
-    if (!this.metadata.source || this.metadata.source === "local") {
-      context.menuItems.push({
-        title: "Settings",
-        icon: "settings",
-        onClick: () => broadcastMessage(
-          IpcRendererNavigationEvents.NAVIGATE_IN_APP,
-          `/entity/${this.getId()}/settings`,
-        ),
-      });
-    }
-
-    switch (this.status.phase) {
-      case LensKubernetesClusterStatus.CONNECTED:
-      case LensKubernetesClusterStatus.CONNECTING:
-        context.menuItems.push({
-          title: "Disconnect",
-          icon: "link_off",
-          onClick: () => requestClusterDisconnection(this.getId()),
-        });
-        break;
-      case LensKubernetesClusterStatus.DISCONNECTED:
-        context.menuItems.push({
-          title: "Connect",
-          icon: "link",
-          onClick: () => context.navigate(`/cluster/${this.getId()}`),
-        });
-        break;
-    }
-  }
-}
-
-export class KubernetesClusterCategory extends CatalogCategory {
-  public readonly apiVersion = "catalog.k8slens.dev/v1alpha1";
-  public readonly kind = "CatalogCategory";
-  public metadata = {
-    name: "Clusters",
-    icon: KubeClusterCategoryIcon,
-  };
-  public spec: CatalogCategorySpec = {
-    group: "entity.k8slens.dev",
-    versions: [
-      categoryVersion("v1alpha1", KubernetesCluster as CatalogEntityConstructor<KubernetesCluster>),
-    ],
-    names: {
-      kind: "KubernetesCluster",
-    },
-  };
-}

src/common/catalog-entities/web-link.ts

@@ -1,68 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { Environments, getEnvironmentSpecificLegacyGlobalDiForExtensionApi } from "../../extensions/as-legacy-globals-for-extension-api/legacy-global-di-for-extension-api";
-import type { CatalogEntityContextMenuContext, CatalogEntityMetadata, CatalogEntityStatus } from "../catalog";
-import { CatalogCategory, CatalogEntity, categoryVersion } from "../catalog/catalog-entity";
-import productNameInjectable from "../vars/product-name.injectable";
-import weblinkStoreInjectable from "../weblinks-store/weblink-store.injectable";
-
-export type WebLinkStatusPhase = "available" | "unavailable";
-
-export interface WebLinkStatus extends CatalogEntityStatus {
-  phase: WebLinkStatusPhase;
-}
-
-export interface WebLinkSpec {
-  url: string;
-}
-
-export class WebLink extends CatalogEntity<CatalogEntityMetadata, WebLinkStatus, WebLinkSpec> {
-  public static readonly apiVersion = "entity.k8slens.dev/v1alpha1";
-  public static readonly kind = "WebLink";
-
-  public readonly apiVersion = WebLink.apiVersion;
-  public readonly kind = WebLink.kind;
-
-  async onRun() {
-    window.open(this.spec.url, "_blank");
-  }
-
-  onContextMenuOpen(context: CatalogEntityContextMenuContext) {
-    // NOTE: this is safe because `onContextMenuOpen` is only supposed to be called in the renderer
-    const di = getEnvironmentSpecificLegacyGlobalDiForExtensionApi(Environments.renderer);
-    const productName = di.inject(productNameInjectable);
-    const weblinkStore = di.inject(weblinkStoreInjectable);
-
-    if (this.metadata.source === "local") {
-      context.menuItems.push({
-        title: "Delete",
-        icon: "delete",
-        onClick: async () => weblinkStore.removeById(this.getId()),
-        confirm: {
-          message: `Remove Web Link "${this.getName()}" from ${productName}?`,
-        },
-      });
-    }
-  }
-}
-
-export class WebLinkCategory extends CatalogCategory {
-  public readonly apiVersion = "catalog.k8slens.dev/v1alpha1";
-  public readonly kind = "CatalogCategory";
-  public metadata = {
-    name: "Web Links",
-    icon: "public",
-  };
-  public spec = {
-    group: "entity.k8slens.dev",
-    versions: [
-      categoryVersion("v1alpha1", WebLink),
-    ],
-    names: {
-      kind: "WebLink",
-    },
-  };
-}

src/common/catalog/catalog-entity.ts

@@ -1,413 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import EventEmitter from "events";
-import type TypedEmitter from "typed-emitter";
-import { observable, makeObservable } from "mobx";
-import { once } from "lodash";
-import type { Disposer } from "../utils";
-import { iter } from "../utils";
-import type { CategoryColumnRegistration } from "../../renderer/components/+catalog/custom-category-columns";
-
-export type CatalogEntityDataFor<Entity> = Entity extends CatalogEntity<infer Metadata, infer Status, infer Spec>
-  ? CatalogEntityData<Metadata, Status, Spec>
-  : never;
-
-export type CatalogEntityInstanceFrom<Constructor> = Constructor extends CatalogEntityConstructor<infer Entity>
-  ? Entity
-  : never;
-
-export type CatalogEntityConstructor<Entity extends CatalogEntity> = (
-  new (data: CatalogEntityDataFor<Entity>) => Entity
-);
-
-export interface CatalogCategoryVersion {
-  /**
-   * The specific version that the associated constructor is for. This MUST be
-   * a DNS label and SHOULD be of the form `vN`, `vNalphaY`, or `vNbetaY` where
-   * `N` and `Y` are both integers greater than 0.
-   *
-   * Examples: The following are valid values for this field.
-   * - `v1`
-   * - `v1beta1`
-   * - `v1alpha2`
-   * - `v3beta2`
-   */
-  readonly name: string;
-
-  /**
-   * The constructor for the entities.
-   */
-  readonly entityClass: CatalogEntityConstructor<CatalogEntity>;
-}
-
-export interface CatalogCategorySpec {
-  /**
-   * The grouping for for the category. This MUST be a DNS label.
-   */
-  readonly group: string;
-
-  /**
-   * The specific versions of the constructors.
-   *
-   * NOTE: the field `.apiVersion` after construction MUST match `{.group}/{.versions.[] | .name}`.
-   * For example, if `group = "entity.k8slens.dev"` and there is an entry in `.versions` with
-   * `name = "v1alpha1"` then the resulting `.apiVersion` MUST be `entity.k8slens.dev/v1alpha1`
-   */
-  readonly versions: CatalogCategoryVersion[];
-
-  /**
-   * This is the concerning the category
-   */
-  readonly names: {
-    /**
-     * The kind of entity that this category is for. This value MUST be a DNS
-     * label and MUST be equal to the `kind` fields that are produced by the
-     * `.versions.[] | .entityClass` fields.
-     */
-    readonly kind: string;
-  };
-
-  /**
-   * These are the columns used for displaying entities when in the catalog.
-   *
-   * If this is not provided then some default columns will be used, similar in
-   * scope to the columns in the "Browse" view.
-   *
-   * Even if you provide columns, a "Name" column will be provided as well with
-   * `priority: 0`.
-   *
-   * These columns will not be used in the "Browse" view.
-   */
-  readonly displayColumns?: CategoryColumnRegistration[];
-}
-
-/**
- * If the filter return a thruthy value, the menu item is displayed
- */
-export type AddMenuFilter = (menu: CatalogEntityAddMenu) => any;
-
-export interface CatalogCategoryEvents {
-  /**
-   * This event will be emitted when the category is loaded in the catalog
-   * view.
-   */
-  load: () => void;
-
-  /**
-   * This event will be emitted when the catalog add menu is opened and is the
-   * way to added entries to that menu.
-   */
-  catalogAddMenu: (context: CatalogEntityAddMenuContext) => void;
-
-  /**
-   * This event will be emitted when the context menu for an entity is declared
-   * by this category is opened.
-   */
-  contextMenuOpen: (entity: CatalogEntity, context: CatalogEntityContextMenuContext) => void;
-}
-
-export interface CatalogCategoryMetadata {
-  /**
-   * The name of your category. The category can be searched for by this
-   * value. This will also be used for the catalog menu.
-   */
-  readonly name: string;
-  /**
-   * Either an `<svg>` or the name of an icon from {@link IconProps}
-   */
-  readonly icon: string;
-}
-
-export function categoryVersion<
-  T extends CatalogEntity<Metadata, Status, Spec>,
-  Metadata extends CatalogEntityMetadata,
-  Status extends CatalogEntityStatus,
-  Spec extends CatalogEntitySpec,
->(name: string, entityClass: new (data: CatalogEntityData<Metadata, Status, Spec>) => T): CatalogCategoryVersion {
-  return {
-    name,
-    entityClass: entityClass as CatalogEntityConstructor<T>,
-  };
-}
-
-export abstract class CatalogCategory extends (EventEmitter as new () => TypedEmitter<CatalogCategoryEvents>) {
-  /**
-   * The version of category that you are wanting to declare.
-   *
-   * Currently supported values:
-   *
-   * - `"catalog.k8slens.dev/v1alpha1"`
-   */
-  abstract readonly apiVersion: string;
-
-  /**
-   * The kind of item you wish to declare.
-   *
-   * Currently supported values:
-   *
-   * - `"CatalogCategory"`
-   */
-  abstract readonly kind: string;
-
-  /**
-   * The data about the category itself
-   */
-  abstract readonly metadata: CatalogCategoryMetadata;
-
-  /**
-   * The most important part of a category, as it is where entity versions are declared.
-   */
-  abstract readonly spec: CatalogCategorySpec;
-
-  /**
-   * @internal
-   */
-  protected readonly filters = observable.set<AddMenuFilter>([], {
-    deep: false,
-  });
-
-  /**
-   * Parse a category ID into parts.
-   * @param id The id of a category is parse
-   * @returns The group and kind parts of the ID
-   */
-  public static parseId(id: string): { group?: string; kind?: string } {
-    const [group, kind] = id.split("/") ?? [];
-
-    return { group, kind };
-  }
-
-  /**
-   * Get the ID of this category
-   */
-  public getId(): string {
-    return `${this.spec.group}/${this.spec.names.kind}`;
-  }
-
-  /**
-   * Get the name of this category
-   */
-  public getName(): string {
-    return this.metadata.name;
-  }
-
-  /**
-   * Get the badge of this category.
-   * Defaults to no badge.
-   * The badge is displayed next to the Category name in the Catalog Category menu
-   */
-  public getBadge(): React.ReactNode {
-    return null;
-  }
-
-  /**
-   * Add a filter for menu items of catalogAddMenu
-   * @param fn The function that should return a truthy value if that menu item should be displayed
-   * @returns A function to remove that filter
-   */
-  public addMenuFilter(fn: AddMenuFilter): Disposer {
-    this.filters.add(fn);
-
-    return once(() => void this.filters.delete(fn));
-  }
-
-  /**
-   * Filter menuItems according to the Category's set filters
-   * @param menuItems menu items to filter
-   * @returns filtered menu items
-   */
-  public filteredItems(menuItems: CatalogEntityAddMenu[]) {
-    return Array.from(
-      iter.reduce(
-        this.filters,
-        iter.filter,
-        menuItems.values(),
-      ),
-    );
-  }
-}
-
-export type EntityMetadataObject = { [Key in string]?: EntityMetadataValue };
-export type EntityMetadataValue = string | number | boolean | EntityMetadataObject | undefined;
-
-export interface CatalogEntityMetadata extends EntityMetadataObject {
-  uid: string;
-  name: string;
-  shortName?: string;
-  description?: string;
-  source?: string;
-  labels: Record<string, string>;
-}
-
-export interface CatalogEntityStatus {
-  phase: string;
-  reason?: string;
-
-  /**
-   * @default true
-   */
-  enabled?: boolean;
-  message?: string;
-  active?: boolean;
-}
-
-export interface CatalogEntityActionContext {
-  navigate: (url: string) => void;
-  setCommandPaletteContext: (context?: CatalogEntity) => void;
-}
-
-export interface CatalogEntityContextMenu {
-  /**
-   * Menu title
-   */
-  title: string;
-  /**
-   * Menu icon
-   */
-  icon?: string;
-  /**
-   * OnClick handler
-   */
-  onClick: () => void | Promise<void>;
-  /**
-   * Confirm click with a message
-   */
-  confirm?: {
-    message: string;
-  };
-}
-
-export interface CatalogEntityAddMenu extends CatalogEntityContextMenu {
-  icon: string;
-  defaultAction?: boolean;
-}
-
-export interface CatalogEntitySettingsMenu {
-  group?: string;
-  title: string;
-  components: {
-    View: React.ComponentType<any>;
-  };
-}
-
-export interface CatalogEntityContextMenuNavigate {
-  /**
-   * @param pathname The location to navigate to in the main iframe
-   */
-  (pathname: string, forceMainFrame?: boolean): void;
-  /**
-   * @param pathname The location to navigate to in the current iframe. Useful for when called within the cluster frame
-   */
-  (pathname: string, forceMainFrame: false): void;
-}
-
-export interface CatalogEntityContextMenuContext {
-  /**
-   * Navigate to the specified pathname
-   */
-  navigate: CatalogEntityContextMenuNavigate;
-  menuItems: CatalogEntityContextMenu[];
-}
-
-export interface CatalogEntitySettingsContext {
-  menuItems: CatalogEntityContextMenu[];
-}
-
-export interface CatalogEntityAddMenuContext {
-  navigate: (url: string) => void;
-  menuItems: CatalogEntityAddMenu[];
-}
-
-export type CatalogEntitySpec = Record<string, any>;
-
-
-export interface CatalogEntityData<
-  Metadata extends CatalogEntityMetadata = CatalogEntityMetadata,
-  Status extends CatalogEntityStatus = CatalogEntityStatus,
-  Spec extends CatalogEntitySpec = CatalogEntitySpec,
-> {
-  metadata: Metadata;
-  status: Status;
-  spec: Spec;
-}
-
-export interface CatalogEntityKindData {
-  readonly apiVersion: string;
-  readonly kind: string;
-}
-
-export abstract class CatalogEntity<
-  Metadata extends CatalogEntityMetadata = CatalogEntityMetadata,
-  Status extends CatalogEntityStatus = CatalogEntityStatus,
-  Spec extends CatalogEntitySpec = CatalogEntitySpec,
-> implements CatalogEntityKindData {
-  /**
-   * The group and version of this class.
-   */
-  public abstract readonly apiVersion: string;
-
-  /**
-   * A DNS label name of the entity.
-   */
-  public abstract readonly kind: string;
-
-  @observable metadata: Metadata;
-  @observable status: Status;
-  @observable spec: Spec;
-
-  constructor({ metadata, status, spec }: CatalogEntityData<Metadata, Status, Spec>) {
-    makeObservable(this);
-
-    if (!metadata || typeof metadata !== "object") {
-      throw new TypeError("CatalogEntity's metadata must be a defined object");
-    }
-
-    if (!status || typeof status !== "object") {
-      throw new TypeError("CatalogEntity's status must be a defined object");
-    }
-
-    if (!spec || typeof spec !== "object") {
-      throw new TypeError("CatalogEntity's spec must be a defined object");
-    }
-
-    this.metadata = metadata;
-    this.status = status;
-    this.spec = spec;
-  }
-
-  /**
-   * Get the UID of this entity
-   */
-  public getId(): string {
-    return this.metadata.uid;
-  }
-
-  /**
-   * Get the name of this entity
-   */
-  public getName(): string {
-    return this.metadata.name;
-  }
-
-  /**
-   * Get the specified source of this entity, defaulting to `"unknown"` if not
-   * provided
-   */
-  public getSource(): string {
-    return this.metadata.source ?? "unknown";
-  }
-
-  /**
-   * Get if this entity is enabled.
-   */
-  public isEnabled(): boolean {
-    return this.status.enabled ?? true;
-  }
-
-  public onRun?(context: CatalogEntityActionContext): void | Promise<void>;
-  public onContextMenuOpen?(context: CatalogEntityContextMenuContext): void | Promise<void>;
-  public onSettingsOpen?(context: CatalogEntitySettingsContext): void | Promise<void>;
-}

src/common/catalog/catalog-run-event.ts

@@ -1,28 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { CatalogEntity } from "../catalog";
-
-export class CatalogRunEvent {
-  #defaultPrevented: boolean;
-  #target: CatalogEntity;
-
-  get defaultPrevented() {
-    return this.#defaultPrevented;
-  }
-
-  get target() {
-    return this.#target;
-  }
-
-  constructor({ target }: { target: CatalogEntity }) {
-    this.#defaultPrevented = false;
-    this.#target = target;
-  }
-
-  preventDefault() {
-    this.#defaultPrevented = true;
-  }
-}

src/common/catalog/categories/general.injectable.ts

@@ -1,15 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import { GeneralCategory } from "../../catalog-entities";
-import { builtInCategoryInjectionToken } from "../category-registry.injectable";
-
-const generalCategoryInjectable = getInjectable({
-  id: "general-category",
-  instantiate: () => new GeneralCategory(),
-  injectionToken: builtInCategoryInjectionToken,
-});
-
-export default generalCategoryInjectable;

src/common/catalog/categories/kubernetes-cluster.injectable.ts

@@ -1,15 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import { KubernetesClusterCategory } from "../../catalog-entities/kubernetes-cluster";
-import { builtInCategoryInjectionToken } from "../category-registry.injectable";
-
-const kubernetesClusterCategoryInjectable = getInjectable({
-  id: "kubernetes-cluster-category",
-  instantiate: () => new KubernetesClusterCategory(),
-  injectionToken: builtInCategoryInjectionToken,
-});
-
-export default kubernetesClusterCategoryInjectable;

src/common/catalog/categories/weblink.injectable.ts

@@ -1,15 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import { WebLinkCategory } from "../../catalog-entities";
-import { builtInCategoryInjectionToken } from "../category-registry.injectable";
-
-const weblinkCategoryInjectable = getInjectable({
-  id: "weblink-category",
-  instantiate: () => new WebLinkCategory(),
-  injectionToken: builtInCategoryInjectionToken,
-});
-
-export default weblinkCategoryInjectable;

src/common/catalog/category-registry.injectable.ts

@@ -1,27 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable, getInjectionToken } from "@ogre-tools/injectable";
-import type { CatalogCategory } from "./catalog-entity";
-import { CatalogCategoryRegistry } from "./category-registry";
-
-export const builtInCategoryInjectionToken = getInjectionToken<CatalogCategory>({
-  id: "built-in-category-token",
-});
-
-const catalogCategoryRegistryInjectable = getInjectable({
-  id: "catalog-category-registry",
-  instantiate: (di) => {
-    const registry = new CatalogCategoryRegistry();
-    const categories = di.injectMany(builtInCategoryInjectionToken);
-
-    for (const category of categories) {
-      registry.add(category);
-    }
-
-    return registry;
-  },
-});
-
-export default catalogCategoryRegistryInjectable;

src/common/catalog/category-registry.ts

@@ -1,103 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { action, computed, observable, makeObservable } from "mobx";
-import { once } from "lodash";
-import { iter, getOrInsertMap, strictSet } from "../utils";
-import type { Disposer } from "../utils";
-import type { CatalogCategory, CatalogEntityData, CatalogEntityKindData } from "./catalog-entity";
-
-export type CategoryFilter = (category: CatalogCategory) => any;
-
-export class CatalogCategoryRegistry {
-  protected readonly categories = observable.set<CatalogCategory>();
-  protected readonly groupKinds = new Map<string, Map<string, CatalogCategory>>();
-  protected readonly filters = observable.set<CategoryFilter>([], {
-    deep: false,
-  });
-
-  constructor() {
-    makeObservable(this);
-  }
-
-  @action add(category: CatalogCategory): Disposer {
-    const byGroup = getOrInsertMap(this.groupKinds, category.spec.group);
-
-    this.categories.add(category);
-    strictSet(byGroup, category.spec.names.kind, category);
-
-    return () => {
-      this.categories.delete(category);
-      byGroup.delete(category.spec.names.kind);
-    };
-  }
-
-  @computed get items() {
-    return Array.from(this.categories);
-  }
-
-  @computed get filteredItems() {
-    return Array.from(
-      iter.reduce(
-        this.filters,
-        iter.filter,
-        this.items.values(),
-      ),
-    );
-  }
-
-
-  getForGroupKind<T extends CatalogCategory>(group: string, kind: string): T | undefined {
-    return this.groupKinds.get(group)?.get(kind) as T;
-  }
-
-  getEntityForData(data: CatalogEntityData & CatalogEntityKindData) {
-    const category = this.getCategoryForEntity(data);
-
-    if (!category) {
-      return null;
-    }
-
-    const splitApiVersion = data.apiVersion.split("/");
-    const version = splitApiVersion[1];
-
-    const specVersion = category.spec.versions.find((v) => v.name === version);
-
-    if (!specVersion) {
-      return null;
-    }
-
-    return new specVersion.entityClass(data);
-  }
-
-  hasCategoryForEntity({ kind, apiVersion }: CatalogEntityData & CatalogEntityKindData): boolean {
-    const splitApiVersion = apiVersion.split("/");
-    const group = splitApiVersion[0];
-
-    return this.groupKinds.get(group)?.has(kind) ?? false;
-  }
-
-  getCategoryForEntity<T extends CatalogCategory>(data: CatalogEntityData & CatalogEntityKindData): T | undefined {
-    const splitApiVersion = data.apiVersion.split("/");
-    const group = splitApiVersion[0];
-
-    return this.getForGroupKind(group, data.kind);
-  }
-
-  getByName(name: string) {
-    return this.items.find(category => category.metadata?.name == name);
-  }
-
-  /**
-   * Add a new filter to the set of category filters
-   * @param fn The function that should return a truthy value if that category should be displayed
-   * @returns A function to remove that filter
-   */
-  addCatalogCategoryFilter(fn: CategoryFilter): Disposer {
-    this.filters.add(fn);
-
-    return once(() => void this.filters.delete(fn));
-  }
-}

src/common/catalog/filtered-categories.injectable.ts

@@ -1,18 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import { computed } from "mobx";
-import catalogCategoryRegistryInjectable from "./category-registry.injectable";
-
-const filteredCategoriesInjectable = getInjectable({
-  id: "filtered-categories",
-  instantiate: (di) => {
-    const registry = di.inject(catalogCategoryRegistryInjectable);
-
-    return computed(() => [...registry.filteredItems]);
-  },
-});
-
-export default filteredCategoriesInjectable;

src/common/catalog/has-category-for-entity.injectable.ts

@@ -1,21 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import type { CatalogEntityData, CatalogEntityKindData } from "./catalog-entity";
-import catalogCategoryRegistryInjectable from "./category-registry.injectable";
-
-export type HasCategoryForEntity = (data: CatalogEntityData & CatalogEntityKindData) => boolean;
-
-const hasCategoryForEntityInjectable = getInjectable({
-  id: "has-category-for-entity",
-
-  instantiate: (di): HasCategoryForEntity => {
-    const registry = di.inject(catalogCategoryRegistryInjectable);
-
-    return (data) => registry.hasCategoryForEntity(data);
-  },
-});
-
-export default hasCategoryForEntityInjectable;

src/common/catalog/index.ts

@@ -1,7 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-export * from "./category-registry";
-export * from "./catalog-entity";

src/common/catalog/visit-entity-context-menu.injectable.ts

@@ -1,23 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import type { CatalogEntity, CatalogEntityContextMenuContext } from "./catalog-entity";
-import catalogCategoryRegistryInjectable from "./category-registry.injectable";
-
-export type VisitEntityContextMenu = (entity: CatalogEntity, context: CatalogEntityContextMenuContext) => void;
-
-const visitEntityContextMenuInjectable = getInjectable({
-  id: "visit-entity-context-menu",
-  instantiate: (di): VisitEntityContextMenu => {
-    const categoryRegistry = di.inject(catalogCategoryRegistryInjectable);
-
-    return (entity, context) => {
-      entity.onContextMenuOpen?.(context);
-      categoryRegistry.getCategoryForEntity(entity)?.emit("contextMenuOpen", entity, context);
-    };
-  },
-});
-
-export default visitEntityContextMenuInjectable;

src/common/certificate-authorities/inject-system-cas.injectable.ts

@@ -1,60 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { getInjectable } from "@ogre-tools/injectable";
-import { globalAgent } from "https";
-import { requestSystemCAsInjectionToken } from "./request-system-cas-token";
-
-// DST Root CA X3, which was expired on 9.30.2021
-const DSTRootCAX3 = "-----BEGIN CERTIFICATE-----\nMIIDSjCCAjKgAwIBAgIQRK+wgNajJ7qJMDmGLvhAazANBgkqhkiG9w0BAQUFADA/\nMSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT\nDkRTVCBSb290IENBIFgzMB4XDTAwMDkzMDIxMTIxOVoXDTIxMDkzMDE0MDExNVow\nPzEkMCIGA1UEChMbRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3QgQ28uMRcwFQYDVQQD\nEw5EU1QgUm9vdCBDQSBYMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\nAN+v6ZdQCINXtMxiZfaQguzH0yxrMMpb7NnDfcdAwRgUi+DoM3ZJKuM/IUmTrE4O\nrz5Iy2Xu/NMhD2XSKtkyj4zl93ewEnu1lcCJo6m67XMuegwGMoOifooUMM0RoOEq\nOLl5CjH9UL2AZd+3UWODyOKIYepLYYHsUmu5ouJLGiifSKOeDNoJjj4XLh7dIN9b\nxiqKqy69cK3FCxolkHRyxXtqqzTWMIn/5WgTe1QLyNau7Fqckh49ZLOMxt+/yUFw\n7BZy1SbsOFU5Q9D8/RhcQPGX69Wam40dutolucbY38EVAjqr2m7xPi71XAicPNaD\naeQQmxkqtilX4+U9m5/wAl0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNV\nHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFMSnsaR7LHH62+FLkHX/xBVghYkQMA0GCSqG\nSIb3DQEBBQUAA4IBAQCjGiybFwBcqR7uKGY3Or+Dxz9LwwmglSBd49lZRNI+DT69\nikugdB/OEIKcdBodfpga3csTS7MgROSR6cz8faXbauX+5v3gTt23ADq1cEmv8uXr\nAvHRAosZy5Q6XkjEGB5YGV8eAlrwDPGxrancWYaLbumR9YbK+rlmM6pZW87ipxZz\nR8srzJmwN0jP41ZL9c8PDHIyh8bwRLtTcm1D9SZImlJnt1ir/md2cXjbDaJWFBM5\nJDGFoqgCWjBH4d1QB7wCCZAA62RjYJsWvIjJEubSfZGL+T0yjWW06XyxV3bqxbYo\nOb8VZRzI9neWagqNdwvYkQsEjgfbKbYK7p2CNTUQ\n-----END CERTIFICATE-----\n";
-
-function isCertActive(cert: string) {
-  const isExpired = typeof cert !== "string" || cert.includes(DSTRootCAX3);
-
-  return !isExpired;
-}
-
-const injectSystemCAsInjectable = getInjectable({
-  id: "inject-system-cas",
-  instantiate: (di) => {
-    const requestSystemCAs = di.inject(requestSystemCAsInjectionToken);
-
-    return async () => {
-      const certs = await requestSystemCAs();
-
-      if (certs.length === 0) {
-        // Leave the global option alone
-        return;
-      }
-
-      const cas = (() => {
-        if (Array.isArray(globalAgent.options.ca)) {
-          return globalAgent.options.ca;
-        }
-
-        if (globalAgent.options.ca) {
-          return [globalAgent.options.ca];
-        }
-
-        return [];
-      })();
-
-      for (const cert of certs) {
-        if (!isCertActive(cert)) {
-          continue;
-        }
-
-        if (!cas.includes(cert)) {
-          cas.push(cert);
-        }
-      }
-
-      globalAgent.options.ca = cas;
-    };
-  },
-});
-
-export default injectSystemCAsInjectable;
-

src/common/certificate-authorities/request-system-cas-token.ts

@@ -1,10 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { getInjectionToken } from "@ogre-tools/injectable";
-
-export const requestSystemCAsInjectionToken = getInjectionToken<() => Promise<string[]>>({
-  id: "request-system-cas-token",
-});

src/common/certificate-authorities/request-system-cas.injectable.darwin.ts

@@ -1,57 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import execFileInjectable from "../fs/exec-file.injectable";
-import loggerInjectable from "../logger.injectable";
-import type { AsyncResult } from "../utils/async-result";
-import { requestSystemCAsInjectionToken } from "./request-system-cas-token";
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Cheatsheet#other_assertions
-const certSplitPattern = /(?=-----BEGIN\sCERTIFICATE-----)/g;
-
-const requestSystemCAsInjectable = getInjectable({
-  id: "request-system-cas",
-  instantiate: (di) => {
-    const execFile = di.inject(execFileInjectable);
-    const logger = di.inject(loggerInjectable);
-
-    const execSecurity = async (...args: string[]): Promise<AsyncResult<string[]>> => {
-      const result = await execFile("/usr/bin/security", args);
-
-      if (!result.callWasSuccessful) {
-        return {
-          callWasSuccessful: false,
-          error: result.error.stderr || result.error.message,
-        };
-      }
-
-      return {
-        callWasSuccessful: true,
-        response: result.response.split(certSplitPattern),
-      };
-    };
-
-    return async () => {
-      const [trustedResult, rootCAResult] = await Promise.all([
-        execSecurity("find-certificate", "-a", "-p"),
-        execSecurity("find-certificate", "-a", "-p", "/System/Library/Keychains/SystemRootCertificates.keychain"),
-      ]);
-
-      if (!trustedResult.callWasSuccessful) {
-        logger.warn(`[INJECT-CAS]: Error retreiving trusted CAs: ${trustedResult.error}`);
-      } else if (!rootCAResult.callWasSuccessful) {
-        logger.warn(`[INJECT-CAS]: Error retreiving root CAs: ${rootCAResult.error}`);
-      } else {
-        return [...new Set([...trustedResult.response, ...rootCAResult.response])];
-      }
-
-      return [];
-    };
-  },
-  causesSideEffects: true,
-  injectionToken: requestSystemCAsInjectionToken,
-});
-
-export default requestSystemCAsInjectable;

src/common/certificate-authorities/request-system-cas.injectable.linux.ts

@@ -1,14 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import { requestSystemCAsInjectionToken } from "./request-system-cas-token";
-
-const requestSystemCAsInjectable = getInjectable({
-  id: "request-system-cas",
-  instantiate: () => async () => [],
-  injectionToken: requestSystemCAsInjectionToken,
-});
-
-export default requestSystemCAsInjectable;

src/common/certificate-authorities/request-system-cas.injectable.testing-env.ts

@@ -1,14 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import { requestSystemCAsInjectionToken } from "./request-system-cas-token";
-
-const requestSystemCAsInjectable = getInjectable({
-  id: "request-system-cas",
-  instantiate: () => async () => [],
-  injectionToken: requestSystemCAsInjectionToken,
-});
-
-export default requestSystemCAsInjectable;

src/common/certificate-authorities/request-system-cas.injectable.win32.ts

@@ -1,56 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import execFileInjectable from "../fs/exec-file.injectable";
-import loggerInjectable from "../logger.injectable";
-import { requestSystemCAsInjectionToken } from "./request-system-cas-token";
-
-const pemEncoding = (hexEncodedCert: String) => {
-  const certData = Buffer.from(hexEncodedCert, "hex").toString("base64");
-  const lines = ["-----BEGIN CERTIFICATE-----"];
-
-  for (let i = 0; i < certData.length; i += 64) {
-    lines.push(certData.substring(i, i + 64));
-  }
-
-  lines.push("-----END CERTIFICATE-----", "");
-
-  return lines.join("\r\n");
-};
-
-const requestSystemCAsInjectable = getInjectable({
-  id: "request-system-cas",
-  instantiate: (di) => {
-    const wincaRootsExePath: string = __non_webpack_require__.resolve("win-ca/lib/roots.exe");
-    const execFile = di.inject(execFileInjectable);
-    const logger = di.inject(loggerInjectable);
-
-    return async () => {
-      /**
-       * This needs to be done manually because for some reason calling the api from "win-ca"
-       * directly fails to load "child_process" correctly on renderer
-       */
-      const result = await execFile(wincaRootsExePath, {
-        maxBuffer: 128 * 1024 * 1024, // 128 MiB
-      });
-
-      if (!result.callWasSuccessful) {
-        logger.warn(`[INJECT-CAS]: Error retreiving CAs`, result.error);
-
-        return [];
-      }
-
-      return result
-        .response
-        .split("\r\n")
-        .filter(Boolean)
-        .map(pemEncoding);
-    };
-  },
-  causesSideEffects: true,
-  injectionToken: requestSystemCAsInjectionToken,
-});
-
-export default requestSystemCAsInjectable;

src/common/certificate/lens-proxy-certificate-channel.ts

@@ -1,9 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { SelfSignedCert } from "selfsigned";
-import { getRequestChannel } from "../utils/channel/get-request-channel";
-
-export const lensProxyCertificateChannel = getRequestChannel<void, SelfSignedCert>("request-lens-proxy-certificate");

src/common/certificate/lens-proxy-certificate.global-override-for-injectable.ts

@@ -1,19 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { getGlobalOverride } from "../test-utils/get-global-override";
-import lensProxyCertificateInjectable from "./lens-proxy-certificate.injectable";
-
-export default getGlobalOverride(lensProxyCertificateInjectable, () => {
-  return {
-    get: () => ({
-      public: "<public-data>",
-      private: "<private-data>",
-      cert: "<ca-data>",
-    }),
-    set: () => {},
-  };
-});
-

src/common/certificate/lens-proxy-certificate.injectable.ts

@@ -1,33 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import type { SelfSignedCert } from "selfsigned";
-
-const lensProxyCertificateInjectable = getInjectable({
-  id: "lens-proxy-certificate",
-  instantiate: () => {
-    let certState: SelfSignedCert;
-    const cert = {
-      get: () => {
-        if (!certState) {
-          throw "certificate has not been set";
-        }
-
-        return certState;
-      },
-      set: (certificate: SelfSignedCert) => {
-        if (certState) {
-          throw "certificate has already been set";
-        }
-
-        certState = certificate;
-      },
-    };
-
-    return cert;
-  },
-});
-
-export default lensProxyCertificateInjectable;

src/common/cluster-frames.injectable.ts

@@ -1,14 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import { clusterFrameMap } from "./cluster-frames";
-
-const clusterFramesInjectable = getInjectable({
-  id: "cluster-frames",
-  instantiate: () => clusterFrameMap,
-  causesSideEffects: true,
-});
-
-export default clusterFramesInjectable;

src/common/cluster-frames.ts

@@ -1,13 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { observable } from "mobx";
-
-export interface ClusterFrameInfo {
-  frameId: number;
-  processId: number;
-}
-
-export const clusterFrameMap = observable.map<string, ClusterFrameInfo>();

src/common/cluster-store/allowed-resources-injection-token.ts

@@ -1,12 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type { IComputedValue } from "mobx";
-import type { KubeApiResourceDescriptor } from "../rbac";
-
-export const shouldShowResourceInjectionToken = getInjectionToken<IComputedValue<boolean>, KubeApiResourceDescriptor>({
-  id: "should-show-resource",
-});

src/common/cluster-store/cluster-store.injectable.ts

@@ -1,42 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import { ClusterStore } from "./cluster-store";
-import { createClusterInjectionToken } from "../cluster/create-cluster-injection-token";
-import readClusterConfigSyncInjectable from "./read-cluster-config.injectable";
-import emitAppEventInjectable from "../app-event-bus/emit-event.injectable";
-import directoryForUserDataInjectable from "../app-paths/directory-for-user-data/directory-for-user-data.injectable";
-import getConfigurationFileModelInjectable from "../get-configuration-file-model/get-configuration-file-model.injectable";
-import loggerInjectable from "../logger.injectable";
-import storeMigrationVersionInjectable from "../vars/store-migration-version.injectable";
-import storeMigrationsInjectable from "../base-store/migrations.injectable";
-import { clusterStoreMigrationInjectionToken } from "./migration-token";
-import { baseStoreIpcChannelPrefixesInjectionToken } from "../base-store/channel-prefix";
-import { shouldBaseStoreDisableSyncInIpcListenerInjectionToken } from "../base-store/disable-sync";
-import { persistStateToConfigInjectionToken } from "../base-store/save-to-file";
-import getBasenameOfPathInjectable from "../path/get-basename.injectable";
-import { enlistMessageChannelListenerInjectionToken } from "../utils/channel/enlist-message-channel-listener-injection-token";
-
-const clusterStoreInjectable = getInjectable({
-  id: "cluster-store",
-
-  instantiate: (di) => new ClusterStore({
-    createCluster: di.inject(createClusterInjectionToken),
-    readClusterConfigSync: di.inject(readClusterConfigSyncInjectable),
-    emitAppEvent: di.inject(emitAppEventInjectable),
-    directoryForUserData: di.inject(directoryForUserDataInjectable),
-    getConfigurationFileModel: di.inject(getConfigurationFileModelInjectable),
-    logger: di.inject(loggerInjectable),
-    storeMigrationVersion: di.inject(storeMigrationVersionInjectable),
-    migrations: di.inject(storeMigrationsInjectable, clusterStoreMigrationInjectionToken),
-    getBasenameOfPath: di.inject(getBasenameOfPathInjectable),
-    ipcChannelPrefixes: di.inject(baseStoreIpcChannelPrefixesInjectionToken),
-    persistStateToConfig: di.inject(persistStateToConfigInjectionToken),
-    enlistMessageChannelListener: di.inject(enlistMessageChannelListenerInjectionToken),
-    shouldDisableSyncInListener: di.inject(shouldBaseStoreDisableSyncInIpcListenerInjectionToken),
-  }),
-});
-
-export default clusterStoreInjectable;

src/common/cluster-store/cluster-store.ts

@@ -1,109 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-
-import { action, comparer, computed, makeObservable, observable } from "mobx";
-import type { BaseStoreDependencies } from "../base-store/base-store";
-import { BaseStore } from "../base-store/base-store";
-import { Cluster } from "../cluster/cluster";
-import { toJS } from "../utils";
-import type { ClusterModel, ClusterId } from "../cluster-types";
-import type { CreateCluster } from "../cluster/create-cluster-injection-token";
-import type { ReadClusterConfigSync } from "./read-cluster-config.injectable";
-import type { EmitAppEvent } from "../app-event-bus/emit-event.injectable";
-
-export interface ClusterStoreModel {
-  clusters?: ClusterModel[];
-}
-
-interface Dependencies extends BaseStoreDependencies {
-  createCluster: CreateCluster;
-  readClusterConfigSync: ReadClusterConfigSync;
-  emitAppEvent: EmitAppEvent;
-}
-
-export class ClusterStore extends BaseStore<ClusterStoreModel> {
-  readonly clusters = observable.map<ClusterId, Cluster>();
-
-  constructor(protected readonly dependencies: Dependencies) {
-    super(dependencies, {
-      configName: "lens-cluster-store",
-      accessPropertiesByDotNotation: false, // To make dots safe in cluster context names
-      syncOptions: {
-        equals: comparer.structural,
-      },
-    });
-
-    makeObservable(this);
-  }
-
-  @computed get clustersList(): Cluster[] {
-    return Array.from(this.clusters.values());
-  }
-
-  @computed get connectedClustersList(): Cluster[] {
-    return this.clustersList.filter((c) => !c.disconnected);
-  }
-
-  hasClusters() {
-    return this.clusters.size > 0;
-  }
-
-  getById(id: ClusterId | undefined): Cluster | undefined {
-    if (id) {
-      return this.clusters.get(id);
-    }
-
-    return undefined;
-  }
-
-  addCluster(clusterOrModel: ClusterModel | Cluster): Cluster {
-    this.dependencies.emitAppEvent({ name: "cluster", action: "add" });
-
-    const cluster = clusterOrModel instanceof Cluster
-      ? clusterOrModel
-      : this.dependencies.createCluster(
-        clusterOrModel,
-        this.dependencies.readClusterConfigSync(clusterOrModel),
-      );
-
-    this.clusters.set(cluster.id, cluster);
-
-    return cluster;
-  }
-
-  @action
-  protected fromStore({ clusters = [] }: ClusterStoreModel = {}) {
-    const currentClusters = new Map(this.clusters);
-    const newClusters = new Map<ClusterId, Cluster>();
-
-    // update new clusters
-    for (const clusterModel of clusters) {
-      try {
-        let cluster = currentClusters.get(clusterModel.id);
-
-        if (cluster) {
-          cluster.updateModel(clusterModel);
-        } else {
-          cluster = this.dependencies.createCluster(
-            clusterModel,
-            this.dependencies.readClusterConfigSync(clusterModel),
-          );
-        }
-        newClusters.set(clusterModel.id, cluster);
-      } catch (error) {
-        this.dependencies.logger.warn(`[CLUSTER-STORE]: Failed to update/create a cluster: ${error}`);
-      }
-    }
-
-    this.clusters.replace(newClusters);
-  }
-
-  toJSON(): ClusterStoreModel {
-    return toJS({
-      clusters: this.clustersList.map(cluster => cluster.toJSON()),
-    });
-  }
-}

src/common/cluster-store/get-by-id.injectable.ts

@@ -1,21 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import type { ClusterId } from "../cluster-types";
-import type { Cluster } from "../cluster/cluster";
-import clusterStoreInjectable from "./cluster-store.injectable";
-
-export type GetClusterById = (id: ClusterId) => Cluster | undefined;
-
-const getClusterByIdInjectable = getInjectable({
-  id: "get-cluster-by-id",
-  instantiate: (di): GetClusterById => {
-    const store = di.inject(clusterStoreInjectable);
-
-    return (id) => store.getById(id);
-  },
-});
-
-export default getClusterByIdInjectable;

src/common/cluster-store/migration-token.ts

@@ -1,11 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type { MigrationDeclaration } from "../base-store/migrations.injectable";
-
-export const clusterStoreMigrationInjectionToken = getInjectionToken<MigrationDeclaration>({
-  id: "cluster-store-migration",
-});

src/common/cluster-store/read-cluster-config.injectable.ts

@@ -1,31 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import type { ClusterConfigData, ClusterModel } from "../cluster-types";
-import readFileSyncInjectable from "../fs/read-file-sync.injectable";
-import { loadConfigFromString, validateKubeConfig } from "../kube-helpers";
-
-export type ReadClusterConfigSync = (model: ClusterModel) => ClusterConfigData;
-
-const readClusterConfigSyncInjectable = getInjectable({
-  id: "read-cluster-config-sync",
-  instantiate: (di): ReadClusterConfigSync => {
-    const readFileSync = di.inject(readFileSyncInjectable);
-
-    return ({ kubeConfigPath, contextName }) => {
-      const kubeConfigData = readFileSync(kubeConfigPath);
-      const { config } = loadConfigFromString(kubeConfigData);
-      const result = validateKubeConfig(config, contextName);
-
-      if (result.error) {
-        throw result.error;
-      }
-
-      return { clusterServerUrl: result.cluster.server };
-    };
-  },
-});
-
-export default readClusterConfigSyncInjectable;

src/common/cluster-types.ts

@@ -1,211 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import Joi from "joi";
-
-/**
- * JSON serializable metadata type
- */
-export type ClusterMetadata = Record<string, string | number | boolean | object>;
-
-/**
- * Metadata for cluster's prometheus settings
- */
-export interface ClusterPrometheusMetadata {
-  success?: boolean;
-  provider?: string;
-  autoDetected?: boolean;
-}
-
-/**
- * A ClusterId is an opaque string
- */
-export type ClusterId = string;
-
-/**
- * The fields that are used for updating a cluster instance
- */
-export type UpdateClusterModel = Omit<ClusterModel, "id">;
-
-/**
- * A type validator for `UpdateClusterModel` so that only expected types are present
- */
-export const updateClusterModelChecker = Joi.object<UpdateClusterModel>({
-  kubeConfigPath: Joi.string()
-    .required()
-    .min(1),
-  contextName: Joi.string()
-    .required()
-    .min(1),
-  workspace: Joi.string()
-    .optional(),
-  workspaces: Joi.array()
-    .items(Joi.string()),
-  preferences: Joi.object(),
-  metadata: Joi.object(),
-  accessibleNamespaces: Joi.array()
-    .items(Joi.string()),
-  labels: Joi.object().pattern(Joi.string(), Joi.string()),
-});
-
-/**
- * A type validator for just the `id` fields of `ClusterModel`. The rest is
- * covered by `updateClusterModelChecker`
- */
-export const clusterModelIdChecker = Joi.object<Pick<ClusterModel, "id">>({
-  id: Joi.string()
-    .required()
-    .min(1),
-});
-
-/**
- * The model for passing cluster data around, including to disk
- */
-export interface ClusterModel {
-  /** Unique id for a cluster */
-  id: ClusterId;
-
-  /** Path to cluster kubeconfig */
-  kubeConfigPath: string;
-
-  /**
-   * Workspace id
-   *
-   * @deprecated
-   */
-  workspace?: string;
-
-  /**
-   * @deprecated this is used only for hotbar migrations from 4.2.X
-   */
-  workspaces?: string[];
-
-  /** User context in kubeconfig  */
-  contextName: string;
-
-  /** Preferences */
-  preferences?: ClusterPreferences;
-
-  /** Metadata */
-  metadata?: ClusterMetadata;
-
-  /** List of accessible namespaces */
-  accessibleNamespaces?: string[];
-
-  /**
-   * Labels for the catalog entity
-   */
-  labels?: Record<string, string>;
-}
-
-/**
- * This data is retreived from the kubeconfig file before calling the cluster constructor.
- *
- * That is done to remove the external dependency on the construction of Cluster instances.
- */
-export interface ClusterConfigData {
-  clusterServerUrl: string;
-}
-
-/**
- * The complete set of cluster settings or preferences
- */
-export interface ClusterPreferences extends ClusterPrometheusPreferences {
-  terminalCWD?: string;
-  clusterName?: string;
-  iconOrder?: number;
-  /**
-   * The <img> src for the cluster. If set to `null` that means that it was
-   * cleared by preferences.
-   */
-  icon?: string | null;
-  httpsProxy?: string;
-  hiddenMetrics?: string[];
-  nodeShellImage?: string;
-  imagePullSecret?: string;
-  defaultNamespace?: string;
-}
-
-/**
- * A cluster's prometheus settings (a subset of cluster settings)
- */
-export interface ClusterPrometheusPreferences {
-  prometheus?: {
-    namespace: string;
-    service: string;
-    port: number;
-    prefix: string;
-  };
-  prometheusProvider?: {
-    type: string;
-  };
-}
-
-/**
- * The options for the status of connection attempts to a cluster
- */
-export enum ClusterStatus {
-  AccessGranted = 2,
-  AccessDenied = 1,
-  Offline = 0,
-}
-
-/**
- * The message format for the "cluster:<cluster-id>:connection-update" channels
- */
-export interface KubeAuthUpdate {
-  message: string;
-  isError: boolean;
-}
-
-/**
- * The OpenLens known static metadata keys
- */
-export enum ClusterMetadataKey {
-  VERSION = "version",
-  CLUSTER_ID = "id",
-  DISTRIBUTION = "distribution",
-  NODES_COUNT = "nodes",
-  LAST_SEEN = "lastSeen",
-  PROMETHEUS = "prometheus",
-}
-
-/**
- * A shorthand enum for resource types that have metrics attached to them via OpenLens metrics stack
- */
-export enum ClusterMetricsResourceType {
-  Cluster = "Cluster",
-  Node = "Node",
-  Pod = "Pod",
-  Deployment = "Deployment",
-  StatefulSet = "StatefulSet",
-  Container = "Container",
-  Ingress = "Ingress",
-  VolumeClaim = "VolumeClaim",
-  ReplicaSet = "ReplicaSet",
-  DaemonSet = "DaemonSet",
-  Job = "Job",
-  Namespace = "Namespace",
-}
-
-/**
- * The default node shell image
- */
-export const initialNodeShellImage = "docker.io/alpine:3.13";
-
-/**
- * The data representing a cluster's state, for passing between main and renderer
- */
-export interface ClusterState {
-  apiUrl: string;
-  online: boolean;
-  disconnected: boolean;
-  accessible: boolean;
-  ready: boolean;
-  isAdmin: boolean;
-  allowedNamespaces: string[];
-  allowedResources: string[];
-  isGlobalWatchEnabled: boolean;
-}

src/common/cluster/authorization-review.injectable.ts

@@ -1,59 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { KubeConfig, V1ResourceAttributes } from "@kubernetes/client-node";
-import { AuthorizationV1Api } from "@kubernetes/client-node";
-import { getInjectable } from "@ogre-tools/injectable";
-import type { Logger } from "../logger";
-import loggerInjectable from "../logger.injectable";
-
-/**
- * Requests the permissions for actions on the kube cluster
- * @param resourceAttributes The descriptor of the action that is desired to be known if it is allowed
- * @returns `true` if the actions described are allowed
- */
-export type CanI = (resourceAttributes: V1ResourceAttributes) => Promise<boolean>;
-
-/**
- * @param proxyConfig This config's `currentContext` field must be set, and will be used as the target cluster
- */
-export type AuthorizationReview = (proxyConfig: KubeConfig) => CanI; 
-
-interface Dependencies { 
-  logger: Logger;
-}
-
-const authorizationReview = ({ logger }: Dependencies): AuthorizationReview => {
-  return (proxyConfig) => {
-    const api = proxyConfig.makeApiClient(AuthorizationV1Api);
-
-    return async (resourceAttributes: V1ResourceAttributes): Promise<boolean> => {
-      try {
-        const { body } = await api.createSelfSubjectAccessReview({
-          apiVersion: "authorization.k8s.io/v1",
-          kind: "SelfSubjectAccessReview",
-          spec: { resourceAttributes },
-        });
-
-        return body.status?.allowed ?? false;
-      } catch (error) {
-        logger.error(`[AUTHORIZATION-REVIEW]: failed to create access review: ${error}`, { resourceAttributes });
-
-        return false;
-      }
-    };
-  };
-};
-
-const authorizationReviewInjectable = getInjectable({
-  id: "authorization-review",
-  instantiate: (di) => {
-    const logger = di.inject(loggerInjectable);
-
-    return authorizationReview({ logger });
-  },
-});
-
-export default authorizationReviewInjectable;

src/common/cluster/cluster.ts

@@ -1,709 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { action, comparer, computed, makeObservable, observable, reaction, runInAction, when } from "mobx";
-import type { ClusterContextHandler } from "../../main/context-handler/context-handler";
-import type { KubeConfig } from "@kubernetes/client-node";
-import { HttpError } from "@kubernetes/client-node";
-import type { Kubectl } from "../../main/kubectl/kubectl";
-import type { KubeconfigManager } from "../../main/kubeconfig-manager/kubeconfig-manager";
-import type { KubeApiResource, KubeApiResourceDescriptor } from "../rbac";
-import { formatKubeApiResource } from "../rbac";
-import plimit from "p-limit";
-import type { ClusterState, ClusterMetricsResourceType, ClusterId, ClusterMetadata, ClusterModel, ClusterPreferences, ClusterPrometheusPreferences, UpdateClusterModel, KubeAuthUpdate, ClusterConfigData } from "../cluster-types";
-import { ClusterMetadataKey, initialNodeShellImage, ClusterStatus, clusterModelIdChecker, updateClusterModelChecker } from "../cluster-types";
-import { disposer, isDefined, isRequestError, toJS } from "../utils";
-import { clusterListNamespaceForbiddenChannel } from "../ipc/cluster";
-import type { CanI } from "./authorization-review.injectable";
-import type { ListNamespaces } from "./list-namespaces.injectable";
-import assert from "assert";
-import type { Logger } from "../logger";
-import type { BroadcastMessage } from "../ipc/broadcast-message.injectable";
-import type { LoadConfigfromFile } from "../kube-helpers/load-config-from-file.injectable";
-import type { CanListResource, RequestNamespaceListPermissions, RequestNamespaceListPermissionsFor } from "./request-namespace-list-permissions.injectable";
-import type { RequestApiResources } from "../../main/cluster/request-api-resources.injectable";
-import type { DetectClusterMetadata } from "../../main/cluster-detectors/detect-cluster-metadata.injectable";
-import type { FalibleOnlyClusterMetadataDetector } from "../../main/cluster-detectors/token";
-
-export interface ClusterDependencies {
-  readonly directoryForKubeConfigs: string;
-  readonly logger: Logger;
-  readonly clusterVersionDetector: FalibleOnlyClusterMetadataDetector;
-  detectClusterMetadata: DetectClusterMetadata;
-  createKubeconfigManager: (cluster: Cluster) => KubeconfigManager;
-  createContextHandler: (cluster: Cluster) => ClusterContextHandler;
-  createKubectl: (clusterVersion: string) => Kubectl;
-  createAuthorizationReview: (config: KubeConfig) => CanI;
-  requestApiResources: RequestApiResources;
-  requestNamespaceListPermissionsFor: RequestNamespaceListPermissionsFor;
-  createListNamespaces: (config: KubeConfig) => ListNamespaces;
-  broadcastMessage: BroadcastMessage;
-  loadConfigfromFile: LoadConfigfromFile;
-}
-
-/**
- * Cluster
- *
- * @beta
- */
-export class Cluster implements ClusterModel {
-  /** Unique id for a cluster */
-  public readonly id: ClusterId;
-  private kubeCtl: Kubectl | undefined;
-  /**
-   * Context handler
-   *
-   * @internal
-   */
-  protected readonly _contextHandler: ClusterContextHandler | undefined;
-  protected readonly _proxyKubeconfigManager: KubeconfigManager | undefined;
-  protected readonly eventsDisposer = disposer();
-  protected activated = false;
-
-  public get contextHandler() {
-    // TODO: remove these once main/renderer are seperate classes
-    assert(this._contextHandler, "contextHandler is only defined in the main environment");
-
-    return this._contextHandler;
-  }
-
-  protected get proxyKubeconfigManager() {
-    // TODO: remove these once main/renderer are seperate classes
-    assert(this._proxyKubeconfigManager, "proxyKubeconfigManager is only defined in the main environment");
-
-    return this._proxyKubeconfigManager;
-  }
-
-  get whenReady() {
-    return when(() => this.ready);
-  }
-
-  /**
-   * Kubeconfig context name
-   *
-   * @observable
-   */
-  @observable contextName!: string;
-  /**
-   * Path to kubeconfig
-   *
-   * @observable
-   */
-  @observable kubeConfigPath!: string;
-  /**
-   * @deprecated
-   */
-  @observable workspace?: string;
-  /**
-   * @deprecated
-   */
-  @observable workspaces?: string[];
-  /**
-   * Kubernetes API server URL
-   *
-   * @observable
-   */
-  @observable apiUrl: string; // cluster server url
-  /**
-   * Is cluster online
-   *
-   * @observable
-   */
-  @observable online = false; // describes if we can detect that cluster is online
-  /**
-   * Can user access cluster resources
-   *
-   * @observable
-   */
-  @observable accessible = false; // if user is able to access cluster resources
-  /**
-   * Is cluster instance in usable state
-   *
-   * @observable
-   */
-  @observable ready = false; // cluster is in usable state
-  /**
-   * Is cluster currently reconnecting
-   *
-   * @observable
-   */
-  @observable reconnecting = false;
-  /**
-   * Is cluster disconnected. False if user has selected to connect.
-   *
-   * @observable
-   */
-  @observable disconnected = true;
-  /**
-   * Does user have admin like access
-   *
-   * @observable
-   */
-  @observable isAdmin = false;
-
-  /**
-   * Global watch-api accessibility , e.g. "/api/v1/services?watch=1"
-   *
-   * @observable
-   */
-  @observable isGlobalWatchEnabled = false;
-  /**
-   * Preferences
-   *
-   * @observable
-   */
-  @observable preferences: ClusterPreferences = {};
-  /**
-   * Metadata
-   *
-   * @observable
-   */
-  @observable metadata: ClusterMetadata = {};
-
-  /**
-   * List of allowed namespaces verified via K8S::SelfSubjectAccessReview api
-   */
-  readonly allowedNamespaces = observable.array<string>();
-
-  /**
-   * List of accessible namespaces provided by user in the Cluster Settings
-   */
-  readonly accessibleNamespaces = observable.array<string>();
-
-  private readonly knownResources = observable.array<KubeApiResource>();
-
-  // The formatting of this is `group.name` or `name` (if in core)
-  private readonly allowedResources = observable.set<string>();
-
-  /**
-   * Labels for the catalog entity
-   */
-  @observable labels: Record<string, string> = {};
-
-  /**
-   * Is cluster available
-   *
-   * @computed
-   */
-  @computed get available() {
-    return this.accessible && !this.disconnected;
-  }
-
-  /**
-   * Cluster name
-   *
-   * @computed
-   */
-  @computed get name() {
-    return this.preferences.clusterName || this.contextName;
-  }
-
-  /**
-   * The detected kubernetes distribution
-   */
-  @computed get distribution(): string {
-    return this.metadata[ClusterMetadataKey.DISTRIBUTION]?.toString() || "unknown";
-  }
-
-  /**
-   * The detected kubernetes version
-   */
-  @computed get version(): string {
-    return this.metadata[ClusterMetadataKey.VERSION]?.toString() || "unknown";
-  }
-
-  /**
-   * Prometheus preferences
-   *
-   * @computed
-   * @internal
-   */
-  @computed get prometheusPreferences(): ClusterPrometheusPreferences {
-    const { prometheus, prometheusProvider } = this.preferences;
-
-    return toJS({ prometheus, prometheusProvider });
-  }
-
-  /**
-   * defaultNamespace preference
-   *
-   * @computed
-   * @internal
-   */
-  @computed get defaultNamespace(): string | undefined {
-    return this.preferences.defaultNamespace;
-  }
-
-  constructor(private readonly dependencies: ClusterDependencies, { id, ...model }: ClusterModel, configData: ClusterConfigData) {
-    makeObservable(this);
-
-    const { error } = clusterModelIdChecker.validate({ id });
-
-    if (error) {
-      throw error;
-    }
-
-    this.id = id;
-    this.updateModel(model);
-    this.apiUrl = configData.clusterServerUrl;
-
-    // for the time being, until renderer gets its own cluster type
-    this._contextHandler = this.dependencies.createContextHandler(this);
-    this._proxyKubeconfigManager = this.dependencies.createKubeconfigManager(this);
-    this.dependencies.logger.debug(`[CLUSTER]: Cluster init success`, {
-      id: this.id,
-      context: this.contextName,
-      apiUrl: this.apiUrl,
-    });
-  }
-
-  /**
-   * Update cluster data model
-   *
-   * @param model
-   */
-  @action updateModel(model: UpdateClusterModel) {
-    // Note: do not assign ID as that should never be updated
-
-    const { error } = updateClusterModelChecker.validate(model, { allowUnknown: true });
-
-    if (error) {
-      throw error;
-    }
-
-    this.kubeConfigPath = model.kubeConfigPath;
-    this.contextName = model.contextName;
-
-    if (model.workspace) {
-      this.workspace = model.workspace;
-    }
-
-    if (model.workspaces) {
-      this.workspaces = model.workspaces;
-    }
-
-    if (model.preferences) {
-      this.preferences = model.preferences;
-    }
-
-    if (model.metadata) {
-      this.metadata = model.metadata;
-    }
-
-    if (model.accessibleNamespaces) {
-      this.accessibleNamespaces.replace(model.accessibleNamespaces);
-    }
-
-    if (model.labels) {
-      this.labels = model.labels;
-    }
-  }
-
-  /**
-   * @internal
-   */
-  protected bindEvents() {
-    this.dependencies.logger.info(`[CLUSTER]: bind events`, this.getMeta());
-    const refreshTimer = setInterval(() => !this.disconnected && this.refresh(), 30000); // every 30s
-    const refreshMetadataTimer = setInterval(() => this.available && this.refreshAccessibilityAndMetadata(), 900000); // every 15 minutes
-
-    this.eventsDisposer.push(
-      reaction(
-        () => this.prometheusPreferences,
-        prefs => this.contextHandler.setupPrometheus(prefs),
-        { equals: comparer.structural },
-      ),
-      () => clearInterval(refreshTimer),
-      () => clearInterval(refreshMetadataTimer),
-      reaction(() => this.defaultNamespace, () => this.recreateProxyKubeconfig()),
-    );
-  }
-
-  /**
-   * @internal
-   */
-  protected async recreateProxyKubeconfig() {
-    this.dependencies.logger.info("[CLUSTER]: Recreating proxy kubeconfig");
-
-    try {
-      await this.proxyKubeconfigManager.clear();
-      await this.getProxyKubeconfig();
-    } catch (error) {
-      this.dependencies.logger.error(`[CLUSTER]: failed to recreate proxy kubeconfig`, error);
-    }
-  }
-
-  /**
-   * @param force force activation
-   * @internal
-   */
-  @action
-  async activate(force = false) {
-    if (this.activated && !force) {
-      return;
-    }
-
-    this.dependencies.logger.info(`[CLUSTER]: activate`, this.getMeta());
-
-    if (!this.eventsDisposer.length) {
-      this.bindEvents();
-    }
-
-    if (this.disconnected || !this.accessible) {
-      try {
-        this.broadcastConnectUpdate("Starting connection ...");
-        await this.reconnect();
-      } catch (error) {
-        this.broadcastConnectUpdate(`Failed to start connection: ${error}`, true);
-
-        return;
-      }
-    }
-
-    try {
-      this.broadcastConnectUpdate("Refreshing connection status ...");
-      await this.refreshConnectionStatus();
-    } catch (error) {
-      this.broadcastConnectUpdate(`Failed to connection status: ${error}`, true);
-
-      return;
-    }
-
-    if (this.accessible) {
-      try {
-        this.broadcastConnectUpdate("Refreshing cluster accessibility ...");
-        await this.refreshAccessibility();
-      } catch (error) {
-        this.broadcastConnectUpdate(`Failed to refresh accessibility: ${error}`, true);
-
-        return;
-      }
-
-      // download kubectl in background, so it's not blocking dashboard
-      this.ensureKubectl()
-        .catch(error => this.dependencies.logger.warn(`[CLUSTER]: failed to download kubectl for clusterId=${this.id}`, error));
-      this.broadcastConnectUpdate("Connected, waiting for view to load ...");
-    }
-
-    this.activated = true;
-  }
-
-  /**
-   * @internal
-   */
-  async ensureKubectl() {
-    this.kubeCtl ??= this.dependencies.createKubectl(this.version);
-
-    await this.kubeCtl.ensureKubectl();
-
-    return this.kubeCtl;
-  }
-
-  /**
-   * @internal
-   */
-  @action
-  async reconnect() {
-    this.dependencies.logger.info(`[CLUSTER]: reconnect`, this.getMeta());
-    await this.contextHandler?.restartServer();
-    this.disconnected = false;
-  }
-
-  /**
-   * @internal
-   */
-  @action disconnect(): void {
-    if (this.disconnected) {
-      return void this.dependencies.logger.debug("[CLUSTER]: already disconnected", { id: this.id });
-    }
-
-    this.dependencies.logger.info(`[CLUSTER]: disconnecting`, { id: this.id });
-    this.eventsDisposer();
-    this.contextHandler?.stopServer();
-    this.disconnected = true;
-    this.online = false;
-    this.accessible = false;
-    this.ready = false;
-    this.activated = false;
-    this.allowedNamespaces.clear();
-    this.dependencies.logger.info(`[CLUSTER]: disconnected`, { id: this.id });
-  }
-
-  /**
-   * @internal
-   */
-  @action
-  async refresh() {
-    this.dependencies.logger.info(`[CLUSTER]: refresh`, this.getMeta());
-    await this.refreshConnectionStatus();
-  }
-
-  /**
-   * @internal
-   */
-  @action
-  async refreshAccessibilityAndMetadata() {
-    await this.refreshAccessibility();
-    await this.refreshMetadata();
-  }
-
-  /**
-  * @internal
-  */
-  async refreshMetadata() {
-    this.dependencies.logger.info(`[CLUSTER]: refreshMetadata`, this.getMeta());
-
-    const newMetadata = await this.dependencies.detectClusterMetadata(this);
-
-    runInAction(() => {
-      this.metadata = {
-        ...this.metadata,
-        ...newMetadata,
-      };
-    });
-  }
-
-  /**
-  * @internal
-  */
-  private async refreshAccessibility(): Promise<void> {
-    this.dependencies.logger.info(`[CLUSTER]: refreshAccessibility`, this.getMeta());
-    const proxyConfig = await this.getProxyKubeconfig();
-    const canI = this.dependencies.createAuthorizationReview(proxyConfig);
-    const requestNamespaceListPermissions = this.dependencies.requestNamespaceListPermissionsFor(proxyConfig);
-
-    this.isAdmin = await canI({
-      namespace: "kube-system",
-      resource: "*",
-      verb: "create",
-    });
-    this.isGlobalWatchEnabled = await canI({
-      verb: "watch",
-      resource: "*",
-    });
-    this.allowedNamespaces.replace(await this.requestAllowedNamespaces(proxyConfig));
-    this.knownResources.replace(await this.dependencies.requestApiResources(this));
-    this.allowedResources.replace(await this.getAllowedResources(requestNamespaceListPermissions));
-    this.ready = true;
-  }
-
-  /**
-   * @internal
-   */
-  @action
-  async refreshConnectionStatus() {
-    const connectionStatus = await this.getConnectionStatus();
-
-    this.online = connectionStatus > ClusterStatus.Offline;
-    this.accessible = connectionStatus == ClusterStatus.AccessGranted;
-  }
-
-  async getKubeconfig(): Promise<KubeConfig> {
-    const { config } = await this.dependencies.loadConfigfromFile(this.kubeConfigPath);
-
-    return config;
-  }
-
-  /**
-   * @internal
-   */
-  async getProxyKubeconfig(): Promise<KubeConfig> {
-    const proxyKCPath = await this.getProxyKubeconfigPath();
-    const { config } = await this.dependencies.loadConfigfromFile(proxyKCPath);
-
-    return config;
-  }
-
-  /**
-   * @internal
-   */
-  async getProxyKubeconfigPath(): Promise<string> {
-    return this.proxyKubeconfigManager.getPath();
-  }
-
-  protected async getConnectionStatus(): Promise<ClusterStatus> {
-    try {
-      const versionData = await this.dependencies.clusterVersionDetector.detect(this);
-
-      this.metadata.version = versionData.value;
-
-      return ClusterStatus.AccessGranted;
-    } catch (error) {
-      this.dependencies.logger.error(`[CLUSTER]: Failed to connect to "${this.contextName}": ${error}`);
-
-      if (isRequestError(error)) {
-        if (error.statusCode) {
-          if (error.statusCode >= 400 && error.statusCode < 500) {
-            this.broadcastConnectUpdate("Invalid credentials", true);
-
-            return ClusterStatus.AccessDenied;
-          }
-
-          const message = String(error.error || error.message) || String(error);
-
-          this.broadcastConnectUpdate(message, true);
-
-          return ClusterStatus.Offline;
-        }
-
-        if (error.failed === true) {
-          if (error.timedOut === true) {
-            this.broadcastConnectUpdate("Connection timed out", true);
-
-            return ClusterStatus.Offline;
-          }
-
-          this.broadcastConnectUpdate("Failed to fetch credentials", true);
-
-          return ClusterStatus.AccessDenied;
-        }
-
-        const message = String(error.error || error.message) || String(error);
-
-        this.broadcastConnectUpdate(message, true);
-      } else if (error instanceof Error || typeof error === "string") {
-        this.broadcastConnectUpdate(`${error}`, true);
-      } else {
-        this.broadcastConnectUpdate("Unknown error has occurred", true);
-      }
-
-      return ClusterStatus.Offline;
-    }
-  }
-
-  toJSON(): ClusterModel {
-    return toJS({
-      id: this.id,
-      contextName: this.contextName,
-      kubeConfigPath: this.kubeConfigPath,
-      workspace: this.workspace,
-      workspaces: this.workspaces,
-      preferences: this.preferences,
-      metadata: this.metadata,
-      accessibleNamespaces: this.accessibleNamespaces,
-      labels: this.labels,
-    });
-  }
-
-  /**
-   * Serializable cluster-state used for sync btw main <-> renderer
-   */
-  getState(): ClusterState {
-    return toJS({
-      apiUrl: this.apiUrl,
-      online: this.online,
-      ready: this.ready,
-      disconnected: this.disconnected,
-      accessible: this.accessible,
-      isAdmin: this.isAdmin,
-      allowedNamespaces: this.allowedNamespaces,
-      allowedResources: [...this.allowedResources],
-      isGlobalWatchEnabled: this.isGlobalWatchEnabled,
-    });
-  }
-
-  /**
-   * @internal
-   * @param state cluster state
-   */
-  @action setState(state: ClusterState) {
-    this.accessible = state.accessible;
-    this.allowedNamespaces.replace(state.allowedNamespaces);
-    this.allowedResources.replace(state.allowedResources);
-    this.apiUrl = state.apiUrl;
-    this.disconnected = state.disconnected;
-    this.isAdmin = state.isAdmin;
-    this.isGlobalWatchEnabled = state.isGlobalWatchEnabled;
-    this.online = state.online;
-    this.ready = state.ready;
-  }
-
-  // get cluster system meta, e.g. use in "logger"
-  getMeta() {
-    return {
-      id: this.id,
-      name: this.contextName,
-      ready: this.ready,
-      online: this.online,
-      accessible: this.accessible,
-      disconnected: this.disconnected,
-    };
-  }
-
-  /**
-   * broadcast an authentication update concerning this cluster
-   * @internal
-   */
-  broadcastConnectUpdate(message: string, isError = false): void {
-    const update: KubeAuthUpdate = { message, isError };
-
-    this.dependencies.logger.debug(`[CLUSTER]: broadcasting connection update`, { ...update, meta: this.getMeta() });
-    this.dependencies.broadcastMessage(`cluster:${this.id}:connection-update`, update);
-  }
-
-  protected async requestAllowedNamespaces(proxyConfig: KubeConfig) {
-    if (this.accessibleNamespaces.length) {
-      return this.accessibleNamespaces;
-    }
-
-    try {
-      const listNamespaces = this.dependencies.createListNamespaces(proxyConfig);
-
-      return await listNamespaces();
-    } catch (error) {
-      const ctx = proxyConfig.getContextObject(this.contextName);
-      const namespaceList = [ctx?.namespace].filter(isDefined);
-
-      if (namespaceList.length === 0 && error instanceof HttpError && error.statusCode === 403) {
-        const { response } = error as HttpError & { response: { body: unknown }};
-
-        this.dependencies.logger.info("[CLUSTER]: listing namespaces is forbidden, broadcasting", { clusterId: this.id, error: response.body });
-        this.dependencies.broadcastMessage(clusterListNamespaceForbiddenChannel, this.id);
-      }
-
-      return namespaceList;
-    }
-  }
-
-  protected async getAllowedResources(requestNamespaceListPermissions: RequestNamespaceListPermissions) {
-    if (!this.allowedNamespaces.length) {
-      return [];
-    }
-
-    try {
-      const apiLimit = plimit(5); // 5 concurrent api requests
-      const canListResourceCheckers = await Promise.all((
-        this.allowedNamespaces.map(namespace => apiLimit(() => requestNamespaceListPermissions(namespace)))
-      ));
-      const canListNamespacedResource: CanListResource = (resource) => canListResourceCheckers.some(fn => fn(resource));
-
-      return this.knownResources
-        .filter(canListNamespacedResource)
-        .map(formatKubeApiResource);
-    } catch (error) {
-      return [];
-    }
-  }
-
-  shouldShowResource(resource: KubeApiResourceDescriptor): boolean {
-    return this.allowedResources.has(formatKubeApiResource(resource));
-  }
-
-  isMetricHidden(resource: ClusterMetricsResourceType): boolean {
-    return Boolean(this.preferences.hiddenMetrics?.includes(resource));
-  }
-
-  get nodeShellImage(): string {
-    return this.preferences?.nodeShellImage || initialNodeShellImage;
-  }
-
-  get imagePullSecret(): string | undefined {
-    return this.preferences?.imagePullSecret;
-  }
-
-  isInLocalKubeconfig() {
-    return this.kubeConfigPath.startsWith(this.dependencies.directoryForKubeConfigs);
-  }
-}

src/common/cluster/create-cluster-injection-token.ts

@@ -1,13 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectionToken } from "@ogre-tools/injectable";
-import type { ClusterConfigData, ClusterModel } from "../cluster-types";
-import type { Cluster } from "./cluster";
-
-export type CreateCluster = (model: ClusterModel, configData: ClusterConfigData) => Cluster;
-
-export const createClusterInjectionToken = getInjectionToken<CreateCluster>({
-  id: "create-cluster-token",
-});

src/common/cluster/current-cluster-channel.ts

@@ -1,11 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { ClusterId } from "../cluster-types";
-import type { MessageChannel } from "../utils/channel/message-channel-listener-injection-token";
-
-export const currentClusterMessageChannel: MessageChannel<ClusterId> = {
-  id: "current-visible-cluster",
-};

src/common/cluster/list-namespaces.injectable.ts

@@ -1,29 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import type { KubeConfig } from "@kubernetes/client-node";
-import { CoreV1Api } from "@kubernetes/client-node";
-import { getInjectable } from "@ogre-tools/injectable";
-import { isDefined } from "../utils";
-
-export type ListNamespaces = () => Promise<string[]>;
-
-export function listNamespaces(config: KubeConfig): ListNamespaces {
-  const coreApi = config.makeApiClient(CoreV1Api);
-
-  return async () => {
-    const { body: { items }} = await coreApi.listNamespace();
-
-    return items
-      .map(ns => ns.metadata?.name)
-      .filter(isDefined);
-  };
-}
-
-const listNamespacesInjectable = getInjectable({
-  id: "list-namespaces",
-  instantiate: () => listNamespaces,
-});
-
-export default listNamespacesInjectable;

src/common/cluster/request-namespace-list-permissions.injectable.ts

@@ -1,78 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { KubeConfig } from "@kubernetes/client-node";
-import { AuthorizationV1Api } from "@kubernetes/client-node";
-import { getInjectable } from "@ogre-tools/injectable";
-import loggerInjectable from "../logger.injectable";
-import type { KubeApiResource } from "../rbac";
-
-export type CanListResource = (resource: KubeApiResource) => boolean;
-
-/**
- * Requests the permissions for actions on the kube cluster
- * @param namespace The namespace of the resources
- */
-export type RequestNamespaceListPermissions = (namespace: string) => Promise<CanListResource>;
-
-/**
- * @param proxyConfig This config's `currentContext` field must be set, and will be used as the target cluster
- */
-export type RequestNamespaceListPermissionsFor = (proxyConfig: KubeConfig) => RequestNamespaceListPermissions;
-
-const requestNamespaceListPermissionsForInjectable = getInjectable({
-  id: "request-namespace-list-permissions-for",
-  instantiate: (di): RequestNamespaceListPermissionsFor => {
-    const logger = di.inject(loggerInjectable);
-
-    return (proxyConfig) => {
-      const api = proxyConfig.makeApiClient(AuthorizationV1Api);
-
-      return async (namespace) => {
-        try {
-          const { body: { status }} = await api.createSelfSubjectRulesReview({
-            apiVersion: "authorization.k8s.io/v1",
-            kind: "SelfSubjectRulesReview",
-            spec: { namespace },
-          });
-
-          if (!status || status.incomplete) {
-            logger.warn(`[AUTHORIZATION-NAMESPACE-REVIEW]: allowing all resources in namespace="${namespace}" due to incomplete SelfSubjectRulesReview: ${status?.evaluationError}`);
-
-            return () => true;
-          }
-
-          const { resourceRules } = status;
-
-          return (resource) => {
-            const resourceRule = resourceRules.find(({
-              apiGroups = [],
-              resources = [],
-            }) => {
-              const isAboutRelevantApiGroup = apiGroups.includes("*") || apiGroups.includes(resource.group);
-              const isAboutResource = resources.includes("*") || resources.includes(resource.apiName);
-
-              return isAboutRelevantApiGroup && isAboutResource;
-            });
-
-            if (!resourceRule) {
-              return false;
-            }
-
-            const { verbs } = resourceRule;
-
-            return verbs.includes("*") || verbs.includes("list");
-          };
-        } catch (error) {
-          logger.error(`[AUTHORIZATION-NAMESPACE-REVIEW]: failed to create subject rules review`, { namespace, error });
-
-          return () => true;
-        }
-      };
-    };
-  },
-});
-
-export default requestNamespaceListPermissionsForInjectable;

src/common/cluster/visibility-channel.ts

@@ -1,11 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import type { ClusterId } from "../cluster-types";
-import type { MessageChannel } from "../utils/channel/message-channel-listener-injection-token";
-
-export const clusterVisibilityChannel: MessageChannel<ClusterId | null> = {
-  id: "cluster-visibility",
-};

src/common/directory-for-lens-local-storage/directory-for-lens-local-storage.injectable.ts

@@ -1,23 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import directoryForUserDataInjectable from "../app-paths/directory-for-user-data/directory-for-user-data.injectable";
-import joinPathsInjectable from "../path/join-paths.injectable";
-
-const directoryForLensLocalStorageInjectable = getInjectable({
-  id: "directory-for-lens-local-storage",
-
-  instantiate: (di) => {
-    const joinPaths = di.inject(joinPathsInjectable);
-    const directoryForUserData = di.inject(directoryForUserDataInjectable);
-
-    return joinPaths(
-      directoryForUserData,
-      "lens-local-storage",
-    );
-  },
-});
-
-export default directoryForLensLocalStorageInjectable;

src/common/error-reporting/initialize-sentry-reporting.global-override-for-injectable.ts

@@ -1,9 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { getGlobalOverride } from "../test-utils/get-global-override";
-import initializeSentryReportingWithInjectable from "./initialize-sentry-reporting.injectable";
-
-export default getGlobalOverride(initializeSentryReportingWithInjectable, () => () => {});

src/common/error-reporting/initialize-sentry-reporting.injectable.ts

@@ -1,63 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import type { ElectronMainOptions } from "@sentry/electron/main";
-import type { BrowserOptions } from "@sentry/electron/renderer";
-import isProductionInjectable from "../vars/is-production.injectable";
-import sentryDataSourceNameInjectable from "../vars/sentry-dsn-url.injectable";
-import { Dedupe, Offline } from "@sentry/integrations";
-import { inspect } from "util";
-import userStoreInjectable from "../user-store/user-store.injectable";
-
-export type InitializeSentryReportingWith = (initSentry: (opts: BrowserOptions | ElectronMainOptions) => void) => void;
-
-const mapProcessName = (type: "browser" | "renderer" | "worker") => type === "browser" ? "main" : type;
-
-const initializeSentryReportingWithInjectable = getInjectable({
-  id: "initialize-sentry-reporting-with",
-  instantiate: (di): InitializeSentryReportingWith => {
-    const sentryDataSourceName = di.inject(sentryDataSourceNameInjectable);
-    const isProduction = di.inject(isProductionInjectable);
-    const userStore = di.inject(userStoreInjectable);
-
-    if (!sentryDataSourceName) {
-      return () => {};
-    }
-
-    return (initSentry) => initSentry({
-      beforeSend: (event) => {
-        if (userStore.allowErrorReporting) {
-          return event;
-        }
-
-        /**
-         * Directly write to stdout so that no other integrations capture this and create an infinite loop
-         */
-        process.stdout.write(`🔒  [SENTRY-BEFORE-SEND-HOOK]: Sentry event is caught but not sent to server.`);
-        process.stdout.write("🔒  [SENTRY-BEFORE-SEND-HOOK]: === START OF SENTRY EVENT ===");
-        process.stdout.write(inspect(event, false, null, true));
-        process.stdout.write("🔒  [SENTRY-BEFORE-SEND-HOOK]: ===  END OF SENTRY EVENT  ===");
-
-        // if return null, the event won't be sent
-        // ref https://github.com/getsentry/sentry-javascript/issues/2039
-        return null;
-      },
-      dsn: sentryDataSourceName,
-      integrations: [
-        new Dedupe(),
-        new Offline(),
-      ],
-      initialScope: {
-        tags: {
-          "process": mapProcessName(process.type),
-        },
-      },
-      environment: isProduction ? "production" : "development",
-    });
-  },
-  causesSideEffects: true,
-});
-
-export default initializeSentryReportingWithInjectable;

src/common/event-emitter.ts

@@ -1,43 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-// Custom event emitter
-
-interface Options {
-  once?: boolean; // call once and remove
-  prepend?: boolean; // put listener to the beginning
-}
-
-type Callback<D extends [...any[]]> = (...data: D) => void | boolean;
-
-export class EventEmitter<D extends [...any[]]> {
-  protected listeners: [Callback<D>, Options][] = [];
-
-  addListener(callback: Callback<D>, options: Options = {}) {
-    const fn = options.prepend ? "unshift" : "push";
-
-    this.listeners[fn]([callback, options]);
-  }
-
-  removeListener(callback: Callback<D>) {
-    this.listeners = this.listeners.filter(([cb]) => cb !== callback);
-  }
-
-  removeAllListeners() {
-    this.listeners.length = 0;
-  }
-
-  emit(...data: D) {
-    for (const [callback, { once }] of this.listeners) {
-      if (once) {
-        this.removeListener(callback);
-      }
-
-      if (callback(...data) === false) {
-        break;
-      }
-    }
-  }
-}

src/common/fetch/download-binary.injectable.ts

@@ -1,56 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import type { RequestInit, Response } from "node-fetch";
-import type { AsyncResult } from "../utils/async-result";
-import fetchInjectable from "./fetch.injectable";
-
-export interface DownloadBinaryOptions {
-  signal?: AbortSignal | null | undefined;
-}
-
-export type DownloadBinary = (url: string, opts?: DownloadBinaryOptions) => Promise<AsyncResult<Buffer, string>>;
-
-const downloadBinaryInjectable = getInjectable({
-  id: "download-binary",
-  instantiate: (di): DownloadBinary => {
-    const fetch = di.inject(fetchInjectable);
-
-    return async (url, opts) => {
-      let result: Response;
-
-      try {
-        // TODO: upgrade node-fetch once we switch to ESM
-        result = await fetch(url, opts as RequestInit);
-      } catch (error) {
-        return {
-          callWasSuccessful: false,
-          error: String(error),
-        };
-      }
-
-      if (result.status < 200 || 300 <= result.status) {
-        return {
-          callWasSuccessful: false,
-          error: result.statusText,
-        };
-      }
-
-      try {
-        return {
-          callWasSuccessful: true,
-          response: await result.buffer(),
-        };
-      } catch (error) {
-        return {
-          callWasSuccessful: false,
-          error: String(error),
-        };
-      }
-    };
-  },
-});
-
-export default downloadBinaryInjectable;

src/common/fetch/download-json/impl.ts

@@ -1,46 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import type { AsyncResult } from "../../utils/async-result";
-import type { Fetch } from "../fetch.injectable";
-import type { RequestInit, Response } from "node-fetch";
-
-export interface DownloadJsonOptions {
-  signal?: AbortSignal | null | undefined;
-}
-
-export type DownloadJson = (url: string, opts?: DownloadJsonOptions) => Promise<AsyncResult<unknown, string>>;
-
-export const downloadJsonWith = (fetch: Fetch): DownloadJson => async (url, opts) => {
-  let result: Response;
-
-  try {
-    result = await fetch(url, opts as RequestInit);
-  } catch (error) {
-    return {
-      callWasSuccessful: false,
-      error: String(error),
-    };
-  }
-
-  if (result.status < 200 || 300 <= result.status) {
-    return {
-      callWasSuccessful: false,
-      error: result.statusText,
-    };
-  }
-
-  try {
-    return {
-      callWasSuccessful: true,
-      response: await result.json(),
-    };
-  } catch (error) {
-    return {
-      callWasSuccessful: false,
-      error: String(error),
-    };
-  }
-};
-

src/common/fetch/download-json/normal.injectable.ts

@@ -1,14 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import fetchInjectable from "../fetch.injectable";
-import { downloadJsonWith } from "./impl";
-
-const downloadJsonInjectable = getInjectable({
-  id: "download-json",
-  instantiate: (di) => downloadJsonWith(di.inject(fetchInjectable)),
-});
-
-export default downloadJsonInjectable;

src/common/fetch/download-json/proxy.injectable.ts

@@ -1,14 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import proxyFetchInjectable from "../proxy-fetch.injectable";
-import { downloadJsonWith } from "./impl";
-
-const proxyDownloadJsonInjectable = getInjectable({
-  id: "proxy-download-json",
-  instantiate: (di) => downloadJsonWith(di.inject(proxyFetchInjectable)),
-});
-
-export default proxyDownloadJsonInjectable;

src/common/fetch/fetch-module.injectable.ts

@@ -1,19 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-import { getInjectable } from "@ogre-tools/injectable";
-import type * as FetchModule from "node-fetch";
-
-const { NodeFetch } = require("../../../build/webpack/node-fetch.bundle") as { NodeFetch: typeof FetchModule };
-
-/**
- * NOTE: while using this module can cause side effects, this specific injectable is not marked as
- * such since sometimes the request can be wholely within the perview of unit test
- */
-const nodeFetchModuleInjectable = getInjectable({
-  id: "node-fetch-module",
-  instantiate: () => NodeFetch,
-});
-
-export default nodeFetchModuleInjectable;

src/common/fetch/fetch.global-override-for-injectable.ts

@@ -1,9 +0,0 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-
-import { getGlobalOverrideForFunction } from "../test-utils/get-global-override-for-function";
-import fetchInjectable from "./fetch.injectable";
-
-export default getGlobalOverrideForFunction(fetchInjectable);