Change how bundled extensions are loaded

Signed-off-by: Sebastian Malton <sebastian@malton.name>

src/extensions/extension-discovery/bundled-extension-path.ts

@@ -4,7 +4,14 @@
  */
 
 import { getInjectionToken } from "@ogre-tools/injectable";
+import type { LensExtensionConstructor, LensExtensionManifest } from "../lens-extension";
 
-export const bundledExtensionPathInjectionToken = getInjectionToken<string>({
+export interface BundledExtension {
+  readonly manifest: LensExtensionManifest;
+  main: () => LensExtensionConstructor | null;
+  renderer: () => LensExtensionConstructor | null;
+}
+
+export const bundledExtensionInjectionToken = getInjectionToken<BundledExtension>({
   id: "bundled-extension-path",
 });

src/extensions/extension-discovery/extension-discovery.injectable.ts

@@ -28,7 +28,6 @@ import joinPathsInjectable from "../../common/path/join-paths.injectable";
 import removePathInjectable from "../../common/fs/remove.injectable";
 import homeDirectoryPathInjectable from "../../common/os/home-directory-path.injectable";
 import lensResourcesDirInjectable from "../../common/vars/lens-resources-dir.injectable";
-import { bundledExtensionPathInjectionToken } from "./bundled-extension-path";
 
 const extensionDiscoveryInjectable = getInjectable({
   id: "extension-discovery",
@@ -58,7 +57,6 @@ const extensionDiscoveryInjectable = getInjectable({
     getRelativePath: di.inject(getRelativePathInjectable),
     joinPaths: di.inject(joinPathsInjectable),
     homeDirectoryPath: di.inject(homeDirectoryPathInjectable),
-    bundledExtensionPaths: di.injectMany(bundledExtensionPathInjectionToken),
   }),
 });
 

src/extensions/extension-discovery/extension-discovery.ts

@@ -41,7 +41,6 @@ interface Dependencies {
   readonly isProduction: boolean;
   readonly fileSystemSeparator: string;
   readonly homeDirectoryPath: string;
-  readonly bundledExtensionPaths: string[];
   isCompatibleExtension: (manifest: LensExtensionManifest) => boolean;
   installExtension: (name: string) => Promise<void>;
   readJsonFile: ReadJson;
@@ -383,40 +382,16 @@ export class ExtensionDiscovery {
   }
 
   async ensureExtensions(): Promise<Map<LensExtensionId, InstalledExtension>> {
-    const bundledExtensions = await this.loadBundledExtensions();
-    const userExtensions = await this.loadFromFolder(this.localFolderPath, bundledExtensions.map((extension) => extension.manifest.name));
-    const extensions = bundledExtensions.concat(userExtensions);
+    const userExtensions = await this.loadFromFolder(this.localFolderPath);
 
-    return this.extensions = new Map(extensions.map(extension => [extension.id, extension]));
+    return this.extensions = new Map(userExtensions.map(extension => [extension.id, extension]));
   }
 
-  async loadBundledExtensions(): Promise<InstalledExtension[]> {
-    const extensions: InstalledExtension[] = [];
-
-    for (const bundledExtensionPath of this.dependencies.bundledExtensionPaths) {
-      const extension = await this.loadExtensionFromFolder(bundledExtensionPath, { isBundled: true });
-
-      if (!extension) {
-        throw new Error(`Couldn't load bundled extension: ${bundledExtensionPath}`);
-      }
-
-      extensions.push(extension);
-    }
-    this.dependencies.logger.debug(`${logModule}: ${extensions.length} extensions loaded`, { extensions });
-
-    return extensions;
-  }
-
-  async loadFromFolder(folderPath: string, bundledExtensions: string[]): Promise<InstalledExtension[]> {
+  async loadFromFolder(folderPath: string): Promise<InstalledExtension[]> {
     const extensions: InstalledExtension[] = [];
     const paths = await this.dependencies.readDirectory(folderPath);
 
     for (const fileName of paths) {
-      // do not allow to override bundled extensions
-      if (bundledExtensions.includes(fileName)) {
-        continue;
-      }
-
       const absPath = this.dependencies.joinPaths(folderPath, fileName);
 
       try {

src/extensions/extension-loader/entry-point-name.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import { getInjectionToken } from "@ogre-tools/injectable";
+
+export const extensionEntryPointNameInjectionToken = getInjectionToken<"main" | "renderer">({
+  id: "extension-entry-point-name-token",
+});

src/extensions/extension-loader/extension-loader.injectable.ts

@@ -12,6 +12,8 @@ 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-path";
+import { extensionEntryPointNameInjectionToken } from "./entry-point-name";
 
 const extensionLoaderInjectable = getInjectable({
   id: "extension-loader",
@@ -21,6 +23,8 @@ const extensionLoaderInjectable = getInjectable({
     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),

src/extensions/extension-loader/extension-loader.ts

@@ -21,12 +21,15 @@ 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-path";
 
 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;
@@ -34,6 +37,12 @@ interface Dependencies {
   getDirnameOfPath: GetDirnameOfPath;
 }
 
+interface SemiLoadedExtension {
+  instance: LensExtension;
+  installedExtension: InstalledExtension;
+  activated: Promise<void>;
+}
+
 export interface ExtensionLoading {
   isBundled: boolean;
   loaded: Promise<void>;
@@ -248,14 +257,84 @@ export class ExtensionLoader {
     });
   }
 
-  protected async loadExtensions(installedExtensions: Map<string, InstalledExtension>) {
+  protected async loadBundledExtensions() {
+    return this.dependencies.bundledExtensions
+      .map(extension => {
+        try {
+          const LensExtensionClass = extension[this.dependencies.extensionEntryPointName]();
+
+          if (!LensExtensionClass) {
+            return null;
+          }
+
+          const installedExtension: InstalledExtension = {
+            absolutePath: "irrelavent",
+            id: extension.manifest.name,
+            isBundled: true,
+            isCompatible: true,
+            isEnabled: true,
+            manifest: extension.manifest,
+            manifestPath: "irrelavent",
+          };
+          const instance = this.dependencies.createExtensionInstance(
+            LensExtensionClass,
+            installedExtension,
+          );
+
+          this.dependencies.extensionInstances.set(extension.manifest.name, instance);
+
+          return {
+            instance,
+            installedExtension,
+            activated: instance.activate(),
+          } as SemiLoadedExtension;
+        } catch (err) {
+          this.dependencies.logger.error(`${logModule}: error loading extension`, { ext: extension, err });
+
+          return null;
+        }
+      })
+      .filter(isDefined);
+  }
+
+  protected async loadExtensions(extensions: SemiLoadedExtension[]): 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[]
 
-    const extensions = [...installedExtensions.entries()]
+    return [...installedExtensions.entries()]
       .map(([extId, extension]) => {
         const alreadyInit = this.dependencies.extensionInstances.has(extId) || this.nonInstancesByName.has(extension.manifest.name);
 
@@ -280,7 +359,7 @@ export class ExtensionLoader {
               instance,
               installedExtension: extension,
               activated: instance.activate(),
-            };
+            } as SemiLoadedExtension;
           } catch (err) {
             this.dependencies.logger.error(`${logModule}: error loading extension`, { ext: extension, err });
           }
@@ -290,52 +369,33 @@ export class ExtensionLoader {
 
         return null;
       })
-      // Remove null values
       .filter(isDefined);
-
-    // 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 ExtensionLoading[]
-    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,
-      };
-    });
   }
 
-  autoInitExtensions() {
+  async autoInitExtensions() {
     this.dependencies.logger.info(`${logModule}: auto initializing extensions`);
 
-    // Setup reaction to load extensions on JSON changes
-    reaction(() => this.toJSON(), installedExtensions => this.loadExtensions(installedExtensions));
+    const bundledExtensions = await this.loadBundledExtensions();
+    const userExtensions = await this.loadUserExtensions(this.toJSON());
+    const loadedExtensions = await this.loadExtensions([
+      ...bundledExtensions,
+      ...userExtensions,
+    ]);
 
-    // Load initial extensions
-    return this.loadExtensions(this.toJSON());
+    // 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 entryPointName = ipcRenderer ? "renderer" : "main";
-    const extRelativePath = extension.manifest[entryPointName];
+    const extRelativePath = extension.manifest[this.dependencies.extensionEntryPointName];
 
     if (!extRelativePath) {
       return null;
@@ -348,7 +408,7 @@ export class ExtensionLoader {
     } catch (error) {
       const message = (error instanceof Error ? error.stack : undefined) || error;
 
-      this.dependencies.logger.error(`${logModule}: can't load ${entryPointName} for "${extension.manifest.name}": ${message}`, { extension });
+      this.dependencies.logger.error(`${logModule}: can't load ${this.dependencies.extensionEntryPointName} for "${extension.manifest.name}": ${message}`, { extension });
     }
 
     return null;

src/main/extension-loader/entry-point-name.injectable.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { extensionEntryPointNameInjectionToken } from "../../extensions/extension-loader/entry-point-name";
+
+const extensionEntryPointNameInjectable = getInjectable({
+  id: "extension-entry-point-name",
+  instantiate: () => "main" as const,
+  injectionToken: extensionEntryPointNameInjectionToken,
+});
+
+export default extensionEntryPointNameInjectable;

src/renderer/extension-loader/entry-point-name.injectable.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { extensionEntryPointNameInjectionToken } from "../../extensions/extension-loader/entry-point-name";
+
+const extensionEntryPointNameInjectable = getInjectable({
+  id: "extension-entry-point-name",
+  instantiate: () => "renderer" as const,
+  injectionToken: extensionEntryPointNameInjectionToken,
+});
+
+export default extensionEntryPointNameInjectable;