Restructure to monorepo (#6907)

* wip: restructure to monorepo

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

* refactor create-release-pr to a package

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

* build fixes

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

* github workflow fixes

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

* fix typo

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

* add webpack-env types to core

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

* fix github workflows

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

* refactor/fix integration tests

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

* lint fix

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

* yarn run dev

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

* eslint settings for vscode

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

* move templates to right package

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

* open-lens build fixes

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

* integration test fix

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

* fix nx task dependencies

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

* use bash shell for unit tests in test workflow

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

* fix test:unit for windows

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

* fix win-ca webpack error in open-lens

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

* fix win-ca webpack error in open-lens

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

* fix build:app on windows

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

* remove ELECTRON_BUILDER_EXTRA_ARGS

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

* sync src/ from master

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

* remove Makefile from core

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

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

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

@@ -0,0 +1,90 @@
+/**
+ * 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);
+  });
+});

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

@@ -0,0 +1,52 @@
+/**
+ * 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();
+  });
+});

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

@@ -0,0 +1,359 @@
+/**
+ * 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: {},
+});

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

@@ -0,0 +1,86 @@
+/**
+ * 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]);
+  });
+});

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

@@ -0,0 +1,356 @@
+/**
+ * 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",
+        },
+      });
+    });
+  });
+});

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

@@ -0,0 +1,235 @@
+/**
+ * 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");
+      });
+    });
+  });
+});

packages/core/src/common/__tests__/timezones.test.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 {};

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

@@ -0,0 +1,105 @@
+/**
+ * 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");
+    });
+  });
+});

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

@@ -0,0 +1,15 @@
+/**
+ * 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;

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

@@ -0,0 +1,21 @@
+/**
+ * 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;

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

@@ -0,0 +1,14 @@
+/**
+ * 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>;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * 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>;

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

@@ -0,0 +1,27 @@
+/**
+ * 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",
+];

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

@@ -0,0 +1,13 @@
+/**
+ * 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",
+};
+

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

@@ -0,0 +1,34 @@
+/**
+ * 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;

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

@@ -0,0 +1,13 @@
+/**
+ * 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;

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

@@ -0,0 +1,153 @@
+/**
+ * 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",
+      });
+    });
+  });
+});

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

@@ -0,0 +1,20 @@
+/**
+ * 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;

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

@@ -0,0 +1,13 @@
+/**
+ * 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;

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

@@ -0,0 +1,13 @@
+/**
+ * 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;

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

@@ -0,0 +1,20 @@
+/**
+ * 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;

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

@@ -0,0 +1,20 @@
+/**
+ * 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;

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

@@ -0,0 +1,13 @@
+/**
+ * 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;

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

@@ -0,0 +1,13 @@
+/**
+ * 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;

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

@@ -0,0 +1,13 @@
+/**
+ * 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;

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

@@ -0,0 +1,22 @@
+/**
+ * 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;

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

@@ -0,0 +1,9 @@
+/**
+ * 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");

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

@@ -0,0 +1,13 @@
+/**
+ * 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;

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

@@ -0,0 +1,148 @@
+/**
+ * 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;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * 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",
+});

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

@@ -0,0 +1,10 @@
+/**
+ * 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",
+});

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

@@ -0,0 +1,46 @@
+/**
+ * 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;

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

@@ -0,0 +1,12 @@
+/**
+ * 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",
+});

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

@@ -0,0 +1,56 @@
+/**
+ * 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]);
+    });
+  });
+});

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

@@ -0,0 +1,10 @@
+/**
+ * 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",
+});

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

@@ -0,0 +1,41 @@
+/**
+ * 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;

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

@@ -0,0 +1,41 @@
+/**
+ * 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;

packages/core/src/common/catalog-entities/general.ts

@@ -0,0 +1,43 @@
+/**
+ * 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",
+    },
+  };
+}

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

@@ -0,0 +1,46 @@
+<?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>

packages/core/src/common/catalog-entities/index.ts

@@ -0,0 +1,8 @@
+/**
+ * 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";

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

@@ -0,0 +1,160 @@
+/**
+ * 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",
+    },
+  };
+}

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

@@ -0,0 +1,68 @@
+/**
+ * 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",
+    },
+  };
+}

packages/core/src/common/catalog/catalog-entity.ts

@@ -0,0 +1,413 @@
+/**
+ * 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>;
+}

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

@@ -0,0 +1,28 @@
+/**
+ * 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;
+  }
+}

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

@@ -0,0 +1,15 @@
+/**
+ * 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;

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

@@ -0,0 +1,15 @@
+/**
+ * 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;

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

@@ -0,0 +1,15 @@
+/**
+ * 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;

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

@@ -0,0 +1,27 @@
+/**
+ * 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;

packages/core/src/common/catalog/category-registry.ts

@@ -0,0 +1,103 @@
+/**
+ * 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));
+  }
+}

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

@@ -0,0 +1,18 @@
+/**
+ * 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;

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

@@ -0,0 +1,21 @@
+/**
+ * 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;

packages/core/src/common/catalog/index.ts

@@ -0,0 +1,7 @@
+/**
+ * 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";

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

@@ -0,0 +1,23 @@
+/**
+ * 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;

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

@@ -0,0 +1,9 @@
+/**
+ * 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");

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

@@ -0,0 +1,19 @@
+/**
+ * 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: () => {},
+  };
+});
+

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

@@ -0,0 +1,33 @@
+/**
+ * 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;

packages/core/src/common/cluster-frames.injectable.ts

@@ -0,0 +1,14 @@
+/**
+ * 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;

packages/core/src/common/cluster-frames.ts

@@ -0,0 +1,13 @@
+/**
+ * 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>();

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

@@ -0,0 +1,12 @@
+/**
+ * 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",
+});

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

@@ -0,0 +1,42 @@
+/**
+ * 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;

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

@@ -0,0 +1,109 @@
+/**
+ * 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()),
+    });
+  }
+}

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

@@ -0,0 +1,21 @@
+/**
+ * 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;

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

@@ -0,0 +1,11 @@
+/**
+ * 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",
+});

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

@@ -0,0 +1,31 @@
+/**
+ * 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;

packages/core/src/common/cluster-types.ts

@@ -0,0 +1,211 @@
+/**
+ * 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;
+}

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

@@ -0,0 +1,59 @@
+/**
+ * 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;

packages/core/src/common/cluster/cluster.ts

@@ -0,0 +1,709 @@
+/**
+ * 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);
+  }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * 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",
+});

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

@@ -0,0 +1,11 @@
+/**
+ * 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",
+};

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

@@ -0,0 +1,29 @@
+/**
+ * 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;

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

@@ -0,0 +1,78 @@
+/**
+ * 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;

packages/core/src/common/cluster/visibility-channel.ts

@@ -0,0 +1,11 @@
+/**
+ * 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",
+};

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

@@ -0,0 +1,23 @@
+/**
+ * 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;

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

@@ -0,0 +1,9 @@
+/**
+ * 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, () => () => {});

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

@@ -0,0 +1,63 @@
+/**
+ * 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;

packages/core/src/common/event-emitter.ts

@@ -0,0 +1,43 @@
+/**
+ * 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;
+      }
+    }
+  }
+}

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

@@ -0,0 +1,56 @@
+/**
+ * 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;

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

@@ -0,0 +1,46 @@
+/**
+ * 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),
+    };
+  }
+};
+

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

@@ -0,0 +1,14 @@
+/**
+ * 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;

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

@@ -0,0 +1,14 @@
+/**
+ * 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;

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

@@ -0,0 +1,19 @@
+/**
+ * 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;

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

@@ -0,0 +1,9 @@
+/**
+ * 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);

packages/core/src/common/fetch/fetch.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 nodeFetchModuleInjectable from "./fetch-module.injectable";
+
+export type Fetch = (url: string, init?: RequestInit) => Promise<Response>;
+
+const fetchInjectable = getInjectable({
+  id: "fetch",
+  instantiate: (di): Fetch => {
+    const { default: fetch } = di.inject(nodeFetchModuleInjectable);
+
+    return (url, init) => fetch(url, init);
+  },
+  causesSideEffects: true,
+});
+
+export default fetchInjectable;

packages/core/src/common/fetch/lens-fetch.global-override-for-injectable.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 lensFetchInjectable from "./lens-fetch.injectable";
+
+export default getGlobalOverrideForFunction(lensFetchInjectable);

packages/core/src/common/fetch/lens-fetch.injectable.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 { Agent } from "https";
+import type { RequestInit, Response } from "node-fetch";
+import lensProxyPortInjectable from "../../main/lens-proxy/lens-proxy-port.injectable";
+import lensProxyCertificateInjectable from "../certificate/lens-proxy-certificate.injectable";
+import nodeFetchModuleInjectable from "./fetch-module.injectable";
+
+export type LensRequestInit = Omit<RequestInit, "agent">;
+
+export type LensFetch = (pathnameAndQuery: string, init?: LensRequestInit) => Promise<Response>;
+
+const lensFetchInjectable = getInjectable({
+  id: "lens-fetch",
+  instantiate: (di): LensFetch => {
+    const { default: fetch } = di.inject(nodeFetchModuleInjectable);
+    const lensProxyPort = di.inject(lensProxyPortInjectable);
+    const lensProxyCertificate = di.inject(lensProxyCertificateInjectable);
+
+    return async (pathnameAndQuery, init = {}) => {
+      const agent = new Agent({
+        ca: lensProxyCertificate.get().cert,
+      });
+
+      return fetch(`https://127.0.0.1:${lensProxyPort.get()}${pathnameAndQuery}`, {
+        ...init,
+        agent,
+      });
+    };
+  },
+  causesSideEffects: true,
+});
+
+export default lensFetchInjectable;

packages/core/src/common/fetch/proxy-fetch.injectable.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 { HttpsProxyAgent } from "hpagent";
+import userStoreInjectable from "../user-store/user-store.injectable";
+import type { Fetch } from "./fetch.injectable";
+import fetchInjectable from "./fetch.injectable";
+
+const proxyFetchInjectable = getInjectable({
+  id: "proxy-fetch",
+  instantiate: (di): Fetch => {
+    const fetch = di.inject(fetchInjectable);
+    const { httpsProxy, allowUntrustedCAs } = di.inject(userStoreInjectable);
+    const agent = httpsProxy
+      ? new HttpsProxyAgent({
+        proxy: httpsProxy,
+        rejectUnauthorized: !allowUntrustedCAs,
+      })
+      : undefined;
+
+    return (url, init = {}) => fetch(url, {
+      agent,
+      ...init,
+    });
+  },
+});
+
+export default proxyFetchInjectable;

packages/core/src/common/fetch/timeout-controller.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+/**
+ * Creates an AbortController with an associated timeout
+ * @param timeout The number of milliseconds before this controller will auto abort
+ */
+export function withTimeout(timeout: number): AbortController {
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), timeout);
+
+  controller.signal.addEventListener("abort", () => clearTimeout(id));
+
+  return controller;
+}

packages/core/src/common/front-end-routing/app-navigation-channel.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { IpcRendererNavigationEvents } from "../ipc/navigation-events";
+import type { MessageChannel } from "../utils/channel/message-channel-listener-injection-token";
+
+export type AppNavigationChannel = MessageChannel<string>;
+
+export const appNavigationChannel: AppNavigationChannel = {
+  id: IpcRendererNavigationEvents.NAVIGATE_IN_APP,
+};

packages/core/src/common/front-end-routing/cluster-frame-navigation-channel.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { IpcRendererNavigationEvents } from "../ipc/navigation-events";
+import type { MessageChannel } from "../utils/channel/message-channel-listener-injection-token";
+
+export type ClusterFrameNavigationChannel = MessageChannel<string>;
+
+export const clusterFrameNavigationChannel: ClusterFrameNavigationChannel = {
+  id: IpcRendererNavigationEvents.NAVIGATE_IN_CLUSTER,
+};

packages/core/src/common/front-end-routing/front-end-route-injection-token.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 { LensRendererExtension } from "../../extensions/lens-renderer-extension";
+
+export const frontEndRouteInjectionToken = getInjectionToken<Route<unknown>>({
+  id: "front-end-route-injection-token",
+});
+
+export interface Route<TParameter = void> {
+  path: string;
+  clusterFrame: boolean;
+  isEnabled: IComputedValue<boolean>;
+  extension?: LensRendererExtension;
+
+  readonly parameterSignature?: TParameter;
+}

packages/core/src/common/front-end-routing/navigate-to-front-page.injectable.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 navigateToCatalogInjectable from "./routes/catalog/navigate-to-catalog.injectable";
+
+const navigateToFrontPageInjectable = getInjectable({
+  id: "navigate-to-front-page",
+  instantiate: (di) => di.inject(navigateToCatalogInjectable),
+});
+
+export default navigateToFrontPageInjectable;

packages/core/src/common/front-end-routing/navigate-to-route-injection-token.ts

@@ -0,0 +1,52 @@
+/**
+ * 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 { Route } from "./front-end-route-injection-token";
+
+type InferParametersFrom<TRoute> = TRoute extends Route<infer TParameters>
+  ? TParameters
+  : never;
+
+type RequiredKeys<T> = Exclude<
+  {
+    [K in keyof T]: T extends Record<K, T[K]> ? K : never;
+  }[keyof T],
+  undefined
+>;
+
+type ObjectContainingNoRequired<T> = T extends void
+  ? never
+  : RequiredKeys<T> extends []
+  ? any
+  : never;
+
+type ObjectContainsNoRequired<T> = T extends ObjectContainingNoRequired<T>
+  ? true
+  : false;
+
+// TODO: Missing types for:
+// - Navigating to route without parameters, with parameters
+// - Navigating to route with required parameters, without parameters
+type Parameters<TParameters> = TParameters extends void
+  ? {}
+  : ObjectContainsNoRequired<TParameters> extends true
+  ? { parameters?: TParameters }
+  : { parameters: TParameters };
+
+export type NavigateToRouteOptions<TRoute> = Parameters<
+  InferParametersFrom<TRoute>
+> & {
+  query?: Record<string, string>;
+  fragment?: string;
+  withoutAffectingBackButton?: boolean;
+};
+
+export type NavigateToRoute = <TRoute extends Route<unknown>>(
+  route: TRoute,
+  options?: NavigateToRouteOptions<TRoute>) => void;
+
+export const navigateToRouteInjectionToken = getInjectionToken<NavigateToRoute>(
+  { id: "navigate-to-route-injection-token" },
+);

packages/core/src/common/front-end-routing/navigate-to-url-injection-token.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 interface NavigateToUrlOptions {
+  withoutAffectingBackButton?: boolean;
+  forceRootFrame?: boolean;
+}
+
+export type NavigateToUrl = (url: string, options?: NavigateToUrlOptions) => void;
+
+export const navigateToUrlInjectionToken = getInjectionToken<NavigateToUrl>(
+  { id: "navigate-to-url-injection-token" },
+);

packages/core/src/common/front-end-routing/routes/add-cluster/add-cluster-route.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { frontEndRouteInjectionToken } from "../../front-end-route-injection-token";
+
+const addClusterRouteInjectable = getInjectable({
+  id: "add-cluster-route",
+
+  instantiate: () => ({
+    path: "/add-cluster",
+    clusterFrame: false,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default addClusterRouteInjectable;

packages/core/src/common/front-end-routing/routes/add-cluster/navigate-to-add-cluster.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 addClusterRouteInjectable from "./add-cluster-route.injectable";
+import { navigateToRouteInjectionToken } from "../../navigate-to-route-injection-token";
+
+const navigateToAddClusterInjectable = getInjectable({
+  id: "navigate-to-add-cluster",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(addClusterRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToAddClusterInjectable;

packages/core/src/common/front-end-routing/routes/catalog/catalog-route.injectable.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 type { Route } from "../../front-end-route-injection-token";
+import { frontEndRouteInjectionToken } from "../../front-end-route-injection-token";
+
+export interface CatalogPathParameters {
+  group?: string;
+  kind?: string;
+}
+
+const catalogRouteInjectable = getInjectable({
+  id: "catalog-route",
+
+  instantiate: (): Route<CatalogPathParameters> => ({
+    path: "/catalog/:group?/:kind?",
+    clusterFrame: false,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default catalogRouteInjectable;

packages/core/src/common/front-end-routing/routes/catalog/navigate-to-catalog.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 { CatalogPathParameters } from "./catalog-route.injectable";
+import catalogRouteInjectable from "./catalog-route.injectable";
+import { navigateToRouteInjectionToken } from "../../navigate-to-route-injection-token";
+
+export type NavigateToCatalog = (parameters?: CatalogPathParameters) => void;
+
+const navigateToCatalogInjectable = getInjectable({
+  id: "navigate-to-catalog",
+
+  instantiate: (di): NavigateToCatalog => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const catalogRoute = di.inject(catalogRouteInjectable);
+
+    return (parameters) =>
+      navigateToRoute(catalogRoute, {
+        parameters,
+      });
+  },
+});
+
+export default navigateToCatalogInjectable;

packages/core/src/common/front-end-routing/routes/cluster-view/cluster-view-route.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { frontEndRouteInjectionToken } from "../../front-end-route-injection-token";
+
+const clusterViewRouteInjectable = getInjectable({
+  id: "cluster-view-route",
+
+  instantiate: () => ({
+    path: "/cluster/:clusterId",
+    clusterFrame: false,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default clusterViewRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster-view/navigate-to-cluster-view.injectable.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 { navigateToRouteInjectionToken } from "../../navigate-to-route-injection-token";
+import clusterViewRouteInjectable from "./cluster-view-route.injectable";
+
+export type NavigateToClusterView = (clusterId: string) => void;
+
+const navigateToClusterViewInjectable = getInjectable({
+  id: "navigate-to-cluster-view",
+
+  instantiate: (di): NavigateToClusterView => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(clusterViewRouteInjectable);
+
+    return (clusterId) =>
+      navigateToRoute(route, { parameters: { clusterId }});
+  },
+});
+
+export default navigateToClusterViewInjectable;