Restructure to monorepo (#6907)

* wip: restructure to monorepo

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

* refactor create-release-pr to a package

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

* build fixes

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

* github workflow fixes

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

* fix typo

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

* add webpack-env types to core

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

* fix github workflows

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

* refactor/fix integration tests

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

* lint fix

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

* yarn run dev

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

* eslint settings for vscode

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

* move templates to right package

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

* open-lens build fixes

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

* integration test fix

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

* fix nx task dependencies

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

* use bash shell for unit tests in test workflow

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

* fix test:unit for windows

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

* fix win-ca webpack error in open-lens

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

* fix win-ca webpack error in open-lens

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

* fix build:app on windows

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

* remove ELECTRON_BUILDER_EXTRA_ARGS

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

* sync src/ from master

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

* remove Makefile from core

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

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

packages/core/src/features/application-update/analytics-for-installing-update.test.ts

@@ -0,0 +1,266 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
+import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
+import electronUpdaterIsActiveInjectable from "../../main/electron-app/features/electron-updater-is-active.injectable";
+import publishIsConfiguredInjectable from "./main/updating-is-enabled/publish-is-configured/publish-is-configured.injectable";
+import type { AsyncFnMock } from "@async-fn/jest";
+import asyncFn from "@async-fn/jest";
+import type { CheckForPlatformUpdates } from "./main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable";
+import checkForPlatformUpdatesInjectable from "./main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable";
+import appEventBusInjectable from "../../common/app-event-bus/app-event-bus.injectable";
+import type { DiContainer } from "@ogre-tools/injectable";
+import processCheckingForUpdatesInjectable from "./main/process-checking-for-updates.injectable";
+import type { DownloadPlatformUpdate } from "./main/download-update/download-platform-update/download-platform-update.injectable";
+import downloadPlatformUpdateInjectable from "./main/download-update/download-platform-update/download-platform-update.injectable";
+import quitAndInstallUpdateInjectable from "./main/quit-and-install-update.injectable";
+import periodicalCheckForUpdatesInjectable from "./child-features/periodical-checking-of-updates/main/periodical-check-for-updates.injectable";
+import { advanceFakeTime, testUsingFakeTime } from "../../common/test-utils/use-fake-time";
+import emitEventInjectable from "../../common/app-event-bus/emit-event.injectable";
+import getBuildVersionInjectable from "../../main/vars/build-version/get-build-version.injectable";
+
+describe("analytics for installing update", () => {
+  let builder: ApplicationBuilder;
+  let checkForPlatformUpdatesMock: AsyncFnMock<CheckForPlatformUpdates>;
+  let downloadPlatformUpdateMock: AsyncFnMock<DownloadPlatformUpdate>;
+  let analyticsListenerMock: jest.Mock;
+  let mainDi: DiContainer;
+
+  beforeEach(async () => {
+    testUsingFakeTime("2015-10-21T07:28:00Z");
+
+    builder = getApplicationBuilder();
+
+    analyticsListenerMock = jest.fn();
+
+    builder.beforeApplicationStart(mainDi => {
+      mainDi.override(getBuildVersionInjectable, () => () => "42.0.0");
+
+      checkForPlatformUpdatesMock = asyncFn();
+
+      mainDi.override(
+        checkForPlatformUpdatesInjectable,
+        () => checkForPlatformUpdatesMock,
+      );
+
+      downloadPlatformUpdateMock = asyncFn();
+
+      mainDi.override(downloadPlatformUpdateInjectable, () => downloadPlatformUpdateMock);
+      mainDi.override(electronUpdaterIsActiveInjectable, () => true);
+
+      mainDi.override(publishIsConfiguredInjectable, () => true);
+
+      mainDi.unoverride(emitEventInjectable);
+
+      const eventBus = mainDi.inject(appEventBusInjectable);
+
+      eventBus.addListener(analyticsListenerMock);
+    });
+
+    mainDi = builder.mainDi;
+  });
+
+  describe("given application is started and checking updates periodically", () => {
+    beforeEach(async () => {
+      mainDi.unoverride(periodicalCheckForUpdatesInjectable);
+      mainDi.permitSideEffects(periodicalCheckForUpdatesInjectable);
+
+      await builder.render();
+    });
+
+    it("sends event to analytics for being checked periodically", () => {
+      expect(analyticsListenerMock).toHaveBeenCalledWith({
+        name: "app",
+        action: "checking-for-updates",
+
+        params: {
+          currentDateTime: "2015-10-21T07:28:00Z",
+          source: "periodic",
+        },
+      });
+    });
+
+    it("when enough time passes to check for updates again, sends event to analytics for being checked periodically", () => {
+      analyticsListenerMock.mockClear();
+
+      advanceFakeTime(1000 * 60 * 60 * 2);
+
+      expect(analyticsListenerMock).toHaveBeenCalledWith({
+        name: "app",
+        action: "checking-for-updates",
+
+        params: {
+          currentDateTime: "2015-10-21T09:28:00Z",
+          source: "periodic",
+        },
+      });
+    });
+  });
+
+  describe("when application is started", () => {
+    beforeEach(async () => {
+      analyticsListenerMock.mockClear();
+
+      await builder.render();
+    });
+
+    it("sends event to analytics about the current version", () => {
+      expect(analyticsListenerMock).toHaveBeenCalledWith({
+        name: "app",
+        action: "current-version",
+
+        params: {
+          version: "42.0.0",
+          currentDateTime: "2015-10-21T07:28:00Z",
+        },
+      });
+    });
+
+    it("when checking for updates using tray, sends event to analytics for being checked from tray", async () => {
+      analyticsListenerMock.mockClear();
+
+      builder.tray.click("check-for-updates");
+
+      expect(analyticsListenerMock.mock.calls).toEqual([
+        [
+          {
+            name: "app",
+            action: "checking-for-updates",
+
+            params: {
+              currentDateTime: "2015-10-21T07:28:00Z",
+              source: "tray",
+            },
+          },
+        ],
+      ]);
+
+    });
+
+    it("when checking for updates using application menu, sends event to analytics for being checked from application menu", async () => {
+      analyticsListenerMock.mockClear();
+
+      builder.applicationMenu.click("root", "mac", "check-for-updates");
+
+      expect(analyticsListenerMock.mock.calls).toEqual([
+        [
+          {
+            name: "app",
+            action: "checking-for-updates",
+
+            params: {
+              currentDateTime: "2015-10-21T07:28:00Z",
+              source: "application-menu",
+            },
+          },
+        ],
+      ]);
+    });
+
+    describe("given checking for updates, when check for updates resolves with new update being available", () => {
+      beforeEach(async () => {
+        const processCheckingForUpdates = mainDi.inject(processCheckingForUpdatesInjectable);
+
+        processCheckingForUpdates("irrelevant");
+
+        analyticsListenerMock.mockClear();
+
+        await checkForPlatformUpdatesMock.resolve({
+          updateWasDiscovered: true,
+          version: "43.0.0",
+        });
+      });
+
+      it("sends event to analytics about new update being available", () => {
+        expect(analyticsListenerMock.mock.calls).toEqual([
+          [
+            {
+              name: "app",
+              action: "update-was-discovered",
+
+              params: {
+                version: "43.0.0",
+                currentDateTime: "2015-10-21T07:28:00Z",
+              },
+            },
+          ],
+        ]);
+      });
+
+      describe("given update is downloaded", () => {
+        beforeEach(async () => {
+          analyticsListenerMock.mockClear();
+
+          await downloadPlatformUpdateMock.resolve({ downloadWasSuccessful: true });
+        });
+
+        describe("given checking for updates again", () => {
+          beforeEach(() => {
+            const processCheckingForUpdates = mainDi.inject(processCheckingForUpdatesInjectable);
+
+            processCheckingForUpdates("irrelevant");
+
+            analyticsListenerMock.mockClear();
+          });
+
+          it("when check resolves with same version that was previously downloaded, does not send event to analytics about update discovered", async () => {
+            await checkForPlatformUpdatesMock.resolve({
+              updateWasDiscovered: true,
+              version: "43.0.0",
+            });
+
+            expect(analyticsListenerMock).not.toHaveBeenCalled();
+          });
+
+          it("when check resolves with different version that was previously downloaded, sends event to analytics about update discovered", async () => {
+            await checkForPlatformUpdatesMock.resolve({
+              updateWasDiscovered: true,
+              version: "44.0.0",
+            });
+
+            expect(analyticsListenerMock.mock.calls).toEqual([
+              [
+                {
+                  name: "app",
+                  action: "update-was-discovered",
+
+                  params: {
+                    version: "44.0.0",
+                    currentDateTime: "2015-10-21T07:28:00Z",
+                  },
+                },
+              ],
+            ]);
+          });
+        });
+
+        it("does not send event to analytics about update downloaded being successful", () => {
+          expect(analyticsListenerMock).not.toHaveBeenCalled();
+        });
+
+        it("when installing the update, sends event to analytics about installing the update", () => {
+          const quitAndInstallUpdate = mainDi.inject(quitAndInstallUpdateInjectable);
+
+          quitAndInstallUpdate();
+
+          expect(analyticsListenerMock.mock.calls).toEqual([
+            [
+              {
+                name: "app",
+                action: "start-installing-update",
+
+                params: {
+                  version: "43.0.0",
+                  currentDateTime: "2015-10-21T07:28:00Z",
+                  updateChannel: "latest",
+                },
+              },
+            ],
+          ]);
+        });
+      });
+    });
+  });
+});

packages/core/src/features/application-update/child-features/application-update-using-application-menu/main/check-for-updates-menu-item.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 { getInjectable } from "@ogre-tools/injectable";
+
+import applicationMenuItemInjectionToken from "../../../../application-menu/main/menu-items/application-menu-item-injection-token";
+import processCheckingForUpdatesInjectable from "../../../main/process-checking-for-updates.injectable";
+import showApplicationWindowInjectable from "../../../../../main/start-main-application/lens-window/show-application-window.injectable";
+import updatingIsEnabledInjectable from "../../../main/updating-is-enabled/updating-is-enabled.injectable";
+import isMacInjectable from "../../../../../common/vars/is-mac.injectable";
+
+const checkForUpdatesMenuItemInjectable = getInjectable({
+  id: "check-for-updates-menu-item",
+
+  instantiate: (di) => {
+    const processCheckingForUpdates = di.inject(
+      processCheckingForUpdatesInjectable,
+    );
+
+    const showApplicationWindow = di.inject(showApplicationWindowInjectable);
+
+    const updatingIsEnabled = di.inject(updatingIsEnabledInjectable);
+    const isMac = di.inject(isMacInjectable);
+
+    return {
+      kind: "clickable-menu-item" as const,
+      id: "check-for-updates",
+      parentId: isMac ? "mac" : "help",
+      orderNumber: isMac ? 20 : 50,
+      label: "Check for updates",
+      isShown: updatingIsEnabled,
+
+      onClick: () => {
+        // Todo: implement using async/await
+        processCheckingForUpdates("application-menu").then(() =>
+          showApplicationWindow(),
+        );
+      },
+    };
+  },
+
+  injectionToken: applicationMenuItemInjectionToken,
+});
+
+export default checkForUpdatesMenuItemInjectable;

packages/core/src/features/application-update/child-features/application-update-using-top-bar/__snapshots__/installing-update-using-topbar-button.test.tsx.snap

@@ -0,0 +1,596 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`encourage user to update when sufficient time passed since update was downloaded when started given the update check when update downloaded given some time passes, when checking for updates again when checking for updates resolves with same version that was previously downloaded renders 1`] = `
+<body>
+  <div>
+    <div
+      class="ClusterManager"
+    >
+      <div
+        class="topBar"
+      >
+        <div
+          class="items"
+        >
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="home-button"
+            >
+              <span
+                class="icon"
+                data-icon-name="home"
+              >
+                home
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="history-back"
+            >
+              <span
+                class="icon"
+                data-icon-name="arrow_back"
+              >
+                arrow_back
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="history-forward"
+            >
+              <span
+                class="icon"
+                data-icon-name="arrow_forward"
+              >
+                arrow_forward
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <button
+              class="updateButton"
+              data-testid="update-button"
+              data-warning-level="light"
+              id="update-lens-button"
+            >
+              Update
+              <i
+                class="Icon icon material focusable"
+              >
+                <span
+                  class="icon"
+                  data-icon-name="arrow_drop_down"
+                >
+                  arrow_drop_down
+                </span>
+              </i>
+            </button>
+          </div>
+          <div
+            class="separator"
+          />
+        </div>
+      </div>
+      <main>
+        <div
+          id="lens-views"
+        />
+        <div
+          class="flex justify-center Welcome align-center"
+          data-testid="welcome-page"
+        >
+          <div
+            data-testid="welcome-banner-container"
+            style="width: 320px;"
+          >
+            <i
+              class="Icon logo svg focusable"
+            >
+              <span
+                class="icon"
+              />
+            </i>
+            <div
+              class="flex justify-center"
+            >
+              <div
+                data-testid="welcome-text-container"
+                style="width: 320px;"
+              >
+                <h2>
+                  Welcome to some-product-name!
+                </h2>
+                <p>
+                  To get you started we have auto-detected your clusters in your
+                   
+                  kubeconfig file and added them to the catalog, your centralized
+                   
+                  view for managing all your cloud-native resources.
+                  <br />
+                  <br />
+                  If you have any questions or feedback, please join our 
+                  <a
+                    class="link"
+                    href="https://k8slens.dev/slack.html"
+                    rel="noreferrer"
+                    target="_blank"
+                  >
+                    Lens Community slack channel
+                  </a>
+                  .
+                </p>
+                <ul
+                  class="block"
+                  data-testid="welcome-menu-container"
+                  style="width: 320px;"
+                >
+                  <li
+                    class="flex grid-12"
+                  >
+                    <i
+                      class="Icon box col-1 material focusable"
+                    >
+                      <span
+                        class="icon"
+                        data-icon-name="view_list"
+                      >
+                        view_list
+                      </span>
+                    </i>
+                    <a
+                      class="box col-10"
+                    >
+                      Browse Clusters in Catalog
+                    </a>
+                    <i
+                      class="Icon box col-1 material focusable"
+                    >
+                      <span
+                        class="icon"
+                        data-icon-name="navigate_next"
+                      >
+                        navigate_next
+                      </span>
+                    </i>
+                  </li>
+                </ul>
+              </div>
+            </div>
+          </div>
+        </div>
+      </main>
+      <div
+        class="HotbarMenu flex column"
+      >
+        <div
+          class="HotbarItems flex column gaps"
+        >
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="0"
+          >
+            <div
+              style="z-index: 12; position: absolute;"
+            >
+              <div
+                class="HotbarIcon contextMenuAvailable"
+              >
+                <div
+                  class="Avatar rounded disabled avatar"
+                  id="hotbarIcon-hotbar-icon-catalog-entity"
+                  style="width: 40px; height: 40px; background: rgb(5, 1, 130);"
+                >
+                  Ca
+                </div>
+              </div>
+            </div>
+          </div>
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="1"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="2"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="3"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="4"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="5"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="6"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="7"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="8"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="9"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="10"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="11"
+          />
+        </div>
+        <div
+          class="HotbarSelector"
+        >
+          <i
+            class="Icon Icon previous material interactive focusable"
+            tabindex="0"
+          >
+            <span
+              class="icon"
+              data-icon-name="arrow_left"
+            >
+              arrow_left
+            </span>
+          </i>
+          <div
+            class="HotbarIndex"
+          >
+            <div
+              class="badge Badge small clickable"
+              id="hotbarIndex"
+            >
+              1
+            </div>
+          </div>
+          <i
+            class="Icon material interactive focusable"
+            tabindex="0"
+          >
+            <span
+              class="icon"
+              data-icon-name="arrow_right"
+            >
+              arrow_right
+            </span>
+          </i>
+        </div>
+      </div>
+      <div
+        class="StatusBar"
+        data-testid="status-bar"
+      >
+        <div
+          class="leftSide"
+          data-testid="status-bar-left"
+        />
+        <div
+          class="rightSide"
+          data-testid="status-bar-right"
+        />
+      </div>
+    </div>
+    <div
+      class="Notifications flex column align-flex-end"
+    />
+  </div>
+</body>
+`;
+
+exports[`encourage user to update when sufficient time passed since update was downloaded when started renders 1`] = `
+<body>
+  <div>
+    <div
+      class="ClusterManager"
+    >
+      <div
+        class="topBar"
+      >
+        <div
+          class="items"
+        >
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="home-button"
+            >
+              <span
+                class="icon"
+                data-icon-name="home"
+              >
+                home
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="history-back"
+            >
+              <span
+                class="icon"
+                data-icon-name="arrow_back"
+              >
+                arrow_back
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="history-forward"
+            >
+              <span
+                class="icon"
+                data-icon-name="arrow_forward"
+              >
+                arrow_forward
+              </span>
+            </i>
+          </div>
+          <div
+            class="separator"
+          />
+        </div>
+      </div>
+      <main>
+        <div
+          id="lens-views"
+        />
+        <div
+          class="flex justify-center Welcome align-center"
+          data-testid="welcome-page"
+        >
+          <div
+            data-testid="welcome-banner-container"
+            style="width: 320px;"
+          >
+            <i
+              class="Icon logo svg focusable"
+            >
+              <span
+                class="icon"
+              />
+            </i>
+            <div
+              class="flex justify-center"
+            >
+              <div
+                data-testid="welcome-text-container"
+                style="width: 320px;"
+              >
+                <h2>
+                  Welcome to some-product-name!
+                </h2>
+                <p>
+                  To get you started we have auto-detected your clusters in your
+                   
+                  kubeconfig file and added them to the catalog, your centralized
+                   
+                  view for managing all your cloud-native resources.
+                  <br />
+                  <br />
+                  If you have any questions or feedback, please join our 
+                  <a
+                    class="link"
+                    href="https://k8slens.dev/slack.html"
+                    rel="noreferrer"
+                    target="_blank"
+                  >
+                    Lens Community slack channel
+                  </a>
+                  .
+                </p>
+                <ul
+                  class="block"
+                  data-testid="welcome-menu-container"
+                  style="width: 320px;"
+                >
+                  <li
+                    class="flex grid-12"
+                  >
+                    <i
+                      class="Icon box col-1 material focusable"
+                    >
+                      <span
+                        class="icon"
+                        data-icon-name="view_list"
+                      >
+                        view_list
+                      </span>
+                    </i>
+                    <a
+                      class="box col-10"
+                    >
+                      Browse Clusters in Catalog
+                    </a>
+                    <i
+                      class="Icon box col-1 material focusable"
+                    >
+                      <span
+                        class="icon"
+                        data-icon-name="navigate_next"
+                      >
+                        navigate_next
+                      </span>
+                    </i>
+                  </li>
+                </ul>
+              </div>
+            </div>
+          </div>
+        </div>
+      </main>
+      <div
+        class="HotbarMenu flex column"
+      >
+        <div
+          class="HotbarItems flex column gaps"
+        >
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="0"
+          >
+            <div
+              style="z-index: 12; position: absolute;"
+            >
+              <div
+                class="HotbarIcon contextMenuAvailable"
+              >
+                <div
+                  class="Avatar rounded disabled avatar"
+                  id="hotbarIcon-hotbar-icon-catalog-entity"
+                  style="width: 40px; height: 40px; background: rgb(5, 1, 130);"
+                >
+                  Ca
+                </div>
+              </div>
+            </div>
+          </div>
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="1"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="2"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="3"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="4"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="5"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="6"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="7"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="8"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="9"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="10"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="11"
+          />
+        </div>
+        <div
+          class="HotbarSelector"
+        >
+          <i
+            class="Icon Icon previous material interactive focusable"
+            tabindex="0"
+          >
+            <span
+              class="icon"
+              data-icon-name="arrow_left"
+            >
+              arrow_left
+            </span>
+          </i>
+          <div
+            class="HotbarIndex"
+          >
+            <div
+              class="badge Badge small clickable"
+              id="hotbarIndex"
+            >
+              1
+            </div>
+          </div>
+          <i
+            class="Icon material interactive focusable"
+            tabindex="0"
+          >
+            <span
+              class="icon"
+              data-icon-name="arrow_right"
+            >
+              arrow_right
+            </span>
+          </i>
+        </div>
+      </div>
+      <div
+        class="StatusBar"
+        data-testid="status-bar"
+      >
+        <div
+          class="leftSide"
+          data-testid="status-bar-left"
+        />
+        <div
+          class="rightSide"
+          data-testid="status-bar-right"
+        />
+      </div>
+    </div>
+    <div
+      class="Notifications flex column align-flex-end"
+    />
+  </div>
+</body>
+`;

packages/core/src/features/application-update/child-features/application-update-using-top-bar/installing-update-using-topbar-button.test.tsx

@@ -0,0 +1,185 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { AsyncFnMock } from "@async-fn/jest";
+import asyncFn from "@async-fn/jest";
+import type { RenderResult } from "@testing-library/react";
+import { act } from "@testing-library/react";
+import type { CheckForPlatformUpdates } from "../../main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable";
+import checkForPlatformUpdatesInjectable from "../../main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable";
+import type { DownloadPlatformUpdate } from "../../main/download-update/download-platform-update/download-platform-update.injectable";
+import downloadPlatformUpdateInjectable from "../../main/download-update/download-platform-update/download-platform-update.injectable";
+import publishIsConfiguredInjectable from "../../main/updating-is-enabled/publish-is-configured/publish-is-configured.injectable";
+import electronUpdaterIsActiveInjectable from "../../../../main/electron-app/features/electron-updater-is-active.injectable";
+import type { ApplicationBuilder } from "../../../../renderer/components/test-utils/get-application-builder";
+import { getApplicationBuilder } from "../../../../renderer/components/test-utils/get-application-builder";
+import processCheckingForUpdatesInjectable from "../../main/process-checking-for-updates.injectable";
+import quitAndInstallUpdateInjectable from "../../main/quit-and-install-update.injectable";
+import { advanceFakeTime, testUsingFakeTime } from "../../../../common/test-utils/use-fake-time";
+
+function daysToMilliseconds(days: number) {
+  return Math.round(days * 24 * 60 * 60 * 1000);
+}
+
+describe("encourage user to update when sufficient time passed since update was downloaded", () => {
+  let applicationBuilder: ApplicationBuilder;
+  let checkForPlatformUpdatesMock: AsyncFnMock<CheckForPlatformUpdates>;
+  let downloadPlatformUpdateMock: AsyncFnMock<DownloadPlatformUpdate>;
+  let quitAndInstallUpdateMock: jest.MockedFunction<() => void>;
+
+  beforeEach(() => {
+    testUsingFakeTime("2015-10-21T07:28:00Z");
+
+    applicationBuilder = getApplicationBuilder();
+
+    applicationBuilder.beforeApplicationStart((mainDi) => {
+      checkForPlatformUpdatesMock = asyncFn();
+      downloadPlatformUpdateMock = asyncFn();
+
+      mainDi.override(
+        checkForPlatformUpdatesInjectable,
+        () => checkForPlatformUpdatesMock,
+      );
+
+      mainDi.override(
+        downloadPlatformUpdateInjectable,
+        () => downloadPlatformUpdateMock,
+      );
+
+      mainDi.override(electronUpdaterIsActiveInjectable, () => true);
+      mainDi.override(publishIsConfiguredInjectable, () => true);
+
+      quitAndInstallUpdateMock = jest.fn();
+      mainDi.override(quitAndInstallUpdateInjectable, () => quitAndInstallUpdateMock);
+    });
+  });
+
+  describe("when started", () => {
+    let rendered: RenderResult;
+
+    beforeEach(async () => {
+      rendered = await applicationBuilder.render();
+    });
+
+    it("renders", () => {
+      expect(rendered.baseElement).toMatchSnapshot();
+    });
+
+    it("does not show update button yet", () => {
+      const button = rendered.queryByTestId("update-button");
+
+      expect(button).toBeNull();
+    });
+
+    describe("given the update check", () => {
+      let processCheckingForUpdates: (source: string) => Promise<{ updateIsReadyToBeInstalled: boolean }>;
+
+      beforeEach(async () => {
+        processCheckingForUpdates = applicationBuilder.mainDi.inject(
+          processCheckingForUpdatesInjectable,
+        );
+
+        processCheckingForUpdates("irrelevant");
+      });
+
+      describe("when update downloaded", () => {
+        let button: HTMLElement;
+
+        beforeEach(async () => {
+          await checkForPlatformUpdatesMock.resolve({
+            updateWasDiscovered: true,
+            version: "some-version",
+          });
+
+          await downloadPlatformUpdateMock.resolve({ downloadWasSuccessful: true });
+
+          button = rendered.getByTestId("update-button");
+        });
+
+        it("shows update button to help user to update", () => {
+          expect(button).toBeInTheDocument();
+        });
+
+        it("has soft emotional indication in the button", () => {
+          expect(button).toHaveAttribute("data-warning-level", "light");
+        });
+
+        it("given closing the application window, when starting the application window again, still shows the button", async () => {
+          applicationBuilder.applicationWindow.closeAll();
+
+          const window = applicationBuilder.applicationWindow.create("some-window-id");
+
+          await window.start();
+
+          const button = window.rendered.queryByTestId("update-button");
+
+          expect(button).toBeInTheDocument();
+        });
+
+        describe("given some time passes, when checking for updates again", () => {
+          beforeEach(() => {
+            advanceFakeTime(daysToMilliseconds(2));
+
+            processCheckingForUpdates("irrelevant");
+          });
+
+          describe("when checking for updates resolves with same version that was previously downloaded", () => {
+            beforeEach(async () => {
+              await checkForPlatformUpdatesMock.resolve({
+                updateWasDiscovered: true,
+                version: "some-version",
+              });
+            });
+
+            it("when enough time from download passes for medium update encouragement, has medium emotional indication in the button", () => {
+              advanceFakeTime(daysToMilliseconds(20));
+
+              expect(button).toHaveAttribute("data-warning-level", "medium");
+            });
+
+            it("renders", () => {
+              expect(rendered.baseElement).toMatchSnapshot();
+            });
+          });
+        });
+
+        describe("when button is clicked", () => {
+          beforeEach(() => {
+            act(() => button.click());
+          });
+
+          it("shows dropdown with update item", () => {
+            expect(rendered.getByTestId("update-lens-menu-item")).toBeInTheDocument();
+          });
+
+          it("when selected update now, restarts the application to update", () => {
+            const updateMenuItem = rendered.getByTestId("update-lens-menu-item");
+
+            act(() => updateMenuItem.click());
+
+            expect(quitAndInstallUpdateMock).toBeCalled();
+          });
+
+          it("when dropdown closed without clicking update item, does not restart the application to update", () => {
+            act(() => button.click());
+
+            expect(quitAndInstallUpdateMock).not.toBeCalled();
+          });
+        });
+
+        it("given just enough time passes for medium update encouragement, has medium emotional indication in the button", () => {
+          advanceFakeTime(daysToMilliseconds(22));
+
+          expect(button).toHaveAttribute("data-warning-level", "medium");
+        });
+
+        it("given just enough time passes for severe update encouragement, has severe emotional indication in the button", () => {
+          advanceFakeTime(daysToMilliseconds(26));
+
+          expect(button).toHaveAttribute("data-warning-level", "high");
+        });
+      });
+    });
+  });
+});

packages/core/src/features/application-update/child-features/application-update-using-top-bar/renderer/update-application-top-bar-item/update-application-top-bar-item.injectable.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 { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { topBarItemOnLeftSideInjectionToken } from "../../../../../../renderer/components/layout/top-bar/top-bar-items/top-bar-item-injection-token";
+import { UpdateButton } from "./update-button";
+import updateWarningLevelInjectable from "./update-warning-level.injectable";
+
+const updateApplicationTopBarItemInjectable = getInjectable({
+  id: "update-application-top-bar-item",
+
+  instantiate: (di) => {
+    const warningLevel = di.inject(updateWarningLevelInjectable);
+
+    return {
+      id: "update-application",
+      isShown: computed(() => !!warningLevel.get()),
+      orderNumber: 50,
+      Component: UpdateButton,
+    };
+  },
+
+  injectionToken: topBarItemOnLeftSideInjectionToken,
+});
+
+export default updateApplicationTopBarItemInjectable;

packages/core/src/features/application-update/child-features/application-update-using-top-bar/renderer/update-application-top-bar-item/update-button/index.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 * from "./update-button";

packages/core/src/features/application-update/child-features/application-update-using-top-bar/renderer/update-application-top-bar-item/update-button/styles.module.scss

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+.updateButton {
+  --accent-color: var(--colorOk);
+
+  border: 1px solid var(--accent-color);
+  border-radius: 4px;
+  color: var(--accent-color);
+  display: flex;
+  align-items: center;
+  padding: calc(var(--padding) / 4) var(--padding);
+  gap: 6px;
+  cursor: default;
+  position: relative;
+
+  &:hover::before{
+    opacity: 0.25;
+  }
+
+  &:focus-visible {
+    box-shadow: 0 0 0 2px var(--blue);
+    border-color: transparent;
+  }
+
+  &::before {
+    content: " ";
+    position: absolute;
+    background: var(--accent-color);
+    width: 100%;
+    height: 100%;
+    left: 0;
+    opacity: 0.15;
+    z-index: -1;
+    transition: opacity 0.1s;
+  }
+}
+
+.icon {
+  width: 16px;
+  height: 16px;
+}
+
+.warningMedium {
+  --accent-color: var(--colorWarning);
+}
+
+.warningHigh {
+  --accent-color: var(--colorSoftError);
+}

packages/core/src/features/application-update/child-features/application-update-using-top-bar/renderer/update-application-top-bar-item/update-button/update-button.tsx

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import styles from "./styles.module.scss";
+
+import type { HTMLAttributes } from "react";
+import React, { useState } from "react";
+import { Menu, MenuItem } from "../../../../../../../renderer/components/menu";
+import { cssNames } from "../../../../../../../renderer/utils";
+import type { IconProps } from "../../../../../../../renderer/components/icon";
+import { Icon } from "../../../../../../../renderer/components/icon";
+import { withInjectables } from "@ogre-tools/injectable-react";
+import { observer } from "mobx-react";
+import type { IComputedValue } from "mobx";
+import restartAndInstallUpdateInjectable from "../../../../../renderer/restart-and-install-update.injectable";
+import updateWarningLevelInjectable from "../update-warning-level.injectable";
+
+interface UpdateButtonProps extends HTMLAttributes<HTMLButtonElement> {}
+
+interface Dependencies {
+  warningLevel: IComputedValue<"light" | "medium" | "high" | "">;
+  update: () => void;
+}
+
+const NonInjectedUpdateButton = observer(({ warningLevel, update, id }: UpdateButtonProps & Dependencies) => {
+  const buttonId = id ?? "update-lens-button";
+  const menuIconProps: IconProps = { material: "update", small: true };
+  const [opened, setOpened] = useState(false);
+  const level = warningLevel.get();
+
+  const toggle = () => {
+    setOpened(!opened);
+  };
+
+  return (
+    <>
+      <button
+        data-testid="update-button"
+        data-warning-level={level}
+        id={buttonId}
+        className={cssNames(styles.updateButton, {
+          [styles.warningHigh]: level === "high",
+          [styles.warningMedium]: level === "medium",
+        })}
+      >
+        Update
+        <Icon material="arrow_drop_down" className={styles.icon}/>
+      </button>
+      <Menu
+        usePortal
+        htmlFor={buttonId}
+        isOpen={opened}
+        close={toggle}
+        open={toggle}
+      >
+        <MenuItem
+          icon={menuIconProps}
+          onClick={update}
+          data-testid="update-lens-menu-item"
+        >
+          Relaunch to Update Lens
+        </MenuItem>
+      </Menu>
+    </>
+  );
+});
+
+export const UpdateButton = withInjectables<Dependencies, UpdateButtonProps>(
+  NonInjectedUpdateButton,
+  {
+    getProps: (di, props) => ({
+      ...props,
+      warningLevel: di.inject(updateWarningLevelInjectable),
+      update: di.inject(restartAndInstallUpdateInjectable),
+    }),
+  },
+);

packages/core/src/features/application-update/child-features/application-update-using-top-bar/renderer/update-application-top-bar-item/update-warning-level.injectable.ts

@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import updateDownloadedDateTimeInjectable from "../../../../common/update-downloaded-date-time/update-downloaded-date-time.injectable";
+import { reactiveNow } from "../../../../../../common/utils/reactive-now/reactive-now";
+
+const updateWarningLevelInjectable = getInjectable({
+  id: "update-warning-level",
+
+  instantiate: (di) => {
+    const updateDownloadedDateTime = di.inject(updateDownloadedDateTimeInjectable);
+
+    return computed(() => {
+      const downloadedAt = updateDownloadedDateTime.value.get();
+
+      if (!downloadedAt) {
+        return "";
+      }
+
+      const ONE_DAY = 1000 * 60 * 60 * 24;
+
+      const downloadedAtTimestamp = new Date(downloadedAt).getTime();
+      const currentDateTimeTimestamp = reactiveNow(ONE_DAY);
+
+      const elapsedTime = currentDateTimeTimestamp - downloadedAtTimestamp;
+
+      const elapsedDays = elapsedTime / ONE_DAY;
+
+      if (elapsedDays < 20) {
+        return "light";
+      }
+
+      if (elapsedDays >= 20 && elapsedDays < 25) {
+        return "medium";
+      }
+
+      return "high";
+    });
+  },
+});
+
+export default updateWarningLevelInjectable;

packages/core/src/features/application-update/child-features/application-update-using-tray/installing-update-using-tray.test.ts

@@ -0,0 +1,282 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { ApplicationBuilder } from "../../../../renderer/components/test-utils/get-application-builder";
+import { getApplicationBuilder } from "../../../../renderer/components/test-utils/get-application-builder";
+import type { RenderResult } from "@testing-library/react";
+import electronUpdaterIsActiveInjectable from "../../../../main/electron-app/features/electron-updater-is-active.injectable";
+import publishIsConfiguredInjectable from "../../main/updating-is-enabled/publish-is-configured/publish-is-configured.injectable";
+import type { CheckForPlatformUpdates } from "../../main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable";
+import checkForPlatformUpdatesInjectable from "../../main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable";
+import type { AsyncFnMock } from "@async-fn/jest";
+import asyncFn from "@async-fn/jest";
+import type { DownloadPlatformUpdate } from "../../main/download-update/download-platform-update/download-platform-update.injectable";
+import downloadPlatformUpdateInjectable from "../../main/download-update/download-platform-update/download-platform-update.injectable";
+import type { LensWindow } from "../../../../main/start-main-application/lens-window/application-window/create-lens-window.injectable";
+import getCurrentApplicationWindowInjectable from "../../../../main/start-main-application/lens-window/application-window/get-current-application-window.injectable";
+
+describe("installing update using tray", () => {
+  let builder: ApplicationBuilder;
+  let checkForPlatformUpdatesMock: AsyncFnMock<CheckForPlatformUpdates>;
+  let downloadPlatformUpdateMock: AsyncFnMock<DownloadPlatformUpdate>;
+
+  beforeEach(() => {
+    builder = getApplicationBuilder();
+
+    builder.beforeApplicationStart((mainDi) => {
+      checkForPlatformUpdatesMock = asyncFn();
+      downloadPlatformUpdateMock = asyncFn();
+
+      mainDi.override(
+        checkForPlatformUpdatesInjectable,
+        () => checkForPlatformUpdatesMock,
+      );
+
+      mainDi.override(
+        downloadPlatformUpdateInjectable,
+        () => downloadPlatformUpdateMock,
+      );
+
+      mainDi.override(electronUpdaterIsActiveInjectable, () => true);
+      mainDi.override(publishIsConfiguredInjectable, () => true);
+    });
+  });
+
+  describe("when started", () => {
+    let rendered: RenderResult;
+
+    beforeEach(async () => {
+      rendered = await builder.render();
+    });
+
+    it("renders", () => {
+      expect(rendered.baseElement).toMatchSnapshot();
+    });
+
+    it("user cannot install update yet", () => {
+      expect(builder.tray.get("install-update")).toBeNull();
+    });
+
+    describe("given all application windows are closed, when checking for updates", () => {
+      let getCurrentApplicationWindow: () => LensWindow | undefined;
+
+      beforeEach(() => {
+        getCurrentApplicationWindow = builder.mainDi.inject(
+          getCurrentApplicationWindowInjectable,
+        );
+
+        builder.applicationWindow.closeAll();
+
+        builder.tray.click("check-for-updates");
+      });
+
+      describe("when check for update resolves with new update", () => {
+        beforeEach(async () => {
+          await checkForPlatformUpdatesMock.resolve({
+            updateWasDiscovered: true,
+            version: "some-version",
+          });
+        });
+
+        it("does not show application window yet", () => {
+          const actual = getCurrentApplicationWindow();
+
+          expect(actual).toBeUndefined();
+        });
+
+        describe("when download of update resolves with success", () => {
+          beforeEach(async () => {
+            await downloadPlatformUpdateMock.resolve({ downloadWasSuccessful: true });
+          });
+
+          it("shows the application window", () => {
+            const actual = getCurrentApplicationWindow();
+
+            expect(actual).not.toBeUndefined();
+          });
+
+          it("given closing application window again and checking for updates again using tray, when check resolves with same version that was earlier downloaded, shows the application window", async () => {
+            builder.applicationWindow.closeAll();
+
+            builder.tray.click("check-for-updates");
+
+            await checkForPlatformUpdatesMock.resolve({
+              updateWasDiscovered: true,
+              version: "some-version",
+            });
+
+            const actual = getCurrentApplicationWindow();
+
+            expect(actual).not.toBeUndefined();
+          });
+        });
+
+        it("when download of update resolves with failure, does not show the application window", async () => {
+          await downloadPlatformUpdateMock.resolve({ downloadWasSuccessful: false });
+
+          const actual = getCurrentApplicationWindow();
+
+          expect(actual).toBeUndefined();
+        });
+      });
+
+      it("when process resolves without new update, does not show the application window", async () => {
+        await checkForPlatformUpdatesMock.resolve({
+          updateWasDiscovered: false,
+        });
+
+        const actual = getCurrentApplicationWindow();
+
+        expect(actual).toBeUndefined();
+      });
+    });
+
+    describe("when user checks for updates using tray", () => {
+      beforeEach(() => {
+        builder.tray.click("check-for-updates");
+      });
+
+      it("user cannot check for updates again", () => {
+        expect(
+          builder.tray.get("check-for-updates")?.enabled,
+        ).toBe(false);
+      });
+
+      it("name of tray item for checking updates indicates that checking is happening", () => {
+        expect(
+          builder.tray.get("check-for-updates")?.label,
+        ).toBe("Checking for updates...");
+      });
+
+      it("user cannot install update yet", () => {
+        expect(builder.tray.get("install-update")).toBeNull();
+      });
+
+      it("renders", () => {
+        expect(rendered.baseElement).toMatchSnapshot();
+      });
+
+      describe("when no new update is discovered", () => {
+        beforeEach(async () => {
+          await checkForPlatformUpdatesMock.resolve({
+            updateWasDiscovered: false,
+          });
+        });
+
+        it("user cannot install update", () => {
+          expect(builder.tray.get("install-update")).toBeNull();
+        });
+
+        it("user can check for updates again", () => {
+          expect(
+            builder.tray.get("check-for-updates")?.enabled,
+          ).toBe(true);
+        });
+
+        it("name of tray item for checking updates no longer indicates that checking is happening", () => {
+          expect(
+            builder.tray.get("check-for-updates")?.label,
+          ).toBe("Check for updates");
+        });
+
+        it("renders", () => {
+          expect(rendered.baseElement).toMatchSnapshot();
+        });
+      });
+
+      describe("when new update is discovered", () => {
+        beforeEach(async () => {
+          await checkForPlatformUpdatesMock.resolve({
+            updateWasDiscovered: true,
+            version: "some-version",
+          });
+        });
+
+        it("user cannot check for updates again yet", () => {
+          expect(
+            builder.tray.get("check-for-updates")?.enabled,
+          ).toBe(false);
+        });
+
+        it("name of tray item for checking updates indicates that downloading is happening", () => {
+          expect(
+            builder.tray.get("check-for-updates")?.label,
+          ).toBe("Downloading update some-version (0%)...");
+        });
+
+        it("when download progresses with decimals, percentage increases as integers", () => {
+          downloadPlatformUpdateMock.mock.calls[0][0]({ percentage: 42.424242 });
+
+          expect(
+            builder.tray.get("check-for-updates")?.label,
+          ).toBe("Downloading update some-version (42%)...");
+        });
+
+        it("user still cannot install update", () => {
+          expect(builder.tray.get("install-update")).toBeNull();
+        });
+
+        it("renders", () => {
+          expect(rendered.baseElement).toMatchSnapshot();
+        });
+
+        describe("when download fails", () => {
+          beforeEach(async () => {
+            await downloadPlatformUpdateMock.resolve({ downloadWasSuccessful: false });
+          });
+
+          it("user cannot install update", () => {
+            expect(
+              builder.tray.get("install-update"),
+            ).toBeNull();
+          });
+
+          it("user can check for updates again", () => {
+            expect(
+              builder.tray.get("check-for-updates")?.enabled,
+            ).toBe(true);
+          });
+
+          it("name of tray item for checking updates no longer indicates that downloading is happening", () => {
+            expect(
+              builder.tray.get("check-for-updates")?.label,
+            ).toBe("Check for updates");
+          });
+
+          it("renders", () => {
+            expect(rendered.baseElement).toMatchSnapshot();
+          });
+        });
+
+        describe("when download succeeds", () => {
+          beforeEach(async () => {
+            await downloadPlatformUpdateMock.resolve({ downloadWasSuccessful: true });
+          });
+
+          it("user can install update", () => {
+            expect(
+              builder.tray.get("install-update")?.label,
+            ).toBe("Install update some-version");
+          });
+
+          it("user can check for updates again", () => {
+            expect(
+              builder.tray.get("check-for-updates")?.enabled,
+            ).toBe(true);
+          });
+
+          it("name of tray item for checking updates no longer indicates that downloading is happening", () => {
+            expect(
+              builder.tray.get("check-for-updates")?.label,
+            ).toBe("Check for updates");
+          });
+
+          it("renders", () => {
+            expect(rendered.baseElement).toMatchSnapshot();
+          });
+        });
+      });
+    });
+  });
+});

packages/core/src/features/application-update/child-features/application-update-using-tray/main/tray-icons/checking-for-updates-tray-icon.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 { computed } from "mobx";
+import getTrayIconPathInjectable from "../../../../../../main/tray/menu-icon/get-tray-icon-path.injectable";
+import { trayIconInjectionToken } from "../../../../../../main/tray/menu-icon/tray-icon-injection-token";
+import updatesAreBeingDiscoveredInjectable from "../../../../common/updates-are-being-discovered/updates-are-being-discovered.injectable";
+import updateIsBeingDownloadedInjectable from "../../../../common/update-is-being-downloaded/update-is-being-downloaded.injectable";
+
+const checkingForUpdatesTrayIconInjectable = getInjectable({
+  id: "checking-for-updates-tray-icon",
+
+  instantiate: (di) => {
+    const getTrayIconPath = di.inject(getTrayIconPathInjectable);
+    const updatesAreBeingDiscovered = di.inject(updatesAreBeingDiscoveredInjectable);
+    const updateIsBeingDownloaded = di.inject(updateIsBeingDownloadedInjectable);
+
+    return {
+      iconPath: getTrayIconPath("checking-for-updates"),
+      priority: 1,
+      shouldBeShown: computed(
+        () =>
+          updatesAreBeingDiscovered.value.get() ||
+          updateIsBeingDownloaded.value.get(),
+      ),
+    };
+  },
+
+  injectionToken: trayIconInjectionToken,
+});
+
+export default checkingForUpdatesTrayIconInjectable;

packages/core/src/features/application-update/child-features/application-update-using-tray/main/tray-icons/update-is-ready-to-be-installed-tray-icon.injectable.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import getTrayIconPathInjectable from "../../../../../../main/tray/menu-icon/get-tray-icon-path.injectable";
+import { trayIconInjectionToken } from "../../../../../../main/tray/menu-icon/tray-icon-injection-token";
+import updateIsReadyToBeInstalledInjectable from "../update-is-ready-to-be-installed.injectable";
+
+const updateIsReadyToBeInstalledTrayIconInjectable = getInjectable({
+  id: "update-is-ready-to-be-installed-tray-icon",
+
+  instantiate: (di) => {
+    const getTrayIconPath = di.inject(getTrayIconPathInjectable);
+    const updateIsReadyToBeInstalled = di.inject(updateIsReadyToBeInstalledInjectable);
+
+    return {
+      iconPath: getTrayIconPath("update-available"),
+      priority: 1,
+      shouldBeShown: updateIsReadyToBeInstalled,
+    };
+  },
+
+  injectionToken: trayIconInjectionToken,
+});
+
+export default updateIsReadyToBeInstalledTrayIconInjectable;

packages/core/src/features/application-update/child-features/application-update-using-tray/main/tray-items/check-for-updates-tray-item.injectable.ts

@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import updatingIsEnabledInjectable from "../../../../main/updating-is-enabled/updating-is-enabled.injectable";
+import { trayMenuItemInjectionToken } from "../../../../../../main/tray/tray-menu-item/tray-menu-item-injection-token";
+import showApplicationWindowInjectable from "../../../../../../main/start-main-application/lens-window/show-application-window.injectable";
+import discoveredUpdateVersionInjectable from "../../../../common/discovered-update-version/discovered-update-version.injectable";
+import updateIsBeingDownloadedInjectable from "../../../../common/update-is-being-downloaded/update-is-being-downloaded.injectable";
+import updatesAreBeingDiscoveredInjectable from "../../../../common/updates-are-being-discovered/updates-are-being-discovered.injectable";
+import progressOfUpdateDownloadInjectable from "../../../../common/progress-of-update-download/progress-of-update-download.injectable";
+import assert from "assert";
+import processCheckingForUpdatesInjectable from "../../../../main/process-checking-for-updates.injectable";
+import { withErrorSuppression } from "../../../../../../common/utils/with-error-suppression/with-error-suppression";
+import { pipeline } from "@ogre-tools/fp";
+import withErrorLoggingInjectable from "../../../../../../common/utils/with-error-logging/with-error-logging.injectable";
+
+const checkForUpdatesTrayItemInjectable = getInjectable({
+  id: "check-for-updates-tray-item",
+
+  instantiate: (di) => {
+    const showApplicationWindow = di.inject(showApplicationWindowInjectable);
+    const updatingIsEnabled = di.inject(updatingIsEnabledInjectable);
+    const progressOfUpdateDownload = di.inject(progressOfUpdateDownloadInjectable);
+    const discoveredVersionState = di.inject(discoveredUpdateVersionInjectable);
+    const downloadingUpdateState = di.inject(updateIsBeingDownloadedInjectable);
+    const checkingForUpdatesState = di.inject(updatesAreBeingDiscoveredInjectable);
+    const processCheckingForUpdates = di.inject(processCheckingForUpdatesInjectable);
+    const withErrorLoggingFor = di.inject(withErrorLoggingInjectable);
+
+    return {
+      id: "check-for-updates",
+      parentId: null,
+      orderNumber: 30,
+
+      label: computed(() => {
+        if (downloadingUpdateState.value.get()) {
+          const discoveredVersion = discoveredVersionState.value.get();
+
+          assert(discoveredVersion);
+
+          const roundedPercentage = Math.round(progressOfUpdateDownload.value.get().percentage);
+
+          return `Downloading update ${discoveredVersion.version} (${roundedPercentage}%)...`;
+        }
+
+        if (checkingForUpdatesState.value.get()) {
+          return "Checking for updates...";
+        }
+
+        return "Check for updates";
+      }),
+
+      enabled: computed(() => !checkingForUpdatesState.value.get() && !downloadingUpdateState.value.get()),
+
+      visible: computed(() => updatingIsEnabled),
+
+      click: pipeline(
+        async () => {
+          const { updateIsReadyToBeInstalled } = await processCheckingForUpdates("tray");
+
+          if (updateIsReadyToBeInstalled) {
+            await showApplicationWindow();
+          }
+        },
+
+        withErrorLoggingFor(() => "[TRAY]: Checking for updates failed."),
+
+        // TODO: Find out how to improve typing so that instead of
+        // x => withErrorSuppression(x) there could only be withErrorSuppression
+        (x) => withErrorSuppression(x),
+      ),
+    };
+  },
+
+  injectionToken: trayMenuItemInjectionToken,
+});
+
+export default checkForUpdatesTrayItemInjectable;

packages/core/src/features/application-update/child-features/application-update-using-tray/main/tray-items/install-application-update-tray-item.injectable.ts

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { trayMenuItemInjectionToken } from "../../../../../../main/tray/tray-menu-item/tray-menu-item-injection-token";
+import discoveredUpdateVersionInjectable from "../../../../common/discovered-update-version/discovered-update-version.injectable";
+import { withErrorSuppression } from "../../../../../../common/utils/with-error-suppression/with-error-suppression";
+import { pipeline } from "@ogre-tools/fp";
+import withErrorLoggingInjectable from "../../../../../../common/utils/with-error-logging/with-error-logging.injectable";
+import quitAndInstallUpdateInjectable from "../../../../main/quit-and-install-update.injectable";
+import updateIsReadyToBeInstalledInjectable from "../update-is-ready-to-be-installed.injectable";
+
+const installApplicationUpdateTrayItemInjectable = getInjectable({
+  id: "install-update-tray-item",
+
+  instantiate: (di) => {
+    const quitAndInstallUpdate = di.inject(quitAndInstallUpdateInjectable);
+    const discoveredVersionState = di.inject(discoveredUpdateVersionInjectable);
+    const withErrorLoggingFor = di.inject(withErrorLoggingInjectable);
+    const updateIsReadyToBeInstalled = di.inject(updateIsReadyToBeInstalledInjectable);
+
+    return {
+      id: "install-update",
+      parentId: null,
+      orderNumber: 50,
+
+      label: computed(() => {
+        const versionToBeInstalled = discoveredVersionState.value.get()?.version;
+
+        return `Install update ${versionToBeInstalled}`;
+      }),
+
+      enabled: computed(() => true),
+
+      visible: updateIsReadyToBeInstalled,
+
+      click: pipeline(
+        quitAndInstallUpdate,
+
+        withErrorLoggingFor(() => "[TRAY]: Update installation failed."),
+
+        // TODO: Find out how to improve typing so that instead of
+        // x => withErrorSuppression(x) there could only be withErrorSuppression
+        (x) => withErrorSuppression(x),
+      ),
+    };
+  },
+
+  injectionToken: trayMenuItemInjectionToken,
+});
+
+export default installApplicationUpdateTrayItemInjectable;

packages/core/src/features/application-update/child-features/application-update-using-tray/main/update-is-ready-to-be-installed.injectable.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 { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import discoveredUpdateVersionInjectable from "../../../common/discovered-update-version/discovered-update-version.injectable";
+import updateIsBeingDownloadedInjectable from "../../../common/update-is-being-downloaded/update-is-being-downloaded.injectable";
+
+const updateIsReadyToBeInstalledInjectable = getInjectable({
+  id: "update-is-ready-to-be-installed",
+
+  instantiate: (di) => {
+    const discoveredUpdateVersion = di.inject(discoveredUpdateVersionInjectable);
+    const updateIsBeingDownloaded = di.inject(updateIsBeingDownloadedInjectable);
+
+    return computed(
+      () =>
+        !!discoveredUpdateVersion.value.get() &&
+        !updateIsBeingDownloaded.value.get(),
+    );
+  },
+});
+
+export default updateIsReadyToBeInstalledInjectable;

packages/core/src/features/application-update/child-features/force-user-to-update-when-too-long-time-since-update-was-downloaded/__snapshots__/force-user-to-update-when-too-long-time-since-update-was-downloaded.test.ts.snap

@@ -0,0 +1,978 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`force user to update when too long since update was downloaded when application is started given checking for updates and it resolves, when update was downloaded renders 1`] = `
+<body>
+  <div>
+    <div
+      class="ClusterManager"
+    >
+      <div
+        class="topBar"
+      >
+        <div
+          class="items"
+        >
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="home-button"
+            >
+              <span
+                class="icon"
+                data-icon-name="home"
+              >
+                home
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="history-back"
+            >
+              <span
+                class="icon"
+                data-icon-name="arrow_back"
+              >
+                arrow_back
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="history-forward"
+            >
+              <span
+                class="icon"
+                data-icon-name="arrow_forward"
+              >
+                arrow_forward
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <button
+              class="updateButton"
+              data-testid="update-button"
+              data-warning-level="light"
+              id="update-lens-button"
+            >
+              Update
+              <i
+                class="Icon icon material focusable"
+              >
+                <span
+                  class="icon"
+                  data-icon-name="arrow_drop_down"
+                >
+                  arrow_drop_down
+                </span>
+              </i>
+            </button>
+          </div>
+          <div
+            class="separator"
+          />
+        </div>
+      </div>
+      <main>
+        <div
+          id="lens-views"
+        />
+        <div
+          class="flex justify-center Welcome align-center"
+          data-testid="welcome-page"
+        >
+          <div
+            data-testid="welcome-banner-container"
+            style="width: 320px;"
+          >
+            <i
+              class="Icon logo svg focusable"
+            >
+              <span
+                class="icon"
+              />
+            </i>
+            <div
+              class="flex justify-center"
+            >
+              <div
+                data-testid="welcome-text-container"
+                style="width: 320px;"
+              >
+                <h2>
+                  Welcome to some-product-name!
+                </h2>
+                <p>
+                  To get you started we have auto-detected your clusters in your
+                   
+                  kubeconfig file and added them to the catalog, your centralized
+                   
+                  view for managing all your cloud-native resources.
+                  <br />
+                  <br />
+                  If you have any questions or feedback, please join our 
+                  <a
+                    class="link"
+                    href="https://k8slens.dev/slack.html"
+                    rel="noreferrer"
+                    target="_blank"
+                  >
+                    Lens Community slack channel
+                  </a>
+                  .
+                </p>
+                <ul
+                  class="block"
+                  data-testid="welcome-menu-container"
+                  style="width: 320px;"
+                >
+                  <li
+                    class="flex grid-12"
+                  >
+                    <i
+                      class="Icon box col-1 material focusable"
+                    >
+                      <span
+                        class="icon"
+                        data-icon-name="view_list"
+                      >
+                        view_list
+                      </span>
+                    </i>
+                    <a
+                      class="box col-10"
+                    >
+                      Browse Clusters in Catalog
+                    </a>
+                    <i
+                      class="Icon box col-1 material focusable"
+                    >
+                      <span
+                        class="icon"
+                        data-icon-name="navigate_next"
+                      >
+                        navigate_next
+                      </span>
+                    </i>
+                  </li>
+                </ul>
+              </div>
+            </div>
+          </div>
+        </div>
+      </main>
+      <div
+        class="HotbarMenu flex column"
+      >
+        <div
+          class="HotbarItems flex column gaps"
+        >
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="0"
+          >
+            <div
+              style="z-index: 12; position: absolute;"
+            >
+              <div
+                class="HotbarIcon contextMenuAvailable"
+              >
+                <div
+                  class="Avatar rounded disabled avatar"
+                  id="hotbarIcon-hotbar-icon-catalog-entity"
+                  style="width: 40px; height: 40px; background: rgb(5, 1, 130);"
+                >
+                  Ca
+                </div>
+              </div>
+            </div>
+          </div>
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="1"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="2"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="3"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="4"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="5"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="6"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="7"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="8"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="9"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="10"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="11"
+          />
+        </div>
+        <div
+          class="HotbarSelector"
+        >
+          <i
+            class="Icon Icon previous material interactive focusable"
+            tabindex="0"
+          >
+            <span
+              class="icon"
+              data-icon-name="arrow_left"
+            >
+              arrow_left
+            </span>
+          </i>
+          <div
+            class="HotbarIndex"
+          >
+            <div
+              class="badge Badge small clickable"
+              id="hotbarIndex"
+            >
+              1
+            </div>
+          </div>
+          <i
+            class="Icon material interactive focusable"
+            tabindex="0"
+          >
+            <span
+              class="icon"
+              data-icon-name="arrow_right"
+            >
+              arrow_right
+            </span>
+          </i>
+        </div>
+      </div>
+      <div
+        class="StatusBar"
+        data-testid="status-bar"
+      >
+        <div
+          class="leftSide"
+          data-testid="status-bar-left"
+        />
+        <div
+          class="rightSide"
+          data-testid="status-bar-right"
+        />
+      </div>
+    </div>
+    <div
+      class="Notifications flex column align-flex-end"
+    />
+  </div>
+</body>
+`;
+
+exports[`force user to update when too long since update was downloaded when application is started given checking for updates and it resolves, when update was downloaded when enough time passes to consider that update must be installed renders 1`] = `
+<body>
+  <div>
+    <div
+      class="ClusterManager"
+    >
+      <div
+        class="topBar"
+      >
+        <div
+          class="items"
+        >
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="home-button"
+            >
+              <span
+                class="icon"
+                data-icon-name="home"
+              >
+                home
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="history-back"
+            >
+              <span
+                class="icon"
+                data-icon-name="arrow_back"
+              >
+                arrow_back
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="history-forward"
+            >
+              <span
+                class="icon"
+                data-icon-name="arrow_forward"
+              >
+                arrow_forward
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <button
+              class="updateButton"
+              data-testid="update-button"
+              data-warning-level="light"
+              id="update-lens-button"
+            >
+              Update
+              <i
+                class="Icon icon material focusable"
+              >
+                <span
+                  class="icon"
+                  data-icon-name="arrow_drop_down"
+                >
+                  arrow_drop_down
+                </span>
+              </i>
+            </button>
+          </div>
+          <div
+            class="separator"
+          />
+        </div>
+      </div>
+      <main>
+        <div
+          id="lens-views"
+        />
+        <div
+          class="flex justify-center Welcome align-center"
+          data-testid="welcome-page"
+        >
+          <div
+            data-testid="welcome-banner-container"
+            style="width: 320px;"
+          >
+            <i
+              class="Icon logo svg focusable"
+            >
+              <span
+                class="icon"
+              />
+            </i>
+            <div
+              class="flex justify-center"
+            >
+              <div
+                data-testid="welcome-text-container"
+                style="width: 320px;"
+              >
+                <h2>
+                  Welcome to some-product-name!
+                </h2>
+                <p>
+                  To get you started we have auto-detected your clusters in your
+                   
+                  kubeconfig file and added them to the catalog, your centralized
+                   
+                  view for managing all your cloud-native resources.
+                  <br />
+                  <br />
+                  If you have any questions or feedback, please join our 
+                  <a
+                    class="link"
+                    href="https://k8slens.dev/slack.html"
+                    rel="noreferrer"
+                    target="_blank"
+                  >
+                    Lens Community slack channel
+                  </a>
+                  .
+                </p>
+                <ul
+                  class="block"
+                  data-testid="welcome-menu-container"
+                  style="width: 320px;"
+                >
+                  <li
+                    class="flex grid-12"
+                  >
+                    <i
+                      class="Icon box col-1 material focusable"
+                    >
+                      <span
+                        class="icon"
+                        data-icon-name="view_list"
+                      >
+                        view_list
+                      </span>
+                    </i>
+                    <a
+                      class="box col-10"
+                    >
+                      Browse Clusters in Catalog
+                    </a>
+                    <i
+                      class="Icon box col-1 material focusable"
+                    >
+                      <span
+                        class="icon"
+                        data-icon-name="navigate_next"
+                      >
+                        navigate_next
+                      </span>
+                    </i>
+                  </li>
+                </ul>
+              </div>
+            </div>
+          </div>
+        </div>
+      </main>
+      <div
+        class="HotbarMenu flex column"
+      >
+        <div
+          class="HotbarItems flex column gaps"
+        >
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="0"
+          >
+            <div
+              style="z-index: 12; position: absolute;"
+            >
+              <div
+                class="HotbarIcon contextMenuAvailable"
+              >
+                <div
+                  class="Avatar rounded disabled avatar"
+                  id="hotbarIcon-hotbar-icon-catalog-entity"
+                  style="width: 40px; height: 40px; background: rgb(5, 1, 130);"
+                >
+                  Ca
+                </div>
+              </div>
+            </div>
+          </div>
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="1"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="2"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="3"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="4"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="5"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="6"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="7"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="8"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="9"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="10"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="11"
+          />
+        </div>
+        <div
+          class="HotbarSelector"
+        >
+          <i
+            class="Icon Icon previous material interactive focusable"
+            tabindex="0"
+          >
+            <span
+              class="icon"
+              data-icon-name="arrow_left"
+            >
+              arrow_left
+            </span>
+          </i>
+          <div
+            class="HotbarIndex"
+          >
+            <div
+              class="badge Badge small clickable"
+              id="hotbarIndex"
+            >
+              1
+            </div>
+          </div>
+          <i
+            class="Icon material interactive focusable"
+            tabindex="0"
+          >
+            <span
+              class="icon"
+              data-icon-name="arrow_right"
+            >
+              arrow_right
+            </span>
+          </i>
+        </div>
+      </div>
+      <div
+        class="StatusBar"
+        data-testid="status-bar"
+      >
+        <div
+          class="leftSide"
+          data-testid="status-bar-left"
+        />
+        <div
+          class="rightSide"
+          data-testid="status-bar-right"
+        />
+      </div>
+    </div>
+    <div
+      class="Notifications flex column align-flex-end"
+    />
+  </div>
+  <div
+    class="Animate opacity-scale Dialog flex center modal pinned enter"
+    style="--enter-duration: 100ms; --leave-duration: 100ms;"
+  >
+    <div
+      class="box"
+    >
+      <div
+        class="ForceUpdateModal"
+        data-testid="must-update-immediately"
+      >
+        <div
+          class="header"
+        >
+          <h2>
+            Please update
+          </h2>
+        </div>
+        <div
+          class="content"
+        >
+          <p>
+            An update to Lens Desktop is required to continue using the application.
+          </p>
+        </div>
+        <div
+          class="footer"
+        >
+          <button
+            class="Button primary"
+            data-testid="update-now-from-must-update-immediately-modal"
+            type="button"
+          >
+            Update
+             
+            (
+            <span
+              data-testid="countdown-to-automatic-update"
+            >
+              5
+            </span>
+            )
+          </button>
+        </div>
+      </div>
+    </div>
+  </div>
+</body>
+`;
+
+exports[`force user to update when too long since update was downloaded when application is started given checking for updates and it resolves, when update was downloaded when not enough time passes to consider that update must be installed renders 1`] = `
+<body>
+  <div>
+    <div
+      class="ClusterManager"
+    >
+      <div
+        class="topBar"
+      >
+        <div
+          class="items"
+        >
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="home-button"
+            >
+              <span
+                class="icon"
+                data-icon-name="home"
+              >
+                home
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="history-back"
+            >
+              <span
+                class="icon"
+                data-icon-name="arrow_back"
+              >
+                arrow_back
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="history-forward"
+            >
+              <span
+                class="icon"
+                data-icon-name="arrow_forward"
+              >
+                arrow_forward
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <button
+              class="updateButton"
+              data-testid="update-button"
+              data-warning-level="light"
+              id="update-lens-button"
+            >
+              Update
+              <i
+                class="Icon icon material focusable"
+              >
+                <span
+                  class="icon"
+                  data-icon-name="arrow_drop_down"
+                >
+                  arrow_drop_down
+                </span>
+              </i>
+            </button>
+          </div>
+          <div
+            class="separator"
+          />
+        </div>
+      </div>
+      <main>
+        <div
+          id="lens-views"
+        />
+        <div
+          class="flex justify-center Welcome align-center"
+          data-testid="welcome-page"
+        >
+          <div
+            data-testid="welcome-banner-container"
+            style="width: 320px;"
+          >
+            <i
+              class="Icon logo svg focusable"
+            >
+              <span
+                class="icon"
+              />
+            </i>
+            <div
+              class="flex justify-center"
+            >
+              <div
+                data-testid="welcome-text-container"
+                style="width: 320px;"
+              >
+                <h2>
+                  Welcome to some-product-name!
+                </h2>
+                <p>
+                  To get you started we have auto-detected your clusters in your
+                   
+                  kubeconfig file and added them to the catalog, your centralized
+                   
+                  view for managing all your cloud-native resources.
+                  <br />
+                  <br />
+                  If you have any questions or feedback, please join our 
+                  <a
+                    class="link"
+                    href="https://k8slens.dev/slack.html"
+                    rel="noreferrer"
+                    target="_blank"
+                  >
+                    Lens Community slack channel
+                  </a>
+                  .
+                </p>
+                <ul
+                  class="block"
+                  data-testid="welcome-menu-container"
+                  style="width: 320px;"
+                >
+                  <li
+                    class="flex grid-12"
+                  >
+                    <i
+                      class="Icon box col-1 material focusable"
+                    >
+                      <span
+                        class="icon"
+                        data-icon-name="view_list"
+                      >
+                        view_list
+                      </span>
+                    </i>
+                    <a
+                      class="box col-10"
+                    >
+                      Browse Clusters in Catalog
+                    </a>
+                    <i
+                      class="Icon box col-1 material focusable"
+                    >
+                      <span
+                        class="icon"
+                        data-icon-name="navigate_next"
+                      >
+                        navigate_next
+                      </span>
+                    </i>
+                  </li>
+                </ul>
+              </div>
+            </div>
+          </div>
+        </div>
+      </main>
+      <div
+        class="HotbarMenu flex column"
+      >
+        <div
+          class="HotbarItems flex column gaps"
+        >
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="0"
+          >
+            <div
+              style="z-index: 12; position: absolute;"
+            >
+              <div
+                class="HotbarIcon contextMenuAvailable"
+              >
+                <div
+                  class="Avatar rounded disabled avatar"
+                  id="hotbarIcon-hotbar-icon-catalog-entity"
+                  style="width: 40px; height: 40px; background: rgb(5, 1, 130);"
+                >
+                  Ca
+                </div>
+              </div>
+            </div>
+          </div>
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="1"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="2"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="3"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="4"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="5"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="6"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="7"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="8"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="9"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="10"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="11"
+          />
+        </div>
+        <div
+          class="HotbarSelector"
+        >
+          <i
+            class="Icon Icon previous material interactive focusable"
+            tabindex="0"
+          >
+            <span
+              class="icon"
+              data-icon-name="arrow_left"
+            >
+              arrow_left
+            </span>
+          </i>
+          <div
+            class="HotbarIndex"
+          >
+            <div
+              class="badge Badge small clickable"
+              id="hotbarIndex"
+            >
+              1
+            </div>
+          </div>
+          <i
+            class="Icon material interactive focusable"
+            tabindex="0"
+          >
+            <span
+              class="icon"
+              data-icon-name="arrow_right"
+            >
+              arrow_right
+            </span>
+          </i>
+        </div>
+      </div>
+      <div
+        class="StatusBar"
+        data-testid="status-bar"
+      >
+        <div
+          class="leftSide"
+          data-testid="status-bar-left"
+        />
+        <div
+          class="rightSide"
+          data-testid="status-bar-right"
+        />
+      </div>
+    </div>
+    <div
+      class="Notifications flex column align-flex-end"
+    />
+  </div>
+</body>
+`;

packages/core/src/features/application-update/child-features/force-user-to-update-when-too-long-time-since-update-was-downloaded/force-user-to-update-when-too-long-time-since-update-was-downloaded.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 { ApplicationBuilder } from "../../../../renderer/components/test-utils/get-application-builder";
+import { getApplicationBuilder } from "../../../../renderer/components/test-utils/get-application-builder";
+import type { CheckForPlatformUpdates } from "../../main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable";
+import checkForPlatformUpdatesInjectable from "../../main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable";
+import type { DownloadPlatformUpdate } from "../../main/download-update/download-platform-update/download-platform-update.injectable";
+import downloadPlatformUpdateInjectable from "../../main/download-update/download-platform-update/download-platform-update.injectable";
+import type { AsyncFnMock } from "@async-fn/jest";
+import asyncFn from "@async-fn/jest";
+import type { DiContainer } from "@ogre-tools/injectable";
+import processCheckingForUpdatesInjectable from "../../main/process-checking-for-updates.injectable";
+import type { RenderResult } from "@testing-library/react";
+import { fireEvent } from "@testing-library/react";
+import { advanceFakeTime, testUsingFakeTime } from "../../../../common/test-utils/use-fake-time";
+import quitAndInstallUpdateInjectable from "../../main/quit-and-install-update.injectable";
+import timeAfterUpdateMustBeInstalledInjectable from "./renderer/force-update-modal/time-after-update-must-be-installed.injectable";
+import secondsAfterInstallStartsInjectable from "./renderer/force-update-modal/seconds-after-install-starts.injectable";
+import forceUpdateModalRootFrameComponentInjectable from "./renderer/force-update-modal/force-update-modal-root-frame-component.injectable";
+
+const TIME_AFTER_UPDATE_MUST_BE_INSTALLED = 1000;
+const TIME_AFTER_INSTALL_STARTS = 5 * 1000;
+
+describe("force user to update when too long since update was downloaded", () => {
+  let applicationBuilder: ApplicationBuilder;
+  let checkForPlatformUpdatesMock: AsyncFnMock<CheckForPlatformUpdates>;
+  let downloadPlatformUpdateMock: AsyncFnMock<DownloadPlatformUpdate>;
+  let mainDi: DiContainer;
+  let quitAndInstallUpdateMock: jest.Mock;
+
+  beforeEach(() => {
+    testUsingFakeTime("2015-10-21T07:28:00Z");
+
+    applicationBuilder = getApplicationBuilder();
+
+    applicationBuilder.beforeApplicationStart(mainDi => {
+      checkForPlatformUpdatesMock = asyncFn();
+
+      mainDi.override(checkForPlatformUpdatesInjectable, () => checkForPlatformUpdatesMock);
+
+      downloadPlatformUpdateMock = asyncFn();
+
+      mainDi.override(downloadPlatformUpdateInjectable, () => downloadPlatformUpdateMock);
+
+      quitAndInstallUpdateMock = jest.fn();
+
+      mainDi.override(quitAndInstallUpdateInjectable, () => quitAndInstallUpdateMock);
+    });
+
+    applicationBuilder.beforeWindowStart(windowDi => {
+      windowDi.unoverride(forceUpdateModalRootFrameComponentInjectable);
+      windowDi.permitSideEffects(forceUpdateModalRootFrameComponentInjectable);
+
+      windowDi.override(timeAfterUpdateMustBeInstalledInjectable, () => TIME_AFTER_UPDATE_MUST_BE_INSTALLED);
+      windowDi.override(secondsAfterInstallStartsInjectable, () => TIME_AFTER_INSTALL_STARTS / 1000);
+    });
+
+    mainDi = applicationBuilder.mainDi;
+  });
+
+  describe("when application is started", () => {
+    let rendered: RenderResult;
+
+    beforeEach(async () => {
+      rendered = await applicationBuilder.render();
+    });
+
+    describe("given checking for updates and it resolves, when update was downloaded", () => {
+      beforeEach(async () => {
+        const processCheckingForUpdates = mainDi.inject(
+          processCheckingForUpdatesInjectable,
+        );
+
+        processCheckingForUpdates("irrelevant");
+
+        await checkForPlatformUpdatesMock.resolve({
+          updateWasDiscovered: true,
+          version: "42.0.0",
+        });
+
+        await downloadPlatformUpdateMock.resolve({
+          downloadWasSuccessful: true,
+        });
+      });
+
+      it("does not show modal yet", () => {
+        expect(rendered.queryByTestId("must-update-immediately")).not.toBeInTheDocument();
+      });
+
+      describe("when not enough time passes to consider that update must be installed", () => {
+        beforeEach(() => {
+          advanceFakeTime(TIME_AFTER_UPDATE_MUST_BE_INSTALLED - 1);
+        });
+
+        it("does not show modal yet", () => {
+          expect(rendered.queryByTestId("must-update-immediately")).not.toBeInTheDocument();
+        });
+
+        it("renders", () => {
+          expect(rendered.baseElement).toMatchSnapshot();
+        });
+      });
+
+      it("renders", () => {
+        expect(rendered.baseElement).toMatchSnapshot();
+      });
+
+      describe("when enough time passes to consider that update must be installed", () => {
+        beforeEach(() => {
+          advanceFakeTime(TIME_AFTER_UPDATE_MUST_BE_INSTALLED);
+        });
+
+        it("shows modal to inform about forced update", () => {
+          expect(rendered.getByTestId("must-update-immediately")).toBeInTheDocument();
+        });
+
+        it("when selected to update now, restarts the application to update", () => {
+          fireEvent.click(rendered.getByTestId("update-now-from-must-update-immediately-modal"));
+
+          expect(quitAndInstallUpdateMock).toHaveBeenCalled();
+        });
+
+        it("shows countdown for automatic update", () => {
+          expect(rendered.getByTestId("countdown-to-automatic-update")).toHaveTextContent("5");
+        });
+
+        it("when some time passes, updates the countdown for automatic update", () => {
+          advanceFakeTime(1000);
+
+          expect(rendered.getByTestId("countdown-to-automatic-update")).toHaveTextContent("4");
+        });
+
+        it("when not enough time passes for automatic update, does not restart the application yet", () => {
+          advanceFakeTime(TIME_AFTER_INSTALL_STARTS - 1);
+
+          expect(quitAndInstallUpdateMock).not.toHaveBeenCalled();
+        });
+
+        it("when enough time passes for automatically update, restarts the application to update", () => {
+          advanceFakeTime(TIME_AFTER_INSTALL_STARTS);
+
+          expect(quitAndInstallUpdateMock).toHaveBeenCalled();
+        });
+
+        it("renders", () => {
+          expect(rendered.baseElement).toMatchSnapshot();
+        });
+      });
+    });
+  });
+});

packages/core/src/features/application-update/child-features/force-user-to-update-when-too-long-time-since-update-was-downloaded/renderer/force-update-modal/force-update-modal-root-frame-component.global-override-for-injectable.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { computed } from "mobx";
+import { getGlobalOverride } from "../../../../../../common/test-utils/get-global-override";
+import forceUpdateModalRootFrameComponentInjectable from "./force-update-modal-root-frame-component.injectable";
+
+export default getGlobalOverride(
+  forceUpdateModalRootFrameComponentInjectable,
+
+  () => ({
+    id: "force-update-modal",
+    Component: () => null,
+    shouldRender: computed(() => false),
+  }),
+);

packages/core/src/features/application-update/child-features/force-user-to-update-when-too-long-time-since-update-was-downloaded/renderer/force-update-modal/force-update-modal-root-frame-component.injectable.ts

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { rootFrameChildComponentInjectionToken } from "../../../../../../renderer/frames/root-frame/root-frame-child-component-injection-token";
+import { ForceUpdateModal } from "./force-update-modal";
+import timeSinceUpdateWasDownloadedInjectable from "./time-since-update-was-downloaded.injectable";
+import updateDownloadedDateTimeInjectable from "../../../../common/update-downloaded-date-time/update-downloaded-date-time.injectable";
+import timeAfterUpdateMustBeInstalledInjectable from "./time-after-update-must-be-installed.injectable";
+
+const forceUpdateModalRootFrameComponentInjectable = getInjectable({
+  id: "force-update-modal-root-frame-component",
+
+  instantiate: (di) => {
+    const timeSinceUpdateWasDownloaded = di.inject(timeSinceUpdateWasDownloadedInjectable);
+    const updateDownloadedDateTime = di.inject(updateDownloadedDateTimeInjectable);
+    const timeWhenUpdateMustBeInstalled = di.inject(timeAfterUpdateMustBeInstalledInjectable);
+
+    return {
+      id: "force-update-modal",
+      Component: ForceUpdateModal,
+
+      shouldRender: computed(
+        () =>
+          !!updateDownloadedDateTime.value.get() &&
+          timeSinceUpdateWasDownloaded.get() >= timeWhenUpdateMustBeInstalled,
+      ),
+    };
+  },
+
+  injectionToken: rootFrameChildComponentInjectionToken,
+
+  // Note: Globally overridden because it observes the current time which can cause long running tests
+  causesSideEffects: true,
+});
+
+export default forceUpdateModalRootFrameComponentInjectable;

packages/core/src/features/application-update/child-features/force-user-to-update-when-too-long-time-since-update-was-downloaded/renderer/force-update-modal/force-update-modal.module.scss

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+$baseline: 8px;
+
+.ForceUpdateModal {
+  background-color: white;
+  border-radius: 1 * $baseline;
+  padding: 3 * $baseline;
+  width: 50 * $baseline;
+
+  .header {
+    margin-bottom: 2 * $baseline;
+  }
+
+  .content {
+    margin-bottom: 2 * $baseline;
+  }
+
+  .footer {
+    display: flex;
+    justify-content: center;
+  }
+}

packages/core/src/features/application-update/child-features/force-user-to-update-when-too-long-time-since-update-was-downloaded/renderer/force-update-modal/force-update-modal.tsx

@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { withInjectables } from "@ogre-tools/injectable-react";
+import React from "react";
+import restartAndInstallUpdateInjectable from "../../../../renderer/restart-and-install-update.injectable";
+import { Countdown } from "../../../../../../renderer/components/countdown/countdown";
+import type { IComputedValue } from "mobx";
+import { observer } from "mobx-react";
+import installUpdateCountdownInjectable from "./install-update-countdown.injectable";
+import { Dialog } from "../../../../../../renderer/components/dialog";
+import { Button } from "../../../../../../renderer/components/button";
+import styles from "./force-update-modal.module.scss";
+
+interface Dependencies {
+  restartAndInstallUpdate: () => void;
+  secondsTill: IComputedValue<number>;
+}
+
+const NonInjectedForceUpdateModal = observer(
+  ({ restartAndInstallUpdate, secondsTill }: Dependencies) => (
+    <Dialog isOpen={true} pinned>
+      <div
+        data-testid="must-update-immediately"
+        className={styles.ForceUpdateModal}
+      >
+        <div className={styles.header}>
+          <h2>Please update</h2>
+        </div>
+
+        <div className={styles.content}>
+          <p>
+            An update to Lens Desktop is required to continue using the application.
+          </p>
+        </div>
+
+        <div className={styles.footer}>
+          <Button
+            primary
+            data-testid="update-now-from-must-update-immediately-modal"
+            onClick={restartAndInstallUpdate}
+            label="Update"
+          >
+            {" "}
+            (
+            <Countdown
+              secondsTill={secondsTill}
+              data-testid="countdown-to-automatic-update"
+            />
+            )
+          </Button>
+        </div>
+      </div>
+    </Dialog>
+  ),
+);
+
+export const ForceUpdateModal = withInjectables<Dependencies>(
+  NonInjectedForceUpdateModal,
+
+  {
+    getProps: (di, props) => ({
+      restartAndInstallUpdate: di.inject(restartAndInstallUpdateInjectable),
+      secondsTill: di.inject(installUpdateCountdownInjectable),
+      ...props,
+    }),
+  },
+);

packages/core/src/features/application-update/child-features/force-user-to-update-when-too-long-time-since-update-was-downloaded/renderer/force-update-modal/install-update-countdown.injectable.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import countdownStateInjectable from "../../../../../../renderer/components/countdown/countdown-state.injectable";
+import secondsAfterInstallStartsInjectable from "./seconds-after-install-starts.injectable";
+import restartAndInstallUpdateInjectable from "../../../../renderer/restart-and-install-update.injectable";
+
+const installUpdateCountdownInjectable = getInjectable({
+  id: "install-update-countdown",
+
+  instantiate: (di) => {
+    const secondsAfterInstallStarts = di.inject(secondsAfterInstallStartsInjectable);
+    const restartAndInstallUpdate = di.inject(restartAndInstallUpdateInjectable);
+
+    return di.inject(countdownStateInjectable, {
+      startFrom: secondsAfterInstallStarts,
+
+      onZero: () => {
+        restartAndInstallUpdate();
+      },
+    });
+  },
+});
+
+export default installUpdateCountdownInjectable;

packages/core/src/features/application-update/child-features/force-user-to-update-when-too-long-time-since-update-was-downloaded/renderer/force-update-modal/seconds-after-install-starts.injectable.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 { getInjectable } from "@ogre-tools/injectable";
+
+const secondsAfterInstallStartsInjectable = getInjectable({
+  id: "seconds-after-install-starts",
+  instantiate: () => 90,
+});
+
+export default secondsAfterInstallStartsInjectable;

packages/core/src/features/application-update/child-features/force-user-to-update-when-too-long-time-since-update-was-downloaded/renderer/force-update-modal/time-after-update-must-be-installed.injectable.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+
+const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
+
+const timeAfterUpdateMustBeInstalledInjectable = getInjectable({
+  id: "time-after-update-must-be-installed",
+  instantiate: () => THIRTY_DAYS,
+});
+
+export default timeAfterUpdateMustBeInstalledInjectable;

packages/core/src/features/application-update/child-features/force-user-to-update-when-too-long-time-since-update-was-downloaded/renderer/force-update-modal/time-since-update-was-downloaded.injectable.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import assert from "assert";
+import { computed } from "mobx";
+import moment from "moment";
+import updateDownloadedDateTimeInjectable from "../../../../common/update-downloaded-date-time/update-downloaded-date-time.injectable";
+import { reactiveNow } from "../../../../../../common/utils/reactive-now/reactive-now";
+
+const timeSinceUpdateWasDownloadedInjectable = getInjectable({
+  id: "time-since-update-was-downloaded",
+
+  instantiate: (di) => {
+    const updateDownloadedDateTime = di.inject(updateDownloadedDateTimeInjectable);
+
+    return computed(() => {
+      const currentTimestamp = reactiveNow();
+
+      const downloadedAt = updateDownloadedDateTime.value.get();
+
+      assert(downloadedAt);
+
+      return currentTimestamp - (moment(downloadedAt).unix() * 1000);
+    });
+  },
+});
+
+export default timeSinceUpdateWasDownloadedInjectable;

packages/core/src/features/application-update/child-features/periodical-checking-of-updates/__snapshots__/periodical-checking-of-updates.test.ts.snap

@@ -0,0 +1,286 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`periodical checking of updates given updater is enabled and configuration exists, when started renders 1`] = `
+<body>
+  <div>
+    <div
+      class="ClusterManager"
+    >
+      <div
+        class="topBar"
+      >
+        <div
+          class="items"
+        >
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="home-button"
+            >
+              <span
+                class="icon"
+                data-icon-name="home"
+              >
+                home
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="history-back"
+            >
+              <span
+                class="icon"
+                data-icon-name="arrow_back"
+              >
+                arrow_back
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="history-forward"
+            >
+              <span
+                class="icon"
+                data-icon-name="arrow_forward"
+              >
+                arrow_forward
+              </span>
+            </i>
+          </div>
+          <div
+            class="separator"
+          />
+        </div>
+      </div>
+      <main>
+        <div
+          id="lens-views"
+        />
+        <div
+          class="flex justify-center Welcome align-center"
+          data-testid="welcome-page"
+        >
+          <div
+            data-testid="welcome-banner-container"
+            style="width: 320px;"
+          >
+            <i
+              class="Icon logo svg focusable"
+            >
+              <span
+                class="icon"
+              />
+            </i>
+            <div
+              class="flex justify-center"
+            >
+              <div
+                data-testid="welcome-text-container"
+                style="width: 320px;"
+              >
+                <h2>
+                  Welcome to some-product-name!
+                </h2>
+                <p>
+                  To get you started we have auto-detected your clusters in your
+                   
+                  kubeconfig file and added them to the catalog, your centralized
+                   
+                  view for managing all your cloud-native resources.
+                  <br />
+                  <br />
+                  If you have any questions or feedback, please join our 
+                  <a
+                    class="link"
+                    href="https://k8slens.dev/slack.html"
+                    rel="noreferrer"
+                    target="_blank"
+                  >
+                    Lens Community slack channel
+                  </a>
+                  .
+                </p>
+                <ul
+                  class="block"
+                  data-testid="welcome-menu-container"
+                  style="width: 320px;"
+                >
+                  <li
+                    class="flex grid-12"
+                  >
+                    <i
+                      class="Icon box col-1 material focusable"
+                    >
+                      <span
+                        class="icon"
+                        data-icon-name="view_list"
+                      >
+                        view_list
+                      </span>
+                    </i>
+                    <a
+                      class="box col-10"
+                    >
+                      Browse Clusters in Catalog
+                    </a>
+                    <i
+                      class="Icon box col-1 material focusable"
+                    >
+                      <span
+                        class="icon"
+                        data-icon-name="navigate_next"
+                      >
+                        navigate_next
+                      </span>
+                    </i>
+                  </li>
+                </ul>
+              </div>
+            </div>
+          </div>
+        </div>
+      </main>
+      <div
+        class="HotbarMenu flex column"
+      >
+        <div
+          class="HotbarItems flex column gaps"
+        >
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="0"
+          >
+            <div
+              style="z-index: 12; position: absolute;"
+            >
+              <div
+                class="HotbarIcon contextMenuAvailable"
+              >
+                <div
+                  class="Avatar rounded disabled avatar"
+                  id="hotbarIcon-hotbar-icon-catalog-entity"
+                  style="width: 40px; height: 40px; background: rgb(5, 1, 130);"
+                >
+                  Ca
+                </div>
+              </div>
+            </div>
+          </div>
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="1"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="2"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="3"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="4"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="5"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="6"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="7"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="8"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="9"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="10"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="11"
+          />
+        </div>
+        <div
+          class="HotbarSelector"
+        >
+          <i
+            class="Icon Icon previous material interactive focusable"
+            tabindex="0"
+          >
+            <span
+              class="icon"
+              data-icon-name="arrow_left"
+            >
+              arrow_left
+            </span>
+          </i>
+          <div
+            class="HotbarIndex"
+          >
+            <div
+              class="badge Badge small clickable"
+              id="hotbarIndex"
+            >
+              1
+            </div>
+          </div>
+          <i
+            class="Icon material interactive focusable"
+            tabindex="0"
+          >
+            <span
+              class="icon"
+              data-icon-name="arrow_right"
+            >
+              arrow_right
+            </span>
+          </i>
+        </div>
+      </div>
+      <div
+        class="StatusBar"
+        data-testid="status-bar"
+      >
+        <div
+          class="leftSide"
+          data-testid="status-bar-left"
+        />
+        <div
+          class="rightSide"
+          data-testid="status-bar-right"
+        />
+      </div>
+    </div>
+    <div
+      class="Notifications flex column align-flex-end"
+    />
+  </div>
+</body>
+`;

packages/core/src/features/application-update/child-features/periodical-checking-of-updates/main/periodical-check-for-updates.global-override-for-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 periodicalCheckForUpdatesInjectable from "./periodical-check-for-updates.injectable";
+import { getGlobalOverride } from "../../../../../common/test-utils/get-global-override";
+
+export default getGlobalOverride(periodicalCheckForUpdatesInjectable, () => ({
+  start: () => {},
+  stop: () => {},
+  started: false,
+}));

packages/core/src/features/application-update/child-features/periodical-checking-of-updates/main/periodical-check-for-updates.injectable.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 { getStartableStoppable } from "../../../../../common/utils/get-startable-stoppable";
+import processCheckingForUpdatesInjectable from "../../../main/process-checking-for-updates.injectable";
+import withOrphanPromiseInjectable from "../../../../../common/utils/with-orphan-promise/with-orphan-promise.injectable";
+
+const TWO_HOURS = 1000 * 60 * 60 * 2;
+
+const periodicalCheckForUpdatesInjectable = getInjectable({
+  id: "periodical-check-for-updates",
+
+  instantiate: (di) => {
+    const withOrphanPromise = di.inject(withOrphanPromiseInjectable);
+    const processCheckingForUpdates = withOrphanPromise(di.inject(processCheckingForUpdatesInjectable));
+
+    return getStartableStoppable("periodical-check-for-updates", () => {
+      processCheckingForUpdates("periodic");
+
+      const intervalId = setInterval(() => {
+        processCheckingForUpdates("periodic");
+      }, TWO_HOURS);
+
+      return () => {
+        clearInterval(intervalId);
+      };
+    });
+  },
+
+  causesSideEffects: true,
+});
+
+export default periodicalCheckForUpdatesInjectable;

packages/core/src/features/application-update/child-features/periodical-checking-of-updates/main/start-checking-for-updates.injectable.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import periodicalCheckForUpdatesInjectable from "./periodical-check-for-updates.injectable";
+import updatingIsEnabledInjectable from "../../../main/updating-is-enabled/updating-is-enabled.injectable";
+import { afterApplicationIsLoadedInjectionToken } from "../../../../../main/start-main-application/runnable-tokens/after-application-is-loaded-injection-token";
+
+const startCheckingForUpdatesInjectable = getInjectable({
+  id: "start-checking-for-updates",
+
+  instantiate: (di) => {
+    const periodicalCheckForUpdates = di.inject(periodicalCheckForUpdatesInjectable);
+    const updatingIsEnabled = di.inject(updatingIsEnabledInjectable);
+
+    return {
+      id: "start-checking-for-updates",
+      run: () => {
+        if (updatingIsEnabled && !periodicalCheckForUpdates.started) {
+          periodicalCheckForUpdates.start();
+        }
+      },
+    };
+  },
+
+  injectionToken: afterApplicationIsLoadedInjectionToken,
+});
+
+export default startCheckingForUpdatesInjectable;

packages/core/src/features/application-update/child-features/periodical-checking-of-updates/main/stop-checking-for-updates.injectable.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import periodicalCheckForUpdatesInjectable from "./periodical-check-for-updates.injectable";
+import { beforeQuitOfBackEndInjectionToken } from "../../../../../main/start-main-application/runnable-tokens/before-quit-of-back-end-injection-token";
+
+const stopCheckingForUpdatesInjectable = getInjectable({
+  id: "stop-checking-for-updates",
+
+  instantiate: (di) => {
+    const periodicalCheckForUpdates = di.inject(periodicalCheckForUpdatesInjectable);
+
+    return {
+      id: "stop-checking-for-updates",
+      run: () => {
+        if (periodicalCheckForUpdates.started) {
+          periodicalCheckForUpdates.stop();
+        }
+
+        return undefined;
+      },
+    };
+  },
+
+  injectionToken: beforeQuitOfBackEndInjectionToken,
+});
+
+export default stopCheckingForUpdatesInjectable;

packages/core/src/features/application-update/child-features/periodical-checking-of-updates/periodical-checking-of-updates.test.ts

@@ -0,0 +1,116 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { ApplicationBuilder } from "../../../../renderer/components/test-utils/get-application-builder";
+import { getApplicationBuilder } from "../../../../renderer/components/test-utils/get-application-builder";
+import type { RenderResult } from "@testing-library/react";
+import electronUpdaterIsActiveInjectable from "../../../../main/electron-app/features/electron-updater-is-active.injectable";
+import publishIsConfiguredInjectable from "../../main/updating-is-enabled/publish-is-configured/publish-is-configured.injectable";
+import processCheckingForUpdatesInjectable from "../../main/process-checking-for-updates.injectable";
+import periodicalCheckForUpdatesInjectable from "./main/periodical-check-for-updates.injectable";
+import { advanceFakeTime, testUsingFakeTime } from "../../../../common/test-utils/use-fake-time";
+
+const ENOUGH_TIME = 1000 * 60 * 60 * 2;
+
+describe("periodical checking of updates", () => {
+  let builder: ApplicationBuilder;
+  let processCheckingForUpdatesMock: jest.Mock;
+
+  beforeEach(() => {
+    testUsingFakeTime("2015-10-21T07:28:00Z");
+
+    builder = getApplicationBuilder();
+
+    builder.beforeApplicationStart((mainDi) => {
+      mainDi.unoverride(periodicalCheckForUpdatesInjectable);
+      mainDi.permitSideEffects(periodicalCheckForUpdatesInjectable);
+
+      processCheckingForUpdatesMock = jest.fn();
+
+      mainDi.override(
+        processCheckingForUpdatesInjectable,
+        () => processCheckingForUpdatesMock,
+      );
+    });
+  });
+
+  describe("given updater is enabled and configuration exists, when started", () => {
+    let rendered: RenderResult;
+
+    beforeEach(async () => {
+      builder.beforeApplicationStart((mainDi) => {
+        mainDi.override(electronUpdaterIsActiveInjectable, () => true);
+        mainDi.override(publishIsConfiguredInjectable, () => true);
+      });
+
+      rendered = await builder.render();
+    });
+
+    it("renders", () => {
+      expect(rendered.baseElement).toMatchSnapshot();
+    });
+
+    it("checks for updates", () => {
+      expect(processCheckingForUpdatesMock).toHaveBeenCalled();
+    });
+
+    it("when just not enough time passes, does not check for updates again automatically yet", () => {
+      processCheckingForUpdatesMock.mockClear();
+
+      advanceFakeTime(ENOUGH_TIME - 1);
+
+      expect(processCheckingForUpdatesMock).not.toHaveBeenCalled();
+    });
+
+    it("when just enough time passes, checks for updates again automatically", () => {
+      processCheckingForUpdatesMock.mockClear();
+
+      advanceFakeTime(ENOUGH_TIME);
+
+      expect(processCheckingForUpdatesMock).toHaveBeenCalled();
+    });
+  });
+
+  describe("given updater is enabled but no configuration exist, when started", () => {
+    beforeEach(async () => {
+      builder.beforeApplicationStart((mainDi) => {
+        mainDi.override(electronUpdaterIsActiveInjectable, () => true);
+        mainDi.override(publishIsConfiguredInjectable, () => false);
+      });
+
+      await builder.render();
+    });
+
+    it("does not check for updates", () => {
+      expect(processCheckingForUpdatesMock).not.toHaveBeenCalled();
+    });
+
+    it("when time passes, never checks for updates", () => {
+      jest.runOnlyPendingTimers();
+
+      expect(processCheckingForUpdatesMock).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("given updater is not enabled but and configuration exist, when started", () => {
+    beforeEach(async () => {
+      builder.beforeApplicationStart((mainDi) => {
+        mainDi.override(electronUpdaterIsActiveInjectable, () => false);
+        mainDi.override(publishIsConfiguredInjectable, () => true);
+      });
+
+      await builder.render();
+    });
+
+    it("does not check for updates", () => {
+      expect(processCheckingForUpdatesMock).not.toHaveBeenCalled();
+    });
+
+    it("when time passes, never checks for updates", () => {
+      jest.runOnlyPendingTimers();
+
+      expect(processCheckingForUpdatesMock).not.toHaveBeenCalled();
+    });
+  });
+});

packages/core/src/features/application-update/child-features/preferences/renderer/update-channel/update-channel-preference-block.injectable.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { preferenceItemInjectionToken } from "../../../../../preferences/renderer/preference-items/preference-item-injection-token";
+import { UpdateChannel } from "./update-channel";
+
+const updateChannelPreferenceBlockInjectable = getInjectable({
+  id: "update-channel-preference-item",
+
+  instantiate: () => ({
+    kind: "block" as const,
+    id: "update-channel",
+    parentId: "application-page",
+    orderNumber: 50,
+    Component: UpdateChannel,
+  }),
+
+  injectionToken: preferenceItemInjectionToken,
+});
+
+export default updateChannelPreferenceBlockInjectable;

packages/core/src/features/application-update/child-features/preferences/renderer/update-channel/update-channel.tsx

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import React from "react";
+import { SubTitle } from "../../../../../../renderer/components/layout/sub-title";
+import { withInjectables } from "@ogre-tools/injectable-react";
+import { Select } from "../../../../../../renderer/components/select";
+import { updateChannels } from "../../../../common/update-channels";
+import type { SelectedUpdateChannel } from "../../../../common/selected-update-channel/selected-update-channel.injectable";
+import selectedUpdateChannelInjectable from "../../../../common/selected-update-channel/selected-update-channel.injectable";
+import { pipeline } from "@ogre-tools/fp";
+import { map, toPairs } from "lodash/fp";
+import { observer } from "mobx-react";
+
+interface Dependencies {
+  selectedUpdateChannel: SelectedUpdateChannel;
+}
+
+const updateChannelOptions = pipeline(
+  toPairs(updateChannels),
+
+  map(([, channel]) => ({
+    value: channel.id,
+    label: channel.label,
+  })),
+);
+
+
+const NonInjectedUpdateChannel = observer(({ selectedUpdateChannel }: Dependencies) => (
+  <section id="update-channel">
+    <SubTitle title="Update Channel" />
+    <Select
+      id="update-channel-input"
+      options={updateChannelOptions}
+      value={selectedUpdateChannel.value.get().id}
+      onChange={(selected) => selectedUpdateChannel.setValue(selected?.value)}
+      themeName="lens"
+    />
+  </section>
+));
+
+export const UpdateChannel = withInjectables<Dependencies>(
+  NonInjectedUpdateChannel,
+
+  {
+    getProps: (di) => ({
+      selectedUpdateChannel: di.inject(selectedUpdateChannelInjectable),
+    }),
+  },
+);

packages/core/src/features/application-update/child-features/selection-of-update-stability/__snapshots__/selection-of-update-stability.test.ts.snap

@@ -0,0 +1,286 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`selection of update stability when started renders 1`] = `
+<body>
+  <div>
+    <div
+      class="ClusterManager"
+    >
+      <div
+        class="topBar"
+      >
+        <div
+          class="items"
+        >
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="home-button"
+            >
+              <span
+                class="icon"
+                data-icon-name="home"
+              >
+                home
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="history-back"
+            >
+              <span
+                class="icon"
+                data-icon-name="arrow_back"
+              >
+                arrow_back
+              </span>
+            </i>
+          </div>
+          <div
+            class="size-sm"
+          />
+          <div
+            class="preventedDragging"
+          >
+            <i
+              class="Icon material interactive disabled focusable"
+              data-testid="history-forward"
+            >
+              <span
+                class="icon"
+                data-icon-name="arrow_forward"
+              >
+                arrow_forward
+              </span>
+            </i>
+          </div>
+          <div
+            class="separator"
+          />
+        </div>
+      </div>
+      <main>
+        <div
+          id="lens-views"
+        />
+        <div
+          class="flex justify-center Welcome align-center"
+          data-testid="welcome-page"
+        >
+          <div
+            data-testid="welcome-banner-container"
+            style="width: 320px;"
+          >
+            <i
+              class="Icon logo svg focusable"
+            >
+              <span
+                class="icon"
+              />
+            </i>
+            <div
+              class="flex justify-center"
+            >
+              <div
+                data-testid="welcome-text-container"
+                style="width: 320px;"
+              >
+                <h2>
+                  Welcome to some-product-name!
+                </h2>
+                <p>
+                  To get you started we have auto-detected your clusters in your
+                   
+                  kubeconfig file and added them to the catalog, your centralized
+                   
+                  view for managing all your cloud-native resources.
+                  <br />
+                  <br />
+                  If you have any questions or feedback, please join our 
+                  <a
+                    class="link"
+                    href="https://k8slens.dev/slack.html"
+                    rel="noreferrer"
+                    target="_blank"
+                  >
+                    Lens Community slack channel
+                  </a>
+                  .
+                </p>
+                <ul
+                  class="block"
+                  data-testid="welcome-menu-container"
+                  style="width: 320px;"
+                >
+                  <li
+                    class="flex grid-12"
+                  >
+                    <i
+                      class="Icon box col-1 material focusable"
+                    >
+                      <span
+                        class="icon"
+                        data-icon-name="view_list"
+                      >
+                        view_list
+                      </span>
+                    </i>
+                    <a
+                      class="box col-10"
+                    >
+                      Browse Clusters in Catalog
+                    </a>
+                    <i
+                      class="Icon box col-1 material focusable"
+                    >
+                      <span
+                        class="icon"
+                        data-icon-name="navigate_next"
+                      >
+                        navigate_next
+                      </span>
+                    </i>
+                  </li>
+                </ul>
+              </div>
+            </div>
+          </div>
+        </div>
+      </main>
+      <div
+        class="HotbarMenu flex column"
+      >
+        <div
+          class="HotbarItems flex column gaps"
+        >
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="0"
+          >
+            <div
+              style="z-index: 12; position: absolute;"
+            >
+              <div
+                class="HotbarIcon contextMenuAvailable"
+              >
+                <div
+                  class="Avatar rounded disabled avatar"
+                  id="hotbarIcon-hotbar-icon-catalog-entity"
+                  style="width: 40px; height: 40px; background: rgb(5, 1, 130);"
+                >
+                  Ca
+                </div>
+              </div>
+            </div>
+          </div>
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="1"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="2"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="3"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="4"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="5"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="6"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="7"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="8"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="9"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="10"
+          />
+          <div
+            class="HotbarCell isDraggingOwner animateDown"
+            index="11"
+          />
+        </div>
+        <div
+          class="HotbarSelector"
+        >
+          <i
+            class="Icon Icon previous material interactive focusable"
+            tabindex="0"
+          >
+            <span
+              class="icon"
+              data-icon-name="arrow_left"
+            >
+              arrow_left
+            </span>
+          </i>
+          <div
+            class="HotbarIndex"
+          >
+            <div
+              class="badge Badge small clickable"
+              id="hotbarIndex"
+            >
+              1
+            </div>
+          </div>
+          <i
+            class="Icon material interactive focusable"
+            tabindex="0"
+          >
+            <span
+              class="icon"
+              data-icon-name="arrow_right"
+            >
+              arrow_right
+            </span>
+          </i>
+        </div>
+      </div>
+      <div
+        class="StatusBar"
+        data-testid="status-bar"
+      >
+        <div
+          class="leftSide"
+          data-testid="status-bar-left"
+        />
+        <div
+          class="rightSide"
+          data-testid="status-bar-right"
+        />
+      </div>
+    </div>
+    <div
+      class="Notifications flex column align-flex-end"
+    />
+  </div>
+</body>
+`;

packages/core/src/features/application-update/child-features/selection-of-update-stability/selection-of-update-stability.test.ts

@@ -0,0 +1,320 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { ApplicationBuilder } from "../../../../renderer/components/test-utils/get-application-builder";
+import { getApplicationBuilder } from "../../../../renderer/components/test-utils/get-application-builder";
+import quitAndInstallUpdateInjectable from "../../main/quit-and-install-update.injectable";
+import type { RenderResult } from "@testing-library/react";
+import electronUpdaterIsActiveInjectable from "../../../../main/electron-app/features/electron-updater-is-active.injectable";
+import publishIsConfiguredInjectable from "../../main/updating-is-enabled/publish-is-configured/publish-is-configured.injectable";
+import type { CheckForPlatformUpdates } from "../../main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable";
+import checkForPlatformUpdatesInjectable from "../../main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable";
+import type { AsyncFnMock } from "@async-fn/jest";
+import asyncFn from "@async-fn/jest";
+import type { UpdateChannel, ReleaseChannel } from "../../common/update-channels";
+import { updateChannels } from "../../common/update-channels";
+import type { DownloadPlatformUpdate } from "../../main/download-update/download-platform-update/download-platform-update.injectable";
+import downloadPlatformUpdateInjectable from "../../main/download-update/download-platform-update/download-platform-update.injectable";
+import selectedUpdateChannelInjectable from "../../common/selected-update-channel/selected-update-channel.injectable";
+import type { IComputedValue } from "mobx";
+import setUpdateOnQuitInjectable from "../../../../main/electron-app/features/set-update-on-quit.injectable";
+import showInfoNotificationInjectable from "../../../../renderer/components/notifications/show-info-notification.injectable";
+import processCheckingForUpdatesInjectable from "../../main/process-checking-for-updates.injectable";
+import type { DiContainer } from "@ogre-tools/injectable";
+import getBuildVersionInjectable
+  from "../../../../main/vars/build-version/get-build-version.injectable";
+
+describe("selection of update stability", () => {
+  let builder: ApplicationBuilder;
+  let quitAndInstallUpdateMock: jest.Mock;
+  let checkForPlatformUpdatesMock: AsyncFnMock<CheckForPlatformUpdates>;
+  let downloadPlatformUpdateMock: AsyncFnMock<DownloadPlatformUpdate>;
+  let setUpdateOnQuitMock: jest.Mock;
+  let showInfoNotificationMock: jest.Mock;
+  let mainDi: DiContainer;
+
+  beforeEach(() => {
+    builder = getApplicationBuilder();
+
+    builder.beforeApplicationStart((mainDi) => {
+      quitAndInstallUpdateMock = jest.fn();
+      checkForPlatformUpdatesMock = asyncFn();
+      downloadPlatformUpdateMock = asyncFn();
+      setUpdateOnQuitMock = jest.fn();
+
+      mainDi.override(setUpdateOnQuitInjectable, () => setUpdateOnQuitMock);
+
+      mainDi.override(
+        checkForPlatformUpdatesInjectable,
+        () => checkForPlatformUpdatesMock,
+      );
+
+      mainDi.override(
+        downloadPlatformUpdateInjectable,
+        () => downloadPlatformUpdateMock,
+      );
+
+      mainDi.override(
+        quitAndInstallUpdateInjectable,
+        () => quitAndInstallUpdateMock,
+      );
+
+      mainDi.override(electronUpdaterIsActiveInjectable, () => true);
+      mainDi.override(publishIsConfiguredInjectable, () => true);
+    });
+
+    builder.beforeWindowStart((windowDi) => {
+      showInfoNotificationMock = jest.fn(() => () => {});
+
+      windowDi.override(showInfoNotificationInjectable, () => showInfoNotificationMock);
+    });
+
+    mainDi = builder.mainDi;
+  });
+
+  describe("when started", () => {
+    let rendered: RenderResult;
+    let processCheckingForUpdates: (source: string) => Promise<{ updateIsReadyToBeInstalled: boolean }>;
+
+    beforeEach(async () => {
+      rendered = await builder.render();
+
+      processCheckingForUpdates = mainDi.inject(processCheckingForUpdatesInjectable);
+    });
+
+    it("renders", () => {
+      expect(rendered.baseElement).toMatchSnapshot();
+    });
+
+    describe('given update channel "alpha" is selected, when checking for updates', () => {
+      let selectedUpdateChannel: {
+        value: IComputedValue<UpdateChannel>;
+        setValue: (channelId: ReleaseChannel) => void;
+      };
+
+      beforeEach(() => {
+        selectedUpdateChannel = mainDi.inject(
+          selectedUpdateChannelInjectable,
+        );
+
+        selectedUpdateChannel.setValue(updateChannels.alpha.id);
+
+        processCheckingForUpdates("irrelevant");
+      });
+
+      it('checks updates from update channel "alpha"', () => {
+        expect(checkForPlatformUpdatesMock).toHaveBeenCalledWith(
+          updateChannels.alpha,
+          { allowDowngrade: false },
+        );
+      });
+
+      it("when update is discovered, does not check update from other update channels", async () => {
+        checkForPlatformUpdatesMock.mockClear();
+
+        await checkForPlatformUpdatesMock.resolve({
+          updateWasDiscovered: true,
+          version: "some-version",
+        });
+
+        expect(checkForPlatformUpdatesMock).not.toHaveBeenCalled();
+      });
+
+      describe("when no update is discovered", () => {
+        beforeEach(async () => {
+          checkForPlatformUpdatesMock.mockClear();
+
+          await checkForPlatformUpdatesMock.resolve({
+            updateWasDiscovered: false,
+          });
+        });
+
+        it('checks updates from update channel "beta"', () => {
+          expect(checkForPlatformUpdatesMock).toHaveBeenCalledWith(
+            updateChannels.beta,
+            { allowDowngrade: false },
+          );
+        });
+
+        it("when update is discovered, does not check update from other update channels", async () => {
+          checkForPlatformUpdatesMock.mockClear();
+
+          await checkForPlatformUpdatesMock.resolve({
+            updateWasDiscovered: true,
+            version: "some-version",
+          });
+
+          expect(checkForPlatformUpdatesMock).not.toHaveBeenCalled();
+        });
+
+        describe("when no update is discovered again", () => {
+          beforeEach(async () => {
+            checkForPlatformUpdatesMock.mockClear();
+
+            await checkForPlatformUpdatesMock.resolve({
+              updateWasDiscovered: false,
+            });
+          });
+
+          it('finally checks updates from update channel "latest"', () => {
+            expect(checkForPlatformUpdatesMock).toHaveBeenCalledWith(
+              updateChannels.latest,
+              { allowDowngrade: false },
+            );
+          });
+
+          it("when update is discovered, does not check update from other update channels", async () => {
+            checkForPlatformUpdatesMock.mockClear();
+
+            await checkForPlatformUpdatesMock.resolve({
+              updateWasDiscovered: true,
+              version: "some-version",
+            });
+
+            expect(checkForPlatformUpdatesMock).not.toHaveBeenCalled();
+          });
+        });
+      });
+    });
+
+    describe('given update channel "beta" is selected', () => {
+      let selectedUpdateChannel: {
+        value: IComputedValue<UpdateChannel>;
+        setValue: (channelId: ReleaseChannel) => void;
+      };
+
+      beforeEach(() => {
+        selectedUpdateChannel = mainDi.inject(
+          selectedUpdateChannelInjectable,
+        );
+
+        selectedUpdateChannel.setValue(updateChannels.beta.id);
+      });
+
+      describe("when checking for updates", () => {
+        beforeEach(() => {
+          processCheckingForUpdates("irrelevant");
+        });
+
+        describe('when update from "beta" channel is discovered', () => {
+          beforeEach(async () => {
+            await checkForPlatformUpdatesMock.resolve({
+              updateWasDiscovered: true,
+              version: "some-beta-version",
+            });
+          });
+
+          describe("when update is downloaded", () => {
+            beforeEach(async () => {
+              await downloadPlatformUpdateMock.resolve({ downloadWasSuccessful: true });
+            });
+
+            it("when user would close the application, installs the update", () => {
+              expect(setUpdateOnQuitMock).toHaveBeenLastCalledWith(true);
+            });
+
+            it('given user changes update channel to "latest", when user would close the application, does not install the update for not being stable enough', () => {
+              selectedUpdateChannel.setValue(updateChannels.latest.id);
+
+              expect(setUpdateOnQuitMock).toHaveBeenLastCalledWith(false);
+            });
+
+            it('given user changes update channel to "alpha", when user would close the application, installs the update for being stable enough', () => {
+              selectedUpdateChannel.setValue(updateChannels.alpha.id);
+
+              expect(setUpdateOnQuitMock).toHaveBeenLastCalledWith(true);
+            });
+          });
+        });
+      });
+    });
+  });
+
+  it("given valid update channel selection is stored, when checking for updates, checks for updates from the update channel", async () => {
+    await builder.render();
+
+    // TODO: Switch to more natural way of setting initial value
+    // TODO: UserStore is currently responsible for getting and setting initial value
+    mainDi.inject(selectedUpdateChannelInjectable).setValue(updateChannels.beta.id);
+
+    const processCheckingForUpdates = mainDi.inject(processCheckingForUpdatesInjectable);
+
+    processCheckingForUpdates("irrelevant");
+
+    expect(checkForPlatformUpdatesMock).toHaveBeenCalledWith(updateChannels.beta, expect.any(Object));
+  });
+
+  it("given invalid update channel selection is stored, when checking for updates, checks for updates from the update channel", async () => {
+    await builder.render();
+
+    // TODO: Switch to more natural way of setting initial value
+    // TODO: UserStore is currently responsible for getting and setting initial value
+    mainDi.inject(selectedUpdateChannelInjectable).setValue("something-invalid" as ReleaseChannel);
+
+    const processCheckingForUpdates = mainDi.inject(processCheckingForUpdatesInjectable);
+
+    processCheckingForUpdates("irrelevant");
+
+    expect(checkForPlatformUpdatesMock).toHaveBeenCalledWith(updateChannels.latest, expect.any(Object));
+  });
+
+  it('given no update channel selection is stored and currently using stable release, when user checks for updates, checks for updates from "latest" update channel by default', async () => {
+    builder.beforeApplicationStart((mainDi) => {
+      mainDi.override(getBuildVersionInjectable, () => () => "1.0.0");
+    });
+
+    await builder.render();
+
+    const processCheckingForUpdates = mainDi.inject(processCheckingForUpdatesInjectable);
+
+    processCheckingForUpdates("irrelevant");
+
+    expect(checkForPlatformUpdatesMock).toHaveBeenCalledWith(
+      updateChannels.latest,
+      { allowDowngrade: false },
+    );
+  });
+
+  it('given no update channel selection is stored and currently using alpha release, when checking for updates, checks for updates from "alpha" channel', async () => {
+    builder.beforeApplicationStart((mainDi) => {
+      mainDi.override(getBuildVersionInjectable, () => () => "1.0.0-alpha");
+    });
+
+    await builder.render();
+
+    const processCheckingForUpdates = mainDi.inject(processCheckingForUpdatesInjectable);
+
+    processCheckingForUpdates("irrelevant");
+
+    expect(checkForPlatformUpdatesMock).toHaveBeenCalledWith(updateChannels.alpha, expect.any(Object));
+  });
+
+  it('given no update channel selection is stored and currently using beta release, when checking for updates, checks for updates from "beta" channel', async () => {
+    builder.beforeApplicationStart((mainDi) => {
+      mainDi.override(getBuildVersionInjectable, () => () => "1.0.0-beta");
+    });
+
+    await builder.render();
+
+    const processCheckingForUpdates = mainDi.inject(processCheckingForUpdatesInjectable);
+
+    processCheckingForUpdates("irrelevant");
+
+    expect(checkForPlatformUpdatesMock).toHaveBeenCalledWith(updateChannels.beta, expect.any(Object));
+  });
+
+  it("given update channel selection is stored and currently using prerelease, when checking for updates, checks for updates from stored channel", async () => {
+    await builder.render();
+
+    // TODO: Switch to more natural way of setting initial value
+    // TODO: UserStore is currently responsible for getting and setting initial value
+    mainDi.inject(selectedUpdateChannelInjectable).setValue(updateChannels.beta.id);
+
+    const processCheckingForUpdates = mainDi.inject(processCheckingForUpdatesInjectable);
+
+    processCheckingForUpdates("irrelevant");
+
+    expect(checkForPlatformUpdatesMock).toHaveBeenCalledWith(updateChannels.beta, expect.any(Object));
+  });
+});

packages/core/src/features/application-update/common/discovered-update-version/discovered-update-version.injectable.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 { getInjectable } from "@ogre-tools/injectable";
+import createSyncBoxInjectable from "../../../../common/utils/sync-box/create-sync-box.injectable";
+import type { UpdateChannel } from "../update-channels";
+import type { SyncBox } from "../../../../common/utils/sync-box/sync-box-injection-token";
+import { syncBoxInjectionToken } from "../../../../common/utils/sync-box/sync-box-injection-token";
+
+export type DiscoveredUpdateVersion = SyncBox<{ version: string; updateChannel: UpdateChannel } | null>;
+
+const discoveredUpdateVersionInjectable = getInjectable({
+  id: "discovered-update-version",
+
+  instantiate: (di) => {
+    const createSyncBox = di.inject(createSyncBoxInjectable);
+
+    return createSyncBox(
+      "discovered-update-version",
+      null,
+    ) as DiscoveredUpdateVersion;
+  },
+
+  injectionToken: syncBoxInjectionToken,
+});
+
+export default discoveredUpdateVersionInjectable;

packages/core/src/features/application-update/common/progress-of-update-download/progress-of-update-download.injectable.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import createSyncBoxInjectable from "../../../../common/utils/sync-box/create-sync-box.injectable";
+import type { SyncBox } from "../../../../common/utils/sync-box/sync-box-injection-token";
+import { syncBoxInjectionToken } from "../../../../common/utils/sync-box/sync-box-injection-token";
+
+export interface ProgressOfDownload {
+  percentage: number;
+  failed?: string;
+}
+
+export type ProgressOfUpdateDownload = SyncBox<ProgressOfDownload>;
+
+const progressOfUpdateDownloadInjectable = getInjectable({
+  id: "progress-of-update-download-state",
+
+  instantiate: (di) => {
+    const createSyncBox = di.inject(createSyncBoxInjectable);
+
+    return createSyncBox<ProgressOfDownload>("progress-of-update-download", { percentage: 0 });
+  },
+
+  injectionToken: syncBoxInjectionToken,
+});
+
+export default progressOfUpdateDownloadInjectable;

packages/core/src/features/application-update/common/restart-and-install-update-channel.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { MessageChannel } from "../../../common/utils/channel/message-channel-listener-injection-token";
+
+export type RestartAndInstallUpdateChannel = MessageChannel<void>;
+
+export const restartAndInstallUpdateChannel: RestartAndInstallUpdateChannel = {
+  id: "restart-and-install-update-channel",
+};

packages/core/src/features/application-update/common/selected-update-channel/default-update-channel.injectable.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import releaseChannelInjectable from "../../../../common/vars/release-channel.injectable";
+import { updateChannels } from "../update-channels";
+import { createInitializableState } from "../../../../common/initializable-state/create";
+
+const defaultUpdateChannelInjectable = createInitializableState({
+  id: "default-update-channel",
+  init: (di) => updateChannels[di.inject(releaseChannelInjectable).get()],
+});
+
+export default defaultUpdateChannelInjectable;

packages/core/src/features/application-update/common/selected-update-channel/selected-update-channel.injectable.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 { IComputedValue } from "mobx";
+import { action, computed, observable } from "mobx";
+import type { UpdateChannel, ReleaseChannel } from "../update-channels";
+import { updateChannels } from "../update-channels";
+import defaultUpdateChannelInjectable from "./default-update-channel.injectable";
+
+export interface SelectedUpdateChannel {
+  value: IComputedValue<UpdateChannel>;
+  setValue: (channelId?: ReleaseChannel) => void;
+}
+
+const selectedUpdateChannelInjectable = getInjectable({
+  id: "selected-update-channel",
+
+  instantiate: (di): SelectedUpdateChannel => {
+    const defaultUpdateChannel = di.inject(defaultUpdateChannelInjectable);
+    const state = observable.box<UpdateChannel>(undefined, { deep: false });
+
+    return {
+      value: computed(() => state.get() ?? defaultUpdateChannel.get()),
+
+      setValue: action((channelId) => {
+        const targetUpdateChannel =
+          channelId && updateChannels[channelId]
+            ? updateChannels[channelId]
+            : defaultUpdateChannel.get();
+
+        state.set(targetUpdateChannel);
+      }),
+    };
+  },
+});
+
+export default selectedUpdateChannelInjectable;

packages/core/src/features/application-update/common/update-channels.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+
+export type ReleaseChannel = "alpha" | "beta" | "latest";
+
+const latestChannel: UpdateChannel = {
+  id: "latest",
+  label: "Stable",
+  moreStableUpdateChannel: null,
+};
+
+const betaChannel: UpdateChannel = {
+  id: "beta",
+  label: "Beta",
+  moreStableUpdateChannel: latestChannel,
+};
+
+const alphaChannel: UpdateChannel = {
+  id: "alpha",
+  label: "Alpha",
+  moreStableUpdateChannel: betaChannel,
+};
+
+export const updateChannels = {
+  latest: latestChannel,
+  beta: betaChannel,
+  alpha: alphaChannel,
+};
+
+export interface UpdateChannel {
+  readonly id: ReleaseChannel;
+  readonly label: string;
+  readonly moreStableUpdateChannel: UpdateChannel | null;
+}

packages/core/src/features/application-update/common/update-downloaded-date-time/update-downloaded-date-time.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 createSyncBoxInjectable from "../../../../common/utils/sync-box/create-sync-box.injectable";
+import { syncBoxInjectionToken } from "../../../../common/utils/sync-box/sync-box-injection-token";
+
+const updateDownloadedDateTimeInjectable = getInjectable({
+  id: "update-downloaded-date-time",
+
+  instantiate: (di) => {
+    const createSyncBox = di.inject(createSyncBoxInjectable);
+
+    return createSyncBox<string | null>(
+      "update-downloaded-date-time",
+      null,
+    );
+  },
+
+  injectionToken: syncBoxInjectionToken,
+});
+
+export default updateDownloadedDateTimeInjectable;

packages/core/src/features/application-update/common/update-is-being-downloaded/update-is-being-downloaded.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 createSyncBoxInjectable from "../../../../common/utils/sync-box/create-sync-box.injectable";
+import type { SyncBox } from "../../../../common/utils/sync-box/sync-box-injection-token";
+import { syncBoxInjectionToken } from "../../../../common/utils/sync-box/sync-box-injection-token";
+
+export type UpdateIsBeingDownloaded = SyncBox<boolean>;
+
+const updateIsBeingDownloadedInjectable = getInjectable({
+  id: "update-is-being-downloaded",
+
+  instantiate: (di) => {
+    const createSyncBox = di.inject(createSyncBoxInjectable);
+
+    return createSyncBox("update-is-being-downloaded", false);
+  },
+
+  injectionToken: syncBoxInjectionToken,
+});
+
+export default updateIsBeingDownloadedInjectable;

packages/core/src/features/application-update/common/updates-are-being-discovered/updates-are-being-discovered.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 createSyncBoxInjectable from "../../../../common/utils/sync-box/create-sync-box.injectable";
+import type { SyncBox } from "../../../../common/utils/sync-box/sync-box-injection-token";
+import { syncBoxInjectionToken } from "../../../../common/utils/sync-box/sync-box-injection-token";
+
+export type UpdatesAreBeingDiscovered = SyncBox<boolean>;
+
+const updatesAreBeingDiscoveredInjectable = getInjectable({
+  id: "updates-are-being-discovered",
+
+  instantiate: (di) => {
+    const createSyncBox = di.inject(createSyncBoxInjectable);
+
+    return createSyncBox("updates-are-being-discovered", false);
+  },
+
+  injectionToken: syncBoxInjectionToken,
+});
+
+export default updatesAreBeingDiscoveredInjectable;

packages/core/src/features/application-update/downgrading-version-update.test.ts

@@ -0,0 +1,120 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
+import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
+import electronUpdaterIsActiveInjectable from "../../main/electron-app/features/electron-updater-is-active.injectable";
+import publishIsConfiguredInjectable from "./main/updating-is-enabled/publish-is-configured/publish-is-configured.injectable";
+import type { AsyncFnMock } from "@async-fn/jest";
+import asyncFn from "@async-fn/jest";
+import type { CheckForPlatformUpdates } from "./main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable";
+import checkForPlatformUpdatesInjectable from "./main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable";
+import processCheckingForUpdatesInjectable from "./main/process-checking-for-updates.injectable";
+import selectedUpdateChannelInjectable from "./common/selected-update-channel/selected-update-channel.injectable";
+import type { DiContainer } from "@ogre-tools/injectable";
+import { updateChannels } from "./common/update-channels";
+import getBuildVersionInjectable from "../../main/vars/build-version/get-build-version.injectable";
+
+describe("downgrading version update", () => {
+  let applicationBuilder: ApplicationBuilder;
+  let checkForPlatformUpdatesMock: AsyncFnMock<CheckForPlatformUpdates>;
+  let mainDi: DiContainer;
+
+  beforeEach(() => {
+    applicationBuilder = getApplicationBuilder();
+
+    applicationBuilder.beforeApplicationStart(mainDi => {
+      checkForPlatformUpdatesMock = asyncFn();
+
+      mainDi.override(
+        checkForPlatformUpdatesInjectable,
+        () => checkForPlatformUpdatesMock,
+      );
+
+      mainDi.override(electronUpdaterIsActiveInjectable, () => true);
+      mainDi.override(publishIsConfiguredInjectable, () => true);
+    });
+
+    mainDi = applicationBuilder.mainDi;
+  });
+
+  [
+    {
+      updateChannel: updateChannels.latest,
+      appVersion: "4.0.0",
+      downgradeIsAllowed: false,
+    },
+    {
+      updateChannel: updateChannels.beta,
+      appVersion: "4.0.0",
+      downgradeIsAllowed: false,
+    },
+    {
+      updateChannel: updateChannels.alpha,
+      appVersion: "4.0.0",
+      downgradeIsAllowed: false,
+    },
+    {
+      updateChannel: updateChannels.latest,
+      appVersion: "4.0.0-latest",
+      downgradeIsAllowed: false,
+    },
+    {
+      updateChannel: updateChannels.beta,
+      appVersion: "4.0.0-latest",
+      downgradeIsAllowed: false,
+    },
+    {
+      updateChannel: updateChannels.alpha,
+      appVersion: "4.0.0-latest",
+      downgradeIsAllowed: false,
+    },
+    {
+      updateChannel: updateChannels.latest,
+      appVersion: "4.0.0-beta",
+      downgradeIsAllowed: true,
+    },
+    {
+      updateChannel: updateChannels.beta,
+      appVersion: "4.0.0-beta",
+      downgradeIsAllowed: false,
+    },
+    {
+      updateChannel: updateChannels.alpha,
+      appVersion: "4.0.0-beta",
+      downgradeIsAllowed: false,
+    },
+    {
+      updateChannel: updateChannels.latest,
+      appVersion: "4.0.0-alpha",
+      downgradeIsAllowed: true,
+    },
+    {
+      updateChannel: updateChannels.beta,
+      appVersion: "4.0.0-alpha",
+      downgradeIsAllowed: false,
+    },
+    {
+      updateChannel: updateChannels.alpha,
+      appVersion: "4.0.0-alpha",
+      downgradeIsAllowed: false,
+    },
+  ].forEach(({ appVersion, updateChannel, downgradeIsAllowed }) => {
+    it(`given application version "${appVersion}" and update channel "${updateChannel.id}", when checking for updates, can${downgradeIsAllowed ? "": "not"} downgrade`, async () => {
+      mainDi.override(getBuildVersionInjectable, () => () => appVersion);
+
+      await applicationBuilder.render();
+
+      const selectedUpdateChannel = mainDi.inject(selectedUpdateChannelInjectable);
+
+      selectedUpdateChannel.setValue(updateChannel.id);
+
+      const processCheckingForUpdates = mainDi.inject(processCheckingForUpdatesInjectable);
+
+      processCheckingForUpdates("irrelevant");
+
+      expect(checkForPlatformUpdatesMock).toHaveBeenCalledWith(expect.any(Object), { allowDowngrade: downgradeIsAllowed });
+    });
+  });
+});

packages/core/src/features/application-update/installing-update.test.ts

@@ -0,0 +1,246 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
+import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
+import quitAndInstallUpdateInjectable from "./main/quit-and-install-update.injectable";
+import type { RenderResult } from "@testing-library/react";
+import electronUpdaterIsActiveInjectable from "../../main/electron-app/features/electron-updater-is-active.injectable";
+import publishIsConfiguredInjectable from "./main/updating-is-enabled/publish-is-configured/publish-is-configured.injectable";
+import type { CheckForPlatformUpdates } from "./main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable";
+import checkForPlatformUpdatesInjectable from "./main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable";
+import type { AsyncFnMock } from "@async-fn/jest";
+import asyncFn from "@async-fn/jest";
+import type { DownloadPlatformUpdate } from "./main/download-update/download-platform-update/download-platform-update.injectable";
+import downloadPlatformUpdateInjectable from "./main/download-update/download-platform-update/download-platform-update.injectable";
+import setUpdateOnQuitInjectable from "../../main/electron-app/features/set-update-on-quit.injectable";
+import processCheckingForUpdatesInjectable from "./main/process-checking-for-updates.injectable";
+import { testUsingFakeTime } from "../../common/test-utils/use-fake-time";
+import staticFilesDirectoryInjectable from "../../common/vars/static-files-directory.injectable";
+
+describe("installing update", () => {
+  let builder: ApplicationBuilder;
+  let quitAndInstallUpdateMock: jest.Mock;
+  let checkForPlatformUpdatesMock: AsyncFnMock<CheckForPlatformUpdates>;
+  let downloadPlatformUpdateMock: AsyncFnMock<DownloadPlatformUpdate>;
+  let setUpdateOnQuitMock: jest.Mock;
+
+  beforeEach(() => {
+    testUsingFakeTime("2015-10-21T07:28:00Z");
+
+    builder = getApplicationBuilder();
+
+    builder.beforeApplicationStart((mainDi) => {
+      quitAndInstallUpdateMock = jest.fn();
+      checkForPlatformUpdatesMock = asyncFn();
+      downloadPlatformUpdateMock = asyncFn();
+      setUpdateOnQuitMock = jest.fn();
+
+      mainDi.override(staticFilesDirectoryInjectable, () => "/some-static-files-directory");
+
+      mainDi.override(setUpdateOnQuitInjectable, () => setUpdateOnQuitMock);
+
+      mainDi.override(
+        checkForPlatformUpdatesInjectable,
+        () => checkForPlatformUpdatesMock,
+      );
+
+      mainDi.override(
+        downloadPlatformUpdateInjectable,
+        () => downloadPlatformUpdateMock,
+      );
+
+      mainDi.override(
+        quitAndInstallUpdateInjectable,
+        () => quitAndInstallUpdateMock,
+      );
+
+      mainDi.override(electronUpdaterIsActiveInjectable, () => true);
+      mainDi.override(publishIsConfiguredInjectable, () => true);
+    });
+  });
+
+  describe("when started", () => {
+    let rendered: RenderResult;
+    let processCheckingForUpdates: (source: string) => Promise<{ updateIsReadyToBeInstalled: boolean }>;
+
+    beforeEach(async () => {
+      rendered = await builder.render();
+
+      processCheckingForUpdates = builder.mainDi.inject(
+        processCheckingForUpdatesInjectable,
+      );
+    });
+
+    it("renders", () => {
+      expect(rendered.baseElement).toMatchSnapshot();
+    });
+
+    it("shows normal tray icon", () => {
+      expect(builder.tray.getIconPath()).toBe(
+        "/some-static-files-directory/build/tray/trayIconTemplate.png",
+      );
+    });
+
+    describe("when user checks for updates", () => {
+      beforeEach(() => {
+        processCheckingForUpdates("irrelevant");
+      });
+
+      it("checks for updates", () => {
+        expect(checkForPlatformUpdatesMock).toHaveBeenCalledWith(
+          expect.any(Object),
+          { allowDowngrade: false },
+        );
+      });
+
+      it("shows tray icon for checking for updates", () => {
+        expect(builder.tray.getIconPath()).toBe(
+          "/some-static-files-directory/build/tray/trayIconCheckingForUpdatesTemplate.png",
+        );
+      });
+
+      it("renders", () => {
+        expect(rendered.baseElement).toMatchSnapshot();
+      });
+
+      describe("when no new update is discovered", () => {
+        beforeEach(async () => {
+          await checkForPlatformUpdatesMock.resolve({
+            updateWasDiscovered: false,
+          });
+        });
+
+        it("shows tray icon for normal", () => {
+          expect(builder.tray.getIconPath()).toBe(
+            "/some-static-files-directory/build/tray/trayIconTemplate.png",
+          );
+        });
+
+        it("does not start downloading update", () => {
+          expect(downloadPlatformUpdateMock).not.toHaveBeenCalled();
+        });
+
+        it("renders", () => {
+          expect(rendered.baseElement).toMatchSnapshot();
+        });
+      });
+
+      describe("when new update is discovered", () => {
+        beforeEach(async () => {
+          await checkForPlatformUpdatesMock.resolve({
+            updateWasDiscovered: true,
+            version: "some-version",
+          });
+        });
+
+        it("starts downloading the update", () => {
+          expect(downloadPlatformUpdateMock).toHaveBeenCalled();
+        });
+
+        it("still shows tray icon for downloading", () => {
+          expect(builder.tray.getIconPath()).toBe(
+            "/some-static-files-directory/build/tray/trayIconCheckingForUpdatesTemplate.png",
+          );
+        });
+
+        it("renders", () => {
+          expect(rendered.baseElement).toMatchSnapshot();
+        });
+
+        describe("when download fails", () => {
+          beforeEach(async () => {
+            await downloadPlatformUpdateMock.resolve({ downloadWasSuccessful: false });
+          });
+
+          it("does not quit and install update yet", () => {
+            expect(quitAndInstallUpdateMock).not.toHaveBeenCalled();
+          });
+
+          it("still shows normal tray icon", () => {
+            expect(builder.tray.getIconPath()).toBe(
+              "/some-static-files-directory/build/tray/trayIconTemplate.png",
+            );
+          });
+
+          it("renders", () => {
+            expect(rendered.baseElement).toMatchSnapshot();
+          });
+        });
+
+        describe("when download succeeds", () => {
+          beforeEach(async () => {
+            await downloadPlatformUpdateMock.resolve({ downloadWasSuccessful: true });
+          });
+
+          it("does not quit and install update yet", () => {
+            expect(quitAndInstallUpdateMock).not.toHaveBeenCalled();
+          });
+
+          it("shows tray icon for update being available", () => {
+            expect(builder.tray.getIconPath()).toBe(
+              "/some-static-files-directory/build/tray/trayIconUpdateAvailableTemplate.png",
+            );
+          });
+
+          it("renders", () => {
+            expect(rendered.baseElement).toMatchSnapshot();
+          });
+
+          describe("given checking for updates again", () => {
+            beforeEach(() => {
+              downloadPlatformUpdateMock.mockClear();
+
+              processCheckingForUpdates("irrelevant");
+            });
+
+            it("shows tray icon for checking for updates", () => {
+              expect(builder.tray.getIconPath()).toBe(
+                "/some-static-files-directory/build/tray/trayIconCheckingForUpdatesTemplate.png",
+              );
+            });
+
+            describe("when check resolves with same update that is already downloaded", () => {
+              beforeEach(async () => {
+                await checkForPlatformUpdatesMock.resolve({
+                  updateWasDiscovered: true,
+                  version: "some-version",
+                });
+              });
+
+              it("does not re-download the update", () => {
+                expect(downloadPlatformUpdateMock).not.toHaveBeenCalled();
+              });
+
+              it("shows tray icon for update being available", () => {
+                expect(builder.tray.getIconPath()).toBe(
+                  "/some-static-files-directory/build/tray/trayIconUpdateAvailableTemplate.png",
+                );
+              });
+            });
+
+            describe("when check resolves with different update that was previously downloaded", () => {
+              beforeEach(async () => {
+                await checkForPlatformUpdatesMock.resolve({
+                  updateWasDiscovered: true,
+                  version: "some-other-version",
+                });
+              });
+
+              it("downloads the update", () => {
+                expect(downloadPlatformUpdateMock).toHaveBeenCalled();
+              });
+
+              it("shows tray icon for downloading update", () => {
+                expect(builder.tray.getIconPath()).toBe(
+                  "/some-static-files-directory/build/tray/trayIconCheckingForUpdatesTemplate.png",
+                );
+              });
+            });
+          });
+        });
+      });
+    });
+  });
+});

packages/core/src/features/application-update/main/check-for-updates/check-for-platform-updates/check-for-platform-updates.global-override-for-injectable.ts

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

packages/core/src/features/application-update/main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable.ts

@@ -0,0 +1,60 @@
+/**
+ * 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 electronUpdaterInjectable from "../../../../../main/electron-app/features/electron-updater.injectable";
+import type { UpdateChannel } from "../../../common/update-channels";
+import loggerInjectable from "../../../../../common/logger.injectable";
+import type { UpdateCheckResult } from "electron-updater";
+
+export type CheckForUpdatesResult = {
+  updateWasDiscovered: false;
+} | {
+  updateWasDiscovered: true;
+  version: string;
+};
+
+export type CheckForPlatformUpdates = (updateChannel: UpdateChannel, opts: { allowDowngrade: boolean }) => Promise<CheckForUpdatesResult>;
+
+const checkForPlatformUpdatesInjectable = getInjectable({
+  id: "check-for-platform-updates",
+
+  instantiate: (di): CheckForPlatformUpdates => {
+    const electronUpdater = di.inject(electronUpdaterInjectable);
+    const logger = di.inject(loggerInjectable);
+
+    return async (updateChannel, { allowDowngrade }) => {
+      electronUpdater.channel = updateChannel.id;
+      electronUpdater.autoDownload = false;
+      electronUpdater.allowDowngrade = allowDowngrade;
+
+      let result: UpdateCheckResult;
+
+      try {
+        result = await electronUpdater.checkForUpdates();
+      } catch (error) {
+        logger.error("[UPDATE-APP/CHECK-FOR-UPDATES]", error);
+
+        return {
+          updateWasDiscovered: false,
+        };
+      }
+
+      const { updateInfo, cancellationToken } = result;
+
+      if (!cancellationToken) {
+        return {
+          updateWasDiscovered: false,
+        };
+      }
+
+      return {
+        updateWasDiscovered: true,
+        version: updateInfo.version,
+      };
+    };
+  },
+});
+
+export default checkForPlatformUpdatesInjectable;

packages/core/src/features/application-update/main/check-for-updates/check-for-platform-updates/check-for-platform-updates.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getDiForUnitTesting } from "../../../../../main/getDiForUnitTesting";
+import electronUpdaterInjectable from "../../../../../main/electron-app/features/electron-updater.injectable";
+import type { AsyncFnMock } from "@async-fn/jest";
+import asyncFn from "@async-fn/jest";
+import type { AppUpdater, UpdateCheckResult } from "electron-updater";
+import type { CheckForPlatformUpdates } from "./check-for-platform-updates.injectable";
+import checkForPlatformUpdatesInjectable from "./check-for-platform-updates.injectable";
+import type { UpdateChannel, ReleaseChannel } from "../../../common/update-channels";
+import { getPromiseStatus } from "../../../../../common/test-utils/get-promise-status";
+import loggerInjectable from "../../../../../common/logger.injectable";
+import { noop } from "../../../../../common/utils";
+
+describe("check-for-platform-updates", () => {
+  let checkForPlatformUpdates: CheckForPlatformUpdates;
+  let electronUpdaterFake: AppUpdater;
+  let checkForUpdatesMock: AsyncFnMock<() => UpdateCheckResult>;
+  let logErrorMock: jest.Mock;
+
+  beforeEach(() => {
+    const di = getDiForUnitTesting();
+
+    checkForUpdatesMock = asyncFn();
+
+    electronUpdaterFake = {
+      channel: undefined,
+      autoDownload: undefined,
+      allowDowngrade: undefined,
+
+      checkForUpdates: checkForUpdatesMock,
+    } as unknown as AppUpdater;
+
+    di.override(electronUpdaterInjectable, () => electronUpdaterFake);
+
+    logErrorMock = jest.fn();
+
+    di.override(loggerInjectable, () => ({
+      error: logErrorMock,
+      debug: noop,
+      info: noop,
+      silly: noop,
+      warn: noop,
+    }));
+
+    checkForPlatformUpdates = di.inject(checkForPlatformUpdatesInjectable);
+  });
+
+  describe("when called", () => {
+    let actualPromise: Promise<any>;
+
+    beforeEach(() => {
+      const testUpdateChannel: UpdateChannel = {
+        id: "some-update-channel" as ReleaseChannel,
+        label: "Some update channel",
+        moreStableUpdateChannel: null,
+      };
+
+      actualPromise = checkForPlatformUpdates(testUpdateChannel, { allowDowngrade: true });
+    });
+
+    it("sets update channel", () => {
+      expect(electronUpdaterFake.channel).toBe("some-update-channel");
+    });
+
+    it("sets flag for allowing downgrade", () => {
+      expect(electronUpdaterFake.allowDowngrade).toBe(true);
+    });
+
+    it("disables auto downloading for being controlled", () => {
+      expect(electronUpdaterFake.autoDownload).toBe(false);
+    });
+
+    it("checks for updates", () => {
+      expect(checkForUpdatesMock).toHaveBeenCalled();
+    });
+
+    it("does not resolve yet", async () => {
+      const promiseStatus = await getPromiseStatus(actualPromise);
+
+      expect(promiseStatus.fulfilled).toBe(false);
+    });
+
+    it("when checking for updates resolves with update, resolves with the discovered update", async () => {
+      await checkForUpdatesMock.resolve({
+        updateInfo: {
+          version: "some-version",
+        },
+
+        cancellationToken: "some-cancellation-token",
+      } as unknown as UpdateCheckResult);
+
+      const actual = await actualPromise;
+
+      expect(actual).toEqual({ updateWasDiscovered: true, version: "some-version" });
+    });
+
+    it("when checking for updates resolves without update, resolves with update not being discovered", async () => {
+      await checkForUpdatesMock.resolve({
+        updateInfo: {
+          version: "some-version-that-matches-to-current-installed-version",
+        },
+
+        cancellationToken: null,
+      } as unknown as UpdateCheckResult);
+
+      const actual = await actualPromise;
+
+      expect(actual).toEqual({ updateWasDiscovered: false });
+    });
+
+    describe("when checking for updates rejects", () => {
+      let errorStub: Error;
+
+      beforeEach(() => {
+        errorStub = new Error("Some error");
+
+        checkForUpdatesMock.reject(errorStub);
+      });
+
+      it("logs errors", () => {
+        expect(logErrorMock).toHaveBeenCalledWith("[UPDATE-APP/CHECK-FOR-UPDATES]", errorStub);
+      });
+
+      it("resolves with update not being discovered", async () => {
+        const actual = await actualPromise;
+
+        expect(actual).toEqual({ updateWasDiscovered: false });
+      });
+    });
+  });
+});

packages/core/src/features/application-update/main/check-for-updates/check-for-updates-starting-from-channel.injectable.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 { UpdateChannel } from "../../common/update-channels";
+import checkForPlatformUpdatesInjectable from "./check-for-platform-updates/check-for-platform-updates.injectable";
+import updateCanBeDowngradedInjectable from "./update-can-be-downgraded.injectable";
+
+export type CheckForUpdatesFromChannelResult = {
+  updateWasDiscovered: false;
+} | {
+  updateWasDiscovered: true;
+  version: string;
+  actualUpdateChannel: UpdateChannel;
+};
+
+const checkForUpdatesStartingFromChannelInjectable = getInjectable({
+  id: "check-for-updates-starting-from-channel",
+
+  instantiate: (di) => {
+    const checkForPlatformUpdates = di.inject(checkForPlatformUpdatesInjectable);
+    const updateCanBeDowngraded = di.inject(updateCanBeDowngradedInjectable);
+
+    const _recursiveCheck = async (
+      updateChannel: UpdateChannel,
+    ): Promise<CheckForUpdatesFromChannelResult> => {
+      const result = await checkForPlatformUpdates(updateChannel, {
+        allowDowngrade: updateCanBeDowngraded.get(),
+      });
+
+      if (result.updateWasDiscovered) {
+        return {
+          updateWasDiscovered: true,
+          version: result.version,
+          actualUpdateChannel: updateChannel,
+        };
+      }
+
+      if (updateChannel.moreStableUpdateChannel) {
+        return await _recursiveCheck(updateChannel.moreStableUpdateChannel);
+      }
+
+      return { updateWasDiscovered: false };
+    };
+
+    return _recursiveCheck;
+  },
+});
+
+export default checkForUpdatesStartingFromChannelInjectable;

packages/core/src/features/application-update/main/check-for-updates/update-can-be-downgraded.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import selectedUpdateChannelInjectable from "../../common/selected-update-channel/selected-update-channel.injectable";
+import releaseChannelInjectable from "../../../../common/vars/release-channel.injectable";
+
+const updateCanBeDowngradedInjectable = getInjectable({
+  id: "update-can-be-downgraded",
+
+  instantiate: (di) => {
+    const selectedUpdateChannel = di.inject(selectedUpdateChannelInjectable);
+    const releaseChannel = di.inject(releaseChannelInjectable);
+
+    return computed(() => (
+      selectedUpdateChannel.value.get().id === "latest"
+      && releaseChannel.get() !== "latest"
+    ));
+  },
+});
+
+export default updateCanBeDowngradedInjectable;

packages/core/src/features/application-update/main/download-update/download-platform-update/download-platform-update.global-override-for-injectable.ts

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

packages/core/src/features/application-update/main/download-update/download-platform-update/download-platform-update.injectable.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 electronUpdaterInjectable from "../../../../../main/electron-app/features/electron-updater.injectable";
+import loggerInjectable from "../../../../../common/logger.injectable";
+import type { ProgressInfo } from "electron-updater";
+import type { ProgressOfDownload } from "../../../common/progress-of-update-download/progress-of-update-download.injectable";
+
+export type DownloadPlatformUpdate = (
+  onDownloadProgress: (arg: ProgressOfDownload) => void
+) => Promise<{ downloadWasSuccessful: boolean }>;
+
+const downloadPlatformUpdateInjectable = getInjectable({
+  id: "download-platform-update",
+
+  instantiate: (di): DownloadPlatformUpdate => {
+    const electronUpdater = di.inject(electronUpdaterInjectable);
+    const logger = di.inject(loggerInjectable);
+
+    return async (onDownloadProgress) => {
+      onDownloadProgress({ percentage: 0 });
+
+      const updateDownloadProgress = ({ percent: percentage }: ProgressInfo) =>
+        onDownloadProgress({ percentage });
+
+      electronUpdater.on("download-progress", updateDownloadProgress);
+
+      try {
+        await electronUpdater.downloadUpdate();
+      } catch(error) {
+        logger.error("[UPDATE-APP/DOWNLOAD]", error);
+
+        return { downloadWasSuccessful: false };
+      } finally {
+        electronUpdater.off("download-progress", updateDownloadProgress);
+      }
+
+      return { downloadWasSuccessful: true };
+    };
+  },
+});
+
+export default downloadPlatformUpdateInjectable;

packages/core/src/features/application-update/main/download-update/download-platform-update/download-platform-update.test.ts

@@ -0,0 +1,161 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getDiForUnitTesting } from "../../../../../main/getDiForUnitTesting";
+import electronUpdaterInjectable from "../../../../../main/electron-app/features/electron-updater.injectable";
+import type { DownloadPlatformUpdate } from "./download-platform-update.injectable";
+import downloadPlatformUpdateInjectable from "./download-platform-update.injectable";
+import type { AppUpdater } from "electron-updater";
+import type { AsyncFnMock } from "@async-fn/jest";
+import asyncFn from "@async-fn/jest";
+import { getPromiseStatus } from "../../../../../common/test-utils/get-promise-status";
+import type { DiContainer } from "@ogre-tools/injectable";
+import loggerInjectable from "../../../../../common/logger.injectable";
+import { noop } from "../../../../../common/utils";
+
+describe("download-platform-update", () => {
+  let downloadPlatformUpdate: DownloadPlatformUpdate;
+  let downloadUpdateMock: AsyncFnMock<() => void>;
+  let electronUpdaterFake: AppUpdater;
+  let electronUpdaterOnMock: jest.Mock;
+  let electronUpdaterOffMock: jest.Mock;
+  let di: DiContainer;
+  let logErrorMock: jest.Mock;
+
+  beforeEach(() => {
+    di = getDiForUnitTesting();
+
+    downloadUpdateMock = asyncFn();
+    electronUpdaterOnMock = jest.fn();
+    electronUpdaterOffMock = jest.fn();
+
+    electronUpdaterFake = {
+      channel: undefined,
+      autoDownload: undefined,
+
+      on: electronUpdaterOnMock,
+      off: electronUpdaterOffMock,
+
+      downloadUpdate: downloadUpdateMock,
+    } as unknown as AppUpdater;
+
+    di.override(electronUpdaterInjectable, () => electronUpdaterFake);
+
+    logErrorMock = jest.fn();
+    di.override(loggerInjectable, () => ({
+      error: logErrorMock,
+      debug: noop,
+      info: noop,
+      silly: noop,
+      warn: noop,
+    }));
+
+    downloadPlatformUpdate = di.inject(downloadPlatformUpdateInjectable);
+  });
+
+  describe("when called", () => {
+    let actualPromise: Promise<{ downloadWasSuccessful: boolean }>;
+    let onDownloadProgressMock: jest.Mock;
+
+    beforeEach(() => {
+      onDownloadProgressMock = jest.fn();
+
+      actualPromise = downloadPlatformUpdate(onDownloadProgressMock);
+    });
+
+    it("calls for downloading of update", () => {
+      expect(downloadUpdateMock).toHaveBeenCalled();
+    });
+
+    it("does not resolve yet", async () => {
+      const promiseStatus = await getPromiseStatus(actualPromise);
+
+      expect(promiseStatus.fulfilled).toBe(false);
+    });
+
+    it("starts progress of download from 0", () => {
+      expect(onDownloadProgressMock).toHaveBeenCalledWith({ percentage: 0 });
+    });
+
+    describe("when downloading progresses", () => {
+      beforeEach(() => {
+        onDownloadProgressMock.mockClear();
+
+        const [, callback] = electronUpdaterOnMock.mock.calls.find(
+          ([event]) => event === "download-progress",
+        );
+
+        callback({
+          percent: 42,
+          total: 0,
+          delta: 0,
+          transferred: 0,
+          bytesPerSecond: 0,
+        });
+      });
+
+      it("updates progress of the download", () => {
+        expect(onDownloadProgressMock).toHaveBeenCalledWith({ percentage: 42 });
+      });
+
+      describe("when downloading resolves", () => {
+        beforeEach(async () => {
+          onDownloadProgressMock.mockClear();
+
+          await downloadUpdateMock.resolve();
+        });
+
+        it("resolves with success", async () => {
+          const actual = await actualPromise;
+
+          expect(actual).toEqual({ downloadWasSuccessful: true });
+        });
+
+        it("does not reset progress of download yet", () => {
+          expect(onDownloadProgressMock).not.toHaveBeenCalled();
+        });
+
+        it("stops watching for download progress", () => {
+          expect(electronUpdaterOffMock).toHaveBeenCalledWith(
+            "download-progress",
+            expect.any(Function),
+          );
+        });
+
+        it("when starting download again, resets progress of download", () => {
+          downloadPlatformUpdate(onDownloadProgressMock);
+
+          expect(onDownloadProgressMock).toHaveBeenCalledWith({ percentage: 0 });
+        });
+      });
+
+      describe("when downloading rejects", () => {
+        let errorStub: Error;
+
+        beforeEach(() => {
+          errorStub = new Error("Some error");
+
+          downloadUpdateMock.reject(errorStub);
+        });
+
+        it("logs error", () => {
+          expect(logErrorMock).toHaveBeenCalledWith("[UPDATE-APP/DOWNLOAD]", errorStub);
+        });
+
+        it("stops watching for download progress", () => {
+          expect(electronUpdaterOffMock).toHaveBeenCalledWith(
+            "download-progress",
+            expect.any(Function),
+          );
+        });
+
+        it("resolves with failure", async () => {
+          const actual = await actualPromise;
+
+          expect(actual).toEqual({ downloadWasSuccessful: false });
+        });
+      });
+    });
+  });
+});

packages/core/src/features/application-update/main/download-update/download-update.injectable.ts

@@ -0,0 +1,57 @@
+/**
+ * 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 downloadPlatformUpdateInjectable from "./download-platform-update/download-platform-update.injectable";
+import updateIsBeingDownloadedInjectable from "../../common/update-is-being-downloaded/update-is-being-downloaded.injectable";
+import discoveredUpdateVersionInjectable from "../../common/discovered-update-version/discovered-update-version.injectable";
+import { action, runInAction } from "mobx";
+import type { ProgressOfDownload } from "../../common/progress-of-update-download/progress-of-update-download.injectable";
+import progressOfUpdateDownloadInjectable from "../../common/progress-of-update-download/progress-of-update-download.injectable";
+import { getCurrentDateTime } from "../../../../common/utils/date/get-current-date-time";
+import updateDownloadedDateTimeInjectable from "../../common/update-downloaded-date-time/update-downloaded-date-time.injectable";
+
+const downloadUpdateInjectable = getInjectable({
+  id: "download-update",
+
+  instantiate: (di) => {
+    const downloadPlatformUpdate = di.inject(downloadPlatformUpdateInjectable);
+    const downloadingUpdateState = di.inject(updateIsBeingDownloadedInjectable);
+    const discoveredVersionState = di.inject(discoveredUpdateVersionInjectable);
+    const progressOfUpdateDownload = di.inject(progressOfUpdateDownloadInjectable);
+    const updateDownloadedDate = di.inject(updateDownloadedDateTimeInjectable);
+
+    const updateDownloadProgress = action((progressOfDownload: ProgressOfDownload) => {
+      progressOfUpdateDownload.set(progressOfDownload);
+    });
+
+    return async () => {
+      runInAction(() => {
+        progressOfUpdateDownload.set({ percentage: 0 });
+        downloadingUpdateState.set(true);
+      });
+
+      const { downloadWasSuccessful } = await downloadPlatformUpdate(
+        updateDownloadProgress,
+      );
+
+      runInAction(() => {
+        if (!downloadWasSuccessful) {
+          progressOfUpdateDownload.set({ percentage: 0, failed: "Download of update failed" });
+          discoveredVersionState.set(null);
+        }
+
+        const currentDateTime = getCurrentDateTime();
+
+        updateDownloadedDate.set(currentDateTime);
+
+        downloadingUpdateState.set(false);
+      });
+
+      return { downloadWasSuccessful };
+    };
+  },
+});
+
+export default downloadUpdateInjectable;

packages/core/src/features/application-update/main/emit-current-version-to-analytics.injectable.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { afterApplicationIsLoadedInjectionToken } from "../../../main/start-main-application/runnable-tokens/after-application-is-loaded-injection-token";
+import emitAppEventInjectable from "../../../common/app-event-bus/emit-event.injectable";
+import { getCurrentDateTime } from "../../../common/utils/date/get-current-date-time";
+import buildVersionInjectable from "../../../main/vars/build-version/build-version.injectable";
+
+const emitCurrentVersionToAnalyticsInjectable = getInjectable({
+  id: "emit-current-version-to-analytics",
+
+  instantiate: (di) => {
+    const emitAppEvent = di.inject(emitAppEventInjectable);
+    const buildVersion = di.inject(buildVersionInjectable);
+
+    return {
+      id: "emit-current-version-to-analytics",
+      run: () => {
+        emitAppEvent({
+          name: "app",
+          action: "current-version",
+
+          params: {
+            version: buildVersion.get(),
+            currentDateTime: getCurrentDateTime(),
+          },
+        });
+      },
+    };
+  },
+
+  injectionToken: afterApplicationIsLoadedInjectionToken,
+});
+
+export default emitCurrentVersionToAnalyticsInjectable;

packages/core/src/features/application-update/main/process-checking-for-updates.injectable.ts

@@ -0,0 +1,82 @@
+/**
+ * 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 selectedUpdateChannelInjectable from "../common/selected-update-channel/selected-update-channel.injectable";
+import updatesAreBeingDiscoveredInjectable from "../common/updates-are-being-discovered/updates-are-being-discovered.injectable";
+import discoveredUpdateVersionInjectable from "../common/discovered-update-version/discovered-update-version.injectable";
+import { runInAction } from "mobx";
+import downloadUpdateInjectable from "./download-update/download-update.injectable";
+import checkForUpdatesStartingFromChannelInjectable from "./check-for-updates/check-for-updates-starting-from-channel.injectable";
+import emitAppEventInjectable from "../../../common/app-event-bus/emit-event.injectable";
+import { getCurrentDateTime } from "../../../common/utils/date/get-current-date-time";
+
+const processCheckingForUpdatesInjectable = getInjectable({
+  id: "process-checking-for-updates",
+
+  instantiate: (di) => {
+    const downloadUpdate = di.inject(downloadUpdateInjectable);
+    const selectedUpdateChannel = di.inject(selectedUpdateChannelInjectable);
+    const checkingForUpdatesState = di.inject(updatesAreBeingDiscoveredInjectable);
+    const discoveredVersionState = di.inject(discoveredUpdateVersionInjectable);
+    const checkForUpdatesStartingFromChannel = di.inject(checkForUpdatesStartingFromChannelInjectable);
+    const emitEvent = di.inject(emitAppEventInjectable);
+
+    return async (source: string) => {
+      emitEvent({
+        name: "app",
+        action: "checking-for-updates",
+        params: { currentDateTime: getCurrentDateTime(), source },
+      });
+
+      runInAction(() => {
+        checkingForUpdatesState.set(true);
+      });
+
+      const result = await checkForUpdatesStartingFromChannel(selectedUpdateChannel.value.get());
+
+      if (!result.updateWasDiscovered) {
+        runInAction(() => {
+          discoveredVersionState.set(null);
+          checkingForUpdatesState.set(false);
+        });
+
+        return { updateIsReadyToBeInstalled: false };
+      }
+
+      const { version, actualUpdateChannel } = result;
+
+      const previouslyDiscovered = discoveredVersionState.value.get();
+
+      if (version === previouslyDiscovered?.version) {
+        runInAction(() => {
+          checkingForUpdatesState.set(false);
+        });
+
+        return { updateIsReadyToBeInstalled: true };
+      }
+
+      emitEvent({
+        name: "app",
+        action: "update-was-discovered",
+        params: { version, currentDateTime: getCurrentDateTime() },
+      });
+
+      runInAction(() => {
+        discoveredVersionState.set({
+          version,
+          updateChannel: actualUpdateChannel,
+        });
+
+        checkingForUpdatesState.set(false);
+      });
+
+      const { downloadWasSuccessful } = await downloadUpdate();
+
+      return { updateIsReadyToBeInstalled: downloadWasSuccessful };
+    };
+  },
+});
+
+export default processCheckingForUpdatesInjectable;

packages/core/src/features/application-update/main/quit-and-install-update.injectable.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 electronQuitAndInstallUpdateInjectable from "../../../main/electron-app/features/electron-quit-and-install-update.injectable";
+import { getCurrentDateTime } from "../../../common/utils/date/get-current-date-time";
+import emitAppEventInjectable from "../../../common/app-event-bus/emit-event.injectable";
+import discoveredUpdateVersionInjectable from "../common/discovered-update-version/discovered-update-version.injectable";
+
+const quitAndInstallUpdateInjectable = getInjectable({
+  id: "quit-and-install-update",
+
+  instantiate: (di) => {
+    const electronQuitAndInstallUpdate = di.inject(
+      electronQuitAndInstallUpdateInjectable,
+    );
+
+    const emitEvent = di.inject(emitAppEventInjectable);
+    const discoveredUpdateVersion = di.inject(discoveredUpdateVersionInjectable);
+
+    return () => {
+      const discoveredVersion = discoveredUpdateVersion.value.get();
+
+      if (!discoveredVersion) {
+        throw new Error("Tried to install update but no update was discovered.");
+      }
+
+      emitEvent({
+        name: "app",
+        action: "start-installing-update",
+
+        params: {
+          version: discoveredVersion.version,
+          updateChannel: discoveredVersion.updateChannel.id,
+          currentDateTime: getCurrentDateTime(),
+        },
+      });
+
+      electronQuitAndInstallUpdate();
+    };
+  },
+});
+
+export default quitAndInstallUpdateInjectable;

packages/core/src/features/application-update/main/restart-and-install-update/restart-and-install-update-listener.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 { restartAndInstallUpdateChannel } from "../../common/restart-and-install-update-channel";
+import { getMessageChannelListenerInjectable } from "../../../../common/utils/channel/message-channel-listener-injection-token";
+import quitAndInstallUpdateInjectable from "../quit-and-install-update.injectable";
+
+const restartAndInstallUpdateListenerInjectable = getMessageChannelListenerInjectable({
+  id: "restart",
+  channel: restartAndInstallUpdateChannel,
+  handler: (di) => di.inject(quitAndInstallUpdateInjectable),
+});
+
+export default restartAndInstallUpdateListenerInjectable;

packages/core/src/features/application-update/main/updating-is-enabled/publish-is-configured/publish-is-configured.global-override-for-injectable.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getGlobalOverride } from "../../../../../common/test-utils/get-global-override";
+import publishIsConfiguredInjectable from "./publish-is-configured.injectable";
+
+export default getGlobalOverride(publishIsConfiguredInjectable, () => false);

packages/core/src/features/application-update/main/updating-is-enabled/publish-is-configured/publish-is-configured.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 applicationInformationToken from "../../../../../common/vars/application-information-token";
+
+const publishIsConfiguredInjectable = getInjectable({
+  id: "publish-is-configured",
+  instantiate: (di) => Boolean(di.inject(applicationInformationToken).build.publish?.length),
+});
+
+export default publishIsConfiguredInjectable;

packages/core/src/features/application-update/main/updating-is-enabled/updating-is-enabled.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 electronUpdaterIsActiveInjectable from "../../../../main/electron-app/features/electron-updater-is-active.injectable";
+import publishIsConfiguredInjectable from "./publish-is-configured/publish-is-configured.injectable";
+
+const updatingIsEnabledInjectable = getInjectable({
+  id: "updating-is-enabled",
+
+  instantiate: (di) => {
+    const electronUpdaterIsActive = di.inject(electronUpdaterIsActiveInjectable);
+    const publishIsConfigured = di.inject(publishIsConfiguredInjectable);
+
+    return electronUpdaterIsActive && publishIsConfigured;
+  },
+});
+
+export default updatingIsEnabledInjectable;

packages/core/src/features/application-update/main/watch-if-update-should-happen-on-quit/start-watching-if-update-should-happen-on-quit.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { onLoadOfApplicationInjectionToken } from "../../../../main/start-main-application/runnable-tokens/on-load-of-application-injection-token";
+import watchIfUpdateShouldHappenOnQuitInjectable from "./watch-if-update-should-happen-on-quit.injectable";
+
+const startWatchingIfUpdateShouldHappenOnQuitInjectable = getInjectable({
+  id: "start-watching-if-update-should-happen-on-quit",
+
+  instantiate: (di) => {
+    const watchIfUpdateShouldHappenOnQuit = di.inject(watchIfUpdateShouldHappenOnQuitInjectable);
+
+    return {
+      id: "start-watching-if-update-should-happen-on-quit",
+      run: () => {
+        watchIfUpdateShouldHappenOnQuit.start();
+      },
+    };
+  },
+
+  injectionToken: onLoadOfApplicationInjectionToken,
+});
+
+export default startWatchingIfUpdateShouldHappenOnQuitInjectable;

packages/core/src/features/application-update/main/watch-if-update-should-happen-on-quit/stop-watching-if-update-should-happen-on-quit.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 watchIfUpdateShouldHappenOnQuitInjectable from "./watch-if-update-should-happen-on-quit.injectable";
+import { beforeQuitOfBackEndInjectionToken } from "../../../../main/start-main-application/runnable-tokens/before-quit-of-back-end-injection-token";
+
+const stopWatchingIfUpdateShouldHappenOnQuitInjectable = getInjectable({
+  id: "stop-watching-if-update-should-happen-on-quit",
+
+  instantiate: (di) => {
+    const watchIfUpdateShouldHappenOnQuit = di.inject(watchIfUpdateShouldHappenOnQuitInjectable);
+
+    return {
+      id: "stop-watching-if-update-should-happen-on-quit",
+      run: () => void watchIfUpdateShouldHappenOnQuit.stop(),
+    };
+  },
+
+  injectionToken: beforeQuitOfBackEndInjectionToken,
+});
+
+export default stopWatchingIfUpdateShouldHappenOnQuitInjectable;

packages/core/src/features/application-update/main/watch-if-update-should-happen-on-quit/watch-if-update-should-happen-on-quit.injectable.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 { autorun } from "mobx";
+import { getStartableStoppable } from "../../../../common/utils/get-startable-stoppable";
+import setUpdateOnQuitInjectable from "../../../../main/electron-app/features/set-update-on-quit.injectable";
+import selectedUpdateChannelInjectable from "../../common/selected-update-channel/selected-update-channel.injectable";
+import type { ReleaseChannel, UpdateChannel } from "../../common/update-channels";
+import discoveredUpdateVersionInjectable from "../../common/discovered-update-version/discovered-update-version.injectable";
+
+const watchIfUpdateShouldHappenOnQuitInjectable = getInjectable({
+  id: "watch-if-update-should-happen-on-quit",
+
+  instantiate: (di) => {
+    const setUpdateOnQuit = di.inject(setUpdateOnQuitInjectable);
+    const selectedUpdateChannel = di.inject(selectedUpdateChannelInjectable);
+    const discoveredVersionState = di.inject(discoveredUpdateVersionInjectable);
+
+    return getStartableStoppable("watch-if-update-should-happen-on-quit", () =>
+      autorun(() => {
+        const sufficientlyStableUpdateChannels = getSufficientlyStableUpdateChannels(selectedUpdateChannel.value.get());
+        const updateIsDiscoveredFromChannel = discoveredVersionState.value.get()?.updateChannel;
+
+        setUpdateOnQuit((
+          updateIsDiscoveredFromChannel
+            ? sufficientlyStableUpdateChannels.includes(updateIsDiscoveredFromChannel.id)
+            : false
+        ));
+      }),
+    );
+  },
+});
+
+const getSufficientlyStableUpdateChannels = (updateChannel: UpdateChannel): ReleaseChannel[] => {
+  if (!updateChannel.moreStableUpdateChannel) {
+    return [updateChannel.id];
+  }
+
+  return [
+    updateChannel.id,
+    ...getSufficientlyStableUpdateChannels(updateChannel.moreStableUpdateChannel),
+  ];
+};
+
+export default watchIfUpdateShouldHappenOnQuitInjectable;

packages/core/src/features/application-update/renderer/restart-and-install-update.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 { restartAndInstallUpdateChannel } from "../common/restart-and-install-update-channel";
+import messageToChannelInjectable from "../../../renderer/utils/channel/message-to-channel.injectable";
+
+const restartAndInstallUpdateInjectable = getInjectable({
+  id: "restart-and-install-update",
+
+  instantiate: (di) => {
+    const messageToChannel = di.inject(messageToChannelInjectable);
+
+    return () => {
+      messageToChannel(restartAndInstallUpdateChannel);
+    };
+  },
+});
+
+export default restartAndInstallUpdateInjectable;