Simplify add cluster view (#2716)

- Only shows editor, and will save all text to file

- Reports some validation errors, but doesn't block the add cluster
  button

- Cleanup kube helpers to facilitate clearer FS interactions

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

package.json

@@ -203,6 +203,7 @@
     "handlebars": "^4.7.7",
     "http-proxy": "^1.18.1",
     "immer": "^8.0.1",
+    "joi": "^17.4.0",
     "js-yaml": "^3.14.0",
     "jsdom": "^16.4.0",
     "jsonpath": "^1.0.2",
@@ -273,7 +274,7 @@
     "@types/mini-css-extract-plugin": "^0.9.1",
     "@types/mock-fs": "^4.10.0",
     "@types/module-alias": "^2.0.0",
-    "@types/node": "^12.12.45",
+    "@types/node": "12.20",
     "@types/npm": "^2.0.31",
     "@types/progress-bar-webpack-plugin": "^2.1.0",
     "@types/proper-lockfile": "^4.1.1",

src/common/__tests__/cluster-store.test.ts

@@ -22,8 +22,10 @@
 import fs from "fs";
 import mockFs from "mock-fs";
 import yaml from "js-yaml";
+import path from "path";
+import fse from "fs-extra";
 import { Cluster } from "../../main/cluster";
-import { ClusterStore, getClusterIdFromHost } from "../cluster-store";
+import { ClusterId, ClusterStore, getClusterIdFromHost } from "../cluster-store";
 import { Console } from "console";
 import { stdout, stderr } from "process";
 
@@ -54,6 +56,15 @@ users:
     token: kubeconfig-user-q4lm4:xxxyyyy
 `;
 
+function embed(clusterId: ClusterId, contents: any): string {
+  const absPath = ClusterStore.getCustomKubeConfigPath(clusterId);
+
+  fse.ensureDirSync(path.dirname(absPath));
+  fse.writeFileSync(absPath, contents, { encoding: "utf-8", mode: 0o600 });
+
+  return absPath;
+}
+
 jest.mock("electron", () => {
   return {
     app: {
@@ -102,7 +113,7 @@ describe("empty config", () => {
             icon: "data:image/jpeg;base64, iVBORw0KGgoAAAANSUhEUgAAA1wAAAKoCAYAAABjkf5",
             clusterName: "minikube"
           },
-          kubeConfigPath: ClusterStore.embedCustomKubeConfig("foo", kubeconfig)
+          kubeConfigPath: embed("foo", kubeconfig)
         })
       );
     });
@@ -130,7 +141,7 @@ describe("empty config", () => {
           preferences: {
             clusterName: "prod"
           },
-          kubeConfigPath: ClusterStore.embedCustomKubeConfig("prod", kubeconfig)
+          kubeConfigPath: embed("prod", kubeconfig)
         }),
         new Cluster({
           id: "dev",
@@ -138,7 +149,7 @@ describe("empty config", () => {
           preferences: {
             clusterName: "dev"
           },
-          kubeConfigPath: ClusterStore.embedCustomKubeConfig("dev", kubeconfig)
+          kubeConfigPath: embed("dev", kubeconfig)
         })
       );
     });
@@ -149,7 +160,7 @@ describe("empty config", () => {
     });
 
     it("check if cluster's kubeconfig file saved", () => {
-      const file = ClusterStore.embedCustomKubeConfig("boo", "kubeconfig");
+      const file = embed("boo", "kubeconfig");
 
       expect(fs.readFileSync(file, "utf8")).toBe("kubeconfig");
     });
@@ -160,6 +171,7 @@ describe("config with existing clusters", () => {
   beforeEach(() => {
     ClusterStore.resetInstance();
     const mockOpts = {
+      "temp-kube-config": kubeconfig,
       "tmp": {
         "lens-cluster-store.json": JSON.stringify({
           __internal__: {
@@ -170,20 +182,20 @@ describe("config with existing clusters", () => {
           clusters: [
             {
               id: "cluster1",
-              kubeConfigPath: kubeconfig,
+              kubeConfigPath: "./temp-kube-config",
               contextName: "foo",
               preferences: { terminalCWD: "/foo" },
               workspace: "default"
             },
             {
               id: "cluster2",
-              kubeConfigPath: kubeconfig,
+              kubeConfigPath: "./temp-kube-config",
               contextName: "foo2",
               preferences: { terminalCWD: "/foo2" }
             },
             {
               id: "cluster3",
-              kubeConfigPath: kubeconfig,
+              kubeConfigPath: "./temp-kube-config",
               contextName: "foo",
               preferences: { terminalCWD: "/foo" },
               workspace: "foo",
@@ -256,6 +268,8 @@ users:
 
     ClusterStore.resetInstance();
     const mockOpts = {
+      "invalid-kube-config": invalidKubeconfig,
+      "valid-kube-config": kubeconfig,
       "tmp": {
         "lens-cluster-store.json": JSON.stringify({
           __internal__: {
@@ -266,14 +280,14 @@ users:
           clusters: [
             {
               id: "cluster1",
-              kubeConfigPath: invalidKubeconfig,
+              kubeConfigPath: "./invalid-kube-config",
               contextName: "test",
               preferences: { terminalCWD: "/foo" },
               workspace: "foo",
             },
             {
               id: "cluster2",
-              kubeConfigPath: kubeconfig,
+              kubeConfigPath: "./valid-kube-config",
               contextName: "foo",
               preferences: { terminalCWD: "/foo" },
               workspace: "default"

src/common/__tests__/kube-helpers.test.ts

@@ -20,7 +20,7 @@
  */
 
 import { KubeConfig } from "@kubernetes/client-node";
-import { validateKubeConfig, loadConfig, getNodeWarningConditions } from "../kube-helpers";
+import { validateKubeConfig, loadConfigFromString, getNodeWarningConditions } from "../kube-helpers";
 
 const kubeconfig = `
 apiVersion: v1
@@ -59,8 +59,6 @@ users:
       command: foo
 `;
 
-const kc = new KubeConfig();
-
 interface kubeconfig {
   apiVersion: string,
   clusters: [{
@@ -88,6 +86,8 @@ let mockKubeConfig: kubeconfig;
 
 describe("kube helpers", () => {
   describe("validateKubeconfig", () => {
+    const kc = new KubeConfig();
+
     beforeAll(() => {
       kc.loadFromString(kubeconfig);
     });
@@ -164,12 +164,12 @@ describe("kube helpers", () => {
       it("invalid yaml string", () => {
         const invalidYAMLString = "fancy foo config";
 
-        expect(() => loadConfig(invalidYAMLString)).toThrowError("must be an object");
+        expect(loadConfigFromString(invalidYAMLString).error).toBeInstanceOf(Error);
       });
       it("empty contexts", () => {
-        const emptyContexts = `apiVersion: v1\ncontexts:`;
+        const emptyContexts = `apiVersion: v1\ncontexts: []`;
 
-        expect(() => loadConfig(emptyContexts)).not.toThrow();
+        expect(loadConfigFromString(emptyContexts).error).toBeUndefined();
       });
     });
 
@@ -200,17 +200,17 @@ describe("kube helpers", () => {
       });
 
       it("single context is ok", async () => {
-        const kc:KubeConfig = loadConfig(JSON.stringify(mockKubeConfig));
+        const { config } = loadConfigFromString(JSON.stringify(mockKubeConfig));
 
-        expect(kc.getCurrentContext()).toBe("minikube");
+        expect(config.getCurrentContext()).toBe("minikube");
       });
 
       it("multiple context is ok", async () => {
         mockKubeConfig.contexts.push({context: {cluster: "cluster-2", user: "cluster-2"}, name: "cluster-2"});
-        const kc:KubeConfig = loadConfig(JSON.stringify(mockKubeConfig));
+        const { config } = loadConfigFromString(JSON.stringify(mockKubeConfig));
 
-        expect(kc.getCurrentContext()).toBe("minikube");
+        expect(config.getCurrentContext()).toBe("minikube");
-        expect(kc.contexts.length).toBe(2);
+        expect(config.contexts.length).toBe(2);
       });
     });
 
@@ -243,40 +243,40 @@ describe("kube helpers", () => {
       it("empty name in context causes it to be removed", async () => {
         mockKubeConfig.contexts.push({context: {cluster: "cluster-2", user: "cluster-2"}, name: ""});
         expect(mockKubeConfig.contexts.length).toBe(2);
-        const kc:KubeConfig = loadConfig(JSON.stringify(mockKubeConfig));
+        const { config } = loadConfigFromString(JSON.stringify(mockKubeConfig));
 
-        expect(kc.getCurrentContext()).toBe("minikube");
+        expect(config.getCurrentContext()).toBe("minikube");
-        expect(kc.contexts.length).toBe(1);
+        expect(config.contexts.length).toBe(1);
       });
 
       it("empty cluster in context causes it to be removed", async () => {
         mockKubeConfig.contexts.push({context: {cluster: "", user: "cluster-2"}, name: "cluster-2"});
         expect(mockKubeConfig.contexts.length).toBe(2);
-        const kc:KubeConfig = loadConfig(JSON.stringify(mockKubeConfig));
+        const { config } = loadConfigFromString(JSON.stringify(mockKubeConfig));
 
-        expect(kc.getCurrentContext()).toBe("minikube");
+        expect(config.getCurrentContext()).toBe("minikube");
-        expect(kc.contexts.length).toBe(1);
+        expect(config.contexts.length).toBe(1);
       });
 
       it("empty user in context causes it to be removed", async () => {
         mockKubeConfig.contexts.push({context: {cluster: "cluster-2", user: ""}, name: "cluster-2"});
         expect(mockKubeConfig.contexts.length).toBe(2);
-        const kc:KubeConfig = loadConfig(JSON.stringify(mockKubeConfig));
+        const { config } = loadConfigFromString(JSON.stringify(mockKubeConfig));
 
-        expect(kc.getCurrentContext()).toBe("minikube");
+        expect(config.getCurrentContext()).toBe("minikube");
-        expect(kc.contexts.length).toBe(1);
+        expect(config.contexts.length).toBe(1);
       });
 
       it("invalid context in between valid contexts is removed", async () => {
         mockKubeConfig.contexts.push({context: {cluster: "cluster-2", user: ""}, name: "cluster-2"});
         mockKubeConfig.contexts.push({context: {cluster: "cluster-3", user: "cluster-3"}, name: "cluster-3"});
         expect(mockKubeConfig.contexts.length).toBe(3);
-        const kc:KubeConfig = loadConfig(JSON.stringify(mockKubeConfig));
+        const { config } = loadConfigFromString(JSON.stringify(mockKubeConfig));
 
-        expect(kc.getCurrentContext()).toBe("minikube");
+        expect(config.getCurrentContext()).toBe("minikube");
-        expect(kc.contexts.length).toBe(2);
+        expect(config.contexts.length).toBe(2);
-        expect(kc.contexts[0].name).toBe("minikube");
+        expect(config.contexts[0].name).toBe("minikube");
-        expect(kc.contexts[1].name).toBe("cluster-3");
+        expect(config.contexts[1].name).toBe("cluster-3");
       });
     });
   });

src/common/__tests__/user-store.test.ts

@@ -66,19 +66,6 @@ describe("user store tests", () => {
       expect(us.lastSeenAppVersion).toBe("1.2.3");
     });
 
-    it("allows adding and listing seen contexts", () => {
-      const us = UserStore.getInstance();
-
-      us.seenContexts.add("foo");
-      expect(us.seenContexts.size).toBe(1);
-
-      us.seenContexts.add("foo");
-      us.seenContexts.add("bar");
-      expect(us.seenContexts.size).toBe(2); // check 'foo' isn't added twice
-      expect(us.seenContexts.has("foo")).toBe(true);
-      expect(us.seenContexts.has("bar")).toBe(true);
-    });
-
     it("allows setting and getting preferences", () => {
       const us = UserStore.getInstance();
 

src/common/cluster-store.ts

@@ -26,11 +26,9 @@ import { action, comparer, computed, makeObservable, observable, reaction } from
 import { BaseStore } from "./base-store";
 import { Cluster, ClusterState } from "../main/cluster";
 import migrations from "../migrations/cluster-store";
+import * as uuid from "uuid";
 import logger from "../main/logger";
 import { appEventBus } from "./event-bus";
-import { dumpConfigYaml } from "./kube-helpers";
-import { saveToAppFiles } from "./utils/saveToAppFiles";
-import type { KubeConfig } from "@kubernetes/client-node";
 import { handleRequest, requestMain, subscribeToBroadcast, unsubscribeAllFromBroadcast } from "./ipc";
 import { disposer, noop, toJS } from "./utils";
 
@@ -116,19 +114,10 @@ export class ClusterStore extends BaseStore<ClusterStoreModel> {
     return path.resolve((app || remote.app).getPath("userData"), "kubeconfigs");
   }
 
-  static getCustomKubeConfigPath(clusterId: ClusterId): string {
+  static getCustomKubeConfigPath(clusterId: ClusterId = uuid.v4()): string {
     return path.resolve(ClusterStore.storedKubeConfigFolder, clusterId);
   }
 
-  static embedCustomKubeConfig(clusterId: ClusterId, kubeConfig: KubeConfig | string): string {
-    const filePath = ClusterStore.getCustomKubeConfigPath(clusterId);
-    const fileContents = typeof kubeConfig == "string" ? kubeConfig : dumpConfigYaml(kubeConfig);
-
-    saveToAppFiles(filePath, fileContents, { mode: 0o600 });
-
-    return filePath;
-  }
-
   @observable clusters = observable.map<ClusterId, Cluster>();
   @observable removedClusters = observable.map<ClusterId, Cluster>();
 

src/common/kube-helpers.ts

@@ -28,6 +28,8 @@ import logger from "../main/logger";
 import commandExists from "command-exists";
 import { ExecValidationNotFoundError } from "./custom-errors";
 import { Cluster, Context, newClusters, newContexts, newUsers, User } from "@kubernetes/client-node/dist/config_types";
+import { resolvePath } from "./utils";
+import Joi from "joi";
 
 export type KubeConfigValidationOpts = {
   validateCluster?: boolean;
@@ -37,50 +39,108 @@ export type KubeConfigValidationOpts = {
 
 export const kubeConfigDefaultPath = path.join(os.homedir(), ".kube", "config");
 
-function resolveTilde(filePath: string) {
+export function loadConfigFromFileSync(filePath: string): ConfigResult {
-  if (filePath[0] === "~" && (filePath[1] === "/" || filePath.length === 1)) {
+  const content = fse.readFileSync(resolvePath(filePath), "utf-8");
-    return filePath.replace("~", os.homedir());
-  }
 
-  return filePath;
+  return loadConfigFromString(content);
 }
 
-function readResolvedPathSync(filePath: string): string {
+export async function loadConfigFromFile(filePath: string): Promise<ConfigResult> {
-  return fse.readFileSync(path.resolve(resolveTilde(filePath)), "utf8");
+  const content = await fse.readFile(resolvePath(filePath), "utf-8");
+
+  return loadConfigFromString(content);
 }
 
-function checkRawCluster(rawCluster: any): boolean {
+const clusterSchema = Joi.object({
-  return Boolean(rawCluster?.name && rawCluster?.cluster?.server);
+  name: Joi
-}
+    .string()
+    .min(1)
+    .required(),
+  cluster: Joi
+    .object({
+      server: Joi
+        .string()
+        .min(1)
+        .required(),
+    })
+    .required(),
+});
 
-function checkRawUser(rawUser: any): boolean {
+const userSchema = Joi.object({
-  return Boolean(rawUser?.name);
+  name: Joi.string()
-}
+    .min(1)
+    .required(),
+});
 
-function checkRawContext(rawContext: any): boolean {
+const contextSchema = Joi.object({
-  return Boolean(rawContext.name && rawContext.context?.cluster && rawContext.context?.user);
+  name: Joi.string()
-}
+    .min(1)
+    .required(),
+  context: Joi.object({
+    cluster: Joi.string()
+      .min(1)
+      .required(),
+    user: Joi.string()
+      .min(1)
+      .required(),
+  }),
+});
+
+const kubeConfigSchema = Joi
+  .object({
+    users: Joi
+      .array()
+      .items(userSchema)
+      .optional(),
+    clusters: Joi
+      .array()
+      .items(clusterSchema)
+      .optional(),
+    contexts: Joi
+      .array()
+      .items(contextSchema)
+      .optional(),
+    "current-context": Joi
+      .string()
+      .min(1)
+      .optional(),
+  })
+  .required();
 
 export interface KubeConfigOptions {
   clusters: Cluster[];
   users: User[];
   contexts: Context[];
-  currentContext: string;
+  currentContext?: string;
 }
 
-function loadToOptions(rawYaml: string): KubeConfigOptions {
+export interface OptionsResult {
-  const obj = yaml.safeLoad(rawYaml);
+  options: KubeConfigOptions;
+  error: Joi.ValidationError;
+}
 
-  if (typeof obj !== "object" || !obj) {
+function loadToOptions(rawYaml: string): OptionsResult {
-    throw new TypeError("KubeConfig root entry must be an object");
+  const parsed = yaml.safeLoad(rawYaml);
-  }
+  const { error } = kubeConfigSchema.validate(parsed, {
+    abortEarly: false,
+    allowUnknown: true,
+  });
+  const { value } = kubeConfigSchema.validate(parsed, {
+    abortEarly: false,
+    allowUnknown: true,
+    stripUnknown: {
+      arrays: true,
+    }
+  });
+  const { clusters: rawClusters, users: rawUsers, contexts: rawContexts, "current-context": currentContext } = value ?? {};
+  const clusters = newClusters(rawClusters);
+  const users = newUsers(rawUsers);
+  const contexts = newContexts(rawContexts);
 
-  const { clusters: rawClusters, users: rawUsers, contexts: rawContexts, "current-context": currentContext } = obj;
+  return {
-  const clusters = newClusters(rawClusters?.filter(checkRawCluster));
+    options: { clusters, users, contexts, currentContext },
-  const users = newUsers(rawUsers?.filter(checkRawUser));
+    error,
-  const contexts = newContexts(rawContexts?.filter(checkRawContext));
+  };
-
-  return { clusters, users, contexts, currentContext };
 }
 
 export function loadFromOptions(options: KubeConfigOptions): KubeConfig {
@@ -92,67 +152,44 @@ export function loadFromOptions(options: KubeConfigOptions): KubeConfig {
   return kc;
 }
 
-export function loadConfig(pathOrContent?: string): KubeConfig {
+export interface ConfigResult {
-  return loadConfigFromString(
+  config: KubeConfig;
-    fse.pathExistsSync(pathOrContent)
+  error: Joi.ValidationError;
-      ? readResolvedPathSync(pathOrContent)
-      : pathOrContent
-  );
 }
 
-export function loadConfigFromString(content: string): KubeConfig {
+export function loadConfigFromString(content: string): ConfigResult {
-  return loadFromOptions(loadToOptions(content));
+  const { options, error } = loadToOptions(content);
+
+  return {
+    config: loadFromOptions(options),
+    error,
+  };
 }
 
-/**
+export interface SplitConfigEntry {
- * KubeConfig is valid when there's at least one of each defined:
+  config: KubeConfig,
- * - User
+  error?: string;
- * - Cluster
- * - Context
- * @param config KubeConfig to check
- */
-export function validateConfig(config: KubeConfig | string): KubeConfig {
-  if (typeof config == "string") {
-    config = loadConfig(config);
-  }
-  logger.debug(`validating kube config: ${JSON.stringify(config)}`);
-
-  if (!config.users || config.users.length == 0) {
-    throw new Error("No users provided in config");
-  }
-
-  if (!config.clusters || config.clusters.length == 0) {
-    throw new Error("No clusters provided in config");
-  }
-
-  if (!config.contexts || config.contexts.length == 0) {
-    throw new Error("No contexts provided in config");
-  }
-
-  return config;
 }
 
 /**
  * Breaks kube config into several configs. Each context as it own KubeConfig object
  */
-export function splitConfig(kubeConfig: KubeConfig): KubeConfig[] {
+export function splitConfig(kubeConfig: KubeConfig): SplitConfigEntry[] {
-  const configs: KubeConfig[] = [];
+  const { contexts = [] } = kubeConfig;
 
-  if (!kubeConfig.contexts) {
+  return contexts.map(context => {
-    return configs;
+    const config = new KubeConfig();
-  }
-  kubeConfig.contexts.forEach(ctx => {
-    const kc = new KubeConfig();
 
-    kc.clusters = [kubeConfig.getCluster(ctx.cluster)].filter(n => n);
+    config.clusters = [kubeConfig.getCluster(context.cluster)].filter(Boolean);
-    kc.users = [kubeConfig.getUser(ctx.user)].filter(n => n);
+    config.users = [kubeConfig.getUser(context.user)].filter(Boolean);
-    kc.contexts = [kubeConfig.getContextObject(ctx.name)].filter(n => n);
+    config.contexts = [kubeConfig.getContextObject(context.name)].filter(Boolean);
-    kc.setCurrentContext(ctx.name);
+    config.setCurrentContext(context.name);
 
-    configs.push(kc);
+    return {
+      config,
+      error: validateKubeConfig(config, context.name)?.toString(),
+    };
   });
-
-  return configs;
 }
 
 export function dumpConfigYaml(kubeConfig: Partial<KubeConfig>): string {
@@ -230,7 +267,7 @@ export function getNodeWarningConditions(node: V1Node) {
  *
  * Note: This function returns an error instead of throwing it, returning `undefined` if the validation passes
  */
-export function validateKubeConfig(config: KubeConfig, contextName: string, validationOpts: KubeConfigValidationOpts = {}): Error | void {
+export function validateKubeConfig(config: KubeConfig, contextName: string, validationOpts: KubeConfigValidationOpts = {}): Error | undefined {
   try {
     // we only receive a single context, cluster & user object here so lets validate them as this
     // will be called when we add a new cluster to Lens
@@ -267,6 +304,8 @@ export function validateKubeConfig(config: KubeConfig, contextName: string, vali
         return new ExecValidationNotFoundError(execCommand, isAbsolute);
       }
     }
+
+    return undefined;
   } catch (error) {
     return error;
   }

src/common/user-store.ts

@@ -22,24 +22,19 @@
 import type { ThemeId } from "../renderer/theme.store";
 import { app, remote } from "electron";
 import semver from "semver";
-import { readFile } from "fs-extra";
 import { action, computed, observable, reaction, makeObservable } from "mobx";
 import moment from "moment-timezone";
 import { BaseStore } from "./base-store";
 import migrations from "../migrations/user-store";
 import { getAppVersion } from "./utils/app-version";
-import { kubeConfigDefaultPath, loadConfig } from "./kube-helpers";
 import { appEventBus } from "./event-bus";
-import logger from "../main/logger";
 import path from "path";
 import os from "os";
 import { fileNameMigration } from "../migrations/user-store";
 import { ObservableToggleSet, toJS } from "../renderer/utils";
 
 export interface UserStoreModel {
-  kubeConfigPath: string;
   lastSeenAppVersion: string;
-  seenContexts: string[];
   preferences: UserPreferencesModel;
 }
 
@@ -47,7 +42,7 @@ export interface KubeconfigSyncEntry extends KubeconfigSyncValue {
   filePath: string;
 }
 
-export interface KubeconfigSyncValue {}
+export interface KubeconfigSyncValue { }
 
 export interface UserPreferencesModel {
   httpsProxy?: string;
@@ -77,13 +72,6 @@ export class UserStore extends BaseStore<UserStoreModel> {
   }
 
   @observable lastSeenAppVersion = "0.0.0";
-
-  /**
-   * used in add-cluster page for providing context
-   */
-  @observable kubeConfigPath = kubeConfigDefaultPath;
-  @observable seenContexts = observable.set<string>();
-  @observable newContexts = observable.set<string>();
   @observable allowTelemetry = true;
   @observable allowUntrustedCAs = false;
   @observable colorTheme = UserStore.defaultTheme;
@@ -121,10 +109,6 @@ export class UserStore extends BaseStore<UserStoreModel> {
     await fileNameMigration();
     await super.load();
 
-    // refresh new contexts
-    await this.refreshNewContexts();
-    reaction(() => this.kubeConfigPath, () => this.refreshNewContexts());
-
     if (app) {
       // track telemetry availability
       reaction(() => this.allowTelemetry, allowed => {
@@ -180,15 +164,6 @@ export class UserStore extends BaseStore<UserStoreModel> {
     this.hiddenTableColumns.get(tableId)?.toggle(columnId);
   }
 
-  @action
-  resetKubeConfigPath() {
-    this.kubeConfigPath = kubeConfigDefaultPath;
-  }
-
-  @computed get isDefaultKubeConfigPath(): boolean {
-    return this.kubeConfigPath === kubeConfigDefaultPath;
-  }
-
   @action
   async resetTheme() {
     await this.whenLoaded;
@@ -206,44 +181,14 @@ export class UserStore extends BaseStore<UserStoreModel> {
     this.localeTimezone = tz;
   }
 
-  protected async refreshNewContexts() {
-    try {
-      const kubeConfig = await readFile(this.kubeConfigPath, "utf8");
-
-      if (kubeConfig) {
-        this.newContexts.clear();
-        loadConfig(kubeConfig).getContexts()
-          .filter(ctx => ctx.cluster)
-          .filter(ctx => !this.seenContexts.has(ctx.name))
-          .forEach(ctx => this.newContexts.add(ctx.name));
-      }
-    } catch (err) {
-      logger.error(err);
-      this.resetKubeConfigPath();
-    }
-  }
-
-  @action
-  markNewContextsAsSeen() {
-    const { seenContexts, newContexts } = this;
-
-    this.seenContexts.replace([...seenContexts, ...newContexts]);
-    this.newContexts.clear();
-  }
-
   @action
   protected async fromStore(data: Partial<UserStoreModel> = {}) {
-    const { lastSeenAppVersion, seenContexts = [], preferences, kubeConfigPath } = data;
+    const { lastSeenAppVersion, preferences } = data;
 
     if (lastSeenAppVersion) {
       this.lastSeenAppVersion = lastSeenAppVersion;
     }
 
-    if (kubeConfigPath) {
-      this.kubeConfigPath = kubeConfigPath;
-    }
-    this.seenContexts.replace(seenContexts);
-
     if (!preferences) {
       return;
     }
@@ -287,9 +232,7 @@ export class UserStore extends BaseStore<UserStoreModel> {
     }
 
     const model: UserStoreModel = {
-      kubeConfigPath: this.kubeConfigPath,
       lastSeenAppVersion: this.lastSeenAppVersion,
-      seenContexts: Array.from(this.seenContexts),
       preferences: {
         httpsProxy: toJS(this.httpsProxy),
         shell: toJS(this.shell),

src/common/utils/index.ts

@@ -21,7 +21,9 @@
 
 // Common utils (main OR renderer)
 
-export const noop: any = () => { /* empty */ };
+export function noop<T extends any[]>(...args: T): void {
+  return void args;
+}
 
 export * from "./app-version";
 export * from "./autobind";
@@ -39,8 +41,8 @@ export * from "./escapeRegExp";
 export * from "./extended-map";
 export * from "./getRandId";
 export * from "./openExternal";
+export * from "./paths";
 export * from "./reject-promise";
-export * from "./saveToAppFiles";
 export * from "./singleton";
 export * from "./splitArray";
 export * from "./tar";

src/common/utils/paths.ts

@@ -19,17 +19,17 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-// 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 os from "os";
-import { ensureDirSync, writeFileSync } from "fs-extra";
-import type { WriteFileOptions } from "fs";
 
-export function saveToAppFiles(filePath: string, contents: any, options?: WriteFileOptions): string {
+function resolveTilde(filePath: string) {
-  const absPath = path.resolve((app || remote.app).getPath("userData"), filePath);
+  if (filePath[0] === "~" && (filePath[1] === "/" || filePath.length === 1)) {
+    return filePath.replace("~", os.homedir());
+  }
 
-  ensureDirSync(path.dirname(absPath));
+  return filePath;
-  writeFileSync(absPath, contents, options);
+}
-
+
-  return absPath;
+export function resolvePath(filePath: string): string {
+  return path.resolve(resolveTilde(filePath));
 }

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

@@ -29,7 +29,7 @@ import type stream from "stream";
 import { Disposer, ExtendedObservableMap, iter, Singleton } from "../../common/utils";
 import logger from "../logger";
 import type { KubeConfig } from "@kubernetes/client-node";
-import { loadConfigFromString, splitConfig, validateKubeConfig } from "../../common/kube-helpers";
+import { loadConfigFromString, splitConfig } from "../../common/kube-helpers";
 import { Cluster } from "../cluster";
 import { catalogEntityFromCluster } from "../cluster-manager";
 import { UserStore } from "../../common/user-store";
@@ -130,18 +130,16 @@ export class KubeconfigSyncManager extends Singleton {
 }
 
 // exported for testing
-export function configToModels(config: KubeConfig, filePath: string): UpdateClusterModel[] {
+export function configToModels(rootConfig: KubeConfig, filePath: string): UpdateClusterModel[] {
   const validConfigs = [];
 
-  for (const contextConfig of splitConfig(config)) {
+  for (const { config, error } of splitConfig(rootConfig)) {
-    const error = validateKubeConfig(contextConfig, contextConfig.currentContext);
-
     if (error) {
-      logger.debug(`${logPrefix} context failed validation: ${error}`, { context: contextConfig.currentContext, filePath });
+      logger.debug(`${logPrefix} context failed validation: ${error}`, { context: config.currentContext, filePath });
     } else {
       validConfigs.push({
         kubeConfigPath: filePath,
-        contextName: contextConfig.currentContext,
+        contextName: config.currentContext,
       });
     }
   }
@@ -156,7 +154,13 @@ type RootSource = ObservableMap<string, RootSourceValue>;
 export function computeDiff(contents: string, source: RootSource, filePath: string): void {
   runInAction(() => {
     try {
-      const rawModels = configToModels(loadConfigFromString(contents), filePath);
+      const { config, error } = loadConfigFromString(contents);
+
+      if (error) {
+        logger.warn(`${logPrefix} encountered errors while loading config: ${error.message}`, { filePath, details: error.details });
+      }
+
+      const rawModels = configToModels(config, filePath);
       const models = new Map(rawModels.map(m => [m.contextName, m]));
 
       logger.debug(`${logPrefix} File now has ${models.size} entries`, { filePath });

src/main/cluster.ts

@@ -27,7 +27,7 @@ import { ContextHandler } from "./context-handler";
 import { AuthorizationV1Api, CoreV1Api, HttpError, KubeConfig, V1ResourceAttributes } from "@kubernetes/client-node";
 import { Kubectl } from "./kubectl";
 import { KubeconfigManager } from "./kubeconfig-manager";
-import { loadConfig, validateKubeConfig } from "../common/kube-helpers";
+import { loadConfigFromFile, loadConfigFromFileSync, validateKubeConfig } from "../common/kube-helpers";
 import { apiResourceRecord, apiResources, KubeApiResource, KubeResource } from "../common/rbac";
 import logger from "./logger";
 import { VersionDetector } from "./cluster-detectors/version-detector";
@@ -258,14 +258,14 @@ export class Cluster implements ClusterModel, ClusterState {
     this.id = model.id;
     this.updateModel(model);
 
-    const kubeconfig = this.getKubeconfig();
+    const { config } = loadConfigFromFileSync(this.kubeConfigPath);
-    const error = validateKubeConfig(kubeconfig, this.contextName, { validateCluster: true, validateUser: false, validateExec: false});
+    const validationError = validateKubeConfig(config, this.contextName);
 
-    if (error) {
+    if (validationError) {
-      throw error;
+      throw validationError;
     }
 
-    this.apiUrl = kubeconfig.getCluster(kubeconfig.getContextObject(this.contextName).cluster).server;
+    this.apiUrl = config.getCluster(config.getContextObject(this.contextName).cluster).server;
 
     if (ipcMain) {
       // for the time being, until renderer gets its own cluster type
@@ -470,17 +470,20 @@ export class Cluster implements ClusterModel, ClusterState {
     this.allowedResources = await this.getAllowedResources();
   }
 
-  protected getKubeconfig(): KubeConfig {
+  async getKubeconfig(): Promise<KubeConfig> {
-    return loadConfig(this.kubeConfigPath);
+    const { config } = await loadConfigFromFile(this.kubeConfigPath);
+
+    return config;
   }
 
   /**
    * @internal
    */
   async getProxyKubeconfig(): Promise<KubeConfig> {
-    const kubeconfigPath = await this.getProxyKubeconfigPath();
+    const proxyKCPath = await this.getProxyKubeconfigPath();
+    const { config } = await loadConfigFromFile(proxyKCPath);
 
-    return loadConfig(kubeconfigPath);
+    return config;
   }
 
   /**

src/main/kubeconfig-manager.ts

@@ -25,7 +25,7 @@ import type { ContextHandler } from "./context-handler";
 import { app } from "electron";
 import path from "path";
 import fs from "fs-extra";
-import { dumpConfigYaml, loadConfig } from "../common/kube-helpers";
+import { dumpConfigYaml } from "../common/kube-helpers";
 import logger from "./logger";
 import { LensProxy } from "./proxy/lens-proxy";
 
@@ -86,9 +86,9 @@ export class KubeconfigManager {
    */
   protected async createProxyKubeconfig(): Promise<string> {
     const { configDir, cluster } = this;
-    const { contextName, kubeConfigPath, id } = cluster;
+    const { contextName, id } = cluster;
-    const tempFile = path.normalize(path.join(configDir, `kubeconfig-${id}`));
+    const tempFile = path.join(configDir, `kubeconfig-${id}`);
-    const kubeConfig = loadConfig(kubeConfigPath);
+    const kubeConfig = await cluster.getKubeconfig();
     const proxyConfig: Partial<KubeConfig> = {
       currentContext: contextName,
       clusters: [

src/migrations/cluster-store/3.6.0-beta.1.ts

@@ -27,7 +27,7 @@ import { app, remote } from "electron";
 import { migration } from "../migration-wrapper";
 import fse from "fs-extra";
 import { ClusterModel, ClusterStore } from "../../common/cluster-store";
-import { loadConfig } from "../../common/kube-helpers";
+import { loadConfigFromFileSync } from "../../common/kube-helpers";
 
 export default migration({
   version: "3.6.0-beta.1",
@@ -46,9 +46,13 @@ export default migration({
          * migrate kubeconfig
          */
         try {
+          const absPath = ClusterStore.getCustomKubeConfigPath(cluster.id);
+
+          fse.ensureDirSync(path.dirname(absPath));
+          fse.writeFileSync(absPath, cluster.kubeConfig, { encoding: "utf-8", mode: 0o600 });
           // take the embedded kubeconfig and dump it into a file
-          cluster.kubeConfigPath = ClusterStore.embedCustomKubeConfig(cluster.id, cluster.kubeConfig);
+          cluster.kubeConfigPath = absPath;
-          cluster.contextName = loadConfig(cluster.kubeConfigPath).getCurrentContext();
+          cluster.contextName = loadConfigFromFileSync(cluster.kubeConfigPath).config.getCurrentContext();
           delete cluster.kubeConfig;
 
         } catch (error) {

src/renderer/api/kube-watch-api.ts

@@ -26,8 +26,8 @@ import type { KubeObjectStore } from "../kube-object.store";
 import type { ClusterContext } from "../components/context";
 
 import plimit from "p-limit";
-import { comparer, IReactionDisposer, observable, reaction, makeObservable } from "mobx";
+import { comparer, observable, reaction, makeObservable } from "mobx";
-import { autoBind, noop } from "../utils";
+import { autoBind, Disposer, noop } from "../utils";
 import type { KubeApi } from "./kube-api";
 import type { KubeJsonApiData } from "./kube-json-api";
 import { isDebugging, isProduction } from "../../common/vars";
@@ -80,7 +80,7 @@ export class KubeWatchApi {
     };
   }
 
-  subscribeStores(stores: KubeObjectStore[], opts: IKubeWatchSubscribeStoreOptions = {}): () => void {
+  subscribeStores(stores: KubeObjectStore[], opts: IKubeWatchSubscribeStoreOptions = {}): Disposer {
     const { preload = true, waitUntilLoaded = true, loadOnce = false, } = opts;
     const subscribingNamespaces = opts.namespaces ?? this.context?.allNamespaces ?? [];
     const unsubscribeList: Function[] = [];
@@ -88,7 +88,7 @@ export class KubeWatchApi {
 
     const load = (namespaces = subscribingNamespaces) => this.preloadStores(stores, { namespaces, loadOnce });
     let preloading = preload && load();
-    let cancelReloading: IReactionDisposer = noop;
+    let cancelReloading: Disposer = noop;
 
     const subscribe = () => {
       if (isUnsubscribed) return;

src/renderer/components/+add-cluster/add-cluster.tsx

@@ -20,35 +20,48 @@
  */
 
 import "./add-cluster.scss";
-import React from "react";
+
+import type { KubeConfig } from "@kubernetes/client-node";
+import fse from "fs-extra";
+import { debounce } from "lodash";
+import { action, computed, observable, makeObservable } from "mobx";
 import { observer } from "mobx-react";
-import { action, observable, runInAction, makeObservable } from "mobx";
+import path from "path";
-import { KubeConfig } from "@kubernetes/client-node";
+import React from "react";
+
+import { catalogURL } from "../+catalog";
+import { ClusterStore } from "../../../common/cluster-store";
+import { appEventBus } from "../../../common/event-bus";
+import { loadConfigFromString, splitConfig } from "../../../common/kube-helpers";
+import { docsUrl } from "../../../common/vars";
+import { navigate } from "../../navigation";
+import { iter } from "../../utils";
 import { AceEditor } from "../ace-editor";
 import { Button } from "../button";
-import { loadConfig, splitConfig, validateKubeConfig } from "../../../common/kube-helpers";
-import { ClusterStore } from "../../../common/cluster-store";
-import { v4 as uuid } from "uuid";
-import { navigate } from "../../navigation";
-import { UserStore } from "../../../common/user-store";
-import { Notifications } from "../notifications";
-import { ExecValidationNotFoundError } from "../../../common/custom-errors";
-import { appEventBus } from "../../../common/event-bus";
 import { PageLayout } from "../layout/page-layout";
-import { docsUrl } from "../../../common/vars";
+import { Notifications } from "../notifications";
-import { catalogURL } from "../+catalog";
+
-import { preferencesURL } from "../+preferences";
+interface Option {
-import { Input } from "../input";
+  config: KubeConfig;
+  error?: string;
+}
+
+function getContexts(config: KubeConfig): Map<string, Option> {
+  return new Map(
+    splitConfig(config)
+      .map(({ config, error }) => [config.currentContext, {
+        config,
+        error,
+      }])
+  );
+}
+
 @observer
 export class AddCluster extends React.Component {
-  @observable.ref kubeConfigLocal: KubeConfig;
+  @observable kubeContexts = observable.map<string, Option>();
-  @observable.ref error: React.ReactNode;
   @observable customConfig = "";
-  @observable proxyServer = "";
   @observable isWaiting = false;
-  @observable showSettings = false;
+  @observable errorText: string;
-
-  kubeContexts = observable.map<string, KubeConfig>();
 
   constructor(props: {}) {
     super(props);
@@ -59,159 +72,75 @@ export class AddCluster extends React.Component {
     appEventBus.emit({ name: "cluster-add", action: "start" });
   }
 
-  componentWillUnmount() {
+  @computed get allErrors(): string[] {
-    UserStore.getInstance().markNewContextsAsSeen();
+    return [
+      this.errorText,
+      ...iter.map(this.kubeContexts.values(), ({ error }) => error)
+    ].filter(Boolean);
   }
 
   @action
-  refreshContexts() {
+  refreshContexts = debounce(() => {
-    this.kubeContexts.clear();
+    const { config, error } = loadConfigFromString(this.customConfig.trim() || "{}");
 
-    try {
+    this.kubeContexts.replace(getContexts(config));
-      this.error = "";
+    this.errorText = error?.toString();
-      const contexts = this.getContexts(loadConfig(this.customConfig || "{}"));
+  }, 500);
-
-      console.log(contexts);
-
-      this.kubeContexts.replace(contexts);
-    } catch (err) {
-      this.error = String(err);
-    }
-  }
-
-  getContexts(config: KubeConfig): Map<string, KubeConfig> {
-    const contexts = new Map();
-
-    splitConfig(config).forEach(config => {
-      contexts.set(config.currentContext, config);
-    });
-
-    return contexts;
-  }
 
   @action
-  addClusters = (): void => {
+  addClusters = async () => {
+    this.isWaiting = true;
+    appEventBus.emit({ name: "cluster-add", action: "click" });
+
     try {
+      const absPath = ClusterStore.getCustomKubeConfigPath();
 
-      this.error = "";
+      await fse.ensureDir(path.dirname(absPath));
-      this.isWaiting = true;
+      await fse.writeFile(absPath, this.customConfig.trim(), { encoding: "utf-8", mode: 0o600 });
-      appEventBus.emit({ name: "cluster-add", action: "click" });
-      const newClusters = Array.from(this.kubeContexts.keys()).filter(context => {
-        const kubeConfig = this.kubeContexts.get(context);
-        const error = validateKubeConfig(kubeConfig, context);
 
-        if (error) {
+      Notifications.ok(`Successfully added ${this.kubeContexts.size} new cluster(s)`);
-          this.error = error.toString();
 
-          if (error instanceof ExecValidationNotFoundError) {
+      return navigate(catalogURL());
-            Notifications.error(<>Error while adding cluster(s): {this.error}</>);
+    } catch (error) {
-          }
+      Notifications.error(`Failed to add clusters: ${error}`);
-        }
-
-        return Boolean(!error);
-      }).map(context => {
-        const clusterId = uuid();
-        const kubeConfig = this.kubeContexts.get(context);
-        const kubeConfigPath = ClusterStore.embedCustomKubeConfig(clusterId, kubeConfig); // save in app-files folder
-
-        return {
-          id: clusterId,
-          kubeConfigPath,
-          contextName: kubeConfig.currentContext,
-          preferences: {
-            clusterName: kubeConfig.currentContext,
-            httpsProxy: this.proxyServer || undefined,
-          },
-        };
-      });
-
-      runInAction(() => {
-        ClusterStore.getInstance().addClusters(...newClusters);
-
-        Notifications.ok(
-          <>Successfully imported <b>{newClusters.length}</b> cluster(s)</>
-        );
-
-        navigate(catalogURL());
-      });
-      this.refreshContexts();
-    } catch (err) {
-      this.error = String(err);
-      Notifications.error(<>Error while adding cluster(s): {this.error}</>);
-    } finally {
-      this.isWaiting = false;
     }
   };
 
-  renderInfo() {
+  render() {
     return (
-      <p>
+      <PageLayout className="AddClusters" showOnTop={true}>
-        Paste kubeconfig as a text from the clipboard to the textarea below.
+        <h2>Add Clusters from Kubeconfig</h2>
-        If you want to add clusters from kubeconfigs that exists on filesystem, please add those files (or folders) to kubeconfig sync via <a onClick={() => navigate(preferencesURL())}>Preferences</a>.
+        <p>
-        Read more about adding clusters <a href={`${docsUrl}/clusters/adding-clusters/`} rel="noreferrer" target="_blank">here</a>.
+          Clusters added here are <b>not</b> merged into the <code>~/.kube/config</code> file.
-      </p>
+          Read more about adding clusters <a href={`${docsUrl}/clusters/adding-clusters/`} rel="noreferrer" target="_blank">here</a>.
-    );
+        </p>
-  }
-
-  renderKubeConfigSource() {
-    return (
-      <>
         <div className="flex column">
           <AceEditor
             autoFocus
             showGutter={false}
             mode="yaml"
             value={this.customConfig}
-            wrap={true}
             onChange={value => {
               this.customConfig = value;
+              this.errorText = "";
               this.refreshContexts();
             }}
           />
         </div>
-      </>
+        {this.allErrors.length > 0 && (
-    );
+          <>
-  }
+            <h3>KubeConfig Yaml Validation Errors:</h3>
-
+            {...this.allErrors.map(error => <div key={error} className="error">{error}</div>)}
-  render() {
+          </>
-    const submitDisabled = this.kubeContexts.size === 0;
-
-    return (
-      <PageLayout className="AddClusters" showOnTop={true}>
-        <h2>Add Clusters from Kubeconfig</h2>
-        {this.renderInfo()}
-        {this.renderKubeConfigSource()}
-        <div className="cluster-settings">
-          <a href="#" onClick={() => this.showSettings = !this.showSettings}>
-            Proxy settings
-          </a>
-        </div>
-        {this.showSettings && (
-          <div className="proxy-settings">
-            <p>HTTP Proxy server. Used for communicating with Kubernetes API.</p>
-            <Input
-              autoFocus
-              value={this.proxyServer}
-              onChange={value => this.proxyServer = value}
-              theme="round-black"
-            />
-            <small className="hint">
-              {"A HTTP proxy server URL (format: http://<address>:<port>)."}
-            </small>
-          </div>
         )}
-        {this.error && (
-          <div className="error">{this.error}</div>
-        )}
-
         <div className="actions-panel">
           <Button
             primary
-            disabled={submitDisabled}
+            disabled={this.kubeContexts.size === 0}
-            label={this.kubeContexts.keys.length < 2 ? "Add cluster" : "Add clusters"}
+            label={this.kubeContexts.size === 1 ? "Add cluster" : "Add clusters"}
             onClick={this.addClusters}
             waiting={this.isWaiting}
-            tooltip={submitDisabled ? "Paste a valid kubeconfig." : undefined}
+            tooltip={this.kubeContexts.size === 0 || "Paste in at least one cluster to add."}
             tooltipOverrideDisabled
           />
         </div>

src/renderer/components/cluster-manager/cluster-status.tsx

@@ -19,21 +19,23 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-import type { KubeAuthProxyLog } from "../../../main/kube-auth-proxy";
-
 import "./cluster-status.scss";
-import React from "react";
+
-import { observer } from "mobx-react";
 import { ipcRenderer } from "electron";
 import { computed, observable, makeObservable } from "mobx";
-import { requestMain, subscribeToBroadcast } from "../../../common/ipc";
+import { observer } from "mobx-react";
-import { Icon } from "../icon";
+import React from "react";
-import { Button } from "../button";
-import { cssNames, IClassName } from "../../utils";
-import type { Cluster } from "../../../main/cluster";
-import { ClusterId, ClusterStore } from "../../../common/cluster-store";
-import { CubeSpinner } from "../spinner";
 import { clusterActivateHandler } from "../../../common/cluster-ipc";
+import { ClusterId, ClusterStore } from "../../../common/cluster-store";
+import { requestMain, subscribeToBroadcast } from "../../../common/ipc";
+import type { Cluster } from "../../../main/cluster";
+import { cssNames, IClassName } from "../../utils";
+import { Button } from "../button";
+import { Icon } from "../icon";
+import { CubeSpinner } from "../spinner";
+import type { KubeAuthProxyLog } from "../../../main/kube-auth-proxy";
+import { navigate } from "../../navigation";
+import { entitySettingsURL } from "../+entity-settings";
 
 interface Props {
   className?: IClassName;
@@ -82,6 +84,15 @@ export class ClusterStatus extends React.Component<Props> {
     this.isReconnecting = false;
   };
 
+  manageProxySettings = () => {
+    navigate(entitySettingsURL({
+      params: {
+        entityId: this.props.clusterId,
+      },
+      fragment: "http-proxy",
+    }));
+  };
+
   renderContent() {
     const { authOutput, cluster, hasErrors } = this;
     const failureReason = cluster.failureReason;
@@ -89,7 +100,7 @@ export class ClusterStatus extends React.Component<Props> {
     if (!hasErrors || this.isReconnecting) {
       return (
         <>
-          <CubeSpinner/>
+          <CubeSpinner />
           <pre className="kube-auth-out">
             <p>{this.isReconnecting ? "Reconnecting..." : "Connecting..."}</p>
             {authOutput.map(({ data, error }, index) => {
@@ -102,7 +113,7 @@ export class ClusterStatus extends React.Component<Props> {
 
     return (
       <>
-        <Icon material="cloud_off" className="error"/>
+        <Icon material="cloud_off" className="error" />
         <h2>
           {cluster.preferences.clusterName}
         </h2>
@@ -121,6 +132,12 @@ export class ClusterStatus extends React.Component<Props> {
           onClick={this.reconnect}
           waiting={this.isReconnecting}
         />
+        <Button
+          primary
+          label="Manage Proxy Settings"
+          className="box center"
+          onClick={this.manageProxySettings}
+        />
       </>
     );
   }

src/renderer/components/cluster-settings/components/cluster-proxy-setting.tsx

@@ -58,7 +58,7 @@ export class ClusterProxySetting extends React.Component<Props> {
   render() {
     return (
       <>
-        <SubTitle title="HTTP Proxy" />
+        <SubTitle title="HTTP Proxy" id="http-proxy" />
         <Input
           theme="round-black"
           value={this.proxy}

yarn.lock

@@ -1476,12 +1476,17 @@
   resolved "https://registry.yarnpkg.com/@types/node/-/node-14.14.41.tgz#d0b939d94c1d7bd53d04824af45f1139b8c45615"
   integrity sha512-dueRKfaJL4RTtSa7bWeTK1M+VH+Gns73oCgzvYfHZywRCoPSd8EkXBL0mZ9unPTveBn+D9phZBaxuzpwjWkW0g==
 
+"@types/node@12.20":
+  version "12.20.11"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-12.20.11.tgz#980832cd56efafff8c18aa148c4085eb02a483f4"
+  integrity sha512-gema+apZ6qLQK7k7F0dGkGCWQYsL0qqKORWOQO6tq46q+x+1C0vbOiOqOwRVlh4RAdbQwV/j/ryr3u5NOG1fPQ==
+
 "@types/node@^10.12.0":
   version "10.17.24"
   resolved "https://registry.yarnpkg.com/@types/node/-/node-10.17.24.tgz#c57511e3a19c4b5e9692bb2995c40a3a52167944"
   integrity sha512-5SCfvCxV74kzR3uWgTYiGxrd69TbT1I6+cMx1A5kEly/IVveJBimtAMlXiEyVFn5DvUFewQWxOOiJhlxeQwxgA==
 
-"@types/node@^12.0.12", "@types/node@^12.12.45":
+"@types/node@^12.0.12":
   version "12.12.45"
   resolved "https://registry.yarnpkg.com/@types/node/-/node-12.12.45.tgz#33d550d6da243652004b00cbf4f15997456a38e3"
   integrity sha512-9w50wqeS0qQH9bo1iIRcQhDXRxoDzyAqCL5oJG+Nuu7cAoe6omGo+YDE0spAGK5sPrdLDhQLbQxq0DnxyndPKA==
@@ -8503,6 +8508,17 @@ joi@^17.3.0:
     "@sideway/formula" "^3.0.0"
     "@sideway/pinpoint" "^2.0.0"
 
+joi@^17.4.0:
+  version "17.4.0"
+  resolved "https://registry.yarnpkg.com/joi/-/joi-17.4.0.tgz#b5c2277c8519e016316e49ababd41a1908d9ef20"
+  integrity sha512-F4WiW2xaV6wc1jxete70Rw4V/VuMd6IN+a5ilZsxG4uYtUXWu2kq9W5P2dz30e7Gmw8RCbY/u/uk+dMPma9tAg==
+  dependencies:
+    "@hapi/hoek" "^9.0.0"
+    "@hapi/topo" "^5.0.0"
+    "@sideway/address" "^4.1.0"
+    "@sideway/formula" "^3.0.0"
+    "@sideway/pinpoint" "^2.0.0"
+
 jose@^1.27.1:
   version "1.27.1"
   resolved "https://registry.yarnpkg.com/jose/-/jose-1.27.1.tgz#a1de2ecb5b3ae1ae28f0d9d0cc536349ada27ec8"