Merge remote-tracking branch 'origin/master' into mobx-6.2

# Conflicts:
#	src/common/catalog/catalog-entity-registry.ts
#	src/common/user-store.ts
#	src/main/catalog-pusher.ts
#	src/main/cluster-manager.ts
#	src/main/cluster.ts
#	src/main/index.ts
#	src/renderer/bootstrap.tsx
#	src/renderer/kube-object.store.ts

src/main/catalog-pusher.ts

@@ -1,7 +1,7 @@
-import { autorun } from "mobx";
-import { toJS } from "../common/utils";
+import { reaction } from "mobx";
+import { toJS, Disposer } from "../common/utils";
 import { broadcastMessage, subscribeToBroadcast, unsubscribeFromBroadcast } from "../common/ipc";
-import { CatalogEntityRegistry } from "../common/catalog";
+import { CatalogEntityRegistry} from "../common/catalog";
 import "../common/catalog-entities/kubernetes-cluster";
 
 export class CatalogPusher {
@@ -9,26 +9,23 @@ export class CatalogPusher {
     new CatalogPusher(catalog).init();
   }
 
-  private constructor(private catalog: CatalogEntityRegistry) {
-  }
+  private constructor(private catalog: CatalogEntityRegistry) {}
 
   init() {
-    const disposers: { (): void; }[] = [];
+    const disposers: Disposer[] = [];
 
-    disposers.push(autorun(() => {
-      this.broadcast();
+    disposers.push(reaction(() => this.catalog.items, (items) => {
+      broadcastMessage("catalog:items", toJS(items, { recurseEverything: true }));
+    }, {
+      fireImmediately: true,
     }));
 
     const listener = subscribeToBroadcast("catalog:broadcast", () => {
-      this.broadcast();
+      broadcastMessage("catalog:items", toJS(this.catalog.items, { recurseEverything: true }));
     });
 
     disposers.push(() => unsubscribeFromBroadcast("catalog:broadcast", listener));
 
     return disposers;
   }
-
-  broadcast() {
-    broadcastMessage("catalog:items", toJS(this.catalog.items));
-  }
 }

src/main/catalog-sources/__test__/kubeconfig-sync.test.ts

@@ -0,0 +1,252 @@
+import { ObservableMap } from "mobx";
+import { CatalogEntity } from "../../../common/catalog";
+import { loadFromOptions } from "../../../common/kube-helpers";
+import { Cluster } from "../../cluster";
+import { computeDiff, configToModels } from "../kubeconfig-sync";
+import mockFs from "mock-fs";
+import fs from "fs";
+
+describe("kubeconfig-sync.source tests", () => {
+  beforeEach(() => {
+    mockFs();
+  });
+
+  afterEach(() => {
+    mockFs.restore();
+  });
+
+  describe("configsToModels", () => {
+    it("should filter out invalid split configs", () => {
+      const config = loadFromOptions({
+        clusters: [],
+        users: [],
+        contexts: [],
+        currentContext: "foobar"
+      });
+
+      expect(configToModels(config, "").length).toBe(0);
+    });
+
+    it("should keep a single valid split config", () => {
+      const config = loadFromOptions({
+        clusters: [{
+          name: "cluster-name",
+          server: "1.2.3.4",
+          skipTLSVerify: false,
+        }],
+        users: [{
+          name: "user-name",
+        }],
+        contexts: [{
+          cluster: "cluster-name",
+          name: "context-name",
+          user: "user-name",
+        }],
+        currentContext: "foobar"
+      });
+
+      const models = configToModels(config, "/bar");
+
+      expect(models.length).toBe(1);
+      expect(models[0].contextName).toBe("context-name");
+      expect(models[0].kubeConfigPath).toBe("/bar");
+    });
+  });
+
+  describe("computeDiff", () => {
+    it("should leave an empty source empty if there are no entries", () => {
+      const contents = "";
+      const rootSource = new ObservableMap<string, [Cluster, CatalogEntity]>();
+      const port = 0;
+      const filePath = "/bar";
+
+      computeDiff(contents, rootSource, port, filePath);
+
+      expect(rootSource.size).toBe(0);
+    });
+
+    it("should add only the valid clusters to the source", () => {
+      const contents = JSON.stringify({
+        clusters: [{
+          name: "cluster-name",
+          cluster: {
+            server: "1.2.3.4",
+          },
+          skipTLSVerify: false,
+        }],
+        users: [{
+          name: "user-name",
+        }],
+        contexts: [{
+          name: "context-name",
+          context: {
+            cluster: "cluster-name",
+            user: "user-name",
+          },
+        }, {
+          name: "context-the-second",
+          context: {
+            cluster: "missing-cluster",
+            user: "user-name",
+          },
+        }],
+        currentContext: "foobar"
+      });
+      const rootSource = new ObservableMap<string, [Cluster, CatalogEntity]>();
+      const port = 0;
+      const filePath = "/bar";
+
+      fs.writeFileSync(filePath, contents);
+
+      computeDiff(contents, rootSource, port, filePath);
+
+      expect(rootSource.size).toBe(1);
+
+      const c = rootSource.values().next().value[0] as Cluster;
+
+      expect(c.kubeConfigPath).toBe("/bar");
+      expect(c.contextName).toBe("context-name");
+    });
+
+    it("should remove a cluster when it is removed from the contents", () => {
+      const contents = JSON.stringify({
+        clusters: [{
+          name: "cluster-name",
+          cluster: {
+            server: "1.2.3.4",
+          },
+          skipTLSVerify: false,
+        }],
+        users: [{
+          name: "user-name",
+
+        }],
+        contexts: [{
+          name: "context-name",
+          context: {
+            cluster: "cluster-name",
+            user: "user-name",
+          },
+        }, {
+          name: "context-the-second",
+          context: {
+            cluster: "missing-cluster",
+            user: "user-name",
+          },
+        }],
+        currentContext: "foobar"
+      });
+      const rootSource = new ObservableMap<string, [Cluster, CatalogEntity]>();
+      const port = 0;
+      const filePath = "/bar";
+
+      fs.writeFileSync(filePath, contents);
+
+      computeDiff(contents, rootSource, port, filePath);
+
+      expect(rootSource.size).toBe(1);
+
+      const c = rootSource.values().next().value[0] as Cluster;
+
+      expect(c.kubeConfigPath).toBe("/bar");
+      expect(c.contextName).toBe("context-name");
+
+      computeDiff("{}", rootSource, port, filePath);
+
+      expect(rootSource.size).toBe(0);
+    });
+
+    it("should remove only the cluster that it is removed from the contents", () => {
+      const contents = JSON.stringify({
+        clusters: [{
+          name: "cluster-name",
+          cluster: {
+            server: "1.2.3.4",
+          },
+          skipTLSVerify: false,
+        }],
+        users: [{
+          name: "user-name",
+        }, {
+          name: "user-name-2",
+        }],
+        contexts: [{
+          name: "context-name",
+          context: {
+            cluster: "cluster-name",
+            user: "user-name",
+          },
+        }, {
+          name: "context-name-2",
+          context: {
+            cluster: "cluster-name",
+            user: "user-name-2",
+          },
+        }, {
+          name: "context-the-second",
+          context: {
+            cluster: "missing-cluster",
+            user: "user-name",
+          },
+        }],
+        currentContext: "foobar"
+      });
+      const rootSource = new ObservableMap<string, [Cluster, CatalogEntity]>();
+      const port = 0;
+      const filePath = "/bar";
+
+      fs.writeFileSync(filePath, contents);
+
+      computeDiff(contents, rootSource, port, filePath);
+
+      expect(rootSource.size).toBe(2);
+
+      {
+        const c = rootSource.values().next().value[0] as Cluster;
+
+        expect(c.kubeConfigPath).toBe("/bar");
+        expect(["context-name", "context-name-2"].includes(c.contextName)).toBe(true);
+      }
+
+      const newContents = JSON.stringify({
+        clusters: [{
+          name: "cluster-name",
+          cluster: {
+            server: "1.2.3.4",
+          },
+          skipTLSVerify: false,
+        }],
+        users: [{
+          name: "user-name",
+        }, {
+          name: "user-name-2",
+        }],
+        contexts: [{
+          name: "context-name",
+          context: {
+            cluster: "cluster-name",
+            user: "user-name",
+          },
+        }, {
+          name: "context-the-second",
+          context: {
+            cluster: "missing-cluster",
+            user: "user-name",
+          },
+        }],
+        currentContext: "foobar"
+      });
+
+      computeDiff(newContents, rootSource, port, filePath);
+
+      expect(rootSource.size).toBe(1);
+
+      {
+        const c = rootSource.values().next().value[0] as Cluster;
+
+        expect(c.kubeConfigPath).toBe("/bar");
+        expect(c.contextName).toBe("context-name");
+      }
+    });
+  });
+});

src/main/catalog-sources/index.ts

@@ -0,0 +1 @@
+export { KubeconfigSyncManager } from "./kubeconfig-sync";

src/main/catalog-sources/kubeconfig-sync.ts

@@ -0,0 +1,251 @@
+import { action, observable, IComputedValue, computed, ObservableMap, runInAction } from "mobx";
+import { CatalogEntity, catalogEntityRegistry } from "../../common/catalog";
+import { watch } from "chokidar";
+import fs from "fs";
+import fse from "fs-extra";
+import * as uuid from "uuid";
+import stream from "stream";
+import { Disposer, ExtendedObservableMap, iter, Singleton } from "../../common/utils";
+import logger from "../logger";
+import { KubeConfig } from "@kubernetes/client-node";
+import { loadConfigFromString, splitConfig, validateKubeConfig } from "../../common/kube-helpers";
+import { Cluster } from "../cluster";
+import { catalogEntityFromCluster } from "../cluster-manager";
+import { UserStore } from "../../common/user-store";
+import { ClusterStore, UpdateClusterModel } from "../../common/cluster-store";
+
+const logPrefix = "[KUBECONFIG-SYNC]:";
+
+export class KubeconfigSyncManager extends Singleton {
+  protected sources = observable.map<string, [IComputedValue<CatalogEntity[]>, Disposer]>();
+  protected syncing = false;
+  protected syncListDisposer?: Disposer;
+
+  protected static readonly syncName = "lens:kube-sync";
+
+  @action
+  startSync(port: number): void {
+    if (this.syncing) {
+      return;
+    }
+
+    this.syncing = true;
+
+    logger.info(`${logPrefix} starting requested syncs`);
+
+    catalogEntityRegistry.addComputedSource(KubeconfigSyncManager.syncName, computed(() => (
+      Array.from(iter.flatMap(
+        this.sources.values(),
+        ([entities]) => entities.get()
+      ))
+    )));
+
+    // This must be done so that c&p-ed clusters are visible
+    this.startNewSync(ClusterStore.storedKubeConfigFolder, port);
+
+    for (const filePath of UserStore.getInstance().syncKubeconfigEntries.keys()) {
+      this.startNewSync(filePath, port);
+    }
+
+    this.syncListDisposer = UserStore.getInstance().syncKubeconfigEntries.observe(change => {
+      switch (change.type) {
+        case "add":
+          this.startNewSync(change.name, port);
+          break;
+        case "delete":
+          this.stopOldSync(change.name);
+          break;
+      }
+    });
+  }
+
+  @action
+  stopSync() {
+    this.syncListDisposer?.();
+
+    for (const filePath of this.sources.keys()) {
+      this.stopOldSync(filePath);
+    }
+
+    catalogEntityRegistry.removeSource(KubeconfigSyncManager.syncName);
+    this.syncing = false;
+  }
+
+  @action
+  protected async startNewSync(filePath: string, port: number): Promise<void> {
+    if (this.sources.has(filePath)) {
+      // don't start a new sync if we already have one
+      return void logger.debug(`${logPrefix} already syncing file/folder`, { filePath });
+    }
+
+    try {
+      this.sources.set(filePath, await watchFileChanges(filePath, port));
+
+      logger.info(`${logPrefix} starting sync of file/folder`, { filePath });
+      logger.debug(`${logPrefix} ${this.sources.size} files/folders watched`, { files: Array.from(this.sources.keys()) });
+    } catch (error) {
+      logger.warn(`${logPrefix} failed to start watching changes: ${error}`);
+    }
+  }
+
+  @action
+  protected stopOldSync(filePath: string): void {
+    if (!this.sources.delete(filePath)) {
+      // already stopped
+      return void logger.debug(`${logPrefix} no syncing file/folder to stop`, { filePath });
+    }
+
+    logger.info(`${logPrefix} stopping sync of file/folder`, { filePath });
+    logger.debug(`${logPrefix} ${this.sources.size} files/folders watched`, { files: Array.from(this.sources.keys()) });
+  }
+}
+
+// exported for testing
+export function configToModels(config: KubeConfig, filePath: string): UpdateClusterModel[] {
+  const validConfigs = [];
+
+  for (const contextConfig of splitConfig(config)) {
+    const error = validateKubeConfig(contextConfig, contextConfig.currentContext);
+
+    if (error) {
+      logger.debug(`${logPrefix} context failed validation: ${error}`, { context: contextConfig.currentContext, filePath });
+    } else {
+      validConfigs.push({
+        kubeConfigPath: filePath,
+        contextName: contextConfig.currentContext,
+      });
+    }
+  }
+
+  return validConfigs;
+}
+
+type RootSourceValue = [Cluster, CatalogEntity];
+type RootSource = ObservableMap<string, RootSourceValue>;
+
+// exported for testing
+export function computeDiff(contents: string, source: RootSource, port: number, filePath: string): void {
+  runInAction(() => {
+    try {
+      const rawModels = configToModels(loadConfigFromString(contents), filePath);
+      const models = new Map(rawModels.map(m => [m.contextName, m]));
+
+      logger.debug(`${logPrefix} File now has ${models.size} entries`, { filePath });
+
+      for (const [contextName, value] of source) {
+        const model = models.get(contextName);
+
+        // remove and disconnect clusters that were removed from the config
+        if (!model) {
+          value[0].disconnect();
+          source.delete(contextName);
+          logger.debug(`${logPrefix} Removed old cluster from sync`, { filePath, contextName });
+          continue;
+        }
+
+        // TODO: For the update check we need to make sure that the config itself hasn't changed.
+        // Probably should make it so that cluster keeps a copy of the config in its memory and
+        // diff against that
+
+        // or update the model and mark it as not needed to be added
+        value[0].updateModel(model);
+        models.delete(contextName);
+        logger.debug(`${logPrefix} Updated old cluster from sync`, { filePath, contextName });
+      }
+
+      for (const [contextName, model] of models) {
+        // add new clusters to the source
+        try {
+          const cluster = new Cluster({ ...model, id: uuid.v4() });
+
+          if (!cluster.apiUrl) {
+            throw new Error("Cluster constructor failed, see above error");
+          }
+
+          cluster.init(port);
+
+          const entity = catalogEntityFromCluster(cluster);
+
+          entity.metadata.labels.file = filePath;
+          source.set(contextName, [cluster, entity]);
+
+          logger.debug(`${logPrefix} Added new cluster from sync`, { filePath, contextName });
+        } catch (error) {
+          logger.warn(`${logPrefix} Failed to create cluster from model: ${error}`, { filePath, contextName });
+        }
+      }
+    } catch (error) {
+      logger.warn(`${logPrefix} Failed to compute diff: ${error}`, { filePath });
+      source.clear(); // clear source if we have failed so as to not show outdated information
+    }
+  });
+}
+
+function diffChangedConfig(filePath: string, source: RootSource, port: number): Disposer {
+  logger.debug(`${logPrefix} file changed`, { filePath });
+
+  // TODO: replace with an AbortController with fs.readFile when we upgrade to Node 16 (after it comes out)
+  const fileReader = fs.createReadStream(filePath, {
+    mode: fs.constants.O_RDONLY,
+  });
+  const readStream: stream.Readable = fileReader;
+  const bufs: Buffer[] = [];
+  let closed = false;
+
+  const cleanup = () => {
+    closed = true;
+    fileReader.close(); // This may not close the stream.
+    // Artificially marking end-of-stream, as if the underlying resource had
+    // indicated end-of-file by itself, allows the stream to close.
+    // This does not cancel pending read operations, and if there is such an
+    // operation, the process may still not be able to exit successfully
+    // until it finishes.
+    fileReader.push(null);
+    fileReader.read(0);
+    readStream.removeAllListeners();
+  };
+
+  readStream
+    .on("data", chunk => bufs.push(chunk))
+    .on("close", () => cleanup())
+    .on("error", error => {
+      cleanup();
+      logger.warn(`${logPrefix} failed to read file: ${error}`, { filePath });
+    })
+    .on("end", () => {
+      if (!closed) {
+        computeDiff(Buffer.concat(bufs).toString("utf-8"), source, port, filePath);
+      }
+    });
+
+  return cleanup;
+}
+
+async function watchFileChanges(filePath: string, port: number): Promise<[IComputedValue<CatalogEntity[]>, Disposer]> {
+  const stat = await fse.stat(filePath); // traverses symlinks, is a race condition
+  const watcher = watch(filePath, {
+    followSymlinks: true,
+    depth: stat.isDirectory() ? 0 : 1, // DIRs works with 0 but files need 1 (bug: https://github.com/paulmillr/chokidar/issues/1095)
+    disableGlobbing: true,
+  });
+  const rootSource = new ExtendedObservableMap<string, ObservableMap<string, RootSourceValue>>(observable.map);
+  const derivedSource = computed(() => Array.from(iter.flatMap(rootSource.values(), from => iter.map(from.values(), child => child[1]))));
+  const stoppers = new Map<string, Disposer>();
+
+  watcher
+    .on("change", (childFilePath) => {
+      stoppers.get(childFilePath)();
+      stoppers.set(childFilePath, diffChangedConfig(childFilePath, rootSource.getOrDefault(childFilePath), port));
+    })
+    .on("add", (childFilePath) => {
+      stoppers.set(childFilePath, diffChangedConfig(childFilePath, rootSource.getOrDefault(childFilePath), port));
+    })
+    .on("unlink", (childFilePath) => {
+      stoppers.get(childFilePath)();
+      stoppers.delete(childFilePath);
+      rootSource.delete(childFilePath);
+    })
+    .on("error", error => logger.error(`${logPrefix} watching file/folder failed: ${error}`, { filePath }));
+
+  return [derivedSource, () => watcher.close()];
+}

src/main/cluster-manager.ts

@@ -1,13 +1,13 @@
 import "../common/cluster-ipc";
 import type http from "http";
 import { ipcMain } from "electron";
-import { action, autorun, makeObservable, observable, reaction } from "mobx";
+import { action, autorun, observable, reaction, makeObservable } from "mobx";
+import { Singleton, toJS } from "../common/utils";
 import { ClusterStore, getClusterIdFromHost } from "../common/cluster-store";
 import { Cluster } from "./cluster";
 import logger from "./logger";
 import { apiKubePrefix } from "../common/vars";
-import { CatalogEntity, CatalogEntityData, catalogEntityRegistry } from "../common/catalog";
-import { Singleton, toJS } from "../common/utils";
+import { CatalogEntity, catalogEntityRegistry } from "../common/catalog";
 import { KubernetesCluster } from "../common/catalog-entities/kubernetes-cluster";
 
 const clusterOwnerRef = "ClusterManager";
@@ -20,7 +20,7 @@ export class ClusterManager extends Singleton {
 
     makeObservable(this);
 
-    catalogEntityRegistry.addSource("lens:kubernetes-clusters", this.catalogSource);
+    catalogEntityRegistry.addObservableSource("lens:kubernetes-clusters", this.catalogSource);
     // auto-init clusters
     reaction(() => ClusterStore.getInstance().enabledClustersList, (clusters) => {
       clusters.forEach((cluster) => {
@@ -32,7 +32,7 @@ export class ClusterManager extends Singleton {
 
     }, { fireImmediately: true });
 
-    reaction(() => toJS(ClusterStore.getInstance().enabledClustersList), () => {
+    reaction(() => toJS(ClusterStore.getInstance().enabledClustersList, { recurseEverything: true }), () => {
       this.updateCatalogSource(ClusterStore.getInstance().enabledClustersList);
     }, { fireImmediately: true });
 
@@ -40,6 +40,7 @@ export class ClusterManager extends Singleton {
       this.syncClustersFromCatalog(entities);
     });
 
+
     // auto-stop removed clusters
     autorun(() => {
       const removedClusters = Array.from(ClusterStore.getInstance().removedClusters.values());
@@ -55,27 +56,22 @@ export class ClusterManager extends Singleton {
       delay: 250
     });
 
-    ipcMain.on("network:offline", () => {
-      this.onNetworkOffline();
-    });
-    ipcMain.on("network:online", () => {
-      this.onNetworkOnline();
-    });
+    ipcMain.on("network:offline", () => { this.onNetworkOffline(); });
+    ipcMain.on("network:online", () => { this.onNetworkOnline(); });
   }
 
-  @action
-  protected updateCatalogSource(clusters: Cluster[]) {
-    this.catalogSource.forEach((entity, index) => {
-      const clusterIndex = clusters.findIndex((cluster) => entity.metadata.uid === cluster.id);
+  @action protected updateCatalogSource(clusters: Cluster[]) {
+    this.catalogSource.replace(this.catalogSource.filter(entity => (
+      clusters.find((cluster) => entity.metadata.uid === cluster.id)
+    )));
 
-      if (clusterIndex === -1) {
-        this.catalogSource.splice(index, 1);
+    for (const cluster of clusters) {
+      if (cluster.ownerRef) {
+        continue;
       }
-    });
 
-    clusters.filter((c) => !c.ownerRef).forEach((cluster) => {
       const entityIndex = this.catalogSource.findIndex((entity) => entity.metadata.uid === cluster.id);
-      const newEntity = this.catalogEntityFromCluster(cluster);
+      const newEntity = catalogEntityFromCluster(cluster);
 
       if (entityIndex === -1) {
         this.catalogSource.push(newEntity);
@@ -90,11 +86,15 @@ export class ClusterManager extends Singleton {
         };
         this.catalogSource.splice(entityIndex, 1, newEntity);
       }
-    });
+    }
   }
 
   @action syncClustersFromCatalog(entities: KubernetesCluster[]) {
-    entities.filter((entity) => entity.metadata.source !== "local").forEach((entity: KubernetesCluster) => {
+    for (const entity of entities) {
+      if (entity.metadata.source !== "local") {
+        continue;
+      }
+
       const cluster = ClusterStore.getInstance().getById(entity.metadata.uid);
 
       if (!cluster) {
@@ -110,7 +110,7 @@ export class ClusterManager extends Singleton {
         });
       } else {
         cluster.enabled = true;
-        if (!cluster.ownerRef) cluster.ownerRef = clusterOwnerRef;
+        cluster.ownerRef ||= clusterOwnerRef;
         cluster.preferences.clusterName = entity.metadata.name;
         cluster.kubeConfigPath = entity.spec.kubeconfigPath;
         cluster.contextName = entity.spec.kubeconfigContext;
@@ -120,34 +120,7 @@ export class ClusterManager extends Singleton {
           active: !cluster.disconnected
         };
       }
-    });
-  }
-
-  protected catalogEntityFromCluster(cluster: Cluster) {
-    const data: CatalogEntityData = toJS({
-      apiVersion: "entity.k8slens.dev/v1alpha1",
-      kind: "KubernetesCluster",
-      metadata: {
-        uid: cluster.id,
-        name: cluster.name,
-        source: "local",
-        labels: {
-          "distro": (cluster.metadata["distribution"] || "unknown").toString()
-        }
-      },
-      spec: {
-        kubeconfigPath: cluster.kubeConfigPath,
-        kubeconfigContext: cluster.contextName
-      },
-      status: {
-        phase: cluster.disconnected ? "disconnected" : "connected",
-        reason: "",
-        message: "",
-        active: !cluster.disconnected
-      }
-    });
-
-    return new KubernetesCluster(data as any);
+    }
   }
 
   protected onNetworkOffline() {
@@ -200,3 +173,28 @@ export class ClusterManager extends Singleton {
     return cluster;
   }
 }
+
+export function catalogEntityFromCluster(cluster: Cluster) {
+  return new KubernetesCluster(toJS({
+    apiVersion: "entity.k8slens.dev/v1alpha1",
+    kind: "KubernetesCluster",
+    metadata: {
+      uid: cluster.id,
+      name: cluster.name,
+      source: "local",
+      labels: {
+        distro: cluster.distribution,
+      }
+    },
+    spec: {
+      kubeconfigPath: cluster.kubeConfigPath,
+      kubeconfigContext: cluster.contextName
+    },
+    status: {
+      phase: cluster.disconnected ? "disconnected" : "connected",
+      reason: "",
+      message: "",
+      active: !cluster.disconnected
+    }
+  }));
+}

src/main/cluster.ts

@@ -1,5 +1,5 @@
 import { ipcMain } from "electron";
-import type { ClusterId, ClusterMetadata, ClusterModel, ClusterPreferences, ClusterPrometheusPreferences } from "../common/cluster-store";
+import type { ClusterId, ClusterMetadata, ClusterModel, ClusterPreferences, ClusterPrometheusPreferences, UpdateClusterModel } from "../common/cluster-store";
 import type { IMetricsReqParams } from "../renderer/api/endpoints/metrics.api";
 import { action, comparer, computed, makeObservable, observable, reaction, when } from "mobx";
 import { apiKubePrefix } from "../common/vars";
@@ -58,7 +58,7 @@ export interface ClusterState {
  */
 export class Cluster implements ClusterModel, ClusterState {
   /** Unique id for a cluster */
-  public id: ClusterId;
+  public readonly id: ClusterId;
   /**
    * Kubectl
    *
@@ -86,7 +86,7 @@ export class Cluster implements ClusterModel, ClusterState {
   whenReady = when(() => this.ready);
 
   /**
-   * Is cluster object initializinng on-going
+   * Is cluster object initializing on-going
    *
    * @observable
    */
@@ -232,6 +232,10 @@ export class Cluster implements ClusterModel, ClusterState {
     return this.preferences.clusterName || this.contextName;
   }
 
+  @computed get distribution(): string {
+    return this.metadata.distribution?.toString() || "unknown";
+  }
+
   /**
    * Prometheus preferences
    *
@@ -253,12 +257,17 @@ export class Cluster implements ClusterModel, ClusterState {
 
   constructor(model: ClusterModel) {
     makeObservable(this);
+
+    this.id = model.id;
     this.updateModel(model);
 
     try {
       const kubeconfig = this.getKubeconfig();
+      const error = validateKubeConfig(kubeconfig, this.contextName, { validateCluster: true, validateUser: false, validateExec: false});
 
-      validateKubeConfig(kubeconfig, this.contextName, { validateCluster: true, validateUser: false, validateExec: false });
+      if (error) {
+        throw error;
+      }
       this.apiUrl = kubeconfig.getCluster(kubeconfig.getContextObject(this.contextName).cluster).server;
     } catch (err) {
       logger.error(err);
@@ -279,8 +288,34 @@ export class Cluster implements ClusterModel, ClusterState {
    *
    * @param model
    */
-  @action updateModel(model: ClusterModel) {
-    Object.assign(this, model);
+  @action updateModel(model: UpdateClusterModel) {
+    // Note: do not assign ID as that should never be updated
+
+    this.kubeConfigPath = model.kubeConfigPath;
+
+    if (model.workspace) {
+      this.workspace = model.workspace;
+    }
+
+    if (model.contextName) {
+      this.contextName = model.contextName;
+    }
+
+    if (model.preferences) {
+      this.preferences = model.preferences;
+    }
+
+    if (model.metadata) {
+      this.metadata = model.metadata;
+    }
+
+    if (model.ownerRef) {
+      this.ownerRef = model.ownerRef;
+    }
+
+    if (model.accessibleNamespaces) {
+      this.accessibleNamespaces = model.accessibleNamespaces;
+    }
   }
 
   /**

src/main/index.ts

@@ -33,6 +33,7 @@ import { CatalogPusher } from "./catalog-pusher";
 import { catalogEntityRegistry } from "../common/catalog";
 import { HotbarStore } from "../common/hotbar-store";
 import { HelmRepoManager } from "./helm/helm-repo-manager";
+import { KubeconfigSyncManager } from "./catalog-sources";
 import configurePackages from "../common/configure-packages";
 
 const workingDir = path.join(app.getPath("appData"), appName);
@@ -133,6 +134,9 @@ app.on("ready", async () => {
 
   const clusterManager = ClusterManager.getInstance();
 
+  // create kubeconfig sync manager
+  KubeconfigSyncManager.createInstance().startSync(clusterManager.port);
+
   // run proxy
   try {
     logger.info("🔌 Starting LensProxy");
@@ -239,6 +243,7 @@ app.on("will-quit", (event) => {
   logger.info("APP:QUIT");
   appEventBus.emit({ name: "app", action: "close" });
   ClusterManager.getInstance(false)?.stop(); // close cluster connections
+  KubeconfigSyncManager.getInstance(false)?.stopSync();
 
   if (blockQuit) {
     event.preventDefault(); // prevent app's default shutdown (e.g. required for telemetry, etc.)

src/main/window-manager.ts

@@ -10,6 +10,7 @@ import { Singleton } from "../common/utils";
 import { ClusterFrameInfo, clusterFrameMap } from "../common/cluster-frames";
 import { IpcRendererNavigationEvents } from "../renderer/navigation/events";
 import logger from "./logger";
+import { productName } from "../common/vars";
 
 export class WindowManager extends Singleton {
   protected mainWindow: BrowserWindow;
@@ -48,6 +49,7 @@ export class WindowManager extends Singleton {
 
       this.mainWindow = new BrowserWindow({
         x, y, width, height,
+        title: productName,
         show: false,
         minWidth: 700,  // accommodate 800 x 600 display minimum
         minHeight: 500, // accommodate 800 x 600 display minimum