wip: restructure to monorepo

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

packages/core/.gitignore

@@ -0,0 +1,5 @@
+static/build/
+build/webpack/
+binaries/
+dist/
+node_modules/

packages/core/Makefile

@@ -0,0 +1,115 @@
+CMD_ARGS = $(filter-out $@,$(MAKECMDGOALS))
+
+%:
+  @:
+
+NPM_RELEASE_TAG ?= latest
+ELECTRON_BUILDER_EXTRA_ARGS ?=
+
+ifeq ($(OS),Windows_NT)
+    DETECTED_OS := Windows
+else
+    DETECTED_OS := $(shell uname)
+endif
+
+node_modules: yarn.lock
+	yarn install --check-files --frozen-lockfile --network-timeout=100000
+
+binaries/client: node_modules
+	yarn download:binaries
+
+.PHONY: compile-dev
+compile-dev: node_modules
+	yarn compile:main --cache
+	yarn compile:renderer --cache
+
+.PHONY: validate-dev
+ci-validate-dev: binaries/client compile-dev
+
+.PHONY: dev
+dev: binaries/client
+	rm -rf static/build/
+	yarn run build:tray-icons
+	yarn dev
+
+.PHONY: lint
+lint: node_modules
+	yarn lint
+
+.PHONY: tag-release
+tag-release:
+	scripts/tag-release.sh $(CMD_ARGS)
+
+.PHONY: test
+test: node_modules binaries/client
+	yarn run jest $(or $(CMD_ARGS), "src")
+
+.PHONY: integration
+integration: build
+	yarn integration
+
+.PHONY: build-impl
+build-impl:
+	yarn run download:binaries
+	yarn run build:tray-icons
+	yarn run compile
+ifeq "$(DETECTED_OS)" "Windows"
+# https://github.com/ukoloff/win-ca#clear-pem-folder-on-publish
+	rm -rf node_modules/win-ca/pem
+endif
+	yarn run electron-builder --publish onTag $(ELECTRON_BUILDER_EXTRA_ARGS)
+
+.PHONY: build
+build: node_modules binaries/client build-impl
+
+src/extensions/npm/extensions/__mocks__:
+	cp -r __mocks__ src/extensions/npm/extensions/
+
+packages/extensions/dist: packages/extensions/node_modules
+	yarn compile:extension-types
+
+packages/extensions/node_modules: packages/extensions/package.json
+	cd packages/extensions/ && ../../node_modules/.bin/npm install --no-audit --no-fund --no-save
+
+.PHONY: build-extensions-npm
+build-extensions-npm: build-extension-types packages/extensions/__mocks__
+	yarn npm:fix-extensions-package-version
+
+.PHONY: build-library-npm
+build-library-npm:
+	yarn compile-library
+
+.PHONY: build-extension-types
+build-extension-types: node_modules packages/extensions/dist
+
+.PHONY: publish-extensions-npm
+publish-extensions-npm: node_modules build-extensions-npm
+	./node_modules/.bin/npm config set '//registry.npmjs.org/:_authToken' "${NPM_TOKEN}"
+	cd packages/extensions && npm publish --access=public --tag=$(NPM_RELEASE_TAG) && git restore package.json
+
+.PHONY: publish-library-npm
+publish-library-npm: node_modules build-library-npm
+	./node_modules/.bin/npm config set '//registry.npmjs.org/:_authToken' "${NPM_TOKEN}"
+	npm publish --access=public --tag=$(NPM_RELEASE_TAG)
+
+.PHONY: build-docs
+build-docs:
+	yarn typedocs-extensions-api
+
+.PHONY: docs
+docs: build-docs
+	yarn mkdocs-serve-local
+
+.PHONY: clean-npm
+clean-npm:
+	rm -rf packages/extensions/{dist,__mocks__,node_modules}
+	rm -rf static/build/library/
+
+.PHONY: clean
+clean: clean-npm
+	rm -rf binaries/client
+	rm -rf dist
+	rm -rf static/build
+	rm -rf node_modules
+	rm -rf site
+	rm -rf docs/extensions/api

packages/core/__mocks__/@sentry/electron/main.ts

@@ -0,0 +1,5 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+export default {};

packages/core/__mocks__/@sentry/electron/renderer.ts

@@ -0,0 +1,5 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+export default {};

packages/core/__mocks__/assetMock.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+export default ""; // mostly path to bundled file or data-url (webpack)

packages/core/__mocks__/electron-updater.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+// This mock exists because library causes criminal side-effect on import
+export const autoUpdater = {};

packages/core/__mocks__/electron.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+export default {
+  require: jest.fn(),
+  match: jest.fn(),
+  app: {
+    getVersion: jest.fn().mockReturnValue("3.0.0"),
+    getLocale: jest.fn().mockRejectedValue("en"),
+    getPath: jest.fn(() => "tmp"),
+  },
+  dialog: jest.fn(),
+  ipcRenderer: {
+    on: jest.fn(),
+  },
+};

packages/core/__mocks__/node-pty.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+// This mock exists because library causes criminal side-effect on import
+export default {};

packages/core/__mocks__/react-beautiful-dnd.tsx

@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import React from "react";
+
+import type {
+  DragDropContextProps,
+  DraggableProps,
+  DraggableProvidedDraggableProps,
+  DroppableProps,
+  DroppableProvidedProps,
+} from "react-beautiful-dnd";
+
+export const DragDropContext = ({ children }: DragDropContextProps) => <>{ children }</>;
+export const Draggable = ({ children }: DraggableProps) => (
+  <>
+    {
+      children(
+        {
+          draggableProps: {} as DraggableProvidedDraggableProps,
+          innerRef: () => {},
+        },
+        {
+          isDragging: false,
+          isDropAnimating: false,
+        },
+        {
+          draggableId: "some-mock-draggable-id",
+          mode: "FLUID",
+          source: {
+            droppableId: "some-mock-droppable-id",
+            index: 0,
+          },
+        },
+      )
+    }
+  </>
+);
+export const Droppable = ({ children }: DroppableProps) => (
+  <>
+    {
+      children(
+        {
+          droppableProps: {} as DroppableProvidedProps,
+          innerRef: () => {},
+        },
+        {
+          isDraggingOver: false,
+          isUsingPlaceholder: false,
+        },
+      )
+    }
+  </>
+);

packages/core/__mocks__/react-virtualized-auto-sizer.tsx

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import React from "react";
+import type { Size } from "react-virtualized-auto-sizer";
+
+export default ({ children } : { children: (size: Size) => React.ReactNode }) => {
+  return (
+    <div>
+      {children({
+        height: 420000,
+        width: 100,
+      })}
+    </div>
+  );
+};

packages/core/build/download_binaries.ts

@@ -0,0 +1,280 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import packageInfo from "../package.json";
+import type { FileHandle } from "fs/promises";
+import { open } from "fs/promises";
+import type { WriteStream } from "fs-extra";
+import { constants, ensureDir, unlink } from "fs-extra";
+import path from "path";
+import type * as FetchModule from "node-fetch";
+import { promisify } from "util";
+import { pipeline as _pipeline, Transform, Writable } from "stream";
+import type { SingleBar } from "cli-progress";
+import { MultiBar } from "cli-progress";
+import { extract } from "tar-stream";
+import gunzip from "gunzip-maybe";
+import { isErrnoException, setTimeoutFor } from "../src/common/utils";
+import AbortController from "abort-controller";
+
+type Response = FetchModule.Response;
+type RequestInfo = FetchModule.RequestInfo;
+type RequestInit = FetchModule.RequestInit;
+
+const pipeline = promisify(_pipeline);
+
+const getBinaryName = (binaryName: string, { forPlatform }: { forPlatform : string }) => {
+  if (forPlatform === "windows") {
+    return `${binaryName}.exe`;
+  }
+
+  return binaryName;
+};
+
+interface BinaryDownloaderArgs {
+  readonly version: string;
+  readonly platform: SupportedPlatform;
+  readonly downloadArch: string;
+  readonly fileArch: string;
+  readonly binaryName: string;
+  readonly baseDir: string;
+}
+
+interface BinaryDownloaderDependencies {
+  fetch: (url: RequestInfo, init?: RequestInit) => Promise<Response>;
+}
+
+abstract class BinaryDownloader {
+  protected abstract readonly url: string;
+  protected readonly bar: SingleBar;
+  protected readonly target: string;
+
+  protected getTransformStreams(file: Writable): (NodeJS.ReadWriteStream | NodeJS.WritableStream)[] {
+    return [file];
+  }
+
+  constructor(protected readonly dependencies: BinaryDownloaderDependencies, public readonly args: BinaryDownloaderArgs, multiBar: MultiBar) {
+    this.bar = multiBar.create(1, 0, args);
+    this.target = path.join(args.baseDir, args.platform, args.fileArch, args.binaryName);
+  }
+
+  async ensureBinary(): Promise<void> {
+    if (process.env.LENS_SKIP_DOWNLOAD_BINARIES === "true") {
+      return;
+    }
+
+    const controller = new AbortController();
+
+    setTimeoutFor(controller, 15 * 60 * 1000);
+
+    const stream = await this.dependencies.fetch(this.url, {
+      signal: controller.signal,
+    });
+    const total = Number(stream.headers.get("content-length"));
+    const bar = this.bar;
+    let fileHandle: FileHandle | undefined = undefined;
+
+    if (isNaN(total)) {
+      throw new Error("no content-length header was present");
+    }
+
+    bar.setTotal(total);
+
+    await ensureDir(path.dirname(this.target), 0o755);
+
+    try {
+      /**
+       * This is necessary because for some reason `createWriteStream({ flags: "wx" })`
+       * was throwing someplace else and not here
+       */
+      const handle = fileHandle = await open(this.target, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL);
+
+      if (!stream.body) {
+        throw new Error("no body on stream");
+      }
+
+      await pipeline(
+        stream.body,
+        new Transform({
+          transform(chunk, encoding, callback) {
+            bar.increment(chunk.length);
+            this.push(chunk);
+            callback();
+          },
+        }),
+        ...this.getTransformStreams(new Writable({
+          write(chunk, encoding, cb) {
+            handle.write(chunk)
+              .then(() => cb())
+              .catch(cb);
+          },
+        })),
+      );
+      await fileHandle.chmod(0o755);
+      await fileHandle.close();
+    } catch (error) {
+      await fileHandle?.close();
+
+      if (isErrnoException(error) && error.code === "EEXIST") {
+        bar.increment(total); // mark as finished
+        controller.abort(); // stop trying to download
+      } else {
+        await unlink(this.target);
+        throw error;
+      }
+    }
+  }
+}
+
+class LensK8sProxyDownloader extends BinaryDownloader {
+  protected readonly url: string;
+
+  constructor(deps: BinaryDownloaderDependencies, args: Omit<BinaryDownloaderArgs, "binaryName">, bar: MultiBar) {
+    const binaryName = getBinaryName("lens-k8s-proxy", { forPlatform: args.platform });
+
+    super(deps, { ...args, binaryName }, bar);
+    this.url = `https://github.com/lensapp/lens-k8s-proxy/releases/download/v${args.version}/lens-k8s-proxy-${args.platform}-${args.downloadArch}`;
+  }
+}
+
+class KubectlDownloader extends BinaryDownloader {
+  protected readonly url: string;
+
+  constructor(deps: BinaryDownloaderDependencies, args: Omit<BinaryDownloaderArgs, "binaryName">, bar: MultiBar) {
+    const binaryName = getBinaryName("kubectl", { forPlatform: args.platform });
+
+    super(deps, { ...args, binaryName }, bar);
+    this.url = `https://storage.googleapis.com/kubernetes-release/release/v${args.version}/bin/${args.platform}/${args.downloadArch}/${binaryName}`;
+  }
+}
+
+class HelmDownloader extends BinaryDownloader {
+  protected readonly url: string;
+
+  constructor(deps: BinaryDownloaderDependencies, args: Omit<BinaryDownloaderArgs, "binaryName">, bar: MultiBar) {
+    const binaryName = getBinaryName("helm", { forPlatform: args.platform });
+
+    super(deps, { ...args, binaryName }, bar);
+    this.url = `https://get.helm.sh/helm-v${args.version}-${args.platform}-${args.downloadArch}.tar.gz`;
+  }
+
+  protected getTransformStreams(file: WriteStream) {
+    const extracting = extract({
+      allowUnknownFormat: false,
+    });
+
+    extracting.on("entry", (headers, stream, next) => {
+      if (headers.name.endsWith(this.args.binaryName)) {
+        stream
+          .pipe(file)
+          .once("finish", () => next())
+          .once("error", next);
+      } else {
+        stream.resume();
+        next();
+      }
+    });
+
+    return [gunzip(3), extracting];
+  }
+}
+
+type SupportedPlatform = "darwin" | "linux" | "windows";
+
+const importFetchModule = new Function('return import("node-fetch")') as () => Promise<typeof FetchModule>;
+
+async function main() {
+  const deps: BinaryDownloaderDependencies = {
+    fetch: (await importFetchModule()).default,
+  };
+  const normalizedPlatform = (() => {
+    switch (process.platform) {
+      case "darwin":
+        return "darwin";
+      case "linux":
+        return "linux";
+      case "win32":
+        return "windows";
+      default:
+        throw new Error(`platform=${process.platform} is unsupported`);
+    }
+  })();
+  const multiBar = new MultiBar({
+    align: "left",
+    clearOnComplete: false,
+    hideCursor: true,
+    autopadding: true,
+    noTTYOutput: true,
+    format: "[{bar}] {percentage}% | {downloadArch} {binaryName}",
+  });
+  const baseDir = path.join(process.cwd(), "binaries", "client");
+  const downloaders: BinaryDownloader[] = [
+    new LensK8sProxyDownloader(deps, {
+      version: packageInfo.config.k8sProxyVersion,
+      platform: normalizedPlatform,
+      downloadArch: "amd64",
+      fileArch: "x64",
+      baseDir,
+    }, multiBar),
+    new KubectlDownloader(deps, {
+      version: packageInfo.config.bundledKubectlVersion,
+      platform: normalizedPlatform,
+      downloadArch: "amd64",
+      fileArch: "x64",
+      baseDir,
+    }, multiBar),
+    new HelmDownloader(deps, {
+      version: packageInfo.config.bundledHelmVersion,
+      platform: normalizedPlatform,
+      downloadArch: "amd64",
+      fileArch: "x64",
+      baseDir,
+    }, multiBar),
+  ];
+
+  if (normalizedPlatform !== "windows") {
+    downloaders.push(
+      new LensK8sProxyDownloader(deps, {
+        version: packageInfo.config.k8sProxyVersion,
+        platform: normalizedPlatform,
+        downloadArch: "arm64",
+        fileArch: "arm64",
+        baseDir,
+      }, multiBar),
+      new KubectlDownloader(deps, {
+        version: packageInfo.config.bundledKubectlVersion,
+        platform: normalizedPlatform,
+        downloadArch: "arm64",
+        fileArch: "arm64",
+        baseDir,
+      }, multiBar),
+      new HelmDownloader(deps, {
+        version: packageInfo.config.bundledHelmVersion,
+        platform: normalizedPlatform,
+        downloadArch: "arm64",
+        fileArch: "arm64",
+        baseDir,
+      }, multiBar),
+    );
+  }
+
+  const settledResults = await Promise.allSettled(downloaders.map(downloader => (
+    downloader.ensureBinary()
+      .catch(error => {
+        throw new Error(`Failed to download ${downloader.args.binaryName} for ${downloader.args.platform}/${downloader.args.downloadArch}: ${error}`);
+      })
+  )));
+
+  multiBar.stop();
+  const errorResult = settledResults.find(res => res.status === "rejected") as PromiseRejectedResult | undefined;
+
+  if (errorResult) {
+    console.error("234", String(errorResult.reason));
+    process.exit(1);
+  }
+
+  process.exit(0);
+}
+
+main().catch(error => console.error("from main", error));

packages/core/build/entitlements.mac.plist

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>com.apple.security.cs.allow-jit</key>
+    <true/>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+    <key>com.apple.security.cs.disable-library-validation</key>
+    <true/>
+  </dict>
+</plist>

packages/core/build/generate-tray-icons.ts

@@ -0,0 +1,139 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import { ensureDir, readFile } from "fs-extra";
+import { JSDOM } from "jsdom";
+import path from "path";
+import sharp from "sharp";
+
+const size = Number(process.env.OUTPUT_SIZE || "16");
+const outputFolder = process.env.OUTPUT_DIR || "./static/build/tray";
+const inputFile = process.env.INPUT_SVG_PATH || path.resolve(__dirname, "../src/renderer/components/icon/logo-lens.svg");
+const noticeFile = process.env.NOTICE_SVG_PATH || path.resolve(__dirname, "../src/renderer/components/icon/notice.svg");
+const spinnerFile = process.env.SPINNER_SVG_PATH || path.resolve(__dirname, "../src/renderer/components/icon/arrow-spinner.svg");
+
+async function ensureOutputFoler() {
+  await ensureDir(outputFolder);
+}
+
+function getSvgStyling(colouring: "dark" | "light"): string {
+  return `
+    <style>
+      ellipse {
+        stroke: ${colouring === "dark" ? "white" : "black"} !important;
+      }
+      path, rect {
+        fill: ${colouring === "dark" ? "white" : "black"} !important;
+      }
+    </style>
+  `;
+}
+
+type TargetSystems = "macos" | "windows-or-linux";
+
+async function getBaseIconImage(system: TargetSystems) {
+  const svgData = await readFile(inputFile, { encoding: "utf-8" });
+  const dom = new JSDOM(`<body>${svgData}</body>`);
+  const root = dom.window.document.body.getElementsByTagName("svg")[0];
+
+  root.innerHTML += getSvgStyling(system === "macos" ? "light" : "dark");
+
+  return Buffer.from(root.outerHTML);
+}
+
+async function generateImage(image: Buffer, size: number, namePrefix: string) {
+  sharp(image)
+    .resize({ width: size, height: size })
+    .png()
+    .toFile(path.join(outputFolder, `${namePrefix}.png`));
+}
+
+async function generateImages(image: Buffer, size: number, name: string) {
+  await Promise.all([
+    generateImage(image, size, name),
+    generateImage(image, size*2, `${name}@2x`),
+    generateImage(image, size*3, `${name}@3x`),
+    generateImage(image, size*4, `${name}@4x`),
+  ]);
+}
+
+async function generateImageWithSvg(baseImage: Buffer, system: TargetSystems, filePath: string) {
+  const svgFile = await getIconImage(system, filePath);
+
+  const circleBuffer = await sharp(Buffer.from(`
+    <svg viewBox="0 0 64 64">
+      <circle cx="32" cy="32" r="32" fill="black" />
+    </svg>
+  `))
+    .toBuffer();
+
+  return sharp(baseImage)
+    .resize({ width: 128, height: 128 })
+    .composite([
+      {
+        input: circleBuffer,
+        top: 64,
+        left: 64,
+        blend: "dest-out",
+      },
+      {
+        input: (
+          await sharp(svgFile)
+            .resize({
+              width: 60,
+              height: 60,
+            })
+            .toBuffer()
+        ),
+        top: 66,
+        left: 66,
+      },
+    ])
+    .toBuffer();
+}
+
+async function getIconImage(system: TargetSystems, filePath: string) {
+  const svgData = await readFile(filePath, { encoding: "utf-8" });
+  const root = new JSDOM(svgData).window.document.getElementsByTagName("svg")[0];
+
+  root.innerHTML += getSvgStyling(system === "macos" ? "light" : "dark");
+
+  return Buffer.from(root.outerHTML);
+}
+
+async function generateTrayIcons() {
+  try {
+    console.log("Generating tray icon pngs");
+    await ensureOutputFoler();
+
+    const baseIconTemplateImage = await getBaseIconImage("macos");
+    const baseIconImage = await getBaseIconImage("windows-or-linux");
+
+    const updateAvailableTemplateImage = await generateImageWithSvg(baseIconTemplateImage, "macos", noticeFile);
+    const updateAvailableImage = await generateImageWithSvg(baseIconImage, "windows-or-linux", noticeFile);
+
+    const checkingForUpdatesTemplateImage = await generateImageWithSvg(baseIconTemplateImage, "macos", spinnerFile);
+    const checkingForUpdatesImage = await generateImageWithSvg(baseIconImage, "windows-or-linux", spinnerFile);
+
+    await Promise.all([
+      // Templates are for macOS only
+      generateImages(baseIconTemplateImage, size, "trayIconTemplate"),
+      generateImages(updateAvailableTemplateImage, size, "trayIconUpdateAvailableTemplate"),
+      generateImages(updateAvailableTemplateImage, size, "trayIconUpdateAvailableTemplate"),
+      generateImages(checkingForUpdatesTemplateImage, size, "trayIconCheckingForUpdatesTemplate"),
+
+      // Non-templates are for windows and linux
+      generateImages(baseIconImage, size, "trayIcon"),
+      generateImages(updateAvailableImage, size, "trayIconUpdateAvailable"),
+      generateImages(checkingForUpdatesImage, size, "trayIconCheckingForUpdates"),
+    ]);
+
+    console.log("Generated all images");
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+generateTrayIcons();

packages/core/build/installer.nsh

@@ -0,0 +1,15 @@
+!macro customInit
+  ; Make sure all old extensions are removed
+  RMDir /r "$INSTDIR\resources\extensions"
+
+  ; Workaround for installer handing when the app directory is removed manually
+  ${ifNot} ${FileExists} "$INSTDIR"
+    DeleteRegKey HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\{${UNINSTALL_APP_KEY}}"
+  ${EndIf}
+
+  ; Workaround for the old-format uninstall registry key (some people report it causes hangups, too)
+  ReadRegStr $0 HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\${UNINSTALL_APP_KEY}" "QuietUninstallString"
+  StrCmp $0 "" proceed 0
+  DeleteRegKey HKCU "Software\Microsoft\Windows\CurrentVersion\Uninstall\${UNINSTALL_APP_KEY}"
+  proceed:
+!macroend

packages/core/build/notarize.js

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+const { notarize } = require("electron-notarize");
+
+exports.default = async function notarizing(context) {
+  const { electronPlatformName, appOutDir } = context;
+
+  if (electronPlatformName !== "darwin") {
+    return;
+  }
+
+  if (!process.env.APPLEID || !process.env.APPLEIDPASS) {
+    return;
+  }
+
+  const appName = context.packager.appInfo.productFilename;
+
+  return await notarize({
+    appBundleId: process.env.APPBUNDLEID || "io.kontena.lens-app",
+    appPath: `${appOutDir}/${appName}.app`,
+    appleId: process.env.APPLEID,
+    appleIdPassword: process.env.APPLEIDPASS,
+    ascProvider:process.env.ASCPROVIDER,
+  });
+};

packages/core/build/set_extensions_npm_version.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import packageInfo from "../packages/extensions/package.json";
+import appInfo from "../package.json";
+import { SemVer } from "semver";
+import { execSync } from "child_process";
+
+const { NPM_RELEASE_TAG = "latest" } = process.env;
+const version = new SemVer(appInfo.version);
+
+if (NPM_RELEASE_TAG !== "latest") {
+  const gitRef = execSync("git rev-parse --short HEAD", {
+    encoding: "utf-8",
+  });
+
+  version.inc("prerelease", `git.${gitRef.trim()}`);
+}
+
+packageInfo.version = version.format();
+
+fs.writeFileSync(path.join(__dirname, "../packages/extensions/package.json"), `${JSON.stringify(packageInfo, null, 2)}\n`);

packages/core/build/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../tsconfig.json",
+  "include": [
+    "./**/*",
+  ]
+}

packages/core/integration/__tests__/app-preferences.tests.ts

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+/*
+  Cluster tests are run if there is a pre-existing minikube cluster. Before running cluster tests the TEST_NAMESPACE
+  namespace is removed, if it exists, from the minikube cluster. Resources are created as part of the cluster tests in the
+  TEST_NAMESPACE namespace. This is done to minimize destructive impact of the cluster tests on an existing minikube
+  cluster and vice versa.
+*/
+import type { ElectronApplication, Page } from "playwright";
+import * as utils from "../helpers/utils";
+
+describe("preferences page tests", () => {
+  let window: Page;
+  let cleanup: undefined | (() => Promise<void>);
+
+  beforeEach(async () => {
+    let app: ElectronApplication;
+
+    ({ window, cleanup, app } = await utils.start());
+    await utils.clickWelcomeButton(window);
+
+    await app.evaluate(async ({ app }) => {
+      await app.applicationMenu
+        ?.getMenuItemById(process.platform === "darwin" ? "mac" : "file")
+        ?.submenu
+        ?.getMenuItemById("navigate-to-preferences")
+        ?.click();
+    });
+  }, 10*60*1000);
+
+  afterEach(async () => {
+    await cleanup?.();
+  }, 10*60*1000);
+
+  it('shows "preferences" and can navigate through the tabs', async () => {
+    const pages = [
+      {
+        id: "app",
+        header: "Application",
+      },
+      {
+        id: "proxy",
+        header: "Proxy",
+      },
+      {
+        id: "kubernetes",
+        header: "Kubernetes",
+      },
+    ];
+
+    for (const { id, header } of pages) {
+      await window.click(`[data-preference-tab-link-test=${id}]`);
+      await window.waitForSelector(`[data-preference-page-title-test] >> text=${header}`);
+    }
+  }, 10*60*1000);
+
+  // Skipping, but will turn it on again in the follow up PR
+  it.skip("ensures helm repos", async () => {
+    await window.click("[data-testid=kubernetes-tab]");
+    await window.waitForSelector("[data-testid=repository-name]");
+    await window.click("#HelmRepoSelect");
+    await window.waitForSelector("div.Select__option");
+  }, 10*60*1000);
+});

packages/core/integration/__tests__/cluster-pages.tests.ts

@@ -0,0 +1,378 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+/*
+  Cluster tests are run if there is a pre-existing minikube cluster. Before running cluster tests the TEST_NAMESPACE
+  namespace is removed, if it exists, from the minikube cluster. Resources are created as part of the cluster tests in the
+  TEST_NAMESPACE namespace. This is done to minimize destructive impact of the cluster tests on an existing minikube
+  cluster and vice versa.
+*/
+import * as utils from "../helpers/utils";
+import { minikubeReady } from "../helpers/minikube";
+import type { Frame, Page } from "playwright";
+import { groupBy, toPairs } from "lodash/fp";
+import { pipeline } from "@ogre-tools/fp";
+import { describeIf } from "../../src/test-utils/skippers";
+
+const TEST_NAMESPACE = "integration-tests";
+
+describeIf(minikubeReady(TEST_NAMESPACE))("Minikube based tests", () => {
+  let window: Page;
+  let cleanup: undefined | (() => Promise<void>);
+  let frame: Frame;
+
+  beforeEach(async () => {
+    ({ window, cleanup } = await utils.start());
+    await utils.clickWelcomeButton(window);
+
+    frame = await utils.lauchMinikubeClusterFromCatalog(window);
+  }, 10 * 60 * 1000);
+
+  afterEach(async () => {
+    await cleanup?.();
+  }, 10 * 60 * 1000);
+
+  it("shows cluster context menu in sidebar", async () => {
+    await frame.click(`[data-testid="sidebar-cluster-dropdown"]`);
+    await frame.waitForSelector(`.Menu >> text="Add to Hotbar"`);
+    await frame.waitForSelector(`.Menu >> text="Settings"`);
+    await frame.waitForSelector(`.Menu >> text="Disconnect"`);
+    await frame.waitForSelector(`.Menu >> text="Remove"`);
+  });
+
+  // FIXME: failed locally since metrics might already exist, cc @aleksfront
+  it.skip("opens cluster settings by clicking link in no-metrics area", async () => {
+    await frame.locator("text=Open cluster settings >> nth=0").click();
+    await window.waitForSelector(`[data-testid="metrics-header"]`);
+  });
+
+  it(
+    "should navigate around common cluster pages",
+    async () => {
+      const scenariosByParent = pipeline(
+        scenarios,
+        groupBy("parentSidebarItemTestId"),
+        toPairs,
+      );
+
+      for (const [parentSidebarItemTestId, scenarios] of scenariosByParent) {
+        if (parentSidebarItemTestId !== "null") {
+          await frame.click(`[data-testid="${parentSidebarItemTestId}"]`);
+        }
+
+        for (const scenario of scenarios) {
+          await frame.click(`[data-testid="${scenario.sidebarItemTestId}"]`);
+
+          await frame.waitForSelector(
+            scenario.expectedSelector,
+            selectorTimeout,
+          );
+        }
+      }
+    },
+
+    10 * 60 * 1000,
+  );
+
+  it(
+    "should show the default namespaces",
+    async () => {
+      await navigateToNamespaces(frame);
+      await frame.waitForSelector("div.TableCell >> text='default'");
+      await frame.waitForSelector("div.TableCell >> text='kube-system'");
+    },
+    10 * 60 * 1000,
+  );
+
+  it(
+    `should create the ${TEST_NAMESPACE} and a pod in the namespace and then remove that pod via the context menu`,
+    async () => {
+      await navigateToNamespaces(frame);
+      await frame.click("button.add-button");
+      await frame.waitForSelector(
+        "div.AddNamespaceDialog >> text='Create Namespace'",
+      );
+
+      const namespaceNameInput = await frame.waitForSelector(
+        ".AddNamespaceDialog input",
+      );
+
+      await namespaceNameInput.type(TEST_NAMESPACE);
+      await namespaceNameInput.press("Enter");
+
+      await frame.waitForSelector(`div.TableCell >> text=${TEST_NAMESPACE}`);
+
+      await navigateToPods(frame);
+
+      const namespacesSelector = await frame.waitForSelector(
+        ".NamespaceSelect",
+      );
+
+      await namespacesSelector.click();
+      await namespacesSelector.type(TEST_NAMESPACE);
+      await namespacesSelector.press("Enter");
+      await namespacesSelector.click();
+
+      await frame.click(".Icon.new-dock-tab");
+
+      try {
+        await frame.click("li.MenuItem.create-resource-tab", {
+          // NOTE: the following shouldn't be required, but is because without it a TypeError is thrown
+          // see: https://github.com/microsoft/playwright/issues/8229
+          position: {
+            y: 0,
+            x: 0,
+          },
+        });
+      } catch (error) {
+        console.log(error);
+        await frame.waitForTimeout(100_000);
+      }
+
+      const testPodName = "nginx-create-pod-test";
+      const monacoEditor = await frame.waitForSelector(`.Dock.isOpen [data-test-id="monaco-editor"]`);
+
+      await monacoEditor.click();
+      await monacoEditor.type("apiVersion: v1", { delay: 10 });
+      await monacoEditor.press("Enter", { delay: 10 });
+      await monacoEditor.type("kind: Pod", { delay: 10 });
+      await monacoEditor.press("Enter", { delay: 10 });
+      await monacoEditor.type("metadata:", { delay: 10 });
+      await monacoEditor.press("Enter", { delay: 10 });
+      await monacoEditor.type(`  name: ${testPodName}`, { delay: 10 });
+      await monacoEditor.press("Enter", { delay: 10 });
+      await monacoEditor.type(`namespace: ${TEST_NAMESPACE}`, { delay: 10 });
+      await monacoEditor.press("Enter", { delay: 10 });
+      await monacoEditor.press("Backspace", { delay: 10 });
+      await monacoEditor.type("spec:", { delay: 10 });
+      await monacoEditor.press("Enter", { delay: 10 });
+      await monacoEditor.type("  containers:", { delay: 10 });
+      await monacoEditor.press("Enter", { delay: 10 });
+      await monacoEditor.type(`- name: ${testPodName}`, { delay: 10 });
+      await monacoEditor.press("Enter", { delay: 10 });
+      await monacoEditor.type("  image: nginx:alpine", { delay: 10 });
+      await monacoEditor.press("Enter", { delay: 10 });
+
+      await frame.click(".Dock .Button >> text='Create'");
+      await frame.waitForSelector(`.TableCell >> text=${testPodName}`);
+      await frame.click(".TableRow .TableCell.menu");
+      await frame.click(".MenuItem >> text=Delete");
+      await frame.click("button >> text=Remove");
+      await frame.waitForSelector(`.TableCell >> text=${testPodName}`, { state: "detached" });
+    },
+    10 * 60 * 1000,
+  );
+});
+
+const selectorTimeout = { timeout: 30000 };
+
+const scenarios = [
+  {
+    expectedSelector: "div[data-testid='cluster-overview-page'] div.label",
+    parentSidebarItemTestId: null,
+    sidebarItemTestId: "sidebar-item-link-for-cluster-overview",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: null,
+    sidebarItemTestId: "sidebar-item-link-for-nodes",
+  },
+
+  {
+    expectedSelector: 'h5 >> text="Overview"',
+    parentSidebarItemTestId: "sidebar-item-link-for-workloads",
+    sidebarItemTestId: "sidebar-item-link-for-overview",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-workloads",
+    sidebarItemTestId: "sidebar-item-link-for-pods",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-workloads",
+    sidebarItemTestId: "sidebar-item-link-for-deployments",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-workloads",
+    sidebarItemTestId: "sidebar-item-link-for-daemon-sets",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-workloads",
+    sidebarItemTestId: "sidebar-item-link-for-stateful-sets",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-workloads",
+    sidebarItemTestId: "sidebar-item-link-for-replica-sets",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-workloads",
+    sidebarItemTestId: "sidebar-item-link-for-jobs",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-workloads",
+    sidebarItemTestId: "sidebar-item-link-for-cron-jobs",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-config",
+    sidebarItemTestId: "sidebar-item-link-for-config-maps",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-config",
+    sidebarItemTestId: "sidebar-item-link-for-secrets",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-config",
+    sidebarItemTestId: "sidebar-item-link-for-resource-quotas",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-config",
+    sidebarItemTestId: "sidebar-item-link-for-limit-ranges",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-config",
+    sidebarItemTestId: "sidebar-item-link-for-horizontal-pod-auto-scalers",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-config",
+    sidebarItemTestId: "sidebar-item-link-for-pod-disruption-budgets",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-network",
+    sidebarItemTestId: "sidebar-item-link-for-services",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-network",
+    sidebarItemTestId: "sidebar-item-link-for-endpoints",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-network",
+    sidebarItemTestId: "sidebar-item-link-for-ingresses",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-network",
+    sidebarItemTestId: "sidebar-item-link-for-network-policies",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-storage",
+    sidebarItemTestId: "sidebar-item-link-for-persistent-volume-claims",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-storage",
+    sidebarItemTestId: "sidebar-item-link-for-persistent-volumes",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-storage",
+    sidebarItemTestId: "sidebar-item-link-for-storage-classes",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: null,
+    sidebarItemTestId: "sidebar-item-link-for-namespaces",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: null,
+    sidebarItemTestId: "sidebar-item-link-for-events",
+  },
+
+  {
+    expectedSelector: "div.HelmCharts input",
+    parentSidebarItemTestId: "sidebar-item-link-for-helm",
+    sidebarItemTestId: "sidebar-item-link-for-charts",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-helm",
+    sidebarItemTestId: "sidebar-item-link-for-releases",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-user-management",
+    sidebarItemTestId: "sidebar-item-link-for-service-accounts",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-user-management",
+    sidebarItemTestId: "sidebar-item-link-for-cluster-roles",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-user-management",
+    sidebarItemTestId: "sidebar-item-link-for-roles",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-user-management",
+    sidebarItemTestId: "sidebar-item-link-for-cluster-role-bindings",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: "sidebar-item-link-for-user-management",
+    sidebarItemTestId: "sidebar-item-link-for-role-bindings",
+  },
+
+  {
+    expectedSelector: "h5.title",
+    parentSidebarItemTestId: null,
+    sidebarItemTestId: "sidebar-item-link-for-custom-resources",
+  },
+];
+
+const navigateToPods = async (frame: Frame) => {
+  await frame.click(`[data-testid="sidebar-item-link-for-workloads"]`);
+  await frame.click(`[data-testid="sidebar-item-link-for-pods"]`);
+};
+
+const navigateToNamespaces = async (frame: Frame) => {
+  await frame.click(`[data-testid="sidebar-item-link-for-namespaces"]`);
+};

packages/core/integration/__tests__/command-palette.tests.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 type { ElectronApplication, Page } from "playwright";
+import * as utils from "../helpers/utils";
+
+describe("Lens command palette", () => {
+  let window: Page;
+  let cleanup: undefined | (() => Promise<void>);
+  let app: ElectronApplication;
+
+  beforeEach(async () => {
+    ({ window, cleanup, app } = await utils.start());
+    await utils.clickWelcomeButton(window);
+  }, 10*60*1000);
+
+  afterEach(async () => {
+    await cleanup?.();
+  }, 10*60*1000);
+
+  describe("menu", () => {
+    it("opens command dialog from menu", async () => {
+      await app.evaluate(async ({ app }) => {
+        await app.applicationMenu
+          ?.getMenuItemById("view")
+          ?.submenu?.getMenuItemById("open-command-palette")
+          ?.click();
+      });
+      await window.waitForSelector(".Select__option >> text=Hotbar: Switch");
+    }, 10*60*1000);
+  });
+});

packages/core/integration/helpers/minikube.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 { spawnSync } from "child_process";
+
+export function minikubeReady(testNamespace: string): boolean {
+  // determine if minikube is running
+  {
+    const { status } = spawnSync("minikube status", { shell: true });
+
+    if (status !== 0) {
+      console.warn("minikube not running");
+
+      return false;
+    }
+  }
+
+  // Remove TEST_NAMESPACE if it already exists
+  {
+    const { status } = spawnSync(`minikube kubectl -- get namespace ${testNamespace}`, { shell: true });
+
+    if (status === 0) {
+      console.warn(`Removing existing ${testNamespace} namespace`);
+
+      const { status, stdout, stderr } = spawnSync(
+        `minikube kubectl -- delete namespace ${testNamespace}`,
+        { shell: true },
+      );
+
+      if (status !== 0) {
+        console.warn(`Error removing ${testNamespace} namespace: ${stderr.toString()}`);
+
+        return false;
+      }
+
+      console.log(stdout.toString());
+    }
+  }
+
+  return true;
+}

packages/core/integration/helpers/utils.ts

@@ -0,0 +1,138 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { createHash } from "crypto";
+import { mkdirp, remove } from "fs-extra";
+import * as os from "os";
+import * as path from "path";
+import * as uuid from "uuid";
+import type { ElectronApplication, Frame, Page } from "playwright";
+import { _electron as electron } from "playwright";
+import { noop } from "lodash";
+import { disposer } from "../../src/common/utils";
+
+export const appPaths: Partial<Record<NodeJS.Platform, string>> = {
+  "win32": "./dist/win-unpacked/OpenLens.exe",
+  "linux": "./dist/linux-unpacked/open-lens",
+  "darwin": "./dist/mac/OpenLens.app/Contents/MacOS/OpenLens",
+};
+
+async function getMainWindow(app: ElectronApplication, timeout = 50_000): Promise<Page> {
+  return new Promise((resolve, reject) => {
+    const cleanup = disposer();
+    let stdoutBuf = "";
+
+    const onWindow = (page: Page) => {
+      console.log(`Page opened: ${page.url()}`);
+
+      if (page.url().startsWith("https://lens.app")) {
+        cleanup();
+        console.log(stdoutBuf);
+        resolve(page);
+      }
+    };
+
+    app.on("window", onWindow);
+    cleanup.push(() => app.off("window", onWindow));
+
+    const onClose = () => {
+      cleanup();
+      reject(new Error("App has unnexpectedly closed"));
+    };
+
+    app.on("close", onClose);
+    cleanup.push(() => app.off("close", onClose));
+
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const stdout = app.process().stdout!;
+    const onData = (chunk: any) => stdoutBuf += chunk.toString();
+
+    stdout.on("data", onData);
+    cleanup.push(() => stdout.off("data", onData));
+
+    const timeoutId = setTimeout(() => {
+      cleanup();
+      console.log(stdoutBuf);
+      reject(new Error(`Lens did not open the main window within ${timeout}ms`));
+    }, timeout);
+
+    cleanup.push(() => clearTimeout(timeoutId));
+  });
+}
+
+async function attemptStart() {
+  const CICD = path.join(os.tmpdir(), "lens-integration-testing", uuid.v4());
+
+  // Make sure that the directory is clear
+  await remove(CICD).catch(noop);
+  await mkdirp(CICD);
+
+  const app = await electron.launch({
+    args: ["--integration-testing"], // this argument turns off the blocking of quit
+    executablePath: appPaths[process.platform],
+    bypassCSP: true,
+    env: {
+      CICD,
+      ...process.env,
+    },
+    timeout: 100_000,
+  });
+
+  try {
+    const window = await getMainWindow(app);
+
+    return {
+      app,
+      window,
+      cleanup: async () => {
+        await app.close();
+        await remove(CICD).catch(noop);
+      },
+    };
+  } catch (error) {
+    await app.close();
+    await remove(CICD).catch(noop);
+    throw error;
+  }
+}
+
+export async function start() {
+  // this is an attempted workaround for an issue with playwright not always getting the main window when using Electron 14.2.4 (observed on windows)
+  for (let i = 0; ; i++) {
+    try {
+      return await attemptStart();
+    } catch (error) {
+      if (i === 4) {
+        throw error;
+      }
+    }
+  }
+}
+
+export async function clickWelcomeButton(window: Page) {
+  await window.click("[data-testid=welcome-menu-container] li a");
+}
+
+function minikubeEntityId() {
+  return createHash("md5").update(`${path.join(os.homedir(), ".kube", "config")}:minikube`).digest("hex");
+}
+
+/**
+ * From the catalog, click the minikube entity and wait for it to connect, returning its frame
+ */
+export async function lauchMinikubeClusterFromCatalog(window: Page): Promise<Frame> {
+  await window.click("div.TableCell >> text='minikube'");
+
+  const minikubeFrame = await window.waitForSelector(`#cluster-frame-${minikubeEntityId()}`);
+
+  const frame = await minikubeFrame.contentFrame();
+
+  if (!frame) {
+    throw new Error("No iframe for minikube found");
+  }
+
+  await frame.waitForSelector("[data-testid=cluster-sidebar]");
+
+  return frame;
+}

packages/core/integration/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../tsconfig.json",
+  "include": [
+    "./**/*",
+  ]
+}

packages/core/package.json

@@ -0,0 +1,357 @@
+{
+  "name": "@k8slens/open-lens",
+  "productName": "OpenLens",
+  "description": "OpenLens - Open Source IDE for Kubernetes",
+  "homepage": "https://github.com/lensapp/lens",
+  "version": "6.4.0-alpha.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lensapp/lens.git"
+  },
+  "keywords": [],
+  "bugs": {
+    "url": "https://github.com/lensapp/lens/issues"
+  },
+  "main": "static/build/main.js",
+  "exports": {
+    "./main": "./static/build/library/main.js",
+    "./renderer": "./static/build/library/renderer.js",
+    "./common": "./static/build/library/common.js",
+    "./styles": "./static/build/library/renderer.css"
+  },
+  "typesVersions": {
+    "*": {
+      "main": [
+        "./static/build/library/src/main/library.d.ts"
+      ],
+      "renderer": [
+        "./static/build/library/src/renderer/library.d.ts"
+      ],
+      "common": [
+        "./static/build/library/src/common/library.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "build/download_binaries.ts",
+    "build/*.plist",
+    "build/installer.nsh",
+    "build/notarize.js",
+    "static/build/library/**/*",
+    "templates/**/*",
+    "types/*",
+    "tsconfig.json"
+  ],
+  "copyright": "© 2022 OpenLens Authors",
+  "license": "MIT",
+  "author": "OpenLens Authors <info@k8slens.dev>",
+  "scripts": {
+    "build": "env NODE_ENV=production yarn run webpack --config webpack/library-bundle.ts",
+    "compile:node-fetch": "yarn run webpack --config webpack/node-fetch.ts",
+    "prepare": "yarn run compile:node-fetch",
+    "build:linux": "yarn run compile && electron-builder --linux --dir",
+    "build:mac": "yarn run compile && electron-builder --mac --dir",
+    "build:win": "yarn run compile && electron-builder --win --dir",
+    "integration": "jest --runInBand --detectOpenHandles --forceExit integration",
+    "test:unit": "func() { jest ${1} --watch --testPathIgnorePatterns integration; }; func",
+    "test:integration": "func() { jest ${1:-xyz} --watch --runInBand --detectOpenHandles --forceExit --modulePaths=[\"<rootDir>/integration/\"]; }; func",
+    "dist": "yarn run compile && electron-builder --publish onTag",
+    "dist:dir": "yarn run dist --dir -c.compression=store -c.mac.identity=null",
+    "download:binaries": "yarn run ts-node build/download_binaries.ts",
+    "build:tray-icons": "yarn run ts-node build/generate-tray-icons.ts",
+    "build:theme-vars": "yarn run ts-node build/build_theme_vars.ts",
+    "lint": "PROD=true yarn run eslint --ext js,ts,tsx --max-warnings=0 .",
+    "lint:fix": "yarn run lint --fix",
+    "version-checkout": "cat package.json | jq '.version' -r | xargs printf \"release/v%s\" | xargs git checkout -b",
+    "version-commit": "cat package.json | jq '.version' -r | xargs printf \"release v%s\" | git commit --no-edit -s -F -",
+    "version": "yarn run version-checkout && git add package.json && yarn run version-commit",
+    "postversion": "git push --set-upstream ${GIT_REMOTE:-origin} release/v$npm_package_version",
+    "precreate-release-pr": "npx swc ./scripts/create-release-pr.ts -o ./scripts/create-release-pr.mjs",
+    "create-release-pr": "node ./scripts/create-release-pr.mjs"
+  },
+  "config": {
+    "k8sProxyVersion": "0.3.0",
+    "bundledKubectlVersion": "1.23.3",
+    "bundledHelmVersion": "3.7.2",
+    "sentryDsn": "",
+    "contentSecurityPolicy": "script-src 'unsafe-eval' 'self'; frame-src https://*.lens.app:*/; img-src * data:",
+    "welcomeRoute": "/welcome"
+  },
+  "engines": {
+    "node": ">=16 <17"
+  },
+  "jest": {
+    "collectCoverage": false,
+    "verbose": true,
+    "transform": {
+      "^.+\\.(t|j)sx?$": [
+        "@swc/jest"
+      ]
+    },
+    "testEnvironment": "jsdom",
+    "resolver": "<rootDir>/src/jest-28-resolver.js",
+    "moduleNameMapper": {
+      "\\.(css|scss)$": "identity-obj-proxy",
+      "\\.(svg|png|jpg|eot|woff2?|ttf)$": "<rootDir>/__mocks__/assetMock.ts"
+    },
+    "modulePathIgnorePatterns": [
+      "<rootDir>/dist",
+      "<rootDir>/packages",
+      "<rootDir>/static/build"
+    ],
+    "setupFiles": [
+      "<rootDir>/src/jest.setup.ts",
+      "jest-canvas-mock"
+    ],
+    "globalSetup": "<rootDir>/src/jest.timezone.ts",
+    "setupFilesAfterEnv": [
+      "<rootDir>/src/jest-after-env.setup.ts"
+    ],
+    "runtime": "@side/jest-runtime"
+  },
+  "build": {},
+  "resolutions": {
+    "@astronautlabs/jsonpath/underscore": "^1.12.1"
+  },
+  "dependencies": {
+    "@astronautlabs/jsonpath": "^1.1.0",
+    "@hapi/call": "^9.0.0",
+    "@hapi/subtext": "^7.0.4",
+    "@kubernetes/client-node": "^0.18.0",
+    "@material-ui/styles": "^4.11.5",
+    "@ogre-tools/fp": "^12.0.1",
+    "@ogre-tools/injectable": "^12.0.1",
+    "@ogre-tools/injectable-extension-for-auto-registration": "^12.0.1",
+    "@ogre-tools/injectable-extension-for-mobx": "^12.0.1",
+    "@ogre-tools/injectable-react": "^12.0.1",
+    "@sentry/electron": "^3.0.8",
+    "@sentry/integrations": "^6.19.3",
+    "@side/jest-runtime": "^1.0.1",
+    "abort-controller": "^3.0.0",
+    "auto-bind": "^4.0.0",
+    "await-lock": "^2.2.2",
+    "byline": "^5.0.0",
+    "chokidar": "^3.5.3",
+    "conf": "^7.1.2",
+    "crypto-js": "^4.1.1",
+    "electron-devtools-installer": "^3.2.0",
+    "electron-updater": "^4.6.5",
+    "electron-window-state": "^5.0.3",
+    "filehound": "^1.17.6",
+    "fs-extra": "^9.0.1",
+    "glob-to-regexp": "^0.4.1",
+    "got": "^11.8.6",
+    "grapheme-splitter": "^1.0.4",
+    "handlebars": "^4.7.7",
+    "history": "^4.10.1",
+    "hpagent": "^1.2.0",
+    "http-proxy": "^1.18.1",
+    "immer": "^9.0.17",
+    "joi": "^17.7.0",
+    "js-yaml": "^4.1.0",
+    "jsdom": "^16.7.0",
+    "lodash": "^4.17.15",
+    "marked": "^4.2.5",
+    "md5-file": "^5.0.0",
+    "mobx": "^6.7.0",
+    "mobx-observable-history": "^2.0.3",
+    "mobx-react": "^7.6.0",
+    "mobx-utils": "^6.0.4",
+    "moment": "^2.29.4",
+    "moment-timezone": "^0.5.40",
+    "node-fetch": "^3.3.0",
+    "node-pty": "0.10.1",
+    "npm": "^8.19.3",
+    "p-limit": "^3.1.0",
+    "path-to-regexp": "^6.2.0",
+    "proper-lockfile": "^4.1.2",
+    "react": "^17.0.2",
+    "react-dom": "^17.0.2",
+    "react-material-ui-carousel": "^2.3.11",
+    "react-router": "^5.3.4",
+    "react-virtualized-auto-sizer": "^1.0.7",
+    "readable-stream": "^3.6.0",
+    "request": "^2.88.2",
+    "request-promise-native": "^1.0.9",
+    "rfc6902": "^5.0.1",
+    "selfsigned": "^2.1.1",
+    "semver": "^7.3.8",
+    "tar": "^6.1.13",
+    "tcp-port-used": "^1.0.2",
+    "tempy": "1.0.1",
+    "typed-regex": "^0.0.8",
+    "url-parse": "^1.5.10",
+    "uuid": "^8.3.2",
+    "win-ca": "^3.5.0",
+    "winston": "^3.8.2",
+    "winston-transport-browserconsole": "^1.0.5",
+    "ws": "^8.12.0",
+    "xterm-link-provider": "^1.3.1"
+  },
+  "devDependencies": {
+    "@async-fn/jest": "1.6.4",
+    "@material-ui/core": "^4.12.3",
+    "@material-ui/icons": "^4.11.2",
+    "@material-ui/lab": "^4.0.0-alpha.60",
+    "@pmmmwh/react-refresh-webpack-plugin": "^0.5.10",
+    "@sentry/types": "^6.19.7",
+    "@swc/cli": "^0.1.59",
+    "@swc/core": "^1.3.25",
+    "@swc/jest": "^0.2.24",
+    "@testing-library/dom": "^7.31.2",
+    "@testing-library/jest-dom": "^5.16.5",
+    "@testing-library/react": "^12.1.5",
+    "@testing-library/user-event": "^13.5.0",
+    "@types/byline": "^4.2.33",
+    "@types/chart.js": "^2.9.36",
+    "@types/circular-dependency-plugin": "5.0.5",
+    "@types/cli-progress": "^3.11.0",
+    "@types/color": "^3.0.3",
+    "@types/command-line-args": "^5.2.0",
+    "@types/crypto-js": "^3.1.47",
+    "@types/dompurify": "^2.4.0",
+    "@types/electron-devtools-installer": "^2.2.1",
+    "@types/fs-extra": "^9.0.13",
+    "@types/glob-to-regexp": "^0.4.1",
+    "@types/gunzip-maybe": "^1.4.0",
+    "@types/hapi__call": "^9.0.0",
+    "@types/hapi__subtext": "^7.0.0",
+    "@types/html-webpack-plugin": "^3.2.6",
+    "@types/http-proxy": "^1.17.9",
+    "@types/jest": "^28.1.6",
+    "@types/js-yaml": "^4.0.5",
+    "@types/jsdom": "^16.2.14",
+    "@types/lodash": "^4.14.191",
+    "@types/marked": "^4.0.8",
+    "@types/md5-file": "^4.0.2",
+    "@types/memorystream": "^0.3.0",
+    "@types/mini-css-extract-plugin": "^2.4.0",
+    "@types/mock-fs": "^4.13.1",
+    "@types/node": "^16.18.11",
+    "@types/proper-lockfile": "^4.1.2",
+    "@types/randomcolor": "^0.5.7",
+    "@types/react": "^17.0.45",
+    "@types/react-beautiful-dnd": "^13.1.3",
+    "@types/react-dom": "^17.0.16",
+    "@types/react-router": "^5.1.19",
+    "@types/react-router-dom": "^5.3.3",
+    "@types/react-table": "^7.7.14",
+    "@types/react-virtualized-auto-sizer": "^1.0.1",
+    "@types/react-window": "^1.8.5",
+    "@types/readable-stream": "^2.3.13",
+    "@types/request": "^2.48.7",
+    "@types/request-promise-native": "^1.0.18",
+    "@types/semver": "^7.3.13",
+    "@types/sharp": "^0.31.1",
+    "@types/tar": "^6.1.3",
+    "@types/tar-stream": "^2.2.2",
+    "@types/tcp-port-used": "^1.0.1",
+    "@types/tempy": "^0.3.0",
+    "@types/triple-beam": "^1.3.2",
+    "@types/url-parse": "^1.4.8",
+    "@types/uuid": "^8.3.4",
+    "@types/webpack": "^5.28.0",
+    "@types/webpack-dev-server": "^4.7.2",
+    "@types/webpack-node-externals": "^2.5.3",
+    "@typescript-eslint/eslint-plugin": "^5.48.1",
+    "@typescript-eslint/parser": "^5.48.1",
+    "adr": "^1.4.3",
+    "ansi_up": "^5.1.0",
+    "chalk": "^4.1.2",
+    "chart.js": "^2.9.4",
+    "circular-dependency-plugin": "^5.2.2",
+    "cli-progress": "^3.11.2",
+    "color": "^3.2.1",
+    "command-line-args": "^5.2.1",
+    "concurrently": "^7.6.0",
+    "css-loader": "^6.7.3",
+    "deepdash": "^5.3.9",
+    "dompurify": "^2.4.3",
+    "electron": "^19.1.9",
+    "electron-builder": "^23.6.0",
+    "electron-notarize": "^0.3.0",
+    "esbuild": "^0.16.14",
+    "esbuild-loader": "^2.20.0",
+    "eslint": "^8.31.0",
+    "eslint-import-resolver-typescript": "^3.5.2",
+    "eslint-plugin-header": "^3.1.1",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-react": "7.31.11",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-unused-imports": "^2.0.0",
+    "fork-ts-checker-webpack-plugin": "^6.5.2",
+    "gunzip-maybe": "^1.4.2",
+    "html-webpack-plugin": "^5.5.0",
+    "identity-obj-proxy": "^3.0.0",
+    "ignore-loader": "^0.1.2",
+    "include-media": "^1.4.9",
+    "jest": "^28.1.3",
+    "jest-canvas-mock": "^2.3.1",
+    "jest-environment-jsdom": "^28.1.3",
+    "jest-mock-extended": "^2.0.9",
+    "make-plural": "^6.2.2",
+    "memfs": "^3.4.12",
+    "memorystream": "^0.3.1",
+    "mini-css-extract-plugin": "^2.7.2",
+    "mock-http": "^1.1.0",
+    "monaco-editor": "^0.29.1",
+    "monaco-editor-webpack-plugin": "^5.0.0",
+    "node-gyp": "^8.3.0",
+    "node-loader": "^2.0.0",
+    "nodemon": "^2.0.20",
+    "playwright": "^1.29.2",
+    "postcss": "^8.4.21",
+    "postcss-loader": "^6.2.1",
+    "query-string": "^7.1.3",
+    "randomcolor": "^0.6.2",
+    "react-beautiful-dnd": "^13.1.1",
+    "react-refresh": "^0.14.0",
+    "react-refresh-typescript": "^2.0.7",
+    "react-router-dom": "^5.3.4",
+    "react-select": "^5.7.0",
+    "react-select-event": "^5.5.1",
+    "react-table": "^7.8.0",
+    "react-window": "^1.8.8",
+    "sass": "^1.57.1",
+    "sass-loader": "^12.6.0",
+    "sharp": "^0.31.3",
+    "style-loader": "^3.3.1",
+    "tailwindcss": "^3.2.4",
+    "tar-stream": "^2.2.0",
+    "ts-loader": "^9.4.2",
+    "ts-node": "^10.9.1",
+    "type-fest": "^2.14.0",
+    "typed-emitter": "^1.4.0",
+    "typedoc": "0.23.24",
+    "typedoc-plugin-markdown": "^3.13.6",
+    "typescript": "^4.9.4",
+    "typescript-plugin-css-modules": "^3.4.0",
+    "webpack": "^5.75.0",
+    "webpack-cli": "^5.0.1",
+    "webpack-dev-server": "^4.11.1",
+    "webpack-node-externals": "^3.0.0",
+    "xterm": "^4.19.0",
+    "xterm-addon-fit": "^0.5.0"
+  },
+  "peerDependencies": {
+    "@types/byline": "^4.2.33",
+    "@types/chart.js": "^2.9.36",
+    "@types/color": "^3.0.3",
+    "@types/crypto-js": "^3.1.47",
+    "@types/lodash": "^4.14.191",
+    "@types/proper-lockfile": "^4.1.2",
+    "@types/react-dom": "^17.0.16",
+    "@types/react-router-dom": "^5.3.3",
+    "@types/react-virtualized-auto-sizer": "^1.0.1",
+    "@types/react-window": "^1.8.5",
+    "@types/request-promise-native": "^1.0.18",
+    "@types/tar": "^6.1.3",
+    "@types/tcp-port-used": "^1.0.1",
+    "@types/url-parse": "^1.4.8",
+    "@types/uuid": "^8.3.4",
+    "monaco-editor": "^0.29.1",
+    "react-select": "^5.7.0",
+    "typed-emitter": "^1.4.0",
+    "xterm-addon-fit": "^0.5.0"
+  }
+}

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 "../../renderer/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;