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>
2025-05-20 05:10:56 +00:00 · 2023-01-24 10:46:26 -08:00
1 parent 0066ca4ea2
commit 2657df2293
@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import { getInjectionToken } from "@ogre-tools/injectable";
+import type { InstalledExtension } from "../extension-discovery/extension-discovery";
+import type { LensExtension, LensExtensionConstructor } from "../lens-extension";
+
+export type CreateExtensionInstance = (ExtensionClass: LensExtensionConstructor, extension: InstalledExtension) => LensExtension;
+
+export const createExtensionInstanceInjectionToken = getInjectionToken<CreateExtensionInstance>({
+  id: "create-extension-instance-token",
+});
@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import { getInjectionToken } from "@ogre-tools/injectable";
+
+export const extensionEntryPointNameInjectionToken = getInjectionToken<"main" | "renderer">({
+  id: "extension-entry-point-name-token",
+});
@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { observable } from "mobx";
+import type { LensExtensionId, LensExtension } from "../lens-extension";
+
+const extensionInstancesInjectable = getInjectable({
+  id: "extension-instances",
+  instantiate: () => observable.map<LensExtensionId, LensExtension>(),
+});
+
+export default extensionInstancesInjectable;
@@ -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, lifecycleEnum } from "@ogre-tools/injectable";
+import type { KubernetesCluster } from "../../common/catalog-entities";
+import type { LensRendererExtension } from "../lens-renderer-extension";
+
+interface ExtensionIsEnabledForCluster {
+  extension: LensRendererExtension;
+  cluster: KubernetesCluster;
+}
+
+const extensionIsEnabledForClusterInjectable = getInjectable({
+  id: "extension-is-enabled-for-cluster",
+
+  instantiate: async (
+    di,
+    { extension, cluster }: ExtensionIsEnabledForCluster,
+  ) => (await extension.isEnabledForCluster(cluster)) as boolean,
+
+  lifecycle: lifecycleEnum.keyedSingleton({
+    getInstanceKey: (
+      di,
+      { extension, cluster }: ExtensionIsEnabledForCluster,
+    ) => `${extension.sanitizedExtensionId}-${cluster.getId()}`,
+  }),
+});
+
+export default extensionIsEnabledForClusterInjectable;
@@ -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 { ExtensionLoader } from "./extension-loader";
+import updateExtensionsStateInjectable from "./update-extensions-state/update-extensions-state.injectable";
+import { createExtensionInstanceInjectionToken } from "./create-extension-instance.token";
+import extensionInstancesInjectable from "./extension-instances.injectable";
+import type { LensExtension } from "../lens-extension";
+import extensionInjectable from "./extension/extension.injectable";
+import loggerInjectable from "../../common/logger.injectable";
+import joinPathsInjectable from "../../common/path/join-paths.injectable";
+import getDirnameOfPathInjectable from "../../common/path/get-dirname.injectable";
+import { bundledExtensionInjectionToken } from "../extension-discovery/bundled-extension-token";
+import { extensionEntryPointNameInjectionToken } from "./entry-point-name";
+
+const extensionLoaderInjectable = getInjectable({
+  id: "extension-loader",
+
+  instantiate: (di) => new ExtensionLoader({
+    updateExtensionsState: di.inject(updateExtensionsStateInjectable),
+    createExtensionInstance: di.inject(createExtensionInstanceInjectionToken),
+    extensionInstances: di.inject(extensionInstancesInjectable),
+    getExtension: (instance: LensExtension) => di.inject(extensionInjectable, instance),
+    bundledExtensions: di.injectMany(bundledExtensionInjectionToken),
+    extensionEntryPointName: di.inject(extensionEntryPointNameInjectionToken),
+    logger: di.inject(loggerInjectable),
+    joinPaths: di.inject(joinPathsInjectable),
+    getDirnameOfPath: di.inject(getDirnameOfPathInjectable),
+  }),
+});
+
+export default extensionLoaderInjectable;
@@ -0,0 +1,428 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import { ipcMain, ipcRenderer } from "electron";
+import { isEqual } from "lodash";
+import type { ObservableMap } from "mobx";
+import { action, computed, makeObservable, observable, observe, reaction, when } from "mobx";
+import { broadcastMessage, ipcMainOn, ipcRendererOn, ipcMainHandle } from "../../common/ipc";
+import { isDefined, toJS } from "../../common/utils";
+import type { InstalledExtension } from "../extension-discovery/extension-discovery";
+import type { LensExtension, LensExtensionConstructor, LensExtensionId } from "../lens-extension";
+import type { LensExtensionState } from "../extensions-store/extensions-store";
+import { extensionLoaderFromMainChannel, extensionLoaderFromRendererChannel } from "../../common/ipc/extension-handling";
+import { requestExtensionLoaderInitialState } from "../../renderer/ipc";
+import assert from "assert";
+import { EventEmitter } from "../../common/event-emitter";
+import type { CreateExtensionInstance } from "./create-extension-instance.token";
+import type { Extension } from "./extension/extension.injectable";
+import type { Logger } from "../../common/logger";
+import type { JoinPaths } from "../../common/path/join-paths.injectable";
+import type { GetDirnameOfPath } from "../../common/path/get-dirname.injectable";
+import type { BundledExtension } from "../extension-discovery/bundled-extension-token";
+
+const logModule = "[EXTENSIONS-LOADER]";
+
+interface Dependencies {
+  readonly extensionInstances: ObservableMap<LensExtensionId, LensExtension>;
+  readonly bundledExtensions: BundledExtension[];
+  readonly logger: Logger;
+  readonly extensionEntryPointName: "main" | "renderer";
+  updateExtensionsState: (extensionsState: Record<LensExtensionId, LensExtensionState>) => void;
+  createExtensionInstance: CreateExtensionInstance;
+  getExtension: (instance: LensExtension) => Extension;
+  joinPaths: JoinPaths;
+  getDirnameOfPath: GetDirnameOfPath;
+}
+
+interface ExtensionBeingActivated {
+  instance: LensExtension;
+  installedExtension: InstalledExtension;
+  activated: Promise<void>;
+}
+
+export interface ExtensionLoading {
+  isBundled: boolean;
+  loaded: Promise<void>;
+}
+
+/**
+ * Loads installed extensions to the Lens application
+ */
+export class ExtensionLoader {
+  protected readonly extensions = observable.map<LensExtensionId, InstalledExtension>();
+
+  /**
+   * This is the set of extensions that don't come with either
+   * - Main.LensExtension when running in the main process
+   * - Renderer.LensExtension when running in the renderer process
+   */
+  protected readonly nonInstancesByName = observable.set<string>();
+
+  /**
+   * This is updated by the `observe` in the constructor. DO NOT write directly to it
+   */
+  protected readonly instancesByName = observable.map<string, LensExtension>();
+
+  private readonly onRemoveExtensionId = new EventEmitter<[string]>();
+
+  @observable isLoaded = false;
+
+  get whenLoaded() {
+    return when(() => this.isLoaded);
+  }
+
+  constructor(protected readonly dependencies: Dependencies) {
+    makeObservable(this);
+
+    observe(this.dependencies.extensionInstances, change => {
+      switch (change.type) {
+        case "add":
+          if (this.instancesByName.has(change.newValue.name)) {
+            throw new TypeError("Extension names must be unique");
+          }
+
+          this.instancesByName.set(change.newValue.name, change.newValue);
+          break;
+        case "delete":
+          this.instancesByName.delete(change.oldValue.name);
+          break;
+        case "update":
+          throw new Error("Extension instances shouldn't be updated");
+      }
+    });
+  }
+
+  @computed get userExtensions(): Map<LensExtensionId, InstalledExtension> {
+    const extensions = this.toJSON();
+
+    extensions.forEach((ext, extId) => {
+      if (ext.isBundled) {
+        extensions.delete(extId);
+      }
+    });
+
+    return extensions;
+  }
+
+  /**
+   * Get the extension instance by its manifest name
+   * @param name The name of the extension
+   * @returns one of the following:
+   * - the instance of `Main.LensExtension` on the main process if created
+   * - the instance of `Renderer.LensExtension` on the renderer process if created
+   * - `null` if no class definition is provided for the current process
+   * - `undefined` if the name is not known about
+   */
+  getInstanceByName(name: string): LensExtension | null | undefined {
+    if (this.nonInstancesByName.has(name)) {
+      return null;
+    }
+
+    return this.instancesByName.get(name);
+  }
+
+  // Transform userExtensions to a state object for storing into ExtensionsStore
+  @computed get storeState() {
+    return Object.fromEntries(
+      Array.from(this.userExtensions)
+        .map(([extId, extension]) => [extId, {
+          enabled: extension.isEnabled,
+          name: extension.manifest.name,
+        }]),
+    );
+  }
+
+  @action
+  async init() {
+    if (ipcMain) {
+      await this.initMain();
+    } else {
+      await this.initRenderer();
+    }
+
+    await Promise.all([this.whenLoaded]);
+
+    // broadcasting extensions between main/renderer processes
+    reaction(() => this.toJSON(), () => this.broadcastExtensions(), {
+      fireImmediately: true,
+    });
+
+    reaction(
+      () => this.storeState,
+
+      (state) => {
+        this.dependencies.updateExtensionsState(state);
+      },
+    );
+  }
+
+  initExtensions(extensions: Map<LensExtensionId, InstalledExtension>) {
+    this.extensions.replace(extensions);
+  }
+
+  addExtension(extension: InstalledExtension) {
+    this.extensions.set(extension.id, extension);
+  }
+
+  @action
+  removeInstance(lensExtensionId: LensExtensionId) {
+    this.dependencies.logger.info(`${logModule} deleting extension instance ${lensExtensionId}`);
+    const instance = this.dependencies.extensionInstances.get(lensExtensionId);
+
+    if (!instance) {
+      return;
+    }
+
+    try {
+      instance.disable();
+
+      const extension = this.dependencies.getExtension(instance);
+
+      extension.deregister();
+
+      this.onRemoveExtensionId.emit(instance.id);
+      this.dependencies.extensionInstances.delete(lensExtensionId);
+      this.nonInstancesByName.delete(instance.name);
+    } catch (error) {
+      this.dependencies.logger.error(`${logModule}: deactivation extension error`, { lensExtensionId, error });
+    }
+  }
+
+  removeExtension(lensExtensionId: LensExtensionId) {
+    this.removeInstance(lensExtensionId);
+
+    if (!this.extensions.delete(lensExtensionId)) {
+      throw new Error(`Can't remove extension ${lensExtensionId}, doesn't exist.`);
+    }
+  }
+
+  setIsEnabled(lensExtensionId: LensExtensionId, isEnabled: boolean) {
+    const extension = this.extensions.get(lensExtensionId);
+
+    assert(extension, `Must register extension ${lensExtensionId} with before enabling it`);
+
+    extension.isEnabled = isEnabled;
+  }
+
+  protected async initMain() {
+    this.isLoaded = true;
+    await this.autoInitExtensions();
+
+    ipcMainHandle(extensionLoaderFromMainChannel, () => {
+      return Array.from(this.toJSON());
+    });
+
+    ipcMainOn(extensionLoaderFromRendererChannel, (event, extensions: [LensExtensionId, InstalledExtension][]) => {
+      this.syncExtensions(extensions);
+    });
+  }
+
+  protected async initRenderer() {
+    const extensionListHandler = (extensions: [LensExtensionId, InstalledExtension][]) => {
+      this.isLoaded = true;
+      this.syncExtensions(extensions);
+
+      const receivedExtensionIds = extensions.map(([lensExtensionId]) => lensExtensionId);
+
+      // Remove deleted extensions in renderer side only
+      this.extensions.forEach((_, lensExtensionId) => {
+        if (!receivedExtensionIds.includes(lensExtensionId)) {
+          this.removeExtension(lensExtensionId);
+        }
+      });
+    };
+
+    requestExtensionLoaderInitialState().then(extensionListHandler);
+    ipcRendererOn(extensionLoaderFromMainChannel, (event, extensions: [LensExtensionId, InstalledExtension][]) => {
+      extensionListHandler(extensions);
+    });
+  }
+
+  broadcastExtensions() {
+    const channel = ipcRenderer
+      ? extensionLoaderFromRendererChannel
+      : extensionLoaderFromMainChannel;
+
+    broadcastMessage(channel, Array.from(this.extensions));
+  }
+
+  syncExtensions(extensions: [LensExtensionId, InstalledExtension][]) {
+    extensions.forEach(([lensExtensionId, extension]) => {
+      if (!isEqual(this.extensions.get(lensExtensionId), extension)) {
+        this.extensions.set(lensExtensionId, extension);
+      }
+    });
+  }
+
+  protected async loadBundledExtensions() {
+    return this.dependencies.bundledExtensions
+      .map(extension => {
+        try {
+          const LensExtensionClass = extension[this.dependencies.extensionEntryPointName]();
+
+          if (!LensExtensionClass) {
+            return null;
+          }
+
+          const installedExtension: InstalledExtension = {
+            absolutePath: "irrelevant",
+            id: extension.manifest.name,
+            isBundled: true,
+            isCompatible: true,
+            isEnabled: true,
+            manifest: extension.manifest,
+            manifestPath: "irrelevant",
+          };
+          const instance = this.dependencies.createExtensionInstance(
+            LensExtensionClass,
+            installedExtension,
+          );
+
+          this.dependencies.extensionInstances.set(extension.manifest.name, instance);
+
+          return {
+            instance,
+            installedExtension,
+            activated: instance.activate(),
+          } as ExtensionBeingActivated;
+        } catch (err) {
+          this.dependencies.logger.error(`${logModule}: error loading extension`, { ext: extension, err });
+
+          return null;
+        }
+      })
+      .filter(isDefined);
+  }
+
+  protected async loadExtensions(extensions: ExtensionBeingActivated[]): Promise<ExtensionLoading[]> {
+    // We first need to wait until each extension's `onActivate` is resolved or rejected,
+    // as this might register new catalog categories. Afterwards we can safely .enable the extension.
+    await Promise.all(
+      extensions.map(extension =>
+        // If extension activation fails, log error
+        extension.activated.catch((error) => {
+          this.dependencies.logger.error(`${logModule}: activation extension error`, { ext: extension.installedExtension, error });
+        }),
+      ),
+    );
+
+    extensions.forEach(({ instance }) => {
+      const extension = this.dependencies.getExtension(instance);
+
+      extension.register();
+    });
+
+    return extensions.map(extension => {
+      const loaded = extension.instance.enable().catch((err) => {
+        this.dependencies.logger.error(`${logModule}: failed to enable`, { ext: extension, err });
+      });
+
+      return {
+        isBundled: extension.installedExtension.isBundled,
+        loaded,
+      };
+    });
+  }
+
+  protected async loadUserExtensions(installedExtensions: Map<string, InstalledExtension>) {
+    // Steps of the function:
+    // 1. require and call .activate for each Extension
+    // 2. Wait until every extension's onActivate has been resolved
+    // 3. Call .enable for each extension
+    // 4. Return ExtensionLoading[]
+
+    return [...installedExtensions.entries()]
+      .map(([extId, extension]) => {
+        const alreadyInit = this.dependencies.extensionInstances.has(extId) || this.nonInstancesByName.has(extension.manifest.name);
+
+        if (extension.isCompatible && extension.isEnabled && !alreadyInit) {
+          try {
+            const LensExtensionClass = this.requireExtension(extension);
+
+            if (!LensExtensionClass) {
+              this.nonInstancesByName.add(extension.manifest.name);
+
+              return null;
+            }
+
+            const instance = this.dependencies.createExtensionInstance(
+              LensExtensionClass,
+              extension,
+            );
+
+            this.dependencies.extensionInstances.set(extId, instance);
+
+            return {
+              instance,
+              installedExtension: extension,
+              activated: instance.activate(),
+            } as ExtensionBeingActivated;
+          } catch (err) {
+            this.dependencies.logger.error(`${logModule}: error loading extension`, { ext: extension, err });
+          }
+        } else if (!extension.isEnabled && alreadyInit) {
+          this.removeInstance(extId);
+        }
+
+        return null;
+      })
+      .filter(isDefined);
+  }
+
+  async autoInitExtensions() {
+    this.dependencies.logger.info(`${logModule}: auto initializing extensions`);
+
+    const bundledExtensions = await this.loadBundledExtensions();
+    const userExtensions = await this.loadUserExtensions(this.toJSON());
+    const loadedExtensions = await this.loadExtensions([
+      ...bundledExtensions,
+      ...userExtensions,
+    ]);
+
+    // Setup reaction to load extensions on JSON changes
+    reaction(() => this.toJSON(), installedExtensions => {
+      void (async () => {
+        const userExtensions = await this.loadUserExtensions(installedExtensions);
+
+        await this.loadExtensions(userExtensions);
+      })();
+    });
+
+    return loadedExtensions;
+  }
+
+  protected requireExtension(extension: InstalledExtension): LensExtensionConstructor | null {
+    const extRelativePath = extension.manifest[this.dependencies.extensionEntryPointName];
+
+    if (!extRelativePath) {
+      return null;
+    }
+
+    const extAbsolutePath = this.dependencies.joinPaths(this.dependencies.getDirnameOfPath(extension.manifestPath), extRelativePath);
+
+    try {
+      return require(/* webpackIgnore: true */ extAbsolutePath).default;
+    } catch (error) {
+      const message = (error instanceof Error ? error.stack : undefined) || error;
+
+      this.dependencies.logger.error(`${logModule}: can't load ${this.dependencies.extensionEntryPointName} for "${extension.manifest.name}": ${message}`, { extension });
+    }
+
+    return null;
+  }
+
+  getExtension(extId: LensExtensionId) {
+    return this.extensions.get(extId);
+  }
+
+  getInstanceById(extId: LensExtensionId) {
+    return this.dependencies.extensionInstances.get(extId);
+  }
+
+  toJSON(): Map<LensExtensionId, InstalledExtension> {
+    return toJS(this.extensions);
+  }
+}
@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectionToken } from "@ogre-tools/injectable";
+import type { IComputedValue } from "mobx";
+import type { LensExtension } from "../lens-extension";
+
+export type ExtensionRegistrator = (extension: LensExtension) =>
+  Injectable<any, any, any>[] | IComputedValue<Injectable<any, any, any>[]>;
+
+export const extensionRegistratorInjectionToken = getInjectionToken<ExtensionRegistrator>({
+  id: "extension-registrator-token",
+});
@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { Injectable } from "@ogre-tools/injectable";
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import { difference, find, map } from "lodash";
+import { reaction, runInAction } from "mobx";
+import { disposer } from "../../../common/utils/disposer";
+import type { LensExtension } from "../../lens-extension";
+import { extensionRegistratorInjectionToken } from "../extension-registrator-injection-token";
+
+export interface Extension {
+  register: () => void;
+  deregister: () => void;
+}
+
+const idsToInjectables = (ids: string[], injectables: Injectable<any, any, any>[]) => ids.map(id => {
+  const injectable = find(injectables, { id });
+
+  if (!injectable) {
+    throw new Error(`Injectable ${id} not found`);
+  }
+
+  return injectable;
+});
+
+const extensionInjectable = getInjectable({
+  id: "extension",
+
+  instantiate: (parentDi, instance: LensExtension): Extension => {
+    const extensionInjectable = getInjectable({
+      id: `extension-${instance.sanitizedExtensionId}`,
+
+      instantiate: (childDi) => {
+        const extensionRegistrators = childDi.injectMany(extensionRegistratorInjectionToken);
+        const reactionDisposer = disposer();
+
+        return {
+          register: () => {
+            extensionRegistrators.forEach((getInjectablesOfExtension) => {
+              const injectables = getInjectablesOfExtension(instance);
+
+              reactionDisposer.push(
+                // injectables is either an array or a computed array, in which case
+                // we need to update the registered injectables with a reaction every time they change 
+                reaction(
+                  () => Array.isArray(injectables) ? injectables : injectables.get(),
+                  (currentInjectables, previousInjectables = []) => {
+                    // Register new injectables and deregister removed injectables by id
+                    const currentIds = map(currentInjectables, "id");
+                    const previousIds = map(previousInjectables, "id");
+                    const idsToAdd = difference(currentIds, previousIds);
+                    const idsToRemove = previousIds.filter(previousId => !currentIds.includes(previousId));
+
+                    if (idsToRemove.length > 0) {
+                      childDi.deregister(...idsToInjectables(idsToRemove, previousInjectables));
+                    }
+
+                    if (idsToAdd.length > 0) {
+                      childDi.register(...idsToInjectables(idsToAdd, currentInjectables));
+                    }
+                  }, {
+                    fireImmediately: true,
+                  },
+                ));
+            });
+          },
+
+          deregister: () => {
+            reactionDisposer();
+
+            runInAction(() => {
+              parentDi.deregister(extensionInjectable);
+            });
+          },
+        };
+      },
+    });
+
+    runInAction(() => {
+      parentDi.register(extensionInjectable);
+    });
+
+    return parentDi.inject(extensionInjectable);
+  },
+
+  lifecycle: lifecycleEnum.keyedSingleton({
+    getInstanceKey: (di, instance: LensExtension) => instance,
+  }),
+});
+
+export default extensionInjectable;
@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import directoryForUserDataInjectable from "../../../common/app-paths/directory-for-user-data/directory-for-user-data.injectable";
+import joinPathsInjectable from "../../../common/path/join-paths.injectable";
+
+const directoryForExtensionDataInjectable = getInjectable({
+  id: "directory-for-extension-data",
+
+  instantiate: (di) => {
+    const joinPaths = di.inject(joinPathsInjectable);
+    const directoryForUserData = di.inject(directoryForUserDataInjectable);
+
+    return joinPaths(directoryForUserData, "extension_data");
+  },
+});
+
+export default directoryForExtensionDataInjectable;
@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { FileSystemProvisionerStore } from "./file-system-provisioner-store";
+import directoryForExtensionDataInjectable from "./directory-for-extension-data.injectable";
+import ensureDirectoryInjectable from "../../../common/fs/ensure-dir.injectable";
+import joinPathsInjectable from "../../../common/path/join-paths.injectable";
+import randomBytesInjectable from "../../../common/utils/random-bytes.injectable";
+import directoryForUserDataInjectable from "../../../common/app-paths/directory-for-user-data/directory-for-user-data.injectable";
+import getConfigurationFileModelInjectable from "../../../common/get-configuration-file-model/get-configuration-file-model.injectable";
+import loggerInjectable from "../../../common/logger.injectable";
+import storeMigrationVersionInjectable from "../../../common/vars/store-migration-version.injectable";
+import { baseStoreIpcChannelPrefixesInjectionToken } from "../../../common/base-store/channel-prefix";
+import { shouldBaseStoreDisableSyncInIpcListenerInjectionToken } from "../../../common/base-store/disable-sync";
+import { persistStateToConfigInjectionToken } from "../../../common/base-store/save-to-file";
+import getBasenameOfPathInjectable from "../../../common/path/get-basename.injectable";
+import { enlistMessageChannelListenerInjectionToken } from "../../../common/utils/channel/enlist-message-channel-listener-injection-token";
+
+const fileSystemProvisionerStoreInjectable = getInjectable({
+  id: "file-system-provisioner-store",
+
+  instantiate: (di) => new FileSystemProvisionerStore({
+    directoryForExtensionData: di.inject(directoryForExtensionDataInjectable),
+    ensureDirectory: di.inject(ensureDirectoryInjectable),
+    joinPaths: di.inject(joinPathsInjectable),
+    randomBytes: di.inject(randomBytesInjectable),
+    directoryForUserData: di.inject(directoryForUserDataInjectable),
+    getConfigurationFileModel: di.inject(getConfigurationFileModelInjectable),
+    logger: di.inject(loggerInjectable),
+    storeMigrationVersion: di.inject(storeMigrationVersionInjectable),
+    migrations: {},
+    getBasenameOfPath: di.inject(getBasenameOfPathInjectable),
+    ipcChannelPrefixes: di.inject(baseStoreIpcChannelPrefixesInjectionToken),
+    persistStateToConfig: di.inject(persistStateToConfigInjectionToken),
+    enlistMessageChannelListener: di.inject(enlistMessageChannelListenerInjectionToken),
+    shouldDisableSyncInListener: di.inject(shouldBaseStoreDisableSyncInIpcListenerInjectionToken),
+  }),
+});
+
+export default fileSystemProvisionerStoreInjectable;
@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import { SHA256 } from "crypto-js";
+import { action, makeObservable, observable } from "mobx";
+import type { BaseStoreDependencies } from "../../../common/base-store/base-store";
+import { BaseStore } from "../../../common/base-store/base-store";
+import type { LensExtensionId } from "../../lens-extension";
+import { getOrInsertWithAsync, toJS } from "../../../common/utils";
+import type { EnsureDirectory } from "../../../common/fs/ensure-dir.injectable";
+import type { JoinPaths } from "../../../common/path/join-paths.injectable";
+import type { RandomBytes } from "../../../common/utils/random-bytes.injectable";
+
+interface FSProvisionModel {
+  extensions: Record<string, string>; // extension names to paths
+}
+
+interface Dependencies extends BaseStoreDependencies {
+  readonly directoryForExtensionData: string;
+  ensureDirectory: EnsureDirectory;
+  joinPaths: JoinPaths;
+  randomBytes: RandomBytes;
+}
+
+export class FileSystemProvisionerStore extends BaseStore<FSProvisionModel> {
+  readonly registeredExtensions = observable.map<LensExtensionId, string>();
+
+  constructor(protected readonly dependencies: Dependencies) {
+    super(dependencies, {
+      configName: "lens-filesystem-provisioner-store",
+      accessPropertiesByDotNotation: false, // To make dots safe in cluster context names
+    });
+
+    makeObservable(this);
+  }
+
+  /**
+   * This function retrieves the saved path to the folder which the extension
+   * can saves files to. If the folder is not present then it is created.
+   * @param extensionName the name of the extension requesting the path
+   * @returns path to the folder that the extension can safely write files to.
+   */
+  async requestDirectory(extensionName: string): Promise<string> {
+    const dirPath = await getOrInsertWithAsync(this.registeredExtensions, extensionName, async () => {
+      const salt = (await this.dependencies.randomBytes(32)).toString("hex");
+      const hashedName = SHA256(`${extensionName}/${salt}`).toString();
+
+      return this.dependencies.joinPaths(this.dependencies.directoryForExtensionData, hashedName);
+    });
+
+    await this.dependencies.ensureDirectory(dirPath);
+
+    return dirPath;
+  }
+
+  @action
+  protected fromStore({ extensions }: FSProvisionModel = { extensions: {}}): void {
+    this.registeredExtensions.merge(extensions);
+  }
+
+  toJSON(): FSProvisionModel {
+    return toJS({
+      extensions: Object.fromEntries(this.registeredExtensions),
+    });
+  }
+}
@@ -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 "./extension-loader";
@@ -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 extensionsStoreInjectable from "../../extensions-store/extensions-store.injectable";
+
+const updateExtensionsStateInjectable = getInjectable({
+  id: "update-extensions-state",
+  instantiate: (di) => di.inject(extensionsStoreInjectable).mergeState,
+});
+
+export default updateExtensionsStateInjectable;