();
@@ -38,6 +38,7 @@ function bindMethod(target: object, prop?: string, descriptor?: PropertyDescript
get() {
if (this === target) return func; // direct access from prototype
if (!boundFunc.has(this)) boundFunc.set(this, func.bind(this));
+
return boundFunc.get(this);
}
});
diff --git a/src/common/utils/buildUrl.ts b/src/common/utils/buildUrl.ts
new file mode 100644
index 0000000000..e3bad9b302
--- /dev/null
+++ b/src/common/utils/buildUrl.ts
@@ -0,0 +1,16 @@
+import { compile } from "path-to-regexp";
+
+export interface IURLParams {
+ params?: P;
+ query?: Q;
+}
+
+export function buildURL
(path: string | any) {
+ const pathBuilder = compile(String(path));
+
+ return function ({ params, query }: IURLParams = {}) {
+ const queryParams = query ? new URLSearchParams(Object.entries(query)).toString() : "";
+
+ return pathBuilder(params) + (queryParams ? `?${queryParams}` : "");
+ };
+}
diff --git a/src/common/utils/camelCase.ts b/src/common/utils/camelCase.ts
index 90c048cad5..306cb45190 100644
--- a/src/common/utils/camelCase.ts
+++ b/src/common/utils/camelCase.ts
@@ -8,7 +8,9 @@ export function toCamelCase(obj: Record): any {
else if (isPlainObject(obj)) {
return Object.keys(obj).reduce((result, key) => {
const value = obj[key];
+
result[camelCase(key)] = typeof value === "object" ? toCamelCase(value) : value;
+
return result;
}, {} as any);
}
diff --git a/src/common/utils/debouncePromise.ts b/src/common/utils/debouncePromise.ts
new file mode 100755
index 0000000000..b5ad88d000
--- /dev/null
+++ b/src/common/utils/debouncePromise.ts
@@ -0,0 +1,10 @@
+// Debouncing promise evaluation
+
+export function debouncePromise(func: (...args: F) => T | Promise, timeout = 0): (...args: F) => Promise {
+ let timer: NodeJS.Timeout;
+
+ return (...params: any[]) => new Promise(resolve => {
+ clearTimeout(timer);
+ timer = global.setTimeout(() => resolve(func.apply(this, params)), timeout);
+ });
+}
diff --git a/src/common/utils/defineGlobal.ts b/src/common/utils/defineGlobal.ts
index 29e2e60ea0..d8883bb38d 100755
--- a/src/common/utils/defineGlobal.ts
+++ b/src/common/utils/defineGlobal.ts
@@ -4,9 +4,10 @@
export function defineGlobal(propName: string, descriptor: PropertyDescriptor) {
const scope = typeof global !== "undefined" ? global : window;
+
if (scope.hasOwnProperty(propName)) {
- console.info(`Global variable "${propName}" already exists. Skipping.`)
return;
}
+
Object.defineProperty(scope, propName, descriptor);
}
diff --git a/src/common/utils/downloadFile.ts b/src/common/utils/downloadFile.ts
new file mode 100644
index 0000000000..dfa549da07
--- /dev/null
+++ b/src/common/utils/downloadFile.ts
@@ -0,0 +1,37 @@
+import request from "request";
+
+export interface DownloadFileOptions {
+ url: string;
+ gzip?: boolean;
+ timeout?: number;
+}
+
+export interface DownloadFileTicket {
+ url: string;
+ promise: Promise;
+ cancel(): void;
+}
+
+export function downloadFile({ url, timeout, gzip = true }: DownloadFileOptions): DownloadFileTicket {
+ const fileChunks: Buffer[] = [];
+ const req = request(url, { gzip, timeout });
+ const promise: Promise = new Promise((resolve, reject) => {
+ req.on("data", (chunk: Buffer) => {
+ fileChunks.push(chunk);
+ });
+ req.once("error", err => {
+ reject({ url, err });
+ });
+ req.once("complete", () => {
+ resolve(Buffer.concat(fileChunks));
+ });
+ });
+
+ return {
+ url,
+ promise,
+ cancel() {
+ req.abort();
+ }
+ };
+}
diff --git a/src/common/utils/escapeRegExp.ts b/src/common/utils/escapeRegExp.ts
new file mode 100644
index 0000000000..b79188f33d
--- /dev/null
+++ b/src/common/utils/escapeRegExp.ts
@@ -0,0 +1,5 @@
+// Helper to sanitize / escape special chars for passing to RegExp-constructor
+
+export function escapeRegExp(str: string) {
+ return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+}
diff --git a/src/common/utils/getRandId.ts b/src/common/utils/getRandId.ts
index afe075085d..ef02e2f0eb 100644
--- a/src/common/utils/getRandId.ts
+++ b/src/common/utils/getRandId.ts
@@ -2,5 +2,6 @@
export function getRandId({ prefix = "", suffix = "", sep = "_" } = {}) {
const randId = () => Math.random().toString(16).substr(2);
+
return [prefix, randId(), suffix].filter(s => s).join(sep);
}
diff --git a/src/common/utils/index.ts b/src/common/utils/index.ts
index 580a8f15c2..582135d7f0 100644
--- a/src/common/utils/index.ts
+++ b/src/common/utils/index.ts
@@ -1,7 +1,19 @@
-// Common utils (main/renderer)
+// Common utils (main OR renderer)
-export * from "./base64"
-export * from "./camelCase"
-export * from "./splitArray"
-export * from "./getRandId"
-export * from "./cloneJson"
+export const noop: any = () => { /* empty */ };
+
+export * from "./app-version";
+export * from "./autobind";
+export * from "./base64";
+export * from "./camelCase";
+export * from "./cloneJson";
+export * from "./debouncePromise";
+export * from "./defineGlobal";
+export * from "./getRandId";
+export * from "./splitArray";
+export * from "./saveToAppFiles";
+export * from "./singleton";
+export * from "./openExternal";
+export * from "./downloadFile";
+export * from "./escapeRegExp";
+export * from "./tar";
diff --git a/src/common/utils/openExternal.ts b/src/common/utils/openExternal.ts
new file mode 100644
index 0000000000..56d7f90ce6
--- /dev/null
+++ b/src/common/utils/openExternal.ts
@@ -0,0 +1,6 @@
+// Opens a link in external browser
+import { shell } from "electron";
+
+export function openExternal(url: string) {
+ return shell.openExternal(url);
+}
diff --git a/src/common/utils/saveToAppFiles.ts b/src/common/utils/saveToAppFiles.ts
index 9092767ccf..87d09290c0 100644
--- a/src/common/utils/saveToAppFiles.ts
+++ b/src/common/utils/saveToAppFiles.ts
@@ -1,11 +1,14 @@
// Save file to electron app directory (e.g. "/Users/$USER/Library/Application Support/Lens" for MacOS)
import path from "path";
import { app, remote } from "electron";
-import { ensureDirSync, writeFileSync, WriteFileOptions } from "fs-extra";
+import { ensureDirSync, writeFileSync } from "fs-extra";
+import { WriteFileOptions } from "fs";
export function saveToAppFiles(filePath: string, contents: any, options?: WriteFileOptions): string {
const absPath = path.resolve((app || remote.app).getPath("userData"), filePath);
+
ensureDirSync(path.dirname(absPath));
writeFileSync(absPath, contents, options);
+
return absPath;
}
diff --git a/src/common/utils/singleton.ts b/src/common/utils/singleton.ts
index 70347f9b42..61269d10b1 100644
--- a/src/common/utils/singleton.ts
+++ b/src/common/utils/singleton.ts
@@ -16,6 +16,7 @@ class Singleton {
if (!Singleton.instances.has(this)) {
Singleton.instances.set(this, Reflect.construct(this, args));
}
+
return Singleton.instances.get(this) as T;
}
@@ -24,5 +25,5 @@ class Singleton {
}
}
-export { Singleton }
+export { Singleton };
export default Singleton;
\ No newline at end of file
diff --git a/src/common/utils/splitArray.ts b/src/common/utils/splitArray.ts
index 90c342827d..7be367ebe6 100644
--- a/src/common/utils/splitArray.ts
+++ b/src/common/utils/splitArray.ts
@@ -12,8 +12,10 @@
*/
export function splitArray(array: T[], element: T): [T[], T[], boolean] {
const index = array.indexOf(element);
+
if (index < 0) {
return [array, [], false];
}
- return [array.slice(0, index), array.slice(index + 1, array.length), true]
+
+ return [array.slice(0, index), array.slice(index + 1, array.length), true];
}
diff --git a/src/common/utils/tar.ts b/src/common/utils/tar.ts
new file mode 100644
index 0000000000..f9876e2b27
--- /dev/null
+++ b/src/common/utils/tar.ts
@@ -0,0 +1,60 @@
+// Helper for working with tarball files (.tar, .tgz)
+// Docs: https://github.com/npm/node-tar
+import tar, { ExtractOptions, FileStat } from "tar";
+import path from "path";
+
+export interface ReadFileFromTarOpts {
+ tarPath: string;
+ filePath: string;
+ parseJson?: boolean;
+}
+
+export function readFileFromTar({ tarPath, filePath, parseJson }: ReadFileFromTarOpts): Promise {
+ return new Promise(async (resolve, reject) => {
+ const fileChunks: Buffer[] = [];
+
+ await tar.list({
+ file: tarPath,
+ filter: entryPath => path.normalize(entryPath) === filePath,
+ onentry(entry: FileStat) {
+ entry.on("data", chunk => {
+ fileChunks.push(chunk);
+ });
+ entry.once("error", err => {
+ reject(new Error(`reading file has failed ${entry.path}: ${err}`));
+ });
+ entry.once("end", () => {
+ const data = Buffer.concat(fileChunks);
+ const result = parseJson ? JSON.parse(data.toString("utf8")) : data;
+
+ resolve(result);
+ });
+ },
+ });
+
+ if (!fileChunks.length) {
+ reject(new Error("Not found"));
+ }
+ });
+}
+
+export async function listTarEntries(filePath: string): Promise {
+ const entries: string[] = [];
+
+ await tar.list({
+ file: filePath,
+ onentry: (entry: FileStat) => {
+ entries.push(path.normalize(entry.path as any as string));
+ },
+ });
+
+ return entries;
+}
+
+export function extractTar(filePath: string, opts: ExtractOptions & { sync?: boolean } = {}) {
+ return tar.extract({
+ file: filePath,
+ cwd: path.dirname(filePath),
+ ...opts,
+ });
+}
diff --git a/src/common/vars.ts b/src/common/vars.ts
index ca28a2f99a..396a1077c5 100644
--- a/src/common/vars.ts
+++ b/src/common/vars.ts
@@ -1,17 +1,19 @@
// App's common configuration for any process (main, renderer, build pipeline, etc.)
import path from "path";
-import packageInfo from "../../package.json"
+import packageInfo from "../../package.json";
import { defineGlobal } from "./utils/defineGlobal";
-export const isMac = process.platform === "darwin"
-export const isWindows = process.platform === "win32"
-export const isDebugging = process.env.DEBUG === "true";
-export const isProduction = process.env.NODE_ENV === "production"
+export const isMac = process.platform === "darwin";
+export const isWindows = process.platform === "win32";
+export const isLinux = process.platform === "linux";
+export const isDebugging = ["true", "1", "yes", "y", "on"].includes((process.env.DEBUG ?? "").toLowerCase());
+export const isSnap = !!process.env.SNAP;
+export const isProduction = process.env.NODE_ENV === "production";
export const isTestEnv = !!process.env.JEST_WORKER_ID;
export const isDevelopment = !isTestEnv && !isProduction;
-export const appName = `${packageInfo.productName}${isDevelopment ? "Dev" : ""}`
-export const publicPath = "/build/"
+export const appName = `${packageInfo.productName}${isDevelopment ? "Dev" : ""}`;
+export const publicPath = "/build/";
// Webpack build paths
export const contextDir = process.cwd();
@@ -20,6 +22,7 @@ export const mainDir = path.join(contextDir, "src/main");
export const rendererDir = path.join(contextDir, "src/renderer");
export const htmlTemplate = path.resolve(rendererDir, "template.html");
export const sassCommonVars = path.resolve(rendererDir, "components/vars.scss");
+export const webpackDevServerPort = 9009;
// Special runtime paths
defineGlobal("__static", {
@@ -27,14 +30,17 @@ defineGlobal("__static", {
if (isDevelopment) {
return path.resolve(contextDir, "static");
}
- return path.resolve(process.resourcesPath, "static")
+
+ return path.resolve(process.resourcesPath, "static");
}
-})
+});
// Apis
-export const apiPrefix = "/api" // local router apis
-export const apiKubePrefix = "/api-kube" // k8s cluster apis
+export const apiPrefix = "/api"; // local router apis
+export const apiKubePrefix = "/api-kube"; // k8s cluster apis
// Links
-export const issuesTrackerUrl = "https://github.com/lensapp/lens/issues"
-export const slackUrl = "https://join.slack.com/t/k8slens/shared_invite/enQtOTc5NjAyNjYyOTk4LWU1NDQ0ZGFkOWJkNTRhYTc2YjVmZDdkM2FkNGM5MjhiYTRhMDU2NDQ1MzIyMDA4ZGZlNmExOTc0N2JmY2M3ZGI"
+export const issuesTrackerUrl = "https://github.com/lensapp/lens/issues";
+export const slackUrl = "https://join.slack.com/t/k8slens/shared_invite/enQtOTc5NjAyNjYyOTk4LWU1NDQ0ZGFkOWJkNTRhYTc2YjVmZDdkM2FkNGM5MjhiYTRhMDU2NDQ1MzIyMDA4ZGZlNmExOTc0N2JmY2M3ZGI";
+export const docsUrl = "https://docs.k8slens.dev/";
+export const supportUrl = "https://docs.k8slens.dev/latest/support/";
diff --git a/src/common/workspace-store.ts b/src/common/workspace-store.ts
index 752a53f41b..921a9126a9 100644
--- a/src/common/workspace-store.ts
+++ b/src/common/workspace-store.ts
@@ -1,39 +1,209 @@
-import { action, computed, observable, toJS } from "mobx";
+import { ipcRenderer } from "electron";
+import { action, computed, observable, toJS, reaction } from "mobx";
import { BaseStore } from "./base-store";
-import { clusterStore } from "./cluster-store"
-import { landingURL } from "../renderer/components/+landing-page/landing-page.route";
-import { navigate } from "../renderer/navigation";
+import { clusterStore } from "./cluster-store";
+import { appEventBus } from "./event-bus";
+import { broadcastMessage, handleRequest, requestMain } from "../common/ipc";
+import logger from "../main/logger";
+import type { ClusterId } from "./cluster-store";
export type WorkspaceId = string;
export interface WorkspaceStoreModel {
+ workspaces: WorkspaceModel[];
currentWorkspace?: WorkspaceId;
- workspaces: Workspace[]
}
-export interface Workspace {
+export interface WorkspaceModel {
id: WorkspaceId;
name: string;
description?: string;
+ ownerRef?: string;
+ lastActiveClusterId?: ClusterId;
+}
+
+export interface WorkspaceState {
+ enabled: boolean;
+}
+
+/**
+ * Workspace
+ *
+ * @beta
+ */
+export class Workspace implements WorkspaceModel, WorkspaceState {
+ /**
+ * Unique id for workspace
+ *
+ * @observable
+ */
+ @observable id: WorkspaceId;
+ /**
+ * Workspace name
+ *
+ * @observable
+ */
+ @observable name: string;
+ /**
+ * Workspace description
+ *
+ * @observable
+ */
+ @observable description?: string;
+ /**
+ * Workspace owner reference
+ *
+ * If extension sets ownerRef then it needs to explicitly mark workspace as enabled onActivate (or when workspace is saved)
+ *
+ * @observable
+ */
+ @observable ownerRef?: string;
+
+ /**
+ * Last active cluster id
+ *
+ * @observable
+ */
+ @observable lastActiveClusterId?: ClusterId;
+
+
+ @observable private _enabled: boolean;
+
+ constructor(data: WorkspaceModel) {
+ Object.assign(this, data);
+
+ if (!ipcRenderer) {
+ reaction(() => this.getState(), () => {
+ this.pushState();
+ });
+ }
+ }
+
+ /**
+ * Is workspace enabled
+ *
+ * Workspaces that don't have ownerRef will be enabled by default. Workspaces with ownerRef need to explicitly enable a workspace.
+ *
+ * @observable
+ */
+ get enabled(): boolean {
+ return !this.isManaged || this._enabled;
+ }
+
+ set enabled(enabled: boolean) {
+ this._enabled = enabled;
+ }
+
+ /**
+ * Is workspace managed by an extension
+ */
+ get isManaged(): boolean {
+ return !!this.ownerRef;
+ }
+
+ /**
+ * Get workspace state
+ *
+ */
+ getState(): WorkspaceState {
+ return toJS({
+ enabled: this.enabled
+ });
+ }
+
+ /**
+ * Push state
+ *
+ * @interal
+ * @param state workspace state
+ */
+ pushState(state = this.getState()) {
+ logger.silly("[WORKSPACE] pushing state", {...state, id: this.id});
+ broadcastMessage("workspace:state", this.id, toJS(state));
+ }
+
+ /**
+ *
+ * @param state workspace state
+ */
+ @action setState(state: WorkspaceState) {
+ Object.assign(this, state);
+ }
+
+ toJSON(): WorkspaceModel {
+ return toJS({
+ id: this.id,
+ name: this.name,
+ description: this.description,
+ ownerRef: this.ownerRef,
+ lastActiveClusterId: this.lastActiveClusterId
+ });
+ }
}
export class WorkspaceStore extends BaseStore {
- static readonly defaultId: WorkspaceId = "default"
+ static readonly defaultId: WorkspaceId = "default";
+ private static stateRequestChannel = "workspace:states";
+
+ @observable currentWorkspaceId = WorkspaceStore.defaultId;
+ @observable workspaces = observable.map();
private constructor() {
super({
configName: "lens-workspace-store",
});
- }
- @observable currentWorkspaceId = WorkspaceStore.defaultId;
-
- @observable workspaces = observable.map({
- [WorkspaceStore.defaultId]: {
+ this.workspaces.set(WorkspaceStore.defaultId, new Workspace({
id: WorkspaceStore.defaultId,
name: "default"
+ }));
+ }
+
+ async load() {
+ await super.load();
+ type workspaceStateSync = {
+ id: string;
+ state: WorkspaceState;
+ };
+
+ if (ipcRenderer) {
+ logger.info("[WORKSPACE-STORE] requesting initial state sync");
+ const workspaceStates: workspaceStateSync[] = await requestMain(WorkspaceStore.stateRequestChannel);
+
+ workspaceStates.forEach((workspaceState) => {
+ const workspace = this.getById(workspaceState.id);
+
+ if (workspace) {
+ workspace.setState(workspaceState.state);
+ }
+ });
+ } else {
+ handleRequest(WorkspaceStore.stateRequestChannel, (): workspaceStateSync[] => {
+ const states: workspaceStateSync[] = [];
+
+ this.workspacesList.forEach((workspace) => {
+ states.push({
+ state: workspace.getState(),
+ id: workspace.id
+ });
+ });
+
+ return states;
+ });
}
- });
+ }
+
+ registerIpcListener() {
+ logger.info("[WORKSPACE-STORE] starting to listen state events");
+ ipcRenderer.on("workspace:state", (event, workspaceId: string, state: WorkspaceState) => {
+ this.getById(workspaceId)?.setState(state);
+ });
+ }
+
+ unregisterIpcListener() {
+ super.unregisterIpcListener();
+ ipcRenderer.removeAllListeners("workspace:state");
+ }
@computed get currentWorkspace(): Workspace {
return this.getById(this.currentWorkspaceId);
@@ -43,6 +213,16 @@ export class WorkspaceStore extends BaseStore {
return Array.from(this.workspaces.values());
}
+ @computed get enabledWorkspacesList() {
+ return this.workspacesList.filter((w) => w.enabled);
+ }
+
+ pushState() {
+ this.workspaces.forEach((w) => {
+ w.pushState();
+ });
+ }
+
isDefault(id: WorkspaceId) {
return id === WorkspaceStore.defaultId;
}
@@ -56,69 +236,94 @@ export class WorkspaceStore extends BaseStore {
}
@action
- setActive(id = WorkspaceStore.defaultId, { redirectToLanding = true, resetActiveCluster = true } = {}) {
+ setActive(id = WorkspaceStore.defaultId) {
if (id === this.currentWorkspaceId) return;
+
if (!this.getById(id)) {
throw new Error(`workspace ${id} doesn't exist`);
}
this.currentWorkspaceId = id;
- if (resetActiveCluster) {
- clusterStore.setActive(null)
- }
- if (redirectToLanding) {
- navigate(landingURL())
- }
}
@action
- saveWorkspace(workspace: Workspace) {
+ addWorkspace(workspace: Workspace) {
const { id, name } = workspace;
- const existingWorkspace = this.getById(id);
+
if (!name.trim() || this.getByName(name.trim())) {
return;
}
- if (existingWorkspace) {
- Object.assign(existingWorkspace, workspace);
- }
this.workspaces.set(id, workspace);
+
+ if (!workspace.isManaged) {
+ workspace.enabled = true;
+ }
+
+ appEventBus.emit({name: "workspace", action: "add"});
+
return workspace;
}
@action
- removeWorkspace(id: WorkspaceId) {
+ updateWorkspace(workspace: Workspace) {
+ this.workspaces.set(workspace.id, workspace);
+ appEventBus.emit({name: "workspace", action: "update"});
+ }
+
+ @action
+ removeWorkspace(workspace: Workspace) {
+ this.removeWorkspaceById(workspace.id);
+ }
+
+ @action
+ removeWorkspaceById(id: WorkspaceId) {
const workspace = this.getById(id);
+
if (!workspace) return;
+
if (this.isDefault(id)) {
throw new Error("Cannot remove default workspace");
}
+
if (this.currentWorkspaceId === id) {
this.currentWorkspaceId = WorkspaceStore.defaultId; // reset to default
}
this.workspaces.delete(id);
- clusterStore.removeByWorkspaceId(id)
+ appEventBus.emit({name: "workspace", action: "remove"});
+ clusterStore.removeByWorkspaceId(id);
+ }
+
+ @action
+ setLastActiveClusterId(clusterId?: ClusterId, workspaceId = this.currentWorkspaceId) {
+ this.getById(workspaceId).lastActiveClusterId = clusterId;
}
@action
protected fromStore({ currentWorkspace, workspaces = [] }: WorkspaceStoreModel) {
if (currentWorkspace) {
- this.currentWorkspaceId = currentWorkspace
+ this.currentWorkspaceId = currentWorkspace;
}
+
if (workspaces.length) {
this.workspaces.clear();
- workspaces.forEach(workspace => {
- this.workspaces.set(workspace.id, workspace)
- })
+ workspaces.forEach(ws => {
+ const workspace = new Workspace(ws);
+
+ if (!workspace.isManaged) {
+ workspace.enabled = true;
+ }
+ this.workspaces.set(workspace.id, workspace);
+ });
}
}
toJSON(): WorkspaceStoreModel {
return toJS({
currentWorkspace: this.currentWorkspaceId,
- workspaces: this.workspacesList,
+ workspaces: this.workspacesList.map((w) => w.toJSON()),
}, {
recurseEverything: true
- })
+ });
}
}
-export const workspaceStore = WorkspaceStore.getInstance()
+export const workspaceStore = WorkspaceStore.getInstance();
diff --git a/src/extensions/__tests__/extension-discovery.test.ts b/src/extensions/__tests__/extension-discovery.test.ts
new file mode 100644
index 0000000000..d0066c3a7e
--- /dev/null
+++ b/src/extensions/__tests__/extension-discovery.test.ts
@@ -0,0 +1,97 @@
+import { watch } from "chokidar";
+import { join, normalize } from "path";
+import { ExtensionDiscovery, InstalledExtension } from "../extension-discovery";
+
+jest.mock("../../common/ipc");
+jest.mock("fs-extra");
+jest.mock("chokidar", () => ({
+ watch: jest.fn()
+}));
+jest.mock("../extension-installer", () => ({
+ extensionInstaller: {
+ extensionPackagesRoot: "",
+ installPackage: jest.fn()
+ }
+}));
+
+const mockedWatch = watch as jest.MockedFunction;
+
+describe("ExtensionDiscovery", () => {
+ it("emits add for added extension", async done => {
+ globalThis.__non_webpack_require__.mockImplementation(() => ({
+ name: "my-extension"
+ }));
+ let addHandler: (filePath: string) => void;
+
+ const mockWatchInstance: any = {
+ on: jest.fn((event: string, handler: typeof addHandler) => {
+ if (event === "add") {
+ addHandler = handler;
+ }
+
+ return mockWatchInstance;
+ })
+ };
+
+ mockedWatch.mockImplementationOnce(() =>
+ (mockWatchInstance) as any
+ );
+ const extensionDiscovery = new ExtensionDiscovery();
+
+ // Need to force isLoaded to be true so that the file watching is started
+ extensionDiscovery.isLoaded = true;
+
+ await extensionDiscovery.watchExtensions();
+
+ extensionDiscovery.events.on("add", (extension: InstalledExtension) => {
+ expect(extension).toEqual({
+ absolutePath: expect.any(String),
+ id: normalize("node_modules/my-extension/package.json"),
+ isBundled: false,
+ isEnabled: false,
+ manifest: {
+ name: "my-extension",
+ },
+ manifestPath: normalize("node_modules/my-extension/package.json"),
+ });
+ done();
+ });
+
+ addHandler(join(extensionDiscovery.localFolderPath, "/my-extension/package.json"));
+ });
+
+ it("doesn't emit add for added file under extension", async done => {
+ let addHandler: (filePath: string) => void;
+
+ const mockWatchInstance: any = {
+ on: jest.fn((event: string, handler: typeof addHandler) => {
+ if (event === "add") {
+ addHandler = handler;
+ }
+
+ return mockWatchInstance;
+ })
+ };
+
+ mockedWatch.mockImplementationOnce(() =>
+ (mockWatchInstance) as any
+ );
+ const extensionDiscovery = new ExtensionDiscovery();
+
+ // Need to force isLoaded to be true so that the file watching is started
+ extensionDiscovery.isLoaded = true;
+
+ await extensionDiscovery.watchExtensions();
+
+ const onAdd = jest.fn();
+
+ extensionDiscovery.events.on("add", onAdd);
+
+ addHandler(join(extensionDiscovery.localFolderPath, "/my-extension/node_modules/dep/package.json"));
+
+ setTimeout(() => {
+ expect(onAdd).not.toHaveBeenCalled();
+ done();
+ }, 10);
+ });
+});
diff --git a/src/extensions/__tests__/extension-loader.test.ts b/src/extensions/__tests__/extension-loader.test.ts
new file mode 100644
index 0000000000..335eb50912
--- /dev/null
+++ b/src/extensions/__tests__/extension-loader.test.ts
@@ -0,0 +1,166 @@
+import { ExtensionLoader } from "../extension-loader";
+import { ipcRenderer } from "electron";
+import { extensionsStore } from "../extensions-store";
+
+const manifestPath = "manifest/path";
+const manifestPath2 = "manifest/path2";
+const manifestPath3 = "manifest/path3";
+
+jest.mock("../extensions-store", () => ({
+ extensionsStore: {
+ whenLoaded: Promise.resolve(true),
+ mergeState: jest.fn()
+ }
+}));
+
+jest.mock(
+ "electron",
+ () => ({
+ ipcRenderer: {
+ invoke: jest.fn(async (channel: string) => {
+ if (channel === "extensions:main") {
+ return [
+ [
+ manifestPath,
+ {
+ manifest: {
+ name: "TestExtension",
+ version: "1.0.0",
+ },
+ id: manifestPath,
+ absolutePath: "/test/1",
+ manifestPath,
+ isBundled: false,
+ isEnabled: true,
+ },
+ ],
+ [
+ manifestPath2,
+ {
+ manifest: {
+ name: "TestExtension2",
+ version: "2.0.0",
+ },
+ id: manifestPath2,
+ absolutePath: "/test/2",
+ manifestPath: manifestPath2,
+ isBundled: false,
+ isEnabled: true,
+ },
+ ],
+ ];
+ }
+ }),
+ on: jest.fn(
+ (channel: string, listener: (event: any, ...args: any[]) => void) => {
+ if (channel === "extensions:main") {
+ // First initialize with extensions 1 and 2
+ // and then broadcast event to remove extensioin 2 and add extension number 3
+ setTimeout(() => {
+ listener({}, [
+ [
+ manifestPath,
+ {
+ manifest: {
+ name: "TestExtension",
+ version: "1.0.0",
+ },
+ id: manifestPath,
+ absolutePath: "/test/1",
+ manifestPath,
+ isBundled: false,
+ isEnabled: true,
+ },
+ ],
+ [
+ manifestPath3,
+ {
+ manifest: {
+ name: "TestExtension3",
+ version: "3.0.0",
+ },
+ id: manifestPath3,
+ absolutePath: "/test/3",
+ manifestPath: manifestPath3,
+ isBundled: false,
+ isEnabled: true,
+ },
+ ],
+ ]);
+ }, 10);
+ }
+ }
+ ),
+ },
+ }),
+ {
+ virtual: true,
+ }
+);
+
+describe("ExtensionLoader", () => {
+ it("renderer updates extension after ipc broadcast", async (done) => {
+ const extensionLoader = new ExtensionLoader();
+
+ expect(extensionLoader.userExtensions).toMatchInlineSnapshot(`Map {}`);
+
+ await extensionLoader.init();
+
+ setTimeout(() => {
+ // Assert the extensions after the extension broadcast event
+ expect(extensionLoader.userExtensions).toMatchInlineSnapshot(`
+ Map {
+ "manifest/path" => Object {
+ "absolutePath": "/test/1",
+ "id": "manifest/path",
+ "isBundled": false,
+ "isEnabled": true,
+ "manifest": Object {
+ "name": "TestExtension",
+ "version": "1.0.0",
+ },
+ "manifestPath": "manifest/path",
+ },
+ "manifest/path3" => Object {
+ "absolutePath": "/test/3",
+ "id": "manifest/path3",
+ "isBundled": false,
+ "isEnabled": true,
+ "manifest": Object {
+ "name": "TestExtension3",
+ "version": "3.0.0",
+ },
+ "manifestPath": "manifest/path3",
+ },
+ }
+ `);
+
+ done();
+ }, 10);
+ });
+
+ it("updates ExtensionsStore after isEnabled is changed", async () => {
+ (extensionsStore.mergeState as any).mockClear();
+
+ // Disable sending events in this test
+ (ipcRenderer.on as any).mockImplementation();
+
+ const extensionLoader = new ExtensionLoader();
+
+ await extensionLoader.init();
+
+ expect(extensionsStore.mergeState).not.toHaveBeenCalled();
+
+ Array.from(extensionLoader.userExtensions.values())[0].isEnabled = false;
+
+ expect(extensionsStore.mergeState).toHaveBeenCalledWith({
+ "manifest/path": {
+ enabled: false,
+ name: "TestExtension"
+ },
+ "manifest/path2": {
+ enabled: true,
+ name: "TestExtension2"
+ }});
+ });
+});
diff --git a/src/extensions/__tests__/lens-extension.test.ts b/src/extensions/__tests__/lens-extension.test.ts
new file mode 100644
index 0000000000..897c246674
--- /dev/null
+++ b/src/extensions/__tests__/lens-extension.test.ts
@@ -0,0 +1,25 @@
+import { LensExtension } from "../lens-extension";
+
+let ext: LensExtension = null;
+
+describe("lens extension", () => {
+ beforeEach(async () => {
+ ext = new LensExtension({
+ manifest: {
+ name: "foo-bar",
+ version: "0.1.1"
+ },
+ id: "/this/is/fake/package.json",
+ absolutePath: "/absolute/fake/",
+ manifestPath: "/this/is/fake/package.json",
+ isBundled: false,
+ isEnabled: true
+ });
+ });
+
+ describe("name", () => {
+ it("returns name", () => {
+ expect(ext.name).toBe("foo-bar");
+ });
+ });
+});
diff --git a/src/extensions/cluster-feature.ts b/src/extensions/cluster-feature.ts
new file mode 100644
index 0000000000..36a2f0bfb8
--- /dev/null
+++ b/src/extensions/cluster-feature.ts
@@ -0,0 +1,128 @@
+import fs from "fs";
+import path from "path";
+import hb from "handlebars";
+import { observable } from "mobx";
+import { ResourceApplier } from "../main/resource-applier";
+import { Cluster } from "../main/cluster";
+import logger from "../main/logger";
+import { app } from "electron";
+import { requestMain } from "../common/ipc";
+import { clusterKubectlApplyAllHandler } from "../common/cluster-ipc";
+
+export interface ClusterFeatureStatus {
+ /** feature's current version, as set by the implementation */
+ currentVersion: string;
+ /** feature's latest version, as set by the implementation */
+ latestVersion: string;
+ /** whether the feature is installed or not, as set by the implementation */
+ installed: boolean;
+ /** whether the feature can be upgraded or not, as set by the implementation */
+ canUpgrade: boolean;
+}
+
+export abstract class ClusterFeature {
+
+ /**
+ * this field sets the template parameters that are to be applied to any templated kubernetes resources that are to be installed for the feature.
+ * See the renderTemplates() method for more details
+ */
+ templateContext: any;
+
+ /**
+ * this field holds the current feature status, is accessed directly by Lens
+ */
+ @observable status: ClusterFeatureStatus = {
+ currentVersion: null,
+ installed: false,
+ latestVersion: null,
+ canUpgrade: false
+ };
+
+ /**
+ * to be implemented in the derived class, this method is typically called by Lens when a user has indicated that this feature is to be installed. The implementation
+ * of this method should install kubernetes resources using the applyResources() method, or by directly accessing the kubernetes api (K8sApi)
+ *
+ * @param cluster the cluster that the feature is to be installed on
+ */
+ abstract async install(cluster: Cluster): Promise;
+
+ /**
+ * to be implemented in the derived class, this method is typically called by Lens when a user has indicated that this feature is to be upgraded. The implementation
+ * of this method should upgrade the kubernetes resources already installed, if relevant to the feature
+ *
+ * @param cluster the cluster that the feature is to be upgraded on
+ */
+ abstract async upgrade(cluster: Cluster): Promise;
+
+ /**
+ * to be implemented in the derived class, this method is typically called by Lens when a user has indicated that this feature is to be uninstalled. The implementation
+ * of this method should uninstall kubernetes resources using the kubernetes api (K8sApi)
+ *
+ * @param cluster the cluster that the feature is to be uninstalled from
+ */
+ abstract async uninstall(cluster: Cluster): Promise;
+
+ /**
+ * to be implemented in the derived class, this method is called periodically by Lens to determine details about the feature's current status. The implementation
+ * of this method should provide the current status information. The currentVersion and latestVersion fields may be displayed by Lens in describing the feature.
+ * The installed field should be set to true if the feature has been installed, otherwise false. Also, Lens relies on the canUpgrade field to determine if the feature
+ * can be upgraded so the implementation should set the canUpgrade field according to specific rules for the feature, if relevant.
+ *
+ * @param cluster the cluster that the feature may be installed on
+ *
+ * @return a promise, resolved with the updated ClusterFeatureStatus
+ */
+ abstract async updateStatus(cluster: Cluster): Promise;
+
+ /**
+ * this is a helper method that conveniently applies kubernetes resources to the cluster.
+ *
+ * @param cluster the cluster that the resources are to be applied to
+ * @param resourceSpec as a string type this is a folder path that is searched for files specifying kubernetes resources. The files are read and if any of the resource
+ * files are templated, the template parameters are filled using the templateContext field (See renderTemplate() method). Finally the resources are applied to the
+ * cluster. As a string[] type resourceSpec is treated as an array of fully formed (not templated) kubernetes resources that are applied to the cluster
+ */
+ protected async applyResources(cluster: Cluster, resourceSpec: string | string[]) {
+ let resources: string[];
+
+ if ( typeof resourceSpec === "string" ) {
+ resources = this.renderTemplates(resourceSpec);
+ } else {
+ resources = resourceSpec;
+ }
+
+ if (app) {
+ await new ResourceApplier(cluster).kubectlApplyAll(resources);
+ } else {
+ await requestMain(clusterKubectlApplyAllHandler, cluster.id, resources);
+ }
+ }
+
+ /**
+ * this is a helper method that conveniently reads kubernetes resource files into a string array. It also fills templated resource files with the template parameter values
+ * specified by the templateContext field. Templated files must end with the extension '.hb' and the template syntax must be compatible with handlebars.js
+ *
+ * @param folderPath this is a folder path that is searched for files defining kubernetes resources.
+ *
+ * @return an array of strings, each string being the contents of a resource file found in the folder path. This can be passed directly to applyResources()
+ */
+ protected renderTemplates(folderPath: string): string[] {
+ const resources: string[] = [];
+
+ logger.info(`[FEATURE]: render templates from ${folderPath}`);
+ fs.readdirSync(folderPath).forEach(filename => {
+ const file = path.join(folderPath, filename);
+ const raw = fs.readFileSync(file);
+
+ if (filename.endsWith(".hb")) {
+ const template = hb.compile(raw.toString());
+
+ resources.push(template(this.templateContext));
+ } else {
+ resources.push(raw.toString());
+ }
+ });
+
+ return resources;
+ }
+}
diff --git a/src/extensions/core-api/app.ts b/src/extensions/core-api/app.ts
new file mode 100644
index 0000000000..2c3a7a4f59
--- /dev/null
+++ b/src/extensions/core-api/app.ts
@@ -0,0 +1,9 @@
+import { getAppVersion } from "../../common/utils";
+import { extensionsStore } from "../extensions-store";
+
+export const version = getAppVersion();
+export { isSnap, isWindows, isMac, isLinux, appName, slackUrl, issuesTrackerUrl } from "../../common/vars";
+
+export function getEnabledExtensions(): string[] {
+ return extensionsStore.enabledExtensions;
+}
diff --git a/src/extensions/core-api/cluster-feature.ts b/src/extensions/core-api/cluster-feature.ts
new file mode 100644
index 0000000000..170f4543f3
--- /dev/null
+++ b/src/extensions/core-api/cluster-feature.ts
@@ -0,0 +1,2 @@
+export { ClusterFeature as Feature } from "../cluster-feature";
+export type { ClusterFeatureStatus as FeatureStatus } from "../cluster-feature";
diff --git a/src/extensions/core-api/event-bus.ts b/src/extensions/core-api/event-bus.ts
new file mode 100644
index 0000000000..1a7be58143
--- /dev/null
+++ b/src/extensions/core-api/event-bus.ts
@@ -0,0 +1,2 @@
+export { appEventBus } from "../../common/event-bus";
+export type { AppEvent } from "../../common/event-bus";
diff --git a/src/extensions/core-api/index.ts b/src/extensions/core-api/index.ts
new file mode 100644
index 0000000000..19ede51817
--- /dev/null
+++ b/src/extensions/core-api/index.ts
@@ -0,0 +1,20 @@
+// Lens-extensions api developer's kit
+export * from "../lens-main-extension";
+export * from "../lens-renderer-extension";
+
+// APIs
+import * as App from "./app";
+import * as EventBus from "./event-bus";
+import * as Store from "./stores";
+import * as Util from "./utils";
+import * as ClusterFeature from "./cluster-feature";
+import * as Interface from "../interfaces";
+
+export {
+ App,
+ EventBus,
+ ClusterFeature,
+ Interface,
+ Store,
+ Util,
+};
diff --git a/src/extensions/core-api/stores.ts b/src/extensions/core-api/stores.ts
new file mode 100644
index 0000000000..706c336fdf
--- /dev/null
+++ b/src/extensions/core-api/stores.ts
@@ -0,0 +1,8 @@
+export { ExtensionStore } from "../extension-store";
+
+export { clusterStore, Cluster, ClusterStore } from "../stores/cluster-store";
+export type { ClusterModel, ClusterId } from "../stores/cluster-store";
+
+export { workspaceStore, Workspace, WorkspaceStore } from "../stores/workspace-store";
+export type { WorkspaceId, WorkspaceModel } from "../stores/workspace-store";
+
diff --git a/src/extensions/core-api/utils.ts b/src/extensions/core-api/utils.ts
new file mode 100644
index 0000000000..c249ff5238
--- /dev/null
+++ b/src/extensions/core-api/utils.ts
@@ -0,0 +1,3 @@
+export { Singleton, openExternal } from "../../common/utils";
+export { prevDefault, stopPropagation } from "../../renderer/utils/prevDefault";
+export { cssNames } from "../../renderer/utils/cssNames";
diff --git a/src/extensions/extension-api.ts b/src/extensions/extension-api.ts
new file mode 100644
index 0000000000..e4a8a77334
--- /dev/null
+++ b/src/extensions/extension-api.ts
@@ -0,0 +1,4 @@
+// Extension-api types generation bundle
+
+export * from "./core-api";
+export * from "./renderer-api";
diff --git a/src/extensions/extension-discovery.ts b/src/extensions/extension-discovery.ts
new file mode 100644
index 0000000000..0994f89995
--- /dev/null
+++ b/src/extensions/extension-discovery.ts
@@ -0,0 +1,466 @@
+import { watch } from "chokidar";
+import { ipcRenderer } from "electron";
+import { EventEmitter } from "events";
+import fs from "fs-extra";
+import { observable, reaction, toJS, when } from "mobx";
+import os from "os";
+import path from "path";
+import { broadcastMessage, handleRequest, requestMain, subscribeToBroadcast } from "../common/ipc";
+import { getBundledExtensions } from "../common/utils/app-version";
+import logger from "../main/logger";
+import { extensionInstaller, PackageJson } from "./extension-installer";
+import { extensionsStore } from "./extensions-store";
+import type { LensExtensionId, LensExtensionManifest } from "./lens-extension";
+
+export interface InstalledExtension {
+ id: LensExtensionId;
+
+ readonly manifest: LensExtensionManifest;
+
+ // Absolute path to the non-symlinked source folder,
+ // e.g. "/Users/user/.k8slens/extensions/helloworld"
+ readonly absolutePath: string;
+
+ // Absolute to the symlinked package.json file
+ readonly manifestPath: string;
+ readonly isBundled: boolean; // defined in project root's package.json
+ isEnabled: boolean;
+ }
+
+const logModule = "[EXTENSION-DISCOVERY]";
+
+export const manifestFilename = "package.json";
+
+interface ExtensionDiscoveryChannelMessage {
+ isLoaded: boolean;
+}
+
+/**
+ * Returns true if the lstat is for a directory-like file (e.g. isDirectory or symbolic link)
+ * @param lstat the stats to compare
+ */
+const isDirectoryLike = (lstat: fs.Stats) => lstat.isDirectory() || lstat.isSymbolicLink();
+
+/**
+ * Discovers installed bundled and local extensions from the filesystem.
+ * Also watches for added and removed local extensions by watching the directory.
+ * Uses ExtensionInstaller to install dependencies for all of the extensions.
+ * This is also done when a new extension is copied to the local extensions directory.
+ * .init() must be called to start the directory watching.
+ * The class emits events for added and removed extensions:
+ * - "add": When extension is added. The event is of type InstalledExtension
+ * - "remove": When extension is removed. The event is of type LensExtensionId
+ */
+export class ExtensionDiscovery {
+ protected bundledFolderPath: string;
+
+ private loadStarted = false;
+ private extensions: Map = new Map();
+
+ // True if extensions have been loaded from the disk after app startup
+ @observable isLoaded = false;
+ whenLoaded = when(() => this.isLoaded);
+
+ // IPC channel to broadcast changes to extension-discovery from main
+ protected static readonly extensionDiscoveryChannel = "extension-discovery:main";
+
+ public events: EventEmitter;
+
+ constructor() {
+ this.events = new EventEmitter();
+ }
+
+ get localFolderPath(): string {
+ return path.join(os.homedir(), ".k8slens", "extensions");
+ }
+
+ get packageJsonPath() {
+ return path.join(extensionInstaller.extensionPackagesRoot, manifestFilename);
+ }
+
+ get inTreeTargetPath() {
+ return path.join(extensionInstaller.extensionPackagesRoot, "extensions");
+ }
+
+ get inTreeFolderPath(): string {
+ return path.resolve(__static, "../extensions");
+ }
+
+ get nodeModulesPath(): string {
+ return path.join(extensionInstaller.extensionPackagesRoot, "node_modules");
+ }
+
+ /**
+ * Initializes the class and setups the file watcher for added/removed local extensions.
+ */
+ async init() {
+ if (ipcRenderer) {
+ await this.initRenderer();
+ } else {
+ await this.initMain();
+ }
+ }
+
+ async initRenderer() {
+ const onMessage = ({ isLoaded }: ExtensionDiscoveryChannelMessage) => {
+ this.isLoaded = isLoaded;
+ };
+
+ requestMain(ExtensionDiscovery.extensionDiscoveryChannel).then(onMessage);
+ subscribeToBroadcast(ExtensionDiscovery.extensionDiscoveryChannel, (_event, message: ExtensionDiscoveryChannelMessage) => {
+ onMessage(message);
+ });
+ }
+
+ async initMain() {
+ handleRequest(ExtensionDiscovery.extensionDiscoveryChannel, () => this.toJSON());
+
+ reaction(() => this.toJSON(), () => {
+ this.broadcast();
+ });
+ }
+
+ /**
+ * Watches for added/removed local extensions.
+ * Dependencies are installed automatically after an extension folder is copied.
+ */
+ async watchExtensions() {
+ logger.info(`${logModule} watching extension add/remove in ${this.localFolderPath}`);
+
+ // Wait until .load() has been called and has been resolved
+ await this.whenLoaded;
+
+ // chokidar works better than fs.watch
+ watch(this.localFolderPath, {
+ // For adding and removing symlinks to work, the depth has to be 1.
+ depth: 1,
+ ignoreInitial: true,
+ // Try to wait until the file has been completely copied.
+ // The OS might emit an event for added file even it's not completely written to the filesysten.
+ awaitWriteFinish: {
+ // Wait 300ms until the file size doesn't change to consider the file written.
+ // For a small file like package.json this should be plenty of time.
+ stabilityThreshold: 300
+ }
+ })
+ // Extension add is detected by watching "/package.json" add
+ .on("add", this.handleWatchFileAdd)
+ // Extension remove is detected by watching " unlink
+ .on("unlinkDir", this.handleWatchUnlinkDir);
+ }
+
+ handleWatchFileAdd = async (manifestPath: string) => {
+ // e.g. "foo/package.json"
+ const relativePath = path.relative(this.localFolderPath, manifestPath);
+
+ // Converts "foo/package.json" to ["foo", "package.json"], where length of 2 implies
+ // that the added file is in a folder under local folder path.
+ // This safeguards against a file watch being triggered under a sub-directory which is not an extension.
+ const isUnderLocalFolderPath = relativePath.split(path.sep).length === 2;
+
+ if (path.basename(manifestPath) === manifestFilename && isUnderLocalFolderPath) {
+ try {
+ const absPath = path.dirname(manifestPath);
+
+ // this.loadExtensionFromPath updates this.packagesJson
+ const extension = await this.loadExtensionFromFolder(absPath);
+
+ if (extension) {
+ // Remove a broken symlink left by a previous installation if it exists.
+ await this.removeSymlinkByManifestPath(manifestPath);
+
+ // Install dependencies for the new extension
+ await this.installPackage(extension.absolutePath);
+
+ this.extensions.set(extension.id, extension);
+ logger.info(`${logModule} Added extension ${extension.manifest.name}`);
+ this.events.emit("add", extension);
+ }
+ } catch (error) {
+ console.error(error);
+ }
+ }
+ };
+
+ handleWatchUnlinkDir = async (filePath: string) => {
+ // filePath is the non-symlinked path to the extension folder
+ // this.packagesJson.dependencies value is the non-symlinked path to the extension folder
+ // LensExtensionId in extension-loader is the symlinked path to the extension folder manifest file
+
+ // Check that the removed path is directly under this.localFolderPath
+ // Note that the watcher can create unlink events for subdirectories of the extension
+ const extensionFolderName = path.basename(filePath);
+
+ if (path.relative(this.localFolderPath, filePath) === extensionFolderName) {
+ const extension = Array.from(this.extensions.values()).find((extension) => extension.absolutePath === filePath);
+
+ if (extension) {
+ const extensionName = extension.manifest.name;
+
+ // If the extension is deleted manually while the application is running, also remove the symlink
+ await this.removeSymlinkByPackageName(extensionName);
+
+ // The path to the manifest file is the lens extension id
+ // Note that we need to use the symlinked path
+ const lensExtensionId = extension.manifestPath;
+
+ this.extensions.delete(extension.id);
+ logger.info(`${logModule} removed extension ${extensionName}`);
+ this.events.emit("remove", lensExtensionId as LensExtensionId);
+ } else {
+ logger.warn(`${logModule} extension ${extensionFolderName} not found, can't remove`);
+ }
+ }
+ };
+
+ /**
+ * Remove the symlink under node_modules if exists.
+ * If we don't remove the symlink, the uninstall would leave a non-working symlink,
+ * which wouldn't be fixed if the extension was reinstalled, causing the extension not to work.
+ * @param name e.g. "@mirantis/lens-extension-cc"
+ */
+ removeSymlinkByPackageName(name: string) {
+ return fs.remove(this.getInstalledPath(name));
+ }
+
+ /**
+ * Remove the symlink under node_modules if it exists.
+ * @param manifestPath Path to package.json
+ */
+ removeSymlinkByManifestPath(manifestPath: string) {
+ const manifestJson = __non_webpack_require__(manifestPath);
+
+ return this.removeSymlinkByPackageName(manifestJson.name);
+ }
+
+ /**
+ * Uninstalls extension.
+ * The application will detect the folder unlink and remove the extension from the UI automatically.
+ * @param extension Extension to unistall.
+ */
+ async uninstallExtension({ absolutePath, manifest }: InstalledExtension) {
+ logger.info(`${logModule} Uninstalling ${manifest.name}`);
+
+ await this.removeSymlinkByPackageName(manifest.name);
+
+ // fs.remove does nothing if the path doesn't exist anymore
+ await fs.remove(absolutePath);
+ }
+
+ async load(): Promise> {
+ if (this.loadStarted) {
+ // The class is simplified by only supporting .load() to be called once
+ throw new Error("ExtensionDiscovery.load() can be only be called once");
+ }
+
+ this.loadStarted = true;
+
+ logger.info(`${logModule} loading extensions from ${extensionInstaller.extensionPackagesRoot}`);
+
+ // fs.remove won't throw if path is missing
+ await fs.remove(path.join(extensionInstaller.extensionPackagesRoot, "package-lock.json"));
+
+
+ try {
+ // Verify write access to static/extensions, which is needed for symlinking
+ await fs.access(this.inTreeFolderPath, fs.constants.W_OK);
+
+ // Set bundled folder path to static/extensions
+ this.bundledFolderPath = this.inTreeFolderPath;
+ } catch {
+ // If there is error accessing static/extensions, we need to copy in-tree extensions so that we can symlink them properly on "npm install".
+ // The error can happen if there is read-only rights to static/extensions, which would fail symlinking.
+
+ // Remove e.g. /Users//Library/Application Support/LensDev/extensions
+ await fs.remove(this.inTreeTargetPath);
+
+ // Create folder e.g. /Users//Library/Application Support/LensDev/extensions
+ await fs.ensureDir(this.inTreeTargetPath);
+
+ // Copy static/extensions to e.g. /Users//Library/Application Support/LensDev/extensions
+ await fs.copy(this.inTreeFolderPath, this.inTreeTargetPath);
+
+ // Set bundled folder path to e.g. /Users//Library/Application Support/LensDev/extensions
+ this.bundledFolderPath = this.inTreeTargetPath;
+ }
+
+ await fs.ensureDir(this.nodeModulesPath);
+ await fs.ensureDir(this.localFolderPath);
+
+ const extensions = await this.ensureExtensions();
+
+ this.isLoaded = true;
+
+ return extensions;
+ }
+
+ /**
+ * Returns the symlinked path to the extension folder,
+ * e.g. "/Users//Library/Application Support/Lens/node_modules/@publisher/extension"
+ */
+ protected getInstalledPath(name: string) {
+ return path.join(this.nodeModulesPath, name);
+ }
+
+ /**
+ * Returns the symlinked path to the package.json,
+ * e.g. "/Users//Library/Application Support/Lens/node_modules/@publisher/extension/package.json"
+ */
+ protected getInstalledManifestPath(name: string) {
+ return path.join(this.getInstalledPath(name), manifestFilename);
+ }
+
+ /**
+ * Returns InstalledExtension from path to package.json file.
+ * Also updates this.packagesJson.
+ */
+ protected async getByManifest(manifestPath: string, { isBundled = false }: {
+ isBundled?: boolean;
+ } = {}): Promise {
+ let manifestJson: LensExtensionManifest;
+
+ try {
+ // check manifest file for existence
+ fs.accessSync(manifestPath, fs.constants.F_OK);
+
+ manifestJson = __non_webpack_require__(manifestPath);
+ const installedManifestPath = this.getInstalledManifestPath(manifestJson.name);
+
+ const isEnabled = isBundled || extensionsStore.isEnabled(installedManifestPath);
+
+ return {
+ id: installedManifestPath,
+ absolutePath: path.dirname(manifestPath),
+ manifestPath: installedManifestPath,
+ manifest: manifestJson,
+ isBundled,
+ isEnabled
+ };
+ } catch (error) {
+ logger.error(`${logModule}: can't load extension manifest at ${manifestPath}: ${error}`, { manifestJson });
+
+ return null;
+ }
+ }
+
+ async ensureExtensions(): Promise> {
+ const bundledExtensions = await this.loadBundledExtensions();
+
+ await this.installBundledPackages(this.packageJsonPath, bundledExtensions);
+
+ const userExtensions = await this.loadFromFolder(this.localFolderPath);
+
+ for (const extension of userExtensions) {
+ if (await fs.pathExists(extension.manifestPath) === false) {
+ await this.installPackage(extension.absolutePath);
+ }
+ }
+ const extensions = bundledExtensions.concat(userExtensions);
+
+ return this.extensions = new Map(extensions.map(extension => [extension.id, extension]));
+ }
+
+ /**
+ * Write package.json to file system and install dependencies.
+ */
+ async installBundledPackages(packageJsonPath: string, extensions: InstalledExtension[]) {
+ const packagesJson: PackageJson = {
+ dependencies: {}
+ };
+
+ extensions.forEach((extension) => {
+ packagesJson.dependencies[extension.manifest.name] = extension.absolutePath;
+ });
+
+ return await extensionInstaller.installPackages(packageJsonPath, packagesJson);
+ }
+
+ async installPackage(name: string) {
+ return extensionInstaller.installPackage(name);
+ }
+
+ async loadBundledExtensions() {
+ const extensions: InstalledExtension[] = [];
+ const folderPath = this.bundledFolderPath;
+ const bundledExtensions = getBundledExtensions();
+ const paths = await fs.readdir(folderPath);
+
+ for (const fileName of paths) {
+ if (!bundledExtensions.includes(fileName)) {
+ continue;
+ }
+
+ const absPath = path.resolve(folderPath, fileName);
+ const extension = await this.loadExtensionFromFolder(absPath, { isBundled: true });
+
+ if (extension) {
+ extensions.push(extension);
+ }
+ }
+ logger.debug(`${logModule}: ${extensions.length} extensions loaded`, { folderPath, extensions });
+
+ return extensions;
+ }
+
+ async loadFromFolder(folderPath: string): Promise {
+ const bundledExtensions = getBundledExtensions();
+ const extensions: InstalledExtension[] = [];
+ const paths = await fs.readdir(folderPath);
+
+ for (const fileName of paths) {
+ // do not allow to override bundled extensions
+ if (bundledExtensions.includes(fileName)) {
+ continue;
+ }
+
+ const absPath = path.resolve(folderPath, fileName);
+
+ if (!fs.existsSync(absPath)) {
+ continue;
+ }
+
+ const lstat = await fs.lstat(absPath);
+
+ // skip non-directories
+ if (!isDirectoryLike(lstat)) {
+ continue;
+ }
+
+ const extension = await this.loadExtensionFromFolder(absPath);
+
+ if (extension) {
+ extensions.push(extension);
+ }
+ }
+
+ logger.debug(`${logModule}: ${extensions.length} extensions loaded`, { folderPath, extensions });
+
+ return extensions;
+ }
+
+ /**
+ * Loads extension from absolute path, updates this.packagesJson to include it and returns the extension.
+ * @param absPath Folder path to extension
+ */
+ async loadExtensionFromFolder(absPath: string, { isBundled = false }: {
+ isBundled?: boolean;
+ } = {}): Promise {
+ const manifestPath = path.resolve(absPath, manifestFilename);
+
+ return this.getByManifest(manifestPath, { isBundled });
+ }
+
+ toJSON(): ExtensionDiscoveryChannelMessage {
+ return toJS({
+ isLoaded: this.isLoaded
+ }, {
+ recurseEverything: true
+ });
+ }
+
+ broadcast() {
+ broadcastMessage(ExtensionDiscovery.extensionDiscoveryChannel, this.toJSON());
+ }
+}
+
+export const extensionDiscovery = new ExtensionDiscovery();
diff --git a/src/extensions/extension-installer.ts b/src/extensions/extension-installer.ts
new file mode 100644
index 0000000000..04b78bbe1a
--- /dev/null
+++ b/src/extensions/extension-installer.ts
@@ -0,0 +1,98 @@
+import AwaitLock from "await-lock";
+import child_process from "child_process";
+import fs from "fs-extra";
+import path from "path";
+import logger from "../main/logger";
+import { extensionPackagesRoot } from "./extension-loader";
+
+const logModule = "[EXTENSION-INSTALLER]";
+
+type Dependencies = {
+ [name: string]: string;
+};
+
+// Type for the package.json file that is written by ExtensionInstaller
+export type PackageJson = {
+ dependencies: Dependencies;
+};
+
+/**
+ * Installs dependencies for extensions
+ */
+export class ExtensionInstaller {
+ private installLock = new AwaitLock();
+
+ get extensionPackagesRoot() {
+ return extensionPackagesRoot();
+ }
+
+ get npmPath() {
+ return __non_webpack_require__.resolve("npm/bin/npm-cli");
+ }
+
+ /**
+ * Write package.json to the file system and execute npm install for it.
+ */
+ async installPackages(packageJsonPath: string, packagesJson: PackageJson): Promise {
+ // Mutual exclusion to install packages in sequence
+ await this.installLock.acquireAsync();
+
+ try {
+ // Write the package.json which will be installed in .installDependencies()
+ await fs.writeFile(path.join(packageJsonPath), JSON.stringify(packagesJson, null, 2), {
+ mode: 0o600
+ });
+
+ logger.info(`${logModule} installing dependencies at ${extensionPackagesRoot()}`);
+ await this.npm(["install", "--no-audit", "--only=prod", "--prefer-offline", "--no-package-lock"]);
+ logger.info(`${logModule} dependencies installed at ${extensionPackagesRoot()}`);
+ } finally {
+ this.installLock.release();
+ }
+ }
+
+ /**
+ * Install single package using npm
+ */
+ async installPackage(name: string): Promise {
+ // Mutual exclusion to install packages in sequence
+ await this.installLock.acquireAsync();
+
+ try {
+ logger.info(`${logModule} installing package from ${name} to ${extensionPackagesRoot()}`);
+ await this.npm(["install", "--no-audit", "--only=prod", "--prefer-offline", "--no-package-lock", "--no-save", name]);
+ logger.info(`${logModule} package ${name} installed to ${extensionPackagesRoot()}`);
+ } finally {
+ this.installLock.release();
+ }
+ }
+
+ private npm(args: string[]): Promise {
+ return new Promise((resolve, reject) => {
+ const child = child_process.fork(this.npmPath, args, {
+ cwd: extensionPackagesRoot(),
+ silent: true,
+ env: {}
+ });
+ let stderr = "";
+
+ child.stderr.on("data", data => {
+ stderr += String(data);
+ });
+
+ child.on("close", (code) => {
+ if (code !== 0) {
+ reject(new Error(stderr));
+ } else {
+ resolve();
+ }
+ });
+
+ child.on("error", error => {
+ reject(error);
+ });
+ });
+ }
+}
+
+export const extensionInstaller = new ExtensionInstaller();
diff --git a/src/extensions/extension-loader.ts b/src/extensions/extension-loader.ts
new file mode 100644
index 0000000000..98697d252c
--- /dev/null
+++ b/src/extensions/extension-loader.ts
@@ -0,0 +1,309 @@
+import { app, ipcRenderer, remote } from "electron";
+import { EventEmitter } from "events";
+import { isEqual } from "lodash";
+import { action, computed, observable, reaction, toJS, when } from "mobx";
+import path from "path";
+import { getHostedCluster } from "../common/cluster-store";
+import { broadcastMessage, handleRequest, requestMain, subscribeToBroadcast } from "../common/ipc";
+import logger from "../main/logger";
+import type { InstalledExtension } from "./extension-discovery";
+import { extensionsStore } from "./extensions-store";
+import type { LensExtension, LensExtensionConstructor, LensExtensionId } from "./lens-extension";
+import type { LensMainExtension } from "./lens-main-extension";
+import type { LensRendererExtension } from "./lens-renderer-extension";
+import * as registries from "./registries";
+import fs from "fs";
+
+// lazy load so that we get correct userData
+export function extensionPackagesRoot() {
+ return path.join((app || remote.app).getPath("userData"));
+}
+
+const logModule = "[EXTENSIONS-LOADER]";
+
+/**
+ * Loads installed extensions to the Lens application
+ */
+export class ExtensionLoader {
+ protected extensions = observable.map();
+ protected instances = observable.map();
+
+ // IPC channel to broadcast changes to extensions from main
+ protected static readonly extensionsMainChannel = "extensions:main";
+
+ // IPC channel to broadcast changes to extensions from renderer
+ protected static readonly extensionsRendererChannel = "extensions:renderer";
+
+ // emits event "remove" of type LensExtension when the extension is removed
+ private events = new EventEmitter();
+
+ @observable isLoaded = false;
+ whenLoaded = when(() => this.isLoaded);
+
+ @computed get userExtensions(): Map {
+ const extensions = this.extensions.toJS();
+
+ extensions.forEach((ext, extId) => {
+ if (ext.isBundled) {
+ extensions.delete(extId);
+ }
+ });
+
+ return extensions;
+ }
+
+ // 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 (ipcRenderer) {
+ await this.initRenderer();
+ } else {
+ await this.initMain();
+ }
+
+ await Promise.all([this.whenLoaded, extensionsStore.whenLoaded]);
+
+ // save state on change `extension.isEnabled`
+ reaction(() => this.storeState, extensionsState => {
+ extensionsStore.mergeState(extensionsState);
+ });
+ }
+
+ initExtensions(extensions?: Map) {
+ this.extensions.replace(extensions);
+ }
+
+ addExtension(extension: InstalledExtension) {
+ this.extensions.set(extension.id, extension);
+ }
+
+ removeInstance(lensExtensionId: LensExtensionId) {
+ logger.info(`${logModule} deleting extension instance ${lensExtensionId}`);
+ const instance = this.instances.get(lensExtensionId);
+
+ if (!instance) {
+ return;
+ }
+
+ try {
+ instance.disable();
+ this.events.emit("remove", instance);
+ this.instances.delete(lensExtensionId);
+ } catch (error) {
+ 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.`);
+ }
+ }
+
+ protected async initMain() {
+ this.isLoaded = true;
+ this.loadOnMain();
+
+ reaction(() => this.toJSON(), () => {
+ this.broadcastExtensions();
+ });
+
+ handleRequest(ExtensionLoader.extensionsMainChannel, () => {
+ return Array.from(this.toJSON());
+ });
+
+ subscribeToBroadcast(ExtensionLoader.extensionsRendererChannel, (_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);
+ }
+ });
+ };
+
+ reaction(() => this.toJSON(), () => {
+ this.broadcastExtensions(false);
+ });
+
+ requestMain(ExtensionLoader.extensionsMainChannel).then(extensionListHandler);
+ subscribeToBroadcast(ExtensionLoader.extensionsMainChannel, (_event, extensions: [LensExtensionId, InstalledExtension][]) => {
+ extensionListHandler(extensions);
+ });
+ }
+
+ syncExtensions(extensions: [LensExtensionId, InstalledExtension][]) {
+ extensions.forEach(([lensExtensionId, extension]) => {
+ if (!isEqual(this.extensions.get(lensExtensionId), extension)) {
+ this.extensions.set(lensExtensionId, extension);
+ }
+ });
+ }
+
+ loadOnMain() {
+ logger.debug(`${logModule}: load on main`);
+ this.autoInitExtensions(async (extension: LensMainExtension) => {
+ // Each .add returns a function to remove the item
+ const removeItems = [
+ registries.menuRegistry.add(extension.appMenus)
+ ];
+
+ this.events.on("remove", (removedExtension: LensRendererExtension) => {
+ if (removedExtension.id === extension.id) {
+ removeItems.forEach(remove => {
+ remove();
+ });
+ }
+ });
+
+ return removeItems;
+ });
+ }
+
+ loadOnClusterManagerRenderer() {
+ logger.debug(`${logModule}: load on main renderer (cluster manager)`);
+ this.autoInitExtensions(async (extension: LensRendererExtension) => {
+ const removeItems = [
+ registries.globalPageRegistry.add(extension.globalPages, extension),
+ registries.globalPageMenuRegistry.add(extension.globalPageMenus, extension),
+ registries.appPreferenceRegistry.add(extension.appPreferences),
+ registries.clusterFeatureRegistry.add(extension.clusterFeatures),
+ registries.statusBarRegistry.add(extension.statusBarItems),
+ ];
+
+ this.events.on("remove", (removedExtension: LensRendererExtension) => {
+ if (removedExtension.id === extension.id) {
+ removeItems.forEach(remove => {
+ remove();
+ });
+ }
+ });
+
+ return removeItems;
+ });
+ }
+
+ loadOnClusterRenderer() {
+ logger.debug(`${logModule}: load on cluster renderer (dashboard)`);
+ const cluster = getHostedCluster();
+
+ this.autoInitExtensions(async (extension: LensRendererExtension) => {
+ if (await extension.isEnabledForCluster(cluster) === false) {
+ return [];
+ }
+
+ const removeItems = [
+ registries.clusterPageRegistry.add(extension.clusterPages, extension),
+ registries.clusterPageMenuRegistry.add(extension.clusterPageMenus, extension),
+ registries.kubeObjectMenuRegistry.add(extension.kubeObjectMenuItems),
+ registries.kubeObjectDetailRegistry.add(extension.kubeObjectDetailItems),
+ registries.kubeObjectStatusRegistry.add(extension.kubeObjectStatusTexts)
+ ];
+
+ this.events.on("remove", (removedExtension: LensRendererExtension) => {
+ if (removedExtension.id === extension.id) {
+ removeItems.forEach(remove => {
+ remove();
+ });
+ }
+ });
+
+ return removeItems;
+ });
+ }
+
+ protected autoInitExtensions(register: (ext: LensExtension) => Promise) {
+ return reaction(() => this.toJSON(), installedExtensions => {
+ for (const [extId, extension] of installedExtensions) {
+ const alreadyInit = this.instances.has(extId);
+
+ if (extension.isEnabled && !alreadyInit) {
+ try {
+ const LensExtensionClass = this.requireExtension(extension);
+
+ if (!LensExtensionClass) {
+ continue;
+ }
+
+ const instance = new LensExtensionClass(extension);
+
+ instance.whenEnabled(() => register(instance));
+ instance.enable();
+ this.instances.set(extId, instance);
+ } catch (err) {
+ logger.error(`${logModule}: activation extension error`, { ext: extension, err });
+ }
+ } else if (!extension.isEnabled && alreadyInit) {
+ this.removeInstance(extId);
+ }
+ }
+ }, {
+ fireImmediately: true,
+ });
+ }
+
+ protected requireExtension(extension: InstalledExtension): LensExtensionConstructor {
+ let extEntrypoint = "";
+
+ try {
+ if (ipcRenderer && extension.manifest.renderer) {
+ extEntrypoint = path.resolve(path.join(path.dirname(extension.manifestPath), extension.manifest.renderer));
+ } else if (!ipcRenderer && extension.manifest.main) {
+ extEntrypoint = path.resolve(path.join(path.dirname(extension.manifestPath), extension.manifest.main));
+ }
+
+ if (extEntrypoint !== "") {
+ if (!fs.existsSync(extEntrypoint)) {
+ console.log(`${logModule}: entrypoint ${extEntrypoint} not found, skipping ...`);
+
+ return;
+ }
+
+ return __non_webpack_require__(extEntrypoint).default;
+ }
+ } catch (err) {
+ console.error(`${logModule}: can't load extension main at ${extEntrypoint}: ${err}`, { extension });
+ console.trace(err);
+ }
+ }
+
+ getExtension(extId: LensExtensionId): InstalledExtension {
+ return this.extensions.get(extId);
+ }
+
+ toJSON(): Map {
+ return toJS(this.extensions, {
+ exportMapsAsObjects: false,
+ recurseEverything: true,
+ });
+ }
+
+ broadcastExtensions(main = true) {
+ broadcastMessage(main ? ExtensionLoader.extensionsMainChannel : ExtensionLoader.extensionsRendererChannel, Array.from(this.toJSON()));
+ }
+}
+
+export const extensionLoader = new ExtensionLoader();
diff --git a/src/extensions/extension-store.ts b/src/extensions/extension-store.ts
new file mode 100644
index 0000000000..c1a1e62bd8
--- /dev/null
+++ b/src/extensions/extension-store.ts
@@ -0,0 +1,23 @@
+import { BaseStore } from "../common/base-store";
+import * as path from "path";
+import { LensExtension } from "./lens-extension";
+
+export abstract class ExtensionStore extends BaseStore {
+ protected extension: LensExtension;
+
+ async loadExtension(extension: LensExtension) {
+ this.extension = extension;
+
+ return super.load();
+ }
+
+ async load() {
+ if (!this.extension) { return; }
+
+ return super.load();
+ }
+
+ protected cwd() {
+ return path.join(super.cwd(), "extension-store", this.extension.name);
+ }
+}
diff --git a/src/extensions/extensions-store.ts b/src/extensions/extensions-store.ts
new file mode 100644
index 0000000000..0885bbb730
--- /dev/null
+++ b/src/extensions/extensions-store.ts
@@ -0,0 +1,57 @@
+import type { LensExtensionId } from "./lens-extension";
+import { BaseStore } from "../common/base-store";
+import { action, computed, observable, toJS } from "mobx";
+
+export interface LensExtensionsStoreModel {
+ extensions: Record;
+}
+
+export interface LensExtensionState {
+ enabled?: boolean;
+ name: string;
+}
+
+export class ExtensionsStore extends BaseStore {
+ constructor() {
+ super({
+ configName: "lens-extensions",
+ });
+ }
+
+ @computed
+ get enabledExtensions() {
+ return Array.from(this.state.values())
+ .filter(({enabled}) => enabled)
+ .map(({name}) => name);
+ }
+
+ protected state = observable.map();
+
+ isEnabled(extId: LensExtensionId) {
+ const state = this.state.get(extId);
+
+ // By default false, so that copied extensions are disabled by default.
+ // If user installs the extension from the UI, the Extensions component will specifically enable it.
+ return Boolean(state?.enabled);
+ }
+
+ @action
+ mergeState(extensionsState: Record) {
+ this.state.merge(extensionsState);
+ }
+
+ @action
+ protected fromStore({ extensions }: LensExtensionsStoreModel) {
+ this.state.merge(extensions);
+ }
+
+ toJSON(): LensExtensionsStoreModel {
+ return toJS({
+ extensions: this.state.toJSON(),
+ }, {
+ recurseEverything: true
+ });
+ }
+}
+
+export const extensionsStore = new ExtensionsStore();
diff --git a/src/extensions/interfaces/index.ts b/src/extensions/interfaces/index.ts
new file mode 100644
index 0000000000..c91d8cdd19
--- /dev/null
+++ b/src/extensions/interfaces/index.ts
@@ -0,0 +1 @@
+export * from "./registrations";
\ No newline at end of file
diff --git a/src/extensions/interfaces/registrations.ts b/src/extensions/interfaces/registrations.ts
new file mode 100644
index 0000000000..47c63062ea
--- /dev/null
+++ b/src/extensions/interfaces/registrations.ts
@@ -0,0 +1,8 @@
+export type { AppPreferenceRegistration, AppPreferenceComponents } from "../registries/app-preference-registry";
+export type { ClusterFeatureRegistration, ClusterFeatureComponents } from "../registries/cluster-feature-registry";
+export type { KubeObjectDetailRegistration, KubeObjectDetailComponents } from "../registries/kube-object-detail-registry";
+export type { KubeObjectMenuRegistration, KubeObjectMenuComponents } from "../registries/kube-object-menu-registry";
+export type { KubeObjectStatusRegistration } from "../registries/kube-object-status-registry";
+export type { PageRegistration, RegisteredPage, PageParams, PageComponentProps, PageComponents, PageTarget } from "../registries/page-registry";
+export type { PageMenuRegistration, ClusterPageMenuRegistration, PageMenuComponents } from "../registries/page-menu-registry";
+export type { StatusBarRegistration } from "../registries/status-bar-registry";
\ No newline at end of file
diff --git a/src/extensions/lens-extension.ts b/src/extensions/lens-extension.ts
new file mode 100644
index 0000000000..aaa6f60ac5
--- /dev/null
+++ b/src/extensions/lens-extension.ts
@@ -0,0 +1,119 @@
+import type { InstalledExtension } from "./extension-discovery";
+import { action, observable, reaction } from "mobx";
+import { filesystemProvisionerStore } from "../main/extension-filesystem";
+import logger from "../main/logger";
+
+export type LensExtensionId = string; // path to manifest (package.json)
+export type LensExtensionConstructor = new (...args: ConstructorParameters) => LensExtension;
+
+export interface LensExtensionManifest {
+ name: string;
+ version: string;
+ description?: string;
+ main?: string; // path to %ext/dist/main.js
+ renderer?: string; // path to %ext/dist/renderer.js
+ lens?: object; // fixme: add more required fields for validation
+}
+
+export class LensExtension {
+ readonly id: LensExtensionId;
+ readonly manifest: LensExtensionManifest;
+ readonly manifestPath: string;
+ readonly isBundled: boolean;
+
+ @observable private isEnabled = false;
+
+ constructor({ id, manifest, manifestPath, isBundled }: InstalledExtension) {
+ this.id = id;
+ this.manifest = manifest;
+ this.manifestPath = manifestPath;
+ this.isBundled = !!isBundled;
+ }
+
+ get name() {
+ return this.manifest.name;
+ }
+
+ get version() {
+ return this.manifest.version;
+ }
+
+ /**
+ * getExtensionFileFolder returns the path to an already created folder. This
+ * folder is for the sole use of this extension.
+ *
+ * Note: there is no security done on this folder, only obfiscation of the
+ * folder name.
+ */
+ async getExtensionFileFolder(): Promise {
+ return filesystemProvisionerStore.requestDirectory(this.id);
+ }
+
+ get description() {
+ return this.manifest.description;
+ }
+
+ @action
+ async enable() {
+ if (this.isEnabled) return;
+ this.isEnabled = true;
+ this.onActivate();
+ logger.info(`[EXTENSION]: enabled ${this.name}@${this.version}`);
+ }
+
+ @action
+ async disable() {
+ if (!this.isEnabled) return;
+ this.isEnabled = false;
+ this.onDeactivate();
+ logger.info(`[EXTENSION]: disabled ${this.name}@${this.version}`);
+ }
+
+ toggle(enable?: boolean) {
+ if (typeof enable === "boolean") {
+ enable ? this.enable() : this.disable();
+ } else {
+ this.isEnabled ? this.disable() : this.enable();
+ }
+ }
+
+ async whenEnabled(handlers: () => Promise) {
+ const disposers: Function[] = [];
+ const unregisterHandlers = () => {
+ disposers.forEach(unregister => unregister());
+ disposers.length = 0;
+ };
+ const cancelReaction = reaction(() => this.isEnabled, async (isEnabled) => {
+ if (isEnabled) {
+ const handlerDisposers = await handlers();
+
+ disposers.push(...handlerDisposers);
+ } else {
+ unregisterHandlers();
+ }
+ }, {
+ fireImmediately: true
+ });
+
+ return () => {
+ unregisterHandlers();
+ cancelReaction();
+ };
+ }
+
+ protected onActivate() {
+ // mock
+ }
+
+ protected onDeactivate() {
+ // mock
+ }
+}
+
+export function sanitizeExtensionName(name: string) {
+ return name.replace("@", "").replace("/", "--");
+}
+
+export function extensionDisplayName(name: string, version: string) {
+ return `${name}@${version}`;
+}
diff --git a/src/extensions/lens-main-extension.ts b/src/extensions/lens-main-extension.ts
new file mode 100644
index 0000000000..f0e943540d
--- /dev/null
+++ b/src/extensions/lens-main-extension.ts
@@ -0,0 +1,19 @@
+import type { MenuRegistration } from "./registries/menu-registry";
+import { LensExtension } from "./lens-extension";
+import { WindowManager } from "../main/window-manager";
+import { getExtensionPageUrl } from "./registries/page-registry";
+
+export class LensMainExtension extends LensExtension {
+ appMenus: MenuRegistration[] = [];
+
+ async navigate(pageId?: string, params?: P, frameId?: number) {
+ const windowManager = WindowManager.getInstance