Merge branch 'master' into feature/registrable-add-to-catalog-button

.azure-pipelines.yml

@@ -1,19 +1,7 @@
 variables:
   YARN_CACHE_FOLDER: $(Pipeline.Workspace)/.yarn
-pr:
+pr: none
-  branches:
-    include:
-    - master
-    - releases/*
-  paths:
-    exclude:
-    - .github/*
-    - docs/*
-    - mkdocs/*
 trigger:
-  branches:
-    include:
-    - '*'
   tags:
     include:
     - "*"
@@ -57,12 +45,6 @@ jobs:
         displayName: Run tests
       - script: make test-extensions
         displayName: Run In-tree Extension tests
-      - bash: |
-          set -e
-          rm -rf extensions/telemetry
-          make integration-win
-          git checkout extensions/telemetry
-        displayName: Run integration tests
       - script: make build
         condition: "and(succeeded(), startsWith(variables['Build.SourceBranch'], 'refs/tags/'))"
         displayName: Build
@@ -102,14 +84,6 @@ jobs:
         displayName: Run tests
       - script: make test-extensions
         displayName: Run In-tree Extension tests
-      - bash: |
-          set -e
-          rm -rf extensions/telemetry
-          make integration-mac
-          git checkout extensions/telemetry
-        displayName: Run integration tests
-      - script: make test-extensions
-        displayName: Run In-tree Extension tests
       - script: make build
         condition: "and(succeeded(), startsWith(variables['Build.SourceBranch'], 'refs/tags/'))"
         displayName: Build
@@ -151,21 +125,6 @@ jobs:
         displayName: Run tests
       - script: make test-extensions
         displayName: Run In-tree Extension tests
-      - bash: |
-          sudo apt-get update
-          sudo apt-get install libgconf-2-4 conntrack -y
-          curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
-          sudo install minikube-linux-amd64 /usr/local/bin/minikube
-          sudo minikube start --driver=none
-          # Although the kube and minikube config files are in placed $HOME they are owned by root
-          sudo chown -R $USER $HOME/.kube $HOME/.minikube
-        displayName: Install integration test dependencies
-      - bash: |
-          set -e
-          rm -rf extensions/telemetry
-          xvfb-run --auto-servernum --server-args='-screen 0, 1600x900x24' make integration-linux
-          git checkout extensions/telemetry
-        displayName: Run integration tests
       - bash: |
           sudo chown root:root /
           sudo apt-get update && sudo apt-get install -y snapd

.github/workflows/test.yml

@@ -0,0 +1,71 @@
+name: Test
+on:
+  - pull_request
+jobs:
+  build:
+    name: Test
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-16.04, macos-10.15, windows-2019]
+        node-version: [12.x]
+    steps:
+      - name: Checkout Release from lens
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - name: Using Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - run: make node_modules
+        name: Install dependencies
+
+      - run: make build-npm
+        name: Generate npm package
+
+      - run: make -j2 build-extensions
+        name: Build bundled extensions
+
+      - run: make test
+        name: Run tests
+
+      - run: make test-extensions
+        name: Run In-tree Extension tests
+
+      - run: |
+          sudo apt-get update
+          sudo apt-get install libgconf-2-4 conntrack -y
+          curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
+          sudo install minikube-linux-amd64 /usr/local/bin/minikube
+          sudo minikube start --driver=none
+          # Although the kube and minikube config files are in placed $HOME they are owned by root
+          sudo chown -R $USER $HOME/.kube $HOME/.minikube
+        name: Install integration test dependencies
+        if: runner.os == 'Linux'
+      - run: |
+          set -e
+          rm -rf extensions/telemetry
+          xvfb-run --auto-servernum --server-args='-screen 0, 1600x900x24' make integration-linux
+          git checkout extensions/telemetry
+        name: Run Linux integration tests
+        if: runner.os == 'Linux'
+
+      - run: |
+          set -e
+          rm -rf extensions/telemetry
+          make integration-win
+          git checkout extensions/telemetry
+        name: Run Windows integration tests
+        shell: bash
+        if: runner.os == 'Windows'
+
+      - run: |
+          set -e
+          rm -rf extensions/telemetry
+          make integration-mac
+          git checkout extensions/telemetry
+        name: Run macOS integration tests
+        if: runner.os == 'macOS'

.yarnrc

@@ -1,3 +1,3 @@
 disturl "https://atom.io/download/electron"
-target "9.1.0"
+target "9.4.4"
 runtime "electron"

package.json

@@ -319,7 +319,7 @@
     "css-loader": "^3.5.3",
     "deepdash": "^5.3.5",
     "dompurify": "^2.0.11",
-    "electron": "^9.4.0",
+    "electron": "^9.4.4",
     "electron-builder": "^22.7.0",
     "electron-notarize": "^0.3.0",
     "eslint": "^7.7.0",

src/common/__tests__/catalog-entity-registry.test.ts

@@ -0,0 +1,63 @@
+import { observable, reaction } from "mobx";
+import { WebLink } from "../catalog-entities";
+import { CatalogEntityRegistry } from "../catalog-entity-registry";
+
+describe("CatalogEntityRegistry", () => {
+  let registry: CatalogEntityRegistry;
+  const entity = new WebLink({
+    apiVersion: "entity.k8slens.dev/v1alpha1",
+    kind: "WebLink",
+    metadata: {
+      uid: "test",
+      name: "test-link",
+      source: "test",
+      labels: {}
+    },
+    spec: {
+      url: "https://k8slens.dev"
+    },
+    status: {
+      phase: "ok"
+    }
+  });
+
+  beforeEach(() => {
+    registry = new CatalogEntityRegistry();
+  });
+
+  describe("addSource", () => {
+    it ("allows to add an observable source", () => {
+      const source = observable.array([]);
+
+      registry.addSource("test", source);
+      expect(registry.items.length).toEqual(0);
+
+      source.push(entity);
+
+      expect(registry.items.length).toEqual(1);
+    });
+
+    it ("added source change triggers reaction", (done) => {
+      const source = observable.array([]);
+
+      registry.addSource("test", source);
+      reaction(() => registry.items, () => {
+        done();
+      });
+
+      source.push(entity);
+    });
+  });
+
+  describe("removeSource", () => {
+    it ("removes source", () => {
+      const source = observable.array([]);
+
+      registry.addSource("test", source);
+      source.push(entity);
+      registry.removeSource("test");
+
+      expect(registry.items.length).toEqual(0);
+    });
+  });
+});

src/common/catalog-entities/web-link.ts

@@ -1,5 +1,5 @@
 import { observable } from "mobx";
-import { CatalogCategory, CatalogEntity, CatalogEntityMetadata, CatalogEntityStatus } from "../catalog-entity";
+import { CatalogCategory, CatalogEntity, CatalogEntityData, CatalogEntityMetadata, CatalogEntityStatus } from "../catalog-entity";
 import { catalogCategoryRegistry } from "../catalog-category-registry";
 
 export interface WebLinkStatus extends CatalogEntityStatus {
@@ -17,6 +17,12 @@ export class WebLink implements CatalogEntity {
   @observable public status: WebLinkStatus;
   @observable public spec: WebLinkSpec;
 
+  constructor(data: CatalogEntityData) {
+    this.metadata = data.metadata;
+    this.status = data.status as WebLinkStatus;
+    this.spec = data.spec as WebLinkSpec;
+  }
+
   getId() {
     return this.metadata.uid;
   }

src/common/catalog-entity-registry.ts

@@ -1,10 +1,10 @@
-import { action, computed, observable } from "mobx";
+import { action, computed, observable, IObservableArray } from "mobx";
 import { CatalogEntity } from "./catalog-entity";
 
 export class CatalogEntityRegistry {
-  protected sources = observable.map<string, CatalogEntity[]>([], { deep: true });
+  protected sources = observable.map<string, IObservableArray<CatalogEntity>>([], { deep: true });
 
-  @action addSource(id: string, source: CatalogEntity[]) {
+  @action addSource(id: string, source: IObservableArray<CatalogEntity>) {
     this.sources.set(id, source);
   }
 
@@ -12,14 +12,8 @@ export class CatalogEntityRegistry {
     this.sources.delete(id);
   }
 
-  @computed get items() {
+  @computed get items(): CatalogEntity[] {
-    const catalogItems: CatalogEntity[] = [];
+    return Array.from(this.sources.values()).flat();
-
-    for (const items of this.sources.values()) {
-      items.forEach((item) => catalogItems.push(item));
-    }
-
-    return catalogItems;
   }
 
   getItemsForApiKind<T extends CatalogEntity>(apiVersion: string, kind: string): T[] {

src/extensions/lens-main-extension.ts

@@ -4,6 +4,7 @@ import { WindowManager } from "../main/window-manager";
 import { getExtensionPageUrl } from "./registries/page-registry";
 import { catalogEntityRegistry } from "../common/catalog-entity-registry";
 import { CatalogEntity } from "../common/catalog-entity";
+import { IObservableArray } from "mobx";
 
 export class LensMainExtension extends LensExtension {
   appMenus: MenuRegistration[] = [];
@@ -19,7 +20,7 @@ export class LensMainExtension extends LensExtension {
     await windowManager.navigate(pageUrl, frameId);
   }
 
-  addCatalogSource(id: string, source: CatalogEntity[]) {
+  addCatalogSource(id: string, source: IObservableArray<CatalogEntity>) {
     catalogEntityRegistry.addSource(`${this.name}:${id}`, source);
   }
 

src/main/cluster-manager.ts

@@ -14,7 +14,7 @@ import { catalogEntityRegistry } from "../common/catalog-entity-registry";
 const clusterOwnerRef = "ClusterManager";
 
 export class ClusterManager extends Singleton {
-  @observable.deep catalogSource: CatalogEntity[] = [];
+  catalogSource = observable.array<CatalogEntity>([]);
 
   constructor(public readonly port: number) {
     super();

src/main/lens-proxy.ts

@@ -5,11 +5,11 @@ import httpProxy from "http-proxy";
 import url from "url";
 import * as WebSocket from "ws";
 import { apiPrefix, apiKubePrefix } from "../common/vars";
-import { openShell } from "./node-shell-session";
 import { Router } from "./router";
 import { ClusterManager } from "./cluster-manager";
 import { ContextHandler } from "./context-handler";
 import logger from "./logger";
+import { NodeShellSession, LocalShellSession } from "./shell-session";
 
 export class LensProxy {
   protected origin: string;
@@ -173,8 +173,12 @@ export class LensProxy {
     return ws.on("connection", ((socket: WebSocket, req: http.IncomingMessage) => {
       const cluster = this.clusterManager.getClusterForRequest(req);
       const nodeParam = url.parse(req.url, true).query["node"]?.toString();
+      const shell = nodeParam
+        ? new NodeShellSession(socket, cluster, nodeParam)
+        : new LocalShellSession(socket, cluster);
 
-      openShell(socket, cluster, nodeParam);
+      shell.open()
+        .catch(error => logger.error(`[SHELL-SESSION]: failed to open: ${error}`, { error }));
     }));
   }
 

src/main/node-shell-session.ts

@@ -1,159 +0,0 @@
-import * as WebSocket from "ws";
-import * as pty from "node-pty";
-import { ShellSession } from "./shell-session";
-import { v4 as uuid } from "uuid";
-import * as k8s from "@kubernetes/client-node";
-import { KubeConfig } from "@kubernetes/client-node";
-import { Cluster } from "./cluster";
-import logger from "./logger";
-import { appEventBus } from "../common/event-bus";
-
-export class NodeShellSession extends ShellSession {
-  protected nodeName: string;
-  protected podId: string;
-  protected kc: KubeConfig;
-
-  constructor(socket: WebSocket, cluster: Cluster, nodeName: string) {
-    super(socket, cluster);
-    this.nodeName = nodeName;
-    this.podId = `node-shell-${uuid()}`;
-  }
-
-  public async open() {
-    // these are needed by the ShellSession getCachedShellEnv() method
-    this.kubeconfigPath =  await this.cluster.getProxyKubeconfigPath();
-    this.kubectlBinDir = await this.kubectl.binDir();
-
-    this.kc = await this.cluster.getProxyKubeconfig();
-    const shell = await this.kubectl.getPath();
-    let args = [];
-
-    if (this.createNodeShellPod(this.podId, this.nodeName)) {
-      await this.waitForRunningPod(this.podId).catch(() => {
-        this.exitAndClean(1001);
-      });
-    }
-    args = ["exec", "-i", "-t", "-n", "kube-system", this.podId, "--", "sh", "-c", "((clear && bash) || (clear && ash) || (clear && sh))"];
-
-    const shellEnv = await this.getCachedShellEnv();
-
-    this.shellProcess = pty.spawn(shell, args, {
-      cols: 80,
-      cwd: this.cwd() || shellEnv["HOME"],
-      env: shellEnv,
-      name: "xterm-256color",
-      rows: 30,
-    });
-    this.running = true;
-    this.pipeStdout();
-    this.pipeStdin();
-    this.closeWebsocketOnProcessExit();
-    this.exitProcessOnWebsocketClose();
-
-    appEventBus.emit({name: "node-shell", action: "open"});
-  }
-
-  protected exitAndClean(code = 1000) {
-    if (this.podId) {
-      this.deleteNodeShellPod();
-    }
-
-    if (code != 1000) {
-      this.sendResponse("Error occurred. ");
-    }
-  }
-
-  protected async createNodeShellPod(podId: string, nodeName: string) {
-    const kc = this.getKubeConfig();
-    const k8sApi = kc.makeApiClient(k8s.CoreV1Api);
-    const pod = {
-      metadata: {
-        name: podId,
-        namespace: "kube-system"
-      },
-      spec: {
-        nodeName,
-        restartPolicy: "Never",
-        terminationGracePeriodSeconds: 0,
-        hostPID: true,
-        hostIPC: true,
-        hostNetwork: true,
-        tolerations: [{
-          operator: "Exists"
-        }],
-        containers: [{
-          name: "shell",
-          image: "docker.io/alpine:3.12",
-          securityContext: {
-            privileged: true,
-          },
-          command: ["nsenter"],
-          args: ["-t", "1", "-m", "-u", "-i", "-n", "sleep", "14000"]
-        }],
-      }
-    } as k8s.V1Pod;
-
-    await k8sApi.createNamespacedPod("kube-system", pod).catch((error) => {
-      logger.error(error);
-
-      return false;
-    });
-
-    return true;
-  }
-
-  protected getKubeConfig() {
-    if (this.kc) {
-      return this.kc;
-    }
-    this.kc = new k8s.KubeConfig();
-    this.kc.loadFromFile(this.kubeconfigPath);
-
-    return this.kc;
-  }
-
-  protected waitForRunningPod(podId: string) {
-    return new Promise<boolean>(async (resolve, reject) => {
-      const kc = this.getKubeConfig();
-      const watch = new k8s.Watch(kc);
-      const req = await watch.watch(`/api/v1/namespaces/kube-system/pods`, {},
-        // callback is called for each received object.
-        (type, obj) => {
-          if (obj.metadata.name == podId && obj.status.phase === "Running") {
-            resolve(true);
-          }
-        },
-        // done callback is called if the watch terminates normally
-        (err) => {
-          logger.error(err);
-          reject(false);
-        }
-      );
-
-      setTimeout(() => {
-        req.abort();
-        reject(false);
-      }, 120 * 1000);
-    });
-  }
-
-  protected deleteNodeShellPod() {
-    const kc = this.getKubeConfig();
-    const k8sApi = kc.makeApiClient(k8s.CoreV1Api);
-
-    k8sApi.deleteNamespacedPod(this.podId, "kube-system");
-  }
-}
-
-export async function openShell(socket: WebSocket, cluster: Cluster, nodeName?: string): Promise<ShellSession> {
-  let shell: ShellSession;
-
-  if (nodeName) {
-    shell = new NodeShellSession(socket, cluster, nodeName);
-  } else {
-    shell = new ShellSession(socket, cluster);
-  }
-  shell.open();
-
-  return shell;
-}

src/main/shell-session.ts

@@ -1,231 +0,0 @@
-import * as pty from "node-pty";
-import * as WebSocket from "ws";
-import { EventEmitter } from "events";
-import path from "path";
-import shellEnv from "shell-env";
-import { app } from "electron";
-import { Kubectl } from "./kubectl";
-import { Cluster } from "./cluster";
-import { helmCli } from "./helm/helm-cli";
-import { isWindows } from "../common/vars";
-import { appEventBus } from "../common/event-bus";
-import { userStore } from "../common/user-store";
-import { clearKubeconfigEnvVars } from "./utils/clear-kube-env-vars";
-
-export class ShellSession extends EventEmitter {
-  static shellEnvs: Map<string, any> = new Map();
-
-  protected websocket: WebSocket;
-  protected shellProcess: pty.IPty;
-  protected kubeconfigPath: string;
-  protected nodeShellPod: string;
-  protected kubectl: Kubectl;
-  protected kubectlBinDir: string;
-  protected kubectlPathDir: string;
-  protected helmBinDir: string;
-  protected running = false;
-  protected cluster: Cluster;
-
-  constructor(socket: WebSocket, cluster: Cluster) {
-    super();
-    this.websocket = socket;
-    this.kubectl = new Kubectl(cluster.version);
-    this.cluster = cluster;
-  }
-
-  public async open() {
-    this.kubeconfigPath =  await this.cluster.getProxyKubeconfigPath();
-    this.kubectlBinDir = await this.kubectl.binDir();
-    const pathFromPreferences = userStore.preferences.kubectlBinariesPath || this.kubectl.getBundledPath();
-
-    this.kubectlPathDir = userStore.preferences.downloadKubectlBinaries ? this.kubectlBinDir : path.dirname(pathFromPreferences);
-    this.helmBinDir = helmCli.getBinaryDir();
-    const env = await this.getCachedShellEnv();
-    const shell = env.PTYSHELL;
-    const args = await this.getShellArgs(shell);
-
-    this.shellProcess = pty.spawn(shell, args, {
-      cols: 80,
-      cwd: this.cwd() || env.HOME,
-      env,
-      name: "xterm-256color",
-      rows: 30,
-    });
-    this.running = true;
-
-    this.pipeStdout();
-    this.pipeStdin();
-    this.closeWebsocketOnProcessExit();
-    this.exitProcessOnWebsocketClose();
-
-    appEventBus.emit({name: "shell", action: "open"});
-  }
-
-  protected cwd(): string {
-    const { preferences } = this.cluster;
-
-    if(!preferences || !preferences.terminalCWD || preferences.terminalCWD === "") {
-      return null;
-    }
-
-    return preferences.terminalCWD;
-  }
-
-  protected async getShellArgs(shell: string): Promise<Array<string>> {
-    switch(path.basename(shell)) {
-      case "powershell.exe":
-        return ["-NoExit", "-command", `& {Set-Location $Env:USERPROFILE; $Env:PATH="${this.helmBinDir};${this.kubectlPathDir};$Env:PATH"}`];
-      case "bash":
-        return ["--init-file", path.join(this.kubectlBinDir, ".bash_set_path")];
-      case "fish":
-        return ["--login", "--init-command", `export PATH="${this.helmBinDir}:${this.kubectlPathDir}:$PATH"; export KUBECONFIG="${this.kubeconfigPath}"`];
-      case "zsh":
-        return ["--login"];
-      default:
-        return [];
-    }
-  }
-
-  protected async getCachedShellEnv() {
-    const { id: clusterId } = this.cluster;
-
-    let env = ShellSession.shellEnvs.get(clusterId);
-
-    if (!env) {
-      env = await this.getShellEnv();
-      ShellSession.shellEnvs.set(clusterId, env);
-    } else {
-      // refresh env in the background
-      this.getShellEnv().then((shellEnv: any) => {
-        ShellSession.shellEnvs.set(clusterId, shellEnv);
-      });
-    }
-
-    return env;
-  }
-
-  protected async getShellEnv() {
-    const env = clearKubeconfigEnvVars(JSON.parse(JSON.stringify(await shellEnv())));
-    const pathStr = [this.kubectlBinDir, this.helmBinDir, process.env.PATH].join(path.delimiter);
-    const shell = userStore.preferences.shell || process.env.SHELL || process.env.PTYSHELL;
-    const { preferences } = this.cluster;
-
-    if(isWindows) {
-      env["SystemRoot"] = process.env.SystemRoot;
-      env["PTYSHELL"] = shell || "powershell.exe";
-      env["PATH"] = pathStr;
-      env["LENS_SESSION"] = "true";
-      const lensWslEnv = "KUBECONFIG/up:LENS_SESSION/u";
-
-      if (process.env.WSLENV != undefined) {
-        env["WSLENV"] = `${process.env["WSLENV"]}:${lensWslEnv}`;
-      } else {
-        env["WSLENV"] = lensWslEnv;
-      }
-    } else if(shell !== undefined) {
-      env["PTYSHELL"] = shell;
-      env["PATH"] = pathStr;
-    } else {
-      env["PTYSHELL"] = ""; // blank runs the system default shell
-    }
-
-    if(path.basename(env["PTYSHELL"]) === "zsh") {
-      env["OLD_ZDOTDIR"] = env.ZDOTDIR || env.HOME;
-      env["ZDOTDIR"] = this.kubectlBinDir;
-      env["DISABLE_AUTO_UPDATE"] = "true";
-    }
-
-    env["PTYPID"] = process.pid.toString();
-    env["KUBECONFIG"] = this.kubeconfigPath;
-    env["TERM_PROGRAM"] = app.getName();
-    env["TERM_PROGRAM_VERSION"] = app.getVersion();
-
-    if (preferences.httpsProxy) {
-      env["HTTPS_PROXY"] = preferences.httpsProxy;
-    }
-    const no_proxy = ["localhost", "127.0.0.1", env["NO_PROXY"]];
-
-    env["NO_PROXY"] = no_proxy.filter(address => !!address).join();
-
-    if (env.DEBUG) { // do not pass debug option to bash
-      delete env["DEBUG"];
-    }
-
-    return(env);
-  }
-
-  protected pipeStdout() {
-    // send shell output to websocket
-    this.shellProcess.onData(((data: string) => {
-      this.sendResponse(data);
-    }));
-  }
-
-  protected pipeStdin() {
-    // write websocket messages to shellProcess
-    this.websocket.on("message", (data: string) => {
-      if (!this.running) { return; }
-
-      const message = Buffer.from(data.slice(1, data.length), "base64").toString();
-
-      switch (data[0]) {
-        case "0":
-          this.shellProcess.write(message);
-          break;
-        case "4":
-          const resizeMsgObj = JSON.parse(message);
-
-          this.shellProcess.resize(resizeMsgObj["Width"], resizeMsgObj["Height"]);
-          break;
-        case "9":
-          this.emit("newToken", message);
-          break;
-      }
-    });
-  }
-
-  protected exit(code = 1000) {
-    if (this.websocket.readyState == this.websocket.OPEN) this.websocket.close(code);
-    this.emit("exit");
-  }
-
-  protected closeWebsocketOnProcessExit() {
-    this.shellProcess.onExit(({ exitCode }) => {
-      this.running = false;
-      let timeout = 0;
-
-      if (exitCode > 0) {
-        this.sendResponse("Terminal will auto-close in 15 seconds ...");
-        timeout = 15*1000;
-      }
-      setTimeout(() => {
-        this.exit();
-      }, timeout);
-    });
-  }
-
-  protected exitProcessOnWebsocketClose() {
-    this.websocket.on("close", () => {
-      this.killShellProcess();
-    });
-  }
-
-  protected killShellProcess(){
-    if(this.running) {
-      // On Windows we need to kill the shell process by pid, since Lens won't respond after a while if using `this.shellProcess.kill()`
-      if (isWindows) {
-        try {
-          process.kill(this.shellProcess.pid);
-        } catch(e) {
-          return;
-        }
-      } else {
-        this.shellProcess.kill();
-      }
-    }
-  }
-
-  protected sendResponse(msg: string) {
-    this.websocket.send(`1${Buffer.from(msg).toString("base64")}`);
-  }
-}

src/main/shell-session/index.ts

@@ -0,0 +1,2 @@
+export * from "./node-shell-session";
+export * from "./local-shell-session";

src/main/shell-session/local-shell-session.ts

@@ -0,0 +1,40 @@
+import path from "path";
+import { helmCli } from "../helm/helm-cli";
+import { userStore } from "../../common/user-store";
+import { ShellSession } from "./shell-session";
+
+export class LocalShellSession extends ShellSession {
+  ShellType = "shell";
+
+  protected getPathEntries(): string[] {
+    return [helmCli.getBinaryDir()];
+  }
+
+  public async open() {
+
+    const env = await this.getCachedShellEnv();
+    const shell = env.PTYSHELL;
+    const args = await this.getShellArgs(shell);
+
+    super.open(env.PTYSHELL, args, env);
+  }
+
+  protected async getShellArgs(shell: string): Promise<string[]> {
+    const helmpath = helmCli.getBinaryDir();
+    const pathFromPreferences = userStore.preferences.kubectlBinariesPath || this.kubectl.getBundledPath();
+    const kubectlPathDir = userStore.preferences.downloadKubectlBinaries ? await this.kubectlBinDirP : path.dirname(pathFromPreferences);
+
+    switch(path.basename(shell)) {
+      case "powershell.exe":
+        return ["-NoExit", "-command", `& {Set-Location $Env:USERPROFILE; $Env:PATH="${helmpath};${kubectlPathDir};$Env:PATH"}`];
+      case "bash":
+        return ["--init-file", path.join(await this.kubectlBinDirP, ".bash_set_path")];
+      case "fish":
+        return ["--login", "--init-command", `export PATH="${helmpath}:${kubectlPathDir}:$PATH"; export KUBECONFIG="${this.kubeconfigPathP}"`];
+      case "zsh":
+        return ["--login"];
+      default:
+        return [];
+    }
+  }
+}

src/main/shell-session/node-shell-session.ts

@@ -0,0 +1,108 @@
+import * as WebSocket from "ws";
+import { v4 as uuid } from "uuid";
+import * as k8s from "@kubernetes/client-node";
+import { KubeConfig } from "@kubernetes/client-node";
+import { Cluster } from "../cluster";
+import { ShellOpenError, ShellSession } from "./shell-session";
+
+export class NodeShellSession extends ShellSession {
+  ShellType = "node-shell";
+
+  protected podId = `node-shell-${uuid()}`;
+  protected kc: KubeConfig;
+
+  constructor(socket: WebSocket, cluster: Cluster, protected nodeName: string) {
+    super(socket, cluster);
+  }
+
+  public async open() {
+    this.kc = await this.cluster.getProxyKubeconfig();
+    const shell = await this.kubectl.getPath();
+
+    try {
+      await this.createNodeShellPod();
+      await this.waitForRunningPod();
+    } catch (error) {
+      this.deleteNodeShellPod();
+      this.sendResponse("Error occurred. ");
+
+      throw new ShellOpenError("failed to create node pod", error);
+    }
+
+    const args = ["exec", "-i", "-t", "-n", "kube-system", this.podId, "--", "sh", "-c", "((clear && bash) || (clear && ash) || (clear && sh))"];
+    const env = await this.getCachedShellEnv();
+
+    super.open(shell, args, env);
+  }
+
+  protected createNodeShellPod() {
+    return this
+      .kc
+      .makeApiClient(k8s.CoreV1Api)
+      .createNamespacedPod("kube-system", {
+        metadata: {
+          name: this.podId,
+          namespace: "kube-system"
+        },
+        spec: {
+          nodeName: this.nodeName,
+          restartPolicy: "Never",
+          terminationGracePeriodSeconds: 0,
+          hostPID: true,
+          hostIPC: true,
+          hostNetwork: true,
+          tolerations: [{
+            operator: "Exists"
+          }],
+          containers: [{
+            name: "shell",
+            image: "docker.io/alpine:3.12",
+            securityContext: {
+              privileged: true,
+            },
+            command: ["nsenter"],
+            args: ["-t", "1", "-m", "-u", "-i", "-n", "sleep", "14000"]
+          }],
+        }
+      });
+  }
+
+  protected waitForRunningPod(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const watch = new k8s.Watch(this.kc);
+
+      watch
+        .watch(`/api/v1/namespaces/kube-system/pods`,
+          {},
+          // callback is called for each received object.
+          (type, obj) => {
+            if (obj.metadata.name == this.podId && obj.status.phase === "Running") {
+              resolve();
+            }
+          },
+          // done callback is called if the watch terminates normally
+          (err) => {
+            console.log(err);
+            reject(err);
+          }
+        )
+        .then(req => {
+          setTimeout(() => {
+            console.log("aborting");
+            req.abort();
+          }, 2 * 60 * 1000);
+        })
+        .catch(err => {
+          console.log("watch failed");
+          reject(err);
+        });
+    });
+  }
+
+  protected deleteNodeShellPod() {
+    this
+      .kc
+      .makeApiClient(k8s.CoreV1Api)
+      .deleteNamespacedPod(this.podId, "kube-system");
+  }
+}

src/main/shell-session/shell-session.ts

@@ -0,0 +1,179 @@
+import { Cluster } from "../cluster";
+import { Kubectl } from "../kubectl";
+import * as WebSocket from "ws";
+import shellEnv from "shell-env";
+import { app } from "electron";
+import { clearKubeconfigEnvVars } from "../utils/clear-kube-env-vars";
+import path from "path";
+import { isWindows } from "../../common/vars";
+import { userStore } from "../../common/user-store";
+import * as pty from "node-pty";
+import { appEventBus } from "../../common/event-bus";
+
+export class ShellOpenError extends Error {
+  constructor(message: string, public cause: Error) {
+    super(`${message}: ${cause}`);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this);
+  }
+}
+
+export abstract class ShellSession {
+  abstract ShellType: string;
+
+  static shellEnvs: Map<string, Record<string, any>> = new Map();
+
+  protected kubectl: Kubectl;
+  protected running = false;
+  protected shellProcess: pty.IPty;
+  protected kubectlBinDirP: Promise<string>;
+  protected kubeconfigPathP: Promise<string>;
+
+  protected get cwd(): string | undefined {
+    return this.cluster.preferences?.terminalCWD;
+  }
+
+  constructor(protected websocket: WebSocket, protected cluster: Cluster) {
+    this.kubectl = new Kubectl(cluster.version);
+    this.kubeconfigPathP = this.cluster.getProxyKubeconfigPath();
+    this.kubectlBinDirP = this.kubectl.binDir();
+  }
+
+  open(shell: string, args: string[], env: Record<string, any>): void {
+    this.shellProcess = pty.spawn(shell, args, {
+      cols: 80,
+      cwd: this.cwd || env.HOME,
+      env,
+      name: "xterm-256color",
+      rows: 30,
+    });
+    this.running = true;
+
+    this.shellProcess.onData(data => this.sendResponse(data));
+    this.shellProcess.onExit(({ exitCode }) => {
+      this.running = false;
+
+      if (exitCode > 0) {
+        this.sendResponse("Terminal will auto-close in 15 seconds ...");
+        setTimeout(() => this.exit(), 15 * 1000);
+      } else {
+        this.exit();
+      }
+    });
+
+    this.websocket
+      .on("message", (data: string) => {
+        if (!this.running) {
+          return;
+        }
+
+        const message = Buffer.from(data.slice(1, data.length), "base64").toString();
+
+        switch (data[0]) {
+          case "0":
+            this.shellProcess.write(message);
+            break;
+          case "4":
+            const { Width, Height } = JSON.parse(message);
+
+            this.shellProcess.resize(Width, Height);
+            break;
+        }
+      })
+      .on("close", () => {
+        if (this.running) {
+          try {
+            process.kill(this.shellProcess.pid);
+          } catch (e) {
+          }
+        }
+
+        this.running = false;
+      });
+
+    appEventBus.emit({ name: this.ShellType, action: "open" });
+  }
+
+  protected getPathEntries(): string[] {
+    return [];
+  }
+
+  protected async getCachedShellEnv() {
+    const { id: clusterId } = this.cluster;
+
+    let env = ShellSession.shellEnvs.get(clusterId);
+
+    if (!env) {
+      env = await this.getShellEnv();
+      ShellSession.shellEnvs.set(clusterId, env);
+    } else {
+      // refresh env in the background
+      this.getShellEnv().then((shellEnv: any) => {
+        ShellSession.shellEnvs.set(clusterId, shellEnv);
+      });
+    }
+
+    return env;
+  }
+
+  protected async getShellEnv() {
+    const env = clearKubeconfigEnvVars(JSON.parse(JSON.stringify(await shellEnv())));
+    const pathStr = [...this.getPathEntries(), await this.kubectlBinDirP, process.env.PATH].join(path.delimiter);
+    const shell = userStore.preferences.shell || process.env.SHELL || process.env.PTYSHELL;
+
+    delete env.DEBUG; // don't pass DEBUG into shells
+
+    if (isWindows) {
+      env.SystemRoot = process.env.SystemRoot;
+      env.PTYSHELL = shell || "powershell.exe";
+      env.PATH = pathStr;
+      env.LENS_SESSION = "true";
+      env.WSLENV = [
+        process.env.WSLENV,
+        "KUBECONFIG/up:LENS_SESSION/u"
+      ]
+        .filter(Boolean)
+        .join(":");
+    } else if (shell !== undefined) {
+      env.PTYSHELL = shell;
+      env.PATH = pathStr;
+    } else {
+      env.PTYSHELL = ""; // blank runs the system default shell
+    }
+
+    if (path.basename(env.PTYSHELL) === "zsh") {
+      env.OLD_ZDOTDIR = env.ZDOTDIR || env.HOME;
+      env.ZDOTDIR = this.kubectlBinDirP;
+      env.DISABLE_AUTO_UPDATE = "true";
+    }
+
+    env.PTYPID = process.pid.toString();
+    env.KUBECONFIG = await this.kubeconfigPathP;
+    env.TERM_PROGRAM = app.getName();
+    env.TERM_PROGRAM_VERSION = app.getVersion();
+
+    if (this.cluster.preferences.httpsProxy) {
+      env.HTTPS_PROXY = this.cluster.preferences.httpsProxy;
+    }
+
+    env.NO_PROXY = [
+      "localhost",
+      "127.0.0.1",
+      env.NO_PROXY
+    ]
+      .filter(Boolean)
+      .join();
+
+    return env;
+  }
+
+  protected exit(code = 1000) {
+    if (this.websocket.readyState == this.websocket.OPEN) {
+      this.websocket.close(code);
+    }
+  }
+
+  protected sendResponse(msg: string) {
+    this.websocket.send(`1${Buffer.from(msg).toString("base64")}`);
+  }
+}

src/renderer/components/+catalog/catalog.scss

@@ -1,15 +1,48 @@
 .CatalogPage {
   --width: 100%;
   --height: 100%;
-  --nav-column-width: 230px;
+  --nav-column-width: 200px;
-  text-align: left;
 
   .sidebarRegion {
     justify-content: flex-start;
+    background-color: var(--sidebarBackground);
+
+    .sidebarHeader {
+      background: var(--sidebarLogoBackground);
+      height: var(--main-layout-header);
+      padding: 4px;
+      color: var(--textColorAccent);
+      font-weight: bold;
+      font-size: 14px;
+      display: flex;
+      align-items: center;
+      padding-left: 10px;
+    }
+
+    > .sidebar {
+      width: 100%;
+
+      .sidebarTabs {
+        margin-top: 5px;
+
+        .Tab {
+          padding: 7px 10px;
+          font-weight: normal;
+          font-size: 14px;
+          border-radius: 0;
+          height: 36px;
+
+          &.active {
+            background-color: var(--blue);
+            color: white;
+          }
+        }
+      }
+    }
   }
 
   .contentRegion {
-    .content {
+    > .content {
       padding: 20px 20px;
     }
   }

src/renderer/components/+catalog/catalog.tsx

@@ -115,10 +115,12 @@ export class Catalog extends React.Component {
   renderNavigation() {
     return (
       <Tabs className="flex column" scrollable={false} onChange={this.onTabChange} value={this.activeTab}>
-        <div className="header">Catalog</div>
+        <div className="sidebarHeader">Catalog</div>
-        { this.categories.map((category, index) => {
+        <div className="sidebarTabs">
-          return <Tab value={category.getId()} key={index} label={category.metadata.name} data-testid={`${category.getId()}-tab`} />;
+          { this.categories.map((category, index) => {
-        })}
+            return <Tab value={category.getId()} key={index} label={category.metadata.name} data-testid={`${category.getId()}-tab`} />;
+          })}
+        </div>
       </Tabs>
     );
   }

yarn.lock

@@ -4861,10 +4861,10 @@ electron@*:
     "@types/node" "^12.0.12"
     extract-zip "^1.0.3"
 
-electron@^9.4.0:
+electron@^9.4.4:
-  version "9.4.0"
+  version "9.4.4"
-  resolved "https://registry.yarnpkg.com/electron/-/electron-9.4.0.tgz#c3c607e3598226ddbaaff8babcdffa8bb2210936"
+  resolved "https://registry.yarnpkg.com/electron/-/electron-9.4.4.tgz#2a74a0655a74bd326216672c5ae6ed3a44451446"
-  integrity sha512-hOC4q0jkb+UDYZRy8vrZ1IANnq+jznZnbkD62OEo06nU+hIbp2IrwDRBNuSLmQ3cwZMVir0WSIA1qEVK0PkzGA==
+  integrity sha512-dcPlTrMWQu5xuSm6sYV42KK/BRIqh3erM8v/WtZqaDmG7pkCeJpvw26Dgbqhdt78XmqqGiN96giEe6A3S9vpAQ==
   dependencies:
     "@electron/get" "^1.0.1"
     "@types/node" "^12.0.12"